图像处理之轮廓跟踪算法及圆提取-代码

已于 2022-06-27 17:12:16 修改
阅读量685 收藏 3
点赞数 2
分类专栏： C 图像处理 文章标签： 开发语言 openCV 轮廓提取
于 2022-06-27 17:03:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ai5945fei/article/details/125487327
版权

 一些基本函数


int icvCodeDeltas[][2] = {{1, 0}, {1, -1}, {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}, {0, 1}, {1, 1}};

int DeltasChangeTab[] = {4, 5, 6, 7, 0, 1, 2, 3};


typedef struct
{
    short i;
    short j;
    short DeltasNum;
} _Point;



inline _Point GetPoint8(int i, int j, int num)
{
    _Point p;
    p.i = i + icvCodeDeltas[num][0];
    p.j = j + icvCodeDeltas[num][1];
    p.DeltasNum = num;
    return p;
}

inline int GetPoint8NBD(char data[][WIDTH], int i, int j, int num)
{
    int _i = i + icvCodeDeltas[num][0];
    int _j = j + icvCodeDeltas[num][1];
    if (_i < 0 || _j < 0)
        return 0;
    if (_i >= HEIGHT || _j >= WIDTH)
        return 0;

    return data[_i][_j];
}

inline int Get8Pos(_Point *cent, _Point *p)
{
    int di = p->i - cent->i;
    int dj = p->j - cent->j;
    for (int n = 0; n < 8; n++)
    {
        if (di == icvCodeDeltas[n][0] && dj == icvCodeDeltas[n][1])
        {
            return n;
        }
    }

    return -1;
}

 查找内外轮廓

//p 二维二值化图片
int findContour(char *p, float d_error, int min, int max, int log_show)
{
    bool object = false;
    bool flag = false;
    int circle_cnt = 0;

    //用于查找单条轮廓的临时变量

    // uint16_t contour_i[CONTOUR_MAX_LENGTH];
    // uint16_t contour_j[CONTOUR_MAX_LENGTH];

    uint16_t contour_len = 0;

    char(*nbd)[WIDTH] = (char(*)[WIDTH])p;
    //查找起点
    _Point I0; //轮廓起点
    _Point I1; //轮廓的终点
    _Point I2; //轮廓 上一个点
    _Point I3; //轮廓 8领域中点
    _Point I4; // 8领域找到的下一个点

    for (int i = 1; i < HEIGHT - 1; i++)
    {
        for (int j = 1; j < WIDTH - 1; j++)
        {
            if (nbd[i][j] == 1 && nbd[i][j - 1] == 0) //找到轮廓起点
            {
                nbd[i][j] |= 2;
                I0.i = i;
                I0.j = j;

                // log("find outer %d\t[%d,%d]\r\n", contour_outr++, i, j);

                contour_init;
                contour_app(i, j);
                //找终点 I1

                if (GetPoint8NBD(nbd, i, j, 6) != 0)
                {
                    I1 = GetPoint8(i, j, 6);
                }
                else if (GetPoint8NBD(nbd, i, j, 7) != 0)
                {
                    I1 = (GetPoint8(i, j, 7));
                }
                else if (GetPoint8NBD(nbd, i, j, 0) != 0)
                {
                    I1 = (GetPoint8(i, j, 0));
                }
                else if (GetPoint8NBD(nbd, i, j, 1) != 0)
                {
                    I1 = (GetPoint8(i, j, 1));
                }
                else
                {
                    // nbd[i][j] = 0; //删除
                    //无效的起始点
                    continue;
                }

                nbd[I1.i][I1.j] |= 2;

                flag = false;
                //查找I2
                int deltas = I1.DeltasNum;
                for (int n = 0; n < 8; n++)
                {
                    deltas = (deltas - 1) & 7;
                    if (GetPoint8NBD(nbd, I0.i, I0.j, deltas) >= 1)
                    {
                        I2 = (GetPoint8(I0.i, I0.j, deltas));
                        flag = true;
                        break;
                    }
                }

                // printf("I0(%d,%d)  I1(%d,%d)%d  I2(%d,%d)%d",I0.i,I0.j,I1.i,I1.j,I1.DeltasNum,I2.i,I2.j,I2.DeltasNum);

                if (flag == false)
                {
                    // printf("I2 invalid\r\n");
                    continue; //位置无效
                }

                nbd[I2.i][I2.j] |= 2;
                contour_app(I2.i, I2.j);

                //设置I3
                if (I2.DeltasNum == I1.DeltasNum) //独立的两个点 I0 I1 , I1 I2未同一个点
                {
                    I2 = I0;
                    I3 = I1;                                      //交换中心点
                    I2.DeltasNum = DeltasChangeTab[I1.DeltasNum]; //交互相对位置
                                                                  // single_list_flag = true;
                                                                  //	contour_init;
                }
                else
                {
                    I3 = I2;
                    I2 = I0;
                    I2.DeltasNum = DeltasChangeTab[I3.DeltasNum];
                }

                //起点过后 开始查找链表
                // printf("# i,j=%d,%d\r\n", i, j);
                // DeltasNum 已针对I3中点更新
                while (true)
                {
                    //  vTaskDelay(2);
                    flag = false;
                    //查找I4 下一个目标点
                    deltas = I2.DeltasNum;
                    for (int n = 0; n < 8; n++)
                    {
                        deltas = (deltas - 1) & 7;
                        int tmp = GetPoint8NBD(nbd, I3.i, I3.j, deltas);
                        if ((tmp & 0x01) == 0x01)
                        {
                            I4 = GetPoint8(I3.i, I3.j, deltas); //找到下一个点
                            flag = true;
                            break;
                        }
                    }

                    if (flag == false)
                    {
                        break; //位置无效
                    }
                    if (I4.i == I0.i && I4.j == I0.j)
                    {
                        break;
                        // return;
                    }
                    //交换 I2 I3
                    if (I4.DeltasNum == I2.DeltasNum) // 找到孤立点
                    {
                        //饶了一圈回来了 说明该点是端点 结束继续查找
                        nbd[I4.i][I4.j] |= 2;

                        contour_app(I4.i, I4.j);

                        I2 = I3;
                        I3 = I4;
                        I2.DeltasNum = DeltasChangeTab[I4.DeltasNum];
                    }
                    else
                    {
                        nbd[I4.i][I4.j] |= 2;

                        contour_app(I4.i, I4.j); //单链不算入链条长度里面
                        I2 = I3;
                        I3 = I4;
                        I2.DeltasNum = DeltasChangeTab[I4.DeltasNum];
                    }
                }
            }
            else if (nbd[i][j] == 1 && nbd[i][j + 1] == 0) //内边界
            {
                //  log("find iner%d\t[%d,%d]\r\n", contour_iner++, i, j);

                nbd[i][j] |= 4;
                I0.i = i;
                I0.j = j;
                contour_init;
                contour_app(i, j);

                int cou_length = 0;
                //找终点 I1

                if (GetPoint8NBD(nbd, i, j, 6) != 0)
                {
                    I1 = (GetPoint8(i, j, 6));
                }
                else if (GetPoint8NBD(nbd, i, j, 5) != 0)
                {
                    I1 = (GetPoint8(i, j, 5));
                }
                else if (GetPoint8NBD(nbd, i, j, 4) != 0)
                {
                    I1 = (GetPoint8(i, j, 4));
                }
                else if (GetPoint8NBD(nbd, i, j, 3) != 0)
                {
                    I1 = (GetPoint8(i, j, 3));
                }
                else
                {
                    // nbd[i][j] = 0; //删除
                    //无效的起始点
                    continue;
                }
                flag = false;
                //查找I2
                int deltas = I1.DeltasNum;
                for (int n = 0; n < 8; n++)
                {
                    deltas = (deltas + 1) & 7;
                    if (GetPoint8NBD(nbd, I0.i, I0.j, deltas) != 0)
                    {
                        I2 = (GetPoint8(I0.i, I0.j, deltas));
                        flag = true;
                        break;
                    }
                }

                if (flag == false)
                {
                    // printf("-I2 invalid\r\n");
                    continue; //位置无效
                }

                nbd[I2.i][I2.j] |= 4;
                contour_app(I2.i, I2.j);

                //设置I3
                if (I2.DeltasNum == I1.DeltasNum) //独立的两个点 I0 I1 , I1 I2未同一个点
                {
                    I2 = (I0);
                    I3 = (I1);                                    //交换中心点
                    I2.DeltasNum = DeltasChangeTab[I1.DeltasNum]; //交互相对位置
                }
                else
                {
                    I3 = (I2);
                    I2 = (I0);
                    I2.DeltasNum = DeltasChangeTab[I3.DeltasNum];
                }

                //起点过后 开始查找链表
                //  printf("o i,j=%d,%d\r\n", i, j);
                // DeltasNum 已针对I3中点更新
                while (true)
                {
                    // vTaskDelay(2);
                    flag = false;
                    //查找I4 下一个目标点
                    deltas = I2.DeltasNum;
                    for (int n = 0; n < 8; n++)
                    {
                        deltas = (deltas + 1) & 7;
                        if (GetPoint8NBD(nbd, I3.i, I3.j, deltas) != 0)
                        {
                            I4 = (GetPoint8(I3.i, I3.j, deltas)); //找到下一个点
                            flag = true;
                            break;
                        }
                    }
                    if (flag == false)
                    {
                        break; //位置无效
                    }

                    // printf("* I4 i,j=%d,%d\r\n", I4.i, I4.j);
                    cou_length++;

                    if (I4.i == I0.i && I4.j == I0.j)
                    {
                        // printf("outer %d len %d\r\n", contour_iner, cou_length);

                        // contour_signal_clear(nbd, contour_i, contour_j, contour_len);

#if 1
                        contour_len = contour_signal_clear(nbd, contour_i, contour_j, contour_len);
                        if (contour_len > FILTER_CONTOUR)
                        {
                            _Point center;
                            printf("\r\n");
                            int area = getContourArea(contour_i, contour_j, contour_vaild, contour_len, &center);
                            if (area > 10)
                            {
                                int length = getContourLength(contour_i, contour_j, contour_vaild, contour_len);
                                float d1 = 2 * sqrt(area / PARAM_PI);
                                float d2 = length / PARAM_PI;
                                float error = fabs(d2 - d1) / d1;
                                // printf("contour >  %d   %d %.2f %.2f (%d %d)\r\n", area, length, d1, d2, center.j, center.i);
                                if (error < d_error)
                                {
                                    contour_set_circle; //圆形外轮廓
                                                        // getCirclePoint(contour_i, contour_j, contour_vaild, contour_len);

                                    nbd[center.i][center.j] |= 0x40; //圆心坐标

                                    if (d1 >= min && d1 <= max)
                                    {
                                        printf(">circle:%d d:%.2f (%d,%d) e:%.2f\r\n", circle_cnt, d1, center.i, center.j, error);
                                        circle_cnt++;
                                    }
                                    if (log_show)
                                        printf("error= %.2f area=%d length=%d d1=%.2f d2=%.2f [%d]\t<<<YES>>>(%d,%d)\r\n", error, area, length, d1, d2, contour_len, center.i, center.j);
                                }
                                else
                                {
                                    if (log_show)
                                        printf("error= %.2f area=%d length=%d d1=%.2f d2=%.2f [%d]\r\n", error, area, length, d1, d2, contour_len);
                                }
                            }
                        }
#endif

                        break;
                    }

                    //交换 I2 I3
                    if (I4.DeltasNum == I2.DeltasNum) //独同一个点 那说明找完了整条轮廓
                    {
                        //饶了一圈回来了 说明该点是端点 结束继续查找

                        contour_app(I4.i, I4.j);
                        I2 = (I3);
                        I3 = (I4);
                        I2.DeltasNum = DeltasChangeTab[I4.DeltasNum];
                    }
                    else
                    {
                        nbd[I4.i][I4.j] |= 4;
                        contour_app(I4.i, I4.j);
                        I2 = (I3);
                        I3 = (I4);
                        I2.DeltasNum = DeltasChangeTab[I4.DeltasNum];
                    }
                }
            }
        }
    }
    printf(">circle end %d\r\n", circle_cnt);
    return circle_cnt;
}

下载链接：

https://download.csdn.net/download/ai5945fei/85800131

dancebit
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
识别圆的强化RANSAC算法
qq_29207457的博客
07-18 1855
# 识别圆的强化RANSAC算法 ## 什么是RANSAC算法？ ​ **随机抽样一致算法（RANdom SAmple Consensus,RANSAC）**，是一种采用迭代的方式从一组包含噪音的数据中找到想要的数学模型。这个算法的使用前提是给定一组数据，存在一种方法能计算出符合这些数据的模型的参数。RANSAC算法把数据分为了两类，正确数据（内点）和异常数据（噪声），并通过一个参数sigma来将数据中的点分类。**该算法的核心思想在于其随机性和假设性**，随机性指的是抽象选取数据是随机的，根据...
图像处理之轮廓跟踪算法及圆提取
ai5945fei的博客
07-17 4490
开发是一个遥远而漫长的路程，每一个程序员都会在这条路上忠贞不渝，直至时间的尽头，依旧乐此不疲 目的是统计出上图贴纸中的小圆。 相关参数： 摄像头：OV2640 开发平台：ESP32-CAM 处理像素：320*240 1、采集原始图像 配置ESP32输出灰度图，像素太高无法存储及处理。320*240= 75K。 2、图像梯度计算 参考代码：C语言绘制图像梯度图 https://www.jianshu.com/p/8624bfe9d3f9 原理介绍：图像的梯度 h...
opencv中轮廓检测以及轮廓近似的分析——轮廓近似原理，所有代码开源，所有函数的参数。
Mr_zhubao的博客
02-14 2532
其中可以看到函数中有一个参数是需要我们自己进行计算的：指定的精度（epsilon），这个参数也是由前面的系数决定的，在示例中用的系数是0.01，实际上可以根据自己对精度的需求自行调整。cv2.RETR_CCOMP：检索所有的轮廓，并将他们分为两个等级的轮廓。上一层是外部边界，里一层是空洞的边界。cv2.CHAIN_APPROX_SIMPLE：压缩水平的、垂直的和斜的部分，也就是，函数只保留他们的终点部分（轮廓的近似的实现：实际上轮廓的近似的实现就是将复杂的曲线用一些直线来代替，使图像更加的光滑和规则化。
OpenCV4探索学习：轮廓
Stone_石头
08-19 613
轮廓提取：findContours void findContours//提取轮廓，用于提取图像的轮廓 ( InputOutputArray image,//输入图像，必须是8位单通道图像，并且应该转化成二值的 OutputArrayOfArrays contours,//检测到的轮廓，每个轮廓被表示成一个point向量 OutputArray hierarchy,//可选的输出向量，包...
边界跟踪、边缘检测、边缘连接
热门推荐
qq_28942407的博客
12-19 1万+
参考 1.图像轮廓跟踪         在识别图象中的目标时，往往需要对目标边缘作跟踪处理，也叫轮廓跟踪。顾名思义，轮廓跟踪就是通过顺序找出边缘点来跟踪边界的。若图象是二值图象或图象中不同区域具有不同的象素值，但每个区域内的象素值是相同的，则如下算法可完成基于4连通或8连通区域的轮廓跟踪。 步骤1：首先按从上到下，从左到右的顺序扫描图象，寻找没有标记跟踪结束记号的第一个边界起始点A0，A
sobel.zip_图像迭代算法_轮廓提取算法
07-14
在图像处理领域，"sobel.zip_图像迭代算法_轮廓提取算法"的标题涉及了两个核心概念：图像迭代算法和轮廓提取算法。这两个算法在计算机视觉、机器学习以及图像分析等应用中扮演着重要角色。 首先，我们来深入探讨...
图象的边沿检测与提取，轮廓跟踪算法代码.zip_跟踪_轮廓提取算法_轮廓算法_边沿提取_边沿检测
09-14
在图像处理领域，边沿检测和轮廓跟踪是两个至关重要的技术。它们被广泛应用于计算机视觉、机器学习、图像分析和模式识别等众多领域。这里，我们主要探讨的是图像的边沿检测与提取以及轮廓跟踪算法。 首先，边沿检测...
numpy-基于numpy实现的图像处理算法之寻找轮廓.zip
最新发布
06-23
总结一下，使用numpy实现图像处理算法之寻找轮廓的过程主要包括以下步骤： 1. 转换图像至灰度并进行二值化。 2. 应用形态学操作（如膨胀和腐蚀）优化边缘。 3. 执行连通组件分析以区分独立物体。 4. 利用其他库（如...
soble.rar_图像前景_图像处理_轮廓提取
07-15
在图像处理领域，"soble.rar_图像前景_图像处理_轮廓提取"这一主题涉及到的是对图像中的前景目标进行分析并提取其轮廓的过程。在这个项目中，MATLAB被用作强大的工具来实现这一目标。MATLAB是一种广泛使用的编程环境...
图像处理 轮廓跟踪 图像处理 轮廓跟踪
06-05
轮廓跟踪轮廓跟踪轮廓跟踪轮廓跟踪轮廓跟踪轮廓跟踪轮廓跟踪轮廓跟踪轮廓跟踪
C 图像轮廓跟踪，边沿检测与提取算法源代码
05-19
#include "bmp.h" #include "memory.h" #include "math.h" #include "stdio.h" //owner defined stack typedef struct{ HGLOBAL hMem; POINT *lpMyStack; LONG ElementsNum; LONG ptr; }MYSTACK; //macro definition #define WIDTHBYTES(i) ((i+31)/32*4) #define PI 3.1415926535 //function declaration int PASCAL WinMain (HANDLE, HANDLE, LPSTR, int); LRESULT CALLBACK MainWndProc(HWND , UINT,WPARAM, LPARAM); BOOL LoadBmpFile (HWND hWnd,char *BmpFileName); BOOL TemplateOperation(HWND hWnd, int TemplateType); BOOL Outline(HWND hWnd); BOOL Hough(HWND hWnd); BOOL LapOfGauss(HWND hWnd); BOOL Contour(HWND hWnd); BOOL IsContourP(LONG x,LONG y, char *lpPtr); BOOL SeedFill(HWND hWnd); BOOL InitStack(HWND hWnd,LONG StackLen); void DeInitStack(); BOOL MyPush(POINT p); POINT MyPop(); BOOL IsStackEmpty(); //global variable declaration BITMAPFILEHEADER bf; BITMAPINFOHEADER bi;
图像边缘检测，还有轮廓提取算法
05-25
是一种好用的算法，包括了图像灰度变化，二值化。还有小目标检测
opencv小案例_图像中圆对象提取
06-18
基于VS2015+WIN8通过opencv实现，图像中对象提取，真实案例，获取这样的对象，去掉其他干扰或非目标对象
数字图像处理(七) 图像分割
小小何先生的学习之旅
11-23 1万+
本文首发于公众微信号-AI研究订阅号。   本节主要目的是介绍图像分割的一些基本概念。来源于东北大学 魏颖教授的模式识别课程笔记。 本节重点：1）图像分割的基本概念及图像分割分类的基础；2）边缘分割法；3）阈值分割法；4）区域分割法。 图像分割概述   人类视觉在观察和分析一幅图像时，总是首先将注意力集中在图像中的感兴趣的物体或区域，即将其从其他景物中分离开来，然后对其进行特征分析，再根据...
图像的分割之轮廓提取算法
qq_43409114的博客
03-05 1万+
目标物体的轮廓提取 轮廓提取法 边界跟踪法 区域增长法 区域分裂合并法 一、轮廓提取法 对于二值图像的轮廓提取，我们可以采用掏空内部点法，如果原图中有一点为黑，且它的8个相邻的点都为黑，则将该点删除。对于非二值图像，要先进行二值处理 掏空内部点法实现如下 def GetOutLine(self): img=np.copy(self.Img) for y ...
轮廓跟踪
yuyututuw
01-09 822
轮廓跟踪 2010年07月23日 　　在识别图象中的目标时，往往需要对目标边缘作跟踪处理，也叫轮廓跟踪。顾名思义，轮廓跟踪就是通过顺序找出边缘点来跟踪边界的。若图象是二值图象或图象中不同区域具有不同的象素值，但每个区域内的象素值是相同的，则如下算法可完成基于4连通或8连通区域的轮廓跟踪。 　　步骤1：首先按从上到下，从左到右的顺序扫描图象，寻找没有标记跟踪结束记号的第一个边界起始点A0...
边沿检测与提取，轮廓跟踪与Hough变换(转)
萧萧雨轩－－云计算/网格计算技术/智能仿生算法&算法优化/
07-19 4551
边沿检测与提取，轮廓跟踪首先,引入了模板操作。边沿检测我们给出一个模板 和一幅图象 。不难发现原图中左边暗，右边亮，中间存在着一条明显的边界。进行模板操作后的结果如下： 。可以看出，第3、4列比其他列的灰度值高很多，人眼观察时，就能发现一条很明显的亮边，其它区域都很暗，这样就起到了边沿检测的作用。为什么会这样呢？仔细看看那个模板就明白了，它的意思是将右邻点的灰度值减左
边缘检测和轮廓提取 (2).docx
11-10
。。。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值