原文地址：数字图像处理笔记2- 边沿检测与提取，轮廓跟踪（转）作者：小草帽

7.1 边沿检测

我们给出一个模板 和一幅图象 。不难发现原图中左边暗，右边亮，中间存在着一条明显的边界。进行模板操作后的结果如下： 。

可以看出，第3、4列比其他列的灰度值高很多，人眼观察时，就能发现一条很明显的亮边，其它区域都很暗，这样就起到了边沿检测的作用。

为什么会这样呢？仔细看看那个模板就明白了，它的意思是将右邻点的灰度值减左邻点的灰度值作为该点的灰度值。在灰度相近的区域内，这么做的结果使得该点的灰度值接近于0；而在边界附近，灰度值有明显的跳变，这么做的结果使得该点的灰度值很大，这样就出现了上面的结果。

这种模板就是一种边沿检测器，它在数学上的涵义是一种基于梯度的滤波器，又称边沿算子，你没有必要知道梯度的确切涵义，只要有这个概念就可以了。梯度是有方向的，和边沿的方向总是正交(垂直)的，例如，对于上面那幅图象的转置图象，边是水平方向的，我们可以用梯度是垂直方向的模板 检测它的边沿。

例如，一个梯度为45度方向模板 ，可以检测出135度方向的边沿。

1.         Sobel算子

在边沿检测中，常用的一种模板是Sobel 算子。Sobel 算子有两个，一个是检测水平边沿的 ；另一个是检测垂直平边沿的 。与 和 相比，Sobel算子对于象素的位置的影响做了加权，因此效果更好。

Sobel算子另一种形式是各向同性Sobel(Isotropic Sobel)算子，也有两个，一个是检测水平边沿的 ，另一个是检测垂直平边沿的 。各向同性Sobel算子和普通Sobel算子相比，它的位置加权系数更为准确，在检测不同方向的边沿时梯度的幅度一致。

下面的几幅图中，图7.1为原图；图7.2为普通Sobel算子处理后的结果图；图7.3为各向同性Sobel算子处理后的结果图。可以看出Sobel算子确实把图象中的边沿提取了出来。

图7.1     原图

图7.2     普通Sobel算子处理后的结果图

图7.3     各向同性Sobel算子处理后的结果图

在程序中仍然要用到第3章介绍的通用3×3模板操作函数TemplateOperation，所做的操作只是增加几个常量标识及其对应的模板数组，这里就不再给出了。

2.         高斯拉普拉斯算子

由于噪声点(灰度与周围点相差很大的点)对边沿检测有一定的影响，所以效果更好的边沿检测器是高斯拉普拉斯(LOG)算子。它把我们在第3章中介绍的高斯平滑滤波器和拉普拉斯锐化滤波器结合了起来，先平滑掉噪声，再进行边沿检测，所以效果会更好。

常用的LOG算子是5×5的模板，如下所示 。到中心点的距离与位置加权系数的关系用曲线表示为图7.4。是不是很象一顶墨西哥草帽？所以，LOG又叫墨西哥草帽滤波器。

图7.4     LOG到中心点的距离与位置加权系数的关系曲线

图7.5为图7.1用LOG滤波器处理后的结果。

图7.5     图7.1用LOG滤波器处理后的结果图

LOG的算法和普通模板操作的算法没什么不同，只不过把3×3改成了5×5，这里就不再给出了。读者可以参照第3章的源程序自己来完成。

7.2 Hough变换

Hough变化的原理是利用点和线的对偶性，将原始空间的给定的曲线通过曲线表达式变为参数空间的一个点。在原始图像坐标系下的一个点对应参数坐标系中的一条直线，同样参数坐标系的一条直线对应原始坐标中的一个点。原始坐标中呈现直线的所有点，它们的斜率和截距是相同的，所以他们在参数坐标下对应于同一个点。

首先，初始化一块缓冲徐，对应于参数平面，将所有的数据置0，对于图像的每一个前景点，求出参数平面对应的直线，把直线上所有的点都加1，最后找到参数平面最大的点的位置，这个位置就是原图像直线上的参数。

Hough变换用来在图象中查找直线。它的原理很简单：假设有一条与原点距离为s，方向角为θ的一条直线，如图7.6所示。

图7.6    一条与原点距离为s，方向角为θ的一条直线

直线上的每一点都满足方程

(7.1)

利用这个事实，我们可以找出某条直线来。下面将给出一段程序，用来找出图象中最长的直线(见图7.7)。找到直线的两个端点，在它们之间连一条红色的直线。为了看清效果，将结果描成粗线，如图7.8所示。

图7.7 原图

图7.8 Hough变换的结果

可以看出，找到的确实是最长的直线。方法是，开一个二维数组做为计数器，第一维是角度，第二维是距离。先计算可能出现的最大距离为 ，用来确定数组第二维的大小。对于每一个黑色点，角度的变化范围从00到1780(为了减少存储空间和计算时间，角度每次增加20而不是10)，按方程(7.1)求出对应的距离s来，相应的数组元素[s][ ]加1。同时开一个数组Line，计算每条直线的上下两个端点。所有的象素都算完后，找到数组元素中最大的，就是最长的那条直线。直线的端点可以在Line中找到。要注意的是，我们处理的虽然是二值图，但实际上是256级灰度图，不过只用到了0和255两种颜色。

BOOL Hough(HWND hWnd)

{

//定义一个自己的直线结构

typedef struct{

int topx; //最高点的x坐标

int topy; //最高点的y坐标

int botx; //最低点的x坐标

int boty; //最低点的y坐标

}MYLINE;

DWORD                             OffBits,BufSize;

LPBITMAPINFOHEADER    lpImgData;

LPSTR                     lpPtr;

HDC                        hDc;

LONG                                  x,y;

long                         i,maxd;

int                           k;

int                           Dist,Alpha;

HGLOBAL                  hDistAlpha,hMyLine;

Int                                         *lpDistAlpha;

MYLINE                             *lpMyLine,*TempLine,MaxdLine;

static LOGPEN                rlp={PS_SOLID,1,1,RGB(255,0,0)};

HPEN                              rhp;

//我们处理的实际上是256级灰度图，不过只用到了0和255两种颜色。

if( NumColors!=256){

MessageBox(hWnd,"Must be a mono bitmap with grayscale palette!",

"Error Message",MB_OK|MB_ICONEXCLAMATION);

return FALSE;

}

//计算最大距离

Dist=(int)(sqrt((double)bi.biWidth*bi.biWidth+

(double)bi.biHeight*bi.biHeight)+0.5);

Alpha=180 /2 ;  //0 到 to 178 度，步长为2度

//为距离角度数组分配内存

if((hDistAlpha=GlobalAlloc(GHND,(DWORD)Dist*Alpha*

sizeof(int)))==NULL){

MessageBox(hWnd,"Error alloc memory!","Error Message",

MB_OK|MB_ICONEXCLAMATION);

return FALSE;

}

//为记录直线端点的数组分配内存

if((hMyLine=GlobalAlloc(GHND,(DWORD)Dist*Alpha*

sizeof(MYLINE)))==NULL){

GlobalFree(hDistAlpha);

return  FALSE;

}

OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);

//BufSize为缓冲区大小

BufSize=OffBits+bi.biHeight*LineBytes;

lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);

lpDistAlpha=(int *)GlobalLock(hDistAlpha);

lpMyLine=(MYLINE *)GlobalLock(hMyLine);

for (i=0;i<(long)Dist*Alpha;i++){

TempLine=(MYLINE*)(lpMyLine+i);

(*TempLine).boty=32767; //初始化最低点的y坐标为一个很大的值

}

for (y=0;y<bi.biHeight;y++){

//lpPtr指向位图数据

lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);

for (x=0;x<bi.biWidth;x++)

if(*(lpPtr++)==0) //是个黑点

for (k=0;k<180;k+=2){

//计算距离i

i=(long)fabs((x*cos(k*PI/180.0)+y*sin(k*PI/180.0)));

//相应的数组元素加1

*(lpDistAlpha+i*Alpha+k/2)=*(lpDistAlpha+i*Alpha+k/2)+1;

TempLine=(MYLINE*)(lpMyLine+i*Alpha+k/2);

if(y> (*TempLine).topy){

//记录该直线最高点的x,y坐标

(*TempLine).topx=x;

(*TempLine).topy=y;

}

if(y< (*TempLine).boty){

//记录该直线最低点的x,y坐标

(*TempLine).botx=x;

(*TempLine).boty=y;

}

}

}

maxd=0;

for (i=0;i<(long)Dist*Alpha;i++){

TempLine=(MYLINE*)(lpMyLine+i);

k=*(lpDistAlpha+i);

if(k > maxd){

//找到数组元素中最大的，及相应的直线端点

maxd=k;

MaxdLine.topx=(*TempLine).topx;

MaxdLine.topy=(*TempLine).topy;

MaxdLine.botx=(*TempLine).botx;

MaxdLine.boty=(*TempLine).boty;

}

}

hDc = GetDC(hWnd);

rhp = CreatePenIndirect(&rlp);

SelectObject(hDc,rhp);

MoveToEx(hDc,MaxdLine.botx,MaxdLine.boty,NULL);

//在两端点之间画一条红线用来标识

LineTo(hDc,MaxdLine.topx,MaxdLine.topy);

DeleteObject(rhp);

ReleaseDC(hWnd,hDc);

//释放内存及资源

GlobalUnlock(hImgData);

GlobalUnlock(hDistAlpha);

GlobalFree(hDistAlpha);

GlobalUnlock(hMyLine);

GlobalFree(hMyLine);

return TRUE;

}

如果 是给定的，用上述方法，我们可以找到该方向上最长的直线。

其实Hough变换能够查找任意的曲线，只要你给定它的方程。这里，我们就不详述了。

7.3 轮廓提取

轮廓提取的实例如图7.9、图7.10所示。

图7.9     原图

图7.10   轮廓提取

轮廓提取的算法非常简单，就是掏空内部点：如果原图中有一点为黑，且它的8个相邻点都是黑色时(此时该点是内部点)，则将该点删除。要注意的是，我们处理的虽然是二值图，但实际上是256级灰度图，不过只用到了0和255两种颜色。源程序如下：

BOOL Outline(HWND hWnd)

{

DWORD                             OffBits,BufSize;

LPBITMAPINFOHEADER    lpImgData;

LPSTR                   lpPtr;

HLOCAL                             hTempImgData;

LPBITMAPINFOHEADER    lpTempImgData;

LPSTR                   lpTempPtr;

HDC                      hDc;

HFILE                     hf;

LONG                    x,y;

int                                        num;

int                               nw,n,ne,w,e,sw,s,se;

//我们处理的实际上是256级灰度图，不过只用到了0和255两种颜色。

if( NumColors!=256){

MessageBox(hWnd,"Must be a mono bitmap with grayscale palette!",

"Error Message",MB_OK|MB_ICONEXCLAMATION);

return FALSE;

}

OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);

//BufSize为缓冲区大小

BufSize=OffBits+bi.biHeight*LineBytes;

//为新图缓冲区分配内存

if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)

{

MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|

MB_ICONEXCLAMATION);

return FALSE;

}

lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);

lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);

//拷贝头信息和位图数据

memcpy(lpTempImgData,lpImgData,BufSize);

for (y=1;y<bi.biHeight-1;y++){ //注意y的范围是从1到高度-2

//lpPtr指向原图数据，lpTempPtr指向新图数据

lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);

lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);

for (x=1;x<bi.biWidth-1;x++){

if(*(lpPtr+x)==0){ //是个黑点

//查找八个相邻点

nw=(unsigned char)*(lpPtr+x+LineBytes-1);

n=(unsigned char)*(lpPtr+x+LineBytes);

ne=(unsigned char)*(lpPtr+x+LineBytes+1);

w=(unsigned char)*(lpPtr+x-1);

e=(unsigned char)*(lpPtr+x+1);

sw=(unsigned char)*(lpPtr+x-LineBytes-1);

s=(unsigned char)*(lpPtr+x-LineBytes);

se=(unsigned char)*(lpPtr+x-LineBytes+1);

num=nw+n+ne+w+e+sw+s+se;

if(num==0) //说明都是黑点

*(lpTempPtr+x)=(unsigned char)255; //删除该黑点

}

}

}

if(hBitmap!=NULL)

DeleteObject(hBitmap);

hDc=GetDC(hWnd);

//创立一个新的位图

hBitmap=CreateDIBitmap(hDc,(LPBITMAPINFOHEADER)lpTempImgData,

(LONG)CBM_INIT,

(LPSTR)lpTempImgData+

sizeof(BITMAPINFOHEADER)+

NumColors*sizeof(RGBQUAD),

(LPBITMAPINFO)lpTempImgData,

DIB_RGB_COLORS);

hf=_lcreat("c:\outline.bmp",0);

_lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER));

_lwrite(hf,(LPSTR)lpTempImgData,BufSize);

_lclose(hf);

//释放内存和资源

ReleaseDC(hWnd,hDc);

LocalUnlock(hTempImgData);

LocalFree(hTempImgData);

GlobalUnlock(hImgData);

return TRUE;

}

7.4 种子填充

种子填充算法用来在封闭曲线形成的环中填充某中颜色，在这里我们只填充黑色。

种子填充其实上是图形学中的算法，其原理是：准备一个堆栈，先将要填充的点push进堆栈中；以后，每pop出一个点，将该点涂成黑色，然后按左上右下的顺序查看它的四个相邻点，若为白(表示还没有填充)，则将该邻点push进栈。一直循环，直到堆栈为空。此时，区域内所有的点都被涂成了黑色。

这里，我们自己定义了一些堆栈的数据结构和操作，实现了堆栈的初始化、push、pop、判断是否为空、及析构。

//堆栈结构

typedef struct{

HGLOBAL hMem; //堆栈全局内存句柄

POINT *lpMyStack; //指向该句柄的指针

LONG  ElementsNum; //堆栈的大小

LONG  ptr; //指向栈顶的指针

}MYSTACK;

//初始化堆栈的操作，第二个参数指定堆栈的大小

BOOL InitStack(HWND hWnd,LONG StackLen)

{

SeedFillStack.ElementsNum=StackLen; //将堆栈的大小赋值

if((SeedFillStack.hMem=GlobalAlloc(GHND,SeedFillStack.ElementsNum*

sizeof(POINT)))==NULL)

{

//内存分配错误，返回FALSE;

MessageBox(hWnd,"Error alloc memory!","ErrorMessage",MB_OK|

MB_ICONEXCLAMATION);

return FALSE;

}

SeedFillStack.lpMyStack=(POINT *)GlobalLock(SeedFillStack.hMem);

//缓冲区全部清零

memset(SeedFillStack.lpMyStack,0,SeedFillStack.ElementsNum*

sizeof(POINT));

//堆顶指针为零

SeedFillStack.ptr=0;

//成功，返回TRUE

return TRUE;

}

//析构函数

void DeInitStack()

{

//释放内存，重置堆栈大小及栈顶指针。

GlobalUnlock(SeedFillStack.hMem);

GlobalFree(SeedFillStack.hMem);

SeedFillStack.ElementsNum=0;

SeedFillStack.ptr=0;

}

//push操作

BOOL MyPush(POINT p)

{

POINT *TempPtr;

if(SeedFillStack.ptr>=SeedFillStack.ElementsNum)

return FALSE; //栈已满，返回FALSE

//进栈，栈顶指针加1

TempPtr=(POINT *)(SeedFillStack.lpMyStack+SeedFillStack.ptr++);

(*TempPtr).x=p.x;

(*TempPtr).y=p.y;

return TRUE;

}

//pop操作

POINT MyPop()

{

POINT InvalidP;

InvalidP.x=-1;

InvalidP.y=-1;

if(SeedFillStack.ptr<=0)

return InvalidP; //栈为空，返回无效点

SeedFillStack.ptr--; //栈顶指针减1

//返回栈顶点

return *(SeedFillStack.lpMyStack+SeedFillStack.ptr);

}

//判断堆栈是否为空

BOOL IsStackEmpty()

{

return (SeedFillStack.ptr==0)?TRUE:FALSE;

}

如果读者对堆栈的概念还不清楚，请参阅有关数据结构方面的书籍，这里就不详述了。

要注意的是：(1)要填充的区域是封闭的；(2)我们处理的虽然是二值图，但实际上是256级灰度图，不过只用到了0和255两种颜色；(3)在菜单中选择种子填充命令时，提示用户用鼠标点取一个要填充区域中的点，处理是在WM_LBUTTONDOWN中。

MYSTACK SeedFillStack;

BOOL SeedFill(HWND hWnd)

{

DWORD                   OffBits,BufSize;

LPBITMAPINFOHEADER    lpImgData;

HLOCAL                  hTempImgData;

LPBITMAPINFOHEADER    lpTempImgData;

LPSTR                   lpTempPtr,lpTempPtr1;

HDC                                      hDc;

HFILE                    hf;

POINT                   CurP,NeighborP;

//我们处理的实际上是256级灰度图，不过只用到了0和255两种颜色。

if( NumColors!=256){

MessageBox(hWnd,"Must be a mono bitmap with grayscale palette!",

"Error Message",MB_OK|MB_ICONEXCLAMATION);

return FALSE;

}

OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);

//BufSize为缓冲区大小

BufSize=OffBits+bi.biHeight*LineBytes;

//为新图缓冲区分配内存

if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)

{

MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|

MB_ICONEXCLAMATION);

return FALSE;

}

lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);

lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);

//拷贝头信息和位图数据

memcpy(lpTempImgData,lpImgData,BufSize);

if(!InitStack(hWnd,(LONG)bi.biHeight*bi.biWidth)){  //初始化堆栈

//若失败，释放内存，返回

LocalUnlock(hTempImgData);

LocalFree(hTempImgData);

GlobalUnlock(hImgData);

return FALSE;

}

lpTempPtr=(char*)lpTempImgData+

(BufSize-LineBytes-SeedPoint.y*LineBytes)+SeedPoint.x;

if(*lpTempPtr==0){

//鼠标点到了黑点上，提示用户不能选择边界上的点，返回FALSE

MessageBox(hWnd,"The point you select is a contour point!",

"Error Message",MB_OK|MB_ICONEXCLAMATION);

LocalUnlock(hTempImgData);

LocalFree(hTempImgData);

GlobalUnlock(hImgData);

DeInitStack();

return FALSE;

}

//push该点(用户用鼠标选择的，处理是在WM_LBUTTONDOWN中

MyPush(SeedPoint);

while(!IsStackEmpty()) //堆栈不空则一直处理

{

CurP=MyPop(); //pop栈顶的点

lpTempPtr=(char*)lpTempImgData+

(BufSize-LineBytes-CurP.y*LineBytes)+CurP.x;

//将该点涂黑

*lpTempPtr=(unsigned char)0;

//左邻点

if(CurP.x>0) //注意判断边界

{

NeighborP.x=CurP.x-1;

NeighborP.y=CurP.y;

lpTempPtr1=lpTempPtr-1;

if(*lpTempPtr1!=0) //如果为白，表示还没有填，进栈

MyPush(NeighborP);

}

//上邻点

if(CurP.y>0) //注意判断边界

{

NeighborP.x=CurP.x;

NeighborP.y=CurP.y-1;

lpTempPtr1=lpTempPtr+LineBytes;

if(*lpTempPtr1!=0) //如果为白，表示还没有填，进栈

MyPush(NeighborP);

}

//右邻点

if(CurP.x<bi.biWidth-1) //注意判断边界

{

NeighborP.x=CurP.x+1;

NeighborP.y=CurP.y;

lpTempPtr1=lpTempPtr+1;

if(*lpTempPtr1!=0) //如果为白，表示还没有填，进栈

MyPush(NeighborP);

}

//下邻点

if(CurP.y<bi.biHeight-1) //注意判断边界

{

NeighborP.x=CurP.x;

NeighborP.y=CurP.y+1;

lpTempPtr1=lpTempPtr-LineBytes;

if(*lpTempPtr1!=0) //如果为白，表示还没有填，进栈

MyPush(NeighborP);

}

}

//析构堆栈，释放内存

DeInitStack();

if(hBitmap!=NULL)

DeleteObject(hBitmap);

hDc=GetDC(hWnd);

//创建新的位图

hBitmap=CreateDIBitmap(hDc,(LPBITMAPINFOHEADER)lpTempImgData,

(LONG)CBM_INIT,

(LPSTR)lpTempImgData+

sizeof(BITMAPINFOHEADER)+

NumColors*sizeof(RGBQUAD),

(LPBITMAPINFO)lpTempImgData,

DIB_RGB_COLORS);

hf=_lcreat("c:\seed.bmp",0);

_lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER));

_lwrite(hf,(LPSTR)lpTempImgData,BufSize);

_lclose(hf);

//释放内存和资源

ReleaseDC(hWnd,hDc);

LocalUnlock(hTempImgData);

LocalFree(hTempImgData);

GlobalUnlock(hImgData);

return TRUE;

}

7.5 轮廓跟踪

轮廓跟踪，顾名思义就是通过顺序找出边缘点来跟踪出边界。图7.9经轮廓跟踪后得到的结果如图7.11所示。

图7.11    图7.9轮廓跟踪后的结果

一个简单二值图象闭合边界的轮廓跟踪算法很简单：首先按从上到下，从左到右的顺序搜索，找到的第一个黑点一定是最左上方的边界点，记为A。它的右，右下，下，左下四个邻点中至少有一个是边界点，记为B。从开始B找起，按右，右下，下，左下，左，左上，上，右上的顺序找相邻点中的边界点C。如果C就是A点，则表明已经转了一圈，程序结束；否则从C点继续找，直到找到A为止。判断是不是边界点很容易：如果它的上下左右四个邻居都是黑点则不是边界点，否则是边界点。源程序如下，其中函数IsContourP用来判断某点是不是边界点。

BOOL Contour(HWND hWnd)

{

DWORD                             OffBits，BufSize;

LPBITMAPINFOHEADER    lpImgData;

LPSTR                   lpPtr;

HLOCAL                  hTempImgData;

LPBITMAPINFOHEADER    lpTempImgData;

LPSTR                   lpTempPtr;

HDC                      hDc;

HFILE                    hf;

LONG                    x,y;

POINT                   StartP,CurP;

BOOL                     found;

int                        i;

int       direct[8][2]={{1,0},{1,1},{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1}};

//我们处理的实际上是256级灰度图，不过只用到了0和255两种颜色。

if( NumColors!=256){

MessageBox(hWnd,"Must be a mono bitmap with grayscale palette!",

"Error Message",MB_OK|MB_ICONEXCLAMATION);

return FALSE;

}

//到位图数据的偏移值

OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);

//缓冲区大小

BufSize=OffBits+bi.biHeight*LineBytes;

//为新图缓冲区分配内存

if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)

{

MessageBox(hWnd,"Error alloc memory!","Error Message",

MB_OK|MB_ICONEXCLAMATION);

return FALSE;

}

lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);

lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);

//新图缓冲区初始化为255

memset(lpTempImgData,(BYTE)255,BufSize);

//拷贝头信息

memcpy(lpTempImgData,lpImgData,OffBits);

//找到标志置为假

found=FALSE;

for (y=0;y<bi.biHeight && !found; y++){

lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);

for (x=0;x<bi.biWidth && !found; x++)

if (*(lpPtr++) ==0) found=TRUE;

//找到了最左上的黑点，一定是个边界点

}

if(found){ //如果找到了，才做处理

//从循环退出时，x，y坐标都做了加1的操作。在这里把它们减1，得到

//起始点坐标StartP

StartP.x=x-1;

StartP.y=y-1;

lpTempPtr=(char*)lpTempImgData+

(BufSize-LineBytes-StartP.y*LineBytes)+StartP.x;

*lpTempPtr=(unsigned char)0; //起始点涂黑

//右邻点

CurP.x=StartP.x+1;

CurP.y=StartP.y;

lpPtr=(char *)lpImgData+(BufSize-LineBytes-CurP.y*LineBytes)+CurP.x;

if(*lpPtr!=0){ //若右邻点为白，则找右下邻点

CurP.x=StartP.x+1;

CurP.y=StartP.y+1;

lpPtr=(char*)lpImgData+

(BufSize-LineBytes-CurP.y*LineBytes)+CurP.x;

if(*lpPtr!=0){ //若仍为白，则找下邻点

CurP.x=StartP.x;

CurP.y=StartP.y+1;

}

else{ //若仍为白，则找左下邻点

CurP.x=StartP.x-1;

CurP.y=StartP.y+1;

}

}

while (! ( (CurP.x==StartP.x) &&(CurP.y==StartP.y))){ //知道找到起始点，

//循环才结束

lpTempPtr=(char*)lpTempImgData+

(BufSize-LineBytes-CurP.y*LineBytes)+CurP.x;

*lpTempPtr=(unsigned char)0;

for(i=0;i<8;i++){

//按右，右上，上，左上，左，左下，下，右下的顺序找相邻点

//direct[i]中存放的是该方向x,y的偏移值

x=CurP.x+direct[i][0];

y=CurP.y+direct[i][1];

//lpPtr指向原图数据，lpTempPtr指向新图数据

lpTempPtr=(char*)lpTempImgData+

(BufSize-LineBytes-y*LineBytes)+x;

lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes)+x;

if(((*lpPtr==0)&&(*lpTempPtr!=0))||

((x==StartP.x)&&(y==StartP.y)))

//原图中为黑点，且新图中为白点(表示还没搜索过)时才处理

//另一种可能是找到了起始点

if(IsContourP(x,y,lpPtr)){ //若是个边界点

//记住当前点的位置

CurP.x=x;

CurP.y=y;

break;

}

}

}

}

if(hBitmap!=NULL)

DeleteObject(hBitmap);

hDc=GetDC(hWnd);

//创立一个新的位图

hBitmap=CreateDIBitmap(hDc,(LPBITMAPINFOHEADER)lpTempImgData,

(LONG)CBM_INIT,

(LPSTR)lpTempImgData+

sizeof(BITMAPINFOHEADER)+

NumColors*sizeof(RGBQUAD),

(LPBITMAPINFO)lpTempImgData,

DIB_RGB_COLORS);

hf=_lcreat("c:\contour.bmp",0);

_lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER));

_lwrite(hf,(LPSTR)lpTempImgData,BufSize);

_lclose(hf);

//释放内存和资源

ReleaseDC(hWnd,hDc);

LocalUnlock(hTempImgData);

LocalFree(hTempImgData);

GlobalUnlock(hImgData);

return TRUE;

}

//判断某点是不是边界点，参数x,y 为该点坐标，lpPtr为指向原数据的指针

BOOL IsContourP(LONG x,LONG y, char *lpPtr)

{

int    num,n,w,e,s;

n=(unsigned char)*(lpPtr+LineBytes); //上邻点

w=(unsigned char)*(lpPtr-1); //左邻点

e=(unsigned char)*(lpPtr+1); //右邻点

s=(unsigned char)*(lpPtr-LineBytes); //下邻点

num=n+w+e+s;

if(num==0) //全是黑点，说明是个内部点而不是边界点

return FALSE;

return TRUE;

}

数字图像处理笔记2-nbsp;边沿检…相关推荐

  1. 数字图像处理笔记（一）——图像存储空间，分辨率，图像内插

    数字图像处理笔记(一)--图像存储空间,分辨率,图像内插 本系列笔记是笔者在学习冈萨雷斯<数字图像处理>第三版时做的总结,日后看的时候方便点,如果有幸得到大家的讨论,喜上眉梢. 本节参考书 ...

  2. 数字图像处理笔记-02（图像空域增强技术及联合运用）

    数字图像处理笔记-02(图像空域增强技术及联合运用) (一) 图像增强 1.1 基本概念 由于图像在传输或者处理过程中会引入噪声或使图像变模糊,从而降低了图像质量,甚至淹没了特 征,给分析带来了困难. ...

  3. 数字图像处理笔记（一）基础内容

    基础内容 数字图像是什么,和模拟图像又有什么区别 数字图像处理 数字图像处理研究内容 数字图像处理有哪些方法 计算机图形学和数字图像处理的区别 常用的数字图像处理开发工具 数字图像 图像的数学表达 数 ...

  4. DIP数字图像处理笔记

    数字图像处理--南信大 范春年老师 期末复习笔记 matlab语法 期中考试总结 邻域 图像增强 概念 直方图的图像增强 点处理 直方图均衡化histogram equalization 意义 效果 ...

  5. 【图像处理】数字图像处理笔记

    文章目录 直方图处理 滤波器 图像复原 形态学图像处理 灰度形态学--多使用平坦结构元(SE)[数字图像处理P428 图像分割 1.canny边缘检测[数字图像处理P463] 图像的表征 特征描述子 ...

  6. 数字图像处理笔记一 - 图像采集(空间分辨率和幅度分辨率)

    本文主要内容来自与<数字图像处理第二版中文版(冈萨雷斯)>第二章, 图像采集小节. 一.数字图像的表示 一幅图像可以被定义为一个二维函数f(x,y),其中(x,y)是空间(平面)坐标,在任 ...

  7. 数字图像处理笔记(一)空间分辨率与灰度分辨率

    前言 因为在准备考研,复习专业课,复习的是<<数字图像处理>>,教材的话就是冈萨雷斯老师的<<数字图像处理>>第三版.把复习到的东西也就写一写,想一想, ...

  8. 数字图像处理笔记 第五章 图像增强 附实验

    第五章 图像增强 附实验 5.1前言,基础概念与分类 图像增强的目的:改善图像的视觉效果,或将图像转换成更适合于人眼观察和机器分析识别的形式,以便从图像中获取更有用的信息 有针对性的,注意主观为导向, ...

  9. 数字图像处理笔记二 - 图片缩放(最近邻插值(Nearest Neighbor interpolation))

    图片缩放的两种常见算法: 最近邻域内插法(Nearest Neighbor interpolation) 双向性内插法(bilinear interpolation) 本文主要讲述最近邻插值(Near ...

最新文章

  1. 电子学会 软件编程（图形化）二级训练营
  2. python encoding报错_菜鸟世界 -docker 环境下解决python 的 UnicodeEncodeError 错误
  3. 曼彻斯特解密_曼彻斯特编码解码方法与流程
  4. SAP Spartacus 电商云 UI Shipping Method 在单元测试环境下没有显示的问题
  5. navicat for mysql 数据库备份与还原
  6. 我是不会运行你的代码吗？不，我是不会导入自己的数据!
  7. C语言课程设计学生籍贯信息,C语言课程设计 学生籍贯信息记录簿设计.doc
  8. WINDOWS平台上扩展SGA,把你的内存用起来吧
  9. mybatis比mysql安全吗_MyBatis 和 SQL 注入的恩恩怨怨
  10. 编程之美---电梯调度算法
  11. MYSQL基础学习了解
  12. 计算机应用基础的课程讨论,(计算机教学论文：计算机应用基础课程教学方法的讨论.doc...
  13. 深度学习——人生为数不多的好出路
  14. Error: L6218E: Undefined symbol
  15. macOS Monterey 12.1 (21C52) 虚拟机 IOS 镜像
  16. 位 bit、字节 B Byte、M兆、MB
  17. 使用Gitee用于进行团队合作，(配合数据库迁移)
  18. 计算机课上玩的打字游戏,人教版信息技术三上第7课《玩打字游戏》教案.doc
  19. 前端萌新面试吃瘪经历分享
  20. Cassandra使用总结

热门文章

  1. JVM 中一次完整的 GC 流程是什么样子的，对象如何晋升到老年代，
  2. WannaCry病毒爆发并未对微软品牌造成太大影响
  3. MySQL的数据是存在哪的
  4. 内存检测之KFENCE
  5. MapKit 进阶教程: 自定义瓦片
  6. 亚洲领军汽车产业展会Automechanika Shanghai开幕丨Xtecher 前线
  7. kwgt 歌词_kwgt桌面插件美化下载-Eight for kwgt专业版主题包v3.9.136.1 最新版-腾飞网...
  8. RENESAS ISL15100IRZ-T7 单端口差分线路驱动器
  9. Eth-Trunk捆绑技术
  10. 输入一个整数将其倒着输出，如54321——12345。