OpenCV 使用分水岭算法进行图像分割

2744557306

分水岭算法：模拟地理形态的图像分割
分水岭算法通过模拟自然地形来实现图像中物体的分类。在这一过程中，每个像素的灰度值被视作其高度，灰度值较高的像素形成山脊，即分水岭，而二值化阈值则相当于水平面，低于这个水平面的区域会被“淹没”。
测地线距离：地形分析的核心
4 \. O" ^+ t4 k/ \9 c测地线距离是分水岭算法中的一个关键概念，它代表地球表面两点间的最短路径。这一概念在图论中同样适用，指的是图中两节点间的最短路径，与欧氏距离相比，测地线距离考虑的是实际路径。
分水岭算法的执行步骤
梯度图像分类：根据灰度值对梯度图像中的像素进行分类，并设定测地距离阈值。起始点标记：选择灰度值最小的像素点作为起始点，这些点通常是局部最小值。水平面上升：随着阈值的增长，测量周围邻域像素到起始点的测地距离。若小于阈值，则淹没这些像素；若大于阈值，则在这些像素上建立“大坝”。大坝设置与区域分区：随着水平面的上升，建立更多的大坝，直到所有区域在分水岭线上相遇，完成图像的分区。避免过度分割的策略
分水岭算法可能会因噪声或干扰导致图像过度分割，形成过多的小区域。解决这一问题的方法包括：
高斯平滑：通过高斯平滑减少噪声，合并小分区。基于标记的分水岭算法：选择相对较高的灰度值像素作为起始点，手动标记或使用自动方法如距离变换来确定，从而合并小区域。OpenCV 实现 Watershed 算法函数原型：void watershed( InputArray image, InputOutputArray markers );1参数说明：image：输入的图像，必须是8位的单通道灰度图像。这个图像的梯度信息将被用来模拟水流向低洼地区流动的过程。
markers：输入输出参数，是一个与原图像大小相同的图像，用于存放分割标记。在函数调用前，这个图像应该被初始化，其中包含了用户定义的分割区域的标记。标记是通过正整数索引来表示的，表示用户已知的前景或背景区域。所有未知区域（即算法需要确定的区域）应该被标记为0。函数执行完成后，每个像素点的标记将被更新为“种子”组件的值，或者在区域边界处被设置为-1。
  ?! n! b6 m, N* T功能说明：watershed 函数会分析 image 的梯度信息，并使用 markers 中定义的已知区域作为分割的起点（种子点）。算法将从这些种子点开始，逐步对图像中的其他像素点进行区域归属的判定，直到所有像素点都被标记。在分割过程中，如果两个相邻的已知区域（种子点）相遇，算法会在它们之间创建一个边界，以避免这些区域合并在一起，从而实现分割。注意事项：markers 中的标记非常重要，它们直接影响分割的结果。因此，用户需要仔细考虑如何标记已知的前景和背景区域。分水岭算法可能会导致过度分割，特别是当图像中存在大量噪声时。在实际应用中，可能需要对图像进行预处理，如使用高斯模糊去除小的局部最小值，以减少过度分割的问题。

1. #include <opencv2/imgcodecs.hpp>
   : h) H9 |\" P% C3 R* o+ d/ F$ R
2. #include <opencv2/highgui.hpp>
   / f/ p; \/ i\" z\" Q% O& m+ c' x% K
3. #include <opencv2/imgproc.hpp>
   4 A% A1 l7 o6 n9 D% v& k
4. 
   1 m* D% D! L' O7 g# M
5. void showImg(const std::string& windowName, const cv::Mat& img){1 Z8 c5 @* I+ X2 V4 S: |
   
6.     cv::imshow(windowName, img);
   8 m+ V8 s, f) G
7. }
   6 c* ?' w. a$ K
8. 
   ! G; o+ u\" B3 I1 v. E4 s! J+ z
9. void getBackground(const cv::Mat& source, cv::Mat& dst) {
   ; _0 H8 t\" ?; s) ~: y% L) @' }6 }
10.     cv::dilate(source, dst, cv::Mat::ones(3, 3, CV_8U)); // 3x3 核2 z6 i7 _: ]2 F8 z2 b
    
11. }
    - G) _* [+ V) W/ G# @\" o( P) F
12. , D& L9 ]; o4 r: x* s8 P
    
13. void getForeground(const cv::Mat& source, cv::Mat& dst) {
    : h. h4 n# F* Q' @) v
14.     cv::distanceTransform(source, dst, cv::DIST_L2, 3, CV_32F);
    & _; H3 k6 X\" i% k
15.     cv::normalize(dst, dst, 0, 1, cv::NORM_MINMAX);
    2 h; E\" r, t. b0 K3 B2 B0 E
16. }
    4 G3 N- h2 z: k. ?\" P6 x! f6 c\" w
17. 
    + h3 {+ F! X1 Y* m. K( _& ~
18. void findMarker(const cv::Mat& sureBg, cv::Mat& markers, std::vector<std::vector<cv::Point>>& contours) {- i  E* J( _\" ^  }\" t
    
19.     cv::findContours(sureBg, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);/ N1 D4 [# \+ S; Y. ~
    
20.     // 绘制前景标记7 B8 M, `$ m2 {\" U, a8 T
    
21.     for (size_t i = 0, size = contours.size(); i < size; i++)
    2 L! Y6 @- {) X# p, V. T  i* ]
22.         drawContours(markers, contours, static_cast<int>(i), cv::Scalar(static_cast<int>(i)+1), -1);
    ' p1 a, t! `\" V& l# y+ B9 \# k
23. }
    \" a$ F4 I! Y, Q
24. % t\" e( p1 E% M0 w4 N
    
25. void getRandomColor(std::vector<cv::Vec3b>& colors, size_t size) {$ B5 Q: R0 I6 R0 \9 T; E  O
    
26.     for (int i = 0; i < size ; ++i) {/ V4 f4 v; x3 B* P( X# C
    
27.         int b = cv::theRNG().uniform(0, 256);* i& U- }9 N* [5 ?0 f8 P) m+ u
    
28.         int g = cv::theRNG().uniform(0, 256);
    % }- J/ ]: S* w, T% Y# w& [- }8 Q/ s
29.         int r = cv::theRNG().uniform(0, 256);
    0 u2 a2 [2 K* ]5 F. f
30.         colors.emplace_back(cv::Vec3b((uchar)b, (uchar)g, (uchar)r));' `) [) `$ H1 X\" {
    
31.     }
      g; V: c& H9 `6 E5 l
32. }. m* {; Z1 d7 z0 v  c/ m$ d
    
33. : r. M/ C6 |6 J\" J' @2 O* I1 b- X
    
34. int main(int argc, char** argv) {
    5 @8 }  Y1 G4 H. V( w7 A
35.     if(argc < 2){8 V) `! I+ p0 z8 l9 e
    
36.         std::cerr << "Errorn";
    9 N8 p( |8 W7 V8 p+ k
37.         std::cerr << "Provide Input Image:n n";
    & w9 M' M; E; ?! f7 c\" e. A
38.         return -1;0 l( R; D! E0 ^7 i  b, @. W
    
39.     }: s7 I$ e3 z$ n, l
    
40.     cv::Mat original_img = cv::imread(argv[1]);
    7 k2 R* k. p1 Y9 L) J7 B8 F6 L  [8 ?
41.     if(original_img.empty()){
    & |9 ^9 t: z. u, L( K8 e6 O' [
42.         std::cerr << "Errorn";
    8 b& V\" O  w. }, n
43.         std::cerr << "Cannot Read Imagen";
    ) {( ~# j% B- {9 {5 l. ?
44.         return -1;2 _2 g- g/ j+ `' q
    
45.     }
    8 }. V; f7 r\" e$ `
46.     cv::Mat shifted;. j3 K* O. y\" h4 z
    
47.     cv::pyrMeanShiftFiltering(original_img, shifted, 21, 51);5 M8 B( {6 V+ F
    
48.     showImg("Mean Shifted", shifted);2 x  t8 {8 S9 Y# Y6 G
    
49.     cv::Mat gray_img;
    1 H1 @. N\" h7 ^\" |0 e/ _& K: u% S! R
50.     cv::cvtColor(original_img, gray_img, cv::COLOR_BGR2GRAY);
    0 ~7 p  \3 ~  _\" H2 j; X
51.     showImg("GrayIMg", gray_img);
    + E0 G9 d9 |' p, b  r
52.     cv::Mat bin_img;
    6 `/ {\" ]/ X  b
53.     cv::threshold(gray_img, bin_img, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);9 V# a; D3 V' j: F( z: J
    
54.     showImg("thres img", bin_img);! X, X: j% o% j  ?
    
55.     cv::Mat sure_bg;
    \" q\" m- B/ p9 g, C
56.     getBackground(bin_img, sure_bg);( j$ L: y/ J5 A, P% ~
    
57.     showImg("Sure Background", sure_bg);
    5 g9 y% E3 ^6 G: N! c- X
58.     cv::Mat sure_fg;  ?# ~. y- q% E3 M
    
59.     getForeground(bin_img, sure_fg);4 ~5 E; {$ ]; ~  t# T% ~
    
60.     showImg("Sure ForeGround", sure_fg);0 }8 @& O' s3 m, n- Z; B+ G
    
61.     cv::Mat markers = cv::Mat::zeros(sure_bg.size(), CV_32S);
    , H0 N. a1 Q: `/ `' `1 e6 X
62.     std::vector<std::vector<cv::Point>> contours;+ U9 j2 J  c3 @- n( b
    
63.     findMarker(sure_bg, markers, contours);* Q- Q! y4 z! X9 X& U! F* a\" {
    
64.     cv::circle(markers, cv::Point(5, 5), 3, cv::Scalar(255), -1); // 在标记周围绘制圆圈+ W, m5 v0 t3 _' o+ ]& l
    
65.     ; u  _. j4 e\" v
    
66.     cv::watershed(original_img, markers);
    , E  r3 {, x+ G\" g- ?
67.     cv::Mat mark;* K/ H* ?8 A4 `- L' x1 B
    
68.     markers.convertTo(mark, CV_8U);
    5 ]) E8 G) E$ H0 P! P
69.     cv::bitwise_not(mark, mark); // 将白色转换为黑色，黑色转换为白色
    * Y0 n% P. D/ h' {4 N+ J
70.     showImg("MARKER", mark);6 W+ S. M1 z$ B* i3 j
    
71.     // 在图像中突出显示标记 /! \, r3 ^/ F/ u6 |: {
    
72.     std::vector<cv::Vec3b> colors;* h6 i# S1 O\" k8 j+ O; u8 A
    
73.     getRandomColor(colors, contours.size()); // 创建结果图像# [# g& V, u5 O+ v. D# ~' V1 A
    
74.     cv::Mat dst = cv::Mat::zeros(markers.size(), CV_8UC3);
    5 n4 ]6 y9 q' v1 S
75.     // 用随机颜色填充标记的对象
    ! ~7 A/ L! \1 U\" e8 y
76.     for (int i = 0; i < markers.rows; i++)
    8 S) d. N0 z* d8 t
77.     {- R0 L1 g9 k0 r: `
    
78.         for (int j = 0; j < markers.cols; j++)
    % {\" x6 ]: L$ x; z# _
79.         {
    3 |: n* P+ T4 M$ u# ~1 e! K
80.             int index = markers.at(i,j);/ u. N) o- m, Z
    
81.             if (index > 0 && index <= static_cast<int>(contours.size()))
    , u0 l1 Y, d. u% a
82.                 dst.at<cv::Vec3b>(i,j) = colors[index-1];
      |2 A- {\" m; F' ^; ^
83.         }
    1 f1 p3 o8 j8 }* W, [; |
84.     }+ E1 s) v! n% F5 |  y5 ^( a0 ?
    
85.     showImg("Final Result", dst);
    , K$ M$ U6 Z( N
86.     cv::waitKey(0);; O  Q6 M! u$ |7 l& }. z, m
    
87.     return 0;; D  z# _0 H$ A: ]' S
    
88. }
    - ~. N$ y2 d7 f. r, P/ L

复制代码

————————————————
$ e3 p5 j: L( r# O                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。                        原文链接：https://blog.csdn.net/matt45m/article/details/138211359
' Y0 S9 _- B& H* n. h
9 D, ^! V* d: Q) A