RGB to Grayscale Conversion

easyFREEColor SpacesComputer Vision 2

Implement a function to convert a list of RGB pixels to their corresponding grayscale values. This process involves transforming color spaces, where each pixel's luminance is calculated based on its red, green, and blue components.

The human visual system is more sensitive to certain colors, which is reflected in the weighted sum used for conversion. The sensitivity to green is highest, followed by red, and then blue, which is represented by the coefficients in the conversion formula.

To perform the conversion, follow these steps:

Extract the R, G, and B values from each pixel.
Apply the weighted sum to calculate the luminance.
Round the result to obtain the grayscale value.

Y = \text{round}(0.299 \cdot R + 0.587 \cdot G + 0.114 \cdot B)

This technique is widely used in image processing applications.

Example

Input

pixels = [[255, 0, 0], [0, 255, 0], [0, 0, 255]]

Output

[76, 150, 29]

Reasoning

Input: pixels is a list of pixels, each a triple $[R, G, B]$ of channel intensities from $0$ (off) to $255$ (full). The sample holds pure red, pure green and pure blue, each at full strength.
Math: each pixel collapses to one luminance number $Y = 0.299R + 0.587G + 0.114B$ $Y = 0.299 R + 0.587 G + 0.114 B$ , rounded to the nearest integer. With only one channel lit, $Y$ $Y$ is just that channel's weight times $255$ $255$ :
- red: $0.299 \times 255 = 76.245 \to 76$
- green: $0.587 \times 255 = 149.685 \to 150$
- blue: $0.114 \times 255 = 29.07 \to 29$
Output: one integer per pixel, in the same order as the input, giving [76, 150, 29].
Notice that three equally bright colours get very different grays: green looks brightest to the eye, blue darkest. Because the weights add up to $1$ , white $[255, 255, 255]$ maps to $255$ and black to $0$ , so the result stays in $[0, 255]$ .

Constraints

Each pixel is [R, G, B] with values in [0, 255]
Return list of integers (use round())
Pure Python, no libraries needed

Learn this in

Image FormationCV Study Plan Image ProcessingCV Study Plan

More from Computer Vision 2

1D Bilateral Filterhard Image Sharpening with Unsharp Maskmedium Gaussian Blurmedium Gaussian Kernel Generationeasy 2D Image Convolutioneasy

Concept primer

Background Knowledge

The problem involves converting RGB (Red, Green, Blue) pixels to grayscale, which is a fundamental concept in computer vision and image processing. In RGB color space, each pixel is represented by three components: red, green, and blue, with values ranging from 0 (minimum intensity) to 255 (maximum intensity). Grayscale, on the other hand, represents each pixel using a single value, typically ranging from 0 (black) to 255 (white). The conversion from RGB to grayscale is based on the luminance formula, which takes into account the sensitivity of the human eye to different colors.

The luminance formula used in this problem, $Y =$ \text{round} $(0.299 \cdot R + 0.587 \cdot G + 0.114 \cdot B)$ , is a weighted sum that reflects the fact that the human eye is most sensitive to green light, followed by red and then blue. This formula is widely used in image and video processing applications. Understanding the concept of color spaces and the relationship between RGB and grayscale is essential to solving this problem.

In computer vision, color spaces are crucial for various applications, including image processing, object recognition, and image segmentation. The conversion between different color spaces, such as RGB to grayscale, allows for more efficient and effective processing of visual data. The luminance formula provides a simple yet effective way to reduce the dimensionality of RGB data while preserving the essential information.

Algorithm/Approach

The general approach to solving this problem involves applying the luminance formula to each RGB pixel in the input list. This can be achieved using a simple iterative algorithm that loops through each pixel, calculates the grayscale value using the formula, and stores the result in a new list. The algorithm pattern is straightforward and involves basic arithmetic operations.

Step-by-Step Strategy

To implement the solution, follow these steps:

Iterate through each RGB pixel in the input list.
For each pixel, extract the R, G, and B values.
Apply the luminance formula to calculate the grayscale value: $Y =$ \text{round} $(0.299 \cdot R + 0.587 \cdot G + 0.114 \cdot B)$ .
Store the calculated grayscale value in a new list.
Return the list of grayscale values.

Common Pitfalls

When implementing the solution, watch out for the following:

Ensure that the input list is properly formatted and contains valid RGB pixel values.
Use the correct weights in the luminance formula (0.299 for R, 0.587 for G, and 0.114 for B).
Apply the round function to the calculated grayscale value to ensure an integer result.
Verify that the output list contains the correct number of grayscale values, matching the number of input RGB pixels.

Time & Space Complexity

The expected time complexity for this problem is O(n), where n is the number of RGB pixels in the input list, since we need to iterate through each pixel once. The space complexity is also O(n), as we need to store the resulting grayscale values in a new list. The algorithm is relatively simple and efficient, making it suitable for large inputs.

solution.py

Python 3.13

Test results