双目视觉 立体匹配

最新推荐文章于 2024-06-03 15:38:35 发布
最新推荐文章于 2024-06-03 15:38:35 发布
阅读量676 收藏 11
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/miahhrgbfcyur/article/details/103263314
版权

双目相机的内参外参：
双目相机的四个坐标系：
双目相机矫正：
双目相机用公式推导法求深度图（需要视差）
双目相机求视差的算法：SAD匹配算法、BM算法、SGBM算法、GC算法等
https://www.cnblogs.com/zyly/p/9373991.html
https://www.cnblogs.com/riddick/p/8486223.html
https://www.cnblogs.com/paladinzxl/p/9366670.html
立体匹配相关代码：
https://www.cnblogs.com/polly333/p/5130375.html
sad算法：最简单的思路。。。。
https://www.cnblogs.com/Crazy-Dog123/articles/5043864.html
关于视差图的理解：
https://blog.csdn.net/cyem1/article/details/80736878
sad：

//
//  main.cpp
//  bioversion
//
//  Created by w e il a n lin on 2019/12/10.
//  Copyright © 2019 w e il a n lin. All rights reserved.
//

#include<iostream>
#include<opencv/cv.h>
#include<opencv2/highgui/highgui.hpp>

using namespace std;
int GetHammingWeight(unsigned int value);
int main(){
    /*Half of the window size for the census transform*/
    int hWin = 11;
    int compareLength = (2*hWin+1)*(2*hWin+1);

    cout<<"hWin: "<<hWin<<";  "<<"compare length:  "<<compareLength<<endl;
    cout<<"SAD test"<<endl;
    // char stopKey;
    IplImage * leftImage = cvLoadImage("/Users/weilanlin/Desktop/bioversion/bioversion/l.png",0);
    IplImage * rightImage = cvLoadImage("/Users/weilanlin/Desktop/bioversion/bioversion/r.png",0);

    int imageWidth = leftImage->width;
    int imageHeight =leftImage->height;

    IplImage * SADImage = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);
    IplImage * MatchLevelImage = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);

    int minDBounds = 0;
    int maxDBounds = 31;

    cvNamedWindow("Left",1);
    cvNamedWindow("Right",1);
    cvNamedWindow("Census",1);
    cvNamedWindow("MatchLevel",1);

    cvShowImage("Left",leftImage);
    cvShowImage("Right",rightImage);



    /*Census Transform */
    int i,j ,m,n,k;
    unsigned char centerPixel = 0;
    unsigned char neighborPixel = 0;
    int bitCount = 0;
    unsigned int bigger = 0;



    int sum = 0;
    unsigned int *matchLevel = new unsigned int[maxDBounds - minDBounds  + 1];
    int tempMin = 0;
    int tempIndex = 0;

    unsigned char* dst;
    unsigned char* leftSrc  = NULL;
    unsigned char* rightSrc = NULL;

    unsigned char leftPixel = 0;
    unsigned char rightPixel =0;
    unsigned char subPixel = 0;


    for(i = 0 ; i < leftImage->height;i++){
        for(j = 0; j< leftImage->width;j++){

            for (k = minDBounds;k <= maxDBounds;k++)
            {
                sum = 0;
                for (m = i-hWin; m <= i + hWin;m++)
                {
                    for (n = j - hWin; n <= j + hWin;n++)
                    {
                          if (m < 0 || m >= imageHeight || n <0 || n >= imageWidth )
                          {
                              subPixel  = 0;
                          }else if (n + k >= imageWidth)
                          {
                              subPixel = 0;
                          }else
                          {
                              leftSrc = (unsigned char*)leftImage->imageData
                                          + m*leftImage->widthStep + n + k;
                              rightSrc = (unsigned char*)rightImage->imageData
                                           + m*rightImage->widthStep + n;

                              leftPixel = *leftSrc;
                              rightPixel = *rightSrc;
                              if (leftPixel > rightPixel)
                              {
                                   subPixel = leftPixel - rightPixel;
                              }else
                              {
                                   subPixel = rightPixel -leftPixel;
                              }

                          }

                          sum += subPixel;
                    }
                }
                matchLevel[k] = sum;
                //cout<<sum<<endl;
            }

            /*寻找最佳匹配点*/
           // matchLevel[0] = 1000000;

            tempMin = 0;
            tempIndex = 0;
            for ( m = 1;m < maxDBounds - minDBounds + 1;m++)
            {
                //cout<<matchLevel[m]<<endl;
                if (matchLevel[m] < matchLevel[tempIndex])
                {
                    tempMin = matchLevel[m];
                    tempIndex = m;
                }
            }
            dst = (unsigned char *)SADImage->imageData + i*SADImage->widthStep + j;
            //cout<<"index: "<<tempIndex<<"  ";

            *dst = tempIndex*8;

            dst = (unsigned char *)MatchLevelImage->imageData + i*MatchLevelImage->widthStep + j;
            *dst = tempMin;
            //cout<<"min:  "<<tempMin<<"  ";
            //cout<< tempIndex<<"  " <<tempMin<<endl;
        }
        //cvWaitKey(0);
    }

    cvShowImage("Census",SADImage);
    cvShowImage("MatchLevel",MatchLevelImage);
    cvSaveImage("depth.jpg",SADImage);
    cvSaveImage("matchLevel.jpg",MatchLevelImage);

    cvWaitKey(0);
    cvDestroyAllWindows();
    cvReleaseImage(&leftImage);
    cvReleaseImage(&rightImage);
    return 0;
}

ssd:

在这里插入代码片

#include
#include<opencv/cv.h>
#include<opencv2/highgui/highgui.hpp>

using namespace std;
int GetHammingWeight(unsigned int value);
int main(){
/Half of the window size for the census transform/
int hWin = 11;
int compareLength = (2hWin+1)(2*hWin+1);

cout<<"hWin: "<<hWin<<";  "<<"compare length:  "<<compareLength<<endl;
cout<<"SAD test"<<endl;
// char stopKey;
IplImage * leftImage = cvLoadImage("/Users/weilanlin/Desktop/bioversion/bioversion/l.png",0);
IplImage * rightImage = cvLoadImage("/Users/weilanlin/Desktop/bioversion/bioversion/r.png",0);

int imageWidth = leftImage->width;
int imageHeight =leftImage->height;

IplImage * SADImage = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);
IplImage * MatchLevelImage = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);

int minDBounds = 0;
int maxDBounds = 31;

cvNamedWindow("Left",1);
cvNamedWindow("Right",1);
cvNamedWindow("Census",1);
cvNamedWindow("MatchLevel",1);

cvShowImage("Left",leftImage);
cvShowImage("Right",rightImage);



/*Census Transform */
int i,j ,m,n,k;
unsigned char centerPixel = 0;
unsigned char neighborPixel = 0;
int bitCount = 0;
unsigned int bigger = 0;



int sum = 0;
unsigned int *matchLevel = new unsigned int[maxDBounds - minDBounds  + 1];
int tempMin = 0;
int tempIndex = 0;

unsigned char* dst;
unsigned char* leftSrc  = NULL;
unsigned char* rightSrc = NULL;

unsigned char leftPixel = 0;
unsigned char rightPixel =0;
unsigned char subPixel = 0;


for(i = 0 ; i < leftImage->height;i++){
    for(j = 0; j< leftImage->width;j++){

        for (k = minDBounds;k <= maxDBounds;k++)
        {
            sum = 0;
            for (m = i-hWin; m <= i + hWin;m++)
            {
                for (n = j - hWin; n <= j + hWin;n++)
                {
                      if (m < 0 || m >= imageHeight || n <0 || n >= imageWidth )
                      {
                          subPixel  = 0;
                      }else if (n + k >= imageWidth)
                      {
                          subPixel = 0;
                      }else
                      {
                          leftSrc = (unsigned char*)leftImage->imageData
                                      + m*leftImage->widthStep + n + k;
                          rightSrc = (unsigned char*)rightImage->imageData
                                       + m*rightImage->widthStep + n;

                          leftPixel = *leftSrc;
                          rightPixel = *rightSrc;
                          if (leftPixel > rightPixel)
                          {
                               subPixel = leftPixel - rightPixel;
                          }else
                          {
                               subPixel = rightPixel -leftPixel;
                          }

                      }

                      sum += subPixel*subPixel;
                }
            }
            matchLevel[k] = sum;
            //cout<<sum<<endl;
        }

        /*寻找最佳匹配点*/
       // matchLevel[0] = 1000000;

        tempMin = 0;
        tempIndex = 0;
        for ( m = 1;m < maxDBounds - minDBounds + 1;m++)
        {
            //cout<<matchLevel[m]<<endl;
            if (matchLevel[m] < matchLevel[tempIndex])
            {
                tempMin = matchLevel[m];
                tempIndex = m;
            }
        }
        dst = (unsigned char *)SADImage->imageData + i*SADImage->widthStep + j;
        //cout<<"index: "<<tempIndex<<"  ";

        *dst = tempIndex*8;

        dst = (unsigned char *)MatchLevelImage->imageData + i*MatchLevelImage->widthStep + j;
        *dst = tempMin;
        //cout<<"min:  "<<tempMin<<"  ";
        //cout<< tempIndex<<"  " <<tempMin<<endl;
    }
    //cvWaitKey(0);
}

cvShowImage("Census",SADImage);
cvShowImage("MatchLevel",MatchLevelImage);
cvSaveImage("depth.jpg",SADImage);
cvSaveImage("matchLevel.jpg",MatchLevelImage);

cvWaitKey(0);
cvDestroyAllWindows();
cvReleaseImage(&leftImage);
cvReleaseImage(&rightImage);
return 0;

}
zssd:

#include<iostream>
#include<opencv/cv.h>
#include<opencv2/highgui/highgui.hpp>

using namespace std;
int GetHammingWeight(unsigned int value);
int main(){
    /*Half of the window size for the census transform*/
    int hWin = 11;
    int compareLength = (2*hWin+1)*(2*hWin+1);

    cout<<"hWin: "<<hWin<<";  "<<"compare length:  "<<compareLength<<endl;
    cout<<"ZSSD test"<<endl;
    // char stopKey;
  /*  IplImage * leftImage = cvLoadImage("l2.jpg",0);
    IplImage * rightImage = cvLoadImage("r2.jpg",0);*/

    IplImage * leftImage = cvLoadImage("/Users/weilanlin/Desktop/bioversion/bioversion/l.png",0);
    IplImage * rightImage = cvLoadImage("/Users/weilanlin/Desktop/bioversion/bioversion/r.png",0);

    int imageWidth = leftImage->width;
    int imageHeight =leftImage->height;

    IplImage * SADImage = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);
    IplImage * MatchLevelImage = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);

    int minDBounds = 0;
    int maxDBounds = 31;

    cvNamedWindow("Left",1);
    cvNamedWindow("Right",1);
    cvNamedWindow("Census",1);
    cvNamedWindow("MatchLevel",1);

    cvShowImage("Left",leftImage);
    cvShowImage("Right",rightImage);



    /*Census Transform */
    int i,j ,m,n,k;
    unsigned char centerPixel = 0;
    unsigned char neighborPixel = 0;
    int bitCount = 0;
    unsigned int bigger = 0;



    int sumLeft = 0;
    int sumRight = 0;
    int sum =0;

    int zSumLeft  = 0;
    int zSumRight = 0;

    unsigned int *matchLevel = new unsigned int[maxDBounds - minDBounds  + 1];
    int tempMin = 0;
    int tempIndex = 0;

    unsigned char* dst;
    unsigned char* leftSrc  = NULL;
    unsigned char* rightSrc = NULL;

    unsigned char leftPixel = 0;
    unsigned char rightPixel =0;
    unsigned char subPixel = 0;
    unsigned char meanLeftPixel  = 0;
    unsigned char meanRightPixel = 0;


    for(i = 0 ; i < leftImage->height;i++){
        for(j = 0; j< leftImage->width;j++){

            /*均值计算 */
            for (k = minDBounds;k <= maxDBounds;k++)
            {
                sumLeft  = 0;
                sumRight = 0;
                for (m = i-hWin; m <= i + hWin;m++)
                {
                    for (n = j - hWin; n <= j + hWin;n++)
                    {
                          if (m < 0 || m >= imageHeight || n <0 || n >= imageWidth )
                          {
                              sumLeft += 0;
                          }else {
                              leftSrc = (unsigned char*)leftImage->imageData
                                  + m*leftImage->widthStep + n + k;
                              leftPixel = *leftSrc;
                              sumLeft += leftPixel;
                          }


                          if (m < 0 || m >= imageHeight || n + k <0 || n +k >= imageWidth)
                          {
                               sumRight += 0;
                          }else
                          {
                              rightSrc = (unsigned char*)rightImage->imageData
                                           + m*rightImage->widthStep + n;
                              rightPixel = *rightSrc;
                              sumRight += rightPixel;
                          }

                    }
                }

                meanLeftPixel  = sumLeft/compareLength;
                meanRightPixel = sumRight/compareLength;
                 /*ZSSD*/
               sum = 0;
                 for (m = i-hWin; m <= i + hWin;m++)
                {
                    for (n = j - hWin; n <= j + hWin;n++)
                    {
                          if (m < 0 || m >= imageHeight || n <0 || n >= imageWidth )
                          {
                              //zSumLeft += 0;
                              leftPixel = 0;
                          }else {
                              leftSrc = (unsigned char*)leftImage->imageData
                                  + m*leftImage->widthStep + n + k;
                              leftPixel = *leftSrc;
                              //zSumLeft += (leftPixel - meanLeftPixel)*(leftPixel -meanLeftPixel);
                          }


                          if (m < 0 || m >= imageHeight || n + k <0 || n +k >= imageWidth)
                          {
                               //zSumRight += 0;
                              rightPixel = 0;
                          }else
                          {
                              rightSrc = (unsigned char*)rightImage->imageData
                                           + m*rightImage->widthStep + n;
                              rightPixel = *rightSrc;
                              // zSumRight += (rightPixel - meanRightPixel)*(rightPixel - meanRightPixel);
                          }

                          sum += ((rightPixel - meanRightPixel)-(leftPixel -meanLeftPixel))
                                 *((rightPixel - meanRightPixel)-(leftPixel -meanLeftPixel));
                    }
                }


                matchLevel[k] = sum;
                //cout<<sum<<endl;
            }

            /*寻找最佳匹配点*/
           // matchLevel[0] = 1000000;

            tempMin = 0;
            tempIndex = 0;
            for ( m = 1;m < maxDBounds - minDBounds + 1;m++)
            {
                //cout<<matchLevel[m]<<endl;
                if (matchLevel[m] < matchLevel[tempIndex])
                {
                    tempMin = matchLevel[m];
                    tempIndex = m;
                }
            }
            dst = (unsigned char *)SADImage->imageData + i*SADImage->widthStep + j;
            //cout<<"index: "<<tempIndex<<"  ";

            *dst = tempIndex*8;
            dst = (unsigned char *)MatchLevelImage->imageData + i*MatchLevelImage->widthStep + j;
            *dst = tempMin;
            //cout<<"min:  "<<tempMin<<"  ";
            //cout<< tempIndex<<"  " <<tempMin<<endl;
        }
       // cvWaitKey(0);
    }

    cvShowImage("Census",SADImage);
    cvShowImage("MatchLevel",MatchLevelImage);
    cvSaveImage("depth.jpg",SADImage);
    cvSaveImage("matchLevel.jpg",MatchLevelImage);


    cout<<endl<<"Over"<<endl;
    cvWaitKey(0);
    cvDestroyAllWindows();
    cvReleaseImage(&leftImage);
    cvReleaseImage(&rightImage);
    return 0;
}

census:

miahhrgbfcyur
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
立体匹配 -- GC-Net网络结构分析
weixin_41405284的博客
10-30 5495
参考 GC-Net pytorch版本 首先看代码要对应着网络结构图和网络层的表格。 一.Unary Features 特征提取 1.使用2-D卷积提取深度特征。首先使用fiter size:5*5,stride:2的conv2d 将输入降维(1/2H,1/2W). imgl0=F.relu(self.bn0(self.conv0(imgLeft))) imgr0=F.relu(self.bn0(self.conv0(imgRight))) self.conv0=nn.Conv2d(3,3.
双目立体视觉入门
OranGO的专栏
01-08 8374
这是我在group meeting的时候，第一次给小伙伴们分享双目立体视觉知识用的ppt内容，主要是学习借鉴了“stereo vision: algorithm and application”课件的内容，希望各位有兴趣的童鞋留言交流！
双目立体匹配方法：BM、SGBM、GC算法的实现及性能对比(附代码)
ldk3679的博客
11-18 7992
BM、SGBM、GC算法的实现及性能对比(附代码) 在双目立体匹配中，有基于SAD算法的BM、SGBM、GC立体匹配技术，但是在OpenCv3.0以后，GC算法就从legacy中去除掉了。为了查看三种算法的匹配效果及运算性能，我在Windows10中安装了OpenCv2.4.9，并以VsCode为IDE进行程序编写。 一、VsCode中集成OpenCv2.4.9 VsCode中集成OpenCv2.4.9，我主要是参照了这个文章的方法，根据这位博主的方法，我完成了环境的配置，由于需要相应的legacy库，所以
BM、GC、SGBM三种算法的比较和BM在OpenCV3下的参数设置
zilanpotou182的博客
05-16 1万+
第一部分BM、GC和SGBM算法的性能比较转自：http://blog.csdn.net/chenyusiyuan/article/details/5967291，其中原博主推荐的Stefano Mattoccia大神的讲义Stereo Vision：algorithms and applications，我看了以后觉得非常受用，讲的非常条理全面，里面的参考文献也很经典。第二部分为原创，主要是
【图像配准】双目视觉图像匹配（含视差图 3D视图）【含Matlab源码 4601期】
最新发布
Matlab领域的博客
06-03 938
双目视觉图像匹配（含视差图 3D视图） 完整的代码，方可运行；可提供运行操作视频！适合小白！
双目立体匹配_StereoNet网络
Twilight737的博客
11-07 5090
传统立体匹配算法通常选取立体校正后的左视图作为参考图像，通过在目标图像上进行行搜索寻找同名点并计算视差，将每个像素的视差进行保存，得到单通道的视差图。距离相机越近的空间点，在视差图中灰度值越大。传统立体匹配算法将双目立体匹配问题转化寻找最小化能量函数的图D问题，此处的D可以时深度图或视差图，因此在深度学习领域立体匹配又被成为视差估计、深度估计。
【算法】OpenCV-SGBM算法及源码的简明分析
LeonJin的博客
04-13 2万+
OpenCV-SGBM的源码在/modules/calib3d/src/stereosgbm.cpp中， 博主用的opencv版本为4.5.2 BT代价就是计算两个像素之间的相似度（或者，代价cost）
litipipei_双目视觉立体匹配_
10-02
双目视觉立体匹配是一种计算机视觉技术，通过利用两个相机（或单个相机的两次不同曝光）获取的图像来计算场景的三维结构。这种技术的核心在于理解图像中的对应关系，即找到左右图像中相同物体的不同视点下的像素对应...
双目视觉立体匹配技术研究及其应用.pdf
08-21
双目立体视觉技术是计算机视觉中的非常重要的技术研究领域，并已经在诸多的实际应用领域得到了推广。本文详细介绍了双目立体视觉技术的理论基础，并结合实际应用，重点研究了边缘特征提取和立体匹配方法。
双目视觉立体匹配方法研究
03-15
该算法在保持平均误匹配率与前者相接近的情况下，有效地降低了算法 时间复杂度，加快了算法的计算速度，体现了局部优化方法和全局优化方法相结 合的互补优势。
一种快速双目视觉立体匹配算法
02-10
针对目前双目视觉立体匹配算法计算量过大、实时性不强的问题, 提出了一种平行配置系统的快速立体匹配算法。利用两幅视图的差异将视图分为特征点和非特征点, 然后对特征点采用WTA (winner-take-all)方法进行匹配, 而...
双目视觉特征点匹配三维重建
01-02
双目视觉利用两幅图像进行特征点匹配，生成三维点云，完成三维重建
基于Census变换的自适应权值Hamming距离立体匹配算法
10-16
传统的Census+Hamming距离立体匹配算法往往由于将邻域像素等同对待，从而缺少足够的匹配信息，造成较高的误匹配率。对此提出了一种自适用加权的Hamming距离算法，通过引入邻域像素空间距离，使在距离测算时将邻域像素分等级计算，丰富了匹配图像的信息。并且使用梯度图像像素之间的距离作为聚合代价计算的权值，实验证明其对于噪声有一定的抗干扰性，并且能够很好地反映纹理等信息，同时引入稀疏聚合窗口来减少算法的复杂度。最后进行亚像素插值增大匹配的正确性。通过对比试验证明，此算法不仅能够提高匹配的准确性和抗干扰性，还能减少算法的复杂度，适用于实时的立体匹配。
双目立体视觉Census算法 matlab
04-18
双目立体视觉Census算法 matlab
对立体视觉的双目图像进行极线校正，以实现双目致密匹配 Fusiello_epipolarrectification.rar
12-06
对立体视觉的双目图像进行极线校正，以实现双目致密匹配 (Of three-dimensional visual image of the binocular epipolar rectification to realize dense binocular matching)
双目视觉立体匹配算法研究
12-15
双目视觉立体匹配算法研究 本文由两部分组成，分别对双目视觉的算法和未标定图像的立体匹配进行了研究 和算法的实现。
双目立体视觉建立深度图_【3D视觉】立体匹配成像算法BM，SGBM，GC，SAD一览
weixin_29113371的博客
01-04 1650
点击上方“新机器视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达在深度相机的主流技术方案Structure Light，ToF，Stereo Dual)中，主动双目成像方案可以基于低成本的硬件，获得高分辨率、高精度的深度图像，但是立体匹配算法(stereo matching)复杂，对计算资源消耗很大。那我们介绍下几种经典的双目匹配的算法。【双目匹配】双目立体视觉理论建立在对人类视觉...
三维视觉论文阅读：GC-Net2017双目立体匹配
Yan
12-17 2005
论文 End-to-End Learning of Geometry and Context for Deep Stereo Regression 摘要 传统问题转化成”end2end"的“可微问题”是很多三维视觉论文讨论的核心，在这篇文章中就展示了如何将SGM可微化。另外，这篇文章的作者估计也很讨厌黑盒子式的端到端，所以整篇文章都在强调网络结构设计的合理性与原理。 网络结构 上图展示了GC-Net的整个网络结构，不难发现，其虽然是一个端到端的网络；但是仍旧被显著的分成了四个模块，分别是“特征提取”、“
双目立体视觉匹配算法-----SAD匹配算法、BM算法、SGBM算法、GC算法
热门推荐
liulina603的专栏
11-23 7万+
一、 SAD算法 1.算法原理         SAD(Sum of absolute differences)是一种图像匹配算法。基本思想：差的绝对值之和。此算法常用于图像块匹配，将每个像素对应数值之差的绝对值求和，据此评估两个图像块的相似度。该算法快速、但并不精确，通常用于多级处理的初步筛选。 2.基本流程 输入：两幅图像，一幅Left-Image，一幅Right-Im
双目视觉立体匹配有什么用
05-17
双目视觉立体匹配是指利用两个摄像机采集的图像进行立体匹配，从而得到场景中物体的三维位置。它的应用非常广泛，例如： 1. 机器人导航：通过双目视觉立体匹配可以获取场景中物体的三维位置，从而帮助机器人进行...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值