1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#include "stdafx.h"
#include "BLOB_Tool.h"
 
CBlobTool::CBlobTool()
{
    
}
 
 
CBlobTool::~CBlobTool()
{
 
}
 
bool CBlobTool::BlobAnalysis(BYTE *pImageData, int nWidth, int nHeight, int nStep, ListEdgeBlobData &blobList, int nMergeRange)
{
    if (pImageData==NULL) return false;
 
    int nIndex;
    int i, j, y, x;
    ListEdgeBlobData pixelList;
 
    for (i=0; i<nHeight; i++)
    {
        for (j=0; j<nWidth; j++)
        {
            nIndex = (i*nStep)+j;
            if (pImageData[nIndex] == 255)
            {
                // push pixel
                CEdgeBlobData *pPos = new CEdgeBlobData(j, i);
                pixelList.push_back(pPos);        
                pImageData[nIndex] = 0;                
 
                int nPixelCount = 0;
                int nTotalX = 0;
                int nTotalY = 0;
                int    nMaxX, nMaxY;
                int    nMinX, nMinY;
 
                nMinX = nMinY = INT_MAX;
                nMaxX = nMaxY = INT_MIN;
 
                ListEdgeBlobDataIt it;
                while (pixelList.size()!=0)
                {
                    // pop pixel
                    it = pixelList.begin();
                    CEdgeBlobData *pCurPos = *it;
 
                    x = (int)pCurPos->fCenterX;
                    y = (int)pCurPos->fCenterY;
 
                    int nTmpIndex;
                    for (int sy=(-nMergeRange); sy<(nMergeRange+1); sy++)
                    {
                        for (int sx=(-nMergeRange); sx<(nMergeRange+1); sx++)
                        {
                            if (((sx+x) > nWidth-1) || ((sx+x) < 0)) continue;        
                            if (((sy+y) > nHeight-1) || ((sy+y) < 0)) continue;        
                            if ((sx==0 && sy==0) || sx==sy || sx==(-sy)) continue;    
 
                            nTmpIndex = ((y+sy)*nStep)+(x+sx);
 
                            if (pImageData[nTmpIndex] == 255)
                            {
                                // push pixel
                                CEdgeBlobData *pNode1 = new CEdgeBlobData(x+sx, y+sy);
                                pixelList.push_back(pNode1);    
                                pImageData[nTmpIndex] = 0;
                            } // end if    
                        } // end for sx
                    } // end for sy
 
                    // blob info
                    nMinX = (nMinX > x) ? x : nMinX;
                    nMinY = (nMinY > y) ? y : nMinY;
                    nMaxX = (nMaxX < x) ? x : nMaxX;
                    nMaxY = (nMaxY < y) ? y : nMaxY;
                    nTotalX        += x;
                    nTotalY        += y;
                    nPixelCount++;
 
                    // delete pixel
                    delete pCurPos;
                    pixelList.erase(it);
 
                } // end while
                pixelList.clear();
 
                // push blob
                CEdgeBlobData *pBlob = new CEdgeBlobData(nMinX, nMinY, nMaxX, nMaxY);
                pBlob->fMassCenterX = float(nTotalX) / float(nPixelCount);
                pBlob->fMassCenterY = float(nTotalY) / float(nPixelCount);
                pBlob->nPixelCount = nPixelCount;
                blobList.push_back(pBlob);
 
            }
        }
    }
 
    return true;
}