二值图像连通区域标记

最新推荐文章于 2021-05-22 17:07:28 发布
最新推荐文章于 2021-05-22 17:07:28 发布
阅读量5.9k 收藏 8
点赞数
分类专栏： Computer Vision

转自：http://blog.csdn.net/jiangxinyu/article/details/7999102

这里列举二值图像连通域标记算法包括直接扫描标记算法和二值图像连通域标记快速算法

一、直接扫描标记算法把连续区域作同一个标记，常见的四邻域标记算法和八邻域标记算法。

1、  四邻域标记算法：

1）   判断此点四邻域中的最左，最上有没有点，如果都没有点，则表示一个新的区域的开始。

2）   如果此点四邻域中的最左有点，最上没有点，则标记此点为最左点的值；如果此点四邻域中的最左没有点，最上有点，则标记此点为最上点的值。

3）   如果此点四邻域中的最左有点，最上都有点，则标记此点为这两个中的最小的标记点，并修改大标记为小标记。

2、  八邻域标记算法：

1）   判断此点八邻域中的最左，左上，最上，上右点的情况。如果都没有点，则表示一个新的区域的开始。

2）   如果此点八邻域中的最左有点，上右都有点，则标记此点为这两个中的最小的标记点，并修改大标记为小标记。

3）   如果此点八邻域中的左上有点，上右都有点，则标记此点为这两个中的最小的标记点，并修改大标记为小标记。

4）   否则按照最左，左上，最上，上右的顺序，标记此点为四个中的一个。

代码实现：

 

[cpp]  view plain copy
  1. #include <list>  
  2. #include <vector>  
  3. #include <algorithm>  
  4. //连通区域属性结构  
  5. typedef struct tagMarkRegion  
  6. {  
  7. std::list<POINT> MarkPointList;//点列表  
  8. RECT rect;  
  9. }MarkRegion;  
  10.    
  11. //定义MarkMap 结构，用来存放等价对  
  12. typedef struct tagEqualMark  
  13. {    int MarkValue1;    //标记值  
  14. int MarkValue2;    //标记值  
  15. } EqualMark;  
  16.    
  17. //定义MarkMapping 结构，用来存放标记映射关系  
  18. typedef struct tagMarkMapping  
  19. {    int nOriginalMark;   //第一次扫描的标记  
  20. int nMappingMark;  //等价整理之后对应标记  
  21. } MarkMapping;  
  22.    
  23. /* 
  24. 功能说明：八连通标记 
  25. 参数说明：I，表示图像数据指针 
  26.            ImageWidth,表示图像宽 
  27.            ImageHeight，表示图像高 
  28.            off，表示偏移量 
  29.           nFlag,表示指定标记 
  30.            iColorType，表示颜色类型，（黑点，白点） 
  31.            markInfo，表示连通区域属性信息 
  32. 返回值：连通点数量，int类型 
  33. */  
  34. int FillAreaFlag33(LPINT I,int ImageWidth,int ImageHeight,long off,int nFlag,int iColorType,MarkRegion &markInfo)  
  35. {  
  36.      bool bNew;  
  37.      RECT rect;  
  38.      int m,n,i,j,k,nDot=1,offset,offtemp,yMin;  
  39.      int dxy[8],x,y;  
  40.      dxy[0]=-ImageWidth-1;     dxy[1]=-ImageWidth;                  dxy[2]=-ImageWidth+1;  
  41.      dxy[3]=-1;                                                                                     dxy[4]=1;  
  42.      dxy[5]=ImageWidth-1;       dxy[6]=ImageWidth;          dxy[7]=ImageWidth+1;  
  43.      rect.left=65535; rect.right=-1;  
  44.      rect.bottom=65535;   rect.top=-1;  
  45.     markInfo.MarkPointList.clear();  
  46.      POINT ptTmp;  
  47.      if(I[off]==iColorType && I[off]!=nFlag)//黑点同时未被标记的情况  
  48.      {  
  49.          I[off]=nFlag;  
  50.          x=off%ImageWidth;  
  51.          y=off/ImageWidth;  
  52.          ptTmp.x = x;  
  53.          ptTmp.y = y;  
  54.          markInfo.MarkPointList.push_back(ptTmp);  
  55.          if(x<rect.left)  
  56.               rect.left=x;  
  57.          if(x>rect.right)  
  58.               rect.right=x;  
  59.          if(y<rect.bottom)  
  60.               rect.bottom=y;  
  61.          if(y>rect.top)  
  62.               rect.top=y;  
  63.      }  
  64.      else  
  65.      {  
  66.          return 0;  
  67.      }  
  68.    
  69.      for(i=y; i<ImageHeight; i++)  
  70.      {  
  71.          bNew=false;  
  72.          yMin=i;  
  73.          for(j=0; j<ImageWidth; j++)  
  74.          {  
  75.               offset=i*ImageWidth+j;  
  76.               if(I[offset]==nFlag)  
  77.               {  
  78.                    for(k=0; k<8; k++)//八邻域搜索  
  79.                    {  
  80.                        if(i==0 && k<=2)  
  81.                             continue;  
  82.                        if(i==ImageHeight-1 && k>=5)  
  83.                             continue;  
  84.                        if(j==0 && (k==0 || k==3 || k==5))  
  85.                             continue;  
  86.                        if(j==ImageWidth-1 && (k==2 || k==4 || k==7))  
  87.                             continue;  
  88.                        offtemp=offset+dxy[k];  
  89.                        if(I[offtemp]==iColorType && I[offtemp]!=nFlag)  
  90.                        {  
  91.                             I[offtemp]=nFlag;  
  92.                             nDot++;  
  93.                             m=offtemp/ImageWidth;  
  94.                             n=offtemp%ImageWidth;  
  95.                             ptTmp.x = n;  
  96.                             ptTmp.y = m;  
  97.                             markInfo.MarkPointList.push_back(ptTmp);  
  98.                             if(n < rect.left)  
  99.                                  rect.left=n;  
  100.                             if(n > rect.right)  
  101.                                  rect.right=n;  
  102.                             if(m < rect.bottom)  
  103.                                  rect.bottom=m;  
  104.                             if(m > rect.top)  
  105.                                  rect.top=m;  
  106.                             y=offtemp/ImageWidth;  
  107.                             if(y<=yMin)  
  108.                             {  
  109.                                  yMin=y;  
  110.                                  if(!bNew)  
  111.                                      bNew=true;  
  112.                             }  
  113.                        }  
  114.                    }  
  115.               }  
  116.          }  
  117.          if(bNew)  
  118.          {  
  119.               i=yMin-1;  
  120.          }  
  121.      }  
  122.      markInfo.rect.left = rect.left;  
  123.      markInfo.rect.right = rect.right;  
  124.      markInfo.rect.top = rect.top;  
  125.      markInfo.rect.bottom = rect.bottom;  
  126.      return nDot;  
  127. }  
  128.    
  129. /* 
  130. 功能说明：四连通标记 
  131. 参数说明：I，表示图像数据指针 
  132. ImageWidth,表示图像宽 
  133. ImageHeight，表示图像高 
  134. off，表示偏移量 
  135. nFlag,表示指定标记 
  136. iColorType，表示颜色类型，（黑点，白点） 
  137. markInfo，表示连通区域属性信息 
  138. 返回值：连通点数量，int类型 
  139. */  
  140. int FillAreaFlag22(LPINT I,int ImageWidth,int ImageHeight,long off,int nFlag,int iColorType,MarkRegion &markInfo)  
  141. {  
  142.      bool bNew;  
  143.      RECT rect;  
  144.      int m,n,i,j,k,nDot=1,offset,offtemp,yMin;  
  145.      int dxy[4],x,y;  
  146.      dxy[0]=-ImageWidth;     dxy[1]=1;                  
  147.      dxy[2]=ImageWidth;      dxy[3]=-1;  
  148.      rect.left=65535; rect.right=-1;  
  149.      rect.bottom=65535;   rect.top=-1;  
  150.      markInfo.MarkPointList.clear();  
  151.      POINT ptTmp;  
  152.      if(I[off]==iColorType && I[off]!=nFlag)//黑点同时未被标记的情况  
  153.      {  
  154.          I[off]=nFlag;  
  155.          x=off%ImageWidth;  
  156.          y=off/ImageWidth;  
  157.          ptTmp.x = x;  
  158.          ptTmp.y = y;  
  159.          markInfo.MarkPointList.push_back(ptTmp);  
  160.          if(x<rect.left)  
  161.               rect.left=x;  
  162.          if(x>rect.right)  
  163.               rect.right=x;  
  164.          if(y<rect.bottom)  
  165.               rect.bottom=y;  
  166.          if(y>rect.top)  
  167.               rect.top=y;  
  168.      }  
  169.      else  
  170.      {  
  171.          return 0;  
  172.      }  
  173.    
  174.      for(i=y; i<ImageHeight; i++)  
  175.      {  
  176.          bNew=false;  
  177.          yMin=i;  
  178.          for(j=0; j<ImageWidth; j++)  
  179.          {  
  180.               offset=i*ImageWidth+j;  
  181.               if(I[offset]==nFlag)  
  182.               {  
  183.                    for(k=0; k<4; k++)//四邻域搜索  
  184.                    {  
  185.                        if(i==0 && k==0)  
  186.                             continue;  
  187.                        if(i==ImageHeight-1 && k==2)  
  188.                             continue;  
  189.                        if(j==0 && k==3)  
  190.                             continue;  
  191.                        if(j==ImageWidth-1 && k==1)  
  192.                             continue;  
  193.                        offtemp=offset+dxy[k];  
  194.                        if(I[offtemp]==iColorType && I[offtemp]!=nFlag)  
  195.                        {  
  196.                             I[offtemp]=nFlag;  
  197.                             nDot++;  
  198.                             m=offtemp/ImageWidth;  
  199.                             n=offtemp%ImageWidth;  
  200.                             ptTmp.x = n;  
  201.                             ptTmp.y = m;  
  202.                             markInfo.MarkPointList.push_back(ptTmp);  
  203.                             if(n < rect.left)  
  204.                                  rect.left=n;  
  205.                             if(n > rect.right)  
  206.                                  rect.right=n;  
  207.                             if(m < rect.bottom)  
  208.                                  rect.bottom=m;  
  209.                             if(m > rect.top)  
  210.                                  rect.top=m;  
  211.                             y=offtemp/ImageWidth;  
  212.                             if(y<=yMin)  
  213.                             {  
  214.                                  yMin=y;  
  215.                                  if(!bNew)  
  216.                                      bNew=true;  
  217.                             }  
  218.                        }  
  219.                    }  
  220.               }  
  221.          }  
  222.          if(bNew)  
  223.          {  
  224.               i=yMin-1;  
  225.          }  
  226.      }  
  227.      markInfo.rect.left = rect.left;  
  228.      markInfo.rect.right = rect.right;  
  229.      markInfo.rect.top = rect.top;  
  230.      markInfo.rect.bottom = rect.bottom;  
  231.      return nDot;  
  232. }  
  233.    
  234.    
  235. 二、二值图像连通域标记快速算法  
  236. 算法描述  
  237. 　　首先，在进行标记算法以前，利用硬件开辟独立的图像标记缓存和连通关系数组，接着在视频流的采集传输过程中，以流水线的方式按照视频传输顺序对图像进行逐行像素扫描，然后对每个像素的邻域分别按照逆时针方向和水平方向进行连通性检测和等价标记关系合并，检测出的结果对标记等价数组和标记缓存进行更新，在一帧图像采集传输结束后，得到图像的初步标记结果以及初步标记之间的连通关系，最后，根据标号对连通关系数组从小到大的传递过程进行标号的归并，利用归并后的连通关系数组对图像标记缓存中的标号进行替换，替换后的图像为最终标记结果，并且连通域按照扫描顺序被赋予唯一的连续自然数。  
  238.    
  239.  <img src="https://img-blog.csdn.net/20130620095112281" alt="">  
  240.     
  241. 图 1 标记算法流程  
  242.    
  243. 　　本文快速二值图像连通域标记算法分为三个环节：  
  244. 　　1.图像初步标记：为每个像素赋予临时标记，并且将临时标记的等价关系记录在等价表中  
  245. 　　2.整理等价表：这一环节分为两个步骤：  
  246.      （1）将具有等价关系的临时标记全部等价为其中的最小值；  
  247.      （2）对连通区域以自然数顺序重新编号，得到临时标记与最终标记之间的等价关系。  
  248. 　　3.图像代换：对图像进行逐像素代换，将临时标记代换为最终标记．经过3个环节处理后，算法输出标记后的图像，图像中连通域按照由上到下，由左至右出现的顺序被标以连续的自然数。  
  249. 代码实现：  
  250. #include <list>  
  251. #include <vector>  
  252. #include <algorithm>  
  253. //连通区域属性结构  
  254. typedef struct tagMarkRegion  
  255. {  
  256. std::list<POINT> MarkPointList;//点列表  
  257. RECT rect;  
  258. }MarkRegion;  
  259.    
  260. //定义MarkMap 结构，用来存放等价对  
  261. typedef struct tagEqualMark  
  262. {    int MarkValue1;    //标记值  
  263. int MarkValue2;    //标记值  
  264. } EqualMark;  
  265.    
  266. //定义MarkMapping 结构，用来存放标记映射关系  
  267. typedef struct tagMarkMapping  
  268. {    int nOriginalMark;   //第一次扫描的标记  
  269. int nMappingMark;  //等价整理之后对应标记  
  270. } MarkMapping;  
  271.    
  272. /* 
  273. 功能说明：将所选出的等价关系，attach到list上里 
  274. 参数说明： 
  275.      pEqualMark   等价关系 
  276.      num1         新的等价关系1 
  277.      num2         新的等价关系2 
  278.      nEqualNum    等价数组的个数 
  279.      plEqualMark  存放等价数组的list 
  280. 返回值：无 
  281. */  
  282. template<typename elemType> void AttachEqualMark(EqualMark &pEqualMark,elemType num1, elemType num2, int & pEqualNum, std::list< EqualMark> & plEqualMark)  
  283. {  
  284.      //num1小的情况  
  285.      if ( num1 < num2 )  
  286.      {  
  287.          if ( pEqualMark.MarkValue1 != num1  
  288.               || pEqualMark.MarkValue2 != num2 )  
  289.          {  
  290.               pEqualMark.MarkValue1=num1;  
  291.               pEqualMark.MarkValue2=num2;  
  292.               //插入到数组中  
  293.               pEqualNum++;  
  294.               plEqualMark.push_back(pEqualMark);  
  295.          }  
  296.      }  
  297.      //num2小的情况  
  298.      else    
  299.      {  
  300.          if ( pEqualMark.MarkValue2 != num1  
  301.               || pEqualMark.MarkValue1 != num2 )  
  302.          {  
  303.               pEqualMark.MarkValue1=num2;  
  304.               pEqualMark.MarkValue2=num1;  
  305.               //插入到数组中  
  306.               pEqualNum++;        
  307.               plEqualMark.push_back(pEqualMark);  
  308.          }  
  309.      }  
  310.    
  311. }  
  312.    
  313. /* 
  314.   功能说明：快速二值图像连通域标记 
  315.   参数说明：lpImgBits，表示图象数据区指针 
  316.               nMarkNumbers，表示标记数量 
  317.               iColorType，表示被标记颜色的值（，） 
  318.               nImageWidth，表示图象的宽 
  319.               nImageHeight，表示图象的高 
  320.   返回值：BOOL类型，TRUE，表示成功；FLASE，表示失败 
  321. */  
  322. BOOL MarkImage(BYTE * lpImgBits,int & nMarkNumbers,int iColorType,long nImageWidth,long nImageHeigt,std::list< MarkRegion> &listMarkData)  
  323. {  
  324.      BYTE * lpImgBitsMove=NULL;//lpImgBitsMove，表示图象数据区偏移指针  
  325.      int * lpMark= NULL;//lpMark，表示标记数据指针  
  326.      int * lpMarkMove = NULL;//lpMarkMove，表示标记数据偏移指针  
  327.      //iColorType为目标的图像值  
  328.     long lSize = nImageWidth*nImageHeigt;  
  329.      lpMark= new int[lSize+1];  
  330.      lpMarkMove=lpMark;  
  331.      ::memset(lpMark,0,(lSize+1)*sizeof(int));  
  332.    
  333.      int nMarkValue=1;            
  334.      /* 每次标识的值，nMarkValue会在后边递增， 
  335.      来表示不同的区域，从开始标记。*/  
  336.      int nMaxMarkValue=0;     //记录最大的标识的值  
  337.      int i,j;                 //循环控制变量  
  338.    
  339.      /* 定义存放等价对的链表，其元素是EqualMark类型， 
  340.      定义list是为了节约存储空间。要使用Clist， 
  341.      应该#include <Afxtempl.h>。 */  
  342.      std::list<EqualMark> lEqualMark;  
  343.    
  344.      //初始化图像移动指针  
  345.      lpImgBitsMove = lpImgBits;  
  346.    
  347.      /*进行第一次扫描，将所得的等价对(EqualMark类型)加到lEqualMark链表中。 
  348.      使用nMarkValue来进行每一次新的标记，标记之后将其值加。 
  349.   
  350.      Note1：图像的四周像素并不会有个相邻的像素。这时就要根据上、下、左、 
  351.      右四种不同的情况做不同的寻找等价对的判断。 
  352.      Note2：可以先对等价对进行排序，每次都保证MarkValue1<MarkValue2， 
  353.      这样易于管理等价对。 
  354.      Note3：在实际工作中，连续寻找出的等价对很容易重复，将本次找出的等价对 
  355.      和链表中保存的最后一个等价对相比较，如果不相等的话再存入等价对链表， 
  356.      这样可以大大降低链表中等价对的重复。 
  357.      Note4：第一次扫描之后，nMarkValue-1即为nMaxMarkValue。*/  
  358.    
  359.      /************************************************************************/  
  360.      //下面为补充代码,完成对图像的第一次扫描  
  361.    
  362.      //初始化图像数组和标识数组的指针  
  363.      int nEqualNum=0;  
  364.      EqualMark tempEqualMark;    //用以暂时存放每次找到的等价关系  
  365.      lpMarkMove=lpMark;  
  366.      lpImgBitsMove = lpImgBits;  
  367.    
  368.    
  369.      //标记图像的第一行、第一列的像素(只有这一个像素)  
  370.      if ( *lpImgBitsMove==iColorType )  
  371.      {  
  372.          *lpMarkMove=nMarkValue++;  
  373.      }  
  374.      lpMarkMove++;  
  375.      lpImgBitsMove++;  
  376.    
  377.      //标记图像的第一行，此时不会出现等价的情况  
  378.      for ( i=1; i < nImageWidth; i++)  
  379.      {  
  380.          //需要标记的情况  
  381.          if ( *lpImgBitsMove==iColorType )  
  382.          {     
  383.               //前面没有被标记过，则开始一个新的标记  
  384.               if ( *(lpMarkMove-1)==(!iColorType))  
  385.               {  
  386.                    *lpMarkMove=nMarkValue++;  
  387.               }  
  388.               //前面被标记过，则跟随前一个标记  
  389.               else  
  390.               {  
  391.                    *lpMarkMove=*(lpMarkMove-1);  
  392.               }  
  393.          }  
  394.          lpMarkMove++;  
  395.          lpImgBitsMove++;  
  396.      }  
  397.    
  398.      //除第一行之外的标记，此时会出现等价的关系  
  399.      for ( j=1; j < nImageHeigt; j++ )  
  400.      {  
  401.          lpImgBitsMove=lpImgBits+j*nImageWidth;  
  402.          lpMarkMove=lpMark+j*nImageWidth;  
  403.    
  404.          //对每行的第一个点做处理，总体就是对图像的最左列做处理  
  405.          //只需要检视上，右上两个点  
  406.          if ( *lpImgBitsMove==iColorType )  
  407.          {     
  408.               //<上>位置被标记过  
  409.               if ( *(lpMarkMove-nImageWidth)!=0 )  
  410.               {     
  411.                    //跟随<上>标记  
  412.                    *lpMarkMove=*(lpMarkMove-nImageWidth);  
  413.                    if ( *(lpMarkMove-nImageWidth)!=*(lpMarkMove-nImageWidth+1) && *(lpMarkMove-nImageWidth+1)!=0)  
  414.                    {  
  415.                        //<上><右上>等价标记  
  416.                         AttachEqualMark(tempEqualMark,*(lpMarkMove-nImageWidth),*(lpMarkMove-nImageWidth+1),nEqualNum,lEqualMark);  
  417.                    }  
  418.    
  419.               }  
  420.               //<上>没有标记，此时一定不会存在等价关系  
  421.               else  
  422.               {  
  423.                    if ( *(lpMarkMove-nImageWidth+1)!=0 )  
  424.                    {  
  425.                        *lpMarkMove=*(lpMarkMove-nImageWidth+1);   //跟随<右上>标记  
  426.                    }  
  427.                    //<上>、<右上>都没有标记，则开始新的标记  
  428.                    else  
  429.                    {  
  430.                        *lpMarkMove=nMarkValue++;  
  431.                    }  
  432.               }  
  433.          }  
  434.          lpMarkMove++;  
  435.          lpImgBitsMove++;  
  436.    
  437.          //对每行的中间点做标记处理，此时存在<左>、<左上>、<上>、<右上> 4种情况  
  438.          for ( i=1; i<=nImageWidth-1; i++ )  
  439.          {     
  440.               //需要标记  
  441.               if ( (*lpImgBitsMove)==iColorType )  
  442.               {     
  443.                    //<左>被标记过  
  444.                    if ( *(lpMarkMove-1)!=0 )  
  445.                    {  
  446.                        *lpMarkMove=*(lpMarkMove-1);          //跟随<左>  
  447.    
  448.                        if ( *(lpMarkMove-1)!=*(lpMarkMove-nImageWidth-1) && *(lpMarkMove-nImageWidth-1)!=0 )  
  449.                        {  
  450.                             //标记<左>、<左上>等价  
  451.                             AttachEqualMark(tempEqualMark,*(lpMarkMove-1),*(lpMarkMove-nImageWidth-1),nEqualNum,lEqualMark);  
  452.                        }  
  453.    
  454.                        if ( *(lpMarkMove-1)!=*(lpMarkMove-nImageWidth) && *(lpMarkMove-nImageWidth)!=0)  
  455.                        {  
  456.                             //标记<左>、<上>等价  
  457.                             AttachEqualMark(tempEqualMark,*(lpMarkMove-1),*(lpMarkMove-nImageWidth),nEqualNum,lEqualMark);  
  458.                        }  
  459.    
  460.                        if ( *(lpMarkMove-1)!=*(lpMarkMove-nImageWidth+1) && *(lpMarkMove-nImageWidth+1)!=0)  
  461.                        {  
  462.                             //标记<左>、<右上>等价  
  463.                             AttachEqualMark(tempEqualMark,*(lpMarkMove-1),*(lpMarkMove-nImageWidth+1),nEqualNum,lEqualMark);  
  464.                        }  
  465.                    }  
  466.                    //<左>未被标记过  
  467.                    else  
  468.                    {  
  469.                        //<左上>被标记过  
  470.                        if ( *(lpMarkMove-nImageWidth-1)!=0 )  
  471.                        {  
  472.                             *lpMarkMove=*(lpMarkMove-nImageWidth-1);  
  473.    
  474.                             if ( *(lpMarkMove-nImageWidth-1)!=*(lpMarkMove-nImageWidth) && *(lpMarkMove-nImageWidth)!=0)  
  475.                             {  
  476.                                  //标记<左上>、<上>等价  
  477.                                  AttachEqualMark(tempEqualMark,*(lpMarkMove-nImageWidth-1),*(lpMarkMove-nImageWidth),nEqualNum,lEqualMark);  
  478.                             }  
  479.    
  480.                             if ( *(lpMarkMove-nImageWidth-1)!=*(lpMarkMove-nImageWidth+1) && *(lpMarkMove-nImageWidth+1)!=0)  
  481.                             {  
  482.                                  //标记<左上>、<右上>等价  
  483.                                  AttachEqualMark(tempEqualMark,*(lpMarkMove-nImageWidth-1),*(lpMarkMove-nImageWidth+1),nEqualNum,lEqualMark);  
  484.                             }  
  485.    
  486.    
  487.                        }  
  488.                        //<左>、<左上>未标记过  
  489.                        else  
  490.                        {  
  491.                             if ( *(lpMarkMove-nImageWidth)!=0 )  
  492.                             {  
  493.                                  *lpMarkMove=*(lpMarkMove-nImageWidth);        //跟随<上>标记  
  494.    
  495.                                  if ( *(lpMarkMove-nImageWidth)!=*(lpMarkMove-nImageWidth+1) && *(lpMarkMove-nImageWidth+1)!=0 )  
  496.                                  {  
  497.                                      //标记<上>和<右上>等价  
  498.                                       AttachEqualMark(tempEqualMark,*(lpMarkMove-nImageWidth),*(lpMarkMove-nImageWidth+1),nEqualNum,lEqualMark);  
  499.                                  }  
  500.                             }  
  501.                             //<左>、<左上>、<上>未标记过，此时不存在等价关系  
  502.                             else  
  503.                             {  
  504.                                  if (*(lpMarkMove-nImageWidth+1)!=0)  
  505.                                  {  
  506.                                      *lpMarkMove=*(lpMarkMove-nImageWidth+1);       //跟随<右上>标记  
  507.                                  }  
  508.                                  //<左>、<左上>、<上>、<右上>未标记过，则开始新的标记值  
  509.                                  else  
  510.                                  {  
  511.                                      *lpMarkMove=nMarkValue++;  
  512.                                  }  
  513.    
  514.                             }    //<左>、<左上>、<上>未标记过结束  
  515.                        }   //<左>、<左上>未标记过结束  
  516.                    }  //<左>未被标记过结束  
  517.               }     // else 不需要标记  
  518.    
  519.               lpMarkMove++;  
  520.               lpImgBitsMove++;  
  521.          }       //中间点处理的结束  
  522.    
  523.          //对每行的最后一个点做处理，总体就是对图像的最左列做处理  
  524.          //此时存在<左>、<左上>、<上> 3种情况  
  525.    
  526.          //需要标记  
  527.          if ( (*lpImgBitsMove)==iColorType )  
  528.          {     
  529.               //<左>被标记过  
  530.               if ( *(lpMarkMove-1)!=0 )  
  531.               {  
  532.                    *lpMarkMove=*(lpMarkMove-1);  
  533.    
  534.                    if ( *(lpMarkMove-1)!=*(lpMarkMove-nImageWidth-1) && *(lpMarkMove-nImageWidth-1)!=0)  
  535.                    {  
  536.                        //标记<左>、<左上>等价  
  537.                        AttachEqualMark(tempEqualMark,*(lpMarkMove-1),*(lpMarkMove-nImageWidth-1),nEqualNum,lEqualMark);  
  538.                    }  
  539.    
  540.                    if ( *(lpMarkMove-1)!=*(lpMarkMove-nImageWidth) && *(lpMarkMove-nImageWidth)!=0)  
  541.                    {  
  542.                        //标记<左>、<上>等价  
  543.                        AttachEqualMark(tempEqualMark,*(lpMarkMove-1),*(lpMarkMove-nImageWidth),nEqualNum,lEqualMark);  
  544.                    }  
  545.    
  546.               }  
  547.               //<左>未被标记过  
  548.               else  
  549.               {  
  550.                    if ( *(lpMarkMove-nImageWidth-1)!=0 )  
  551.                    {  
  552.                        *lpMarkMove=*(lpMarkMove-nImageWidth-1);    //跟随<左上>  
  553.    
  554.                        if ( *(lpMarkMove-nImageWidth-1)!=*(lpMarkMove-nImageWidth) && *(lpMarkMove-nImageWidth)!=0)  
  555.                        {  
  556.                             //标记<左上>、<上>等价  
  557.                             AttachEqualMark(tempEqualMark,*(lpMarkMove-nImageWidth-1),*(lpMarkMove-nImageWidth),nEqualNum,lEqualMark);  
  558.                        }  
  559.    
  560.                    }  
  561.                    //<左>、<左上>未标记过  
  562.                    else  
  563.                    {  
  564.                        if ( *(lpMarkMove-nImageWidth)!=0 )  
  565.                        {  
  566.                             *lpMarkMove=*(lpMarkMove-nImageWidth);   //跟随<上>标记  
  567.                        }  
  568.                        //<左>、<左上>、<上>未标记过,则开始新的标记值  
  569.                        else  
  570.                        {  
  571.                             *lpMarkMove=nMarkValue++;  
  572.                        }  
  573.    
  574.                    }  
  575.               }  
  576.          }  //对每行的最后一个点做处理，总体就是对图像的最左列做处理  
  577.    
  578.      }     //"除第一行之外的标记"的结束  
  579.    
  580.      //因为在每次标记完之后，nMarkValue都会自动++  
  581.      //所以要通过（-1）操作来记录所标记的最大的个数  
  582.    
  583.      nMaxMarkValue=nMarkValue-1;  
  584.      /************************************************************************/  
  585.      /* 定义双层链表的外层链表，它的元素是一个指向内层链表的指针。 
  586.      内层链表的型别也是CptrList，其元素是标记值。*/  
  587.      CPtrList exList;  
  588.      CPtrList * pInnerList;  
  589.      POSITION posExElem;     
  590.    
  591.      if ( lEqualMark.size() !=0 )  
  592.      {  
  593.          // pInnerListAdd，每次向exList中添加的新元素  
  594.          CPtrList * pInnerListAdd=new CPtrList;      
  595.          ASSERT ( pInnerListAdd != NULL );  
  596.    
  597.          /* 添加第一个等价对到exList的第一个元素所指向的InnerList中。 */  
  598.          pInnerListAdd->AddTail( (void *)lEqualMark.front().MarkValue1);  
  599.          pInnerListAdd->AddTail( (void *)lEqualMark.front().MarkValue2);  
  600.          exList.AddTail( (void *)pInnerListAdd );  
  601.          lEqualMark.pop_front();  
  602.    
  603.          /* 定义pFindValue1和pFindValue2，存放在所有内层链表中找到特定值 
  604.          的某个内层链表的头指针，也就是外层链表的某个元素值。*/  
  605.          CPtrList * pFindValue1=NULL;  
  606.          CPtrList * pFindValue2=NULL;  
  607.    
  608.          //整理剩余的等价对  
  609.          while ( !lEqualMark.empty() )  
  610.          {     
  611.               posExElem=exList.GetHeadPosition();  
  612.               pFindValue1=NULL;  
  613.               pFindValue2=NULL;  
  614.    
  615.               while ( posExElem )  
  616.               {  
  617.                    pInnerList=(CPtrList *)exList.GetAt(posExElem);  
  618.                    if ( pInnerList->Find( (void *)lEqualMark.front().MarkValue1) )  
  619.                    {     
  620.                        pFindValue1=pInnerList;  
  621.                    }  
  622.                    if( pInnerList->Find( (void *)lEqualMark.front().MarkValue2) )  
  623.                    {     
  624.                        pFindValue2=pInnerList;  
  625.                    }  
  626.                    exList.GetNext(posExElem);  
  627.               }  
  628.    
  629.               //该等价对中两个值都在已经整理过的等价关系中  
  630.               if ( pFindValue1 && pFindValue2 )  
  631.               {     
  632.                    //当两个地址不一样时，对链表进行调整  
  633.                    if ( pFindValue1!=pFindValue2 )  
  634.                    {         
  635.                        pFindValue1->AddTail(pFindValue2);  
  636.                        /* 清除链表元素，通过new得到的CptrList 类型， 
  637.                        必须采用delete进行删除，否则会造成内存泄露。*/  
  638.                        POSITION posDelete = exList.Find((void *)pFindValue2);  
  639.                        pFindValue2->RemoveAll();  
  640.                        delete pFindValue2;  
  641.                        exList.RemoveAt( posDelete );  
  642.                    }  
  643.               }  
  644.               /* 只在已经整理过的等价关系中找到Value1， 
  645.               那么将Vaule2加到Value1所在的链表中。*/  
  646.               else if ( pFindValue1 )  
  647.               {  
  648.                    pFindValue1->AddTail((void *)lEqualMark.front().MarkValue2 );  
  649.               }  
  650.               else if ( pFindValue2)  
  651.               {  
  652.                    pFindValue2->AddTail( (void *)lEqualMark.front().MarkValue1 );  
  653.               }  
  654.               /* 等价对中两个值在整理过的等价关系中都 
  655.               没有找到，则在exList中增加新元素。*/  
  656.               else  
  657.               {  
  658.                    CPtrList * pInnerListAdd=new CPtrList;  
  659.                    pInnerListAdd->AddTail( (void *)lEqualMark.front().MarkValue1 );  
  660.                    pInnerListAdd->AddTail( (void *)lEqualMark.front().MarkValue2 );  
  661.                    exList.AddTail((void *)pInnerListAdd);  
  662.               }              
  663.               //去掉此时等价对的头元素  
  664.               lEqualMark.pop_front();  
  665.          }  // while ( !lEqualMark.IsEmpty() )循环结束  
  666.      }  // if ( lEqualMark.GetCount() !=0 )语句结束  
  667.      else    
  668.      {  
  669.          /* 等价对链表大小为0，说明第一次扫描之后没有产生等价对，标记已经完成。*/  
  670.      int nMarkRegion=0;   //图像中连通区域个数  
  671.   //记录连通区域的个数  
  672.   nMarkRegion = nMarkValue-1;  
  673.   nMarkNumbers = nMarkRegion;  
  674.   if(nMarkRegion==0)  
  675.    return FALSE;  
  676.   //统计连通域属性信息  
  677.   MarkRegion *pRegionData = new MarkRegion[nMarkNumbers+1];  
  678.   for (int MarkNo = 0; MarkNo<nMarkNumbers;MarkNo++)  
  679.   {  
  680.    pRegionData[MarkNo].rect.left   = -1;  
  681.    pRegionData[MarkNo].rect.right  = -1;  
  682.    pRegionData[MarkNo].rect.bottom = -1;  
  683.    pRegionData[MarkNo].rect.top    = -1;  
  684.    pRegionData[MarkNo].MarkPointList.clear();  
  685.   }  
  686.   
  687.   for ( j=0;j<nImageHeigt;j++ )  
  688.   {  
  689.    lpMarkMove=lpMark + j*nImageWidth;   
  690.    for ( i=0;i<nImageWidth;i++ )  
  691.    {  
  692.     if ( *lpMarkMove > 0 )  
  693.     {  
  694.      if (pRegionData[*lpMarkMove-1].rect.left == -1)  
  695.      {  
  696.       pRegionData[*lpMarkMove-1].rect.left   = i;  
  697.       pRegionData[*lpMarkMove-1].rect.right  = i;  
  698.       pRegionData[*lpMarkMove-1].rect.bottom = j;  
  699.       pRegionData[*lpMarkMove-1].rect.top    = j;  
  700.       POINT ptInsert;  
  701.       ptInsert.x = i;  
  702.       ptInsert.y = j;  
  703.       pRegionData[*lpMarkMove-1].MarkPointList.push_back(ptInsert);  
  704.      }  
  705.      else  
  706.      {  
  707.       POINT ptInsert;  
  708.       ptInsert.x = i;  
  709.       ptInsert.y = j;  
  710.       pRegionData[*lpMarkMove-1].MarkPointList.push_back(ptInsert);  
  711.       if (pRegionData[*lpMarkMove-1].rect.left>i)  
  712.       {  
  713.        pRegionData[*lpMarkMove-1].rect.left = i;  
  714.       }  
  715.       if (pRegionData[*lpMarkMove-1].rect.right<i)  
  716.       {  
  717.        pRegionData[*lpMarkMove-1].rect.right = i;  
  718.       }  
  719.       if (pRegionData[*lpMarkMove-1].rect.top<j)  
  720.       {  
  721.        pRegionData[*lpMarkMove-1].rect.top = j;  
  722.       }  
  723.       if (pRegionData[*lpMarkMove-1].rect.bottom>j)  
  724.       {  
  725.        pRegionData[*lpMarkMove-1].rect.bottom = j;  
  726.       }  
  727.      }  
  728.     }  
  729.     lpMarkMove++;  
  730.    }  
  731.   }  
  732.   for(i=0;i<nMarkNumbers;i++)  
  733.   {  
  734.    listMarkData.push_back(pRegionData[i]);  
  735.   }  
  736.   if(pRegionData)  
  737.   {  
  738.    delete []pRegionData;  
  739.    pRegionData = NULL;  
  740.   }  
  741.          return TRUE;  
  742.      }         
  743.    
  744.      /*等价关系整理完成，下面建立第一次扫描的标记值和 
  745.      第二次扫描的标记值之间的映射关系。*/  
  746.    
  747.      int nTotalEqualNum=0; //列入等价关系的标记个数  
  748.      int nMarkRegion=0;   //图像中连通区域个数  
  749.    
  750.      posExElem=exList.GetHeadPosition();  
  751.      while ( posExElem )  
  752.      {     
  753.          pInnerList=(CPtrList *)exList.GetAt(posExElem);  
  754.          nTotalEqualNum += pInnerList->GetCount();  
  755.          exList.GetNext(posExElem);  
  756.      }  
  757.      nMarkRegion=nMaxMarkValue-nTotalEqualNum+exList.GetCount();  
  758.    
  759.      /* 定义第一次扫描和第二次扫描之间的映射向量，要使用vector， 
  760.      应该#include <vector>并且使用std命名空间。*/  
  761.      std::vector<MarkMapping> vMarkMap(nMaxMarkValue);  
  762.    
  763.      //初始化映射向量，令其做自身映射  
  764.      for ( i=0;i<nMaxMarkValue;i++ )  
  765.      {     
  766.          vMarkMap[i].nOriginalMark=i+1;  
  767.          vMarkMap[i].nMappingMark=i+1;  
  768.      }  
  769.    
  770.      POSITION posInnerElem; //InnerList中元素的位置  
  771.      int nMin;              //InnerList中最小值  
  772.      int nIndex=0;  
  773.    
  774.      posExElem=exList.GetHeadPosition();  
  775.      /* while循环实现了如下功能：找到每个等价组中最小的标记值， 
  776.      然后将映射向量中nMappingMark设定为其所在等价组的最小的标记值。*/  
  777.      while ( posExElem )  
  778.      {     
  779.          pInnerList=(CPtrList *)exList.GetAt(posExElem);  
  780.          nMin=(int)pInnerList->GetHead();  
  781.          posInnerElem=pInnerList->GetHeadPosition();  
  782.          pInnerList->GetNext(posInnerElem);  
  783.    
  784.          while ( posInnerElem )  
  785.          {  
  786.               if ( (int)pInnerList->GetAt(posInnerElem)<nMin )  
  787.               {     
  788.                    nMin=(int)pInnerList->GetAt(posInnerElem);  
  789.               }  
  790.               pInnerList->GetNext(posInnerElem);  
  791.          }  
  792.    
  793.          /* 根据每组等价关系中的最小的标记值对Mapping向量做出调整。*/  
  794.          posInnerElem=pInnerList->GetHeadPosition();  
  795.          while ( posInnerElem )  
  796.          {  
  797.               nIndex=(int)pInnerList->GetAt(posInnerElem)-1;  
  798.               vMarkMap[ nIndex ].nMappingMark=nMin;  
  799.               pInnerList->GetNext(posInnerElem);  
  800.          }  
  801.          exList.GetNext(posExElem);  
  802.      }  
  803.    
  804.      /* 将映射向量nMappingMark中不重复的部分找出并对其进行排序。 
  805.      使用find()和sort()这两种泛型算法，应该#include <algorithm>。*/  
  806.      std::vector <int> vSortMark(nMarkRegion); //排序向量  
  807.      nIndex=0;  
  808.    
  809.      for ( i=0; i<nMaxMarkValue; i++ )  
  810.      {  
  811.          if  ( find( vSortMark.begin(),vSortMark.end(), vMarkMap[i].nMappingMark )  
  812.               ==vSortMark.end() )  
  813.          {  
  814.               vSortMark[nIndex++]= vMarkMap[i].nMappingMark;  
  815.          }  
  816.      }  
  817.      sort ( vSortMark.begin(),vSortMark.end() );  
  818.    
  819.      /* 根据排序后的标记在vSortMark向量中的位置，对映射向量做出重新调整。*/  
  820.      std::vector<int>::iterator itFind;  
  821.      std::vector<int>::iterator itBegin;  
  822.      itBegin=vSortMark.begin();  
  823.    
  824.      for (i=0;i<nMaxMarkValue;i++ )  
  825.      {  
  826.          itFind = find ( vSortMark.begin(),vSortMark.end(), vMarkMap[i].nMappingMark );  
  827.          vMarkMap[i].nMappingMark= ( itFind-itBegin + 1);  
  828.      }  
  829.    
  830.      //根据映射向量对标记数组进行调整  
  831.      for ( j=0;j<nImageHeigt;j++ )  
  832.      {  
  833.          lpMarkMove=lpMark + j*nImageWidth;  
  834.          for ( i=0;i<nImageWidth;i++ )  
  835.          {  
  836.               if ( *lpMarkMove != 0 )  
  837.               {  
  838.                    *lpMarkMove = vMarkMap[ *lpMarkMove-1].nMappingMark;  
  839.               }  
  840.               lpMarkMove++;  
  841.          }  
  842.      }  
  843.    
  844.      //删除链表结构中通过new得到的元素  
  845.      posExElem = exList.GetHeadPosition();  
  846.      while( posExElem )  
  847.      {  
  848.          pInnerList = (CPtrList *)exList.GetAt( posExElem );  
  849.          pInnerList->RemoveAll();  
  850.          delete pInnerList;  
  851.          exList.GetNext( posExElem );  
  852.      }  
  853.      exList.RemoveAll();  
  854.    
  855.      //记录连通区域的个数  
  856.      nMarkNumbers = nMarkRegion;  
  857.    
  858.      if(nMarkRegion==0)  
  859.          return FALSE;  
  860.    
  861.      //统计连通域属性信息  
  862.      MarkRegion *pRegionData = new MarkRegion[nMarkNumbers+1];  
  863.      for (int MarkNo = 0; MarkNo<nMarkNumbers;MarkNo++)  
  864.      {  
  865.          pRegionData[MarkNo].rect.left   = -1;  
  866.          pRegionData[MarkNo].rect.right  = -1;  
  867.          pRegionData[MarkNo].rect.bottom = -1;  
  868.          pRegionData[MarkNo].rect.top    = -1;  
  869.          pRegionData[MarkNo].MarkPointList.clear();  
  870.      }  
  871.    
  872.      //long offset = 0;  
  873.      for ( j=0;j<nImageHeigt;j++ )  
  874.      {  
  875.          lpMarkMove=lpMark + j*nImageWidth;    
  876.          for ( i=0;i<nImageWidth;i++ )  
  877.          {  
  878.               //offset = j*nImageWidth+i;  
  879.               //lpMarkMove = lpMark+offset;     
  880.               if ( *lpMarkMove > 0 )  
  881.               {  
  882.                    if (pRegionData[*lpMarkMove-1].rect.left == -1)  
  883.                    {  
  884.                        pRegionData[*lpMarkMove-1].rect.left   = i;  
  885.                        pRegionData[*lpMarkMove-1].rect.right  = i;  
  886.                        pRegionData[*lpMarkMove-1].rect.bottom = j;  
  887.                        pRegionData[*lpMarkMove-1].rect.top    = j;  
  888.                        POINT ptInsert;  
  889.                        ptInsert.x = i;  
  890.                        ptInsert.y = j;  
  891.                        pRegionData[*lpMarkMove-1].MarkPointList.push_back(ptInsert);  
  892.                    }  
  893.                    else  
  894.                    {  
  895.                        POINT ptInsert;  
  896.                        ptInsert.x = i;  
  897.                        ptInsert.y = j;  
  898.                        pRegionData[*lpMarkMove-1].MarkPointList.push_back(ptInsert);  
  899.                        if (pRegionData[*lpMarkMove-1].rect.left>i)  
  900.                        {  
  901.                             pRegionData[*lpMarkMove-1].rect.left = i;  
  902.                        }  
  903.                        if (pRegionData[*lpMarkMove-1].rect.right<i)  
  904.                        {  
  905.                             pRegionData[*lpMarkMove-1].rect.right = i;  
  906.                        }  
  907.                        if (pRegionData[*lpMarkMove-1].rect.top>j)  
  908.                        {  
  909.                             pRegionData[*lpMarkMove-1].rect.top = j;  
  910.                        }  
  911.                        if (pRegionData[*lpMarkMove-1].rect.bottom<j)  
  912.                        {  
  913.                             pRegionData[*lpMarkMove-1].rect.bottom = j;  
  914.                        }  
  915.                    }  
  916.               }  
  917.               lpMarkMove++;  
  918.          }  
  919.      }  
  920.      for(i=0;i<nMarkNumbers;i++)  
  921.      {  
  922.          listMarkData.push_back(pRegionData[i]);  
  923.      }  
  924.     if(pRegionData)  
  925.      {  
  926.          delete []pRegionData;  
  927.          pRegionData = NULL;  
  928.      }  
  929.      return TRUE;  
  930.    
  931. }  

 

 

 


http://comic.sjtu.edu.cn/thucs/GD_jsj_027y/text/chapter2/section5/part01/l1_bq2.htm

2) 种子填充算法
　　种子填充算法又称为边界填充算法。其基本思想是：从多边形区域的一个内点开始，由内向外用给定的颜色画点直到边界为止。如果边界是以一种颜色指定的，则种子填充算法可逐个像素地处理直到遇到边界颜色为止。
种子填充算法常用四连通域和八连通域技术进行填充操作。
　　从区域内任意一点出发，通过上、下、左、右四个方向到达区域内的任意像素。用这种方法填充的区域就称为四连通域；这种填充方法称为四向连通算法。
　　从区域内任意一点出发，通过上、下、左、右、左上、左下、右上和右下八个方向到达区域内的任意像素。用这种方法填充的区域就称为八连通域；这种填充方法称为八向连通算法。
　　一般来说，八向连通算法可以填充四向连通区域，而四向连通算法有时不能填充八向连通区域。例如，八向连通填充算法能够正确填充如图2.4a所示的区域的内部，而四向连通填充算法只能完成如图2.4b的部分填充。

四向连通填充算法：

a） 种子像素压入栈中；
b） 如果栈为空，则转e)；否则转c)；
c） 弹出一个像素，并将该像素置成填充色；并判断该像素相邻的四连通像素是否为边界色或已经置成多边形的填充色，若不是，则将该像素压入栈；
d） 转b）；
e） 结束。
四向连通填充方法可以用递归函数实现如下：

算法2.3 四向连通递归填充算法：
void BoundaryFill4(int x, int y, long FilledColor, long BoundaryColor)
{
　　long CurrentColor;
　　CurrentColor = GetPixelColor(x,y);
　　if (CurrentColor != BoundaryColor && CurrentColor != FilledColor)
　　{
　　　SetColor(FilledColor);
　　　SetPixel (x,y);
　　　BoundaryFill4(x+1, y, FilledColor, BoundaryColor);
　　　BoundaryFill4(x-1, y, FilledColor, BoundaryColor);
　　　BoundaryFill4(x, y+1, FilledColor, BoundaryColor);
　　　BoundaryFill4(x, y-1, FilledColor, BoundaryColor);
　　}
}

　　上述算法的优点是非常简单，缺点是需要大量栈空间来存储相邻的点。一个改进的方法就是：通过沿扫描线填充水平像素段，来处理四连通或八连通相邻点，这样就仅仅只需要将每个水平像素段的起始位置压入栈，而不需要将当前位置周围尚未处理的相邻像素都压入栈，从而可以节省大量的栈空间。

开心罗
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现二值图像连通区域标记
11-23
C语言实现二值图像连通区域标记，VS2005工程，需要OpenCV支持
OpenCV_连通区域分析（Connected Component Analysis-Labeling）
热门推荐
09-01 12万+
OpenCV_连通区域分析（Connected Component Analysis/Labeling） 【摘要】本文主要介绍在CVPR和图像处理领域中较为常用的一种图像区域（Blob）提取的方法——连通性分析法（连通区域标记法）。文中介绍了两种常见的连通性分析的算法：1）Two-pass；2）种子填充，并给出了两个算法的基于OpenCV和C++的实现程序。
c语言实现二值图像的坐标,C语言版二值图像统计连通区域
weixin_33814090的博客
05-16 156
连通区标记是最基本的图像处理算法之一。该算法中，按从左至右、从上至下的顺序，对整幅图像进行扫描，通过比较每个前景像素的邻域进行连通区标记，并创建等效标记列表。最后，合并等效标记列表，并再次扫描图像以更新标记。算法的优点的是通俗易懂，缺点是需要两次扫描图像，效率不高。区域生长法利用区域生长的思想，一次生长过程可以标记一整个连通区，只需对图像进行一次扫描就能标记出所有连通区。算法描述如下：输入待标记图...
二值图像连通域标记算法与代码
ffghggf的博客
11-06 752
二值图像连通域标记算法与代码
二值图像连通域标记之全面分析（代码实践）
视觉小新的博客
03-11 1629
一、前言 二值图像，顾名思义就是图像的亮度值只有两个状态：黑(0)和白(255)。二值图像在图像分析与识别中有着举足轻重的地位，因为其模式简单，对像素在空间上的关系有着极强的表现力。在实际应用中，很多图像的分析最终都转换为二值图像的分析，比如：医学图像分析、前景检测、字符识别，形状识别。二值化+数学形态学能解决很多计算机识别工程中目标提取的问题。 二值图像分析最重要的方法就是连通区域标记，它是...
C语言版二值图像统计连通区域
08-28
主要为大家详细介绍了C语言版二值图像统计连通区域的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
c语言实现二值图像的坐标,实现基于C语言的二值图像连通域标记算法
weixin_42502382的博客
05-16 390
1 #include 2 #include 3 #include 4 #include 5 #include 6 #include 78 #define CONNECTIVITY4 49 #define CONNECTIVITY8 810 #define STACK_INIT_SIZE 25611 #define STACK_INCRE 25612 #define TRUE 113 #define...
如何用c语言寻找连通域,C语言版二值图像统计连通区域
weixin_32085599的博客
05-22 969
连通区标记是最基本的图像处理算法之一。该算法中，按从左至右、从上至下的顺序，对整幅图像进行扫描，通过比较每个前景像素的邻域进行连通区标记，并创建等效标记列表。最后，合并等效标记列表，并再次扫描图像以更新标记。算法的优点的是通俗易懂，缺点是需要两次扫描图像，效率不高。区域生长法利用区域生长的思想，一次生长过程可以标记一整个连通区，只需对图像进行一次扫描就能标记出所有连通区。算法描述如下：输入待标记图...
图像处理：连通区域算法
weixin_43793960的博客
02-14 8547
OpenCV_连通区域分析（Connected Component Analysis/Labeling） 【摘要】 本文主要介绍在CVPR和图像处理领域中较为常用的一种图像区域（Blob）提取的方法——连通性分析法（连通区域标记法）。文中介绍了两种常...
查找二值图像最大连通区域
11-29
查找二值图像最大连通区域，返回连通域的矩形框
二值图像连通区域标记算法代码
01-23
这是非常实用的VC代码，用于二值图像连通区域的标记，请大家参考
二值图像连通区域的标记,二值图像分支点连接数,matlab
09-10
使用MATLAB提取二值图像特征值，并对连通区域进行标记、分析与计算
二值图像连通区域标记opecv源代码
05-09
可实现连通区域标记，用于选取规定面积范围的连通域，我自己都实现了
一种二值图像连通区域标记的新算法
05-12
二值图像 连通区域 标记 算法.O（N）
node-v16.12.0-darwin-x64.tar.xz
最新发布
04-23
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
试用Dev Containers的示例项目-Go
04-23
计算机技术是指评价计算机系统的各种知识和技能的总称。它涵盖了计算机硬件、软件、网络和信息安全等方面。计算机技术的发展使我们能够进行高效的数据处理、信息存储和传输。现代计算机技术包括操作系统、数据库管理、编程语言、算法设计等。同时，人工智能、云计算和大数据等新兴技术也在不断推动计算机技术的进步。计算机技术的应用广泛，涵盖了各个领域，如商业、医疗、教育和娱乐等。随着计算机技术的不断革新，我们可以更加高效地实现预期自动化、标准化
NTsky新闻发布v1.0测试版(提供JavaBean).zip
04-23
### 内容概要： 《NTsky新闻发布v1.0测试版》是一款基于 Java 开发的新闻发布系统的测试版本，旨在为新闻机构和媒体提供一个简单易用的新闻发布平台。该系统具有基本的新闻发布和管理功能，包括新闻分类、新闻编辑、新闻发布等核心功能。此外，该版本还提供了 JavaBean，使开发人员能够方便地将系统集成到自己的项目中，快速实现新闻发布的功能。 ### 适用人群： 本测试版本适用于新闻机构、媒体从业者以及Java开发人员。如果你是一家新闻机构或媒体，希望拥有一个简单易用的新闻发布平台，方便快捷地发布和管理新闻，那么这个测试版本将为你提供一个初步的体验。同时，如果你是一名Java开发人员，希望学习和掌握新闻发布系统的开发技术，并且对新闻行业有一定的了解，那么通过这个测试版本，你可以获取到一些JavaBean，并且可以参考系统的设计和实现，为你的项目开发提供参考和借鉴。无论是从业务需求还是技术学习的角度，该测试版本都将为你提供一定的帮助和支持。
JavaScript介绍.zip
04-23
javascript，JavaScript 最初由 Netscape 公司的 Brendan Eich 在 1995 年开发，用于 Netscape Navigator 浏览器。随着时间的推移，JavaScript 成为了网页开发中不可或缺的一部分，并且其应用范围已经远远超出了浏览器，成为了全栈开发的重要工具。
matlab边缘图像连通区域标记的算法
08-15
下面是使用`bwlabel`函数进行边缘图像连通区域标记的示例代码： ```matlab % 读取二值图像 binaryImage = imread('binary_image.png'); % 执行连通区域标记 labeledImage = bwlabel(binaryImage); % 显示标记后的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值