Segmentation algorithms for monochrome images operate on two fundamental gray-level properties: discontinuity and similarity. Approaches based on detecting abrupt local intensity variations form the computational foundation for separating objects from background.

Differential Operators and Local Features

First-order derivatives typically generate thicker edge representations, while second-order derivatives excel at detecting fine structural details. Second-order operators produce double-edge responses at intensity ramps and step transitions, where the sign indicates the direction of the gray-level chenge (light-to-dark versus dark-to-light).

Detection of Isolated Points and Linear Structures

Isolated points are identified using the Laplacian operator:

∇²f(x,y) = ∂²f/∂x² + ∂²f/∂y² = f(x+1,y) + f(x-1,y) + f(x,y+1) + f(x,y-1) - 4f(x,y)

Linear features require directional convolution masks. Horizontal structures respond maximally to specific kernels, while 45°, vertical, and -45° orientations each possess optimized detection templates for enhanced directional selectivity.

Edge Models and Detection Methodology

Edge characterization utilizes three primary models:

• Step edges: Ideal transitions occurring over single-pixel distances
• Ramp edges: Gradual intensity changes where slope inversely correlates with blur magnitude
• Roof edges: Represent linear structures where base width depends on line thickness and sharpness

The edge detection pipeline comprises three essential stages: noise attenuation via smoothing filters, candidate edge point identification, and precise edge localization.

Gradient-Based Edge Operators

Edge magnitude and orientation derive from first-order partial derivatives.

Prewitt operator computes horizontal and vertical gradients:

g_x = (z₇ + z₈ + z₉) - (z₁ + z₂ + z₃) g_y = (z₃ + z₆ + z₉) - (z₁ + z₄ + z₇)

Sobel operator incorporates center pixel weighting for noise suppression:

g_x = (z₇ + 2z₈ + z₉) - (z₁ + 2z₂ + z₃) g_y = (z₃ + 2z₆ + z₉) - (z₁ + 2z₄ + z₇)

Roberts operator employs 2×2 diagonal masks:

g_x = z₉ - z₅ g_y = z₈ - z₆

import cv2
import numpy as np

# Prewitt edge detection implementation
img_gray = cv2.imread('input.jpg', cv2.IMREAD_GRAYSCALE)
kernel_h = np.array([[1, 1, 1], [0, 0, 0], [-1, -1, -1]], dtype=np.int16)
kernel_v = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]], dtype=np.int16)
grad_h = cv2.filter2D(img_gray, cv2.CV_16S, kernel_h)
grad_v = cv2.filter2D(img_gray, cv2.CV_16S, kernel_v)
abs_h = cv2.convertScaleAbs(grad_h)
abs_v = cv2.convertScaleAbs(grad_v)
prewitt_edges = cv2.addWeighted(abs_h, 0.5, abs_v, 0.5, 0)

# Sobel gradient computation
grad_x = cv2.Sobel(img_gray, cv2.CV_16S, 1, 0, ksize=3)
grad_y = cv2.Sobel(img_gray, cv2.CV_16S, 0, 1, ksize=3)
mag_x = cv2.convertScaleAbs(grad_x)
mag_y = cv2.convertScaleAbs(grad_y)
sobel_result = cv2.addWeighted(mag_x, 0.5, mag_y, 0.5, 0)

# Roberts cross-gradient operator
roberts_x = np.array([[0, 1], [-1, 0]], dtype=np.int16)
roberts_y = np.array([[1, 0], [0, -1]], dtype=np.int16)
rx = cv2.filter2D(img_gray, cv2.CV_16S, roberts_x)
ry = cv2.filter2D(img_gray, cv2.CV_16S, roberts_y)
roberts_final = cv2.addWeighted(cv2.convertScaleAbs(rx), 0.5, 
                                cv2.convertScaleAbs(ry), 0.5, 0)

Advanced Edge Detection Algorithms

The Marr-Hildreth detector utilizes the Laplacian of Gaussian (LoG), operating on the principle that intensity variations are scale-independent. Abrupt changes create zero-crossings in the second derivative. The algorithm applies Gasusian smoothing, computes the Laplacian, and detects zero-crossings to locate edges.

The Canny algorithm achieves superior performance through Gaussian smoothing, gradient computation, non-maximum suppression, and hysteresis thresholding.

# Canny edge detection pipeline
source_img = cv2.imread('sample.jpg', cv2.IMREAD_GRAYSCALE)
blurred_img = cv2.GaussianBlur(source_img, (5, 5), sigmaX=0)
canny_edges = cv2.Canny(blurred_img, threshold1=50, threshold2=150)
cv2.imshow('Original', source_img)
cv2.imshow('Canny Result', canny_edges)
cv2.waitKey(0)
cv2.destroyAllWindows()

Intensity Thresholding Techniques

When objects exhibit distinct intensity from background, histograms display bimodal distributions. Thresholding separates these modes using a value T, generating binary output:

g(x,y) = 1 if f(x,y) > T, otherwise 0

Iterative Global Thresholding

The algorithm proceeds as follows:

1. Initialize threshold estimate T
2. Partition image in to G₁ (pixels > T) and G₂ (pixels ≤ T)
3. Calculate mean intensities m₁ and m₂ for each group
4. Update T = (m₁ + m₂)/2
5. Iterate until |T_new - T_old| < ε

Otsu Automatic Thresholding

This method maximizes between-class variance, optimal for bimodal distributions. It exhaustively searches the intensity histogram to identify the threshold value that optimally separates foreground and background classes.

import cv2
import matplotlib.pyplot as plt

input_image = cv2.imread('scene.jpg', cv2.IMREAD_GRAYSCALE)
optimal_thresh, binary_img = cv2.threshold(input_image, 0, 255, 
                                          cv2.THRESH_BINARY + cv2.THRESH_OTSU)

plt.figure(figsize=(8, 6))
plt.imshow(binary_img, cmap='gray')
plt.title(f'Otsu Segmentation (T={optimal_thresh:.1f})')
plt.axis('off')
plt.tight_layout()
plt.show()

Adaptive and Variable Thresholding

Global thresholding fails under non-uniform illumination. Local approaches divide the image into subregions or compute thresholds based on neighborhood statistics (moving averages) to compensate for lighting gradients.

Region-Based Segmentation Approaches

Region Growing initiates from seed points and aggregates neighboring pixels satisfying homogeneity criteria, such as intensity range or color similarity constraints.

Region Splitting and Merging begins with arbitrary disjoint regions, recursively subdividing non-homogeneous areas while merging adjacent similar regions to achieve segmentation.

Morphological Watershed treats image intensity as a topographic surface, constructing dams (watershed lines) that separate catchment basins to delineate object boundaries.