OpenCV基础数据类型主要分为三类：

• 直接从C 中继承的基本数据类型。int、float等。
• 辅助对象。如垃圾收集指针类，数据切片范围对象(ranges objects)以及抽象的终止条件。
• 例如，大型数组类型cv::Mat。

下表为cv::Point类别支持操作：

cv: : Scalar是四维点类。cv:: Scalar 一些与四元向量相关的特殊成员函数。cv::Scalar类别支持操作：

cv::Size类在实际操作中与 Point 类似，可以和Point类互相转换。两者的主要区别在于Point 类数据成员是x，y，而Size类对应的成员是width和height。Size三个类别的别名分别是cv::Size，cv::Size2i， cv: :Size2f。前两个等价，表示整数类型。下表是cv::Size类别支持操作：

下表为cv::Rect类支持的操作：

cv::RotatedRect 类是OpenCV 中少数底层没有使用模板的C++接口类之一。同时，它是包含一个中心点cv::Point2f 个大小cv: : Size2f和一个角度float 。其浮点类型 (float) 的角度代表图形绕中心点旋转的角度。下表为cv::RotatedRect支持的操作：

cv::Matx<>是轻量级矩阵模块类，最大支持6x6矩阵，在运行时不需要动态分布内存，执行效率更高。固定矩阵类的矩阵名称格式为cv::Matx{1,2,…}{1,2,…}{f,d}，其中数字为1到6中的任何数，尾部的字母f表示float，d表示double。如cv::Matx33f表示3*3的数据类型为float的矩阵，同cv::Matx<3,3,float>。下表为cv::Matx支持的操作：

相比于STL的向量类，模版类cv::Vec<>具有固定的长度，被称为固定向量向量类(FIxed Vector Class)，固定向量类的大小在编译时就已经知道，因此在运行时无需动态的分配内存。固定向量类继承至固定矩阵类，名称格式为cv::vec{2,3,4,6}{b,s,w,I,f,d}，其中b表示uchar，s表示short int，w表示unsigned short，I表示int。下表为cv::Vec支持的操作：

OpenCV的复数类与STL复数类模板complex<> 不一样，但是与之兼容，可以相互转换。它们最大的区别在于成员获取。STL类中，虚部或者实部是通过成员函数real() imag() 获取的，而在OpenCV 中，直接通过成员变量re和im获取。另外，cv::Complexf cv::Complexd分别为单精度和双精度复数的别名。下表为复数类cv::Complex支持的操作：

用于退出算法的停止条件。终止条件的形式要么是达到允许的有限迭代次数(称为COUNT或MAX_ITER) ，要么是某种形式的误差参数(如果接近于如此程度，就可以退出，称为EPS，即epsilon 的简称) 。常见的做法是通过构造函数：TermCriteria(int type, int maxCount, double epsilon) 进行设置。变量type设置为 cv::TermCriteria::COUNT或者cv::TermCriteria::EPS，也可以将两个条件并(使用位运算符:|)在一起。如果终止条件包含cv::TermCriteria::COUNT就是告诉算法在maxCount次迭代之后终止。如果终止条件包含cv::TermCriteria::EPS，就是告诉算法在与算法收敛相关的某些度量降到epsilon以下后终止。

该类用于确定一个连续的整数序列。cv::Range对象有start和end两个元素。一般使用构造函数cv::Range(int start, int end)进行设定，范围包含初始值start，不包含终止值end。如，cv::Range rng(0, 4)包含0，1，2，3，但不包含4。 使用size()函数可以得到该类对象所含的元素数量，上述rng的元素数量为4，即rng.size()等于4。该类使用empty()判断range是否含有元素。cv::Range::all()可以用于获得对象可用范围。

智能指针 (smart pointer) 是C++ 中的类型。这个指针允许我们创建一个对象指针的引用，所有这些引用都会被计数，且其是线程安全的。当引用超出范围，智能指针的引用计数就会减少。一旦所有的引用（指针的实例）消失，这个对象将自动清理（释放）。可以通过类似似cv::Ptr< Matx33f > p(new cv: :Matx33f) 或者 cv::Ptr< Matx33f > p = makePtr< cv::Matx33f() > 的形式实现。以下是其一些成员函数介绍：

• addref()。增加指针内部的引用计数
• release()。减少指针内部的引用计数
• empty()。确定智能指针是否由于一次或多次release()而指向一个已经被释放掉的对象
• delete_obj()。引用计数为零时自动调用的函数

OpenCV使用异常来处理错误。OpenCV定义了自己的异常类型cv::exception，它派生自STL异常类std::exception。实际上，这种异常类型并没有什么特别之处，只是存在于cv::命名空间中，从而与同样派生自std::exception的其他对象区别开来。 类型cv::Exception有成员code、err、func、file和line，它们分别是一个数字错误代码、一个表示生成异常的错误性质的字符串、发生错误的函数的名称、发生错误的文件以及一个表示该文件中发生错误所在的行数。err、func和file都是STL字符串。OpenCV有以下内置宏用于抛出自己的异常：

• CV_Error(errorcode description)。生成并抛出一个有固定文字描述的异常
• CV_Error_(errorcode printf_fmt_str, [printf-args]) 。使用类似printf格式的字符串和参数代替固定的描述
• CV_Assert(condition)。如果条件不符合，则抛出异常
• CV_DbgAssert(condition)。如果条件不符合，则抛出异常，仅在调试版本中运行

DataType<>本身是一个模板，因此传递的实际对象是该模板的特殊化。这是c++的一个特性。以下为DataType定义的模板类的示例：

template<typename _Tp> class DataType
{
    typedef _Tp value_type;
    typedef value_type work_type;
    typedef value_type channel_type;
    typedef value_type vec_type;
    enum 
    {
        generic_type = 1,
        depth = -1,
        channels = 1,
        fmt = 0,
        type = CV_MAKETYPE(depth, channels)
    };
};

float类型定义的cv::DataType<>:

template<> class DataType<float>
{
public:
    typedef float value_type;
    typedef value_type work_type;
    typedef value_type channel_type;
    typedef value_type vec_type;
    enum 
    {
        generic_type = 0, // 在core.hpp中所有类型都是零
        depth = DataDepth<channel_type>::value, // OpenCV使用的数据类型标识符，cv::DataDepth<float>::value解析为常量CV_32F
        channels = 1, // channels为1，因为float仅仅是一个数
        fmt = DataDepth<channel_type>::fmt, // cv::DataDepth<float>::fmt 解析为f
        type = CV_MAKETYPE(depth, channels) // type解析为CV_32FC1
    };
};

关于DataType<>的重要一点是传达更复杂结构的性质。这是必不可少的，例如，允许算法以一种与传入数据类型无关的方式实现(即，使用内省来决定如何处理传入数据的算法)。 cv::Rect实际上是模板的别名，其对应的模板名为cv::Rect_<>。因此，这个模板可以被特殊化为cv::DataType<Rect>或者cv::DataType< Rect_<float> >。对于cv::DataType<Rect>，其所有的元素都是整数，模板形参Tp的所有实例化都会解析为int。以下为cv::Rect<>实例化cv::DataType<>的例子(它本身包含一个尚未特化的类型Tp):

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;
    typedef Vec<channel_type, channels> vec_type;
    enum 
    {
        generic_type = 0,
        depth = DataDepth<channel_type>::value,
        channels = 4,
        fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
        type = CV_MAKETYPE(depth, channels)
    };
};

上述例子中，value_type在编译时用来表示cv::DataType<>的名称(即Rect)。work_type表示cv::DataType<>是由什么类型的数据组成的，如cv::DataType<int>的work_type为int。channel_type为int类型，表示多通道对象。vec_type用来描述如何将它表示成cv::Vec<>类型对象。如cv::DataType<Rect>::vec_type会解析成cv::Vec<int, 4>。 对于运行时常量：generic_type仍然是0，depth是CV_32S，channel是4（因为实际上有4个数，所以这里的channel为4，上述的cv::Vec<>的大小也为4），fmt解析成0x3069（因为i是0x69），type则解析成CV_32SC4。

在OpenCV中，支持cv::Scalar，cv::Vec，cv::Matx以及STL中的std::vector<>这些小的数组了欸行，另外还支持cv::Mat和cvSparseMat这类大型数组类型。OpenCV定义了cv::InputArray，cv::OutputArray，cv::InputOutputArray支持上述数组类型以就简化接口。cv::InputArray是一个const的只读常量，cv::OutputArray是一个可变量引用。当cv::InputArray或cv::OutputArray可传递cv::noArray()以表示其输入或输出为空的数组。

template<T> T* cv::alignPtr( // 返回T*类型的对齐指针
    T* ptr, // 未对齐指针
    int n = sizeof(T) // 对齐到块大小，为2的幂
);

给定任意类型的指针，该函数按照以下计算方法计算同一类型的对齐指针:

(T*)(((size_t)ptr + n + 1) & -n)

size_t cv::alignSize( // 返回大于等于sz且能被n整除的大小
    size_t sz, // 缓冲区大小
    int n = sizeof(T) // 对齐到块大小，为2的幂
);

给定一个数字n(通常是sizeof()的返回值)和一个缓冲区的大小sz, cv::alignSize()计算该缓冲区的大小，以便包含数量大小为n的对象，即大于或等于sz但能被n整除的最小数字。使用以下公式:

(sz + n-1) & -n

template<T> T* cv::allocate( // 返回指向已分配缓冲区的指针
    size_t sz // 缓冲区大小，是sizeof(T)的倍数
);

函数cv::allocate()的作用类似于new的数组形式，它分配了一个c风格的数组，包含n个T类型对象，为每个对象调用默认构造函数，并返回指向数组中第一个对象的指针。

template<T> void cv::deallocate(
    T* ptr, // 需要释放的缓冲区的指针
    size_t sz // 缓冲区的大小，是sizeof(T)的倍数
);

函数cv::deallocate()的作用类似于数组形式的delete，用于释放C风格的数组，包含n个T类型对象，并为每个对象调用析构函数。cv::deallocate()用于释放用cv::allocate()分配的对象。传递给cv::deallocate()的元素数量n必须与cv::allocate()最初分配的对象数量相同。

float cv::fastAtan2( // 返回二维向量角度
    float y, // y
    float x // x
);

这个函数计算(x,y)的arctan值，并返回从原点到指定点的角度。计算结果的范围为[0.0, 360.0)，包括0.0但不包括360.0。

int cvCeil( // 返回大于或等于x的最小整数，int >= x
 float x // 输入32位浮点数
);

给定一个浮点数x, cvCeil()计算不小于x的最小整数。如果输入值在32位整数可表示的范围之外，则结果为未定义的浮点型变量。

float cv::cubeRoot( // 返回32位浮点数
    float x // 输入32位浮点数
);

该函数计算参数x的立方根。若x为负数，则返回结果也为负数。

// example
CV_Assert( x!=0 )

CV_Assert()是一个宏，在运行时计算传递进来的表达式结果，如果该表达式的计算结果为False(或0)，则抛出异常。CV_Assert()宏在任何运行模式下都生效。对于CV_DbgAssert()，则只在调试模式下运行才会生效。

void cv::error(
    const cv::Exception& ex // 抛出的异常
);

这个函数主要是从CV_Error()和CV_Error_()调用的。如果代码是在非调试版本中编译的，则在运行时抛出ex异常。如果代码是在调试版本中编译的，则在运行时引发内存访问违规，使得调试器可以正常访问执行堆栈和所有的参数。 一般情况下我们不直接调用cv::error()，而是依赖于宏CV_Error()和CV_Error_()来为抛出错误异常。这些宏获取我们需要显示的异常信息，并将产生的异常传递给cv::error()。

void cv::fastFree(
    void* ptr // 需要释放的缓冲区的指针
);

该函数用于回收cv::fastMalloc()分配的缓冲区。

void* cv::fastMalloc( // 返回分配的缓冲区指针
    size_t size // 要分配的缓冲区大小
);

cv::fastMalloc()相较于malloc()速度更快而且会进行缓冲区内存大小对其，如传递的缓冲区大小超过16字节，则返回的缓冲区将以16字节的边界对齐。

int cvFloor( // 返回不大于x的最大整数 int <= x
    float x // 输入332位浮点数
};

给定一个浮点数x, cv::Floor()计算不大于x的最大整数。如果输入值超出32位整数所代表的范围，则结果未定义。

string cv::format( // 返回STL字符串 STL-string
    const char* fmt, // 格式化字符串, 如sprintf()
    ... // vargs, 如sprintf()
);

该函数本质上与标准库中的sprintf()相同，但它不要求调用者提供字符缓冲区，而是构造一个STL字符串对象并返回该对象。该函数对Exception()构造函数(参数中包含STL字符串)格式化错误消息特别方便。

int64 cv::getCPUTickCount( void ); // CPU滴答计数

在多核系统中，一个线程可以在一个核上休眠，而在另一个核上唤醒，因此随后两次调用cv::getCPUTickCount()的结果之间的差异可能会造成误差，或者完全没有意义。另外该函数适合初始化随机数生成器。

int cv::getNumThreads( void ); // 当前OpenCV使用的线程总数

返回当前OpenCV正在使用的线程数。

int cv::getOptimalDFTSize( int n ); // 用于离散傅里叶变换的最佳数组大小, >= n

函数cv::getOptimalDFTSize()将已经传递给cv::dft()的数组的大小作为参数，并返回应该传递给cv::dft()的数组的大小。OpenCV使用这个信息来创建一个更大的数组，可将数据复制到其中，然后用0来填充剩下的数据。

int cv::getThreadNum( void ); // 当前线程的序号

若OpenCV库是用OpenMP支持编译的，该函数将返回当前执行的线程的索引(从零开始)。

int64 cv::getTickCount( void ); // 返回当前CPU滴答计数

该函数返回相对于某些体系结构相关时间的滴答计数。而节拍率也依赖于体系结构和操作系统，每一滴答计数的时间可以通过cv::getTickFrequency()计算。对于大多数计时应用程序来说，这个函数比cv::getCPUTickCount()更好，因为它不受底层问题的影响，比如线程运行在哪个核心上，以及CPU频率的自动调节(大多数现代处理器出于电源管理的原因会这对CPU的频率进行调节)。

double cv::getTickFrequency( void ); // 滴答计数频率，即每秒钟的滴答计数频次

当cv::getTickCount()用于计时分析时，滴答计数通常与CPU架构或系统体系结构有关。函数cv::getTickFrequency()计算每秒钟的滴答频次。

int cvIsInf( double x ); // 如果x为无穷大则返回1

如果x为正负无穷，则cvIsInf()的返回值为1，否则为0。无穷大测试由IEEE754标准提供。

int cvIsNan( double x ); // 如果x不是一个数就返回1

如果x不是一个数则返回1，否则返回0。NaN“非数”测试由IEEE754标准提供。

int cvRound( double x ); // 返回一个最接近x的整数

给定一个浮点数x, cvRound()计算并返回最接近x的整数。如果输入值在32位整数可表示的范围之外，则结果为未定义。在OpenCV 3.0中有重载cvRound(float x)(如cvFloor和cvCeil)，其在ARM上更快。

void cv::setNumThreads( int nthreads ); // 设置OpenCV可以使用的线程数

当OpenCV使用OpenMP支持编译时，该函数设置OpenCV将在并行OpenMP块中使用的线程数。线程数的默认值是CPU上逻辑核的数量(假设有四个核，每个核带有两个超线程，那么默认情况下将有八个线程)，如果nthreads设置为0，线程数将返回默认值。

void cv::setUseOptimized( bool on_off ); // 如果为false, 关闭优化操作

早期版本的OpenCV依赖于外部库(如IPP, Intel性能原语库)用于访问高性能的优化，如SSE2指令，后来的版本越来越多地将优化代码包含在OpenCV本身中。默认情况下，这些优化操作的使用是启用的，除非在编译库时禁用了优化。我们可以随时通过cv::setUseOptimized()打开或关闭这些优化的使用。

当其它例程(在任何线程上)正在运行时不能调用cv::setUseOptimized()。

bool cv::useOptimized( void ); // 优化开启时返回true

当优化启用时，返回True否则返回False。

类似于STL、Boost以及其它库，OpenCV 2.1及更新版本建立在模板元编程风格上。这种类型的库设计在最终代码的质量和速度，以及灵活性都比较好。

OpenCV中常用模板参数如下表所示：

cv::Mat是整个OpenCV库c++实现的中心。OpenCV库中的绝大多数函数都是cv::Mat类的成员，接受cv::Mat作为参数，或者以cv::Mat作为返回值。

cv::Mat类用于表示任意维数的密集数组。密集意味着数组中都有一一对应的数据值，即使其数值为零，大多数图像都以密集数组的形式存储。另一种是稀疏数组cv::SparseMat，在稀疏数组中，通常只存储非零数值，当许多数值为零时采用稀疏数组进行存储，可以极大地节省存储空间。常见使用稀疏数组的情况为直方图，对于许多直方图，大多数数值都为0。

cv::Mat类可以作为任意维数的数组。其数据可以看做是以按照栅格扫描顺序存储的n维数组。在一维数组中，元素是顺序的。这意味着在一维数组巾，元素是按顺序排列的；而在 个二维数组中，数据按行组织，每一行也按顺序排列，对于三维数组来说，所有的通道都被行填充，每一个通道同样按顺序排列。

所有的矩阵都含有一个表示它所包含数组类型的flag，一个表示其维度的dims，分别表示行和列的数目的rows和cols (在dims大于2的时候无效) ，一个指示数据存储位置的指针data，以及一个表示该内存区域有多少个引用的refcount，类似于cv: :Ptr<>的引用计数器。cv: :Mat像智能指针一样管理内存区域。数据实体data的结构被step[]所描述。数据数组按如下公式排列数据:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yEnDlot9-1657066618361)(/image-20220622074616574.png)]

对于一个二维数组，其公式可以简化如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xWiQdSqD-1657066618363)(/image-20220622074809184.png)]

cv: :Mat中的元素可以是一个简单的数字，也可以是多个数字。在包含多个数字的时候，它就被称为"多通道数组"。从定义上来说，一个数组的元素是许多带有数值的向量的 部分。比如说，一个数组也许会被声明为二维三通道32位浮点型数组，在这个情况下，数组的元素就是大小为12字节的32位浮点数据。当在内存中储存的时候，数组的行可能不是绝对按顺序存储的，由于数据对齐（数据对齐是为了内存的存取效率）的原因，每一行之间可能存在一个很小的间隔。

可以通过实例化变量cv: :Mat来创建数组，通过这种方式创建的数组没有大小和数据类型。但可以再次使用成员函数create()来申请一个内存区域。一个create()的重载是通过指定行数和列数以及数据类型来配置二维数组的规模。数组的类型(type) 决定了它含有什么样的元素。 一个有效的数据类型需要同时指明数据的类型和通道数。所有这些数据类型都在库的头文件中声明，包括CV_{8U 16S 16U 32S 32F 64F}C{1 3} 的多种组合。比如，CV_32F_C3表示3通道的32位浮点数据。OpenCV 允许定义超过3通道的数据类型，需妥调用函数CV{8U,16S,32S,32F,64F}C()这些函数只有一个参数，表明通道数，如CV_8UC(3) 等效于CV_8UC3，由于没有宏CV 8UC7，必须使用函数飞CV_8UC(7)。

数组创建示例：

cv::Mat m;
// Create data area for 3 rows and 10 columns of 3-channel 32-bit floats
m.create( 3, 10, CV_32FC3 ); 
// Set the values in the 1st channel to 1.0, the 2nd to 0.0, and the 3rd to 1.0
m.setTo( cv::Scalar( 1.0f, 0.0f, 1.0f ) );

等效于：

cv::Mat m(3, 10, CV_32FC3, cv::Scalar(1.0f, 0.0f, 1.0f ));

以下为所有cv::Mat构造函数的列表，一般常用的只是其中几个：

cv::Mat构造函数（非复制构造函数）

cv::Mat复制构造函数

针对OpenCV 2.1以往版本的数据类型的cv::Mat构造函数

cv::Mat模板构造函数

构造cv::Mat的静态函数

使用cv::Mat::ones()或cv::Mat::eye()创建一个多维数组时，只有第一通道会设置为1，其余通道保持为0。

访问一个数组元素的方法主要有两种，分别为通过位置访问以及迭代器访问。以下为使用行列位置访问对应元素数据的两个例子。

访问单通道数组元素：

cv::Mat m = cv::Mat::eye( 10, 10, 32FC1 );
printf(
 "Element (3,3) is %f\n",
 m.at<float>(3,3)
);

访问多通道数组：

cv::Mat m = cv::Mat::eye( 10, 10, 32FC2 );
printf(
 "Element (3,3) is (%f,%f)\n",
 m.at<cv::Vec2f>(3,3)[0],
 m.at<cv::Vec2f>(3,3)[1]
);

当使用at<>()的模板函数访问多维数组时，优先使用cv::Vec对象。

创建并访问由更复杂类型(如复数)组成的数组：

cv::Mat m = cv::Mat::eye( 10, 10, cv::DataType<cv::Complexf>::type );
printf(
 "Element (3,3) is %f + i%f\n",
 m.at<cv::Complexf>(3,3).re,
 m.at<cv::Complexf>(3,3).im,
);

at<>()访问器函数的变体

ptr<>()访问元素

使用ptr<>()指针访问数组是最快的一种方式，且可以通过指针的方式向指定位置写入数据。C风格的数据指针data也是一种指针访问方式。成员函数isContinuous()可以判断数组是否连续的，如果数组是连续的，则可以通过获取第一行第一个元素的指针，然后再遍历整个数组。

OpenCVcv::Mat提供另一种序列存储方式的迭代器机制。包括一个用于只读（const）数组的cv::MatConstIterator<>和一个用于非只读（non-const）数组的cv::MatIterator<>。cv::Mat的成员函数begin()和end()可以返回这种迭代器对象，使用迭代器可以自动处理连续的内存区域和非连续的内存区域，在任一种维度的数组中都可有效使用。

使用迭代器计算三通道数组中“最长”元素（一个三维向量域）示例：

int sz[3] = { 4, 4, 4 };
cv::Mat m( 3, sz, CV_32FC3 ); // 一个4×4×4的三维数组
cv::randu( m, -1.0f, 1.0f ); // 填充从-1.0到1.0的随机数字
float max = 0.0f; // L2范数的最小可能值
cv::MatConstIterator<cv::Vec3f> it = m.begin();
while( it != m.end() ) 
{
    len2 = (*it)[0]*(*it)[0]+(*it)[1]*(*it)[1]+(*it)[2]*(*it)[2];
    if( len2 > max ) max = len2;
    it++;
}

cv::NaryMatIterator要求被迭代的数组有相同的几何结构(维度以及每一个维度的范围)。该迭代器不会返回一个用于迭代的单独元素，而通过返回一堆数组进行N-ary迭代器操作，这些返回的数组也称为“面”（plane）。一个面表示输入数组有连续内存的部分（一般来说是一维或二维的片段）。

一个多维数组的求和，计算m0和m1的和，并将结果放在m2中。

const int n_mat_size = 5;
const int n_mat_sz[] = { n_mat_size, n_mat_size, n_mat_size };
cv::Mat n_mat( 3, n_mat_sz, CV_32FC1 );
cv::RNG rng;
rng.fill( n_mat, cv::RNG::UNIFORM, 0.f, 1.f );
const cv::Mat* arrays[] = { &n_mat, 0 };
cv::Mat my_planes[1];
cv::NAryMatIterator it( arrays, my_planes );
// On each iteration, it.planes[i] will be the current plane of the
// i-th array from 'arrays'.
float s = 0.f; // Total sum over all planes
int n = 0; // Total number of planes
for (int p = 0; p < it.nplanes; p++, ++it) {
 s += cv::sum(it.planes[0])[0];
 n++;
}

使用N-ary对两个数组求和

const int n_mat_size = 5;
const int n_mat_sz[] = { n_mat_size, n_mat_size, n_mat_size };
cv::Mat n_mat0( 3, n_mat_sz, CV_32FC1 );
cv::Mat n_mat1( 3, n_mat_sz, CV_32FC1 );
cv::RNG rng;
rng.fill( n_mat0, cv::RNG::UNIFORM, 0.f, 1.f );
rng.fill( n_mat1, cv::RNG::UNIFORM, 0.f, 1.f );
const cv::Mat* arrays[] = { &n_mat0, &n_mat1, 0 };
cv::Mat my_planes[2];
cv::NAryMatIterator it( arrays, my_planes );
float s = 0.f; // Total sum over all planes in both arrays
int n = 0; // Total number of planes
for(int p = 0; p < it.nplanes; p++, ++it) {
 s += cv::sum(it.planes[0])[0];
 s += cv::sum(it.planes[1])[0];
 n++;
}

使用N-ary对两个数组求方根

/// compute dst[*] = pow(src1[*], src2[*]) //
const Mat* arrays[] = { src1, src2, dst, 0 };
float* ptrs[3];
NAryMatIterator it(arrays, (uchar**)ptrs);//先*(ptrs)从数组中取出float*，再通过uchar*(float*)将float型指针转换为uchar型指针
for( size_t i = 0; i < it.nplanes; i++, ++it )
{
    for( size_t j = 0; j < it.size; j++ )

    {
        ptrs[2][j] = std::pow(ptrs[0][j], ptrs[1][j]);
    }
} 

通过块访问数组元素

以上通过块访问数组元素的方式不会将对应块的数据重新复制，而是创建了一个新的数组头，并且分配data指针、step数组以及其他一些东西。如表达式m2=m.row(3)，通过m2可以访问m中的第三行数据，如果修改了m2中得到的数据，也会修改到位于m中对应位置的数据。

m.diag(int shift)返回的数组指向矩阵m的对角元素。当shift为0时返回主对角线元素，shift为正数时，相对于主对角线向数组上半部分偏移。shift为负数时，相对于主对角线向下半部分偏移。

数组于数组之间的赋值不会新申请内存，而矩阵之间的运算或通过矩阵表达式获得的结果需要新申请内存进行保存。如m1=m2仅是引用数据，m=m1+m2则会新申请内存存储m中的数据。

矩阵表达式可用的运算操作

**饱和转换（saturatio