基于OpenCv的摄像机立体标定和立体矫正的源代码

最新推荐文章于 2023-04-18 22:20:34 发布
最新推荐文章于 2023-04-18 22:20:34 发布
阅读量1.8k 收藏 2
点赞数
分类专栏： OpenCv专栏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maweifei/article/details/52825344
版权 
/********************************************************************************************************************** 
程序功能: 
        摄像机立体标定和立体校正的Demo------此程序现在还不可以运行,但思路是正确的,最近正在调试这个程序
开发环境: 
        OpenCv2.4.8 + VS2012 + Halocn10.0 + Win10
时间地点: 
        陕西师范大学 2016.10.14
作者信息: 
        九月----马卫飞 
***********************************************************************************************************************/  
/*************************************************【函数的头文件和命名空间】*******************************************/ 
#include<stdio.h>
#include<iostream>


#include<opencv2/calib3d/calib3d.hpp>
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>

#include<opencv2/core/core_c.h>
#include<opencv2/highgui/highgui_c.h>
#include<opencv2/imgproc/imgproc_c.h>

using namespace std;
using namespace cv;

/*****************************************************************************************************
******************************************************************************************************/
static void StereoCalibrate(const char* strImageList,int iNx,int iNy,int iUseUncalibrateed)
{
	int   iDisplayCorners      = 0;
	int   iShowUndistorted     = 1;
	bool  bIsVerticalStereo    = false;        //【1】OpenCv can handle left-right or up-down camera arrangements

	const int   iMaxScale      = 1;
	const float fSquareSize    = 1.f;          //【2】Set this to your actual square size
	                                           //【3】"rt"读写一个文本文件,允许读和写
	std::FILE*  pF             = std::fopen(strImageList,"rt");

	int   i                    = 0;
	int   j                    = 0;
	int   lr                   = 0;
	int   iNFreams             = 0;
	int   n                    = iNx*iNy;
	int   N                    = 0;

	std::vector<string>         vImageNames[2];
	std::vector<CvPoint3D32f>   vObjectPoints;
	std::vector<CvPoint2D32f>   vPoints[2];
	std::vector<int>            vNPoints;
	std::vector<uchar>          vActive[2];
	std::vector<CvPoint2D32f>   vTemp(n);
	CvSize    imageSize        =cvSize(0,0);
	
	double                      M1[3][3];
	double                      M2[3][3];
	double                      D1[5];
	double                      D2[5];
	double                      R[3][3];
	double                      T[3];
	double                      E[3][3];
	double                      F[3][3];

	CvMat*   _M1 = cvCreateMat(3,3,CV_64F);
	CvMat*   _M2 = cvCreateMat(3,3,CV_64F);
	CvMat*   _D1 = cvCreateMat(1,5,CV_64F);
	CvMat*   _D2 = cvCreateMat(1,5,CV_64F);
	CvMat*   _R  = cvCreateMat(3,3,CV_64F);
	CvMat*   _T  = cvCreateMat(3,1,CV_64F);
	CvMat*   _E  = cvCreateMat(3,3,CV_64F);
	CvMat*   _F  = cvCreateMat(3,3,CV_64F);

	if(iDisplayCorners)
		cvNamedWindow("【corners】",1);

	//【1】读棋盘格列表
	if(!pF)
	{
		fprintf(stderr,"can not open file %s\n",strImageList);
		return;
	}
	for(int i=0; ;i++)
	{
		char   cBuf[1024];
		int    iCount              = 0;
		int    iResult             = 0;
		lr                         = i%2;

		std::vector<CvPoint2D32f>& pts = vPoints[lr];
		if(!fgets(cBuf,sizeof(cBuf)-3,pF))
			break;
		size_t len     = strlen(cBuf);
			while(len>0&&isspace(cBuf[len-1]))
				cBuf[--len]='\0';
		if(cBuf[0]=='#')
			continue;
		IplImage* pImg = cvLoadImage(cBuf,0);
		if(!pImg)
			break;
		imageSize      = cvGetSize(pImg);

		vImageNames[lr].push_back(cBuf);

		for(int s=1;s<=iMaxScale;s++)
		{
			IplImage* pTImg = pImg;
			if(s>1)
			{
				pTImg = cvCreateImage(cvSize(pImg->width*s,pImg->height*s),pImg->depth,pImg->nChannels);
				cvResize(pImg,pTImg,CV_INTER_CUBIC);
			}
			iResult = cvFindChessboardCorners(pTImg,                   //【1】提取棋盘格上的角点(ICS::像素)
				                              cvSize(iNx,iNy),
											  &vTemp[0],
											  &iCount,
											  CV_CALIB_CB_ADAPTIVE_THRESH|CV_CALIB_CB_NORMALIZE_IMAGE
				); 
			if(pTImg!=pImg)
			{
				cvReleaseImage(&pTImg);
			}
			if(iResult||s==iMaxScale)
				for(int j=0;j<iCount;j++)
				{
					vTemp[j].x /= s;
					vTemp[j].y /= s;
				}
				if(iResult)
					break;
		}
		if(iDisplayCorners)
		{
			std::printf("%s\n",cBuf);
			IplImage* pCImg = cvCreateImage(imageSize,8,3);
			cvCvtColor(pImg,pCImg,CV_GRAY2BGR);                          //【2】将灰度图像转化为彩色图像
			cvDrawChessboardCorners(pImg,                                //【3】将从棋盘格上检测出来的角点绘制出来
				                    cvSize(iNx,iNy),
									&vTemp[0],
									iCount,
									iResult
				);
			cvShowImage("【corners】",pCImg);
			cvReleaseImage(&pCImg);
			if(cvWaitKey(0)==27)
				std::exit(-1);
		}
		else
		{
			std::putchar('.');
		}
		N = pts.size();

		CvPoint2D32f ptTemp;

		ptTemp.x = 0;
		ptTemp.y = 0;

		pts.resize(N+n,ptTemp);
		vActive[lr].push_back((uchar)iResult);
		if(iResult)
		{
			cvFindCornerSubPix(pImg,                                     //【4】精确提取的角点
				               &vTemp[0],
							   iCount,
							   cvSize(11,11),
							   cvSize(-1,-1),
							   cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,30,0.01));
		}
		copy(vTemp.begin(),vTemp.end(),pts.begin()+N);
	}
	fclose(pF);
	//【5】捕获棋盘格上3D目标对象的列表
	std::cout<<std::endl;
	iNFreams = vActive[0].size();                                        //【1】棋盘格角点的数目
	vObjectPoints.resize(iNFreams*n);                                    //【2】WCS下棋盘格角点的3D坐标(WCS::cm/mm)
	for(int i=0;i<iNy;i++)                                               //【3】计算WCS下棋盘格的3D坐标点
	{
		for(int j=0;j<iNx;j++)
		{
			vObjectPoints[i*iNx+j].x = i*fSquareSize;
			vObjectPoints[i*iNx+j].y = j*fSquareSize;
			vObjectPoints[i*iNx+j].z = 0; 

		}
	}
	vNPoints.resize(iNFreams,n);
	N = iNFreams*n;

	CvMat* _pObjectPoints = cvCreateMat(1,N,CV_32FC3);
	CvMat* _pImagePoints1 = cvCreateMat(1,N,CV_32FC2);
	CvMat* _pImagePoints2 = cvCreateMat(1,N,CV_32FC2);
	CvMat* _pNPoints      = cvCreateMat(1,vNPoints.size(),CV_32S);

	cvSetIdentity(&_M1);
	cvSetIdentity(&_M2);
	cvZero(&_D1);
	cvZero(&_D2);

	//【6】进行摄像机的立体标定
	std::cout<<"【HELP INFO】进行摄像机的立体标定..........."<<std::endl;
	fflush(stdout);                                                            //【1】摄像机立体标定的第一个重要模块
	cvStereoCalibrate(_pObjectPoints,                                      
		              _pImagePoints1,
		              _pImagePoints2,
					  _pNPoints,
		              _M1,
		              _D2,
		              _M2,
		              _D2,
		              imageSize,
					  _R,
					  _T,
					  _E,
					  _F,
					  cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,100,1e-5),
					  CV_CALIB_FIX_ASPECT_RATIO|
					  CV_CALIB_ZERO_TANGENT_DIST|
					  CV_CALIB_SAME_FOCAL_LENGTH);
	printf("Done\n");
	/***********************************************************************************************
	*模块说明:
	*         1---立体标定的评价
	*         2---因为输出的【基础矩阵】已经隐式的包含了所有的输出信息
	*         3---我们可以使用极线约束去检查摄像机标定的质量
	************************************************************************************************/
	std::vector<CvPoint3D32f>          vLines[2];
	vPoints[0].resize(N);
	vPoints[1].resize(N);

	//_pImagePoints1 = 
    //_pImagePoints2 =
	vLines[0].resize(N);
	vLines[1].resize(N);

	CvMat* _L1 = cvCreateMat(1,N,CV_32FC3);
	CvMat* _L2 = cvCreateMat(1,N,CV_32FC3);

	cvUndistortPoints(_pImagePoints1,
		              _pImagePoints1,
					  _M1,
					  _D1,
					  0,
					  _M1
		);
	cvUndistortPoints(_pImagePoints2,
		              _pImagePoints2,
					  _M2,
					  _D2,
					  0,_M2
		);
	cvComputeCorrespondEpilines(_pImagePoints1,
		                        1,
								_F,
								_L1
	    );
	cvComputeCorrespondEpilines(_pImagePoints2,
		                        1,
								_F,
								_L2
		);
	double    dAveErr = 0;
	for(int i=0;i<N;i++)
	{
		double dErr = std::fabs(vPoints[0][i].x*vLines[1][i].x+vPoints[0][i].y*vPoints[0][i].y);
		dAveErr = dAveErr+dErr;
	}
	printf("dAveErr = %g\n",dAveErr/(iNFreams*n));
	/***********************************************************************************************
	*模块说明:
	*         1---计算并且显示矫正
	************************************************************************************************/
	if(iShowUndistorted)
	{
		CvMat* pMx1    = cvCreateMat(imageSize.height,imageSize.width,CV_32F);
		CvMat* pMy1    = cvCreateMat(imageSize.height,imageSize.width,CV_32F);
		CvMat* pMx2    = cvCreateMat(imageSize.height,imageSize.width,CV_32F);
		CvMat* pMy2    = cvCreateMat(imageSize.height,imageSize.width,CV_32F);

		CvMat* pImg1r  = cvCreateMat(imageSize.height,imageSize.width,CV_8U);
		CvMat* pImg2r  = cvCreateMat(imageSize.height,imageSize.width,CV_8U);
		CvMat* pDisp   = cvCreateMat(imageSize.height,imageSize.width,CV_8U);

		CvMat* pPair   = NULL;
		double R1[3][3];
		double R2[3][3];
		double P1[3][4];
		double P2[3][4];

		CvMat _R1     = cvMat(3,4,CV_64F,R1);
		CvMat _R2     = cvMat(3,4,CV_64F,R2);

		if(iUseUncalibrateed == 0)
		{
			CvMat _P1     = cvMat(3,4,CV_64F,P1);
		    CvMat _P2     = cvMat(3,4,CV_64F,P2);
			cvStereoRectify(_M1,
				            _M2,
							_D1,
							_D2,
							imageSize,
							_R,
							_T,
							&_R1,
							&_R2,
							&_P1,
							&_P2,
							0,
							0);
			cvInitUndistortRectifyMap(_M1,_D1,&_R1,&_P1,pMx1,pMy1);
			cvInitUndistortRectifyMap(_M2,_D2,&_R2,&_P2,pMx2,pMy2);
		}
		else if (iUseUncalibrateed==1||iUseUncalibrateed==2)
		{
			double dH1[3][3];
			double dH2[3][3];
			double dIM[3][3];
			CvMat  _H1 = cvMat(3,3,CV_64F,dH1);
			CvMat  _H2 = cvMat(3,3,CV_64F,dH2);
			CvMat  _iM = cvMat(3,3,CV_64F,dIM);
			if(iUseUncalibrateed==2)
				cvFindFundamentalMat(_pImagePoints1,_pImagePoints2,_F);
			cvStereoRectifyUncalibrated(_pImagePoints1,
				                        _pImagePoints2,
										_F,
										imageSize,
										&_H1,
										&_H2,
										3
										);
			cvInvert(&_M1,&_iM);
			cvMatMul(&_H1,&_M1,&_R1);
			cvMatMul(&_iM,&_R1,&_R1);
			cvInvert(&_M2,&_iM);
			cvMatMul(&_H2,&_M2,&_R2);
			cvMatMul(&_iM,&_R2,&_R2);
			cvInitUndistortRectifyMap(_M1,_D1,&_R1,_M1,pMx1,pMy1);
			cvInitUndistortRectifyMap(_M2,_D2,&_R2,_M2,pMx2,pMy2);
		}
		else
		{
			assert(0);
		}
		cvNamedWindow("【*rectified】",1);
		if(!bIsVerticalStereo)
		{
			pPair = cvCreateMat(imageSize.height,imageSize.width*2,CV_8UC3);
		}
		else
		{
			pPair = cvCreateMat(imageSize.height*2,imageSize.width,CV_8UC3);
		}
		CvStereoBMState *BMState = cvCreateStereoBMState();
		assert(BMState!=0);
		BMState->preFilterSize       = 41;
		BMState->preFilterCap        = 31;
		BMState->SADWindowSize       = 41;
		BMState->minDisparity        = -64;
		BMState->numberOfDisparities = 128;
		BMState->textureThreshold    = 10;
		BMState->uniquenessRatio     = 15;
		for(int i=0;i<iNFreams;i++)
		{
			IplImage* pImg1 = cvLoadImage(vImageNames[0][i].c_str(),0);
			IplImage* pImg2 = cvLoadImage(vImageNames[1][i].c_str(),0);
			if(pImg1&&pImg2)
			{
				CvMat part;
				cvRemap(pImg1,pImg1r,pMx1,pMy1);
				cvRemap(pImg2,pImg2r,pMx2,pMy2);
				if(!bIsVerticalStereo||iUseUncalibrateed!=0)
				{
					cvFindStereoCorrespondenceBM(pImg1r,
						                         pImg2r,
												 pDisp,
												 BMState);
					cvNormalize(pDisp,pDisp,0,256,CV_MINMAX);
					cvNamedWindow("【DispParity】",1);
					cvShowImage("【DispParity】",pDisp);
				}
				if(!bIsVerticalStereo)
				{
					cvGetCols(pPair,&part,0,imageSize.width);
					cvCvtColor(pImg1r,&part,CV_GRAY2BGR);
					cvGetCols(pPair,&part,imageSize.width,imageSize.width*2);
					for(int j=0;j<imageSize.width;j+=16)
						cvLine(pPair,cvPoint(0,j),cvPoint(imageSize.width*2,j),CV_RGB(0,255,0));
				}
				else
				{
					cvGetRows(pPair,&part,0,imageSize.height);
					cvCvtColor(pImg1r,&part,CV_GRAY2BGR);
					cvGetRows(pPair,&part,imageSize.height,imageSize.height*2);
					cvCvtColor(pImg2,&part,CV_GRAY2RGB);
				}
				cvShowImage("【DispParity】",pPair);
				if(cvWaitKey()==27)
					break;
			}
			cvReleaseImage(&pImg1);
			cvReleaseImage(&pImg2);
		}
		cvReleaseStereoBMState(&BMState);
		cvReleaseMat(&pMx1);
		cvReleaseMat(&pMy1);
		cvReleaseMat(&pMx2);
		cvReleaseMat(&pMy1);
		cvReleaseMat(&pImg1r);
		cvReleaseMat(&pImg2r);
		cvReleaseMat(&pDisp);
	}
}
int main(int argc,char** argv)
{
	StereoCalibrate("list.txt",9,6,1);
	return 0;
}

马卫飞
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[代码记录] 图像处理合集——立体矫正；膨胀腐蚀；高斯滤波；hough直线检测python matlab
学习笔记居多
05-05 153
【代码】[代码记录] 图像处理合集——立体矫正；膨胀腐蚀；高斯滤波；hough直线检测python。
[双目视差] 立体校正源码分析(opencv)
yegeli的博客
05-28 3361
OpenCV双目视觉：Bouguet立体校正https://jingyan.baidu.com/article/a681b0de74312a3b1843460d.html cvConvert函数用于图像和矩阵之间的相互转换 为什么要用cvConvert 把IplImage转为矩阵？ 因为IplImage里的数据，你只能用uchar的形式存放，当你需要这些图像数据看作数据矩阵来运算时，0~255的精度显然满足不了要求； 然而CvMat里却可以存放任意通道数、任意格式的数据，这个机制方便了研究中的这种需求，转化
opencv-python立体匹配（极线校正）
小张的技术分享博客
04-26 9653
文章目录前言一、立体校正是什么？二、校准步骤1.照片准备2.立体匹配总结 前言   对照片进行光学畸变矫正后，因为是在研究双目视觉，所以就要进行立体矫正了。 一、立体校正是什么？   标定后得到了左右相机的内参数:焦距、主点坐标以及径向畸变和切向畸变，通过相机的内参数和畸变系数可校正左右拍摄图像的畸变，得到对应环境场景正确的图像。同时实验还得到了相机外参，外参用于立体校正，使左右图像处于同一平面内，且实现行对准，这一过程被称为极线校正。 二、校准步骤 1.照片准备 因为还没有实地拍摄照片，只能先用ope
【立体视觉】双目立体标定与立体校正
热门推荐
把岁月化成歌 留在博客
06-28 3万+
参考： 机器视觉学习笔记（6）——双目摄像机标定参数说明 机器视觉学习笔记（8）——基于OpenCV的Bouguet立体校正 双摄像头立体成像(三)-畸变矫正与立体校正人类可以看到3维立体的世界，是因为人的两只眼睛，从不同的方向看世界，两只眼睛中的图像的视差，让我们可以看到3维立体的世界。类似的，要想让计算机“看到”3维世界，就需要使用两个摄像头构成双目立体视觉系统。想要让双目视觉系统知道视差，
使用python-opencv对双目摄像头进行立体视觉图像矫正，去畸变
c2793的博客
04-18 5180
1、一张棋盘图可以直接从opencv官方github下载，这是一个拥有10*7个格子的棋盘，共有，本文所使用的就是这一个棋盘。你需要将它打印在A4纸上用于后续使用。（也可以根据官方教程自行设置棋盘大小2、一个双目摄像头随便在tb买的一个不知名摄像头，附赠了一个.exe的测试工具用于简单使用摄像头效果如下使用opencv简单测试一下，我用的笔记本，接上usb摄像头就是从1开始了，这个双目摄像头虽然有两个输入index=1和index=2但是其实只需要获取index=1的那个视频流就可以得到双目效果。
基于opencv的摄像机标定
10-18
基于opencv的摄像机标定程序，实现的效果较好，值得信赖
基于OPENCV的摄像机标定源代码
07-13
环境：VC6.0 && OpenCV1.0 程序说明： image_points.xml 保存所有角点的图像坐标（本程序要求每幅图像图像中的点数目一样） 现成的数据中"image_points.xml"文件中 <rows>1280</rows> 中的1280 = 5(图像数)×256...
基于OpenCV的立体摄像机标定
06-25
This software performs stereo camera calibration using OpenCV. For further details, please visit http://blog.martinperis.com/2011/01/opencv-stereo-camera-calibration.html
基于OpenCV的挖掘机器人摄像机参数标定
06-27
为了建立挖掘机器人视觉系统摄像机测量模型,提高视觉测量精度,分析了挖掘机器人摄像机视觉系统内、外参数成像模型及摄像机非线性畸变参数,确定了适合挖掘机器人视觉系统的标定参数。通过采集自制的棋盘标定模板不同...
基于OpenCV的单目摄像机标定
07-21
1.单目摄像机标定目的 单目摄像机标定的目的就是使摄像机实际状态无限接近理论推导的理想状态。单目摄像机标定最终将确定9个参数，摄像机内参数有4个，透镜畸变参数5个。 2.单目摄像机标定流程 制作标定板使用...
双目视觉立体标定与校正代码opencv
01-16
运用opencv对双目视觉系统进行标定和校正，精度很高
基于OpenCV立体校正匹配
08-28
通过Matlab实现双目视觉的标定，将标定后的数据写入OpenCV中，同过OpenCV实现立体校正、匹配。
opencv做立体矫正和视差
05-07
根据learning opencv当中的例程修改的代码。我自己调过，完全可以做立体矫正和视差，比较有用的
matlab立体矫正和畸变矫正代码
04-19
文件里面的.mat文件就是参考，要矫正自己的图必须要先得到标定结果，就是你自己相机标定的结果.mat文件
用OpenCV进行相机标定(张正友标定,有代码)
qq_41253960的博客
05-23 1万+
目录1. 内参与畸变2. 用OpenCV标定相机程序3.画棋盘标定板4.OpenCV拍照 1. 内参与畸变 理论部分可以参考其他博客或者视觉slam十四讲 相机标定主要是为了获得相机的内参矩阵K和畸变参数 内参矩阵K 畸变系数:径向畸变(k1,k2,k3), 切向畸变(p1,p2) 径向畸变公式 切向畸变公式 张正友标定方法能够提供一个比较好的初始解,用于后序的最优化. 这里用棋盘格进行标定,如果能够处理圆的偏心误差问题,用圆形图案标定板可能效果更好. 至少三张图片,一般用10-20张图片为最佳,要保证相
Bouguet极线校正的方法
wangxiaokun671903的专栏
07-22 1万+
哈哈
基于opencv的相机标定C++代码
Goodness2020的博客
08-09 8283
基于opencv的相机标定
双目立体校正C/C++复现
qq_43049432的博客
01-15 2958
【立体校正】C/C++复现前言立体校正原理简述实际效果问题求助 前言 项目需要，基于C/C++复现了双目立体校正功能，仅支持双线性插值方式。 立体校正原理简述 功能简述： 立体校正即把左右摄像头采集的图像中同一物点变换到同一水平线（使其在图像中的纵坐标相等），其主要目的是加速后续双目匹配速度。如下图中，红点1与红点2在真实三维世界中表示同一物点，但两个摄像机光心并不处于同一水平线，导致成像时该点纵坐标不相等，极大的增加了双目匹配时的搜索范围。 双目校正原理简述： 通过一个（模型、方程式）获取校正后的图中每
node-v10.22.0-darwin-x64.tar.xz
最新发布
05-03
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于opencv的双目立体视觉测距_摄像机标定
05-01
双目立体视觉测距是利用两个摄像机拍摄同一个目标，在...综上所述，基于opencv的双目立体视觉测距需要进行摄像机标定，以获得摄像机的内参和外参，再进行图像预处理和双目视差算法计算，最终可以得到目标物体的距离。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值