测试

最新推荐文章于 2023-07-21 18:52:51 发布
最新推荐文章于 2023-07-21 18:52:51 发布
阅读量232 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43795395/article/details/90676754
版权

 

 

在localMapping 中，我们需要利用局部地图进行BA（）

void Optimizer::LocalBundleAdjustmentWithLine(KeyFrame *pKF, bool *pbStopFlag, Map *pMap)
    {
        double invSigma = 0.01;
        // Local KeyFrames: First Breath Search from Current KeyFrame
        list<KeyFrame*> lLocalKeyFrames;

        // step1: 将当前关键帧加入到lLocalKeyFrames
        lLocalKeyFrames.push_back(pKF);
        pKF->mnBALocalForKF = pKF->mnId;

        // step2:找到关键帧连接的关键帧（一级相连），加入到lLocalKeyFrames中

        const vector<KeyFrame*> vNeighKFs = pKF->GetVectorCovisibleKeyFrames();
        cout<<"Optimizer: 关键帧相连的帧:"<<vNeighKFs.size()<<endl;
        for(int i=0, iend=vNeighKFs.size(); i<iend; i++)
        {
            KeyFrame* pKFi = vNeighKFs[i];
            pKFi->mnBALocalForKF = pKF->mnId;
            if(!pKFi->isBad())
                lLocalKeyFrames.push_back(pKFi);
        }

        // step3：将lLocalKeyFrames的MapPoints加入到lLocalMapPoints
        list<MapPoint*> lLocalMapPoints;
        for(list<KeyFrame*>::iterator lit=lLocalKeyFrames.begin(), lend=lLocalKeyFrames.end(); lit!=lend; lit++)
        {
            vector<MapPoint*> vpMPs = (*lit)->GetMapPointMatches();
            cout<<"Optimizer: get mappointMatches():"<<vpMPs.size()<<endl;
            for(vector<MapPoint*>::iterator vit=vpMPs.begin(), vend=vpMPs.end(); vit!=vend; vit++)
            {
                MapPoint* pMP = *vit;
                if(pMP)
                {
                    if(!pMP->isBad())
                    {
                        if(pMP->mnBALocalForKF!=pKF->mnId)
                        {
                            lLocalMapPoints.push_back(pMP);
                            pMP->mnBALocalForKF=pKF->mnId;
                        }
                    }
                }
            }
        }
        cout<<"Optimizer: finish adding points"<<endl;
        // step4: 遍历lLocalKeyFrames，将每个关键帧所能观测到的MapLine提取出来，放到lLocalMapLines
        list<MapLine*> lLocalMapLines;
        vector<long unsigned int> mlID;
        for(list<KeyFrame*>::iterator lit=lLocalKeyFrames.begin(), lend=lLocalKeyFrames.end(); lit!=lend; lit++)
        {
            vector<MapLine*> vpMLs = (*lit)->GetMapLineMatches();
            cout<<"Optimizer: get mapLineMatches():"<<vpMLs.size()<<endl;
            for(vector<MapLine*>::iterator vit=vpMLs.begin(), vend=vpMLs.end(); vit!=vend; vit++)
            {

                MapLine* pML = *vit;
                if(pML)
                {
                    cout<<"Optimizer: mapline exist"<<endl;
                    if(!pML->isBad())
                    {
                        cout<<"Optimizer: mapline is not bad"<<endl;
                        if(pML->mnBALocalForKF!=pKF->mnId)
                        {
                            lLocalMapLines.push_back(pML);
                            pML->mnBALocalForKF = pKF->mnId;
                            mlID.push_back(pML->mnId);
                            cout<<"Optimizer:maplinesmatches id: "<<pKF->mnId<<endl;
                        }
                    }
                }
            }
        }

        cout<<"Optimizer: finish adding lines: size:"<< lLocalMapLines.size()<<endl;
#if 0
        for(list<MapLine*>::iterator lit=lLocalMapLines.begin(), lend=lLocalMapLines.end(); lit!=lend; lit++)
    {
        int i=0;
        if(count(mlID.begin(), mlID.end(), mlID[i])>1)
        {
            cout << "exist ===============" << endl;
            lit = lLocalMapLines.erase(lit);
        }
        i++;
    }
#endif

        // step5: 得到能被局部MapPoints观测到，但不属于局部关键帧的关键帧，这些关键帧在局部BA优化时固定
        list<KeyFrame*> lFixedCameras;
        for(list<MapPoint*>::iterator lit=lLocalMapPoints.begin(), lend=lLocalMapPoints.end(); lit!=lend; lit++)
        {
            map<KeyFrame*, size_t > observations = (*lit)->GetObservations();
            for(map<KeyFrame*, size_t>::iterator mit=observations.begin(), mend=observations.end(); mit!=mend; mit++)
            {
                KeyFrame* pKFi = mit->first;

                if(pKFi->mnBALocalForKF!=pKF->mnId && pKFi->mnBAFixedForKF!=pKF->mnId)
                {
                    pKFi->mnBAFixedForKF=pKF->mnId;
                    if(!pKFi->isBad())
                        lFixedCameras.push_back(pKFi);
                }
            }
        }

        // step6：构造g2o优化器
        g2o::SparseOptimizer optimizer;
        g2o::BlockSolver_6_3::LinearSolverType* linearSolver;

        linearSolver = new g2o::LinearSolverEigen<g2o::BlockSolver_6_3::PoseMatrixType>();

        g2o::BlockSolver_6_3* solver_ptr = new g2o::BlockSolver_6_3(linearSolver);

        g2o::OptimizationAlgorithmLevenberg* solver = new g2o::OptimizationAlgorithmLevenberg(solver_ptr);
        optimizer.setAlgorithm(solver);

        if(pbStopFlag)
            optimizer.setForceStopFlag(pbStopFlag);

        unsigned long maxKFid = 0;

        cout<<"Optimizer: adding pose od local Keyframe"<<endl;
        // step7：添加顶点，Pose of Local KeyFrame
        for(list<KeyFrame*>::iterator lit=lLocalKeyFrames.begin(), lend=lLocalKeyFrames.end(); lit!=lend; lit++)
        {
            KeyFrame* pKFi = *lit;
            g2o::VertexSE3Expmap* vSE3 = new g2o::VertexSE3Expmap();
            vSE3->setEstimate(Converter::toSE3Quat(pKFi->GetPose()));
            vSE3->setId(pKFi->mnId);
//        cout << "KeyFrame Id = " << pKFi->mnId << endl;
            vSE3->setFixed(pKFi->mnId==0);  //第一个关键帧需要Fix
            optimizer.addVertex(vSE3);
            if(pKFi->mnId>maxKFid)
                maxKFid=pKFi->mnId;
        }
        cout<<"Optimizer:  adding fixed keyframe"<<endl;
        // step8:添加固定帧的顶点，Pose of Fixed KeyFrame
        for(list<KeyFrame*>::iterator lit=lFixedCameras.begin(), lend=lFixedCameras.end(); lit!=lend; lit++)
        {
            KeyFrame* pKFi = *lit;
            g2o::VertexSE3Expmap* vSE3 = new g2o::VertexSE3Expmap();
            vSE3->setEstimate(Converter::toSE3Quat(pKFi->GetPose()));
            vSE3->setId(pKFi->mnId);
//        cout << "Fixed KeyFrame Id = " << pKFi->mnId << endl;
            vSE3->setFixed(true);
            optimizer.addVertex(vSE3);
            if(pKFi->mnId > maxKFid)
                maxKFid = pKFi->mnId;
        }

        vector<int> MapPointID;
        //***********************Set MapPoint Vertices******************************
        // step9：添加MapPoint的3D顶点
        const int nExpectedSize = (lLocalKeyFrames.size()+lFixedCameras.size())*lLocalMapPoints.size();

        vector<g2o::EdgeSE3ProjectXYZ*> vpEdgesMono;
        vpEdgesMono.reserve(nExpectedSize);

        vector<KeyFrame*> vpEdgeKFMono;
        vpEdgeKFMono.reserve(nExpectedSize);

        vector<MapPoint*> vpMapPointEdgeMono;
        vpMapPointEdgeMono.reserve(nExpectedSize);

        vector<g2o::EdgeStereoSE3ProjectXYZ*> vpEdgesStereo;
        vpEdgesStereo.reserve(nExpectedSize);

        vector<KeyFrame*> vpEdgeKFStereo;
        vpEdgeKFStereo.reserve(nExpectedSize);

        vector<MapPoint*> vpMapPointEdgeStereo;
        vpMapPointEdgeStereo.reserve(nExpectedSize);

        const float thHuberMono = sqrt(5.991);
        const float thHuberStereo = sqrt(7.815);

        for(list<MapPoint*>::iterator lit=lLocalMapPoints.begin(), lend=lLocalMapPoints.end(); lit!=lend; lit++)
        {
            MapPoint* pMP = *lit;
            g2o::VertexSBAPointXYZ* vPoint = new g2o::VertexSBAPointXYZ();
            vPoint->setEstimate(Converter::toVector3d(pMP->GetWorldPos()));
            int id = pMP->mnId + maxKFid + 1;
            vPoint->setId(id);
//        cout << "MapPoint Id = " << id << endl;
            vPoint->setMarginalized(true);
            optimizer.addVertex(vPoint);
            MapPointID.push_back(id);

            const map<KeyFrame*, size_t > observations = pMP->GetObservations();

            // Set Edges
            for(map<KeyFrame*, size_t>::const_iterator mit=observations.begin(), mend=observations.end(); mit!=mend; mit++)
            {
                KeyFrame* pKFi = mit->first;

                if(!pKFi->isBad())
                {
                    const cv::KeyPoint &kpUn = pKFi->mvKeysUn[mit->second];

                    if(pKFi->mvuRight[mit->second]<0)
                    {
                        Eigen::Matrix<double,2,1> obs;
                        obs << kpUn.pt.x, kpUn.pt.y;

                        g2o::EdgeSE3ProjectXYZ* e = new g2o::EdgeSE3ProjectXYZ();

                        e->setVertex(0, dynamic_cast<g2o::OptimizableGraph::Vertex*>(optimizer.vertex(id)));
                        e->setVertex(1, dynamic_cast<g2o::OptimizableGraph::Vertex*>(optimizer.vertex(pKFi->mnId)));
                        e->setMeasurement(obs);
                        const float &invSigma2 = pKFi->mvInvLevelSigma2[kpUn.octave];
                        e->setInformation(Eigen::Matrix2d::Identity()*invSigma2);

                        g2o::RobustKernelHuber* rk = new g2o::RobustKernelHuber;
                        e->setRobustKernel(rk);
                        rk->setDelta(thHuberMono);

                        e->fx = pKFi->fx;
                        e->fy = pKFi->fy;
                        e->cx = pKFi->cx;
                        e->cy = pKFi->cy;

                        optimizer.addEdge(e);
                        vpEdgesMono.push_back(e);
                        vpEdgeKFMono.push_back(pKFi);
                        vpMapPointEdgeMono.push_back(pMP);
                    }
                    else // Stereo observation
                    {
                        Eigen::Matrix<double,3,1> obs;
                        const float kp_ur = pKFi->mvuRight[mit->second];
                        obs << kpUn.pt.x, kpUn.pt.y, kp_ur;

                        g2o::EdgeStereoSE3ProjectXYZ* e = new g2o::EdgeStereoSE3ProjectXYZ();

                        e->setVertex(0, dynamic_cast<g2o::OptimizableGraph::Vertex*>(optimizer.vertex(id)));
                        e->setVertex(1, dynamic_cast<g2o::OptimizableGraph::Vertex*>(optimizer.vertex(pKFi->mnId)));
                        e->setMeasurement(obs);
                        const float &invSigma2 = pKFi->mvInvLevelSigma2[kpUn.octave];
                        Eigen::Matrix3d Info = Eigen::Matrix3d::Identity()*invSigma2;
                        e->setInformation(Info);

                        g2o::RobustKernelHuber* rk = new g2o::RobustKernelHuber;
                        e->setRobustKernel(rk);
                        rk->setDelta(thHuberStereo);

                        e->fx = pKFi->fx;
                        e->fy = pKFi->fy;
                        e->cx = pKFi->cx;
                        e->cy = pKFi->cy;
                        e->bf = pKFi->mbf;

                        optimizer.addEdge(e);
                        vpEdgesStereo.push_back(e);
                        vpEdgeKFStereo.push_back(pKFi);
                        vpMapPointEdgeStereo.push_back(pMP);
                    }

                }
            }
        }

        sort(MapPointID.begin(), MapPointID.end());
        int maxMapPointID = MapPointID[MapPointID.size()-1];
        cout << "Optimizer:************ maxMapPointID = " << maxMapPointID << " ************" << endl;

       

            // =========设置线段终止点和相机位姿之间的边=========
            for(map<KeyFrame*, size_t>::const_iterator mit=observations.begin(), mend=observations.end(); mit!=mend; mit++)
            {
                KeyFrame* pKFi = mit->first;

                if(!pKFi->isBad())
                {
                    Eigen::Vector3d line_obs;
                    line_obs = pKFi->mvKeyLineFunctions[mit->second];

                    EdgeLineProjectXYZ* e = new EdgeLineProjectXYZ();

                    e->setVertex(0, dynamic_cast<g2o::OptimizableGraph::Vertex*>(optimizer.vertex(ide)));
                    e->setVertex(1, dynamic_cast<g2o::OptimizableGraph::Vertex*>(optimizer.vertex(pKFi->mnId)));
                    e->setMeasurement(line_obs);
                    e->setInformation(Eigen::Matrix3d::Identity()*invSigma);

                    g2o::RobustKernelHuber* rk_line_e = new g2o::RobustKernelHuber;
                    e->setRobustKernel(rk_line_e);
                    rk_line_e->setDelta(thHuberMono);

                    e->fx = pKF->fx;
                    e->fy = pKF->fy;
                    e->cx = pKF->cx;
                    e->cy = pKF->cy;

                    e->Xw = pML->mWorldPos.head(3);

                    optimizer.addEdge(e);
                    vpLineEdgesEP.push_back(e);
                    vpLineEdgeKF.push_back(pKFi);
                    vpMapLineEdge.push_back(pML);
                }
            }
        }

        cout<<"Optimizer: finish 终点of lines"<<endl;

        if(pbStopFlag)
            if(*pbStopFlag)
                return;

        optimizer.initializeOptimization();
        optimizer.optimize(5);

        bool bDoMore = true;

        if(pbStopFlag)
            if(*pbStopFlag)
                bDoMore = false;

        if(bDoMore)
        {
            // Check inlier observations
            for(size_t i=0, iend=vpEdgesMono.size(); i<iend; i++)
            {
                g2o::EdgeSE3ProjectXYZ* e = vpEdgesMono[i];
                MapPoint* pMP = vpMapPointEdgeMono[i];

                if(pMP->isBad())
                    continue;

                if(e->chi2()>5.991 || !e->isDepthPositive())
                {
                    e->setLevel(1);
                }
                e->setRobustKernel(0);
            }
            cout<<"Optimizer: finish checking inlier observations"<<endl;

            for(size_t i=0, iend=vpLineEdgesSP.size(); i<iend; i++)
            {
                EdgeLineProjectXYZ* e = vpLineEdgesSP[i];
                MapLine* pML = vpMapLineEdge[i];

                if(pML->isBad())
                    continue;

                if(e->chi2()>7.815)
                {
                    e->setLevel(1);
                }
                e->setRobustKernel(0);
            }
            cout<<"Optimizer: finish start points of lines"<<endl;
            for(size_t i=0, iend=vpLineEdgesEP.size(); i<iend; i++)
            {
                EdgeLineProjectXYZ* e = vpLineEdgesEP[i];
                MapLine* pML = vpMapLineEdge[i];

                if(pML->isBad())
                    continue;

                if(e->chi2()>7.815)
                {
                    e->setLevel(1);
                }
                e->setRobustKernel(0);
            }
            cout<<"Optimizer: finish end points of lines"<<endl;
            // Optimize again without the outliers
            optimizer.initializeOptimization(0);
            cout<<"Optimizer: finish initialization optimization"<<endl;
            optimizer.optimize(10);
        }
        cout<<"Optimizer: finish bDoMore"<<endl;

        vector<pair<KeyFrame*, MapPoint*>> vToErase;
        vToErase.reserve(vpEdgesMono.size());
        cout<<"Optimizer: check inlier observations"<<endl;
        // check inlier observations
        for(size_t i=0, iend=vpEdgesMono.size(); i<iend; i++)
        {
            g2o::EdgeSE3ProjectXYZ* e = vpEdgesMono[i];
            MapPoint* pMP = vpMapPointEdgeMono[i];

            if(pMP->isBad())
                continue;

            if(e->chi2()>5.991 || !e->isDepthPositive())
            {
                KeyFrame* pKFi = vpEdgeKFMono[i];
                vToErase.push_back(make_pair(pKFi,pMP));
            }
        }

        vector<pair<KeyFrame*,MapLine*>> vLineToErase;
        vLineToErase.reserve(vpLineEdgesSP.size());
        for(size_t i=0, iend=vpLineEdgesSP.size(); i<iend; i++)
        {
            EdgeLineProjectXYZ* e = vpLineEdgesSP[i];
            MapLine* pML = vpMapLineEdge[i];

            if(pML->isBad())
                continue;

            if(e->chi2()>7.815)
            {
                KeyFrame* pKFi = vpLineEdgeKF[i];
                vLineToErase.push_back(make_pair(pKFi, pML));
            }
        }

        // Get Map Mutex
        unique_lock<mutex> lock(pMap->mMutexMapUpdate);

        if(!vToErase.empty())
        {
            for(size_t i=0; i<vToErase.size(); i++)
            {
                KeyFrame* pKFi = vToErase[i].first;
                MapPoint* pMPi = vToErase[i].second;
                pKFi->EraseMapPointMatch(pMPi);
                pMPi->EraseObservation(pKFi);
            }
        }

        if(!vLineToErase.empty())
        {
            for(size_t i=0; i<vLineToErase.size(); i++)
            {
                KeyFrame* pKFi = vLineToErase[i].first;
                MapLine* pMLi = vLineToErase[i].second;
                pKFi->EraseMapLineMatch(pMLi);
                pMLi->EraseObservation(pKFi);
            }
        }
        cout<<"Optimizer: recover optimized data"<<endl;
        // Recover optimized data
        //Keyframes
        for(list<KeyFrame*>::iterator lit=lLocalKeyFrames.begin(), lend=lLocalKeyFrames.end(); lit!=lend; lit++)
        {
            KeyFrame* pKF = *lit;
            g2o::VertexSE3Expmap* vSE3 = static_cast<g2o::VertexSE3Expmap*>(optimizer.vertex(pKF->mnId));
            g2o::SE3Quat SE3quat = vSE3->estimate();
            pKF->SetPose(Converter::toCvMat(SE3quat));
        }

        //Points
        for(list<MapPoint*>::iterator lit=lLocalMapPoints.begin(), lend=lLocalMapPoints.end(); lit!=lend; lit++)
        {
            MapPoint* pMP = *lit;
            g2o::VertexSBAPointXYZ* vPoint = static_cast<g2o::VertexSBAPointXYZ*>(optimizer.vertex(pMP->mnId+maxKFid+1));
            pMP->SetWorldPos(Converter::toCvMat(vPoint->estimate()));
            pMP->UpdateNormalAndDepth();
        }

        // Lines
        for(list<MapLine*>::iterator lit=lLocalMapLines.begin(), lend=lLocalMapLines.end(); lit!=lend; lit++)
        {
            MapLine* pML = *lit;
            g2o::VertexSBAPointXYZ* vStartP = static_cast<g2o::VertexSBAPointXYZ*>(optimizer.vertex(pML->mnId + maxKFid + maxMapPointID + 1));
            g2o::VertexSBAPointXYZ* vEndP = static_cast<g2o::VertexSBAPointXYZ *>(optimizer.vertex(pML->mnId + maxKFid + maxMapPointID + maxMapLineSPID + 1));

            Vector6d LinePos;
            LinePos << Converter::toVector3d(Converter::toCvMat(vStartP->estimate())), Converter::toVector3d(Converter::toCvMat(vEndP->estimate()));
            pML->SetWorldPos(LinePos);
            pML->UpdateAverageDir();
        }
        cout<<"Optimizer: finish local BA "<<endl;
    }
在localkeyframe中，装的是当前关键帧 相关联的关键帧（一级关键帧）。我们需要从这些关键帧中获得mvpMapPoint。使用GetMapPointMatches.

 

西部小狼_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
测试报告
04-29
完整版测试报告
ORBSLAM2总结之-LocalMapping.cpp
joun772的博客
12-16 255
/** * @file LocalMapping.cc * @author guoqing ([email protected]) * @brief 局部建图线程 * @version 0.1 * @date 2019-04-29 * * @copyright Copyright (c) 2019 * */ /** * This file is part of ORB-SLAM2. * * Copyright (C) 2014-2016 Raúl Mur-Artal <raul
g2o中的核函数
不要当真！
11-07 747
g2o优化库中的核函数
g2o使用总结
chengwei0019
10-22 2428
本文转自：https://blog.csdn.net/hzwwpgmwy/article/details/79884070 需要解决的问题： 如何自定义Vertex和Edge？ 如何选择Edge类型？一元还是二元？ 如何赋值信息矩阵？ 如何设置鲁棒核函数的阈值？ 如何选择Vertex设置为固定？ 如何边缘化以便稀疏化求解？ 如何处理优化结束后outliner？ 如何设置根据卡方分...
ORB-SLAM2 --- LoopClosing::CorrectLoop函数
qq_41694024的博客
01-12 1010
调整位姿、融合地图点、全局优化
ORB-SLAM3 LocalMapping源码分析（三）
qq_53377744的博客
11-09 326
2021SC@SDUSC
IOS安全测试工具
05-07
IOS安全测试工具、
SNMP测试工具 Getif 2.3.1
05-31
SNMP测试工具 Getif 2.3.1 用于网络管理中SNMP设置测试联通状态的工具
接口测试报告接口测试报告
07-28
接口测试报告接口测试报告接口测试报告接口测试报告
集成测试报告
04-30
该集成测试报告是关于移动办公的集成测试报告，具体的实际测试报告还是要与项目结合起来
硬件测试用例参考（一）
07-04
硬件测试用例参考（一）
软件测试过程
01-16
软件测试过程介绍，知识点整理，测试方法、测试过程、
GB28181测试工具，解压即可用。亲自测试。
02-17
GB28181测试工具，解压即可用。亲自测试。
工程测试文件
04-12
http://www.cnblogs.com/xueyudlut/p/7498115.html ，
测试测试测试app.html
09-10
测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试...
【SLAM学习笔记】8-ORB_SLAM3关键源码分析⑥ Optimizer（三）全局优化
qq_47891062的博客
11-14 893
2021SC@SDUSC
ORB-SLAM2从理论到代码实现（九）：LocalMapping程序详解
人无远虑，必有近忧
09-18 657
LocalMapping线程负责对新加入的KeyFrames和MapPoints筛选融合，剔除冗余的KeyFrames和MapPoints，维护稳定的KeyFrame集合，传给后续的LoopClosing线程。 主要的功能点在： 处理新的关键帧ProcessNewKeyFrame() 剔除不合格地图点MapPointCulling() 三角化恢复新地图点CreateNewMapPoints() 融合当前帧与相邻帧重复的地图点SearchInNeighbors() 局
图优化g2o教程简介
u010196944的博客
07-21 1319
图优化g2o教程简介，包括g2o间接、如何使用，顶点和边的定义，信息矩阵、鲁棒核函数对于优化的结果的影响。
软件测试——Linux操作系统
mercury__的博客
01-09 724
Linux
agile测试流程 测试
最新发布
02-04
敏捷测试流程是一种灵活的测试方法，旨在应对快速变化的需求和交付周期。它强调快速、频繁、可迭代的测试，并注重团队合作和持续改进。 敏捷测试流程通常包括以下步骤： 1. 制定测试计划：测试团队与相关利益相关...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值