融合定位学习--激光里程计（解析式求导）

最新推荐文章于 2024-08-21 11:02:00 发布
最新推荐文章于 2024-08-21 11:02:00 发布
阅读量199 收藏 1
点赞数 2
文章标签： 学习 算法 自动驾驶
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44081378/article/details/130847295
版权

环境问题

ceres 的更新中提到LocalParameterization将在版本2.2中删除，如果编译报错，可安装低版本的ceres。
http://ceres-solver.org/version_history.html#id1

ceres入门

参考文档：
slam中ceres的用法解析: link
ceres的常见用法总结：link
官方文档：http://ceres-solver.org/

简单的优化问题可以分两类：
1、残差的维度和优化变量的维度相同；
2、残差的维度和优化变量的维度不同；

1、维度相同

优化问题最重要的就是构建残差函数和求雅可比矩阵，维度相同时优化更新可以直接相加减，基本步骤是：
1.建立一个最小二乘问题；
2.建立CostFunction;
3.添加残差模块；
4.设置求解器；
用一个简单的例子结合代码说明使用方法，y = a x + b ，随即生成一些含噪声的点（x,y），通过优化得到a和b的值。

// 一个仿函数用于设置残差计算 
class ExpResidual { 
 public: 
  ExpResidual(double x, double y) : x_(x), y_(y) {} 
 
  // 残差计算 
  // 注意残差计算operator后边是先优化变量再残差，和AutoDiff中相反 
  template <typename T> 
  bool operator()(const T* a, const T* b, T* residual) const { 
    residual[0] = T(y_) - a[0] * T(x_) - b[0]; 
    return true; 
  } 
 
  const double x_; 
  const double y_; 
}; 

int main(int argc, char **argv)
{
    double a = 0.0, b = 0.0; 
    cv::RNG rng; 
    double w_sigma = 0.2;

    // 1. 建立一个最小二乘问题 
    ceres::Problem problem; 
    for (int i = 0; i < 100; ++i) { 
        // 按照m = 2.2, c = 1.1 来对100个点进行赋值，并给予白噪声 
        std::cout << "gaussian = " << rng.gaussian(w_sigma * w_sigma) << std::endl; 
        double y_with_noise = 2.2 * i  + 1.1 + rng.gaussian(w_sigma * w_sigma); 
        // 2. 建立一个CostFunction, 如果是AutoDiff自动求解就如下 
        // AutoDiffCostFunction<仿函数类，残差的维度，剩下的一堆是优化变量的维度> 
        ceres::CostFunction* cost_function = 
            new ceres::AutoDiffCostFunction<ExpResidual, 1, 1, 1>( new ExpResidual(i , y_with_noise)); 
        // 3. 添加残差模块，用problem.AddResidualBlock(costFunc, 鲁邦核函数，优化变量们用指针传) 
        problem.AddResidualBlock(cost_function, new ceres::CauchyLoss(0.5), &a, &b); 
    } 
    
    // 4. 设置求解器和输出报告 
    ceres::Solver::Options options; 
    options.linear_solver_type = ceres::DENSE_NORMAL_CHOLESKY; 
    options.minimizer_progress_to_stdout = true; 
    
    ceres::Solver::Summary summary; 
    ceres::Solve(options, &problem, &summary); 
    
    std::cout << summary.BriefReport() << std::endl; 
    std::cout << "a = " << a << " b = " << b << std::endl; 

    return 0;
}

结果很接近
在这里插入图片描述

如果不使用自动求导而使用解析式求导（即直接给出导数的解析形式），可以通过定义一个SizedCostFunction的子类，实现Evaluate函数，手动给出雅可比。代码如下：

// 第一个参数是ResidualBlock的维数
// 第二个参数是ParameterBlock的维数
class LineCostFunction : public ceres::SizedCostFunction<1,1,1>{
    public:
    LineCostFunction(const double x_, const double y_) : x(x_),y(y_){}
    virtual ~LineCostFunction(){}
    virtual bool Evaluate(double const* const* parameters,
                          double* residuals,
                          double** jacobians) const{
        const double a = parameters[0][0];
        const double b = parameters[1][0];

        residuals[0] = y - a * x - b;
        if(jacobians != NULL)
		{
			if(jacobians[0] != NULL)
			{
                jacobians[0][0] = - x ;
                jacobians[0][1] = -1.0 ;
            } 
        }
        return true;
    }
    protected:
	const double x;
	const double y;
};

主函数里面这样构建优化问题：

 		// 2.1 建立一个CostFunction, 如果是AutoDiff自动求解就如下 
        // AutoDiffCostFunction<仿函数类，残差的维度，剩下的一堆是优化变量的维度> 
        // ceres::CostFunction* cost_function = 
        //    new ceres::AutoDiffCostFunction<ExpResidual, 1, 1, 1>( new ExpResidual(i , y_with_noise));
        // 2.2 解析式求导数
            ceres::CostFunction* cost_function = new LineCostFunction(i , y_with_noise);
        // 3. 添加残差模块，用problem.AddResidualBlock(costFunc, 鲁邦核函数，优化变量们用指针传) 
        problem.AddResidualBlock(cost_function, new ceres::CauchyLoss(0.5), &a, &b);

2、维度不同

优化问题最重要的就是要计算雅克比矩阵和残差，因此如何执行加减法运算对于优化求解至关重要。由于四元数并不是通过简单的加减乘除就可以进行运算，而是有一套自己的计算方法，因此这种情况必须手动定义加运算，在ceres中要增加ceres::LocalParameterization来定义运算。
aloam(自动求导)
该代码优化变量为七维位姿parameters[7], t(3,1) | q(4, 1) 使用ceres自带的计算四元数的方法ceres::EigenQuaternionParameterization()

// 1. 设置鲁邦核函数，用在AddResidualBlock 
ceres::LossFunction *loss_function = new ceres::HuberLoss(0.1); 
// 2. 设置LocalParameterization，即四元数的加法定义 
ceres::LocalParameterization *q_parameterization = 
    new ceres::EigenQuaternionParameterization(); 
// 3. 建立求解器选项 
ceres::Problem::Options problem_options; 
//... 
ceres::Problem problem(problem_options); 
// 4.注意到如果使用了LocalParameterization，那么必须添加AddParameterBlock来添加不规则+-优化变量 
problem.AddParameterBlock(parameters, 4, q_parameterization); 
problem.AddParameterBlock(parameters + 4, 3); 
 
// 5.使用工厂模式创建cost_function 
ceres::CostFunction *cost_function =  
    LidarEdgeFactor::Create(curr_point, point_a, point_b, 1.0); 
problem.AddResidualBlock(cost_function, loss_function, parameters, parameters + 4); 
 
// 定义了激光雷达角点计算残差的方式，和上一个例子中class ExpResidual类似 
// 与上一个例子class ExpResidual不同的是，增加了Create函数， 
// 实际上省掉了一些主函数中要写的东西 
struct LidarEdgeFactor { 
    LidarEdgeFactor(Eigen::Vector3d curr_point_, Eigen::Vector3d last_point_a_, 
                    Eigen::Vector3d last_point_b_, double s_) 
        : curr_point(curr_point_), last_point_a(last_point_a_),  
          last_point_b(last_point_b_), s(s_) {} 
 
    template<typename T> 
    bool operator()(const T *q, const T *t, T *residual) const { // 仿函数，用于计算残差 
        Eigen::Matrix<T, 3, 1> cp{T(curr_point.x()), T(curr_point.y()), T(curr_point.z())}; 
        Eigen::Matrix<T, 3, 1> lpa{T(last_point_a.x()), T(last_point_a.y()), T(last_point_a.z())}; 
        Eigen::Matrix<T, 3, 1> lpb{T(last_point_b.x()), T(last_point_b.y()), T(last_point_b.z())}; 
 
        // Eigen::Quaternion<T>  
        Eigen::Quaternion<T> q_last_curr{q[3], q[0], q[1], q[2]}; // q 
        Eigen::Quaternion<T> q_identity{T(1), T(0), T(0), T(0)}; // 单位四元数 
        q_last_curr = q_identity.slerp(T(s), q_last_curr); // 四元数线性插值, s是0-1之间的值，用于 
        Eigen::Matrix<T, 3, 1> t_last_curr{T(s) * t[0], T(s) * t[1], T(s) * t[2]}; // t 
 
        Eigen::Matrix<T, 3, 1> lp; 
        lp = q_last_curr * cp + t_last_curr; 
 
        // distance = |(pi - pj)x(pi - pl)| / |pj - pl| 
        Eigen::Matrix<T, 3, 1> nu = (lp - lpa).cross(lp - lpb); 
        Eigen::Matrix<T, 3, 1> de = lpa - lpb; 
 
        residual[0] = nu.x() / de.norm(); 
        residual[1] = nu.y() / de.norm(); 
        residual[2] = nu.z() / de.norm(); 
 
        return true; 
    } 
 
    static ceres::CostFunction *Create(const Eigen::Vector3d curr_point_,  
                                       const Eigen::Vector3d last_point_a_, 
                                       const Eigen::Vector3d last_point_b_, 
                                       const double s_) 
    { 
        return (new ceres::AutoDiffCostFunction<LidarEdgeFactor, 3, 4, 3>( 
            new LidarEdgeFactor(curr_point_, last_point_a_, last_point_b_, s_) 
        )); 
    } 
 
    Eigen::Vector3d curr_point, last_point_a, last_point_b; 
    double s; 
};

aloam (解析式求导)
线特征雅克比推导：
在这里插入图片描述在这里插入图片描述面特征雅克比推导
在这里插入图片描述代码实现：
反对称矩阵定义

inline Eigen::Matrix<double,3,3> skew(Eigen::Matrix<double,3,1>& mat_in){
    Eigen::Matrix<double,3,3> skew_mat;
    skew_mat.setZero();
    skew_mat(0,1) = -mat_in(2);
    skew_mat(0,2) =  mat_in(1);
    skew_mat(1,2) = -mat_in(0);
    skew_mat(1,0) =  mat_in(2);
    skew_mat(2,0) = -mat_in(1);
    skew_mat(2,1) =  mat_in(0);
    return skew_mat;
}

定义CostFunction

// EdgeAnalyticCostFunction
class LidarEdgeAnalyticCostFunction : public ceres::SizedCostFunction<1, 4, 3> {
public:
    LidarEdgeAnalyticCostFunction(Eigen::Vector3d curr_point_, Eigen::Vector3d last_point_a_,
								Eigen::Vector3d last_point_b_, double s_)
		: curr_point(curr_point_), last_point_a(last_point_a_), last_point_b(last_point_b_), s(s_) {}

  	virtual bool Evaluate(double const* const* parameters,
                        double* residuals,
                        double** jacobians) const
	{
		Eigen::Map<const Eigen::Quaterniond> q_last_curr(parameters[0]);
		Eigen::Map<const Eigen::Vector3d> t_last_curr(parameters[1]);
		Eigen::Vector3d lp;
		Eigen::Vector3d lp_r;
		lp_r = q_last_curr * curr_point; // for computing Jacobian of Rotation: dp_by_dr
		lp = q_last_curr * curr_point + t_last_curr; //new point
		Eigen::Vector3d nu = (lp - last_point_b).cross(lp - last_point_a);
		Eigen::Vector3d de = last_point_a - last_point_b;

		residuals[0] = nu.norm() / de.norm();

		if(jacobians != NULL)
		{
			if(jacobians[0] != NULL)
			{
				Eigen::Vector3d X = nu;
				Eigen::Vector3d re = last_point_a - last_point_b;
				Eigen::Matrix3d skew_re = skew(re);
				Eigen::Matrix3d skew_de = skew(de);
				//  Rotation
				Eigen::Matrix3d skew_lp_r = skew(lp_r);
				Eigen::Matrix<double, 3, 3> dp_by_dr;
				dp_by_dr.block<3,3>(0,0) = -skew_lp_r;
				Eigen::Map<Eigen::Matrix<double, 1, 4, Eigen::RowMajor> > J_so3_r(jacobians[0]);
				J_so3_r.setZero();
				J_so3_r.block<1,3>(0,0) = X.transpose() * skew_de * dp_by_dr / X.norm() / de.norm();

				// Translation
				Eigen::Matrix<double, 3, 3> dp_by_dt;
				(dp_by_dt.block<3,3>(0,0)).setIdentity();
				Eigen::Map<Eigen::Matrix<double, 1, 3, Eigen::RowMajor> > J_so3_t(jacobians[1]);
				J_so3_t.setZero();
				J_so3_t.block<1,3>(0,0) = X.transpose() * skew_re * dp_by_dt / X.norm() / de.norm();
			}
		}

		return true;
 
	}

protected:
	Eigen::Vector3d curr_point, last_point_a, last_point_b;
	double s;
};


// PlaneAnalyticCostFunction
class LidarPlaneAnalyticCostFunction : public ceres::SizedCostFunction<1, 4, 3> {
public:
    LidarPlaneAnalyticCostFunction(Eigen::Vector3d curr_point_, Eigen::Vector3d last_point_j_,
								Eigen::Vector3d last_point_l_, Eigen::Vector3d last_point_m_, double s_)
		: curr_point(curr_point_), last_point_j(last_point_j_), last_point_l(last_point_l_), last_point_m(last_point_m_), s(s_) {}

  	virtual bool Evaluate(double const* const* parameters,
                        double* residuals,
                        double** jacobians) const 
	{
		Eigen::Map<const Eigen::Quaterniond> q_last_curr(parameters[0]);
		Eigen::Map<const Eigen::Vector3d> t_last_curr(parameters[1]);
		Eigen::Vector3d lp;
		Eigen::Vector3d lp_r;
		lp_r = q_last_curr * curr_point; // for computing Jacobian of Rotation: dp_dr
		lp = q_last_curr * curr_point + t_last_curr; //new point
		Eigen::Vector3d de = (last_point_l-last_point_j).cross(last_point_m-last_point_j);
		de.normalize();

		double nu = (lp-last_point_j).dot(de);
		
		residuals[0] = nu / de.norm();

		if(jacobians != NULL)
		{
			if(jacobians[0] != NULL)
			{
				Eigen::Vector3d dX_dp = de / de.norm();
				double X = nu / de.norm();
				Eigen::Vector3d ddh_dp = X * dX_dp / std::abs(X);
				//  Rotation
				Eigen::Matrix3d skew_lp_r = skew(lp_r);
				Eigen::Matrix<double, 3, 3> dp_dr;
				dp_dr.block<3,3>(0,0) = -skew_lp_r;
				Eigen::Map<Eigen::Matrix<double, 1, 4, Eigen::RowMajor> > J_so3_r(jacobians[0]);
				J_so3_r.setZero();
				J_so3_r.block<1,3>(0,0) = ddh_dp.transpose() * dp_dr;

				// Translation
				Eigen::Matrix<double, 3, 3> dp_dt;
				(dp_dt.block<3,3>(0,0)).setIdentity();
				Eigen::Map<Eigen::Matrix<double, 1, 3, Eigen::RowMajor> > J_so3_t(jacobians[1]);
				J_so3_t.setZero();
				J_so3_t.block<1,3>(0,0) = ddh_dp.transpose() * dp_dt;
			}
		}

		return true;
 
	}

protected:
	Eigen::Vector3d curr_point, last_point_j, last_point_l, last_point_m;
	double s;
};

定义旋转参数块
这里可以用ceres的四元数参数块：

 config_.q_parameterization_ptr = new ceres::EigenQuaternionParameterization();

自己定义四元数更新参数块

//  自定义旋转残差块
//参考博客   https://blog.csdn.net/jdy_lyy/article/details/119360492
class PoseSO3Parameterization  :   public  ceres::LocalParameterization {                               //  自定义so3  旋转块
 public:       
        PoseSO3Parameterization()  { }

        virtual ~PoseSO3Parameterization() { }
  
        virtual bool Plus(const double* x,
                        const double* delta,
                        double* x_plus_delta) const          //参数正切空间上的更新函数
                { 
                        Eigen::Map<const  Eigen::Quaterniond>   quater(x);       //   待更新的四元数
                        Eigen::Map<const  Eigen::Vector3d>     delta_so3(delta);     //    delta 值,使用流形 so3 更新

                        Eigen::Quaterniond  delta_quater  =   Sophus::SO3d::exp(delta_so3).unit_quaternion();     //   so3 转换位 delta_p  四元数
                        
                        Eigen::Map<Eigen::Quaterniond>  quter_plus(x_plus_delta);    //   更新后的四元数

                        // 旋转更新公式
                        quter_plus =  (delta_quater*quater).normalized();        

                        return  true;
                }

        virtual bool ComputeJacobian(const double* x, double* jacobian) const  //  四元数对so3的偏导数
        {
                Eigen::Map<Eigen::Matrix<double, 4, 3, Eigen::RowMajor>> j(jacobian);
                (j.topRows(3)).setIdentity();
                (j.bottomRows(1)).setZero();

                return true;
        }

        // virtual bool MultiplyByJacobian(const double* x,
        //                                 const int num_rows,
        //                                 const double* global_matrix,
        //                                 double* local_matrix) const;//一般不用

        virtual int GlobalSize() const  {return  4;} // 参数的实际维数
        virtual int LocalSize() const   {return  3;} // 正切空间上的参数维数
};

解析求导

CeresALOAMRegistration::~CeresALOAMRegistration() {
}

/**
  * @brief  add residual block for edge constraint from lidar frontend
  * @param  source, source point  
  * @param  target_x, target point x
  * @param  target_y, target point y
  * @param  ratio, interpolation ratio 
  * @return void
  */
bool CeresALOAMRegistration::AddEdgeFactor(
    const Eigen::Vector3d &source,
    const Eigen::Vector3d &target_x, const Eigen::Vector3d &target_y,
    const double &ratio
) {
    /*自动求导*/
   /* ceres::CostFunction *factor_edge = LidarEdgeFactor::Create(
        source, 
        target_x, target_y, 
        ratio
    );
    
    problem_.AddResidualBlock(
        factor_edge, 
        config_.loss_function_ptr, 
        param_.q, param_.t
    );*/
    /*解析求导*/
   ceres::CostFunction *factor_analytic_edge =   new LidarEdgeAnalyticCostFunction(
        source, 
        target_x, target_y, 
        ratio
   );

    problem_.AddResidualBlock(
        factor_analytic_edge,                                    //   约束边   cost_function
        config_.loss_function_ptr,        //   鲁棒核函数  lost_function
        param_.q, param_.t                      //  关联参数
    );
    return true;
}

/**
  * @brief  add residual block for plane constraint from lidar frontend
  * @param  source, source point
  * @param  target_x, target point x
  * @param  target_y, target point y
  * @param  target_z, target point z
  * @param  ratio, interpolation ratio
  * @return void
  */
bool CeresALOAMRegistration::AddPlaneFactor(
    const Eigen::Vector3d &source,
    const Eigen::Vector3d &target_x, const Eigen::Vector3d &target_y, const Eigen::Vector3d &target_z,
    const double &ratio
) {
    /*自动求导*/
    /*
    ceres::CostFunction *factor_plane = LidarPlaneFactor::Create(
        source, 
        target_x, target_y, target_z, 
        ratio
    );

    problem_.AddResidualBlock(
        factor_plane,
        config_.loss_function_ptr, 
        param_.q, param_.t
    );
    */

     /*解析求导*/
    ceres::CostFunction *factor_analytic_plane =new LidarPlaneAnalyticCostFunction(
        source, 
        target_x, target_y, target_z, 
        ratio
    );
    problem_.AddResidualBlock(
        factor_analytic_plane,
        config_.loss_function_ptr, 
        param_.q, param_.t
    );

    return true;
}

evo 评价

在这里插入图片描述
在这里插入图片描述

weixin_44081378
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
imu 里程计融合_自动驾驶汽车中的精准定位—IMU&RTK
weixin_29342901的博客
12-31 3318
ACEINNA随着科技的不断发展，自动驾驶技术日趋成熟。车辆通过感知周围世界来进行自主导航，但这一切都基于对车辆定位精确性和安全性的承诺和保障。为了实现自动驾驶汽车的各种复杂功能，精确而又可靠的位置信息开始变得不可或缺。拥挤的城市峡谷环境给自动驾驶汽车传感器阵列带来了巨大的挑战。当自动驾驶汽车在失去GPS/GNSS信号的情况下试图左转时，IMU技术开始凸显它的重要作用。拥挤的城市峡谷环境...
imu 里程计融合_视觉里程计IMU辅助GPS融合定位算法研究
weixin_39792803的博客
12-29 1440
视觉里程计/IMU辅助GPS融合定位算法研究不同的传感器用于导航定位各有其优势与不足,需要依据不同的应用场景对各传感器进行组合以获取最优导航定位性能。在城市、桥梁等遮挡环境下,GPS信号容易发生中断或卫星信号质量不佳,导致室外定位精度不够。为此,本文将主要研究视觉里程计/IMU辅助GPS融合定位算法,提高室外受限环境下导航定位精度与可靠性。本文的主要研究内容有:(1)分别研究了视觉里程计和IMU的...
多传感器融合定位-3D激光里程计（二）
咩吃咩
05-05 389
多传感器融合定位-3D激光里程计预备知识内积外积点云线面特征提取基于线面特征的位姿优化相关开源里程计 预备知识 内积 向量点乘，是a向量在b向量方向上投影的长度。 外积 叉乘，叉积，向量积可以表示为向量a、b所组成的平行四边形的面积。 点云线面特征提取 基于线面特征的位姿优化 相关开源里程计 ...
多传感器融合定位 第二讲 3D激光里程计1
天天向上的博客
04-07 302
多传感器融合定位第二讲
【激光SLAM】里程计运动模型及标定
PuddleRubbish的博客
02-05 790
自由度为3（即X,Y,θ），但是驱动数只有2个（即VL,VR，左轮速度和右轮速度)。欠驱动系统造成差分模型的平移运动和旋转运动是耦合的，无法单独分解运动。差分底盘只能做一种运动——圆弧运动。对于纯旋转而言，r趋于0，实际上还是两个圆弧运动。，提高机器人导航的精度和可靠性。通过标定，可以确定里程计的误差模型和参数，从而对机器人的位移和姿态进行更准确的计算。Ax=b的每一行代表一个约束，列代表未知数的维数。表示激光雷达测得的第i帧与第j帧的相对位置关系，即u_i。同理，u_i则为由里程计测量得到的同一关系。
多传感器融合定位四-3D激光里程计其四：点云线面特征提取
泠山的博客
12-18 1421
假如我们求一个点到线的距离的时候，假如这个线上有一百个点，不可能这一百个点都求一个点到线的距离，这个计算量会大到无法接受，这时只能选一部分点来计算点到直线的距离。应该将曲率最大的几个点选出来-----曲率大的点有更大的概率属于一个良好的线特征(错误归进来的点可能并不属于线特征，它们的曲率一般都是比较小的)，反之亦然。假设我们有一个残差，我们需要对残差求雅可比，如果将雅可比直接输到代码里，叫做解析求导，就是说已经解析式的，将求导的公式告诉算法了。帧之前的某些帧，共同构建出来了一个特征集合的map。
【多传感器融合定位】【3 3D激光里程计Ⅱ】【学习过程记录】
qq_45954434的博客
04-26 428
【多传感器融合定位】【3 3D激光里程计Ⅱ】【学习过程记录】0 前言1 A_LOAM的学习及详细注释2 ceres的学习2.1 前言2.2 待看文章 0 前言 1 A_LOAM的学习及详细注释 请转到：【多传感器融合定位】【代码阅读】【A_LOAM及详细注释】 2 ceres的学习 2.1 前言 2.2 待看文章 【Ceres】（二）LocalParameterization参数化 [ceres-solver] From QuaternionParameterization to LocalParamet
多传感器融合定位六-惯性导航原理及误差分析
泠山的博客
12-31 1909
前面几章讲了怎样用单个传感器把图建出来然后再做定位。接下来就进入了融合的环节，即怎样把图和定位建的更好。1687年，伟大的英国科学家牛顿提出力学三大定律，为惯性导航技术奠定了理论基础。 自20世纪60年代起，出现了挠性陀螺仪和动力谐调陀螺仪，同时平台式惯导系统发展迅速，并大量装备各种飞机、舰船、导弹和航天飞行器。 Sagnac效应由法国物理学家 Sagnac 于 1913 年发现，其原理是干涉仪相对惯性空间静止时，光路 A 和 B 的光程相等，当有角速度时，光程不相等，便会产生干涉。 同样基于Sagnac效
RTAB-MAP开源视觉-激光-里程计SLAM代码
04-22
RTAB-MAP压缩包里有以下个开源代码： 1、RTAB-Map as an open-source lidar and visual simultaneous localization and mapping library for large-scale and long-term online operation-2018.pdf ...
SLAM+激光里程计+定位+移动机器人
10-07
本文介绍的CT-ICP（Continuous-Time Iterative Closest Point）是一种新的实时激光里程计算法，特别适用于多束激光雷达传感器，如在自动驾驶汽车中的应用。激光雷达因其对环境的精确感知能力，在定位和感知任务中...
基于多传感器融合的车辆里程计系统设计
02-26
### 基于多传感器融合的车辆里程计...综上所述，基于多传感器融合的车辆里程计系统通过利用多种传感器的数据并结合先进的状态估计方法（如ESKF），能够有效地提高定位精度，为自动驾驶技术的发展提供了重要的技术支持。
SLAM-GICP点云配准算法实现-实现scan-scan的GICP里程计-优质项目实战.zip
03-19
在SLAM系统中，GICP里程计是用于连续扫描匹配的关键组件，它通过连续的配准更新机器人的位姿估计，从而实现长期定位的稳定性。GICP的优势在于它能够处理非刚性变形和局部环境变化，使得在动态环境中也能获得较好的...
论文研究-轮式移动机器人里程计系统误差校核.pdf
07-22
里程计在轮式移动机器人运行过程中存在严重的误差累计，通过校核系统参数可以减小系统误差。针对传统UMBmark系统误差校核方法存在的不足，提出一种改进的系统误差校核新方法。该算法综合考虑三种主要系统误差来源...
Freertos学习笔记
qq_45031559的博客
08-21 628
Freertos学习笔记
零基础学习人工智能—Python—Pytorch学习（六）
最新发布
kiba518的博客
08-21 852
前言 本文主要讲神经网络的上半部分。 这篇文章开始有很多公式了，这些公式都很简单，但是如果是不经常在脑海里思考公式的人，那可能需要多花点时间做一下自我训练，个人感觉，也就几天时间，就能把自己感觉给调整出来。 习惯了公式看下面内容就会轻松很多，另外如果要深入学习人工智能，熟练的认知公式也是个必须的事情。 另外，我发现我前面文章写的有歧义的地方还是挺多，虽然，已经改了一部分，但，可能还有没发现的，大...
一起学习LeetCode热题100道（48/100）
weixin_53224223的博客
08-20 524
7.注意：虽然代码中包含了回溯部分（即减少当前路径和的计数并从prefixSums中删除它），但在本问题中，由于树是无环的，并且我们不需要精确跟踪每条路径，因此这部分是多余的。输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22。输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8。1.这是主函数，接收根节点和目标和作为参数，并返回满足条件的路径数量。
sed & awk 第二版学习（一）—— sed 与 awk 基本操作
wzy0623的专栏
08-20 951
sed 与 awk 基本操作
FreeRTOS学习笔记（四）——延时函数，列表，软件定时器，低功耗模式，内存管理
个人风格极强的知识汇总
08-20 1319
FreeRTOS学习笔记（四）——延时函数，列表，软件定时器，低功耗模式，内存管理
RGB-D相机视觉里程计：解决双舵轮AGV定位难题
此外，该研究还在Linux和ROS（Robot Operating System）环境下构建了视觉里程计系统，并结合激光雷达数据，运用粒子滤波算法进行定位。实验结果表明，该系统具有良好的鲁棒性，并在不同环境下对比了编码器和视觉里程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值