求hough变换检测圆和椭圆的源代码

[lnaonao]

求hough变换检测圆和椭圆的源代码

[lnaonao]

很惨！没人给我回复。

[Sportbeuty]

《北京希望电子出版社》的数字图象处理学，VC＋＋实现。有检测圆的。你找找看了

[duwenyong]

一个hough你自己看看
/////////////////////////////////////////////////////////////////////////////////////
// 边缘与轮廓
//
void CCh1_1View::OnEdgeHough()
{
//Hough运算

// 获取文档
CCh1_1Doc* pDoc = GetDocument();

// 指向DIB的指针
LPSTR lpDIB;

// 指向DIB象素指针
LPSTR lpDIBBits;

// 锁定DIB
lpDIB = (LPSTR) ::GlobalLock((HGLOBAL) pDoc->GetHDIB());

// 判断是否是8-bpp位图（这里为了方便，只处理8-bpp位图的Hough变换，其它的可以类推）
if (::DIBNumColors(lpDIB) != 256)
{
// 提示用户
MessageBox("目前只支持256色位图的运算！", "系统提示" , MB_ICONINFORMATION | MB_OK);

// 解除锁定
::GlobalUnlock((HGLOBAL) pDoc->GetHDIB());

// 返回
return;
}

// 更改光标形状
BeginWaitCursor();

// 找到DIB图像象素起始位置
lpDIBBits = ::FindDIBBits(lpDIB);

// 调用HoughDIB()函数对DIB
if (HoughDIB(lpDIBBits, ::DIBWidth(lpDIB), ::DIBHeight(lpDIB)))
{

// 设置脏标记
pDoc->SetModifiedFlag(TRUE);

// 更新视图
pDoc->UpdateAllViews(NULL);
}
else
{
// 提示用户
MessageBox("分配内存失败或者图像中含有0和255之外的像素值！", "系统提示" , MB_ICONINFORMATION | MB_OK);
}

// 解除锁定
::GlobalUnlock((HGLOBAL) pDoc->GetHDIB());

// 恢复光标
EndWaitCursor();

}

/*************************************************************************
*
* 函数名称：
* HoughDIB()
*
* 参数:
* LPSTR lpDIBBits - 指向源DIB图像指针
* LONG lWidth - 源图像宽度（象素数，必须是4的倍数）
* LONG lHeight - 源图像高度（象素数）
* 返回值:
* BOOL - 运算成功返回TRUE，否则返回FALSE。
*
* 说明:
* 该函数用于对检测图像中的平行直线。如果图像中有两条平行的直线，则将这两条平行直线
* 提取出来。
*
* 要求目标图像为只有0和255两个灰度值的灰度图像。
************************************************************************/

BOOL WINAPI HoughDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
{

// 指向源图像的指针
LPSTR lpSrc;

// 指向缓存图像的指针
LPSTR lpDst;

// 指向变换域的指针
LPSTR lpTrans;

// 图像每行的字节数
LONG lLineBytes;

// 指向缓存DIB图像的指针
LPSTR lpNewDIBBits;
HLOCAL hNewDIBBits;

//指向变换域的指针
LPSTR lpTransArea;
HLOCAL hTransArea;

//变换域的尺寸
int iMaxDist;
int iMaxAngleNumber;

//变换域的坐标
int iDist;
int iAngleNumber;

//循环变量
long i;
long j;

//像素值
unsigned char pixel;

//存储变换域中的两个最大值
MaxValue MaxValue1;
MaxValue MaxValue2;

// 暂时分配内存，以保存新图像
hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);

if (hNewDIBBits == NULL)
{
// 分配内存失败
return FALSE;
}

// 锁定内存
lpNewDIBBits = (char * )LocalLock(hNewDIBBits);

// 初始化新分配的内存，设定初始值为255
lpDst = (char *)lpNewDIBBits;
memset(lpDst, (BYTE)255, lWidth * lHeight);

//计算变换域的尺寸
//最大距离
iMaxDist = (int) sqrt(lWidth*lWidth + lHeight*lHeight);

//角度从0－180，每格2度
iMaxAngleNumber = 90;

//为变换域分配内存
hTransArea = LocalAlloc(LHND, lWidth * lHeight * sizeof(int));

if (hNewDIBBits == NULL)
{
// 分配内存失败
return FALSE;
}

// 锁定内存
lpTransArea = (char * )LocalLock(hTransArea);

// 初始化新分配的内存，设定初始值为0
lpTrans = (char *)lpTransArea;
memset(lpTrans, 0, lWidth * lHeight * sizeof(int));

// 计算图像每行的字节数
lLineBytes = WIDTHBYTES(lWidth * 8);

for(j = 0; j <lHeight; j++)
{
for(i = 0;i <lWidth; i++)
{

// 指向源图像倒数第j行，第i个象素的指针
lpSrc = (char *)lpDIBBits + lLineBytes * j + i;

//取得当前指针处的像素值，注意要转换为unsigned char型
pixel = (unsigned char)*lpSrc;

//目标图像中含有0和255外的其它灰度值
if(pixel != 255 && *lpSrc != 0)
return FALSE;

//如果是黑点，则在变换域的对应各点上加1
if(pixel == 0)
{
//注意步长是2度
for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)
{
iDist = (int) fabs(i*cos(iAngleNumber*2*pi/180.0) + \
j*sin(iAngleNumber*2*pi/180.0));

//变换域的对应点上加1
*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber) = \
*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber) +1;
}
}

}
}

//找到变换域中的两个最大值点
MaxValue1.Value=0;
MaxValue2.Value=0;

//找到第一个最大值点
for (iDist=0; iDist<iMaxDist;iDist++)
{
for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)
{
if((int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber)>MaxValue1.Value)
{
MaxValue1.Value = (int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber);
MaxValue1.Dist = iDist;
MaxValue1.AngleNumber = iAngleNumber;
}

}
}

//将第一个最大值点附近清零
for (iDist = -9;iDist < 10;iDist++)
{
for(iAngleNumber=-1; iAngleNumber<2; iAngleNumber++)
{
if(iDist+MaxValue1.Dist>=0 && iDist+MaxValue1.Dist<iMaxDist \
&& iAngleNumber+MaxValue1.AngleNumber>=0 && iAngleNumber+MaxValue1.AngleNumber<=iMaxAngleNumber)
{
*(lpTransArea+(iDist+MaxValue1.Dist)*iMaxAngleNumber+\
(iAngleNumber+MaxValue1.AngleNumber))=0;
}
}
}

//找到第二个最大值点
for (iDist=0; iDist<iMaxDist;iDist++)
{
for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)
{
if((int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber)>MaxValue2.Value)
{
MaxValue2.Value = (int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber);
MaxValue2.Dist = iDist;
MaxValue2.AngleNumber = iAngleNumber;
}

}
}


//判断两直线是否平行
if(abs(MaxValue1.AngleNumber-MaxValue2.AngleNumber)<=2)
{
//两直线平行，在缓存图像中重绘这两条直线
for(j = 0; j <lHeight; j++)
{
for(i = 0;i <lWidth; i++)
{

// 指向缓存图像倒数第j行，第i个象素的指针
lpDst = (char *)lpNewDIBBits + lLineBytes * j + i;

//如果该点在某一条平行直线上，则在缓存图像上将该点赋为黑

//在第一条直线上
iDist = (int) fabs(i*cos(MaxValue1.AngleNumber*2*pi/180.0) + \
j*sin(MaxValue1.AngleNumber*2*pi/180.0));
if (iDist == MaxValue1.Dist)
*lpDst = (unsigned char)0;

//在第二条直线上
iDist = (int) fabs(i*cos(MaxValue2.AngleNumber*2*pi/180.0) + \
j*sin(MaxValue2.AngleNumber*2*pi/180.0));
if (iDist == MaxValue2.Dist)
*lpDst = (unsigned char)0;
}
}
}

// 复制腐蚀后的图像
memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);

// 释放内存
LocalUnlock(hNewDIBBits);
LocalFree(hNewDIBBits);

// 释放内存
LocalUnlock(hTransArea);
LocalFree(hTransArea);

// 返回
return TRUE;

}