How to check if there are any out-of-sRGB-pixels in an image?

Question

Since 2016, new Apple products (like the iPhone 7) use the P3 color space instead of the sRGB color space. Therefore I'm interesting in measuring the practical impact on some pictures I have shot.

Given a JPEG file, how can I check if it contains any pixels that are not within sRGB? And how can I mark them, e.g. turn them pink or yellow? (Or almost equivalently: How can I check if conversion to sRGB has any destructive impact on an image?)

For example, on www.astramael.com, there are various examples of images that are representable with Adobe RGB or sRGB, but cannot be accurately represented using sRGB. If you scroll a bit down, you see a picture where all non-sRGB-pixels have been replaced with light red pixels, in order to make the difference visible. How is it possible to create such an image? Which tools can be used for that?

My motivation is that I want to check the impact of a color space that is different from sRGB. I don't doubt that there are real colors that are not-in-sRGB. But are there any colors out-of-sRGB in any of the pictures that I shot with my iPhone 7? How common are out-of-sRGB-colors really?

Update: It would be nice to have a freeware or opensource tool for that. I don't want to install Adobe Photoshop or a similar heavyweight application. In fact a 300KB-sized command line tool could solve the problem. I'm an iOS- and macOS-developer, so it would be fine if the program works on that platform too (this includes being installable by following the standard install instructions found in the docs.) For me, it would (probably) be an option to write such a program on my own; but I hoped that someone did it already.

Answer 1

The Foundry Nuke or Blackmagic Design Fusion perform operations with floating point numbers which allow you to implement that type of tests. It essentially boils down to convert your image from DCI-P3 to sRGB colourspace and check for any negative numbers in the output image/array. Here is an example in The Foundry Nuke:

This is the above node tree that you can copy-paste into the application:

set cut_paste_input [stack 0]
version 10.5 v2
Read {
inputs 0
file /Users/kelsolaar/Downloads/Italy-P3.jpg
format "600 400 0 0 600 400 1 "
origset true
name Read1
selected true
xpos -50
ypos 11
}
set N30e152e0 [stack 0]
push $N30e152e0
Colorspace {
illuminant_in DCI-P3
primary_in DCI-P3
bradford_matrix true
name Colorspace1
selected true
xpos -50
ypos 91
}
Expression {
expr0 "r < 0 ? 1 : 0"
expr1 "g < 0 ? 1 : 0"
expr2 "b < 0 ? 1 : 0"
name Expression1
selected true
xpos -50
ypos 115
}
Viewer {
inputs 2
frame_range 1-100
input_number 1
name Viewer1
selected true
xpos -50
ypos 139
}

If you are comfortable with Python, you can also use Colour as follows:

import numpy as np

import colour
import colour.plotting

DCI_P3 = colour.read_image('/Users/kelsolaar/Downloads/Italy-P3.jpg')

sRGB = colour.RGB_to_RGB(DCI_P3, colour.DCI_P3_COLOURSPACE, colour.sRGB_COLOURSPACE)

colour.plotting.image_plot(np.where(sRGB < 0, 1.0, 0.0), 'sRGB - Out of Gamut')

The source image is available at this url: https://webkit.org/blog-files/color-gamut/Italy-P3.jpg

As mentioned by @doug in the comments below, and given that the original post is about images in general and also specific to iPhone images, it is important to note that colours with high chroma and luminance might also overflow the [0-255] range. Those values need to be accounted for if you encode your images in an low dynamic range container, e.g. JPEG, PNG or any integer based image format.

Answer 2

Most color management engines should have a mechanism to mark out-of-gamut pixels when converting an image from one colourspace to another.

Your image editing program may have a function to mark out of gamut pixels (maybe not iphone versions, but a possibility for desktop ones that use colour management and let you switch between colourspaces).

If you write your own programs, littleCMS (a free colour manangement engine that works with ICC profiles) definitely has such a mechanism, and if you hunt around on the web you may find someone has already put a suitable utility together.

Answer 3

One application that can show you this is Final Cut Pro X. Another is Motion.

In FCPX, create a new project and be sure to select Rec. 709 as the color space:

Import your image into your library, and then drop it into the new project. From the canvas' "View" menu select "Luminance" or "Saturation" (you should probably check both):

If you have any out-of-gamut values, it should display zebra-stripes like this:

In Motion, you can simply put the footage on the canvas, open the canvas' "Channels" menu, and select either "Exposure" or "Saturation":