【Basic】Image Watershed Algorithm in MATLAB: Implementing Image Watershed Segmentation

# 1. Overview of the Image Watershed Algorithm

The image watershed algorithm is a segmentation technique based on mathematical morphology that treats an image as a terrain where pixel values represent heights. The algorithm considers local minima in the image as watersheds and floods the areas to segment the image. Watershed algorithms can effectively segment objects with complex shapes and are widely used in the field of image segmentation.

# 2. Theoretical Foundation of the Image Watershed Algorithm

### 2.1 Concepts and Principles of the Image Watershed

The image watershed algorithm is an image segmentation technique based on topological principles, inspired by the geographical concept of watersheds. Geographically, a watershed is a ridge line that separates one drainage basin from another, determining the flow direction of rainwater into different rivers or lakes.

In the context of the image watershed algorithm, an image is treated as a topographic map, where pixel values represent the height of the terrain. The algorithm considers local maxima pixels in the image as peaks, while other pixels are seen as slopes. Starting from each peak, the algorithm floods outwards until it encounters other peaks or the image boundary. The boundaries between the flooded areas form the image's watershed lines, which divide the image into different regions.

### 2.2 Mathematical Model of the Watershed Algorithm

The mathematical model of the image watershed algorithm can be described as follows:

Given an image f(x, y), where x and y are the coordinates of the image. The algorithm starts from a set of marked points S, which correspond to the local maxima pixels in the image.

For each marked point s ∈ S, the algorithm performs the following steps:

1. **Compute the flooding function:** Calculate the distance function D(x, y, s) from each pixel (x, y) to the marked point s in the image.
2. **Flood the area:** Find the pixel (x, y) with the smallest distance function D(x, y, s) and add it to the flooded area R(s).
3. **Update the distance function:** Update the distance function D(x, y, s) to be equal to the distance from the pixel (x, y) to the boundary of the flooded area R(s).

The algorithm repeats steps 2 and 3 until all pixels are flooded or until the flooded areas meet. The boundaries between the meeting flooded areas form the image's watershed lines.

#### Code Block:

import numpy as np

def watershed_algorithm(image, markers):
     """
     Image Watershed Algorithm

     Parameters:
         image: input image
         markers: marked points

     Returns:
         Watershed segmentation result
     """

     # Initialize distance function
     distance_function = np.zeros_like(image)

     # Initialize flooded areas
     flooded_regions = [[] for _ in range(len(markers))]

     # Loop through marked points
     for i, marker in enumerate(markers):
         # Compute the flooding function
         distance_function = np.minimum(distance_function, np.abs(image - image[marker[0], marker[1]]))

         # Flood the area
         flooded_regions[i].append(marker)

     # Loop through flooded areas
     while True:
         # Find the pixel with the minimum distance function
         min_pixel = np.unravel_index(np.argmin(distance_function), distance_function.shape)

         # Update the flooded areas
         for i, flooded_region in enumerate(flooded_regions):
             if min_pixel in flooded_region:
                 continue
             else:
                 flooded_regions[i].append(min_pixel)
                 break

         # Update the distance function
         distance_function[min_pixel[0], min_pixel[1]] = np.inf

         # Check if all pixels are flooded
         if np.all(distance_function == np.inf):
             break

     # Return wate