Note

以下原理的说明来自书籍 学习OpenCV 作者Bradski和Kaehler.

霍夫线变换

1. 霍夫线变换是一种用来寻找直线的方法.
2. 是用霍夫线变换之前, 首先要对图像进行边缘检测的处理，也即霍夫线变换的直接输入只能是边缘二值图像.

#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"#include <iostream>using namespace cv;
using namespace std;void help()
{cout << "\nThis program demonstrates line finding with the Hough transform.\n""Usage:\n""./houghlines <image_name>, Default is pic1.jpg\n" << endl;
}int main(int argc, char** argv)
{const char* filename = argc >= 2 ? argv[1] : "pic1.jpg";Mat src = imread(filename, 0);if(src.empty()){help();cout << "can not open " << filename << endl;return -1;}Mat dst, cdst;Canny(src, dst, 50, 200, 3);cvtColor(dst, cdst, CV_GRAY2BGR);#if 0
  vector<Vec2f> lines;
  HoughLines(dst, lines, 1, CV_PI/180, 100, 0, 0 );  for( size_t i = 0; i < lines.size(); i++ )
  {     float rho = lines[i][0], theta = lines[i][1];
     Point pt1, pt2;
     double a = cos(theta), b = sin(theta);
     double x0 = a*rho, y0 = b*rho;
     pt1.x = cvRound(x0 + 1000*(-b));
     pt1.y = cvRound(y0 + 1000*(a));
     pt2.x = cvRound(x0 - 1000*(-b));
     pt2.y = cvRound(y0 - 1000*(a));
     line( cdst, pt1, pt2, Scalar(0,0,255), 3, CV_AA);
  }
 #else
  vector<Vec4i> lines;
  HoughLinesP(dst, lines, 1, CV_PI/180, 50, 50, 10 );
  for( size_t i = 0; i < lines.size(); i++ )
  {    Vec4i l = lines[i];
    line( cdst, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0,0,255), 3, CV_AA);
  }
 #endifimshow("source", src);imshow("detected lines", cdst);waitKey();return 0;
}

Note

得到的结果使用的是在上面 代码 部分提到的更高级版代码. 霍夫线变换的代码没有改变, 唯一不同的是在GUI的部分加入了活动条可动态改变阈值.输入图像为:

目标

在这个教程中你将学习如何:

• 使用OpenCV函数 HoughCircles 在图像中检测圆.

原理

例程

1. 这个例程是用来干嘛的?
   • 加载一幅图像并对其模糊化以降噪
   • 对模糊化后的图像执行霍夫圆变换 .
   • 在窗体中显示检测到的圆.
2. 下面要讲解的例程代码能从 这里 下载. 一个更高级的版本 (能同时演示标准霍夫圆变换和统计概率霍夫圆变换并带有可改变阈值的滑动条) 能从 这里 找到.

#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <iostream>
#include <stdio.h>using namespace cv;/** @function main */
int main(int argc, char** argv)
{Mat src, src_gray;/// Read the imagesrc = imread( argv[1], 1 );if( !src.data ){ return -1; }/// Convert it to graycvtColor( src, src_gray, CV_BGR2GRAY );/// Reduce the noise so we avoid false circle detectionGaussianBlur( src_gray, src_gray, Size(9, 9), 2, 2 );vector<Vec3f> circles;/// Apply the Hough Transform to find the circlesHoughCircles( src_gray, circles, CV_HOUGH_GRADIENT, 1, src_gray.rows/8, 200, 100, 0, 0 );/// Draw the circles detectedfor( size_t i = 0; i < circles.size(); i++ ){Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));int radius = cvRound(circles[i][2]);// circle centercircle( src, center, 3, Scalar(0,255,0), -1, 8, 0 );// circle outlinecircle( src, center, radius, Scalar(0,0,255), 3, 8, 0 );}/// Show your resultsnamedWindow( "Hough Circle Transform Demo", CV_WINDOW_AUTOSIZE );imshow( "Hough Circle Transform Demo", src );waitKey(0);return 0;
}

说明

1. 加载一幅图像

   src = imread( argv[1], 1 );if( !src.data ){ return -1; }
   

2. 转成灰度图:

   cvtColor( src, src_gray, CV_BGR2GRAY );
   

3. 执行高斯模糊以降低噪声:

   GaussianBlur( src_gray, src_gray, Size(9, 9), 2, 2 );
   

4. 执行霍夫圆变换:

   vector<Vec3f> circles;HoughCircles( src_gray, circles, CV_HOUGH_GRADIENT, 1, src_gray.rows/8, 200, 100, 0, 0 );
   

   函数带有以下自变量:

   • src_gray: 输入图像 (灰度图)
   • circles: 存储下面三个参数:  集合的容器来表示每个检测到的圆.
   • CV_HOUGH_GRADIENT: 指定检测方法. 现在OpenCV中只有霍夫梯度法
   • dp = 1: 累加器图像的反比分辨率
   • min_dist = src_gray.rows/8: 检测到圆心之间的最小距离
   • param_1 = 200: Canny边缘函数的高阈值
   • param_2 = 100: 圆心检测阈值.
   • min_radius = 0: 能检测到的最小圆半径, 默认为0.
   • max_radius = 0: 能检测到的最大圆半径, 默认为0

5. 绘出检测到的圆:

   for( size_t i = 0; i < circles.size(); i++ )
   {Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));int radius = cvRound(circles[i][2]);// circle centercircle( src, center, 3, Scalar(0,255,0), -1, 8, 0 );// circle outlinecircle( src, center, radius, Scalar(0,0,255), 3, 8, 0 );}
   

   你将会看到圆用红色绘出而圆心用小绿点表示

6. 显示检测到的圆:

   namedWindow( "Hough Circle Transform Demo", CV_WINDOW_AUTOSIZE );
   imshow( "Hough Circle Transform Demo", src );
   

7. 等待用户按键结束程序

   waitKey(0);
   

结果

上面例程输入一张图例得出的运行结果如下:

目标

本教程向你展示如何使用OpenCV函数 remap 来实现简单重映射.

理论

代码

1. 本程序做什么?
   • 装载一幅图像.
   • 程序按秒循环, 在一个窗口中顺序出现4种重映射过程对相同的图像.
   • 等待用户按 ‘ESC’ 键退出程序。
2. 下面是本教程代码. 你也可以从 这里 下载。

 #include "opencv2/highgui/highgui.hpp"#include "opencv2/imgproc/imgproc.hpp"#include <iostream>#include <stdio.h>using namespace cv;/// Global variablesMat src, dst;Mat map_x, map_y;char* remap_window = "Remap demo";int ind = 0;/// Function Headersvoid update_map( void );/**
 * @function main
 */int main( int argc, char** argv ){/// Load the imagesrc = imread( argv[1], 1 );/// Create dst, map_x and map_y with the same size as src:dst.create( src.size(), src.type() );map_x.create( src.size(), CV_32FC1 );map_y.create( src.size(), CV_32FC1 );/// Create windownamedWindow( remap_window, CV_WINDOW_AUTOSIZE );/// Loopwhile( true ){/// Each 1 sec. Press ESC to exit the programint c = waitKey( 1000 );if( (char)c == 27 ){ break; }/// Update map_x & map_y. Then apply remapupdate_map();remap( src, dst, map_x, map_y, CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0,0, 0) );/// Display resultsimshow( remap_window, dst );}return 0;}/**
 * @function update_map
 * @brief Fill the map_x and map_y matrices with 4 types of mappings
 */void update_map( void ){ind = ind%4;for( int j = 0; j < src.rows; j++ ){ for( int i = 0; i < src.cols; i++ ){switch( ind ){case 0:if( i > src.cols*0.25 && i < src.cols*0.75 && j > src.rows*0.25 && j < src.rows*0.75 ){map_x.at<float>(j,i) = 2*( i - src.cols*0.25 ) + 0.5 ;map_y.at<float>(j,i) = 2*( j - src.rows*0.25 ) + 0.5 ;}else{ map_x.at<float>(j,i) = 0 ;map_y.at<float>(j,i) = 0 ;}break;case 1:map_x.at<float>(j,i) = i ;map_y.at<float>(j,i) = src.rows - j ;break;case 2:map_x.at<float>(j,i) = src.cols - i ;map_y.at<float>(j,i) = j ;break;case 3:map_x.at<float>(j,i) = src.cols - i ;map_y.at<float>(j,i) = src.rows - j ;break;} // end of switch}}ind++;
}

说明

1. 首先准备程序用到的变量:

   Mat src, dst;
   Mat map_x, map_y;
   char* remap_window = "Remap demo";
   int ind = 0;
   

2. 加载一幅图像:

   src = imread( argv[1], 1 );
   

3. 创建目标图像和两个映射矩阵.( x 和 y )

   dst.create( src.size(), src.type() );
   map_x.create( src.size(), CV_32FC1 );
   map_y.create( src.size(), CV_32FC1 );
   

4. 创建一个窗口用于展示结果.

   namedWindow( remap_window, CV_WINDOW_AUTOSIZE );
   

5. 建立一个间隔1000毫秒的循环,每次循环执行更新映射矩阵参数并对源图像进行重映射处理(使用 mat_x 和 mat_y),然后把更新后的目标图像显示出来:

   while( true )
   {/// Each 1 sec. Press ESC to exit the programint c = waitKey( 1000 );if( (char)c == 27 ){ break; }/// Update map_x & map_y. Then apply remapupdate_map();remap( src, dst, map_x, map_y, CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0,0, 0) );/// Display resultsimshow( remap_window, dst );
   }
   

   上面用到的重映射函数 remap. 参数说明:

   • src: 源图像
   • dst: 目标图像，与 src 相同大小
   • map_x: x方向的映射参数. 它相当于方法  的第一个参数
   • map_y: y方向的映射参数. 注意 map_y 和 map_x 与 src 的大小一致。
   • CV_INTER_LINEAR: 非整数像素坐标插值标志. 这里给出的是默认值(双线性插值).
   • BORDER_CONSTANT: 默认

   如何更新重映射矩阵 mat_x 和 mat_y? 请继续看:

6. 更新重映射矩阵: 我们将分别使用4种不同的映射:

   1. 图像宽高缩小一半，并显示在中间:

      

      所有成对的参数  处理后都符合:  和 

   2. 图像上下颠倒: 

   3. 图像左右颠倒: 

   4. 同时执行b和c的操作: 

下面的代码片段说明上述的映射过程. 在这里 map_x 代表第一个坐标 h(i,j) , map_y 是第二个坐标.

for( int j = 0; j < src.rows; j++ )
{ for( int i = 0; i < src.cols; i++ ){switch( ind ){case 0:if( i > src.cols*0.25 && i < src.cols*0.75 && j > src.rows*0.25 && j < src.rows*0.75 ){map_x.at<float>(j,i) = 2*( i - src.cols*0.25 ) + 0.5 ;map_y.at<float>(j,i) = 2*( j - src.rows*0.25 ) + 0.5 ;}else{ map_x.at<float>(j,i) = 0 ;map_y.at<float>(j,i) = 0 ;}break;case 1:map_x.at<float>(j,i) = i ;map_y.at<float>(j,i) = src.rows - j ;break;case 2:map_x.at<float>(j,i) = src.cols - i ;map_y.at<float>(j,i) = j ;break;case 3:map_x.at<float>(j,i) = src.cols - i ;map_y.at<float>(j,i) = src.rows - j ;break;} // end of switch}}ind++;
}

结果

1. 上面的代码编译后, 运行时给一个图片路径参数. 例如,使用下面的图片:

   

2. 图像宽高缩小一半，并显示在中间:

   

3. 图像上下颠倒:

   

4. 图像左右颠倒:

   

5. 两个方向同时颠倒:

目标

在这个教程中你将学习到如何:

1. 使用OpenCV函数 warpAffine 来实现一些简单的重映射.
2. 使用OpenCV函数 getRotationMatrix2D 来获得一个  旋转矩阵

原理

例程

1. 这个例程是做什么的?
   • 加载一幅图片
   • 对这幅图片应用仿射变换. 这个变换是从源图像和目标图像的两组三点之间的联系获得的. 这一步我们使用函数warpAffine 来实现.
   • 仿射变换结束后再对图像应用旋转. 这里的旋转绕图像中点
   • 等待用户退出程序
2. 例程代码在下面给出. 当然你也可以从 这里 下载

#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <iostream>
#include <stdio.h>using namespace cv;
using namespace std;/// 全局变量
char* source_window = "Source image";
char* warp_window = "Warp";
char* warp_rotate_window = "Warp + Rotate";/** @function main */int main( int argc, char** argv ){Point2f srcTri[3];Point2f dstTri[3];Mat rot_mat( 2, 3, CV_32FC1 );Mat warp_mat( 2, 3, CV_32FC1 );Mat src, warp_dst, warp_rotate_dst;/// 加载源图像src = imread( argv[1], 1 );/// 设置目标图像的大小和类型与源图像一致warp_dst = Mat::zeros( src.rows, src.cols, src.type() );/// 设置源图像和目标图像上的三组点以计算仿射变换srcTri[0] = Point2f( 0,0 );srcTri[1] = Point2f( src.cols - 1, 0 );srcTri[2] = Point2f( 0, src.rows - 1 );dstTri[0] = Point2f( src.cols*0.0, src.rows*0.33 );dstTri[1] = Point2f( src.cols*0.85, src.rows*0.25 );dstTri[2] = Point2f( src.cols*0.15, src.rows*0.7 );/// 求得仿射变换warp_mat = getAffineTransform( srcTri, dstTri );/// 对源图像应用上面求得的仿射变换warpAffine( src, warp_dst, warp_mat, warp_dst.size() );/** 对图像扭曲后再旋转 *//// 计算绕图像中点顺时针旋转50度缩放因子为0.6的旋转矩阵Point center = Point( warp_dst.cols/2, warp_dst.rows/2 );double angle = -50.0;double scale = 0.6;/// 通过上面的旋转细节信息求得旋转矩阵rot_mat = getRotationMatrix2D( center, angle, scale );/// 旋转已扭曲图像warpAffine( warp_dst, warp_rotate_dst, rot_mat, warp_dst.size() );/// 显示结果namedWindow( source_window, CV_WINDOW_AUTOSIZE );imshow( source_window, src );namedWindow( warp_window, CV_WINDOW_AUTOSIZE );imshow( warp_window, warp_dst );namedWindow( warp_rotate_window, CV_WINDOW_AUTOSIZE );imshow( warp_rotate_window, warp_rotate_dst );/// 等待用户按任意按键退出程序waitKey(0);return 0;}

说明

1. 定义一些需要用到的变量, 比如需要用来储存中间和目标图像的Mat和两个需要用来定义仿射变换的二维点数组.

   Point2f srcTri[3];
   Point2f dstTri[3];Mat rot_mat( 2, 3, CV_32FC1 );
   Mat warp_mat( 2, 3, CV_32FC1 );
   Mat src, warp_dst, warp_rotate_dst;
   

2. 加载源图像:

   src = imread( argv[1], 1 );
   

3. 以与源图像同样的类型和大小来对目标图像初始化:

   warp_dst = Mat::zeros( src.rows, src.cols, src.type() );
   

4. 仿射变换: 正如上文所说, 我们需要源图像和目标图像上分别一一映射的三个点来定义仿射变换:

   srcTri[0] = Point2f( 0,0 );
   srcTri[1] = Point2f( src.cols - 1, 0 );
   srcTri[2] = Point2f( 0, src.rows - 1 );dstTri[0] = Point2f( src.cols*0.0, src.rows*0.33 );
   dstTri[1] = Point2f( src.cols*0.85, src.rows*0.25 );
   dstTri[2] = Point2f( src.cols*0.15, src.rows*0.7 );
   

   你可能想把这些点绘出来以获得对变换的更直观感受. 他们的位置大概就是在上面图例中的点的位置 (原理部分). 你会注意到由三点定义的三角形的大小和方向改变了.

5. 通过这两组点, 我们能够使用OpenCV函数 getAffineTransform 来求出仿射变换:

   warp_mat = getAffineTransform( srcTri, dstTri );
   

   我们获得了用以描述仿射变换的  矩阵 (在这里是 warp_mat)

6. 将刚刚求得的仿射变换应用到源图像

   warpAffine( src, warp_dst, warp_mat, warp_dst.size() );
   

   函数有以下参数:

   • src: 输入源图像
   • warp_dst: 输出图像
   • warp_mat: 仿射变换矩阵
   • warp_dst.size(): 输出图像的尺寸

   这样我们就获得了变换后的图像! 我们将会把它显示出来. 在此之前, 我们还想要旋转它...

7. 旋转: 想要旋转一幅图像, 你需要两个参数:

   1. 旋转图像所要围绕的中心
   2. 旋转的角度. 在OpenCV中正角度是逆时针的
   3. 可选择: 缩放因子

   我们通过下面的代码来定义这些参数:

   Point center = Point( warp_dst.cols/2, warp_dst.rows/2 );
   double angle = -50.0;
   double scale = 0.6;
   

8. 我们利用OpenCV函数 getRotationMatrix2D 来获得旋转矩阵, 这个函数返回一个  矩阵 (这里是 rot_mat)

   rot_mat = getRotationMatrix2D( center, angle, scale );
   

9. 现在把旋转应用到仿射变换的输出.

   warpAffine( warp_dst, warp_rotate_dst, rot_mat, warp_dst.size() );
   

10. 最后我们把仿射变换和旋转的结果绘制在窗体中，源图像也绘制出来以作参照:

    namedWindow( source_window, CV_WINDOW_AUTOSIZE );
    imshow( source_window, src );namedWindow( warp_window, CV_WINDOW_AUTOSIZE );
    imshow( warp_window, warp_dst );namedWindow( warp_rotate_window, CV_WINDOW_AUTOSIZE );
    imshow( warp_rotate_window, warp_rotate_dst );
    

11. 等待用户退出程序

    waitKey(0);
    

结果

1. 编译上述例程之后, 我们给出一个图像的路径作为参数. 比如这样一幅图片:

   

   仿射变换后我们获得:

   

   最后, 应用了一个负角度旋转 (记住负角度指的是顺时针) 和基于一个缩放因子的缩放之后, 我们得到: