Image as Matrix

In computer vision, a grayscale image is just a 2D matrix where each entry is a pixel intensity (brightness), usually an integer like 0–255. Thinking of the image as a matrix lets you treat image processing as numerical computation: you can sum pixels, scale them, or apply functions just like you would on any 2D array. Many later CV tasks (filtering, edge detection, feature extraction) assume you are comfortable viewing images as numeric data rather than pictures.

Basic statistics on pixel values—mean, min, max, standard deviation—are core tools for image preprocessing and normalization. For example, mean and standard deviation are often used to normalize images so that they have zero mean and unit variance, which can make learning algorithms more stable. Min and max can be used to rescale intensities to a standard range (like [0, 1]) or detect overexposed/underexposed images. At this level, the task is simply: “Given a 2D array of numbers, compute these scalar statistics.”

---

1. Background Knowledge

• Mean pixel value: If the image has $H$ rows and $W$ columns, and pixel intensities are $I[i][j]$, the mean is $\mu = \frac{1}{H \cdot W} \sum_{i=0}^{H-1} \sum_{j=0}^{W-1} I[i][j]$ This measures the average brightness.

• Min and max pixel values: $\text{min} = \min_{i,j} I[i][j], \quad \text{max} = \max_{i,j} I[i][j]$ These show the darkest and brightest pixels in the image.

• Standard deviation (population form): $\sigma = \sqrt{\frac{1}{H \cdot W} \sum_{i,j} (I[i][j] - \mu)^2}$ This tells you how spread out the pixel values are around the mean (contrast/variation).

All of these can be computed by treating the image as a flat list of $N = H \cdot W$ numbers and applying basic statistics.

---

2. Algorithm / General Approach

The common pattern here is a single pass aggregation over all pixels:

• Traverse every element in the 2D array.
• Maintain running values you need:
• Sum of pixels (for mean).
• Optional: sum of squared pixels (for variance/standard deviation).
• Current min.
• Current max.
• After the traversal, compute:
• Mean from the sum and count.
• Variance (and then standard deviation) from sum, sum of squares, and count.

You can do this either:

• In two passes:
• 1st pass: compute mean.
• 2nd pass: compute variance using the mean.
• Or in one pass:
• Maintain both sum and sum of squares while also tracking min and max.

---

3. Step-by-Step Strategy

Assume the image is a 2D array img with rows and cols.

1. Initialize accumulators:

total = 0.0
total_sq = 0.0
current_min = +infinity # or img
current_max = -infinity # or img
count = rows * cols

2. Loop over all pixels:

• For each pixel = img[i][j]:
• total += pixel
• total_sq += pixel * pixel
• current_min = min(current_min, pixel)
• current_max = max(current_max, pixel)

3. Compute mean:

mean = total / count

4. Compute variance and standard deviation (population version):

variance = (total_sq / count) - (mean * mean)
std_dev = sqrt(variance)

5. Return results:

• Mean value
• Min value
• Max value
• Standard deviation

If you are not using sum of squares, an alternative is:

• Pass 1: compute mean.
• Pass 2: compute sum((pixel - mean)**2) and then std_dev.

---

4. Common Pitfalls

• Integer division: If your language uses integer division by default, total / count might truncate. Cast to float before division.

• Overflow with large sums: If pixel values and image size are large, total or total_sq can overflow an int. Use a wider type (e.g., long, double, or float in many languages).

• Negative variance from rounding: In floating-point, (total_sq / count) - mean * mean can be slightly negative due to precision errors. Clamp very small negative values to zero before taking sqrt.

• Empty image: If rows or cols can be zero, you must define what to do (return zeros, error, etc.). Many platforms guarantee at least one pixel; check constraints.

• Population vs. sample std dev: The formula above uses N in the denominator (population). Some definitions use N - 1 (sample). Use the one the problem specifies; if not specified, population is typical in basic CV preprocessing.

---

5. Time & Space Complexity

• Time Complexity:

• You visit each pixel a constant number of times (once in a one-pass solution, twice in a two-pass solution).

• Let $N = H \cdot W$ be the number of pixels.

• Time: $O(N)$

• Space Complexity:

• You only store a few scalar accumulators in addition to the input image.

• Extra space: $O(1)$ (constant).