mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2025-06-07 09:25:45 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add Java and Python code for Image Segmentation with Distance Transform and Watershed Algorithm tutorial. Use more Pythonic code.

Browse Source
This commit is contained in:
catree 2018-06-27 18:48:32 +02:00
parent db48f7b5d1
commit 7469981d1a
7 changed files with 555 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

162
doc/tutorials/imgproc/imgtrans/distance_transformation/distance_transform.markdown
View File

@ -16,42 +16,152 @@ Theory
Code Code
---- ----
@add_toggle_cpp
This tutorial code's is shown lines below. You can also download it from This tutorial code's is shown lines below. You can also download it from
[here](https://github.com/opencv/opencv/tree/3.4/samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp). [here](https://github.com/opencv/opencv/tree/3.4/samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp).
@include samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp @include samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp
@end_toggle
@add_toggle_java
This tutorial code's is shown lines below. You can also download it from
[here](https://github.com/opencv/opencv/tree/3.4/samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java)
@include samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java
@end_toggle
@add_toggle_python
This tutorial code's is shown lines below. You can also download it from
[here](https://github.com/opencv/opencv/tree/3.4/samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py)
@include samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py
@end_toggle
Explanation / Result Explanation / Result
-------------------- --------------------
-# Load the source image and check if it is loaded without any problem, then show it: - Load the source image and check if it is loaded without any problem, then show it:
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp load_image
![](images/source.jpeg)
-# Then if we have an image with a white background, it is good to transform it to black. This will help us to discriminate the foreground objects easier when we will apply the Distance Transform: @add_toggle_cpp
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp black_bg @snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp load_image
![](images/black_bg.jpeg) @end_toggle
-# Afterwards we will sharpen our image in order to acute the edges of the foreground objects. We will apply a laplacian filter with a quite strong filter (an approximation of second derivative): @add_toggle_java
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp sharp @snippet samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java load_image
![](images/laplace.jpeg) @end_toggle
![](images/sharp.jpeg)
-# Now we transform our new sharpened source image to a grayscale and a binary one, respectively: @add_toggle_python
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp bin @snippet samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py load_image
![](images/bin.jpeg) @end_toggle
-# We are ready now to apply the Distance Transform on the binary image. Moreover, we normalize the output image in order to be able visualize and threshold the result: ![](images/source.jpeg)
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp dist
![](images/dist_transf.jpeg)
-# We threshold the *dist* image and then perform some morphology operation (i.e. dilation) in order to extract the peaks from the above image: - Then if we have an image with a white background, it is good to transform it to black. This will help us to discriminate the foreground objects easier when we will apply the Distance Transform:
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp peaks
![](images/peaks.jpeg)
-# From each blob then we create a seed/marker for the watershed algorithm with the help of the @ref cv::findContours function: @add_toggle_cpp
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp seeds @snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp black_bg
![](images/markers.jpeg) @end_toggle
-# Finally, we can apply the watershed algorithm, and visualize the result: @add_toggle_java
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp watershed @snippet samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java black_bg
![](images/final.jpeg) @end_toggle
@add_toggle_python
@snippet samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py black_bg
@end_toggle
![](images/black_bg.jpeg)
- Afterwards we will sharpen our image in order to acute the edges of the foreground objects. We will apply a laplacian filter with a quite strong filter (an approximation of second derivative):
@add_toggle_cpp
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp sharp
@end_toggle
@add_toggle_java
@snippet samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java sharp
@end_toggle
@add_toggle_python
@snippet samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py sharp
@end_toggle
![](images/laplace.jpeg)
![](images/sharp.jpeg)
- Now we transform our new sharpened source image to a grayscale and a binary one, respectively:
@add_toggle_cpp
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp bin
@end_toggle
@add_toggle_java
@snippet samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java bin
@end_toggle
@add_toggle_python
@snippet samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py bin
@end_toggle
![](images/bin.jpeg)
- We are ready now to apply the Distance Transform on the binary image. Moreover, we normalize the output image in order to be able visualize and threshold the result:
@add_toggle_cpp
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp dist
@end_toggle
@add_toggle_java
@snippet samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java dist
@end_toggle
@add_toggle_python
@snippet samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py dist
@end_toggle
![](images/dist_transf.jpeg)
- We threshold the *dist* image and then perform some morphology operation (i.e. dilation) in order to extract the peaks from the above image:
@add_toggle_cpp
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp peaks
@end_toggle
@add_toggle_java
@snippet samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java peaks
@end_toggle
@add_toggle_python
@snippet samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py peaks
@end_toggle
![](images/peaks.jpeg)
- From each blob then we create a seed/marker for the watershed algorithm with the help of the @ref cv::findContours function:
@add_toggle_cpp
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp seeds
@end_toggle
@add_toggle_java
@snippet samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java seeds
@end_toggle
@add_toggle_python
@snippet samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py seeds
@end_toggle
![](images/markers.jpeg)
- Finally, we can apply the watershed algorithm, and visualize the result:
@add_toggle_cpp
@snippet samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp watershed
@end_toggle
@add_toggle_java
@snippet samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java watershed
@end_toggle
@add_toggle_python
@snippet samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py watershed
@end_toggle
![](images/final.jpeg)

2
doc/tutorials/imgproc/table_of_content_imgproc.markdown
View File

@ -285,6 +285,8 @@ In this section you will learn about the image processing (manipulation) functio
- @subpage tutorial_distance_transform - @subpage tutorial_distance_transform
*Languages:* C++, Java, Python
*Compatibility:* \> OpenCV 2.0 *Compatibility:* \> OpenCV 2.0
*Author:* Theodore Tsesmelis *Author:* Theodore Tsesmelis

113
samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp
View File

@ -1,5 +1,4 @@
/** /**
* @function Watershed_and_Distance_Transform.cpp
* @brief Sample code showing how to segment overlapping objects using Laplacian filtering, in addition to Watershed and Distance Transformation * @brief Sample code showing how to segment overlapping objects using Laplacian filtering, in addition to Watershed and Distance Transformation
* @author OpenCV Team * @author OpenCV Team
*/ */
@ -12,43 +11,47 @@
using namespace std; using namespace std;
using namespace cv; using namespace cv;
int main() int main(int argc, char *argv[])
{ {
//! [load_image] //! [load_image]
// Load the image // Load the image
Mat src = imread("../data/cards.png"); CommandLineParser parser( argc, argv, "{@input | ../data/cards.png | input image}" );
Mat src = imread( parser.get<String>( "@input" ) );
// Check if everything was fine if( src.empty() )
if (!src.data) {
cout << "Could not open or find the image!\n" << endl;
cout << "Usage: " << argv[0] << " <Input image>" << endl;
return -1; return -1;
}
// Show source image // Show source image
imshow("Source Image", src); imshow("Source Image", src);
//! [load_image] //! [load_image]
//! [black_bg] //! [black_bg]
// Change the background from white to black, since that will help later to extract // Change the background from white to black, since that will help later to extract
// better results during the use of Distance Transform // better results during the use of Distance Transform
for( int x = 0; x < src.rows; x++ ) { for ( int i = 0; i < src.rows; i++ ) {
for( int y = 0; y < src.cols; y++ ) { for ( int j = 0; j < src.cols; j++ ) {
if ( src.at<Vec3b>(x, y) == Vec3b(255,255,255) ) { if ( src.at<Vec3b>(i, j) == Vec3b(255,255,255) )
src.at<Vec3b>(x, y)[0] = 0; {
src.at<Vec3b>(x, y)[1] = 0; src.at<Vec3b>(i, j)[0] = 0;
src.at<Vec3b>(x, y)[2] = 0; src.at<Vec3b>(i, j)[1] = 0;
} src.at<Vec3b>(i, j)[2] = 0;
}
} }
} }
// Show output image // Show output image
imshow("Black Background Image", src); imshow("Black Background Image", src);
//! [black_bg] //! [black_bg]
//! [sharp] //! [sharp]
// Create a kernel that we will use for accuting/sharpening our image // Create a kernel that we will use to sharpen our image
Mat kernel = (Mat_<float>(3,3) << Mat kernel = (Mat_<float>(3,3) <<
1, 1, 1, 1, 1, 1,
1, -8, 1, 1, -8, 1,
1, 1, 1); // an approximation of second derivative, a quite strong kernel 1, 1, 1); // an approximation of second derivative, a quite strong kernel
// do the laplacian filtering as it is // do the laplacian filtering as it is
// well, we need to convert everything in something more deeper then CV_8U // well, we need to convert everything in something more deeper then CV_8U
@ -57,8 +60,8 @@ int main()
// BUT a 8bits unsigned int (the one we are working with) can contain values from 0 to 255 // 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 // so the possible negative number will be truncated
Mat imgLaplacian; Mat imgLaplacian;
Mat sharp = src; // copy source image to another temporary one filter2D(src, imgLaplacian, CV_32F, kernel);
filter2D(sharp, imgLaplacian, CV_32F, kernel); Mat sharp;
src.convertTo(sharp, CV_32F); src.convertTo(sharp, CV_32F);
Mat imgResult = sharp - imgLaplacian; Mat imgResult = sharp - imgLaplacian;
@ -68,41 +71,39 @@ int main()
// imshow( "Laplace Filtered Image", imgLaplacian ); // imshow( "Laplace Filtered Image", imgLaplacian );
imshow( "New Sharped Image", imgResult ); imshow( "New Sharped Image", imgResult );
//! [sharp] //! [sharp]
src = imgResult; // copy back //! [bin]
//! [bin]
// Create binary image from source image // Create binary image from source image
Mat bw; Mat bw;
cvtColor(src, bw, COLOR_BGR2GRAY); cvtColor(imgResult, bw, COLOR_BGR2GRAY);
threshold(bw, bw, 40, 255, THRESH_BINARY | THRESH_OTSU); threshold(bw, bw, 40, 255, THRESH_BINARY | THRESH_OTSU);
imshow("Binary Image", bw); imshow("Binary Image", bw);
//! [bin] //! [bin]
//! [dist] //! [dist]
// Perform the distance transform algorithm // Perform the distance transform algorithm
Mat dist; Mat dist;
distanceTransform(bw, dist, DIST_L2, 3); distanceTransform(bw, dist, DIST_L2, 3);
// Normalize the distance image for range = {0.0, 1.0} // Normalize the distance image for range = {0.0, 1.0}
// so we can visualize and threshold it // so we can visualize and threshold it
normalize(dist, dist, 0, 1., NORM_MINMAX); normalize(dist, dist, 0, 1.0, NORM_MINMAX);
imshow("Distance Transform Image", dist); imshow("Distance Transform Image", dist);
//! [dist] //! [dist]
//! [peaks] //! [peaks]
// Threshold to obtain the peaks // Threshold to obtain the peaks
// This will be the markers for the foreground objects // This will be the markers for the foreground objects
threshold(dist, dist, .4, 1., THRESH_BINARY); threshold(dist, dist, 0.4, 1.0, THRESH_BINARY);
// Dilate a bit the dist image // Dilate a bit the dist image
Mat kernel1 = Mat::ones(3, 3, CV_8UC1); Mat kernel1 = Mat::ones(3, 3, CV_8U);
dilate(dist, dist, kernel1); dilate(dist, dist, kernel1);
imshow("Peaks", dist); imshow("Peaks", dist);
//! [peaks] //! [peaks]
//! [seeds] //! [seeds]
// Create the CV_8U version of the distance image // Create the CV_8U version of the distance image
// It is needed for findContours() // It is needed for findContours()
Mat dist_8u; Mat dist_8u;
@ -113,34 +114,36 @@ int main()
findContours(dist_8u, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE); findContours(dist_8u, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
// Create the marker image for the watershed algorithm // Create the marker image for the watershed algorithm
Mat markers = Mat::zeros(dist.size(), CV_32SC1); Mat markers = Mat::zeros(dist.size(), CV_32S);
// Draw the foreground markers // Draw the foreground markers
for (size_t i = 0; i < contours.size(); i++) for (size_t i = 0; i < contours.size(); i++)
drawContours(markers, contours, static_cast<int>(i), Scalar::all(static_cast<int>(i)+1), -1); {
drawContours(markers, contours, static_cast<int>(i), Scalar(static_cast<int>(i)+1), -1);
}
// Draw the background marker // Draw the background marker
circle(markers, Point(5,5), 3, CV_RGB(255,255,255), -1); circle(markers, Point(5,5), 3, Scalar(255), -1);
imshow("Markers", markers*10000); imshow("Markers", markers*10000);
//! [seeds] //! [seeds]
//! [watershed] //! [watershed]
// Perform the watershed algorithm // Perform the watershed algorithm
watershed(src, markers); watershed(imgResult, markers);
Mat mark = Mat::zeros(markers.size(), CV_8UC1); Mat mark;
markers.convertTo(mark, CV_8UC1); markers.convertTo(mark, CV_8U);
bitwise_not(mark, mark); bitwise_not(mark, mark);
// imshow("Markers_v2", mark); // uncomment this if you want to see how the mark // imshow("Markers_v2", mark); // uncomment this if you want to see how the mark
// image looks like at that point // image looks like at that point
// Generate random colors // Generate random colors
vector<Vec3b> colors; vector<Vec3b> colors;
for (size_t i = 0; i < contours.size(); i++) for (size_t i = 0; i < contours.size(); i++)
{ {
int b = theRNG().uniform(0, 255); int b = theRNG().uniform(0, 256);
int g = theRNG().uniform(0, 255); int g = theRNG().uniform(0, 256);
int r = theRNG().uniform(0, 255); int r = theRNG().uniform(0, 256);
colors.push_back(Vec3b((uchar)b, (uchar)g, (uchar)r)); colors.push_back(Vec3b((uchar)b, (uchar)g, (uchar)r));
} }
@ -155,16 +158,16 @@ int main()
{ {
int index = markers.at<int>(i,j); int index = markers.at<int>(i,j);
if (index > 0 && index <= static_cast<int>(contours.size())) if (index > 0 && index <= static_cast<int>(contours.size()))
{
dst.at<Vec3b>(i,j) = colors[index-1]; dst.at<Vec3b>(i,j) = colors[index-1];
else }
dst.at<Vec3b>(i,j) = Vec3b(0,0,0);
} }
} }
// Visualize the final image // Visualize the final image
imshow("Final Result", dst); imshow("Final Result", dst);
//! [watershed] //! [watershed]
waitKey(0); waitKey();
return 0; return 0;
} }

215
samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java Normal file
View File

@ -0,0 +1,215 @@
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, 1., Core.NORM_MINMAX);
Mat distDisplayScaled = dist.mul(dist, 255);
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, .4, 1., 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);
distDisplay2 = distDisplay2.mul(distDisplay2, 255);
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
Imgproc.circle(markers, new Point(5, 5), 3, new Scalar(255, 255, 255), -1);
Mat markersScaled = markers.mul(markers, 10000);
Mat markersDisplay = new Mat();
markersScaled.convertTo(markersDisplay, CvType.CV_8U);
HighGui.imshow("Markers", markersDisplay);
//! [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);
}
}

138
samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py Normal file
View File

@ -0,0 +1,138 @@
from __future__ import print_function
import cv2 as cv
import numpy as np
import argparse
import random as rng
rng.seed(12345)
## [load_image]
# Load the image
parser = argparse.ArgumentParser(description='Code for Image Segmentation with Distance Transform and Watershed Algorithm.\
Sample code showing how to segment overlapping objects using Laplacian filtering, \
in addition to Watershed and Distance Transformation')
parser.add_argument('--input', help='Path to input image.', default='../data/cards.png')
args = parser.parse_args()
src = cv.imread(args.input)
if src is None:
print('Could not open or find the image:', args.input)
exit(0)
# Show source image
cv.imshow('Source Image', src)
## [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
src[np.all(src == 255, axis=2)] = 0
# Show output image
cv.imshow('Black Background Image', src)
## [black_bg]
## [sharp]
# Create a kernel that we will use to sharpen our image
# an approximation of second derivative, a quite strong kernel
kernel = np.array([[1, 1, 1], [1, -8, 1], [1, 1, 1]], dtype=np.float32)
# 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
imgLaplacian = cv.filter2D(src, cv.CV_32F, kernel)
sharp = np.float32(src)
imgResult = sharp - imgLaplacian
# convert back to 8bits gray scale
imgResult = np.clip(imgResult, 0, 255)
imgResult = imgResult.astype('uint8')
imgLaplacian = np.clip(imgLaplacian, 0, 255)
imgLaplacian = np.uint8(imgLaplacian)
#cv.imshow('Laplace Filtered Image', imgLaplacian)
cv.imshow('New Sharped Image', imgResult)
## [sharp]
## [bin]
# Create binary image from source image
bw = cv.cvtColor(imgResult, cv.COLOR_BGR2GRAY)
_, bw = cv.threshold(bw, 40, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
cv.imshow('Binary Image', bw)
## [bin]
## [dist]
# Perform the distance transform algorithm
dist = cv.distanceTransform(bw, cv.DIST_L2, 3)
# Normalize the distance image for range = {0.0, 1.0}
# so we can visualize and threshold it
cv.normalize(dist, dist, 0, 1.0, cv.NORM_MINMAX)
cv.imshow('Distance Transform Image', dist)
## [dist]
## [peaks]
# Threshold to obtain the peaks
# This will be the markers for the foreground objects
_, dist = cv.threshold(dist, 0.4, 1.0, cv.THRESH_BINARY)
# Dilate a bit the dist image
kernel1 = np.ones((3,3), dtype=np.uint8)
dist = cv.dilate(dist, kernel1)
cv.imshow('Peaks', dist)
## [peaks]
## [seeds]
# Create the CV_8U version of the distance image
# It is needed for findContours()
dist_8u = dist.astype('uint8')
# Find total markers
_, contours, _ = cv.findContours(dist_8u, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
# Create the marker image for the watershed algorithm
markers = np.zeros(dist.shape, dtype=np.int32)
# Draw the foreground markers
for i in range(len(contours)):
cv.drawContours(markers, contours, i, (i+1), -1)
# Draw the background marker
cv.circle(markers, (5,5), 3, (255,255,255), -1)
cv.imshow('Markers', markers*10000)
## [seeds]
## [watershed]
# Perform the watershed algorithm
cv.watershed(imgResult, markers)
#mark = np.zeros(markers.shape, dtype=np.uint8)
mark = markers.astype('uint8')
mark = cv.bitwise_not(mark)
# uncomment this if you want to see how the mark
# image looks like at that point
#cv.imshow('Markers_v2', mark)
# Generate random colors
colors = []
for contour in contours:
colors.append((rng.randint(0,256), rng.randint(0,256), rng.randint(0,256)))
# Create the result image
dst = np.zeros((markers.shape[0], markers.shape[1], 3), dtype=np.uint8)
# Fill labeled objects with random colors
for i in range(markers.shape[0]):
for j in range(markers.shape[1]):
index = markers[i,j]
if index > 0 and index <= len(contours):
dst[i,j,:] = colors[index-1]
# Visualize the final image
cv.imshow('Final Result', dst)
## [watershed]
cv.waitKey()

7
samples/python/tutorial_code/features2D/feature_flann_matcher/SURF_FLANN_matching_Demo.py
View File

@ -28,10 +28,9 @@ knn_matches = matcher.knnMatch(descriptors1, descriptors2, 2)
#-- Filter matches using the Lowe's ratio test #-- Filter matches using the Lowe's ratio test
ratio_thresh = 0.7 ratio_thresh = 0.7
good_matches = [] good_matches = []
for matches in knn_matches: for m,n in knn_matches:
if len(matches) > 1: if m.distance / n.distance <= ratio_thresh:
if matches[0].distance / matches[1].distance <= ratio_thresh: good_matches.append(m)
good_matches.append(matches[0])
#-- Draw matches #-- Draw matches
img_matches = np.empty((max(img1.shape[0], img2.shape[0]), img1.shape[1]+img2.shape[1], 3), dtype=np.uint8) img_matches = np.empty((max(img1.shape[0], img2.shape[0]), img1.shape[1]+img2.shape[1], 3), dtype=np.uint8)

7
samples/python/tutorial_code/features2D/feature_homography/SURF_FLANN_matching_homography_Demo.py
View File

@ -28,10 +28,9 @@ knn_matches = matcher.knnMatch(descriptors_obj, descriptors_scene, 2)
#-- Filter matches using the Lowe's ratio test #-- Filter matches using the Lowe's ratio test
ratio_thresh = 0.75 ratio_thresh = 0.75
good_matches = [] good_matches = []
for matches in knn_matches: for m,n in knn_matches:
if len(matches) > 1: if m.distance / n.distance <= ratio_thresh:
if matches[0].distance / matches[1].distance <= ratio_thresh: good_matches.append(m)
good_matches.append(matches[0])
#-- Draw matches #-- Draw matches
img_matches = np.empty((max(img_object.shape[0], img_scene.shape[0]), img_object.shape[1]+img_scene.shape[1], 3), dtype=np.uint8) img_matches = np.empty((max(img_object.shape[0], img_scene.shape[0]), img_object.shape[1]+img_scene.shape[1], 3), dtype=np.uint8)