mlCIELabToRGBTools.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
//----------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------
 
#pragma once
 
#include "MLMLToDicomToolsSystem.h"
#include <mlTypeDefs.h>
#include <mlLinearAlgebra.h>
 
ML_START_NAMESPACE
 
inline Vector3 convertXYZToRGB(const Vector3& xyzIn, bool clampToStayInRGB=true) {
  double var_X = xyzIn[0] / 100.0;        // X from 0 to  95.047      (Observer = 2°, Illuminant = D65)
  double var_Y = xyzIn[1] / 100.0;        // Y from 0 to 100.000
  double var_Z = xyzIn[2] / 100.0;        // Z from 0 to 108.883
 
  double var_R = var_X *  3.240479 + var_Y * -1.537150 + var_Z * -0.498535;
  double var_G = var_X * -0.969256 + var_Y *  1.875992 + var_Z *  0.041556;
  double var_B = var_X *  0.055648 + var_Y * -0.204043 + var_Z *  1.057311;
 
  if ( var_R > 0.0031308 ){ var_R = 1.055 * ( pow(var_R , ( 1.0 / 2.4 )) ) - 0.055; }
  else                    { var_R = 12.92 * var_R;  }
  if ( var_G > 0.0031308 ){ var_G = 1.055 * ( pow(var_G , ( 1.0 / 2.4 )) ) - 0.055; }
  else                    { var_G = 12.92 * var_G;  }
  if ( var_B > 0.0031308 ){ var_B = 1.055 * ( pow(var_B , ( 1.0 / 2.4 )) ) - 0.055; }
  else                    { var_B = 12.92 * var_B;  }
 
  if (clampToStayInRGB){
    if (var_R < 0.){ var_R = 0.; } else if (var_R > 1.){ var_R = 1.; }
    if (var_G < 0.){ var_G = 0.; } else if (var_G > 1.){ var_G = 1.; }
    if (var_B < 0.){ var_B = 0.; } else if (var_B > 1.){ var_B = 1.; }
  }
 
  Vector3 rgbOut;
  rgbOut[0] = var_R;
  rgbOut[1] = var_G;
  rgbOut[2] = var_B;
  return rgbOut;
}
 
inline Vector3 convertCIELabToXYZ(const Vector3& cieLabIn) {
  double var_Y = ( cieLabIn[0] + 16.0 ) / 116.0;
  double var_X = cieLabIn[1] / 500.0 + var_Y;
  double var_Z = var_Y - cieLabIn[2] / 200.0;
 
  if ( pow(var_Y,3.0) > 0.008856 ){ var_Y = pow(var_Y,3.0); }
  else                            { var_Y = ( var_Y - 16 / 116 ) / 7.787; }
  if ( pow(var_X,3.0) > 0.008856 ){ var_X = pow(var_X,3.0); }
  else                            { var_X = ( var_X - 16 / 116 ) / 7.787; }
  if ( pow(var_Z,3.0) > 0.008856 ){ var_Z = pow(var_Z,3.0); }
  else                            { var_Z = ( var_Z - 16 / 116 ) / 7.787; }
 
  const double ref_X =  95.047;  //   Observer= 2°, Illuminant= D65
  const double ref_Y = 100.000;
  const double ref_Z = 108.883;
 
  Vector3 xyzOut;
  xyzOut[0] = ref_X * var_X;    // ref_X =  95.047     Observer= 2°, Illuminant= D65
  xyzOut[1] = ref_Y * var_Y;    // ref_Y = 100.000
  xyzOut[2] = ref_Z * var_Z;    // ref_Z = 108.883
  return xyzOut;
}
 
inline Vector3 convertCIELabToRGB(const Vector3& cieLabIn, bool clampToStayInRGB=true) {
  return convertXYZToRGB(convertCIELabToXYZ(cieLabIn), clampToStayInRGB);
}
 
inline Vector3 convertRGBToXYZ(const Vector3& rgbIn, bool clampToObserver2IlluminantD65=false) {
  double var_R = rgbIn[0];
  double var_G = rgbIn[1];
  double var_B = rgbIn[2];
 
  if ( var_R > 0.04045 ){ var_R = pow(( ( var_R + 0.055 ) / 1.055 ) , 2.4); }
  else                  { var_R = var_R / 12.92;                       }
  if ( var_G > 0.04045 ){ var_G = pow(( ( var_G + 0.055 ) / 1.055 ) , 2.4); }
  else                  { var_G = var_G / 12.92;                       }
  if ( var_B > 0.04045 ){ var_B = pow(( ( var_B + 0.055 ) / 1.055 ) , 2.4); }
  else                  { var_B = var_B / 12.92;                       }
 
  var_R = var_R * 100.;
  var_G = var_G * 100.;
  var_B = var_B * 100.;
 
  // Observer. = 2°, Illuminant = D65
  // Source for example https://de.wikipedia.org/wiki/CIE-Normvalenzsystem
  // and for more precise values now used in matrix 
  // https://stackoverflow.com/questions/6629798/whats-wrong-with-this-rgb-to-xyz-color-space-conversion-algorithm
  Vector3 xyzOut;
  xyzOut[0] = var_R * 0.4124564 + var_G * 0.3575761 + var_B * 0.1804375;
  xyzOut[1] = var_R * 0.2126729 + var_G * 0.7151522 + var_B * 0.0721750;
  xyzOut[2] = var_R * 0.0193339 + var_G * 0.1191920 + var_B * 0.9503041;
  
  if (clampToObserver2IlluminantD65){
    if (xyzOut[0] < 0.){ xyzOut[0] = 0.; } else if (xyzOut[0] >  95.047){ xyzOut[0] =  95.047; }
    if (xyzOut[1] < 0.){ xyzOut[1] = 0.; } else if (xyzOut[1] > 100.000){ xyzOut[1] = 100.000; }
    if (xyzOut[2] < 0.){ xyzOut[2] = 0.; } else if (xyzOut[2] > 108.883){ xyzOut[2] = 108.883; }
  }
  return xyzOut;
}
 
inline Vector3 convertXYZToCIELab(const Vector3& xyzIn) {
  const double ref_X =  95.047;  //   Observer= 2°, Illuminant= D65
  const double ref_Y = 100.000;
  const double ref_Z = 108.883;
 
  double var_X = xyzIn[0] / ref_X;
  double var_Y = xyzIn[1] / ref_Y;
  double var_Z = xyzIn[2] / ref_Z;
 
  if ( var_X > 0.008856 ){ var_X = pow(var_X, ( 1./3. ));              }
  else                   { var_X = ( 7.787 * var_X ) + ( 16. / 116. ); }
  if ( var_Y > 0.008856 ){ var_Y = pow(var_Y, ( 1./3. ));              }
  else                   { var_Y = ( 7.787 * var_Y ) + ( 16. / 116. ); }
  if ( var_Z > 0.008856 ){ var_Z = pow(var_Z, ( 1./3. ));              }
  else                   { var_Z = ( 7.787 * var_Z ) + ( 16. / 116. ); }
 
  Vector3 cieLabOut;
  cieLabOut[0] = ( 116. * var_Y ) - 16.;
  cieLabOut[1] = 500. * ( var_X - var_Y );
  cieLabOut[2] = 200. * ( var_Y - var_Z );
  return cieLabOut;
}
 
inline Vector3 convertRGBToCIELab(const Vector3& rgbIn) {
  return convertXYZToCIELab(convertRGBToXYZ(rgbIn));
}
 
inline Vector3 scaleCIELabTo16BitUnsigned(Vector3 cieLabIn) {
  cieLabIn[0] *= 655.35; // Scale from [0,100] to [0,65535]
  cieLabIn[1]  = (cieLabIn[1] + 128.)*256.; // Scale from [-128,127] to [0,65535].
  cieLabIn[2]  = (cieLabIn[2] + 128.)*256.; // Scale from [-128,127] to [0,65535].
  return cieLabIn;
}
 
inline Vector3 unscaleCIELabTagValue(Vector3 cieLabScaledIn) {
  cieLabScaledIn[0] /= 655.35; // Scale from [0,65535] to [0,100].
  cieLabScaledIn[1]  = cieLabScaledIn[1]/256. - 128.; // Scale from  [0,65535] to [-128,127].
  cieLabScaledIn[2]  = cieLabScaledIn[2]/256. - 128.; // Scale from  [0,65535] to [-128,127].
  return cieLabScaledIn;
}
 
ML_END_NAMESPACE