A-LOAM 源码阅读一 scanRegistration

最新推荐文章于 2024-04-21 21:21:51 发布
最新推荐文章于 2024-04-21 21:21:51 发布
阅读量445 收藏 2
点赞数 1
分类专栏： LOAM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bancheng6095/article/details/115392408
版权

scanRegistration 的内容是 corner 与 surface 特征点的提取。

一、main()函数

订阅：velodyne_points，激光雷达点云数据。

发布：velodyne_cloud_2，由 velodyne_points 经过处理后的有序点云；

           laser_cloud_sharp、laser_cloud_less_sharp、laser_cloud_flat、laser_cloud_less_flat，特征点云。

二、laserCloudHandler()函数

laserCloudHandler 是对 velodyne_points 点云数据的处理。

1. 去除无效点云

// 首先对点云滤波，去除 NaN 值的无效点云，以及在 Lidar 坐标系原点 MINIMUM_RANGE 距离以内的点
pcl::removeNaNFromPointCloud(laserCloudIn, laserCloudIn, indices);
removeClosedPointCloud(laserCloudIn, laserCloudIn, MINIMUM_RANGE);

2. 根据仰角确定 scanID

根据多线激光雷达 scan 的角度分布情况，结合仰角，即可确定所有点是由哪个 scan 扫描得到的。

float angle = atan(point.z / sqrt(point.x * point.x + point.y * point.y)) * 180 / M_PI;
int scanID = 0;
// 确定每一个点对应的 scanID，即确定该点是由哪个扫描线扫描得到的
if (N_SCANS == 16)
{
    scanID = int((angle + 15) / 2 + 0.5);
    if (scanID > (N_SCANS - 1) || scanID < 0)
    {
        count--;
        continue;
    }
}
else if (N_SCANS == 32)
{
    scanID = int((angle + 92.0/3.0) * 3.0 / 4.0);
    if (scanID > (N_SCANS - 1) || scanID < 0)
    {
        count--;
        continue;
    }
}
else if (N_SCANS == 64)
{   
    if (angle >= -8.83)
        scanID = int((2 - angle) * 3.0 + 0.5);
    else
        scanID = N_SCANS / 2 + int((-8.83 - angle) * 2.0 + 0.5);

    // use [0 50]  > 50 remove outlies 
    if (angle > 2 || angle < -24.33 || scanID > 50 || scanID < 0)
    {
        count--;
        continue;
    }
}
else
{
    printf("wrong scan number\n");
    ROS_BREAK();
}

3. 根据水平方位角确定 fireID

计算各个点相对于起始点的时间差，便于后续消除点云数据的运动畸变。

1) 计算起始点与终止点的方位角

// 点云的方位角，起始角度和终止角度
// 扫描起始的方位角，atan2范围 [-pi,pi]，计算方位角时取负号是因为 velodyne 顺时针旋转
float startOri = -atan2(laserCloudIn.points[0].y, laserCloudIn.points[0].x);
// 扫描结束点的方位角，加 2*pi 使点云旋转周期为 2*pi
float endOri = -atan2(laserCloudIn.points[cloudSize - 1].y, laserCloudIn.points[cloudSize - 1].x) + 2 * M_PI;

// 终止方位角与起始方位角之间的角度差在 (pi, 3*pi), 允许雷达不是一个圆周扫描
if (endOri - startOri > 3 * M_PI)
    endOri -= 2 * M_PI;
else if (endOri - startOri < M_PI)
    endOri += 2 * M_PI;

2) 计算各个点相对于起始点的时间差

// 确定每一个点的水平方位角
float ori = -atan2(point.y, point.x);
if (!halfPassed)
{ 
    if (ori < startOri - M_PI / 2)
        ori += 2 * M_PI;
    else if (ori > startOri + M_PI * 3 / 2)
        ori -= 2 * M_PI;

    if (ori - startOri > M_PI)
        halfPassed = true;
}
else
{
    ori += 2 * M_PI;
    if (ori < endOri - M_PI * 3 / 2)
        ori += 2 * M_PI;
    else if (ori > endOri + M_PI / 2)
        ori -= 2 * M_PI;
}

// 点云中点的相对时间：点旋转的角度与整个周期旋转角度的比率
float relTime = (ori - startOri) / (endOri - startOri);
// 点强度 = scanID + 点相对时间
point.intensity = scanID + scanPeriod * relTime;    // intensity 字段的整数部分存放 scanID，小数部分存放归一化后的 fireID
laserCloudScans[scanID].push_back(point);           // 将点根据 scanID 放到对应的子点云 laserCloudScans 中

intensity 用于存放 scanID 和 fireID。

4. 有序点云

// 将子点云 laserCloudScans 合并成一帧点云 laserCloud
// 这里的单帧点云 laserCloud 可以认为已经是有序点云了，按照 scanID 和 fireID 的顺序存放
pcl::PointCloud<PointType>::Ptr laserCloud(new pcl::PointCloud<PointType>());
for (int i = 0; i < N_SCANS; i++)
{   // 确定每一个 scanline 对应点云的起始和结束索引
    // 记录每个scan的开始index，忽略前5个点
    scanStartInd[i] = laserCloud->size() + 5;
    *laserCloud += laserCloudScans[i];
    // 记录每个 scan 的结束 index，忽略后5个点，开始和结束处的点云 scan 容易产生不闭合的“接缝”，对提取 edge feature 不利
    scanEndInd[i] = laserCloud->size() - 6;
}

5. 特征点提取

1) 计算点的曲率

遍历每个点（除了前五个点和后五个点）差值的平方代表曲率。

// 使用每个点的前后五个点计算曲率，因此前五个点和后五个点跳过
for (int i = 5; i < cloudSize - 5; i++)
{ 
    // 该点与周围10个点的偏差
    // diff = sum(p(i-5:i-1)) + sum(p(i+1:i+5)) - 10*p(i)
    float diffX = laserCloud->points[i - 5].x + laserCloud->points[i - 4].x + laserCloud->points[i - 3].x + laserCloud->points[i - 2].x + laserCloud->points[i - 1].x - 10 * laserCloud->points[i].x + laserCloud->points[i + 1].x + laserCloud->points[i + 2].x + laserCloud->points[i + 3].x + laserCloud->points[i + 4].x + laserCloud->points[i + 5].x;
    float diffY = laserCloud->points[i - 5].y + laserCloud->points[i - 4].y + laserCloud->points[i - 3].y + laserCloud->points[i - 2].y + laserCloud->points[i - 1].y - 10 * laserCloud->points[i].y + laserCloud->points[i + 1].y + laserCloud->points[i + 2].y + laserCloud->points[i + 3].y + laserCloud->points[i + 4].y + laserCloud->points[i + 5].y;
    float diffZ = laserCloud->points[i - 5].z + laserCloud->points[i - 4].z + laserCloud->points[i - 3].z + laserCloud->points[i - 2].z + laserCloud->points[i - 1].z - 10 * laserCloud->points[i].z + laserCloud->points[i + 1].z + laserCloud->points[i + 2].z + laserCloud->points[i + 3].z + laserCloud->points[i + 4].z + laserCloud->points[i + 5].z;

    // 确定每一个点对应的离散曲率
    cloudCurvature[i] = diffX * diffX + diffY * diffY + diffZ * diffZ;
    // 记录曲率点的索引
    cloudSortInd[i] = i;
    // 初始时，点都未被选为特征点
    cloudNeighborPicked[i] = 0;
    cloudLabel[i] = 0; // Label 2: corner_sharp
                       // Label 1: corner_less_sharp, 包含Label 2
                       // Label -1: surf_flat
                       // Label 0: surf_less_flat， 包含Label -1，因为点太多，最后会降采样
}

2) 根据曲率计算4种特征点

TicToc t_pts;

pcl::PointCloud<PointType> cornerPointsSharp;
pcl::PointCloud<PointType> cornerPointsLessSharp;
pcl::PointCloud<PointType> surfPointsFlat;
pcl::PointCloud<PointType> surfPointsLessFlat;

float t_q_sort = 0;
for (int i = 0; i < N_SCANS; i++) // 按照 scan 的顺序提取4种特征点
{
    if( scanEndInd[i] - scanStartInd[i] < 6) // 如果该 scan 的点数少于7个点，就跳过
        continue;

    pcl::PointCloud<PointType>::Ptr surfPointsLessFlatScan(new pcl::PointCloud<PointType>);
    for (int j = 0; j < 6; j++)  // 将该 scan 分成6小段(subscan)执行特征检测
    {
        // subscan 的起始 index
        int sp = scanStartInd[i] + (scanEndInd[i] - scanStartInd[i]) * j / 6;
        // subscan 的结束 index
        int ep = scanStartInd[i] + (scanEndInd[i] - scanStartInd[i]) * (j + 1) / 6 - 1; 

        TicToc t_tmp;
        // 根据曲率由小到大对 subscan 的点进行 sort
        std::sort (cloudSortInd + sp, cloudSortInd + ep + 1, comp);
        t_q_sort += t_tmp.toc();

        int largestPickedNum = 0;
        // 从后往前，即从曲率大的点开始提取 corner feature
        for (int k = ep; k >= sp; k--)
        {
            int ind = cloudSortInd[k];          // ind != k ?

            if (cloudNeighborPicked[ind] == 0 && cloudCurvature[ind] > 0.1)
            { // 如果该点没有被选择过，并且曲率大于 0.1
                largestPickedNum++;
                if (largestPickedNum <= 2)
                { // 该 subscan 中曲率最大的前2个点认为是 corner_sharp 特征点  
                    cloudLabel[ind] = 2;
                    cornerPointsSharp.push_back(laserCloud->points[ind]);
                    cornerPointsLessSharp.push_back(laserCloud->points[ind]);
                }
                else if (largestPickedNum <= 20)
                { // 该 subscan 中曲率最大的前20个点认为是 corner_less_sharp 特征点
                    cloudLabel[ind] = 1; 
                    cornerPointsLessSharp.push_back(laserCloud->points[ind]);
                }
                else
                    break;

                cloudNeighborPicked[ind] = 1;   // 标记该点被选择过了

                // 与当前点距离的平方 <= 0.05的点标记为选择过，避免特征点密集分布
                for (int l = 1; l <= 5; l++)
                {
                    float diffX = laserCloud->points[ind + l].x - laserCloud->points[ind + l - 1].x;
                    float diffY = laserCloud->points[ind + l].y - laserCloud->points[ind + l - 1].y;
                    float diffZ = laserCloud->points[ind + l].z - laserCloud->points[ind + l - 1].z;
                    if (diffX * diffX + diffY * diffY + diffZ * diffZ > 0.05)
                        break;

                    cloudNeighborPicked[ind + l] = 1;
                }
                for (int l = -1; l >= -5; l--)
                {
                    float diffX = laserCloud->points[ind + l].x - laserCloud->points[ind + l + 1].x;
                    float diffY = laserCloud->points[ind + l].y - laserCloud->points[ind + l + 1].y;
                    float diffZ = laserCloud->points[ind + l].z - laserCloud->points[ind + l + 1].z;
                    if (diffX * diffX + diffY * diffY + diffZ * diffZ > 0.05)
                        break;

                    cloudNeighborPicked[ind + l] = 1;
                }
            }
        }

        // 提取 surf 平面 feature，与上述类似，选取该 subscan 曲率最小的前4个点为 surf_flat
        int smallestPickedNum = 0;
        for (int k = sp; k <= ep; k++)
        {
            int ind = cloudSortInd[k];

            if (cloudNeighborPicked[ind] == 0 && cloudCurvature[ind] < 0.1)
            {

                cloudLabel[ind] = -1;
                surfPointsFlat.push_back(laserCloud->points[ind]);

                smallestPickedNum++;
                if (smallestPickedNum >= 4)
                    break;

                cloudNeighborPicked[ind] = 1;
                for (int l = 1; l <= 5; l++)
                { 
                    float diffX = laserCloud->points[ind + l].x - laserCloud->points[ind + l - 1].x;
                    float diffY = laserCloud->points[ind + l].y - laserCloud->points[ind + l - 1].y;
                    float diffZ = laserCloud->points[ind + l].z - laserCloud->points[ind + l - 1].z;
                    if (diffX * diffX + diffY * diffY + diffZ * diffZ > 0.05)
                        break;

                    cloudNeighborPicked[ind + l] = 1;
                }
                for (int l = -1; l >= -5; l--)
                {
                    float diffX = laserCloud->points[ind + l].x - laserCloud->points[ind + l + 1].x;
                    float diffY = laserCloud->points[ind + l].y - laserCloud->points[ind + l + 1].y;
                    float diffZ = laserCloud->points[ind + l].z - laserCloud->points[ind + l + 1].z;
                    if (diffX * diffX + diffY * diffY + diffZ * diffZ > 0.05)
                        break;

                    cloudNeighborPicked[ind + l] = 1;
                }
            }
        }

        // 其他的非 corner 特征点与 surf_flat 特征点一起组成 surf_less_flat 特征点
        for (int k = sp; k <= ep; k++)
        {
            if (cloudLabel[k] <= 0)
                surfPointsLessFlatScan->push_back(laserCloud->points[k]);
        }
    }

    // 最后对该 scan 点云中提取的所有 surf_less_flat 特征点进行降采样，因为点太多了 体素滤波下采样
    pcl::PointCloud<PointType> surfPointsLessFlatScanDS;
    pcl::VoxelGrid<PointType> downSizeFilter;
    downSizeFilter.setInputCloud(surfPointsLessFlatScan);
    downSizeFilter.setLeafSize(0.2, 0.2, 0.2);
    downSizeFilter.filter(surfPointsLessFlatScanDS);

    surfPointsLessFlat += surfPointsLessFlatScanDS;
       
/* sharp corner 和 flat surface 特征作为激光里程计中 source 点云，less sharp corner 和 less flat surface 特征作为激光里程计中的 target 点云 */
/* 添加less sharp、less flat ? :
 * 基于曲率的方法并不能准确、稳定地检出 corner 和 surface 特征，尤其是 corner 特征,
 * 将数量更多的 less sharp corner 和 less flat surface 特征作为激光里程计中的 target 点云，有利于提高有效关联的数量，以提高激光里程计的精度
 */
}

3) publish特征点云

sensor_msgs::PointCloud2 laserCloudOutMsg;
pcl::toROSMsg(*laserCloud, laserCloudOutMsg);
laserCloudOutMsg.header.stamp = laserCloudMsg->header.stamp;
laserCloudOutMsg.header.frame_id = "/camera_init";
pubLaserCloud.publish(laserCloudOutMsg);

sensor_msgs::PointCloud2 cornerPointsSharpMsg;
pcl::toROSMsg(cornerPointsSharp, cornerPointsSharpMsg);
cornerPointsSharpMsg.header.stamp = laserCloudMsg->header.stamp;
cornerPointsSharpMsg.header.frame_id = "/camera_init";
pubCornerPointsSharp.publish(cornerPointsSharpMsg);

sensor_msgs::PointCloud2 cornerPointsLessSharpMsg;
pcl::toROSMsg(cornerPointsLessSharp, cornerPointsLessSharpMsg);
cornerPointsLessSharpMsg.header.stamp = laserCloudMsg->header.stamp;
cornerPointsLessSharpMsg.header.frame_id = "/camera_init";
pubCornerPointsLessSharp.publish(cornerPointsLessSharpMsg);

sensor_msgs::PointCloud2 surfPointsFlat2;
pcl::toROSMsg(surfPointsFlat, surfPointsFlat2);
surfPointsFlat2.header.stamp = laserCloudMsg->header.stamp;
surfPointsFlat2.header.frame_id = "/camera_init";
pubSurfPointsFlat.publish(surfPointsFlat2);

sensor_msgs::PointCloud2 surfPointsLessFlat2;
pcl::toROSMsg(surfPointsLessFlat, surfPointsLessFlat2);
surfPointsLessFlat2.header.stamp = laserCloudMsg->header.stamp;
surfPointsLessFlat2.header.frame_id = "/camera_init";
pubSurfPointsLessFlat.publish(surfPointsLessFlat2);

// pub each scam
if(PUB_EACH_LINE)
{
    for(int i = 0; i< N_SCANS; i++)
    {
        sensor_msgs::PointCloud2 scanMsg;
        pcl::toROSMsg(laserCloudScans[i], scanMsg);
        scanMsg.header.stamp = laserCloudMsg->header.stamp;
        scanMsg.header.frame_id = "/camera_init";
        pubEachScan[i].publish(scanMsg);
    }
}

 

开花的松树
关注
专栏目录
A-loam代码详解(2) — a-loam源码图文详解
几度春风里的博客
03-31 2760
a-loam源码图文详解
手撕LOAM源代码(一)--scanRegistration.cpp
3D视觉工坊
10-19 137
作者：K.Fire | 来源：3D视觉工坊添加微信：dddvisiona，备注：SLAM，拉你入群。文末附行业细分群。写在前面本系列文章将对LOAM源代码进行讲解，在讲解过程中，涉及到论文中提到的部分，会结合论文以及我自己的理解进行解读，尤其是对于其中坐标变换的部分，将会进行详细的讲解。本来是懒得写的，一个是怕自己以后忘了，另外是我在学习过程中，其实没有感觉哪一个博主能讲解的通篇都能让我很明白，...
A-LOAM之scanRegistration.cpp
weixin_58045467的博客
07-31 773
aloam将主要分为高频率 低精度的激光里程计估计算法，和 低频率高精度的 借助激光里程计作为初始估计的 将当前帧到地图的优化算法。本质就是构建点到线，点到面的残差来估计机器人的位姿状态。......
自动驾驶系列（3）ALOAM源码解析-scanRegistration.cpp
最新发布
earo0的博客
04-21 799
接收两个pcl::PointCloud类型的参数：cloud_in（输入点云）和cloud_out（输出点云）。原理:是遍历输入点云中的每个点，检查其三维空间坐标（x、y和z）是否满足条件。如果满足条件，将该点复制到输出点云中，否则跳过该点。最后，调整输出点云的大小以匹配有效点的数量。订阅LiDAR点云数据，并对其进行处理，最后将处理后的点云数据发布出去。功能：初始化ROS节点，订阅激光点云数据，发布处理后的点云数据。1.定义了一些变量和结构体，如点云类型、点云尺寸等。7.将处理后的点云数据发布出去。
aloam源码学习——scanRegisteration
sinat_38685124的博客
01-08 473
最近有项目要用激光建图与定位(SLAM)，花了一周把aloam源码读了一遍；后来开了几次项目会议，才发现用不到激光slam，于是对激光slam的研究暂时搁浅。 参考了其他aloam源码的理解的文章，这里是我理解的部分。 主要的逻辑： 订阅激光点云数据; 剔除无效点与离传感器过近的点； 确定点云的起始方位角和结束方位角，令结束方位角与开始方位角差值控制在(PI,3*PI)范围 计算每个点的仰角，根据仰角为每个点找到了对应的扫描线; 每条扫瞄线分成6段扇区，每个扇区选出2个曲率极大点和20个曲率次极大点，同时
A-LOAM代码理解scanRegistration(一)
qq_20184333的博客
11-03 338
A-LOAM代码理解
A-LOAM代码注释学习（三）scanRegistration.cpp
abanchao的博客
10-13 1008
根据代码，对A-LOAM算法框架进一步理解，进行数学推导理解和代码里函数的使用。scanRegistration.cpp对应scanRegistration节点，包括主函数，近点剔除函数和特征点提取回调函数。对各部件进行了详细的代码注释，并对部分难点进行梳理和理解。
A-LOAM阅读笔记（5）：src文件：scanRegistration.cpp
m0_50046535的博客
04-12 1287
这个文件主要分为3个函数， 一个点云滤除函数，主要是对距离过近的点进行滤除 第二个是特征提取函数，分别提取了极大边线点，次极大边线点，极小平面点，次极小平面点四个特征 第三个就是main函数了。 参考一些前人的工作，自己做了总结，进行学习。 #include <cmath> #include <vector> #include <string> #include "aloam_velodyne/common.h" #include "aloam_velody.
LOAM源码解析——scanRegistration
try_again_later的博客
04-12 1536
入手激光雷达SLAM，从最经典的LOAM源码开始，之后会对秦通在此基础上改进的A-LOAM源码进行观看，应该就会很简单了，第三步是把LEGO-LOAM的源码进行解读。之前对LOAM的论文进行了详细解读。 LOAM的源码主要分为scanRegistration提取特征点、laserOdometry 10HZ估计位姿、laserMapping 1HZ构建三维地图、transforMaintenance...
Loam流程分析以及源码解析
Limiao_123的博客
04-20 1381
前一阵看网课讲解Loam的视频，觉得十分简单而且直观。然而纸上得来终觉浅，最近结合网上前人的解析加以自己的理解，希望能得到新的深一些的理解。写下做一下记录，方便将来回忆复习。 贴上参考的资料： github上用中文注释的一个代码，十分清晰，配合着其他讲解，理解Loam的源码很有帮助：源码加中文注释 知乎密斯特李的专栏文章，将Loam源码的四个node分开解析，清晰明了：知乎文章1 知乎晓伟Liu的解析，在看mapping部分的时候给我帮助较大知乎文章2 csdn博主Nksjc的文章csdn文章 感谢前人
A-loam学习笔记——scanRegistration过程代码详解
weixin_51326570的博客
04-15 594
scanRegistration过程代码详解 #include <cmath> #include <vector> #include <string> #include "aloam_velodyne/common.h" #include "aloam_velodyne/tic_toc.h" #include <nav_msgs/Odometry.h> #include <opencv2/imgproc.hpp> #include "opencv
LOAM笔记及A-LOAM源码阅读
dxmcu的专栏
11-29 1697
导读 下面是我对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 一、
A-LOAM代码详解（注释）
jjjqqq123321的博客
10-23 936
逐句注释加解析，超详细
A-LOAM源码解析——scanRegistration.cpp
weixin_48404151的博客
08-01 623
A-LOAM主要包括四个主要的源程序，刚看完scanRegistration，顺便分享总结一下，剩余三个以后看完会及时更新，本文件主要是通过曲率来对角点以及平面点进行提取。 1.首先是对后面用到的一些变量进行定义，主要包括，激光雷达扫描周期，初始化标志，雷达线数，以及6类点等等。 //定义激光雷达的扫描周期，频率为10Hz，周期为0.1s const double scanPeriod = 0.1; const int systemDelay = 0; //计数过了多少帧 int systemInit
loam论文与Aloam代码学习归纳（三）--scanRegistration节点
qq_41586768的博客
08-20 1379
一.作用 数据预处理，特征点提取 ，用以接下来的Odometry和mapping的点云配准。所以这个节点本身就是一个计算的过程：根据曲率C划分不同类型的特征点（边缘点或是平面点或是非特征点）。 根据VLP16的激光扫描模型, 对单帧点云（paper中称为一个Sweep）进行分线束（分为16束）, 每束称为一个Scan， 并记录每个点所属线束和每个点在此帧电云内的相对扫描时间（相对于本帧第一个点）。针对单个Scan提取特征点, 而相对时间会在laserOdometry中用于运动补偿.所有Scan的特征点,拼到
大白话解析LeGO-LOAM(2)--featureAssociation.cpp
weixin_42068054的博客
02-18 1453
主要是对分割后点云进行特征提取以及特征匹配。
A-LOAM代码解读
dloading7的博客
11-09 2533
A-LOAM源码解读
aloam学习笔记(二)
weixin_45572737的博客
01-04 593
对于scanRegistration.cpp源码的学习
3D 激光SLAM ->loam_velodyne论文与代码解析Lidar Odometry and Mapping
热门推荐
Nksjc的博客
07-30 4万+
3D 激光SLAM ->loam_velodyne论文与代码解析Lidar Odometry and Mapping
ubuntu18.04安装a-loam
01-26
a-loam是一款基于Lidar数据的SLAM（Simultaneous Localization and Mapping，同时定位与地图构建）算法软件包。要在Ubuntu 18.04上安装a-loam，您可以按照以下步骤进行操作： 1. 安装ROS：a-loam依赖ROS（Robot ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值