1.Complex：这个是复数类，跟我们数学上学到的复数是一样的。

2.Point_：表示的是二维点，包括两个坐标坐标值，也包括最常见的点的相关操作。

3.Point3_：表示三维点，包括三个坐标值：

4.Size_：表示图像或矩形大小。包括两个成员变量：width和height，表示图像或者矩阵的大小。

5.Rect_：这个用于描述二维矩形，主要有两个部分的参数：

（1）图像矩阵的左上角坐标。

（2）图像矩阵的宽度和高度。

6.RotatedRect：带有旋转角度的矩形。主要有三个部分的参数：

（1）矩形的中心坐标。

（2）矩形长宽。

（3）图像旋转角度。

7.Range：表示图像的连续子序列。

8.Scalar_：常用于定义像素值。

9.KeyPoint：用于角点检测。

10.DMatch：用于查询描述符索引、列车描述符索引、列车图像索引和描述符之间的距离。

11.TermCriteria：定义迭代算法终止条件的类。我们可以使用默认构造函数初始化它，然后重写任何参数，或者可以使用构造函数的高级变量完全初始化结构。

2、Point_

然后，我们又详细讲解了Point_类，讲了它的基本定义和常见用法。

Point_类有两个成员变量：

    _Tp x; //!< x coordinate of the point
    _Tp y; //!< y coordinate of the point

有多个构造函数：

    //! default constructor
    Point_();
    Point_(_Tp _x, _Tp _y);
    Point_(const Point_& pt);
    Point_(Point_&& pt) CV_NOEXCEPT;
    Point_(const Size_<_Tp>& sz);
    Point_(const Vec<_Tp, 2>& v);

还有很多常用操作，因为内容比较多，就不再在这里说明啦！大家可以打开上一篇博客去详细查看哦：

Point_类常用方法

3、Size_

然后，我们又详细讲解了Size_类，讲了它的基本定义和常见用法。

Size_类也有两个成员变量：

    _Tp width; //!< the width
    _Tp height; //!< the height

有多个构造函数：

    //! default constructor
    Size_();
    Size_(_Tp _width, _Tp _height);
    Size_(const Size_& sz);
    Size_(Size_&& sz) CV_NOEXCEPT;
    Size_(const Point_<_Tp>& pt);

还有很多常用操作，因为内容比较多，就不再在这里说明啦！大家可以打开上一篇博客去详细查看哦：

Size_类常用方法

接下来让我们进入一个新的结构。

三、Rect_

除了上面两个最基本的就是Rect_了，我们怎么理解Rect_呢？

一个明确位置且横平竖直的矩形。

比如下面这几个：

一般来说，我们构建这个矩形，可以通过如下方法：

1.一个定位点，矩形的长和宽；

2.两个定位点（要求分别为对角线）；

这是我们最基本的理解方式，了解了这些，就让我们从定义出发，一步一步来了解它吧！

1、定义

跟上一次一样，我们先从定义入手，对它有个最基本的认识：

template<typename _Tp> class Rect_
{
public:
    typedef _Tp value_type;

    //! default constructor
    Rect_();
    Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);
    Rect_(const Rect_& r);
    Rect_(Rect_&& r) CV_NOEXCEPT;
    Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz);
    Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2);

    Rect_& operator = ( const Rect_& r );
    Rect_& operator = ( Rect_&& r ) CV_NOEXCEPT;
    //! the top-left corner
    Point_<_Tp> tl() const;
    //! the bottom-right corner
    Point_<_Tp> br() const;

    //! size (width, height) of the rectangle
    Size_<_Tp> size() const;
    //! area (width*height) of the rectangle
    _Tp area() const;
    //! true if empty
    bool empty() const;

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

    //! checks whether the rectangle contains the point
    bool contains(const Point_<_Tp>& pt) const;

    _Tp x; //!< x coordinate of the top-left corner
    _Tp y; //!< y coordinate of the top-left corner
    _Tp width; //!< width of the rectangle
    _Tp height; //!< height of the rectangle
};

typedef Rect_<int> Rect2i;
typedef Rect_<float> Rect2f;
typedef Rect_<double> Rect2d;
typedef Rect2i Rect;

template<typename _Tp> class DataType< Rect_<_Tp> >
{
public:
    typedef Rect_<_Tp>                               value_type;
    typedef Rect_<typename DataType<_Tp>::work_type> work_type;
    typedef _Tp                                      channel_type;

    enum { generic_type = 0,
           channels     = 4,
           fmt          = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
           ,depth        = DataType<channel_type>::depth
           ,type         = CV_MAKETYPE(depth, channels)
#endif
         };

    typedef Vec<channel_type, channels> vec_type;
};

namespace traits {
template<typename _Tp>
struct Depth< Rect_<_Tp> > { enum { value = Depth<_Tp>::value }; };
template<typename _Tp>
struct Type< Rect_<_Tp> > { enum { value = CV_MAKETYPE(Depth<_Tp>::value, 4) }; };
} // namespace

这里面最基本的定义主要包括如下三部分：

1.构造函数

几个构造函数，用于生成Rect对象：

    //! default constructor
    Rect_();
    Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);
    Rect_(const Rect_& r);
    Rect_(Rect_&& r) CV_NOEXCEPT;
    Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz);
    Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2);

对于第一个构造函数，可以创建一个空的矩形，左上角顶点坐标为（0,0），矩形的长宽均为0。一般这种无参构造函数都是创建空的对象，值的初始化要么为空，要么为0。

我们上面说到，想要构造一个矩形，可以有两种方式：

第一种方式是使用一个点的坐标和长宽。

（1）对于这种方式，我们既可以给四个参数：横坐标、纵坐标、长、宽：

    Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);

（2）也可以使用我们昨天提到的两个类型：Point_和Size_。

    Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz);

第二种方式是使用两个对角线顶点：

    Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2);

除了上面的两种方法，我们还有一种方法就是使用另外的矩形为该矩形赋值：

    Rect_(const Rect_& r);
    Rect_(Rect_&& r) CV_NOEXCEPT;

2.基本操作

在定义中，还有如下基本操作：

    Rect_& operator = ( const Rect_& r );
    Rect_& operator = ( Rect_&& r ) CV_NOEXCEPT;
    //! the top-left corner
    Point_<_Tp> tl() const;
    //! the bottom-right corner
    Point_<_Tp> br() const;

    //! size (width, height) of the rectangle
    Size_<_Tp> size() const;
    //! area (width*height) of the rectangle
    _Tp area() const;
    //! true if empty
    bool empty() const;

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

    //! checks whether the rectangle contains the point
    bool contains(const Point_<_Tp>& pt) const;

我们分类说明一下，方便大家理解：

第一类，基本赋值操作：

    Rect_& operator = ( const Rect_& r );
    Rect_& operator = ( Rect_&& r ) CV_NOEXCEPT;

这个跟上面讲到的使用别的矩形为矩形赋值的功能是一致的；

第二类，求顶点，获取矩形的左上角顶点和右下角顶点的坐标：

    //! the top-left corner
    Point_<_Tp> tl() const;
    //! the bottom-right corner
    Point_<_Tp> br() const;

第三类，长宽系列，包括获取长宽，利用长宽求面积，利用长宽判断是否为空：

    //! size (width, height) of the rectangle
    Size_<_Tp> size() const;
    //! area (width*height) of the rectangle
    _Tp area() const;
    //! true if empty
    bool empty() const;

第四类，转化为其他类型：

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

第五类，判断矩形是否包含某点，跟在点中的函数是一个含义：

    //! checks whether the rectangle contains the point
    bool contains(const Point_<_Tp>& pt) const;

3.成员变量

四个类体成员变量，包括横纵坐标，还有矩形的长和宽：

    _Tp x; //!< x coordinate of the top-left corner
    _Tp y; //!< y coordinate of the top-left corner
    _Tp width; //!< width of the rectangle
    _Tp height; //!< height of the rectangle

4.使用时的数据类型

当我们定义了Rect_类之后，跟上面一样，我们要定义具体的使用过程中的类型：

typedef Point_<int> Point2i;
typedef Point_<int64> Point2l;
typedef Point_<float> Point2f;
typedef Point_<double> Point2d;
typedef Point2i Point;

2、常用方法

接下来我们要说的就是方法，这里有很多实现了上面的类定义时的方法，我们在上面也具体讲解了，在这里我们讲一下具体的实战。

1.定义中的方法

定义中的方法包括构造函数和几个常用方法，构造函数如下：

template<typename _Tp> inline
Rect_<_Tp>::Rect_()
    : x(0), y(0), width(0), height(0) {}

template<typename _Tp> inline
Rect_<_Tp>::Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height)
    : x(_x), y(_y), width(_width), height(_height) {}

template<typename _Tp> inline
Rect_<_Tp>::Rect_(const Rect_<_Tp>& r)
    : x(r.x), y(r.y), width(r.width), height(r.height) {}

template<typename _Tp> inline
Rect_<_Tp>::Rect_(Rect_<_Tp>&& r) CV_NOEXCEPT
    : x(std::move(r.x)), y(std::move(r.y)), width(std::move(r.width)), height(std::move(r.height)) {}

template<typename _Tp> inline
Rect_<_Tp>::Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz)
    : x(org.x), y(org.y), width(sz.width), height(sz.height) {}

template<typename _Tp> inline
Rect_<_Tp>::Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2)
{
    x = std::min(pt1.x, pt2.x);
    y = std::min(pt1.y, pt2.y);
    width = std::max(pt1.x, pt2.x) - x;
    height = std::max(pt1.y, pt2.y) - y;
}

常用方法如下：

template<typename _Tp> inline
Point_<_Tp> Rect_<_Tp>::tl() const
{
    return Point_<_Tp>(x,y);
}

template<typename _Tp> inline
Point_<_Tp> Rect_<_Tp>::br() const
{
    return Point_<_Tp>(x + width, y + height);
}

template<typename _Tp> inline
Size_<_Tp> Rect_<_Tp>::size() const
{
    return Size_<_Tp>(width, height);
}

template<typename _Tp> inline
_Tp Rect_<_Tp>::area() const
{
    const _Tp result = width * height;
    CV_DbgAssert(!std::numeric_limits<_Tp>::is_integer
        || width == 0 || result / width == height); // make sure the result fits in the return value
    return result;
}

template<typename _Tp> inline
bool Rect_<_Tp>::empty() const
{
    return width <= 0 || height <= 0;
}

template<typename _Tp> template<typename _Tp2> inline
Rect_<_Tp>::operator Rect_<_Tp2>() const
{
    return Rect_<_Tp2>(saturate_cast<_Tp2>(x), saturate_cast<_Tp2>(y), saturate_cast<_Tp2>(width), saturate_cast<_Tp2>(height));
}

template<typename _Tp> inline
bool Rect_<_Tp>::contains(const Point_<_Tp>& pt) const
{
    return x <= pt.x && pt.x < x + width && y <= pt.y && pt.y < y + height;
}

我们使用构造函数创建几个矩形：

	Rect r1 = Rect();
	Rect r2 = Rect(1, 2, 3, 4);
	Rect r3 = Rect(Point(5, 5), Size(10, 10));
	Rect r4 = Rect(Point(5, 6), Point(10, 10));
	Rect r5 = Rect(r4);

然后我们调用常用方法，查看一下效果：

	cout << "r1 = " << r1 << endl;
	cout << "r2 = " << r2 << endl;
	cout << "r3 = " << r3 << endl;
	cout << "r4 = " << r4 << endl;
	cout << "r5 = " << r5 << endl;
	cout << "【r5 info】" << endl;
	cout << "r5.x = " << r5.x << endl;
	cout << "r5.y = " << r5.y << endl;
	cout << "r5.width = " << r5.width << endl;
	cout << "r5.height = " << r5.height << endl;
	cout << "r5.size = " << r5.size() << endl;
	cout << "r5.area = " << r5.area() << endl;
	cout << "r5.br = " << r5.br() << endl;
	cout << "r5.tl = " << r5.tl() << endl;

	if (r4 == r5) cout << "r4 = r5" << endl;
	else cout << "r4 != r5" << endl;
	if (r5.contains(Point())) cout << "Point" << Point() << " 在 Rect" << r5 << "中！" << endl;
	else cout << "Point" << Point() << " 不在 Rect" << r5 << "中！" << endl;

执行结果如下：

2.常用运算

常用运算包括赋值运算，四则运算等，具体如下：

1.让左上角定位点移位的加赋值与减赋值，及其相关运算：

template<typename _Tp> static inline
Rect_<_Tp>& operator += ( Rect_<_Tp>& a, const Point_<_Tp>& b )
{
    a.x += b.x;
    a.y += b.y;
    return a;
}

template<typename _Tp> static inline
Rect_<_Tp>& operator -= ( Rect_<_Tp>& a, const Point_<_Tp>& b )
{
    a.x -= b.x;
    a.y -= b.y;
    return a;
}

template<typename _Tp> static inline
Rect_<_Tp> operator + (const Rect_<_Tp>& a, const Point_<_Tp>& b)
{
    return Rect_<_Tp>( a.x + b.x, a.y + b.y, a.width, a.height );
}

template<typename _Tp> static inline
Rect_<_Tp> operator - (const Rect_<_Tp>& a, const Point_<_Tp>& b)
{
    return Rect_<_Tp>( a.x - b.x, a.y - b.y, a.width, a.height );
}

2.改变矩形尺寸的加赋值与减赋值，及其相关运算：

template<typename _Tp> static inline
Rect_<_Tp>& operator += ( Rect_<_Tp>& a, const Size_<_Tp>& b )
{
    a.width += b.width;
    a.height += b.height;
    return a;
}

template<typename _Tp> static inline
Rect_<_Tp>& operator -= ( Rect_<_Tp>& a, const Size_<_Tp>& b )
{
    const _Tp width = a.width - b.width;
    const _Tp height = a.height - b.height;
    CV_DbgAssert(width >= 0 && height >= 0);
    a.width = width;
    a.height = height;
    return a;
}

template<typename _Tp> static inline
Rect_<_Tp> operator + (const Rect_<_Tp>& a, const Size_<_Tp>& b)
{
    return Rect_<_Tp>( a.x, a.y, a.width + b.width, a.height + b.height );
}

template<typename _Tp> static inline
Rect_<_Tp> operator - (const Rect_<_Tp>& a, const Size_<_Tp>& b)
{
    const _Tp width = a.width - b.width;
    const _Tp height = a.height - b.height;
    CV_DbgAssert(width >= 0 && height >= 0);
    return Rect_<_Tp>( a.x, a.y, width, height );
}

3.两个矩形的公共矩形，如果没有，就是空：

template<typename _Tp> static inline
Rect_<_Tp>& operator &= ( Rect_<_Tp>& a, const Rect_<_Tp>& b )
{
    _Tp x1 = std::max(a.x, b.x);
    _Tp y1 = std::max(a.y, b.y);
    a.width = std::min(a.x + a.width, b.x + b.width) - x1;
    a.height = std::min(a.y + a.height, b.y + b.height) - y1;
    a.x = x1;
    a.y = y1;
    if( a.width <= 0 || a.height <= 0 )
        a = Rect();
    return a;
}

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

4.两个矩形的最小包围矩形：

template<typename _Tp> static inline
Rect_<_Tp>& operator |= ( Rect_<_Tp>& a, const Rect_<_Tp>& b )
{
    if (a.empty()) {
        a = b;
    }
    else if (!b.empty()) {
        _Tp x1 = std::min(a.x, b.x);
        _Tp y1 = std::min(a.y, b.y);
        a.width = std::max(a.x + a.width, b.x + b.width) - x1;
        a.height = std::max(a.y + a.height, b.y + b.height) - y1;
        a.x = x1;
        a.y = y1;
    }
    return a;
}

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

5.判断两个矩形是否相等：

template<typename _Tp> static inline
bool operator == (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
{
    return a.x == b.x && a.y == b.y && a.width == b.width && a.height == b.height;
}

template<typename _Tp> static inline
bool operator != (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
{
    return a.x != b.x || a.y != b.y || a.width != b.width || a.height != b.height;
}

比较简单，我们就通过代码实战来巩固一下吧！

3、代码实战

接下来我们走进实战，为我们以后的使用打好基础吧。

	Rect rect1 = Rect(Point(5, 5), Point(15, 15));
	Rect rect2 = Rect(Point(7, 7), Point(20, 20));
	Point point1 = Point(3, 3);
	Size size1 = Size(4, 4);

	rect1 += point1;
	cout << "rect1 += point1 =  " << rect1 << endl;
	rect1 = rect1 - point1;
	cout << "rect1 - point1  =  " << rect1 << endl;

	rect2 += size1;
	cout << "rect2 += size1  =  " << rect2 << endl;
	rect2 = rect2 - size1;
	cout << "rect2 - size1   =  " << rect2 << endl;
	 
	cout << "rect1 & rect2   =  " << (rect1 & rect2) << endl;
	cout << "rect1 | rect2   =  " << (rect1 | rect2) << endl;