Gamma Correction

mediumFREEPoint OperatorsImage ProcessingCV: Image Processing

Implement a point operator to apply gamma correction to an image. This process transforms the image's intensity values to adjust its brightness and contrast.

Gamma correction is a non-linear operation that modifies the image's pixel values based on a power-law relationship, which can brighten or darken regions. The gamma value determines the amount of correction, where values less than 1 increase the brightness of dark areas and values greater than 1 decrease the brightness.

Here are the steps to perform gamma correction:

Normalize the input image intensity values to the range [0,1].
Raise each normalized value to the power of gamma.
Scale the result back to the original range [0,255].

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

This technique is widely used in image and video processing applications to adjust the display's brightness and contrast.

Example

Input

gamma_correct([[64, 128]], 0.5)

Output

[[128, 181]]

Reasoning

Input: image is a $1 \times 2$ grid of 8-bit intensities, $64$ (dark grey) and $128$ (mid grey), and gamma is $\gamma = 0.5$ .
Normalize: dividing by $255$ maps each pixel into $[0,1]$ : $\frac{64}{255} \approx 0.2510$ and $\frac{128}{255} \approx 0.5020$ .
Apply the power: with $\gamma = 0.5$ the power is a square root: $0.2510^{0.5} \approx 0.5010$ and $0.5020^{0.5} \approx 0.7085$ . Because both values lie below $1$ , an exponent below $1$ pushes them up.
Scale back: $255 \cdot 0.5010 \approx 127.75$ and $255 \cdot 0.7085 \approx 180.67$ , which round to the nearest integers $128$ and $181$ , giving [[128, 181]].
Notice: the dark pixel roughly doubled ( $64 \to 128$ ) while the mid-grey one gained only about $41\%$ , so $\gamma < 1$ lifts shadows most. The endpoints never move, since $0^\gamma = 0$ and $1^\gamma = 1$ , so $0$ and $255$ stay fixed for any $\gamma$ . With $\gamma = 1$ the image is unchanged.

Constraints

gamma > 0
Output rounded to nearest integer

Learn this in

Image FormationCV Study Plan Image ProcessingCV Study Plan

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

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.

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).

Step-by-Step Strategy
Read the image

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

Convert to float

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

Normalize

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

Apply gamma

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

Rescale

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

Clamp and cast

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

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)

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.

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.

solution.py

Python 3.13

Test results