RGB to Grayscale

easyFREEWhat is Computer Vision?Color ConversionCV: Introduction to Computer Vision

Implement a function to convert an RGB pixel to grayscale using the luminosity method, which is a widely used technique in Computer Vision. This method involves calculating a weighted average of the RGB values to produce a grayscale value that approximates human perception.

The human eye perceives colors differently, with varying sensitivities to red, green, and blue light, which is why we use weighted averaging to convert RGB to grayscale. The weights used in this method reflect the sensitivity of the human eye to different colors, with green contributing most to perceived luminance.

To perform this conversion, follow these steps:

Extract the RGB values from the input pixel
Apply the weighted sum formula to calculate the grayscale value
Round the result to obtain the final grayscale value

Gray = 0.2126 \times R + 0.7152 \times G + 0.0722 \times B

This technique is widely used in image processing applications.

Example

Input

rgb_to_gray([255, 0, 0])

Output

Reasoning

Input: rgb is one pixel as three intensities $[R, G, B]$ , each from 0 (none of that colour) to 255 (full). Here $R = 255$ , $G = 0$ , $B = 0$ : pure, fully saturated red.
Weighted sum: each channel is scaled by how bright the eye perceives it. Red contributes $0.2126 \times 255 = 54.213$ , green contributes $0.7152 \times 0 = 0$ , and blue contributes $0.0722 \times 0 = 0$ , so $Gray = 54.213$ .
Rounding: grayscale levels are whole numbers, so $54.213$ rounds to the nearest integer, giving the output 54.
Notice: the three weights add up to exactly $1$ , so white $[255, 255, 255]$ maps to $255$ and black maps to $0$ , which keeps the result inside $[0, 255]$ .
Pure green at full intensity would give about $182$ and pure blue only about $18$ . A red that looks vivid on screen ends up as a fairly dark gray, because red light counts for far less perceived brightness than green.

Constraints

RGB values are in range [0, 255]
Return grayscale value rounded to nearest integer
Output should be in range [0, 255]

Learn this in

Introduction to Computer VisionCV Study Plan

More from CV: Introduction to Computer Vision

Sparse Matrix Operations for Imagesmedium Multi-Scale Feature Pyramidhard Implement Prewitt Edge Detectorhard Connected Components Labelinghard K-Means Color Quantizationmedium

Concept primer

RGB to Grayscale Conversion: Background Knowledge & Strategy

Background Knowledge

Color Perception and Luminosity

The human eye doesn't perceive all colors with equal intensity. Our visual system is most sensitive to green light, moderately sensitive to red, and least sensitive to blue. This physiological reality is why the luminosity method uses weighted coefficients rather than simple averaging. The weights (0.2126 for red, 0.7152 for green, 0.0722 for blue) are standardized in the ITU-R BT.709 color space and represent how much each color channel contributes to perceived brightness. This approach is more perceptually accurate than naive methods like averaging all three channels equally, which would overemphasize blue and underemphasize green.

Grayscale Conversion in Computer Vision

Converting RGB to grayscale is a fundamental preprocessing step in many computer vision applications. It reduces data dimensionality (from 3 channels to 1), decreases computational complexity, and can help algorithms focus on structural features rather than color information. The luminosity method is one of several conversion techniques; others include simple averaging, desaturation, and more sophisticated approaches using singular value decomposition or attention mechanisms. However, the luminosity method remains widely used because it balances perceptual accuracy with computational efficiency.

Pixel-Level Operations

This problem involves a pixel-level transformation, where each pixel is processed independently using the same formula. In image processing, pixels are typically represented as integers in the range [0, 255] for 8-bit images. The conversion formula produces a floating-point result that must be handled appropriately—either rounded, truncated, or clamped to ensure the output remains a valid grayscale value.

Algorithm/Approach

The luminosity method is a linear combination of the three color channels:

$\text{Gray} = 0.2126 \times R + 0.7152 \times G + 0.0722 \times B$

The general approach is:

Extract the red, green, and blue components from an RGB pixel
Multiply each component by its corresponding weight
Sum the weighted values
Handle the result appropriately (rounding, type conversion, etc.)

This is a straightforward mathematical operation applied uniformly to each pixel.

Step-by-Step Strategy

Understand the input format: Determine how the RGB pixel is represented (e.g., as separate R, G, B values, or as a single integer encoding all three channels).
Extract color components: Separate the red, green, and blue values from the input. If the pixel is encoded as a single integer (common in some languages), use bitwise operations or division to extract each channel.
Apply the weighted formula: Multiply each component by its weight and sum them:

Multiply R by 0.2126
Multiply G by 0.7152
Multiply B by 0.0722
Add all three products together

Handle the result: The sum will likely be a floating-point number. Decide whether to round, truncate, or use another method to convert it to an integer in the range [0, 255].
Return the grayscale value: Output the final grayscale pixel value in the appropriate format.

Common Pitfalls

Integer overflow: If working with integer arithmetic, multiplying large values (up to 255) by weights can cause overflow in some languages. Consider using floating-point arithmetic or larger integer types.
Rounding vs. truncation: Simply casting a float to an integer truncates (discards the decimal part). For better accuracy, round to the nearest integer using a rounding function.
Output range: Ensure the final grayscale value stays within [0, 255]. If using floating-point intermediate calculations, clamp or round the result appropriately.
Precision loss: The weights are given to four decimal places. Using lower precision (e.g., 0.21, 0.71, 0.07) will introduce small errors that accumulate across many pixels.
Confusing color spaces: Don't mix up the luminosity method with other conversion methods (like simple averaging or desaturation), which use different formulas and produce different results.

Time & Space Complexity

Time Complexity: $O(1)$ per pixel. The conversion involves a fixed number of arithmetic operations (three multiplications and two additions) regardless of pixel values.
Space Complexity: $O(1)$ per pixel. Only a constant amount of extra memory is needed to store intermediate values during the calculation.

If converting an entire image with $n$ pixels, the overall complexity would be $O(n)$ time and $O(n)$ space (for storing the output image), but the per-pixel operation itself is constant.

solution.py

Python 3.13

Test results