基于傅里叶变换的旋转文本图像矫正

首先介绍一下我的算法思路：

1. 先用傅里叶变换求出频域的图像
2. 利用霍夫直线变换求出里面的直线的旋转角度
3. 根据倾斜角旋转矫正

然后给出OpenCV的实现算法：

#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
using namespace cv;
using namespace std;

//傅里叶变化模块
Mat DFT(Mat srcImage)
{
	//1.转换位灰度图
	Mat srcGray;
	cvtColor(srcImage, srcGray, CV_BGR2GRAY);

	//2.将输入图像延扩到最佳的尺寸，边界用0填充
	int nRows = getOptimalDFTSize(srcGray.rows);
	int nCols = getOptimalDFTSize(srcGray.cols);

	Mat padded;
	//BORDER_CONSTANT是填充是常数的意思，填充的数是后面的0
	copyMakeBorder(srcGray, padded, 0, nRows - srcGray.rows, 0, nCols - srcGray.cols, BORDER_CONSTANT, Scalar::all(0));

	//3.为傅里叶变换的结果（实部与虚部）分别存储空间
	Mat planes[] = { Mat_<float>(padded),Mat::zeros(padded.size(),CV_32F) };
	Mat complexI;
	//将planes数组组合合并成一个多通道的数组complexI
	merge(planes, 2, complexI);//将两个数组合并成一个多通道的数组

	//4.进行离散傅里叶变换
	dft(complexI, complexI);
	//5.将复数转化为幅值
	// planes[0] = Re(DFT(I), planes[1] = Im(DFT(I)
	split(complexI, planes);//将多通道数组complexI分解为几个单通道的数组
	//magnitude(x,y,dst);dst=sqrt(x(I)^2+y(I)^2);
	magnitude(planes[0], planes[1], planes[0]);
	Mat magnitudeImage = planes[0];//傅里叶变换的幅值矩阵
	//6.进行对数尺度缩放
	magnitudeImage += Scalar::all(1);//对幅值都加1
	log(magnitudeImage, magnitudeImage);
	//归一化，用0到1之间的浮点值将矩阵变换为可视的图像格式
	normalize(magnitudeImage, magnitudeImage, 0, 1, CV_MINMAX);
	//图像类型转换，为了下一步的霍夫直线检测做准备
	magnitudeImage.convertTo(magnitudeImage, CV_8UC1, 255, 0);
	//7.剪切与重分布幅度图象限
	//若有奇数行或者奇数列，进行频谱裁剪
	magnitudeImage = magnitudeImage(Rect(0, 0, magnitudeImage.cols & -2, magnitudeImage.rows & -2));
	//重新排列傅里叶图像中的象限，使得原点位于图像中心
	int cx = magnitudeImage.cols / 2;
	int cy = magnitudeImage.rows / 2;
	Mat q0(magnitudeImage, Rect(0, 0, cx, cy));//ROI区域的左上
	Mat q1(magnitudeImage, Rect(cx, 0, cx, cy));//ROI区域的右上
	Mat q2(magnitudeImage, Rect(0, cy, cx, cy));//ROI区域的左下
	Mat q3(magnitudeImage, Rect(cx, cy, cx, cy));//ROI区域的右上

	//交换象限（左上与右下进行交换）
	Mat temp;
	q0.copyTo(temp);
	q3.copyTo(q0);
	temp.copyTo(q3);
	//交换象限（右上与左下进行交换）
	q1.copyTo(temp);
	q2.copyTo(q1);
	temp.copyTo(q2);
	
	return magnitudeImage;
}
//倾斜角检测  返回检测到的倾斜角
float AngleDetection(Mat srcImage)
{
	int nRows = srcImage.rows;
	int nCols = srcImage.cols;
	Mat binaryMat;
	//对傅里叶变换之后的图像进行二值化处理
	threshold(srcImage, binaryMat, 132, 255, CV_THRESH_BINARY);
	imshow("binaryMat", binaryMat);//显示二值图像
	//霍夫变换
	vector<Vec2f> lines;
	binaryMat.convertTo(binaryMat, CV_8UC1, 255, 0);
	HoughLines(binaryMat, lines, 1, CV_PI / 180, 100, 0, 0);
	//检测线的个数
	cout <<"lines.size:"<<lines.size() << endl;
	//创建一张直线检测图形
	Mat houghMat(binaryMat.size(), CV_8UC3);
	//绘制线检测
	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(houghMat, pt1, pt2, Scalar(255, 0, 0), 3, CV_AA);
	}
	//显示绘制的图
	imshow("houghMat", houghMat);

	float theta2 = 0;
	//检测线角度判断
	//因为文本检测的时候有三条直线，一条水平，一条垂直，还有一条就是我们需要的直线
	for (size_t i = 0; i < lines.size(); i++)
	{
		float ThetaTemp = lines[i][1] * 180 / CV_PI;
		//找出我们需要的那条直线就退出循环
		if (ThetaTemp > 0 && ThetaTemp < 90)
		{
			theta2 = ThetaTemp;
			break;
		}
	}
	//角度转换
	float angelT = nRows*tan(theta2 / 180 * CV_PI) / nCols;
	theta2 = atan(angelT) * 180 / CV_PI;
	cout << "theta2:" << theta2 << endl;
	return theta2;
}

//旋转图像
Mat RotIamge(Mat &srcImage, float Angle) //旋转角度然后返回一张旋转后的图像
{
	//以图像的中心为原点求出原图中的四个角的坐标
	float SrcX1, SrcY1, SrcX2, SrcY2, SrcX3, SrcY3, SrcX4, SrcY4;
	//新图中四个角的坐标
	float DstX1, DstY1, DstX2, DstY2, DstX3, DstY3, DstX4, DstY4;
	//将角度转换位弧度
	float alpha = Angle*CV_PI / 180;
	//原图的宽高
	int Wold = srcImage.cols;
	int Hold = srcImage.rows;

	//假设原图的原点在原图的中心主要是为了求出新图的宽高
	//原图的四个角的坐标
	SrcX1 = (float)((-0.5)*Wold);
	SrcY1 = (float)((0.5)*Hold);
	SrcX2 = (float)((0.5)*Wold);
	SrcY2 = (float)((0.5)*Hold);
	SrcX3 = (float)((-0.5)*Wold);
	SrcY3 = (float)((-0.5)*Hold);
	SrcX4 = (float)((0.5)*Wold);
	SrcY4 = (float)((-0.5)*Hold);
	//求出cosa 和sina
	float cosa = cos(alpha);
	float sina = sin(alpha);

	//求出新图的四个角的坐标
	DstX1 = cosa*SrcX1 + sina*SrcY1;
	DstY1 = -sina*SrcX1 + cosa*SrcY1;
	DstX2 = cosa*SrcX2 + sina*SrcY2;
	DstY2 = -sina*SrcX2 + cosa*SrcY2;
	DstX3 = cosa*SrcX3 + sina*SrcY3;
	DstY3 = -sina*SrcX3 + cosa*SrcY3;
	DstX4 = cosa*SrcX4 + sina*SrcY4;
	DstY4 = -sina*SrcX4 + cosa*SrcY4;

	//计算新图的宽和高
	int Wnew = cvRound(max(abs(DstX4 - DstX1), abs(DstX3 - DstX2)));
	int Hnew = cvRound(max(abs(DstY4 - DstY1), abs(DstY3 - DstY2)));

	//计算矩阵中的两个常数
	float num1 = (float)(-0.5*Wnew*cosa - 0.5*Hnew*sina + 0.5*Wold);
	float num2 = (float)(0.5*Wnew*sina - 0.5*Hnew*cosa + 0.5*Hold);
	//创建一张新的大小的图
	Mat resultImage(Hnew, Wnew, srcImage.type());
	for (int i = 0; i < Hnew; i++) //rows
	{
		for (int j = 0; j < Wnew; j++)//cols
		{
			//求出新图中的像素在原图的位置
			int x = cvRound(i*cosa + j*sina + num1);
			int y = cvRound(-sina*i + j*cosa + num2);
			if ((x >= 0) && (x < Wold) && (y >= 0) && (y < Hold))//在原图中的范围
			{
				resultImage.at<Vec3b>(i, j) = srcImage.at<Vec3b>(x, y);
			}
		}
	}
	return resultImage;
}
int main()
{
	Mat srcImage = imread("text.jpg");
	if (!srcImage.data)
	{
		printf("could not load image...\n");
		return -1;
	}
	imshow("srcImage", srcImage);
	//输出傅里叶变换之后的图形
	Mat DFTImage = DFT(srcImage);
	imshow("DFT", DFTImage);
	//求出傅里叶变换里面的倾斜角
	float theta = AngleDetection(DFTImage);
	Mat retultImage=RotIamge(srcImage, theta);
	imshow("res", retultImage);
	waitKey(0);
	return 0;
}

下面给出原图和效果图：

原图：

傅里叶变化图：

傅里叶变换的二值图像图：

霍夫直线检测图：

最后的效果图：

这个小小的案例也算是对前期的一个总结吧！希望自己更加的加把劲好好学习！