距离计算

最新推荐文章于 2023-08-02 23:20:15 发布
最新推荐文章于 2023-08-02 23:20:15 发布
阅读量144 收藏
点赞数
分类专栏： 图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qingsong1001/article/details/108880890
版权

步骤：

1）从左到右，从上到下扫描

2）从右到左，从下到上扫描

 

#include <opencv2/highgui.hpp>
#include "opencv2/imgproc.hpp"
#include <iostream>
#include <fstream>

using namespace std;

#ifndef uint8
#define uint8 unsigned char
#endif

/*left mask *************************
*|AL|AL|
*|AL|P |
*|AL| 
*
****************************/
void leftTop_mask_move(cv::Mat &src, cv::Mat &distance)
{
    //firt line
    {
        uint8 *pcur = distance.ptr<uint8>(0);
        uint8 *pafter = distance.ptr<uint8>(1);
        for(int j = 1; j < distance.cols; j++)
        {
            uint8 *pmin = pcur+j;
            if((*(pcur+j -1)+1) < *pmin)
            {
                *pmin = *(pcur+j-1)+1;
            }
            if((*(pafter+j -1)+2) < *pmin)
            {
                *pmin = *(pafter+j-1)+2;
            }
        }
    }

    for(int i = 2; i < distance.rows; i++)
    {
        uint8 *pprev = distance.ptr<uint8>(i-2);
        uint8 *pcur = distance.ptr<uint8>(i-1);
        uint8 *pafter = distance.ptr<uint8>(i);
        for(int j = 0; j < distance.cols; j++)
        {
            uint8 *pmin = pcur+j;
            if(j == 0)
            {
                if((*(pprev+j)+1) < *pmin)
                {
                    *pmin = *(pprev+j)+1;
                }
            }
            else
            {
                if((*(pprev+j-1) + 2) < *pmin)
                {
                    *pmin = *(pprev+j-1) + 2;
                }
                if((*(pprev+j)+1) < *pmin)
                {
                    *pmin = *(pprev+j)+1;
                }
                if((*(pcur+j -1)+1) < *pmin)
                {
                    *pmin = *(pcur+j-1)+1;
                }
                if((*(pafter+j -1)+2) < *pmin)
                {
                    *pmin = *(pafter+j-1)+2;
                }
            }
        }
    }
    //last line
    {
        uint8 *pcur = distance.ptr<uint8>(distance.rows-1);
        uint8 *pprev= distance.ptr<uint8>(distance.rows-2);
        for(int j = 1; j < distance.cols; j++)
        {
            uint8 *pmin = pcur+j;
            if((*(pprev+j-1) + 2) < *pmin)
            {
                *pmin = *(pprev+j-1) + 2;
            }
            if((*(pprev+j)+1) < *pmin)
            {
                *pmin = *(pprev+j)+1;
            }
            if((*(pcur+j -1)+1) < *pmin)
            {
                *pmin = *(pcur+j-1)+1;
            }
        }
    }

    return;
}

/*right mask *************************
*   |BR|
*|P |BR|
*|BR|BR| 
*
****************************/
void rightTop_mask_move(cv::Mat &src, cv::Mat &distance)
{
    //last line
    {
        uint8 *pcur = distance.ptr<uint8>(distance.rows-1);
        uint8 *pprev= distance.ptr<uint8>(distance.rows-2);
        for(int j = 0; j < distance.cols-1; j++)
        {
            uint8 *pmin = pcur+j;
            if((*(pprev+j+1) + 2) < *pmin)
            {
                *pmin = *(pprev+j+1) + 2;
            }
            if((*(pcur+j + 1)+1) < *pmin)
            {
                *pmin = *(pcur+j+1)+1;
            }
        }
    }
    for(int i = distance.rows - 1 ; i > 1; i--)
    {
        uint8 *pprev = distance.ptr<uint8>(i-2);
        uint8 *pcur = distance.ptr<uint8>(i-1);
        uint8 *pafter = distance.ptr<uint8>(i);
        for(int j = 0; j < distance.cols; j++)
        {
            uint8 *pmin = pcur+j;
            if(j == (distance.cols-1))
            {
                if((*(pafter+j)+1) < *pmin)
                {
                    *pmin = *(pafter+j)+1;
                }
            }
            else
            {
                if((*(pafter+j+1) + 2) < *pmin)
                {
                    *pmin = *(pafter+j-1) + 2;
                }
                if((*(pafter+j)+1) < *pmin)
                {
                    *pmin = *(pafter+j)+1;
                }
                if((*(pcur+j+1)+1) < *pmin)
                {
                    *pmin = *(pcur+j+1)+1;
                }
                if((*(pprev+j+1)+2) < *pmin)
                {
                    *pmin = *(pprev+j+1)+2;
                }
            }
        }
    }
    //firt line
    {
        uint8 *pcur = distance.ptr<uint8>(0);
        uint8 *pafter = distance.ptr<uint8>(1);
        for(int j = 1; j < distance.cols; j++)
        {
            uint8 *pmin = pcur+j-1;
            if((*(pafter+j)+2) < *pmin)
            {
                *pmin = *(pafter+j)+2;
            }
            if((*(pcur+j)+1) < *pmin)
            {
                *pmin = *(pcur+j)+1;
            }
            if((*(pafter+j-1)+1) < *pmin)
            {
                *pmin = *(pafter+j-1)+1;
            }
        }
    }

    return;
}

int main(int argc, char* argv[])
{
    cv::Mat src, distance; 
    src.create(8,8, CV_8U); 
    distance.create(8,8, CV_8U); 
    for(int i = 0; i < distance.rows; i++)
    {
        uint8 *pTmp = distance.ptr<uint8>(i);
        uint8 *pSrc = src.ptr<uint8>(i);
        for(int j = 0; j < distance.cols; j++, pTmp++, pSrc++)
        {
            *pTmp = 0xf; 
            *pSrc = 0x0; 
            if(i == 0)
            {
                if(j == 6)
                {
                    *pTmp = 0x0; 
                    *pSrc = 0x1; 
                } 
            }
            if(i > 0 && i < 4)
            {
                if(j == 5)
                {
                    *pTmp = 0x0; 
                    *pSrc = 0x1; 
                } 
            }
            if(i == 4)
            {
                if(j==6 || j==1 || j==2)
                {
                    *pTmp = 0x0; 
                    *pSrc = 0x1; 
                } 
            }
            if(i == 5)
            {
                if(j==7 || j==1)
                {
                    *pTmp = 0x0; 
                    *pSrc = 0x1; 
                } 
            }
            if(i == 6 || i==7)
            {
                if(j==1)
                {
                    *pTmp = 0x0; 
                    *pSrc = 0x1; 
                } 
            }
        }
    }

    for(int i = 0; i < distance.rows; i++)
    {
        uint8 *pTmp = distance.ptr<uint8>(i);
        for(int j = 0; j < distance.cols; j++, pTmp++)
        {
            printf("%02x ", *pTmp);
        }
        printf("\n");
    }
    printf("\n");
    for(int i = 0; i < src.rows; i++)
    {
        uint8 *pSrc= src.ptr<uint8>(i);
        for(int j = 0; j < src.cols; j++, pSrc++)
        {
            printf("%02x ", *pSrc);
        }
        printf("\n");
    }
    printf("\n");
    leftTop_mask_move(src, distance);
    
    printf("after left top move\n");
    for(int i = 0; i < distance.rows; i++)
    {
        uint8 *pTmp = distance.ptr<uint8>(i);
        for(int j = 0; j < distance.cols; j++, pTmp++)
        {
            printf("%02x ", *pTmp);
        }
        printf("\n");
    }
    printf("\n");
    rightTop_mask_move(src, distance);

    for(int i = 0; i < distance.rows; i++)
    {
        uint8 *pTmp = distance.ptr<uint8>(i);
        for(int j = 0; j < distance.cols; j++, pTmp++)
        {
            printf("%02x ", *pTmp);
        }
        printf("\n");
    }
    printf("\n");

   return 0;
}

输出：

0f 0f 0f 0f 0f 0f 00 0f 
0f 0f 0f 0f 0f 00 0f 0f 
0f 0f 0f 0f 0f 00 0f 0f 
0f 0f 0f 0f 0f 00 0f 0f 
0f 00 00 0f 0f 0f 00 0f 
0f 00 0f 0f 0f 0f 0f 00 
0f 00 0f 0f 0f 0f 0f 0f 
0f 00 0f 0f 0f 0f 0f 0f 

00 00 00 00 00 00 01 00 
00 00 00 00 00 01 00 00 
00 00 00 00 00 01 00 00 
00 00 00 00 00 01 00 00 
00 01 01 00 00 00 01 00 
00 01 00 00 00 00 00 01 
00 01 00 00 00 00 00 00 
00 01 00 00 00 00 00 00 

after left top move
0f 0f 0f 0f 0f 0f 00 01 
0f 0f 0f 0f 0f 00 01 02 
0f 0f 0f 0f 0f 00 01 02 
0f 0f 02 02 03 00 01 02 
0f 00 00 01 02 01 00 01 
0f 00 01 02 03 02 01 00 
0f 00 01 02 03 03 02 01 
0f 00 01 02 03 04 03 02 

05 04 04 03 02 01 00 01 
04 03 03 04 01 00 01 02 
03 02 02 03 01 00 01 02 
02 01 01 02 01 00 01 02 
01 00 00 01 02 01 00 01 
01 00 01 02 03 02 01 00 
01 00 01 02 03 03 02 01 
01 00 01 02 03 04 03 02 

singing1001
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Halcon距离计算算子
qq_41234432的博客
04-27 5287
Halcon距离计算算子 1.distance_pp（点到点距离） 2.distance_pl （点到线距离） 3.distance_pr （点到区域距离） 4.distance_ss （线到线的距离） 5.distance_lr （线到区域距离）
常见距离计算方法
lian740930980的博客
02-25 6354
1、欧式距离(Euclidean Distance) 2、曼哈顿距离(Manhattan Distance) 不能直接走两点连接的直线，红、蓝、黄距离一样长 3、切比雪夫距离 (Chebyshev Distance) 国际象棋中，国王走一步可以移动到相邻8个方格中的任意一个，如下图。A到B的距离为红色线，需要走4步，和绿色线距离是相同的。 4、闵可夫斯基距离(Minkowski Distance) 闵氏距离不是一种距离，而是一组距离的定义，是对多个距离度量公式的概括性的表述。
欧式距离计算公式
热门推荐
Panpan Wei的博客
06-26 15万+
欧式距离也称欧几里得距离，是最常见的距离度量，衡量的是多维空间中两个点之间的绝对距离。 也可以理解为：m维空间中两个点之间的真实距离，或者向量的自然长度（即该点到原点的距离）。在二维和三维空间中的欧氏距离就是两点之间的实际距离 下面是具体的计算公式 ...
常见距离计算的Python实现
归去来兮的博客
08-02 2861
常见的距离有曼哈顿距离、欧式距离、切比雪夫距离、闵可夫斯基距离、汉明距离、余弦距离等，用Python实现计算的方式有多种，可以直接构造公式计算，也可以利用内置线性代数函数计算，还可以利用scipy库计算。
等效距离计算公式_实用的计算方法-架空输电线路导线线间距离计算
weixin_39631370的博客
12-24 3375
1. 10kV 及以下架空线路导线线间距离 380V及以下沿墙敷设的绝缘导线，当档距不大于20m时，其线间距离不宜小于0.2m；3kV以下架空线路，靠近杆塔的两导线间的水平距离不应小于0.5m；10kV及以下杆塔的最小线间距离如下表。笔者工作地主要属于山区，10kV线路实际档距比上表大许多，笔者根据GB 50061 7.0.3 中公式即参考第2部分35kV和66kV 架空线路导线线间距离计算公式计...
经纬度距离计算
12-14
基于Windows 下的qt开发程序，可以根据两地经纬度，计算出两点间的距离
Desktop_巴氏距离计算程序_
10-03
用于计算巴氏距离的matlab程序。输入是两个向量，输出是巴氏系数和巴氏距离。
距离计算工具
12-04
此工具只要输入两个点的经纬度就可以得到距离,可用于人工距离测量
雷达作用距离计算
12-28
有源雷达作用距离计算matlab程序，根据雷达方程，设定参数，计算作用作用距离
stereo calibration使用opencv获取图像rectification
qingsong1001的专栏
08-22 3684
使用opencv获取图像rectification 左右两张图像经过rectification后，会前向共面，也就是它们的主光轴平行，见“三角测量的前提的假设”。 该处理的源代码对应于opencv的sample的stereo_calib.cpp。 基本处理过程 基本处理过程分为两个部分，1)获取进行rectification所需要的map1和map2。 2)对每...
高斯噪声模拟
qingsong1001的专栏
10-02 1444
#include <stdio.h> #include <stdlib.h> #include <math.h> #include <opencv2/highgui.hpp> #include "opencv2/imgproc.hpp" #include <iostream> #include <fstream> #define PIXEL_MAX 255.f float get_float_0_1() { return ...
PGM格式的p5类型的双字节存储的读取操作，关于CV的第一篇博客，敬请指教
qingsong1001的专栏
07-30 1418
该文章是本人原创，可以转发分享，但希望标注本原创的链接，谢谢！ 关于PGM/PPM格式的描述文章很多，因此，基本知识咱就不多说了。只是关于p5类型的双字节的描述太少，我没有搜到，基于一些零碎的信息，对GPM格式的P5类型的双字节存储予以代码实现。 以下的代码可以正确运行的。 #include &lt;cv.h&gt; #include &lt;opencv2/highgui.hpp&gt; ...
平均旋转掩码平滑
qingsong1001的专栏
10-19 201
#include <stdio.h> #include <float.h> #include <cstdlib> #include <string> #include <opencv2/highgui.hpp> #include "opencv2/imgproc.hpp" #include <iostream> #include <fstream> void calc_disperse( cv::Mat &sr.
中值滤波
qingsong1001的专栏
10-20 155
#include <stdio.h> #include <float.h> #include <cstdlib> #include <string> #include <opencv2/highgui.hpp> #include "opencv2/imgproc.hpp" #include <iostream> #include <fstream> //using 5x5 window #define FILTER_..
直方图均衡化
qingsong1001的专栏
10-14 117
#include <stdio.h> #include <cstdlib> #include <string> #include <opencv2/highgui.hpp> #include "opencv2/imgproc.hpp" #include <iostream> #include <fstream> #define LIGHT_MAX 256 int main(int argc, char* argv[]) { ..
积分图
qingsong1001的专栏
10-13 110
#include <stdio.h> #include <cstdlib> #include <opencv2/highgui.hpp> #include "opencv2/imgproc.hpp" #include <iostream> #include <fstream> int main(int argc, char* argv[]) { int w = 0, h = 0; // string fileName = arg...
chromedriver-linux64-V124.0.6367.91 稳定版
最新发布
04-30
chromedriver-linux64-V124.0.6367.91稳定版
matlab距离计算
03-19
在MATLAB中，可以使用多种方法计算距离。以下是一些常用的距离计算方法： 1. 欧氏距离（Euclidean Distance）：欧氏距离是最常见的距离度量方法，它衡量两个点之间的直线距离。在MATLAB中，可以使用`pdist2`函数来计算欧氏距离。 2. 曼哈顿距离（Manhattan Distance）：曼哈顿距离是指两个点在标准坐标系上的绝对轴距总和。在MATLAB中，可以使用`pdist2`函数，并将参数设置为`'cityblock'`来计算曼哈顿距离。 3. 切比雪夫距离（Chebyshev Distance）：切比雪夫距离是指两个点在各个坐标轴上的差值的最大绝对值。在MATLAB中，可以使用`pdist2`函数，并将参数设置为`'chebychev'`来计算切比雪夫距离。 4. 闵可夫斯基距离（Minkowski Distance）：闵可夫斯基距离是欧氏距离和曼哈顿距离的一种推广，可以通过调整参数来控制距离的计算方式。在MATLAB中，可以使用`pdist2`函数，并将参数设置为`'minkowski'`来计算闵可夫斯基距离。 5. 马氏距离（Mahalanobis Distance）：马氏距离考虑了数据的协方差矩阵，可以用于处理具有相关性的数据。在MATLAB中，可以使用`mahal`函数来计算马氏距离。 这些是MATLAB中常用的距离计算方法，你可以根据具体的需求选择适合的方法进行计算。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值