目的

本节你将学到:

OpenCV 原理

本节中，我门将大量使用Point和Scalar这两个结构：

Point pt;
pt.x = 10;
pt.y 8;

代码

• 这些代码都来自OpenCV代码的sample文件夹。或者可点击此处获取。

代码分析

1. 我们打算画两个例子（原子和赌棍）， 所以必须创建两个图像和对应的窗口以显示。

   /// 窗口名字
   char atom_window[] = "Drawing 1: Atom";
   char rook_window[] "Drawing 2: Rook";
   
   /// 创建空全黑像素的空图像
   Mat atom_image = Mat::zeros( w, w, CV_8UC3 );
   Mat rook_image CV_8UC3 );
   

2. 创建用来画不同几何形状的函数。比如用MyEllipse和MyFilledCircle来画原子。

   /// 1. 画一个简单的原子。 /// 1.a. 创建椭圆 MyEllipse( atom_image,80)">90 ); MyEllipse( atom_image,80)">0 ); MyEllipse( atom_image,80)">45 ); MyEllipse( atom_image, -45 ); /// 1.b. 创建圆 MyFilledCircle( atom_image, Point( w/2.0, w2.0) );

3. 接下来用MyLine*，*rectangle和 aMyPolygon来画赌棍：

   /// 2. 画一个赌棍 /// 2.a. 创建一个凸多边形 MyPolygon( rook_image ); /// 2.b. 创建矩形 rectangle( rook_image, Point( 0,80)">7*w8.0 ), Point( w, w), Scalar( 255,80)">255 ), 1, 8 ); /// 2.c. 画几条直线 MyLine( rook_image, Point( 15/16 ), Point( w,80)">16 ) ); MyLine( rook_image,80)">4,80)">8 ), w ) ); MyLine( rook_image,80)">2,80)">3w ) );

4. 现在来看看每个函数内部如何定义:

   • MyLine

     void MyLine( Mat img, Point start, Point end )
     {
       int thickness 2;
       int lineType 8;
       line( img,
             start,
             end,
             Scalar( 0 ),
             thickness,
             lineType );
     }
     

     正如我们所见,MyLine调用函数line来实现以下操作:

     • 画一条从点start到点end的直线段
     • 此线段将被画到图像img上
     • 线的颜色由Scalar( 0,0)来定义，在此其相应RGB值为黑色
     • 线的粗细由thickness设定(此处设为 2)
     • 此线为8联通 (lineType= 8)

   • MyEllipse

     void MyEllipse( Mat img, double angle ) { 8; ellipse( img, Point( w2.0 ), Size( w4.0,80)">16.0 ), angle,80)">360, thickness, lineType ); }

     根据以上代码，我们可看到函数ellipse按照以下规则绘制椭圆：

     • 椭圆将被画到图像img上
     • 椭圆中心为点(w/2.0,w/2.0)并且大小位于矩形(w/4.0,w/16.0)内
     • 椭圆旋转角度为angle
     • 椭圆扩展的弧度从0度到360度
     • 图形颜色为Scalar( 255,0)，既蓝色
     • 绘椭圆的线粗为thickness，此处是2

   • MyFilledCircle

     void MyFilledCircle( Mat img, Point center ) { = 1; 8; circle( img, center, w32.0, Scalar( thickness, lineType ); }

     类似于椭圆函数，我们可以看到circle函数的参数意义如下：

     • 圆将被画到图像 (img)上
     • 圆心由点center定义
     • 圆的半径为:w/32.0
     • 圆的颜色为:Scalar(0,255)，按BGR的格式为红色
     • 线粗定义为thickness= -1,因此次圆将被填充

   • MyPolygon

     void MyPolygon( Mat img )
     {
       int lineType = 8;
     
       /** 创建一些点 */
       Point rook_points[1][20];
       rook_points[0][0] = Point( w/4.0,7*w/8.0 );
       rook_points[0][1] = Point( 3*w/4.0,7*w/8.0 );
       rook_points[0][2] = Point( 3*w/4.0,13*w/16.0 );
       rook_points[0][3] = Point( 11*w/16.0,13*w/16.0 );
       rook_points[0][4] = Point( 19*w/32.0,3*w/8.0 );
       rook_points[0][5] = Point( 3*w/4.0,3*w/8.0 );
       rook_points[0][6] = Point( 3*w/4.0,w/8.0 );
       rook_points[0][7] = Point( 26*w/40.0,w/8.0 );
       rook_points[0][8] = Point( 26*w/40.0,w/4.0 );
       rook_points[0][9] = Point( 22*w/40.0,w/4.0 );
       rook_points[0][10] = Point( 22*w/40.0,w/8.0 );
       rook_points[0][11] = Point( 18*w/40.0,w/8.0 );
       rook_points[0][12] = Point( 18*w/40.0,w/4.0 );
       rook_points[0][13] = Point( 14*w/40.0,w/4.0 );
       rook_points[0][14] = Point( 14*w/40.0,w/8.0 );
       rook_points[0][15] = Point( w/4.0,w/8.0 );
       rook_points[0][16] = Point( w/4.0,3*w/8.0 );
       rook_points[0][17] = Point( 13*w/32.0,3*w/8.0 );
       rook_points[0][18] = Point( 5*w/16.0,13*w/16.0 );
       rook_points[0][19] = Point( w/4.0,13*w/16.0) ;
     
       const Point* ppt[1] = { rook_points[0] };
       int npt[] = { 20 };
     
       fillPoly( img,ppt,npt,1,Scalar( 255,255 ),lineType );
      }
     
     
      我们用函数 :fill_poly:`fillPoly <>` 来绘制填充的多边形。请注意：

     • 多边形将被画到图像img上
     • 多边形的顶点集为ppt
     • 要绘制的多边形顶点数目为npt
     • 要绘制的多边形数量仅为1
     • 多边形的颜色定义为Scalar( 255,255),既BGR值为白色

   • rectangle

     rectangle( rook_image,80)">8 );

     最后是函数:rectangle:rectangle <>（我们并没有为这家伙创建特定函数）。请注意：

     • 矩形将被画到图像rook_image上
     • 矩形两个对角顶点为Point( 0,7*w/8.0 )和Point( w,w)
     • 矩形的颜色为Scalar(0,255)，既BGR格式下的黄色
     • 由于线粗为-1,此矩形将被填充

结果

编译并运行例程，你将看到如下结果:

随机数发生器&绘制文字

离散傅立叶变换 目标

本文档尝试解答如下问题：

源码

你可以从此处下载源码或者通过OpenCV源码库文件samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp查看.

以下为函数dft()使用范例:

 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

原理

对一张图像使用傅立叶变换就是将它分解成正弦和余弦两部分。也就是将图像从空间域(spatial domain)转换到频域(frequency domain)。 这一转换的理论基础来自于以下事实：任一函数都可以表示成无数个正弦和余弦函数的和的形式。傅立叶变换就是一个用来将函数分解的工具。 2维图像的傅立叶变换可以用以下数学公式表达:

式中 f 是空间域(spatial domain)值， F 则是频域(frequency domain)值。 转换之后的频域值是复数， 因此，显示傅立叶变换之后的结果需要使用实数图像(real image) 加虚数图像(complex image),或者幅度图像(magitude image)加相位图像(phase image)。 在实际的图像处理过程中，仅仅使用了幅度图像，因为幅度图像包含了原图像的几乎所有我们需要的几何信息。 然而，如果你想通过修改幅度图像或者相位图像的方法来间接修改原空间图像，你需要使用逆傅立叶变换得到修改后的空间图像，这样你就必须同时保留幅度图像和相位图像了。

在此示例中，我将展示如何计算以及显示傅立叶变换后的幅度图像。由于数字图像的离散性，像素值的取值范围也是有限的。比如在一张灰度图像中，像素灰度值一般在0到255之间。 因此，我们这里讨论的也仅仅是离散傅立叶变换(DFT)。 如果你需要得到图像中的几何结构信息，那你就要用到它了。请参考以下步骤(假设输入图像为单通道的灰度图像I):

1. 将图像延扩到最佳尺寸. 离散傅立叶变换的运行速度与图片的尺寸息息相关。当图像的尺寸是2， 3，5的整数倍时，计算速度最快。 因此，为了达到快速计算的目的，经常通过添凑新的边缘像素的方法获取最佳图像尺寸。函数getOptimalDFTSize()返回最佳尺寸，而函数copyMakeBorder()填充边缘像素:

   Mat padded; //将输入图像延扩到最佳的尺寸 = getOptimalDFTSize( I.rows ); // 在边缘添加0 copyMakeBorder(I,80)">0));

   添加的像素初始化为0.

2. 为傅立叶变换的结果(实部和虚部)分配存储空间. 傅立叶变换的结果是复数，这就是说对于每个原图像值，结果是两个图像值。 此外，频域值范围远远超过空间值范围， 因此至少要将频域储存在float格式中。 结果我们将输入图像转换成浮点类型，并多加一个额外通道来储存复数部分：

   Mat planes[] CV_32F)}; Mat complexI; merge(planes,144); font-style:italic">// 为延扩后的图像增添一个初始化为0的通道

3. 进行离散傅立叶变换. 支持图像原地计算 (输入输出为同一图像):

   dft(complexI,144); font-style:italic">// 变换结果很好的保存在原始矩阵中

4. 将复数转换为幅度.复数包含实数部分(Re)和复数部分 (imaginary -Im)。 离散傅立叶变换的结果是复数，对应的幅度可以表示为:

转化为OpenCV代码:

split(complexI,planes[1] = Im(DFT(I)) magnitude(planes[// planes[0] = magnitude Mat magI 0];

5. 对数尺度(logarithmic scale)缩放. 傅立叶变换的幅度值范围大到不适合在屏幕上显示。高值在屏幕上显示为白点，而低值为黑点，高低值的变化无法有效分辨。为了在屏幕上凸显出高低变化的连续性，我们可以用对数尺度来替换线性尺度:

   转化为OpenCV代码:

   magI // 转换到对数尺度 log(magI, magI);

6. 剪切和重分布幅度图象限. 还记得我们在第一步时延扩了图像吗? 那现在是时候将新添加的像素剔除了。为了方便显示，我们也可以重新分布幅度图象限位置(注：将第五步得到的幅度图从中间划开得到四张1/4子图像，将每张子图像看成幅度图的一个象限，重新分布即将四个角点重叠到图片中心)。 这样的话原点(0,0)就位移到图像中心。

   2)); 2; 2; Mat q0(magI,144); font-style:italic">// Top-Left - 为每一个象限创建ROI Mat q1(magI,144); font-style:italic">// Top-Right Mat q2(magI,144); font-style:italic">// Bottom-Left Mat q3(magI,144); font-style:italic">// Bottom-Right Mat tmp; // 交换象限 (Top-Left with Bottom-Right) q0.copyTo(tmp); q3.copyTo(q0); tmp.copyTo(q3); q1.copyTo(tmp); // 交换象限 (Top-Right with Bottom-Left) q2.copyTo(q1); tmp.copyTo(q2);

7. 归一化. 这一步的目的仍然是为了显示。 现在我们有了重分布后的幅度图，但是幅度值仍然超过可显示范围[0,1] 。我们使用normalize()函数将幅度归一化到可显示范围。

normalize(magI,144); font-style:italic">// 将float类型的矩阵转换到可显示图像范围 // (float [0， 1]).

结果

离散傅立叶变换的一个应用是决定图片中物体的几何方向.比如，在文字识别中首先要搞清楚文字是不是水平排列的? 看一些文字，你就会注意到文本行一般是水平的而字母则有些垂直分布。文本段的这两个主要方向也是可以从傅立叶变换之后的图像看出来。我们使用这个水平文本图像以及旋转文本图像来展示离散傅立叶变换的结果 。

水平文本图像:

旋转文本图像:

观察这两张幅度图你会发现频域的主要内容(幅度图中的亮点)是和空间图像中物体的几何方向相关的。 通过这点我们可以计算旋转角度并修正偏差。

输入输出XML和YAML文件

  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
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

%YAML:1.0
iterationNr: 100
strings:
   - "image1.jpg"
   - Awesomeness
   - "baboon.jpg"
Mapping:
   One: 1
   Two: 2
R: !!opencv-matrix
   rows: 3
   cols: 3
   dt: u
   data: [ 1,1 ]
T: !!opencv-matrix
   rows: 3
   cols: 1
   dt: d
   data: [ 0.,0.,0. ]
MyData:
   A: 97
   X: 3.1415926535897931e+000
   id: mydata1234

与 OpenCV 1 同时使用 目的

对于OpenCV的开发团队来说，持续稳定地提高代码库非常重要。我们一直在思考如何在使其易用的同时保持灵活性。新的C++接口即为此而来。尽管如此，向下兼容仍然十分重要。我们并不想打断你基于早期OpenCV库的开发。因此，我们添加了一些函数来处理这种情况。在以下内容中你将学到：

概述

在用新版本之前，你首先需要学习一些新的图像数据结构：Mat - 基本图像容器，它取代了旧的CvMat和IplImage。转换到新函数非常容易，你仅需记住几条新的原则。

OpenCV 2 接受按需定制。所有函数不再装入一个单一的库中。我们会提供许多模块，每个模块都包含了与其功能相关的数据结构和函数。这样一来，如果你仅仅需要使用OpenCV的一部分功能，你就不需要把整个巨大的OpenCV库都装入你的程序中。使用时，你仅需要包含用到的头文件，比如：

所有OpenCV用到的东西都被放入名字空间cv中以避免与其他库的数据结构和函数名称的命名冲突。因此，在使用OpenCV库中的任何定义和函数时，你必须在名称之前冠以cv::，或者在包含头文件后，加上以下指令：

因为所有库中函数都已在此名字空间中，所以无需加cv作为前缀。据此所有新的C++兼容函数都无此前缀，并且遵循驼峰命名准则。也就是第一个字母为小写（除非是单个单词作为函数名，如 Canny）并且后续单词首字母大写（如copyMakeBorder).

接下来，请记住你需要将所有用到的模块链接到你的程序中。如果你在Windows下开发且用到了动态链接库（DLL），你还需要将OpenCV对应动态链接库的路径加入程序执行路径中。关于Windows下开发的更多信息请阅读How to build applications with OpenCV inside the Microsoft Visual Studio；对于Linux用户，可参考Using OpenCV with Eclipse (plugin CDT)中的实例及说明。

你可以使用IplImage或CvMat操作符来转换Mat对象。在C接口中，你习惯于使用指针，但此处将不再需要。在C++接口中，我们大多数情况下都是用Mat对象。此对象可通过简单的赋值操作转换为IplImage和CvMat。示例如下：

现在，如果你想获取指针，转换就变得麻烦一点。编译器将不能自动识别你的意图，所以你需要明确指出你的目的。可以通过调用IplImage和CvMat操作符来获取他们的指针。我们可以用 & 符号获取其指针如下：

来自C接口最大的抱怨是它将所有内存管理工作交给你来做。你需要知道何时可以安全释放不再使用的对象，并且确定在程序结束之前释放它，否则就会造成讨厌的内存泄露。为了绕开这一问题，OpenCV引进了一种智能指针。它将自动释放不再使用的对象。使用时，指针将被声明为Ptr模板的特化：

将C接口的数据结构转换为Mat时，可将其作为构造函数的参数传入，例如：

实例学习

现在，你已经学习了最基本的知识。这里你将会看到一个混合使用C接口和C++接口的例子。你也可以在可以再OpenCV的代码库中的sample目录中找到此文件samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp。为了进一步帮助你认清其中区别，程序支持两种模式：C和C++混合，以及纯C++。如果你宏定义了DEMO_MIXED_API_USE，程序将按第一种模式编译。程序的功能是划分颜色平面，对其进行改动并最终将其重新合并。

 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

在此，你可一看到新的结构再无指针问题，哪怕使用旧的函数，并在最后结束时将结果转换为Mat对象。

1
2
3
4
5
6

因为我们打算搞乱图像的亮度通道，所以首先将图像由默认的RGB颜色空间转为YUV颜色空间，然后将其划分为独立颜色平面（Y，U，V）。第一个例子中，我们对每一个平面用OpenCV中三个主要图像扫描算法（C []操作符，迭代，单独元素访问）中的一个进行处理。在第二个例子中，我们给图像添加一些高斯噪声，然后依据一些准则融合所有通道。

运用扫描算法的代码如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

此处可看到，我们可以以三种方式遍历图像的所有像素：迭代器，C指针和单独元素访问方式你可在OpenCV如何扫描图像、利用查找表和计时中获得更深入的了解。从旧的函数名转换新版本非常容易，仅需要删除 cv 前缀，并且使用Mat数据结构。下面的例子中使用了加权加法：

 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

正如你所见，变量planes也是Mat类型的。无论如何，将Mat转换为IplImage都可通过简单的赋值操作符自动实现。

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

新的imshowhighgui函数可接受Mat和IplImage数据结构。 编译并运行例程，如果输入以下第一幅图像，程序将输出以下第二幅或者第三幅图像。

你可以在点击此处看到动态示例：YouTube here，并可以点击此处下载源文件，或者在OpenCV源代码库中找到源文件：samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp。