import java.util.ArrayList; import java.util.List; import java.util.Random; import org.opencv.core.Core; import org.opencv.core.CvType; import org.opencv.core.Mat; import org.opencv.core.MatOfPoint; 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; /** * * @brief Sample code showing how to segment overlapping objects using Laplacian filtering, in addition to Watershed * and Distance Transformation * */ class ImageSegmentation { public void run(String[] args) { //! [load_image] // Load the image String filename = args.length > 0 ? args[0] : "../data/cards.png"; Mat srcOriginal = Imgcodecs.imread(filename); if (srcOriginal.empty()) { System.err.println("Cannot read image: " + filename); System.exit(0); } // Show source image HighGui.imshow("Source Image", srcOriginal); //! [load_image] //! [black_bg] // Change the background from white to black, since that will help later to // extract // better results during the use of Distance Transform Mat src = srcOriginal.clone(); byte[] srcData = new byte[(int) (src.total() * src.channels())]; src.get(0, 0, srcData); for (int i = 0; i < src.rows(); i++) { for (int j = 0; j < src.cols(); j++) { if (srcData[(i * src.cols() + j) * 3] == (byte) 255 && srcData[(i * src.cols() + j) * 3 + 1] == (byte) 255 && srcData[(i * src.cols() + j) * 3 + 2] == (byte) 255) { srcData[(i * src.cols() + j) * 3] = 0; srcData[(i * src.cols() + j) * 3 + 1] = 0; srcData[(i * src.cols() + j) * 3 + 2] = 0; } } } src.put(0, 0, srcData); // Show output image HighGui.imshow("Black Background Image", src); //! [black_bg] //! [sharp] // Create a kernel that we will use to sharpen our image Mat kernel = new Mat(3, 3, CvType.CV_32F); // an approximation of second derivative, a quite strong kernel float[] kernelData = new float[(int) (kernel.total() * kernel.channels())]; kernelData[0] = 1; kernelData[1] = 1; kernelData[2] = 1; kernelData[3] = 1; kernelData[4] = -8; kernelData[5] = 1; kernelData[6] = 1; kernelData[7] = 1; kernelData[8] = 1; kernel.put(0, 0, kernelData); // do the laplacian filtering as it is // well, we need to convert everything in something more deeper then CV_8U // because the kernel has some negative values, // and we can expect in general to have a Laplacian image with negative values // BUT a 8bits unsigned int (the one we are working with) can contain values // from 0 to 255 // so the possible negative number will be truncated Mat imgLaplacian = new Mat(); Imgproc.filter2D(src, imgLaplacian, CvType.CV_32F, kernel); Mat sharp = new Mat(); src.convertTo(sharp, CvType.CV_32F); Mat imgResult = new Mat(); Core.subtract(sharp, imgLaplacian, imgResult); // convert back to 8bits gray scale imgResult.convertTo(imgResult, CvType.CV_8UC3); imgLaplacian.convertTo(imgLaplacian, CvType.CV_8UC3); // imshow( "Laplace Filtered Image", imgLaplacian ); HighGui.imshow("New Sharped Image", imgResult); //! [sharp] //! [bin] // Create binary image from source image Mat bw = new Mat(); Imgproc.cvtColor(imgResult, bw, Imgproc.COLOR_BGR2GRAY); Imgproc.threshold(bw, bw, 40, 255, Imgproc.THRESH_BINARY | Imgproc.THRESH_OTSU); HighGui.imshow("Binary Image", bw); //! [bin] //! [dist] // Perform the distance transform algorithm Mat dist = new Mat(); Imgproc.distanceTransform(bw, dist, Imgproc.DIST_L2, 3); // Normalize the distance image for range = {0.0, 1.0} // so we can visualize and threshold it Core.normalize(dist, dist, 0.0, 1.0, Core.NORM_MINMAX); Mat distDisplayScaled = new Mat(); Core.multiply(dist, new Scalar(255), distDisplayScaled); Mat distDisplay = new Mat(); distDisplayScaled.convertTo(distDisplay, CvType.CV_8U); HighGui.imshow("Distance Transform Image", distDisplay); //! [dist] //! [peaks] // Threshold to obtain the peaks // This will be the markers for the foreground objects Imgproc.threshold(dist, dist, 0.4, 1.0, Imgproc.THRESH_BINARY); // Dilate a bit the dist image Mat kernel1 = Mat.ones(3, 3, CvType.CV_8U); Imgproc.dilate(dist, dist, kernel1); Mat distDisplay2 = new Mat(); dist.convertTo(distDisplay2, CvType.CV_8U); Core.multiply(distDisplay2, new Scalar(255), distDisplay2); HighGui.imshow("Peaks", distDisplay2); //! [peaks] //! [seeds] // Create the CV_8U version of the distance image // It is needed for findContours() Mat dist_8u = new Mat(); dist.convertTo(dist_8u, CvType.CV_8U); // Find total markers List<MatOfPoint> contours = new ArrayList<>(); Mat hierarchy = new Mat(); Imgproc.findContours(dist_8u, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE); // Create the marker image for the watershed algorithm Mat markers = Mat.zeros(dist.size(), CvType.CV_32S); // Draw the foreground markers for (int i = 0; i < contours.size(); i++) { Imgproc.drawContours(markers, contours, i, new Scalar(i + 1), -1); } // Draw the background marker Mat markersScaled = new Mat(); markers.convertTo(markersScaled, CvType.CV_32F); Core.normalize(markersScaled, markersScaled, 0.0, 255.0, Core.NORM_MINMAX); Imgproc.circle(markersScaled, new Point(5, 5), 3, new Scalar(255, 255, 255), -1); Mat markersDisplay = new Mat(); markersScaled.convertTo(markersDisplay, CvType.CV_8U); HighGui.imshow("Markers", markersDisplay); Imgproc.circle(markers, new Point(5, 5), 3, new Scalar(255, 255, 255), -1); //! [seeds] //! [watershed] // Perform the watershed algorithm Imgproc.watershed(imgResult, markers); Mat mark = Mat.zeros(markers.size(), CvType.CV_8U); markers.convertTo(mark, CvType.CV_8UC1); Core.bitwise_not(mark, mark); // imshow("Markers_v2", mark); // uncomment this if you want to see how the mark // image looks like at that point // Generate random colors Random rng = new Random(12345); List<Scalar> colors = new ArrayList<>(contours.size()); for (int i = 0; i < contours.size(); i++) { int b = rng.nextInt(256); int g = rng.nextInt(256); int r = rng.nextInt(256); colors.add(new Scalar(b, g, r)); } // Create the result image Mat dst = Mat.zeros(markers.size(), CvType.CV_8UC3); byte[] dstData = new byte[(int) (dst.total() * dst.channels())]; dst.get(0, 0, dstData); // Fill labeled objects with random colors int[] markersData = new int[(int) (markers.total() * markers.channels())]; markers.get(0, 0, markersData); for (int i = 0; i < markers.rows(); i++) { for (int j = 0; j < markers.cols(); j++) { int index = markersData[i * markers.cols() + j]; if (index > 0 && index <= contours.size()) { dstData[(i * dst.cols() + j) * 3 + 0] = (byte) colors.get(index - 1).val[0]; dstData[(i * dst.cols() + j) * 3 + 1] = (byte) colors.get(index - 1).val[1]; dstData[(i * dst.cols() + j) * 3 + 2] = (byte) colors.get(index - 1).val[2]; } else { dstData[(i * dst.cols() + j) * 3 + 0] = 0; dstData[(i * dst.cols() + j) * 3 + 1] = 0; dstData[(i * dst.cols() + j) * 3 + 2] = 0; } } } dst.put(0, 0, dstData); // Visualize the final image HighGui.imshow("Final Result", dst); //! [watershed] HighGui.waitKey(); System.exit(0); } } public class ImageSegmentationDemo { public static void main(String[] args) { // Load the native OpenCV library System.loadLibrary(Core.NATIVE_LIBRARY_NAME); new ImageSegmentation().run(args); } }