MAT矩阵的应用（一）

最新推荐文章于 2022-04-28 17:03:53 发布
最新推荐文章于 2022-04-28 17:03:53 发布
阅读量814 收藏
点赞数
分类专栏： opencv learning

一、Mat简介

    在2001年刚刚出现的时候，OpenCV基于 C 语言接口而建。为了在内存（memory）中存放图像，当时采用名为 IplImage 的C语言结构体，时至今日这仍出现在大多数的旧版教程和教学材料。但这种方法必须接受C语言所有的不足，这其中最大的不足要数手动内存管理，其依据是用户要为开辟和销毁内存负责。虽然对于小型的程序来说手动管理内

一、Mat简介

    在2001年刚刚出现的时候，OpenCV基于 C 语言接口而建。为了在内存（memory）中存放图像，当时采用名为 IplImage 的C语言结构体，时至今日这仍出现在大多数的旧版教程和教学材料。但这种方法必须接受C语言所有的不足，这其中最大的不足要数手动内存管理，其依据是用户要为开辟和销毁内存负责。虽然对于小型的程序来说手动管理内存不是问题，但一旦代码开始变得越来越庞大，你需要越来越多地纠缠于这个问题，而不是着力解决你的开发目标。

   幸运的是，C++出现了，并且带来类的概念，这给用户带来另外一个选择：自动的内存管理（不严谨地说）。这是一个好消息，如果C++完全兼容C的话，这个变化不会带来兼容性问题。为此，OpenCV在2.0版本中引入了一个新的C++接口，利用自动内存管理给出了解决问题的新方法。使用这个方法，你不需要纠结在管理内存上，而且你的代码会变得简洁（少写多得）。但C++接口唯一的不足是当前许多嵌入式开发系统只支持C语言。所以，当目标不是这种开发平台时，没有必要使用旧 方法（除非你是自找麻烦的受虐狂码农）。

   关于 Mat ，首先要知道的是你不必再手动地（1）为其开辟空间（2）在不需要时立即将空间释放。但手动地做还是可以的：大多数OpenCV函数仍会手动地为输出数据开辟空间。当传递一个已经存在的Mat 对象时，开辟好的矩阵空间会被重用。也就是说，我们每次都使用大小正好的内存来完成任务。

   基本上讲 Mat 是一个类，由两个数据部分组成：矩阵头（包含矩阵尺寸，存储方法，存储地址等信息）和一个指向存储所有像素值的矩阵（根据所选存储方法的不同矩阵可以是不同的维数）的指针。矩阵头的尺寸是常数值，但矩阵本身的尺寸会依图像的不同而不同，通常比矩阵头的尺寸大数个数量级。因此，当在程序中传递图像并创建拷贝时，大的开销是由矩阵造成的，而不是信息头。OpenCV是一个图像处理库，囊括了大量的图像处理函数，为了解决问题通常要使用库中的多个函数，因此在函数中传递图像是家常便饭。同时不要忘了我们正在讨论的是计算量很大的图像处理算法，因此，除非万不得已，我们不应该拷贝大 的图像，因为这会降低程序速度。

二、Mat的基本操作

   这里展示一个例子解释一下Mat的基本操作

[cpp]  view plain copy
  1. <strong>#include<cv.h>  
  2. #include<highgui.h>  
  3. #include<iostream>  
  4. using namespace cv;  
  5. using namespace std;  
  6. int main()  
  7. {  
  8.     /*********************************Mat基本操作-矩阵*******************************************/  
  9.     //二维三通道矩阵建立  
  10.     Mat M(2,2, CV_8UC3, Scalar(0,0,255)); //使用构造函数创建矩阵  
  11.     /* 
  12.     CV_8UC3 表示使用8位的 unsigned char 型，每个像素由三个元素组成三通道,初始化为（0，0，255） 
  13.     */  
  14.     cout << "M = " << endl << " " << M << endl << endl; //格式化输出  
  15.     //三维  
  16.     int sz[3] = {3,3,3};   
  17.     Mat L(3,sz, CV_8UC(1), Scalar::all(0));  
  18.     /* 
  19.     超过两维的矩阵：指定维数，然后传递一个指向一个数组的指针，这个数组包含每个维度的尺寸；其余的相同 
  20.     */  
  21.     cout << "L = " << endl << " " << M << endl << endl; //格式化输出  
  22.   
  23.     /********************************************Mat基本操作-图像*******************************/  
  24.     Mat A, C;      // 只创建信息头部分  
  25.     A=imread("D:\\openCV\\openCVProject\\openCv笔记\\openCv笔记\\test.jpg", CV_LOAD_IMAGE_COLOR); // 这里为矩阵开辟内存  
  26.     Mat B(A);                // 使用拷贝构造函数  
  27.     C = A;                  // 赋值运算符  
  28.     /* 
  29.     拷贝构造函数和赋值函数 只拷贝信息头和矩阵指针 
  30.     */  
  31.   
  32.     Mat D (A, Rect(10, 10, 100, 100) ); //选取A中一个矩形区域,即只访问其矩形区域的信息头，只是创建信息头  
  33.     Mat E = A(cv::Range::all(), Range(1,3)); // 创建访问边界的信息头。  
  34.     /* 
  35.     要创建一个感兴趣区域（ ROI ），你只需要创建包含边界信息的信息头 
  36.     */  
  37.   
  38.     Mat F = A.clone();//复制图像，包括数据  
  39.     Mat G;  
  40.     A.copyTo(G);  
  41.     /* 
  42.     拷贝矩阵本身(不只是信息头和矩阵指针)， 
  43.     */  
  44.   
  45.     //测试  
  46.     namedWindow( "a", CV_WINDOW_AUTOSIZE );  
  47.     namedWindow( "c", CV_WINDOW_AUTOSIZE );  
  48.       
  49.     imshow( "a", D);  
  50.     imshow( "c", E );  
  51.   
  52.       
  53.     /****************************************图像的读取、处理和保存**************************************/  
  54.       Mat image;  
  55.      image = imread( "D:\\openCV\\openCVProject\\openCv笔记\\openCv笔记\\test.jpg", CV_LOAD_IMAGE_COLOR);//导入图像  
  56.   
  57.      if( !image.data )  
  58.      {  
  59.         cout<< " No image data \n " ;  
  60.         return -1;  
  61.      }  
  62.   
  63.      Mat gray_image;  
  64.      cvtColor( image, gray_image, CV_BGR2GRAY );//转化为灰度图  
  65.   
  66.      imwrite( "../../images/Gray_Image.jpg", gray_image );//写入图像  
  67.   
  68.      namedWindow( "source", CV_WINDOW_AUTOSIZE );  
  69.      namedWindow( "Gray image", CV_WINDOW_AUTOSIZE );  
  70.   
  71.      imshow( "source", image );  
  72.      imshow( "Gray image", gray_image );  
  73.      /*******************************************************************************************/  
  74.      waitKey(0);  
  75.      return 0;  
  76. }</strong>  

  对于Mat数据结构，在对图像进行处理时要注意：

 

  • OpenCV函数中输出图像的内存分配是自动完成的（如果不特别指定的话）。
  • 使用OpenCV的C++接口时不需要考虑内存释放问题。
  • 赋值运算符和拷贝构造函数（ ctor ）只拷贝信息头。
  • 使用函数 clone() 或者copyTo() 来拷贝一副图像的矩阵

     

  • 三、扫描图像的方法

        

    [cpp]  view plain copy
    1. <strong>#include<cv.h>  
    2. #include<highgui.h>  
    3. #include<time.h>  
    4. #include<iostream>  
    5. using namespace cv;  
    6. using namespace std;  
    7. int main()  
    8. {  
    9.     //Mat img(10,10,CV_8UC3,Scalar(0,0,255));  
    10.     Mat img,img_gray,img_gray2;  
    11.     img=imread("D:\\openCV\\openCVProject\\openCv笔记\\openCv笔记\\test.jpg", CV_LOAD_IMAGE_COLOR);  
    12.     cvtColor( img, img_gray, CV_BGR2GRAY );//转化为灰度图  
    13.     img_gray.copyTo(img_gray2);  
    14.     //方式一  
    15.     for(<strong> int i=0;i<img_gray.rows;i++</strong>)  
    16.     {  
    17.         uchar* data = img_gray.ptr<uchar>(i);  
    18.         for(int j=0;j<img_gray.cols;j++)  
    19.         {  
    20.             data[j] = 255;   
    21.         }  
    22.     }  
    23.     //img.create(10,10,CV_8UC3,Scalar(0,0,255));  
    24.     //cout << "img = " << endl << " " << img_gray << endl << endl; //格式化输出  
    25.     //方式二 W*H的一幅图像看成是一个1*（w*h）的一个一维数组  
    26.     int nc;  
    27.     if(img_gray.isContinuous())//判断是否被所有的像素填满  
    28.     {  
    29.         nc = img_gray.rows*img_gray.cols*img_gray.channels();     
    30.     }  
    31.     else  
    32.     {  
    33.         cout<<"像素未填满，不可用第二种方式"<<endl;  
    34.         return -1;  
    35.     }  
    36.     uchar* data_2 = img_gray.ptr<uchar>(0);//提取第一个像素点指针  
    37.     for(int i=0;i<nc;i++)//遍历所有的元素  
    38.     {  
    39.         data_2[i] = 255;  
    40.     }  
    41.     //方式三指针扫描  
    42.     uchar* data_3 = img.data;//单个元素  
    43.     img.at<uchar>(0,0)=0;  
    44.     for(int i=0;i<img.rows;i++)//遍历所有的元素  
    45.     {  
    46.         for(int j=0;j<img.cols;j++)  
    47.         {  
    48.              data_3 = img.data + i*img.step + j * img.elemSize();   
    49.              //对各个通道赋值  
    50.              data_3[0]=100;  
    51.              data_3[1]=100;  
    52.              data_3[2]=100;  
    53.         }  
    54.     }  
    55.     /*时间函数 
    56.     double start = getTickCount(); 
    57.     finish = clock();  
    58.     duration = (double)(finish - start) / CLOCKS_PER_SEC;  
    59.     */  
    60.     //方式四 迭代器iterator扫描图像  
    61.     Mat_<Vec3b>::iterator it = img.begin<Vec3b>();    
    62.     Mat_<Vec3b>::iterator itend = img.end<Vec3b>();    
    63.     for (; it!=itend; it++)    
    64.     {    
    65.              //对各个通道赋值  
    66.              (*it)[0] = 200;    
    67.              (*it)[1] = 200;   
    68.              (*it)[2] = 200;   
    69.     }    
    70.       
    71.     //测试，根据自己的选择查看结果  
    72.     namedWindow("sorce",WINDOW_AUTOSIZE);  
    73.     namedWindow("result",WINDOW_AUTOSIZE);  
    74.   
    75.     cv::imshow("sorce",img);  
    76.     cv::imshow("result",img_gray);  
    77.   
    78.     waitKey(0);  
    79.     return 0;  
    80.   
    81. }</strong>  


    以上是对http://blog.csdn.net/yang_xian521/article/details/7182185#的综合，以下是其博文，正如博主所说的，data_3 = img.data + i*img.step + j * img.elemSize();，int i=0;i<img_gray.rows;i++。。。这种在循环中出现的语句识别比较耗时的，注意避免。以下是其博文

  •  

    1.存取单个像素值

    最通常的方法就是

    [cpp]  view plain copy
    1. img.at<uchar>(i,j) = 255; 
    2. img.at<Vec3b>(i,j)[0] = 255; 
    [cpp]  view plain copy
    1. img.at<uchar>(i,j) = 255;  
    2. img.at<Vec3b>(i,j)[0] = 255;  


    如果你觉得at操作显得太笨重了，不想用Mat这个类，也可以考虑使用轻量级的Mat_类，使用重载操作符()实现取元素的操作。

    [cpp]  view plain copy
    1. cv::Mat_<uchar> im2= img; // im2 refers to image 
    2.    im2(50,100)= 0; // access to row 50 and column 100 
    [cpp]  view plain copy
    1. cv::Mat_<uchar> im2= img; // im2 refers to image  
    2.    im2(50,100)= 0; // access to row 50 and column 100  


     

    2.用指针扫描一幅图像

    对于一幅图像的扫描，用at就显得不太好了，还是是用指针的操作方法更加推荐。先介绍一种上一讲提到过的

    [cpp]  view plain copy
    1. for (int j=0; j<nl; j++) 
    2. { 
    3.         uchar* data= image.ptr<uchar>(j); 
    4.         for (int i=0; i<nc; i++) 
    5.        {                  
    6.                   data[i] = 255; 
    7.         } 
    8. } 
    [cpp]  view plain copy
    1. for (int j=0; j<nl; j++)  
    2. {  
    3.         uchar* data= image.ptr<uchar>(j);  
    4.         for (int i=0; i<nc; i++)  
    5.        {                   
    6.                   data[i] = 255;  
    7.         }  
    8. }  


    更高效的扫描连续图像的做法可能是把W*H的衣服图像看成是一个1*（w*h）的一个一维数组，这个想法是不是有点奇葩，这里要利用isContinuous这个函数判断图像内的像素是否填充满，使用方法如下：

    [cpp]  view plain copy
    1. if (img.isContinuous()) 
    2. { 
    3.         nc = img.rows*img.cols*img.channels(); 
    4. } 
    5. uchar* data = img.ptr<uchar>(0); 
    6. for (int i=0; i<nc; i++) 
    7. { 
    8.         data[i] = 255; 
    9. } 
    [cpp]  view plain copy
    1. if (img.isContinuous())  
    2. {  
    3.         nc = img.rows*img.cols*img.channels();  
    4. }  
    5. uchar* data = img.ptr<uchar>(0);  
    6. for (int i=0; i<nc; i++)  
    7. {  
    8.         data[i] = 255;  
    9. }  


    更低级的指针操作就是使用Mat里的data指针，之前我称之为暴力青年，使用方法如下：

    [cpp]  view plain copy
    1. uchar* data = img.data; 
    2. // img.at(i, j) 
    3. data = img.data + i * img.step + j * img.elemSize(); 
    [cpp]  view plain copy
    1. uchar* data = img.data;  
    2. // img.at(i, j)  
    3. data = img.data + i * img.step + j * img.elemSize();  


     

    3.用迭代器iterator扫描图像

    和C++STL里的迭代器类似，Mat的迭代器与之是兼容的。是MatIterator_。声明方法如下：

    [cpp]  view plain copy
    1. cv::MatIterator_<Vec3b> it; 
    [cpp]  view plain copy
    1. cv::MatIterator_<Vec3b> it;  


    或者是：

    [cpp]  view plain copy
    1. cv::Mat_<Vec3b>::iterator it; 
    [cpp]  view plain copy
    1. cv::Mat_<Vec3b>::iterator it;  


    扫描图像的方法如下：

    [cpp]  view plain copy
    1. Mat_<Vec3b>::iterator it = img.begin<Vec3b>(); 
    2. Mat_<Vec3b>::iterator itend = img.end<Vec3b>(); 
    3. for (; it!=itend; it++) 
    4. { 
    5.          (*it)[0] = 255; 
    6. } 
    [cpp]  view plain copy
    1. Mat_<Vec3b>::iterator it = img.begin<Vec3b>();  
    2. Mat_<Vec3b>::iterator itend = img.end<Vec3b>();  
    3. for (; it!=itend; it++)  
    4. {  
    5.          (*it)[0] = 255;  
    6. }  


     

    4.高效的scan image方案总结

    还是用我们之前使用过的getTickCount、getTickFrequency函数测试速度。这里我就不一一列举我测试的结果了，直接上结论。测试发现，好的编写风格可以提高50%的速度！要想减少程序运行的时间，必要的优化包括如下几个方面：

    （1）内存分配是个耗时的工作，优化之；

    （2）在循环中重复计算已经得到的值，是个费时的工作，优化之；举例：

    [cpp]  view plain copy
    1. int nc = img.cols * img.channels(); 
    2. for (int i=0; i<nc; i++) 
    3. {.......} 
    4. //************************** 
    5. for (int i=0; i<img.cols * img.channels(); i++) 
    6. {......} 
    [cpp]  view plain copy
    1. int nc = img.cols * img.channels();  
    2. for (int i=0; i<nc; i++)  
    3. {.......}  
    4. //**************************  
    5. for (int i=0; i<img.cols * img.channels(); i++)  
    6. {......}  


    后者的速度比前者要慢上好多。

    （3）使用迭代器也会是速度变慢，但迭代器的使用可以减少程序错误的发生几率，考虑这个因素，可以酌情优化

    （4）at操作要比指针的操作慢很多，所以对于不连续数据或者单个点处理，可以考虑at操作，对于连续的大量数据，不要使用它

    （5）扫描连续图像的做法可能是把W*H的衣服图像看成是一个1*（w*h）的一个一维数组这种办法也可以提高速度。短的循环比长循环更高效，即使他们的操作数是相同的

    以上的这些优化可能对于大家的程序运行速度提高并不明显，但它们毕竟是个得到速度提升的好的编程策略，希望大家能多采纳。

    还有就是利用多线程也可以高效提高运行速度。OpenMP和TBB是两种流行的APT，不过对于多线程的东西，我是有些迷糊的，呵呵

    5.整行整列像素值的赋值

    对于整行或者整列的数据，可以考虑这种方式处理

    [cpp]  view plain copy
    1. img.row(i).setTo(Scalar(255)); 
    2. img.col(j).setTo(Scalar(255)); 
    [cpp]  view plain copy
    1. img.row(i).setTo(Scalar(255));  
    2. img.col(j).setTo(Scalar(255));  


    这节就先介绍这么多攻略吧~希望大家喜欢

     

    参考资料

              1.http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/core/mat%20-%20the%20basic%20image%20container/mat%20-%20the%20basic%20image%20container.html

              2http://blog.sina.com.cn/s/blog_73ee929c01010yor.html

    文章出处

    http://blog.csdn.net/liurong_cn/article/details/7791815           

1290939507
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Qt OpenGL 缩放矩阵,旋转矩阵 移动矩阵.mat4x4
02-04
在这个项目中，"Qt OpenGL 缩放矩阵,旋转矩阵 移动矩阵.mat4x4"，重点在于理解并应用线性代数中的矩阵变换，特别是缩放、旋转和移动（平移）这三种基本变换。这些变换在3D图形编程中至关重要，因为它们帮助我们在三...
OpenCV Mat数据存储格式详解
chenwk891的专栏
11-10 1万+
http://blog.csdn.net/u013488563/article/details/19981887 Mat_对应的是CV_8U，Mat_对应的是CV_8S，Mat_对应的是CV_32S，Mat_对应的是CV_32F，Mat_对应的是CV_64F，对应的数据深度如下： • CV_8U - 8-bit unsigned integers ( 0..255 )
OpenCV调试笔记——读取图片存入Mat_<uchar>变量，下次提取时变灰色条纹图的问题
Yimi-依米 的博客
03-04 987
在OpenCV中，为了避免各种内存错误，使用Mat时，常自己指定好类型，即写作Mat_。使用Mat_对imread读入的图像数据存储，因为OpenCV里Mat_这种类型只存储8位的图片，若所读图不是CV_8U类型的，存储时图片会被强制转化为CV_8U类型，再用imshow展示出来的效果就是有灰色条纹的图了。 原图 有条纹的图 Mat temp = imread(&amp;amp;amp;amp;quot;F:/baby.png&amp;amp;amp;amp;quot;); ...
openCV学习（二）——Mat的衍生类
lvyaer_1122的博客
04-28 5420
学习Vec类、Mat_类、Matx类
opencv C++ Mat类的基本知识（混
cicistream
11-09 1万+
Mat::clone()  创建一个全拷贝 Mat::copyTo();  不止表示拷贝数据，还表示n=m.col(0) Mat矩阵中数据指针Mat.data是uchar类型指针，CV_8U系列可以通过计算指针位置快速地定位矩阵中的任意元素。
opencv中遍历图像（Mat格式）
lilin020401的专栏
10-28 3051
当Mat为多通道图像时，遍历整幅图像：
mat4-recompose:重组一个 4x4 矩阵
06-26
mat4-recompose 从平移、缩放、倾斜、透视和旋转重构一个 4x4 矩阵。 这通常用于矩阵动画（即在和插值之后）。... 构建平移矩阵，然后应用四元数旋转和透视。 然后将矩阵乘以 YZ 剪切，然后是 XZ 剪切，然
QT调用python，并给python传递Mat矩阵和二维数组
01-03
在IT领域，跨语言通信是常见的需求，这里我们讨论的是如何使用QT（一种C++的图形用户界面应用程序开发框架）调用Python脚本，并传递数据，如OpenCV中的Mat矩阵和二维数组。这个过程涉及到了多语言接口设计、数据类型...
fuzzy_sim_mat.rar_模糊相似矩阵_矩阵相似
09-19
在这个上下文中，"fuzzy_sim_mat.rar"是一个压缩包，包含了一个名为"fuzzy_sim_mat.doc"的文档，很可能提供了关于如何实现模糊相似矩阵的详细步骤和源代码。 模糊相似矩阵是模糊系统理论中的核心概念，它扩展了传统...
MATLAB mat文件转mdf
07-28
1. **MATLAB .mat文件**：MATLAB的数据存储方式非常灵活，它可以保存矩阵、数组、结构体、字符串、函数、甚至图形对象。.mat文件是二进制文件，能够高效地存储和读取大量数据。在MATLAB中，可以使用`save`函数将变量...
HankelMatrix_构件汉克尔矩阵_
10-02
汉克尔矩阵（Hankel Matrix）是一种特殊的矩阵，在数学、信号处理和控制系统等领域有着广泛的应用。本主题将深入探讨汉克尔矩阵的定义、构造方法及其在实际问题中的应用。 1. 汉克尔矩阵定义： 汉克尔矩阵是由相同...
2.2建立矩阵（Mat）
03-27
一个简单的创建空`Mat`的例子是： ```java Mat mat = new Mat(); ``` 如果你想创建具有特定形状和类型的`Mat`，可以指定行数、列数和类型。例如，创建一个3x3的整型矩阵： ```java int rows = 3, cols = 3, type ...
OpenCV Mat实例详解一源码
最新发布
02-13
在`OpenCVMatTest`源代码中，我们可以预期看到这些概念的实例应用，如创建`Mat`对象、读取和写入图像、进行基本的图像处理操作、使用`Mat`进行矩阵运算等。通过分析和运行这些示例，我们可以更好地理解和掌握OpenCV...
mat_inv.rar_MAT求逆矩阵_mat inv_求逆_矩阵求逆_矩阵逆运算
09-23
在数学和计算机科学中，矩阵求逆是一种基本的线性代数操作，它在各种领域如图像处理、机器学习、控制系统、数值分析等都有广泛应用。标题"mat_inv.rar"和描述提示我们，这个压缩包可能包含一系列用于计算矩阵逆的...
labview读取mat格式文件
04-28
MAT文件是MATLAB用于存储变量和数据的标准格式，它能够保存数组、向量、矩阵、字符串、结构体等多种类型的数据。 "labview读取mat格式文件"这个主题意味着我们需要探讨如何在LabVIEW中操作MAT文件，以便将MATLAB...
opencv中Mat的数据类型设置问题
Bery的专栏
07-14 3342
在编码过程中已经编好的代码，觉得yi
OpenCV矩阵运算
热门推荐
延陵小明
03-02 3万+
一、矩阵 Mat I,img,I1,I2,dst,A,B; double k,alpha; Scalar s; 1.加法 I=I1+I2;//等同add(I1,I2,I); add(I1,I2,dst,mask,dtype); scaleAdd(I1,scale,I2,dst);//dst=scale*I1+I2; 2.减法 absdiff(I1,I2,I);//I=|I1-I2
opencv c++中的9种方式创建矩阵Mat
love code, love life.
11-12 3990
//1 create a mat with random values //2 create zeors or ones Mat //3 common attribute of Mat //4 access element of Mat by at //5 access element of Mat by ptr //6 access element of Mat by ptr and is continous //7 get one row or one col of a Mat //...
为什么要定义Mat_类
u011817406的博客
03-01 3594
本文内容摘自于仕琪老师写的《opencv入门教程》示例程序如最下面所示：         在读取矩阵元素时，以及获取矩阵某行的地址时，需要指定数据类型。这样首先需要不停地写“&lt;uchar&gt;”，让人感觉很繁琐，在繁琐和烦躁中容易犯错，如下面代码中的错误，用 at()获取矩阵元素时错误的使用了 double 类型。这种错误不是语法错误，因此在编译时编译器不会提醒。在程序运行时， at()函...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值