图像处理之计算任意点与轮廓点集中距离最近的点坐标

最新推荐文章于 2024-07-11 22:02:56 发布
最新推荐文章于 2024-07-11 22:02:56 发布
阅读量5.1k 收藏 34
点赞数 17
分类专栏： 图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GK_2014/article/details/105477538
版权

opencv中计算任意一点P与轮廓C的距离很简单，可以直接调用pointPolygonTest函数获取，但是想要知道轮廓C中哪个点与点P的距离最近却没有现成的函数可用。

思路一：一个最朴实的想法就是获取以点P为中心，半径为r的圆的坐标点集，一步步增大半径r，直到圆上某一点Q在轮廓C上，即点Q就是我们需要找的点。考虑到效率问题，有两个地方可以优化一下：1>把轮廓C的点集额外保存成x坐标和y坐标作为键值的map结构中，在通过判断y坐标和x坐标是否相等快速查找；2>可以直接调用pointPolygonTest获取点P到轮廓C的距离d，然后直接让半径r从d开始增大，避免不必要的迭代。

其中一个需要解决的问题是怎么通过中心点P和半径r获取圆上所有点的集合？这个问题并不像表面上看起来那么简单，我自己写了个getCirclePts函数(参考了opencv的circle函数)，代码如下：

vector<Point> getCirclePts(Point center, int radius)
{
    vector<Point> ret;
    int err = 0, dx = radius, dy = 0, plus = 1, minus = (radius << 1) - 1;
    while(dx >= dy)
    {
        int mask;
        int y11 = center.y - dy, y12 = center.y + dy, y21 = center.y - dx, y22 = center.y + dx;
        int x11 = center.x - dx, x12 = center.x + dx, x21 = center.x - dy, x22 = center.x + dy;

        ret.push_back(Point(x11,y11));
        ret.push_back(Point(x11,y12));
        ret.push_back(Point(x12,y11));
        ret.push_back(Point(x12,y12));
        ret.push_back(Point(x21,y21));
        ret.push_back(Point(x21,y22));
        ret.push_back(Point(x22,y21));
        ret.push_back(Point(x22,y22));

        dy++;
        err += plus;
        plus += 2;
        mask = (err <= 0) - 1;
        err -= minus & mask;
        dx += mask;
        minus -= mask & 2;
    }
    return ret;
}

根据思路一写了份测试代码如下，把显示部分注释掉打印了在我笔记本上的每计算一次的执行时间大概200us。这个方法一个隐藏的缺点在于当点P与轮廓C距离较远时，需要获取以点P为中心的圆上点集数量比较多，再去遍历这些点判断是否在轮廓C上较为耗时。

void demo1()
{
    Mat srcImg = imread("/home/gk/program/C++/CalcDistance/test1.png", IMREAD_GRAYSCALE);
    Mat binaryImg;
    threshold(srcImg, binaryImg, 128, 255, CV_THRESH_BINARY);

    vector<vector<Point>> contours;
    findContours(binaryImg, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);

    vector<Point>& pts = contours[0];
    map<int,vector<Point>> pts_x,pts_y;
    for(auto pt : pts)
    {
        //将轮廓坐标保存成键值对的形式，便于查找
        pts_x[pt.x].push_back(pt);
        pts_y[pt.y].push_back(pt);
    }

    for(int x=0,y=0; x<srcImg.cols&&y<srcImg.rows; x+=2,y++)
    {
        Mat showImg;
        cvtColor(binaryImg, showImg, CV_GRAY2BGR);

        Point nearestPt;
        bool flag = false;

        int min_d = static_cast<int>(abs(pointPolygonTest(pts, Point(x,y), true)));
        int d = min_d;
        while(true)
        {
            vector<Point> points = getCirclePts(Point(x,y), d);
            //遍历圆上的点
            for(auto curPt : points)
            {    
                //判断该点是否也在轮廓上
                for(auto pt : pts_x[curPt.x])
                {
                    if(pt.y == curPt.y)
                    {
                        nearestPt = pt;
                        flag = true;
                        break;
                    }
                }
                if(flag) break;
            }
            if(flag) break;
            d++;
        }

        if(flag)
        {
            circle(showImg, nearestPt, 2, Scalar(0,0,255), 2);
        }

        circle(showImg, Point(x,y), 2, Scalar(0,255,0), 2);
        imshow("show", showImg);
        waitKey(50);
    }
}

思路二：将思路一中以点P为中心以圆的方式扩张改成以矩形的方式扩张，好处在于要描述圆的点集必须遍历圆上每一个点，而描述一个矩形只需要4个顶点就可以了。同样调用pointPolygonTest获取点P到轮廓C的距离d(需要找的点Q与给定点P的距离为d)，当点Q在矩形顶点时，此时矩形边长为(d/0.707)*2即可覆盖点Q，当点Q在矩形边长中心时，矩形边长d*2才能覆盖点Q，因此矩形的边长迭代范围确定好了，只需要在迭代过程中找到距离点P最小的轮廓C上的点即可。

代码如下，把显示部分注释掉打印了在我笔记本上的每计算一次的执行时间大概40us。

void demo2()
{
    Mat srcImg = imread("/home/gk/program/C++/CalcDistance/test1.png", IMREAD_GRAYSCALE);
    Mat binaryImg;
    threshold(srcImg, binaryImg, 128, 255, CV_THRESH_BINARY);

    vector<vector<Point>> contours;
    findContours(binaryImg, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);

    vector<Point>& pts = contours[0];
    map<int,vector<Point>> pts_x,pts_y;
    for(auto pt : pts)
    {
        pts_x[pt.x].push_back(pt);
        pts_y[pt.y].push_back(pt);
    }

    for(int x=0,y=0; x<srcImg.cols&&y<srcImg.rows; x+=2,y++)
    {
        Mat showImg;
        cvtColor(binaryImg, showImg, CV_GRAY2BGR);

        bool rectFlag = false;
        bool findFlag = false;
        Point nearestPt;
        int max_d = INT_MAX;
        double min_dist = DBL_MAX;

        double v = pointPolygonTest(pts, Point(x,y), true);
        int min_d = static_cast<int>(abs(0.707*distance));

        for(int d=min_d; d<max_d; d++)
        {
            //矩形的上下左右边界，分别判断这四条边界的情况
            int minx=x-d,maxx=x+d,miny=y-d,maxy=y+d;

            for(auto pt : pts_x[minx])
            {
                if(pt.y>=miny && pt.y<=maxy)
                {
                    double temp_d = sqrt(pow(pt.x-x,2)+pow(pt.y-y,2));
                    if(abs(temp_d-abs(distance)) < 0.01)
                    {
                        //当找到的点与点P的距离与distance基本一致时直接结束迭代
                        nearestPt = pt;
                        findFlag = true;
                        break;
                    }
                    if(!rectFlag)
                    {
                        //当矩形框首次覆盖到轮廓上的点时，确定max_d
                        rectFlag = true;
                        max_d = sqrt(pow(pt.x-x,2)+pow(pt.y-y,2))+0.5;
                    }
                    if(temp_d < min_dist)
                    {
                        min_dist = temp_d;
                        nearestPt = pt;
                    }
                }
            }
            if(findFlag) break;

            for(auto pt : pts_y[miny])
            {
                if(pt.x>=minx && pt.x<=maxx)
                {
                    double temp_d = sqrt(pow(pt.x-x,2)+pow(pt.y-y,2));
                    if(abs(temp_d-abs(distance)) < 0.01)
                    {
                        nearestPt = pt;
                        findFlag = true;
                        break;
                    }
                    if(!rectFlag)
                    {
                        rectFlag = true;
                        max_d = sqrt(pow(pt.x-x,2)+pow(pt.y-y,2))+0.5;
                    }
                    if(temp_d < min_dist)
                    {
                        min_dist = temp_d;
                        nearestPt = pt;
                    }
                }
            }
            if(findFlag) break;

            for(auto pt : pts_x[maxx])
            {
                if(pt.y>=miny && pt.y<=maxy)
                {
                    double temp_d = sqrt(pow(pt.x-x,2)+pow(pt.y-y,2));
                    if(abs(temp_d-abs(distance)) < 0.01)
                    {
                        nearestPt = pt;
                        findFlag = true;
                        break;
                    }
                    if(!rectFlag)
                    {
                        rectFlag = true;
                        max_d = sqrt(pow(pt.x-x,2)+pow(pt.y-y,2))+0.5;
                    }
                    if(temp_d < min_dist)
                    {
                        min_dist = temp_d;
                        nearestPt = pt;
                    }
                }
            }
            if(findFlag) break;

            for(auto pt : pts_y[maxy])
            {
                if(pt.x>=minx && pt.x<=maxx)
                {
                    double temp_d = sqrt(pow(pt.x-x,2)+pow(pt.y-y,2));
                    if(abs(temp_d-abs(distance)) < 0.01)
                    {
                        nearestPt = pt;
                        findFlag = true;
                        break;
                    }
                    if(!rectFlag)
                    {
                        rectFlag = true;
                        max_d = sqrt(pow(pt.x-x,2)+pow(pt.y-y,2))+0.5;
                    }
                    if(temp_d < min_dist)
                    {
                        min_dist = temp_d;
                        nearestPt = pt;
                    }
                }
            }
            if(findFlag) break;
        }

        if(findFlag || rectFlag)
        {
            circle(showImg, nearestPt, 2, Scalar(0,0,255), 2);
        }

        circle(showImg, Point(x,y), 2, Scalar(0,255,0), 2);
        imshow("show", showImg);
        waitKey(50);
    }
}

效果如下所示，绿点表示任意点P，红点表示找到的轮廓上最近的点Q

GK_2014
关注
  • 17
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
使用Python，OpenCV旋转图像任意角度（完整和局部丢失~）
qq_40985985的博客
06-19 9894
这篇博客将介绍如何使用OpenCV旋转图像。并演示如何使用imutils库中的两个方便函数imutils.rotate和imutils.rotate_bound不丢失细节的旋转图像。
在OpenCV里图像上的点与轮廓的测试
大坡3D软件开发
10-15 621
前面学习轮廓一些函数，接着继续学习图像上一点与轮廓的关系，主要使用cv.pointPolygonTest函数： dist = cv.pointPolygonTest(cnt,(50,50),True) 这行代码就是表示点（50，50）与轮廓cnt的最近距离。pointPolygonTest函数主要用来判断点与边缘最近的距离，如果第三个参数设置为True，返回数据表示点与边缘的实际距离，负数表示...
OpenCV实现快速近似最近邻（FLANN）
yt100323的博客
01-14 2633
高维数据的快速最近邻算法FLANN FLANN特征匹配
学习OpenCV——Surf（特征点篇）&flann
热门推荐
小熊不去实验室
04-20 5万+
Surf(Speed Up Robust Feature) Surf算法的原理                                                                            1.构建Hessian矩阵构造高斯金字塔尺度空间 其实surf构造的金字塔图像与sift有很大不同，就是因为这些不同才加快了其检测的速度。S
OpenCV 轮廓检测
weixin_33923148的博客
08-16 124
2019独角兽企业重金招聘Python工程师标准>>> ...
OpenCv案例(十二)：基于OpenCVSharp学习之模板匹配寻找距离中心位置最近的目标
qq_37835727的博客
05-17 1543
模板匹配 目标查找 寻找中心位置点 图像处理
opencv空间最近点搜索
W_AYF0726的博客
08-14 2034
#include "opencv2//flann/flann.hpp" #include "opencv2//flann/miniflann.hpp" #include "opencv2//flann/kdtree_index.h" #include "opencv2//flann/matrix.h" #include "opencv2//flann/miniflann.hpp" using...
Opencv(C++)笔记--cv::pointPolygonTest()判断点的位置
牵一只蜗牛去散步
01-02 2500
measureDist = flase时，内部返回+1，边缘返回0，外部返回-1；判断当前位置的点在多边形轮廓的相对位置，即内部、边缘和外部；measureDist = true时，返回的是有符号的距离；1--cv::pointPolygonTest()用途。
《数字图像处理》-（2）灰度变换与空间滤波&halcon代码
Guopinglu的博客
07-11 1377
1灰度变换 最简单的形式是邻域为1x1的尺度 (即一单个像素)。在这种情况下(仅依赖于f在(x，y)点的值，T操作成为灰度级变换函数(也叫做强度映射)，形式为： s=T® s和r是所定义的变量，分别是f(x，y)和g(x，y)在任意点(x，y)的灰度值。 1.1图像反转 灰度级范围为丨0，L-1丨的图像反转可由示于前图的反比变换获得，表达式为： s=L-1-r 用这种方式倒转图像的强度产生图像反转的对等图像。这种处理尤其适用于增强嵌入于图像暗色区域的白色或灰色细节，特别是当黑色面积占主导地位时: 1.2对
数字图像处理——第十章 图像分割
最新发布
weixin_46002351的博客
07-11 625
分割将图像细分为构成它的子区域或物体。形态学图像处理中，输入的是图像，输出的是从图像中提取出来的属性，分割是该方向上的另一步骤。分割将图像细分为构成它的子区域或物体，细分的程度取决于要解决的问题。多数分割算法均基于灰度值的两个基本性质之一：不连续性和相似性。对于不连续的灰度，方法是以灰度突变为基础分割一幅图像，比如图像的边缘。对于相似的灰度，主要方法是根据一组预定义的准则把一幅图像分割为相似的区域。阈值处理、区域生长、区域分割和区域聚合都是这类方法的例子。
OPENCV系列（一） 读取图像中任意点的像素值，并显示坐标
傲龙残雪
07-30 3万+
OPENCV系列（一） 读取图像中任意点的像素值，并显示坐标需求：在鼠标左键按下时，显示该位置的像素值和坐标。在vs2010下新建了Win32控制台项目#include "iostream" #include "cv.h" #include "highgui.h" #include "math.h"using namespace std;void mouseHandler(int event, in
数字图像处理(1)
Universalera的博客
10-27 6264
由于缺乏信号与系统的理论知识，学数字图像处理挺吃力的。看了课件还是有些一知半解，暂时整理了一些笔记。 第一章、绪论 一、数字图像： 自然界在人眼呈现的图像一般都是连续的模拟图像。对一幅静态非彩色图像可以表示成一个二维函数f(x,y)来表示，其中(x,y) 为空间或平面坐标（像素），f的幅度称亮度、强度或灰度级；当图像为彩色时，还应有波长的信息，表示为波长变量：f(x,y,λ)；如果是动态图像
计算点集中最近两点
08-15
计算平面点集中的最近点对，完整代码，VS开发！
【opencv学习之三十六】轮廓特征应用：计算点与轮廓距离
abcvincent的博客
02-06 5748
opencv实现了Contours与point的距离关系的计算使用起来很方便，不用自己再进行坐标转换计算了；示例代码如下： void imgContoursPoint()//26轮廓与点的距离计算 { //1.查找轮廓前的预处理 Mat srcImg = imread("D:/ImageTest/11.png"); Mat copyImg = srcImg.clone()
图像轮廓
shirley的专栏
09-07 345
opencv中提供findContours()函数来寻找图像中物体的轮廓，并结合drawContours()函数将找到的轮廓绘制出。首先看一下findContours(),opencv中提供了两种定义形式 findContours() void cv::findContours ( InputOutputArray image, OutputArrayOfArrays contours, ...
轮廓之间距离
jacke121的专栏
03-26 3751
点到轮廓的距离待测 import cv2 def point_contour_dist(img, hull, point, text, measure_dist=True): """点与轮廓hull的距离 :param img: 绘制结果图片 :param hull: 轮廓hull :param point: 计算的点 :param text: 文本距离 :param measure_dist: 计算结果方式 :return: 距离 ...
opencv_tutorial_code学习——pointPolygonTest计算点到轮廓的距离
LHHopencv的博客
12-28 1711
tutorial_code\ShapeDescriptors\pointPolygonTest_demo.cpp double pointPolygonTest(InputArray contour, Point2f pt, bool measureDist) 参数： contour            ---输入轮廓             pt      
【力扣算法题】找最近的坐标点
qq_44671773的博客
04-04 1126
【力扣算法题】找最近的坐标点
OpenCV Python – 如何找到图像中的点和轮廓之间的最短距离？
很酷的站长的博客
01-10 1453
我们可以使用计算图像上点和轮廓之间的最短距离，将轮廓点坐标和点坐标作为参数传递。在应用之前，我们需要计算图像中的轮廓。我们可以按照以下给定的步骤来找到给定点与图像中物体轮廓之间的最短距离-导入所需的库。在以下所有 Python 示例中，所需的 Python 库是确保您已经安装了它。使用读取输入图像。使用此方法读取的 RGB 图像采用 BGR 格式。（可选）将读取的 BGR 图像分配给 img。现在使用函数将此 BGR 图像转换为灰度图像，如下所示。（可选）将转换后的灰度图像指定为。
Java求两点的中点坐标_计算两点坐标距离与中点坐标
05-26
可以使用以下代码来计算两点的中点和两点之间的距离： ```java public class MidpointAndDistance { public static void main(String[] args) { // 第一个点的坐标 double x1 = 1.0; double y1 = 2.0; // 第二个点的坐标 double x2 = 4.0; double y2 = 6.0; // 计算两点的中点坐标 double midpointX = (x1 + x2) / 2; double midpointY = (y1 + y2) / 2; // 计算两点之间的距离 double distance = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2)); // 输出结果 System.out.println("中点坐标：(" + midpointX + ", " + midpointY + ")"); System.out.println("两点间距离：" + distance); } } ``` 输出结果为： ``` 中点坐标：(2.5, 4.0) 两点间距离：4.242640687119285 ``` 其中，`Math.sqrt()` 方法用于计算平方根，`Math.pow()` 方法用于计算次方。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值