图像分割与距离变换和分水岭算法

目录

• 目标
• 理论
• 代码
• 解释 / 结果

上一个教程： 点多边形测试
下一个教程： 散焦去模糊滤镜

原始作者	Theodore Tsesmelis
兼容性	OpenCV >= 3.0

目标

在本教程中，您将学习如何

• 使用OpenCV函数 cv::filter2D 执行拉普拉斯滤波以锐化图像
• 使用OpenCV函数 cv::distanceTransform 获取二值图像的派生表示，其中每个像素的值被替换为其到最近背景像素的距离
• 使用OpenCV函数 cv::watershed 将图像中的对象与背景分离

理论

代码

C++

本教程代码如下所示。您也可以从 此处 下载。

 
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
 
using namespace std;
using namespace cv;
 
int main(int argc, char *argv[])
{
    // Load the image
    CommandLineParser parser( argc, argv, "{@input | cards.png | input image}" );
    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
    if( src.empty() )
    {
cout << "Could not open or find the image!\n" << endl;
cout << "Usage: " << argv[0] << " <Input image>" << endl;
        return -1;
    }
 
    // 显示源图像
imshow("Source Image", src);
 
    // 将背景从白色更改为黑色，因为这有助于以后在使用距离变换时
    // 提取更好的结果
    Mat mask;
inRange(src, Scalar(255, 255, 255), Scalar(255, 255, 255), mask);
src.setTo(Scalar(0, 0, 0), mask);
 
    // 显示输出图像
imshow("Black Background Image", src);
 
    // 创建我们将用于锐化图像的核
    Mat kernel = (Mat_<float>(3,3) <<
                  1,  1, 1,
                  1, -8, 1,
1, 1, 1); // 二阶导数的近似，一个相当强的核
 
    // 执行拉普拉斯滤波
    // 我们需要将所有内容转换为比CV_8U更深的类型
    // 因为核包含一些负值，
    // 并且我们通常会得到带有负值的拉普拉斯图像
    // 但是我们正在处理的8位无符号整数只能包含0到255的值
    // 所以可能的负数将被截断
    Mat imgLaplacian;
filter2D(src, imgLaplacian, CV_32F, kernel);
    Mat sharp;
src.convertTo(sharp, CV_32F);
    Mat imgResult = sharp - imgLaplacian;
 
    // 转换回8位灰度图
imgResult.convertTo(imgResult, CV_8UC3);
imgLaplacian.convertTo(imgLaplacian, CV_8UC3);
 
    // imshow( "拉普拉斯滤波图像", imgLaplacian );
imshow( "新锐化图像", imgResult );
 
    // 从源图像创建二值图像
    Mat bw;
cvtColor(imgResult, bw, COLOR_BGR2GRAY);
threshold(bw, bw, 40, 255, THRESH_BINARY | THRESH_OTSU);
imshow("二值图像", bw);
 
    // 执行距离变换算法
    Mat dist;
distanceTransform(bw, dist, DIST_L2, 3);
 
    // 将距离图像归一化到范围 = {0.0, 1.0}
    // 以便我们可以可视化和阈值化它
normalize(dist, dist, 0, 1.0, NORM_MINMAX);
imshow("距离变换图像", dist);
 
    // 阈值化以获得峰值
    // 这将是前景对象的标记
threshold(dist, dist, 0.4, 1.0, THRESH_BINARY);
 
    // 对距离图像进行少量膨胀
    Mat kernel1 = Mat::ones(3, 3, CV_8U);
dilate(dist, dist, kernel1);
imshow("峰值", dist);
 
    // 创建距离图像的CV_8U版本
    // findContours()需要它
    Mat dist_8u;
dist.convertTo(dist_8u, CV_8U);
 
    // 查找所有标记
vector<vector<Point> > contours;
findContours(dist_8u, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
 
    // 为分水岭算法创建标记图像
    Mat markers = Mat::zeros(dist.size(), CV_32S);
 
    // 绘制前景标记
    for (size_t i = 0; i < contours.size(); i++)
    {
drawContours(markers, contours, static_cast<int>(i), Scalar(static_cast<int>(i)+1), -1);
    }
 
    // 绘制背景标记
circle(markers, Point(5,5), 3, Scalar(255), -1);
    Mat markers8u;
markers.convertTo(markers8u, CV_8U, 10);
imshow("标记", markers8u);
 
    // 执行分水岭算法
watershed(imgResult, markers);
 
    Mat mark;
markers.convertTo(mark, CV_8U);
bitwise_not(mark, mark);
    // imshow("Markers_v2", mark); // 如果你想看mark图像此时的样子，取消注释此行
    // 图像此时的样子
 
    // 生成随机颜色
vector<Vec3b> colors;
    for (size_t i = 0; i < contours.size(); i++)
    {
        int b = theRNG().uniform(0, 256);
        int g = theRNG().uniform(0, 256);
        int r = theRNG().uniform(0, 256);
 
colors.push_back(Vec3b((uchar)b, (uchar)g, (uchar)r));
    }
 
    // 创建结果图像
    Mat dst = Mat::zeros(markers.size(), CV_8UC3);
 
    // 用随机颜色填充标记对象
    for (int i = 0; i < markers.rows; i++)
    {
        for (int j = 0; j < markers.cols; j++)
        {
            int index = markers.at<int>(i,j);
            if (index > 0 && index <= static_cast<int>(contours.size()))
            {
dst.at<Vec3b>(i,j) = colors[index-1];
            }
        }
    }
 
    // 可视化最终图像
    imshow("最终结果", dst);
 
    waitKey();
    return 0;
}

Java

本教程代码如下所示。您也可以从 此处 下载

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;
 
class ImageSegmentation {
    public void run(String[] args) {
        // Load the image
String filename = args.length > 0 ? args[0] : "../data/cards.png";
Mat srcOriginal = Imgcodecs.imread(filename);
        if (srcOriginal.empty()) {
System.err.println("无法读取图像：" + filename);
System.exit(0);
        }
 
        // Show source image
HighGui.imshow("源图像", srcOriginal);
 
        // 将背景从白色改为黑色，因为这有助于以后
        // 提取
        // 提取更好的结果
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);
 
        // 显示输出图像
HighGui.imshow("黑色背景图像", src);
 
        // 创建我们将用于锐化图像的核
Mat kernel = new Mat(3, 3, CvType.CV_32F);
        // 二阶导数的近似，一个相当强的核
        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);
 
        // 执行拉普拉斯滤波
        // 我们需要将所有内容转换为比CV_8U更深的类型
        // 因为核包含一些负值，
        // 并且我们通常会得到带有负值的拉普拉斯图像
        // 但是我们正在处理的8位无符号整数可以包含
        // 0到255的值
        // 所以可能的负数将被截断
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);
 
        // 转换回8位灰度图
imgResult.convertTo(imgResult, CvType.CV_8UC3);
imgLaplacian.convertTo(imgLaplacian, CvType.CV_8UC3);
 
        // imshow( "拉普拉斯滤波图像", imgLaplacian );
HighGui.imshow("新锐化图像", imgResult);
 
        // 从源图像创建二值图像
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("二值图像", bw);
 
        // 执行距离变换算法
Mat dist = new Mat();
Imgproc.distanceTransform(bw, dist, Imgproc.DIST_L2, 3);
 
        // 将距离图像归一化到范围 = {0.0, 1.0}
        // 以便我们可以可视化和阈值化它
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("距离变换图像", distDisplay);
 
        // 阈值化以获得峰值
        // 这将是前景对象的标记
Imgproc.threshold(dist, dist, 0.4, 1.0, Imgproc.THRESH_BINARY);
 
        // 对距离图像进行少量膨胀
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("峰值", distDisplay2);
 
        // 创建距离图像的CV_8U版本
        // findContours()需要它
Mat dist_8u = new Mat();
dist.convertTo(dist_8u, CvType.CV_8U);
 
        // 查找所有标记
List<MatOfPoint> contours = new ArrayList<>();
Mat hierarchy = new Mat();
Imgproc.findContours(dist_8u, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
 
        // 为分水岭算法创建标记图像
Mat markers = Mat.zeros(dist.size(), CvType.CV_32S);
 
        // 绘制前景标记
        for (int i = 0; i < contours.size(); i++) {
Imgproc.drawContours(markers, contours, i, new Scalar(i + 1), -1);
        }
 
        // 绘制背景标记
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("标记", markersDisplay);
Imgproc.circle(markers, new Point(5, 5), 3, new Scalar(255, 255, 255), -1);
 
        // 执行分水岭算法
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); // 如果你想看mark图像此时的样子，取消注释此行
        // 图像此时的样子
 
        // 生成随机颜色
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));
        }
 
        // 创建结果图像
Mat dst = Mat.zeros(markers.size(), CvType.CV_8UC3);
        byte[] dstData = new byte[(int) (dst.total() * dst.channels())];
dst.get(0, 0, dstData);
 
        // 用随机颜色填充标记对象
        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);
 
        // 可视化最终图像
HighGui.imshow("最终结果", dst);
 
HighGui.waitKey();
System.exit(0);
    }
}
 
public class ImageSegmentationDemo {
    public static void main(String[] args) {
        // 加载本地 OpenCV 库
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
 
        new ImageSegmentation().run(args);
    }
}

Python

本教程代码如下所示。您也可以从 此处 下载

from __future__ import print_function
import cv2 as cv
import numpy as np
import argparse
import random as rng
 
rng.seed(12345)
 
 
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'
args = parser.parse_args()
 
parser.add_argument('--input', help='输入图像的路径。', default='cards.png')
src = cv.imread(cv.samples.findFile(args.input))
if src is None
exit(0)
 
# Show source image
print('无法打开或找到图像：', args.input)
 
 
 
cv.imshow('源图像', src)
 
src[np.all(src == 255, axis=2)] = 0
# 显示输出图像
 
 
 
cv.imshow('黑色背景图像', src)
 
kernel = np.array([[1, 1, 1], [1, -8, 1], [1, 1, 1]], dtype=np.float32)
# 执行拉普拉斯滤波
# 我们需要将所有内容转换为比CV_8U更深的类型
# 因为核包含一些负值，
# 并且我们通常会得到带有负值的拉普拉斯图像
# 但是我们正在处理的8位无符号整数可以包含0到255的值
# 所以可能的负数将被截断
imgLaplacian = cv.filter2D(src, cv.CV_32F, kernel)
sharp = np.float32(src)
 
imgResult = sharp - imgLaplacian
# 转换回8位灰度图
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('新锐化图像', imgResult)
bw = cv.cvtColor(imgResult, cv.COLOR_BGR2GRAY)
_, bw = cv.threshold(bw, 40, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
 
 
 
cv.imshow('二值图像', bw)
 
dist = cv.distanceTransform(bw, cv.DIST_L2, 3)
# 将距离图像归一化到范围 = {0.0, 1.0}
# 以便我们可以可视化和阈值化它
cv.normalize(dist, dist, 0, 1.0, cv.NORM_MINMAX)
 
 
 
cv.imshow('距离变换图像', dist)
 
_, dist = cv.threshold(dist, 0.4, 1.0, cv.THRESH_BINARY)
# 对距离图像进行少量膨胀
kernel1 = np.ones((3,3), dtype=np.uint8)
dist = cv.dilate(dist, kernel1)
 
 
 
cv.imshow('峰值', dist)
 
dist_8u = dist.astype('uint8')
# 查找所有标记
 
contours, _ = cv.findContours(dist_8u, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
# 为分水岭算法创建标记图像
 
markers = np.zeros(dist.shape, dtype=np.int32)
# 绘制前景标记
    for i in range(len(contours))
 
cv.drawContours(markers, contours, i, (i+1), -1)
# 绘制背景标记
cv.circle(markers, (5,5), 3, (255,255,255), -1)
markers_8u = (markers * 10).astype('uint8')
 
 
 
cv.imshow('标记', markers_8u)
 
cv.watershed(imgResult, markers)
#mark = np.zeros(markers.shape, dtype=np.uint8)
mark = markers.astype('uint8')
mark = cv.bitwise_not(mark)
# 如果你想看mark图像此时的样子，取消注释此行
# 图像此时的样子
 
#cv.imshow('Markers_v2', mark)
# 生成随机颜色
colors = []
for contour in contours
 
colors.append((rng.randint(0,256), rng.randint(0,256), rng.randint(0,256)))
# 创建结果图像
 
dst = np.zeros((markers.shape[0], markers.shape[1], 3), dtype=np.uint8)
# 用随机颜色填充标记对象
    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]
# 可视化最终图像
 
 
cv.waitKey()

void findContours(InputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point())

• 解释/结果

C++

    // Load the image
    CommandLineParser parser( argc, argv, "{@input | cards.png | input image}" );
    加载源图像并检查是否加载无误，然后显示它
    if( src.empty() )
    {
cout << "Could not open or find the image!\n" << endl;
cout << "Usage: " << argv[0] << " <Input image>" << endl;
        return -1;
    }
 
    // 显示源图像
    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ) );

Java

        // Load the image
        imshow("源图像", src);
Mat srcOriginal = Imgcodecs.imread(filename);
        if (srcOriginal.empty()) {
System.err.println("无法读取图像：" + filename);
System.exit(0);
        }
 
        // Show source image
HighGui.imshow("源图像", srcOriginal);

Python

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'
args = parser.parse_args()
 
parser.add_argument('--input', help='输入图像的路径。', default='cards.png')
src = cv.imread(cv.samples.findFile(args.input))
if src is None
exit(0)
 
# Show source image
print('无法打开或找到图像：', args.input)

• String filename = args.length > 0 ? args[0] : "../data/cards.png";

C++

    // 将背景从白色更改为黑色，因为这有助于以后在使用距离变换时
    // 提取更好的结果
    然后，如果图像有白色背景，最好将其转换为黑色。这有助于我们在应用距离变换时更容易地区分前景对象
    Mat mask;
src.setTo(Scalar(0, 0, 0), mask);
 
    // 显示输出图像
    inRange(src, Scalar(255, 255, 255), Scalar(255, 255, 255), mask);

Java

        // 将背景从白色改为黑色，因为这有助于以后
        // 提取
        // 提取更好的结果
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);
 
        // 显示输出图像
HighGui.imshow("黑色背景图像", src);

Python

cv.imshow('源图像', src)
 
src[np.all(src == 255, axis=2)] = 0
# 显示输出图像

• imshow("黑色背景图像", src);

C++

    // 创建我们将用于锐化图像的核
    Mat kernel = (Mat_<float>(3,3) <<
                  1,  1, 1,
                  1, -8, 1,
1, 1, 1); // 二阶导数的近似，一个相当强的核
 
    // 执行拉普拉斯滤波
    // 我们需要将所有内容转换为比CV_8U更深的类型
    // 因为核包含一些负值，
    // 并且我们通常会得到带有负值的拉普拉斯图像
    // 但是我们正在处理的8位无符号整数只能包含0到255的值
    // 所以可能的负数将被截断
    Mat imgLaplacian;
    之后，我们将锐化图像，以使前景对象的边缘更清晰。我们将应用一个相当强的拉普拉斯滤镜（二阶导数的近似）
    Mat sharp;
src.convertTo(sharp, CV_32F);
    Mat imgResult = sharp - imgLaplacian;
 
    // 转换回8位灰度图
imgResult.convertTo(imgResult, CV_8UC3);
imgLaplacian.convertTo(imgLaplacian, CV_8UC3);
 
    // imshow( "拉普拉斯滤波图像", imgLaplacian );
    filter2D(src, imgLaplacian, CV_32F, kernel);

Java

        // 创建我们将用于锐化图像的核
Mat kernel = new Mat(3, 3, CvType.CV_32F);
        // 二阶导数的近似，一个相当强的核
        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);
 
        // 执行拉普拉斯滤波
        // 我们需要将所有内容转换为比CV_8U更深的类型
        // 因为核包含一些负值，
        // 并且我们通常会得到带有负值的拉普拉斯图像
        // 但是我们正在处理的8位无符号整数可以包含
        // 0到255的值
        // 所以可能的负数将被截断
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);
 
        // 转换回8位灰度图
imgResult.convertTo(imgResult, CvType.CV_8UC3);
imgLaplacian.convertTo(imgLaplacian, CvType.CV_8UC3);
 
        // imshow( "拉普拉斯滤波图像", imgLaplacian );
HighGui.imshow("新锐化图像", imgResult);

Python

cv.imshow('黑色背景图像', src)
 
kernel = np.array([[1, 1, 1], [1, -8, 1], [1, 1, 1]], dtype=np.float32)
# 执行拉普拉斯滤波
# 我们需要将所有内容转换为比CV_8U更深的类型
# 因为核包含一些负值，
# 并且我们通常会得到带有负值的拉普拉斯图像
# 但是我们正在处理的8位无符号整数可以包含0到255的值
# 所以可能的负数将被截断
imgLaplacian = cv.filter2D(src, cv.CV_32F, kernel)
sharp = np.float32(src)
 
imgResult = sharp - imgLaplacian
# 转换回8位灰度图
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)

• imshow( "新锐化图像", imgResult );

C++

    // 从源图像创建二值图像
    Mat bw;
    现在，我们将新的锐化源图像分别转换为灰度图像和二值图像
    cvtColor(imgResult, bw, COLOR_BGR2GRAY);
    threshold(bw, bw, 40, 255, THRESH_BINARY | THRESH_OTSU);

Java

        // 从源图像创建二值图像
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("二值图像", bw);

Python

cv.imshow('新锐化图像', imgResult)
bw = cv.cvtColor(imgResult, cv.COLOR_BGR2GRAY)
_, bw = cv.threshold(bw, 40, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)

• imshow("二值图像", bw);

C++

    // 执行距离变换算法
    Mat dist;
    现在我们准备对二值图像应用距离变换。此外，我们对输出图像进行归一化，以便能够可视化和阈值化结果
 
    // 将距离图像归一化到范围 = {0.0, 1.0}
    // 以便我们可以可视化和阈值化它
    distanceTransform(bw, dist, DIST_L2, 3);
    normalize(dist, dist, 0, 1.0, NORM_MINMAX);

Java

        // 执行距离变换算法
Mat dist = new Mat();
Imgproc.distanceTransform(bw, dist, Imgproc.DIST_L2, 3);
 
        // 将距离图像归一化到范围 = {0.0, 1.0}
        // 以便我们可以可视化和阈值化它
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("距离变换图像", distDisplay);

Python

cv.imshow('二值图像', bw)
 
dist = cv.distanceTransform(bw, cv.DIST_L2, 3)
# 将距离图像归一化到范围 = {0.0, 1.0}
# 以便我们可以可视化和阈值化它
cv.normalize(dist, dist, 0, 1.0, cv.NORM_MINMAX)

• imshow("距离变换图像", dist);

C++

    // 阈值化以获得峰值
    // 这将是前景对象的标记
    我们对_dist_图像进行阈值处理，然后执行一些形态学操作（即膨胀），以从上述图像中提取峰值
 
    // 对距离图像进行少量膨胀
    Mat kernel1 = Mat::ones(3, 3, CV_8U);
    threshold(dist, dist, 0.4, 1.0, THRESH_BINARY);
    dilate(dist, dist, kernel1);

Java

        // 阈值化以获得峰值
        // 这将是前景对象的标记
Imgproc.threshold(dist, dist, 0.4, 1.0, Imgproc.THRESH_BINARY);
 
        // 对距离图像进行少量膨胀
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("峰值", distDisplay2);

Python

cv.imshow('距离变换图像', dist)
 
_, dist = cv.threshold(dist, 0.4, 1.0, cv.THRESH_BINARY)
# 对距离图像进行少量膨胀
kernel1 = np.ones((3,3), dtype=np.uint8)
dist = cv.dilate(dist, kernel1)

• imshow("峰值", dist);

C++

    // 创建距离图像的CV_8U版本
    // findContours()需要它
    Mat dist_8u;
dist.convertTo(dist_8u, CV_8U);
 
    // 查找所有标记
vector<vector<Point> > contours;
    然后，我们借助 cv::findContours 函数从每个斑点创建一个分水岭算法的种子/标记
 
    // 为分水岭算法创建标记图像
    Mat markers = Mat::zeros(dist.size(), CV_32S);
 
    // 绘制前景标记
    for (size_t i = 0; i < contours.size(); i++)
    {
        findContours(dist_8u, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
    }
 
    // 绘制背景标记
    drawContours(markers, contours, static_cast<int>(i), Scalar(static_cast<int>(i)+1), -1);
    Mat markers8u;
markers.convertTo(markers8u, CV_8U, 10);
    circle(markers, Point(5,5), 3, Scalar(255), -1);

Java

        // 创建距离图像的CV_8U版本
        // findContours()需要它
Mat dist_8u = new Mat();
dist.convertTo(dist_8u, CvType.CV_8U);
 
        // 查找所有标记
List<MatOfPoint> contours = new ArrayList<>();
Mat hierarchy = new Mat();
Imgproc.findContours(dist_8u, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
 
        // 为分水岭算法创建标记图像
Mat markers = Mat.zeros(dist.size(), CvType.CV_32S);
 
        // 绘制前景标记
        for (int i = 0; i < contours.size(); i++) {
Imgproc.drawContours(markers, contours, i, new Scalar(i + 1), -1);
        }
 
        // 绘制背景标记
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("标记", markersDisplay);
Imgproc.circle(markers, new Point(5, 5), 3, new Scalar(255, 255, 255), -1);

Python

cv.imshow('峰值', dist)
 
dist_8u = dist.astype('uint8')
# 查找所有标记
 
contours, _ = cv.findContours(dist_8u, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
# 为分水岭算法创建标记图像
 
markers = np.zeros(dist.shape, dtype=np.int32)
# 绘制前景标记
    for i in range(len(contours))
 
cv.drawContours(markers, contours, i, (i+1), -1)
# 绘制背景标记
cv.circle(markers, (5,5), 3, (255,255,255), -1)
markers_8u = (markers * 10).astype('uint8')

• imshow("标记", markers8u);

C++

    // 执行分水岭算法
    最后，我们可以应用分水岭算法，并可视化结果
 
    Mat mark;
markers.convertTo(mark, CV_8U);
    watershed(imgResult, markers);
    // imshow("Markers_v2", mark); // 如果你想看mark图像此时的样子，取消注释此行
    // 图像此时的样子
 
    // 生成随机颜色
vector<Vec3b> colors;
    for (size_t i = 0; i < contours.size(); i++)
    {
        bitwise_not(mark, mark);
        int b = theRNG().uniform(0, 256);
        int g = theRNG().uniform(0, 256);
 
colors.push_back(Vec3b((uchar)b, (uchar)g, (uchar)r));
    }
 
    // 创建结果图像
    Mat dst = Mat::zeros(markers.size(), CV_8UC3);
 
    // 用随机颜色填充标记对象
    for (int i = 0; i < markers.rows; i++)
    {
        for (int j = 0; j < markers.cols; j++)
        {
            int r = theRNG().uniform(0, 256);
            if (index > 0 && index <= static_cast<int>(contours.size()))
            {
dst.at<Vec3b>(i,j) = colors[index-1];
            }
        }
    }
 
    // 可视化最终图像
    imshow("最终结果", dst);

Java

        // 执行分水岭算法
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); // 如果你想看mark图像此时的样子，取消注释此行
        // 图像此时的样子
 
        // 生成随机颜色
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));
        }
 
        // 创建结果图像
Mat dst = Mat.zeros(markers.size(), CvType.CV_8UC3);
        byte[] dstData = new byte[(int) (dst.total() * dst.channels())];
dst.get(0, 0, dstData);
 
        // 用随机颜色填充标记对象
        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);
 
        // 可视化最终图像
HighGui.imshow("最终结果", dst);

Python

cv.imshow('标记', markers_8u)
 
cv.watershed(imgResult, markers)
#mark = np.zeros(markers.shape, dtype=np.uint8)
mark = markers.astype('uint8')
mark = cv.bitwise_not(mark)
# 如果你想看mark图像此时的样子，取消注释此行
# 图像此时的样子
 
#cv.imshow('Markers_v2', mark)
# 生成随机颜色
colors = []
for contour in contours
 
colors.append((rng.randint(0,256), rng.randint(0,256), rng.randint(0,256)))
# 创建结果图像
 
dst = np.zeros((markers.shape[0], markers.shape[1], 3), dtype=np.uint8)
# 用随机颜色填充标记对象
    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]
# 可视化最终图像