Contrast Adjustment

easyFREEPoint OperatorsImage ProcessingCV: Image Processing

Implement a point operator to adjust the contrast of an image by modifying its pixel values. This task involves applying a simple transformation to each pixel in the image.

The concept of contrast adjustment is fundamental in image processing, as it enables the enhancement or reduction of the difference between various regions in an image, making it more visually appealing or suitable for further analysis. The contrast of an image can be adjusted by applying a multiplication factor, denoted as $\alpha$ , to each pixel value, $I_{in}(x,y)$ .

Here are the steps to achieve contrast adjustment:

Multiply each pixel value by the factor $\alpha$ .
Apply a clamping operation to ensure the resulting pixel values fall within the valid range.

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

This technique is widely used in digital photography and image editing software.

Example

Input

adjust_contrast([[100, 200]], 1.5)

Output

[[150, 255]]

Reasoning

Inputs: image is a grayscale image given as rows of 8-bit intensities, here one row of two pixels, $100$ and $200$ (0 is black, 255 is white). alpha $= 1.5$ is the contrast gain; values above 1 stretch intensities apart, values below 1 squeeze them together.
Scale: every pixel is treated independently: $1.5 \times 100 = 150$ and $1.5 \times 200 = 300$ . The gap between the two pixels grows from $100$ to $150$ , which is exactly what "more contrast" means.
Round and clamp: both products are already whole numbers. $150$ lies inside $[0, 255]$ and stays; $300$ is brighter than any 8-bit value can be, so it saturates at $255$ .
Output: [[150, 255]], a list of lists with the same $1 \times 2$ shape as the input, holding integers.
Notice that clipping loses information: any input above $255 / 1.5 = 170$ would also come out as $255$ , so bright pixels become indistinguishable. With alpha $= 0.5$ nothing clips and the result is [[50, 100]].

Constraints

alpha > 0
Clamp output to [0, 255]
Round to nearest integer

Learn this in

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

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

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

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

Store in output image:

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

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

solution.py

Python 3.13

Test results