[转]-Snake模型&&openCV代码

Snake模型&&openCV代码

出处：http://blog.csdn.net/hongxingabc/article/details/51606520

主动轮廓线模型又称为Snake模型，由Kass于1987年提出，它对于在噪声和对比度不敏感，能将目标从复杂背景中分割出来，并能有效的跟踪目标的形变和非刚体的复杂运动而被广泛用于图像分割和物体跟踪等图像处理领域。已广泛应用于数字图像分析和计算机视觉领域。由于Snake模型具有良好的提取和跟踪特定区域内目标轮廓的能力，因此非常适合于医学图像如CT和MR图像的处理，以获得特定器官及组织的轮廓。Snake主要原理是先在待分割图像目标位置附近定义的一个初始轮廓曲线函数，并对其定义个能量函数，通过最小化能量目标函数使轮廓沿能量降低的方向靠近，控制参数曲线变形，当能量函数达到最小的时候，提供的初始轮廓收敛到图形中目标的真实轮廓。

Snake能量函数是有内部能量函数和外部能量函数组成，内部能量控制轮廓的平滑性和连续性，外部能量由图像能量和约束能量组成，控制轮廓向着实际轮廓收敛，其中约束能量可根据具体的对象形态定义，使得snake具有很大的灵活性。

Snake模型具有一些经典方法所无法比拟的优点：图像数据、初始估计、目标轮廓及基于知识的约束统一于一个过程中；经适当的初始化后，它能自主地收敛于能量极小值状态；尺度空间中由初到精地极小化能量可以极大地扩展捕获区域和降低复杂性。同时，Snake模型也有其自身的缺点：对初始位置敏感，需要依赖其他机制将Snake放置在感兴趣的图像特征附近，而当图像边缘模糊，目标比较复杂或与其他的物体靠的比较近时，其初始轮廓更不易确定；由于Snake模型的非凸性，它有可能收敛到局部极值点，甚至发散。现有的初始轮廓确定的方法有以下几种：1.人工勾勒图像的边缘 2.序列图像差分边界 3.基于序列图像的前一帧图像边界的预测 4.基于传统图像分割结果进行边界选取。

Snake模型发展10多年来，许多学者对于经典的snake模型做了改进，提出各种改进的snake模型，其中梯度矢量流（Gradient Vector Flow,GVF）模型扩大了经典snake的外力作用范围，加强了对目标凹轮廓边缘的吸引力，提高了传统的snake模型。Snake模型主要研究的方面：(1) 表示内部能量的曲线演化；(2) 外力；(3) 能量最小化。

Snake模型的改进算法：

1.Cohen提出的气球（balloon）理论模型:应用压力和高斯能力一起增大吸引范围的方法，该压力可使模型扩大或缩小，因此不再要求将模型初始化在所期望的对象边界附近。在图像的梯度力场上叠加气球里，以使轮廓线作为一个整体进行膨胀或收缩，从而扩大了模型寻找图像特证的范围。

优势：对初始边界不敏感

存在的缺点：存在弱边界，漏出边界间隙等问题。

2.Xu提出梯度矢量流（GVF）概念，用GVF场代替经典外力场，GVF场可以看做是对图像梯度场得逼近，这不仅使模型捕捉的范围得到了提高，而且能使活动轮廓进入凹陷区。

优势：有良好的收敛性，深入目标边缘的凹陷区域

存在的缺点：仍不能解决曲线的拓扑变化问题

局部优化算法：

1.Amini提出基于动态规划的snake算法。 2.变分法 3.贪婪算法 4.有限差分法 5.有限元法

全局优化算法：

1.模拟退火 2.遗传算法 3.神经网络

Snake模型的蚁群算法（Ant Colony Optimization）模型

蚁群算法是最近几年有意大利学者M.Dorigo等人首次提出的一种新型的模拟进化算法，称为蚁群系统，蚁群算法通过候选解组成的群体的进化过程来寻求最优解，该过程包括两个基本阶段：适应阶段和协同工作阶段，算法本身采用正反馈原理，加快了进化过程，不易陷入局部最优解，而且个体之间不断进行信息交流和传递，有利于对解空间的进一步探索，因此有很强的发展解的能力。

Snake的进化模型

1.McInerney 提出一种拓扑自适应snake模型（Topology Adaptive Snake,T-Snake）

该算法基于仿射细胞图像分解（Affine Cell Image Decomposition，ACID）先在待分割图像上加以三角网格，然后在图像区域的适当位置做一条初始曲线，最后取曲线与网格的交点作为snake的初始离散点，其第i个snake的离散点的坐标为其中，相邻两点，之间由一条弹性样条连接而成

由于T-Snake模型可借助三角形网格和网格点的特征函数来确定边界三角形，可促使snake模型演化过程中的分裂和合并，从而保证了其具有能够处理拓扑结果复杂图像的能力，因此能够很好的满足医学图像拓扑结果复杂的特点。此算法用于脑部MR切片有良好的性能。

2.双T-Snake模型

双T-Snake模型（Dual-T-Snakes）是在T-Snake模型的基础上产生的，其主要思想是采用内外两个初始轮廓，其中一个轮廓从目标外向内收缩和分裂，另一个轮廓从目标内部向外膨胀，两个初始轮廓可以离目标边界较远，迭代的过程中对能量较大的轮廓增加驱动力，使其靠近与之相对应的轮廓，直到连个轮廓收敛到同一个为止

3.Loop Snake 模型

Loop Snake模型是一种加强了拓扑控制的T-Snake模型，这种方法的关键集中在曲线的每一步进化中都要形成循环，其基本思想是，确保图像轮廓曲线精确地线性地映射到适当的分类中，然后在额外的记过loop-Tree的帮助下，尽可能少的时间内运用已经被snake探究的循环来决定是否进行区域划分，这种模型的实质是对T-Snake模型的一种改进。由于加强了拓扑控制，使得Loop Snake模型既可以忽略背景中强噪声又可以在演化过程中进行多次分裂。

4.连续snake模型

在Snake模型中，轮廓曲线由一条给定容许误差范围的光滑曲线组成，相对于离散snake来说，连续snake模型所需要的控制点少，比离散的更具优越性。

5.B-Snake模型

B-Snake模型是通过B样条曲线来定义的，其轮廓曲线由各曲线段光滑相连而成，每一个曲线段都是由一个给定次数多项式表示，这种多项式是B样条曲度函数的一种线性组合，并以控制点为系数。在有些B-Snake模型中并没有明确应用内部能量，这是因为B样条本身就含有内部能量，snake轮廓曲线只受外力影响着图像边缘移动。可用于对图像切片分割区域的描述与跟踪而用于器官的三维重建。

应用snake的优势：由于生物或人体组织解剖结构的复杂性，以及软组织形状的易变性，那些仅依赖于图像本身的灰度，纹理属性等低层次视觉属性来进行分割的图像分割方法难以获得理想的分割效果，因此医学图像分割迫切需要有一种灵活的框架，能将基于图像本身低层次视觉属性（边缘，纹理，灰度，色彩）和人们对于待分割目标的知识经验，如目标形状的描述，亮度，色彩的经验统计，医生的经验等，可以一种有机的方式整合起来，得到待分割区域的完整表达。

Opencv中snake函数解析及例子：

[cpp]view
plain copy

/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// Intel License Agreement
// For Open Source Computer Vision Library
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of Intel Corporation may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "_cv.h"
#define _CV_SNAKE_BIG 2.e+38f
#define _CV_SNAKE_IMAGE 1
#define _CV_SNAKE_GRAD 2
/*F///////////////////////////////////////////////////////////////////////////////////////
// Name: icvSnake8uC1R
// Purpose:
// Context:
// Parameters:
// src - source image,
// srcStep - its step in bytes,
// roi - size of ROI,
// pt - pointer to snake points array
// n - size of points array,
// alpha - pointer to coefficient of continuity energy,
// beta - pointer to coefficient of curvature energy,
// gamma - pointer to coefficient of image energy,
// coeffUsage - if CV_VALUE - alpha, beta, gamma point to single value
// if CV_MATAY - point to arrays
// criteria - termination criteria.
// scheme - image energy scheme
// if _CV_SNAKE_IMAGE - image intensity is energy
// if _CV_SNAKE_GRAD - magnitude of gradient is energy
// Returns:
//F*/
static CvStatus
icvSnake8uC1R( unsigned char *src, //原始图像数据
int srcStep, //每行的字节数
CvSize roi, //图像尺寸
CvPoint * pt, //轮廓点(变形对象)
int n, //轮廓点的个数
float *alpha, //指向α的指针，α可以是单个值，也可以是与轮廓点个数一致的数组
float *beta, //β的值，同α
float *gamma, //γ的值，同α
int coeffUsage, //确定αβγ是用作单个值还是个数组
CvSize win, //每个点用于搜索的最小的领域大小,宽度为奇数
CvTermCriteria criteria, //递归迭代终止的条件准则
int scheme ) //确定图像能量场的数据选择，1为灰度，2为灰度梯度
{
int i, j, k;
int neighbors = win.height * win.width; //当前点领域中点的个数
//当前点的位置
int centerx = win.width >> 1;
int centery = win.height >> 1;
float invn; //n 的倒数？
int iteration = 0; //迭代次数
int converged = 0; //收敛标志，0为非收敛
//能量
float *Econt; //
float *Ecurv; //轮廓曲线能量
float *Eimg; //图像能量
float *E; //
//αβγ的副本
float _alpha, _beta, _gamma;
/*#ifdef GRAD_SNAKE */
float *gradient = NULL;
uchar *map = NULL;
int map_width = ((roi.width - 1) >> 3) + 1;
int map_height = ((roi.height - 1) >> 3) + 1;
CvSepFilter pX, pY;
#define WTILE_SIZE 8
#define TILE_SIZE (WTILE_SIZE + 2)
short dx[TILE_SIZE*TILE_SIZE], dy[TILE_SIZE*TILE_SIZE];
CvMat _dx = cvMat( TILE_SIZE, TILE_SIZE, CV_16SC1, dx );
CvMat _dy = cvMat( TILE_SIZE, TILE_SIZE, CV_16SC1, dy );
CvMat _src = cvMat( roi.height, roi.width, CV_8UC1, src );
/* inner buffer of convolution process */
//char ConvBuffer[400];
/*#endif */
//检点参数的合理性
/* check bad arguments */
if( src == NULL )
return CV_NULLPTR_ERR;
if( (roi.height <= 0) || (roi.width <= 0) )
return CV_BADSIZE_ERR;
if( srcStep < roi.width )
return CV_BADSIZE_ERR;
if( pt == NULL )
return CV_NULLPTR_ERR;
if( n < 3 ) //轮廓点至少要三个
return CV_BADSIZE_ERR;
if( alpha == NULL )
return CV_NULLPTR_ERR;
if( beta == NULL )
return CV_NULLPTR_ERR;
if( gamma == NULL )
return CV_NULLPTR_ERR;
if( coeffUsage != CV_VALUE && coeffUsage != CV_ARRAY )
return CV_BADFLAG_ERR;
if( (win.height <= 0) || (!(win.height & 1))) //邻域搜索窗口得是奇数
return CV_BADSIZE_ERR;
if( (win.width <= 0) || (!(win.width & 1)))
return CV_BADSIZE_ERR;
invn = 1 / ((float) n); //轮廓点数n的倒数，用于求平均？
if( scheme == _CV_SNAKE_GRAD )
{
//X方向上和Y方向上的Scoble梯度算子，用于求图像的梯度,
//处理的图像最大尺寸为TILE_SIZE+2，此例为12，算子半长为3即{-3，-2，-1，0，1，2，3}
//处理后的数据类型为16位符号数,分别存放在_dx,_dy矩阵中,长度为10
pX.init_deriv( TILE_SIZE+2, CV_8UC1, CV_16SC1, 1, 0, 3 );
pY.init_deriv( TILE_SIZE+2, CV_8UC1, CV_16SC1, 0, 1, 3 );
//图像梯度存放缓冲区
gradient = (float *) cvAlloc( roi.height * roi.width * sizeof( float ));
if( !gradient )
return CV_OUTOFMEM_ERR;
//map用于标志相应位置的分块的图像能量是否已经求得
map = (uchar *) cvAlloc( map_width * map_height );
if( !map )
{
cvFree( &gradient );
return CV_OUTOFMEM_ERR;
}
/* clear map - no gradient computed */
//清除map标志
memset( (void *) map, 0, map_width * map_height );
}
//各种能量的存放处，取每点的邻域的能量
Econt = (float *) cvAlloc( neighbors * sizeof( float ));
Ecurv = (float *) cvAlloc( neighbors * sizeof( float ));
Eimg = (float *) cvAlloc( neighbors * sizeof( float ));
E = (float *) cvAlloc( neighbors * sizeof( float ));
//开始迭代
while( !converged ) //收敛标志无效时进行
{
float ave_d = 0; //轮廓各点的平均距离
int moved = 0; //轮廓变形时，发生移动的数量
converged = 0; //标志未收敛
iteration++; //更新迭代次数+1
//计算轮廓中各点的平均距离
/* compute average distance */
//从点0到点n-1的距离和
for( i = 1; i < n; i++ )
{
int diffx = pt[i - 1].x - pt[i].x;
int diffy = pt[i - 1].y - pt[i].y;
ave_d += cvSqrt( (float) (diffx * diffx + diffy * diffy) );
}
//再加上从点n-1到点0的距离,形成回路轮廓
ave_d += cvSqrt( (float) ((pt[0].x - pt[n - 1].x) *
(pt[0].x - pt[n - 1].x) +
(pt[0].y - pt[n - 1].y) * (pt[0].y - pt[n - 1].y)));
//求平均，得出平均距离
ave_d *= invn;
/* average distance computed */
//对于每个轮廓点进行特定循环迭代求解
for( i = 0; i < n; i++ )
{
/* Calculate Econt */
//初始化各个能量
float maxEcont = 0;
float maxEcurv = 0;
float maxEimg = 0;
float minEcont = _CV_SNAKE_BIG;
float minEcurv = _CV_SNAKE_BIG;
float minEimg = _CV_SNAKE_BIG;
float Emin = _CV_SNAKE_BIG;
//初始化变形后轮廓点的偏移量
int offsetx = 0;
int offsety = 0;
float tmp;
//计算边界
/* compute bounds */
//计算合理的搜索边界，以防领域搜索超过ROI图像的范围
int left = MIN( pt[i].x, win.width >> 1 );
int right = MIN( roi.width - 1 - pt[i].x, win.width >> 1 );
int upper = MIN( pt[i].y, win.height >> 1 );
int bottom = MIN( roi.height - 1 - pt[i].y, win.height >> 1 );
//初始化Econt
maxEcont = 0;
minEcont = _CV_SNAKE_BIG;
//在合理的搜索范围内进行Econt的计算
for( j = -upper; j <= bottom; j++ )
{
for( k = -left; k <= right; k++ )
{
int diffx, diffy;
float energy;
//在轮廓点集的首尾相接处作相应处理,求轮廓点差分
if( i == 0 )
{
diffx = pt[n - 1].x - (pt[i].x + k);
diffy = pt[n - 1].y - (pt[i].y + j);
}
else
//在其他地方作一般处理
{
diffx = pt[i - 1].x - (pt[i].x + k);
diffy = pt[i - 1].y - (pt[i].y + j);
}
//将邻域陈列坐标转成Econt数组的下标序号，计算邻域中每点的Econt
//Econt的值等于平均距离和此点和上一点的距离的差的绝对值（这是怎么来的？）
Econt[(j + centery) * win.width + k + centerx] = energy =
(float) fabs( ave_d -
cvSqrt( (float) (diffx * diffx + diffy * diffy) ));
//求出所有邻域点中的Econt的最大值和最小值
maxEcont = MAX( maxEcont, energy );
minEcont = MIN( minEcont, energy );
}
}
//求出邻域点中最大值和最小值之差,并对所有的邻域点的Econt进行标准归一化,若最大值最小
//相等，则邻域中的点Econt全相等，Econt归一化束缚为0
tmp = maxEcont - minEcont;
tmp = (tmp == 0) ? 0 : (1 / tmp);
for( k = 0; k < neighbors; k++ )
{
Econt[k] = (Econt[k] - minEcont) * tmp;
}
//计算每点的Ecurv
/* Calculate Ecurv */
maxEcurv = 0;
minEcurv = _CV_SNAKE_BIG;
for( j = -upper; j <= bottom; j++ )
{
for( k = -left; k <= right; k++ )
{
int tx, ty;
float energy;
//第一个点的二阶差分
if( i == 0 )
{
tx = pt[n - 1].x - 2 * (pt[i].x + k) + pt[i + 1].x;
ty = pt[n - 1].y - 2 * (pt[i].y + j) + pt[i + 1].y;
}
//最后一个点的二阶差分
else if( i == n - 1 )
{
tx = pt[i - 1].x - 2 * (pt[i].x + k) + pt[0].x;
ty = pt[i - 1].y - 2 * (pt[i].y + j) + pt[0].y;
}
//其余点的二阶差分
else
{
tx = pt[i - 1].x - 2 * (pt[i].x + k) + pt[i + 1].x;
ty = pt[i - 1].y - 2 * (pt[i].y + j) + pt[i + 1].y;
}
//转换坐标为数组序号，并求各点的Ecurv的值,二阶差分后取平方
Ecurv[(j + centery) * win.width + k + centerx] = energy =
(float) (tx * tx + ty * ty);
//取最小的Ecurv和最大的Ecurv
maxEcurv = MAX( maxEcurv, energy );
minEcurv = MIN( minEcurv, energy );
}
}
//对Ecurv进行标准归一化
tmp = maxEcurv - minEcurv;
tmp = (tmp == 0) ? 0 : (1 / tmp);
for( k = 0; k < neighbors; k++ )
{
Ecurv[k] = (Ecurv[k] - minEcurv) * tmp;
}
//求Eimg
/* Calculate Eimg */
for( j = -upper; j <= bottom; j++ )
{
for( k = -left; k <= right; k++ )
{
float energy;
//若采用灰度梯度数据
if( scheme == _CV_SNAKE_GRAD )
{
/* look at map and check status */
int x = (pt[i].x + k)/WTILE_SIZE;
int y = (pt[i].y + j)/WTILE_SIZE;
//若此处的图像能量还没有获取，则对此处对应的图像分块进行图像能量的求解
if( map[y * map_width + x] == 0 )
{
int l, m;
/* evaluate block location */
//计算要进行梯度算子处理的图像块的位置
int upshift = y ? 1 : 0;
int leftshift = x ? 1 : 0;
int bottomshift = MIN( 1, roi.height - (y + 1)*WTILE_SIZE );
int rightshift = MIN( 1, roi.width - (x + 1)*WTILE_SIZE );
//图像块的位置大小（由于原ROI不一定是8的倍数，所以图像块会大小不一）
CvRect g_roi = { x*WTILE_SIZE - leftshift, y*WTILE_SIZE - upshift,
leftshift + WTILE_SIZE + rightshift, upshift + WTILE_SIZE + bottomshift };
CvMat _src1;
cvGetSubArr( &_src, &_src1, g_roi ); //得到图像块的数据
//分别对图像的X方向和Y方向进行梯度算子
pX.process( &_src1, &_dx );
pY.process( &_src1, &_dy );
//求分块区域中的每个点的梯度
for( l = 0; l < WTILE_SIZE + bottomshift; l++ )
{
for( m = 0; m < WTILE_SIZE + rightshift; m++ )
{
gradient[(y*WTILE_SIZE + l) * roi.width + x*WTILE_SIZE + m] =
(float) (dx[(l + upshift) * TILE_SIZE + m + leftshift] *
dx[(l + upshift) * TILE_SIZE + m + leftshift] +
dy[(l + upshift) * TILE_SIZE + m + leftshift] *
dy[(l + upshift) * TILE_SIZE + m + leftshift]);
}
}
//map相应位置置1表示此处图像能量已经获取
map[y * map_width + x] = 1;
}
//以梯度数据作为图像能量
Eimg[(j + centery) * win.width + k + centerx] = energy =
gradient[(pt[i].y + j) * roi.width + pt[i].x + k];
}
else
{
//以灰度作为图像能量
Eimg[(j + centery) * win.width + k + centerx] = energy =
src[(pt[i].y + j) * srcStep + pt[i].x + k];
}
//获得邻域中最大和最小的图像能量
maxEimg = MAX( maxEimg, energy );
minEimg = MIN( minEimg, energy );
}
}
//Eimg的标准归一化
tmp = (maxEimg - minEimg);
tmp = (tmp == 0) ? 0 : (1 / tmp);
for( k = 0; k < neighbors; k++ )
{
Eimg[k] = (minEimg - Eimg[k]) * tmp;
}
//加入系数
/* locate coefficients */
if( coeffUsage == CV_VALUE)
{
_alpha = *alpha;
_beta = *beta;
_gamma = *gamma;
}
else
{
_alpha = alpha[i];
_beta = beta[i];
_gamma = gamma[i];
}
/* Find Minimize point in the neighbors */
//求得每个邻域点的Snake能量
for( k = 0; k < neighbors; k++ )
{
E[k] = _alpha * Econt[k] + _beta * Ecurv[k] + _gamma * Eimg[k];
}
Emin = _CV_SNAKE_BIG;
//获取最小的能量，以及对应的邻域中的相对位置
for( j = -upper; j <= bottom; j++ )
{
for( k = -left; k <= right; k++ )
{
if( E[(j + centery) * win.width + k + centerx] < Emin )
{
Emin = E[(j + centery) * win.width + k + centerx];
offsetx = k;
offsety = j;
}
}
}
//如果轮廓点发生改变，则记得移动次数
if( offsetx || offsety )
{
pt[i].x += offsetx;
pt[i].y += offsety;
moved++;
}
}
//各个轮廓点迭代计算完成后，如果没有移动的点了，则收敛标志位有效，停止迭代
converged = (moved == 0);
//达到最大迭代次数时，收敛标志位有效，停止迭代
if( (criteria.type & CV_TERMCRIT_ITER) && (iteration >= criteria.max_iter) )
converged = 1;
//到大相应精度时，停止迭代（与第一个条件有相同效果）
if( (criteria.type & CV_TERMCRIT_EPS) && (moved <= criteria.epsilon) )
converged = 1;
}
//释放各个缓冲区
cvFree( &Econt );
cvFree( &Ecurv );
cvFree( &Eimg );
cvFree( &E );
if( scheme == _CV_SNAKE_GRAD )
{
cvFree( &gradient );
cvFree( &map );
}
return CV_OK;
}
CV_IMPL void
cvSnakeImage( const IplImage* src, CvPoint* points,
int length, float *alpha,
float *beta, float *gamma,
int coeffUsage, CvSize win,
CvTermCriteria criteria, int calcGradient )
{
CV_FUNCNAME( "cvSnakeImage" );
__BEGIN__;
uchar *data;
CvSize size;
int step;
if( src->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, "input image has more than one channel" );
if( src->depth != IPL_DEPTH_8U )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
cvGetRawData( src, &data, &step, &size );
IPPI_CALL( icvSnake8uC1R( data, step, size, points, length,
alpha, beta, gamma, coeffUsage, win, criteria,
calcGradient ? _CV_SNAKE_GRAD : _CV_SNAKE_IMAGE ));
__END__;
}
/* end of file */
测试应用程序
#include "stdafx.h"
#include <iostream>
#include <string.h>
#include <cxcore.h>
#include <cv.h>
#include <highgui.h>
#include <fstream>
IplImage *image = 0 ; //原始图像
IplImage *image2 = 0 ; //原始图像copy
using namespace std;
int Thresholdness = 141;
int ialpha = 20;
int ibeta=20;
int igamma=20;
void onChange(int pos)
{
if(image2) cvReleaseImage(&image2);
if(image) cvReleaseImage(&image);
image2 = cvLoadImage("grey.bmp",1); //显示图片
image= cvLoadImage("grey.bmp",0);
cvThreshold(image,image,Thresholdness,255,CV_THRESH_BINARY); //分割域值
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* contours = 0;
cvFindContours( image, storage, &contours, sizeof(CvContour), //寻找初始化轮廓
CV_RETR_EXTERNAL , CV_CHAIN_APPROX_SIMPLE );
if(!contours) return ;
int length = contours->total;
if(length<10) return ;
CvPoint* point = new CvPoint[length]; //分配轮廓点
CvSeqReader reader;
CvPoint pt= cvPoint(0,0);;
CvSeq *contour2=contours;
cvStartReadSeq(contour2, &reader);
for (int i = 0; i < length; i++)
{
CV_READ_SEQ_ELEM(pt, reader);
point[i]=pt;
}
cvReleaseMemStorage(&storage);
//显示轮廓曲线
for(int i=0;i<length;i++)
{
int j = (i+1)%length;
cvLine( image2, point[i],point[j],CV_RGB( 0, 0, 255 ),1,8,0 );
}
float alpha=ialpha/100.0f;
float beta=ibeta/100.0f;
float gamma=igamma/100.0f;
CvSize size;
size.width=3;
size.height=3;
CvTermCriteria criteria;
criteria.type=CV_TERMCRIT_ITER;
criteria.max_iter=1000;
criteria.epsilon=0.1;
cvSnakeImage( image, point,length,&alpha,&beta,&gamma,CV_VALUE,size,criteria,0 );
//显示曲线
for(int i=0;i<length;i++)
{
int j = (i+1)%length;
cvLine( image2, point[i],point[j],CV_RGB( 0, 255, 0 ),1,8,0 );
}
delete []point;
}
int main(int argc, char* argv[])
{
cvNamedWindow("win1",0);
cvCreateTrackbar("Thd", "win1", &Thresholdness, 255, onChange);
cvCreateTrackbar("alpha", "win1", &ialpha, 100, onChange);
cvCreateTrackbar("beta", "win1", &ibeta, 100, onChange);
cvCreateTrackbar("gamma", "win1", &igamma, 100, onChange);
cvResizeWindow("win1",300,500);
onChange(0);
for(;;)
{
if(cvWaitKey(40)==27) break;
cvShowImage("win1",image2);
}
return 0;
}

本文由以下两篇博客整理得到：

http://blog.csdn.net/lbd2008/article/details/7180506

http://chyyeng.blog.163.com/blog/static/16918230201272724529214/

查看全文
如若内容造成侵权/违法违规/事实不符，请联系编程学习网邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！

Shiro教程（八）Shiro Freemarker标签的使用。
Shiro 提供了JSP 的一套JSTL 标签，用于做JSP 页面做权限控制的。可以控制一些按钮和一些超链接，或者一些显示内容。JSP 的下篇文章会讲到，这篇先讲讲 Freemarker 的 Shiro 标签。引用包：<dependency><groupId&…...
2024/4/14 22:02:06
几种经典的网络服务器架构模型的分析与比较
事件驱动为广大的程序员所熟悉，其最为人津津乐道的是在图形化界面编程中的应用；事实上，在网络编程中事件驱动也被广泛使用，并大规模部署在高连接数高吞吐量的服务器程序中，如 http 服务器程序、ftp 服务器程序等。相比于传统的网络编程方式，事件驱动能够极大的降低资源占…...
2024/4/17 7:35:12
VMware12版虚拟机怎么安装win7系统（win7镜像ios安装版）
VMware12版虚拟机怎么安装win7系统（详细教程）现在很多人都会在虚拟机上体验不同的系统，可是很多时候我们并不能非常顺利的安装好系统，这中间经常会出现很多差错，导致我们安装不上，比如在虚拟机上安装 win7系统，很多人发现安装的时候总是会跳到工具箱中去，导致根本不能…...
2024/4/27 1:48:33
matlab二进制十进制十六进制和任意进制之间的转换
>> a=bin2dec(1011001) %将二进制转换为10进制a = 89>> b=dec2bin(22) %将10进制转换为2进制b =10110>> c=hex2dec(9B3C) %将16进制转换为10进制c = 39740>> d=dec2hex(97) %将10进制转换为16进制d =61>> e=base2dec(212,3) %将任…...
2024/4/18 12:41:37
第一次IPC捣乱
1、先扫出139端口开放，且密码为空的机子2、建立空连接 net use //192.168.1.67/ipc$ ""/user:"administrator"3、telnet登录 telnet 192.168.1.67 514、几个有用的命令 net share sharename=d:/ net share sharename /delete copy srv.exe //19…...
2024/4/14 22:38:16
Snake模型综合介绍
Snake模型背景及应用 Snake模型称为动态轮廓模型（Active Contour Model）是Kass与1987年提出的，它对于在噪声和对比度不敏感，能将目标从复杂背景中分割出来，并能有效的跟踪目标的形变和非刚体的复杂运动而被广泛用于图像分割和物体跟踪等图像处理领域。 Snake主要原理是先…...
2024/4/20 12:52:53
16进制字符串转换成10进制数据
//16进制字符串转换成10进制数据 #include "stdafx.h" #include <string.h> bool IsValidateStr16(const char *str); int StrToNumber16(const char *str); int Char16ToInt(char c);int main(int argc, char* argv[]) {int num;char str[] = "00Ff"…...
2024/4/17 23:57:42
shiro
一：Shiro1.shiro是一个安全框架使用shiro可以非常容易开发出足够好的应用，可以帮助我们完成：认证授权加密会话管理与web集成缓存等。2.Shiro的三个核心组件*Subject：即”当前操作用户“，但在shiro中不仅仅指人还指第三方进程后台账户或其他类似事物。仅仅意味着”…...
2024/4/16 2:19:09
12、渗透测试笔记_信息收集 20191014
1、域名信息对应ip收集相关域名对应ip，相关工具：nslookup，一些工具网站子域名收集工具：layer、subDomainsBrutewhois（注册人）信息查询根据已知域名反查，分析出此域名的注册人、邮箱、电话等；工具：爱站网、站长之家、微步在线 site.ip138.com、searchdns.netcraft.com…...
2024/4/25 10:08:02
NTP服务器同步本地时间（WinForm）
WinForm实现从NTP服务器自动同步本地时间，并且能够自动检测计算机设置的时区是否为中国，若不是，则提示是否更改时区。并且可以通过相关设置，实现一键式自动同步本地时间。代码下载：点击打开链接1. 主界面：2. 单击右侧的【扩展】按钮，显示日志栏；再次单击右侧的【扩展】…...
2024/4/14 22:38:11
安装WIN7加载识别USB3.0驱动的解决办法
主要原因是Intel新平台不再对USB 2.0提供支持，可以使用下面方法添加 USB3.0 驱动。方法一：1.华硕主板（1）下载win7原版镜像iso。（2）进入华硕的官网 http://www.asus.com.cn 找到主板型号以Z170-K为例选择驱动程序和工具软件选择常用系统 WIN7 64位。公用程序中找到如…...
2024/4/14 22:38:10
使用van-cli创建项目
使用van-cli创建项目 https://www.cnblogs.com/jiangxiangit/p/10992007.html...
2024/4/16 9:39:21
itk中的图像分割算法（一）
本文要记录的是图像分割中的经典：Snake。简单分割算法关注的是局部信息，忽略了图像的纹理结构、位置等信息，而Snake模型可以将局部特征和全局特征相结合。 Snake简介： Snake的思路就是将目标图像的边缘检测转变为求解能量泛函最小值的过程。这类算法需要给出初始的轮廓，然…...
2024/4/14 22:38:08
咨询关于以下电路的作用？
这个电路的作用是滤波吗...
2024/4/25 2:10:44
怎么看服务器网络带宽？该怎样选择服务器的网络带宽和流量？
一、在这里首先和大家介绍一下带宽是什么：带宽是决定主机访问速度的重要因素之一，尤其是对于访问量大的网站，网络带宽的大小显得尤为重要。带宽指的是在单位时间内可以传输的数据总量。二、那如何查看服务器的网络带宽呢： 1.利用文件下载测试下载文件，一般情况下载速度…...
2024/4/16 2:19:40
几个10进制和16进制之间转化的函数
只是粗略的写了写，希望能够起到抛砖引玉的作用以下在模块： Option ExplicitPrivate Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (Destination As Any, Source As Any, ByVal Length As Long)10进制到16进制数组Public Sub mDec2HexA…...
2024/4/19 8:43:05
Shiro教程（九）Shiro JSP标签的使用。
Shiro 提供了 JSP 的一套 JSTL 标签，用于做 JSP 页面做权限控制的。可以控制一些按钮和一些超链接，或者一些显示内容。Freemarker Shiro标签讲解：https://blog.csdn.net/baidu_37366055/article/details/88072120其实标签都是和Freemarker Shiro标签对应的，只不过是把@…...
2024/4/14 22:38:05
win7下安装配置coursera课程文件批量下载工具
安装环境：win7 ultimate 64位(这个安装过程对32位也适用) Github上的coursera课程下载工具有详细的配置安装过程，在windows上其实也是大同小异，闲话少说，开始安装： 1.安装Python2.7.3从这里下载Python2.7.3对应安装包，双击进行安装，并将python安装目录加入到系统的环境变…...
2024/4/24 1:33:46
28. 各类信息收集手段
1、域名信息对应ip收集相关域名对应ip，相关工具：nslookup，一些工具网站子域名收集工具：layer、subDomainsBrutewhois（注册人）信息查询根据已知域名反查，分析出此域名的注册人、邮箱、电话等；工具：爱站网、站长之家、微步在线 site.ip138.com、searchdns.netcraft.c…...
2024/4/14 22:02:13
git推送多个仓库的config文件配置
[core]repositoryformatversion = 0filemode = falsebare = falselogallrefupdates = truesymlinks = falseignorecase = true [remote "origin"]url = 这里填你推送代码和拉取代码的仓库1链接，会推送到仓库1，并且拉取代码从仓库1拉取pushurl = 这里填仓库2的git链…...
2024/4/14 22:02:11

[转]-Snake模型&&openCV代码

相关文章

最新文章