视觉SLAM课程-第6讲作业

已于 2024-09-02 10:31:13 修改
阅读量6.5k 收藏 11
点赞数 3
分类专栏： SLAM 文章标签： slam c++
于 2022-03-20 11:43:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37746927/article/details/123609423
版权

课程Github地址：https://github.com/wrk666/VSLAM-Course/tree/master
第6讲作业

2. T2

2.1 光流文献综述

文献还没读完，这部分参考博客

2.2 forward-addtive Gauss-Newton 光流的实现

在这里插入图片描述
在这里插入图片描述
核心代码和结果：
Listing1：

                    // TODO START YOUR CODE HERE (~8 lines)
                    //计算误差
                    double error = GetPixelValue(img1, kp.pt.x + x, kp.pt.y + y)-GetPixelValue(img2, kp.pt.x + x + dx, kp.pt.y + y + dy);
                    Eigen::Vector2d J;  // Jacobian
                    if (inverse == false)
                    {
                        // Forward Jacobian  前向雅可比（因为是离散的，不能用微分，使用中心差分方式来进行求导）
                        J = -1.0 * Eigen::Vector2d(
                                0.5 * (GetPixelValue(img2,kp.pt.x + dx + x + 1, kp.pt.y + dy + y)-GetPixelValue(img2, kp.pt.x + dx + x -1, kp.pt.y + dy + y)),
                                0.5 * (GetPixelValue(img2, kp.pt.x + dx + x, kp.pt.y+ dy + y + 1)- GetPixelValue(img2, kp.pt.x + dx + x, kp.pt.y + dy + y -1))
                                );
                    }
                    else
                    {
                        if(iter == 0 )
                        // Inverse Jacobian
                        // NOTE this J does not change when dx, dy is updated, so we can store it and only compute error
                        //反向模式，使用I1处的梯度替换I2处的梯度，雅可比不随dx，dy的改变而改变，所以不加dx，dy
                        {
                            J = -1.0 * Eigen::Vector2d(
                                    0.5 * (GetPixelValue(img2,kp.pt.x + x + 1, kp.pt.y + y)-
                                           GetPixelValue(img2, kp.pt.x +  x -1, kp.pt.y + y)),
                                    0.5 * (GetPixelValue(img2, kp.pt.x +  x, kp.pt.y + y + 1)-
                                           GetPixelValue(img2, kp.pt.x +  x, kp.pt.y + y -1))
                                    );
                        }
                    }
                    // compute H, b and set cost;
                    b += -error * J;
                    cost += error * error;
                    if(inverse==false || iter==0)  //如果是正向或者是第一次迭代，就需要更新系数矩阵H
                    {
                        H +=  J * J.transpose() ;  //这里的雅可比定义出来是J^T，直接就是向量，求H要得是矩阵，所以得J*J^T
                    }
                    // TODO END YOUR CODE HERE
                }
            // compute update  更新
            // TODO START YOUR CODE HERE (~1 lines)
            Eigen::Vector2d update = H.ldlt().solve(b);  //求解方程H[dx,dy]^T=b
            // TODO END YOUR CODE HERE

图 2.1 前向 G-N 光流与 OpenCV 光流对比：
图 2.1 前向 G-N 光流与 OpenCV 光流对比

2.3 反向法

在这里插入图片描述
图 2.2 反向 G-N 光流与 OpenCV 光流对比
在这里插入图片描述

2.4 推广至金字塔

在这里插入图片描述
在这里插入图片描述

Listing2

void OpticalFlowMultiLevel(
        const Mat &img1,
        const Mat &img2,
        const vector<KeyPoint> &kp1,
        vector<KeyPoint> &kp2,
        vector<bool> &success,
        bool inverse) {

    // parameters
    int pyramids = 4;  //4层金字塔
    double pyramid_scale = 0.5;  //缩放率为0.5
    double scales[] = {1.0, 0.5, 0.25, 0.125};

    // create pyramids
    vector<Mat> pyr1, pyr2; // image pyramids
    // TODO START YOUR CODE HERE (~8 lines)
    for (int i = 0; i < pyramids; i++) {
        if(i==0)
        {
            pyr1.push_back(img1);
            pyr2.push_back(img2);
        }
        else
        {
            Mat img1_pyr, img2_pyr;
            //自底向上缩放
            cv::resize(pyr1[i-1], img1_pyr, cv::Size(pyr1[i-1].cols * pyramid_scale, pyr1[i-1].rows * pyramid_scale));
            cv::resize(pyr2[i-1], img2_pyr, cv::Size(pyr2[i-1].cols * pyramid_scale, pyr2[i-1].rows * pyramid_scale));
            pyr1.push_back(img1_pyr);
            pyr2.push_back(img2_pyr);
        }
    }
    // TODO END YOUR CODE HERE

    // coarse-to-fine LK tracking in pyramids
    // TODO START YOUR CODE HERE
    vector<KeyPoint> kp1_pyr, kp2_pyr;  //特征点金字塔

//    int tmp_level = pyramids;
    for(auto &kp:kp1)
    {
        auto kp_top = kp;

        kp_top.pt *= scales[pyramids - 1];
        kp1_pyr.push_back(kp_top);
        kp2_pyr.push_back(kp_top);
    }

    for(int level = pyramids-1; level>=0; level--)
    {
        success.clear();
        OpticalFlowSingleLevel(pyr1[level], pyr2[level], kp1_pyr, kp2_pyr, success, inverse);

        if(level>0)
        {
            for(auto &kp: kp1_pyr)  //引用，改变源数据
                kp.pt /= pyramid_scale;
            for(auto &kp: kp2_pyr)
                kp.pt /= pyramid_scale;
        }
    }

    // don't forget to set the results into kp2
    for(auto &kp: kp2_pyr)
        kp2.push_back(kp);
    // TODO END YOUR CODE HERE
}

图 2.4 正向金字塔 G-N 光流与 OpenCV 光流对比
在这里插入图片描述
图 2.5 反向金字塔 G-N 光流与 OpenCV 光流对比
在这里插入图片描述

2.5 并行化

在这里插入图片描述

    vector<int> indexes;
    for (int (i) = 0; (i) < kp1.size(); ++(i))
        indexes.push_back(i);
    std::mutex m;
    std::lock_guard<std::mutex> guard(m);//代替m.lock; m.unlock();
    for_each(execution::par_unseq, indexes.begin(), indexes.end(),
                  [&](auto& i)
                  {
                  //和单层光流一样
                  });

在这里插入图片描述

2.6 讨论

在这里插入图片描述
图 2.6 8 × 8 和 16 × 16 的窗口对比
在这里插入图片描述
在这里插入图片描述
图 2.7 \quad 3、 5、 7 层金字塔对比
在这里插入图片描述
在这里插入图片描述
图 2.7 \quad 0.25， 0.5， 0.75 缩放率对比
在这里插入图片描述

3. 直接法

3.1 单层直接法

之前一直对各种坐标和各种变换莫不太清，这题通过手抄一些代码，差不多弄懂了，总结一下：
借鉴博客

  1. 世界坐标是相对于每一帧图像处的相机所观测到的3D坐标，一个点的3D坐标会因相机的位姿不同而不同。2D坐标常指像素坐标， K P + t = 1 Z [ u 1 , v 1 , 1 ] T KP+t=\frac{1}{Z}[u_1,v_1,1]^T KP+t=Z1​[u1​,v1​,1]T，去掉了深度信息。
  2. 从图像中读取的都是通过2D坐标读取的ref的 [ u 1 , v 1 , 1 ] T [u_1,v_1,1]^T [u1​,v1​,1]T，根据2D坐标读到的是光度值，
  3. 根据disparity能算得 I r e f I_ref Ir​ef的每个点的深度值，即第一张图片中的相机处观测到的这个点的Z
  4. 像素的2D坐标结合深度信息，通过针孔相机模型计算出此点的3D坐标 p o i n t r e f point_{ref} pointref​

X = ( u − c x ) ∗ Z f x Y = ( v − c y ) Z f y Z = d e p t h X = (u-c_x)*\frac{Z}{f_x} \\ Y = (v-c_y)\frac{Z}{f_y}\\ Z = depth X=(u−cx​)∗fx​Z​Y=(v−cy​)fy​Z​Z=depth
5. 要估计的是 I 1 I_1 I1​-> I 2 I_2 I2​的变换矩阵 T 21 T_{21} T21​，而这个变换是3D坐标的变换，所以
p o i n t c u r = T 21 ∗ p o i n t r e f = [ X ′ Y ′ Z ′ ] T point_{cur}=T{21}*point_{ref} = \begin{bmatrix} X' & Y' & Z' \end{bmatrix}^T pointcur​=T21∗pointref​=[X′​Y′​Z′​]T
得到 I 2 I_2 I2​下的3D坐标
6. 再将 I 2 I_2 I2​下的3D坐标变换为像素坐标
u 2 = f x ∗ X ′ Z ′ + c x v 2 = f y ∗ Y ′ Z ′ + c y u_2 = f_x*\frac{X'}{Z'}+c_x \\ v_2 = f_y * \frac{Y'}{Z'}+c_y u2​=fx​∗Z′X′​+cx​v2​=fy​∗Z′Y′​+cy​
然后判断此时的 u 2 , v 2 u_2,v_2 u2​,v2​是否越界，若未越界则为good。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
核心代码如 Listing4 所示，对第一张图的直接法结果如图 3.1 所示：
Listing4


    for (int iter = 0; iter < iterations; iter++) {
        nGood = 0;
        goodProjection.clear();

        // Define Hessian and bias
        Matrix6d H = Matrix6d::Zero();  // 6x6 Hessian
        Vector6d b = Vector6d::Zero();  // 6x1 bias

        for (size_t i = 0; i < px_ref.size(); i++)
        {

            // compute the projection in the second image
            // TODO START YOUR CODE HERE
            Eigen::Vector3d point_ref = depth_ref[i] * Eigen::Vector3d((px_ref[i][0]-cx)/fx, (px_ref[i][1]-cy)/fy, 1);  //ref中的3D点坐标
            Eigen::Vector3d point_cur = T21 * point_ref;  //ref中的3D点转换到cur中的3D点
            if (point_cur[2] < 0)   // depth invalid
                continue;

            float u = fx * point_cur[0]/point_cur[2] + cx, v = fy * point_cur[1]/point_cur[2] + cy;
            if(u<half_patch_size || u+half_patch_size>img2.cols || v<half_patch_size || v+half_patch_size>img2.rows)  //变换到cur中若越界则不优化
                continue;

            double X = point_cur[0], Y = point_cur[1], Z = point_cur[2], inv_z = 1.0 / Z, inv_z2 = inv_z * inv_z;  //cur中的3D坐标X'Y'Z'
            nGood++;
            goodProjection.push_back(Eigen::Vector2d(u, v));

            // and compute error and jacobian
            for (int x = -half_patch_size; x < half_patch_size; x++)
                for (int y = -half_patch_size; y < half_patch_size; y++)
                {
                    double error =  GetPixelValue(img1, px_ref[i][0]+x, px_ref[i][1]+y) -
                                    GetPixelValue(img2, u+x, v+y);

                    Eigen::Vector2d J_img_pixel;    // image gradients(2*1)  像素梯度,使用cur中的像素坐标和窗口偏移量x，y计算*
                    J_img_pixel<<(1.0 / 2) * (GetPixelValue(img2, u+1+x, v+y)-GetPixelValue(img2, u-1+x, v+y)),
                            (1.0 / 2) * (GetPixelValue(img2, u+x, v+1+y)-GetPixelValue(img2, u+x, v-1+y));

                    Matrix26d J_pixel_xi;   // pixel to \xi in Lie algebra  2*6
                    J_pixel_xi<<fx * inv_z,
                                0,
                                -fx * X * inv_z2,
                                -fx * X * Y * inv_z2,
                                fx + fx * X * X * inv_z2,
                                -fx * Y * inv_z,
                                0,
                                fy * inv_z,
                                -fy * Y * inv_z2,
                                -fy - fy * Y * Y * inv_z2,
                                fy * X * Y * inv_z2,
                                fy * X * inv_z;

                    // total jacobian   应该是1*6的
                    Vector6d J=-1.0 * (J_img_pixel.transpose() * J_pixel_xi).transpose();

                    H += J * J.transpose();
                    b += -error * J;
                    cost += error * error;
                }
            // END YOUR CODE HERE
        }

        // solve update and put it into estimation
        // TODO START YOUR CODE HERE
        Vector6d update = H.ldlt().solve(b);
        T21 = Sophus::SE3d::exp(update) * T21;  //李群更新
        // END YOUR CODE HERE

图 3.1 单层直接法第一张图结果
在这里插入图片描述

3.2 多层直接法

  1. 在缩放图像时，图像内参也需要跟着变化。那么，例如图像缩小一倍，
    fx, fy, cx, cy 应该如何变化？
    相机内参也应该对应金字塔的层数做与图像对应的缩放，如 Listing5
    所示

Listing5

void DirectPoseEstimationMultiLayer(
        const cv::Mat &img1,
        const cv::Mat &img2,
        const VecVector2d &px_ref,
        const vector<double> depth_ref,
        Sophus::SE3d &T21,
        string order
) {

    // parameters  4层2倍金字塔
    int pyramids = 4;
    double pyramid_scale = 0.5;
    double scales[] = {1.0, 0.5, 0.25, 0.125};

    // create pyramids
    vector<cv::Mat> pyr1, pyr2; // image pyramids
    // TODO START YOUR CODE HERE  构建图像金字塔
    for(int i=0; i<pyramids; i++)
    {
        if(i==0)
        {
            pyr1.push_back(img1);
            pyr2.push_back(img2);
        }
        else
        {
            Mat img1_pyr, img2_pyr;
            //自底向上缩放
            cv::resize(pyr1[i-1], img1_pyr, cv::Size(pyr1[i-1].cols * pyramid_scale, pyr1[i-1].rows * pyramid_scale));   //Size(width, height)
            cv::resize(pyr2[i-1], img2_pyr, cv::Size(pyr2[i-1].cols * pyramid_scale, pyr2[i-1].rows * pyramid_scale));
            pyr1.push_back(img1_pyr);
            pyr2.push_back(img2_pyr);
        }
    }

    // END YOUR CODE HERE
    //构建特征点金字塔
    double fxG = fx, fyG = fy, cxG = cx, cyG = cy;  // backup the old values
    for (int level = pyramids - 1; level >= 0; level--) {
        VecVector2d px_ref_pyr; // set the keypoints in this pyramid level
        for (auto &px: px_ref) {
            px_ref_pyr.push_back(scales[level] * px);
        }

        // TODO START YOUR CODE HERE
        // scale fx, fy, cx, cy in different pyramid levels
        fx = fxG * scales[level];
        fy = fyG * scales[level];
        cx = cxG * scales[level];
        cy = cyG * scales[level];
        // END YOUR CODE HERE
        DirectPoseEstimationSingleLayer(pyr1[level], pyr2[level], px_ref_pyr, depth_ref, T21, order);
    }
}

第 5 张图的结果如图 3.2-3.6 所示

图 3.2 多层直接法，图 5 第 4层
在这里插入图片描述

图 3.3 多层直接法，图 5 第 3 层
在这里插入图片描述

图 3.4 多层直接法，图 5 第 2 层
在这里插入图片描述

图 3.5 多层直接法，图 5 第 1 层
在这里插入图片描述

图 3.6 估计结果
在这里插入图片描述
估计结果有些差别，但在0.5米内，可以接受。

3.3 并行化

使用 for_each 和 execution 进行改进，在遍历 ref 中的特征点处使用
多线程并发，注意在对有序容器进行插入前需要加锁，核心代码如Listing6所示：
Listing6

        // Define Hessian and bias
        Matrix6d H = Matrix6d::Zero();  // 6x6 Hessian
        Vector6d b = Vector6d::Zero();  // 6x1 bias

        vector<int> ref_index;
        for(int i=0;i<px_ref.size();++i)
            ref_index.push_back(i);

        std::mutex m;
        for_each(execution::par_unseq, ref_index.begin(), ref_index.end(),
                 [&](auto& i)
                 {
                     // compute the projection in the second image
                     // TODO START YOUR CODE HERE
                     Eigen::Vector3d point_ref = depth_ref[i] * Eigen::Vector3d((px_ref[i][0]-cx)/fx, (px_ref[i][1]-cy)/fy, 1);  //ref中的3D点坐标
                     Eigen::Vector3d point_cur = T21 * point_ref;  //ref中的3D点转换到cur中的3D点
                     if (point_cur[2] >= 0)   // depth invalid
                     {
                         float u = fx * point_cur[0]/point_cur[2] + cx, v = fy * point_cur[1]/point_cur[2] + cy;
                         if(u>=half_patch_size && u+half_patch_size<=img2.cols && v>=half_patch_size && v+half_patch_size<=img2.rows)  //变换到cur中若越界则不优化
                         {
                             double X = point_cur[0], Y = point_cur[1], Z = point_cur[2], inv_z = 1.0 / Z, inv_z2 = inv_z * inv_z;  //cur中的3D坐标X'Y'Z'
                             nGood++;
                             std::lock_guard<std::mutex> guard(m);//代替m.lock; m.unlock();
                             //记录投影前后的uv坐标
                             goodProjection.push_back(Eigen::Vector2d(u, v));
                             GoodRefIndex.push_back(Eigen::Vector2d(px_ref[i][0],px_ref[i][1]));

选择两张 000001.png 和 000002.png 分别与单进程进行对比，普通单层
和并行化单层运行时间比较如图 3.7-3.8 所示

图 3.7 估计结果 _1
在这里插入图片描述
在这里插入图片描述

图 3.8 估计结果 _2
在这里插入图片描述
在这里插入图片描述
可以看出，并行化之后速度略微有些变慢，具体是什么原因呢？和上一次的作业中一样的问题，实验过后发现先执行一遍普通的，再执行并行化，并行化速度才会变快…

3.4 延伸讨论

在这里插入图片描述
在这里插入图片描述

4. 使用光流计算视差

使用 LK 光流计算 left 中的 GFTT 特征点在 right 中的对应，根据坐
标的对应关系计算出水平视差，计算视差的核心代码如 Listing7 所示，计
算结果如图 4.1 所示， OpenCV 的光流法之后的视差平均误差为-24.5884。
参考博客中的这个应该是用了直接法，在直接法中提前用了深度图，光流法只是进行特征点匹配，具体来说只是算出left的2D相对运动，根据运动计算出left中的特征点在right中的对应位置，而博客中最后算出了变换矩阵，明显不是光流法，所以结果和我的不同，如果哪位同学做的和我不一样可以和我讨论一下。
Listing7

    //OpenCV
    Mat img2_CV;
    cv::cvtColor(img2, img2_CV, CV_GRAY2BGR);
    for (int i = 0; i < pt2.size(); i++) {
        if (status[i]) {
            cv::circle(img2_CV, pt2[i], 2, cv::Scalar(0, 250, 0), 2);
            cv::line(img2_CV, pt1[i], pt2[i], cv::Scalar(0, 250, 0));
            dis = kp1[i].pt.x - kp2_single[i].pt.x;
            cost.push_back(dis- GetPixelValue(disparity_img, kp1[i].pt.x, kp1[i].pt.y));
        }
    }
    cost_sum = accumulate(cost.begin(), cost.end(), 0.0);  //求和
    cout<<"OpenCV光流平均误差："<<cost_sum/cost.size()<<endl;
    cost.clear();

在这里插入图片描述

开始下一章。

读书健身敲代码
关注
专栏目录
视觉SLAM入门 -- 学习笔记 - Part2
～勿据散客～的博客
10-13 310
熟悉 Eigen 矩阵运算 设线性方程 Ax = b，在 A 为⽅阵的前提下，请回答以下问题： 1. 在什么条件下，x 有解且唯⼀？ A满秩，det(A) ≠ 0， 当非齐次线性方程在A的秩与[A|B]的秩相同时方程有解； 当R(A|b) = R(A) = n（n为未知数个数）时有唯一解。 2. 高斯消元法的原理是什么？ 3. QR 分解的原理是什么？ 4. Cholesky 分解的原理是什么？ 5. 编程实现 A 为 100 × 100 随机矩阵时，⽤ QR 和 Cholesky 分解求 x 的程序。 几
视觉SLAM入门 -- 学习笔记 - Part 1
～勿据散客～的博客
10-13 966
熟悉Linux 1. 如何在Ubuntu 中安装软件（命令⾏界⾯）？它们通常被安装在什么地⽅？ 软件安装命令行： ubuntu下安装软件有四种方式: 1.通过deb格式的离线软件包安装 sudo dpkg -i xxx.deb # 安装包,安装程序 -i: install sudo dpkg -r package # 删除包 -r: remove 此方法的默认安装目录为: /opt 2.通过apt-get包管理器从软件源中在线安装(最常用的方式) sudo apt-get install 软件
深蓝学院-视觉SLAM理论与实践-第十二期-第6章作业
weixin_40918019的博客
03-22 3858
LK光流 问题1：光流文献综述 问题2：forward-addtive Gauss-Newton 光流的实现 从最小二乘角度来看，每个像素的误差怎么定义？ 像素的误差指的是匹配像素的差值 误差相对于自变量的导数如何定义？ 利用导数的定义求解图像对坐标的导数(img(i,j+1)−img(i,j−1))/2(img(i,j+1)-img(i,j-1))/2(img(i,j+1)−img(i,j−1))/2 主要思想 利用导数的定义求解图像对坐标的导数(img(i,j+1)−img(i,j−1))/2(img
视觉SLAM理论与实践6-2
whut_chengjun的博客
12-25 582
视觉SLAM理论与实践-直接法一、直接法基础介绍二、单层直接法三、多层直接法四、延申讨论 一、直接法基础介绍 二、单层直接法 该问题的误差项为： 其中p1,p2 为非其次像素坐标，ξ为R,t对应的李代数 本题目中位姿的自由度为6，误差函数中的光度的变化是1维的数据，所以雅克比矩阵为1×6，误差项相对于自变量的雅克比维度为1×6．求解过程如下： 有上式可知，一阶导由于链式法...
深蓝学院-视觉SLAM十四讲-第六章作业
记录和分享
11-16 3651
第六节课作业 2. LK光流 2.1 光流文献综述 问题： 按此文的分类，光流法可分为哪几类？ 算法分类 应用例子 复杂度 可以应用的场景 Forwards Additive(正向加性) Lucas-Kanade (1981) O(n2N+n3)O(n^2 N + n^3)O(n2N+n3) Any warp Forwards Compositional（正向组合） Shum-Szeliski (2000) O(n2N+n3)O(n^2N + n^3)O(n2N+n3) Any se
视觉SLAM十四讲学习笔记-第六讲-非线性优化的实践-高斯牛顿法和曲线拟合
weixin_36773706的博客
01-13 2269
专栏系列文章如下： 视觉SLAM十四讲学习笔记-第一讲_goldqiu的博客-CSDN博客 视觉SLAM十四讲学习笔记-第二讲-初识SLAM_goldqiu的博客-CSDN博客 视觉SLAM十四讲学习笔记-第二讲-开发环境搭建_goldqiu的博客-CSDN博客 视觉SLAM十四讲学习笔记-第三讲-旋转矩阵和Eigen库_goldqiu的博客-CSDN博客 视觉SLAM十四讲学习笔记-第三讲-旋转向量、欧拉角、四元数_goldqiu的博客-CSDN博客 视觉SLAM十四讲学习笔记-第三讲-相..
深蓝-视觉slam-第六讲学习笔记
weixin_46417419的博客
04-19 1133
不需要特征匹配好的点就可以估计相机的位姿
课后作业 视觉SLAM 十四讲
04-23
总的来说，这个视觉SLAM十四讲的课程旨在提供一个全面的学习路径，帮助学生掌握从理论到实践的视觉SLAM技术，为未来的机器人导航、自动驾驶等领域打下坚实基础。通过系统地研究每个部分，你将有能力设计和实施自己的...
slam14讲习题作业
02-28
这个“slam14讲习题作业”压缩包似乎包含了高翔教授关于SLAM的课程学习资料，包括代码、习题和论文集，对于学习者来说是一份宝贵的资源。 首先，我们要了解SLAM的基本概念。SLAM是指机器人在未知环境中移动时，同时...
视觉SLAM入门 -- 学习笔记 - Part3
～勿据散客～的博客
10-23 429
2 群的性质 1. fZ;+g 是否为群？若是，验证其满⾜群定义；若不是，说明理由。 2. fN;+g 是否为群？若是，验证其满⾜群定义；若不是，说明理由。 其中Z 为整数集，N 为⾃然数集。 3 验证向量叉乘的李代数性质 附： ⾃反性是指⾃⼰与⾃⼰的运算为零 4 推导SE(3) 的指数映射(2 分，约1 小时) 课上给出了SO(3) 的指数映射推导，但对于SE(3)，仅介绍了结论，没有给出详细推导。请你完成SE(3) 指数映射部分，有关左雅可⽐的详细推导。 这也正是课件⾥提到的左雅可⽐。 提⽰：
深蓝学院视觉slam十四讲第6章作业
Jevin-L的博客
07-07 2321
每个像素的误差为第一张图像在特征点(x, y) 处的像素值减去第二张图像在(x+dx, y+dy) 处的像素值 记自变量为[Δx,Δy]T[\Delta x, \Delta y]^T[Δx,Δy]T，用中值查分表示图像梯度，导数为 [−dI2dΔx−dI2dΔy]=[−I2(x+Δx+1,y+Δy)−I2(x+Δx−1,y+Δy)2−I2(x+Δx,y+Δy+1)−I2(x+Δx,y+Δy−1)2]\begin{bmatrix} -\dfrac{d I_2}{d\Delta x} \\ \\ -\d..
视觉SLAM深蓝学院作业解答
Charles的博客
03-06 3636
视觉SLAM深蓝学院作业解答（正在更新）3-6 轨迹的描绘 最近整理一下之前所做的深蓝学院视觉SLAM课程的作业，因为发现从做作业的过程中收获很大。 3-6 轨迹的描绘 程序代码： #include <sophus/se3.h> #include <string> #include <iostream> #include <fstream> #in...
深蓝学院-视觉SLAM课程-第6讲笔记
qq_37746927的博客
03-14 947
视觉SLAM第6讲笔记
尝试运行示例：LK光流
一个搬运知识的笨小孩
05-09 347
CMakeLists.txt cmake_minimum_required(VERSION 3.13) project(opticalflow) set(CMAKE_CXX_STANDARD 14) //# set(OpenCV_DIR /usr/local/opencv4/lib/cmake/opencv4) find_package(OpenCV REQUIRED) include_directories(${OpenCV_INCLUDE_DIRS}) include_directories("/
深蓝学院视觉SLAM第六次习题（上）
weixin_44218240的博客
05-09 2409
现在的内容更加注重实践，对于我来说也更加需要时间了，好难 1.LK 光流 1.1光流文献综述 问题： 按此文的分类，光流法可分为哪几类？ 可将算法分类为加性算法(additive)或组合算法(compositional)，以及正向算法(forwards)或逆算法(inverse) 在 compositional 中，为什么有时候需要做原始图像的 wrap？该 wrap 有何物理意义？ 需要在当前位姿估计之前引入增量式 warp（incremental warp）以建立半群约束要求（the se
视觉SLAM十四讲 读书编程笔记 Chapter8 视觉里程计2
wolfcsharp的博客
08-31 589
Chapter8 后端2
深蓝学院视觉SLAM第六次习题（下）
weixin_44218240的博客
05-11 2032
2.直接法
视觉SLAM十四讲学习笔记——第八讲 视觉里程计（3）
weixin_61294345的博客
11-21 2830
前文提到的特征点法基本过程为： （1）提取关键点并计算描述子，得到特征点后进行两幅图像间的匹配。 （2）构建最小二乘问题：最小化重投影误差（图像平面上或者世界坐标系下）。 （3）迭代优化求出最优解，确定摄像机运动参数。 上述过程中，特征点的提取最为耗时，因为要遍历整场图像并计算描述子。因此这一章引出了光流法和直接法，二者都是基于“最小光度误差”进行求解，但解决问题的方法不同： 光流法：本质上是替代图像间特征点匹配的过程，使用“灰度不变”的假设确定关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值