Java OpenCV-Hough变换矩形检测

Question

我正在开发一个程序来检测矩形并在检测到的区域绘制边界框。

对于边缘检测，我使用了Canny边缘检测。然后，我使用霍夫变换来提取线条。

这是原始图像在此处输入图像描述

这是结果图像在此处输入图像描述

我的问题是，我无法绘制到检测区域的边界框。我的程序似乎只能检测到一条水平线。如何检测矩形并在检测到的形状上绘制矩形线？

我读过类似的问题，需要找到矩形的4个角点，检查该点是否为90度，并找到交点。我真的很困惑如何用Java opencv来编码它。其他检测形状并为检测到的形状绘制边界框的方法也可以。

这是代码

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.imgcodecs.*;
import org.opencv.imgproc.Imgproc;
public class HoughTransformCV2 {
    public static void main(String[] args) {
        try {
            System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
            Mat source = Imgcodecs.imread("rectangle.jpg", Imgcodecs.CV_LOAD_IMAGE_ANYCOLOR);
            Mat destination = new Mat(source.rows(), source.cols(), source.type());
            Imgproc.cvtColor(source, destination, Imgproc.COLOR_RGB2GRAY);
            Imgproc.equalizeHist(destination, destination);
            Imgproc.GaussianBlur(destination, destination, new Size(5, 5), 0, 0, Core.BORDER_DEFAULT);
            Imgproc.Canny(destination, destination, 50, 100);
            //Imgproc.adaptiveThreshold(destination, destination, 255, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 15, 40);
            Imgproc.threshold(destination, destination, 0, 255, Imgproc.THRESH_BINARY);
            if (destination != null) {
                Mat lines = new Mat();
                Imgproc.HoughLinesP(destination, lines, 1, Math.PI / 180, 50, 30, 10);
                Mat houghLines = new Mat();
                houghLines.create(destination.rows(), destination.cols(), CvType.CV_8UC1);
                //Drawing lines on the image
                for (int i = 0; i < lines.cols(); i++) {
                    double[] points = lines.get(0, i);
                    double x1, y1, x2, y2;
                    x1 = points[0];
                    y1 = points[1];
                    x2 = points[2];
                    y2 = points[3];
                    Point pt1 = new Point(x1, y1);
                    Point pt2 = new Point(x2, y2);
                    //Drawing lines on an image
                    Imgproc.line(source, pt1, pt2, new Scalar(0, 0, 255), 4);
                }
            }
            Imgcodecs.imwrite("rectangle_houghtransform.jpg", source);
        } catch (Exception e) {
            System.out.println("error: " + e.getMessage());
        }
    }
}

如有Java方面的帮助，我们将不胜感激：）非常感谢！

Answer 1

您可以通过以下步骤完成：

1. 将颜色转换为灰色后，执行精明的边缘处理。

   int阈值=100

   Imgproc.Canny（灰度图像，边缘，阈值，阈值*3）

2. 现在在边缘图像中找到轮廓。

Imgproc.findContours(edges, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);

3. 然后在所有轮廓上循环

MatOfPoint2f matOfPoint2f = new MatOfPoint2f();
MatOfPoint2f approxCurve = new MatOfPoint2f();
for (int idx = 0; idx >= 0; idx = (int) hierarchy.get(0, idx)[0]) {
    MatOfPoint contour = contours.get(idx);
    Rect rect = Imgproc.boundingRect(contour);
    double contourArea = Imgproc.contourArea(contour);
    matOfPoint2f.fromList(contour.toList());
    Imgproc.approxPolyDP(matOfPoint2f, approxCurve, Imgproc.arcLength(matOfPoint2f, true) * 0.02, true);
    long total = approxCurve.total();
    if (total == 3) { // is triangle
        // do things for triangle
    }
    if (total >= 4 && total <= 6) {
        List<Double> cos = new ArrayList<>();
        Point[] points = approxCurve.toArray();
        for (int j = 2; j < total + 1; j++) {
            cos.add(angle(points[(int) (j % total)], points[j - 2], points[j - 1]));
        }
        Collections.sort(cos);
        Double minCos = cos.get(0);
        Double maxCos = cos.get(cos.size() - 1);
        boolean isRect = total == 4 && minCos >= -0.1 && maxCos <= 0.3;
        boolean isPolygon = (total == 5 && minCos >= -0.34 && maxCos <= -0.27) || (total == 6 && minCos >= -0.55 && maxCos <= -0.45);
        if (isRect) {
            double ratio = Math.abs(1 - (double) rect.width / rect.height);
            drawText(rect.tl(), ratio <= 0.02 ? "SQU" : "RECT");
        }
        if (isPolygon) {
            drawText(rect.tl(), "Polygon");
        }
    }
}

辅助方法：

private double angle(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 void drawText(Point ofs, String text) {
    Imgproc.putText(colorImage, text, ofs, Core.FONT_HERSHEY_SIMPLEX, 0.5, new Scalar(255,255,25));
}

希望这能帮助你！！