双目立体视觉SGBM

最新推荐文章于 2023-06-28 07:01:33 发布
最新推荐文章于 2023-06-28 07:01:33 发布
阅读量418 收藏 7
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sxk20091111/article/details/113454102
版权

算法原理

bm的局部的代价聚合算法，受到噪声影响比较大，所以bm算法的速度虽然比较快，但是效果比较差，

而sgbm是一个半全局的代价聚合算法，计算代价的时候考虑周围领域的代价值，但不是一次性及算法

整个图像上的代价最小值（这样全局的算法效率比较低），而是利用动态规划的算法，从局部利用贪心的

思想计算全局。

能量代价函数如下：

E(D) = \sum_{p}\left ( C\left ( p,D_{p} \right ) \right ) + \sum_{q=N_{p}}\left ( P1*T[\left \| D_{p}- D_{q}\right \| ==1]\right ) + \sum_{q=N_{p}}\left ( P2*T[\left \| D_{p}- D_{q}\right \| ]\right )

总共包含三项：

  • 第一项就是局部的代价SAD聚合值

  • 第二项表示的是视差小于1的惩罚项

  • 第三项表示的是视差大于1的惩罚项

这样第二项的惩罚项可以适应变化比较小的平滑区域，第三项的惩罚项适应的是变化比较大的边缘区域或者纹理丰富区域。

具体某一点像素p沿着方向r的路径代价函数如下：

上面的公式就是一个BP算法的基本状态变化公式，平滑项就是选择当前方向的路径代价值、视差小于1的路径代价值加上p1、

当前方向范围内的最小值加上p2 这几项的最小值减去当前方向的最小代价聚合值。这样当前方向的代价聚合的上限为：

L \leqslant C_{max}+ P2  ↵

 总的代价聚合函数就是计算各个路径的路径代价之和：

S = \sum_{r} (L_{r}(p, d))

最终就是计算最小的S对应的视差作为最优的视差。

 

代码分析

代价计算

static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y,
                            int minD, int maxD, CostType* cost,
                            PixType* buffer, const PixType* tab,
                            int xrange_min = 0, int xrange_max = DEFAULT_RIGHT_BORDER )
{
    int x, c, width = img1.cols, cn = img1.channels();
    int minX1 = std::max(maxD, 0), maxX1 = width + std::min(minD, 0);
    int D = (int)alignSize(maxD - minD, v_int16::nlanes), width1 = maxX1 - minX1;
    //This minX1 & maxX2 correction is defining which part of calculatable line must be calculated
    //That is needs of parallel algorithm
    xrange_min = (xrange_min < 0) ? 0: xrange_min;
    xrange_max = (xrange_max == DEFAULT_RIGHT_BORDER) || (xrange_max > width1) ? width1 : xrange_max;
    maxX1 = minX1 + xrange_max;
    minX1 += xrange_min;
    width1 = maxX1 - minX1;
    int minX2 = std::max(minX1 - maxD, 0), maxX2 = std::min(maxX1 - minD, width);
    int width2 = maxX2 - minX2;
    const PixType *row1 = img1.ptr<PixType>(y), *row2 = img2.ptr<PixType>(y);
    PixType *prow1 = buffer + width2*2, *prow2 = prow1 + width*cn*2;

    for( c = 0; c < cn*2; c++ )
    {
        prow1[width*c] = prow1[width*c + width-1] =
        prow2[width*c] = prow2[width*c + width-1] = tab[0];
    }

    int n1 = y > 0 ? -(int)img1.step : 0, s1 = y < img1.rows-1 ? (int)img1.step : 0;
    int n2 = y > 0 ? -(int)img2.step : 0, s2 = y < img2.rows-1 ? (int)img2.step : 0;

    int minX_cmn = std::min(minX1,minX2)-1;
    int maxX_cmn = std::max(maxX1,maxX2)+1;
    minX_cmn = std::max(minX_cmn, 1);
    maxX_cmn = std::min(maxX_cmn, width - 1);
    if( cn == 1 )   //prow1 是左影像的响应值， 
    {
        for( x = minX_cmn; x < maxX_cmn; x++ )
        {
            prow1[x] = tab[(row1[x+1] - row1[x-1])*2 + row1[x+n1+1] - row1[x+n1-1] + row1[x+s1+1] - row1[x+s1-1]];
            prow2[width-1-x] = tab[(row2[x+1] - row2[x-1])*2 + row2[x+n2+1] - row2[x+n2-1] + row2[x+s2+1] - row2[x+s2-1]];

            prow1[x+width] = row1[x];
            prow2[width-1-x+width] = row2[x];
        }
    }
    else
    {
        for( x = minX_cmn; x < maxX_cmn; x++ )
        {
            prow1[x] = tab[(row1[x*3+3] - row1[x*3-3])*2 + row1[x*3+n1+3] - row1[x*3+n1-3] + row1[x*3+s1+3] - row1[x*3+s1-3]];
            prow1[x+width] = tab[(row1[x*3+4] - row1[x*3-2])*2 + row1[x*3+n1+4] - row1[x*3+n1-2] + row1[x*3+s1+4] - row1[x*3+s1-2]];
            prow1[x+width*2] = tab[(row1[x*3+5] - row1[x*3-1])*2 + row1[x*3+n1+5] - row1[x*3+n1-1] + row1[x*3+s1+5] - row1[x*3+s1-1]];

            prow2[width-1-x] = tab[(row2[x*3+3] - row2[x*3-3])*2 + row2[x*3+n2+3] - row2[x*3+n2-3] + row2[x*3+s2+3] - row2[x*3+s2-3]];
            prow2[width-1-x+width] = tab[(row2[x*3+4] - row2[x*3-2])*2 + row2[x*3+n2+4] - row2[x*3+n2-2] + row2[x*3+s2+4] - row2[x*3+s2-2]];
            prow2[width-1-x+width*2] = tab[(row2[x*3+5] - row2[x*3-1])*2 + row2[x*3+n2+5] - row2[x*3+n2-1] + row2[x*3+s2+5] - row2[x*3+s2-1]];

            prow1[x+width*3] = row1[x*3];
            prow1[x+width*4] = row1[x*3+1];
            prow1[x+width*5] = row1[x*3+2];

            prow2[width-1-x+width*3] = row2[x*3];
            prow2[width-1-x+width*4] = row2[x*3+1];
            prow2[width-1-x+width*5] = row2[x*3+2];
        }
    }

    memset( cost + xrange_min*D, 0, width1*D*sizeof(cost[0]) );

    buffer -= width-maxX2;
    cost -= (minX1-xrange_min)*D + minD; // simplify the cost indices inside the loop

    for( c = 0; c < cn*2; c++, prow1 += width, prow2 += width )
    {
        int diff_scale = c < cn ? 0 : 2;

        // precompute
        //   v0 = min(row2[x-1/2], row2[x], row2[x+1/2]) and
        //   v1 = max(row2[x-1/2], row2[x], row2[x+1/2]) and
        //   to process values from [minX2, maxX2) we should check memory location (width - 1 - maxX2, width - 1 - minX2]
        //   so iterate through [width - maxX2, width - minX2)
        for( x = width-maxX2; x < width-minX2; x++ )
        {
            int v = prow2[x];
            int vl = x > 0 ? (v + prow2[x-1])/2 : v;
            int vr = x < width-1 ? (v + prow2[x+1])/2 : v;
            int v0 = std::min(vl, vr); v0 = std::min(v0, v);
            int v1 = std::max(vl, vr); v1 = std::max(v1, v);
            buffer[x] = (PixType)v0;
            buffer[x + width2] = (PixType)v1;
        }

        for( x = minX1; x < maxX1; x++ )
        {
            int u = prow1[x];
            int ul = x > 0 ? (u + prow1[x-1])/2 : u;
            int ur = x < width-1 ? (u + prow1[x+1])/2 : u;
            int u0 = std::min(ul, ur); u0 = std::min(u0, u);
            int u1 = std::max(ul, ur); u1 = std::max(u1, u);

            int d = minD;

            for( ; d < maxD; d++ )
            {
                int v = prow2[width-x-1 + d];
                int v0 = buffer[width-x-1 + d];
                int v1 = buffer[width-x-1 + d + width2];
                int c0 = std::max(0, u - v1); c0 = std::max(c0, v0 - u);
                int c1 = std::max(0, v - u1); c1 = std::max(c1, u0 - v);

                cost[x*D + d] = (CostType)(cost[x*D+d] + (std::min(c0, c1) >> diff_scale));
            }
        }
    }
}

这里计算代价值方式是：(之前BM是直接计算代价， sgbm中采用左右临域平均值进行处理可以减少噪声点的影响，同时根据左右一致性选择最优的代价值）

            int u1l =  (prow1[x] + prow1[x-1])/2 ;
            int u1r =  (prow1[x] + prow1[x+1])/2 ;

            u0  = min(prow1[x], u1l , u1r )
            u1 = max(prow1[x], u1l , u1r )

            u  = prow1[x]

            int u2l =  (prow2[x] + prow2[x-1])/2 ;
            int u2r =  (prow2[x] + prow2[x+1])/2 ;

            v0  = min(prow2[x], u2l , u2r )
            v1 = max(prow2[x], u2l , u2r )

           
            v  = prow2[x]
          
           #计算代价为：
             c0  = max(v- u1, u0-v)
             c1  = max(u- v1, v0 -u)
              
             C = min(c0, c1)

代价聚合

第一步是前向SP聚合

        #计算上一行的-1, 0, 1 和当前一行的-1    四个方向的路径代价
          for( x = x1; x != x2; x += dx )
            {
                int delta0 = P2 + *mem.getMinLr(lrID, x - dx);
                int delta1 = P2 + *mem.getMinLr(1 - lrID, x - 1, 1);
                int delta2 = P2 + *mem.getMinLr(1 - lrID, x,     2);
                int delta3 = P2 + *mem.getMinLr(1 - lrID, x + 1, 3);

                CostType* Lr_p0 = mem.getLr(lrID, x - dx);
                CostType* Lr_p1 = mem.getLr(1 - lrID, x - 1, 1);
                CostType* Lr_p2 = mem.getLr(1 - lrID, x,     2);
                CostType* Lr_p3 = mem.getLr(1 - lrID, x + 1, 3);

                Lr_p0[-1] = Lr_p0[D] = MAX_COST;
                Lr_p1[-1] = Lr_p1[D] = MAX_COST;
                Lr_p2[-1] = Lr_p2[D] = MAX_COST;
                Lr_p3[-1] = Lr_p3[D] = MAX_COST;

                CostType* Lr_p = mem.getLr(lrID, x);
                const CostType* Cp = C + x*Da;
                CostType* Sp = S + x*Da;

                CostType* minL = mem.getMinLr(lrID, x);
            }
          
            #代价sp传递到4个方向，并聚合4个路径代价值

                for( ; d < D; d++ )
                {
                    int Cpd = Cp[d], L;
                    int Spd = Sp[d];

                    L = Cpd + std::min((int)Lr_p0[d], std::min(Lr_p0[d - 1] + P1, std::min(Lr_p0[d + 1] + P1, delta0))) - delta0;
                    Lr_p[d] = (CostType)L;
                    minL[0] = std::min(minL[0], (CostType)L);
                    Spd += L;

                    L = Cpd + std::min((int)Lr_p1[d], std::min(Lr_p1[d - 1] + P1, std::min(Lr_p1[d + 1] + P1, delta1))) - delta1;
                    Lr_p[d + Dlra] = (CostType)L;
                    minL[1] = std::min(minL[1], (CostType)L);
                    Spd += L;

                    L = Cpd + std::min((int)Lr_p2[d], std::min(Lr_p2[d - 1] + P1, std::min(Lr_p2[d + 1] + P1, delta2))) - delta2;
                    Lr_p[d + Dlra*2] = (CostType)L;
                    minL[2] = std::min(minL[2], (CostType)L);
                    Spd += L;

                    L = Cpd + std::min((int)Lr_p3[d], std::min(Lr_p3[d - 1] + P1, std::min(Lr_p3[d + 1] + P1, delta3))) - delta3;
                    Lr_p[d + Dlra*3] = (CostType)L;
                    minL[3] = std::min(minL[3], (CostType)L);
                    Spd += L;

                    Sp[d] = saturate_cast<CostType>(Spd);
                }

第二步是反向计算BP

                for( x = width1 - 1; x >= 0; x-- )
                {
                    CostType* Sp = S + x*Da;
                    CostType minS = MAX_COST;
                    short bestDisp = -1;

                    if( npasses == 1 )
                    {
                        CostType* Lr_p0 = mem.getLr(lrID, x + 1);
                        Lr_p0[-1] = Lr_p0[D] = MAX_COST;
                        CostType* Lr_p = mem.getLr(lrID, x);

                        const CostType* Cp = C + x*Da;

                        d = 0;
                        int delta0 = P2 + *mem.getMinLr(lrID, x + 1);
                        int minL0 = MAX_COST;
                        for( ; d < D; d++ )
                        {
                            int L0 = Cp[d] + std::min((int)Lr_p0[d], std::min(Lr_p0[d-1] + P1, std::min(Lr_p0[d+1] + P1, delta0))) - delta0;

                            Lr_p[d] = (CostType)L0;
                            minL0 = std::min(minL0, L0);

                            CostType Sval = Sp[d] = saturate_cast<CostType>(Sp[d] + L0);
                            if( Sval < minS )
                            {
                                minS = Sval;
                                bestDisp = (short)d;
                            }
                        }
                        *mem.getMinLr(lrID, x) = (CostType)minL0;

通过构建前向BP聚合和反向BP聚合，相当于构建了5个方向的路径代价聚合，相当于一个弱化的全局代价函数。

视差计算

                        for( ; d < D; d++ )
                        {
                            int Sval = Sp[d];
                            if( Sval < minS )
                            {
                                minS = (CostType)Sval;
                                bestDisp = (short)d;
                            }
                        }

找最小的代价聚合对应的视差d。

视差后处理

左右一致性原则

\left \| d_{L,R}(x,y) - d_{R,L}(y, x)\right \| < T

 int _x2 = x + minX1 - d - minD;
                    if( mem.disp2cost[_x2] > minS )
                    {
                        mem.disp2cost[_x2] = (CostType)minS;
                        mem.disp2ptr[_x2] = (DispType)(d + minD);
                    }

                    if( 0 < d && d < D-1 )
                    {
                        // do subpixel quadratic interpolation:
                        //   fit parabola into (x1=d-1, y1=Sp[d-1]), (x2=d, y2=Sp[d]), (x3=d+1, y3=Sp[d+1])
                        //   then find minimum of the parabola.
                        int denom2 = std::max(Sp[d-1] + Sp[d+1] - 2*Sp[d], 1);
                        d = d*DISP_SCALE + ((Sp[d-1] - Sp[d+1])*DISP_SCALE + denom2)/(denom2*2);
                    }
                    else
                        d *= DISP_SCALE;
                    disp1ptr[x + minX1] = (DispType)(d + minD*DISP_SCALE);
                }

                for( x = minX1; x < maxX1; x++ )
                {
                    // we round the computed disparity both towards -inf and +inf and check
                    // if either of the corresponding disparities in disp2 is consistent.
                    // This is to give the computed disparity a chance to look valid if it is.
                    int d1 = disp1ptr[x];
                    if( d1 == INVALID_DISP_SCALED )
                        continue;
                    int _d = d1 >> DISP_SHIFT;
                    int d_ = (d1 + DISP_SCALE-1) >> DISP_SHIFT;
                    int _x = x - _d, x_ = x - d_;
                    if( 0 <= _x && _x < width && mem.disp2ptr[_x] >= minD && std::abs(mem.disp2ptr[_x] - _d) > disp12MaxDiff &&
                       0 <= x_ && x_ < width && mem.disp2ptr[x_] >= minD && std::abs(mem.disp2ptr[x_] - d_) > disp12MaxDiff )
                        disp1ptr[x] = (DispType)INVALID_DISP_SCALED;
                }

唯一性检测

\frac{s}{mins} < \frac{100}{100-uniquenessRatio}

如果次最小视差和最小视差的的比值小于某一个阈值就剔除

 

去除离群的小离群点

参考上一章BM所讲的方式通过四连域构建相同的连通域，如果连通域面积小于一定的阈值就剔除。

视差亚像素化

主要采用相邻的视差值采用二次曲线拟合的方式，二次曲线需要三个点进行插值

（d-1, S(d-1)), (d, S(d)) , (d+1, S(d+1))

然后取曲线中的最小值。

                    if( 0 < d && d < D-1 )
                    {
                        // do subpixel quadratic interpolation:
                        //   fit parabola into (x1=d-1, y1=Sp[d-1]), (x2=d, y2=Sp[d]), (x3=d+1, y3=Sp[d+1])
                        //   then find minimum of the parabola.
                        int denom2 = std::max(Sp[d-1] + Sp[d+1] - 2*Sp[d], 1);
                        d = d*DISP_SCALE + ((Sp[d-1] - Sp[d+1])*DISP_SCALE + denom2)/(denom2*2);
                    }
                    else
                        d *= DISP_SCALE;

滤波处理

采用双边滤波或者均值滤波，会更平滑。双边滤波可以参考https://blog.csdn.net/u013066730/article/details/87859184

 

算法优化

  • 只采用前后左右这四个方向的聚合，这个时候可以先水平方向上的并行聚合处理，然后再进行垂直方向的并行聚合
  • 直接在垂直方向上分多块进行分别求解代价值，每一块进行了一定程度上的重叠这样可以实现并行。

 

sxk20091111
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
vs2015+opencv2.4.10实现的双目立体视觉三维重建c++代码
06-11
vs2015+opencv2.4.10实现的双目立体视觉三维重建c++代码。SGBM立体匹配
opencv双目测距-SGBM、BM算法输出深度图完整程序（三角视差测距法）
ADDfish的博客
12-15 9736
前言 本篇文章是在高博的一起做RGB-D SLAM 系列 的基础上修改代码，增加了单、双目接口以及实时点云图构建和路径显示功能，并利用词袋模型进行闭环检测，实现了一个简易单双目slam系统。
VS2017+OpenCV3.3基于SGBM算法的双目立体视觉、双目测距（双目校正和立体匹配）(文档里包含了测试图片)
08-13
VS2017+OpenCV3.3基于SGBM算法的双目立体视觉、双目测距（双目校正和立体匹配）(文档里包含了测试图片)
python实现SGBM图像匹配算法
01-24
使用python3.7实现SGBM算法，通过调用opencv库函数来实现图像匹配，计算出左右图的视差图
基于VS2017+opencv3.4.3的立体匹配SGBM与BM算法代码
11-19
基于VS2017+opencv3.4.3的立体匹配SGBM与BM算法代码，opencv更新后，SGBM与SM的调用也发生改变，在网上查了一大圈后，终于将代码成功运行出来了。（注：此代码不涉及两种算法的具体流程，只是基于opencv库的成功调用运行，每个代码就60行左右。想看算法原理的就别下了）
OpenCV学习笔记（18）双目测距与三维重建的OpenCV实现问题集锦（三）立体匹配与视差计算
热门推荐
晨宇思远
10-26 11万+
四、双目匹配与视差计算立体匹配主要是通过找出每对图像间的对应关系，根据三角测量原理，得到视差图；在获得了视差信息后，根据投影模型很容易地可以得到原始图像的深度信息和三维信息。立体匹配技术被普遍认为是立体视觉中最困难也是最关键的问题，主要是以下因素的影响：（1） 光学失真和噪声（亮度、色调、饱和度等失衡）（2） 平滑表面的镜面反射（3） 投影缩减（Foreshortening）（4） 透视失真（Perspective distortions）（5） 低纹理（Low texture）（6） 重复纹理（Repet
KITTI下使用SGBM立体匹配算法获得深度图
逆水独流的博客
03-22 4373
KITTI下使用SGBM立体匹配算法获得深度图 以下内容不涉及原理，仅为工程性内容： 经典的立体匹配算法主要由：BM（Block Matching），SGBM（Semi-Global Block matching），GC。更高级的就直接用上了深度学习，这里就不在考虑了。 上述三种算法速度：BM > SGBM > GC，效果：BM < SGBM < GC；暂取折中的SGBM算...
视觉深度图后处理中空洞填充问题
qq_41641044的博客
10-10 3879
在双目SGBM匹配之后，由于遮挡和误匹配等问题，最后出来的深度图会存在很多噪点和空洞，这些问题无法通过某一种滤波方法解决，对于这个问题我尝试自己写了一个脚本，能比较好的去除空洞。代码如下： 头文件hole_filling.h #pragma once #include<iostream> #include <opencv2/opencv.hpp> #include<typeinfo> #include<algorithm> #include<vector
[双目视差] 立体匹配算法推理 - SGBM算法（二）
yegeli的博客
08-18 2708
文章目录[双目视差] 立体匹配算法推理 - SGBM算法（二）一、SGM算法二、 后处理 [双目视差] 立体匹配算法推理 - SGBM算法（二） 一、SGM算法 SGM算法的全称为Semi-Global Matching，网上关于它的介绍有很多不细讲，它的论文出处详见文末参考文献，但是这里也要为作者赞一把，很牛逼。 SGM其实本质上还是一种代价聚合算法，和局部立体匹配算法中的代价聚合很像，不然也不会叫Semi-Global了（当然也不全是哈，重点在后面~），而Global又是从何而来呢？为了达到和全局立体匹
【双目视觉】 SGBM算法应用（Python版）
yzfzzz的博客
08-22 1万+
我们可以通过cv.remap()函数来将img2映射到img1对应位置上并合成。：重映射，即把一幅图像内的像素点放置到另外一幅图像内的指定位置，俗称“拼接”四种模式，它们的精度和速度呈反比，可根据情况来选择不同的模式.自制的标定数据集，必须用自己相机拍摄照片制作数据集。函数为opencv集成的算法；会降低精度，但提高速度。
SAD、BM、SGBM算法获得视差图
07-02
调用opencv库提供的BM以及SGBM算法获得效果较好的视差图。其中算法具体参数详解见http://blog.csdn.net/this_is_chris/article/details/51810735，SAD算法参考网上自己实现，效果不是很好。
基于python-opencv实现SGBM
12-12
直接替换文件运行即可，增加wls滤波选择。
SGBM你不知道的秘密：深入探讨SGBM参数影响效果
3D视觉工坊
06-28 210
作者：小张Tt | 来源：3DCV添加微信：cv3d007, 备注：立体匹配， 拉你入群。文末附行业细分交流群。什么是SGBMSGBM（Semi-Global Block Matching）是一种用于计算双目视觉中视差（disparity）的半全局匹配算法，在OpenCV中的实现为semi-global block matching（SGBM）。它是基于全局匹配算法和局部匹配算法的优缺点，提出了一...
SGBM参数意义
qq_37053137的博客
04-04 716
转自：https://blog.csdn.net/wwp2016/article/details/86080722 博主写得很详细！！ blockSize = 3 param = {'minDisparity': 0, 'numDisparities': 128, 'blockSize': blockSize, 'P1': 8 * img_channels * blockSize ** 2, ..
双目立体视觉建立深度图_【3D视觉】立体匹配成像算法BM，SGBM，GC，SAD一览
weixin_29113371的博客
01-04 1593
点击上方“新机器视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达在深度相机的主流技术方案Structure Light，ToF，Stereo Dual)中，主动双目成像方案可以基于低成本的硬件，获得高分辨率、高精度的深度图像，但是立体匹配算法(stereo matching)复杂，对计算资源消耗很大。那我们介绍下几种经典的双目匹配的算法。【双目匹配】双目立体视觉理论建立在对人类视觉...
opencv SGBM 练习总结
weixin_39266208的博客
11-14 3732
标定，得到相机内参矩阵，或直接读取以前保留的标定结果，标定过程见https://blog.csdn.net/weixin_39266208/article/details/120955007 利用VideoCapture打开双目摄像头，读取并分割成左右两张图像。 通过stereoRectify initUndistortRectifyMap remap 得到校正后的图像，两张图像在同一坐标平面，y对齐。 StereoSGBM_create(python) + compute得到视差。 然后通过repro.
局部立体匹配算法BM中的匹配代价聚合方法
Alfred's Blog
05-17 5947
Block Matching methods The following matching costs are defined for patches centered at the pixel positions  and . The matching costs described below are trivially extended to color images by no
双目立体视觉匹配算法之视差图disparity计算——SAD算法、SGBM算法
hitzijiyingcai的博客
10-19 2万+
一、SAD算法 1.算法原理         SAD(Sum of absolute differences)是一种图像匹配算法。基本思想：差的绝对值之和。此算法常用于图像块匹配，将每个像素对应数值之差的绝对值求和，据此评估两个图像块的相似度。该算法快速、但并不精确，通常用于多级处理的初步筛选。 2.基本流程 输入：两幅图像，一幅Left-Image，一幅Right-Image 对左图，依...
基于matlab实现的空间调制通信过程，包含信号调制、天线选择等发送过程，以及采用最大似然估计的检测过程 .rar
最新发布
05-02
基于matlab实现的空间调制通信过程，包含信号调制、天线选择等发送过程，以及采用最大似然估计的检测过程。.rar
sgbm双目立体匹配算法
08-24
SGM（Semi-Global Matching）是一种常用的双目视觉立体匹配算法，而 SGBM（Semi-Global Block Matching）是 SGM 算法的改进版本。SGBM 算法在 SGM 算法的基础上引入了块匹配策略，可以提高匹配效果和计算速度。 SGBM 算法首先将图像进行预处理，包括灰度化、直方图均衡化等操作。然后通过计算代价体积（cost volume），即每个像素与搜索窗口内所有像素之间的代价，来表示匹配程度。接着，使用代价聚合方法计算每个像素点的聚合代价，以找到最佳匹配。最后，通过优化路径成本来获得一致性检验结果，并生成视差图。 SGBM 算法的优点是能够在不同场景下实现较好的立体匹配效果，并且具有较快的计算速度。然而，它也存在一些局限性，例如对纹理较弱、光照变化大等情况下可能会出现匹配错误的情况。因此，在实际应用中需要根据具体情况选择合适的算法或进行算法改进来提升匹配精度和鲁棒性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值