影像分割與距離變換和分水嶺演算法

目錄

• 目標
• 理論
• 程式碼
• 解釋 / 結果

上一個教程： 點多邊形測試
下一個教程： 散焦去模糊濾鏡

原始作者	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]
# 視覺化最終影像