Add wide color gamut (WCG) support

In practice, this means color space conversions between sRGB, DCI-P3,
and Rec2020. Input and output color spaces can be toggled on the fly
and independent of each other with the hotkeys 'i' and 'o'.

This commit constitutes release 1.8.0.

Author: toaarnio

README.md

@@ -2,7 +2,7 @@
 
 [![Build Status](https://travis-ci.com/toaarnio/glview.svg?branch=master)](https://travis-ci.com/github/toaarnio/glview)
 
-Lightning-fast image viewer with synchronized split-screen zooming & panning + HDR exposure control.
+Lightning-fast image viewer with synchronized split-screen zooming & panning + HDR & WCG support
 
 **Installing:**
 ```

glview/glrenderer.py

@@ -84,6 +84,8 @@ def redraw(self):
             self.prog['scale'] = self.ui.scale
             self.prog['grayscale'] = (texture.components == 1)
             self.prog['gamma'] = self.ui.gamma
+            self.prog['cs_in'] = self.ui.cs_in
+            self.prog['cs_out'] = self.ui.cs_out
             self.prog['maxval'] = maxval if self.ui.normalize else 1.0
             self.prog['ev'] = self.ui.ev
             self.prog['gamut.compress'] = (self.ui.gamut_fit != 0)

glview/glview.py

@@ -138,6 +138,8 @@ def main():
         print("    n                       toggle exposure normalization on/off")
         print("    e                       slide exposure from -2EV to +2EV & back")
         print("    b                       toggle between HDR/LDR exposure control")
+        print("    i                       toggle input color space: sRGB/P3/Rec2020")
+        print("    o                       toggle output color space: sRGB/P3/Rec2020")
         print("    k                       toggle gamut compression strength")
         print("    x                       print image information (EXIF)")
         print("    d                       drop the currently shown image")

glview/pygletui.py

@@ -40,6 +40,8 @@ def __init__(self, files, debug, verbose=False):
         self.renderer = None
         self.texture_filter = "NEAREST"
         self.img_per_tile = [0, 1, 2, 3]
+        self.cs_in = 0
+        self.cs_out = 0
         self.gamma = 0
         self.normalize = False
         self.ev_range = 2
@@ -109,10 +111,12 @@ def _init_pyglet(self):
 
     def _caption(self):
         fps = pyglet.clock.get_frequency()
+        cspaces = ["sRGB", "DCI-P3", "Rec2020"]
+        csc = f"{cspaces[self.cs_in]} => {cspaces[self.cs_out]}"
         norm = "off" if not self.normalize else "on"
         gamma = ["off", "sRGB", "HDR"][self.gamma]
         gamut = "off" if not self.gamut_fit else f"p = {self.gamut_pow[0]:.1f}"
-        caption = f"glview [{self.ev:+1.2f}EV | norm {norm} | gamma {gamma} | gamut fit {gamut} | {fps:.1f} fps]"
+        caption = f"glview [{self.ev:+1.2f}EV | norm {norm} | {csc} | gamma {gamma} | gamut fit {gamut} | {fps:.1f} fps]"
         for tileidx in range(self.numtiles):
             imgidx = self.img_per_tile[tileidx]
             basename = self.files.filespecs[imgidx]
@@ -286,6 +290,12 @@ def on_key_press(symbol, modifiers):
                 if symbol == keys.G:  # gamma
                     self.gamma = (self.gamma + 1) % 3
                     self.need_redraw = True
+                if symbol == keys.I:  # input color space
+                    self.cs_in = (self.cs_in + 1) % 3
+                    self.need_redraw = True
+                if symbol == keys.O:  # output color space
+                    self.cs_out = (self.cs_out + 1) % 3
+                    self.need_redraw = True
                 if symbol == keys.B:  # toggle between narrow/wide (LDR/HDR) exposure control
                     self.ev_range = (self.ev_range + 6) % 12
                     self.need_redraw = True

glview/texture.fs

@@ -1,6 +1,10 @@
-#version 130
+#version 140
+
+precision highp float;
 
 uniform int debug;
+uniform int cs_in;
+uniform int cs_out;
 uniform bool grayscale;
 uniform int gamma;
 uniform float ev;
@@ -39,6 +43,18 @@ float max3(vec3 v) {
 }
 
 
+mat3 mround(mat3 mtx) {
+  /**
+   * Rounds the elements of the given matrix to the nearest integer. Annoyingly,
+   * the built-in round() function does not work with matrices.
+   */
+  mtx[0] = round(mtx[0]);
+  mtx[1] = round(mtx[1]);
+  mtx[2] = round(mtx[2]);
+  return mtx;
+}
+
+
 /**************************************************************************************/
 /*
 /*    G A M M A
@@ -102,6 +118,245 @@ vec3 apply_gamma(vec3 rgb) {
 }
 
 
+/**************************************************************************************/
+/*
+/*    C O L O R   S P A C E   C O N V E R S I O N S
+/*
+/**************************************************************************************/
+
+
+vec3 xy_to_xyz(vec2 xy) {
+  /**
+   * Transforms the given color coordinates from CIE xy to CIE XYZ.
+   */
+  vec3 xyz;
+  xyz.x = xy.x / xy.y;
+  xyz.y = 1.0;
+  xyz.z = (1.0 - xy.x - xy.y) / xy.y;
+  return xyz;
+}
+
+
+mat3 rgb_to_xyz_mtx(vec2 xy_r, vec2 xy_g, vec2 xy_b, vec2 xy_w) {
+  /**
+   * Returns a 3 x 3 conversion matrix from RGB to XYZ, given the (x, y) chromaticity
+   * coordinates of the RGB primaries and the reference white. Conversion formula taken
+   * from http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html.
+   */
+  vec3 XYZ_r = xy_to_xyz(xy_r);
+  vec3 XYZ_g = xy_to_xyz(xy_g);
+  vec3 XYZ_b = xy_to_xyz(xy_b);
+  vec3 XYZ_w = xy_to_xyz(xy_w);
+  mat3 M = mat3(XYZ_r, XYZ_g, XYZ_b);
+
+  // Scale each column of the RGB-to-XYZ matrix with a scalar such
+  // that [1, 1, 1] gets transformed to the given whitepoint (XYZ_w);
+  // for example, M * [1, 1, 1] = [0.9504, 1.0, 1.0888] in case of D65.
+
+  vec3 S = inverse(M) * XYZ_w;  // whitepoint in RGB
+  M[0] *= S[0];  // R column vector scale
+  M[1] *= S[1];  // G column vector scale
+  M[2] *= S[2];  // B column vector scale
+  return M;
+}
+
+
+mat3 xyz_to_rgb_mtx(vec2 xy_r, vec2 xy_g, vec2 xy_b, vec2 xy_w) {
+  /**
+   * Returns a 3 x 3 conversion matrix from XYZ to RGB, given the (x, y) chromaticity
+   * coordinates of the RGB primaries and the reference white. Conversion formula taken
+   * from http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html.
+   */
+  mat3 M = rgb_to_xyz_mtx(xy_r, xy_g, xy_b, xy_w);
+  M = inverse(M);
+  return M;
+}
+
+
+mat3 srgb_to_xyz_mtx() {
+  /**
+   * Returns the exact sRGB to XYZ conversion matrix defined by the sRGB specification.
+   * Note that the matrix is computed from limited-precision primaries and whitepoint,
+   * and rounded to four decimals at the end, as per the specification.
+   */
+  vec2 D65_WP = vec2(0.3127, 0.3290);
+  vec2 xy_r = vec2(0.640, 0.330);
+  vec2 xy_g = vec2(0.300, 0.600);
+  vec2 xy_b = vec2(0.150, 0.060);
+  mat3 M = rgb_to_xyz_mtx(xy_r, xy_g, xy_b, D65_WP);
+  M = mround(M * 10000.0) / 10000.0;
+  return M;
+}
+
+
+mat3 xyz_to_srgb_mtx() {
+  /**
+   * Returns the exact XYZ to sRGB conversion matrix defined by the sRGB specification.
+   * Note that the matrix is computed from limited-precision primaries and whitepoint,
+   * and rounded to four decimals at the end, as per the specification.
+   */
+  mat3 M = inverse(srgb_to_xyz_mtx());
+  M = mround(M * 10000.0) / 10000.0;
+  return M;
+}
+
+
+mat3 p3_to_xyz_mtx() {
+  /**
+   * Returns the exact DCI-P3 to XYZ conversion matrix defined by the P3 specification.
+   * Note that the matrix is computed from limited-precision primaries and whitepoint,
+   * as per the specification.
+   */
+  vec2 D65_WP = vec2(0.3127, 0.3290);
+  vec2 xy_r = vec2(0.680, 0.320);
+  vec2 xy_g = vec2(0.265, 0.690);
+  vec2 xy_b = vec2(0.150, 0.060);
+  mat3 M = rgb_to_xyz_mtx(xy_r, xy_g, xy_b, D65_WP);
+  return M;
+}
+
+
+mat3 xyz_to_p3_mtx() {
+  /**
+   * Returns the exact XYZ to DCI-P3 conversion matrix defined by the P3 specification.
+   * Note that the matrix is computed from limited-precision primaries and whitepoint,
+   * as per the specification.
+   */
+  mat3 M = inverse(p3_to_xyz_mtx());
+  return M;
+}
+
+
+mat3 rec2020_to_xyz_mtx() {
+  /**
+   * Returns the exact Rec2020 to XYZ conversion matrix defined by the Rec2020
+   * specification. Note that the matrix is computed from limited-precision
+   * primaries and whitepoint, as per the specification.
+   */
+  vec2 D65_WP = vec2(0.3127, 0.3290);
+  vec2 xy_r = vec2(0.708, 0.292);
+  vec2 xy_g = vec2(0.170, 0.797);
+  vec2 xy_b = vec2(0.131, 0.046);
+  mat3 M = rgb_to_xyz_mtx(xy_r, xy_g, xy_b, D65_WP);
+  return M;
+}
+
+
+mat3 xyz_to_rec2020_mtx() {
+  /**
+   * Returns the exact XYZ to Rec2020 conversion matrix defined by the Rec2020
+   * specification. Note that the matrix is computed from limited-precision
+   * primaries and whitepoint, as per the specification.
+   */
+  mat3 M = inverse(rec2020_to_xyz_mtx());
+  return M;
+}
+
+
+vec3 srgb_to_xyz(vec3 rgb) {
+  /**
+   * Transforms the given sRGB color to CIE XYZ.
+   */
+  vec3 xyz = srgb_to_xyz_mtx() * rgb;
+  return xyz;
+}
+
+
+vec3 xyz_to_srgb(vec3 xyz) {
+  /**
+   * Transforms the given CIE XYZ color to sRGB.
+   */
+  vec3 rgb = xyz_to_srgb_mtx() * xyz;
+  return rgb;
+}
+
+
+vec3 p3_to_xyz(vec3 rgb) {
+  /**
+   * Transforms the given DCI-P3 color to CIE XYZ.
+   */
+  vec3 xyz = p3_to_xyz_mtx() * rgb;
+  return xyz;
+}
+
+
+vec3 xyz_to_p3(vec3 xyz) {
+  /**
+   * Transforms the given CIE XYZ color to DCI-P3.
+   */
+  vec3 rgb = xyz_to_p3_mtx() * xyz;
+  return rgb;
+}
+
+
+vec3 rec2020_to_xyz(vec3 rgb) {
+  /**
+   * Transforms the given Rec2020 color to CIE XYZ.
+   */
+  vec3 xyz = rec2020_to_xyz_mtx() * rgb;
+  return xyz;
+}
+
+
+vec3 xyz_to_rec2020(vec3 xyz) {
+  /**
+   * Transforms the given CIE XYZ color to Rec2020.
+   */
+  vec3 rgb = xyz_to_rec2020_mtx() * xyz;
+  return rgb;
+}
+
+
+vec3 csconv(vec3 rgb) {
+  /**
+   * Transforms the given color from a given input color space to a given output
+   * color space. If the input and output color spaces are the same, the color is
+   * unchanged. The following color spaces are available as both input & output:
+   *
+   *   0 - sRGB
+   *   1 - DCI-P3
+   *   2 - Rec2020
+   *
+   * As a concrete example, to display a P3-JPEG captured by a modern smartphone
+   * on a high-quality wide-gamut monitor, you would set the input color space to
+   * DCI-P3 and the output to Rec2020, while making sure that the monitor is set
+   * to Rec2020 mode.
+   */
+  if (cs_in != cs_out) {
+    vec3 xyz;
+    switch (cs_in) {
+      case 0:
+        xyz = srgb_to_xyz(rgb);
+        break;
+      case 1:
+        xyz = p3_to_xyz(rgb);
+        break;
+      case 2:
+        xyz = rec2020_to_xyz(rgb);
+        break;
+      default:
+        xyz = rgb;
+        break;
+    }
+    switch (cs_out) {
+      case 0:
+        rgb = xyz_to_srgb(xyz);
+        break;
+      case 1:
+        rgb = xyz_to_p3(xyz);
+        break;
+      case 2:
+        rgb = xyz_to_rec2020(xyz);
+        break;
+      default:
+        rgb = xyz;
+        break;
+    }
+  }
+  return rgb;
+}
+
+
 /**************************************************************************************/
 /*
 /*    G A M U T   C O M P R E S S I O N
@@ -230,6 +485,7 @@ vec3 debug_indicators(vec3 rgb) {
 void main() {
   color = texture2D(texture, rotate(texcoords, orientation));
   color.rgb = color.rgb / maxval;
+  color.rgb = csconv(color.rgb);
   color.rgb = grayscale ? color.rrr : color.rgb;
   color.rgb = gamut.compress ? compress_gamut(color.rgb) : color.rgb;
   color.rgb = color.rgb * exp(ev);  // exp(x) == 2^x

glview/version.py

@@ -1 +1 @@
-__version__ = "1.7.0"
+__version__ = "1.8.0"