Contrast Adjustment

You are adjusting each pixel’s intensity by a scalar factor α, then clipping to the valid range $[0, 255]$. This is a simple point-wise linear contrast adjustment: each pixel is processed independently using the same formula.

---

1. Background Knowledge

In digital images, a grayscale pixel value $I(x,y)$ usually lies in the range $[0, 255]$ (for 8-bit images). Low values are dark, high values are bright. Contrast describes how different bright and dark regions are: high contrast means strong differences; low contrast looks “washed out” or “flat”.

A point operator (or pointwise operation) transforms each pixel based only on its own value, not its neighbors. Mathematically, you apply a function $f$ to each pixel:

$$I_{out}(x,y) = f(I_{in}(x,y)).$$

Here, the function is linear scaling with clamping:

$$I_{out}(x,y) = \text{clamp}(\alpha \cdot I_{in}(x,y), 0, 255).$$

If $\alpha > 1$, differences between pixel values are stretched, increasing contrast. If $0 <$\alpha$< 1$, differences shrink, decreasing contrast.

---

2. Algorithm / General Approach

This problem is a straightforward per-pixel transform:

• Iterate over all pixels.
• For each pixel, multiply by α.
• Clamp the result to the valid intensity range $[0, 255]$.
• Store the result in the output image.

You can think of it as applying the same simple formula to each pixel independently.

---

3. Step-by-Step Strategy

1. Read input:

• Load or receive the image as a 2D array (grayscale) or 3D array (color).
• Read the contrast factor $\alpha$ (e.g., a float).

2. For each pixel $(x, y)$:

• Get the input intensity:

$$v = I_{in}(x,y)$$

• Compute the scaled value:

$$s = \alpha \cdot v$$

• Clamp to $[0, 255]$:
• If $s < 0$, set $s = 0$.
• If $s > 255$, set $s = 255$.
• Optionally round to integer (e.g., int(s + 0.5) or cast).

3. Store in output image:

• Set $I_{out}(x,y) = s$.

4. Return / print / display the output image.

If the image is color (RGB), apply the same operation to each channel separately.

Example in pseudocode:

for y in range(height):
 for x in range(width):
 v = input_img[y][x]
 s = alpha * v
 if s < 0:
 s = 0
 elif s > 255:
 s = 255
 output_img[y][x] = int(s)

---

4. Common Pitfalls

• Integer overflow before clamp: If you multiply using an 8-bit type, it can overflow before you clamp. Use a wider type (e.g., int or float) for the multiplication, then clamp.

• Forgetting to clamp: Values above 255 or below 0 must be clipped; otherwise they may wrap or cause errors.

• Not handling color images correctly: If the image has multiple channels, ensure you adjust each channel consistently.

• Precision issues: When using floating-point α, ensure you convert back to an integer type correctly (round or floor consistently).

---

5. Time & Space Complexity

• Time complexity: You visit each pixel once and perform O(1) work per pixel. For an image with $N$ pixels:

$$T = O(N).$$

• Space complexity:
• If you create a separate output image: $O(N)$ extra space.
• If you modify the image in-place: $O(1)$ extra space (besides the input image itself).