使用距离变换和分水岭算法进行图像分割

目录

• 目标
• 原理
• 代码
• 说明 / 结果

上一篇教程: 点多边形测试 (Point Polygon Test)
下一篇教程: 失焦去模糊滤波器 (Out-of-focus Deblur Filter)

原作者	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[])
{
    // 加载图像
    CommandLineParser parser( argc, argv, "{@input | cards.png | 输入图像}" );
    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
    if( src.empty() )
    {
cout << "无法打开或找到图像！\n" << endl;
cout << "用法: " << argv[0] << " <输入图像>" << 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( "Laplace Filtered Image", imgLaplacian );
imshow( "New Sharped Image", imgResult );
 
    // 从源图像创建二值图像
    Mat bw;
cvtColor(imgResult, bw, COLOR_BGR2GRAY);
threshold(bw, bw, 40, 255, THRESH_BINARY | THRESH_OTSU);
imshow("Binary Image", bw);
 
    // 执行距离变换算法
    Mat dist;
distanceTransform(bw, dist, DIST_L2, 3);
 
    // 将距离图像归一化到 {0.0, 1.0} 范围
    // 以便我们可以可视化并对其进行阈值处理
normalize(dist, dist, 0, 1.0, NORM_MINMAX);
imshow("Distance Transform Image", dist);
 
    // 阈值化以获得峰值 (peaks)
    // 这将作为前景对象的标记
threshold(dist, dist, 0.4, 1.0, THRESH_BINARY);
 
    // 对距离图像进行稍微膨胀
    Mat kernel1 = Mat::ones(3, 3, CV_8U);
dilate(dist, dist, kernel1);
imshow("Peaks", 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("Markers", markers8u);
 
    // 执行分水岭算法
watershed(imgResult, markers);
 
    Mat mark;
markers.convertTo(mark, CV_8U);
bitwise_not(mark, mark);
    // imshow("Markers_v2", 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("Final Result", 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) {
        // 加载图像
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);
        }
 
        // 显示源图像
HighGui.imshow("Source Image", 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("Black Background Image", 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( "Laplace Filtered Image", imgLaplacian );
HighGui.imshow("New Sharped Image", 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("Binary Image", 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("Distance Transform Image", distDisplay);
 
        // 阈值化以获得峰值 (peaks)
        // 这将作为前景对象的标记
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("Peaks", 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("Markers", 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); // 如果你想看当时的标记
        // 图像长什么样，请取消此行注释
 
        // 生成随机颜色
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("Final Result", 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='使用距离变换和分水岭算法进行图像分割的代码。\
显示如何使用拉普拉斯滤波、\
分水岭和距离变换来分割重叠对象的示例代码')
parser.add_argument('--input', help='输入图像的路径。', default='cards.png')
args = parser.parse_args()
 
src = cv.imread(cv.samples.findFile(args.input))
if src is None
print('无法打开或找到图像:', args.input)
exit(0)
 
# 显示源图像
cv.imshow('Source Image', src)
 
 
 
src[np.all(src == 255, axis=2)] = 0
 
# 显示输出图像
cv.imshow('Black Background Image', 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('New Sharped Image', imgResult)
 
 
 
bw = cv.cvtColor(imgResult, cv.COLOR_BGR2GRAY)
_, bw = cv.threshold(bw, 40, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
cv.imshow('Binary Image', 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('Distance Transform Image', 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('Peaks', 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', markers_8u)
 
 
 
cv.watershed(imgResult, markers)
 
#mark = np.zeros(markers.shape, dtype=np.uint8)
mark = markers.astype('uint8')
mark = cv.bitwise_not(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.imshow('Final Result', dst)
 
 
cv.waitKey()

说明 / 结果

• 加载源图像，检查其是否加载无误，然后显示它

C++

    // 加载图像
    CommandLineParser parser( argc, argv, "{@input | cards.png | 输入图像}" );
    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
    if( src.empty() )
    {
cout << "无法打开或找到图像！\n" << endl;
cout << "用法: " << argv[0] << " <输入图像>" << endl;
        return -1;
    }
 
    // 显示原图
    imshow("Source Image", src);

Java

        // 加载图像
        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);
        }
 
        // 显示源图像
HighGui.imshow("Source Image", srcOriginal);

Python

parser = argparse.ArgumentParser(description='使用距离变换和分水岭算法进行图像分割的代码。\
显示如何使用拉普拉斯滤波、\
分水岭和距离变换来分割重叠对象的示例代码')
parser.add_argument('--input', help='输入图像的路径。', default='cards.png')
args = parser.parse_args()
 
src = cv.imread(cv.samples.findFile(args.input))
if src is None
print('无法打开或找到图像:', args.input)
exit(0)
 
# 显示源图像
cv.imshow('Source Image', src)

• 然后，如果我们有一张白色背景的图像，最好将其转换为黑色。这将在我们应用距离变换时，帮助我们更容易地辨别前景对象

C++

    // 将背景从白色改为黑色，因为这有助于随后在
    // 使用距离变换期间提取更好的结果
    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);

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("Black Background Image", src);

Python

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

• 随后，我们将锐化图像，以使前景对象的边缘更加尖锐。我们将应用一个相当强的拉普拉斯滤波器（二阶导数的近似）

C++

    // 创建用于锐化图像的卷积核
    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( "Laplace Filtered Image", imgLaplacian );
    imshow( "New Sharped Image", imgResult );

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( "Laplace Filtered Image", imgLaplacian );
HighGui.imshow("New Sharped Image", imgResult);

Python

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('New Sharped Image', imgResult)

• 现在我们将新的锐化后的源图像分别转换为灰度图和二值图

C++

    // 从源图像创建二值图像
    Mat bw;
    cvtColor(imgResult, bw, COLOR_BGR2GRAY);
    threshold(bw, bw, 40, 255, THRESH_BINARY | THRESH_OTSU);
    imshow("Binary Image", bw);

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("Binary Image", bw);

Python

bw = cv.cvtColor(imgResult, cv.COLOR_BGR2GRAY)
_, bw = cv.threshold(bw, 40, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
cv.imshow('Binary Image', bw)

• 现在我们准备在二值图像上应用距离变换。此外，我们对输出图像进行归一化，以便能够可视化并对结果进行阈值处理

C++

    // 执行距离变换算法
    Mat dist;
    distanceTransform(bw, dist, DIST_L2, 3);
 
    // 将距离图像归一化到 {0.0, 1.0} 范围
    // 以便我们可以可视化并对其进行阈值处理
    normalize(dist, dist, 0, 1.0, NORM_MINMAX);
    imshow("Distance Transform Image", dist);

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("Distance Transform Image", distDisplay);

Python

dist = cv.distanceTransform(bw, cv.DIST_L2, 3)
 
# 将距离图像归一化到 {0.0, 1.0} 范围
# 以便我们可以可视化并对其进行阈值处理
cv.normalize(dist, dist, 0, 1.0, cv.NORM_MINMAX)
cv.imshow('Distance Transform Image', dist)

• 我们对 dist 图像进行阈值处理，然后执行一些形态学操作（即膨胀），以便从上述图像中提取峰值

C++

    // 阈值化以获得峰值 (peaks)
    // 这将作为前景对象的标记
    threshold(dist, dist, 0.4, 1.0, THRESH_BINARY);
 
    // 对距离图像进行稍微膨胀
    Mat kernel1 = Mat::ones(3, 3, CV_8U);
    dilate(dist, dist, kernel1);
    imshow("Peaks", dist);

Java

        // 阈值化以获得峰值 (peaks)
        // 这将作为前景对象的标记
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("Peaks", distDisplay2);

Python

_, 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('Peaks', dist)

• 然后，我们借助 cv::findContours 函数从每个连通区域（blob）中为分水岭算法创建一个种子/标记

C++

    // 创建距离图像的 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("Markers", markers8u);

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("Markers", markersDisplay);
Imgproc.circle(markers, new Point(5, 5), 3, new Scalar(255, 255, 255), -1);

Python

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', markers_8u)

• 最后，我们可以应用分水岭算法，并可视化结果

C++

    // 执行分水岭算法
    watershed(imgResult, markers);
 
    Mat mark;
markers.convertTo(mark, CV_8U);
    bitwise_not(mark, mark);
    // imshow("Markers_v2", 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("Final Result", 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); // 如果你想看当时的标记
        // 图像长什么样，请取消此行注释
 
        // 生成随机颜色
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("Final Result", dst);

Python

cv.watershed(imgResult, markers)
 
#mark = np.zeros(markers.shape, dtype=np.uint8)
mark = markers.astype('uint8')
mark = cv.bitwise_not(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.imshow('Final Result', dst)