opencv双目测距(BM 与SGBM匹配）

最新推荐文章于 2024-09-24 09:00:00 发布
最新推荐文章于 2024-09-24 09:00:00 发布
阅读量2.4w 收藏 384
点赞数 59
分类专栏： c++与opencv做图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiao__run/article/details/92789922
版权

１、引言
在一年之前小编写了一篇双目测距的博文，引入了大量的童鞋阅读，其博文介绍了详细的相机标定与双目测距过程和代码

https://blog.csdn.net/xiao__run/article/details/78900652

摄像头如前面文章所示，大家可自行购买，小编就是在这家购买

https://shop224405513.taobao.com/search.htm?spm=a1z10.1-c-s.0.0.751b3e49u0Kz6o&search=y

文章评论特别多，由此可见很多读者遇到了很多的问题，有标定不准的，测距距离不准，误差特别大，视差图很差的等各种问题。今天小编再写一篇博文，可能对您有所帮助。

双目测距流程如图

在这里插入图片描述

２　标定
首先准备一张标定板，标定板要比较大，不能反光等特性，小博的标定板如图
在这里插入图片描述接下来拍照，大约二十张，就可以了，我重新修改了下拍照程序

#include <iostream>
#include <opencv2/opencv.hpp>
 
using namespace std;
using namespace cv;
 
 
int main()
{

/*
    //双目摄像头，两个usb
    cv::VideoCapture capl(0);
    cv::VideoCapture capr(1);
    int i = 0;
 
    cv::Mat cam_left;
    cv::Mat cam_right;
 
    char filename_l[15];
    char filename_r[15];
    while(capl.read(cam_left) && capr.read(cam_right))
    {
        cv::imshow("cam_left", cam_left);
        cv::imshow("cam_right", cam_right);
	
        char c = cv::waitKey(1);
        char s[40];
        
        if(c==' ') //按空格采集图像
        {
	        sprintf(filename_l, "/home/lqx/ClionProjects/Calibration/left_img/left%d.jpg",i);
            imwrite(filename_l, cam_left);
	        sprintf(filename_r, "/home/lqx/ClionProjects/Calibration/right_img/right%d.jpg",i++);
            imwrite(filename_r, cam_right);
            //printf(s, "%s%d%s\n", "the ",i++,"th image");
            cout << "save the "<< i <<"th image\n"<< endl;
        }
        if(c=='q' || c=='Q') // 按q退出
        {
            break;
        }
    }
 
    return 0;
 */

    //双目摄像头，一个usb
    //图像大小为640*240，左右各为320*240
    cv::VideoCapture cap(0);
    int i = 0;
    cap.set(CV_CAP_PROP_FRAME_WIDTH,640);//可以

    cap.set(CV_CAP_PROP_FRAME_HEIGHT,240);
    cv::Mat cam, cam_left,cam_right;
    char filename_l[15];
    char filename_r[15];
    while(cap.read(cam) )
    {

        cam_right=cam(Rect(0,0,320,240));
        cam_left=cam(Rect(320,0,320,240));

        cv::imshow("cam_left", cam_left);
        cv::imshow("cam_right", cam_right);
        char c = cv::waitKey(1);
        char s[40];

        if(c==' ') //按空格采集图像
        {
            sprintf(filename_l, "left_img/left%d.jpg",i);
            imwrite(filename_l, cam_left);
            sprintf(filename_r, "right_img/right%d.jpg",i++);
            imwrite(filename_r, cam_right);
            //printf(s, "%s%d%s\n", "the ",i++,"th image");
            cout << "save the "<< i <<"th image\n"<< endl;
        }
        if(c=='q' || c=='Q') // 按q退出
        {
            break;
        }
    }

    return 0;
}

调用上述代码即可得到左右二十多张图像。

接下来我们使用matlab工具箱的标定工具进行标定，也可以使用我上面的博文进行标定。我建议使用matlab标定，结果会更准确点。
标定得到内参和外参如下：

//T 矩阵参数
    Mat T = Mat::zeros(3,1,CV_64F);
    T.at<double>(0,0)= 119.5815;
    T.at<double>(1,0)=-0.5328;
    T.at<double>(2,0)=-1.7296;

//R矩阵
   // Rodrigues(rec,R);
   // cout<<R<<endl;
    Mat R=Mat::eye(3,3,CV_64F);
    R.at<double>(0,1)= 0.000055498;
    R.at<double>(0,2)= -0.0184;
    R.at<double>(1,0)= -0.0001629;
    R.at<double>(1,2)= 0.0118;
    R.at<double>(2,0)= 0.0184;
    R.at<double>(2,1)= -0.0118;


    //*******************左相机参数**********************************
    //*******************左相机参数**********************************
    double fx=202.0386,fy=202.6377;
    double cx=156.0528,cy=116.9724;

    Size size(320,240);

    Rect left(0,0,320,240);
    Rect right(320,0,320,240);
    Mat cameraMatrixL=Mat ::eye(3,3,CV_64F);
    Mat cameraMatrixR=Mat ::eye(3,3,CV_64F);
   //左边相机内参 
    cameraMatrixL.at<double>(0,0)=fx;
    cameraMatrixL.at<double>(0,2)=cx;
    cameraMatrixL.at<double>(1,1)=fy;
    cameraMatrixL.at<double>(1,2)=cy;
   //左边相机畸变
 Mat distCoffsL=Mat::zeros(5,1,CV_64F);
    distCoffsL.at<double>(0,0)=-0.0446;
    distCoffsL.at<double>(1,0)=0.0597;
    distCoffsL.at<double>(2,0)=0;
    distCoffsL.at<double>(3,0)=0.;
    distCoffsL.at<double>(4,0)=0;

    //*******************右相机参数**********************************
    cameraMatrixR.at<double>(0,0)=204.1203;
    cameraMatrixR.at<double>(0,2)=164.9597;
    cameraMatrixR.at<double>(1,1)=204.5797;
    cameraMatrixR.at<double>(1,2)=117.9534;
    Mat distCoffsR=Mat::zeros(5,1,CV_64F);

    distCoffsR.at<double>(0,0)=-0.0352;
    distCoffsR.at<double>(1,0)=0.0345;
    distCoffsR.at<double>(2,0)=0.;
    distCoffsR.at<double>(3,0)=0;
    distCoffsR.at<double>(4,0)=0;

3、 BM与SGBM匹配算法
SGBM是一种立体匹配算法，准确度和速度适中，工程中比较常用

oid  stereo_SGBM_match(int, void*)
{
	int mindisparity = 0;
	int ndisparities = 64;  
	int SADWindowSize = 11; 
	cv::Ptr<cv::StereoSGBM> sgbm = cv::StereoSGBM::create(mindisparity, ndisparities, SADWindowSize);

	int P1 = 8 * left_camera_calibration.channels() * SADWindowSize* SADWindowSize;
	int P2 = 32 * left_camera_calibration.channels() * SADWindowSize* SADWindowSize;
	sgbm->setP1(P1);
	sgbm->setP2(P2);
	sgbm->setPreFilterCap(15);
	sgbm->setUniquenessRatio(6);
	sgbm->setSpeckleRange(2);
	sgbm->setSpeckleWindowSize(100);
	sgbm->setDisp12MaxDiff(1);
        //sgbm->setNumDisparities(1);
	sgbm->setMode(cv::StereoSGBM::MODE_HH);
        Mat disp,disp8U;
	sgbm->compute(left_camera_calibration, right_camrera_calibration, disp);
	disp.convertTo(disp, CV_32F, 1.0 / 16);                //除以16得到真实视差值
	disp8U = Mat(disp.rows, disp.cols, CV_8UC1);       //显示
	//normalize(disp, disp8U, 0, 255, NORM_MINMAX, CV_8UC1);
	disp.convertTo(disp8U,CV_8U,255/(numDisparities*16.));
	reprojectImageTo3D(disp,xyz,Q);
        xyz=xyz*16;
	imshow("disparity",disp8U);

}

BM算法之前博文已经提过

oid  stereo_match(int, void*)
{
    bm->setBlockSize(2*blockSize+5);
    bm->setROI1(validROIL);
    bm->setROI2(validROIR);
    bm->setPreFilterCap(31);
    bm->setMinDisparity(0);  
//最小视差，默认值为0, 可以是负值，int型
    bm->setNumDisparities(numDisparities * 16 + 16);
//视差窗口，即最大视差值与最小视差值之差,窗口大小必须是16的整数倍，int型
    bm->setTextureThreshold(10);
    bm->setUniquenessRatio(uniquenessRation);
    bm->setSpeckleWindowSize(100);
    bm->setSpeckleRange(32);
    bm->setDisp12MaxDiff(-1);
    Mat disp,disp8;
    bm->compute(left_camera_calibration,right_camrera_calibration,disp);
    disp.convertTo(disp8,CV_8U,255/((numDisparities*16+16)*16.));
    reprojectImageTo3D(disp,xyz,Q);
    xyz=xyz*16;
    imshow("disparity",disp8);

}

４、视差图测距
我们先看下效果图，效果蛮不错，误差1m以内大约1cm以内；
在这里插入图片描述在这里插入图片描述在这里插入图片描述可以看到本文的测距方法还是挺准，视差图效果也不错。

最后给出部分工程代码吧,此代码未经我优化，仅仅作为学习使用，其实经优化，在树莓派等设备上也能实时生成视差图测距。

#include <iostream>
#include <opencv2/opencv.hpp>
using namespace cv;
using namespace std;


int framewidth=320;
int frameheight=240;
Size imageSize=Size(framewidth,frameheight);
Mat left_camera,right_camera,left_camera_calibration,right_camrera_calibration,xyz;
Point origin;
Rect selection;
bool selectObject= false;
int blockSize=0,uniquenessRation=0,numDisparities=0;
Rect validROIL,validROIR;

Mat view,rview,mapL1,map_L2,mapR1,mapR2,RL,PL,RR,PR,Q;
Ptr<StereoBM>bm=StereoBM::create(16,9);
int mindisparity = 0;
int ndisparities = 64;  
int SADWindowSize = 11; 
cv::Ptr<cv::StereoSGBM> sgbm = cv::StereoSGBM::create(mindisparity, ndisparities, SADWindowSize);
//*******************bm**********************************
//*******************bm**********************************

/*
void  stereo_match(int, void*)
{
    bm->setBlockSize(2*blockSize+5);
    bm->setROI1(validROIL);
    bm->setROI2(validROIR);
    bm->setPreFilterCap(31);
    bm->setMinDisparity(0);  
//最小视差，默认值为0, 可以是负值，int型
    bm->setNumDisparities(numDisparities * 16 + 16);
//视差窗口，即最大视差值与最小视差值之差,窗口大小必须是16的整数倍，int型
    bm->setTextureThreshold(10);
    bm->setUniquenessRatio(uniquenessRation);
    bm->setSpeckleWindowSize(100);
    bm->setSpeckleRange(32);
    bm->setDisp12MaxDiff(-1);
    Mat disp,disp8;
    bm->compute(left_camera_calibration,right_camrera_calibration,disp);
    disp.convertTo(disp8,CV_8U,255/((numDisparities*16+16)*16.));
    reprojectImageTo3D(disp,xyz,Q);
    xyz=xyz*16;
    imshow("disparity",disp8);

}

*/
//*******************bm**********************************
//*******************bm**********************************

void  stereo_SGBM_match(int, void*)
{

	int P1 = 8 * left_camera_calibration.channels() * SADWindowSize* SADWindowSize;
	int P2 = 32 * left_camera_calibration.channels() * SADWindowSize* SADWindowSize;
	sgbm->setP1(P1);
	sgbm->setP2(P2);
	sgbm->setPreFilterCap(15);
	sgbm->setUniquenessRatio(6);
	sgbm->setSpeckleRange(2);
	sgbm->setSpeckleWindowSize(100);
	sgbm->setDisp12MaxDiff(1);
        //sgbm->setNumDisparities(1);
	sgbm->setMode(cv::StereoSGBM::MODE_HH);
        Mat disp,disp8U;
	sgbm->compute(left_camera_calibration, right_camrera_calibration, disp);
	disp.convertTo(disp, CV_32F, 1.0 / 16);                //除以16得到真实视差值
	disp8U = Mat(disp.rows, disp.cols, CV_8UC1);       //显示
	//normalize(disp, disp8U, 0, 255, NORM_MINMAX, CV_8UC1);
	disp.convertTo(disp8U,CV_8U,255/(numDisparities*16.));
	reprojectImageTo3D(disp,xyz,Q);
        xyz=xyz*16;
	imshow("disparity",disp8U);

}



static void onMouse(int envent,int x,int y,int, void*)
{
    if (selectObject)
    {
        selection.x=MIN(x,origin.x);
        selection.y=MIN(y,origin.y);
        selection.width=abs(x-origin.x);
        selection.height=abs(y-origin.y);

    }
    switch (envent)
    {
        case EVENT_LBUTTONDOWN:
            origin=Point(x,y);
            selection=Rect(x,y,0,0);
            selectObject= true;
            cout<<origin<<"in the world coordinate is: "<<xyz.at<Vec3f>(origin)<<endl;
            break;
        case EVENT_LBUTTONUP:
            selectObject= false;
            if(selection.width>0 && selection.height>0)
            break;

    }
}



int main()
{
//T 矩阵参数
    Mat T = Mat::zeros(3,1,CV_64F);
    T.at<double>(0,0)= 119.5815;
    T.at<double>(1,0)=-0.5328;
    T.at<double>(2,0)=-1.7296;


    //Mat rec = Mat::zeros(3,1,CV_64F);
    //rec.at<double>(0,0)= 0.0191;
   // rec.at<double>(1,0)=0.03125;
    //rec.at<double>(2,0)=-0.00960;


    //Mat R;

//R矩阵
   // Rodrigues(rec,R);
   // cout<<R<<endl;
    Mat R=Mat::eye(3,3,CV_64F);
    R.at<double>(0,1)= 0.000055498;
    R.at<double>(0,2)= -0.0184;
    R.at<double>(1,0)= -0.0001629;
    R.at<double>(1,2)= 0.0118;
    R.at<double>(2,0)= 0.0184;
    R.at<double>(2,1)= -0.0118;


    //*******************左相机参数**********************************
    //*******************左相机参数**********************************
    double fx=202.0386,fy=202.6377;
    double cx=156.0528,cy=116.9724;

    Size size(320,240);

    Rect left(0,0,320,240);
    Rect right(320,0,320,240);
    Mat cameraMatrixL=Mat ::eye(3,3,CV_64F);
    Mat cameraMatrixR=Mat ::eye(3,3,CV_64F);
   //左边相机内参 
    cameraMatrixL.at<double>(0,0)=fx;
    cameraMatrixL.at<double>(0,2)=cx;
    cameraMatrixL.at<double>(1,1)=fy;
    cameraMatrixL.at<double>(1,2)=cy;
   //左边相机畸变
 Mat distCoffsL=Mat::zeros(5,1,CV_64F);
    distCoffsL.at<double>(0,0)=-0.0446;
    distCoffsL.at<double>(1,0)=0.0597;
    distCoffsL.at<double>(2,0)=0;
    distCoffsL.at<double>(3,0)=0.;
    distCoffsL.at<double>(4,0)=0;
    //*******************做相机参数**********************************
    //*******************右相机参数**********************************
    cameraMatrixR.at<double>(0,0)=204.1203;
    cameraMatrixR.at<double>(0,2)=164.9597;
    cameraMatrixR.at<double>(1,1)=204.5797;
    cameraMatrixR.at<double>(1,2)=117.9534;
    Mat distCoffsR=Mat::zeros(5,1,CV_64F);

    distCoffsR.at<double>(0,0)=-0.0352;
    distCoffsR.at<double>(1,0)=0.0345;
    distCoffsR.at<double>(2,0)=0.;
    distCoffsR.at<double>(3,0)=0;
    distCoffsR.at<double>(4,0)=0;
    //*******************有相机参数**********************************
    //*******************有相机参数**********************************


    cout<<"calibration ......."<<endl;
    //Mat new_cameraMatrix_L=getOptimalNewCameraMatrix(cameraMatrix1, distCoeffs1, image_size, 1, image_size, 0);

    stereoRectify(cameraMatrixL,distCoffsL,cameraMatrixR,distCoffsR,size,R,T,RL,RR,PL,PR,Q,CALIB_ZERO_DISPARITY,0,size,&validROIL,&validROIR);

    initUndistortRectifyMap(cameraMatrixL,distCoffsL,RL,PL ,size,CV_16SC2,mapL1,map_L2);

    initUndistortRectifyMap(cameraMatrixR,distCoffsR,RR,PR ,size,CV_16SC2,mapR1,mapR2);
    VideoCapture cap (0);
    Mat rectifyL,rectifyR;
    cap.set(CV_CAP_PROP_FRAME_WIDTH, 640);
    cap.set(CV_CAP_PROP_FRAME_HEIGHT, 320);

    while (cap.isOpened())
    {
        Mat frame,grayL,grayR;
        cap>>frame;
        left_camera=frame(left);
        right_camera=frame(right);
        imshow("left_org",left_camera);
        imshow("right_org",right_camera);
        imshow("org",frame);

        cvtColor(left_camera,grayL,CV_RGB2GRAY);
        cvtColor(right_camera,grayR,CV_RGB2GRAY);

        remap(grayL,left_camera_calibration,mapL1,map_L2,INTER_LINEAR);
        remap(grayR,right_camrera_calibration,mapR1,mapR2,INTER_LINEAR);
/*
        Mat canvas;
        double sf;
        int w ,h;
        sf=240. /320;
        w=cvRound(240*sf);
        h=cvRound(320*sf);
        canvas.create(h,w*2,CV_8UC3);

        Mat canvasPart=canvas(Rect(0,0,w,h));
        resize(left_camera_calibration,canvasPart,canvasPart.size(),0,0,INTER_AREA);
        Rect vroiL(cvRound(validROIL.x*sf),cvRound(validROIL.y*sf),cvRound(validROIL.width*sf),cvRound(validROIL.height*sf));

        canvasPart=canvas(Rect(w,0,w,h));
        resize(right_camrera_calibration,canvasPart,canvasPart.size(),0,0,INTER_AREA);
        Rect vroiR(cvRound(validROIR.x*sf),cvRound(validROIR.y*sf),cvRound(validROIR.width*sf),cvRound(validROIR.height*sf));

        for(int i=0;i<canvas.rows;i+=16)
            line(canvas,Point(0,i),Point(canvas.cols,i),Scalar(0,255,0),1,8);
        imshow("rectify",canvas);
*/
        namedWindow("disparity",CV_WINDOW_AUTOSIZE);

//        createTrackbar("blocksize:\n","disparity",&blockSize,16,stereo_match);

//        createTrackbar("UniquenessRatio:\n","disparity",&uniquenessRation,50,stereo_match);

        createTrackbar("NumDisparities:\n","disparity",&numDisparities,16,stereo_SGBM_match);

        setMouseCallback("disparity",onMouse,0);

//        stereo_match(0,0);
	
	stereo_SGBM_match(0, 0);
	// Mat output;
	//sgbm->compute(left_camera_calibration,right_camrera_calibration,output);
	//imshow("SGBM",output);
        //cvtColor(left_camera_calibration,left_camera_calibration,CV_GRAY2BGR);

       // cvtColor(right_camrera_calibration,right_camrera_calibration,CV_GRAY2BGR);

        imshow("cali_right",right_camrera_calibration);

        imshow("cali_left",left_camera_calibration);

        int key=waitKey(1);
        if (key==27)
        {
            break;
        }




    }


    return 0;
}

若测得距离为负数，可将Ｔ向量的三个值变换个符号即可，OK ,先讲这么多，觉得不错的点个赞哦。

xiao__run
关注
专栏目录
【计算机视觉】双目测距（五）--匹配算法对比
ZhangPY的专栏
11-09 1万+
原文： http://www.cnblogs.com/polly333/p/5130375.html 三种匹配算法比较 BM算法： 该算法代码： view plaincopy to clipboardprint? CvStereoBMState *BMState = cvCreateStereoBMState();  int SADWindowSize=15; 
双目测距 SGBM算法 Python版
黎国溥
09-17 9168
前言 首先进行双目定标，获取双目摄像头内部的参数后，进行测距。本次的双目视觉测距，基于SGBM算法。 注意：双目定标的效果会影响测距的精准度，建议大家在做双目定标时，做好一些（尽量让误差小） 如果不太了解双目视觉原理，建议先看看这篇文章：一篇文章认识《双目立体视觉》 一、双目测距 效果 基于SGBM算法，生成视差图的效果 用鼠标点击视差图，程序会自动计算该点的世界坐标、距离，输出信息如下： 像素坐标 x = 523, y = 366 世界坐标xyz 是： 0.37038836669.
双目立体匹配算法：SGBM
最新发布
weixin_45303602的博客
09-24 2009
SGBM（Semi-Global Block Matching）是一种用于计算双目视觉中视差（disparity）的半全局匹配算法，在OpenCV中的实现为semi-global block matching（SGBM）。它是基于全局匹配算法和局部匹配算法的优缺点，提出了一种折中的方法，既能保证视差图的质量，又能降低计算复杂度。
三维重建（10）之立体匹配算法详解：BM、SGBM
yohnyang的博客
11-05 2685
三维重建（10）之立体匹配算法详解：BM、SGBM
双目立体视觉建立深度图_【3D视觉】立体匹配成像算法BM，SGBM，GC，SAD一览
weixin_29113371的博客
01-04 1733
点击上方“新机器视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达在深度相机的主流技术方案Structure Light，ToF，Stereo Dual)中，主动双目成像方案可以基于低成本的硬件，获得高分辨率、高精度的深度图像，但是立体匹配算法(stereo matching)复杂，对计算资源消耗很大。那我们介绍下几种经典的双目匹配的算法。【双目匹配】双目立体视觉理论建立在对人类视觉...
VS2017+OpenCV3.3基于SGBM算法的双目立体视觉、双目测距（双目校正和立体匹配）(文档里包含了测试图片)
01-11
VS2017+OpenCV3.3基于SGBM算法的双目立体视觉、双目测距（双目校正和立体匹配）(文档里包含了测试图片)
vs2019+opencv-SGBM双目测距代码.7z
09-01
opencv自带的SGBM算法，简单实现双目测距功能，可以使用自己标定的双目相机参数
opencv立体匹配算法（BM+SGBM+VAR）运行官方立体匹配图对程序
03-08
基于opencv2.4.9中的立体匹配三种算法，去掉了校正图像的步骤，可以直接使用校正好的标准图像进行实验，对比视差图的效果！环境是VS2010！
Demo_006_opencv双目测距_双目测距_factord54_sgbm_DEMO_源码.rar.rar
09-29
《OpenCV双目测距技术详解——基于factord54_sgbm的DEMO源码解析》 在计算机视觉领域，双目测距是一种利用两个摄像头（或单个立体相机）获取深度信息的方法，它是模拟人类双眼视觉原理，通过计算视差来估算物体的...
OpenCV求视差图方法实现（sgbm方法）
05-20
使用的OpenCV自带方法sgbm计算求取视差图，配置好OpenCV环境，入口写好的，直接可用。opencv2和opencv3sgbm的写法略有不同。
基于VS2017+opencv3.4.3的立体匹配SGBM与BM算法代码
11-19
基于VS2017+opencv3.4.3的立体匹配SGBM与BM算法代码，opencv更新后，SGBM与SM的调用也发生改变，在网上查了一大圈后，终于将代码成功运行出来了。（注：此代码不涉及两种算法的具体流程，只是基于opencv库的成功调用运行，每个代码就60行左右。想看算法原理的就别下了）
基于opencv的双目测距（代码+文章）
05-09
文章名称：3-D Point Cloud Generation from Rigid and Flexible Stereo Vision Systems 文章（英文）详细讲解了双目视觉的一些基本原理，已经如何使用两个普通的网络摄像头来实现双目视觉，以及如何根据两个摄像头来计算物体深度信息。 代码为文章中附带的代码 仅供参考学习
测试opencv,sgbm，make编译
10-25
测试make编译包含opencv库的cpp文件，源码包括makefile
基于opencv的双目测距原理与方法
AI天才研究院
08-06 1062
基于opencv的双目测距原理与方法 作者：禅与计算机程序设计艺术 1. 背景介绍 双目视觉是计算机视觉领域的一个重要分支,它模拟人类双眼视觉,通过两个摄像头从不同角度拍摄同一场景,获取场景的深度信息。双目视觉在机器人导航、自动驾驶、三维重建等领域有广泛应用。
基于C++和OpenCV实现双目测距系统
m0_57781768的博客
06-09 1401
本文详细介绍了双目测距的基本原理及其在C++和OpenCV中的实现，通过具体的代码示例展示了如何实现一个简单的双目测距系统。本文还介绍了系统的性能优化与测量精度优化方法，并提供了两个应用实例，帮助读者更好地理解和应用双目测距技术。双目测距技术在多个领域有广泛的应用前景，通过不断学习和实践，我们可以更好地利用该技术进行复杂系统的开发与优化，推动技术的发展和应用。
双目相机立体匹配算法BM和SGBM
weixin_43662044的博客
06-20 3182
OpenCV实现的计算机视觉立体匹配算法BM和SGBM
OpenCV双目匹配BM算法和SGBM算法的速度和精度比较
u013317903的专栏
05-26 7478
OpenCV在双目匹配上所做的工作相当不错，从1.0版本到4.3这么多年的版本迭代，官方始终在优化双目匹配算法。最常用的当属BM算法和SGBM算法了： BM全称是BlockMatching，可以理解为一种块匹配算法，这里一个通俗的说法就是，为了找到两张图像中某一对同名点（也就是匹配点对），我们不可能只使用该像素的像素值进行比较，因为像素值相同的点在一副图像中往往不止一个，这时自然想到的就是利用周围的像素点和待匹配点作为一个整体，毕竟在实际生活中，相同的点周围也是相似的嘛。 ...
sgbm算法python代码
03-04
SGMB算法（Semi-Global Matching）是一种用于立体匹配的算法，它可以用于生成视差图。下面是一个简单的SGMB算法的Python代码示例： ```python import cv2 # 读取左右视图图像 left_image = cv2.imread('left_image.png', 0) right_image = cv2.imread('right_image.png', 0) # 创建SGMB对象 sgbm = cv2.StereoSGBM_create(minDisparity=0, numDisparities=16, blockSize=3) # 计算视差图 disparity_map = sgbm.compute(left_image, right_image) # 可选：进行视差图的后处理 disparity_map = cv2.normalize(disparity_map, disparity_map, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U) # 显示视差图 cv2.imshow('Disparity Map', disparity_map) cv2.waitKey(0) cv2.destroyAllWindows() ``` 上述代码中，首先使用`cv2.imread`函数读取了左右视图的图像。然后，通过`cv2.StereoSGBM_create`函数创建了一个SGMB对象，并设置了一些参数，如最小视差、视差范围和块大小等。接下来，调用`compute`方法计算视差图。最后，可以选择进行视差图的后处理，例如使用`cv2.normalize`函数将视差图进行归一化处理。最后，使用`cv2.imshow`函数显示视差图。
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xiao__run

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值