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

2744557306

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

1. #include <opencv2/imgcodecs.hpp>, f# R2 T% Y$ A+ ^0 Z0 l: A
   
2. #include <opencv2/highgui.hpp>& S. e) X; I4 M$ R, L# ?, P! J7 \( R' P
   
3. #include <opencv2/imgproc.hpp>) [8 B- D/ b! a% v3 v
   
4. 
   # i6 ~% ?/ s) Z7 _+ h: h4 m
5. void showImg(const std::string& windowName, const cv::Mat& img){5 D- M& T. A* B5 g2 A' t6 S
   
6.     cv::imshow(windowName, img);
   ' B' P  y2 Z& \+ g# u: L/ d
7. }
   0 f  b: w9 d: A( f8 K
8. . J' Y+ K& C; H1 @9 t$ k
   
9. void getBackground(const cv::Mat& source, cv::Mat& dst) {5 e+ W: e& j3 H! L* |
   
10.     cv::dilate(source, dst, cv::Mat::ones(3, 3, CV_8U)); // 3x3 核
    ) f+ s  {/ ^/ a8 m. }
11. }! K# Y% j\" S2 V+ M8 o
    
12. 
    2 m7 `' o- a4 G# t. Y) o3 l9 s
13. void getForeground(const cv::Mat& source, cv::Mat& dst) {
    * X0 \: g! I% R* ^
14.     cv::distanceTransform(source, dst, cv::DIST_L2, 3, CV_32F);
    / a* a1 _6 b; C% z7 Y/ }
15.     cv::normalize(dst, dst, 0, 1, cv::NORM_MINMAX);
    2 W6 x* I  P\" s) @
16. }' w/ N4 e6 [- t2 P, g
    
17. \" u8 h2 ]4 r; j2 C( u8 R+ g
    
18. void findMarker(const cv::Mat& sureBg, cv::Mat& markers, std::vector<std::vector<cv::Point>>& contours) {
    ! D* d5 Y7 }7 I$ d0 _. o
19.     cv::findContours(sureBg, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);0 Z2 l- |\" h, w& X& T  [3 B/ g
    
20.     // 绘制前景标记
    3 a' U( y. |! [% c/ D2 C
21.     for (size_t i = 0, size = contours.size(); i < size; i++); k9 D. v& r5 p
    
22.         drawContours(markers, contours, static_cast<int>(i), cv::Scalar(static_cast<int>(i)+1), -1);2 u: ~5 {8 L: j\" s- {0 h
    
23. }
    % @4 ^9 W5 W* V3 y
24. 
    ' H  J9 K# |; ~
25. void getRandomColor(std::vector<cv::Vec3b>& colors, size_t size) {; r' v2 Q& h5 v. a5 ~* K
    
26.     for (int i = 0; i < size ; ++i) {9 v. B. H; `7 z
    
27.         int b = cv::theRNG().uniform(0, 256);
    & e+ @1 ~& h, L( m6 B, |- U
28.         int g = cv::theRNG().uniform(0, 256);  U& w6 n' D\" e, K+ k  ?1 w
    
29.         int r = cv::theRNG().uniform(0, 256);- ^2 [$ q$ c  n% g( i1 v\" X$ e# ~/ i
    
30.         colors.emplace_back(cv::Vec3b((uchar)b, (uchar)g, (uchar)r));: M; s4 {& X+ s0 b
    
31.     }
    4 }/ H1 S( ?% v\" t0 y2 {! w
32. }
    . n) @5 O$ G* v7 x
33. 9 j. x( M' F; e' ]
    
34. int main(int argc, char** argv) {
    8 w; [7 V8 N* A
35.     if(argc < 2){) o% s4 p% W0 U) h, b
    
36.         std::cerr << "Errorn";6 @# j. W! S9 H5 A\" |
    
37.         std::cerr << "Provide Input Image:n n";
      [( m) s( }: H' t9 e  T; ~
38.         return -1;- I  F) ]& R$ u' Z2 w; x3 n
    
39.     }
    , r1 C, q* ]  Z- {9 Y' P
40.     cv::Mat original_img = cv::imread(argv[1]);
    1 J, \- r9 {. B' }( G1 G
41.     if(original_img.empty()){3 C- V, m! g. Z( l. d2 N
    
42.         std::cerr << "Errorn";
    & q# k% m, a8 ^: c
43.         std::cerr << "Cannot Read Imagen";6 o5 u$ c& Q: n4 [/ h+ p, [
    
44.         return -1;7 Z- w# a- e  z: s8 ^
    
45.     }
    ' l$ Z, p. r/ n; }
46.     cv::Mat shifted;5 C7 ~: l7 `) u4 ~. b/ v4 b. c
    
47.     cv::pyrMeanShiftFiltering(original_img, shifted, 21, 51);
    9 E% G8 K8 r* {\" v. e
48.     showImg("Mean Shifted", shifted);
    # c3 S7 g$ B$ l% U& Q
49.     cv::Mat gray_img;3 ?\" e& F: K8 y* K& ]/ s2 u
    
50.     cv::cvtColor(original_img, gray_img, cv::COLOR_BGR2GRAY);  N2 E# t- A& r$ q$ M8 j
    
51.     showImg("GrayIMg", gray_img);% y- W9 U' U\" G# ]$ H
    
52.     cv::Mat bin_img;9 }* ]6 n  h6 B, N! G: `8 H
    
53.     cv::threshold(gray_img, bin_img, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
    ( H: l. f& k. p/ \' H  u% S' Z
54.     showImg("thres img", bin_img);+ V% m$ W  g8 q  I
    
55.     cv::Mat sure_bg;; i# C9 i1 F2 L
    
56.     getBackground(bin_img, sure_bg);
      _7 o! j; N! S6 Q- C' q3 w) T
57.     showImg("Sure Background", sure_bg);6 I8 E# e4 h4 C# S* V% F\" I2 D5 b
    
58.     cv::Mat sure_fg;* E% C; B- C0 O! O
    
59.     getForeground(bin_img, sure_fg);
    6 R  S  Q4 W/ x# F' s- k
60.     showImg("Sure ForeGround", sure_fg);
    6 B; @9 `% W) o9 A7 e
61.     cv::Mat markers = cv::Mat::zeros(sure_bg.size(), CV_32S);
    2 F1 v\" ~0 \- [6 h' m
62.     std::vector<std::vector<cv::Point>> contours;
    - L( _$ y. O5 w' i5 G% O% e
63.     findMarker(sure_bg, markers, contours);
      x& L6 _) q7 c/ M, T
64.     cv::circle(markers, cv::Point(5, 5), 3, cv::Scalar(255), -1); // 在标记周围绘制圆圈
    / X; p( }* S; e, m3 \
65.     ; r0 U' Z! N  j& p1 V% B
    
66.     cv::watershed(original_img, markers);
    / L+ a: m; A( n  V: f* N
67.     cv::Mat mark;
    % P: m\" J3 k3 s8 K: `1 N
68.     markers.convertTo(mark, CV_8U);
    7 L6 d  O3 ]  s% k: S
69.     cv::bitwise_not(mark, mark); // 将白色转换为黑色，黑色转换为白色
    ( n8 M& H4 F% w
70.     showImg("MARKER", mark);
    5 d' U$ D1 i% x( Y8 K/ Q9 v7 C, }
71.     // 在图像中突出显示标记 /$ ~9 L( _% W) V* X- O9 g
    
72.     std::vector<cv::Vec3b> colors;& e3 y8 f$ c* S\" l' \
    
73.     getRandomColor(colors, contours.size()); // 创建结果图像
    - e  @7 ~5 \\" j) z) p: z1 ?) k
74.     cv::Mat dst = cv::Mat::zeros(markers.size(), CV_8UC3);7 G, B8 {  b2 J7 P  }. ^, L, a0 ]
    
75.     // 用随机颜色填充标记的对象
    % C7 x+ X+ I  K7 Z; p
76.     for (int i = 0; i < markers.rows; i++). A: L( U3 M2 U+ z7 g9 k1 D
    
77.     {
    6 I- G; V* S& f8 g3 s
78.         for (int j = 0; j < markers.cols; j++)
    ; G: h, p. t. z' A9 l
79.         {
    . d! @+ W0 j: D: T! X# L
80.             int index = markers.at(i,j);- U4 c. K  E8 \+ z
    
81.             if (index > 0 && index <= static_cast<int>(contours.size()))$ i4 ]. }\" u, N
    
82.                 dst.at<cv::Vec3b>(i,j) = colors[index-1];3 E1 z) y$ d% L$ i% ]* K
    
83.         }; S* @6 a/ @\" S& z* ]0 ^
    
84.     }
    2 @) \- _- Y4 R# q( T. w
85.     showImg("Final Result", dst);
    4 |3 o7 U# a* J* {1 |' y* Q+ G/ @
86.     cv::waitKey(0);
    6 J; c& Z: D6 |2 Z+ Q
87.     return 0;
    & d4 b6 E6 }4 R* F' V
88. }2 i- R  l* Q% `2 A\" o4 N
    

复制代码

————————————————
                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。                        原文链接：https://blog.csdn.net/matt45m/article/details/138211359
3 b+ t" c! G, d" @2 c& i$ D4 s2 k