一心专注 + 日积月累 = 滴水穿石

qt图像算法—图像的轮廓跟踪之c++实现（不调包）（一）

【源码下载】GitCode，关键词【qt图像算法】

整套项目源码内容包含

[1].根据算法原理，编写纯c++源码，不调用外源库opencv 等；
[2].包括各种图像处理的基本算法，包含腐蚀膨胀，缩放，转置，镜像，平移，均衡变化，灰度拉升，灰度阈值，灰度非线性，转灰度，灰度线性，旋转，简单平滑，高斯平滑，轮廓跟踪，种子算法，hough直线检测，拉普拉斯，带方向边缘检测，常规边缘检测(梯度算子、Roberts算子和Sobel算子)，中值滤波，反色操作等；
[3].程序中有完整的注释，便于大家很好理解代码。

1.基本原理

轮廓跟踪是根据图像边界点的连通性，通过逐点跟踪获得区域轮廓的方法

常用的区域表示方法有两种，分别为轮廓表示法和线段表示法（可见下图）。轮廓表示法利用区域轮廓的连通性，以此记录每个轮廓点，最终绕一周回到起点；而线段表示法利用数字图像像素排列的规律，依次记录图像每行中的轮廓点。

7fc4fcd88aeb5dc98568b4828de9e557.png

链码的方向：一般分为八方向链码和四方向链码，其方向都为逆时针，可见下图

85fd7fcdae7d14ef60f329e3794bb5c9.png

链码的寻址：通过链码获得中心像素邻近像素的过程。链码的寻址是通过中心像素坐标加上偏移向量来实现的。这个过程通常是用偏移向量表来实现，可见下图的八方向偏移向量表

582930470fc7cba225236cd5cc74707b.png

链码方向的旋转：每逆时针旋转45°，链码值加1，如果大于7，则对8取模。若想取相反方向，则可以对链码值加4得到，给链码值加8可以回到原方向。

链码表的存储结构：链码表中前2个单元存储起始点坐标，第3个单元记录链码表长度，从第4个存储单元开始为轮廓上每个点的链码值，可见下图：

fd76d7fb3890d5441ed0a09b013ee323.png

链码表的应用：轮廓绘制以及周长计算

//应用链码进行轮廓绘制 track 为轮廓的链码表
QImage* MainWindow::DrawTrack(QImage* image,int* track)
{
    QImage* newImage = new QImage(image->height(),image->width(),QImage::Format_ARGB32);
    int directData[8][2] = {
        {1,0},
        {1,-1},
        {0,-1},
        {-1,-1},
        {-1,0},
        {-1,1},
        {0,1},
        {1,1}
    };
    int x,y,n;
    int i,index;
    x = track[0];
    y = track[1];
    n = track[2];
    for(i = 0;i<n;i++)
    {
		image->setPixel(x,y,qRgb(255,255,255));
		index = track[i+3];
		x+=directData[index][0];
		y+=directData[index][1];
    }
    return image;
}

//应用链码表进行轮廓周长的计算 track 为轮廓的链码表
double MainWindow:: TrackPeri(int* track)
{
    int i,n,c1=0,c2=0;
    double peri;
    n=track[2];
    for(i=0;i<n;i++)
    {
        if(track[i+3]%2 == 0)
            c2++;
        else c1++;
    }
    peri=(double)c1*sqrt(2)+c2;
    return peri;
}

对于轮廓表示法，参考上面，现在讲线段表示法。数字图像由像素组成，因此区域可以表示为一系列像素组成的水平线段的集合，每一条线段可由它的两个端点来表示，将构成区域的各线段的端点按顺序存储起来就可以得到线段表，线段表的存储结构可见下图

795bbb891b30be9785004f00fcc5dc17.png

线段的应用：可对区域填充、复制和面积的计算

//利用线段表来对区域进行填充 trackDot为轮廓的线段表 color为用来填充的颜色
QImage*MainWindow::TrackFill(QImage* image,int* trackDot,unsigned char* color)
{
    QImage* newImage = new QImage(image->height(),image->width(),QImage::Format_ARGB32);
    int n = trackDot[0];
    int y,x0,x1,i,j;
    for(i=0;i<n;i++)
    {
        y = trackDot[i*4+1];
        x0 = trackDot[i*4 +2];
        x1 = trackDot[i*4+4];
        for(j=x0;j<=x1;j++)
        {
			newImage->setPixel(j,y,qRgb(color[0],color[1],color[2]));
        }
    }
    return newImage;
}
//利用线段表来对区域进行复制 trackDot为轮廓的线段表 image为区域所在图像，image1为目标图像
QImage*MainWindow::TrackCopy(QImage* image,QImage* image1,int* trackDot)
{
    QColor color;
    int n = trackDot[0];
    int y,x0,x1,i,j;
    int r,g,b;
    for(i=0;i<n;i++)
    {
        y = trackDot[i*4+1];
        x0 = trackDot[i*4 +2];
        x1 = trackDot[i*4+4];
        for(j=x0;j<=x1;j++)
        {
            color = QColor(image->pixel(j,y));
            r = color.red();
            g = color.green();
            b = color.blue();
			image1->setPixel(j,y,qRgb(r,g,b));
        }
    }
    return image1;
}

/利用线段表计算区域的面积 trackDot为区域的链码表
double MainWindow:: TrackArea(int* trackDot)
{
    int n=trackDot[0];
    int y,x0,x1,i;
    double m=0.0;
    for(i=0;i<n;i++)
    {
        x0=trackDot[i*4+2];
        x1=trackDot[i*4+4];
        m+=(x1-x0+1);
    }
    return m;
}

链码表到线段表的转换：将图像的轮廓点按照线段表示法的思路分为4类，即左端点、右端点、中间点和奇异点。如果某轮廓点的右边为区域的内部，而左边为区域的外部，那么此点为左端点；相反则为右端点；如果某轮廓点左、右相邻点都是轮廓点，则此点为中间点；如果某轮廓点左、右相邻点都是区域外部，则此点为奇异点。如果用0表示中间点，1表示左端点，2表示右端点，3表示奇异点，那么根据下图可以容易地通过进入链码和离开链码判断轮廓点类型。

a2d8d63a9db41eb91a509bf32810f0b1.png

利用上述分类生成线段表的步骤：

1）顺序检测链码表，根据链码表提取轮廓中的左端点、右端点和奇异点，并存入线段表。其中奇异点提取两次。

2）将线段表中的所有点按照纵坐标排序

3）将纵坐标相同的点按照横坐标排序

//链码表到线段表的转换
 void MainWindow:: CodeToDot(int* track,int* trackDot)
{
    int directData[8][2] = {
        {1,0},
        {1,-1},
        {0,-1},
        {-1,-1},
        {-1,0},
        {-1,1},
        {0,1},
        {1,1}
    };

    int transTable[8][8]={
        {0,0,0,0,2,2,2,2},
        {1,1,1,1,0,3,3,3},
        {1,1,1,1,0,0,3,3},
        {1,1,1,1,0,0,0,3},
        {1,1,1,1,0,0,0,0},
        {0,3,3,3,2,2,2,2},
        {0,0,3,3,2,2,2,2},
        {0,0,0,3,2,2,2,2}
    };

    int x,y,m,dIn,dOut,i,j,k,c;
    x = track[0];
    y = track[1];
    m=track[2];
    track[m+3] = track[3];
    k = 3;
    for(i = 3; i< m+3;i++)
    {
        dIn = track[i];
        dOut = track[i+1];
        x+=directData[dIn][0];
        y+=directData[dIn][1];
        c = transTable[dIn][dOut];
        if(c>0)
        {
            trackDot[k] = x;
            trackDot[k+1] = y;
            k+=2;
            if(c==3)
            {
                trackDot[k] = x;
                trackDot[k+1] = y;
                k+=2;
            }
        }
    }
    m=(k-3)/2;
    for(i = 0;i<m-1;i++)
    {
        k = i;
        for(j=i+1;j<m;j++)
        {
            if(trackDot[j*2+4]<trackDot[k*2+4])
            {
                k=j;
            }
        }
        trackDot[i*2+1]=trackDot[k*2+3];
        trackDot[i*2+2]=trackDot[k*2+4];
        trackDot[k*2+3]=trackDot[i*2+3];
        trackDot[k*2+4]=trackDot[i*2+4];
    }
    i = 0;
    while(i<m)
    {
        k=i;
        while(i<m && trackDot[i*2+2] == trackDot[k*2+2])
        {
            i++;
        }
        for(;k<i-1;k++)
        {
            for(j=i-1;j>k;j--)
            {
                if(trackDot[j*2+1]<trackDot[j*2-1])
                {
                    x=trackDot[j*2+1];
                    y=trackDot[j*2+2];
                    trackDot[j*2+1]=trackDot[j*2-1];
                    trackDot[j*2+2]=trackDot[j*2];
                    trackDot[j*2-1]=x;
                    trackDot[j*2]=y;
                }
            }
        }
    }
    trackDot[0]=m/2;
}

导航