视觉SLAM之单目稠密重建

最新推荐文章于 2024-04-16 09:48:05 发布
最新推荐文章于 2024-04-16 09:48:05 发布
阅读量1.4k 收藏 12
点赞数 6
分类专栏： slam opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44671418/article/details/109455959
版权
opencv 同时被 2 个专栏收录
12 篇文章 3 订阅
订阅专栏
slam
3 篇文章 1 订阅
订阅专栏

参考高翔的slam十四讲，单目相机在已知轨迹下的稠密深度估计。
数据集参考：
将使用 REMODE[113, 109] 的测试数据集。它提供了一架无人机采集
的单目俯视图像，共有 200 张，同时提供了每张图像的真实位姿。

http://rpg.ifi.uzh.ch/datasets/remode_test_data.zip 处下载。
下载慢的可以去本人上传的资源处下载。

解压后，将在 test_-data/Images 中有从 0 至 200 的所有图像，并在 test_data 目录下可以看到一个文本文件，它记录了每张图像对应的位姿。
解释都写在内码中：

#include <iostream>
#include <vector>
#include <fstream>
 
using namespace std;
 
#include <boost/timer.hpp>
 
// for sophus
#include <sophus/se3.hpp>
 
using Sophus::SE3d;
 
// for eigen
#include <Eigen/Core>
#include <Eigen/Geometry>
 
using namespace Eigen;
 
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
 
using namespace cv;
 
/**********************************************
* 本程序演示了单目相机在已知轨迹下的稠密深度估计
* 使用极线搜索 + NCC 匹配的方式，与书本的 12.2 节对应
* 请注意本程序并不完美，你完全可以改进它——我其实在故意暴露一些问题(这是借口)。
***********************************************/
 
// ------------------------------------------------------------------
// parameters
const int boarder = 20;         // 边缘宽度?
//图像640×480
const int width = 640;          // 图像宽度
const int height = 480;         // 图像高度
// 相机内参
const double fx = 481.2f;
const double fy = -480.0f;
const double cx = 319.5f;
const double cy = 239.5f;
const int ncc_window_size = 3;    // NCC 取的窗口半宽度
const int ncc_area = (2 * ncc_window_size + 1) * (2 * ncc_window_size + 1); // NCC窗口面积
const double min_cov = 0.1;     // 收敛判定：最小方差
const double max_cov = 10;      // 发散判定：最大方差
 
// ------------------------------------------------------------------函数声明
// 重要的函数
/// 从 REMODE 数据集读取数据
bool readDatasetFiles(
    const string &path,//路径
    vector<string> &color_image_files,//彩图
    vector<SE3d> &poses,//位姿
    cv::Mat &ref_depth
);
/**
 * 根据新的图像更新深度估计
 * @param ref           参考图像
 * @param curr          当前图像
 * @param T_C_R         参考图像到当前图像的位姿
 * @param depth         深度
 * @param depth_cov     深度方差
 * @return              是否成功
 */
bool update(
    const Mat &ref,
    const Mat &curr,
    const SE3d &T_C_R,
    Mat &depth,
    Mat &depth_cov2
);
 
/**
 * 极线搜索
 * @param ref           参考图像
 * @param curr          当前图像
 * @param T_C_R         位姿
 * @param pt_ref        参考图像中点的位置
 * @param depth_mu      深度均值
 * @param depth_cov     深度方差
 * @param pt_curr       当前点
 * @param epipolar_direction  极线方向
 * @return              是否成功
 */
 /**************************极线搜索**********************************************/
bool epipolarSearch(
    const Mat &ref,
    const Mat &curr,
    const SE3d &T_C_R,
    const Vector2d &pt_ref,
    const double &depth_mu,
    const double &depth_cov,
    Vector2d &pt_curr,
    Vector2d &epipolar_direction
);
 
/**
 * 更新深度滤波器
 * @param pt_ref    参考图像点
 * @param pt_curr   当前图像点
 * @param T_C_R     位姿
 * @param epipolar_direction 极线方向
 * @param depth     深度均值
 * @param depth_cov2    深度方向
 * @return          是否成功
 */
bool updateDepthFilter(
    const Vector2d &pt_ref,
    const Vector2d &pt_curr,
    const SE3d &T_C_R,
    const Vector2d &epipolar_direction,
    Mat &depth,
    Mat &depth_cov2
);
 
/**
 * 计算 NCC 评分
 * @param ref       参考图像
 * @param curr      当前图像
 * @param pt_ref    参考点
 * @param pt_curr   当前点
 * @return          NCC评分
 */
double NCC(const Mat &ref, const Mat &curr, const Vector2d &pt_ref, const Vector2d &pt_curr);
/**********************************************************************************************/
// 双线性灰度插值
inline double getBilinearInterpolatedValue(const Mat &img, const Vector2d &pt)
{
    uchar *d = &img.data[int(pt(1, 0)) * img.step + int(pt(0, 0))];
    double xx = pt(0, 0) - floor(pt(0, 0));
    double yy = pt(1, 0) - floor(pt(1, 0));
    return ((1 - xx) * (1 - yy) * double(d[0]) +
            xx * (1 - yy) * double(d[1]) +
            (1 - xx) * yy * double(d[img.step]) +
            xx * yy * double(d[img.step + 1])) / 255.0;
}
/*********************************************************************************************/
// ------------------------------------------------------------------
// 一些小工具
// 显示估计的深度图
void plotDepth(const Mat &depth_truth, const Mat &depth_estimate);
/*******************像素到相机坐标系的转换************************************/
// 像素到相机坐标系
inline Vector3d px2cam(const Vector2d px) {
    return Vector3d(
        (px(0, 0) - cx) / fx,
        (px(1, 0) - cy) / fy,
        1
    );
}
 
// 相机坐标系到像素
inline Vector2d cam2px(const Vector3d p_cam) {
    return Vector2d(
        p_cam(0, 0) * fx / p_cam(2, 0) + cx,
        p_cam(1, 0) * fy / p_cam(2, 0) + cy
    );
}
/*******************像素到相机坐标系的转换************************************/
// 检测一个点是否在图像边框内
inline bool inside(const Vector2d &pt) {
    return pt(0, 0) >= boarder && pt(1, 0) >= boarder
           && pt(0, 0) + boarder < width && pt(1, 0) + boarder <= height;
}
 
// 显示极线匹配
void showEpipolarMatch(const Mat &ref, const Mat &curr, const Vector2d &px_ref, const Vector2d &px_curr);
//ref:参考图像;curr:当前图像；px_ref:参考点;px_curr:当前点
// 显示极线
void showEpipolarLine(const Mat &ref, const Mat &curr, const Vector2d &px_ref, const Vector2d &px_min_curr,
                      const Vector2d &px_max_curr);
 
/// 评测深度估计
void evaludateDepth(const Mat &depth_truth, const Mat &depth_estimate);
// ------------------------------------------------------------------
 
/*****************************main*******************************************************/
int main(int argc, char **argv)
{
    if (argc != 2) {
        cout << "Usage: dense_mapping path_to_test_dataset" << endl;
        return -1;
    }
    Eigen::Vector3d I;
    I<<1,2,3;
    Eigen::Vector3d m;
    m<<1,2,3;
    cout<<"@@@@@@"<<I.dot(m)<<endl;
    // 从数据集读取数据
    vector<string> color_image_files;
    vector<SE3d> poses_TWC;
    Mat ref_depth;
    bool ret = readDatasetFiles(argv[1], color_image_files, poses_TWC, ref_depth);
    if (ret == false) {
        cout << "Reading image files failed!" << endl;
        return -1;
    }
    cout << "read total " << color_image_files.size() << " files." << endl;
 
    // 第一张图作为参考图像
    Mat ref = imread(color_image_files[0], 0);                // gray-scale image
    SE3d pose_ref_TWC = poses_TWC[0];//第一张图像的位姿
    double init_depth = 3.0;    // 深度初始值
    double init_cov2 = 3.0;     // 方差初始值
    Mat depth(height, width, CV_64F, init_depth);             // 深度图
    Mat depth_cov2(height, width, CV_64F, init_cov2);         // 深度图方差
    //遍历每一张图像
    for (int index = 1; index < color_image_files.size(); index++)
    {
        cout << "*** loop " << index << " ***" << endl;
        Mat curr = imread(color_image_files[index], 0);
        if (curr.data == nullptr) continue;
        SE3d pose_curr_TWC = poses_TWC[index];
        SE3d pose_T_C_R = pose_curr_TWC.inverse() * pose_ref_TWC;   // 坐标转换关系： T_C_W * T_W_R = T_C_R  参考图像到当前图像的位姿
        update(ref, curr, pose_T_C_R, depth, depth_cov2);//更新深度估计
        evaludateDepth(ref_depth, depth);//评估深度估计
        plotDepth(ref_depth, depth);
        imshow("image", curr);
        waitKey(1);
    }
 
    cout << "estimation returns, saving depth map ..." << endl;
    imwrite("depth.png", depth);//保存深度图
    cout << "done." << endl;
 
    return 0;
}
//读取数据集中的文件
bool readDatasetFiles(
    const string &path,
    vector<string> &color_image_files,
    std::vector<SE3d> &poses,
    cv::Mat &ref_depth)
    {
    ifstream fin(path + "/first_200_frames_traj_over_table_input_sequence.txt");
    if (!fin)
    {
        cout<<"^^^^^^^^^^^^^^^^^^"<<endl;
        return false;}
 
    while (!fin.eof()) {
        // 数据格式：图像文件名 tx, ty, tz, qx, qy, qz, qw ，注意是 TWC 而非 TCW
        string image;
        fin >> image;
        double data[7];
        for (double &d:data) fin >> d;
        cout<<path + string("/images/") + image<<endl;
 
        color_image_files.push_back(path + string("/images/") + image);
        poses.push_back(
            SE3d(Quaterniond(data[6], data[3], data[4], data[5]),
                 Vector3d(data[0], data[1], data[2]))
        );
        //cout<<"poses,data()"<<poses.()<<endl;
        if (!fin.good()) break;
    }
    fin.close();//读取文件完成后关闭.
 
    // load reference depth装载每个像素点的深度值
    fin.open(path + "/depthmaps/scene_000.depth");
    ref_depth = cv::Mat(height, width, CV_64F);
    if (!fin) return false;
    for (int y = 0; y < height; y++)
        for (int x = 0; x < width; x++)
        {
            double depth = 0;
            fin >> depth;
            ref_depth.ptr<double>(y)[x] = depth / 100.0;//？
        }
 
    return true;
}
 
// 对整个深度图进行更新
bool update(const Mat &ref, const Mat &curr, const SE3d &T_C_R, Mat &depth, Mat &depth_cov2) {
    for (int x = boarder; x < width - boarder; x++)
        for (int y = boarder; y < height - boarder; y++)
        {
            // 遍历每个像素
            if (depth_cov2.ptr<double>(y)[x] < min_cov || depth_cov2.ptr<double>(y)[x] > max_cov) // 深度已收敛或发散
                continue;
            // 在极线上搜索 (x,y) 的匹配
            Vector2d pt_curr;//pt_curr当前点
            Vector2d epipolar_direction;
            bool ret = epipolarSearch(
                ref,
                curr,
                T_C_R,
                Vector2d(x, y),
                depth.ptr<double>(y)[x],
                sqrt(depth_cov2.ptr<double>(y)[x]),
                pt_curr,
                epipolar_direction
            );
 
            if (ret == false) // 匹配失败
                continue;
 
            // 取消该注释以显示匹配
             //showEpipolarMatch(ref, curr, Vector2d(x, y), pt_curr);
 
            // 匹配成功，更新深度图
            updateDepthFilter(Vector2d(x, y), pt_curr, T_C_R, epipolar_direction, depth, depth_cov2);
        }
}
/*********************************************主要算法**************************************************/
// 极线搜索
// 方法见书 12.2 12.3 两节
bool epipolarSearch(
    const Mat &ref, const Mat &curr,
    const SE3d &T_C_R, const Vector2d &pt_ref,
    const double &depth_mu, const double &depth_cov,//depth_mu:深度均值depth_cov深度方差
    Vector2d &pt_curr, Vector2d &epipolar_direction)
    {
    Vector3d f_ref = px2cam(pt_ref);//像素坐标系转换成相机坐标系
    //cout<<"f_ref:"<<f_ref<<endl;
    f_ref.normalize();//归一化
    //cout<<"f_ref.normalize()"<<f_ref<<endl;
    Vector3d P_ref = f_ref * depth_mu;    // 参考帧的 P 向量
 
    Vector2d px_mean_curr = cam2px(T_C_R * P_ref); // 按深度均值投影的像素
    double d_min = depth_mu - 3 * depth_cov, d_max = depth_mu + 3 * depth_cov;//(u-3q,u+3q)
    if (d_min < 0.1) d_min = 0.1;
    Vector2d px_min_curr = cam2px(T_C_R * (f_ref * d_min));    // 按最小深度投影的像素
    Vector2d px_max_curr = cam2px(T_C_R * (f_ref * d_max));    // 按最大深度投影的像素
 
    Vector2d epipolar_line = px_max_curr - px_min_curr;    // 极线（线段形式）
    epipolar_direction = epipolar_line;        // 极线方向
    epipolar_direction.normalize();//对所有数据进行归一化，相当于等比例缩小
    double half_length = 0.5 * epipolar_line.norm();    // 极线线段的半长度
    if (half_length > 100) half_length = 100;   // 我们不希望搜索太多东西
 
    // 取消此句注释以显示极线（线段）
     //showEpipolarLine( ref, curr, pt_ref, px_min_curr, px_max_curr );
 
    // 在极线上搜索，以深度均值点为中心，左右各取半长度
    double best_ncc = -1.0;
    Vector2d best_px_curr;
    for (double l = -half_length; l <= half_length; l += 0.7) { // l+=sqrt(2)
        Vector2d px_curr = px_mean_curr + l * epipolar_direction;  // 待匹配点
        if (!inside(px_curr))
            continue;
        // 计算待匹配点与参考帧的 NCC
        double ncc = NCC(ref, curr, pt_ref, px_curr);//ref:参考图像curr:当前图像pt_ref:参考点px_curr:待匹配点
        if (ncc > best_ncc)
        {
            best_ncc = ncc;
            best_px_curr = px_curr;
        }
    }
    if (best_ncc < 0.85f)      // 只相信 NCC 很高的匹配
        return false;
    pt_curr = best_px_curr;
    return true;
}
/*****************************计算两张图像像素块的相关性***********************************************/
double NCC(
    const Mat &ref, const Mat &curr,
    const Vector2d &pt_ref, const Vector2d &pt_curr) {//ref:参考图像curr:当前图像pt_ref:参考点px_curr:待匹配点
    // 零均值-归一化互相关
    // 先算均值
    double mean_ref = 0, mean_curr = 0;
    vector<double> values_ref, values_curr; // 参考帧和当前帧的均值
    for (int x = -ncc_window_size; x <= ncc_window_size; x++)
        for (int y = -ncc_window_size; y <= ncc_window_size; y++)
        {
            double value_ref = double(ref.ptr<uchar>(int(y + pt_ref(1, 0)))[int(x + pt_ref(0, 0))]) / 255.0;
            mean_ref += value_ref;
            //依次累加窗口内的值，得到参考帧中极线上某个点所在块内的灰度值之和
            double value_curr = getBilinearInterpolatedValue(curr, pt_curr + Vector2d(x, y));
            mean_curr += value_curr;
            //依次累加窗口内的值，得到当前帧中极线上的对应点所在块内的灰度值之和，注意这里用的是双线性插值法
            values_ref.push_back(value_ref);
            values_curr.push_back(value_curr);
        }
    //除以面积，得到均值
    mean_ref /= ncc_area;
    mean_curr /= ncc_area;
 
    // 计算 Zero mean NCC(公式13.12)
    double numerator = 0, demoniator1 = 0, demoniator2 = 0;
    for (int i = 0; i < values_ref.size(); i++) {
        double n = (values_ref[i] - mean_ref) * (values_curr[i] - mean_curr);
        numerator += n;
        demoniator1 += (values_ref[i] - mean_ref) * (values_ref[i] - mean_ref);
        demoniator2 += (values_curr[i] - mean_curr) * (values_curr[i] - mean_curr);
    }
    return numerator / sqrt(demoniator1 * demoniator2 + 1e-10);   // 防止分母出现零
}
//更新深度滤波器
bool updateDepthFilter(
    const Vector2d &pt_ref,
    const Vector2d &pt_curr,
    const SE3d &T_C_R,
    const Vector2d &epipolar_direction,
    Mat &depth,//深度均值
    Mat &depth_cov2) //深度方差
   {
    // 不知道这段还有没有人看
    // 用三角化计算深度
    SE3d T_R_C = T_C_R.inverse();
    Vector3d f_ref = px2cam(pt_ref);//参考点像素转换为相机坐标系的坐标
    f_ref.normalize();//归一化处理
    Vector3d f_curr = px2cam(pt_curr);//当前点像素转换为相机坐标系的坐标
    f_curr.normalize();//归一化处理
 
    // 方程
    // d_ref * f_ref = d_cur * ( R_RC * f_cur ) + t_RC（视觉SLAM十四讲P156,公式7.24）
    // f2 = R_RC * f_cur
    // 转化成下面这个矩阵方程组
    // => [ f_ref^T f_ref, -f_ref^T f2 ] [d_ref]   [f_ref^T t]
    //    [ f_cur^T f_ref, -f2^T f2    ] [d_cur] = [f2^T t   ]
 
    //重点：
    //s1*x1=s2*R*x2+t,移项得到s1*x1-s2*R*x2=t   (1)
    //(1)两边同乘x1的转置x1T，得s1*x1T*x1-s2*x1T*R*x2=x1T*t   (2) 注意"T"指的是转置的意思
    //因此接下来的A[]就是存放未知数为s1和s2的线性方程组的系数矩阵，b存放方程组右端的两个常数
   // cout<<"fref"<<f_ref<<endl;
    Vector3d t = T_R_C.translation();
    //cout<<"t"<<t<<endl;
    //cout<<"t.dot(f_ref)"<<t.dot(f_ref)<<endl;
    Vector3d f2 = T_R_C.so3() * f_curr;
    //AX=B;
    Vector2d b = Vector2d(t.dot(f_ref), t.dot(f2));
    Matrix2d A;
    A(0, 0) = f_ref.dot(f_ref);
    A(0, 1) = -f_ref.dot(f2);
    A(1, 0) = -A(0, 1);
    A(1, 1) = -f2.dot(f2);
    Vector2d ans = A.inverse() * b;
    Vector3d xm = ans[0] * f_ref;           // ref 侧的结果
    Vector3d xn = t + ans[1] * f2;          // cur 结果
    Vector3d p_esti = (xm + xn) / 2.0;      // P的位置，取两者的平均
    double depth_estimation = p_esti.norm();   // 深度值
 
    // 计算不确定性（以一个像素为误差）
    Vector3d p = f_ref * depth_estimation;
    Vector3d a = p - t;//327公式13.7
    double t_norm = t.norm();
    double a_norm = a.norm();
    double alpha = acos(f_ref.dot(t) / t_norm);//a=arccos<p,t>
    double beta = acos(-a.dot(t) / (a_norm * t_norm));//beta=arccos<a,-t>
    Vector3d f_curr_prime = px2cam(pt_curr + epipolar_direction);//
    f_curr_prime.normalize();
    double beta_prime = acos(f_curr_prime.dot(-t) / t_norm);//计算beta'
    double gamma = M_PI - alpha - beta_prime;//计算y'
    double p_prime = t_norm * sin(beta_prime) / sin(gamma);//计算p‘的大小||p'||
    double d_cov = p_prime - depth_estimation;//计算sigma/obs
    double d_cov2 = d_cov * d_cov;//计算方差
 
    // 高斯融合
    //新的数据到来的深度估计均值以及方差
    double mu = depth.ptr<double>(int(pt_ref(1, 0)))[int(pt_ref(0, 0))];
    double sigma2 = depth_cov2.ptr<double>(int(pt_ref(1, 0)))[int(pt_ref(0, 0))];
    //具体高斯融合
    double mu_fuse = (d_cov2 * mu + sigma2 * depth_estimation) / (sigma2 + d_cov2);//公式13.6
    double sigma_fuse2 = (sigma2 * d_cov2) / (sigma2 + d_cov2);
    //融合后的高斯分布
    depth.ptr<double>(int(pt_ref(1, 0)))[int(pt_ref(0, 0))] = mu_fuse;
    depth_cov2.ptr<double>(int(pt_ref(1, 0)))[int(pt_ref(0, 0))] = sigma_fuse2;
 
    return true;
}
 
// 后面这些太简单我就不注释了（其实是因为懒）
void plotDepth(const Mat &depth_truth, const Mat &depth_estimate) {
    imshow("depth_truth", depth_truth * 0.4);
    imshow("depth_estimate", depth_estimate * 0.4);
    imshow("depth_error", depth_truth - depth_estimate);
    waitKey(1);
}
//评估深度
void evaludateDepth(const Mat &depth_truth, const Mat &depth_estimate) {
    double ave_depth_error = 0;     // 平均误差
    double ave_depth_error_sq = 0;      // 平方误差
    int cnt_depth_data = 0;
    for (int y = boarder; y < depth_truth.rows - boarder; y++)
        for (int x = boarder; x < depth_truth.cols - boarder; x++) {
            double error = depth_truth.ptr<double>(y)[x] - depth_estimate.ptr<double>(y)[x];
            ave_depth_error += error;
            ave_depth_error_sq += error * error;
            cnt_depth_data++;
        }
    ave_depth_error /= cnt_depth_data;
    ave_depth_error_sq /= cnt_depth_data;
 
    cout << "Average squared error = " << ave_depth_error_sq << ", average error: " << ave_depth_error << endl;
}
//显示极线匹配
void showEpipolarMatch(const Mat &ref, const Mat &curr, const Vector2d &px_ref, const Vector2d &px_curr) {
    Mat ref_show, curr_show;
    cv::cvtColor(ref, ref_show, CV_GRAY2BGR);
    cv::cvtColor(curr, curr_show, CV_GRAY2BGR);
 
    cv::circle(ref_show, cv::Point2f(px_ref(0, 0), px_ref(1, 0)), 5, cv::Scalar(0, 0, 250), 2);
    cv::circle(curr_show, cv::Point2f(px_curr(0, 0), px_curr(1, 0)), 5, cv::Scalar(0, 0, 250), 2);
 
    imshow("ref", ref_show);
    imshow("curr", curr_show);
    waitKey(1);
}
//画极线
void showEpipolarLine(const Mat &ref, const Mat &curr, const Vector2d &px_ref, const Vector2d &px_min_curr,
                      const Vector2d &px_max_curr) {
 
    Mat ref_show, curr_show;
    cv::cvtColor(ref, ref_show, CV_GRAY2BGR);
    cv::cvtColor(curr, curr_show, CV_GRAY2BGR);
 
    cv::circle(ref_show, cv::Point2f(px_ref(0, 0), px_ref(1, 0)), 5, cv::Scalar(0, 255, 0), 2);
    cv::circle(curr_show, cv::Point2f(px_min_curr(0, 0), px_min_curr(1, 0)), 5, cv::Scalar(0, 255, 0), 2);
    cv::circle(curr_show, cv::Point2f(px_max_curr(0, 0), px_max_curr(1, 0)), 5, cv::Scalar(0, 255, 0), 2);
    cv::line(curr_show, Point2f(px_min_curr(0, 0), px_min_curr(1, 0)), Point2f(px_max_curr(0, 0), px_max_curr(1, 0)),
             Scalar(0, 255, 0), 1);
 
    imshow("ref", ref_show);
    imshow("curr", curr_show);
    waitKey(1);
}

结果还行：
在这里插入图片描述
小问题：
虚拟机bug：运行虚拟机时Pangolin的问题：terminate called after throwing an instance of ‘std::runtime_error‘

人工智睿
关注
  • 6
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
Ubuntu16.04中单目相机稠密重建（深度估计）
qq_36122936的博客
04-03 2155
基于SLAM14讲13.3中提到的单目稠密重建方法，重建自己的单目相机图片的深度图。 我们已经制作了自己的数据集，而且我们现在也根据合适的算法得到了对应的相机位姿。那么就已经达到了单目相机深度估计的要求。下面这些例程使用的是公开的REMODE测试数据集。 例程效果如下 dense_mapping.cpp 主程序如下所示 #include <iostream> #incl...
SLAM中单目稠密重建的数据集
yycsin的博客
04-13 876
我也是无语了，网上那么多数据集竟然通过CSDN下载还要积分，也是醉了 remode_test_data.zip 用于单目稠密重建的数据集，有需要的可以下载，百度云，方便大家使用 链接：https://pan.baidu.com/s/1CuVT7354QH7rC6e_zw0xgA 提取码：pcxz ...
ORB_SLAM2 基于realsense D455 的稠密重建，基于ROS通讯系统
weixin_54347747的博客
10-13 1326
83项优秀的开源SLAM工作： 极市开发者平台-计算机视觉算法开发落地平台realsense D455 实现elastic fusion: 【SLAM】ElasticFusion：使用RealSense进行3D稠密重建 - 知乎D455 VINS fusion: RealSense D455的标定并运行VINS-FUSION_Z_Jin16的博客-CSDN博客_d455 标定bundle fusion: BundleFusion使用Intel RealSense D435i深度相机实现_shenggedeq
视觉SLAM学习打卡【11】-尾述
最新发布
小幸运召唤师的博客
04-16 1047
特征点法能构建稠密地图吗？
slam14讲之13讲--建图
qq_40574123的博客
01-29 2381
论文推荐+更细致的理论描述
SLAM第12讲 建图实践部分
weixin_46417419的博客
04-27 2121
1 实践：单目稠密重建 我们需要下载示例程序所需要的数据集http://rpg.ifi.uzh.ch/datasets/remode_test_data.zip。它提供了一架无人机采集到的单目俯视图像，共200张，同时提供了每张图像对应的位姿。下面我们通过这些数据估算第一帧图像每个像素对应的深度值，即进行单目稠密重建。 估计稠密深度的步骤： 假设所有像素的深度满足某个初始的高斯分布； 当新数据产生时，通过极线搜索和块匹配确定投影点位置； 根据几何关系计算三角化后的深度及不确定性； 将当前观测融合进上一次的
slambook2（ch12）—— Ubuntu18.04安装pcl库 + octomap库 + 例程演示 + VMware虚拟机扩展磁盘容量
曾记否@
01-13 1722
slambook2（ch12）—— Ubuntu18.04安装pcl库 + octomap库 + 例程演示 + VMware虚拟机扩展磁盘容量一、单目稠密重建：1.dense_mapping.cpp二、点云地图：dense_RGBD1.pointcloud_mapping：安装pcl库修改pointcloud_mapping.cpp执行结果2.surfel_mapping执行结果3.octomap_mapping安装octomap修改octomap_mapping.cpp执行结果三、VMware虚拟机扩展
面向稠密重建的单目视觉SLAM方法1
08-03
《面向稠密重建的单目视觉SLAM方法》是一篇探讨如何在单目视觉SLAM系统中实现稠密重建的硕士论文。作者纪祥在软件工程领域进行研究，由导师李豪杰指导，完成于2019年4月。SLAM（Simultaneous Localization And ...
基于单目SLAM的稠密重建1
08-03
基于单目SLAM的稠密重建是计算机视觉中一个非常热门的研究方向。三维重建的目的是根据相机获取的图像恢复出周围环境的三维信息。单目SLAM（Simultaneous Localization and Mapping）是一种基于单目相机的SLAM技术，...
slam十四讲第13章 单目稠密重建数据集(http://rpg.ifi.uzh.ch/datasets/remode_test_data.zip)
09-30
slam十四讲 ch13 第13章 单目稠密重建数据集(http://rpg.ifi.uzh.ch/datasets/remode_test_data.zip) slam十四讲 ch13 第13章 单目稠密重建数据集(http://rpg.ifi.uzh.ch/datasets/remode_test_data.zip)
单目重建用于SLAM学习。加入深度图像
09-27
SLAM（Simultaneous Localization ...总的来说，单目重建在SLAM学习中扮演着重要角色，深度图像的引入极大地提高了定位精度和地图质量。随着硬件和算法的不断进步，我们可以期待在未来看到更加智能和自主的机器人系统。
slam14讲，ch13单目数据集 depthmaps.rar
10-14
slam14讲，ch13单目数据集 depthmaps.rar slam14讲，ch13单目数据集 depthmaps.rar slam14讲，ch13单目数据集 depthmaps.rar
test_led.zip
08-14
功能描述：在三十个时间间隔中（每个时间间隔的长度可通过编程实现），前十个时间间隔，LED灯在亮、暗两种状态下进行切换，每个状态持续一个时间间隔；中间十个时间间隔中，实现LED流水灯功能；后十个时间间隔中，前五个时间间隔，LED由暗逐渐变亮，后五个时间间隔，LED由亮逐渐变暗。而后LED按这三十个时间间隔的变化规律一直运行下去。
datasets.zip
10-22
mnist和imdb数据包，用于解决直接load_data()不成功时候。
ml-datasets::water_wave:用于测试和示例脚本的机器学习数据集加载器
05-24
机器学习数据集加载器以进行测试和示例 用于各种机器学习数据集的加载程序，用于测试和示例脚本。 以前在thinc.extra.datasets 。 设定与安装 该软件包可以通过pip安装： pip install ml-datasets 装载机 加载程序可以直接导入，也可以通过其字符串名称使用（如果通过命令行参数进行设置，则很有用）。 一些加载程序可能会带参数-有关详细信息，请参见源代码。 # Import directly from ml_datasets import imdb train_data , dev_data = imdb () # Load via registry from ml_datasets import loaders imdb_loader = loaders . get ( "imdb" ) train_data , dev_data = imdb_l
test_qr.py
02-13
本文章中相关的python代码.基于opencv的QRCodeDetector实现二维码的识别。并提供运行时间。 总结起来opencv 4.2的二维码识别效果无论误动作率还是识别速度都比较差。
SLAM-单目3D物体检测+SLAM算法实现-优质项目-附完整流程教程.zip
02-11
2. **单目视觉SLAM**：相对于双目或激光雷达SLAM，单目视觉SLAM仅依赖一个摄像头作为传感器，因此更具挑战性，因为它需要从二维图像中恢复三维信息。常见的单目SLAM方法包括ORB-SLAM、DVO SLAM等。 3. **3D物体检测...
SLAM学习笔记-------------（12）建图
1900的博客
05-29 1044
我们之前的讨论，基本集中于“稀疏路标地图”部分，还没有探讨稠密地图。所谓稠密地图是相对于稀疏地图而言的。稀疏地图只建模感兴趣的部分，也就是前面说了很久的特征点（路标点)。而稠密地图是指建模所有看到过的部分。对于同一张桌子，稀疏地图可能只建模了桌子的四个角，而稠密地图则会建模整个桌面。虽然从定位角度看，只有四个角的地图也可以用于对相机进行定位，但由于我们无法从四个角推断这几个点之间的空间结构，所以无法仅用四个角完成导航、避障等需要稠密地图才能完成的工作。 ...
REMODE解析
weixin_30586257的博客
04-20 2916
　　版权声明：本文为博主原创文章，未经博主允许不得转载。 　　纯视觉的三维重建（不考虑用结构光的那一类）常用的有两大类方法：一类是SfM，缺点是计算量比较大，做不到实时运行；另一类是KinectFusion为代表的用深度相机做实时重建，缺点是一般只能在室内小范围运行。REMODE（REgularized MOnocular Depth Estimation）[1]是用单目RGB相机实现三维...
orbslam3 单目稠密建图
01-29
ORB-SLAM3是一种具有单目稠密建图功能的视觉SLAM（同时定位与地图构建）算法。它被广泛应用于无人机、机器人和增强现实等领域。 相比于传统的单目SLAM算法，ORB-SLAM3主要有以下特点和优势。首先，它使用了稠密重建模块，能够根据稀疏地图或关键帧进行场景的更加精确建模。这种方式能够提供更加细节丰富的地图，并能够为后续的任务提供更多的信息。 其次，ORB-SLAM3还采用了深度预测网络来分析图像，并估计每个像素的深度。通过融合各个关键帧的深度信息，可以进一步提高单目SLAM的稠密建图性能。这种方法能够准确地恢复场景中物体的三维形状和大小，从而实现更加精确的场景还原。 最后，ORB-SLAM3还可以进行在线和增量式建图，能够在实时环境中对场景进行精确的定位和建图。它可以自适应地选择关键帧，并与之前的地图进行融合，实现连续的场景建模。 总的来说，ORB-SLAM3通过稠密建图模块和深度预测网络，实现了更加准确和精细的单目SLAM建图。它的算法技术使得我们能够在无人机、机器人和增强现实等领域中实现更加精确和逼真的场景感知和定位。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值