视觉SLAM-光流法

最新推荐文章于 2024-05-15 14:52:45 发布
最新推荐文章于 2024-05-15 14:52:45 发布
阅读量2.2k 收藏 20
点赞数 1
分类专栏： SLAM基础 文章标签： SLAM 光流法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40301351/article/details/131571182
版权

文章目录

目录

前言

🌟光流法的基本原理

🌟OpenCV中的光流法实现

🌟光流法的应用

🌟代码实现

🍉OpenCV代码

🍉OpenCV代码

🌟总结

前言

        当我们观察一个视频或连续帧的图像时，我们经常想知道图像中的物体是如何移动的。光流法（Optical Flow）就是一种用于估计图像中像素点在时间上的运动的计算机视觉技术。它可以帮助我们跟踪物体的移动，并提供关于物体速度和运动方向的信息。

源码在后面，需要的自行下载。

🌟光流法的基本原理

光流法基于以下假设：在相邻帧之间，一个像素点的亮度不会发生大的变化。基于这个假设，光流法通过比较两帧之间像素的亮度变化，推断像素点的运动。

在实际应用中，光流法通常使用Lucas-Kanade算法，该算法假设图像中的运动是局部的，即在一个小的邻域内，像素点的运动是相似的。该算法通过以下步骤计算光流：

  1. 检测特征点：在第一帧图像中，通过特征点检测算法（如Harris角点检测）找到一些具有显著变化的点，作为跟踪的起点。
  2. 选择跟踪窗口：对于每个特征点，在第一帧图像中选择一个小的窗口作为跟踪窗口。
  3. 在相邻帧中跟踪特征点：在第二帧图像中，根据第一帧图像中的特征点位置，通过最小化特征点窗口内的亮度变化，计算第二帧中对应的特征点位置。
  4. 计算光流：根据第一帧和第二帧中特征点的位置差异，计算特征点的光流向量，表示特征点的运动方向和速度。

🌟OpenCV中的光流法实现

OpenCV是一个流行的计算机视觉库，提供了用于光流估计的函数cv::calcOpticalFlowPyrLK。该函数使用了基于Lucas-Kanade算法的金字塔方法，可以在图像金字塔的不同尺度上进行光流估计，提高了算法的鲁棒性和准确性。

使用OpenCV中的cv::calcOpticalFlowPyrLK函数，你可以传入两帧图像、特征点位置，并计算出特征点的光流向量。这个函数还会返回一个状态向量，指示光流是否成功计算，并提供一个误差向量，表示光流估计的精度。

🌟光流法的应用

光流法在计算机视觉和计算机图形学中有广泛的应用。以下是一些常见的应用领域：

  1. 物体跟踪：光流法可以用于跟踪视频序列中的物体。通过跟踪物体的光流向量，可以实现目标检测、运动分析和行为识别等任务。

  2. 视频稳定：通过计算视频序列中的光流，可以检测到相机的运动和抖动，并进行图像稳定化，以提高视频质量和观看体验。

  3. 动作分析：通过跟踪人体的光流，可以分析人的动作和姿态。这在行为分析、运动捕捉和虚拟现实等领域具有重要意义。

  4. 三维重建：通过光流法估计图像中的运动，可以从多个视角的图像中恢复场景的三维结构，实现三维重建和立体视觉。

  5. 视频编码：光流法在视频编码中扮演着重要的角色。通过估计图像序列之间的运动，可以提供更高的压缩率和更好的视频质量。

  6. 虚拟现实和增强现实：光流法可以用于虚拟现实和增强现实应用中，实现对虚拟对象或信息的准确定位和交互。

总结起来，光流法是一种用于估计图像中像素点运动的技术。它在计算机视觉领域有广泛的应用，包括物体跟踪、视频稳定、动作分析、三维重建、视频编码以及虚拟现实和增强现实等方面。通过OpenCV提供的函数，我们可以方便地实现光流法，并应用于各种视觉任务中。

🌟代码实现

🍉OpenCV代码

代码如下：

#include <opencv2/opencv.hpp>

int main() {
    cv::Mat prevImg, nextImg;
    std::vector<cv::Point2f> prevPts, nextPts;
    std::vector<uchar> status;
    std::vector<float> err;

    // Load previous and current frames

    // Detect features in the previous frame and store them in prevPts

    // Calculate optical flow
    cv::calcOpticalFlowPyrLK(prevImg, nextImg, prevPts, nextPts, status, err);

    // Print the tracked points
    for (int i = 0; i < prevPts.size(); i++) {
        if (status[i]) {
            std::cout << "Tracked point: (" << prevPts[i].x << ", " << prevPts[i].y << ") -> "
                      << "(" << nextPts[i].x << ", " << nextPts[i].y << ")" << std::endl;
        } else {
            std::cout << "Tracking failed for point: (" << prevPts[i].x << ", " << prevPts[i].y << ")" << std::endl;
        }
    }

    return 0;
}

🍉OpenCV代码

        我们首先导入所需的头文件和库，包括OpenCV、Eigen等。然后，我们定义了两幅图像的文件路径和一些辅助函数。

        接下来，我们实现了两个函数OpticalFlowSingleLevel和OpticalFlowMultiLevel，用于单层和多层光流估计。这两个函数使用Lucas-Kanade算法来估计图像中关键点的光流向量。OpticalFlowSingleLevel函数用于单层光流估计，而OpticalFlowMultiLevel函数使用金字塔方法在多个尺度上进行光流估计。

        在主函数中，我们加载了两幅图像并使用Good Features to Track (GFTT)检测算法检测了第一幅图像中的关键点。然后，我们分别使用单层光流估计和多层光流估计方法跟踪这些关键点在第二幅图像中的位置。我们还使用OpenCV的calcOpticalFlowPyrLK函数进行验证。

        最后，我们将结果进行可视化，并显示了单层光流估计、多层光流估计和OpenCV光流估计的对比图像。通过这些图像，我们可以观察到不同方法的跟踪效果。

#include <opencv2/opencv.hpp>
#include <string>
#include <Eigen/Core>
#include <Eigen/Dense>

using namespace std;
using namespace cv;

// this program shows how to use optical flow

string file_1 = "./1.png";  // 第一幅图像
string file_2 = "./2.png";  // 第二幅图像

// TODO 实现这个函数
/**
 * 单层光流估计
 * @param [in] img1 第一幅图像
 * @param [in] img2 第二幅图像
 * @param [in] kp1 第一幅图像中的关键点
 * @param [in|out] kp2 第二幅图像中的关键点，如果为空，则使用kp1的初始值
 * @param [out] success 关键点是否成功跟踪的标志
 * @param [in] inverse 是否使用逆向公式？
 */
void OpticalFlowSingleLevel(
        const Mat &img1,
        const Mat &img2,
        const vector<KeyPoint> &kp1,
        vector<KeyPoint> &kp2,
        vector<bool> &success,
        bool inverse = false
);

// TODO 实现这个函数
/**
 * 多层光流估计，默认金字塔的尺度为2
 * 图像金字塔将在函数内部创建
 * @param [in] img1 第一幅图像
 * @param [in] img2 第二幅图像
 * @param [in] kp1 第一幅图像中的关键点
 * @param [out] kp2 第二幅图像中的关键点
 * @param [out] success 关键点是否成功跟踪的标志
 * @param [in] inverse 设置为true以启用逆向公式
 */
void OpticalFlowMultiLevel(
        const Mat &img1,
        const Mat &img2,
        const vector<KeyPoint> &kp1,
        vector<KeyPoint> &kp2,
        vector<bool> &success,
        bool inverse = false
);

/**
 * 根据参考图像获取灰度值（双线性插值）
 * @param img 图像
 * @param x x坐标
 * @param y y坐标
 * @return 像素的灰度值
 */
inline float GetPixelValue(const cv::Mat &img, float x, float y) {
    uchar *data = &img.data[int(y) * img.step + int(x)];
    float xx = x - floor(x);
    float yy = y - floor(y);
    return float(
            (1 - xx) * (1 - yy) * data[0] +
            xx * (1 - yy) * data[1] +
            (1 - xx) * yy * data[img.step] +
            xx * yy * data[img.step + 1]
    );
}


int main(int argc, char **argv) {

    // 图像，注意这里使用的是CV_8UC1而不是CV_8UC3
    Mat img1 = imread(file_1, 0);
    Mat img2 = imread(file_2, 0);

    // 关键点，这里使用GFTT（Good Features to Track）算法
    vector<KeyPoint> kp1;
    Ptr<GFTTDetector> detector =GFTTDetector::create(500, 0.01, 20); // 最多检测500个关键点
    detector->detect(img1, kp1);

    // 现在让我们在第二幅图像中跟踪这些关键点
    // 首先在验证图片中使用单层LK
    vector<KeyPoint> kp2_single;
    vector<bool> success_single;
    OpticalFlowSingleLevel(img1, img2, kp1, kp2_single, success_single);

    // 然后测试多层LK
    vector<KeyPoint> kp2_multi;
    vector<bool> success_multi;
    OpticalFlowMultiLevel(img1, img2, kp1, kp2_multi, success_multi);

    // 使用OpenCV的光流进行验证
    vector<Point2f> pt1, pt2;
    for (auto &kp: kp1) pt1.push_back(kp.pt);
    vector<uchar> status;
    vector<float> error;
    cv::calcOpticalFlowPyrLK(img1, img2, pt1, pt2, status, error, cv::Size(8, 8));

    // 绘制这些函数的差异
    Mat img2_single;
    cv::cvtColor(img2, img2_single, CV_GRAY2BGR);
    for (int i = 0; i < kp2_single.size(); i++) {
        if (success_single[i]) {
            cv::circle(img2_single, kp2_single[i].pt, 2, cv::Scalar(0, 250, 0), 2);
            cv::line(img2_single, kp1[i].pt, kp2_single[i].pt, cv::Scalar(0, 250, 0));
        }
    }

    Mat img2_multi;
    cv::cvtColor(img2, img2_multi, CV_GRAY2BGR);
    for (int i = 0; i < kp2_multi.size(); i++) {
        if (success_multi[i]) {
            cv::circle(img2_multi, kp2_multi[i].pt, 2, cv::Scalar(0, 250, 0), 2);
            cv::line(img2_multi, kp1[i].pt, kp2_multi[i].pt, cv::Scalar(0, 250, 0));
        }
    }

    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));
        }
    }

    cv::imshow("tracked single level", img2_single);
    cv::imshow("tracked multi level", img2_multi);
    cv::imshow("tracked by opencv", img2_CV);
    cv::waitKey(0);

    return 0;
}

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

    // 参数
    int half_patch_size = 4;
    int iterations = 10;
    bool have_initial = !kp2.empty();

   ```cpp
    for (size_t i = 0; i < kp1.size(); i++) {
        auto kp = kp1[i];
        double dx = 0, dy = 0; // dx,dy 需要估计
        if (have_initial) {
            dx = kp2[i].pt.x - kp.pt.x;
            dy = kp2[i].pt.y - kp.pt.y;
        }

        double cost = 0, lastCost = 0;
        bool succ = true; // 标志关键点是否成功跟踪

        // Gauss-Newton 迭代
        for (int iter = 0; iter < iterations; iter++) {
            Eigen::Matrix2d H = Eigen::Matrix2d::Zero();
            Eigen::Vector2d b = Eigen::Vector2d::Zero();
            cost = 0;

            if (kp.pt.x + dx <= half_patch_size || kp.pt.x + dx >= img1.cols - half_patch_size ||
                kp.pt.y + dy <= half_patch_size || kp.pt.y + dy >= img1.rows - half_patch_size) {   // 超出图像边界
                succ = false;
                break;
            }

            // 计算误差和雅可比矩阵
            for (int x = -half_patch_size; x < half_patch_size; x++)
                for (int y = -half_patch_size; y < half_patch_size; y++) {

                    // TODO 从这里开始编写代码 (~8 行)
                    double error = 0;
                    Eigen::Vector2d J;  // 雅可比矩阵
                    if (inverse == false) {
                        // 正向雅可比矩阵
                    } else {
                        // 逆向雅可比矩阵
                        // 注意，当 dx、dy 更新时，J 不会改变，所以我们可以存储它并且只计算误差
                    }

                    // 计算 H、b 和设置 cost；
                    H;
                    b;
                    cost;
                    // TODO 编写代码结束
                }

            // 计算更新量
            // TODO 从这里开始编写代码 (~1 行)
            Eigen::Vector2d update;
            // TODO 编写代码结束

            if (isnan(update[0])) {
                // 有时会出现当我们拥有黑色或白色的补丁时，H 是不可逆的情况
                cout << "update is nan" << endl;
                succ = false;
                break;
            }
            if (iter > 0 && cost > lastCost) {
                cout << "cost increased: " << cost << ", " << lastCost << endl;
                break;
            }

            // 更新 dx、dy
            dx += update[0];
            dy += update[1];
            lastCost = cost;
            succ = true;
        }

        success.push_back(succ);

        // 设置 kp2
        if (have_initial) {
            kp2[i].pt = kp.pt + Point2f(dx, dy);
        } else {
            KeyPoint tracked = kp;
            tracked.pt += cv::Point2f(dx, dy);
            kp2.push_back(tracked);
        }
    }
}

void OpticalFlowMultiLevel(
        const Mat &img1,
        const Mat &img2,
        const vector<KeyPoint> &kp1,
        vector<KeyPoint> &kp2,
```cpp
        vector<bool> &success,
        bool inverse
) {
    // 参数
    int half_patch_size = 4;
    int iterations = 10;
    bool have_initial = !kp2.empty();

    // 创建图像金字塔
    vector<Mat> pyramid1, pyramid2;
    buildOpticalFlowPyramid(img1, pyramid1, cv::Size(2, 2));
    buildOpticalFlowPyramid(img2, pyramid2, cv::Size(2, 2));

    for (size_t i = 0; i < kp1.size(); i++) {
        auto kp = kp1[i];
        double dx = 0, dy = 0; // dx,dy 需要估计
        if (have_initial) {
            dx = kp2[i].pt.x - kp.pt.x;
            dy = kp2[i].pt.y - kp.pt.y;
        }

        double cost = 0, lastCost = 0;
        bool succ = true; // 标志关键点是否成功跟踪

        // Gauss-Newton 迭代
        for (int level = pyramid1.size() - 1; level >= 0; level--) {
            Mat img1_level = pyramid1[level];
            Mat img2_level = pyramid2[level];

            // 根据金字塔的尺度调整 dx、dy
            dx *= 2;
            dy *= 2;

            cost = 0;
            lastCost = 0;

            for (int iter = 0; iter < iterations; iter++) {
                Eigen::Matrix2d H = Eigen::Matrix2d::Zero();
                Eigen::Vector2d b = Eigen::Vector2d::Zero();
                cost = 0;

                if (kp.pt.x + dx <= half_patch_size || kp.pt.x + dx >= img1_level.cols - half_patch_size ||
                    kp.pt.y + dy <= half_patch_size || kp.pt.y + dy >= img1_level.rows - half_patch_size) {   // 超出图像边界
                    succ = false;
                    break;
                }

                // 计算误差和雅可比矩阵
                for (int x = -half_patch_size; x < half_patch_size; x++)
                    for (int y = -half_patch_size; y < half_patch_size; y++) {

                        // TODO 从这里开始编写代码 (~8 行)
                        double error = 0;
                        Eigen::Vector2d J;  // 雅可比矩阵
                        if (inverse == false) {
                            // 正向雅可比矩阵
                        } else {
                            // 逆向雅可比矩阵
                            // 注意，当 dx、dy 更新时，J 不会改变，所以我们可以存储它并且只计算误差
                        }

                        // 计算 H、b 和设置 cost；
                        H;
                        b;
                        cost;
                        // TODO 编写代码结束
                    }

                // 计算更新量
                // TODO 从这里开始编写代码 (~1 行)
                Eigen::Vector2d update;
                // TODO 编写代码结束

                if (isnan(update[0])) {
                    // 有时会出现当我们拥有黑色或白色的补丁时，H 是不可逆的情况
                    cout << "update is nan" << endl```cpp
                    succ = false;
                    break;
                }
                if (iter > 0 && cost > lastCost) {
                    cout << "cost increased: " << cost << ", " << lastCost << endl;
                    break;
                }

                // 更新 dx、dy
                dx += update[0];
                dy += update[1];
                lastCost = cost;
                succ = true;
            }

            if (level > 0) {
                dx /= 2;
                dy /= 2;
            }
        }

        success.push_back(succ);

        // 设置 kp2
        if (have_initial) {
            kp2[i].pt = kp.pt + Point2f(dx, dy);
        } else {
            KeyPoint tracked = kp;
            tracked.pt += cv::Point2f(dx, dy);
            kp2.push_back(tracked);
        }
    }
}

🌟总结

🍎源码

        光流法是计算机视觉领域中用于估计图像中像素点运动的一种技术。它通过分析图像序列中像素点的灰度值变化，推断出像素点的运动方向和速度。光流法基于以下两个假设：

  1. 亮度恒定假设（Brightness Constancy Assumption）：在一个像素点的邻域内，随着时间的推移，像素点的灰度值保持不变。
  2. 空间连续性假设（Spatial Coherence Assumption）：邻近的像素点在图像中的运动方向和速度相似。

        光流法的主要思想是通过比较图像序列中的相邻帧来计算像素点的位移向量。常见的光流算法包括Lucas-Kanade算法和Horn-Schunck算法。这些算法基于局部像素点间的亮度差异，建立了一个优化问题，并使用最小二乘法或其他优化方法求解。

        光流法在计算机视觉中有广泛的应用，包括物体跟踪、运动分析、视频稳定、三维重建、虚拟现实和增强现实等领域。它可以用于目标检测和跟踪，分析人体动作和姿态，实现视频稳定化和运动捕捉，以及构建三维场景模型等。

        然而，光流法也存在一些限制。首先，它假设像素点在邻域内亮度恒定，这在存在光照变化或纹理缺失的情况下可能不成立。其次，光流法对于大的位移或快速运动的物体可能无法准确估计。此外，光流法对图像噪声和运动模糊也比较敏感。

        为了克服这些问题，研究人员提出了许多改进的光流算法和技术，如金字塔光流、密集光流、稠密光流和基于学习的光流等方法。这些方法利用多尺度信息、稠密采样和机器学习等技术来提高光流估计的准确性和鲁棒性。

总结起来，光流法是一种用于估计图像中像素点运动的重要技术。它在计算机视觉领域有广泛的应用，并为物体跟踪、运动分析、视频稳定、三维重建和虚拟现实等任务提供了基础。然而，光流法也存在一些局限性，需要根据具体的应用场景和需求选择合适的算法和技术。同时，随着计算机视觉领域的不断发展，新的光流算法和改进技术不断涌现，为光流法的性能和应用提供了更多的可能性。

点云兔子
关注
  • 1
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
视觉slam光流法资源
07-06
光流法的主要思想是通过比较图像序列中的相邻帧来计算像素点的位移向量。常见的光流算法包括Lucas-Kanade算法和Horn-Schunck算法。这些算法基于局部像素点间的亮度差异，建立了一个优化问题，并使用最小二乘法或其他优化方法求解。
光学定位与追踪技术_视觉SLAM技术学习笔记（一）基础知识以及SLAM的应用
weixin_39662432的博客
12-05 1073
SLAM 技术的发展距今已有 30 余年的历史，涉及的技术领域众多。由于本身包含许多步骤，每一个步骤均可以使用不同算法实现，SLAM 技术也是机器人和计算机视觉领域的热门研究方向。一. 什么是SLAM SLAM 是同步定位与地图构建 (Simultaneous Localization And Mapping) 的缩写，最早由 Hugh Durrant-Whyte 和 John J.Leonard...
光流法（运动检测）
最新发布
K_K_yl的博客
05-15 963
光流法（Optical Flow）是一种用于计算图像序列中像素点运动的技术。它在计算机视觉中有广泛的应用，包括运动检测、对象跟踪和视频稳定等。
光流法总结
程序员深度学习
10-01 4400
光流法总结
光流法(optical flow)简介
热门推荐
weixin_39568744的博客
05-22 3万+
转载自：https://blog.csdn.net/qq_41368247/article/details/82562165 光流法理论背景 1.什么是光流 光流（optical flow）是空间运动物体在观察成像平面上的像素运动的瞬时速度。 光流法是利用图像序列中像素在时间域上的变化以及相邻帧之间的相关性来找到上一帧跟当前帧之间存在的对应关系，从而计算出相邻帧之间物体的运动信息的一种方法...
SLAM中光流算法
Turn life into a dream, and then turn dreams into reality
07-29 1318
为什么要用金字塔？因为lk算法的约束条件即：小速度，亮度不变以及区域一致性都是较强的假设，并不很容易得到满足。如当物体运动速度较快时，假设不成立，那么后续的假设就会有较大的偏差，使得最终求出的光流值有较大的误差。 考虑物体的运动速度较大时，算法会出现较大的误差。那么就希望能减少图像中物体的运动速度。一个直观的方法就是，缩小图像的尺寸。假设当图像为400×400时，物体速度为[16 16],那么图像缩小为200×200时，速度变为[8,8]。缩小为100*100时，速度减少到[4,4]。所以在源图像缩放了很多
光流法和直接法介绍
m0_37604894的博客
10-09 747
光流为追踪源图像某个点在其他图像中的运动， 一般分为稀疏光流和稠密光流，其本质是估计像素在不同时刻图像中的运动本文主要介绍LK光流。
光流法
GH_HOME的专栏
05-29 1220
另外一种推导方式是基于最优化求导和泰勒展开来实现的 由于标准LK算法的前提是泰勒展开足够近似，也就是说pixel displacement is small 光流较小。所以为了足够精确，采用了迭代的方法。事实上没迭代一次，就更新一下图的位置，让两张track的图的位置接近一次，然后再根据此时的图的位置加上标准光流方法重新计算光流，更新光流。根据光流方程的残差是否小于设定精度以及迭代次数小于设定阈值来
optical_flow_光流法_光流法计算特征点匹配_光流_
09-30
光流法是计算机视觉领域中的一个关键概念，用于分析连续两帧图像中像素的运动信息。这个技术在视频处理、自动驾驶、无人机导航、虚拟现实等多个领域有着广泛应用。本文将深入探讨光流法的基本原理、计算方法以及在...
Lucas-Kanade光流法原理及应用
11-04
著名的Lucas-Kanade光流法，自己也不是很懂
光流追踪法
04-21
在opencv和VS2015配置环境中，采用光流法对视频中的事物进行追踪
SLAM-用于单目+立体+RGBD相机的实时视觉SLAM-具有视觉环路检测+重定位功能.zip
02-11
由于只有一个摄像头，无法直接获取深度信息，因此算法需要通过光流法、特征匹配等方法估计距离。单目SLAM的关键挑战在于尺度漂移问题，即长期运行后定位精度会逐渐下降。 2. **立体SLAM**：立体SLAM利用两个或多个...
视觉SLAM十四讲PPT
05-04
5. **位姿估计算法**：包括基于特征的EKF-SLAM、MSCKF（多状态约束卡尔曼滤波）、以及无迹变换UKF等滤波方法，还有直接法如直接法光流法和稀疏光流法。 6. **图优化**：SLAM过程中，通常会用到图优化来改进位姿估计...
基于改进光流法的视觉SLAM1
08-03
Simultaneous Localization and Mapping (SLAM) technology is a core research topic in mobile robotics, unmanned aerial vehicles (UAVs), and autonomous driving fields. It enables robots, drones, and self...
视觉SLAM十四讲学习5 位姿估计（7）光流法，光流跟踪
qq_41035283的博客
12-28 1911
视觉SLAM十四讲学习5 位姿估计（7）光流法前言LK光流光流金字塔 前言 本篇继续位姿估计，光流法，光流跟踪。 LK光流 基于特征点的位姿估计中，特征匹配是比较耗时的过程。因此，光流法常被用来替换特征匹配法，来加速特征点的跟踪。 假设相机的相邻位姿之间，空间点的亮度（像素灰度值）是不变的，则： I(x+dx,y+dy,t+dt)=I(x,y,t) I(x+dx,y+dy,t+dt)=I(x,y,t) \\ I(x+dx,y+dy,t+dt)=I(x,y,t) 上面这个式子表示，空间点在dtdtdt的时间内
视频插帧算法之光流法
weixin_42394431的博客
01-31 1万+
视频插帧算法之光流法视频插帧算法光流法稀疏光流法演示稠密光流法演示如何补帧合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 视频插帧算法 一句话概括视频插帧算法，就是利用图象算法生成出视频的中间帧，将中间帧补充（提高FPS）或替换原视频帧（可
视觉SLAM笔记（42） 光流法跟踪特征点
氢键H-H
10-23 1万+
使用 TUM 公开数据集、第一张图像提取 FAST 角点，然后用 LK 光流跟踪它们，并画在图中
orb-slam3结合光流法
10-23
ORB-SLAM3是一种基于视觉的同时定位和地图构建算法，它可以使用单目、双目、RGB-D相机或者外部IMU传感器来实现定位和地图构建。ORB-SLAM3结合光流法的主要目的是提高算法的鲁棒性和精度。 光流法是一种基于图像序列的运动估计方法，它可以通过计算相邻帧之间的像素位移来估计相机的运动。在ORB-SLAM3中，光流法可以用来对图像序列进行预处理，以提高ORB特征点的匹配精度和鲁棒性。具体来说，ORB-SLAM3使用光流法来计算相邻帧之间的像素位移，并将其用于ORB特征点的跟踪和匹配。这样可以减少由于图像噪声、运动模糊等因素导致的ORB特征点匹配失败的情况，从而提高算法的鲁棒性和精度。 总之，ORB-SLAM3结合光流法可以提高算法的鲁棒性和精度，从而更好地适应各种复杂场景下的定位和地图构建任务。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

点云兔子

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

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

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

打赏作者

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

抵扣说明：

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

余额充值