what is image segmentation?

image segmentation is the process of partitioning an image into multiple segments to make the image easier to analyze. each segment or region usually corresponds to a different object or a part of an object.

by segmenting an image, we can focus on specific areas, making it easier to identify and analyze objects within the image.

importance of image segmentation

image segmentation is imporant for various applications in computer vision, such as −

object detection: identifying and locating objects within an image.
medical imaging: analyzing medical images to detect and diagnose diseases.
autonomous driving: understanding the surroundings by identifying roads, vehicles, pedestrians, etc.
image editing: selecting and manipulating specific parts of an image.

types of image segmentation

there are several types of image segmentation, they are −

thresholding
edge-based segmentation
region-based segmentation
clustering-based segmentation
deep learning-based segmentation

thresholding

thresholding is one of the simplest segmentation techniques. it converts a grayscale image into a binary image by setting a threshold value.

pixels with intensity values above the threshold are assigned one value (e.g., white), and those below the threshold are assigned another value (e.g., black).

we can apply thresholding using the following ways −

global thresholding: uses a single threshold value for the entire image.

import cv2

# load image in grayscale
image = cv2.imread('image.jpg', cv2.imread_grayscale)
_, binary_image = cv2.threshold(image, 127, 255, cv2.thresh_binary)

adaptive thresholding: uses different threshold values for different regions of the image.

adaptive_binary_image = cv2.adaptivethreshold(image, 255, cv2.adaptive_thresh_gaussian_c, cv2.thresh_binary, 11, 2)

edge-based segmentation

edge-based segmentation detects the edges within an image and uses them to define the boundaries of segments. this method relies on detecting significant changes in intensity values.

the commonly used edge detection method is canny edge detector. it is a multi-stage algorithm that detects a wide range of edges.

edges = cv2.canny(image, 100, 200)

region-based segmentation

region-based segmentation groups pixels into regions based on predefined criteria, such as intensity values or texture. the idea is to group neighboring pixels with similar properties into the same region.

the common region based methods are as shown below −

region growing: starts with seed points and grows regions by adding neighboring pixels that meet certain criteria.
watershed algorithm: treats the image as a topographic surface and finds the watershed lines to segment the regions.

following is an example on how to apply region based segmentation −

# apply watershed algorithm
import numpy as np

# convert image to binary
_, binary_image = cv2.threshold(image, 0, 255, cv2.thresh_binary_inv + cv2.thresh_otsu)
# perform distance transform
distance_transform = cv2.distancetransform(binary_image, cv2.dist_l2, 5)
_, foreground = cv2.threshold(distance_transform, 0.7 * distance_transform.max(), 255, 0)
foreground = np.uint8(foreground)
unknown = cv2.subtract(binary_image, foreground)
# marker labeling
_, markers = cv2.connectedcomponents(foreground)
markers = markers + 1
markers[unknown == 255] = 0
# apply watershed
markers = cv2.watershed(image, markers)
image[markers == -1] = [255, 0, 0]

clustering-based segmentation

clustering-based segmentation groups pixels into clusters based on their similarity. k-means clustering is a popular method for this type of segmentation.

following is an example on how to apply k-means clustering −

import numpy as np

# convert image to float32
image = np.float32(image)
# define criteria and apply k-means
criteria = (cv2.term_criteria_eps + cv2.term_criteria_max_iter, 10, 1.0)
_, labels, centers = cv2.kmeans(image, 3, none, criteria, 10, cv2.kmeans_random_centers)
# convert back to uint8 and reshape the image
centers = np.uint8(centers)
segmented_image = centers[labels.flatten()]
segmented_image = segmented_image.reshape((image.shape))

deep learning-based segmentation

deep learning-based segmentation uses convolutional neural networks (cnns) to segment images. this method is very accurate and can handle complex images.

following are the common deep learning models −

fully convolutional networks (fcns): replace fully connected layers with convolutional layers to produce segmentation maps.
u-net: a popular model for biomedical image segmentation that uses an encoder-decoder architecture.

following is an example on how to apply deep learning based segmentation −

from keras.models import model
from keras.layers import input, conv2d, maxpooling2d, upsampling2d, concatenate

inputs = input((image_height, image_width, 1))
conv1 = conv2d(64, 3, activation='relu', padding='same')(inputs)
pool1 = maxpooling2d(pool_size=(2, 2))(conv1)
conv2 = conv2d(128, 3, activation='relu', padding='same')(pool1)
up1 = concatenate([upsampling2d(size=(2, 2))(conv2), conv1], axis=3)
conv3 = conv2d(64, 3, activation='relu', padding='same')(up1)
outputs = conv2d(1, 1, activation='sigmoid')(conv3)
model = model(inputs=[inputs], outputs=[outputs])

Save or share this article