Implementing OpenCV Hough line transformation using Java

You can use the Hough line transform to detect straight lines in a given image. There are two Hough line transform methods available in OpenCV, namely standard Hough line transform and probabilistic Hough line transform.

You can apply the standard Hough line transformation using the HoughLines() method of the Imgproc class. The method accepts the following parameters:

• Two Mat objects representing the source image and a vector storing the line parameters (r, Φ).

• Two double variables representing the resolution of parameters r (pixels) and Φ (radians).

• An integer representing the minimum number of intersections required to "detect" a line.

You can apply the probabilistic Hough line transformation using the HoughLinesP() method of the Imgproc class (same parameters).

You can detect edges in a given image using the Canny() method of the Imgproc class. This method accepts the following parameters:

• Two Mat objects representing the source image and the target image.

• Two double variables used to save the threshold value.

To detect edges of a given image using Canny edge detector, follow these steps:

• Use imread() of Imgcodecs class Method reads the contents of the source image.

• Convert it to a grayscale image using the cvtColor() method of the Imgproc class.

• Use the blur() method of the Imgproc class to blur the resulting (grayscale) image with a kernel value of 3.

• Use Imgproc's canny() method to apply the Canny edge detection algorithm on the blurred image.

• Create an empty matrix with all values ​​0.

• Use the copyTo() method of the Mat class to add the detected edges to it.

Example

import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.IOException;
import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;
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.highgui.HighGui;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class HoughLineTransform extends Application {
   public void start(Stage stage) throws IOException {
      //Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
      String file ="D:\Images\road4.jpg";
      Mat src = Imgcodecs.imread(file);
      //Converting the image to Gray
      Mat gray = new Mat();
      Imgproc.cvtColor(src, gray, Imgproc.COLOR_RGBA2GRAY);
      //Detecting the edges
      Mat edges = new Mat();
      Imgproc.Canny(gray, edges, 60, 60*3, 3, false);
      // Changing the color of the canny
      Mat cannyColor = new Mat();
      Imgproc.cvtColor(edges, cannyColor, Imgproc.COLOR_GRAY2BGR);
      //Detecting the hough lines from (canny)
      Mat lines = new Mat();
      Imgproc.HoughLines(edges, lines, 1, Math.PI/180, 150);
      for (int i = 0; i < lines.rows(); i++) {
         double[] data = lines.get(i, 0);
         double rho = data[0];
         double theta = data[1];
         double a = Math.cos(theta);
         double b = Math.sin(theta);
         double x0 = a*rho;
         double y0 = b*rho;
         //Drawing lines on the image
         Point pt1 = new Point();
         Point pt2 = new Point();
         pt1.x = Math.round(x0 + 1000*(-b));
         pt1.y = Math.round(y0 + 1000*(a));
         pt2.x = Math.round(x0 - 1000*(-b));
         pt2.y = Math.round(y0 - 1000 *(a));
         Imgproc.line(cannyColor, pt1, pt2, new Scalar(0, 0, 255), 3);
      }
      //Converting matrix to JavaFX writable image
      Image img = HighGui.toBufferedImage(cannyColor);
      WritableImage writableImage= SwingFXUtils.toFXImage((BufferedImage) img, null);
      //Setting the image view
      ImageView imageView = new ImageView(writableImage);
      imageView.setX(10);
      imageView.setY(10);
      imageView.setFitWidth(575);
      imageView.setPreserveRatio(true);
      //Setting the Scene object
      Group root = new Group(imageView);
      Scene scene = new Scene(root, 595, 400);
      stage.setTitle("Hough Line Transform");
      stage.setScene(scene);
      stage.show();
   }
   public static void main(String args[]) {
      launch(args);
   }
}

Input image

Output

After execution, the above code will produce the following output −

The above is the detailed content of Implementing OpenCV Hough line transformation using Java. For more information, please follow other related articles on the PHP Chinese website!