opencv 笔记

http://docs.opencv.org/

opencv 2.x API

opencv包含以下模块

• core    基本数据机构
• imgproc    图像处理方法
• video    视频处理方法
• calib3d    图形学方法
• features2d    区域检测算子和描述算子
• objdetect    目标检测方法
• highgui    GUI相关
• gup    GPU加速方法
• ......

opencv中有些函数名称会与其他包提供的名称冲突，因此:

using namespace cv;

 OpenCV内存管理
opencv的基本数据结构如Mat包含析构函数，在引用数为0时，释放空间；引用数非0时调用则引用数减1。copy只是增加引用，clone才重新分配内存。
原文：

This means that the destructors do not always deallocate the buffers as in case of Mat. They take into account possible data sharing. A destructor decrements the reference counter associated with the matrix data buffer. The buffer is deallocated if and only if the reference counter reaches zero, that is, when no other structures refer to the same buffer. Similarly, when a Mat instance is copied, no actual data is really copied. Instead, the reference counter is incremented to memorize that there is another owner of the same data. There is also the Mat::clone method that creates a full copy of the matrix data. 

// create a big 8Mb matrix
//新建矩阵
Mat A(, , CV_64F);

// create another header for the same matrix;
// this is an instant operation, regardless of the matrix size.
// AB共享内存
Mat B = A;

// create another header for the 3-rd row of A; no data is copied either
// C指向A和B的第三行
Mat C = B.row();

// now create a separate copy of the matrix
// 新的矩阵，重新分配内存
Mat D = B.clone();

// copy the 5-th row of B to C, that is, copy the 5-th row of A
// to the 3-rd row of A.
//将B的第五行复制到C，也就是复制到A,B的第三行
B.row().copyTo(C);

// now let A and D share the data; after that the modified version
// of A is still referenced by B and C.
// 将A指向D， B,C仍然指向第一行申请的内存空间
A = D;

// now make B an empty matrix (which references no memory buffers),
// but the modified version of A will still be referenced by C,
// despite that C is just a single row of the original A
// 释放B，但是B所指向的内存空间没有被释放，因为还有C，虽然C只是指向了其中一行
B.release();

// finally, make a full copy of C. As a result, the big modified
// matrix will be deallocated, since it is not referenced by anyone
// 将原先C指向的一行clone，那么第一行申请的1000*1000的矩阵就引用数为0，则自动释放
C = C.clone();

对于自定义的数据类型，opencv提供了类似的机制来管理内存：

// 传统方法
T* ptr = new T();

// 推荐方法  Ptr<T> 分配一个指针和一个引用计数器
Ptr<T> ptr = new T();

template<typename_Tp> class Ptr
{
　　public:
　　　　// default constructor
　　　　Ptr();
　　　　// constructor that wraps the object pointer
　　　　Ptr(_Tp*_obj);
　　　　// destructor: calls release()
　　　　~Ptr();
　　　　// copy constructor; increments ptr’s reference counter
　　　　Ptr(const Ptr& ptr);
　　　　// assignment operator; decrements own reference counter
　　　　// (with release()) and increments ptr’s reference counter
　　　　Ptr& operator = (const Ptr& ptr);
　　　　// increments reference counter
　　　　void addref();
　　　　// decrements reference counter; when it becomes 0,
　　　　// delete_obj() is called
　　　　void release();
　　　　// user-specified custom object deletion operation.
　　　　// by default, "delete obj;" is called
　　　　void delete_obj();
　　　　// returns true if obj == 0;
　　　　bool empty() const;
　　　　// provide access to the object fields and methods
　　　　_Tp* operator -> ();
　　　　const _Tp*operator -> () const;
　　　　// return the underlying object pointer;
　　　　// thanks to the methods, the Ptr<_Tp> can be
　　　　// used instead of_Tp*
　　　　operator _Tp*();
　　　　operator const _Tp*() const;
　　protected:
　　　　// the encapsulated object pointer
　　　　_Tp* obj;
　　　　// the associated reference counter
　　　　int* refcount;
};

函数返回值自动分配内存

#include "cv.h"
#include "highgui.h"
using namespace cv;
int main(int, char**)
{
　　VideoCapture cap();
　　if(!cap.isOpened()) return -;
　　Mat frame, edges;
　　namedWindow("edges",);
　　for(;;)
　　{
　　　　cap >> frame;
　　　　cvtColor(frame, edges, CV_BGR2GRAY);
　　　　GaussianBlur(edges, edges, Size(,), 1.5, 1.5);
　　　　Canny(edges, edges, , , );
　　　　imshow("edges", edges);
　　　　if(waitKey() >= ) break;
　　}
　　return ;
}

• cap >> frame 自动分配内存
• cvtColor也会为edges自动分配内存
• 在for循环中，只有第一次会分配内存（若分辨率改变，则会重新分配）

机制： Mat::create() 会检测包含的数组的大小和类型，若满足要求，则不作处理；若为空，则分配；若不满足要求，则先释放再分配。

例外：Some notable exceptions from this scheme are cv::mixChannels, cv::RNG::fill, and a few other functions and methods. They are not able to allocate the output array, so you have to do this in advance.

像素数据类型：
• 8-bit unsigned integer (uchar)
• 8-bit signed integer (schar)
• 16-bit unsigned integer (ushort)
• 16-bit signed integer (short)
• 32-bit signed integer (int)
• 32-bit floating-point number (float)
• 64-bit floating-point number (double)

enum { CV_8U=, CV_8S=, CV_16U=, CV_16S=, CV_32S=, CV_32F=, CV_64F= };

颜色通道：（最大通道数CV_CN_MAX = 512）
• CV_8UC1 ... CV_64FC4 constants (for a number of channels from 1 to 4)
• CV_8UC(n) ... CV_64FC(n) or CV_MAKETYPE(CV_8U, n) ... CV_MAKETYPE(CV_64F, n) macros when the
number of channels is more than 4 or unknown at the compilation time.

CV_32FC1 == CV_32F,
CV_32FC2 == CV_32FC(2) == CV_MAKETYPE(CV_32F, 2),

// 原文中的没看懂。。。 理解应该是 CV_MAKETYPE(depth, n) == (n-1)<<3+x, x=0,...,6对应{ CV_8U=, CV_8S=, CV_16U=, CV_16S=, CV_32S=, CV_32F=, CV_64F= };
CV_MAKETYPE(depth, n) == ((x&)<<) + (n-)

Mat mtx(, , CV_32F); // make a 3x3 floating-point matrix
Mat cmtx(, , CV_64FC2); // make a 10x1 2-channel floating-point
// matrix (10-element complex vector)
Mat img(Size(, ), CV_8UC3); // make a 3-channel (color) image
// of 1920 columns and 1080 rows.
Mat grayscale(image.size(), CV_MAKETYPE(image.depth(), )); // make a 1-channel image of
// the same size and same
// channel type as img