Dyna-SLAM代码解读：Geometry.cc（五）

最新推荐文章于 2024-07-14 12:25:25 发布
最新推荐文章于 2024-07-14 12:25:25 发布
阅读量84 收藏 1
点赞数 1
分类专栏： Dyna-SLAM 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63293091/article/details/132141585
版权 
for (int j(0); j < p; j++)
            {

                int _x = (int)vPixels.at<float>(j, 0);
                int _y = (int)vPixels.at<float>(j, 1);
                float x = vProjPixels.at<float>(j, 0); // x of *
                float y = vProjPixels.at<float>(j, 1); // y of *
                /*
                    -----------
                    | A  | B  |
                    ----*------ y
                    | C  | D  |
                    -----------
                         x
                */
                float x_a = floor(x);
                float y_a = floor(y);
                float x_b = ceil(x);
                float y_b = floor(y);
                float x_c = floor(x);
                float y_c = ceil(y);
                float x_d = ceil(x);
                float y_d = ceil(y);

                float weight = 0;

定义一些权值

if (IsInImage(x_a, y_a, imGrayAccumulator))
                {
                    if (abs(imMinDepth.at<float>(y_a, x_a) - matProjDepth.at<float>(j, 0)) < MIN_DEPTH_THRESHOLD)
                    {
                        weight = Area(x, x_a, y, y_a);
                        imCounter.at<float>(int(y_a), int(x_a)) += weight;
                        imGrayAccumulator.at<float>(int(y_a), int(x_a)) += weight * (float)refFrame.mImGray.at<uchar>(_y, _x);
                        imDepthAccumulator.at<float>(int(y_a), int(x_a)) += weight * matProjDepth.at<float>(j, 0);
                        mask.at<uchar>(int(y_a), int(x_a)) = 1;
                    }
                    else if ((imMinDepth.at<float>(y_a, x_a) - matProjDepth.at<float>(j, 0)) > 0)
                    {
                        weight = Area(x, x_a, y, y_a);
                        imCounter.at<float>(int(y_a), int(x_a)) = weight;
                        imGrayAccumulator.at<float>(int(y_a), int(x_a)) = weight * (float)refFrame.mImGray.at<uchar>(_y, _x);
                        imDepthAccumulator.at<float>(int(y_a), int(x_a)) = weight * matProjDepth.at<float>(j, 0);
                        mask.at<uchar>(int(y_a), int(x_a)) = 1;
                    }
                    imMinDepth.at<float>(y_a, x_a) = min(imMinDepth.at<float>(y_a, x_a), matProjDepth.at<float>(j, 0));
                }

这段代码是根据条件对不同的像素进行处理和更新。让我解释一下每个部分的含义：

  1. IsInImage(x_a, y_a, imGrayAccumulator): 这是一个条件判断函数，用于检查坐标 (x_a, y_a) 是否在目标图像的范围内。如果在图像范围内，则执行下面的代码段。

  2. abs(imMinDepth.at<float>(y_a, x_a) - matProjDepth.at<float>(j, 0)) < MIN_DEPTH_THRESHOLD: 这是一个条件判断语句，检查 imMinDepth 图像在坐标 (y_a, x_a) 处的深度值与 matProjDepth 的第 j 行第一列元素的差的绝对值是否小于 MIN_DEPTH_THRESHOLD。如果满足条件，则执行相应的代码块。

  3. weight = Area(x, x_a, y, y_a): 这个语句计算权重值，根据目标像素 (x, y) 与像素点 A 的相对位置 (x_a, y_a)，使用某种计算公式来确定权重值。

  4. imCounter.at<float>(int(y_a), int(x_a)) += weight: 这行代码将权重值加到 imCounter 图像的坐标 (int(y_a), int(x_a)) 处的像素值上。

  5. imGrayAccumulator.at<float>(int(y_a), int(x_a)) += weight * (float)refFrame.mImGray.at<uchar>(_y, _x): 这行代码将权重值乘以参考帧 refFrame 的灰度图像在坐标 (_y, _x) 处的像素值，并加到 imGrayAccumulator 图像的坐标 (int(y_a), int(x_a)) 处的像素值上。

  6. imDepthAccumulator.at<float>(int(y_a), int(x_a)) += weight * matProjDepth.at<float>(j, 0): 这行代码将权重值乘以 matProjDepth 的第 j 行第一列元素的值，并加到 imDepthAccumulator 图像的坐标 (int(y_a), int(x_a)) 处的像素值上。

  7. mask.at<uchar>(int(y_a), int(x_a)) = 1: 这行代码将 mask 图像在坐标 (int(y_a), int(x_a)) 处的像素值设置为 1，表示此像素处于有效区域。

  8. imMinDepth.at<float>(y_a, x_a) = min(imMinDepth.at<float>(y_a, x_a), matProjDepth.at<float>(j, 0)): 这行代码比较 imMinDepth 图像在坐标 (y_a, x_a) 处的深度值和 matProjDepth 的第 j 行第一列元素的值，并将较小的值更新到 imMinDepth 图像的相应位置上。

总体来说，这段代码通过计算权重值并根据一些条件来更新不同图像和变量的值，可能涉及到图像深度处理、像素累积计算和掩码操作等

if (IsInImage(x_b, y_b, imGrayAccumulator) && (x_a != x_b))
                {
                    if (abs(imMinDepth.at<float>(y_b, x_b) - matProjDepth.at<float>(j, 0)) < MIN_DEPTH_THRESHOLD)
                    {
                        weight = Area(x, x_b, y, y_b);
                        imCounter.at<float>(int(y_b), int(x_b)) += weight;
                        imGrayAccumulator.at<float>(int(y_b), int(x_b)) += weight * (float)refFrame.mImGray.at<uchar>(_y, _x);
                        imDepthAccumulator.at<float>(int(y_b), int(x_b)) += weight * matProjDepth.at<float>(j, 0);
                        mask.at<uchar>(int(y_b), int(x_b)) = 1;
                    }
                    else if ((imMinDepth.at<float>(y_b, x_b) - matProjDepth.at<float>(j, 0)) > 0)
                    {
                        weight = Area(x, x_b, y, y_b);
                        imCounter.at<float>(int(y_b), int(x_b)) = weight;
                        imGrayAccumulator.at<float>(int(y_b), int(x_b)) = weight * (float)refFrame.mImGray.at<uchar>(_y, _x);
                        imDepthAccumulator.at<float>(int(y_b), int(x_b)) = weight * matProjDepth.at<float>(j, 0);
                        mask.at<uchar>(int(y_b), int(x_b)) = 1;
                    }
                    imMinDepth.at<float>(y_b, x_b) = min(imMinDepth.at<float>(y_b, x_b), matProjDepth.at<float>(j, 0));
                }

 

这段代码与上一段代码类似，是根据条件对不同的像素进行处理和更新。让我解释一下每个部分的含义：

  1. IsInImage(x_b, y_b, imGrayAccumulator): 这是一个条件判断函数，用于检查坐标 (x_b, y_b) 是否在目标图像的范围内。如果在图像范围内，则执行下面的代码段。

  2. (x_a != x_b): 这是一个条件判断语句，检查 x_a 是否不等于 x_b。如果两者不相等，则执行下面的代码段。

  3. abs(imMinDepth.at<float>(y_b, x_b) - matProjDepth.at<float>(j, 0)) < MIN_DEPTH_THRESHOLD: 这是一个条件判断语句，检查 imMinDepth 图像在坐标 (y_b, x_b) 处的深度值与 matProjDepth 的第 j 行第一列元素的差的绝对值是否小于 MIN_DEPTH_THRESHOLD。如果满足条件，则执行相应的代码块。

  4. weight = Area(x, x_b, y, y_b): 这个语句计算权重值，根据目标像素 (x, y) 与像素点 B 的相对位置 (x_b, y_b)，使用某种计算公式来确定权重值。

  5. imCounter.at<float>(int(y_b), int(x_b)) += weight: 这行代码将权重值加到 imCounter 图像的坐标 (int(y_b), int(x_b)) 处的像素值上。

  6. imGrayAccumulator.at<float>(int(y_b), int(x_b)) += weight * (float)refFrame.mImGray.at<uchar>(_y, _x): 这行代码将权重值乘以参考帧 refFrame 的灰度图像在坐标 (_y, _x) 处的像素值，并加到 imGrayAccumulator 图像的坐标 (int(y_b), int(x_b)) 处的像素值上。

  7. imDepthAccumulator.at<float>(int(y_b), int(x_b)) += weight * matProjDepth.at<float>(j, 0): 这行代码将权重值乘以 matProjDepth 的第 j 行第一列元素的值，并加到 imDepthAccumulator 图像的坐标 (int(y_b), int(x_b)) 处的像素值上。

  8. mask.at<uchar>(int(y_b), int(x_b)) = 1: 这行代码将 mask 图像在坐标 (int(y_b), int(x_b)) 处的像素值设置为 1，表示此像素处于有效区域。

  9. imMinDepth.at<float>(y_b, x_b) = min(imMinDepth.at<float>(y_b, x_b), matProjDepth.at<float>(j, 0)): 这行代码比较 imMinDepth 图像在坐标 (y_b, x_b) 处的深度值和 matProjDepth 的第 j 行第一列元素的值，并将较小的值更新到 imMinDepth 图像的相应位置上。

这段代码的作用是根据条件将权重值和一些变量更新到不同的图像和变量中。

if (IsInImage(x_c, y_c, imGrayAccumulator) && (y_a != y_c) && (x_b != x_c && y_b != y_c))
                {
                    if (abs(imMinDepth.at<float>(y_c, x_c) - matProjDepth.at<float>(j, 0)) < MIN_DEPTH_THRESHOLD)
                    {
                        weight = Area(x, x_c, y, y_c);
                        imCounter.at<float>(int(y_c), int(x_c)) += weight;
                        imGrayAccumulator.at<float>(int(y_c), int(x_c)) += weight * (float)refFrame.mImGray.at<uchar>(_y, _x);
                        imDepthAccumulator.at<float>(int(y_c), int(x_c)) += weight * matProjDepth.at<float>(j, 0);
                        mask.at<uchar>(int(y_c), int(x_c)) = 1;
                    }
                    else if ((imMinDepth.at<float>(y_c, x_c) - matProjDepth.at<float>(j, 0)) > 0)
                    {
                        weight = Area(x, x_c, y, y_c);
                        imCounter.at<float>(int(y_c), int(x_c)) = weight;
                        imGrayAccumulator.at<float>(int(y_c), int(x_c)) = weight * (float)refFrame.mImGray.at<uchar>(_y, _x);
                        imDepthAccumulator.at<float>(int(y_c), int(x_c)) = weight * matProjDepth.at<float>(j, 0);
                        mask.at<uchar>(int(y_c), int(x_c)) = 1;
                    }
                    imMinDepth.at<float>(y_c, x_c) = min(imMinDepth.at<float>(y_c, x_c), matProjDepth.at<float>(j, 0));
                }

 

这段代码与前面类似，在特定的条件下对像素进行处理和更新。让我逐步解释每个部分的含义：

  1. IsInImage(x_c, y_c, imGrayAccumulator): 这是一个条件判断函数，用于检查坐标 (x_c, y_c) 是否在目标图像的范围内。

  2. (y_a != y_c) && (x_b != x_c && y_b != y_c): 这是一个条件判断语句，同时检查 y_a 是否不等于 y_c，以及 x_b 和 y_b 是否都不等于 x_c 和 y_c。如果这些条件都满足，则执行下面的代码。

  3. abs(imMinDepth.at<float>(y_c, x_c) - matProjDepth.at<float>(j, 0)) < MIN_DEPTH_THRESHOLD: 这是一个条件判断语句，检查 imMinDepth 图像在坐标 (y_c, x_c) 处的深度值与 matProjDepth 的第 j 行第一列元素的差的绝对值是否小于 MIN_DEPTH_THRESHOLD。如果满足条件，则执行相应的代码块。

  4. weight = Area(x, x_c, y, y_c): 这个语句计算权重值，根据目标像素 (x, y) 与像素点 C 的相对位置 (x_c, y_c)，使用某种计算公式来确定权重值。

  5. imCounter.at<float>(int(y_c), int(x_c)) += weight: 这行代码将权重值加到 imCounter 图像的坐标 (int(y_c), int(x_c)) 处的像素值上。

  6. imGrayAccumulator.at<float>(int(y_c), int(x_c)) += weight * (float)refFrame.mImGray.at<uchar>(_y, _x): 这行代码将权重值乘以参考帧 refFrame 的灰度图像在坐标 (_y, _x) 处的像素值，并加到 imGrayAccumulator 图像的坐标 (int(y_c), int(x_c)) 处的像素值上。

  7. imDepthAccumulator.at<float>(int(y_c), int(x_c)) += weight * matProjDepth.at<float>(j, 0): 这行代码将权重值乘以 matProjDepth 的第 j 行第一列元素的值，并加到 imDepthAccumulator 图像的坐标 (int(y_c), int(x_c)) 处的像素值上。

  8. mask.at<uchar>(int(y_c), int(x_c)) = 1: 这行代码将 mask 图像在坐标 (int(y_c), int(x_c)) 处的像素值设置为 1，表示此像素处于有效区域。

  9. imMinDepth.at<float>(y_c, x_c) = min(imMinDepth.at<float>(y_c, x_c), matProjDepth.at<float>(j, 0)): 这行代码比较 imMinDepth 图像在坐标 (y_c, x_c) 处的深度值和 matProjDepth 的第 j 行第一列元素的值，并将较小的值更新到 imMinDepth 图像的相应位置上。

这段代码的作用是根据一系列条件对像素进行处理和更新，将权重值和一些变量更新到不同的图像和变量中。

if (IsInImage(x_d, y_d, imGrayAccumulator) && (x_a != x_d && y_a != y_d) && (y_b != y_d) && (x_d != x_c))
                {
                    if (abs(imMinDepth.at<float>(y_d, x_d) - matProjDepth.at<float>(j, 0)) < MIN_DEPTH_THRESHOLD)
                    {
                        weight = Area(x, x_d, y, y_d);
                        imCounter.at<float>(int(y_d), int(x_d)) += weight;
                        imGrayAccumulator.at<float>(int(y_d), int(x_d)) += weight * (float)refFrame.mImGray.at<uchar>(_y, _x);
                        imDepthAccumulator.at<float>(int(y_d), int(x_d)) += weight * matProjDepth.at<float>(j, 0);
                        mask.at<uchar>(int(y_d), int(x_d)) = 1;
                    }
                    else if ((imMinDepth.at<float>(y_d, x_d) - matProjDepth.at<float>(j, 0)) > 0)
                    {
                        weight = Area(x, x_d, y, y_d);
                        imCounter.at<float>(int(y_d), int(x_d)) = weight;
                        imGrayAccumulator.at<float>(int(y_d), int(x_d)) = weight * (float)refFrame.mImGray.at<uchar>(_y, _x);
                        imDepthAccumulator.at<float>(int(y_d), int(x_d)) = weight * matProjDepth.at<float>(j, 0);
                        mask.at<uchar>(int(y_d), int(x_d)) = 1;
                    }
                    imMinDepth.at<float>(y_d, x_d) = min(imMinDepth.at<float>(y_d, x_d), matProjDepth.at<float>(j, 0));
                }

 

这段代码与前面的代码类似，也是在特定条件下对像素进行处理和更新。让我逐步解释每个部分的含义：

  1. IsInImage(x_d, y_d, imGrayAccumulator): 这是一个条件判断函数，用于检查坐标 (x_d, y_d) 是否在目标图像的范围内。

  2. (x_a != x_d && y_a != y_d) && (y_b != y_d) && (x_d != x_c): 这是一个条件判断语句，同时检查 x_a 和 y_a 是否都不等于 x_d 和 y_d，且 y_b 不能等于 y_d，还不能等于 x_d 和 x_c。如果这些条件都满足，则执行下面的代码。

  3. abs(imMinDepth.at<float>(y_d, x_d) - matProjDepth.at<float>(j, 0)) < MIN_DEPTH_THRESHOLD: 这是一个条件判断语句，检查 imMinDepth 图像在坐标 (y_d, x_d) 处的深度值与 matProjDepth 的第 j 行第一列元素的差的绝对值是否小于 MIN_DEPTH_THRESHOLD。如果满足条件，则执行相应的代码块。

  4. weight = Area(x, x_d, y, y_d): 这个语句计算权重值，根据目标像素 (x, y) 与像素点 D 的相对位置 (x_d, y_d)，使用某种计算公式来确定权重值。

  5. imCounter.at<float>(int(y_d), int(x_d)) += weight: 这行代码将权重值加到 imCounter 图像的坐标 (int(y_d), int(x_d)) 处的像素值上。

  6. imGrayAccumulator.at<float>(int(y_d), int(x_d)) += weight * (float)refFrame.mImGray.at<uchar>(_y, _x): 这行代码将权重值乘以参考帧 refFrame 的灰度图像在坐标 (_y, _x) 处的像素值，并加到 imGrayAccumulator 图像的坐标 (int(y_d), int(x_d)) 处的像素值上。

  7. imDepthAccumulator.at<float>(int(y_d), int(x_d)) += weight * matProjDepth.at<float>(j, 0): 这行代码将权重值乘以 matProjDepth 的第 j 行第一列元素的值，并加到 imDepthAccumulator 图像的坐标 (int(y_d), int(x_d)) 处的像素值上。

  8. mask.at<uchar>(int(y_d), int(x_d)) = 1: 这行代码将 mask 图像在坐标 (int(y_d), int(x_d)) 处的像素值设置为 1，表示此像素处于有效区域。

  9. imMinDepth.at<float>(y_d, x_d) = min(imMinDepth.at<float>(y_d, x_d), matProjDepth.at<float>(j, 0)): 这行代码比较 imMinDepth 图像在坐标 (y_d, x_d) 处的深度值和 matProjDepth 的第 j 行第一列元素的值，并将较小的值更新到 imMinDepth 图像的相应位置上。

这段代码的作用是根据一系列条件对像素进行处理和更新，将权重值和一些变量更新到不同的图像和变量中。

imGrayAccumulator = imGrayAccumulator.mul(1 / imCounter);
        imDepthAccumulator = imDepthAccumulator.mul(1 / imCounter);

        imGrayAccumulator.convertTo(imGrayAccumulator, CV_8U);
        imGray = imGray * 0;
        imGrayAccumulator.copyTo(imGray, mask);
        imDepth = imDepth * 0;
        imDepthAccumulator.copyTo(imDepth, mask);

 

这段代码是对图像进行计算和复制操作的一部分。让我逐步解释每个部分的含义：

  1. imGrayAccumulator = imGrayAccumulator.mul(1 / imCounter): 这行代码将 imGrayAccumulator 图像中的每个像素值与 imCounter 图像对应位置的像素值做除法运算。这相当于将 imGrayAccumulator 中的每个像素值除以 imCounter 中对应位置的像素值。

  2. imDepthAccumulator = imDepthAccumulator.mul(1 / imCounter): 这行代码将 imDepthAccumulator 图像中的每个像素值与 imCounter 图像对应位置的像素值做除法运算。这相当于将 imDepthAccumulator 中的每个像素值除以 imCounter 中对应位置的像素值。

  3. imGrayAccumulator.convertTo(imGrayAccumulator, CV_8U): 这行代码将 imGrayAccumulator 图像的数据类型转换为 8 位无符号整数型（CV_8U）。这可能是为了将图像的像素值转换为合适的范围或准备后续的操作。

  4. imGray = imGray * 0: 这行代码将 imGray 图像中的所有像素值乘以 0，相当于将所有像素值设置为 0。这可能是为了清空图像。

  5. imGrayAccumulator.copyTo(imGray, mask): 这行代码将 imGrayAccumulator 图像中的非零像素值复制到 imGray 图像对应位置，并且只复制 mask 图像中对应位置为非零的像素值。这可能是为了将计算得到的累加结果 imGrayAccumulator 应用到 imGray 图像上。

  6. imDepth = imDepth * 0: 这行代码将 imDepth 图像中的所有像素值乘以 0，相当于将所有像素值设置为 0。这可能是为了清空图像。

  7. imDepthAccumulator.copyTo(imDepth, mask): 这行代码将 imDepthAccumulator 图像中的非零像素值复制到 imDepth 图像对应位置，并且只复制 mask 图像中对应位置为非零的像素值。这可能是为了将计算得到的累加结果 imDepthAccumulator 应用到 imDepth 图像上。

总体来说，这段代码的作用是通过除以 imCounter 图像中的像素值，将累加器图像中的值归一化。然后，将归一化后的结果复制到对应的目标图像 imGray 和 imDepth 上，同时只复制 mask 中对应位置为非零的像素值。这可能是为了根据某种条件选择性地更新目标图像中的像素值，并清空累加器图像以备下一轮计算使用。

小鳄鱼先生
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
DynaSLAM-14 DynaSLAM中RGB-D运行流程（Ⅳ）：多视图几何部分Geometry.cc解析（深度区域生长算法、合并动态蒙版）
qq_41694024的博客
02-08 986
DynaSLAM中多视图几何部分Geometry.cc解析（深度区域生长算法、合并动态蒙版）
DynaSLAM/src/python/
11-07
将源码中一些关于tab与空格混用以及缩进不匹配问题更改
【学习记录】Dynaslam源代码魔改-替换MaskRCNN为YoloV5
博客标题不能为空我也没办法
12-03 2623
Dynaslam代码修改，替换内部的MaskRCNN为YoloV5，代码已开源
Dyna-SLAM代码解读：Geometry.cc（一）
weixin_63293091的博客
08-06 184
Dyna-SLAM代码解读：Geometry.cc（一）
Dyna-SLAM代码解读：Geometry.cc（四）
weixin_63293091的博客
08-07 166
Dyna-SLAM代码解读：Geometry.cc（四）
Dyna-SLAM代码解读：Geometry.cc（二）
weixin_63293091的博客
08-06 116
Dyna-SLAM代码解读：Geometry.cc（二）
Dyna-SLAM代码解读：Geometry.cc（六）
weixin_63293091的博客
08-07 119
Dyna-SLAM代码解读：Geometry.cc（六）
Dyna-SLAM代码解读：Geometry.cc（三）
weixin_63293091的博客
08-06 95
Dyna-SLAM代码解读：Geometry.cc（三）
论文笔记-DynaSLAM: Tracking, Mapping and Inpainting in Dynamic Scenes
SLAM小土堆
11-12 3087
I. INTRODUCTION 在视觉SLAM中，动态物体会带来如下挑战： 1）如何检测图像中的动态物体，从而： a. 防止tracking算法使用动态物体上的匹配点对 b. 防止mapping算法把移动物体加入3D地图中 2）怎么去补全3D地图中那些被移动物体挡住从而缺失了的部分。 DynaSLAM是可以用于单目，双目，RGB-D的动态SLAM系统，相当于是在ORB-SLAM2上加了一个前端的模块，上面的两个挑战，这篇论文都给出了对应的解决办法。 对于单目和双目：使用CNN进行像素分割，把图像中的人和车
ANSYS-LS-DYNA-users-manual.rar_DYNA manual_LS DYNA_ls-dyna
09-24
《ANSYS LS-DYNA用户手册》是针对LS-DYNA这一高级非线性有限元分析软件的重要参考资料。LS-DYNA是一款广泛应用于机械、航空航天、汽车工程等领域的动态分析工具，尤其在碰撞、爆炸、冲击等瞬态动力学问题上表现卓越...
dyna-sors:围绕服务实现动态生成 RESTful 微服务的代码
06-02
dyana-sors项目的源代码位于“dyna-sors-master”压缩包内，包含了项目的完整结构和源码。开发者可以通过查看源代码，了解其内部实现机制，甚至可以根据自己的需求进行定制和扩展。 总之，dyana-sors项目提供了一种...
ls-dyna-human-model.rar_LS-DYNA假人_dyna 假人_lsdyna假人_lsdyna假人模型_ls
07-14
标题提到的"ls-dyna-human-model.rar"是一个包含LS-DYNA假人模型的压缩包。LS-DYNA假人模型是根据真实人体的生理数据和解剖学特征构建的三维几何模型，用于仿真分析。这些模型通常由多个细分的体素或壳单元组成，每...
matlab提取文件要素代码-matlab-lsdyna:Matlab-Lsdyna
05-21
matlab提取文件要素代码Matlab-Lsdyna 该项目包含来自有限元求解器LS-DYNA的ascii结果文件的阅读器，以及用于从MATLAB中以编程方式运行LS-DYNA模拟的包装器。 该项目与LS-DYNA的创建者或发行者没有任何关系，因此是...
LS-Dyna-Job 批处理.rar
11-14
在"LS-Dyna-Job 批处理.rar"这个压缩包中，包含的"Dyna-Job Submitter"可能是一个用于自动化提交LS-DYNA作业的脚本或工具。这个工具通常会帮助用户避免手动逐一启动计算，尤其在需要运行大量相似或相同参数设置的...
DynaSLAM代码详解(1) — RGBD模式DynaSLAM运行流程
几度春风里的博客
07-09 1501
随后开始进行图像分割，对分割的结果利用膨胀操作；最后根据不同的参数利用不同的TrackRGBD函数开启跟踪线程，并将跟踪线程输出的结果imRGBOut，imDOut, maskOut 保存到创建的文件路径中。：因为有关于图像分割的操作，因此在设置了图像膨胀的相关参数，后面也创建了相关的的文件路径用于TrackRGB中的输出imRGBOut,imDOut,maskOut。检查和加载相关的配置文件，首先判断传入的参数数是否符合要求，然后进行变量的声明用于存放彩色图像、深度图像的路径，以及对应的时间戳的变量。
函数模板与类模板
程序员_小兵
07-12 1565
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
算法014：找到字符串中所有字母异位词
最新发布
m0_62319039的博客
07-14 414
算法014：找到字符串中所有字母异位词
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 379
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
dynaslam代码解读
07-13
下面是对Dynaslam代码的简要解读： 1. 功能概述：Dynaslam代码实现了一个基于视觉的SLAM系统，可以从输入的图像序列中估计相机的运动以及场景的地图。它使用了视觉特征提取、特征匹配、运动估计和地图优化等技术来...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值