Python gets pixels and colors

Python Getting Pixels and Colors How do you get a structure containing all the pixels and colors? The method is not complicated, but as you will see later, it is not the optimal solution.

One way to map pixels to colors is to use the product() function to enumerate all pixels and colors.

xy = lambda xyp_c: xyp_c[0][0]
p = lambda xyp_c: xyp_c[0][1]
c = lambda xyp_c: xyp_c[1]

distances = (
(xy(item), p(item), c(item), euclidean(p(item), c(item)))
for item in product(pixel_iter(img), colors)
)

The core part is to use product(pixel_iter(img), colors) to generate all combinations of pixels and colors, then reconstruct the resulting data to flatten it, and use the euclidean() function to calculate the distance between the pixel color and the color of the Color object. The result is a sequence of four tuples, each consisting of the x-y coordinates, the source pixel, the given color, and the distance from the pixel to the given color.

Finally, the groupby() function and the min(choices, ...) expression are used to obtain the color result, as shown below:

for _, choices in groupby(
distances, key=lambda xy_p_c_d: xy_p_c_d[0]):
yield min(choices, key=lambda xypcd: xypcd[3])

Multiplying the pixels and colors yields a long one-dimensional iterable object, which is then grouped by its coordinate values to decompose it into a set of relatively short iterable objects, each corresponding to a pixel, and then the color with the shortest distance is selected.

For a 3648×2736 image containing 133 Crayola colors, the above algorithm requires 1,327,463,424 iterations. Yes, the distances expression generates billions of combinations. This isn’t unmanageable, and Python can still handle it, but it’s enough to highlight the issues with using the naive produce() function.

When processing large amounts of data, it’s important to estimate the scale. After running one million distance calculations, the runtime measured with the timeit() function is as follows:

• Euclidean distance: 2.8
• Manhattan distance: 1.8

Scaling up 1,000-fold, from one million to one billion runs, the Manhattan distance calculation takes 1,800 seconds, or half an hour, while the Euclidean distance calculation takes 46 minutes. For large datasets, this computational approach is far too inefficient.

More importantly, this approach is wrong. This straightforward “width x height x color” approach is poor algorithmic design, and in many cases, there are better solutions.