The color of every photo on the internet blended together is orange (opens in new tab)

This wouldn't explain why the same effect was seen from photos of graffiti (which presumably were outside, in the day.)

"When someone told him that it was probably due to the colors of flesh in photographs, he tried it with a pool of graffiti. Still orange. "

It is perhaps worth pointing out that I observed the same effect in collections of purely synthetic art (such as Fractals).

https://www.flickr.com/photos/krazydad/3794489938/in/set-721...

While I don't think this rules out light as a possible culprit, it perhaps implies that humans are mimicking the natural world when they are making color choices.

This is pretty much what I was coming here to say.

Don't forget that we live under a yellow sun, too. There is a hell of a lot of warm light in our world, natural and artificial.

So the color could change in the next years with the emergence of fluorescent lamps, LEDs and cold cathode lighting.

That's what I thought of too. It could be tested by averaging a pool of images lit by fluorescent bulbs, LEDs, or LCD monitor glow.

Also the colour of a human, the most photographed animal on the planet.

The averaging is happening in RGB space, not an HSV-esque space. There's no obvious reason to expect the hue to end up averaged.

For example, the RGB average of red and blue is not orange; it's pink or purple.

I'd say that a large part of their sample source was instagram, where every hipster known to humanity gathers to share their sepia saturated abominations.

Hi, this Jim, the subject of the article. The Atlantic article omits that I'm normalizing the result (otherwise, the histogram is clustered in the middle and you get a dirt-brown color -- the hue is orange, but it's very desaturated). Here is pseudo-code in Processing showing what I'm doing:

To avoid floating point rounding issues, I process the pixels in integer space. For each channel (R,G,B) I create an 1D array of integers (one integer for each pixel) and initialize them to zero.

smaxPixels = width*height; srmap = new int[smaxPixels]; sgmap = new int[smaxPixels]; sbmap = new int[smaxPixels]; for (int i = 0; i < smaxPixels; ++i) { srmap[i] = 0; sgmap[i] = 0; sbmap[i] = 0; }

For each pixel in each image, I add the pixel value to the sum for the corresponding pixel (in the below code, 'offset' is typically zero).

  for (int i = 0; i < smaxPixels; ++i) {
    int px = sImage.pixels[i];
    srmap[i] += red(px);
    sgmap[i] += green(px);
    sbmap[i] += blue(px);
  }

I then produce a normalized image by finding the minimum and maximum components, and mapping all the pixel sums to that range.

for (int i = 0; i < smaxPixels; ++i) { minValue = min(minValue, srmap[i]); maxValue = max(maxValue, srmap[i]); minValue = min(minValue, sgmap[i]); maxValue = max(maxValue, sgmap[i]); minValue = min(minValue, sbmap[i]); maxValue = max(maxValue, sbmap[i]); }

  pg.beginDraw();  // pg is an offscreen Image buffer I am going to draw into...
  pg.loadPixels();
  for (int i = 0; i < smaxPixels; ++i) 
  {
    if (maxImagesPerTile == 1) 
      pg.pixels[i] = color(srmap[i],sgmap[i],sbmap[i]);
    else
      pg.pixels[i] = color( map(srmap[i],minValue,maxValue,0,255),
                       map(sgmap[i],minValue,maxValue,0,255),
                      map(sbmap[i],minValue,maxValue,0,255));
  }
  pg.updatePixels();
  pg.endDraw();

 

That's the essence of it. The bright "orange" is a normalization effect. Note that if I were to simply "average" the images without the normalization step, the resulting color is generally a dirt-brown. Normalizing the image has the effect of increasing the saturation and the contrast, without affecting the hue in an HSL sense. I discuss this in my paper, although the Atlantic article omitted this important point.

Maybe you should include lots of faces? And check that you're doing sRGB gamma math correctly. http://http.developer.nvidia.com/GPUGems3/gpugems3_ch24.html

Edit: I'm guessing convert("RGB") means convert from whatever to linear RGB? So that part should be fine.

Your grayish results are exactly what I would expect from averaging RGB values.

There's definitely some interesting things going on with human reasoning in the way different people interpret the result. I originally assumed the images would average to gray, but when I think about it logically, that would be kind of miraculous. We wouldn't expect a bunch of photos taken on Mars to average to gray (to be perfectly balanced in R, G and B), so why did I expect photos taken on Earth to? It would mean all the colors are in a very precise balance, which would be kind of odd.

With random images which include a few outdoor photos, there is a noticeable effect from the sky, but not as dramatic as I might expect - it tends to produce a whitening, rather than a visible blue.

Hmm, are you really sure that, had you been asked without reading the article, you'd think the average colour to be reddish/yellowish gray due to lighting and ... etc? Really really?

If I'd been asked, I'd perhaps have tried to be clever and said that the top half of the image would be blue as the sky is blue and indoor walls are usually white which won't hurt the blue so much, and that the bottom half would be a browny green due to grass and carpet etc.

Ah, that's problematic.

The RGB color model is closely modeled after the physical phenomenon of light. In a linear RGB color space, you can average two colors to get the same result as if you had physically averaged those colors in the real world by combining light.

However, Lab is modeled after the subjective human perception of light and color. Lab is divorced from physical interpretations. Averaging colors in Lab does not have any real physical interpretation.

My guess is that the average smart phone app colour is blue.

If you're weighting by page views, you could get a pretty good approximation by just taking screenshots of the top 10000 or so websites.

Also, the common rgb->greyscale algorithm has a very low factor for the blue component (0.21 for r, 0.72 for g, 0.07 for b was one of the first on google)