自动驾驶系列（4）ALOAM源码解析-laserOdometry.cpp

于 2024-05-13 19:10:55 发布
阅读量349 收藏 4
点赞数 5
文章标签： 自动驾驶 人工智能 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/earo0/article/details/138795797
版权

1原理

利用激光雷达数据进行机器人的位姿估计。具体来说，它通过订阅激光雷达的不同类型点云话题，获取尖锐角点、不尖锐角点、平坦平面和不平坦平面等信息。然后，对这些点云数据进行处理和关联，利用 Ceres 库进行优化求解，估计机器人的位姿变换。最后，将位姿信息发布到 ROS 话题中，供其他节点使用。

  • 点云数据处理：代码首先对订阅到的点云数据进行处理，包括去畸变、坐标变换等操作。
  • 特征提取：从点云中提取尖锐角点和平坦平面等特征，并建立相应的 Kd 树用于快速搜索最近邻点。
  • 对应关系建立：通过遍历特征点，利用 Kd 树搜索最近邻点，并根据距离和扫描线信息建立对应关系。
  • 位姿优化：使用 Ceres 库构建优化问题，将对应关系作为约束，通过最小化误差函数来求解机器人的位姿变换。
  • 位姿发布：将优化得到的位姿信息发布到 ROS 话题中

2 实现

2.1去畸变函数

先转换到初始点，依据匀速模型。
再转换到结束点，迭代优化。

// 对激光雷达点进行去畸变
void TransformToStart(PointType const *const pi, PointType *const po)
{
    // 插值比例
    double s;
    // 如果考虑畸变
    if (DISTORTION)
        s = (pi->intensity - int(pi->intensity)) / SCAN_PERIOD;
    else
        s = 1.0;
    //s = 1;
    // 上一帧的四元数
    Eigen::Quaterniond q_point_last = Eigen::Quaterniond::Identity().slerp(s, q_last_curr);
    // 上一帧的平移
    Eigen::Vector3d t_point_last = s * t_last_curr;
    // 当前点的坐标
    Eigen::Vector3d point(pi->x, pi->y, pi->z);
    // 去畸变后的点坐标
    Eigen::Vector3d un_point = q_point_last * point + t_point_last;

    po->x = un_point.x();
    po->y = un_point.y();
    po->z = un_point.z();
    po->intensity = pi->intensity;
}

// 将所有激光雷达点变换到下一帧的开始
void TransformToEnd(PointType const *const pi, PointType *const po)
{
    // 先去畸变
    pcl::PointXYZI un_point_tmp;
    TransformToStart(pi, &un_point_tmp);

    Eigen::Vector3d un_point(un_point_tmp.x, un_point_tmp.y, un_point_tmp.z);
    Eigen::Vector3d point_end = q_last_curr.inverse() * (un_point - t_last_curr);

    po->x = point_end.x();
    po->y = point_end.y();
    po->z = point_end.z();

    // 去除畸变时间信息
    po->intensity = int(pi->intensity);
}

2.2主函数

功能：

  • main 函数：
  • 初始化 ROS 节点。
  • 订阅激光雷达点云话题。
  • 创建 ROS 发布者，发布激光里程计、激光路径和处理后的点云数据。
  • 在主循环中，处理接收到的点云数据。
  • 如果系统尚未初始化，则进行初始化操作。
  • 否则，进行点云数据的关联和优化。
  • 发布激光里程计和路径。
  • 转换和发布处理后的点云数据。
  • 统计时间并输出警告信息。
    （1）订阅和发布的话题
    // 订阅尖锐角点话题
    ros::Subscriber subCornerPointsSharp = nh.subscribe<sensor_msgs::PointCloud2>("/laser_cloud_sharp", 100, laserCloudSharpHandler);

    // 订阅不尖锐角点话题
    ros::Subscriber subCornerPointsLessSharp = nh.subscribe<sensor_msgs::PointCloud2>("/laser_cloud_less_sharp", 100, laserCloudLessSharpHandler);

    // 订阅平坦平面话题
    ros::Subscriber subSurfPointsFlat = nh.subscribe<sensor_msgs::PointCloud2>("/laser_cloud_flat", 100, laserCloudFlatHandler);

    // 订阅不平坦平面话题
    ros::Subscriber subSurfPointsLessFlat = nh.subscribe<sensor_msgs::PointCloud2>("/laser_cloud_less_flat", 100, laserCloudLessFlatHandler);

    // 订阅全分辨率激光云话题
    ros::Subscriber subLaserCloudFullRes = nh.subscribe<sensor_msgs::PointCloud2>("/velodyne_cloud_2", 100, laserCloudFullResHandler);

    // 发布上一帧尖锐角点的激光云话题
    ros::Publisher pubLaserCloudCornerLast = nh.advertise<sensor_msgs::PointCloud2>("/laser_cloud_corner_last", 100);

    // 发布上一帧平坦平面的激光云话题
    ros::Publisher pubLaserCloudSurfLast = nh.advertise<sensor_msgs::PointCloud2>("/laser_cloud_surf_last", 100);

    // 发布全分辨率激光云话题
    ros::Publisher pubLaserCloudFullRes = nh.advertise<sensor_msgs::PointCloud2>("/velodyne_cloud_3", 100);

    // 发布激光里程计话题
    ros::Publisher pubLaserOdometry = nh.advertise<nav_msgs::Odometry>("/laser_odom_to_init", 100);

    // 发布激光路径话题
    ros::Publisher pubLaserPath = nh.advertise<nav_msgs::Path>("/laser_odom_path", 100);

（2）点云数据的关联和优化
利用Ceres库（一个非线性优化器）解决基于激光雷达数据的形状配准问题。首先，它初始化了一些必要的变量和对象，然后进入一个循环，针对边缘点和平面点分别进行配准。同时在每个循环中，它首先找到当前点在上一帧激光雷达数据中的 nearest neighbor，然后根据扫描ID的差异来搜索更近或更远的点。

// 寻找平面特征的对应关系
for (int i = 0; i < surfPointsFlatNum; ++i)
{
    TransformToStart(&(surfPointsFlat->points[i]), &pointSel);
    kdtreeSurfLast->nearestKSearch(pointSel, 1, pointSearchInd, pointSearchSqDis);

    int closestPointInd = -1, minPointInd2 = -1, minPointInd3 = -1;
    if (pointSearchSqDis[0] < DISTANCE_SQ_THRESHOLD)
    {
        closestPointInd = pointSearchInd[0];

        // 获取最近点的扫描 ID
        int closestPointScanID = int(laserCloudSurfLast->points[closestPointInd].intensity);
        double minPointSqDis2 = DISTANCE_SQ_THRESHOLD, minPointSqDis3 = DISTANCE_SQ_THRESHOLD;

        // 在扫描线增加的方向搜索
        for (int j = closestPointInd + 1; j < (int)laserCloudSurfLast->points.size(); ++j)
        {
            // 如果不在附近扫描，结束循环
            if (int(laserCloudSurfLast->points[j].intensity) > (closestPointScanID + NEARBY_SCAN))
                break;

            double pointSqDis = (laserCloudSurfLast->points[j].x - pointSel.x) *
                                    (laserCloudSurfLast->points[j].x - pointSel.x) +
                                (laserCloudSurfLast->points[j].y - pointSel.y) *
                                    (laserCloudSurfLast->points[j].y - pointSel.y) +
                                (laserCloudSurfLast->points[j].z - pointSel.z) *
                                    (laserCloudSurfLast->points[j].z - pointSel.z);

            // 如果在同一或更低扫描线，更新 minPointSqDis2
            if (int(laserCloudSurfLast->points[j].intensity) <= closestPointScanID && pointSqDis < minPointSqDis2)
            {
                minPointSqDis2 = pointSqDis;
                minPointInd2 = j;
            }
            // 如果在更高扫描线，更新 minPointSqDis3
            else if (int(laserCloudSurfLast->points[j].intensity) > closestPointScanID && pointSqDis < minPointSqDis3)
            {
                minPointSqDis3 = pointSqDis;
                minPointInd3 = j;
            }
        }

        // 在扫描线减少的方向搜索
        for (int j = closestPointInd - 1; j >= 0; --j)
        {
            // 如果不在附近扫描，结束循环
            if (int(laserCloudSurfLast->points[j].intensity) < (closestPointScanID - NEARBY_SCAN))
                break;

            double pointSqDis = (laserCloudSurfLast->points[j].x - pointSel.x) *
                                    (laserCloudSurfLast->points[j].x - pointSel.x) +
                                (laserCloudSurfLast->points[j].y - pointSel.y) *
                                    (laserCloudSurfLast->points[j].y - pointSel.y) +
                                (laserCloudSurfLast->points[j].z - pointSel.z) *
                                    (laserCloudSurfLast->points[j].z - pointSel.z);

            // 如果在同一或更高扫描线，更新 minPointSqDis2
            if (int(laserCloudSurfLast->points[j].intensity) >= closestPointScanID && pointSqDis < minPointSqDis2)
            {
                minPointSqDis2 = pointSqDis;
                minPointInd2 = j;
            }
            // 如果在更低扫描线，更新 minPointSqDis3
            else if (int(laserCloudSurfLast->points[j].intensity) < closestPointScanID && pointSqDis < minPointSqDis3)
            {
                minPointSqDis3 = pointSqDis;
                minPointInd3 = j;
            }
        }

        if (minPointInd2 >= 0 && minPointInd3 >= 0)
        {
            Eigen::Vector3d curr_point(surfPointsFlat->points[i].x,
                                        surfPointsFlat->points[i].y,
                                        surfPointsFlat->points[i].z);
            Eigen::Vector3d last_point_a(laserCloudSurfLast->points[closestPointInd].x,
                                            laserCloudSurfLast->points[closestPointInd].y,
                                            laserCloudSurfLast->points[closestPointInd].z);
            Eigen::Vector3d last_point_b(laserCloudSurfLast->points[minPointInd2].x,
                                            laserCloudSurfLast->points[minPointInd2].y,
                                            laserCloudSurfLast->points[minPointInd2].z);
            Eigen::Vector3d last_point_c(laserCloudSurfLast->points[minPointInd3].x,
                                            laserCloudSurfLast->points[minPointInd3].y,
                                            laserCloudSurfLast->points[minPointInd3].z);

            double s;
            if (DISTORTION)
                s = (surfPointsFlat->points[i].intensity - int(surfPointsFlat->points[i].intensity)) / SCAN_PERIOD;
            else
                s = 1.0;
            ceres::CostFunction *cost_function = LidarPlaneFactor::Create(curr_point, last_point_a, last_point_b, last_point_c, s);
            problem.AddResidualBlock(cost_function, loss_function, para_q, para_t);
            plane_correspondence++;
        }
    }
}

// 优化两次
for (size_t opti_counter = 0; opti_counter < 2; ++opti_counter)
{
    // 重置对应点数量
    corner_correspondence = 0;
    plane_correspondence = 0;

    //ceres::LossFunction *loss_function = NULL;
    ceres::LossFunction *loss_function = new ceres::HuberLoss(0.1);
    ceres::LocalParameterization *q_parameterization =
        new ceres::EigenQuaternionParameterization();
    ceres::Problem::Options problem_options;

    ceres::Problem problem(problem_options);
    problem.AddParameterBlock(para_q, 4, q_parameterization);
    problem.AddParameterBlock(para_t, 3);

    pcl::PointXYZI pointSel;
    std::vector<int> pointSearchInd;
    std::vector<float> pointSearchSqDis;

    TicToc t_data;
    // 寻找角点特征的对应关系
    for (int i = 0; i < cornerPointsSharpNum; ++i)
    {
        TransformToStart(&(cornerPointsSharp->points[i]), &pointSel);
        kdtreeCornerLast->nearestKSearch(pointSel, 1, pointSearchInd, pointSearchSqDis);

        int closestPointInd = -1, minPointInd2 = -1;
        if (pointSearchSqDis[0] < DISTANCE_SQ_THRESHOLD)
        {
            closestPointInd = pointSearchInd[0];
            int closestPointScanID = int(laserCloudCornerLast->points[closestPointInd].intensity);

            double minPointSqDis2 = DISTANCE_SQ_THRESHOLD;
            // 搜索在扫描线增加的方向
            for (int j = closestPointInd + 1; j < (int)laserCloudCornerLast->points.size(); ++j)
            {
                // 如果在同一扫描线，继续
                if (int(laserCloudCornerLast->points[j].intensity) <= closestPointScanID)
                    continue;

                // 如果不在附近扫描，结束循环
                if (int(laserCloudCornerLast->points[j].intensity) > (closestPointScanID + NEARBY_SCAN))
                    break;

                double pointSqDis = (laserCloudCornerLast->points[j].x - pointSel.x) *
                                        (laserCloudCornerLast->points[j].x - pointSel.x) +
                                    (laserCloudCornerLast->points[j].y - pointSel.y) *
                                        (laserCloudCornerLast->points[j].y - pointSel.y) +
                                    (laserCloudCornerLast->points[j].z - pointSel.z) *
                                        (laserCloudCornerLast->points[j].z - pointSel.z);

                if (pointSqDis < minPointSqDis2)
                {
                    // 找到更近的点
                    minPointSqDis2 = pointSqDis;
                    minPointInd2 = j;
                }
            }

            // 搜索在扫描线减少的方向
            for (int j = closestPointInd - 1; j >= 0; --j)
            {
                // 如果在同一扫描线，继续
                if (int(laserCloudCornerLast->points[j].intensity) >= closestPointScanID)
                    continue;

                // 如果不在附近扫描，结束循环
                if (int(laserCloudCornerLast->points[j].intensity) < (closestPointScanID - NEARBY_SCAN))
                    break;

                double pointSqDis = (laserCloudCornerLast->points[j].x - pointSel.x) *
                                        (laserCloudCornerLast->points[j].x - pointSel.x) +
                                    (laserCloudCornerLast->points[j].y - pointSel.y) *
                                        (laserCloudCornerLast->points[j].y - pointSel.y) +
                                    (laserCloudCornerLast->points[j].z - pointSel.z) *
                                        (laserCloudCornerLast->points[j].z - pointSel.z);

                if (pointSqDis < minPointSqDis2)
                {
                    // 找到更近的点
                    minPointSqDis2 = pointSqDis;
                    minPointInd2 = j;
                }
            }
        }

        // 找到角点特征的对应关系
        if (minPointInd2 >= 0) // 两个最近点都有效
        {
            Eigen::Vector3d curr_point(cornerPointsSharp->points[i].x,
                                       cornerPointsSharp->points[i].y,
                                       cornerPointsSharp->points[i].z);
            Eigen::Vector3d last_point_a(laserCloudCornerLast->points[closestPointInd].x,
                                           laserCloudCornerLast->points[closestPointInd].y,
                                           laserCloudCornerLast->points[closestPointInd].z);
            Eigen::Vector3d last_point_b(laserCloudCornerLast->points[minPointInd2].x,
                                           laserCloudCornerLast->points[minPointInd2].y,
                                           laserCloudCornerLast->points[minPointInd2].z);

            double s;
            if (DISTORTION)
                s = (cornerPointsSharp->points[i].intensity - int(cornerPointsSharp->points[i].intensity)) / SCAN_PERIOD;
            else
                s = 1.0;
            ceres::CostFunction *cost_function = LidarEdgeFactor::Create(curr_point, last_point_a, last_point_b, s);
            problem.AddResidualBlock(cost_function, loss_function, para_q, para_t);
            corner_correspondence++;
        }
    }

    // 寻找平面特征的对应关系
    for (int i = 0; i < surfPointsFlatNum; ++i)
    {
        TransformToStart(&(surfPointsFlat->points[i]), &pointSel);
        kdtreeSurfLast->nearestKSearch(pointSel, 1, pointSearchInd, pointSearchSqDis);

        int closestPointInd = -1, minPointInd2 = -1, minPointInd3 = -1;
        if (pointSearchSqDis[0] < DISTANCE_SQ_THRESHOLD)
        {
            closestPointInd = pointSearchInd[0];

            // 获取最近点的扫描 ID
            int closestPointScanID = int(laserCloudSurfLast->points[closestPointInd].intensity);
            double minPointSqDis2 = DISTANCE_SQ_THRESHOLD, minPointSqDis3 = DISTANCE_SQ_THRESHOLD;

            // 搜索在扫描线增加的方向
            for (int j = closestPointInd + 1; j < (int)laserCloudSurfLast->points.size(); ++j)
            {
                // 如果不在附近扫描，结束循环
                if (int(laserCloudSurfLast->points[j].intensity) > (closestPointScanID + NEARBY_SCAN))
                    break;

                double pointSqDis = (laserCloudSurfLast->points[j].x - pointSel.x) *
                                        (laserCloudSurfLast->points[j].x - pointSel.x) +
                                    (laserCloudSurfLast->points[j].y - pointSel.y) *
                                        (laserCloudSurfLast->points[j].y - pointSel.y) +
                                    (laserCloudSurfLast->points[j].z - pointSel.z) *
                                        (laserCloudSurfLast->points[j].z - pointSel.z);

                // 如果在同一或更低扫描线，更新 minPointSqDis2
                if (int(laserCloudSurfLast->points[j].intensity) <= closestPointScanID && pointSqDis < minPointSqDis2)
                {
                    minPointSqDis2 = pointSqDis;
                    minPointInd2 = j;
                }
                // 如果在更高扫描线，更新 minPointSqDis3
                else if (int(laserCloudSurfLast->points[j].intensity) > closestPointScanID && pointSqDis < minPointSqDis3)
                {
                    minPointSqDis3 = pointSqDis;
                    minPointInd3 = j;
                }
            }

            // 搜索在扫描线减少的方向
            for (int j = closestPointInd - 1; j >= 0; --j)
            {
                // 如果不在附近扫描，结束循环
                if (int(laserCloudSurfLast->points[j].intensity) < (closestPointScanID - NEARBY_SCAN))
                    break;

                double pointSqDis = (laserCloudSurfLast->points[j].x - pointSel.x) *
                                        (laserCloudSurfLast->points[j].x - pointSel.x) +
                                    (laserCloudSurfLast->points[j
一0一0一0
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
cpp-4.8.5-4.el7.x86-64.rpm
12-27
cpp-4.8.5-4.el7.x86_64.rpm
C++小游戏源码之-为民除害.cpp
最新发布
11-09
C++小游戏源码,可供学习及设计参考。
A-LOAM理论解读
weixin_48837949的博客
09-27 780
A-LOAM理论解读
五.激光SLAM框架学习之A-LOAM框架---项目工程代码介绍---3.laserOdometry.cpp--前端雷达里程计和位姿粗估计
weixin_36773706的博客
10-19 1301
laserOdometry这个节点订阅了5个话题：有序点云、极大边线点、次极大边线点、极小平面点、次极小平面点。发布了4个话题：有序点云、上一帧的平面点、上一帧的边线点、当前帧位姿粗估计。主要功能是前端的激光里程计和位姿粗估计。 我们先看主函数： int main(int argc, char **argv) { ros::init(argc, argv, "laserOdometry"); ros::NodeHandle nh; nh.param<int>("m
LOAM笔记及A-LOAM源码阅读
dxmcu的专栏
11-29 1672
导读 下面是我对LOAM论文的理解以及对A-LOAM的源码阅读（中文注释版的A-LOAM已经push到github，见A-LOAM-NOTED），最后也会手推一下LOAM源码中高斯牛顿法（论文中说的是LM法）求解ICP配准的非线性最小二乘问题，这一部分在A-LOAM代码中用Ceres优化函数库做了简化，CSDN也有篇不错的博文，知乎也有篇很赞的文章，如有问题，欢迎在评论区讨论。 码字绘图不易，转载请注明出处：https://www.cnblogs.com/wellp/p/8877990.html 一、
3D激光SLAM:ALOAM:激光雷达的运动畸变补偿代码解析
月照银海似蛟龙的博客
10-28 4215
ALOAM:激光雷达的运动畸变以及补偿方式Code将帧中间的点转到起始点坐标系下将帧中间的点转到起始点坐标系下 什么是激光雷达的运动畸变 激光雷达的一帧数据是过去一段时间而非某个时刻的数据,因此在这一帧时间内的激光雷达或者其载体通常会发生运动,因此,这一帧的原点不一致,会导致一些问题,这个问题就是运动畸变 图 所以需要去运动畸变,也叫畸变校正 如何进行运动补偿 运动补偿的目的就是把所有的点云补偿到某一时刻,这样就可以把本身在过去100ms内收集的点云统一到一个时间点上去 这个时间点可以是起始时刻,也可以是
3D激光SLAM:ALOAM---后端laserMapping代码结构与数据处理分析
月照银海似蛟龙的博客
07-19 1269
ALOAM方法实现了低的漂移,并且计算的复杂度低,实时性很好.并且不需要高精度的lidar和惯导这个方法的核心思想就是把SLAM问题进行了拆分,通过两个算法来进行.一个是执行高频率的前端里程计但是低精度的运动估计（定位）,另一个算法在比定位低一个数量级的频率执行后端建图（建图和校正里程计）.这个两个算法都需要提特征点,就是经典的角点和面点,然后进行配准.在前端的那个算法中也就是里程计算法,特征点的提取会用到快速计算的方法.在建图的后端算法中,相互关联的特征点是通过特征值和特征向量来获得的....
A-LOAM学习笔记（三）
qq_39003748的博客
03-07 475
// This is an advanced implementation of the algorithm described in the following paper: // J. Zhang and S. Singh. LOAM: Lidar Odometry and Mapping in Real-time. // Robotics: Science and Systems Conference (RSS). Berkeley, CA, July 2014. // Modifi.
Eigen库四元数表示顺序
kenhuyang的博客
12-12 2694
Eigen::Quaterniond Q(1,2,3,4)  表示顺序为：w=1, x=2, y=3, z=4。 同理其余常用四元数数组顺序为q[w,x,y,z] euler = R.eulerAngles（2,1,0）其中2,1,0表示旋转顺序为zyx，euler[0], euler[1], euler[2]分别表示绕zyx三轴的旋转角度。...
C++小游戏源码之-神域.cpp
11-09
C++小游戏源码,可供学习及设计参考。
C++小游戏源码之-秘境.cpp
11-09
C++小游戏源码,可供学习及设计参考。
C++小游戏源码之-弹球.cpp
11-09
C++小游戏源码,可供学习及设计参考。
Eigen学习笔记(16)-空间变换
ClaireQi的博客
12-19 6239
原文：Eigen官网-Space transformations
Eigen中欧拉角，旋转向量，旋转矩阵，四元数的转换
沧海一帆的专栏
07-26 1万+
三维空间的旋转可以用欧拉角，旋转向量，旋转矩阵，四元数来表示。 首先是欧拉角表示法，我们可以用绕某个轴旋转来表示。 旋转向量就是用一个旋转轴和一个旋转角来表示旋转。 旋转矩阵用一个矩阵来表示空间中的旋转变换关系。 四元数用４个变量来表示旋转（增加一个纬度），可以避免万向节锁现象。具体转换公式可参考《视觉slam十四讲》这本书。下面的程序为使用Eigen库进行转换。 （1）旋转向量->旋转矩
激光雷达去畸变
xjblalala的博客
09-13 595
激光雷达去畸变作业
Eigen 中的 Quaternion
热门推荐
luanqibaazao的博客
11-03 2万+
参考网址： http://eigen.tuxfamily.org/dox-devel/classEigen_1_1Quaternion.htmlhttp://www.cc.gatech.edu/classes/AY2015/cs4496_spring/Eigen.htmlEigen中quaternion的构造函数为 Quaternion (const Scalar &w, const Scala
Eigen四元数 初始化的坑！！！一天的教训！
delovsam的博客
02-21 1万+
四元数初始化有多种形式，容易出错的是：由于Eigen中四元数存储顺序（从打印可知）是xyzw，导致赋值出现的错误： 方式一：4个标量 Quaterniond q1(1, 2, 3, 4); // 第一种方式 实部为1 ，虚部234 方式二：Vector4d Quaterniond q2(Vector4d(1, 2, 3, 4))...
旋转矩阵、欧拉角、四元数及四元数插值
weixin_41469272的博客
08-20 8186
在三维世界中的旋转的表示的方法主要有： 旋转只是3个自由度未知量。 3*3旋转矩阵 3维坐标系经过旋转，得到新的坐标系，新坐标系三轴在旧坐标系下的表示构成的3*3矩阵，就是能够表述旋转的旋转矩阵。 但是3*3矩阵用来表述3个自由度的旋转时，变量产生冗余，因此旋转矩阵及其还要满足一系列其他的性质。且表示也不够直观 角轴 任何旋转都可以看成，围绕空间某个轴旋转一定的角度产生的，角轴对应旋转轴的方向，其模长可以用来关联旋转的角度。 欧拉角 欧拉角它使用了三个分离的转角，把一个旋转分解成三次绕不同轴的旋转。比较清
(messenger-libusb.cpp:42) control_transfer returned error, index: 768, error
09-13
(messenger-libusb.cpp:42) control_transfer返回了错误，索引: 768，错误。 这个错误是指在messenger-libusb.cpp文件中的第42行，执行了一个名为control_transfer的函数，但该函数返回了错误。错误信息显示索引为768，但具体的错误原因并没有提供。 要解决这个问题，我们可以进行以下几步： 1. 检查索引是否超出了范围。索引通常用于引用某种数据或操作对象，如果超过了其有效范围，就会导致错误。检查代码中对该索引的使用，并确保其在合理的范围内。 2. 检查传递给control_transfer函数的参数是否正确。函数可能需要特定的参数或特定的格式。查看函数的文档或源代码，确保传递给它的参数是正确的。 3. 检查是否需要更新或更改相关的库文件。错误可能是由于库文件中的bug或不兼容性引起的。查看最新版本的库文件，并尝试更新或更改它们来修复错误。 4. 使用调试工具进行调试。通过使用调试器或日志记录器等工具，可以跟踪代码的执行过程，以便更容易发现错误所在。可以逐步执行代码并观察变量的值，以找出导致错误的原因。 5. 寻求帮助。如果以上方法都没有解决问题，可以向开发人员或相关论坛或社区寻求帮助。提供具体的错误信息和相关的代码片段，以便他们更好地理解问题并提供解决方案。 总之，错误(messenger-libusb.cpp:42) control_transfer返回了错误，索引: 768，错误表明在执行control_transfer函数时出现了问题。我们需要检查索引范围、参数正确性、库文件更新、调试等方面，以找出并解决问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值