java基于OpenCV进行图片纠正

// 根据三个点计算中间那个点的夹角   pt1 pt0 pt2
   private static double getAngle(Point pt1, Point pt2, Point pt0)
   {
       double dx1 = pt1.x - pt0.x;
       double dy1 = pt1.y - pt0.y;
       double dx2 = pt2.x - pt0.x;
       double dy2 = pt2.y - pt0.y;
       return (dx1*dx2 + dy1*dy2)/Math.sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10);
   }

   // 找到最大的正方形轮廓
   private static int findLargestSquare(List<MatOfPoint> squares) {
       if (squares.size() == 0)
           return -1;
       int max_width = 0;
       int max_height = 0;
       int max_square_idx = 0;
       int currentIndex = 0;
       for (MatOfPoint square : squares) {
           Rect rectangle = Imgproc.boundingRect(square);
           if (rectangle.width >= max_width && rectangle.height >= max_height) {
               max_width = rectangle.width;
               max_height = rectangle.height;
               max_square_idx = currentIndex;
           }
           currentIndex++;
       }
       return max_square_idx;
   }

   // 点到点的距离
   private static double getSpacePointToPoint(Point p1, Point p2) {
       double a = p1.x - p2.x;
       double b = p1.y - p2.y;
       return Math.sqrt(a * a + b * b);
   }

   // 两直线的交点
   private static Point computeIntersect(double[] a, double[] b) {
       if (a.length != 4 || b.length != 4)
           {throw new ClassFormatError();}
       double x1 = a[0], y1 = a[1], x2 = a[2], y2 = a[3], x3 = b[0], y3 = b[1], x4 = b[2], y4 = b[3];
       double d = ((x1 - x2) * (y3 - y4)) - ((y1 - y2) * (x3 - x4));
       if (d != 0) {
           Point pt = new Point();
           pt.x = ((x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4)) / d;
           pt.y = ((x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4)) / d;
           return pt;
       }
       else{
           return new Point(-1, -1);
       }
   }

   // 对多个点按顺时针排序
   private static void sortCorners(List<Point> corners) {
       if (corners.size() == 0) return;
       Point p1 = corners.get(0);
       int index = 0;
       for (int i = 1; i < corners.size(); i++) {
           Point point = corners.get(i);
           if (p1.x > point.x) {
               p1 = point;
               index = i;
           }
       }

       corners.set(index, corners.get(0));
       corners.set(0, p1);

       Point lp = corners.get(0);
       for (int i = 1; i < corners.size(); i++) {
           for (int j = i + 1; j < corners.size(); j++) {
               Point point1 = corners.get(i);
               Point point2 = corners.get(j);
               if ((point1.y-lp.y*1.0)/(point1.x-lp.x)>(point2.y-lp.y*1.0)/(point2.x-lp.x)) {
                   Point temp = point1.clone();
                   corners.set(i, corners.get(j));
                   corners.set(j, temp);
               }
           }
       }
   }

上面是待会要用到的计算函数

接下来就是主要的识别函数

private void Correct(Mat src) {
		Mat[] mat_list = new Mat[9];
		int img_w = src.cols();
		int img_h = src.rows();
		Mat gary = new Mat();
		Mat edges = new Mat();
		Mat hierarchy =new Mat();
		Mat rotated_image = new Mat();
		Mat crop_image = new Mat();
		List<MatOfPoint> contours = new ArrayList<>();
		Imgproc.cvtColor(src, gary, Imgproc.COLOR_RGB2GRAY);
		Imgproc.threshold(gary, edges, 70,255,Imgproc.THRESH_BINARY_INV);
		HighGui.imshow("edges", edges);
	    HighGui.waitKey(0);
		Imgproc.findContours(edges, contours, hierarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE);
// 找出轮廓对应凸包的四边形拟合
        List<MatOfPoint> squares = new ArrayList<>();
        List<MatOfPoint> hulls = new ArrayList<>();
        MatOfInt hull = new MatOfInt();
        MatOfPoint2f approx = new MatOfPoint2f();
        approx.convertTo(approx, CvType.CV_32F);

        for (MatOfPoint contour: contours) {
            // 边框的凸包
            Imgproc.convexHull(contour, hull);
//            Imgproc.minAreaRect(approx);
            // 用凸包计算出新的轮廓点
            Point[] contourPoints = contour.toArray();
            int[] indices = hull.toArray();
            List<Point> newPoints = new ArrayList<>();
            for (int index : indices) {
                newPoints.add(contourPoints[index]);
            }
            
            MatOfPoint2f contourHull = new MatOfPoint2f();
            contourHull.fromList(newPoints);

            // 多边形拟合凸包边框(此时的拟合的精度较低)
            Imgproc.approxPolyDP(contourHull, approx, Imgproc.arcLength(contourHull, true)*0.02, true);

            // 筛选出面积大于某一阈值的，且四边形的各个角度都接近直角的凸四边形
            MatOfPoint approxf1 = new MatOfPoint();
            approx.convertTo(approxf1, CvType.CV_32S);
            System.out.println("---------------------------------------");
            System.out.println(approx.rows());
            System.out.println(Math.abs(Imgproc.contourArea(approx)));
            System.out.println(Imgproc.isContourConvex(approxf1));
            System.out.println("---------------------------------------");
            if (approx.rows() == 4 && Math.abs(Imgproc.contourArea(approx)) > 2000 &&
                    Imgproc.isContourConvex(approxf1)) {
                double maxCosine = 0;
                for (int j = 2; j < 5; j++) {
                    double cosine = Math.abs(getAngle(approxf1.toArray()[j%4], approxf1.toArray()[j-2], approxf1.toArray()[j-1]));
                    maxCosine = Math.max(maxCosine, cosine);
                    System.out.println("maxCosine" + maxCosine);
                }
                // 角度大概72度
                if (maxCosine < 0.3) {
                    MatOfPoint tmp = new MatOfPoint();
                    contourHull.convertTo(tmp, CvType.CV_32S);
                    squares.add(approxf1);
                    hulls.add(tmp);
                }
            }
        }
        Imgproc.polylines(src, contours, true, new Scalar(255, 0, 0));
//        Imgproc.drawContours(src, contours, -1, new Scalar(255, 0, 0));
        HighGui.imshow("src", src);
	    HighGui.waitKey(0);
        // 找出外接矩形最大的四边形
        int index = findLargestSquare(squares);
        if(index == -1) {
        	System.out.println("外接矩阵最大四边形没找到");
        	return mat_list;
        }
        MatOfPoint largest_square = squares.get(index);
        if (largest_square.rows() == 0 || largest_square.cols() == 0)
            return mat_list;

        // 找到这个最大的四边形对应的凸边框，再次进行多边形拟合，此次精度较高，拟合的结果可能是大于4条边的多边形
        MatOfPoint contourHull1 = hulls.get(index);
        MatOfPoint2f tmp = new MatOfPoint2f();
        contourHull1.convertTo(tmp, CvType.CV_32F);
        Imgproc.approxPolyDP(tmp, approx, 3, true);
        List<Point> newPointList = new ArrayList<>();
        double maxL = Imgproc.arcLength(approx, true) * 0.02;

        
        // 找到高精度拟合时得到的顶点中 距离小于低精度拟合得到的四个顶点maxL的顶点，排除部分顶点的干扰
        for (Point p : approx.toArray()) {
            if (!(getSpacePointToPoint(p, largest_square.toList().get(0)) > maxL &&
                    getSpacePointToPoint(p, largest_square.toList().get(1)) > maxL &&
                    getSpacePointToPoint(p, largest_square.toList().get(2)) > maxL &&
                    getSpacePointToPoint(p, largest_square.toList().get(3)) > maxL)) {
                newPointList.add(p);
            }
        }

        // 找到剩余顶点连线中，边长大于 2 * maxL的四条边作为四边形物体的四条边
        List<double[]> lines = new ArrayList<>();
        for (int i = 0; i < newPointList.size(); i++) {
            Point p1 = newPointList.get(i);
            Point p2 = newPointList.get((i+1) % newPointList.size());
            if (getSpacePointToPoint(p1, p2) > 2 * maxL) {
                lines.add(new double[]{p1.x, p1.y, p2.x, p2.y});
            }
        }

        // 计算出这四条边中 相邻两条边的交点，即物体的四个顶点
        List<Point> corners = new ArrayList<>();
        for (int i = 0; i < lines.size(); i++) {
            Point corner = computeIntersect(lines.get(i),lines.get((i+1) % lines.size()));
            corners.add(corner);
        }

        // 对顶点顺时针排序

        sortCorners(corners);

        // 计算目标图像的尺寸
        Point p0 = corners.get(0);
        Point p1 = corners.get(1);
        Point p2 = corners.get(2);
        Point p3 = corners.get(3);
        Point[] pointArr = new Point[4];
        pointArr[0] = p0;
        pointArr[1] = p1;
        pointArr[2] = p2;
        pointArr[3] = p3;
        MatOfPoint2f matOfPoint2f = new MatOfPoint2f(pointArr);
        System.out.println(Imgproc.minAreaRect(matOfPoint2f));
        double space0 = getSpacePointToPoint(p0, p1);
        double space1 = getSpacePointToPoint(p1, p2);
        double space2 = getSpacePointToPoint(p2, p3);
        double space3 = getSpacePointToPoint(p3, p0);
//        System.out.println(corners +"-" +space0 +"-"+ space1 +"-"+space2 +"-"+space3);
        double imgWidth = space1 > space3 ? space1 : space3;
        double imgHeight = space0 > space2 ? space0 : space2;
//        System.out.println("变化前四个点"+ p0+"-"+ p1+"-"+ p2+"-"+ p3);
        System.out.println( space0+"-"+ space1+"-"+ space2+"-"+ space3);
        // 如果提取出的图片宽小于高，则旋转90度
        if (imgWidth < imgHeight) {
            double temp = imgWidth;
            imgWidth = imgHeight;
            imgHeight = temp;
            Point tempPoint = p0.clone();
            p0 = p3.clone();
            p3 = p2.clone();
            p2 = p1.clone();
            p1 = tempPoint.clone();
        }
//        double x_ = p0.x - p2.x;
//        double y_ = p0.y - p2.y;
//        if() {
//        	
//        }
        System.out.println(p0 + "-" + p2);
        Imgproc.putText(src, "P0", p0, Imgproc.FONT_HERSHEY_COMPLEX, 0.8, new Scalar(0,0,0));
        Imgproc.putText(src, "P1", p1, Imgproc.FONT_HERSHEY_COMPLEX, 0.8, new Scalar(0,0,0));
        Imgproc.putText(src, "P2", p2, Imgproc.FONT_HERSHEY_COMPLEX, 0.8, new Scalar(0,0,0));
        Imgproc.putText(src, "P3", p3, Imgproc.FONT_HERSHEY_COMPLEX, 0.8, new Scalar(0,0,0));
        
        HighGui.imshow("src image", src);
	    HighGui.waitKey(0);
//        System.out.println("变化后四个点"+ p0+"-"+ p1+"-"+ p2+"-"+ p3);
        Mat quad = Mat.zeros((int)img_h, (int)img_w, CvType.CV_8UC3);

        MatOfPoint2f cornerMat = new MatOfPoint2f(p0, p1, p2, p3);
        MatOfPoint2f quadMat = new MatOfPoint2f(new Point(imgWidth*0.4, imgHeight*1.6),
                new Point(imgWidth*0.4, imgHeight*0.4),
                new Point(imgWidth*1.6, imgHeight*0.4),
                new Point(imgWidth*1.6, imgHeight*1.6));

        // 提取图像
        Mat transmtx = Imgproc.getPerspectiveTransform(cornerMat, quadMat);
        Imgproc.warpPerspective(src, rotated_image, transmtx, quad.size());
        // return quad;
		HighGui.imshow("Rotated image", rotated_image);
	    HighGui.waitKey(0);