opencv函数（二）

最新推荐文章于 2024-09-17 11:11:05 发布
最新推荐文章于 2024-09-17 11:11:05 发布
阅读量598 收藏 2
点赞数
分类专栏： opencv 文章标签： opencv 函数 class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37871032/article/details/69936599
版权

1.Mat中的构造函数

Mat是一个非常优秀的图像类，它同时也是一个通用的矩阵类，可以用来创建和操作多维矩阵。Mat类提供了一系列构造函数，可以方便的根据需要创建Mat对象。

    Mat();
    Mat(int rows, int cols, int type);
    Mat(Size size, int type);
    Mat::operator=(const Scalar& value) .
    Mat(int rows, int cols, int type, const Scalar& s);
    Mat(Size size, int type, const Scalar& s);
    Mat(int ndims, const int* sizes, int type);
    Mat(int ndims, const int* sizes, int type, const Scalar& s);
    Mat(const Mat& m);
    Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP);
    Mat(Size size, int type, void* data, size_t step=AUTO_STEP);
    Mat(int ndims, const int* sizes, int type, void* data, const size_t* steps=0);
    Mat(const Mat& m, const Range& rowRange, const Range& colRange=Range::all());
    Mat(const Mat& m, const Rect& roi);
    Mat(const Mat& m, const Range* ranges); 

1、Mat::Mat() 
无参数构造方法； 
2、Mat::Mat(int rows, int cols, int type) 
创建行数为 rows，列数为 col，类型为 type 的图像； 
3、Mat::Mat(Size size, int type) 
创建大小为 size，类型为 type 的图像； 
4、Mat::Mat(int rows, int cols, int type, const Scalar& s) 

创建行数为 rows，列数为 col，类型为 type 的图像，并将所有元素初始化为值 s； 
5、Mat::Mat(Size size, int type, const Scalar& s) 
创建大小为 size，类型为 type 的图像，并将所有元素初始化为值 s； 
6、Mat::Mat(const Mat& m) 
将m赋值给新创建的对象，此处不会对图像数据进行复制，m和新对象共用图像数据； 
7、Mat::Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP) 
创建行数为rows，列数为col，类型为type的图像，此构造函数不创建图像数据所需内存，而是直接使用data所指内存，图像的行步长由 step指定。 
8、Mat::Mat(Size size, int type, void* data, size_t step=AUTO_STEP) 
创建大小为size，类型为type的图像，此构造函数不创建图像数据所需内存，而是直接使用data所指内存，图像的行步长由step指定。 
9、Mat::Mat(const Mat& m, const Range& rowRange, const Range& colRange) 
创建的新图像为m的一部分，具体的范围由rowRange和colRange指定，此构造函数也不进行图像数据的复制操作，新图像与m共用图像数据； 
10、Mat::Mat(const Mat& m, const Rect& roi) 
创建的新图像为m的一部分，具体的范围roi指定，此构造函数也不进行图像数据的复制操作，新图像与m共用图像数据。

这些构造函数中，很多都涉及到类型type。type可以是CV_8UC1，CV_16SC1，…，CV_64FC4 等。里面的 8U 表示 8 位无符号整数，16S 表示 16 位有符号整数，64F表示 64 位浮点数（即 double 类型）；C 后面的数表示通道数，例如 C1 表示一个通道的图像，C4 表示 4 个通道的图像，以此类推。 

2、randu函数

声明：

CV_EXPORTS_W void randu(InputOutputArray dst, InputArray low, InputArray high);

3、Scalar_类的构造函数

       typedef Scalar_<double> Scalar;

声明：

    Scalar_();
    Scalar_(_Tp v0, _Tp v1, _Tp v2=0, _Tp v3=0);
    Scalar_(_Tp v0);

    template<typename _Tp2, int cn>
    Scalar_(const Vec<_Tp2, cn>& v);

    //! returns a scalar with all elements set to v0
    static Scalar_<_Tp> all(_Tp v0);

    //! conversion to another data type
    template<typename T2> operator Scalar_<T2>() const;

    //! per-element product
    Scalar_<_Tp> mul(const Scalar_<_Tp>& a, double scale=1 ) const;

    // returns (v0, -v1, -v2, -v3)
    Scalar_<_Tp> conj() const;
定义： 

template<typename _Tp> inline
Scalar_<_Tp>::Scalar_()
{
    this->val[0] = this->val[1] = this->val[2] = this->val[3] = 0;
}

template<typename _Tp> inline
Scalar_<_Tp>::Scalar_(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
{
    this->val[0] = v0;
    this->val[1] = v1;
    this->val[2] = v2;
    this->val[3] = v3;
}

template<typename _Tp> template<typename _Tp2, int cn> inline
Scalar_<_Tp>::Scalar_(const Vec<_Tp2, cn>& v)
{
    int i;
    for( i = 0; i < (cn < 4 ? cn : 4); i++ )
        this->val[i] = cv::saturate_cast<_Tp>(v.val[i]);
    for( ; i < 4; i++ )
        this->val[i] = 0;
}

template<typename _Tp> inline
Scalar_<_Tp>::Scalar_(_Tp v0)
{
    this->val[0] = v0;
    this->val[1] = this->val[2] = this->val[3] = 0;
}

template<typename _Tp> inline
Scalar_<_Tp> Scalar_<_Tp>::all(_Tp v0)
{
    return Scalar_<_Tp>(v0, v0, v0, v0);
}


template<typename _Tp> inline
Scalar_<_Tp> Scalar_<_Tp>::mul(const Scalar_<_Tp>& a, double scale ) const
{
    return Scalar_<_Tp>(saturate_cast<_Tp>(this->val[0] * a.val[0] * scale),
                        saturate_cast<_Tp>(this->val[1] * a.val[1] * scale),
                        saturate_cast<_Tp>(this->val[2] * a.val[2] * scale),
                        saturate_cast<_Tp>(this->val[3] * a.val[3] * scale));
}

template<typename _Tp> inline
Scalar_<_Tp> Scalar_<_Tp>::conj() const
{
    return Scalar_<_Tp>(saturate_cast<_Tp>( this->val[0]),
                        saturate_cast<_Tp>(-this->val[1]),
                        saturate_cast<_Tp>(-this->val[2]),
                        saturate_cast<_Tp>(-this->val[3]));
}

template<typename _Tp> inline
bool Scalar_<_Tp>::isReal() const
{
    return this->val[1] == 0 && this->val[2] == 0 && this->val[3] == 0;
}


template<typename _Tp> template<typename T2> inline
Scalar_<_Tp>::operator Scalar_<T2>() const
{
    return Scalar_<T2>(saturate_cast<T2>(this->val[0]),
                       saturate_cast<T2>(this->val[1]),
                       saturate_cast<T2>(this->val[2]),
                       saturate_cast<T2>(this->val[3]));
}


template<typename _Tp> static inline
Scalar_<_Tp>& operator += (Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
{
    a.val[0] += b.val[0];
    a.val[1] += b.val[1];
    a.val[2] += b.val[2];
    a.val[3] += b.val[3];
    return a;
}

template<typename _Tp> static inline
Scalar_<_Tp>& operator -= (Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
{
    a.val[0] -= b.val[0];
    a.val[1] -= b.val[1];
    a.val[2] -= b.val[2];
    a.val[3] -= b.val[3];
    return a;
}

template<typename _Tp> static inline
Scalar_<_Tp>& operator *= ( Scalar_<_Tp>& a, _Tp v )
{
    a.val[0] *= v;
    a.val[1] *= v;
    a.val[2] *= v;
    a.val[3] *= v;
    return a;
}

template<typename _Tp> static inline
bool operator == ( const Scalar_<_Tp>& a, const Scalar_<_Tp>& b )
{
    return a.val[0] == b.val[0] && a.val[1] == b.val[1] &&
           a.val[2] == b.val[2] && a.val[3] == b.val[3];
}

template<typename _Tp> static inline
bool operator != ( const Scalar_<_Tp>& a, const Scalar_<_Tp>& b )
{
    return a.val[0] != b.val[0] || a.val[1] != b.val[1] ||
           a.val[2] != b.val[2] || a.val[3] != b.val[3];
}

template<typename _Tp> static inline
Scalar_<_Tp> operator + (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
{
    return Scalar_<_Tp>(a.val[0] + b.val[0],
                        a.val[1] + b.val[1],
                        a.val[2] + b.val[2],
                        a.val[3] + b.val[3]);
}

template<typename _Tp> static inline
Scalar_<_Tp> operator - (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
{
    return Scalar_<_Tp>(saturate_cast<_Tp>(a.val[0] - b.val[0]),
                        saturate_cast<_Tp>(a.val[1] - b.val[1]),
                        saturate_cast<_Tp>(a.val[2] - b.val[2]),
                        saturate_cast<_Tp>(a.val[3] - b.val[3]));
}

template<typename _Tp> static inline
Scalar_<_Tp> operator * (const Scalar_<_Tp>& a, _Tp alpha)
{
    return Scalar_<_Tp>(a.val[0] * alpha,
                        a.val[1] * alpha,
                        a.val[2] * alpha,
                        a.val[3] * alpha);
}

template<typename _Tp> static inline
Scalar_<_Tp> operator * (_Tp alpha, const Scalar_<_Tp>& a)
{
    return a*alpha;
}

template<typename _Tp> static inline
Scalar_<_Tp> operator - (const Scalar_<_Tp>& a)
{
    return Scalar_<_Tp>(saturate_cast<_Tp>(-a.val[0]),
                        saturate_cast<_Tp>(-a.val[1]),
                        saturate_cast<_Tp>(-a.val[2]),
                        saturate_cast<_Tp>(-a.val[3]));
}


template<typename _Tp> static inline
Scalar_<_Tp> operator * (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
{
    return Scalar_<_Tp>(saturate_cast<_Tp>(a[0]*b[0] - a[1]*b[1] - a[2]*b[2] - a[3]*b[3]),
                        saturate_cast<_Tp>(a[0]*b[1] + a[1]*b[0] + a[2]*b[3] - a[3]*b[2]),
                        saturate_cast<_Tp>(a[0]*b[2] - a[1]*b[3] + a[2]*b[0] + a[3]*b[1]),
                        saturate_cast<_Tp>(a[0]*b[3] + a[1]*b[2] - a[2]*b[1] + a[3]*b[0]));
}

template<typename _Tp> static inline
Scalar_<_Tp>& operator *= (Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
{
    a = a * b;
    return a;
}

template<typename _Tp> static inline
Scalar_<_Tp> operator / (const Scalar_<_Tp>& a, _Tp alpha)
{
    return Scalar_<_Tp>(a.val[0] / alpha,
                        a.val[1] / alpha,
                        a.val[2] / alpha,
                        a.val[3] / alpha);
}

template<typename _Tp> static inline
Scalar_<float> operator / (const Scalar_<float>& a, float alpha)
{
    float s = 1 / alpha;
    return Scalar_<float>(a.val[0] * s, a.val[1] * s, a.val[2] * s, a.val[3] * s);
}

template<typename _Tp> static inline
Scalar_<double> operator / (const Scalar_<double>& a, double alpha)
{
    double s = 1 / alpha;
    return Scalar_<double>(a.val[0] * s, a.val[1] * s, a.val[2] * s, a.val[3] * s);
}

template<typename _Tp> static inline
Scalar_<_Tp>& operator /= (Scalar_<_Tp>& a, _Tp alpha)
{
    a = a / alpha;
    return a;
}

template<typename _Tp> static inline
Scalar_<_Tp> operator / (_Tp a, const Scalar_<_Tp>& b)
{
    _Tp s = a / (b[0]*b[0] + b[1]*b[1] + b[2]*b[2] + b[3]*b[3]);
    return b.conj() * s;
}

template<typename _Tp> static inline
Scalar_<_Tp> operator / (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
{
    return a * ((_Tp)1 / b);
}

template<typename _Tp> static inline
Scalar_<_Tp>& operator /= (Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
{
    a = a / b;
    return a;
}

template<typename _Tp> static inline
Scalar operator * (const Matx<_Tp, 4, 4>& a, const Scalar& b)
{
    Matx<double, 4, 1> c((Matx<double, 4, 4>)a, b, Matx_MatMulOp());
    return reinterpret_cast<const Scalar&>(c);
}

template<> inline
Scalar operator * (const Matx<double, 4, 4>& a, const Scalar& b)
{
    Matx<double, 4, 1> c(a, b, Matx_MatMulOp());
    return reinterpret_cast<const Scalar&>(c);
}



HuYuBing_
关注
专栏目录
opencv中Mat数据类型中data、size、depth、channels、elemsize、rows、cols、step等属性内涵
程序员，他们想的是什么?他们想的永远都是技术，他们崇尚的也永远都是技术。
11-20 1887
用来度量每一个像素中每一个通道的精度，但它本身与图像的通道数无关！elemSize 表示每个元素的大小(单位字节)，每个元素可能有多个通道，示例中，每个元素有三个通道，而每个通道类型为CV_16U,算3个通道的总数, 2*3=6。表示的是一个矩阵中的每个元素分别有几个值，如一个4*3的矩阵，有12个元素，每个元素如果有三个值，则此矩阵有三个通道。Mat矩阵的维度，若Mat是一个二维矩阵，则dims=2，三维则dims=3，大多数情况下处理的都是二维矩阵，是一个平面上的矩阵。Mat矩阵元素拥有的通道数。
OPENCV函数手册_opencv_opencv函数手册_
09-28
二、OpenCV函数分类 OpenCV函数大致可以分为以下几类： 1. 图像基本操作：包括读取、显示、保存图像，以及图像的基本变换如缩放、旋转、平移等。 2. 图像处理：包括滤波、边缘检测、直方图均衡化、色彩空间转换等。 ...
Opencv Mat矩阵中data、size、depth、elemSize、step等属性的理解
热门推荐
牧野的博客
08-23 8万+
data：          uchar类型的指针，指向Mat数据矩阵的首地址。可以理解为标示一个房屋的门牌号； dims：          Mat矩阵的维度，若Mat是一个二维矩阵，则dims=2，三维则dims=3，大多数情况下处理的都是二维矩阵，是一         个平面上的矩阵。         可以理解为房屋是一个一层的平房，三维或更多维的则是多层楼房
Opencv基础知识
sdlsgsl的博客
04-14 3127
一 有关 Mat 类型的属性变量 在 Opencv中，用 Mat 二维数组 存储二维图像。 1）获取Mat 类型的行数、列数 cv::Mat gray,； int rows=gray.rows; int cols=gray.cols; 2) Mat 类型的通道数、深度 cv:: Mat gray ； int channel=gray.channels(); 如果图像是三通道的，则 channel=3,如果是单通道，则 channel=1; 如果是三通道的话，顺序分别是BGR。 图像的深度，代表图像灰度值可达
OpenCV(C++)基本操作
最新发布
Somewhere, nowhere.
09-17 1311
站内已经有很多大神写过了，而且还是配图的，这里自己之前敲过一个笔记（没有配图的），也就发出来当作备份了。
Mat的构造函数
weixin_43489667的博客
09-27 3193
然后我们看看Mat常用的构造函数： 1、Mat::Mat() 无参数构造方法； 2、Mat::Mat(int rows, int cols, int type) 创建行数为 rows，列数为 col，类型为 type 的图像； 3、Mat::Mat(Size size, int type) 创建大小为 size，类型为 type 的图像； 4、Mat::Mat(int rows, int cols, int type, const Scalar& s) 创建行数为 rows，列数为 col，类型为
opencv关于mat的详解
weixin_43615373的博客
07-09 854
##1、起源 OpenCV作为强大的计算机视觉开源库，很大程度上参考了MatLab的实现细节和风格，比如说，在OpenCV2.x 版本以后，越来越多的函数实现了MatLab具有的功能，甚至干脆连函数名都一模一样（如 imread, imshow,imwriter等）。这一做法，不仅拉近了产品开发与学术研究的距离，并极大程度的提高了开发人员的研发效率，不得不说，Intel公司真的是一个伟大的公司。 在计算机内存中，数字图像以矩阵的形式存储和运算，比如，在MatLab中，图像读取之后对应一个矩阵，在OpenCV
OpenCV函数详解
09-26
mmshow(const String& winname, InputArray mat)在OpenCV中，`imshow`函数用于在先前用`namedWindow`创建的窗口中显示图像。它接受两个参数：窗口的名字和要显示的图像。图像数据通常是一个`Mat`对象，可以从`imread...
OPENCV函数手册（中文）.zip
08-16
这个压缩包“OPENCV函数手册（中文）.zip”显然是为中文用户提供的OpenCV函数参考手册，帮助开发者更好地理解和使用OpenCV中的各种函数。 OpenCV库的核心功能主要分为以下几个方面： 1. 图像处理：包括读取、写入...
opencv函数查询
10-23
可以方便的查看任何opencv包含的函数。对每个函数进行了定义说明，例子解析。非常好的资料。对于opencv的学习者必备。
Opencv函数手册
10-30
内容包含了Opencv的各种函数的使用中英文详细介绍。唯一的缺点是因为没有顺利，无法检索快速找出来所需要啊的函数。 有木有大神，知道怎样快速的检索Opencv函数的调用介绍？
OpenCV中Mat属性step，size，step1，elemSize，elemSize1
QQ哥的专栏
04-27 4万+
Mat属性step，size，step1，elemSize，elemSize1总结
OPENCV 学习系列一（包括知识，形态学）
qq_39545674的博客
03-01 856
opencv函数学习 目录 0、Mat 1、构造函数 2、向外提供的函数以及变量 1、dims --变量 2、channels() 3、cols 、rows 4、size 1、imread函数 2、resize函数 3、Size结构 4、createTrackbar --创建滑动条 getTrackbarPos --获取滑动条的值 5、namedWindow --新...
【c++】Opencv Mat类详解
热爱数据库的小胖
08-31 7750
1. Mat类常用成员函数和成员变量 由于 Mat 类使用的非常广泛，使用的形式也非常之多，这里只对较为常用的成员函数和成员变量做出了整理； 1.1 构造函数 （1）默认构造函数 cv::Mat::Mat() 默认构造函数：生成一个矩阵并由OpenCV提供的函数(一般是Mat::create() 和 cv::imread() )来分配储存空间。 Mat类可以分为两个部分：矩阵头和指向像素数据的矩阵指针 矩阵头：包括数字图像的矩阵尺寸、存储方法、存储地址和引用次数等，矩阵头的大...
OpenCV：创建Mat矩阵的几种常用方法
GodLei1995
05-16 1万+
目录 创建二维矩阵 创建多维矩阵 创建特殊矩阵 创建二维矩阵 默认构造函数 函数原型： Mat(); 示例： Mat m(480,640,CV_8UC3); Mat n; n=m; 创建无颜色矩阵 函数原型： void Mat::create(int _rows, int _cols, int _type) void Mat::create(Size _s...
opencv和cv::Mat常用属性和函数
踏雪飞鸿的博客
12-23 4499
这篇文章包括: 1. opencv常用头文件及作用 2. cv::Mat常见初始化 3. cv::Mat常见属性 4. cv::Mat常见函数   clone()和copyTo()的区别 5.cv::Mat的RGB赋值(改颜色) 6.待续   1. opencv常用头文件: 1.1 最常用头文件: #include <opencv2/core/core.hpp> #incl...
＜OpenCV＞ Mat属性
thisiszdy的博客
09-09 530
OpenCV-Mat类型属性分析
opencv中Mat类相关用法个人总结
晴明大大的创作中心
07-21 498
Mat类 Mat 有两部分组成，分别为矩阵头和指向像素数据的矩阵指针。 矩阵头：数字图像的矩阵尺寸，存储方法，存储地址和引用次数。矩阵头是一个常数，不会随着图像大小的改变而改变。 常用构造函数： cv::Mat::Mat(int rows,int cols,int type) cv::Mat::Mat(int rows,int cols,int type,const Scalar&amp...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值