【SLAM】双目图像视差图填充

最新推荐文章于 2024-07-09 22:37:42 发布
最新推荐文章于 2024-07-09 22:37:42 发布
阅读量893 收藏 14
点赞数 2
分类专栏： SLAM 文章标签： c++ 算法 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Valeni/article/details/126409053
版权

由于不同视角的遮挡或者错误的匹配，经过SGBM算法计算的视差图存在一些无效区。为了获得稠密的视差图，或者对关键点的无效视差进行近似，我们需要填充这些无效区。
请添加图片描述
这些乌漆嘛黑的区域就是需要填充的无效区

这里不讨论遮挡与误匹配的判定，有需要请移步大佬的博客：
【码上实战】【立体匹配系列】经典SGM：（6）视差填充
这篇博客也提供了视差填充的方法和代码，我这里提供原理上更简易（简陋）的实现

等角度往外发射8条射线进行采样，计算均值

在这里插入图片描述

原理很简单，直接放代码，就是写的很丑。。。

#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>

using namespace std;

int main()
{
    cv::Mat image = cv::imread("../disparity/000000.png", 0);
    const int width = image.cols;
    const int height = image.rows;
    cv::Mat newImage = cv::Mat::zeros(cv::Size(width, height), CV_8UC1);
    std::vector<float> disp_collects;
    for(int col = 0; col < width; ++col)
    {
        for(int row = 0; row < height; ++row)
        {
            // cout << "col: " << col << ", row: " << row << endl;
            if(image.at<uchar>(row, col) == 0)
            {
               int usefulPoint = 0, sumPixel = 0;
               int v = col, u = row;
               // 0
               while(v < width)
               {
                   ++v;
                   if(image.at<uchar>(u, v) > 0)
                   {
                       sumPixel += image.at<uchar>(u, v);
                       ++usefulPoint;
                       break;
                   }
               }

               // pi/4
               v = col, u = row;
               while(v < width && u < height)
               {
                   ++v;
                   ++u;
                   if(image.at<uchar>(u, v) > 0)
                   {
                       sumPixel += image.at<uchar>(u, v);
                       ++usefulPoint;
                       break;
                   }
               }

                // pi/2
                v = col, u = row;
                while(u < height)
                {
                    ++u;
                    if(image.at<uchar>(u, v) > 0)
                    {
                        sumPixel += image.at<uchar>(u, v);
                        ++usefulPoint;
                        break;
                    }
                }

                // pi*3/4
                v = col, u = row;
                while(v > 0 && u < height)
                {
                    --v;
                    ++u;
                    if(image.at<uchar>(u, v) > 0)
                    {
                        sumPixel += image.at<uchar>(u, v);
                        ++usefulPoint;
                        break;
                    }
                }

                // pi
                v = col, u = row;
                while(v > 0)
                {
                    --v;
                    if(image.at<uchar>(u, v) > 0)
                    {
                        sumPixel += image.at<uchar>(u, v);
                        ++usefulPoint;
                        break;
                    }
                }

                // pi*5/4
                v = col, u = row;
                while(v > 0 && u > 0)
                {
                    --v;
                    --u;
                    if(image.at<uchar>(u, v) > 0)
                    {
                        sumPixel += image.at<uchar>(u, v);
                        ++usefulPoint;
                        break;
                    }
                }

                // pi*3/2
                v = col, u = row;
                while(u > 0)
                {
                    --u;
                    if(image.at<uchar>(u, v) > 0)
                    {
                        sumPixel += image.at<uchar>(u, v);
                        ++usefulPoint;
                        break;
                    }
                }

                // pi*7/4
                v = col, u = row;
                while(v < width && u > 0)
                {
                    ++v;
                    --u;
                    if(image.at<uchar>(u, v) > 0)
                    {
                        sumPixel += image.at<uchar>(u, v);
                        ++usefulPoint;
                        break;
                    }
                }
                // cout << sumPixel / usefulPoint << " and " << (unsigned char)(sumPixel / usefulPoint) << endl;
                newImage.at<uchar>(row, col) = (unsigned char)(sumPixel / usefulPoint);
            }
            else newImage.at<uchar>(row, col) = image.at<uchar>(row, col);
        }
    }
    cv::Mat saveImage;
    cv::medianBlur(newImage, saveImage, 3);
    cv::imwrite("../test.png", saveImage);
    return 0;
}

请添加图片描述
这是用这种方法填充的效果，一片原本的无效区域内的值都差不多，缺乏过渡
在这里插入图片描述

等角度往外发射8条射线进行采样，进行线性插值

为了获取有更好过渡的视差填充，可以在采样后做4次简单的单线性插值，再算平均值
首先把8个方向的射线分为4组，0和π，π/4和5π/4，π/2和3π/2, 3π/4和7π/4
这4组方向都在一条直线上，对这条直线的两个端点进行采样插值，可以使填充的过渡效果更好一些
这里再简单推导一下单线性插值的算法：
请添加图片描述
代码如下：

#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
#include "math.h"

using namespace std;

int main()
{
    cv::Mat image = cv::imread("../disparity/000000.png", 0);
    const int width = image.cols;
    const int height = image.rows;
    cv::Mat newImage = cv::Mat::zeros(cv::Size(width, height), CV_8UC1);
    bool flag = false;
    for(int col = 0; col < width; ++col)
    {
        for(int row = 0; row < height; ++row)
        {
            cout << "col: " << col << ", row: " << row << endl;
            if(image.at<uchar>(row, col) == 0)
            {
               double sumPixel = 0;
               double x;
               int v = col, u = row;
               int y_1, y_2, x_length;
               int coordX_1, coordX_2, coordY_1, coordY_2;

               // Group 1 --------------------------------------------------------------------------------------
               // 0
               flag = false;
               while(v < width)
               {
                   ++v;
                   if(image.at<uchar>(u, v) > 0)
                   {
                       y_1 = image.at<uchar>(u, v);
                       flag = true;
                       break;
                   }
               }
               if(!flag) y_1 = 0;
               coordX_1 = v;
               coordY_1 = u;

                // pi
                flag = false;
                v = col, u = row;
                while(v > 0)
                {
                    --v;
                    if(image.at<uchar>(u, v) > 0)
                    {
                        y_2 = image.at<uchar>(u, v);
                        flag = true;
                        break;
                    }
                }
                if(!flag) y_2 = 0;
                coordX_2 = v;
                coordY_2 = u;

                // compute line 1
                x_length = sqrt(pow((coordX_2 - coordX_1), 2) + pow((coordY_2 - coordY_1), 2));
                x = sqrt(pow((col - coordX_1), 2) + pow((row - coordY_1), 2)) / x_length;
                sumPixel += (1 - x) * (y_1 - y_2) + y_2;
//                cout << "col: " << col << ", row: " << row << ", coordX_1: " << coordX_1 << ", coordY_1: " << coordY_1 << ", coordX_2: " << coordX_2 << ", coordY_2: " << coordY_2 << endl;
//                cout << "x_length: " << x_length << ", x: " << x << ", y_1: " << y_1 << ", y_2: " << y_2 << endl;
//                cout << "result: " << (1 - x) * (y_1 - y_2) + y_2 << endl;

                // Group 2 --------------------------------------------------------------------------------------
                // pi/4
                flag = false;
                v = col, u = row;
                while(v < width && u < height)
                {
                    ++v;
                    ++u;
                    if(image.at<uchar>(u, v) > 0)
                    {
                        y_1 = image.at<uchar>(u, v);
                        flag = true;
                        break;
                    }
                }
                if(!flag) y_1 = 0;
                coordX_1 = v;
                coordY_1 = u;

                // pi*5/4
                flag = false;
                v = col, u = row;
                while(v > 0 && u > 0)
                {
                    --v;
                    --u;
                    if(image.at<uchar>(u, v) > 0)
                    {
                        y_2 = image.at<uchar>(u, v);
                        flag = true;
                        break;
                    }
                }
                if(!flag) y_2 = 0;
                coordX_2 = v;
                coordY_2 = u;

                // compute line 2
                x_length = sqrt(pow((coordX_2 - coordX_1), 2) + pow((coordY_2 - coordY_1), 2));
                x = sqrt(pow((col - coordX_1), 2) + pow((row - coordY_1), 2)) / x_length;
                sumPixel += (1 - x) * (y_1 - y_2) + y_2;

                // Group 3 --------------------------------------------------------------------------------------
                // pi/2
                flag = false;
                v = col, u = row;
                while(u < height)
                {
                    ++u;
                    if(image.at<uchar>(u, v) > 0)
                    {
                        y_1 = image.at<uchar>(u, v);
                        flag = true;
                        break;
                    }
                }
                if(!flag) y_1 = 0;
                coordX_1 = v;
                coordY_1 = u;

                // pi*3/2
                flag = false;
                v = col, u = row;
                while(u > 0)
                {
                    --u;
                    if(image.at<uchar>(u, v) > 0)
                    {
                        y_2 = image.at<uchar>(u, v);
                        flag = true;
                        break;
                    }
                }
                if(!flag) y_2 = 0;
                coordX_2 = v;
                coordY_2 = u;

                // compute line 3
                x_length = sqrt(pow((coordX_2 - coordX_1), 2) + pow((coordY_2 - coordY_1), 2));
                x = sqrt(pow((col - coordX_1), 2) + pow((row - coordY_1), 2)) / x_length;
                sumPixel += (1 - x) * (y_1 - y_2) + y_2;

                // Group 4 --------------------------------------------------------------------------------------
                // pi*3/4
                v = col, u = row;
                flag = false;
                while(v > 0 && u < height)
                {
                    --v;
                    ++u;
                    if(image.at<uchar>(u, v) > 0)
                    {
                        y_1 = image.at<uchar>(u, v);
                        flag = true;
                        break;
                    }
                }
                if(!flag) y_1 = 0;
                coordX_1 = v;
                coordY_1 = u;

                // pi*7/4
                v = col, u = row;
                flag = false;
                while(v < width && u > 0)
                {
                    ++v;
                    --u;
                    if(image.at<uchar>(u, v) > 0)
                    {
                        y_2 = image.at<uchar>(u, v);
                        flag = true;
                        break;
                    }
                }
                if(!flag) y_2 = 0;
                coordX_2 = v;
                coordY_2 = u;

                // compute line 4
                x_length = sqrt(pow((coordX_2 - coordX_1), 2) + pow((coordY_2 - coordY_1), 2));
                x = sqrt(pow((col - coordX_1), 2) + pow((row - coordY_1), 2)) / x_length;
                sumPixel += (1 - x) * (y_1 - y_2) + y_2;

                // cout << sumPixel / usefulPoint << " and " << (unsigned char)(sumPixel / usefulPoint) << endl;
                newImage.at<uchar>(row, col) = (unsigned char)(sumPixel / 4);
            }
            else newImage.at<uchar>(row, col) = image.at<uchar>(row, col);
        }
    }
    cv::Mat saveImage;
    cv::medianBlur(newImage, saveImage, 3);
    cv::imwrite("../test.png", saveImage);
    return 0;
}

效果如下：
在这里插入图片描述
可以看到过渡好了一些
在这里插入图片描述

Valeni
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
立体匹配得到的视差图孔洞填充
opencv_fjc的博客
07-18 7198
void insertDepth32f(cv::Mat& depth) { const int width = depth.cols; const int height = depth.rows; float* data = (float*)depth.data; cv::Mat integralMap = cv::Mat::zeros(height, w...
SAD法（附python实现）和Siamese神经网络计算图像的视差图
PLUS_WAVE的博客
03-30 1338
原理：是在给定窗口大小的情况下，对左图像和右图像的对应窗口进行比较，计算它们之间的绝对差的总和，从而确定最佳匹配的视差。利用图像卷积的思想，通过对每个候选视差值计算绝对差图像，并将其与一个均值滤波器进行卷积操作来实现视差图的计算。视差图：以左视图视差图为例，在像素位置p的视差值等于该像素在右图上的匹配点的列坐标减去其在左图上的列坐标。局部窗口匹配：块匹配方法通常只考虑局部窗口内的像素信息进行匹配，而对于同质区域，局部窗口内的。计算左图像窗口和右图像匹配窗口的绝对差的总和，即SAD值。
双目立体成像（三）视差图空洞填充
qq_62964142的博客
10-25 641
采用多层次滤波填补空洞
【码上实战】【立体匹配系列】经典SGM：（6）视差填充
热门推荐
闲情逸致~
05-03 1万+
SemiGlobalMatching（SGM），立体匹配经典算法，编码实战教学！
三维重构（7）：双目立体视觉梳理（细节处理，算法理解）
TiffanyXYf的博客
01-03 1266
三维重构学习笔记（7）：双目立体视觉梳理（细节处理，算法理解） 在上一篇博客中，遗留下来以下问题： 视差图填充，视差图格式，深度范围限制（防止出现inf出现，导致视图显示不完整），视差图转色温图（为了显示好看） 另外，在保存视差图的时候发现：视差图的精度会受格式的影响，有的博主说可以将视差图同意保存xml类型的数据。 还有SGBM算法是怎么工作的？如何计算得到视差的，函数可以随意调用，但是参数设...
OpenCV3.4两种立体匹配算法效果对比
weixin_30568591的博客
01-19 970
以OpenCV自带的Aloe图像对为例： 1.BM算法（Block Matching） 参数设置如下： int numberOfDisparities = ((imgSize.width / 8) + 15) & -16; cv::Ptr<cv::StereoBM> bm = cv::StereoBM::create(16, 9); ...
双目立体视差图进行三维点云重建【OpenCV3.4.1+PCL1.8】
02-01
首先，双目立体视觉是通过两个摄像头捕捉到的图像差异来计算出场景中每个像素的深度信息，即视差图。视差图的每一个像素值代表对应点在左右两幅图像中的水平偏移，这个偏移量可以转换为距离信息。`disp0.pfm`和`disp...
基于深度图像的SLAM实现
09-18
在本项目"基于深度图像的SLAM实现"中，我们关注的是使用RGB-D相机进行SLAM的方法。RGB-D相机能同时提供彩色图像和深度信息，为三维建模提供了便利。 1. **RGB-D数据处理**：RGB-D数据包括彩色图像和对应的深度图像...
SLAM-基于RGB-D相机的SLAM密集图像视觉测距-优质项目实战.zip
02-20
本项目实战主要聚焦于使用RGB-D相机进行SLAM，尤其是密集图像视觉测距的应用。RGB-D相机能够同时提供彩色图像和深度信息，为SLAM算法提供了丰富的数据源。 首先，我们需要理解RGB-D相机的工作原理。这种相机通过...
SLAM 双目DSO+IMU 论文
03-01
双目DSO+IMU 论文下载，供研究DSO 的读者使用，欢迎下载！
基于点线综合特征的双目视觉SLAM方法.pdf_vslam_slam_双目slam_
09-30
双目SLAM是SLAM的一种重要实现方式，通过两个摄像头获取的立体图像来计算场景的三维结构和自身的位置。本文将深入探讨一种结合点特征和线特征的双目视觉SLAM方法，以提升系统的鲁棒性和精度。 传统的双目SLAM主要...
【三维重建补充知识-0】视差、深度概念及其转换
Liverwhles
11-28 6395
对于三维视觉当中“视差”这一概念的知识补充
双目立体视觉——视差图（stereo matching）三种相似度算法实现
lingying77的博客
10-24 3080
双目立体视觉——视差图生成
三维重建之视图差的计算--SGBM和GC算法
blank_screen的博客
04-15 8712
最近一直在做三维重建的毕业设计，看了好多的算法、论文和代码。在查找资料的过程中发现很多人上传的东西真的是没法用，而且全都要积分。我虽说是一个水货，也不致力于从事着方面的研究和工作，但是为了毕设也没办法，目前调通了很多算法，虽然说不清原理，但是还是把代码创传上来，供大家使用。 一、win32项目工程，stereo vision1 1、头文件： #include "stdafx.h" #
立体匹配基础：视差图、深度图、点云
3D视觉工坊
06-01 8739
作者丨李迎松@知乎来源丨https://zhuanlan.zhihu.com/p/522285892编辑丨3D视觉工坊本篇是比较简单的基础概念，刚入门的朋友可能是需要的。视差图点云首先，我们要介绍下这三个概念。视差（disparity）深度（depth）深度D等于像素在该视图相机坐标系下Z坐标，是空间单位。深度并不特在校正后的图像对里使用，而是任意图像都可获取深度图。视差...
python opencv双目相机标定_python+openCV实现双目视差图及测距
weixin_39619433的博客
11-28 1127
importcv2importnumpy as npimportstereoconfigdefgetRectifyTransform(height, width, config):#读取矩阵参数left_K =config.cam_matrix_leftright_K=config.cam_matrix_rightleft_distortion=config.distortion_lright_d...
C++初探究（2）
最新发布
Frenemy__的博客
07-09 737
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 611
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
ORB-SLAM2图像预处理
05-11
6. 双目匹配：如果输入是双目图像，ORB-SLAM2会对左右两幅图像进行匹配，以得到每个关键点在右图上的对应点。 以上是ORB-SLAM2的图像预处理过程，它们都是为了提取尽可能多的稳定特征点，以便后续的视觉SLAM过程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值