Digital Image Fundamentals & Classical Vision

Computer Vision is the discipline of enabling computational systems to extract high-level semantic understanding, geometric structure, and actionable insights from digital images and multidimensional visual signals. Before the advent of deep convolutional neural networks and vision transformers, computer vision was grounded in the rigorous mathematical foundations of digital signal processing, differential geometry, multiscale analysis, and linear algebra.

Understanding classical vision—spatial domain filtering, gradient vector fields, Canny edge detection, structure tensors (Harris corners), and scale-space representations (SIFT)—is not merely historical pedagogy. Classical algorithms remain mission-critical for low-power edge robotics, high-throughput industrial optical inspection, real-time SLAM (Simultaneous Localization and Mapping), and data augmentation preprocessing pipelines. Furthermore, the foundational inductive biases that govern deep vision architectures—such as shift equivariance, spatial locality, and hierarchical feature abstraction—derive directly from these classical operators.

1. Digital Image Representation and Color Geometry#

Spatial and Radiometric Quantization#

A continuous physical visual scene is an analog optical intensity distribution f_c(x, y, λ, t), where (x, y) denote spatial coordinates, λ represents spectral wavelength, and t represents time. A digital camera converts this continuous signal into a discrete representation via two physical sampling operations:

+-----------------------------------------------------------------------------------+
| DIGITAL IMAGE ACQUISITION PIPELINE |
+-----------------------------------------------------------------------------------+
| Continuous Optical Scene: f_c(x, y, λ) |
| | |
| v (Spatial Sampling via CMOS / CCD Pixel Sensor Grid) |
| Discrete Pixel Matrix: Size H x W (Height x Width) |
| | |
| v (Radiometric Quantization via Analog-to-Digital Converter - ADC) |
| Quantized Digital Tensor: I(x, y) in {0, 1, ..., 2^b - 1}^C |
| where b = bit depth (e.g., b = 8 bits -> [0, 255]), C = color channels (e.g., 3) |
+-----------------------------------------------------------------------------------+

1. Spatial Quantization (Sampling): Partitions the continuous image plane into a uniform rectangular grid of H rows and W columns. The spatial resolution determines the Nyquist sampling limit: according to the Shannon-Whittaker theorem, to prevent aliasing, the spatial sampling rate must be at least twice the highest spatial frequency present in the optical scene.
2. Radiometric Quantization: Discretizes the continuous electrical voltage output by each photosensor site into an integer gray-level value spanning 2^b discrete levels. For standard 8-bit unsigned integer channels (uint8), intensity values range across [0, 255]. High-dynamic-range (HDR) scientific imaging utilizes 16-bit integers ([0, 65535]) or 32-bit IEEE-754 floating-point representations ([0.0, 1.0]).

Color Spaces and Trichromatic Colorimetry#

Human visual perception relies on three classes of retinal cone photoreceptors (S, M, and L cones), sensitive respectively to short (≈ 420 nm), medium (≈ 530 nm), and long (≈ 560 nm) wavelengths. Consequently, color is represented as a three-dimensional manifold:

In classical object tracking, RGB is notoriously brittle: changing room lighting alters all three (R, G, B) coordinates simultaneously. Transforming to HSV decouples the invariant object color (H) from shadows and lighting intensity (V), enabling robust thresholding under dynamic illumination.

2. Spatial Domain Filtering and Discrete 2D Convolution#

Spatial domain filtering modifies pixel intensities based on a localized neighborhood of surrounding pixels using a sliding mathematical matrix called a Kernel (or Mask).

The Discrete 2D Cross-Correlation and Convolution Operators#

Let I ∈ R^{H × W} represent an input image, and let K ∈ R^{(2a+1) × (2b+1)} represent a spatial filter kernel of odd dimensions k_h = 2a + 1 and k_w = 2b + 1.

• 2D Cross-Correlation:

(I * K)(x, y) = ∑_{i=-a}^a ∑_{j=-b}^b I(x + i, y + j) K(i, j)

• 2D Discrete Convolution:

(I * K)(x, y) = ∑_{i=-a}^a ∑_{j=-b}^b I(x - i, y - j) K(i, j)

Difference: Discrete convolution mirrors the kernel across both horizontal and vertical axes prior to sliding. For symmetric kernels (such as Gaussian or Laplacian filters), cross-correlation and convolution are mathematically identical. In deep learning frameworks (PyTorch, TensorFlow), the operator labeled Conv2d is technically cross-correlation, as learned weight kernels do not require runtime reflection.

Separable Kernels and Algorithmic Acceleration#

A 2D kernel K ∈ R^{k × k} is Separable if it can be factored into the outer product of two 1D vector kernels:

K = u v^T where u ∈ R^{k × 1}, v ∈ R^{1 × k}

+-----------------------------------------------------------------------------------+
| SEPARABLE 2D CONVOLUTION ACCELERATION |
+-----------------------------------------------------------------------------------+
| STANDARD 2D CONVOLUTION (k^2 operations per pixel): |
| [Pixel (x, y)] <=== Convolve with full k x k matrix ===> k^2 multiplications |
| |
| SEPARABLE 1D CONVOLUTION (2k operations per pixel): |
| Pass 1: Convolve every row with horizontal 1D kernel [ v ] ===> k mults/pixel |
| Pass 2: Convolve every column of intermediate with [ u ] ===> k mults/pixel |
| Total Complexity: 2k multiplications per pixel! |
| Algorithmic Speedup: k^2 / 2k = k / 2 |
+-----------------------------------------------------------------------------------+

The 2D Gaussian Kernel:

The continuous 2D isotropic Gaussian filter with scale parameter σ:

G(x, y, σ) = 1 / (2π σ²) exp( -(x² + y²) / (2σ²) )

can be mathematically factored as:

G(x, y, σ) = ( (1 / √(2π)σ) exp( -(x^2 / 2σ^2) ) ) × ( (1 / √(2π)σ) exp( -(y^2 / 2σ^2) ) ) = G_x(x) × G_y(y)

For a 15 × 15 kernel (k = 15), separable convolution requires 2 × 15 = 30 operations per pixel, compared to 15^2 = 225 operations for 2D convolution—delivering an 7.5× computational speedup.

3. Differential Operators and the Canny Edge Detector#

Edges correspond to localized spatial discontinuities in image brightness, reflecting physical phenomena: object boundaries, surface normal creases, depth discontinuities, and illumination shadows.

The Image Gradient Vector Field#

Let continuous image intensity be modeled as a differentiable scalar field I(x, y). The spatial gradient vector ∇ I is defined as:

∇ I(x, y) = [ [∂I/∂x], [∂I/∂y] ] = [ [I_x], [I_y] ]

• Gradient Magnitude: Quantifies the rate of local intensity change:

\|∇ I(x, y)\| = √(I_x^2 + I_y^2) ≈ |I_x| + |I_y|

• Gradient Orientation: Points in the spatial direction of maximum intensity growth (perpendicular to the edge boundary):

θ(x, y) = atan2(I_y, I_x)

The Sobel Differential Operators:

In discrete digital grids, spatial derivatives are approximated using finite difference kernels that integrate local smoothing to suppress sensor noise:

S_x = [ [-1, 0, +1], [-2, 0, +2], [-1, 0, +1] ], S_y = [ [-1, -2, -1], [0, 0, 0], [+1, +2, +1] ]

S_x = [ [1], [2], [1] ] [ [-1, 0, +1] ] (Separable filter: vertical smoothing + horizontal difference)

The Canny Edge Detection Pipeline (1986)#

John F. Canny formalized optimal edge detection against three mathematical criteria:

1. Low Error Rate: Minimal false positives (marking noise as edges) and false negatives (missing true edges).
2. Localization: Detected edge pixels must be centered as close as possible to true physical edges.
3. Single Response: Exactly one response per edge (no thick, multi-pixel blurred boundaries).

+-----------------------------------------------------------------------------------+
| CANNY EDGE DETECTION 5-STAGE PIPELINE |
+-----------------------------------------------------------------------------------+
| 1. GAUSSIAN SMOOTHING: Convolve with G_σ to suppress high-frequency noise |
| 2. GRADIENT VECTOR FIELD: Compute magnitude ||∇I|| and angle θ via Sobel |
| 3. NON-MAXIMUM SUPPRESSION (NMS): Thin wide edges to 1-pixel ridges along angle θ|
| 4. DOUBLE THRESHOLDING: Classify pixels into Strong, Weak, and Suppressed |
| - M(x, y) >= T_high --> Strong Edge |
| - T_low <= M < T_high --> Weak Edge |
| - M(x, y) < T_low --> Discard (Noise) |
| 5. HYSTERESIS TRACKING: Retain Weak pixels only if 8-connected to a Strong pixel |
+-----------------------------------------------------------------------------------+

Non-Maximum Suppression (NMS):

At each pixel (x, y), the gradient orientation θ(x, y) is rounded to one of four canonical discrete sectors: 0^° (horizontal), 45^° (diagonal), 90^° (vertical), or 135^° (anti-diagonal).

• The magnitude M(x, y) is compared against its two immediate neighbors along the gradient normal direction.
• If M(x, y) is strictly greater than both neighbors, it is preserved; otherwise, it is suppressed to zero (M ≤ftarrow 0). NMS thins wide edge bands into razor-sharp 1-pixel wide ridges.

4. Feature Detection: Harris Corners and SIFT#

While edges localize boundaries, they suffer from the Aperture Problem: looking at an edge through a small local window reveals motion or position along only one dimension (perpendicular to the edge). Corners—points where two distinct edge directions intersect—provide unique, 2D-constrained localized visual landmarks.

The Harris Corner Detector and the Structure Tensor#

Harris & Stephens (1988) analyzed the change in local intensity E(u, v) when shifting an image window by small displacement (u, v):

E(u, v) = ∑_{(x, y) ∈ W} w(x, y) [ I(x + u, y + v) - I(x, y) ]^2

Using first-order Taylor expansion: I(x + u, y + v) ≈ I(x, y) + u I_x + v I_y:

E(u, v) ≈ ∑_{(x, y) ∈ W} w(x, y) [ u I_x + v I_y ]^2 = [ [u, v] ] M [ [u], [v] ]

where M ∈ R^{2 × 2} is the Second-Moment Matrix (Structure Tensor):

M = ∑_{(x, y) ∈ W} w(x, y) [ [I_x^2, I_x I_y], [I_x I_y, I_y^2] ] = [ [⟨ I_x^2 ⟩, ⟨ I_x I_y ⟩], [⟨ I_x I_y ⟩, ⟨ I_y^2 ⟩] ]

EIGENVALUE GEOMETRY OF THE STRUCTURE TENSOR M:
λ_2 ^
 | EDGE (λ_1 << λ_2) CORNER (λ_1 >> 0, λ_2 >> 0)
 | Significant gradient in one Significant gradient in both
 | direction only spatial directions!
 |
 | FLAT REGION (λ_1 ≈ 0, λ_2 ≈ 0)
 | Zero intensity variation
 +--------------------------------------------------------> λ_1

The Harris Corner Response Metric R:

Directly computing eigenvalues λ_1, λ_2 via quadratic formula is computationally expensive. Harris proposed an algebraic formulation:

R = det(M) - k (trace(M))^2

where:

det(M) = λ_1 λ_2 = ⟨ I_x^2 ⟩ ⟨ I_y^2 ⟩ - ⟨ I_x I_y ⟩^2

trace(M) = λ_1 + λ_2 = ⟨ I_x^2 ⟩ + ⟨ I_y^2 ⟩

and k is an empirical sensitivity parameter (typically 0.04 ≤ k ≤ 0.06).

• Corner: R > 0 and R > threshold (λ_1, λ_2 are both large).
• Edge: R < 0 (λ_1 >> λ_2 or λ_2 >> λ_1).
• Flat: |R| ≈ 0 (λ_1, λ_2 ≈ 0).

Scale-Invariant Feature Transform (SIFT)#

Harris corners are rotation-invariant, but fail catastrophically under scale changes: zooming into a sharp corner enlarges the radius of curvature, turning the corner into a gentle edge within a fixed-size window.

David Lowe (2004) solved this through SIFT (Scale-Invariant Feature Transform):

1. Scale-Space Representation:

The only linear scale-space kernel that does not introduce spurious visual artifacts is the Gaussian kernel. Scale space L(x, y, σ) is constructed by convolving image I with Gaussians of varying scale σ:

L(x, y, σ) = G(x, y, σ) * I(x, y)

1. Difference-of-Gaussians (DoG) Pyramid:

SIFT efficiently approximates the computationally heavy Laplacian-of-Gaussian (σ^2 ∇^2 G) by computing differences between adjacent smoothed octave levels:

D(x, y, σ) = L(x, y, kσ) - L(x, y, σ)

1. Keypoint Localization:

Extrema (minima/maxima) are detected by comparing each sample point in D(x, y, σ) against its 26 spatio-temporal neighbors (8 in the current scale level, 9 in the scale above, 9 in the scale below). Unstable low-contrast points and edge responses are pruned using a 3D Hessian structure tensor.

1. Orientation Assignment:

Computes gradient magnitudes and directions around the keypoint, creating a 36-bin orientation histogram. The dominant peak assigns a canonical rotation angle θ, ensuring rotation invariance.

1. 128-Dimensional Local Descriptor:

Constructs a 16 × 16 neighborhood around the keypoint, divided into sixteen 4 × 4 sub-regions. Each sub-region generates an 8-bin gradient orientation histogram:

Descriptor Length = 16 sub-regions × 8 bins = 128 dimensions

The 128D vector is L2-normalized, clipped at 0.2, and re-normalized, providing invariance to affine illumination changes, 3D viewpoint perspective, and sensor noise.

5. University-Grade Checkpoint Practice Problems#

Problem 1: Separable 2D Gaussian Kernel Convolution Computational Complexity#

Context: An industrial semiconductor visual inspection system analyzes high-resolution silicon wafer images with dimensions:

H = 4,096 rows, W = 3,072 columns (12,582,912 pixels per image)

To suppress optical sensor noise, each image is convolved with a 2D isotropic Gaussian filter of kernel dimensions k × k with k = 15 (a = b = 7):

G(x, y, σ) = 1 / (2π σ²) exp( -(x² + y²) / (2σ²) )

We compare two convolution architectures:

• Method A (Direct 2D Spatial Convolution): Standard unseparated convolution computing k^2 multiplications and k^2 - 1 additions per pixel.
• Method B (Separable 1D Cascade Convolution): Factoring the 2D Gaussian into horizontal and vertical 1D kernels:

G(x, y, σ) = G_x(x) × G_y(y)

Pass 1 applies horizontal 1D convolution (k multiplications, k - 1 additions per pixel).

Pass 2 applies vertical 1D convolution on the intermediate image (k multiplications, k - 1 additions per pixel).

Assume border padding is handled with negligible boundary overhead.

Task:

1. Formally prove that the 2D Gaussian function is separable into G_x(x) G_y(y).
2. Calculate the total number of floating-point multiplications required to process a single image under Method A.
3. Calculate the total number of floating-point multiplications required to process a single image under Method B.
4. Compute the absolute floating-point operations saved and the theoretical speedup factor.
5. If the inspection camera operates at a real-time throughput of 60 frames per second (fps), calculate the required floating-point multiplication throughput in GigaFLOPs per second (GFLOPs/s) for both methods.

Solution:

1. Proof of Separability:

G(x, y, σ) = 1 / (2π σ²) exp( -(x² + y²) / (2σ²) )

Using the exponent product rule e^{-(a + b)} = e^{-a} e^{-b}:

G(x, y, σ) = (1 / √(2π)σ) exp(-(x^2 / 2σ^2)) × (1 / √(2π)σ) exp(-(y^2 / 2σ^2))

Setting G_x(x) = (1 / √(2π)σ) e^{-(x^2 / 2σ^2)} and G_y(y) = (1 / √(2π)σ) e^{-(y^2 / 2σ^2)}:

G(x, y, σ) = G_x(x) G_y(y)

The outer product of the two 1D vectors equals the 2D matrix: G = g_y g_x^T. The kernel is separable.

1. Multiplications under Method A (Direct 2D):

* Total pixels: N = 4,096 × 3,072 = 12,582,912 pixels.

* Multiplications per pixel: k^2 = 15^2 = 225 mults/pixel.

* Total multiplications:

M_A = 12,582,912 × 225 = 2,831,155,200 multiplications (≈ 2.831× 10^9)

1. Multiplications under Method B (Separable 1D):

* Pass 1 (Horizontal 1D): k = 15 mults/pixel.

* Pass 2 (Vertical 1D): k = 15 mults/pixel.

* Total multiplications per pixel: 2 × k = 2 × 15 = 30 mults/pixel.

* Total multiplications:

M_B = 12,582,912 × 30 = 377,487,360 multiplications (≈ 3.775× 10^8)

1. Efficiency Comparison & Speedup:

* Multiplications saved:

Δ M = 2,831,155,200 - 377,487,360 = 2,453,667,840 operations saved per frame

* Theoretical Speedup Ratio:

Speedup = (M_A / M_B) = (k^2 / 2k) = (k / 2) = (15 / 2) = 7.5×

1. Compute Throughput at 60 FPS:

* Method A Throughput:

Throughput_A = 2,831,155,200 × 60 = 169,869,312,000 mults/s ≈ 169.87 GFLOPs/s

* Method B Throughput:

Throughput_B = 377,487,360 × 60 = 22,649,241,600 mults/s ≈ 22.65 GFLOPs/s

System Engineering Conclusion*: Method A requires an expensive high-end GPU or FPGA to process 170 GFLOPs/s, whereas separable convolution (Method B) executes comfortably at 22.6 GFLOPs/s on an inexpensive embedded processor.

Problem 2: Discrete Sobel Gradient Magnitude & Direction Calculus#

Context: In an optical edge tracking pipeline, a 3 × 3 sub-window of grayscale pixel intensities centered at coordinate (x, y) is extracted:

P = [ [I(x-1, y-1), I(x, y-1), I(x+1, y-1)], [I(x-1, y), I(x, y), I(x+1, y)], [I(x-1, y+1), I(x, y+1), I(x+1, y+1)] ] = [ [30, 40, 90], [35, 50, 160], [40, 70, 210] ]

The system evaluates edge properties using standard 3 × 3 Sobel differential operators:

S_x = [ [-1, 0, +1], [-2, 0, +2], [-1, 0, +1] ], S_y = [ [-1, -2, -1], [0, 0, 0], [+1, +2, +1] ]

Coordinate convention:

• x increases to the right (columns).
• y increases downward (rows).

Task:

1. Compute the discrete horizontal spatial gradient G_x = P * S_x.
2. Compute the discrete vertical spatial gradient G_y = P * S_y.
3. Calculate the exact Euclidean Gradient Magnitude \|∇ I\| and the Manhattan approximation \|∇ I\|_1.
4. Calculate the Gradient Orientation angle θ in degrees (θ ∈ [-180^°, +180^°]).
5. Determine the canonical Canny normal edge sector (0^°, 45^°, 90^°, 135^°) to which this pixel's gradient angle belongs.

Solution:

1. Horizontal Gradient G_x:

* Evaluating element-wise product of P with S_x:

G_x = (-1 · 30) + (0 · 40) + (+1 · 90) + (-2 · 35) + (0 · 50) + (+2 · 160) + (-1 · 40) + (0 · 70) + (+1 · 210)

G_x = -30 + 0 + 90 - 70 + 0 + 320 - 40 + 0 + 210

G_x = 60 + 250 + 170 = 480

1. Vertical Gradient G_y:

* Evaluating element-wise product of P with S_y:

G_y = (-1 · 30) + (-2 · 40) + (-1 · 90) + (0 · 35) + (0 · 50) + (0 · 160) + (+1 · 40) + (+2 · 70) + (+1 · 210)

G_y = -30 - 80 - 90 + 0 + 0 + 0 + 40 + 140 + 210

G_y = -200 + 390 = 190

1. Gradient Magnitude Calculation:

* Euclidean Magnitude:

\|∇ I\| = √(G_x^2 + G_y^2) = √(480^2 + 190^2) = √(230,400 + 36,100) = √(266,500) ≈ 516.236

* Manhattan L_1 Approximation:

\|∇ I\|_1 = |G_x| + |G_y| = |480| + |190| = 670

1. Gradient Orientation Angle θ:

θ = atan2(G_y, G_x) = atan2(190, 480)

* Since G_x > 0 and G_y > 0, the angle lies in the first quadrant:

θ = arctan((190 / 480)) = arctan(0.395833...) ≈ 0.37699 radians

* Converting to degrees:

θ = 0.37699 × (180^° / π) ≈ 21.599^° ≈ 21.60^°

1. Canonical Canny Sector Classification:

* In the Canny pipeline, angles are quantized into four 45^° sectors centered at:

* Sector 0 (0^°): [-22.5^°, 22.5^°) ∪ [157.5^°, 180^°] ∪ [-180^°, -157.5^°) (Horizontal edge, vertical normal).

* Sector 1 (45^°): [22.5^°, 67.5^°) ∪ [-157.5^°, -112.5^°).

* Sector 2 (90^°): [67.5^°, 112.5^°) ∪ [-112.5^°, -67.5^°).

* Sector 3 (135^°): [112.5^°, 157.5^°) ∪ [-67.5^°, -22.5^°).

* Since θ = 21.60^° falls within [-22.5^°, 22.5^°):

Canonical Sector = 0^° (Horizontal edge normal)

* In Non-Maximum Suppression, pixel (x, y) will be compared horizontally against its left neighbor (x-1, y) and right neighbor (x+1, y).

Problem 3: Harris Corner Structure Tensor Eigenvalue & Response Analysis#

Context: In an autonomous robot visual odometry pipeline, a localized image patch around coordinate (x_0, y_0) is analyzed using the Harris corner detector.

The Second-Moment Matrix (Structure Tensor) M is computed across Gaussian window W:

M = [ [⟨ I_x^2 ⟩, ⟨ I_x I_y ⟩], [⟨ I_x I_y ⟩, ⟨ I_y^2 ⟩] ] = [ [650, 420], [420, 580] ]

Harris Corner Sensitivity Constant: k = 0.04.

Corner Acceptance Threshold: T_{corner} = 80,000.

Task:

1. Compute the matrix trace: trace(M).
2. Compute the matrix determinant: det(M).
3. Calculate the exact eigenvalues λ_1, λ_2 of M by solving the characteristic polynomial det(M - λ I) = 0.
4. Compute the Harris Corner Response scalar R = det(M) - k (trace(M))^2.
5. Classify the patch as a Flat Region, Edge, or Corner, and verify your conclusion using both the eigenvalues λ_1, λ_2 and the response metric R.

Solution:

1. Matrix Trace Calculation:

trace(M) = M_{11} + M_{22} = 650 + 580 = 1,230

1. Matrix Determinant Calculation:

det(M) = (M_{11} × M_{22}) - (M_{12} × M_{21})

det(M) = (650 × 580) - (420 × 420) = 377,000 - 176,400 = 200,600

1. Eigenvalue Derivation:

* Characteristic equation:

λ^2 - trace(M) λ + det(M) = 0

λ^2 - 1,230 λ + 200,600 = 0

* Applying the quadratic formula:

λ = (1,230 ± √(1,230^2 - 4(1)(200,600)) / 2) = (1,230 ± √(1,512,900 - 802,400) / 2)

λ = (1,230 ± √(710,500) / 2) = (1,230 ± 842.9116 / 2)

* Evaluating roots:

λ_1 = (1,230 + 842.9116 / 2) = (2,072.9116 / 2) ≈ 1,036.46

λ_2 = (1,230 - 842.9116 / 2) = (387.0884 / 2) ≈ 193.54

* Verification: λ_1 + λ_2 = 1,036.46 + 193.54 = 1,230 = trace(M). λ_1 λ_2 ≈ 200,600 = det(M).

1. Harris Response Metric R:

R = det(M) - k (trace(M))^2

R = 200,600 - 0.04 × (1,230)^2 = 200,600 - 0.04 × 1,512,900 = 200,600 - 60,516

R = 140,084

1. Structural Classification:

Eigenvalue Analysis*: Both eigenvalues are strictly positive and substantially greater than zero: λ_1 ≈ 1,036.5, λ_2 ≈ 193.5. Neither eigenvalue dominates the other to zero (the ratio λ_1 / λ_2 ≈ 5.35 is bounded).

Response Metric Analysis*: R = 140,084 > T_{corner} = 80,000.

Conclusion: The candidate pixel represents a Corner* (a high-curvature point with significant gradient variance in both spatial directions). The visual odometry tracker will extract this coordinate as a stable landmark.

Problem 4: Canny Sub-Pixel Non-Maximum Suppression & Hysteresis Continuity#

Context: In a precision robotic metrology system, the Canny edge detection pipeline evaluates pixel P_0 located at coordinate (x, y) = (50, 50).

Pipeline State at (50, 50):

• Computed gradient magnitude: M_0 = M(50, 50) = 74.0.
• Computed gradient orientation: θ = 30.0^° (0.5236 radians).

Local Gradient Magnitude Neighborhood Matrix:

The gradient magnitudes M(x + Δ x, y + Δ y) for the 3 × 3 grid surrounding (50, 50) are given as:

M_{local} = [ [M(49, 49), M(50, 49), M(51, 49)], [M(49, 50), M(50, 50), M(51, 50)], [M(49, 51), M(50, 51), M(51, 51)] ] = [ [52.0, 68.0, 88.0], [45.0, 74.0, 62.0], [40.0, 58.0, 70.0] ]

Sub-Pixel Non-Maximum Suppression Formulation:

Rather than crude 45^° sector quantization, the high-precision pipeline computes the gradient values at points p_1 and p_2 along the exact gradient line (θ = 30.0^°) passing through P_0 using bilinear interpolation between adjacent grid neighbors:

• In the first quadrant (θ = 30^°, 0^° ≤ θ ≤ 45^°):

* p_1 lies between the East neighbor (51, 50) and Northeast neighbor (51, 49):

M(p_1) = (1 - tanθ) M(51, 50) + tanθ M(51, 49)

* p_2 lies between the West neighbor (49, 50) and Southwest neighbor (49, 51):

M(p_2) = (1 - tanθ) M(49, 50) + tanθ M(49, 51)

Hysteresis Thresholds:

• T_{high} = 80.0
• T_{low} = 45.0

Task:

1. Calculate tan(30^°) and evaluate the interpolated gradient magnitudes M(p_1) and M(p_2) along the exact gradient normal vector.
2. Determine whether pixel P_0 survives Non-Maximum Suppression (i.e., whether M_0 ≥ M(p_1) and M_0 ≥ M(p_2)).
3. Classify the surviving pixel as a Strong Edge, Weak Edge, or Suppressed Pixel based on T_{high} and T_{low}.
4. Given that neighbor pixel (51, 49) is a verified Strong Edge (M = 88.0 > T_{high}), explain whether pixel P_0 is ultimately preserved in the final binary edge map via Hysteresis Edge Tracking.

Solution:

1. Interpolated Gradient Magnitudes M(p_1) and M(p_2):

* tan(30^°) = (1 / √(3)) ≈ 0.57735

* Weighting factor: 1 - tan(30^°) = 1 - 0.57735 = 0.42265

* Evaluating M(p_1) along forward normal:

* East neighbor M(51, 50) = 62.0.

* Northeast neighbor M(51, 49) = 88.0.

M(p_1) = (0.42265 × 62.0) + (0.57735 × 88.0) = 26.2043 + 50.8068 = 77.0111 ≈ 77.01

* Evaluating M(p_2) along backward normal:

* West neighbor M(49, 50) = 45.0.

* Southwest neighbor M(49, 51) = 40.0.

M(p_2) = (0.42265 × 45.0) + (0.57735 × 40.0) = 19.01925 + 23.0940 = 42.11325 ≈ 42.11

1. Non-Maximum Suppression Decision:

* Center magnitude: M_0 = 74.0.

* Forward interpolated neighbor: M(p_1) = 77.01.

* Backward interpolated neighbor: M(p_2) = 42.11.

* Condition for survival: M_0 ≥ M(p_1) AND M_0 ≥ M(p_2).

* Comparison:

74.0 < 77.01 ⇒ M_0 < M(p_1)

Result: P_0 is NOT a local maximum* along the gradient normal vector! The true edge peak is located closer to neighbor (51, 49).

NMS Action: Pixel P_0 is suppressed to zero* (M_0 ≤ftarrow 0).

1. Hysteresis Classification:

* Because P_0 failed Non-Maximum Suppression, it is discarded immediately. It does not advance to the double-thresholding stage.

(Hypothetical Evaluation)*: If crude sector quantization were used instead of sub-pixel interpolation, 30^° would map to the 45^° diagonal sector, comparing M_0 = 74.0 against M(51, 49) = 88.0, which also correctly suppresses P_0.

1. Hysteresis Connectivity Evaluation:

Even though neighbor (51, 49) is a Strong Edge (88.0 ≥ 80.0), Hysteresis Tracking connects only* pixels that survived Non-Maximum Suppression as valid Weak Edges.

* Because P_0 was thinned out by NMS, it is permanently discarded, preserving optimal 1-pixel edge sharpness and preventing artificial edge blurring.