Box Blur

easyFREELinear FilteringImage ProcessingCV: Image Processing

Implement a box blur, also known as a mean filter, to an image by averaging neighboring pixels. This technique is a fundamental concept in Linear Filtering for image processing.

The box blur operates by convolving an image with a kernel, a small matrix that slides over the entire image, computing a weighted average of neighboring pixels at each position. For a given kernel size, the kernel is typically a square matrix with all elements being equal, resulting in a uniform average of the neighboring pixels.

Here are the steps to apply the box blur:

Define the kernel size and compute the kernel elements as $1 / (kernel\_size^2)$ .
Slide the kernel over the image, computing the average of neighboring pixels at each position.
Assign the computed average to the corresponding pixel in the output image.

K = \frac{1}{kernel\_size^2}\begin{pmatrix} 1 & 1 &... & 1 \\ 1 & 1 &... & 1 \\... &... &... &... \\ 1 & 1 &... & 1 \end{pmatrix}

This technique is widely used in image processing applications to reduce noise.

Example

Input

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

Output

[[1, 2, 2], [3, 5, 4], [3, 4, 3]]

Reasoning

Inputs: image is a $3 \times 3$ grayscale grid with values 1 to 9, and kernel_size $k = 3$ , so every kernel weight is $\frac{1}{k^2} = \frac{1}{9}$ .
The math: each output pixel is $\frac{1}{9}$ times the sum of the $3 \times 3$ neighbourhood centred on it. Neighbours that fall outside the image are zeros, but the divisor stays 9.
Centre pixel (value 5): all nine pixels are inside, $\frac{1+2+\dots+9}{9} = \frac{45}{9} = 5$ .
Top-left corner (value 1): only $1, 2, 4, 5$ are inside, so $\frac{12}{9} \approx 1.33 \to 1$ . Top-middle (value 2): the top two rows count, $\frac{21}{9} \approx 2.33 \to 2$ . Right-middle (value 6): $\frac{2+3+5+6+8+9}{9} = \frac{33}{9} \approx 3.67 \to 4$ .
Output: the remaining sums are $16, 27, 24, 39, 28$ , giving $1.78, 3, 2.67, 4.33, 3.11$ , which round to [[1, 2, 2], [3, 5, 4], [3, 4, 3]], the same $3 \times 3$ size as the input.
Notice the border pixels come out darker than the original: the zero padding contributes nothing to the sum but still counts in the divisor.

Constraints

kernel_size is odd (3, 5, 7, etc.)
Round output to nearest integer
Use zero-padding

More from CV: Image Processing

Frequency Domain Filteringhard Separable Filter Optimizationhard Contrast Limited Adaptive Histogram Equalizationmedium Frequency Component Energyeasy Low-Pass Filter (Frequency)medium

Concept primer

A box blur is a simple linear filter that replaces each pixel with the average of its neighbors in a fixed window (here, a 3×3 window). Conceptually, this is a special case of convolution in image processing, where you slide a kernel (the 3×3 matrix of weights) over the image and compute a weighted sum at each position. For the given kernel $K = \frac{1}{9}\begin{pmatrix}1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1\end{pmatrix},$ each pixel in the output is the mean of itself and its 8 neighbors.

This operation acts as a low-pass filter: it smooths local variations and reduces noise by averaging nearby values, but also blurs edges and fine details. Because all kernel entries are equal and sum to 1, the overall brightness of the image is roughly preserved (no systematic darkening or brightening), and the filter is both shift-invariant and linear (superposition holds).

2. Algorithm / General Approach

For a k×k box blur (k odd, pad = k // 2):

For every pixel (y, x) in the image, including the border:
Look at the k×k window centred on it.
Add up the pixels that fall inside the image; pixels outside count as 0 (zero padding).
Divide by k×k (always the full window size, not the number of pixels inside).
Round to the nearest integer and store it at (y, x).

Because the image is padded, the output has the same size as the input. Border pixels come out darker than the interior, since part of their window is zeros.

3. Step-by-Step Strategy

Set up

h, w = number of rows and columns; pad = kernel_size // 2.
Create out[h][w] filled with 0.

Loop over every pixel

For y in 0..h-1 and x in 0..w-1.

Accumulate the window

total = 0
For dy in -pad..pad and dx in -pad..pad:
ny, nx = y + dy, x + dx
If 0 ≤ ny < h and 0 ≤ nx < w: total += img[ny][nx] (otherwise it's padding and adds 0).

Average and assign

out[y][x] = round(total / (kernel_size * kernel_size))

Return out

Example: for [[1,2,3],[4,5,6],[7,8,9]] with k = 3, the centre is 45/9 = 5, the corner (0,0) is (1+2+4+5)/9 ≈ 1.33 → 1, and the full result is [[1,2,2],[3,5,4],[3,4,3]].

4. Common Pitfalls

Dividing by the number of in-bounds pixels. Zero padding means the divisor is always k×k. Dividing by 4 at a corner gives a different filter and fails the tests.
Shrinking the output. "Valid" convolution (only where the full window fits) returns a smaller image; this problem expects the same size as the input.
Out-of-bounds indexing. Check 0 ≤ ny < h and 0 ≤ nx < w before reading. Python's negative indices don't raise an error; they silently wrap around to the other side.
Rounding too early. Round each final average, not the running sum.
Mutating the input in place. Write into a separate output array, or later windows will read already-blurred values.

5. Time & Space Complexity

Time: $O(H \times W \times k^2)$ , k² work per pixel; for a fixed 3×3 kernel that's $O(H \times W)$ .
Space: $O(H \times W)$ for the output image.

solution.py

Python 3.13

Test results