opencv cv::Mat In/Out putArray InputArray

已于 2022-10-18 11:10:32 修改
阅读量1.1k 收藏
点赞数
分类专栏： 编程语言 文章标签： opencv 计算机视觉 人工智能
于 2022-10-17 17:22:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoma_bk/article/details/127368345
版权

文章目录

综述

该目的是函数的形参类型基于实际情况而定，不需要传入指针等情况

InputArray

  • 其中 _InputArray 是一个类，可以从 Mat、Mat_<T>、Matx<T, m, n>、std::vector<T>、std::vector<std: :vector<T> >、std::vector<Mat>、std::vector<Mat_<T> >、UMat、std::vector<UMat> 或 double。它也可以从矩阵表达式构造。
  • 可选输入参数：如果某些输入数组可能为空，则传递 cv::noArray() （或者像您之前所做的那样简单地传递 cv::Mat()）。
  • 该类仅用于传递参数。也就是说，通常你 不应该 声明这种类型的类成员、局部和全局变量。
  • 如果您想设计自己的函数或类方法，可以操作多种类型的数组，您可以使用 InputArray（或 OutputArray）作为相应的参数。在函数内部，您应该使用 _InputArray::getMat() 方法为数组构造矩阵头（不复制数据）。
class CV_EXPORTS _InputArray
{
public:
    enum KindFlag {
        KIND_SHIFT = 16,
        FIXED_TYPE = 0x8000 << KIND_SHIFT,
        FIXED_SIZE = 0x4000 << KIND_SHIFT,
        KIND_MASK = 31 << KIND_SHIFT,

        NONE              = 0 << KIND_SHIFT,
        MAT               = 1 << KIND_SHIFT,
        MATX              = 2 << KIND_SHIFT,
        STD_VECTOR        = 3 << KIND_SHIFT,
        STD_VECTOR_VECTOR = 4 << KIND_SHIFT,
        STD_VECTOR_MAT    = 5 << KIND_SHIFT,
#if OPENCV_ABI_COMPATIBILITY < 500
        EXPR              = 6 << KIND_SHIFT,  //!< removed: https://github.com/opencv/opencv/pull/17046
#endif
        OPENGL_BUFFER     = 7 << KIND_SHIFT,
        CUDA_HOST_MEM     = 8 << KIND_SHIFT,
        CUDA_GPU_MAT      = 9 << KIND_SHIFT,
        UMAT              =10 << KIND_SHIFT,
        STD_VECTOR_UMAT   =11 << KIND_SHIFT,
        STD_BOOL_VECTOR   =12 << KIND_SHIFT,
        STD_VECTOR_CUDA_GPU_MAT = 13 << KIND_SHIFT,
#if OPENCV_ABI_COMPATIBILITY < 500
        STD_ARRAY         =14 << KIND_SHIFT,  //!< removed: https://github.com/opencv/opencv/issues/18897
#endif
        STD_ARRAY_MAT     =15 << KIND_SHIFT
    };

    _InputArray();
    _InputArray(int _flags, void* _obj);
    _InputArray(const Mat& m);
    _InputArray(const MatExpr& expr);
    _InputArray(const std::vector<Mat>& vec);
    template<typename _Tp> _InputArray(const Mat_<_Tp>& m);
    template<typename _Tp> _InputArray(const std::vector<_Tp>& vec);
    _InputArray(const std::vector<bool>& vec);
    template<typename _Tp> _InputArray(const std::vector<std::vector<_Tp> >& vec);
    _InputArray(const std::vector<std::vector<bool> >&) = delete;  // not supported
    template<typename _Tp> _InputArray(const std::vector<Mat_<_Tp> >& vec);
    template<typename _Tp> _InputArray(const _Tp* vec, int n);
    template<typename _Tp, int m, int n> _InputArray(const Matx<_Tp, m, n>& matx);
    _InputArray(const double& val);
    _InputArray(const cuda::GpuMat& d_mat);
    _InputArray(const std::vector<cuda::GpuMat>& d_mat_array);
    _InputArray(const ogl::Buffer& buf);
    _InputArray(const cuda::HostMem& cuda_mem);
    template<typename _Tp> _InputArray(const cudev::GpuMat_<_Tp>& m);
    _InputArray(const UMat& um);
    _InputArray(const std::vector<UMat>& umv);

    template<typename _Tp, std::size_t _Nm> _InputArray(const std::array<_Tp, _Nm>& arr);
    template<std::size_t _Nm> _InputArray(const std::array<Mat, _Nm>& arr);

    template<typename _Tp> static _InputArray rawIn(const std::vector<_Tp>& vec);
    template<typename _Tp, std::size_t _Nm> static _InputArray rawIn(const std::array<_Tp, _Nm>& arr);

    Mat getMat(int idx=-1) const;
    Mat getMat_(int idx=-1) const;
    UMat getUMat(int idx=-1) const;
    void getMatVector(std::vector<Mat>& mv) const;
    void getUMatVector(std::vector<UMat>& umv) const;
    void getGpuMatVector(std::vector<cuda::GpuMat>& gpumv) const;
    cuda::GpuMat getGpuMat() const;
    ogl::Buffer getOGlBuffer() const;

    int getFlags() const;
    void* getObj() const;
    Size getSz() const;

    _InputArray::KindFlag kind() const;
    int dims(int i=-1) const;
    int cols(int i=-1) const;
    int rows(int i=-1) const;
    Size size(int i=-1) const;
    int sizend(int* sz, int i=-1) const;
    bool sameSize(const _InputArray& arr) const;
    size_t total(int i=-1) const;
    int type(int i=-1) const;
    int depth(int i=-1) const;
    int channels(int i=-1) const;
    bool isContinuous(int i=-1) const;
    bool isSubmatrix(int i=-1) const;
    bool empty() const;
    void copyTo(const _OutputArray& arr) const;
    void copyTo(const _OutputArray& arr, const _InputArray & mask) const;
    size_t offset(int i=-1) const;
    size_t step(int i=-1) const;
    bool isMat() const;
    bool isUMat() const;
    bool isMatVector() const;
    bool isUMatVector() const;
    bool isMatx() const;
    bool isVector() const;
    bool isGpuMat() const;
    bool isGpuMatVector() const;
    ~_InputArray();

protected:
    int flags;
    void* obj;
    Size sz;

    void init(int _flags, const void* _obj);
    void init(int _flags, const void* _obj, Size _sz);
};

OutputArray

  • 该类型与 InputArray 非常相似，只是它用于输入/输出和输出函数参数。
  • 该类型基本都是引用 ，毕竟要作为输出使用
class CV_EXPORTS _OutputArray : public _InputArray
{
public:
    enum DepthMask
    {
        DEPTH_MASK_8U = 1 << CV_8U,
        DEPTH_MASK_8S = 1 << CV_8S,
        DEPTH_MASK_16U = 1 << CV_16U,
        DEPTH_MASK_16S = 1 << CV_16S,
        DEPTH_MASK_32S = 1 << CV_32S,
        DEPTH_MASK_32F = 1 << CV_32F,
        DEPTH_MASK_64F = 1 << CV_64F,
        DEPTH_MASK_16F = 1 << CV_16F,
        DEPTH_MASK_ALL = (DEPTH_MASK_64F<<1)-1,
        DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S,
        DEPTH_MASK_ALL_16F = (DEPTH_MASK_16F<<1)-1,
        DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F
    };

    _OutputArray();
    _OutputArray(int _flags, void* _obj);
    _OutputArray(Mat& m);
    _OutputArray(std::vector<Mat>& vec);
    _OutputArray(cuda::GpuMat& d_mat);
    _OutputArray(std::vector<cuda::GpuMat>& d_mat);
    _OutputArray(ogl::Buffer& buf);
    _OutputArray(cuda::HostMem& cuda_mem);
    template<typename _Tp> _OutputArray(cudev::GpuMat_<_Tp>& m);
    template<typename _Tp> _OutputArray(std::vector<_Tp>& vec);
    _OutputArray(std::vector<bool>& vec) = delete;  // not supported
    template<typename _Tp> _OutputArray(std::vector<std::vector<_Tp> >& vec);
    _OutputArray(std::vector<std::vector<bool> >&) = delete;  // not supported
    template<typename _Tp> _OutputArray(std::vector<Mat_<_Tp> >& vec);
    template<typename _Tp> _OutputArray(Mat_<_Tp>& m);
    template<typename _Tp> _OutputArray(_Tp* vec, int n);
    template<typename _Tp, int m, int n> _OutputArray(Matx<_Tp, m, n>& matx);
    _OutputArray(UMat& m);
    _OutputArray(std::vector<UMat>& vec);

    _OutputArray(const Mat& m);
    _OutputArray(const std::vector<Mat>& vec);
    _OutputArray(const cuda::GpuMat& d_mat);
    _OutputArray(const std::vector<cuda::GpuMat>& d_mat);
    _OutputArray(const ogl::Buffer& buf);
    _OutputArray(const cuda::HostMem& cuda_mem);
    template<typename _Tp> _OutputArray(const cudev::GpuMat_<_Tp>& m);
    template<typename _Tp> _OutputArray(const std::vector<_Tp>& vec);
    template<typename _Tp> _OutputArray(const std::vector<std::vector<_Tp> >& vec);
    template<typename _Tp> _OutputArray(const std::vector<Mat_<_Tp> >& vec);
    template<typename _Tp> _OutputArray(const Mat_<_Tp>& m);
    template<typename _Tp> _OutputArray(const _Tp* vec, int n);
    template<typename _Tp, int m, int n> _OutputArray(const Matx<_Tp, m, n>& matx);
    _OutputArray(const UMat& m);
    _OutputArray(const std::vector<UMat>& vec);

    template<typename _Tp, std::size_t _Nm> _OutputArray(std::array<_Tp, _Nm>& arr);
    template<typename _Tp, std::size_t _Nm> _OutputArray(const std::array<_Tp, _Nm>& arr);
    template<std::size_t _Nm> _OutputArray(std::array<Mat, _Nm>& arr);
    template<std::size_t _Nm> _OutputArray(const std::array<Mat, _Nm>& arr);

    template<typename _Tp> static _OutputArray rawOut(std::vector<_Tp>& vec);
    template<typename _Tp, std::size_t _Nm> static _OutputArray rawOut(std::array<_Tp, _Nm>& arr);

    bool fixedSize() const;
    bool fixedType() const;
    bool needed() const;
    Mat& getMatRef(int i=-1) const;
    UMat& getUMatRef(int i=-1) const;
    cuda::GpuMat& getGpuMatRef() const;
    std::vector<cuda::GpuMat>& getGpuMatVecRef() const;
    ogl::Buffer& getOGlBufferRef() const;
    cuda::HostMem& getHostMemRef() const;
    void create(Size sz, int type, int i=-1, bool allowTransposed=false, _OutputArray::DepthMask fixedDepthMask=static_cast<_OutputArray::DepthMask>(0)) const;
    void create(int rows, int cols, int type, int i=-1, bool allowTransposed=false, _OutputArray::DepthMask fixedDepthMask=static_cast<_OutputArray::DepthMask>(0)) const;
    void create(int dims, const int* size, int type, int i=-1, bool allowTransposed=false, _OutputArray::DepthMask fixedDepthMask=static_cast<_OutputArray::DepthMask>(0)) const;
    void createSameSize(const _InputArray& arr, int mtype) const;
    void release() const;
    void clear() const;
    void setTo(const _InputArray& value, const _InputArray & mask = _InputArray()) const;

    void assign(const UMat& u) const;
    void assign(const Mat& m) const;

    void assign(const std::vector<UMat>& v) const;
    void assign(const std::vector<Mat>& v) const;

    void move(UMat& u) const;
    void move(Mat& m) const;
};

案例

  • cv::Mat 中 .at<类型>(行，列) 取对应数据

Code

  void PointCvMat(const cv::Mat& mat,const std::string& head_str = "") {
    std::cout<<head_str<<" data: \n"<<mat<<std::endl;
  }

  void ComputeL_6x4(double * l_6x4) {

      for(int i=0;i<6;i++) {
         double * row = l_6x4 + 4 * i;
         row[0] = i * 10 + 0;
         row[1] = i * 10 + 1;
         row[2] = i * 10 + 2;
         row[3] = i * 10 + 3;
      }
  }


  void TestChangeL(cv::InputArray _src,cv::OutputArray _dst) {

    cv::Mat src = _src.getMat();
    _dst.createSameSize(_src,src.type());
    cv::Mat dst = _dst.getMat();
    int rows = src.rows,cols = src.cols;
    CHECK_EQ(src.rows,dst.rows);
    CHECK_EQ(src.cols,dst.cols);
    LOG(INFO)<<"r:"<<rows<<" c:"<<cols;
    for(int i =0; i< rows;i++) {
      for(int j =0; j< cols;j++) {
        dst.at<double>(rows-1-i,cols-1 -j) = src.at<double>(i,j);
      }
    }
  }

TEST(FunctionTest,cvMatTest1) {


  double l_6x4[6 * 4], b4[4] = {0};
  cv::Mat L_6x41,L_6x4 = cv::Mat(6, 4, CV_64F, l_6x4);
  cv::Mat B4    = cv::Mat(4, 1, CV_64F, b4);

  PointCvMat(L_6x4,"front");
  std::cout<<"------------------"<<std::endl;
  L_6x4.setTo(0);
  PointCvMat(L_6x4,"set_zero");
  std::cout<<"------------------"<<std::endl;
  ComputeL_6x4(l_6x4);
  PointCvMat(L_6x4,"back ");
  std::cout<<"------------------"<<std::endl;
  TestChangeL(L_6x4,L_6x41);
  PointCvMat(L_6x41,"TestChange ");
  std::cout<<"------------------"<<std::endl;

}

输出

在这里插入图片描述

xiaoma_bk
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cv::Mat 测试
大脸猴的博客
12-09 296
opencv Mat 测试
OpenCV中：CvArr、CvMat、IplImage、cv::Mat和cv::InputArray的相关总结
weixin_36234773的博客
11-02 6355
1.CvArr* ： typedef void CvArr；        可以认为CvArr*是一个万能指针，例如某个函数参数是CvArr*，该函数内部会强制转换回该函数需要的数据类型，所以在调用该函数时，传入的参数类型就必须与该函数要求的类型一致，否则就会出错。         2.cv::Mat：          我们可以认为cv::Mat类型把向量、矩阵、图像等都统一了操作
OpenCV中将MAT类型的对象作为InputArray类型的对像传递给函数
NodYoung
12-07 8589
初学OpenCV发现，发现这样一种情况：void imshow(const string& winname, InputArray mat);明明是InputArray类型的形参，而我们一般都使用Mat类型的实参来直接传递。 这是怎么回事呢？ 说白了，这是一个类型的对象转换为另一个类型的对象。使用C++中的类型转换构造函数来完成，关于类型转换构造函数这里有个链接，仅供参考：（C++数据类型转换以
Opencv学习----基本结构对象-cv::_InputArray
charce_you的专栏
08-15 6096
4.1.1 定义 这是将只读输入数组传递到OpenCV函数的代理类。 它被定义为： typedef const _InputArray＆ InputArray ; _InputArray是由Mat、Mat_<T>、Matx<T,m,n>、std::vector<T>、std::vector<std::vector<T> >、s...
讲解undefined reference to cv::_InputArray::_InputArray(cv::Mat const&)
最新发布
牛肉胡辣汤
12-29 733
错误常见于链接阶段，通常是由于链接选项设置不正确或未正确安装 OpenCV 库导致。通过正确设置链接选项和确保 OpenCV 库被正确安装，你可以解决这个错误，使你的 OpenCV 项目顺利编译和运行。
opencv3/C++实现霍夫圆/直线检测
08-25
在计算机视觉领域，OpenCV库提供了强大的图像处理和分析功能，其中包括霍夫变换（Hough Transform）算法，用于检测图像中的直线和圆。本篇文章将详细介绍如何使用OpenCV3和C++来实现霍夫直线检测和霍夫圆检测。 ...
Duanxx的OpenCV学习：flip翻转图像
08-27
总的来说，OpenCV的`flip`函数是一个简单但功能强大的工具，能帮助开发者快速实现图像翻转操作，广泛应用于图像处理和计算机视觉的各种场景。通过理解其工作原理和灵活运用，我们可以更好地解决实际问题，提升算法...
Duanxx的OpenCV学习：filter2D使用说明
09-13
void filter2D(InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor = Point(-1, -1), double delta = 0, int borderType = BORDER_DEFAULT); ``` #### 参数详解 1. **`src`** – 输入...
Qt+OpenCV2.4.4实现拉普拉斯算子图像锐化(Mat结构实现)
05-28
void Laplacian(InputArray src, OutputArray dst, int ddepth, int ksize=3, double scale=1, double delta=0, BorderTypes borderType=BORDER_DEFAULT) ``` 参数说明如下： - `src`：输入图像 - `dst`：输出图像 ...
openCV自学总结（基础操作，非完整版，后续学完了还会更新）
09-06
1. cv::InputArray：是一个抽象基类，用于描述输入数据，包括Mat、Matx、Scalar等。 2. cv::OutputArray：是一个抽象基类，用于描述输出数据，包括Mat、Matx、Scalar等。 3. cv::Scalar：是一个四维数据结构，包括...
InputArray和OutputArray
ahelloyou的博客
11-19 562
看过OpenCV源代码的朋友，肯定都知道很多函数的接口都是InputArray或者OutputArray型的，这个接口类还是很强大的，今个就来说说它们的那些事。 InputArray这个接口类可以是Mat、Mat_、Mat_<T, m, n>、vector、vector<vector>、vector。也就意味着当你看refman或者源代码时，如果看见函数的参数类型是InputArray型时，把上诉几种类型作为参数都是可以的。 有时候InputArray输入的矩阵是个空参数，你只需要用
_InputArray 和 outputArray在ORBslam中的使用
08-20 504
InputArray() 是一个接口类， 可以传入多种类型，例如Mat, Mat_<T>, Mat_<T, m,n>, vector<vector<T>>, vector<Mat>等； 因为在opencv中属于执行类，所以接口可能会改变，因此有几点需要注意： 1. 当在opencv的函数中看到出入类型为InputArray的参数，就可以...
OpenCV里常用的数据结构（Mat,Mask,Scalar,Range,InputArray,OutputArray等）
czl389的专栏
12-26 3285
一、读取，显示和保存图像 在这里只是进行图像读取、显示和保存，一些基本操作。需要引入两个头文件：定义了图像数据结构的核心库core.hpp和包含了所有图形接口函数的highgui头文件。 #include"opencv2/core/core.hpp" #include"opencv2/highgui/highgui.hpp" #include int main() { //创建空图像，并读
OpenCV辅助对象(help objects)(6)_InputArray和OutputArray
weixin_42730667的博客
02-03 619
opencv中的cv:DataType<>解决了算法与数据类型分类的问题，使算法能够适应多种类型的数据，以及能够方便提取出数据类型。但是OpenCV的基本数据类型有多多，Mat matx, vec等等以及为了适应cuda和opencl而特殊封装的数据类型，以及还要适应c++ 的vect等，在封装接口时，如果将所有的数据类型都作为入参提供给用户适应，可以想象API入参是非常的多。为了适应...
安装caffe框架时报错——对‘cv::_InputArray::_InputArray(cv::Mat const&)’未定义的引用
hnyzyty的专栏
01-27 1012
关于在ubuntu上安装caffe框架的教程，网上已有很多，因此本文旨在：（1）整理现有资料;（2）分享若干自己遇到的特殊问题和解决方案。 1. 现有资料： （1）安装opencv （2）安装caffe框架 2. 自己遇到的特殊问题及解决方案： 问题描述： 我按照上述教程安装caffe时，遇到一个问题：在caffe目录下执行make all时，链接过程报错——对‘cv::_InputArray::_InputArray(cv::Mat const&)’未定义的引用。 关于上述问题，网上
[Opencv源码阅读]InputArray和OutputArray
热门推荐
小柯的博客
12-09 1万+
概述 InputArray和OutputArray两个类都是代理数据类型，用来接收Mat和Vector<>作为输入参数，OutputArray继承自InputArray。 InputArray作为输入参数的时候，传入的参数加了const限定符，即它只接收参数作为纯输入参数，无法更改输入参数的内容。而OutputArray则没有加入限定符，可以对参数的内容进行更改。  InputArray
OpenCV c++ assertion failed <i < 0> in cv::_InputArray::getMat 错误的原因
lwhard的博客
03-09 5295
这个问题的主要原因是在与InputArray需要初始化，即需要声明InputArray的内存空间大小，否则无法读取正常的值。 代码比较多的时候一定要仔细检测这个问题。 尤其在声明一个vector> 时，注意申请内存空间。 使用cv::drawContours函数时可能会返回上述错误。
OpenCV源码详解之InputArray, OutputArray
tanmx219的博客
12-12 1万+
在OpenCV中，有两个代理类是经常出现的：InputArray和OutputArray，它巧妙地利用了C++的定义转换，辅助完成对矩阵的管理。 定义 typedef const _InputArray&amp; InputArray; typedef InputArray InputArrayOfArrays; typedef const _OutputArray&amp; OutputA...
但是运行后报错：terminate called after throwing an instance of 'cv::Exception' what(): OpenCV(4.5.0) /home/sniper/Downloads/opencv-4.5.0/modules/imgproc/src/contours.cpp:1799: error: (-215:Assertion failed) (_contours.kind() == _InputArray::STD_VECTOR_VECTOR || _contours.kind() == _InputArray::STD_VECTOR_MAT || _contours.kind() == _InputArray::STD_VECTOR_UMAT) in function 'findContours'
06-09
这个错误通常是由于传递给 `findContours()` 函数的轮廓参数类型不正确导致的。 在你的代码中，`findContours()` 函数的第一个参数是一个 `cv::Mat` 类型的矩阵，而第二个参数 `intersectionPolygon` 是一个 `std::vector<cv::Point>` 类型的向量。这里的问题是，`findContours()` 函数期望的第二个参数是一个用于存储轮廓的输出向量，而你传递了一个点的向量。因此，你需要将 `intersectionPolygon` 声明为一个 `std::vector<std::vector<cv::Point>>` 类型的向量，以存储轮廓。 更改后的代码如下所示： ``` bool isPolygonInside(const std::vector<cv::Point>& polygon1, const std::vector<cv::Point>& polygon2, double& outsideArea) { // Check if all vertices of polygon1 are inside polygon2 bool allInside = true; for (const auto& vertex : polygon1) { double distance = cv::pointPolygonTest(polygon2, vertex, true); if (distance < 0) { allInside = false; break; } } if (allInside) { return true; } // Polygon1 is partially or completely outside polygon2 std::vector<std::vector<cv::Point>> intersectionPolygon; // 修改此处 if (cv::isContourConvex(polygon1) && cv::isContourConvex(polygon2)) { cv::Mat intersectionMat; cv::intersectConvexConvex(cv::Mat(polygon1), cv::Mat(polygon2), intersectionMat); if (cv::countNonZero(intersectionMat) > 0) { cv::findContours(intersectionMat, intersectionPolygon, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE); } } else { std::vector<cv::Point> hull1, hull2; cv::convexHull(polygon1, hull1); cv::convexHull(polygon2, hull2); std::vector<cv::Point> hullIntersection; cv::convexHull(hull1, hullIntersection, false, false); cv::fillConvexPoly(cv::Mat(hullIntersection), hull2, cv::Scalar(0), false); cv::findContours(cv::Mat(hullIntersection), intersectionPolygon, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE); } if (intersectionPolygon.empty()) { outsideArea = 0; return false; } double intersectionArea = std::abs(cv::contourArea(intersectionPolygon[0])); // 修改此处 double polygon1Area = std::abs(cv::contourArea(polygon1)); outsideArea = polygon1Area - intersectionArea; return true; // 修改此处 } ``` 你需要将 `intersectionPolygon` 的类型从 `std::vector<cv::Point>` 改为 `std::vector<std::vector<cv::Point>>`，以及在计算交集面积时使用 `intersectionPolygon[0]` 来获取轮廓。 另外，最后一行需要返回 true，因为在计算出多边形1在多边形2外部的面积后，函数应该返回 true。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值