Pixel Neighborhood

easyFREEWhat is Computer Vision?Image ProcessingCV: Introduction to Computer Vision

Implement a function to extract the neighborhood of pixels around a given position in an image. This task is essential in image processing as it involves analyzing local regions of an image.

In computer vision, many operations rely on considering local neighborhoods, such as filtering, where the value of a pixel is determined by its neighboring pixels. The neighborhood of the pixel at position $(\text{row}, \text{col})$ in an image can be represented as a square region of size $n \times n$ centered at that pixel. To handle boundary conditions, zero-padding is used, where pixels outside the image boundaries are assumed to have a value of $0$ .

The neighborhood is defined by:

The half-size $\lfloor n/2 \rfloor$ , which sets how far the window reaches from the center in each direction.
The window covers every row from $\text{row} - \text{half-size}$ to $\text{row} + \text{half-size}$ and every column from $\text{col} - \text{half-size}$ to $\text{col} + \text{half-size}$ , both ends inclusive.
A window position inside the image takes the image's value there; a position outside the image takes $0$ .

n = \text{neighborhood size} \\ \text{half-size} = \lfloor n/2 \rfloor \\ \text{bounds} = (\text{row} - \text{half-size}, \text{row} + \text{half-size}), (\text{col} - \text{half-size}, \text{col} + \text{half-size})

Return the neighborhood as an $n \times n$ list of lists (one inner list per row, top to bottom), with the center pixel in the middle.

This technique is widely used in image filtering applications.

Example

Input

get_neighborhood([[1,2,3],[4,5,6],[7,8,9]], 1, 1, 3)

Output

[[1,2,3],[4,5,6],[7,8,9]]

Reasoning

Inputs: image is a $3 \times 3$ grid of intensities $1$ – $9$ (row $0$ at the top), row $= 1$ , col $= 1$ pick the centre pixel (value $5$ ), and size $n = 3$ is the window's side length.
Bounds: the half-size is $h = \lfloor 3/2 \rfloor = 1$ , so the window covers rows $0$ through $2$ and columns $0$ through $2$ , inclusive: $2h + 1 = 3$ positions each way.
Padding: valid indices here are $0$ – $2$ , so all $9$ window positions are inside the image. Nothing is zero-padded; each entry is the image value there.
Output: a $3 \times 3$ list of lists, [[1,2,3],[4,5,6],[7,8,9]], with $5$ in the middle. Here it equals the whole image.
Notice the edge: centred at $(0, 0)$ the window spans indices $-1$ to $1$ . The $5$ positions with a $-1$ index lie outside and become $0$ , giving [[0, 0, 0], [0, 1, 2], [0, 4, 5]]. The window stays $n \times n$ wherever it sits.

Constraints

Image is a 2D array
Position (row, col) may be near edges
Neighborhood size n is odd (1, 3, 5, etc.)
Use zero-padding for out-of-bounds pixels

Learn this in

Introduction to Computer VisionCV Study Plan

More from CV: Introduction to Computer Vision

Sparse Matrix Operations for Imagesmedium Multi-Scale Feature Pyramidhard Implement Prewitt Edge Detectorhard Connected Components Labelinghard K-Means Color Quantizationmedium

Concept primer

Pixel Neighborhood Extraction: Background & Strategy

Background Knowledge

Pixel neighborhoods are fundamental to computer vision and image processing operations. A neighborhood refers to a set of pixels surrounding a given pixel position, typically arranged in a square or rectangular pattern (e.g., 3×3, 5×5). These local neighborhoods are essential because many image processing algorithms—such as convolution filters, edge detection, and feature extraction—operate by examining how a pixel relates to its surrounding context rather than treating each pixel in isolation.

The concept of neighborhood connectivity is crucial: in image processing, we typically use 8-neighborhood connectivity, meaning a pixel has up to 8 neighbors (the surrounding pixels in all directions: up, down, left, right, and diagonals). When extracting a neighborhood around a position, you're essentially creating a window or kernel that slides across the image. This windowing operation is the foundation for convolution operations used in convolutional neural networks and traditional filtering techniques.

Boundary handling is a practical challenge when extracting neighborhoods near image edges. When a neighborhood extends beyond the image boundaries, we need a strategy to handle missing pixels. Zero-padding is the most common approach: pixels outside the image are treated as having a value of 0. This ensures that every pixel in the image can have a complete neighborhood extracted, even those near edges or corners, without throwing errors or producing incomplete results.

Algorithm/Approach

The general approach involves:

Define the neighborhood size (e.g., n×n where n is typically odd: 3, 5, 7, etc.)
Calculate the offset from the center position to the neighborhood boundaries
Extract pixel values from the image, using zero-padding for out-of-bounds coordinates
Return the neighborhood as a 2D array or matrix

This is a direct indexing and array slicing problem with boundary condition handling.

Step-by-Step Strategy

Step 1: Understand the Input Parameters

Image (2D array of pixel values)
Center position (row, column)
Neighborhood size n (typically odd, so the center is well-defined)

Step 2: Calculate Boundary Coordinates

Determine the offset: offset = n // 2
Calculate the starting row: start_row = center_row - offset
Calculate the starting column: start_col = center_col - offset
The neighborhood spans from [start_row, start_col] to [start_row + n - 1, start_col + n - 1]

Step 3: Initialize the Neighborhood Array

Create an n×n array filled with zeros (this handles padding automatically)

Step 4: Extract Valid Pixels

Iterate through each position in the n×n neighborhood
For each position, check if the corresponding image coordinate is within bounds
If within bounds, copy the pixel value; otherwise, leave it as 0 (already initialized)

Step 5: Return the Neighborhood

Return the extracted n×n neighborhood array

Common Pitfalls

Off-by-one errors: Carefully verify your loop bounds and offset calculations, especially when determining which pixels fall within the image
Confusing row/column ordering: Ensure consistency between (row, col) indexing and (x, y) coordinate systems
Incorrect offset calculation: For an n×n neighborhood, the offset should be n // 2, not (n - 1) // 2 or n / 2
Forgetting zero-padding: Don't skip pixels at boundaries; initialize your output array with zeros to handle padding automatically
Negative indices: In some languages, negative indices wrap around; explicitly check bounds rather than relying on wraparound behavior
Assuming square images: Images may have different heights and widths; always check both dimensions when validating bounds

Time & Space Complexity

Time Complexity: $O(n^2)$ where n is the neighborhood size (e.g., 3×3 = 9 operations, 5×5 = 25 operations). This is constant relative to image size since you're only extracting a fixed-size neighborhood.
Space Complexity: $O(n^2)$ for storing the output neighborhood array. The space required is independent of the image size and depends only on the neighborhood dimensions.

solution.py

Python 3.13

Test results