java 图片中的二维码定位
使用技术：opencv 3.4.14 执行下载安装
import com.google.zxing.*;
import com.google.zxing.client.j2se.BufferedImageLuminanceSource;
import com.google.zxing.common.HybridBinarizer;
import org.opencv.core.*;
import org.opencv.core.Point;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.QRCodeDetector;
import org.opencv.utils.Converters;
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.InputStream;
import java.util.*;
import java.util.List;
/**
* 参考：https://www.cnblogs.com/huacanfly/p/9908408.html
* 参考：https://blog.csdn.net/StrangeSir/article/details/93143177
* 参考：https://opencv.org/releases/
*/
public class OpenCVQrCodePosition {
private boolean isDebug = true;
static {
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
}
// 获取二维码图片位置信息
public Point[] getPosition(String imgUrl){
Mat src = Imgcodecs.imread(imgUrl ,1);
Mat src_gray = new Mat();
List<MatOfPoint> contours = new ArrayList<MatOfPoint>();
//彩色图转灰度图
Imgproc.cvtColor(src ,src_gray ,Imgproc.COLOR_RGB2GRAY);
//对图像进行平滑处理
Imgproc.GaussianBlur(src_gray, src_gray, new Size(3,3), 0);
this.printImg("1-1.jpg", src_gray);
Imgproc.Canny(src_gray,src_gray,112,255);
this.printImg("1-2.jpg", src_gray);
Mat hierarchy = new Mat();
// 寻找轮廓
Imgproc.findContours(src_gray ,contours ,hierarchy ,Imgproc.RETR_TREE ,Imgproc.CHAIN_APPROX_NONE);
List<MatOfPoint> markContours = this.markContour(src_gray, contours, hierarchy);
markContours = this.filterByAngle(markContours);
Point[] points = this.centerCals(markContours);
if(points != null){
this.cutRect(src, points, 12);
}
return points;
}
// 裁剪指定区域
public BufferedImage cutRect(Mat src,Point[] points, int offset){
if(points == null || points.length < 3){
System.out.println("-------没有点---------");
return null;
}
int left_x = (int)Math.min(points[0].x, Math.min(points[1].x, points[2].x)) - offset;
int right_x = (int)Math.max(points[0].x, Math.max(points[1].x, points[2].x)) + offset;
int y = (int)Math.min(points[0].y, Math.min(points[1].y, points[2].y)) - offset;
Rect roiArea = new Rect(left_x, y, right_x - left_x, right_x - left_x);
Mat dstRoi = new Mat(src, roiArea);
this.printImg("cutRect.jpg", dstRoi);
return this.mat2BufImg(dstRoi, ".png");
}
// 通过角度筛选点， 只处理正常角度二维码
private List<MatOfPoint> filterByAngle(List<MatOfPoint> markContours) {
// 二维码有三个角轮廓，少于三个的无法定位放弃，多余三个的循环裁剪出来
if (markContours.size() < 3){
return null;
}else{
for (int i=0; i<markContours.size()-2; i++){
List<MatOfPoint> threePointList = new ArrayList<>();
for (int j=i+1;j<markContours.size()-1; j++){
for (int k=j+1;k<markContours.size();k++){
threePointList.add(markContours.get(i));
threePointList.add(markContours.get(j));
threePointList.add(markContours.get(k));
if(capture(threePointList)){
return threePointList;
}else{
threePointList.clear();
}
}
}
}
}
return null;
}
// 计算三个点是否符合 90，45，45
private boolean capture(List<MatOfPoint> contours){
Point[] pointthree = this.centerCals(contours);
double angle1 = this.angle(pointthree[1], pointthree[0], pointthree[2]);
double angle2 = this.angle(pointthree[0], pointthree[1], pointthree[2]);
double angle3 = this.angle(pointthree[1], pointthree[2], pointthree[0]);
System.out.println("angle1:"+angle1+",angle2:"+angle2+",angle3:"+angle3);
if (Double.isNaN(angle1) || Double.isNaN(angle2) || Double.isNaN(angle3)){
return false;
}
// 最大角度和最小角度
double maxAngle = Math.max(angle3,Math.max(angle1,angle2));
double minAngle = Math.min(angle3,Math.min(angle1,angle2));
if (maxAngle<85 || maxAngle>95 || minAngle < 40 || minAngle > 50){
/**二维码为直角，最大角过大或者过小都判断为不是二维码*/
return false;
}
return true;
}
// 计算夹角
private double angle(Point p1, Point p2, Point p3){
double[] ca = new double[2];
double[] cb = new double[2];
ca[0] = p1.x - p2.x;
ca[1] = p1.y - p2.y;
cb[0] = p3.x - p2.x;
cb[1] = p3.y - p2.y;
return 180/3.1415*Math.acos((ca[0]*cb[0]+ca[1]*cb[1])/(Math.sqrt(ca[0]*ca[0]+ca[1]*ca[1])*Math.sqrt(cb[0]*cb[0]+cb[1]*cb[1])));
}
// 转换为点
private Point[] centerCals(List<MatOfPoint> matOfPoint){
if(matOfPoint == null || matOfPoint.size() == 0){
return null;
}
Point[] pointthree = new Point[matOfPoint.size()];
for(int i=0; i<matOfPoint.size(); i++){
pointthree[i] = centerCal(matOfPoint.get(i));
}
return pointthree;
}
// 转换为中心点
private Point centerCal(MatOfPoint matOfPoint){
double centerx=0,centery=0;
MatOfPoint2f mat2f = new MatOfPoint2f( matOfPoint.toArray() );
RotatedRect rect = Imgproc.minAreaRect( mat2f );
Point vertices[] = new Point[4];
rect.points(vertices);
centerx = ((vertices[0].x + vertices[1].x)/2 + (vertices[2].x + vertices[3].x)/2)/2;
centery = ((vertices[0].y + vertices[1].y)/2 + (vertices[2].y + vertices[3].y)/2)/2;
Point point= new Point(centerx,centery);
return point;
}
// 寻找二维码轮廓点
private List<MatOfPoint> markContour(Mat src_gray, List<MatOfPoint> contours, Mat hierarchy) {
List<MatOfPoint> markContours = new ArrayList<>();
for (int i = 0; i< contours.size(); i++ ) {
MatOfPoint2f newMtx = new MatOfPoint2f(contours.get(i).toArray() );
RotatedRect rotRect = Imgproc.minAreaRect( newMtx );
double w = rotRect.size.width;
double h = rotRect.size.height;
double rate = Math.max(w, h)/Math.min(w, h) ;
//长短轴比小于1.3，总面积大于60
if (rate < 1.3 && w < src_gray.cols()/4 && h< src_gray.rows()/4 && Imgproc.contourArea(contours.get(i))>60) {
//计算层数，二维码角框有五层轮廓（有说六层），这里不计自己这一层，有4个以上子轮廓则标记这一点
double[] ds = hierarchy.get(0, i);
if (ds != null && ds.length>3){
int count =0;
if (ds[3] == -1){
/**最外层轮廓排除*/
continue;
}
//计算所有子轮廓数量
while ((int) ds[2] !=-1){
++count;
ds = hierarchy.get(0 ,(int) ds[2]);
}
if (count >= 4){
markContours.add(contours.get(i));
}
}
}
}
return markContours;
}
// 测试打印图片
private void printImg(String name, Mat img){
if(isDebug) {
String path = String.format("%s/%s", System.getProperty("user.dir"), name);
System.out.println("out:" + path);
Imgcodecs.imwrite(path, img);
}
}
/**
* Mat转换成BufferedImage
*
* @param matrix 要转换的Mat
* @param fileExtension 格式为 ".jpg", ".png", etc
* @return
*/
public static BufferedImage mat2BufImg(Mat matrix, String fileExtension) {
// convert the matrix into a matrix of bytes appropriate for
// this file extension
MatOfByte mob = new MatOfByte();
Imgcodecs.imencode(fileExtension, matrix, mob);
// convert the "matrix of bytes" into a byte array
byte[] byteArray = mob.toArray();
BufferedImage bufImage = null;
try {
InputStream in = new ByteArrayInputStream(byteArray);
bufImage = ImageIO.read(in);
} catch (Exception e) {
e.printStackTrace();
}
return bufImage;
}
/**
* BufferedImage转换成Mat
*
* @param original
* 要转换的BufferedImage
* @param imgType
* bufferedImage的类型 如 BufferedImage.TYPE_3BYTE_BGR
* @param matType
* 转换成mat的type 如 CvType.CV_8UC3
*/
public static Mat bufImg2Mat (BufferedImage original, int imgType, int matType) {
if (original == null) {
throw new IllegalArgumentException("original == null");
}
// Don't convert if it already has correct type
if (original.getType() != imgType) {
// Create a buffered image
BufferedImage image = new BufferedImage(original.getWidth(), original.getHeight(), imgType);
// Draw the image onto the new buffer
Graphics2D g = image.createGraphics();
try {
g.setComposite(AlphaComposite.Src);
g.drawImage(original, 0, 0, null);
} finally {
g.dispose();
}
}
DataBufferByte dbi = (DataBufferByte) original.getRaster().getDataBuffer();
byte[] pixels = dbi.getData();
Mat mat = Mat.eye(original.getHeight(), original.getWidth(), matType);
mat.put(0, 0, pixels);
return mat;
}
/**
* 解析读取二维码
* 先使用ZXING二维码识别，若失败，使用OPENCV自带的二维码识别
* 个人测试，两者的识别率差不多，都不尽人意，但一起使用还是可以略微提高一点识别率，毕竟实现算法不一样
* 若还要其它的识别，类似Zbar，都可以集成进来
*
* @param qrCodePath 二维码图片路径
* @return 成功返回二维码识别结果，失败返回null
* @throws Exception
*/
public static String decodeQRcode(String qrCodePath){
String qrCodeText = null;
try {
BufferedImage image = ImageIO.read(new File(qrCodePath));
LuminanceSource source = new BufferedImageLuminanceSource(image);
Binarizer binarizer = new HybridBinarizer(source);
BinaryBitmap binaryBitmap = new BinaryBitmap(binarizer);
Map<DecodeHintType, Object> hints = new HashMap<DecodeHintType, Object>();
hints.put(DecodeHintType.CHARACTER_SET, "UTF-8");
Result result = new MultiFormatReader().decode(binaryBitmap, hints);
qrCodeText = result.getText();
} catch (Exception e) {
qrCodeText = new QRCodeDetector().detectAndDecode(Imgcodecs.imread(qrCodePath, 1));
}
return qrCodeText;
}
public static void main(String[] args) {
String img = "C:\\Users\\jonk\\Desktop\\2.png";
Point[] points = new OpenCVQrCodePosition().getPosition(img);
if(points == null) {
System.out.println("可能不包含二维码:"+img);
return;
}
for (int i = 0; i < points.length; i++) {
Point p = points[i];
System.out.println("点" + i + ": " + "(" + p.x + "," + p.y + ")");
}
QRCodeDetector detector = new QRCodeDetector();
String path = String.format("%s/%s", System.getProperty("user.dir"), "cutRect.jpg");
System.out.println("读取二维码："+path);
String qrCodeText = decodeQRcode(path);
System.out.println("二维码内容："+ qrCodeText);
}
}
运行结果
out:C:\Users\jonk\workspace\springcloud\opencv/1-1.jpg
out:C:\Users\jonk\workspace\springcloud\opencv/1-2.jpg
angle1:80.21728934490619,angle2:68.08326088303801,angle3:31.704758588278217
angle1:35.215962140850586,angle2:125.8393600086319,angle3:18.949986666739946
angle1:45.001327204055606,angle2:90.00265440811121,angle3:45.001327204055606
out:C:\Users\jonk\workspace\springcloud\opencv/cutRect.jpg
点0: (495.5,743.5)
点1: (495.5,623.5)
点2: (375.5,623.5)
参考文档：https://www.cnblogs.com/huacanfly/p/9908408.html
参考文档：https://blog.csdn.net/StrangeSir/article/details/93143177