第7章邊沿檢測與提取，輪廓跟蹤

我們在第三章介紹平滑與銳化時引入了模板操作，今天還要用到它。

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變換用來在圖象中查找直線。它的原理很簡單：假設有一條與原點距離爲s，方向角爲θ的一條直線，如圖7.6所示。

圖7.6 一條與原點距離爲s，方向角爲θ的一條直線

直線上的每一點都滿足方程

(7.1)

利用這個事實，我們可以找出某條直線來。下面將給出一段程序，用來找出圖象中最長的直線(見圖7.7)。找到直線的兩個端點，在它們之間連一條紅色的直線。爲了看清效果，將結果描成粗線，如圖7.8所示。

圖7.7 原圖

圖7.8 Hough變換的結果

可以看出，找到的確實是最長的直線。方法是，開一個二維數組做爲計數器，第一維是角度，第二維是距離。先計算可能出現的最大距離爲，用來確定數組第二維的大小。對於每一個黑色點，角度的變化範圍從0⁰到178⁰(爲了減少存儲空間和計算時間，角度每次增加2⁰而不是1⁰)，按方程(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;

}

圖像的論輪廓提取算法與代碼

第7章邊沿檢測與提取，輪廓跟蹤

7.1 邊沿檢測

7.2 Hough變換

7.3 輪廓提取

7.4 種子填充

7.5 輪廓跟蹤

985 碩士程序員，空窗 4 個月沒有 Offer！

一文搞懂 Spring 循環依賴

賽博鬥地主——使用大語言模型扮演Agent智能體玩牌類遊戲。

VScode右鍵打開(添加到右鍵)

ubuntu安裝Theano+cuda

圖像的論輪廓提取算法與代碼

python與C 聯合編譯

基於能量模型的RBM

馬爾科夫鏈與吉布斯抽樣

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

圖像的論輪廓提取算法與代碼

第7章 邊沿檢測與提取，輪廓跟蹤

7.1 邊沿檢測

7.2 Hough變換

7.3 輪廓提取

7.4 種子填充

7.5 輪廓跟蹤

第7章邊沿檢測與提取，輪廓跟蹤