当前位置:   article > 正文

opencv中Vec类的小白向介绍_opencv vec

opencv vec

大纲

  1. 前置知识:C++中类(class)的相关知识
  2. 前置知识:C++中模板(template)的相关知识
  3. opencv中Vec类的定义及源码
  4. 引申:opencv中的宏定义如CV_8UC3

一、C++中的类
“类”是对对象的抽象,C++中的类实际上就是对一类具有相同特性的对象的交集,类相当于一种新的数据类型,数据类型不占用存储空间,用类型定义一个实体的时候,才会为它分配存储空间。
1.类的定义如下:

class 类名
{
成员类表
};

成员列表是类成员的集合,成员可以无限多,也可以没有;可以是数据,也可以是函数,成员函数如普通函数一样可以进行重载或者带默认参数。如果类成员中有函数的话,有以下两种定义方式:

在类内部定义函数体
class 类名
{
返回类型 函数名(形参列表)
{
函数体
} };
在类外部定义函数体
class 类名
{
返回类型 函数名(形参列表);
};
返回类型 类名 :: 函数名(形参列表)
{
函数体
}

前一种定义方式相当于内联函数,调用速度快,但是会占用额外的内存,后一种方式则为普通的外部函数,建议使用第二种方式定义。
如果使用后一种方式定义的话,需要注意C++中设置默认形参的动作之只能有一次,在类中声明时设置了默认参数,外部定义时就不能再重复设置。

class Test
{
public:
    void Sum(int a=0,int b=0);
};
void Test::Sum(int a,int b)
//void Test::Sum(int a=0,int b=0)  错误
{
    cout<<a+b;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

2.类成员的访问控制
类的每个成员都有着自己的访问属性,包括“public"、”private"、"protected
“public"通常包含成员函数、”private“通常包括一般的变量。对于外部用户像是全局函数、另一个类的成员函数,只能通过"public"来访问类的成员。如:

#include <iostream>

using namespace std;

class Test
{
public:
	Test() {}
	Test(int x, int y) :a(x), b(y) {}
	void Sum();
private:
	int a, b;
	void minus()
};

void Test::Sum()
{
	cout << a + b;
}
void Test::minus()
{
	cout << b - a;
}
int main()
{
	Test test2(3, 4);
	test2.Sum();  //可以运行
	cout << test2.a;   //无法访问
	test2.minus()   //无法访问
	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

从而类的定义扩展为:

class 类名
{
public:
公有的数据成员和成员函数
protected:
保护的数据成员和成员函数
private:
私有的数据成员和成员函数
};

3.类成员的初始化
建立一个类的对象时,需要对对象进行初始化,因为在类里面是不能对成员进行进行初始化的(类是数据类型,不占用存储空间),初始化的过程通过构造函数来实现。构造函数是一个没有返回值、和类同名的成员函数,由于创建对象通常是在外部进行的,所以构造函数申明为”public",例下:

#include <iostream>
 
using namespace std;
 
class Test
{
public:
    Test ();
    Test (int x,int y);
    void Sum();
private:
    int a,b;
};
Test::Test()
{
 
}
Test::Test(int x,int y)
{
    a=x;
    b=y;
}
void Test::Sum()
{
    cout<<a+b;
}
int main()
{
    Test test(3,4);
    test.Sum();
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

第一个“Test()“为默认构造函数也叫无参构造函数,它没有形参,可以在后续过程中赋值而不需要立即初始化。使用方法即:

TEST test
  • 1

如果类中没有默认构造函数的话会报错,但IDE通常情况下会自动生成默认构造函数(实际上是4种特定情况,参见:自动生成默认构造函数情况),但如果自己定义了一个有参的构造函数就如“TEST (int x int y)",那IDE就不会自动再生成。也就是说,如果类中无默认构造函数,也可以通过”TEST test“初始化,一旦类中只存在有参构造函数,就必须带参初始化。、

构造函数初始化列表
之前介绍的构造函数是利用函数体内赋值的方式完成初始化,但更常用的一种方法其实是构造函数初始化列表,如:

#include <iostream>
 
using namespace std;
 
class Test
{
public:
    Test ();
    Test (int x,int y);
    void Sum();
private:
    int a,b;
};
Test::Test()
{
 
}
Test::Test(int x,int y):a(x),b(y)  //构造初始化列表而非赋值
{
 
}
void Test::Sum()
{
    cout<<a+b;
}
int main()
{
    Test test(3,4);
    test.Sum();
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

也可以更简洁的表述为:


class Test
{
public:
    Test () {}
    Test (int x,int y):a(x),b(y) {}  //直接在类内部完成定义
    void Sum();
private:
    int a,b;
};
 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

这种方式较函数内赋值一般情况下没有区别,但如果需要初始化的是类类型的成员,就需要使用构建函数初始化列表的方法了。如:

#include <iostream>
 
using namespace std;
 
class Test
{
public:
    Test () {}
    Test (int x,int y):a(x),b(y) {}
    void Sum();
private:
    int a,b;
};
 
void Test::Sum()
{
    cout<<a+b;
}
class AnotherTest
{
public:
    AnotherTest(int i,int j):test(i,j) {test.Sum();}
private:
    Test test;
};
int main()
{
    AnotherTest test(3,4);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

这里Anothertest类中含有一个数据类型为Test的成员,因此需要使用
初始化列表,注意因为在AnotherTest的构造函数里调用了Test类中的Sum成员函数,所以会有输出”7“,如果直接写test.test.Sum()是不会有输出值的,第二个test属于private类型,无法访问。

复制构造函数
复制构造函数顾名思义,通过一个已经存在的对象对另一个对象赋值初始化,常用形式为:

类名 (const 类名& obj)
{
函数体
}

例如:

#include <iostream>
 
using namespace std;
 
class Test
{
public:
    Test () {}
    Test (int x ,int y):a(x),b(y) {}
    Test (const Test& t):a(t.a),b(t.b) {}
    void Sum();
private:
    int a,b;
};
 
void Test::Sum()
{
    cout<<a+b;
}
 
int main()
{
    Test test1(3,4);
    Test test2 = test1;
    test2.Sum();
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

如果不定义复制构造函数,以上对象也可以这样进行初始化,原因就是系统也会自己生成一个复制构造函数。

类的继承
类的继承允许在已有类的基础上建立新类,继承方式,c++提供了三中继承方式。
public(公有继承):基类中的公有和保护成员保持原属性,私有成员为基类私有。
private(私有继承):基类中的所有成员在派生类中都是私有的。
protected(保护继承):基类的公有成员和保护成员在派生类中成了保护成员,私有成员仍为基类私有。
继承的写法如下:

class 子类名:public/ptivate/prtected 父类名
{
成员
}

例矩形对平行四边形的继承:

#include <iostream>
 
using namespace std;
 
class Parallelogram
{
public:
    Parallelogram(int a,int b):length(a),width(b) {}
    int getLength(){return length;}
    int getWidth() {return width;}
private:
    int length,width;
};
class Rectangle : public Parallelogram  //公有继承
{
public:
    Rectangle(int a,int b):Parallelogram(a,b) {}  //先对基类中的数据成员进行初始化
    void Area()     //计算面积
    {
        cout<<getLength()*getWidth();
    }
};
int main()
{
    Rectangle r(3,4);
    r.Area();
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

至此,“类”相关知识介绍完毕。
二、C++中的模板
如果说类是对对象的抽象,那么模板就是对类的抽象,模板相当于具有相同特性的类的交集,它声明了一种类的模板,并且提供了一个或多个的虚拟类型参数,从而给出不同数据类型的同一特性类。

模板的定义
常用形式为:

template<class/typename 虚拟类型1, class/typename 虚拟类型2…>
class 类名
{
成员
}

以下给出了一个适用于float和int型比较的类模板。

template <class numtype> //声明一个模板,虚拟类型名为numtype
class Compare //类模板名为Compare
{
public :
   Compare(numtype a,numtype b)
   {
      x=a;y=b;
   }
   numtype max( )
   {
      return (x>y)?x:y;
   }
   numtype min( )
   {
      return (x<y)?x:y;
   }
private :
   numtype x,y;
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

需要注意这里的成员函数是在类里面定义的,如果是在类外定义的话不能使用一般类成员函数的定义方法

numtype Compare::max( ) {…}

而应该先声明类模板:

template <class numtype>
numtype Compare<numtype>::max( )
{
    return (x>y)?x:y;
}
  • 1
  • 2
  • 3
  • 4
  • 5

模板的初始化
使用模板定义对象时的形式为:
类模板名<实际类型名> 对象名;
类模板名<实际类型名> 对象名(实参表列);
如:Compare<int> cmp; Compare<int> cmp(3,7);
至此,所需“模板”知识介绍完毕。

三、opencv中的 Vec类
opencv中经常使用Vec+数字+字母来定义变量,像是Vec4b,Vec3s,其实这就是一个向量模板类,首先它在任何时刻都是一个一维矩阵(即列向量),其次它的元素数据类型可变。这一模板类是对与Mat类的继承,其源码如下;

//【1】下面是OpenCv中定义---定义---向量模板类----的源代码
//【2】一个拥有非类型模板形参的---类模板-----向量模板类
 template<typename _Tp, int cn> 
 class Vec : public Matx<_Tp, cn, 1>
{
	public:
		typedef _Tp value_type;
		enum { depth = DataDepth<_Tp>::value, channels = cn, 
					type = CV_MAKETYPE(depth, channels) };
					
	//! default constructor
	//【1】向量类的默认构造函数
	Vec();
	//【1】向量类有参构造函数
	Vec(_Tp v0); //!< 1-element vector constructor
	Vec(_Tp v0, _Tp v1); //!< 2-element vector constructor
	Vec(_Tp v0, _Tp v1, _Tp v2); //!< 3-element vector constructor
	Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3); //!< 4-element vector constructor
	Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4); //!< 5-element vector constructor
	Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5); //!< 6-element vector constructor
	Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6); //!< 7-element vector constructor
	Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7); //!< 8-element vector constructor
	Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8); //!< 9-element vector constructor
	Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9); //!< 10-element vector constructor
	explicit Vec(const _Tp* values);  //保证函数显式调用

	Vec(const Vec<_Tp, cn>& v);

	static Vec all(_Tp alpha);

	//! per-element multiplication
	Vec mul(const Vec<_Tp, cn>& v) const;

	//! conjugation (makes sense for complex numbers and quaternions)
	Vec conj() const;

	/*!
	  cross product of the two 3D vectors.

	  For other dimensionalities the exception is raised
	*/
	Vec cross(const Vec& v) const;
	//! convertion to another data type
	template<typename T2> operator Vec<T2, cn>() const;
	//! conversion to 4-element CvScalar.
	operator CvScalar() const;

	/*! element access */
	const _Tp& operator [](int i) const;
	_Tp& operator[](int i);
	const _Tp& operator ()(int i) const;
	_Tp& operator ()(int i);

	Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_AddOp);
	Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_SubOp);
	template<typename _T2> Vec(const Matx<_Tp, cn, 1>& a, _T2 alpha, Matx_ScaleOp);
};	
//【3】用typedef关键字给---向量类模板----template<typename _Tp, int cn> class Vec
	//【1】向量模板类Vec的实例化,并且给相应实例的Vec向量模板类实例---指定新的名字
	//【1】Vec2b--这是一个具体的--类类型---这个类类型实例话的类对象表示如下所示:
	//【1】Vec2b---表示每个Vec2b对象中,可以存储2个char(字符型)数据
	typedef Vec<uchar, 2> Vec2b;//【2】Vec3b---表示每一个Vec3b对象中,可以存储3个char(字符型)数据,比如可以用这样的对象,去存储RGB图像中的一个像素点
	typedef Vec<uchar, 3> Vec3b;
	//【3】Vec4b---表示每一个Vec4b对象中,可以存储4个字符型数据,可以用这样的类对象去存储---4通道RGB+Alpha的图像中的像素点
	typedef Vec<uchar, 4> Vec4b;
             
	//【1】Vec2s---表示这个类的每一个类对象,可以存储2个short int(短整型)的数据
	typedef Vec<short, 2> Vec2s;
	typedef Vec<short, 3> Vec3s;
	typedef Vec<short, 4> Vec4s;

	typedef Vec<ushort, 2> Vec2w;
	typedef Vec<ushort, 3> Vec3w;
	typedef Vec<ushort, 4> Vec4w;

	typedef Vec<int, 2> Vec2i;
	typedef Vec<int, 3> Vec3i;
	typedef Vec<int, 4> Vec4i;
	typedef Vec<int, 6> Vec6i;
	typedef Vec<int, 8> Vec8i;

	typedef Vec<float, 2> Vec2f;
	typedef Vec<float, 3> Vec3f;
	typedef Vec<float, 4> Vec4f;
	typedef Vec<float, 6> Vec6f;

	typedef Vec<double, 2> Vec2d;
	typedef Vec<double, 3> Vec3d;
	typedef Vec<double, 4> Vec4d;
	typedef Vec<double, 6> Vec6d;

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92

至此,opencv中的Vec模板类介绍完毕。

四、Opencv中的宏定义
使用Opencv时常常看到的字母加数字缩写除了Vec模板类,还有就是宏定义了,它经常性的用于Mat的初始化,其具体形式及含义如下:

CV+位深+数据类型缩写+U+通道数目

数据类型缩写有:

S–代表—signed int—有符号整形
U–代表–unsigned int–无符号整形
F–代表–float---------单精度浮点型

其具体含义也就不难理解,CV16UC4就表示16位无符号整型三通道矩阵。
如果我们要使用到Vec类来对使用这种宏定义初始化的Mat赋值时,需要注意Vec类要和宏定义相互对应,像是:

Mat tempImg1(480,640,CV_8UC3);
Vec3b& test = temp.at<Vec3b>(i, j);
  • 1
  • 2

由于此处定义的Mat为8位深3通道,所以对应Vec模板类为可容纳3(3通道
个字符型数据(8位)的Vec3b
再如:

Mat tempImg1(480,640,CV_16UC4);
Vec4w& test = temp.at<Vec4w>(i, j);
  • 1
  • 2

由于此处定义的Mat为16位深4通道,所以对应Vec模板类为可容纳4个(4通道)无符号整型数据(16位)的Vec4w

参考文献:
C++中类的介绍
C++template模板使用方法
OpenCV 中的 Scalar 类、Vec类
详解 c++ 关键字 explicit

声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:【wpsshop博客】
推荐阅读
相关标签
  

闽ICP备14008679号