java 结合opencv图片旋转

package com.dinghui;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import javax.imageio.ImageIO;

import javax.swing.plaf.basic.BasicInternalFrameTitlePane.MaximizeAction;

import org.opencv.core.Core;

import org.opencv.core.Mat;

import org.opencv.core.Point;

import org.opencv.core.Scalar;

import org.opencv.highgui.Highgui;

import org.opencv.imgproc.Imgproc;

import sun.security.krb5.Config;

import com.dinghui.showimage.Main;

import com.sun.org.apache.bcel.internal.generic.IF_ACMPEQ;

import com.sun.org.apache.xml.internal.serializer.utils.Utils;

public class BitmapHoughTransFormLine {

public static void main(String[] args) {

// TODO Auto-generated method stub

System.loadLibrary(“opencv_;

try {

BitmapHoughTransFormLine bitmapHoughTransFormLine = new BitmapHoughTransFormLine();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

Mat rgbMat;

private BitmapHoughTransFormLine( ) throws IOException

{

rgbMat  = Highgui.imread("./Image/test2.jpg");  //存储原图像的矩阵

Mat grayMat = new Mat(); //存储灰度图像的矩阵

Mat lineMat = new Mat(); //存储检测出的直线坐标的矩阵，每个element有4个通道，第1、2个通道为直线的1个端点，第3、4个通道为直线的另1个端点

Imgproc.cvtColor(rgbMat,grayMat, Imgproc.COLOR_RGB2GRAY); //灰度化

Imgproc.Canny(grayMat, grayMat,50, 200);                  //Canny边缘检测

// Imgproc.HoughLinesP(grayMat,lineMat, 1, Math.PI/180,50, 50.0, 10.0);
Imgproc.HoughLinesP(grayMat, lineMat, 5, 6, 9);
System.out.println("lineMat.total():"+lineMat.total());
System.out.println("lineMat.channels():"+lineMat.channels());

int[] a = new int[(int)lineMat.total()*lineMat.channels()]; //数组a存储检测出的直线端点坐标

lineMat.get(0,0,a); //
System.out.print(a.length);
//System.out.print()
int max =1;
//得到水平线为最长一根线的坐标
int x1=0 ,y1=0,x2=0,y2=0;
for(int i=0;i
if(a[i+2]-a[i]>max) {
max=Math.max((a[i+2]-a[i]), max);
x1=a[i];
y1=a[i+1];
x2=a[i+2];
y2=a[i+3];
}
}

System.out.println("max"+max);
//得到一条倾斜的直线
//Core.line(grayMat, new Point(a[i], a[i+1]), new Point(a[i+2], a[i+3]), new Scalar(255, 0, 255),4);
//计算水平线最长直线的倾斜角
int angle= Util.angle(x1, y1, x2, y2);
BufferedImage src = Imag
4000
eIO.read(new File("./Image/test2.jpg"));
//根据倾斜角将图片旋转为正立的图片
BufferedImage des = RotateImage.Rotate(src, angle);
//将旋转后的图片写入硬盘
ImageIO.write(des, "jpg", new File("./Image/test3.jpg"));
grayMat= Highgui.imread("./Image/test3.jpg");

//将旋转后的图片进行展示
//  TransferProcess.transferAlpha("./Image/test3.jpg","./Image/test4.jpg",0);

Imgproc.cvtColor(grayMat,grayMat, Imgproc.COLOR_RGB2GRAY); //灰度化

Imgproc.Canny(grayMat, grayMat,50, 200);                  //Canny边缘检测

// Imgproc.HoughLinesP(grayMat,lineMat, 1, Math.PI/180,50, 50.0, 10.0);
Imgproc.HoughLinesP(grayMat, lineMat, 1, 3, 5);
lineMat.get(0,0,a); //
for (int i = 0; i < a.length; i+=4) {
Core.line(grayMat, new Point(a[i], a[i+1]), new Point(a[i+2], a[i+3]), new Scalar(255, 0, 255),4);

}

Main.showResult(grayMat);

rgbMat = null;

grayMat = null;

lineMat = null;

a = null;

}

//检查偏转角度

package com.dinghui;

public class Util {

public static int angle(int x1,int y1,int x2,int y2){

int angle = 0;

int x=Math.abs(x1-x2);

int y=Math.abs(y1-y2);

double z=Math.sqrt(x*x+y*y);

angle=Math.round((float)(Math.asin(y/z)/Math.PI*180));//最终角度

return angle;

}

}

//旋转图片

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Rectangle;

import java.awt.image.BufferedImage;

public class RotateImage {

public static BufferedImage Rotate(Image src, int angel) {
int src_width = src.getWidth(null );
int src_height = src.getHeight(null);
// calculate the new image size
Rectangle rect_des = CalcRotatedSize(new Rectangle(new Dimension(
src_width, src_height)), angel);

BufferedImage res = null;
res = new BufferedImage(rect_des.width, rect_des.height,
BufferedImage.TYPE_INT_RGB);  //TYPE_INT_RGB
Graphics2D g2 = res.createGraphics();
Graphics2D g3 = res.createGraphics();
// transform
g2.translate((rect_des.width - src_width)  ,
(rect_des.height - src_height)  );
g2.rotate(Math.toRadians(angel), src_width  , src_height );
System.out.print("颜色"+g2.getColor()) ;
g3.setPaint(Color.WHITE);
g3.fill(rect_des);
System.out.print("颜色1"+g2.getColor()) ;
g2.drawImage(src, null, null);
return res;
}

public static Rectangle CalcRotatedSize(Rectangle src, int angel) {
// if angel is greater than 90 degree, we need to do some conversion
if (angel >= 90) {
if(angel / 90 % 2 == 1){
int temp = src.height;
src.height = src.width;
src.width = temp;
}
angel = angel % 90;
}

double r = Math.sqrt(src.height * src.height + src.width * src.width) / 2;
double len = 2 * Math.sin(Math.toRadians(angel) / 2) * r;
double angel_alpha = (Math.PI - Math.toRadians(angel)) / 2;
double angel_dalta_width = Math.atan((double) src.height / src.width);
double angel_dalta_height = Math.atan((double) src.width / src.height);

int len_dalta_width = (int) (len * Math.cos(Math.PI - angel_alpha
- angel_dalta_width));
int len_dalta_height = (int) (len * Math.cos(Math.PI - angel_alpha
- angel_dalta_height));
int des_width = src.width + len_dalta_width * 2;
int des_height = src.height + len_dalta_height * 2;
return new java.awt.Rectangle(new Dimension(des_width, des_height));
}

}