多线激光雷达扫描匹配方法

已于 2024-07-08 15:05:46 修改
阅读量429 收藏 5
点赞数 3
文章标签： 自动驾驶 算法
于 2024-07-08 11:10:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiner0114/article/details/140254752
版权

文章目录

ICP方法

ICP原理

点到线、点到面的ICP原理，具体查看参考书籍。

ICP实现

点到面的ICP

选取5个最近邻，进行局部平面拟合。

bool Icp3d::AlignP2Plane(SE3& init_pose) {
    LOG(INFO) << "aligning with point to plane";
    assert(target_ != nullptr && source_ != nullptr);
    // 整体流程与p2p一致，读者请关注变化部分

    SE3 pose = init_pose;
    if (!options_.use_initial_translation_) {
        pose.translation() = target_center_ - source_center_;  // 设置平移初始值
    }

    std::vector<int> index(source_->points.size());
    for (int i = 0; i < index.size(); ++i) {
        index[i] = i;
    }

    std::vector<bool> effect_pts(index.size(), false);
    std::vector<Eigen::Matrix<double, 1, 6>> jacobians(index.size());
    std::vector<double> errors(index.size());

    for (int iter = 0; iter < options_.max_iteration_; ++iter) {
        // gauss-newton 迭代
        // 最近邻，可以并发
        std::for_each(std::execution::par_unseq, index.begin(), index.end(), [&](int idx) {
            auto q = ToVec3d(source_->points[idx]);
            Vec3d qs = pose * q;  // 转换之后的q
            std::vector<int> nn;
            kdtree_->GetClosestPoint(ToPointType(qs), nn, 5);  // 这里取5个最近邻
            if (nn.size() > 3) {
                // convert to eigen
                std::vector<Vec3d> nn_eigen;
                for (int i = 0; i < nn.size(); ++i) {
                    nn_eigen.emplace_back(ToVec3d(target_->points[nn[i]]));
                }

                Vec4d n;
                if (!math::FitPlane(nn_eigen, n)) {
                    // 失败的不要
                    effect_pts[idx] = false;
                    return;
                }

                double dis = n.head<3>().dot(qs) + n[3];
                if (fabs(dis) > options_.max_plane_distance_) {
                    // 点离的太远了不要
                    effect_pts[idx] = false;
                    return;
                }

                effect_pts[idx] = true;

                // build residual
                Eigen::Matrix<double, 1, 6> J;
                J.block<1, 3>(0, 0) = -n.head<3>().transpose() * pose.so3().matrix() * SO3::hat(q);
                J.block<1, 3>(0, 3) = n.head<3>().transpose();

                jacobians[idx] = J;
                errors[idx] = dis;
            } else {
                effect_pts[idx] = false;
            }
        });

        // 累加Hessian和error,计算dx
        // 原则上可以用reduce并发，写起来比较麻烦，这里写成accumulate
        double total_res = 0;
        int effective_num = 0;
        auto H_and_err = std::accumulate(
            index.begin(), index.end(), std::pair<Mat6d, Vec6d>(Mat6d::Zero(), Vec6d::Zero()),
            [&jacobians, &errors, &effect_pts, &total_res, &effective_num](const std::pair<Mat6d, Vec6d>& pre,
                                                                           int idx) -> std::pair<Mat6d, Vec6d> {
                if (!effect_pts[idx]) {
                    return pre;
                } else {
                    total_res += errors[idx] * errors[idx];
                    effective_num++;
                    return std::pair<Mat6d, Vec6d>(pre.first + jacobians[idx].transpose() * jacobians[idx],
                                                   pre.second - jacobians[idx].transpose() * errors[idx]);
                }
            });

        if (effective_num < options_.min_effective_pts_) {
            LOG(WARNING) << "effective num too small: " << effective_num;
            return false;
        }

        Mat6d H = H_and_err.first;
        Vec6d err = H_and_err.second;

        Vec6d dx = H.inverse() * err;
        pose.so3() = pose.so3() * SO3::exp(dx.head<3>());
        pose.translation() += dx.tail<3>();

        // 更新
        LOG(INFO) << "iter " << iter << " total res: " << total_res << ", eff: " << effective_num
                  << ", mean res: " << total_res / effective_num << ", dxn: " << dx.norm();

        if (gt_set_) {
            double pose_error = (gt_pose_.inverse() * pose).log().norm();
            LOG(INFO) << "iter " << iter << " pose error: " << pose_error;
        }

        if (dx.norm() < options_.eps_) {
            LOG(INFO) << "converged, dx = " << dx.transpose();
            break;
        }
    }

    init_pose = pose;
    return true;
}

点到线的ICP

bool Icp3d::AlignP2Line(SE3& init_pose) {
    LOG(INFO) << "aligning with point to line";
    assert(target_ != nullptr && source_ != nullptr);
    // 点线与点面基本是完全一样的

    SE3 pose = init_pose;
    if (options_.use_initial_translation_) {
        pose.translation() = target_center_ - source_center_;  // 设置平移初始值
        LOG(INFO) << "init trans set to " << pose.translation().transpose();
    }

    std::vector<int> index(source_->points.size());
    for (int i = 0; i < index.size(); ++i) {
        index[i] = i;
    }

    std::vector<bool> effect_pts(index.size(), false);
    std::vector<Eigen::Matrix<double, 3, 6>> jacobians(index.size());
    std::vector<Vec3d> errors(index.size());

    for (int iter = 0; iter < options_.max_iteration_; ++iter) {
        // gauss-newton 迭代
        // 最近邻，可以并发
        std::for_each(std::execution::par_unseq, index.begin(), index.end(), [&](int idx) {
            auto q = ToVec3d(source_->points[idx]);
            Vec3d qs = pose * q;  // 转换之后的q
            std::vector<int> nn;
            kdtree_->GetClosestPoint(ToPointType(qs), nn, 5);  // 这里取5个最近邻
            if (nn.size() == 5) {
                // convert to eigen
                std::vector<Vec3d> nn_eigen;
                for (int i = 0; i < 5; ++i) {
                    nn_eigen.emplace_back(ToVec3d(target_->points[nn[i]]));
                }

                Vec3d d, p0;
                if (!math::FitLine(nn_eigen, p0, d, options_.max_line_distance_)) {
                    // 失败的不要
                    effect_pts[idx] = false;
                    return;
                }

                Vec3d err = SO3::hat(d) * (qs - p0);

                if (err.norm() > options_.max_line_distance_) {
                    // 点离的太远了不要
                    effect_pts[idx] = false;
                    return;
                }

                effect_pts[idx] = true;

                // build residual
                Eigen::Matrix<double, 3, 6> J;
                J.block<3, 3>(0, 0) = -SO3::hat(d) * pose.so3().matrix() * SO3::hat(q);
                J.block<3, 3>(0, 3) = SO3::hat(d);

                jacobians[idx] = J;
                errors[idx] = err;
            } else {
                effect_pts[idx] = false;
            }
        });

        // 累加Hessian和error,计算dx
        // 原则上可以用reduce并发，写起来比较麻烦，这里写成accumulate
        double total_res = 0;
        int effective_num = 0;
        auto H_and_err = std::accumulate(
            index.begin(), index.end(), std::pair<Mat6d, Vec6d>(Mat6d::Zero(), Vec6d::Zero()),
            [&jacobians, &errors, &effect_pts, &total_res, &effective_num](const std::pair<Mat6d, Vec6d>& pre,
                                                                           int idx) -> std::pair<Mat6d, Vec6d> {
                if (!effect_pts[idx]) {
                    return pre;
                } else {
                    total_res += errors[idx].dot(errors[idx]);
                    effective_num++;
                    return std::pair<Mat6d, Vec6d>(pre.first + jacobians[idx].transpose() * jacobians[idx],
                                                   pre.second - jacobians[idx].transpose() * errors[idx]);
                }
            });

        if (effective_num < options_.min_effective_pts_) {
            LOG(WARNING) << "effective num too small: " << effective_num;
            return false;
        }

        Mat6d H = H_and_err.first;
        Vec6d err = H_and_err.second;

        Vec6d dx = H.inverse() * err;
        pose.so3() = pose.so3() * SO3::exp(dx.head<3>());
        pose.translation() += dx.tail<3>();

        if (gt_set_) {
            double pose_error = (gt_pose_.inverse() * pose).log().norm();
            LOG(INFO) << "iter " << iter << " pose error: " << pose_error;
        }

        // 更新
        LOG(INFO) << "iter " << iter << " total res: " << total_res << ", eff: " << effective_num
                  << ", mean res: " << total_res / effective_num << ", dxn: " << dx.norm();

        if (dx.norm() < options_.eps_) {
            LOG(INFO) << "converged, dx = " << dx.transpose();
            break;
        }
    }

    init_pose = pose;
    return true;
}

NDT方法

NDT原理

NDT大致思路：
1、把目标点云按一定分辨率分成若干体素。
2、计算每个体素中的点云高斯分布。
3、配准时，先计算每个点落在哪个体素中，然后建立该点与该体素的均值，方差构成的残差。
4、利用高斯-牛顿法或L-M(Levenberg-Marquardt)方法对估计位姿进行迭代，然后更新位姿估计。

NDT实现

建立体素

NDT类定义
src/ch7/ndt_3d.cc

/**
 * 3D 形式的NDT
 */
class Ndt3d {
   public:
    enum class NearbyType {
        CENTER,   // 只考虑中心
        NEARBY6,  // 上下左右前后
    };

  ...
    using KeyType = Eigen::Matrix<int, 3, 1>;  // 体素的索引
    struct VoxelData {
        VoxelData() {}
        VoxelData(size_t id) { idx_.emplace_back(id); }

        std::vector<size_t> idx_;      // 点云中点的索引
        Vec3d mu_ = Vec3d::Zero();     // 均值
        Mat3d sigma_ = Mat3d::Zero();  // 协方差
        Mat3d info_ = Mat3d::Zero();   // 协方差之逆
    };
    ...
    /// 使用gauss-newton方法进行ndt配准
    bool AlignNdt(SE3& init_pose);

   private:
    void BuildVoxels();

    /// 根据最近邻的类型，生成附近网格
    void GenerateNearbyGrids();

    CloudPtr target_ = nullptr;
    CloudPtr source_ = nullptr;

    Vec3d target_center_ = Vec3d::Zero();
    Vec3d source_center_ = Vec3d::Zero();

    SE3 gt_pose_;
    bool gt_set_ = false;

    Options options_;

    std::unordered_map<KeyType, VoxelData, hash_vec<3>> grids_;  // 栅格数据
    std::vector<KeyType> nearby_grids_;                          // 附近的栅格
};

构建体素
体素最近邻可以仅使用中心体素，或加上周围的6个体素做最近邻。
体素内部点数大于3，就可计算均值和协方差。
点云稠密，可仅使用中心体素；点云稀疏，可考虑周边体素的情况。

void Ndt3d::BuildVoxels() {
    assert(target_ != nullptr);
    assert(target_->empty() == false);
    grids_.clear();

    /// 分配体素
    std::vector<size_t> index(target_->size());
    std::for_each(index.begin(), index.end(), [idx = 0](size_t& i) mutable { i = idx++; });

    std::for_each(index.begin(), index.end(), [this](const size_t& idx) {
        Vec3d pt = ToVec3d(target_->points[idx]) * options_.inv_voxel_size_;
        auto key = CastToInt(pt);
        if (grids_.find(key) == grids_.end()) {
            grids_.insert({key, {idx}});
        } else {
            grids_[key].idx_.emplace_back(idx);
        }
    });

    /// 计算每个体素中的均值和协方差
    std::for_each(std::execution::par_unseq, grids_.begin(), grids_.end(), [this](auto& v) {
        if (v.second.idx_.size() > options_.min_pts_in_voxel_) {
            // 要求至少有３个点
            math::ComputeMeanAndCov(v.second.idx_, v.second.mu_, v.second.sigma_,
                                    [this](const size_t& idx) { return ToVec3d(target_->points[idx]); });
            // SVD 检查最大与最小奇异值，限制最小奇异值

            Eigen::JacobiSVD svd(v.second.sigma_, Eigen::ComputeFullU | Eigen::ComputeFullV);
            Vec3d lambda = svd.singularValues();
            if (lambda[1] < lambda[0] * 1e-3) {
                lambda[1] = lambda[0] * 1e-3;
            }

            if (lambda[2] < lambda[0] * 1e-3) {
                lambda[2] = lambda[0] * 1e-3;
            }

            Mat3d inv_lambda = Vec3d(1.0 / lambda[0], 1.0 / lambda[1], 1.0 / lambda[2]).asDiagonal();

            // v.second.info_ = (v.second.sigma_ + Mat3d::Identity() * 1e-3).inverse();  // 避免出nan
            v.second.info_ = svd.matrixV() * inv_lambda * svd.matrixU().transpose();
        }
    });

    /// 删除点数不够的
    for (auto iter = grids_.begin(); iter != grids_.end();) {
        if (iter->second.idx_.size() > options_.min_pts_in_voxel_) {
            iter++;
        } else {
            iter = grids_.erase(iter);
        }
    }
}

void Ndt3d::GenerateNearbyGrids() {
    if (options_.nearby_type_ == NearbyType::CENTER) {
        nearby_grids_.emplace_back(KeyType::Zero());
    } else if (options_.nearby_type_ == NearbyType::NEARBY6) {
        nearby_grids_ = {KeyType(0, 0, 0),  KeyType(-1, 0, 0), KeyType(1, 0, 0), KeyType(0, 1, 0),
                         KeyType(0, -1, 0), KeyType(0, 0, -1), KeyType(0, 0, 1)};
    }
}

配准

bool Ndt3d::AlignNdt(SE3& init_pose) {
    LOG(INFO) << "aligning with ndt";
    assert(grids_.empty() == false);

    SE3 pose = init_pose;
    if (options_.remove_centroid_) {
        pose.translation() = target_center_ - source_center_;  // 设置平移初始值
        LOG(INFO) << "init trans set to " << pose.translation().transpose();
    }

    // 对点的索引，预先生成
    int num_residual_per_point = 1;
    if (options_.nearby_type_ == NearbyType::NEARBY6) {
        num_residual_per_point = 7;
    }

    std::vector<int> index(source_->points.size());
    for (int i = 0; i < index.size(); ++i) {
        index[i] = i;
    }

    // 我们来写一些并发代码
    int total_size = index.size() * num_residual_per_point;

    for (int iter = 0; iter < options_.max_iteration_; ++iter) {
        std::vector<bool> effect_pts(total_size, false);
        std::vector<Eigen::Matrix<double, 3, 6>> jacobians(total_size);
        std::vector<Vec3d> errors(total_size);
        std::vector<Mat3d> infos(total_size);

        // gauss-newton 迭代
        // 最近邻，可以并发
        std::for_each(std::execution::par_unseq, index.begin(), index.end(), [&](int idx) {
            auto q = ToVec3d(source_->points[idx]);
            Vec3d qs = pose * q;  // 转换之后的q

            // 计算qs所在的栅格以及它的最近邻栅格
            Vec3i key = CastToInt(Vec3d(qs * options_.inv_voxel_size_));

            for (int i = 0; i < nearby_grids_.size(); ++i) {
                auto key_off = key + nearby_grids_[i];
                auto it = grids_.find(key_off);
                int real_idx = idx * num_residual_per_point + i;
                if (it != grids_.end()) {
                    auto& v = it->second;  // voxel

e的相关公式
在这里插入图片描述

res的相关公式
在这里插入图片描述

J的相关公式
在这里插入图片描述

                    Vec3d e = qs - v.mu_;

                    // check chi2 th
                    double res = e.transpose() * v.info_ * e;
                    if (std::isnan(res) || res > options_.res_outlier_th_) {
                        effect_pts[real_idx] = false;
                        continue;
                    }

                    // build residual
                    Eigen::Matrix<double, 3, 6> J;
                    J.block<3, 3>(0, 0) = -pose.so3().matrix() * SO3::hat(q);
                    J.block<3, 3>(0, 3) = Mat3d::Identity();

                    jacobians[real_idx] = J;
                    errors[real_idx] = e;
                    infos[real_idx] = v.info_;
                    effect_pts[real_idx] = true;
                } else {
                    effect_pts[real_idx] = false;
                }
            }
        });

H的计算公式
在这里插入图片描述

err的计算公式
在这里插入图片描述
由H和err的表达式，结合以下公式（加权最小二乘问题的高斯-牛顿法）
在这里插入图片描述
可推出dx的计算方法 dx = H.inverse() * err。

total_res的计算公式
在这里插入图片描述

        // 累加Hessian和error,计算dx
        // 原则上可以用reduce并发，写起来比较麻烦，这里写成accumulate
        double total_res = 0;
        int effective_num = 0;

        Mat6d H = Mat6d::Zero();
        Vec6d err = Vec6d::Zero();

        for (int idx = 0; idx < effect_pts.size(); ++idx) {
            if (!effect_pts[idx]) {
                continue;
            }

            total_res += errors[idx].transpose() * infos[idx] * errors[idx];
            // chi2.emplace_back(errors[idx].transpose() * infos[idx] * errors[idx]);
            effective_num++;

            H += jacobians[idx].transpose() * infos[idx] * jacobians[idx];
            err += -jacobians[idx].transpose() * infos[idx] * errors[idx];
        }

        if (effective_num < options_.min_effective_pts_) {
            LOG(WARNING) << "effective num too small: " << effective_num;
            return false;
        }

        Vec6d dx = H.inverse() * err;
        pose.so3() = pose.so3() * SO3::exp(dx.head<3>());
        pose.translation() += dx.tail<3>();

        // 更新
        LOG(INFO) << "iter " << iter << " total res: " << total_res << ", eff: " << effective_num
                  << ", mean res: " << total_res / effective_num << ", dxn: " << dx.norm()
                  << ", dx: " << dx.transpose();

        // std::sort(chi2.begin(), chi2.end());
        // LOG(INFO) << "chi2 med: " << chi2[chi2.size() / 2] << ", .7: " << chi2[chi2.size() * 0.7]
        //           << ", .9: " << chi2[chi2.size() * 0.9] << ", max: " << chi2.back();

        if (gt_set_) {
            double pose_error = (gt_pose_.inverse() * pose).log().norm();
            LOG(INFO) << "iter " << iter << " pose error: " << pose_error;
        }

        if (dx.norm() < options_.eps_) {
            LOG(INFO) << "converged, dx = " << dx.transpose();
            break;
        }
    }

    init_pose = pose;
    return true;
}

参考资料：
1、书籍：《自动驾驶与机器人中的SLAM技术：从理论到实践》
2、代码：https://github.com/gaoxiang12/slam_in_autonomous_driving/tree/master/src/ch7

gaohualan
关注
激光雷达数据含义和激光SLAM算法匹配原理
小秋 AI SLAM 入门实战教程
05-12 1846
SLAM的关键部分是匹配算法，该算法将当前激光雷达扫描与先前扫描或已构建的地图进行对比，以估计机器人的位置和姿态。二维激光局部定位算法主要依赖于当前激光扫描数据与已建立的地图（或历史扫描数据）之间的匹配来估计机器人的位姿。数据关联是激光SLAM匹配算法中的关键环节。数据关联的目标是找到当前激光扫描中的特征点与先前扫描或地图中的特征点之间的对应关系。数据关联的目的是找到当前扫描中的特征点与先前扫描或地图中的特征点之间的对应关系。将当前激光扫描中的特征与先前激光扫描或地图中的特征进行匹配，找到最佳的对应关系。
激光SLAM总结——特征点提取与匹配
weixin_44580210的博客
08-22 1万+
学习LOAM笔记——特征点提取与匹配学习LOAM笔记——特征点提取与匹配1. 特征点提取1.1 对激光点按线束分类1.2 计算激光点曲率1.3 根据曲率提取特征点2. 特征点匹配2.1 scan-to-scan中的特征点匹配2.2 scan-to-map中特征点匹配3. 补充 学习LOAM笔记——特征点提取与匹配 兜兜转转一圈，最近又开始接触一些和SLAM相关的工作，LOAM是一个非常经典的激光SLAM框架，LOAM和VLOAM至今还在kitti榜上有着不错的表现，从这篇博客开始，我开始着手对LOAM以及L
手持多线激光三维重建
clipp_Huang的博客
01-25 5031
手持多线激光采用的硬件如下，两个交叉的7线线激光和双目相机，通过控制器来控制交叉7线的投射和触发相机进行采集。 算法主要分为两部分，即标定和重建。标定包括双目相机标定和激光线空间方程标定。首先标定采用平板标定法标定出双目相机的内参和外参，然后标定出7线激光的每个光平面方程并保持所有的标定结果。重建的时候基于双目标定结果和7线光平面方程，结合双目极线匹配的方法来找到每个激光点左右图像的匹配点，通过左右图像的匹配点基于双目重建方法来进行三维重建。 ...
多线阵列激光三维扫描系统及多线阵列激光三维扫描方法
smartvxworks的博客
02-23 5389
多线阵列激光三维扫描系统及多线阵列激光三维扫描方法
如何用少线束的激光雷达获得多线束的激光雷达的感知效果——点云配准
bigmarshal的博客
03-24 1693
激光雷达的价格一般都比较昂贵，对于无人驾驶应用中，激光雷达是系统成本的重要组成部分。激光雷达的价格随着线数的增加而增加，基本规则就是线数越多，价格越贵。在产品开发过程中，成本控制是很重要的，一个产品，如果功能没问题，但是价格昂贵，也不会有好的市场，只有物美价廉的产品才会受到消费者的青睐。所以压缩激光雷达的成本在无人驾驶落地过程中就显得尤为重要。首先，我们可以选择线数相对少的激光雷达...
杂记8---多线激光雷达与相机外参标定
qq_45701501的博客
03-18 1248
camera_type ： 1 表示针孔相机（fov < 90°） 2 表示鱼眼相机（fov > 90°） [当前版本没有适配全景相机]chessboard_size ： 表示标定板的物理尺寸，注意不是棋盘格轮廓尺寸，单位 米。标定数据，只需要一个棋盘格标定板。估计处理过的图片，角点提取有影响。4、采集数据时，标定板的稳定性与环境光线情况[标定板材质和稳定性对标定结果影响较大]2、选择每帧pcd的标定板中心时，需要注意shift+鼠标左键。
激光感知算法--多激光雷达的静态标定
JimmyC18的博客
12-06 1622
利用最小方差法和点云配准方法实现多个激光雷达与车身坐标系的静态联合标定。
python激光扫描雷达_一文详解固态激光雷达的里程计（loam_livox）
weixin_39531229的博客
12-08 1047
作者：Liam点击上方“3D视觉工坊”，选择“星标”干货第一时间送达Loam livox(2019 IROS)介绍：大疆出品，必属精品。固态激光雷达里程计的工作现阶段还是比较少的，大疆自己出了固态激光雷达后在LOAM的基础上改进了一个适用于固态激光雷达的里程计，该系统可以用在小视场角和非重复性扫描的雷达上。代码地址：在公众号「3D视觉工坊」，后台回复「loam_livox」，即可直接下载。需要...
激光雷达考试基础知识
热门推荐
yuanYW7556的博客
12-12 1万+
一、技术介绍 1.激光雷达 概念：激光探测与测量，Light Detection And Ranging，英文缩写为LiDAR，LiDAR的光源一般采用激光，原理与雷达原理相同，故都将LiDAR翻译为激光雷达，也可称为激光扫描仪。 工作原理：脉冲式和相位式，它有激光发射器、接收器、时间计数器、微电脑构成，成像为点云，并以数据为基础重建目标三维模型。 （相位式问题：相位测量仅能测出不足一周的相位差...
激光雷达数据和里程计数据的时间同步方法汇总
小秋 AI SLAM 入门实战教程
01-14 2243
/ 可以是任何类型的数据，这里用double举例这是一个简单的结构体，用于存储数据点。timestamp：数据点的时间戳，表示数据点的时间。value：与时间戳相关的数据值，在这个例子中是一个double类型，但可以根据实际情况修改为其他类型。
点云从入门到精通技术详解100篇-基于多线激光雷达的点云数据处理与导航
getusushu的博客
01-05 956
近些年来，国内工业智能化的市场不断扩大，各大工业企业都开始引进工业智。但是磁导航的缺点也非常明显，磁条一旦铺设好的就很难改变或扩充路径，并。的新技术解决磁导航的缺点。二维码图片并解析二维码中包含的信息来获取当前所在的位置。程度上解决了磁导航改变或者扩充路径困难的问题，但由于二维码一般铺设在地面。上，若地面凹凸不平会对识别造成影响，并且成本相对较高，铺设的二维码图片也。随着自动驾驶的普及，作为自动驾驶主要传感器之一的激光雷达发。境下对周围的物体进行快速扫描，从而计算获取物体表面的三维坐标、反射强度等。
2.1.2 激光雷达
nwaysir的博客
11-25 2407
激光雷达是实现更高级别自动驾驶（L3级别以上），以及更高安全性的良好途径，相比于毫米波雷达，激光雷达的分辨率更高、稳定性更好、三维数据也更可靠。
点云从入门到精通技术详解100篇-基于多线激光雷达的点云数据处理与导航（续）
getusushu的博客
01-06 1039
进的点云预处理方法进行点云数据的去噪与下采样处理，预处理过的数据就可以传。构建先验地图的步骤非常简单，人为确定好起点后，运行建图算法，地图便开。当前需要导航的场地地图进行构建，完成先验地图的构建后，以该地图作为。光雷达的原始点云数据，然后将原始点云数据通过使用第二章提出的基于。的特征且如果车身产生剧烈的抖动会影响建图的效果，所以我们添加了。首先进行的是先验地图构建，先验地图的构建采用第三章介绍的。的导航路线的示意图相对比，可以看出导航定位坐标点的数据并。上图 4-20 为最终构建出来的点云俯视图，与图。
基于人工智能的自动驾驶系统项目教学指南
最新发布
stm32d1219的博客
09-13 1457
自动驾驶系统是人工智能的一个核心应用领域，涉及多个学科的交叉：从计算机视觉、深度学习、传感器融合到控制系统，自动驾驶项目可以提供高度的挑战性和实践意义。通过本文的详细教学，你可以构建一个简化的自动驾驶系统。我们将构建一个卷积神经网络（CNN），用于处理输入的道路图像，并预测车辆应保持的方向。该模型可以扩展到实际的自动驾驶中，通过搭载摄像头与其他传感器（如雷达、LIDAR）来获取实时道路信息，并做出相应的控制决策。1. 仿真数据：在仿真环境中驾驶车辆，记录摄像头采集的图像数据，以及对应的方向盘转向角度。
自动驾驶自动泊车场景应用总结
xiaomu_347的博客
09-12 279
自动泊车技术是当前智能驾驶技术的一个重要分支，其目标是通过车辆自身的感知、决策和控制系统，实现车辆在有限空间内的自主泊车操作。目前自动泊车可分为半自动泊车、全自动泊车、记忆泊车、四种产品形态，其中， 根据搭载传感器和使用场景的不同，全自动泊车又可分为基于超声波的全自动泊车、超声波融合环视摄像头的全自动泊车、遥控泊车三种形态。随着自动泊车技术的不断迭代，自动泊车功能的实用性也越来越强。目前存在的自动泊车的典型方案如下。
自动驾驶系列—掌握速度，驾驭安全，限速信息提醒功能（SLIF）介绍
u013889591的专栏
09-12 1865
🌟🌟 欢迎来到我的技术小筑，一个专为技术探索者打造的交流空间。在这里，我们不仅分享代码的智慧，还探讨技术的深度与广度。无论您是资深开发者还是技术新手，这里都有一片属于您的天空。让我们在知识的海洋中一起航行，共同成长，探索技术的无限可能。🚀 探索专栏：学步_技术的首页 —— 持续学习，不断进步，让学习成为我们共同的习惯，让总结成为我们前进的动力。🌈 非常期待在这个数字世界里与您相遇，一起学习、探讨、成长。不要忘了订阅本专栏，让我们的技术之旅不再孤单！💖💖💖 ✨✨ 欢迎关注和订阅，一起开启技术探索之旅！
准备好启程了：Nuro将授权其自动驾驶系统
2401_87032549的博客
09-12 692
Nuro Driver基于NVIDIA的端到端安全自动驾驶架构，可以将传感器处理和其他关键安全功能以及AI驱动的自动驾驶整合到单一的集中计算系统中，”NVIDIA汽车业务副总裁Rishi Dhall说。Nuro在三月份的GTC上宣布，支持多种车辆类型的L4级自动驾驶的Nuro Driver将在NVIDIA DRIVE Thor上构建，并运行NVIDIA DriveOS操作系统，以实现安全且由AI定义的自动驾驶车辆。DMV的许可允许Nuro的车辆全天行驶，以及在小雨和中等雾的条件下行驶。
多线激光雷达外部转轴标定技术研究
"余向东的硕士论文《面向多线激光雷达的外部转轴标定方法》探讨了在自动驾驶、遥感技术和智能机器人等领域广泛应用的激光雷达技术。该论文主要关注旋转激光雷达系统的外部转轴标定，特别是针对多线激光雷达，以解决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值