Hector代码笔记

最新推荐文章于 2025-05-13 13:09:58 发布
最新推荐文章于 2025-05-13 13:09:58 发布
阅读量1.1k 收藏 8
点赞数 3
CC 4.0 BY-SA版权
分类专栏： 激光SLAM 文章标签： hector slam
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tiancailx/article/details/112573852

阅读Hector代码时的笔记，更多Hector内容请看

https://blog.csdn.net/tiancailx/article/details/112978031

1 入口

hector_mapping/src/HectorMappingRos.cpp

1.1 scanCallback()

/**
 * 激光数据处理回调函数，将ros数据格式转换为算法中的格式，并转换成地图尺度，交由slamProcessor处理。
 * 算法中所有的计算都是在地图尺度下进行。  ROS部分的内容根据实际需求添加删减
 * @param scan  激光的数据ROS消息包
 */
void HectorMappingRos::scanCallback(const sensor_msgs::LaserScan& scan)
{
    if (hectorDrawings)
    {
        hectorDrawings->setTime(scan.header.stamp);
    }

    ros::WallTime startTime = ros::WallTime::now();

    // 不使用tf，默认雷达的坐标系就是base_link
    if (!p_use_tf_scan_transformation_) // 未使用tf
    {

        if (rosLaserScanToDataContainer(scan, laserScanContainer,slamProcessor->getScaleToMap()))
        {
            slamProcessor->update(laserScanContainer,slamProcessor->getLastScanMatchPose());
        }
    }
    else
    {
        ros::Duration dur (0.5);

        if (tf_.waitForTransform(p_base_frame_,scan.header.frame_id, scan.header.stamp,dur))
        {
            tf::StampedTransform laserTransform;
            tf_.lookupTransform(p_base_frame_,scan.header.frame_id, scan.header.stamp, laserTransform);

            //projector_.transformLaserScanToPointCloud(p_base_frame_ ,scan, pointCloud,tf_);
            /** 将laser scan 转换成 laser frame下的点云消息 **/
            projector_.projectLaser(scan, laser_point_cloud_,30.0);

            if (scan_point_cloud_publisher_.getNumSubscribers() > 0){
                scan_point_cloud_publisher_.publish(laser_point_cloud_);
            }

            Eigen::Vector3f startEstimate(Eigen::Vector3f::Zero());

            if(rosPointCloudToDataContainer(laser_point_cloud_, laserTransform, laserScanContainer, slamProcessor->getScaleToMap()))
            {
                if (initial_pose_set_){
                    initial_pose_set_ = false;
                    startEstimate = initial_pose_;
                }else if (p_use_tf_pose_start_estimate_){

                    try
                    {
                        tf::StampedTransform stamped_pose;

                        tf_.waitForTransform(p_map_frame_,p_base_frame_, scan.header.stamp, ros::Duration(0.5));
                        tf_.lookupTransform(p_map_frame_, p_base_frame_,  scan.header.stamp, stamped_pose);

                        tfScalar yaw, pitch, roll;
                        stamped_pose.getBasis().getEulerYPR(yaw, pitch, roll);

                        startEstimate = Eigen::Vector3f(stamped_pose.getOrigin().getX(),stamped_pose.getOrigin().getY(), yaw);
                    }
                    catch(tf::TransformException e)
                    {
                        ROS_ERROR("Transform from %s to %s failed\n", p_map_frame_.c_str(), p_base_frame_.c_str());
                        startEstimate = slamProcessor->getLastScanMatchPose();
                    }

                }else{
                    startEstimate = slamProcessor->getLastScanMatchPose();
                }


                if (p_map_with_known_poses_){
                    slamProcessor->update(laserScanContainer, startEstimate, true);
                }else{
                    // 进入扫描匹配与地图更新
                    slamProcessor->update(laserScanContainer, startEstimate);
                }
            }

        }else{
            ROS_INFO("lookupTransform %s to %s timed out. Could not transform laser scan into base_frame.", p_base_frame_.c_str(), scan.header.frame_id.c_str());
            return;
        }
    }
    // ...
}

1.2 update()

hector_mapping/include/hector_slam_lib/slam_main/HectorSlamProcessor.h

    /**
    * 对每一帧的激光数据进行处理
    * @param dataContainer  激光数据存储容器，坐标已转换成地图尺度，为地图中激光系的坐标
    * @param poseHintWorld  激光系在地图中的初始pose
    * @param map_without_matching 是否进行匹配
    */
    void update(const DataContainer &dataContainer, const Eigen::Vector3f &poseHintWorld, bool map_without_matching = false)
    {
        //std::cout << "\nph:\n" << poseHintWorld << "\n";

        /** 1. 位姿匹配 **/
        Eigen::Vector3f newPoseEstimateWorld;

        if (!map_without_matching)
        {
            // 进行 scan to map 的地方
            newPoseEstimateWorld = (mapRep->matchData(poseHintWorld, dataContainer, lastScanMatchCov));
        }
        else
        {
            newPoseEstimateWorld = poseHintWorld;
        }

        lastScanMatchPose = newPoseEstimateWorld;

        /** 2.地图更新 **/
        if (util::poseDifferenceLargerThan(newPoseEstimateWorld, lastMapUpdatePose, paramMinDistanceDiffForMapUpdate, paramMinAngleDiffForMapUpdate) || map_without_matching)
        { // 仅在位姿变化大于阈值 或者 map_without_matching为真 的时候进行地图更新
            mapRep->updateByScan(dataContainer, newPoseEstimateWorld);

            mapRep->onMapUpdated();
            lastMapUpdatePose = newPoseEstimateWorld;
        }
    }

2 扫描匹配

2.1 matchData()

hector_mapping/include/hector_slam_lib/slam_main/MapRepMultiMap.h

    /**
     * 地图匹配，通过金字塔求解当前激光帧的pose。
     * @param beginEstimateWorld
     * @param dataContainer
     * @param covMatrix
     * @return
     */
    virtual Eigen::Vector3f matchData(const Eigen::Vector3f &beginEstimateWorld, const DataContainer &dataContainer, Eigen::Matrix3f &covMatrix)
    {
        size_t size = mapContainer.size();

        Eigen::Vector3f tmp(beginEstimateWorld);

        /// coarse to fine 的pose求精过程，i层的求解结果作为i-1层的求解初始值。
        for (int index = size - 1; index >= 0; --index)
        {
            //std::cout << " m " << i;
            if (index == 0)
            {
                tmp = (mapContainer[index].matchData(tmp, dataContainer, covMatrix, 5)); /// 输入数据dataContainer 对应 mapContainer[0]
            }
            else
            {
                // 根据地图层数对原始激光数据坐标进行缩小，得到对应图层尺寸的激光数据
                dataContainers[index - 1].setFrom(dataContainer, static_cast<float>(1.0 / pow(2.0, static_cast<double>(index))));
                tmp = (mapContainer[index].matchData(tmp, dataContainers[index - 1], covMatrix, 3));
                /// dataContainers[i]对应mapContainer[i+1]
            }
        }
        return tmp;
    }

2.2 matchData()

hector_mapping/include/hector_slam_lib/slam_main/MapProcContainer.h

  /**
   * 给定位姿初值，估计当前scan在当前图层中的位姿 ---- 位姿为世界系下的pose 、  dataContainer应与当前图层尺度匹配
   * @param beginEstimateWorld 世界系下的位姿
   * @param dataContainer       激光数据
   * @param covMatrix           scan-match的不确定性 -- 协方差矩阵
   * @param maxIterations       最大的迭代次数
   * @return
   */
  Eigen::Vector3f matchData(const Eigen::Vector3f& beginEstimateWorld, const DataContainer& dataContainer, Eigen::Matrix3f& covMatrix, int maxIterations)
  {
    return scanMatcher->matchData(beginEstimateWorld, *gridMapUtil, dataContainer, covMatrix, maxIterations);
  }

2.3 matchData()

hector_mapping/include/hector_slam_lib/matcher/ScanMatcher.h

    /**
     * 实际进行位姿估计的函数
     * @param beginEstimateWorld  位姿初值
     * @param gridMapUtil         网格地图工具,这里主要是用来做坐标变换
     * @param dataContainer       激光数据
     * @param covMatrix           协方差矩阵
     * @param maxIterations       最大迭代次数
     * @return
     */
    Eigen::Vector3f matchData(const Eigen::Vector3f &beginEstimateWorld, ConcreteOccGridMapUtil &gridMapUtil, const DataContainer &dataContainer, Eigen::Matrix3f &covMatrix, int maxIterations)
    {
        if (drawInterface)
        {
            drawInterface->setScale(0.05f);
            drawInterface->setColor(0.0f, 1.0f, 0.0f);
            drawInterface->drawArrow(beginEstimateWorld);

            Eigen::Vector3f beginEstimateMap(gridMapUtil.getMapCoordsPose(beginEstimateWorld));

            drawScan(beginEstimateMap, gridMapUtil, dataContainer);

            drawInterface->setColor(1.0, 0.0, 0.0);
        }

        if (dataContainer.getSize() != 0)
        {

            /// 1. 初始pose转换为地图尺度下的pose --仿射变换,包括位姿的尺度和偏移，旋转在 X Y 同尺度变化时保持不变
            Eigen::Vector3f beginEstimateMap(gridMapUtil.getMapCoordsPose(beginEstimateWorld));

            Eigen::Vector3f estimate(beginEstimateMap);

            /// 2. 一次迭代
            estimateTransformationLogLh(estimate, gridMapUtil, dataContainer);
            //bool notConverged = estimateTransformationLogLh(estimate, gridMapUtil, dataContainer);


            //std::cout << "\n cond: " << cond << " det: " << determinant << "\n";

            int numIter = maxIterations;

            /** 3. 多次迭代求解 **/
            for (int i = 0; i < numIter; ++i)
            {
                //std::cout << "\nest:\n" << estimate;

                estimateTransformationLogLh(estimate, gridMapUtil, dataContainer);
                //notConverged = estimateTransformationLogLh(estimate, gridMapUtil, dataContainer);

                if (drawInterface)
                {
                    float invNumIterf = 1.0f / static_cast<float>(numIter);
                    drawInterface->setColor(static_cast<float>(i) * invNumIterf, 0.0f, 0.0f);
                    drawInterface->drawArrow(gridMapUtil.getWorldCoordsPose(estimate));
                    //drawInterface->drawArrow(Eigen::Vector3f(0.0f, static_cast<float>(i)*0.05, 0.0f));
                }

                if (debugInterface)
                {
                    debugInterface->addHessianMatrix(H);
                }
            }

            if (drawInterface)
            {
                drawInterface->setColor(0.0, 0.0, 1.0);
                drawScan(estimate, gridMapUtil, dataContainer);
            }

            /// 角度正则化
            estimate[2] = util::normalize_angle(estimate[2]);

            covMatrix = Eigen::Matrix3f::Zero();

            ///　使用Hessian矩阵近似协方差矩阵
            covMatrix = H;

            ///　结果转换回物理坐标系下 -- 转换回实际尺度
            return gridMapUtil.getWorldCoordsPose(estimate);
        }

        return beginEstimateWorld;
    }

2.4 estimateTransformationLogLh()

    /**
     *  高斯牛顿估计位姿
     * @param estimate      位姿初始值
     * @param gridMapUtil   网格地图相关计算工具
     * @param dataPoints    激光数据
     * @return  提示是否有解　－－－　貌似没用上
    */
    bool estimateTransformationLogLh(Eigen::Vector3f &estimate, ConcreteOccGridMapUtil &gridMapUtil, const DataContainer &dataPoints)
    {
        /** 计算H矩阵与ｂ列向量，涉及坐标变换，使用网格工具 ---- occGridMapUtil.h 中 **/
        gridMapUtil.getCompleteHessianDerivs(estimate, dataPoints, H, dTr);
        //std::cout << "\nH\n" << H  << "\n";
        //std::cout << "\ndTr\n" << dTr  << "\n";

        //　判断H是否可逆
        if ((H(0, 0) != 0.0f) && (H(1, 1) != 0.0f))
        {

            //H += Eigen::Matrix3f::Identity() * 1.0f;
            /// 求解位姿增量
            Eigen::Vector3f searchDir(H.inverse() * dTr);

            //std::cout << "\nsearchdir\n" << searchDir  << "\n";

            /// 角度增量不能太大
            if (searchDir[2] > 0.2f)
            {
                searchDir[2] = 0.2f;
                std::cout << "SearchDir angle change too large\n";
            }
            else if (searchDir[2] < -0.2f)
            {
                searchDir[2] = -0.2f;
                std::cout << "SearchDir angle change too large\n";
            }

            ///　更新估计值 --- 结果在地图尺度下
            updateEstimatedPose(estimate, searchDir);
            return true;
        }
        return false;
    }

2.5 getCompleteHessianDerivs()

hector_mapping/include/hector_slam_lib/map/OccGridMapUtil.h

    /**
     * 使用当前pose投影dataPoints到地图，计算出 H 矩阵 b列向量， 理论部分详见Hector论文： 《A Flexible and Scalable SLAM System with Full 3D Motion Estimation》.
     * @param pose    地图系上的位姿
     * @param dataPoints  已转换为地图尺度的激光点数据
     * @param H   需要计算的 H矩阵
     * @param dTr  需要计算的 b列向量
     */
    void getCompleteHessianDerivs(const Eigen::Vector3f& pose, const DataContainer& dataPoints, Eigen::Matrix3f& H, Eigen::Vector3f& dTr)
    {
        int size = dataPoints.getSize();

        /** 1. 获取变换矩阵，用于将激光点转换到地图系上。 **/
        Eigen::Affine2f transform(getTransformForState(pose));

        float sinRot = sin(pose[2]);
        float cosRot = cos(pose[2]);

        H = Eigen::Matrix3f::Zero();
        dTr = Eigen::Vector3f::Zero();

        for (int i = 0; i < size; ++i) {

            /** 地图尺度下的激光body系激光点坐标 **/
            const Eigen::Vector2f& currPoint (dataPoints.getVecEntry(i));

            /** transform * currPoint 为地图系下的激光点坐标 **/
            Eigen::Vector3f transformedPointData(interpMapValueWithDerivatives(transform * currPoint));
            /// 这里获取的是 transformedPointData[0]--网格插值得分   transformedPointData[1]--x方向的梯度  transformedPointData[2] -- y方向梯度

            float funVal = 1.0f - transformedPointData[0];

            dTr[0] += transformedPointData[1] * funVal;
            dTr[1] += transformedPointData[2] * funVal;

            float rotDeriv = ((-sinRot * currPoint.x() - cosRot * currPoint.y()) * transformedPointData[1] + (cosRot * currPoint.x() - sinRot * currPoint.y()) * transformedPointData[2]);

            dTr[2] += rotDeriv * funVal;

            H(0, 0) += util::sqr(transformedPointData[1]);
            H(1, 1) += util::sqr(transformedPointData[2]);
            H(2, 2) += util::sqr(rotDeriv);

            H(0, 1) += transformedPointData[1] * transformedPointData[2];
            H(0, 2) += transformedPointData[1] * rotDeriv;
            H(1, 2) += transformedPointData[2] * rotDeriv;
        }
        /// 上面就是按照公式计算H、b，具体公式见论文。
        /// 其中H是对称矩阵，只算上三角就行， 减少计算量。
        H(1, 0) = H(0, 1);
        H(2, 0) = H(0, 2);
        H(2, 1) = H(1, 2);
    }

3 地图更新

3.1 updateByScan()

hector_mapping/include/hector_slam_lib/slam_main/MapProcContainer.h

  /**
   * 有Scan数据更新地图
   * @param dataContainer   当前scan激光数据
   * @param robotPoseWorld  当前scan世界系下位姿
   */
  void updateByScan(const DataContainer &dataContainer, const Eigen::Vector3f &robotPoseWorld)
  {
      if (mapMutex)
      {
          mapMutex->lockMap();
      } //加锁，禁止其他线程竞争地图资源

      /// 更新地图
      gridMap->updateByScan(dataContainer, robotPoseWorld);

      if (mapMutex)
      {
          mapMutex->unlockMap();
      } //地图解锁
  }

3.2 updateByScan()

hector_mapping/include/hector_slam_lib/map/OccGridMapBase.h

    /**
     * 地图更新函数！！！ 使用scan的位姿和激光数据更新地图。英文注释已经很清楚了==
     * Updates the map using the given scan data and robot pose
     * @param dataContainer Contains the laser scan data
     * @param robotPoseWorld The 2D robot pose in world coordinates
     */
    void updateByScan(const DataContainer& dataContainer, const Eigen::Vector3f& robotPoseWorld)
    {
        currMarkFreeIndex = currUpdateIndex + 1;
        currMarkOccIndex = currUpdateIndex + 2;

        //Get pose in map coordinates from pose in world coordinates
        Eigen::Vector3f mapPose(this->getMapCoordsPose(robotPoseWorld));

        //Get a 2D homogenous transform that can be left-multiplied to a robot coordinates vector to get world coordinates of that vector
        Eigen::Affine2f poseTransform((Eigen::Translation2f(mapPose[0], mapPose[1]) * Eigen::Rotation2Df(mapPose[2])));
        ///实际上就是变换矩阵

        //Get start point of all laser beams in map coordinates (same for all beams, stored in robot coords in dataContainer)
        Eigen::Vector2f scanBeginMapf(poseTransform * dataContainer.getOrigo());

        //Get integer vector of laser beams start point
        Eigen::Vector2i scanBeginMapi(scanBeginMapf[0] + 0.5f, scanBeginMapf[1] + 0.5f);

        //Get number of valid beams in current scan
        int numValidElems = dataContainer.getSize();

        //std::cout << "\n maxD: " << maxDist << " num: " << numValidElems << "\n";

        //Iterate over all valid laser beams
        for (int i = 0; i < numValidElems; ++i)
        {

            //Get map coordinates of current beam endpoint
            Eigen::Vector2f scanEndMapf(poseTransform * (dataContainer.getVecEntry(i)));
            //std::cout << "\ns\n" << scanEndMapf << "\n";

            //add 0.5 to beam endpoint vector for following integer cast (to round, not truncate)
            scanEndMapf.array() += (0.5f);

            //Get integer map coordinates of current beam endpoint
            Eigen::Vector2i scanEndMapi(scanEndMapf.cast<int>());

            //Update map using a bresenham variant for drawing a line from beam start to beam endpoint in map coordinates
            if (scanBeginMapi != scanEndMapi)
            {
                updateLineBresenhami(scanBeginMapi, scanEndMapi); /// Bresenhami 算法计算两点连线经过的所有格子
            }
        }

        //Tell the map that it has been updated
        this->setUpdated();/// 记录更新序号

        //Increase update index (used for updating grid cells only once per incoming scan)
        currUpdateIndex += 3; // currUpdateIndex 被吃掉了呗
    }

3.3 updateLineBresenhami()

    inline void updateLineBresenhami( const Eigen::Vector2i& beginMap, const Eigen::Vector2i& endMap, unsigned int max_length = UINT_MAX){

        int x0 = beginMap[0];
        int y0 = beginMap[1];

        //check if beam start point is inside map, cancel update if this is not the case
        if ((x0 < 0) || (x0 >= this->getSizeX()) || (y0 < 0) || (y0 >= this->getSizeY())) {
            return;
        }

        int x1 = endMap[0];
        int y1 = endMap[1];

        //std::cout << " x: "<< x1 << " y: " << y1 << " length: " << length << "     ";

        //check if beam end point is inside map, cancel update if this is not the case
        if ((x1 < 0) || (x1 >= this->getSizeX()) || (y1 < 0) || (y1 >= this->getSizeY())) {
            return;
        }

        int dx = x1 - x0;
        int dy = y1 - y0;

        unsigned int abs_dx = abs(dx);
        unsigned int abs_dy = abs(dy);

        int offset_dx = util::sign(dx);
        int offset_dy = util::sign(dy) * this->sizeX;

        unsigned int startOffset = beginMap.y() * this->sizeX + beginMap.x();

        //if x is dominant
        if(abs_dx >= abs_dy){ /// 激光束穿过的点更新一次Free状态
            int error_y = abs_dx / 2;
            bresenham2D(abs_dx, abs_dy, error_y, offset_dx, offset_dy, startOffset);
        }else{
            //otherwise y is dominant
            int error_x = abs_dy / 2;
            bresenham2D(abs_dy, abs_dx, error_x, offset_dy, offset_dx, startOffset);
        }

        unsigned int endOffset = endMap.y() * this->sizeX + endMap.x();
        this->bresenhamCellOcc(endOffset);/// 激光束端点更新一次Occupied状态

    }

3.4 bresenham2D()

    inline void bresenham2D( unsigned int abs_da, unsigned int abs_db, int error_b, int offset_a, int offset_b, unsigned int offset){

        this->bresenhamCellFree(offset);

        unsigned int end = abs_da-1;

        for(unsigned int i = 0; i < end; ++i){
            offset += offset_a;
            error_b += abs_db;

            if((unsigned int)error_b >= abs_da){
                offset += offset_b;
                error_b -= abs_da;
            }
            /// 激光束穿过的网格被更新一次free状态
            this->bresenhamCellFree(offset);
        }
    }

3.5 bresenhamCellFree()

    inline void bresenhamCellFree(unsigned int offset)
    {
        ConcreteCellType& cell (this->getCell(offset));

        /// 单次scan中,每个网格只允许更新一次free状态（可能有多条激光束穿过同一个网格）
        if (cell.updateIndex < currMarkFreeIndex) {
            concreteGridFunctions.updateSetFree(cell);
            cell.updateIndex = currMarkFreeIndex;
        }
    }

3.6 bresenhamCellOcc()

    inline void bresenhamCellOcc(unsigned int offset)
    {
        ConcreteCellType& cell (this->getCell(offset));
        /// 单次scan中，每个网格只允许更新一次occupied状态
        if (cell.updateIndex < currMarkOccIndex) {

            //if this cell has been updated as free in the current iteration, revert this
            /// 如果击中的网格在当前scan中曾被更新为free状态，那么撤销次free的更新，以occupied状态为准。
            if (cell.updateIndex == currMarkFreeIndex) {
                concreteGridFunctions.updateUnsetFree(cell);
            }

            concreteGridFunctions.updateSetOccupied(cell);
            //std::cout << " setOcc " << "\n";
            cell.updateIndex = currMarkOccIndex;
        }
    }
ROS学习笔记---SLAM之Hector_Mapping
皓冰
06-11 406
以上描述及图片来源于B站UP：机器人工匠阿杰。改变运行参数让机器人动起来，以实时更新地图。
ROS学习记录：launch文件启动Hector_Mapping的建图功能
qq_52251819的博客
06-18 1408
在上一篇笔记中，通过软件包实现了功能，运行了四条指令，有些麻烦。本文通过文件的使用将指令整合起来，方便功能的实现。
Hector slam算法原理解析与代码详解
学之知之的博客
04-19 9779
目录 PS：写了markdown 上传，公式都乱码，无果，截图上传吧。 1. hector 原理解析 1.4 多重分辨率地图 2.代码框架 2.1 回调函数 3. 扫描匹配 3.1 多分辨率匹配 3.2 matchData_2 3.5 hession 矩阵H 求解 3.6 双线性插值计算得分与梯度 4. 地图更新 4.1多分辨率地图 4.2用激光数据和位姿更新地图 4.3 应用分层scan更新地图 4.4.
Hector 入门
weixin_30904593的博客
01-03 551
导入jar包 为了能够使用hector操作Cassandra数据库，首先导入hector的jar包，注意根据实际情况修改版本号 <dependency> <groupId>me.prettyprint</groupId> <artifactId>hector-core</artifactId> <versio...
Hector SLAM算法：同时定位与建图的实践指南
最新发布
weixin_33245447的博客
05-13 1374
Hector SLAM（Simultaneous Localization and Mapping）是SLAM领域中一种基于激光雷达的非线性优化算法。它以无需初始位姿估计、无需里程计数据和不依赖于特定传感器特性而闻名。在本章中，我们将对Hector SLAM算法的基本原理进行概述，以帮助读者建立对该算法的基础了解。Hector SLAM的核心在于实时地从激光雷达数据中提取特征信息，并利用这些信息对环境地图进行增量式构建和更新。算法中，环境中的静态点云被用作地图构建的基准。
cartographer 添加约束 /分支界定法
xiaoma_bk的博客
10-13 5944
1.调用添加约束函数     ComputeConstraint 中（pose_graph_2d）  调用   MaybeAddConstraint         MaybeAddGlobalConstraint if (maybe_add_local_constraint) { const transform::Rigid2d initial_relative_pose = ...
Eigen变换矩阵的几种用法Matrix4f、Affine3f
09-13 1547
【代码】Eigen变换矩阵的几种用法Matrix4f、Affine3f。
cartographer详解（三）—— Real Time Correlative Scan Matcher（2d模式）
weixin_40215443的博客
11-13 1416
cartographer详解（三）—— Real Time Correlative Scan Matcher（2d模式） 摘要：关于real time 匹配的主要原理、代码详解，上一章：cartographer详解（二）—— Real Time Correlative Scan Matcher（3d模式）做了详细的介绍。这一章主要分析2d模式下的做法。 主要区别： 3d: 暴力搜索 2d: 先通过角度切片，然后在在xy方向上暴力搜索。为了减少计算量 一、主要工作逻辑 以初始位置（角度）为基础，角度搜索
hector slam源码
11-24
- `src`: 包含了海克托SLAM的主要源代码文件，如`hector_mapping`和`hector_pose_estimation`。 - `CMakeLists.txt`: 定义了构建过程，包括编译选项和依赖项。 - `package.xml`: 描述了该ROS包的信息，如作者、版本...
学习笔记：使用pointcloud_to_laserscan和hector slam过程中遇到的问题
m0_53567875的博客
09-30 2561
concurrency_level: 2
机器人工匠阿杰ROS快速入门笔记记录
lyd-y1s1的博客
11-22 1522
ros笔记
hector_slam_slam_
10-01
Hector slam利用高斯牛顿方法解决scan-matching问题，对传感器要求较高。
ros中的hector_mapping节点详细介绍
sunyoop的博客
09-27 4983
hector slam可以在没有里程计的情况下，以及展示俯仰的平台上使用建图 在hector_slam程序中，最重要的是hector_mapping节点。 hector_mapping： 订阅的主题： scan (sensor_msgs/LaserScan) ：激光雷达的扫描数据，通常由设备的运行的节点提供，例如：hokuyo node syscommand (std_msg
css磨砂效果背景和特殊背景
AdeZhang1的博客
09-03 4万+
磨砂效果背景 思路其实就是把一张半透明的噪点图做背景然后覆盖颜色，下面用的是一个base64转的半透明图片，家里有条件的可以自己做一张噪点图。 background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAALgAAAC3CAYAAAChZZQSAAAABmJLR0QA/wD/AP+gvaeTAACAAElEQVR42oW9C5huZXnf/dZpI2MUgwOyhQ3vxr2B7csZPEZjGEWM0oxiAI2fDGKM
HTTPS原理
洛阳城下逢公子
07-21 6148
HTTP请求都是明文传输的，所谓的明文指的是没有经过加密的信息，如果HTTP请求被黑客拦截，并且里面含有银行卡密码等敏感数据的话，会非常危险。为了解决这个问题，Netscape 公司制定了HTTPS协议，HTTPS可以将数据加密传输，也就是传输的是密文，即便黑客在传输过程中拦截到数据也无法破译，这就保证了网络通信的安全。 一.密码学基础 明文 明文指的是未被加密过的原始数据 密文 明文被某种加密算法加密之后，会变成密文，从而确保原始数据的安全。密文也可以被解密，得到原始的明文。 密钥 密钥是一种参数，它是在
机器人导航地图——Obstacle层的障碍物-Bresenham算法详细解释
qq_40464599的博客
12-01 2037
作者在读源代码时，遇到了下述的代码void ObstacleLayer::raytraceFreespace，不是很好理解，有很多疑惑，于是打算对此部分进行详解，并记下笔记。////clearing_observation的origin_是传感器坐标，传入//得到传感器原点在地图上的坐标if (!ox, oy);return;//我们可以在内环之外预先计算地图的点。。。我们稍后需要这些//接下来的几个判断结构实际上做的主要工作就是不断迭代传感器原点和点云中的点的连线，
Bresenham's 光线追踪算法，点到直线距离算法，点与多边形相交检测
qq_33179208的博客
07-05 1288
/**    * @brief  A 2D implementation of Bresenham's raytracing algorithm... applies an action at each step    */   template     inline void bresenham2D(ActionType at, unsigned int abs_da, unsigned
上机作业
热门推荐
qq_21919839的专栏
10-12 7万+
// Copyright (c) 2014软件技术1班 // All rights reserved. // 作 者：A38 // 完成日期：2014年 10 月 12 日 // 版 本 号：v1.0 // // 问题描述：创建一个程序来把摄氏温度值转换成华氏温度值。该程序提示用户输入摄氏温度值数据，然后显示出转换后的华氏温度值的数据。 // 输入描述：一个实数，代表摄氏温度值 //
Eigen学习笔记(16)-空间变换
ClaireQi的博客
12-19 7067
原文：Eigen官网-Space transformations
掌握Hector SLAM源码实现与应用
Hector SLAM源码是指实施Hector SLAM算法的程序代码，通常以ROS（Robot Operating System，机器人操作系统）的形式提供，确保了开发者的方便集成和使用。 ### 知识点概述 1. **SLAM技术**：SLAM是一种让机器人在...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值