OpenCV 2.3.1 参考手册：图像处理与计算机视觉

需积分: 18 176 浏览量更新于2024-07-29 收藏 3MB PDF 举报

"Opencv-ref-man-2.3.1.pdf 是OpenCV库的官方参考手册，涵盖2.3版本的详细信息，是学习和查阅OpenCV功能的重要资料。" OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉库，它包含了大量的图像处理和计算机视觉的算法，适用于各种应用领域，如图像分析、人脸识别、机器学习等。本手册详细介绍了OpenCV的核心功能以及各种图像处理和分析技术。 1. **介绍** - API概念：手册首先介绍了OpenCV API的基本设计原则和使用方法，帮助开发者理解如何有效地与库进行交互。 2. **核心功能** - 基本结构：这部分涵盖了OpenCV中的基本数据结构，如IplImage和cv::Mat，它们用于存储和操作图像数据。 - 基本C结构与操作：详述了C接口下的图像操作，如拷贝、转换、裁剪等。 - 动态结构：介绍了如vector和Matx等动态数据结构，用于灵活处理图像和数组。 - 数组操作：包括对数组的各种数学和逻辑运算，如加减乘除、比较和位操作。 - 绘图函数：提供了绘制几何形状、线条、文本等图像元素的API。 - XML/YAML持久化：讲解了如何使用OpenCV保存和加载配置文件或模型参数。 - 聚类：包括K-means等聚类算法的实现和使用。 - 工具和系统函数及宏：提供了系统级别的辅助函数和宏定义。 3. **图像处理**（imgproc模块） - 图像滤波：涵盖了各种滤波技术，如卷积、平滑、边缘检测等。 - 几何图像变换：包括缩放、旋转、平移、仿射和透视变换。 - 其他图像变换：如直方图均衡化、色彩空间转换等。 - 直方图：提供了直方图计算和直方图特征提取的函数。 - 结构分析与形状描述符：用于识别和描述图像中的形状特征。 - 平面细分（CAPI）：在旧版C接口中处理图像细分的方法。 - 运动分析与对象追踪：提供了跟踪算法，如光流法、卡尔曼滤波等。 - 特征检测：包括角点检测、边缘检测等特征定位方法。 - 对象检测：如Haar级联分类器、LBP特征等用于对象识别。 4. **高层GUI和媒体I/O**（highgui模块） - 用户界面：提供了创建窗口、显示图像、处理用户事件的函数。 - 读写图像和视频：支持多种格式的图像和视频读取、写入和播放。 - Qt新功能：如果使用Qt框架，手册还介绍了与Qt的集成。 5. **视频分析**（video模块） - 运动分析与对象追踪：进一步探讨了在视频流中进行运动分析和目标追踪的技术。 6. **相机标定与3D重建**（calib3d模块） - 相机标定与3D重建：提供了从多个视图重建场景3D结构的算法，如单应性矩阵、本质矩阵、内参标定等。 7. **特征提取与描述符**（未提供完整章节，通常包括SIFT、SURF、ORB等特征描述符） 8. **其他模块**（如objdetect、features2d、ml等）未在摘要中列出，但这些模块涉及物体检测、特征2D操作、机器学习等功能。 OpenCV的这些模块和功能为开发者提供了强大的工具集，使得图像处理和计算机视觉任务变得更为便捷。通过深入理解和实践手册中的内容，开发者可以构建复杂的视觉应用，从基础的图像处理到高级的视觉算法都有所涵盖。

The OpenCV Reference Manual, Release 2.3

Being derived from Vec<

Tp, 4> , Scalar

and Scalar can be used just as typical 4-element vectors. In addition,

they can be converted to/from CvScalar . The type Scalar is widely used in OpenCV to pass pixel values.

Range

class Range

Template class specifying a continuous subsequence (slice) of a sequence.

class Range

{

public:

...

int start, end;

};

The class is used to specify a row or a column span in a matrix ( Mat ) and for many other purposes. Range(a,b) is

basically the same as a:b in Matlab or a..b in Python. As in Python, start is an inclusive left boundary of the range

and end is an exclusive right boundary of the range. Such a half-opened interval is usually denoted as [start, end) .

The static method Range::all() returns a special variable that means “the whole sequence” or “the whole range”,

just like ” : ” in Matlab or ” ... ” in Python. All the methods and functions in OpenCV that take Range support this

special Range::all() value. But, of course, in case of your own custom processing, you will probably have to check

and handle it explicitly:

void my

function(..., const Range& r, ....)

{

if(r == Range::all()) {

// process all the data

}

else {

// process [r.start, r.end)

}

Ptr

class Ptr

Template class for smart reference-counting pointers

template<typename

Tp> class Ptr

{

public:

// default constructor

Ptr();

// constructor that wraps the object pointer

Ptr(

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();

12 Chapter 2. core. The Core Functionality

The OpenCV Reference Manual, Release 2.3

// 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

operator -> ();

const

operator -> () const;

// return the underlying object pointer;

// thanks to the methods, the Ptr<

Tp> can be

// used instead of

operator

();

operator const

() const;

protected:

// the encapsulated object pointer

obj;

// the associated reference counter

int

refcount;

};

The Ptr<

Tp> class is a template class that wraps pointers of the corresponding type. It is similar to shared

ptr that

is part of the Boost library ( http://www.boost.org/doc/libs/1_40_0/libs/smart_ptr/shared_ptr.htm ) and also part of the

C++0x standard.

This class provides the following options:

• Default constructor, copy constructor, and assignment operator for an arbitrary C++ class or a C structure. For

some objects, like ﬁles, windows, mutexes, sockets, and others, a copy constructor or an assignment operator

are difﬁcult to deﬁne. For some other objects, like complex classiﬁers in OpenCV, copy constructors are absent

and not easy to implement. Finally, some of complex OpenCV and your own data structures may be written in

C. However, copy constructors and default constructors can simplify programming a lot. Besides, they are often

required (for example, by STL containers). By wrapping a pointer to such a complex object TObj to Ptr<TObj>

, you automatically get all of the necessary constructors and the assignment operator.

• O(1) complexity of the above-mentioned operations. While some structures, like std::vector, provide a copy

constructor and an assignment operator, the operations may take a considerable amount of time if the data

structures are large. But if the structures are put into Ptr<> , the overhead is small and independent of the data

size.

• Automatic destruction, even for C structures. See the example below with FILE

• Heterogeneous collections of objects. The standard STL and most other C++ and OpenCV containers can store

only objects of the same type and the same size. The classical solution to store objects of different types in the

same container is to store pointers to the base class base

class

instead but then you loose the automatic

memory management. Again, by using Ptr<base

class

t>() instead of the raw pointers, you can solve the

problem.

The Ptr class treats the wrapped object as a black box. The reference counter is allocated and managed separately.

The only thing the pointer class needs to know about the object is how to deallocate it. This knowledge is incapsulated

in the Ptr::delete

obj() method that is called when the reference counter becomes 0. If the object is a C++ class

instance, no additional coding is needed, because the default implementation of this method calls delete obj; .

However, if the object is deallocated in a different way, the specialized method should be created. For example, if you

want to wrap FILE , the delete

obj may be implemented as follows:

2.1. Basic Structures 13

The OpenCV Reference Manual, Release 2.3

data layout of the array M is deﬁned by the array M.step[] , so that the address of element (i

, ..., i

M.dims−1

) ,

where 0 ≤ i

< M.size[k] , is computed as:

addr(M

,...,i

M.dims−1

) = M.data + M.step[0] ∗ i

+ M.step[1] ∗ i

+ ... + M.step[M.dims − 1] ∗ i

M.dims−1

In case of a 2-dimensional array, the above formula is reduced to:

addr(M

i,j

) = M.data + M.step[0] ∗ i + M.step[1] ∗ j

Note that M.step[i] >= M.step[i+1] (in fact, M.step[i] >= M.step[i+1]

M.size[i+1] ). This means

that 2-dimensional matrices are stored row-by-row, 3-dimensional matrices are stored plane-by-plane, and so on.

M.step[M.dims-1] is minimal and always equal to the element size M.elemSize() .

So, the data layout in Mat is fully compatible with CvMat, IplImage, and CvMatND types from OpenCV 1.x. It is also

compatible with the majority of dense array types from the standard toolkits and SDKs, such as Numpy (ndarray),

Win32 (independent device bitmaps), and others, that is, with any array that uses steps (or strides) to compute the

position of a pixel. Due to this compatibility, it is possible to make a Mat header for user-allocated data and process it

in-place using OpenCV functions.

There are many different ways to create a Mat object. The most popular options are listed below:

• Use the create(nrows, ncols, type) method or the similar Mat(nrows, ncols, type[, fillValue])

constructor. A new array of the speciﬁed size and type is allocated. type has the same meaning as in the

cvCreateMat method. For example, CV

8UC1 means a 8-bit single-channel array, CV

32FC2 means a 2-channel

(complex) ﬂoating-point array, and so on.

// make a 7x7 complex matrix filled with 1+3j.

Mat M(7,7,CV

32FC2,Scalar(1,3));

// and now turn M to a 100x60 15-channel 8-bit matrix.

// The old content will be deallocated

M.create(100,60,CV

8UC(15));

As noted in the introduction to this chapter, create() allocates only a new array when the shape or type of the

current array are different from the speciﬁed ones.

• Create a multi-dimensional array:

// create a 100x100x100 8-bit array

int sz[] = {100, 100, 100};

Mat bigCube(3, sz, CV

8U, Scalar::all(0));

It passes the number of dimensions =1 to the Mat constructor but the created array will be 2-dimensional with

the number of columns set to 1. So, Mat::dims is always >= 2 (can also be 0 when the array is empty).

• Use a copy constructor or assignment operator where there can be an array or expression on the right side (see

below). As noted in the introduction, the array assignment is an O(1) operation because it only copies the header

and increases the reference counter. The Mat::clone() method can be used to get a full (deep) copy of the

array when you need it.

• Construct a header for a part of another array. It can be a single row, single column, several rows, several

columns, rectangular region in the array (called a minor in algebra) or a diagonal. Such operations are also O(1)

because the new header references the same data. You can actually modify a part of the array using this feature,

for example:

// add the 5-th row, multiplied by 3 to the 3rd row

M.row(3) = M.row(3) + M.row(5)

// now copy the 7-th column to the 1-st column

// M.col(1) = M.col(7); // this will not work

Mat M1 = M.col(1);

2.1. Basic Structures 15

The OpenCV Reference Manual, Release 2.3

M.col(7).copyTo(M1);

// create a new 320x240 image

Mat img(Size(320,240),CV

8UC3);

// select a ROI

Mat roi(img, Rect(10,10,100,100));

// fill the ROI with (0,255,0) (which is green in RGB space);

// the original 320x240 image will be modified

roi = Scalar(0,255,0);

Due to the additional datastart and dataend members, it is possible to compute a relative sub-array position

in the main container array using locateROI():

Mat A = Mat::eye(10, 10, CV

32S);

// extracts A columns, 1 (inclusive) to 3 (exclusive).

Mat B = A(Range::all(), Range(1, 3));

// extracts B rows, 5 (inclusive) to 9 (exclusive).

// that is, C ~ A(Range(5, 9), Range(1, 3))

Mat C = B(Range(5, 9), Range::all());

Size size; Point ofs;

C.locateROI(size, ofs);

// size will be (width=10,height=10) and the ofs will be (x=1, y=5)

As in case of whole matrices, if you need a deep copy, use the clone() method of the extracted sub-matrices.

• Make a header for user-allocated data. It can be useful to do the following:

1. Process “foreign” data using OpenCV (for example, when you implement a DirectShow* ﬁlter or a pro-

cessing module for gstreamer, and so on). For example:

void process

video

frame(const unsigned char

pixels,

int width, int height, int step)

{

Mat img(height, width, CV

8UC3, pixels, step);

GaussianBlur(img, img, Size(7,7), 1.5, 1.5);

}

2. Quickly initialize small matrices and/or get a super-fast element access.

double m[3][3] = {{a, b, c}, {d, e, f}, {g, h, i}};

Mat M = Mat(3, 3, CV

64F, m).inv();

Partial yet very common cases of this user-allocated data case are conversions from CvMat and IplImage to

Mat. For this purpose, there are special constructors taking pointers to CvMat or IplImage and the optional ﬂag

indicating whether to copy the data or not.

Backward conversion from Mat to CvMat or IplImage is provided via cast operators Mat::operator

CvMat() const and Mat::operator IplImage(). The operators do NOT copy the data.

IplImage

img = cvLoadImage("greatwave.jpg", 1);

Mat mtx(img); // convert IplImage

-> Mat

CvMat oldmat = mtx; // convert Mat -> CvMat

Assert(oldmat.cols == img->width && oldmat.rows == img->height &&

oldmat.data.ptr == (uchar

)img->imageData && oldmat.step == img->widthStep);

• Use MATLAB-style array initializers, zeros(), ones(), eye(), for example:

// create a double-precision identity martix and add it to M.

M += Mat::eye(M.rows, M.cols, CV

64F);

16 Chapter 2. core. The Core Functionality

剩余552页未读，继续阅读

zjtongyong

粉丝: 0
资源: 19

OpenCV 2.3.1 参考手册：图像处理与计算机视觉

opencv-python-4.10.0.84.tar.gz

opencv-python 3.4.1.15 opencv-contrib-python 3.4.1.15 win64版

PyPI 官网下载 | opencv-python-4.5.3.56.tar.gz

opencv-python-2.3.1.win32-py2.7.exe

opencv4.5.4 centos7相关资源,包含libopencv-java454.so、opencv-4.5.4.tar.gz、opencv-454.jar

opencv包括libopencv-java440.so,opencv-440.jar,opencv-java440.dll

opencv-4.5.5.zip/opencv-4.5.5.zip

opencv-2.3.1.zip_ECLIPSE OPENCV_opencv_opencv jar_opencv jar包_op

qt-opencv-qt-opencv-master.tar.gz_QT opencv_opencv QT_opencv

OpenCV-2.3.1-win-superpack.exe

最新资源