OpenCV学习(18) 细化算法(6)

本章我们在学习一下基于索引表的细化算法。

假设要处理的图像为二值图，前景值为1，背景值为0。

索引表细化算法使用下面的8邻域表示法：

一个像素的8邻域，我们可以用8位二进制表示，比如下面的8邻域，表示为00111000=0x38=56

我们可以枚举出各种情况下，当前像素能否删除的表，该表大小为256。它的索引即为8邻域表示的值，表中存的值为0或1，0表示当前像素不能删除，1表示可以删除。deletemark[256]

比如下图第一个表示，索引值为0，它表示孤立点，不能删除，所以deletemark[0]=0,第二个表示索引值为17，它表示端点，也不能删除，所以deletemark[17]=0，第三个表示索引为21，删除的话会改变连通域数量，所以deletemark[21]=0，第四个表示索引值为96，此时可以删除，所以deletemark[96]=1。

最终我们会定义一张完整的表来表示当前像素能否删除。

索引表细化算法描述很简单。

1.找到轮廓，其值用4表示

2.查找值为4的轮廓，查找索引表判断能否删除，能删除的话把它置为0。

循环迭代1，2直到再也没有可以删除的点为止。

下面的算法的代码：

void gThin::cvidxThin1(cv::Mat& src, cv::Mat& dst)
        {

        if(src.type()!=CV_8UC1)
            {
            printf("只能处理二值或灰度图像\n");
            return;
            }
        //非原地操作时候，copy src到dst
        if(dst.data!=src.data)
            {
            src.copyTo(dst);
            }

        //    P0 P1 P2
        //    P7    P3
        //    P6 P5 P4
        unsigned char deletemark[256] = {
            0,0,0,0,0,0,0,1,    0,0,1,1,0,0,1,1,
            0,0,0,0,0,0,0,0,    0,0,1,1,1,0,1,1,
            0,0,0,0,0,0,0,0,    1,0,0,0,1,0,1,1,
            0,0,0,0,0,0,0,0,    1,0,1,1,1,0,1,1,
            0,0,0,0,0,0,0,0,    0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,    0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,    1,0,0,0,1,0,1,1,
            1,0,0,0,0,0,0,0,    1,0,1,1,1,0,1,1,
            0,0,1,1,0,0,1,1,    0,0,0,1,0,0,1,1,
            0,0,0,0,0,0,0,0,    0,0,0,1,0,0,1,1,
            1,1,0,1,0,0,0,1,    0,0,0,0,0,0,0,0,
            1,1,0,1,0,0,0,1,    1,1,0,0,1,0,0,0,
            0,1,1,1,0,0,1,1,    0,0,0,1,0,0,1,1,
            0,0,0,0,0,0,0,0,    0,0,0,0,0,1,1,1,
            1,1,1,1,0,0,1,1,    1,1,0,0,1,1,0,0,
            1,1,1,1,0,0,1,1,    1,1,0,0,1,1,0,0
            };//索引
        int i, j;
        int width, height;
        //之所以减1，是方便处理8邻域，防止越界
        width = src.cols -1;
        height = src.rows -1;
        int step = src.step;
        int  p0, p1, p2,p3,p4,p5,p6,p7;
        uchar* img;
        bool ifEnd;
        bool border = false; //交换删除的次序，防止从一边细化
        while(1)
            {

            border = !border;
            img = dst.data;
            for(i = 1; i < height; i++)
                {
                img += step;
                for(j =1; j<width; j++)
                    {
                    uchar* p = img + j;
                    //如果p点是背景点,继续循环
                    if(p[0]==0) continue;
                    p0 = p[-step-1]>0?1:0;
                    p1 = p[-step]>0?1:0;
                    p2 = p[-step+1]>0?1:0;
                    p3 = p[1]>0?1:0;
                    p4 = p[step+1]>0?1:0;
                    p5 = p[step]>0?1:0;
                    p6 = p[step-1]>0?1:0;
                    p7 = p[-1]>0?1:0;

                    //如果sum等于0，则不是内部点，是轮廓点，设置其像素值为2
                    int sum;
                    sum =  p0 & p1 & p2 & p3 & p4 & p5 & p6 & p7;

                    //判断是否是邻接点或孤立点,0,1分别对于那个孤立点和端点
                    if(sum==0)
                        {
                        dst.at<uchar>(i,j) = 4; //满足删除条件，设置当前像素为0
                        }

                    }
                }
            //printf("\n");
            //PrintMat(dst);
            //执行删除操作
            ifEnd = false;

            img = dst.data;
            for(i = 1; i < height; i++)
                {
                img += step;
                for(j =1; j<width; j++)
                    {
                    uchar* p = img + j;
                    //如果p点是背景点,继续循环
                    if(p[0]!=4) continue;
                    p0 = p[-step-1]>0?1:0;
                    p1 = p[-step]>0?1:0;
                    p2 = p[-step+1]>0?1:0;
                    p3 = p[1]>0?1:0;
                    p4 = p[step+1]>0?1:0;
                    p5 = p[step]>0?1:0;
                    p6 = p[step-1]>0?1:0;
                    p7 = p[-1]>0?1:0;

                    p1 = p1<<1;
                    p2 = p2<<2;
                    p3 = p3 <<3;
                    p4 = p4<<4;
                    p5 = p5<<5;
                    p6 = p6 <<6;
                    p7 = p7 << 7;

                    //求的8邻域在索引表中的索引
                    int sum;
                    sum = p0 | p1 | p2 | p3 | p4 | p5 | p6 | p7;

                    //判断是否是邻接点或孤立点,0,1分别对于那个孤立点和端点
                    if(deletemark[sum] == 1)
                        {
                        dst.at<uchar>(i,j) = 0; //满足删除条件，设置当前像素为0
                        ifEnd = true;
                        }

                    }
                }

            //printf("\n");
            //PrintMat(dst);
            //printf("\n");

            //已经没有可以细化的像素了，则退出迭代
            if(!ifEnd) break;
            }

上面的算法可以看到细化后的轮廓偏右了，我们可以更改删除的循环条件，把循环拆分成三个，修改后的代码如下：

void gThin::cvidxThin(cv::Mat& src, cv::Mat& dst)
    {

    if(src.type()!=CV_8UC1)
        {
        printf("只能处理二值或灰度图像\n");
        return;
        }
    //非原地操作时候，copy src到dst
    if(dst.data!=src.data)
        {
        src.copyTo(dst);
        }

    //    P0 P1 P2
    //    P7    P3
    //    P6 P5 P4
    unsigned char deletemark[256] = {
        0,0,0,0,0,0,0,1,    0,0,1,1,0,0,1,1,
        0,0,0,0,0,0,0,0,    0,0,1,1,1,0,1,1,
        0,0,0,0,0,0,0,0,    1,0,0,0,1,0,1,1,
        0,0,0,0,0,0,0,0,    1,0,1,1,1,0,1,1,
        0,0,0,0,0,0,0,0,    0,0,0,0,0,0,0,0,
        0,0,0,0,0,0,0,0,    0,0,0,0,0,0,0,0,
        0,0,0,0,0,0,0,0,    1,0,0,0,1,0,1,1,
        1,0,0,0,0,0,0,0,    1,0,1,1,1,0,1,1,
        0,0,1,1,0,0,1,1,    0,0,0,1,0,0,1,1,
        0,0,0,0,0,0,0,0,    0,0,0,1,0,0,1,1,
        1,1,0,1,0,0,0,1,    0,0,0,0,0,0,0,0,
        1,1,0,1,0,0,0,1,    1,1,0,0,1,0,0,0,
        0,1,1,1,0,0,1,1,    0,0,0,1,0,0,1,1,
        0,0,0,0,0,0,0,0,    0,0,0,0,0,1,1,1,
        1,1,1,1,0,0,1,1,    1,1,0,0,1,1,0,0,
        1,1,1,1,0,0,1,1,    1,1,0,0,1,1,0,0
        };//索引
    int i, j;
    int width, height;
    //之所以减1，是方便处理8邻域，防止越界
    width = src.cols -1;
    height = src.rows -1;
    int step = src.step;
    int  p0, p1, p2,p3,p4,p5,p6,p7;
    uchar* img;
    bool ifEnd;
    bool border = false; //交换删除的次序，防止从一边细化
    while(1)
        {

        border = !border;
        img = dst.data;
        for(i = 1; i < height; i++)
            {
            img += step;
            for(j =1; j<width; j++)
                {
                uchar* p = img + j;
                //如果p点是背景点,继续循环
                if(p[0]==0) continue;
                p0 = p[-step-1]>0?1:0;
                p1 = p[-step]>0?1:0;
                p2 = p[-step+1]>0?1:0;
                p3 = p[1]>0?1:0;
                p4 = p[step+1]>0?1:0;
                p5 = p[step]>0?1:0;
                p6 = p[step-1]>0?1:0;
                p7 = p[-1]>0?1:0;

                //如果sum等于0，则不是内部点，是轮廓点，设置其像素值为2
                int sum;
                sum =  p0 & p1 & p2 & p3 & p4 & p5 & p6 & p7;

                //判断是否是邻接点或孤立点,0,1分别对于那个孤立点和端点
                if(sum==0)
                    {
                    dst.at<uchar>(i,j) = 4; //满足删除条件，设置当前像素为0
                    }

                }
            }
        //printf("\n");
        //PrintMat(dst);
        //执行删除操作
        ifEnd = false;

        img = dst.data;
        for(i = 1; i < height; i++)
            {
            img += step;
            for(j =1; j<width; j+=3)
                {
                uchar* p = img + j;
                //如果p点是背景点,继续循环
                if(p[0]!=4) continue;
                p0 = p[-step-1]>0?1:0;
                p1 = p[-step]>0?1:0;
                p2 = p[-step+1]>0?1:0;
                p3 = p[1]>0?1:0;
                p4 = p[step+1]>0?1:0;
                p5 = p[step]>0?1:0;
                p6 = p[step-1]>0?1:0;
                p7 = p[-1]>0?1:0;

                p1 = p1<<1;
                p2 = p2<<2;
                p3 = p3 <<3;
                p4 = p4<<4;
                p5 = p5<<5;
                p6 = p6 <<6;
                p7 = p7 << 7;

                //求的8邻域在索引表中的索引
                int sum;
                sum = p0 | p1 | p2 | p3 | p4 | p5 | p6 | p7;

                //判断是否是邻接点或孤立点,0,1分别对于那个孤立点和端点
                if(deletemark[sum] == 1)
                    {
                    dst.at<uchar>(i,j) = 0; //满足删除条件，设置当前像素为0
                    ifEnd = true;
                    }

                }
            }

        img = dst.data;
        for(i = 1; i < height; i++)
            {
            img += step;
            for(j =2; j<width; j+=3)
                {
                uchar* p = img + j;
                //如果p点是背景点,继续循环
                if(p[0]!=4) continue;
                p0 = p[-step-1]>0?1:0;
                p1 = p[-step]>0?1:0;
                p2 = p[-step+1]>0?1:0;
                p3 = p[1]>0?1:0;
                p4 = p[step+1]>0?1:0;
                p5 = p[step]>0?1:0;
                p6 = p[step-1]>0?1:0;
                p7 = p[-1]>0?1:0;

                p1 = p1<<1;
                p2 = p2<<2;
                p3 = p3 <<3;
                p4 = p4<<4;
                p5 = p5<<5;
                p6 = p6 <<6;
                p7 = p7 << 7;

                //求的8邻域在索引表中的索引
                int sum;
                sum = p0 | p1 | p2 | p3 | p4 | p5 | p6 | p7;

                //判断是否是邻接点或孤立点,0,1分别对于那个孤立点和端点
                if(deletemark[sum] == 1)
                    {
                    dst.at<uchar>(i,j) = 0; //满足删除条件，设置当前像素为0
                    ifEnd = true;
                    }

                }
            }

        img = dst.data;
        for(i = 1; i < height; i++)
            {
            img += step;
            for(j =3; j<width; j+=3)
                {
                uchar* p = img + j;
                //如果p点是背景点,继续循环
                if(p[0]!=4) continue;
                p0 = p[-step-1]>0?1:0;
                p1 = p[-step]>0?1:0;
                p2 = p[-step+1]>0?1:0;
                p3 = p[1]>0?1:0;
                p4 = p[step+1]>0?1:0;
                p5 = p[step]>0?1:0;
                p6 = p[step-1]>0?1:0;
                p7 = p[-1]>0?1:0;

                p1 = p1<<1;
                p2 = p2<<2;
                p3 = p3 <<3;
                p4 = p4<<4;
                p5 = p5<<5;
                p6 = p6 <<6;
                p7 = p7 << 7;

                //求的8邻域在索引表中的索引
                int sum;
                sum = p0 | p1 | p2 | p3 | p4 | p5 | p6 | p7;

                //判断是否是邻接点或孤立点,0,1分别对于那个孤立点和端点
                if(deletemark[sum] == 1)
                    {
                    dst.at<uchar>(i,j) = 0; //满足删除条件，设置当前像素为0
                    ifEnd = true;
                    }

                }
            }

        //printf("\n");
        //PrintMat(dst);
        //printf("\n");

        //已经没有可以细化的像素了，则退出迭代
        if(!ifEnd) break;
        }

    }

修改后的结果：

程序源代码：工程FirstOpenCV11

OpenCV学习(18) 细化算法(6)的更多相关文章

OpenCV学习(16) 细化算法(4)
本章我们学习Rosenfeld细化算法,参考资料:http://yunpan.cn/QGRjHbkLBzCrn 在开始学习算法之前,我们先看下连通分量,以及4连通性,8连通性的概念: http://w ...
OpenCV学习(15) 细化算法(3)
本章我们学习一下Hilditch算法的基本原理,从网上找资料的时候,竟然发现两个有很大差别的算法描述,而且都叫Hilditch算法.不知道那一个才是正宗的,两个算法实现的效果接近,第一种算 ...
OpenCV学习(17) 细化算法(5)
本章我们看下Pavlidis细化算法,参考资料http://www.imageprocessingplace.com/downloads_V3/root_downloads/tutorials/con ...
OpenCV学习(14) 细化算法(2)
前面一篇教程中,我们实现了Zhang的快速并行细化算法,从算法原理上,我们可以知道,算法是基于像素8邻域的形状来决定是否删除当前像素.还有很多与此算法相似的细化算法,只是判断的条件不一样. ...
OpenCV学习(13) 细化算法(1)
程序编码参考经典的细化或者骨架算法文章: T. Y. Zhang and C. Y. Suen, "A fast parallel algorithm for thinning digita ...
OpenCV学习(19) 细化算法(7)
最后再来看一种通过形态学腐蚀和开操作得到骨架的方法.http://felix.abecassis.me/2011/09/opencv-morphological-skeleton/ 代码非常简单: v ...
c++opencv中线条细化算法
要达到的效果就是将线条尽量细化成单像素,按照论文上的Hilditch算法试了一下,发现效果不好,于是自己尝试着写了一下细化的算法,基本原理就是从上下左右四个方向向内收缩. 1.先是根据图片中的原则确定 ...
OpenCV学习(9) 分水岭算法(3)
本教程我学习一下opencv中分水岭算法的具体实现方式. 原始图像和Mark图像,它们的大小都是32*32,分水岭算法的结果是得到两个连通域的轮廓图. 原始图像:(原始图像必须是3通道图像) Mark ...
OpenCV学习(21) Grabcut算法详解
grab cut算法是graph cut算法的改进.在理解grab cut算之前,应该学习一下graph cut算法的概念及实现方式. 我搜集了一些graph cut资料:http://yunpan. ...

随机推荐

MongoDB入门教程二［MongoDB Shell 简介与使用］
MongoDB Shell 是MongoDB自带的JavaScript Shell,随MongoDB一同发布,它是MonoDB客户端工具,可以在Shell中使用命令与MongoDB实例交互,对数据库的 ...
有关FPGA
在FPGA发展历史上,前后共有过超过50家厂商,在国外目前剩下不到10家,除赛灵思和ALTERA两家持续不断地军备竞赛,其它的都有着各自固守的市场定位.即使是有新进入者,例如受英特尔新工艺支 ...
如何定义最佳 Cache-Control 策略
定义最佳 Cache-Control 策略按照以上决策树为您的应用使用的特定资源或一组资源确定最佳缓存策略.在理想的情况下,您的目标应该是在客户端上缓存尽可能多的响应,缓存尽可能长的时间,并且为每个 ...
机器学习之路：python 字典特征提取器 DictVectorizer
python3 学习使用api 将字典类型数据结构的样本,抽取特征,转化成向量形式源码git: https://github.com/linyi0604/MachineLearning 代码: fr ...
LCD
<LCD硬件体系结构> LCD控制器:位于ARM核内部,为LCD提供需要显示的数据,控制信息,控制时序 <LCD控制器结构> REGBANKK : 寄存器组,总共有17个寄存器 ...
SPOJ QTREE
QTREE /* 题目大意:维护一棵树,允许修改边权以及查询链上最大值题解:我们将边权转为点权,标记在深度较深的点上,树链剖分后用线段树处理即可 */ #include <cstdio> ...
SB!SB!SB! ----WriteUp
原题下载图片 http://ctf5.shiyanbar.com/stega/ste.png 用Stegsolve查看发现有个二维码扫码可以知道flag
王彪-20162321-Java程序设计与数据结构2nd-第十周学习总结
学习目标讨论有向图和无向图定义带权图并讨论它们的应用定义图的广度优先遍历和深度优先遍历定义最小生成树讨论图的实现策略书中图的基本定义图是由结点及结点间的连接组成的,结点称为顶点,结点间的 ...
Codeforces Round #254 (Div. 1) D. DZY Loves Strings hash 暴力
D. DZY Loves Strings 题目连接: http://codeforces.com/contest/444/problem/D Description DZY loves strings ...
vijos 1659 河蟹王国线段树区间加、区间查询最大值
河蟹王国 Time Limit: 1 Sec Memory Limit: 256 MB 题目连接 https://vijos.org/p/1659 Description 河蟹王国有一位河蟹国王,他 ...

OpenCV学习(18) 细化算法(6)

OpenCV学习(18) 细化算法(6)的更多相关文章

随机推荐

热门专题