opencv学习记录2

最新推荐文章于 2024-11-15 22:58:39 发布
最新推荐文章于 2024-11-15 22:58:39 发布
阅读量159 收藏
点赞数
分类专栏： OPENCV学习 文章标签： opencv c++ matlab
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tu1603_3LiWen/article/details/119886010
版权

**

OPENCV学习

**
基础数据结构
主要是图像处理中需要用到的数据结构：
1.Point(点)
点在图像处理中通常用来标记特征点（交点、角点、拐点等）
Point( intx,int y )表示二维整型坐标,以（0，0）基点
Point2f(float x,float y)表示浮点坐标，以（0，0）为基点
图像上两点，坐标为A（200，300）和B（150.2，260.5）在代码中表示为
Point A A={200,300}或者 A.x=200; A.y=300; Point2f B B={150.2,260.5} 或 B.x=150.2;B=260.5;
2.矩阵Mat
opencv中的矩阵计算很大程度上与matlab相似，从OpenCV2开始，开始使用Mat类存储图像，具有以下优势：
（1）图像的内存分配和释放由Mat类自动管理
（2）Mat类由两部分数据组成：矩阵头(包含矩阵尺寸、存储方法、存储地址等)和一个指向存储所有像素值的矩阵(根据所选存储方法的不同，矩阵可以是不同的维数)的指针。Mat在进行赋值和拷贝时，只复制矩阵头，而不复制矩阵，提高效率。如果矩阵属于多个Mat对象，则通过引用计数来判断，当最后一个使用它的对象，则负责释放矩阵。
（3）可以使用clone和copyTo函数，不仅复制矩阵头还复制矩阵。
2.1构造Mat函数

  1. 使用构造函数(使用Mat图像容器类创建Mat类的对象)
    //! default constructor
    Mat();
    //! constructs 2D matrix of the specified size and type
    // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
    Mat(int rows, int cols, int type);
    Mat(Size size, int type);
    //! constucts 2D matrix and fills it with the specified value _s.
    Mat(int rows, int cols, int type, const Scalar& s);
    Mat(Size size, int type, const Scalar& s);

    //! constructs n-dimensional matrix
    Mat(int ndims, const int* sizes, int type);
    Mat(int ndims, const int* sizes, int type, const Scalar& s);

例：

    cv::Mat M1(3, 3, CV_8UC4, cv::Scalar(0, 0, 0, 255));
	std::cout << "M1 = " << std::endl << M1 << std::endl;

这里指定矩阵的行和列，并表示为4通道的矩阵，每个点的颜色值为（0, 0, 0, 255）。输出结果如下：
M1 =
[ 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255;
0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255;
0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255]

  1. 通过数组初始化矩阵维数
	int sz[2] = { 3, 3 };
	cv::Mat M2(2, sz, CV_8UC1, cv::Scalar::all(0));
	std::cout << "M2 = " << std::endl << M2 << std::endl;

如上，构造函数的第一个参数指定的是矩阵的维数，那么sz数组表示的是每一维数的数量，即这里表示的是3行3列。如果第一个参数是3的话，数组的大小也应该是3，表示的就是x，y，z三个维度，每个维度有3个。输出如下：
M2 =
[ 0, 0, 0;
0, 0, 0;
0, 0, 0]

3. 通过create函数来初始化

 cv::Mat M3;
 M3.create(4, 4, CV_8UC(1));
 std::cout << "M3 = " << std::endl << M3 << std::endl;

这里是4*4的二维单通道矩阵，矩阵中的数据为随机值。如下：

M3=
[205, 205, 205, 205;
205, 205, 205, 205;
205, 205, 205, 205;
205, 205, 205, 205]

4. 通过opencv提供的类matlab的函数创建

//! Matlab-style matrix initialization
    static MatExpr zeros(int rows, int cols, int type);
    static MatExpr zeros(Size size, int type);
    static MatExpr zeros(int ndims, const int* sz, int type);
    static MatExpr ones(int rows, int cols, int type);
    static MatExpr ones(Size size, int type);
    static MatExpr ones(int ndims, const int* sz, int type);
    static MatExpr eye(int rows, int cols, int type);
    static MatExpr eye(Size size, int type);

例：

 cv::Mat Me = cv::Mat::eye(4, 4, CV_64F);
 std::cout << "Me = " << std::endl << Me << std::endl;

 cv::Mat Mo = cv::Mat::ones(4, 4, CV_64F);
 std::cout << "Mo = " << std::endl << Mo << std::endl;

 cv::Mat Mz = cv::Mat::zeros(4, 4, CV_64F);
 std::cout << "Mz = " << std::endl << Mz << std::endl;

eye函数表示的是单位矩阵，ones顾名思义是全是1的矩阵，zeros表示全是0的矩阵。输出如下：
Me =
[1, 0, 0, 0;
0, 1, 0, 0;
0, 0, 1, 0;
0, 0, 0, 1]
Mo =
[1, 1, 1, 1;
1, 1, 1, 1;
1, 1, 1, 1;
1, 1, 1, 1]
Mz =
[0, 0, 0, 0;
0, 0, 0, 0;
0, 0, 0, 0;
0, 0, 0, 0]

5. 数据自定义矩阵Mat创建

 cv::Mat M4 = (cv::Mat_<double>(3, 3) << 0, -1, 0, -1, 0, 0, 0, 0, 1);
 std::cout << "M4 = " << std::endl << M4 << std::endl;

我们可以自己定义自己需要的数据量比较小的矩阵，然后通过如上的方式将其封装到cv::Mat中。如下：

M4 =
[0, -1, 0;
-1, 0, 0;
0, 0, 1]

6. 通过clone函数创建不同的Mat
cv::Mat M5 = M4.row(1).clone();
std::cout << "M5 = " << std::endl << M5 << std::endl;

通过克隆函数clone获取我们需要的某一行或列的数据，这里构建出来的矩阵是深拷贝出来的Mat类对象。输出如下：

M5 =
[-1, 0, 0]

创建Mat矩阵/图像容器类的很多构造方法或者其他成员方法在创建Mat对象的时候,都需要指定type–所创建图像/矩阵的类型。
(_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
通过转到定义法,看一下CV_8UC1,CV_64FC3等这些宏到底是什么，OpenCv的源代码显示如下（源代码在在types_c.h中）:

#define CV_CN_MAX     512
#define CV_CN_SHIFT   3
#define CV_DEPTH_MAX  (1 << CV_CN_SHIFT)

#define CV_8U   0
#define CV_8S   1
#define CV_16U  2
#define CV_16S  3
#define CV_32S  4
#define CV_32F  5
#define CV_64F  6
#define CV_USRTYPE1 7

#define CV_MAT_DEPTH_MASK       (CV_DEPTH_MAX - 1)
#define CV_MAT_DEPTH(flags)     ((flags) & CV_MAT_DEPTH_MASK)

#define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))
#define CV_MAKE_TYPE CV_MAKETYPE

#define CV_8UC1 CV_MAKETYPE(CV_8U,1)
#define CV_8UC2 CV_MAKETYPE(CV_8U,2)
#define CV_8UC3 CV_MAKETYPE(CV_8U,3)
#define CV_8UC4 CV_MAKETYPE(CV_8U,4)
#define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))

#define CV_8SC1 CV_MAKETYPE(CV_8S,1)
#define CV_8SC2 CV_MAKETYPE(CV_8S,2)
#define CV_8SC3 CV_MAKETYPE(CV_8S,3)
#define CV_8SC4 CV_MAKETYPE(CV_8S,4)
#define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))

#define CV_16UC1 CV_MAKETYPE(CV_16U,1)
#define CV_16UC2 CV_MAKETYPE(CV_16U,2)
#define CV_16UC3 CV_MAKETYPE(CV_16U,3)
#define CV_16UC4 CV_MAKETYPE(CV_16U,4)
#define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))

#define CV_16SC1 CV_MAKETYPE(CV_16S,1)
#define CV_16SC2 CV_MAKETYPE(CV_16S,2)
#define CV_16SC3 CV_MAKETYPE(CV_16S,3)
#define CV_16SC4 CV_MAKETYPE(CV_16S,4)
#define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))

#define CV_32SC1 CV_MAKETYPE(CV_32S,1)
#define CV_32SC2 CV_MAKETYPE(CV_32S,2)
#define CV_32SC3 CV_MAKETYPE(CV_32S,3)
#define CV_32SC4 CV_MAKETYPE(CV_32S,4)
#define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))

#define CV_32FC1 CV_MAKETYPE(CV_32F,1)
#define CV_32FC2 CV_MAKETYPE(CV_32F,2)
#define CV_32FC3 CV_MAKETYPE(CV_32F,3)
#define CV_32FC4 CV_MAKETYPE(CV_32F,4)
#define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))

#define CV_64FC1 CV_MAKETYPE(CV_64F,1)
#define CV_64FC2 CV_MAKETYPE(CV_64F,2)
#define CV_64FC3 CV_MAKETYPE(CV_64F,3)
#define CV_64FC4 CV_MAKETYPE(CV_64F,4)
#define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))

这里的type可以是任何的预定义类型，预定义类型的结构如下所示:CV_<bit_depth>(S|U|F)C<number_of_channels>

  1--bit_depth---比特数---代表8bite,16bites,32bites,64bites---举个例子吧--比如说,如
        如果你现在创建了一个存储--灰度图片的Mat对象,这个图像的大小为宽100,高100,那么,现在这张
        灰度图片中有10000个像素点，它每一个像素点在内存空间所占的空间大小是8bite,8位--所以它对
        应的就是CV_8
     2--S|U|F--S--代表---signed int---有符号整形
               U--代表--unsigned int--无符号整形
               F--代表--float---------单精度浮点型
     3--C<number_of_channels>----代表---一张图片的通道数,比如:
         1--灰度图片--grayImg---是--单通道图像
         2--RGB彩色图像---------是--3通道图像
         3--带Alph通道的RGB图像--是--4通道图像

OpenCv的矩阵类型源代码解释:

//【1】CV_8UC1---则可以创建----8位无符号的单通道---灰度图片------grayImg
#define CV_8UC1 CV_MAKETYPE(CV_8U,1)
#define CV_8UC2 CV_MAKETYPE(CV_8U,2)
//【2】CV_8UC3---则可以创建----8位无符号的三通道---RGB彩色图像---colorImg 
#define CV_8UC3 CV_MAKETYPE(CV_8U,3)
//【3】CV_8UC4--则可以创建-----8位无符号的四通道---带透明色的RGB图像 
#define CV_8UC4 CV_MAKETYPE(CV_8U,4)

2.2 Mat的基本计算
1.初始化

Mat I(img,Rect(10,10,100,100));//用一块地方初始化。
Mat I=img(Range:all(),Range(1,3));//所有行，1~3列
Mat I=img.clone();//完全复制
img.copyTo(I);//传递矩阵头
Mat I(2,2,CV_8UC3,Scalar(0,0,255));//I=[0,0,255,0,0,255;0,0,255,0,0,255];
Mat E=Mat::eye(4,4,CV_64F);//对角矩阵
Mat O=Mat::ones(2,2,CV_32F);//全一矩阵
Mat Z=Mat::zeros(3,3,CV_8UC1);//全零矩阵
Mat C=(Mat_(2,2)<<0,-1,2,3);//如果是简单矩阵的初始化
Mat::row(i);Mat::row(j);Mat::rowRange(start,end);Mat::colRange(start,end);都只是创建个头
Mat::diag(int d);d=0是是主对角线，d=1是比主低的对角线,d=-1....
static Mat Mat::diag(const Mat& matD)
Mat::setTo(Scalar &s);以s初始化矩阵
Mat::push_back(Mat);在原来的Mat的最后一行后再加几行
Mat::pop_back(size_t nelems=1);//移出最下面几行
    b=a.clone();

2.运算符

//注意Mat的行列号是从0开始的
	//定义矩阵a,b,c
 	Mat a,b,c; 
	//生成三行四列的全一矩阵 CV_64F表示精度
 	a=Mat::ones(3,4,CV_64F);
	//a=mat::zeros(3,4,CV_64F);为生成全0
	//把矩阵a复制给矩阵b  注意不能用b=a
 	b=a.clone();
	//矩阵a每一个元素乘以2
	a=a.mul(2);
	//矩阵b每一个元素乘以4
 	b=b.mul(4);
	//矩阵a点乘矩阵b
 	c=a.mul(b);
   	cout<<"a"<<a<<endl;
   	cout<<"b"<<b<<endl;
   	cout<<"c"<<c<<endl;

在这里插入图片描述

//常用的矩阵运算
 	Mat d,e,f,g;
	//带权重的矩阵加法  d=a*1+b*1+4,4为常数，1,1,4均可以改变值
 	addWeighted(a,1,b,1,4,d);
	//矩阵a除以a，结果为e
 	divide(d,a,e);
	//常数6除以矩阵e中的每一个元素，结果为f
 	divide(6,e,f);
	//常数2加矩阵f的每一个元素，结果为g，其中2可以为矩阵
 	add(2,f,g);
	cout<<"d"<<d<<endl;
	cout<<"e"<<e<<endl;
	cout<<"f"<<f<<endl;
 	cout<<"g"<<g<<endl;

在这里插入图片描述
3.Mat类成员函数
//更改矩阵的行数。

Mat::resize
//更改矩阵的行数。

C++: void Mat::resize(size_t sz)

C++: void Mat::resize(size_t sz, const Scalar& s)

//参数

//sz –新的行数。

//s –分配给新添加的元素的值。

//该方法更改矩阵的行数。如果矩阵重新分配，第一最少(Mat::rows，sz) 行数
//要保留下来。该方法模拟相应的 STL 向量类的方法

//保留一定数量的行的空间。

C++: void Mat::reserve(size_t sz)

//参数

//sz –的行数。

//该方法sz行存储空间。如果矩阵已经有足够的空间来存储sz行，没有任何异常
//发生。如果矩阵重新分配，保留前（Mat::rows） 行。该方法模拟了相应的
//STL 向量类的方法。

//将元素添加到矩阵的底部

C++: template<typename T> voidMat::push_back(const T& elem)

C++: void Mat::push_back(const Mat& elem)

//参数

//elem –增加的一个或多个元素。

//该方法将一个或多个元素添加到矩阵的底部。他们是模拟相应的 STL 向量类的
//方法。元素为Mat时，其类型和列的数目必须和矩阵容器是相同的。

//从底部的列表中删除元素

C++: template<typename T> voidMat::pop_back(size_t nelems=1)

//参数

//nelems –删除的行的数目。如果它大于总的行数，则会引发异常。

//该方法从底部的列表中删除一行或多行。

//提取矩形子阵
C++: Mat Mat::operator()(Range rowRange, RangecolRange) const

C++: Mat Mat::operator()(const Rect& roi) const

C++: Mat Mat::operator()(const Ranges* ranges) const

//参数：

//rowRange –提取的子阵的开始和结束的行。不包括的上限。若要选择的所有
//行，请使用 Range::all()。

//colRange –提取的子阵的开始和结束的列。不包括的上限。若要选择的所有
//列，请使用 Range::all()。

//roi – 抽出子阵 specified 作为一个矩形。

//ranges – 选定范围沿每个数组维度的数组。

//该运算符为*this的子数组创建新的头。他们是Mat::row()、 Mat::col()、 //Mat::rowRange()，和Mat::colRange()最普遍的形式。例如，A(Range(0, 10),Range::all()) 是相当于A.rowRange(0, 10)。与上述所有操作相同，该操
//作运算符是复杂度为O(1)的操作，就是没有矩阵数据将被复制。
//矩阵第二行到第三行
	h = M4.rowRange(1, 3);
	//取矩阵第二行，行数和列数从0开始
	I = M4.row(1);

Mat::size
//返回一个矩阵大小。

C++: Size Mat::size() const

//该方法返回一个矩阵大小：Size(cols, rows)。矩阵超过 2 维时返回大小为（-1，-1）。

Mat::empty
//如果数组有没有 elemens，则返回 true。

C++: bool Mat::empty() const

//如果 Mat::total() 是 0 或 Mat::data 为 NULL，则方法返回 true。
//因为pop_back() 和 resize()方法M.total()= = 0，并不意味着M.data = =NULL。

指针

Mat::ptr
//返回指定矩阵行的指针。

C++: uchar* Mat::ptr(int i=0)

C++: const uchar* Mat::ptr(int i=0) const

C++: template<typename _Tp> _Tp* Mat::ptr(inti=0)

C++: template<typename _Tp> const _Tp*Mat::ptr(int i=0) const

//参数：

//i –一个基于0的行索引。

//该方法返回uchar*，或指向由输入指定矩阵行的指针。参看Mat::isContinuous()的中示例了解如何使用这些方法。

At访问Mat矩阵

Mat::at
返回对指定数组元素的引用。

C++: template<typename T> T& Mat::at(int i)const

C++: template<typename T> const T&Mat::at(int i) const

C++: template<typename T> T& Mat::at(int i,int j)

C++: template<typename T> const T&Mat::at(int i, int j) const

C++: template<typename T> T& Mat::at(Pointpt)

C++: template<typename T> const T&Mat::at(Point pt) const

C++: template<typename T> T& Mat::at(int i,int j, int k)

C++: template<typename T> const T&Mat::at(int i, int j, int k) const

C++: template<typename T> T& Mat::at(constint* idx)

C++: template<typename T> const T&Mat::at(const int* idx) const

//参数

//i –索引 0 维度

//j – 1 维度的索引

//k – 沿 2 维度的索引

//pt – Point(j,i) 作为指定元素的位置。

//idx – Mat::dims 数组的索引。

//该模板方法返回指定数组元素的引用。为了具有更高的性能，索引范围检查只
//在调试配置下执行。请注意使用具有单个索引 (i) 的变量可以访问的单行或单
//列的2 维的数组元素。也就是比方说，如果A是1 x N 浮点矩阵和B是M x 1的
//整数矩阵，您只需编写A.at<float>(k+4) 和 B.at<int>(2*i+1) 分别代替A.at<float>(0,k+4)和

B.at<int>(2*i+1,0)。

//下面的示例将初始化希尔伯特矩阵：

Mat H(100, 100, CV_64F);

for(inti= 0; i<H.rows; i++)

for(intj= 0; j<H.cols; j++)

H.at<double>(i,j)=1./(i+j+1);

迭代器

Mat::begin
//返回矩阵迭代器，并将其设置为第一矩阵元。

C++: template<typename _Tp>MatIterator_<_Tp> Mat::begin()

C++: template<typename _Tp>MatConstIterator_<_Tp> Mat::begin() const

//该方法返回矩阵的只读或读写的迭代器。矩阵迭代器的使用和双向 STL 迭代器
//的使用是非常相似的。在下面的示例中，alpha融合函数是使用矩阵迭代器重写：

template<typename T>

void alphaBlendRGBA(const Mat& src1,const Mat& src2, Mat& dst)

{
typedef Vec<T, 4> VT;

const float alpha_scale =(float)std::numeric_limits<T>::max(),

inv_scale = 1.f/alpha_scale;

CV_Assert( src1.type() == src2.type()&&

src1.type() == DataType<VT>::type&&

src1.size() == src2.size());

Size size = src1.size();

dst.create(size, src1.type());

MatConstIterator_<VT> it1 =src1.begin<VT>(), it1_end = src1.end<VT>();

MatConstIterator_<VT> it2 =src2.begin<VT>();

MatIterator_<VT> dst_it =dst.begin<VT>();

for( ; it1 != it1_end; ++it1, ++it2,++dst_it )

{
VT pix1 = *it1, pix2 = *it2;

float alpha = pix1[3]*inv_scale, beta =pix2[3]*inv_scale;

*dst_it =VT(saturate_cast<T>(pix1[0]*alpha + pix2[0]*beta),

saturate_cast<T>(pix1[1]*alpha + pix2[1]*beta),

saturate_cast<T>(pix1[2]*alpha +pix2[2]*beta),

saturate_cast<T>((1 -(1-alpha)*(1-beta))*alpha_scale));

}

}

Mat::end
//返回矩阵迭代器，并将其设置为 最后元素之后（after-last）的矩阵元。

C++: template<typename _Tp>MatIterator_<_Tp> Mat::end()

C++: template<typename _Tp>MatConstIterator_<_Tp> Mat::end() const

//该方法返回矩阵只读或读写的迭代器，设置为紧随最后一个矩阵元素的点。
Tu1603_3LiWen
关注
专栏目录
opencv学习笔记.docx
08-09
OpenCV 学习笔记 本文档为 OpenCV 学习笔记，涵盖了 OpenCV 库的基本使用和图像处理技术。文档分为两章，第一章介绍了图像的载入、保存和旋转操作，第二章详细介绍了图像的遍历和处理。 第一章：图像载入、保存和...
Opencv常见数据类型（二）
sunshineking9的博客
08-10 2129
一.cv::Scalar类 1.基本概念 在介绍cv::Scalar类之前，我们先看cv::Scalar_类在Opencv中的定义，如下： template<typename _Tp> class Scalar_ : public Vec<_Tp, 4> { public: // default constructor Scalar_()//参数数量 0 Scalar_(_Tp v0, _Tp v1, _Tp v2=0, _Tp v3=0);//参数数
opencv之CvScalar
fu6543210的博客
04-13 2695
CvScalar就是一个可以用来存放4个double数值的数组(O'Reilly的书上写的是4个整型成员）；一般用来存放像素值（不一定是灰度值哦）的，最多可以存放4个通道的。 typedef struct CvScalar { 　　double val[4]; 　　}CvScalar;赋值/CvScalar 编辑 1. inline CvScalar cvScalar( double val0...
我看到的关于CvScalar数据结构的经…
rxm1989的专栏
09-25 488
本文转自：http://fzzl.is-programmer.com/posts/10332.html CvPoint,CvScalar,CvArr数据结构的功能最主要是配置IplImage数据结构跟相关矩阵数据的结构数据,只要是图像空间有关的配置大部分都用到CvSize,CvScalar. 而CvArr只是个Interface,可以让子程序容纳IplImage数据结构及CvMat数据结构
数组转化成opencv图像并显示
random_repick的专栏
05-25 5824
void arrar2mat(int* data, int width, int height) { cv::Mat src = cv::Mat::zeros(width, height, CV_8UC3); for(int i = 0; i &amp;lt; width; ++i) { for(int j = 0; j &amp;lt; height; ++j) { ...
opencv学习(9):cv::Scalar、cv::Mat::zeros
热门推荐
biter0088的博客
04-20 2万+
1 cv::Scalar cv::Scalar是opencv的一个结构体，其定义如下：（c++中的结构体如下，可以存放1~4个数值。） //! various constructors Scalar_(); Scalar_(_Tp v0, _Tp v1, _Tp v2=0, _Tp v3=0); Scalar_(_Tp v0); 表示图像颜色时，单通道图像用下标[0]即可，三通道图像用下标[0]、[1]、[2]分别表示B、G、R通道 ............
opencv学习笔记.zip
04-17
Opencv现在支持与计算机视觉和机器学习有关的多种算法，并且正在日益扩展。 Opencv支持多种编程语言，例如C++, Python, Java等，并且可以再Windows , Linux , OS X , Android和IOS等不同平台上使用。基于CUDA和...
opencv学习笔记_opencv_
10-01
在本"opencv学习笔记"中，我们将深入探讨OpenCV的核心概念、功能以及如何使用C++进行编程。 一、OpenCV基础 OpenCV最初由Intel公司开发，现在由它自己的非营利组织OpenCV.org维护。它的主要目标是提供高效和灵活的...
OPENCV学习笔记一：图像基本操作
01-20
标题学习opencv第一天： 一、图像基本操作： 1.图像读取：cv.imread(“文件位置：D:/python/picture.png” ) 函数功能：从文件路径中读取图片文件并显示出来，可读取的文件类型有JPG、JPEG、PNG、Webp等 函数原型：...
OpenCV里面Mat方法中的Scalar详解
Luckily118的专栏
06-15 3533
OpenCV参考手册2.3.1中第15页，有这么一个例子： // make a 7x7 complex matrix filled with 1+3j. Mat M(7,7,CV_32FC2,Scalar(1,3)); 解释如下：创建一个M矩阵，7行7列，类型为CV_32F，C2表示有2个通道。Scalar(1,3)是对矩阵进行初始化赋值。第一个通道全为1，第2个通道全为3。具体见一
OpenCV中基本数据结构(2)_Scalar
weixin_42730667的博客
01-28 545
Scalar是一个固定的四维大小的vector,一般是主要用于表示颜色RGBA各个颜色的值，其数据精度为double类型，Scalar类其实是Vec类的一个派生类，是只有1行4列的矩阵，对Vec不清楚的可以了解下https://blog.csdn.net/weixin_42730667/article/details/104121969 Scalar定义 Scalar定义如下： 其实...
opencv之cvScalar函数
Abner的博客
12-26 5095
CvScalar有一个单独的成员val，它是一个指向4个双精度浮点数数组的指针。函数cvScalar（首字母不大写，这是c而不是c++）是一个特殊的函数：它有3个构造函数。 （1）第一个是cvScalar函数，它需要一个、两个、三个或者四个参数并将这些参数传递给数组val[]中的相应元素。 （2）第二个构造函数是cvRealScalar(), 它需要一个参数，它被传递给val[0]，而val[]
详解CvScalar类型
李丽的博客
11-23 1万+
CvScalar类型 :         它包括四个整型成员，当内存不是问题的时候，CvScalar经常用来代替1，2或者3个实数成员（这种情况下，不需要的分量被忽略掉），CvScalar有一个单独的成员val，val是一个指针，它指向一个4个双精度浮点数数组。 CvScalar就是一个可以用来存放4个double数值的数组，一般用来存放像素值（不一定是灰度值哦）最多可以存放四个通道。type
【opencv11】cv::Scalar：四维点类
yuanCruise
12-22 1269
Scalar是一个四维点类。虽然可以通过模板类实现各类型的点，但不管是哪一种类型，其返回值都是双精度浮点型数据。 下表是一些Scalar类直接支持的才操作。 操作 例子 默认构造方法 cv::Scalar s; 拷贝构造方法 cv::Scalar s2( s1 ); 带初始化值的构造方法 cv::Scalar s( x0, x1, x2,x3 ); Elementwis...
对话 OpenCV 之父 Gary Bradski：灾难性遗忘和持续学习是尚未解决的两大挑战 | Open AGI Forum
GOSIM2023的博客
11-15 830
甚至在旅行中，比如我们没有查清火车票是去哪的，我太太会问我们要怎么办，我会说，“不知道啊，可能有人会告诉我们吧，不然就只能被困在车站然后再想办法解决。我可以想到一些可能的解释，比如在生物的发育过程中，我们经历了不同的阶段，在某些阶段你能学到特定的知识，随后这些知识就变得固定了。此外，人类还会建模世界的因果关系，换句话说，即“世界的物理法则”。OpenCV 发展起来时，市场上已经有其他的图像库了，但它们采用的是复杂的 C++结构，我只想通过简单的函数来完成特定的功能，这样开发出来的工具很简单。
opencv调用扩展库SIFT算法
新兴IT民工的专栏
11-15 878
最近有个图像处理的任务，是要提取图像中的特征点。在OPENCV库中，提供了很多的特征提取库，一些基础的算法在feature2d库中就有，但是有些算法在这个核心库中没有，需要在扩展库xfeatrue2d中才有，比如我需要用的SIFT。这一篇先不说SIFT的原理，说说如何用上opencv中的这个SIFT。
基于OpenCV的图片人脸检测研究
最新发布
一只老虎的专栏
11-15 685
人脸检测是计算机视觉中的一个重要研究方向，广泛应用于身份识别、安全监控、社交媒体等领域。本文介绍了使用 OpenCV 实现图片人脸检测的方法，分析了代码的具体实现过程，并探讨了 OpenCV 基于 Haar 特征的人脸检测技术的优势和局限性。
opencv调整图片对比度和亮度
weixin_44313745的博客
11-15 144
【代码】opencv调整图片对比度和亮度。
opencv学习笔记
06-25
OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉库，它提供了大量的图像处理和计算机视觉功能，常用于机器学习、机器人技术、视频分析等领域。学习OpenCV的笔记可能会包括以下几个部分： 1. **安装与配置**：如何在不同的操作系统（如Windows、Linux或macOS）上安装OpenCV库，以及与Python或其他语言的集成。 2. **基本概念**：介绍像素、图像类型、通道等基本概念，以及OpenCV的数据结构（如Mat或Image）。 3. **图像读写**：使用OpenCV读取和保存图片、视频文件的函数。 4. **图像处理**：基础操作如图像缩放、旋转、裁剪、滤波器（如高斯滤波、边缘检测）。 5. **特征检测与描述**：SIFT、SURF、ORB等特征点检测算法，以及描述子的计算。 6. **物体识别与分类**：使用Haar级联分类器进行物体检测，以及深度学习方法（如SSD、YOLO）的应用。 7. **机器学习应用**：比如人脸识别、行人检测、车牌识别等领域的案例。 8. **计算机视觉算法**：例如图像分割、光流估计、立体视觉等高级技术。 9. **实践项目**：提供一些实战项目，帮助巩固理论知识，并提升实际操作能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值