Gamma Correction

1. Background Knowledge

Gamma correction is a point operation on images: each pixel is transformed independently according to a nonlinear function, without considering its neighbors. For an 8-bit grayscale (or per-channel color) image, pixel intensities lie in $[0, 255]$. The given formula

$$I_{out} = 255 \cdot \left(\frac{I_{in}}{255}\right)^\gamma$$

maps each input intensity $I_{in}$ to a new intensity $I_{out}$ using an exponent $\gamma$.

Because the function is nonlinear, it redistributes brightness: $\gamma < 1$ stretches dark values and brightens shadows, while $\gamma > 1$ compresses bright values and darkens the image. Conceptually, this is related to how human vision and displays respond nonlinearly to light: applying gamma correction lets us adjust perceived contrast and brightness more naturally than with a simple linear scaling.

---

2. Algorithm / Approach

General pattern for this type of point-operator problem:

• Normalize pixel values to a standard range (usually $[0, 1]$).
• Apply a mathematical function independently to each pixel (here, power with exponent $\gamma$).
• Rescale back to the original value range (e.g., $[0, 255]$) and data type (e.g., 8-bit).

For color images, the same formula is usually applied per channel (R, G, B) unless the problem specifies working in a different color space (e.g., only on luminance).

---

3. Step-by-Step Strategy

4. Read the image

• Get pixel values as a numeric array.
• Ensure you know the data type (e.g., uint8) and shape (grayscale vs color).

2. Convert to float

• Cast to a floating-point type to avoid integer overflow/truncation during computation.

3. Normalize

• Compute $X = I_{in} / 255.0$.
• Now $X \in [0, 1]$.

4. Apply gamma

• Compute $Y = X^\gamma$ (element-wise power).

5. Rescale

• Compute $I_{out\_float} = 255 \cdot Y$.

6. Clamp and cast

• Clamp values to $[0, 255]$ to avoid rounding artifacts.
• Cast back to the original integer type (e.g., uint8).

7. Return or display

• Ensure the output has the same shape and type as the input.

Example (Python-like pseudocode):

def gamma_correction(img, gamma):
 img_float = img.astype(np.float32)
 normalized = img_float / 255.0
 corrected = np.power(normalized, gamma)
 out = corrected * 255.0
 out = np.clip(out, 0, 255)
 return out.astype(np.uint8)

---

4. Common Pitfalls

• Integer math: Applying powers on integer arrays without converting to float will give wrong results (due to truncation and overflow).
• Wrong normalization: Forgetting to divide by 255 (or dividing twice) changes the meaning of $\gamma$.
• Type and range issues: Not clamping to $[0, 255]$ before casting back to uint8 can cause wrap-around in some environments.
• Color images: Treating a color image as grayscale accidentally (e.g., by averaging channels) if the problem expects per-channel gamma.
• Gamma sign / value: Using negative or zero gamma will break the formula; typically $\gamma > 0$ is assumed.

---

5. Time & Space Complexity

Let $N$ be the number of pixels (for color, think of $N$ as “number of scalar values,” i.e., width × height × channels):

• Time complexity: $O(N)$ You perform a constant number of arithmetic operations per pixel.

• Space complexity:

• If you create a separate output image: $O(N)$ extra space.

• If you do it in-place (carefully, with correct types): auxiliary space can be $O(1)$ beyond the image itself.