二值图像连通标记矩阵计算

最新推荐文章于 2024-06-10 12:06:40 发布
最新推荐文章于 2024-06-10 12:06:40 发布
阅读量797 收藏
点赞数
分类专栏： 视觉

原作者：avrmax

#include <stdlib.h>  
#include <stdio.h>  
#include <time.h>  
#include <windows.h>  

HANDLE hOut, hIn; /*标准输出输入句柄*/  
COORD size = {200, 1000}; /*窗口大小*/  
SMALL_RECT rc = {0, 0, 200-1, 50-1};  
CONSOLE_CURSOR_INFO cursor = {1, FALSE}; /*光标信息，用于隐藏光标*/  

typedef struct{  
    unsigned short sc;  
    unsigned short ec;  
    unsigned short r;  
    int label;  
}RunNode_t;  

typedef struct equivnode   
{  
    int LabelA;  
    int LabelB;  
    struct equivnode *next;  
}EquivNode;  

typedef struct equivlist   
{  
    EquivNode *head;  
    int length;  
}EquivList;  

typedef struct MapListNode_tag  
{  
    int idx;  
    struct MapListNode_tag* pNext;  
}MapListNode_t;  

typedef struct MapListList_tag  
{  
    MapListNode_t* pMapNodeList;  
    struct MapListList_tag* pNext;  
}MapListListNode_t;  

typedef struct    
{  
    int mode ;   
    int minarea ;   
    int minpixDiff;  
}SparseInfoExtractCondition_t;  

void DeleteEquivListHeadNode(EquivList *list)   
{  
    EquivNode *killNode;  
    if (list->head != NULL)   
    {  
        killNode = list->head;  
        list->head = killNode->next;  
        free(killNode);  
        list->length--;  
    }  
}  

void DestroyEquivList(EquivList *list)   
{  
    while (list->head != NULL)  
    {  
        EquivNode *killNode = list->head;  
        list->head = killNode->next;  
        free(killNode);  
        list->length--;  
    }  
}  

void UpdateRunNode(int *pTable , RunNode_t* pNode, int NodeNum)  
{  
    int i;  
    for(i = 0 ; i < NodeNum ; i++)  
    {  
        pNode[i].label = pTable[pNode[i].label-1];  
    }  
}  

void BWCreateRunNodeInfoEx(int* BW , int M ,int N ,  
                           SparseInfoExtractCondition_t* pCondtion,  
                           RunNode_t** ppRunNode, int *pRunNodeNum,  
                           int* plabels, EquivList** ppEquivList)  
{  
    int *pr = NULL;  
    int numRuns = 0;  
    RunNode_t* pNode = NULL;  
    int offset ;  
    int i ,j ,k ,p;    
    int currentRow = -1;  
    int nextLabel = 1;  
    int firstRunOnPreviousRow = -1;  
    int lastRunOnPreviousRow = -1;  
    int firstRunOnThisRow = -1;  
    EquivList* pEquivList = (EquivList*)malloc(sizeof(EquivList));  

    int Mode = pCondtion->mode;  
    int MinArea = pCondtion->minarea;  
    int MinpixDiff = pCondtion->minpixDiff;  

    //(1)Computer numRuns  
    for (i = 0; i < N; i++)   //按行遍历  
    {  
        pr = &BW[i*M] ;    //第row行的头指针  

        if (pr[0] != 0)  
            numRuns++;        //本行的第一个元素就是一个Run的头 Run的数目+1  

        for (j = 1; j < M; j++) {  
            if ((pr[j] != 0) && (pr[j-1] == 0))   //01的模式就是Run  
                numRuns++;                        //Run的总数+1  
        }  
    }  
    *pRunNodeNum = numRuns;  

    //(2) 生成 RunNode信息  
    pNode = (RunNode_t*)malloc(numRuns*sizeof(RunNode_t));  
    k = 0;  
    for (i = 0; i < N; i++)   
    {  
        pr = &BW[i*M];  //第row行的头指针  

        j = 0;  
        while (j < M)   
        {       
            //遍历该行  
            while (j < M && pr[j] == 0)  
                j++;                        //找到第一个Run所在的行号  

            if ((j < M) && (pr[j] != 0))   
            {  
                pNode[k].r = i ;       //  
                pNode[k].sc = j ;  
                while (j < M && pr[j] )   //走完这个Run  
                    j++;  
                pNode[k].ec = j-1;  //这个是结尾  
                pNode[k].label = 0;  
                k++;          //处理下一个Run  
            }  
        }  
    }  

    //(3)扫描标记 ,并统计Label 关系的  
    printf("\n\n");  
    printf("(2)打印等价关系对\n");  
    pEquivList->head = NULL;  
    pEquivList->length = 0;  
    offset = 1;  //八邻域为1  ,四邻域为0  
    for (k = 0; k < numRuns; k++)   
    {  
        if (pNode[k].r == currentRow + 1)   
        {     
            //第k个Run与第k-1个Run在相邻的两行上  
            firstRunOnPreviousRow = firstRunOnThisRow;   //firstRunOnPreviousColumn指向第k-1个Run所在的列的第一个（最上面的）Run  
            firstRunOnThisRow = k;  
            lastRunOnPreviousRow = k-1;  
            currentRow = pNode[k].r;  
        }  
        else if (pNode[k].r > (currentRow + 1))   
        {  
            /* 开始新列:前一列没有Run  直接进入下一轮循环*/  
            firstRunOnPreviousRow = -1;  
            lastRunOnPreviousRow = -1;  
            firstRunOnThisRow = k;  
            currentRow = pNode[k].r;  
        }  

        if (firstRunOnPreviousRow >= 0)   
        {  
            p = firstRunOnPreviousRow;  
            while (p <= lastRunOnPreviousRow && pNode[p].sc <= pNode[k].ec + offset)   
            {  
                if ((pNode[k].ec >= pNode[p].sc-offset) &&   
                    (pNode[k].sc <= pNode[p].ec+offset)) //有交叉  
                {  
                    if (pNode[k].label == 0)   
                    {  
                        pNode[k].label = pNode[p].label;  
                    }  
                    else   
                    {  
                        if (pNode[k].label != pNode[p].label)   
                        {  
                            EquivNode *newNode = (EquivNode *)malloc(sizeof(EquivNode));  
                            newNode->LabelA = pNode[k].label;  
                            newNode->LabelB = pNode[p].label;  
                            newNode->next = pEquivList->head;  
                            pEquivList->head = newNode;  
                            pEquivList->length++;  
                            printf("%4d %4d\n" , newNode->LabelA , newNode->LabelB);  
                        }  
                    }  
                }  
                p++;  
            }  
        }  

        if (pNode[k].label == 0)   
        {  
            pNode[k].label = nextLabel;  
            nextLabel++;  
        }  
    }  
    *plabels =nextLabel-1;  
    *ppRunNode = pNode;  
    *ppEquivList = pEquivList;  

    printf("\n\n(3) 打印初始RunNode信息\n");  
    printf("  sc   ec    r   label \n");  
    for(i=0;i<numRuns;i++)  
    {  
        printf("%4d ",pNode[i].sc);  
        printf("%4d ",pNode[i].ec);  
        printf("%4d ",pNode[i].r);  
        printf("%4d ",pNode[i].label);  
        printf("\n");  
    }  
}  

void MapListAddNode(MapListNode_t* pNode , int Idx)  
{  
    MapListNode_t* pNodeTemp = (MapListNode_t*)malloc(sizeof(MapListNode_t));  
    MapListNode_t* pNodeMove = pNode;  
    pNodeTemp->idx = Idx;  
    pNodeTemp->pNext = NULL;  

    while(pNodeMove->pNext)  
        pNodeMove = pNodeMove->pNext;  

    pNodeMove->pNext = pNodeTemp;  
}  

void MapListListAddNode(MapListListNode_t* pListListNode ,MapListNode_t* pListNode)  
{  
    MapListListNode_t* pListListNodeMove = pListListNode;  
    MapListListNode_t* pListListNodeNew = (MapListListNode_t*)malloc(sizeof(MapListListNode_t));  
    while(pListListNodeMove->pNext)  
        pListListNodeMove = pListListNodeMove->pNext;  

    pListListNodeNew->pMapNodeList = pListNode;  
    pListListNodeNew->pNext = NULL;  
    pListListNodeMove->pNext = pListListNodeNew;  
}  

void MapListListDeleteNode(MapListListNode_t* pListListNode ,MapListNode_t* pListNode)  
{  
    MapListListNode_t* pListListNodeMove = pListListNode;  
    MapListListNode_t* pListListNodeKill = NULL;  
    while(pListListNodeMove->pNext)  
    {  
        if(pListListNodeMove->pNext->pMapNodeList == pListNode)  
        {  
            pListListNodeKill = pListListNodeMove->pNext;  
            pListListNodeMove->pNext = pListListNodeMove->pNext->pNext;  
            free(pListListNodeKill);   
            break;  
        }  
        pListListNodeMove = pListListNodeMove->pNext;  
    }  

}  
int MapListMinIdx(MapListNode_t* pNode)  
{  
    int min = 0x7FFFFFFF;  
    while(pNode)  
    {  
        if(pNode->idx < min)  
            min = pNode->idx;  
        pNode = pNode->pNext;  
    }  
    return min;  
}  
MapListNode_t* MapListListFindIdx(MapListListNode_t* pMapListList ,int Idx)  
{  
    MapListNode_t* pMapListNodeHead = NULL;  
    MapListNode_t* pMapNodeListMove = NULL;  
    MapListListNode_t* pMapListListMove = pMapListList;  
    while(pMapListListMove->pNext)  
    {  
        pMapListListMove = pMapListListMove->pNext;  
        pMapListNodeHead = pMapListListMove->pMapNodeList;  
        pMapNodeListMove = pMapListNodeHead;  
        while(pMapNodeListMove)   
        {  
            if(Idx == pMapNodeListMove->idx)  
                return pMapListNodeHead;  

            pMapNodeListMove = pMapNodeListMove->pNext;  
        }  
    }  
    return NULL;  
}  

void MapListMerge(MapListNode_t* pMapListA , MapListNode_t* pMapListB)  
{  
    while(pMapListA->pNext)  
        pMapListA = pMapListA->pNext;  
    pMapListA->pNext = pMapListB;  
}  


void CreateMapTable(EquivList* pList ,int MapTableSize ,int **ppMapTable )  
{  
    int i,j,k;  
    int labela,labelb;  
    MapListNode_t* pMapNodeList = (MapListNode_t*)malloc(sizeof(MapListNode_t));  
    MapListListNode_t* pMapListListNode = NULL;  
    MapListListNode_t* pMapListListforMove = NULL;  
    MapListNode_t* pMapListforMove = NULL ;  
    int *pMapTableInit = NULL;  
    pMapNodeList->idx = pList->head->LabelA;     
    pMapNodeList->pNext = NULL;  
    MapListAddNode(pMapNodeList,pList->head->LabelB);  

    DeleteEquivListHeadNode(pList);  

    pMapListListNode = (MapListListNode_t*)malloc(sizeof(MapListListNode_t));  
    pMapListListNode->pMapNodeList = NULL;  
    pMapListListNode->pNext = NULL;  
    MapListListAddNode(pMapListListNode,pMapNodeList);  

    while(pList->length)  
    {  
        MapListNode_t* pMapListFindA = NULL;  
        MapListNode_t* pMapListFindB = NULL;  
        labela = pList->head->LabelA;  
        labelb = pList->head->LabelB;  
        pMapListFindA = MapListListFindIdx(pMapListListNode,labela);  
        pMapListFindB = MapListListFindIdx(pMapListListNode,labelb);  

        if(pMapListFindA)  
        {  
            if(pMapListFindB)  
            {  
                if (pMapListFindA!=pMapListFindB)  
                {             
                    MapListMerge(pMapListFindA,pMapListFindB);  
                    MapListListDeleteNode(pMapListListNode,pMapListFindB);  
                }  
            }  
            else  
            {  
                MapListAddNode(pMapListFindA,labelb);  
            }  
        }  
        else  
        {  
            if(pMapListFindB)  
            {  
                MapListAddNode(pMapListFindB,labela);  
            }  
            else  
            {  
                pMapNodeList = (MapListNode_t*)malloc(sizeof(MapListNode_t));  
                pMapNodeList->pNext = NULL;  
                pMapNodeList->idx = labela;  
                MapListAddNode(pMapNodeList,labelb);  
                MapListListAddNode(pMapListListNode,pMapNodeList);  
            }  
        }  
        DeleteEquivListHeadNode(pList);  
    }  

    printf("\n\n(4)打印等价链表:\n");  
    pMapListListforMove = pMapListListNode;  
    while (pMapListListforMove->pNext)  
    {  
        pMapListforMove = pMapListListforMove->pNext->pMapNodeList;  
        while(pMapListforMove)  
        {  
            printf("%4d",pMapListforMove->idx);  
            pMapListforMove = pMapListforMove->pNext;  
        }  
        printf("\n");  
        pMapListListforMove = pMapListListforMove->pNext;  
    }  

    pMapTableInit = (int*)malloc(MapTableSize*sizeof(int));  
    printf("\n\n打印初始关系表");  
    for(i = 1 ; i <= MapTableSize ; i++ )  
    {  
        pMapListforMove = MapListListFindIdx(pMapListListNode,i);  
        if(pMapListforMove)  
        {  
            pMapTableInit[i-1] = MapListMinIdx(pMapListforMove);  
            printf("%3d " ,pMapTableInit[i-1]);  
        }  
        else  
        {  
            pMapTableInit[i-1] = i;  
            printf("%3d " ,i);  
        }  
    }  

    printf("\n\n打印对应关系表");  
    *ppMapTable = (int*)malloc(MapTableSize*sizeof(int));  
    (*ppMapTable)[0] = 1;  
    printf("%3d ",(*ppMapTable)[0]);  
    k = 2;  
    for(i = 1 ; i < MapTableSize ; i++ )  
    {  
        j = 0;  

        while(j<i)  
        {  
            if(pMapTableInit[j] == pMapTableInit[i])  
            {  
                (*ppMapTable)[i] = (*ppMapTable)[j];  
                break;  
            }  
            j++;  
        }  

        if(j == i)  
            (*ppMapTable)[i] = k++;  

        printf("%3d ",(*ppMapTable)[i]);  
    }  
}  

void BWCreateRunNodeInfo(int* BW , int M ,int N ,  
                         SparseInfoExtractCondition_t* pCondtion,  
                         RunNode_t** ppRunNode, int *pRunNodeNum)  
{  
    EquivList* pEquivList = NULL;  
    int *pMapTable = NULL;  
    int labels = 0;  
    BWCreateRunNodeInfoEx(BW ,M ,N ,pCondtion,ppRunNode, pRunNodeNum,&labels ,&pEquivList);  

    if(pEquivList->length)  
    {  
        CreateMapTable( pEquivList, labels,&pMapTable);  
        UpdateRunNode(pMapTable,*ppRunNode,*pRunNodeNum);  
    }  
}  

void UpadateBWData(int* BW, int M ,RunNode_t* pNode , int NodeNum)  
{  
    int k = 0 , p = 0;  
    int *pr = NULL;  
    for (k = 0; k < NodeNum; k++)   
    {  
        pr = &BW[pNode[k].r*M + pNode[k].sc];  
        for (p = 0; p < pNode[k].ec - pNode[k].sc + 1; p++)  
            *pr++ = pNode[k].label;  
    }  
}  

#define M 40  
#define N 30  

int main()   
{  
    int i = 0, j = 0;  
    RunNode_t* pRunNode = NULL;  
    int RunNum = 0;  
    SparseInfoExtractCondition_t ExtractCondition;  
    int BW[N][M];  

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);  
    SetConsoleWindowInfo(hOut, TRUE, &rc);  
    SetConsoleScreenBufferSize(hOut, size);  
    SetConsoleCursorInfo(hOut, &cursor);  


    srand( (unsigned)time( NULL ) );  
    printf("(1) 打印实验矩阵\n");  
    for(i = 0; i< N ;i++)  
    {  
        for( j =0 ;j < M;j++ )  
        {  
            if(j == 0)  
                printf("\n");  

            BW[i][j] = (rand()%100)<40;  
            printf("%3d ",BW[i][j]);  
        }  
    }  

    ExtractCondition.minarea = 10;  
    ExtractCondition.minpixDiff = 10;  
    ExtractCondition.mode = 1;  
    BWCreateRunNodeInfo((int*)BW ,M ,N ,&ExtractCondition,&pRunNode, &RunNum);  

    printf("\n\n");  
    printf("(5) 打印最后RunNode信息\n");  
    printf("  sc  ec   r   label\n");  
    for(i=0;i<RunNum;i++)  
    {  
        printf("%4d ",pRunNode[i].sc);  
        printf("%4d ",pRunNode[i].ec);  
        printf("%4d ",pRunNode[i].r);  
        printf("%4d ",pRunNode[i].label);  
        printf("\n");  
    }  

    //(4)根据统计表建立，影射关系表  
    UpadateBWData((int*)BW,M,pRunNode,RunNum);  


    //打印矩阵  
    printf("\n(6) 生成最后的连通标记矩阵");  
    for(i = 0; i< N ;i++)  
    {  
        for( j =0 ;j<M;j++ )  
        {  
            if(j == 0)  
                printf("\n");  
            printf("%3d ",BW[i][j]);  
        }  
    }  
    printf("\n");  
}

———————————————————————–

稍微改一下

#include "lib.h"

using namespace std;

/*
   二值图像连通域标记算法---8领域
  label = BWLABEL(BW) 返回一个矩阵L，维度与BW相同，包含了2-D二值图像中的连通的各部分的标签。
  label中的元素是整数，大于或等于0，像素为0表示背景，像素为1表示第1个物体，像素为2表示第2个物体，依次类推
*/
/*
   对物体的表示过程如下：
   1、从做到有，从上到下逐个像素扫描
   2、若该店的左上、正上、右上以及左前共四个点的像素都不为物体，则标号加1，且此数组值为1
   3、采用（行坐标，列坐标）方式标记物体。若遇到当前像素为物体A，依次判断该像素的右上点，正上点，
      左上点及左前点。右上点的优先级最高，左前点的优先级最低。
   4、若右上点为物体，则当前点跟右上点，并标记与右上点相同的值。
   5、若右上点不为物体，则判断正上点，当正上点为物体，标记为与正上点相同的值。
   6、同理，若右上点、正上点都不为物体，用同样的方法依次判断左上点，若左上点也不为物体，则再判断左前点。
   7、若右上点、正上点、左上点、左前点都不为物体，则当前点的值在原来的标记加1，以此标记来作为另一物体的区别。
*/

typedef struct
{  
    unsigned short sc;  
    unsigned short ec;  
    unsigned short r;  
    int label;  
}RunNode_t;  

typedef struct equivnode   
{  
    int LabelA;  
    int LabelB;  
    struct equivnode *next;  
}EquivNode;  

typedef struct equivlist   
{  
    EquivNode *head;  
    int length;  
}EquivList;  

typedef struct MapListNode_tag  
{  
    int idx;  
    struct MapListNode_tag* pNext;  
}MapListNode_t;  

typedef struct MapListList_tag  
{  
    MapListNode_t* pMapNodeList;  
    struct MapListList_tag* pNext;  
}MapListListNode_t;  

typedef struct    
{  
    int mode ;   
    int minarea ;   
    int minpixDiff;  
}SparseInfoExtractCondition_t; 

//vector< vector<int> > bwlabel(vector< vector<int> > &BW, int N, int M);
void DeleteEquivListHeadNode(EquivList *list);
void DestroyEquivList(EquivList *list);
void UpdateRunNode(int *pTable , RunNode_t* pNode, int NodeNum);
void BWCreateRunNodeInfoEx(vector< vector<int> > &BW , int M ,int N ,  
                           SparseInfoExtractCondition_t* pCondtion,  
                           RunNode_t** ppRunNode, int *pRunNodeNum,  
                           int* plabels, EquivList** ppEquivList);
void MapListAddNode(MapListNode_t* pNode , int Idx);
void MapListListAddNode(MapListListNode_t* pListListNode ,MapListNode_t* pListNode);
void MapListListDeleteNode(MapListListNode_t* pListListNode ,MapListNode_t* pListNode);
int MapListMinIdx(MapListNode_t* pNode);
MapListNode_t* MapListListFindIdx(MapListListNode_t* pMapListList ,int Idx);
void MapListMerge(MapListNode_t* pMapListA , MapListNode_t* pMapListB);
void CreateMapTable(EquivList* pList ,int MapTableSize ,int **ppMapTable );
void BWCreateRunNodeInfo(vector< vector<int> > &BW , int M ,int N ,  
                         SparseInfoExtractCondition_t* pCondtion,  
                         RunNode_t** ppRunNode, int *pRunNodeNum);
void UpadateBWData(int* BW, int M ,RunNode_t* pNode , int NodeNum);

void DeleteEquivListHeadNode(EquivList *list)   
{  
    EquivNode *killNode;  
    if (list->head != NULL)   
    {  
        killNode = list->head;  
        list->head = killNode->next;  
        free(killNode);  
        list->length--;  
    }  
}  

void DestroyEquivList(EquivList *list)   
{  
    while (list->head != NULL)  
    {  
        EquivNode *killNode = list->head;  
        list->head = killNode->next;  
        free(killNode);  
        list->length--;  
    }  
}  

void UpdateRunNode(int *pTable , RunNode_t* pNode, int NodeNum)  
{  
    int i;  
    for(i = 0 ; i < NodeNum ; i++)  
    {  
        pNode[i].label = pTable[pNode[i].label-1];  
    }  
}  

void BWCreateRunNodeInfoEx(vector< vector<int> > &BW , int M ,int N ,  
                           SparseInfoExtractCondition_t* pCondtion,  
                           RunNode_t** ppRunNode, int *pRunNodeNum,  
                           int* plabels, EquivList** ppEquivList)  
{  
    int *pr = NULL;  
    int numRuns = 0;  
    RunNode_t* pNode = NULL;  
    int offset ;  
    int i ,j ,k ,p;    
    int currentRow = -1;  
    int nextLabel = 1;  
    int firstRunOnPreviousRow = -1;  
    int lastRunOnPreviousRow = -1;  
    int firstRunOnThisRow = -1;  
    EquivList* pEquivList = (EquivList*)malloc(sizeof(EquivList));  

    int Mode = pCondtion->mode;  
    int MinArea = pCondtion->minarea;  
    int MinpixDiff = pCondtion->minpixDiff;  

    //(1)Computer numRuns  
    for (i = 0; i < N; i++)   //按行遍历  
    {  
        if(BW[i][0] != 0)  //本行的第一个元素就是一个Run的头 Run的数目+1  
            numRuns++;

        for(j=1; j<M; j++)
        {
            if((BW[i][j] != 0) && (BW[i][j-1] == 0)) // 01的模式就是Run 
                numRuns++;                                   // Run的总数+1  
        }


        //pr = &BW[i*M] ;    //第row行的头指针  

        //if (pr[0] != 0)  
        //    numRuns++;        //本行的第一个元素就是一个Run的头 Run的数目+1  

        //for (j = 1; j < M; j++) {  
        //    if ((pr[j] != 0) && (pr[j-1] == 0))   //01的模式就是Run  
        //        numRuns++;                        //Run的总数+1  
        //}  
    }  
    *pRunNodeNum = numRuns;  

    //(2) 生成 RunNode信息  
    pNode = (RunNode_t*)malloc(numRuns * sizeof(RunNode_t));  
    k = 0;  
    for (i = 0; i < N; i++)   
    {  
        j = 0;
        while(j < M)
        {
            // 遍历该行
            while(j < M && BW[i][j] == 0)
                j++;

            if ((j < M) && (BW[i][j] != 0))   
            {  
                pNode[k].r = i ;       //  
                pNode[k].sc = j ;  
                while (j < M && BW[i][j] )   //走完这个Run  
                    j++;  
                pNode[k].ec = j-1;  //这个是结尾  
                pNode[k].label = 0;  
                k++;          //处理下一个Run  
            } 
        }
        //pr = &BW[i*M];  //第row行的头指针  

        //j = 0;  
        //while (j < M)   
        //{       
        //    //遍历该行  
        //    while (j < M && pr[j] == 0)  
        //        j++;                        //找到第一个Run所在的行号  

        //    if ((j < M) && (pr[j] != 0))   
        //    {  
        //        pNode[k].r = i ;       //  
        //        pNode[k].sc = j ;  
        //        while (j < M && pr[j] )   //走完这个Run  
        //            j++;  
        //        pNode[k].ec = j-1;  //这个是结尾  
        //        pNode[k].label = 0;  
        //        k++;          //处理下一个Run  
        //    }  
        //}  
    }  

    //(3)扫描标记 ,并统计Label 关系的  
    pEquivList->head = NULL;  
    pEquivList->length = 0;  
    offset = 1;  //八邻域为1  ,四邻域为0  
    for (k = 0; k < numRuns; k++)   
    {  
        if (pNode[k].r == currentRow + 1)   
        {     
            //第k个Run与第k-1个Run在相邻的两行上  
            firstRunOnPreviousRow = firstRunOnThisRow;   //firstRunOnPreviousColumn指向第k-1个Run所在的列的第一个（最上面的）Run  
            firstRunOnThisRow = k;  
            lastRunOnPreviousRow = k-1;  
            currentRow = pNode[k].r;  
        }  
        else if (pNode[k].r > (currentRow + 1))   
        {  
            /* 开始新列:前一列没有Run  直接进入下一轮循环*/  
            firstRunOnPreviousRow = -1;  
            lastRunOnPreviousRow = -1;  
            firstRunOnThisRow = k;  
            currentRow = pNode[k].r;  
        }  

        if (firstRunOnPreviousRow >= 0)   
        {  
            p = firstRunOnPreviousRow;  
            while (p <= lastRunOnPreviousRow && pNode[p].sc <= pNode[k].ec + offset)   
            {  
                if ((pNode[k].ec >= pNode[p].sc-offset) &&   
                    (pNode[k].sc <= pNode[p].ec+offset)) //有交叉  
                {  
                    if (pNode[k].label == 0)   
                    {  
                        pNode[k].label = pNode[p].label;  
                    }  
                    else   
                    {  
                        if (pNode[k].label != pNode[p].label)   
                        {  
                            EquivNode *newNode = (EquivNode *)malloc(sizeof(EquivNode));  
                            newNode->LabelA = pNode[k].label;  
                            newNode->LabelB = pNode[p].label;  
                            newNode->next = pEquivList->head;  
                            pEquivList->head = newNode;  
                            pEquivList->length++;  
                        }  
                    }  
                }  
                p++;  
            }  
        }  

        if (pNode[k].label == 0)   
        {  
            pNode[k].label = nextLabel;  
            nextLabel++;  
        }  
    }  
    *plabels =nextLabel-1;  
    *ppRunNode = pNode;  
    *ppEquivList = pEquivList;  
}  

void MapListAddNode(MapListNode_t* pNode , int Idx)  
{  
    MapListNode_t* pNodeTemp = (MapListNode_t*)malloc(sizeof(MapListNode_t));  
    MapListNode_t* pNodeMove = pNode;  
    pNodeTemp->idx = Idx;  
    pNodeTemp->pNext = NULL;  

    while(pNodeMove->pNext)  
        pNodeMove = pNodeMove->pNext;  

    pNodeMove->pNext = pNodeTemp;  
}  

void MapListListAddNode(MapListListNode_t* pListListNode ,MapListNode_t* pListNode)  
{  
    MapListListNode_t* pListListNodeMove = pListListNode;  
    MapListListNode_t* pListListNodeNew = (MapListListNode_t*)malloc(sizeof(MapListListNode_t));  
    while(pListListNodeMove->pNext)  
        pListListNodeMove = pListListNodeMove->pNext;  

    pListListNodeNew->pMapNodeList = pListNode;  
    pListListNodeNew->pNext = NULL;  
    pListListNodeMove->pNext = pListListNodeNew;  
}  

void MapListListDeleteNode(MapListListNode_t* pListListNode ,MapListNode_t* pListNode)  
{  
    MapListListNode_t* pListListNodeMove = pListListNode;  
    MapListListNode_t* pListListNodeKill = NULL;  
    while(pListListNodeMove->pNext)  
    {  
        if(pListListNodeMove->pNext->pMapNodeList == pListNode)  
        {  
            pListListNodeKill = pListListNodeMove->pNext;  
            pListListNodeMove->pNext = pListListNodeMove->pNext->pNext;  
            free(pListListNodeKill);   
            break;  
        }  
        pListListNodeMove = pListListNodeMove->pNext;  
    }  

}  
int MapListMinIdx(MapListNode_t* pNode)  
{  
    int min = 0x7FFFFFFF;  
    while(pNode)  
    {  
        if(pNode->idx < min)  
            min = pNode->idx;  
        pNode = pNode->pNext;  
    }  
    return min;  
}  
MapListNode_t* MapListListFindIdx(MapListListNode_t* pMapListList ,int Idx)  
{  
    MapListNode_t* pMapListNodeHead = NULL;  
    MapListNode_t* pMapNodeListMove = NULL;  
    MapListListNode_t* pMapListListMove = pMapListList;  
    while(pMapListListMove->pNext)  
    {  
        pMapListListMove = pMapListListMove->pNext;  
        pMapListNodeHead = pMapListListMove->pMapNodeList;  
        pMapNodeListMove = pMapListNodeHead;  
        while(pMapNodeListMove)   
        {  
            if(Idx == pMapNodeListMove->idx)  
                return pMapListNodeHead;  

            pMapNodeListMove = pMapNodeListMove->pNext;  
        }  
    }  
    return NULL;  
}  

void MapListMerge(MapListNode_t* pMapListA , MapListNode_t* pMapListB)  
{  
    while(pMapListA->pNext)  
        pMapListA = pMapListA->pNext;  
    pMapListA->pNext = pMapListB;  
}  


void CreateMapTable(EquivList* pList ,int MapTableSize ,int **ppMapTable )  
{  
    int i,j,k;  
    int labela,labelb;  
    MapListNode_t* pMapNodeList = (MapListNode_t*)malloc(sizeof(MapListNode_t));  
    MapListListNode_t* pMapListListNode = NULL;  
    MapListListNode_t* pMapListListforMove = NULL;  
    MapListNode_t* pMapListforMove = NULL ;  
    int *pMapTableInit = NULL;  
    pMapNodeList->idx = pList->head->LabelA;     
    pMapNodeList->pNext = NULL;  
    MapListAddNode(pMapNodeList,pList->head->LabelB);  

    DeleteEquivListHeadNode(pList);  

    pMapListListNode = (MapListListNode_t*)malloc(sizeof(MapListListNode_t));  
    pMapListListNode->pMapNodeList = NULL;  
    pMapListListNode->pNext = NULL;  
    MapListListAddNode(pMapListListNode,pMapNodeList);  

    while(pList->length)  
    {  
        MapListNode_t* pMapListFindA = NULL;  
        MapListNode_t* pMapListFindB = NULL;  
        labela = pList->head->LabelA;  
        labelb = pList->head->LabelB;  
        pMapListFindA = MapListListFindIdx(pMapListListNode,labela);  
        pMapListFindB = MapListListFindIdx(pMapListListNode,labelb);  

        if(pMapListFindA)  
        {  
            if(pMapListFindB)  
            {  
                if (pMapListFindA!=pMapListFindB)  
                {             
                    MapListMerge(pMapListFindA,pMapListFindB);  
                    MapListListDeleteNode(pMapListListNode,pMapListFindB);  
                }  
            }  
            else  
            {  
                MapListAddNode(pMapListFindA,labelb);  
            }  
        }  
        else  
        {  
            if(pMapListFindB)  
            {  
                MapListAddNode(pMapListFindB,labela);  
            }  
            else  
            {  
                pMapNodeList = (MapListNode_t*)malloc(sizeof(MapListNode_t));  
                pMapNodeList->pNext = NULL;  
                pMapNodeList->idx = labela;  
                MapListAddNode(pMapNodeList,labelb);  
                MapListListAddNode(pMapListListNode,pMapNodeList);  
            }  
        }  
        DeleteEquivListHeadNode(pList);  
    }  

    pMapListListforMove = pMapListListNode;  
    while (pMapListListforMove->pNext)  
    {  
        pMapListforMove = pMapListListforMove->pNext->pMapNodeList;  
        while(pMapListforMove)  
        {   
            pMapListforMove = pMapListforMove->pNext;  
        }  
        pMapListListforMove = pMapListListforMove->pNext;  
    }  

    pMapTableInit = (int*)malloc(MapTableSize*sizeof(int)); 
    for(i = 1 ; i <= MapTableSize ; i++ )  
    {  
        pMapListforMove = MapListListFindIdx(pMapListListNode,i);  
        if(pMapListforMove)  
        {  
            pMapTableInit[i-1] = MapListMinIdx(pMapListforMove); 
        }  
        else  
        {  
            pMapTableInit[i-1] = i; 
        }  
    }  

    *ppMapTable = (int*)malloc(MapTableSize*sizeof(int));  
    (*ppMapTable)[0] = 1;   
    k = 2;  
    for(i = 1 ; i < MapTableSize ; i++ )  
    {  
        j = 0;  

        while(j<i)  
        {  
            if(pMapTableInit[j] == pMapTableInit[i])  
            {  
                (*ppMapTable)[i] = (*ppMapTable)[j];  
                break;  
            }  
            j++;  
        }  

        if(j == i)  
            (*ppMapTable)[i] = k++;    
    }  
}  

void BWCreateRunNodeInfo(vector< vector<int> > &BW , int M ,int N ,  
                         SparseInfoExtractCondition_t* pCondtion,  
                         RunNode_t** ppRunNode, int *pRunNodeNum)  
{  
    EquivList* pEquivList = NULL;  
    int *pMapTable = NULL;  
    int labels = 0;  
    BWCreateRunNodeInfoEx(BW ,M ,N ,pCondtion,ppRunNode, pRunNodeNum,&labels ,&pEquivList);  

    if(pEquivList->length)  
    {  
        CreateMapTable( pEquivList, labels,&pMapTable);  
        UpdateRunNode(pMapTable,*ppRunNode,*pRunNodeNum);  
    }  
}  

void UpadateBWData(vector< vector<int> > &BW, int M ,RunNode_t* pNode , int NodeNum)  
{  
    int k = 0 , p = 0;  
    for (k = 0; k < NodeNum; k++)   
    {  
        for (p = 0; p < pNode[k].ec - pNode[k].sc + 1; p++)  
            BW[ pNode[k].r][ pNode[k].sc + p] = pNode[k].label;  
    }
}   

vector< vector<int> > bwlabel(vector< vector<int> > &BW, int N, int M)
{  
    int i = 0, j = 0;  
    RunNode_t* pRunNode = NULL;  
    int RunNum = 0;  
    SparseInfoExtractCondition_t ExtractCondition;  

    ExtractCondition.minarea = 10;  
    ExtractCondition.minpixDiff = 10;  
    ExtractCondition.mode = 1;  
    BWCreateRunNodeInfo(BW ,M ,N ,&ExtractCondition, &pRunNode, &RunNum);  

    //(4)根据统计表建立，映射关系表  
    UpadateBWData(BW, M, pRunNode, RunNum);  

    return BW;
}  


void testBwlabel()
{
    int BW1[][4] = 
    {
        {1, 1, 0, 0},
        {1, 0, 0, 0},
        {1, 0, 0, 1},
        {1, 0, 0, 0},
        {1, 1, 0, 0},
    };

    vector< vector<int> > BW(5, vector<int>(4));

    for(int i=0; i<5; i++)
        for(int j=0; j<4; j++)
            BW[i][j] = BW1[i][j];

    vector< vector<int> > label = bwlabel(BW, 5, 4);
    for(int i=0; i<5; i++)
    {
        for(int j=0; j<4; j++)
            printf("%d ", label[i][j]);
        printf("\n");
    }
}

这里写图片描述

谛听-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
社会网络分析法（Social Network Analysis）中矩阵二值化阈值的确定
weixin_43978805的博客
03-27 9949
这里写自定义目录标题矩阵二值化1.基础知识2.多值矩阵转换为二值矩阵 矩阵二值化 由于毕设用到社会网络分析法所以研究了一下，其中遇到了“阈值”确定这个痛点，网上资源也没看到直接相关，所以看了一下刘军老师翻译的约翰·斯科特《社会网络分析法》以及文献悟了一下，以下为个人见解，仅供参考，欢迎交流。 1.基础知识 1.1 社会网络分析法是用来分析行动者间关系的方法，评价的是关系数据，而不是属性数据。属性数据是可以独立存在于行动者上的（如年龄、性别、学历等），能作为单变量进行分析；关系数据则是关于接触、联络、关联、群
二值图像连通域标记算法与代码
ffghggf的博客
11-06 767
二值图像连通域标记算法与代码
离散数学--连通性和矩阵
最新发布
binhyun的博客
06-10 1144
0.关系的运算和性质 1.通路和回路 2.连通关系 3.割点（边）和点（边）割集 4.强（弱）连通&单向连通
2值矩阵，将 -1，1矩阵变为0,1矩阵，或者将0,1矩阵变为其他2值矩阵
博客 小站
03-14 5796
当遇到矩阵为0-1类型，或者是-1，1类型的时候，可以选择利用numpy中的where 进行修改矩阵内部值 若矩阵为： import numpy as np #生成一个3*3的矩阵数字1-9的矩阵 a=np.arange(9).reshape(3,3) print(a) #将a 中，小于1的数变为-1，其余的，变为1 b=np.where(a&lt;1,-1,1) print(b) 结果为 ...
MATLAB编程（2）——图像划分图像块，得到标记矩阵。
热门推荐
Daniel_Shi的博客
12-22 2万+
在进行图像处理时，有时需要将图像划分成若干个图像块。 下面的程序实现的功能： 输入图像的大小（height, width）和图像块的大小（windowSize）。 返回图像块划分后的索引图（或者称为标记图，大小与源图像相同），该索引图中相同图像块的像素点共用一个标记值。 注：这里划分的图像块之间没有像素重叠。 function idxImg = generateIdxImg( height...
二值图像分析笔记（1）—— 图像二值化
一角残叶的博客
07-22 2465
1 二值图像 像素矩阵只包含0和1； 0：黑色 1：白色 1.1 RGB彩色图像到二值图像的转换 彩色图像到灰度图像的转换 灰度图像到二值图像 1.2 常见的图像二值化方法 基于均值-统计学原理 迭代法 Otus 法（最好用的） 直方图法 1.3 基于均值-统计学原理 计算灰度图像的像素均值 m,以 m 作为阈值把图像分成二值图像，对任意一个像素点的灰度值x x > m ? x...
二值图像连通区域标记matlab,二值图像快速连通区域计算方法与流程
weixin_39609354的博客
03-19 571
本发明涉及图像处理技术领域，具体涉及一种二值图像快速连通区域计算方法。背景技术：连通分量标记(或者称连通分量分析，连通区域标记)是图论应用中的一种算法，给二值图像中的每个连通区域标上一个特定的标号。该算法可用来对图像的目标进行定位和计数。连通分量标记通常在计算机视觉领域中对二值图像的连通区域进行检测，也可以处理彩色图像和更高维的数据。当将其集成到图像识别系统或者是人机交互系统是，该算法也起到重要作...
C语言版二值图像统计连通区域
08-28
C语言版二值图像统计连通区域 一、引言 在图像处理领域中，二值图像统计连通区域是一种常用的图像处理算法。该算法的主要目的是将二值图像中的连通区域进行标记和统计，以便于后续的图像处理和分析。本文将详细...
二值图像连通区域的标记,二值图像分支点连接数,matlab源码.zip
10-15
一、二值图像连通区域的标记 1. 连通组件：在二值图像中，如果两个白像素通过一串相邻的白像素相连，则它们属于同一个连通区域。连通组件分析是寻找并标记这些区域的过程，用于识别图像中的独立对象。 2. 标记...
python 连通区域_二值图像连通区域标记
weixin_39849800的博客
12-05 2152
原像素矩阵M为：根据原像素矩阵M大小，初始化标记矩阵labelM：算法流程1. 首先要确定是标记8邻域连通还是4邻域连通，如果是8邻域连通，就用模板1，如果是4邻域连通，就用模板2。中间像素记为目标像素，模版其余像素记为包围像素。 (1) (2)2. 若原像素矩阵M中，包围像素均为0，则labelM中目标像素标记号+1；如果不全为0，则l...
基于互信息的EEG脑网络情感识别（五）——矩阵二值化
ZhangJiawen的博客
09-30 3861
上一篇文章介绍了互信息矩阵的建立 这篇文章主要讲一下矩阵的二值化 矩阵二值化 对于一个MI矩阵来说，二值化就是选择一个合适的阈值，如果MI值大于阈值，则记为1，如果MI值小于阈值，则记为0 。按照此方法，依次处理矩阵中的每个值，就能得到二值矩阵。 在解决该问题时遇到的难点和问题 观察得到的MI矩阵可以发现，不同被试者不同次实验中，有些实验数据差别较大，所以重点就在于阈值的选择。 刚开始是这样...
二值图像数字矩阵的距离变换（python+opencv)
一只在cv道路上爬行的小乌龟~
05-23 1351
代码链接：数字图像处理距离变换实现（python+opencv) 实验要求： 1，自定义64乘64二值图，随机生成图案（像素随机置成0，1，其中1像素的数量为100个） 2，按照某种距离度量，D4或D8（这里计算的是D4，即城市街区距离） 3，根据二值图，计算64*64的距离矩阵，如图 数字图像处理中三种常见的距离 距离变换原理： 在实际处理中我们要将输入图像中1全部转为0，输入矩阵中的0转为一个比较大的值，如下图： 然后利用两个掩膜进行扫描，参考数字图像的距离变换算法 最终得到的更新后的数组即为距
图结构（二）- 邻接矩阵无向图
AnndyR的专栏
01-22 975
一、邻接矩阵无向图的介绍 邻接矩阵无向图是指通过邻接矩阵表示的无向图。 上面的图G1包含了"A,B,C,D,E,F,G"共7个顶点，而且包含了"(A,C),(A,D),(A,F),(B,C),(C,D),(E,G),(F,G)"共7条边。由于这是无向图，所以边(A,C)和边(C,A)是同一条边；这里列举边时，是按照字母先后顺序列举的。 上图右边的矩阵是G1在内存中的邻接矩阵示意图。A[i
matlab数字图像处理——图像的读写，灰度、二值图像
fffmvp的博客
09-26 5338
利用imread读入trees_gray.jpg，利用size函数得到图像数据矩阵维度，利用imresize将图像缩小原来的一半，显示缩小后的图像，将此缩小后图像存储成为trees_small.jpg文件。利用imread读入trees_gray.jpg，利用im2bw将灰度图像转换二值图像（阈值自行设定），显示二值图像，将此二值图像存储成为trees_bw.jpg文件。对比二值图像和灰度图像的数据矩阵差别：二值图像数据矩阵元素只由0和1构成。（5）在保证将图像的长宽比不变的情况下，将图像缩小。
matlab中二值图像、灰度图像、彩色图像、索引图像都是几维矩阵，区别是什么？
zhb123GGGGGG的专栏
04-30 1万+
文章出处：http://zhidao.baidu.com/question/530453986.html?qbl=relate_question_3&word=matlab%D6%D0%C8%E7%BA%CE%C5%D0%B6%CF%D2%BB%B8%F6%CD%BC%CF%F1%CA%C7%BB%D2%B6%C8%CD%BC%CF%F1%B2%CA%C9%AB%CD%BC%CF%F1&optim
python---图片转二值矩阵
qwer492915298的博客
03-19 1万+
一，如果想获取图片的数据，我们就需要获取 读入图片数据----》转为灰色图片（如果不转的话，转二维时就会出现数据比较大的元素，因为颜色多变）---》 转二维数组-----》转二值矩阵（0或1） im.shape--返回行与列，例如（10,3），10行3列，shape[0]=10 , shape[1]=3 ''' Created on 2019年3月19日 转图片的灰度 数据灰度值都...
【数字图像处理】第8章 二值图像分析
小羊咩咩的博客
05-21 6062
8 二值图像分析 目录（一）二值图像分析基本概念（二）二值图像分析方法1）贴标签2）腐蚀3）膨胀4）开运算与闭运算 问题的提出 经过图像分割之后，获得了目标物与非目标物两种不同的对象。但是提取出的目标物存在以下的问题： 1）提取的目标中存在伪目标物； 2）多个目标物中，存在粘连或者是断裂； 3）多个目标物存在形态的不同。 （一）二值图像分析基本概念 二值图像分析的目的 二值图像的分析首先是区分所提取出的不同的目标物，之后，对不同的目标物特征差异进行描述与计算，最后获得所需要的分析结果。 二值图像分析的基.
matlab获得二值图像平均面积
10-08
要计算MATLAB中二值图像的平均面积，可以按照以下步骤进行： 1. 首先，加载二值图像。可以使用imread函数加载图像文件，或者通过其他方法创建二值图像。 2. 然后，使用bwlabel函数对二值图像进行标记，将连通的区域标记为不同的整数。这将生成一个标记矩阵。 3. 接下来，使用regionprops函数计算每个区域的属性，包括面积。该函数将返回一个结构体数组，其中每个元素对应一个区域。 4. 使用for循环遍历每个结构体元素，并累加面积。同时，记录区域的个数。 5. 最后，将累加的面积除以区域的个数，得到平均面积。 下面是一个示例代码： ```matlab binaryImage = imread('binary_image.jpg'); % 替换为二值图像的文件路径 % 标记连通区域 labelMatrix = bwlabel(binaryImage); % 计算每个区域的属性 regionProps = regionprops(labelMatrix, 'Area'); % 累加面积并计算平均面积 totalArea = 0; regionCount = numel(regionProps); for i = 1 : regionCount totalArea = totalArea + regionProps(i).Area; end averageArea = totalArea / regionCount; disp(['二值图像的平均面积为：', num2str(averageArea)]); ``` 请注意，在上述示例代码中，要替换“binary_image.jpg”为实际的二值图像文件路径。此外，还可以根据需要添加错误处理机制和输出形式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值