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

目录

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

上一篇教程： 点多边形测试
下一篇教程： 散焦去模糊滤波器

原作者	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("源图像", src);
 
    // 将背景从白色更改为黑色，因为这将在以后使用距离变换时帮助提取
    // 更好的结果
    Mat mask;
inRange(src, Scalar(255, 255, 255), Scalar(255, 255, 255), mask);
src.setTo(Scalar(0, 0, 0), mask);
 
    // 显示输出图像
imshow("黑色背景图像", 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( "新的锐化图像", 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);
 
    // 对 dist 图像进行一点膨胀
    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) {
        // 加载图像
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("源图像", 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( "Laplace Filtered Image", 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);
 
        // 对 dist 图像进行一点膨胀
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='使用距离变换和分水岭算法进行图像分割的代码。'
示例代码展示了如何使用拉普拉斯滤波来分割重叠对象，\
以及分水岭和距离变换')
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('源图像', 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)
 
# 稍微膨胀一下 dist 图像
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)
# 如果要查看标记图像在该阶段的样子
# 请取消以下注释
#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('最终结果', 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("源图像", 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("源图像", 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('源图像', src)

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

C++

    // 将背景从白色更改为黑色，因为这将在以后使用距离变换时帮助提取
    // 更好的结果
    Mat mask;
inRange(src, Scalar(255, 255, 255), Scalar(255, 255, 255), mask);
src.setTo(Scalar(0, 0, 0), mask);
 
    // 显示输出图像
imshow("黑色背景图像", 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("黑色背景图像", src);

Python

# 将背景从白色更改为黑色，因为这将有助于稍后提取
# 使用距离变换时获得更好的结果
src[np.all(src == 255, axis=2)] = 0
 
# 显示输出图像
cv.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;
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( "新的锐化图像", 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("新锐化图像", 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('新锐化图像', imgResult)

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

C++

    // 从源图像创建二进制图像
    Mat bw;
cvtColor(imgResult, bw, COLOR_BGR2GRAY);
threshold(bw, bw, 40, 255, THRESH_BINARY | THRESH_OTSU);
imshow("二进制图像", 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("二值图像", bw);

Python

# 从源图像创建二值图像
bw = cv.cvtColor(imgResult, cv.COLOR_BGR2GRAY)
_, bw = cv.threshold(bw, 40, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
cv.imshow('二值图像', bw)

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

C++

    // 执行距离变换算法
    Mat dist;
distanceTransform(bw, dist, DIST_L2, 3);
 
    // 将距离图像归一化为范围 = {0.0, 1.0}
    // 这样我们就可以可视化并对其进行阈值化
normalize(dist, dist, 0, 1.0, NORM_MINMAX);
imshow("距离变换图像", 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("距离变换图像", 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('距离变换图像', dist)

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

C++

    // 阈值化以获取峰值
    // 这将成为前景对象的标记
threshold(dist, dist, 0.4, 1.0, THRESH_BINARY);
 
    // 对 dist 图像进行一点膨胀
    Mat kernel1 = Mat::ones(3, 3, CV_8U);
dilate(dist, dist, kernel1);
imshow("峰值", dist);

Java

        // 阈值化以获取峰值
        // 这将成为前景对象的标记
Imgproc.threshold(dist, dist, 0.4, 1.0, Imgproc.THRESH_BINARY);
 
        // 对 dist 图像进行一点膨胀
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

# 进行阈值化以获得峰值
# 这将是前景对象的标记
_, dist = cv.threshold(dist, 0.4, 1.0, cv.THRESH_BINARY)
 
# 稍微膨胀一下 dist 图像
kernel1 = np.ones((3,3), dtype=np.uint8)
dist = cv.dilate(dist, kernel1)
cv.imshow('峰值', dist)

• 然后，我们使用 cv::findContours 函数从每个斑点中创建一个种子/标记，用于分水岭算法

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

Python

# 创建距离图像的 CV_8U 版本
# 它需要用于 findContours()
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)

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

C++

    // 执行分水岭算法
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);

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.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('最终结果', dst)