Java OpenCV - 使用霍夫变换的矩形检测

Question

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

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

这是原始图像 enter image description here

这是结果图像 enter image description here

我的问题是我不能画一个边界框所检测到的区域。 看来我的程序只能检测到一条水平线。 如何检测矩形形状并将矩形线绘制为检测到的形状？

我读过类似的问题，它需要找到矩形的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. 你做了转换的颜色以灰色后，执行Canny边缘。

   int threshold = 100;

   Imgproc.Canny（grayImage，edges，threshold，threshold * 3）;

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

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

然后环上遍及轮廓

.....

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)); 
} 

希望这可以帮助你！