连通域提取

最新推荐文章于 2023-11-13 18:46:55 发布
最新推荐文章于 2023-11-13 18:46:55 发布
阅读量4.7k 收藏 7
点赞数 1
分类专栏： 图像处理基础算法 文章标签： 图像处理 连通域提取
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guanyuqiu/article/details/53009305
版权

基于区域生长的方法

单次扫描的算法有一种基于区域生长的连通区域标记算法，算法流程如下：
  1. 输入待标记图像bitmap，初始化一个与输入图像同样尺寸的标记矩阵labelmap，一个队列queue以及标记计数labelIndex；
  2. 从左至右、从上至下的顺序扫描bitmap，当扫描到一个未被标记的前景像素p时，labelIndex加1，并在labelmap中标记p(相应点的值赋为labelIndex)，同时，扫描p的八邻域点，若存在未被标记的前景像素，则在labelmap中进行标记，并放入queue中，做为区域生长的种子；
  3. 当queue不为空时，从queue中取出一个生长种子点p1，扫描p1的八邻域点，若存在未被标记过的前景像素，则在labelmap中进行标记，并放入queue中；
  4. 重复3直至queue为空，一个连通区标记完成；
  5. 转到2，直至整幅图像都被扫描完毕，得到标记矩阵labelmap和联通区的个数labelIndex。
以上是基于区域生长进行连通域提取的步骤，在实际操作中，我对其中的queue进行了修改，利用两个指针(一个指向头，一个指向尾)来进行操作。 
<pre name="code" class="cpp">typedef struct _IVT_QUEUE
{
	IVT_POINT	       point;
	int			nIndex;
}IVT_QUEUE,*pIVT_QUEUE;
typedef struct _IVT_BLOB_
{
	IVT_RECT             BlobRect;
	int			nArea;
}IVT_BLOB;
int*       m_pLabelmap = NULL;
m_pLabelmap = new int[m_nMulti];


 
 
<pre name="code" class="cpp">int ConnectedComponentROI(unsigned char* pImgData,  IVT_BLOB* pBlob)
{
	IVT_QUEUE       *pHead,*pEnd;
	int		labelIndex=0,nIndex,i,cx,cy;
	int		nCreateBlobNum=0;		

	memset(m_pLabelmap, 0, m_nMulti * sizeof(int));

	for (cy=1; cy<m_nHeight-1; cy++)
	{
          for(cx=1;cx<m_nWidth-1;cx++)
	  {
		nIndex = cy*m_nWidth+cx;
		if (pImgData[nIndex]&(!m_pLabelmap[nIndex]))
		{
			pEnd = pHead = m_pQueue;

			m_pNewBlob->nTop = cy;
			m_pNewBlob->nLeft = cx;
			m_pNewBlob->nRight = cx;
			m_pNewBlob->nBottom = cy;
			pHead->nIndex = nIndex;
			pHead->point.x = pInder->nWidth;
			pHead->point.y = pInder->nHeight;
			labelIndex++;
			SearchNeighbor(pImgData,pHead,labelIndex, nIndex, m_pLabelmap, pEnd);

			while(pHead!=pEnd)
			{
				SearchNeighbor(pImgData, pHead,labelIndex, m_pLabelmap, pEnd);
				pHead++;;
			}

			if (nCreateBlobNum>999)
			{
				printf("BlobNum too many!\r\n");
				return -1;
			}


			pBlob[nCreateBlobNum].BlobRect =  m_pNewBlob;
			nCreateBlobNum++;
		}
	}

	nCreateBlobNum = CombineBlob(nCreateBlobNum,pBlob);
	nCreateBlobNum = DeleteSmallBlob(nCreateBlobNum,pBlob);
	return nCreateBlobNum;
}
 
 


 
 
 
 
void SearchNeighbor(unsigned char* pImgData,IVT_QUEUE *pQueue, int labelIndex,int* &pLabelmap,IVT_QUEUE* &pEnd)
{
	int		        searchIndex,i; 
	int				nCx,nCy;
	pLabelmap[pQueue->nIndex] = labelIndex;
	nCx = pQueue->point.x;
	nCy = pQueue->point.y;

	//邻域{0，1}
	searchIndex = pQueue->nIndex + 1;
	if ( (searchIndex>=0) && (nCx+1 <m_nWidth) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nRight = m_pNewBlob->nRight>nCx+1?m_pNewBlob->nRight:nCx+1;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx+1;
		pEnd->point.y = nCy;
		pEnd++;
	}

	//邻域{1，1}
	searchIndex = pQueue->nIndex + m_nWidth + 1;
	if ((searchIndex>=0) && (nCx+1<m_nWidth) && (nCy+1<m_nHeight) && (255 == pImgData[searchIndex]) && (!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nRight = m_pNewBlob->nRight>nCx+1?m_pNewBlob->nRight:nCx+1;
		m_pNewBlob->nBottom = m_pNewBlob->nBottom>nCy+1?m_pNewBlob->nBottom:nCy+1;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx+1;
		pEnd->point.y = nCy+1;
		pEnd++;
	}

	//邻域{1，0}
	searchIndex = pQueue->nIndex + m_nWidth;
	if ((searchIndex>=0) && (nCy+1<m_nHeight) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nBottom = m_pNewBlob->nBottom>nCy+1?m_pNewBlob->nBottom:nCy+1;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx;
		pEnd->point.y = nCy+1;
		pEnd++;
	}

	//邻域{1，-1}
	searchIndex = pQueue->nIndex + m_nWidth - 1;
	if ((searchIndex>=0) && (nCx-1>=0) && (nCy+1<m_nHeight) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nLeft = m_pNewBlob->nLeft<nCx-1?m_pNewBlob->nLeft:nCx-1;
		m_pNewBlob->nBottom = m_pNewBlob->nBottom>nCy+1?m_pNewBlob->nBottom:nCy+1;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx-1;
		pEnd->point.y = nCy+1;
		pEnd++;
	}

	//邻域{0，-1}
	searchIndex = pQueue->nIndex - 1;
	if ((searchIndex>=0) && (nCx-1>=0) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nLeft = m_pNewBlob->nLeft<nCx-1?m_pNewBlob->nLeft:nCx-1;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx-1;
		pEnd->point.y = nCy;
		pEnd++;
	}
	
	//邻域{-1，-1}
	searchIndex = pQueue->nIndex - m_nWidth - 1;
	if ((searchIndex>=0) && (nCx-1>=0) && (nCy-1>=0) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nLeft = m_pNewBlob->nLeft<nCx-1?m_pNewBlob->nLeft:nCx-1;
		m_pNewBlob->nTop = m_pNewBlob->nTop<nCy-1?m_pNewBlob->nTop:nCy-1;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx-1;
		pEnd->point.y = nCy-1;
		pEnd++;
	}

	//邻域{-1，0}
	searchIndex = pQueue->nIndex - m_nWidth;
	if ((searchIndex>=0) && (nCy-1>=0) && (255 == pImgData[searchIndex]) && (!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nTop = m_pNewBlob->nTop<nCy-1?m_pNewBlob->nTop:nCy-1;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx;
		pEnd->point.y = nCy-1;
		pEnd++;
	}

	//邻域{-1，1}
	searchIndex = pQueue->nIndex - m_nWidth + 1;
	if ((searchIndex>=0) && (nCx+1<m_nWidth) && (nCy-1>=0) && (255 == pImgData[searchIndex]) &(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nRight = m_pNewBlob->nRight>nCx+1?m_pNewBlob->nRight:nCx+1;
		m_pNewBlob->nTop = m_pNewBlob->nTop<nCy-1?m_pNewBlob->nTop:nCy-1;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx+1;
		pEnd->point.y = nCy-1;
		pEnd++;
	}

	//邻域{-2，-2}
	searchIndex = pQueue->nIndex - 2 * m_nWidth - 2;
	if ( (searchIndex>=0) && (nCx-2>=0) && (nCy-2>=0) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nLeft = m_pNewBlob->nLeft<nCx-2?m_pNewBlob->nLeft:nCx-2;
		m_pNewBlob->nTop = m_pNewBlob->nTop<nCy-2?m_pNewBlob->nTop:nCy-2;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx-2;
		pEnd->point.y = nCy-2;
		pEnd++;
	}

	//邻域{-2，-1}
	searchIndex = pQueue->nIndex - 2 * m_nWidth - 1;
	if ( (searchIndex>=0) && (nCx-1>=0) && (nCy-2>=0) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nLeft = m_pNewBlob->nLeft<nCx-1?m_pNewBlob->nLeft:nCx-1;
		m_pNewBlob->nTop = m_pNewBlob->nTop<nCy-2?m_pNewBlob->nTop:nCy-2;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx-1;
		pEnd->point.y = nCy-2;
		pEnd++;
	}

	//邻域{-2，0}
	searchIndex = pQueue->nIndex - 2 * m_nWidth;
	if ( (searchIndex>=0) && (nCy-2>=0) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nTop = m_pNewBlob->nTop<nCy-2?m_pNewBlob->nTop:nCy-2;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx;
		pEnd->point.y = nCy-2;
		pEnd++;
	}

	//邻域{-2，1}
	searchIndex = pQueue->nIndex - 2 * m_nWidth + 1;
	if ( (searchIndex>=0) && (nCx+1<m_nWidth) && (nCy-2>=0) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nRight = m_pNewBlob->nRight>nCx+1?m_pNewBlob->nRight:nCx+1;
		m_pNewBlob->nTop = m_pNewBlob->nTop<nCy-2?m_pNewBlob->nTop:nCy-2;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx+1;
		pEnd->point.y = nCy-2;
		pEnd++;
	}

	//邻域{-2，2}
	searchIndex = pQueue->nIndex - 2 * m_nWidth + 2;
	if ( (searchIndex>=0) && (nCx+2<m_nWidth) && (nCy-2>=0) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nRight = m_pNewBlob->nRight>nCx+2?m_pNewBlob->nRight:nCx+2;
		m_pNewBlob->nTop = m_pNewBlob->nTop<nCy-2?m_pNewBlob->nTop:nCy-2;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx+2;
		pEnd->point.y = nCy-2;
		pEnd++;
	}

	//邻域{-1，-2}
	searchIndex = pQueue->nIndex - m_nWidth - 2;
	if ( (searchIndex>=0) && (nCx-2>=0) && (nCy-1>=0) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nLeft = m_pNewBlob->nLeft<nCx-2?m_pNewBlob->nLeft:nCx-2;
		m_pNewBlob->nTop = m_pNewBlob->nTop<nCy-1?m_pNewBlob->nTop:nCy-1;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx-2;
		pEnd->point.y = nCy-1;
		pEnd++;
	}

	//邻域{-1，2}
	searchIndex = pQueue->nIndex - m_nWidth + 2;
	if ( (searchIndex>=0) && (nCx+2<m_nWidth) && (nCy-1>=0) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nRight = m_pNewBlob->nRight>nCx+2?m_pNewBlob->nRight:nCx+2;
		m_pNewBlob->nTop = m_pNewBlob->nTop<nCy-1?m_pNewBlob->nTop:nCy-1;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx+2;
		pEnd->point.y = nCy-1;
		pEnd++;
	}

	//邻域{0，-2}
	searchIndex = pQueue->nIndex - 2;
	if ( (searchIndex>=0) && (nCx-2>=0) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nLeft = m_pNewBlob->nLeft<nCx-2?m_pNewBlob->nLeft:nCx-2;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx-2;
		pEnd->point.y = nCy;
		pEnd++;
	}

	//邻域{0，2}
	searchIndex = pQueue->nIndex + 2;
	if ( (searchIndex>=0) && (nCx+2<m_nWidth) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nRight = m_pNewBlob->nRight>nCx+2?m_pNewBlob->nRight:nCx+2;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx+2;
		pEnd->point.y = nCy;
		pEnd++;
	}

	//邻域{1，-2}
	searchIndex = pQueue->nIndex + m_nWidth - 2;
	if ( (searchIndex>=0) && (nCx-2>=0) && (nCy+1<m_nHeight) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nLeft = m_pNewBlob->nLeft<nCx-2?m_pNewBlob->nLeft:nCx-2;
		m_pNewBlob->nBottom = m_pNewBlob->nBottom>nCy+1?m_pNewBlob->nBottom:nCy+1;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx-2;
		pEnd->point.y = nCy+1;
		pEnd++;
	}

	//邻域{1，2}
	searchIndex = pQueue->nIndex + m_nWidth + 2;
	if ( (searchIndex>=0) && (nCx+2<m_nWidth) && (nCy+1<m_nHeight) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nRight = m_pNewBlob->nRight>nCx+2?m_pNewBlob->nRight:nCx+2;
		m_pNewBlob->nBottom = m_pNewBlob->nBottom>nCy+1?m_pNewBlob->nBottom:nCy+1;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx+2;
		pEnd->point.y = nCy+1;
		pEnd++;
	}

	//邻域{2，-2}
	searchIndex = pQueue->nIndex + 2 * m_nWidth - 2;
	if ( (searchIndex>=0) && (nCx-2>=0) && (nCy+2<m_nHeight) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nLeft = m_pNewBlob->nLeft<nCx-2?m_pNewBlob->nLeft:nCx-2;
		m_pNewBlob->nBottom = m_pNewBlob->nBottom>nCy+2?m_pNewBlob->nBottom:nCy+2;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx-2;
		pEnd->point.y = nCy+2;
		pEnd++;
	}

	//邻域{2，-1}
	searchIndex = pQueue->nIndex + 2 * m_nWidth - 1;
	if ( (searchIndex>=0) && (nCx-1>=0) && (nCy+2<m_nHeight) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nLeft = m_pNewBlob->nLeft<nCx-1?m_pNewBlob->nLeft:nCx-1;
		m_pNewBlob->nBottom = m_pNewBlob->nBottom>nCy+2?m_pNewBlob->nBottom:nCy+2;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx-1;
		pEnd->point.y = nCy+2;
		pEnd++;
	}

	//邻域{2，0}
	searchIndex = pQueue->nIndex + 2 * m_nWidth;
	if ( (searchIndex>=0) && (nCy+2<m_nHeight) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nBottom = m_pNewBlob->nBottom>nCy+2?m_pNewBlob->nBottom:nCy+2;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx;
		pEnd->point.y = nCy+2;
		pEnd++;
	}

	//邻域{-2，1}
	searchIndex = pQueue->nIndex + 2 * m_nWidth + 1;
	if ( (searchIndex>=0) && (nCx+1<m_nWidth) && (nCy+2<m_nHeight) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nRight = m_pNewBlob->nRight>nCx+1?m_pNewBlob->nRight:nCx+1;
		m_pNewBlob->nBottom = m_pNewBlob->nBottom>nCy+2?m_pNewBlob->nBottom:nCy+2;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx+1;
		pEnd->point.y = nCy+2;
		pEnd++;
	}

	//邻域{-2，2}
	searchIndex = pQueue->nIndex + 2 * m_nWidth + 2;
	if ( (searchIndex>=0) && (nCx+2<m_nWidth) && (nCy+2<m_nHeight) && (255 == pImgData[searchIndex]) &&(!pLabelmap[searchIndex]))
	{
		pLabelmap[searchIndex] = labelIndex;
		m_pNewBlob->nRight = m_pNewBlob->nRight>nCx+2?m_pNewBlob->nRight:nCx+2;
		m_pNewBlob->nBottom = m_pNewBlob->nBottom>nCy+2?m_pNewBlob->nBottom:nCy+2;
		pEnd->nIndex = searchIndex;
		pEnd->point.x = nCx+2;
		pEnd->point.y = nCy+2;
		pEnd++;
	}
}
 
 
/************************************************************************/
/* 目标连通域较近的进行合并                                             */
/************************************************************************/
int	CombineBlob(int nNum, IVT_BLOB *pBlob)
{
	int			i=0,nFlag,j,k=0;
	IVT_RECT	*p1,*p2;
	IVT_BLOB	*pB1;
	if (nNum<2||pBlob==NULL)
	{
		return nNum;
	}
	for (i=0;i<nNum; i++,k=0)
	{
		p1 = &pBlob[i].BlobRect;
		for (;k<nNum; k++)
		{
			if (i!=k)
			{
				p2 = &pBlob[k].BlobRect;
				nFlag = RectsIfMerge(p1,p2);
				if (nFlag == 1)
				{
					if (k>i)
					{
						for (j=k;j<nNum-1;j++)
						{
							pBlob[j] = pBlob[j+1];
						}
					}
					else
					{
						for (j=k;j<nNum-1;j++)
						{
							pBlob[j] = pBlob[j+1];
						}
						i--;
						p1 = &pBlob[i].BlobRect;
					}
					nNum--;
					k = -1;
				}

			}
		}
	}
	return nNum;
}
/************************************************************************/
/* 两个目标框离得是否近
   1——近
   0——远*/
/************************************************************************/
int RectsIfMerge(IVT_RECT *ptRectI,	IVT_RECT *pRectJ)
{
	int		x1, y1, x11, y11, x2, y2, x22, y22,Wi, Hi,Wj, Hj,Ow, Oh,Uw, Uh;  
	int		nCenter_x1,nCenter_y1,nCenter_x2,nCenter_y2,nIndex1,nIndex2,nLocation1,nLocation2,nIndexMin;
	int		nMax_X,nMax_Y,nMin_X,nMin_Y;

	nCenter_x1 = (ptRectI->nLeft+ptRectI->nRight)>>1;
	nCenter_y1 = (ptRectI->nTop+ptRectI->nBottom)>>1;
	nIndex1 = nCenter_y1*m_nWidth+nCenter_x1;
	nLocation1 = m_pImageROI_Data[nIndex1].nIndex;

	nCenter_x2 = (pRectJ->nLeft+pRectJ->nRight)>>1;
	nCenter_y2 = (pRectJ->nTop+pRectJ->nBottom)>>1;
	nIndex2 = nCenter_y2*m_nWidth+nCenter_x2;
	nLocation2 = m_pImageROI_Data[nIndex2].nIndex;

	if (abs(nLocation1-nLocation2)>1)
	{
		return 0;
	}
	nIndexMin = nLocation1<nLocation2?nLocation1:nLocation2;

	x1  = ptRectI->nLeft;
	y1  = ptRectI->nTop;
	x11 = ptRectI->nRight;
	y11 = ptRectI->nBottom; 

	x2  = pRectJ->nLeft;
	y2  = pRectJ->nTop;
	x22 = pRectJ->nRight;
	y22 = pRectJ->nBottom;

	nMax_X = MaxInt(x11, x22);
	nMin_X = MinInt(x1, x2);
	nMax_Y = MaxInt(y11, y22);
	nMin_Y = MinInt(y1, y2);

	if ((((y2<y11)&&(y1<y2))||((y22<y11)&&(y22>y1)))
		&&(((x2<x11)&&(x1<x2))||((x22<x11)&&(x1<x22))))
	{
		ptRectI->nLeft = nMin_X;
		ptRectI->nTop = nMin_Y;
		ptRectI->nRight = nMax_X;
		ptRectI->nBottom = nMax_Y; 
		return 1;
	}
	if (((y1<y22)&&(y2<y1)||(y11<y22)&&(y11>y2))
		&&((x1<x22)&&(x1>x2)||(x22>x11)&&(x2<x11)))
	{
		ptRectI->nLeft = nMin_X;
		ptRectI->nTop = nMin_Y;
		ptRectI->nRight = nMax_X;
		ptRectI->nBottom = nMax_Y; 
		return 1;
	}  
	Wi = x11 - x1;
	Hi = y11 - y1;

	Wj = x22 - x2;
	Hj = y22 - y2;

	Uw = nMax_X - nMin_X;
	Uh = nMax_Y - nMin_Y;
	Ow = Uw - Wi - Wj;
	Oh = Uh - Hi - Hj;

	if((Ow<Trow[nIndexMin])&&(Oh<Troh[nIndexMin]))
	{
		ptRectI->nLeft = nMin_X;
		ptRectI->nTop = nMin_Y;
		ptRectI->nRight = nMax_X;
		ptRectI->nBottom = nMax_Y; 
		return 1;
	}

	return 0;  
}
int	MaxInt(int n, int m)
{
	return m>n?m:n;
}
int MinInt(int n, int m)
{
	return m<n?m:n;
}

 
 
 
 
 
 
 
 
 
 
 


                

        

        

    




    

      

        

            

              
                
                  sunny_develop
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    7
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
【图像处理】CCL算法--二值图的连通域提取

				
			

			

				

					gongdiwudu的专栏
				

				

					05-21
					
					5589
					
				

			

		

		

			
				
术语连通分量标记 (CCL) 的使用及其定义在学术文献中非常一致，而连通分量分析 (CCA-connected component Algorithm) 在术语定义方面各不相同，类似的算法也不少。这里介绍建立在二值化图的连通分量分析。

			
		

	



                

              
                



	

		

			

				
					
目标分割算法之连通域分析

				
			

			

				

					yohnyang的博客
				

				

					01-27
					
					6384
					
				

			

		

		

			
				
1.连通域提取
二值化后的图像为8位图CV_8UC1,首先对连通域进行标记，然后针对32位CV_32S图像进行连通域提取
具体如下：
//标记连通域  img_bw == 二值图像
Mat mask;
connectedComponents(img_bw, mask, 8);//mask位32位图，连通域标签为其索引值
map<int, vector<Point>> map_connect;
for (int i = 0; i < mask.rows; i++)
{
	for 

			
		

	



                


  
              

                


	

		

			

				
					
HSV颜色空间

				
			

			

				

					qccz123456的博客
				

				

					12-01
					
					647
					
				

			

		

		

			
				
色调H
        用角度度量，取值范围为0°～360°，从红色开始按逆时针方向计算，红色为0°，绿色为120°,蓝色为240°。它们的补色是：黄色为60°，青色为180°,品红为300°；
饱和度S
        饱和度S表示颜色接近光谱色的程度。一种颜色，可以看成是某种光谱色与白色混合的结果。其中光谱色所占的比例愈大，颜色接近光谱色的程度就愈高，颜色的饱和度也就愈高。饱和度高，颜色

			
		

	





	

		

			

				
					
C++实现查找连通域

				
			

			

				

					整理ing
				

				

					11-13
					
					1686
					
				

			

		

		

			
				
C++实现查找连通域

			
		

	



		

			
		



	

		

			

				
					
图像处理（五）——连通域

				
			

			

				

					南木的博客
				

				

					11-07
					
					3万+
					
				

			

		

		

			
				
连通区域（Connected Component）一般是指图像中具有相同像素值且位置相邻的前景像素点组成的图像区域（Region，Blob）。连通区域分析（Connected Component Analysis,Connected Component Labeling）是指将图像中的各个连通区域找出并标记。
连通区域分析是一种在CVPR和图像分析处理的众多应用领域中较为常用和基本的方法。例如：...

			
		

	





	

		

			

				
					
数字图像处理实训-基于C++实现的图像连通域提取与形状特征分析源码+代码注释.zip

				
			

			

				

					10-26
				

			

		

		

			
				
数字图像处理实训-基于C++实现的图像连通域提取与形状特征分析源码+代码注释.zip数字图像处理实训-基于C++实现的图像连通域提取与形状特征分析源码+代码注释.zip数字图像处理实训-基于C++实现的图像连通域提取与形状...

			
		

	





	

		

			

				
					
连通域提取matlab程序-connectdomain.m

				
			

			

				

					08-13
				

			

		

		

			
				
连通域提取matlab程序-connectdomain.m   一个简单的提取连通域的matlab程序，希望对大家有用

			
		

	





	

		

			

				
					
获取连通域(可根据面积筛选封闭图形)

				
			

			

				

					11-19
				

			

		

		

			
				
通过对图像的连通域进行分析和筛选，可以有效地提取图像中有价值的信息，这对于后续的目标识别、分类等任务非常重要。读者可以根据自己的需求调整代码中的参数，如面积阈值等，以满足不同的应用场景。

			
		

	





	

		

			

				
					
数字图像处理实习 - 图像连通域提取与形状特征分析+C++源代码+文档说明（高分作品）

					
最新发布

				
			

			

				

					08-18
				

			

		

		

			
				
图像连通域提取与形状特征分析 - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ 1、该资源内项目代码都...

			
		

	





	

		

			

				
					
基于Matlab的连通域算法

				
			

			

				

					06-06
				

			

		

		

			
				
采用连通域方式，对图像进行切分，以助于下一步提取有用的信息。

			
		

	





	

		

			

				
					
【OpenCV学习笔记 010】提取直线、轮廓及连通区域

				
			

			

				

					10-01
				

			

		

		

			
				
爱分享、爱极客的编程怪兽--DaveBobo
博文 《【OpenCV学习笔记 010】提取直线、轮廓及连通区域》
博文链接：
http://blog.csdn.net/davebobo/article/details/52583167
OpenCV版本：2.4.9

			
		

	





	

		

			

				
					
图像处理CCL算法-二值图的连通域提取

				
			

			

				

					10-14
				

			

		

		

			
				
连通分量标记 (CCL)、连通分量分析 (CCA)、blob 提取、区域标记、blob 发现或区域提取是图论的一种算法应用，其中连通分量的子集根据给定的启发式方法进行唯一标记。不要将连通分量标记与分段混淆。  连通分量标记在...

			
		

	





	

		

			

				
					
【机器视觉学习笔记】二值图像连通区域提取算法（C++）

				
			

			

				

					乙酸氧铍的博客
				

				

					10-26
					
					3668
					
				

			

		

		

			
				
目录源码效果示例一示例二
平台：Windows 10 20H2
 Visual Studio 2015
 OpenCV 4.5.3

本文代码摘自OpenCV-二值图像连通域分析 —— 青雲-吾道乐途
源码
#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <map>
#include <stack>
#include &lt

			
		

	





	

		

			

				
					
基于行程标记的快速连通域提取实现

				
			

			

				

					u010050735的博客
				

				

					07-14
					
					1464
					
				

			

		

		

			
				
一直在使用halcon进行图像处理，但本人更倾向于自己写算法，所以也一直在使用Opencv。对于halcon，其连通域的处理相当方便，所以一直想用Opencv来实现这样的功能。由于最近项目以及对后续转用Opencv的想法，利用工作之余的时间查了些资料，再结合自己的一些想法，用Opencv实现了这项功能。

最开始在网上找了些方法，例如1）Two-Pass法；2）Seed-Filling种子填充法[1] ,这两种方法容易理解，都是基于8连通或者4连通的基础，但效率相当低。后来找了几篇论文，提到了基于行程的提取

			
		

	





	

		

			

				
					
openCV连通域的提取与质心标记

				
			

			

				

					李文韬的博客
				

				

					02-10
					
					1954
					
				

			

		

		

			
				
openCV的函数可以轻松提取黑白图像的连通域，并给出每个连通区质心的位置。以下图为例我们希望提取图片中的两个白色正方体和一个圆形，并标记它们的质量中心。

			
		

	





	

		

			

				
					
opencv形态学应用之连通域提取

				
			

			

				

					wxplol的博客
				

				

					06-12
					
					8066
					
				

			

		

		

			
				
提取连通域实际上是标记连通域的过程，其算法如下：
初始点：Bo=某个连通分量中的某点（这里通过遍历图像，知道像素值为255，将此点作为种子点）
循环：


（用3X3d的结构元素对种子点进行膨胀，然后用原图像对膨胀结果取交集）
结束条件：知道膨胀的图像不发生变化


在这里可以用一个模板来存储连通分量，其位置对应原图像的位置。提取完后可以修改原图像的像素值，即一个标签。
实现过

			
		

	





	

		

			

				
					
python连通域提取 原理_连通域的原理与Python实现

				
			

			

				

					weixin_36121284的博客
				

				

					02-04
					
					3120
					
				

			

		

		

			
				
二值图像连通域二值图像分析最基础的也是最重要的方法之一就是连通域标记，它是所有二值图像分析的基础。它通过对二值图像中目标像素的标记，让每个单独的连通区域形成一个被标识的块，进一步的我们就可以获取这些块的轮廓、外接矩形、质心、不变矩等几何参数。 连通区域的定义一般有两种，分为4邻接和8邻接。下面这幅图中，如果考虑4邻接，则有3个连通域，8邻接则是2个连通域。从连通区域的定义可以知道，一个连通域是由具...

			
		

	





	

		

			

				
					
图像纹理——灰度共生矩阵

					
热门推荐

				
			

			

				

					sunny的专栏
				

				

					11-11
					
					8万+
					
				

			

		

		

			
				
1.灰度共生矩阵
本文是借用一篇文章的例子讲解灰度共生矩阵，用文字说明感觉说不清，自己之前用该方法做过实验，还是会忘，所以干脆用例子的方式介绍，下一次再看也容易理解。
在图像中任意一点（x,y）及偏离它的一点(x+a,y+b)(其中a，b为整数，认为定义)构成点对。设该点对的灰度值为(f1,f2),假设图像的最大灰度级为L,则f1与f2的组合共有L*L种。对于整福图像，统计每一种(f1,f2)

			
		

	





	

		

			

				
					
python连通域提取

				
			

			

				

					09-17
				

			

		

		

			
				
Python连通域提取是指在图像处理中使用Python编程语言来识别和分离图像中的连通域。连通域是指在一幅图像中，像素值相同且相互连接的一组像素点集合。  在Python中，可以使用OpenCV库来进行图像处理。OpenCV提供了一...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值