Brightness Adjustment

easyFREEPoint OperatorsImage ProcessingCV: Image Processing

Implement a point operator to adjust the brightness of an image by modifying the intensity of each pixel. This task involves understanding how to apply a simple transformation to every pixel in an image.

The concept of brightness adjustment is fundamental in image processing, as it allows for the enhancement or correction of images based on their lighting conditions. The process involves adding a constant value to each pixel's intensity, which can be represented mathematically.

Start with the input image $I_{in}(x,y)$ , where $(x,y)$ represents the coordinates of a pixel.
Add a constant $\beta$ to the intensity of each pixel. The resulting output image $I_{out}(x,y)$ is calculated by applying this transformation and ensuring the values stay within the valid range.

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

This technique is widely used in photography editing software.

Example

Input

adjust_brightness([[100, 200]], 50)

Output

[[150, 250]]

Reasoning

image is a grid of grayscale intensities, here one row holding two pixels, $100$ and $200$ . Each value lies in $[0, 255]$ , where $0$ is black and $255$ is white. beta $= 50$ is the offset applied to every pixel.
Apply $I_{out}(x,y) = \text{clamp}(I_{in}(x,y) + \beta, 0, 255)$ : $100 + 50 = 150$ and $200 + 50 = 250$ .
Both sums already lie inside $[0, 255]$ , so clamping leaves them unchanged. The result is [[150, 250]], the same $1 \times 2$ shape as the input, still whole-number intensities.
Clamping only matters near the ends of the range. With $\beta = 10$ , a pixel of $250$ would give $260$ , which saturates to $255$ . With $\beta = -20$ , a pixel of $10$ would give $-10$ , which is floored to $0$ .
Notice that every unclamped pixel shifts by the same amount, so the gap between them is preserved: $250 - 150 = 200 - 100 = 100$ . Brightness changes, contrast does not.

Constraints

beta can be positive (brighten) or negative (darken)
Clamp output to [0, 255]

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

Brightness Adjustment: Background & Implementation Guide

Background Knowledge

Point Operators and Pixel-Level Transformations

Brightness adjustment is a fundamental point operator in image processing, meaning each output pixel depends only on the corresponding input pixel at the same spatial location—no neighboring pixels are involved. This is one of the simplest yet most practical image enhancement techniques. The operation is straightforward: add a constant value β (beta) to every pixel intensity, then constrain the result to the valid range [0, 255] for standard 8-bit images.

Why Brightness Adjustment Matters

Images captured in suboptimal lighting conditions often appear too dark or too bright. Brightness adjustment is commonly used as a preprocessing step before more complex image analysis tasks, or as a standalone enhancement technique. The key insight is that this operation preserves image structure and relationships between pixels—it only shifts the overall intensity distribution. This makes it computationally efficient and predictable, unlike more complex enhancement methods that might introduce artifacts or distort image content.

The Clamping Operation

The clamping function is critical: without it, pixel values could exceed 255 (overflow) or drop below 0 (underflow), causing wraparound artifacts or loss of information. Clamping ensures that all output values remain within the valid 8-bit range by forcing any value below 0 to become 0, and any value above 255 to become 255.

Algorithm/Approach

The general approach for point operators follows this pattern:

Iterate through all pixels in the input image (typically row by row, column by column)
Apply the transformation to each pixel independently
Clamp the result to the valid range
Store the output in the corresponding location of the output image

For brightness adjustment specifically, this becomes:

For each pixel at position (x, y): compute new_value = input_pixel + β
Apply clamping: output_pixel = max(0, min(255, new_value))

Step-by-Step Strategy

Read or receive the input image as a 2D array (or 3D for color images with RGB channels)
Create an output image of the same dimensions to store results
Iterate through each pixel:

Access the pixel value at position (x, y)
Add the brightness constant β to it
Clamp the result to [0, 255]
Store in the output image

Handle color images: If working with RGB images, apply the same operation to each channel independently (R, G, and B channels all get the same β added)
Return or save the output image

Common Pitfalls

Integer overflow: If you add two 8-bit values without checking, the result might overflow. Always clamp after addition.
Forgetting to clamp: Omitting the clamping step leads to wraparound artifacts where bright pixels become dark and vice versa.
Off-by-one errors: When iterating through image dimensions, ensure your loop bounds are correct (typically 0 to height-1 and 0 to width-1).
Data type mismatches: Be careful when mixing integer and floating-point operations; ensure intermediate calculations don't lose precision.
Not handling all channels: For color images, remember to apply the operation to all three (or four, if alpha channel exists) channels.
Boundary assumptions: Verify whether your image library uses row-major or column-major ordering, and whether coordinates are (x, y) or (row, column).

Time & Space Complexity

Time Complexity: $O(h \times w \times c)$

h = image height, w = image width, c = number of channels (1 for grayscale, 3 for RGB)
You must visit every pixel exactly once, and each operation (addition + clamping) is constant time

Space Complexity: $O(h \times w \times c)$

You need to store the output image, which is the same size as the input
If you're modifying in-place, space complexity could be $O(1)$ extra space (beyond the input/output image itself)

solution.py

Python 3.13

Test results