opencv图像去畸变

这篇具有很好参考价值的文章主要介绍了opencv图像去畸变。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

图像去畸变的思路

对于目标图像(无畸变图像)上的每个像素点,转换到normalize平面,再进行畸变变换,进行投影,得到这个像素点畸变后的位置,然后将这个位置的源图像(畸变图像)的像素值作为目标图像该点的像素值。

通常我们得到的原图是畸变后的图像(x_distort,y_distort),要计算畸变之前的真实图像(x,y),不是用逆运算,而是计算真实图像畸变后会投影在哪,对应过去。先把原图像设置为一个空的图像,把一个个像素畸变投影过去,找到和畸变后图像像素点的对应关系

鱼眼相机模型

世界坐标系内的点转换到相机坐标系

X_c = RX_w + t

转到归一化平面

opencv图像去畸变

 

对归一化平面内的点,进行畸变变换

opencv图像去畸变

 

畸变模型

径向畸变:桶形或者鱼眼

opencv图像去畸变

切向畸变:镜片安装和成像平面不平行引起的。

opencv图像去畸变

opencv图像去畸变

undistort

 注意,OpenCV畸变系数矩阵的默认顺序 [k1, k2, p1, p2, k3]

#include <opencv2/opencv.hpp>
#include <chrono>
using namespace std;

int main(int argc, char **argv)
{
  // 内参
  double fx = 458.654, fy = 457.296, cx = 367.215, cy = 248.375;
  /**内参矩阵K
   * fx  0  cx
   * 0  fy  cy
   * 0   0   1
   */
  // 畸变参数
  double k1 = -0.28340811, k2 = 0.07395907, p1 = 0.00019359, p2 = 1.76187114e-05;

  cv::Mat image = cv::imread(argv[1], 0); // 图像是灰度图,CV_8UC1
  int rows = image.rows, cols = image.cols;
  cv::Mat image_undistort = cv::Mat(rows, cols, CV_8UC1); // 方法1去畸变以后的图
  cv::Mat image_undistort2 = cv::Mat(rows, cols, CV_8UC1);  // 方法2 OpenCV去畸变以后的图



  chrono::steady_clock::time_point t1 = chrono::steady_clock::now();
  //! 方法1. 自己写计算去畸变后图像的内容
  for (int v = 0; v < rows; v++)
  {
    for (int u = 0; u < cols; u++)
    {
      double x = (u - cx) / fx, y = (v - cy) / fy; //要求解的真实图,归一化平面上的坐标
      double r = sqrt(x * x + y * y);
      double x_distorted = x * (1 + k1 * r * r + k2 * r * r * r * r) + 2 * p1 * x * y + p2 * (r * r + 2 * x * x); //畸变后归一化坐标
      double y_distorted = y * (1 + k1 * r * r + k2 * r * r * r * r) + p1 * (r * r + 2 * y * y) + 2 * p2 * x * y;
      double u_distorted = fx * x_distorted + cx; //畸变后像素坐标,即原图
      double v_distorted = fy * y_distorted + cy;
      // 投影赋值
      if (u_distorted >= 0 && v_distorted >= 0 && u_distorted < cols && v_distorted < rows) //真实图畸变后仍然在图上的
      {
        image_undistort.at<uchar>(v, u) = image.at<uchar>((int)v_distorted, (int)u_distorted);
      }
      else
      {
        image_undistort.at<uchar>(v, u) = 0; //这里最好用插值法
      }
    }
  }
  chrono::steady_clock::time_point t2 = chrono::steady_clock::now();
  chrono::duration<double> time_used = chrono::duration_cast<chrono::duration<double>>(t2 - t1);
  cout << "time = " << time_used.count() << endl;






  //! 方法2. OpenCV自带的undistort函数,更快速
  cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1); //内参矩阵
  K.at<float>(0, 0) = fx;
  K.at<float>(1, 1) = fy;
  K.at<float>(0, 2) = cx;
  K.at<float>(1, 2) = cy;
  cv::Mat distort_coeffs = cv::Mat::zeros(1, 5, CV_32FC1); //畸变系数矩阵 顺序是[k1, k2, p1, p2, k3]
  distort_coeffs.at<float>(0, 0) = k1;
  distort_coeffs.at<float>(0, 1) = k2;
  distort_coeffs.at<float>(0, 2) = p1;
  distort_coeffs.at<float>(0, 3) = p2;
  cout << "K = " << endl
       << K << endl;
  cout << "distort_coeffs = " << endl
       << distort_coeffs << endl;

  t1 = chrono::steady_clock::now();
  cv::undistort(image, image_undistort2, K, distort_coeffs); //去畸变
  t2 = chrono::steady_clock::now();
  time_used = chrono::duration_cast<chrono::duration<double>>(t2 - t1);
  cout << "time = " << time_used.count() << endl;

  // 展示去畸变后图像
  cv::imshow("distorted", image);
  cv::imshow("undistorted", image_undistort);
  cv::imshow("image_undistort2", image_undistort2);
  cv::waitKey(0);
  return 0;
}

undistortPoints

opencv图像去畸变

opencv图像去畸变

opencv图像去畸变

 opencv图像去畸变

if (_distCoeffs) 
{
	// compensate tilt distortion
	cv::Vec3d vecUntilt = invMatTilt * cv::Vec3d(x, y, 1);
	double invProj = vecUntilt(2) ? 1. / vecUntilt(2) : 1;
	x0 = x = invProj * vecUntilt(0);
	y0 = y = invProj * vecUntilt(1);

	double error = 1.7976931348623158e+308;
	// compensate distortion iteratively

	//注1: 开始循环迭代去除畸变
	for (int j = 0;; j++)
	{
		//注2:一个是最大迭代次数条件
		if ((criteria.type & cv::TermCriteria::COUNT) && j >= criteria.maxCount)
			break;
		//注3:一个是迭代最大误差条件
		if ((criteria.type & cv::TermCriteria::EPS) && error < criteria.epsilon)
			break;
			
		//注4:在只有k1,k2,k3,p1,p2共5个畸变参数时,对应的k数组中只有k[0]~k[4]有值,其他都为0
		double r2 = x*x + y*y;
		double icdist = (1 + ((k[7] * r2 + k[6])*r2 + k[5])*r2) / (1 + ((k[4] * r2 + k[1])*r2 + k[0])*r2);
		double deltaX = 2 * k[2] * x*y + k[3] * (r2 + 2 * x*x) + k[8] * r2 + k[9] * r2*r2;
		double deltaY = k[2] * (r2 + 2 * y*y) + 2 * k[3] * x*y + k[10] * r2 + k[11] * r2*r2;
		//注5:形如式(8)的迭代
		x = (x0 - deltaX)*icdist;
		y = (y0 - deltaY)*icdist;

		if (criteria.type & cv::TermCriteria::EPS)
		{
			double r4, r6, a1, a2, a3, cdist, icdist2;
			double xd, yd, xd0, yd0;
			cv::Vec3d vecTilt;

			//注6:将第k次计算的无畸变点代入畸变模型,得到于当前有畸变的偏差
			r2 = x*x + y*y;
			r4 = r2*r2;
			r6 = r4*r2;
			a1 = 2 * x*y;
			a2 = r2 + 2 * x*x;
			a3 = r2 + 2 * y*y;
			cdist = 1 + k[0] * r2 + k[1] * r4 + k[4] * r6;
			icdist2 = 1. / (1 + k[5] * r2 + k[6] * r4 + k[7] * r6);
			xd0 = x*cdist*icdist2 + k[2] * a1 + k[3] * a2 + k[8] * r2 + k[9] * r4;
			yd0 = y*cdist*icdist2 + k[2] * a3 + k[3] * a1 + k[10] * r2 + k[11] * r4;

			vecTilt = matTilt*cv::Vec3d(xd0, yd0, 1);
			invProj = vecTilt(2) ? 1. / vecTilt(2) : 1;
			xd = invProj * vecTilt(0);
			yd = invProj * vecTilt(1);

			double x_proj = xd*fx + cx;
			double y_proj = yd*fy + cy;

			error = sqrt(pow(x_proj - u, 2) + pow(y_proj - v, 2));
		}
	}
}
void cvUndistortPointsInternal( const CvMat* _src, CvMat* _dst, const CvMat* _cameraMatrix,
                   const CvMat* _distCoeffs,
                   const CvMat* matR, const CvMat* matP, cv::TermCriteria criteria)
{
	// 判断迭代条件是否有效
    CV_Assert(criteria.isValid());
	// 定义中间变量--A相机内参数组,和matA共享内存;RR-矫正变换数组,和_RR共享内存
	// k-畸变系数数组
    double A[3][3], RR[3][3], k[14]={0,0,0,0,0,0,0,0,0,0,0,0,0,0};
    CvMat matA=cvMat(3, 3, CV_64F, A), _Dk;
    CvMat _RR=cvMat(3, 3, CV_64F, RR);
    cv::Matx33d invMatTilt = cv::Matx33d::eye();
    cv::Matx33d matTilt = cv::Matx33d::eye();
	
	// 检查输入变量是否有效
    CV_Assert( CV_IS_MAT(_src) && CV_IS_MAT(_dst) &&
        (_src->rows == 1 || _src->cols == 1) &&
        (_dst->rows == 1 || _dst->cols == 1) &&
        _src->cols + _src->rows - 1 == _dst->rows + _dst->cols - 1 &&
        (CV_MAT_TYPE(_src->type) == CV_32FC2 || CV_MAT_TYPE(_src->type) == CV_64FC2) &&
        (CV_MAT_TYPE(_dst->type) == CV_32FC2 || CV_MAT_TYPE(_dst->type) == CV_64FC2));
 
    CV_Assert( CV_IS_MAT(_cameraMatrix) &&
        _cameraMatrix->rows == 3 && _cameraMatrix->cols == 3 );
 
    cvConvert( _cameraMatrix, &matA );// _cameraMatrix <--> matA / A
 
	// 判断输入的畸变系数是否有效
    if( _distCoeffs )
    {
        CV_Assert( CV_IS_MAT(_distCoeffs) &&
            (_distCoeffs->rows == 1 || _distCoeffs->cols == 1) &&
            (_distCoeffs->rows*_distCoeffs->cols == 4 ||
             _distCoeffs->rows*_distCoeffs->cols == 5 ||
             _distCoeffs->rows*_distCoeffs->cols == 8 ||
             _distCoeffs->rows*_distCoeffs->cols == 12 ||
             _distCoeffs->rows*_distCoeffs->cols == 14));
 
        _Dk = cvMat( _distCoeffs->rows, _distCoeffs->cols,
            CV_MAKETYPE(CV_64F,CV_MAT_CN(_distCoeffs->type)), k);// _Dk和数组k共享内存指针
 
        cvConvert( _distCoeffs, &_Dk );
        if (k[12] != 0 || k[13] != 0)
        {
            cv::detail::computeTiltProjectionMatrix<double>(k[12], k[13], NULL, NULL, NULL, &invMatTilt);
            cv::detail::computeTiltProjectionMatrix<double>(k[12], k[13], &matTilt, NULL, NULL);
        }
    }
 
    if( matR )
    {
        CV_Assert( CV_IS_MAT(matR) && matR->rows == 3 && matR->cols == 3 );
        cvConvert( matR, &_RR );// matR和_RR共享内存指针
    }
    else
        cvSetIdentity(&_RR);
 
    if( matP )
    {
        double PP[3][3];
        CvMat _P3x3, _PP=cvMat(3, 3, CV_64F, PP);
        CV_Assert( CV_IS_MAT(matP) && matP->rows == 3 && (matP->cols == 3 || matP->cols == 4));
        cvConvert( cvGetCols(matP, &_P3x3, 0, 3), &_PP );// _PP和数组PP共享内存指针
        cvMatMul( &_PP, &_RR, &_RR );// _RR=_PP*_RR 放在一起计算比较高效
    }
 
    const CvPoint2D32f* srcf = (const CvPoint2D32f*)_src->data.ptr;
    const CvPoint2D64f* srcd = (const CvPoint2D64f*)_src->data.ptr;
    CvPoint2D32f* dstf = (CvPoint2D32f*)_dst->data.ptr;
    CvPoint2D64f* dstd = (CvPoint2D64f*)_dst->data.ptr;
    int stype = CV_MAT_TYPE(_src->type);
    int dtype = CV_MAT_TYPE(_dst->type);
    int sstep = _src->rows == 1 ? 1 : _src->step/CV_ELEM_SIZE(stype);
    int dstep = _dst->rows == 1 ? 1 : _dst->step/CV_ELEM_SIZE(dtype);
 
    double fx = A[0][0];
    double fy = A[1][1];
    double ifx = 1./fx;
    double ify = 1./fy;
    double cx = A[0][2];
    double cy = A[1][2];
 
    int n = _src->rows + _src->cols - 1;
	// 开始对所有点开始遍历
    for( int i = 0; i < n; i++ )
    {
        double x, y, x0 = 0, y0 = 0, u, v;
        if( stype == CV_32FC2 )
        {
            x = srcf[i*sstep].x;
            y = srcf[i*sstep].y;
        }
        else
        {
            x = srcd[i*sstep].x;
            y = srcd[i*sstep].y;
        }
        u = x; v = y;
        x = (x - cx)*ifx;//转换到归一化图像坐标系(含有畸变)
        y = (y - cy)*ify;
 
		//进行畸变矫正
        if( _distCoeffs ) {
            // compensate tilt distortion--该部分系数用来弥补沙氏镜头畸变??
			// 如果不懂也没管,因为普通镜头中没有这些畸变系数
            cv::Vec3d vecUntilt = invMatTilt * cv::Vec3d(x, y, 1);
            double invProj = vecUntilt(2) ? 1./vecUntilt(2) : 1;
            x0 = x = invProj * vecUntilt(0);
            y0 = y = invProj * vecUntilt(1);
 
            double error = std::numeric_limits<double>::max();// error设定为系统最大值
            // compensate distortion iteratively
			// 迭代去除镜头畸变
			// 迭代公式    x′= (x−2p1 xy−p2 (r^2 + 2x^2))∕( 1 + k1*r^2 + k2*r^4 + k3*r^6)
			//             y′= (y−2p2 xy−p1 (r^2 + 2y^2))∕( 1 + k1*r^2 + k2*r^4 + k3*r^6)
 
            for( int j = 0; ; j++ )
            {
                if ((criteria.type & cv::TermCriteria::COUNT) && j >= criteria.maxCount)// 迭代最大次数为5次
                    break;
                if ((criteria.type & cv::TermCriteria::EPS) && error < criteria.epsilon)// 迭代误差阈值为0.01
                    break;
                double r2 = x*x + y*y;
                double icdist = (1 + ((k[7]*r2 + k[6])*r2 + k[5])*r2)/(1 + ((k[4]*r2 + k[1])*r2 + k[0])*r2);
                double deltaX = 2*k[2]*x*y + k[3]*(r2 + 2*x*x)+ k[8]*r2+k[9]*r2*r2;
                double deltaY = k[2]*(r2 + 2*y*y) + 2*k[3]*x*y+ k[10]*r2+k[11]*r2*r2;
                x = (x0 - deltaX)*icdist;
                y = (y0 - deltaY)*icdist;
 
				// 对当前迭代的坐标加畸变,计算误差error用于判断迭代条件
                if(criteria.type & cv::TermCriteria::EPS)
                {
                    double r4, r6, a1, a2, a3, cdist, icdist2;
                    double xd, yd, xd0, yd0;
                    cv::Vec3d vecTilt;
 
                    r2 = x*x + y*y;
                    r4 = r2*r2;
                    r6 = r4*r2;
                    a1 = 2*x*y;
                    a2 = r2 + 2*x*x;
                    a3 = r2 + 2*y*y;
                    cdist = 1 + k[0]*r2 + k[1]*r4 + k[4]*r6;
                    icdist2 = 1./(1 + k[5]*r2 + k[6]*r4 + k[7]*r6);
                    xd0 = x*cdist*icdist2 + k[2]*a1 + k[3]*a2 + k[8]*r2+k[9]*r4;
                    yd0 = y*cdist*icdist2 + k[2]*a3 + k[3]*a1 + k[10]*r2+k[11]*r4;
 
                    vecTilt = matTilt*cv::Vec3d(xd0, yd0, 1);
                    invProj = vecTilt(2) ? 1./vecTilt(2) : 1;
                    xd = invProj * vecTilt(0);
                    yd = invProj * vecTilt(1);
 
                    double x_proj = xd*fx + cx;
                    double y_proj = yd*fy + cy;
 
                    error = sqrt( pow(x_proj - u, 2) + pow(y_proj - v, 2) );
                }
            }
        }
		// 将坐标从归一化图像坐标系转换到成像平面坐标系
        double xx = RR[0][0]*x + RR[0][1]*y + RR[0][2];
        double yy = RR[1][0]*x + RR[1][1]*y + RR[1][2];
        double ww = 1./(RR[2][0]*x + RR[2][1]*y + RR[2][2]);
        x = xx*ww;
        y = yy*ww;
 
        if( dtype == CV_32FC2 )
        {
            dstf[i*dstep].x = (float)x;
            dstf[i*dstep].y = (float)y;
        }
        else
        {
            dstd[i*dstep].x = x;
            dstd[i*dstep].y = y;
        }
    }
}

畸变矫正

通过calibrate Camera()得到的内参和畸变系数

图像的畸变矫正需要相机的内参和畸变系数, 在opencv中, 有以下两个函数可以实现:

  • initUndistortRectifyMap() + remap()函数
  • undistort()函数

推荐使用第一种方法:initUndistortRectifyMap只用运行一次,remap读取一次图像运行一次。

void initUndistortRectifyMap( InputArray cameraMatrix, InputArray distCoeffs,
InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2 );

参数说明:
cameraMatrix——输入的摄像头内参数矩阵(3X3矩阵)
distCoeffs——输入的摄像头畸变系数矩阵(5X1矩阵)
R——输入的第一和第二摄像头坐标系之间的旋转矩阵
newCameraMatrix——输入的校正后的3X3摄像机矩阵
size——摄像头采集的无失真图像尺寸
m1type——map1的数据类型,可以是CV_32FC1或CV_16SC2
map1——输出的X坐标重映射参数
map2——输出的Y坐标重映射参数
 

void remap(InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar())

参数说明:
src——输入图像,即原图像,需要单通道8位或者浮点类型的图像
dst(c++)——输出图像,即目标图像,需和原图形一样的尺寸和类型
map1——它有两种可能表示的对象:(1)表示点(x,y)的第一个映射;(2)表示CV_16SC2,CV_32FC1等
map2——有两种可能表示的对象:(1)若map1表示点(x,y)时,这个参数不代表任何值;(2)表示 CV_16UC1,CV_32FC1类型的Y值
intermap2polation——插值方式,有四中插值方式:
(1)INTER_NEAREST——最近邻插值
(2)INTER_LINEAR——双线性插值(默认)
(3)INTER_CUBIC——双三样条插值(默认)
(4)INTER_LANCZOS4——lanczos插值(默认)

intborderMode——边界模式,默认BORDER_CONSTANT
borderValue——边界颜色,默认Scalar()黑色
 

projectPoints

先将世界坐标系内的点转换到相机坐标系、图像坐标系、像素坐标系。

然后再利用undistortPoint对这个点畸变矫正。

opencv图像去畸变

opencv图像去畸变文章来源地址https://www.toymoban.com/news/detail-469507.html

到了这里,关于opencv图像去畸变的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • OpenCV开发笔记(七十七):相机标定(二):通过棋盘标定计算相机内参矩阵矫正畸变摄像头图像

    若该文为原创文章,转载请注明原文出处 本文章博客地址:https://hpzwl.blog.csdn.net/article/details/136616551 各位读者,知识无穷而人力有穷,要么改需求,要么找专业人士,要么自己研究 红胖子(红模仿)的博文大全:开发技术集合(包含Qt实用技术、树莓派、三维、OpenCV、OpenGL、

    2024年03月13日
    浏览(48)
  • python利用opencv进行相机标定获取参数,并根据畸变参数修正图像附有全部代码(流畅无痛版)

    今天的低价单孔摄像机(照相机)会给图像带来很多畸变。畸变主要有两 种:径向畸变和切想畸变。如下图所示,用红色直线将棋盘的两个边标注出来, 但是你会发现棋盘的边界并不和红线重合。所有我们认为应该是直线的也都凸 出来了。 在 3D 相关应用中,必须要先校正这些畸变

    2024年02月06日
    浏览(50)
  • opencv实现图像去畸变——几种实现方式(含完整代码)&&效果对比图&&详细参数说明&&核心参数变化对应变化效果图&&常见问题

    以下介绍下opencv实现图像去畸变的几种方式以及详细参数说明,含项目案例,含扩展的相关知识 ① cv::fisheye::initUndistortRectifyMap 和 ② cv::initUndistortRectifyMap 都是 OpenCV 库中的函数,用于摄像机的畸变校正和图像的矫正。二者的区别在于,cv::fisheye::initUndistortRectifyMap 适用于

    2024年02月10日
    浏览(110)
  • Matlab 校正镜头畸变图像

    生活中一些针孔相机会给图像带来严重的失真,这主要是由于硬件和环境的因素所示导致的,其中主要的两种畸变是径向畸变和切向畸变。 径向畸变会导致直线看起来弯曲,即点距离图像中心越远,径向畸变就越大。例如,下面显示了一张图像,其中棋盘的两个边缘标有红线

    2024年02月11日
    浏览(47)
  • 全景图像畸变校正

    理想的相机基本上是小孔成像的,在小孔成像模型中,如果焦距一定,那么图像传感器像素平面的面积直接决定了相机视场角的大小,超过这个视场角范围的物体不会被镜头获取到。因此基于透镜成像原理的相机,视场角无法做到足够大,水平视场角一般小于140°。 但是在一

    2024年02月09日
    浏览(51)
  • 1、opencv相机畸变矫正

    2.1保存矩阵 2.1直接使用保存的矩阵

    2024年02月11日
    浏览(46)
  • 图像质量评估(5) -- 畸变(Distortion)

            当图像中原本应该是直线的地方看起来发生了不自然的变形或扭曲时,我们称为图像畸变。有三种类型的镜头畸变:桶形畸变(后文使用英文barrel),枕形畸变(后文使用pincushion)和胡子畸变(后文使用英文wave或mustache,这种畸变里包含了桶形畸变和枕形畸变)

    2024年02月05日
    浏览(37)
  • K210入门使用处理图像畸变方法

           在嵌入式开发中通常会使用到视觉方面的硬件做图像识别, 经常使用的小型嵌入式图像识别硬件有个K210,Openmv等,这里介绍的是K210这款可编程机器视觉硬件,它支持一系列广泛的图像处理和神经网络,其最突出的优点是它的算力可以达到1TOPS算力,连我们的树莓派

    2024年02月15日
    浏览(48)
  • 相机的畸变矫正与opencv代码说明

    图像算法中会经常用到摄像机的畸变校正,有必要总结分析OpenCV中畸变校正方法,其中包括普通针孔相机模型和鱼眼相机模型fisheye两种畸变校正方法。普通相机模型畸变校正函数针对OpenCV中的cv::initUndistortRectifyMap(),鱼眼相机模型畸变校正函数对应OpenCV中的cv::fisheye::initUndi

    2024年02月14日
    浏览(42)
  • python opencv多路视频畸变矫正与显示

    用于测试的计算机配置如下: 计算机为八核Intel(R) Xeon(R) CPU E3-1230 V2 @ 3.30GHz 注意:文中所说的cpu使用率是指该算法占用的cpu使用率 测试用的视频规格为1920*1080 做一路视频的去除畸变 cpu的使用率为126.9% 多路视频去除畸变显示 三路视频去除畸变显示代码如下: import cv2 import numpy

    2023年04月09日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包