RGBColorSystem.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.7.0
// ----------------------------------------------------------------------------
// pcl/RGBColorSystem.h - Released 2024-06-18T15:48:54Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2024 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------------
 
#ifndef __PCL_RGBColorSystem_h
#define __PCL_RGBColorSystem_h
 
 
#include <pcl/Defs.h>
 
#include <pcl/Math.h>
#include <pcl/ReferenceCounter.h>
#include <pcl/Vector.h>
 
#define _1_3            3.333333333333333e-01 // 1/3
#define _1_6            1.666666666666667e-01 // 1/6
#define _2_3            6.666666666666667e-01 // 2/3
#define _16_116         1.379310344827586e-01 // 16/116
#define CIEEpsilon      8.856451679035631e-03 // 216/24389
#define CIEKappa        9.032962962962963e+02 // 24389/27
#define CIEKappa116     7.787037037037037e+00 // CIEKappa/116
#define CIED501931XR    0.96422 // D50 (1931) mX reference white (ASTM E308-01)
#define CIED501931ZR    0.82521 // D50 (1931) mZ reference white (ASTM E308-01)
#define CIED501964XR    0.96720 // D50 (1964) mX reference white (ASTM E308-01)
#define CIED501964ZR    0.81427 // D50 (1964) mZ reference white (ASTM E308-01)
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS RGBColorSystem
{
public:
 
   using sample = double;
 
   RGBColorSystem()
      : m_data( RGBColorSystem::sRGB.m_data )
   {
      if ( m_data != nullptr )
         m_data->Attach();
      else // should not happen!
         m_data = new Data( 2.2F/*gamma*/, true/*issRGB*/, sRGB_x, sRGB_y, sRGB_Y );
   }
 
   RGBColorSystem( const RGBColorSystem& s )
      : m_data( s.m_data )
   {
      m_data->Attach();
   }
 
   RGBColorSystem( float gamma, bool issRGB, const FVector& x, const FVector& y, const FVector& Y = FVector() )
   {
      m_data = new Data( gamma, issRGB, x, y, Y );
   }
 
   RGBColorSystem( float gamma, bool issRGB, const float* x, const float* y, const float* Y = nullptr )
   {
      m_data = new Data( gamma, issRGB, FVector( x, 3 ), FVector( y, 3 ), (Y != nullptr) ? FVector( Y, 3 ) : FVector() );
   }
 
   virtual ~RGBColorSystem()
   {
      if ( m_data != nullptr )
      {
         DetachFromData();
         m_data = nullptr;
      }
   }
 
   bool IsUnique() const
   {
      return m_data->IsUnique();
   }
 
   bool IsAliasOf( const RGBColorSystem& s ) const
   {
      return m_data == s.m_data;
   }
 
   void EnsureUnique()
   {
      if ( !IsUnique() )
      {
         Data* newData = new Data( *m_data );
         DetachFromData();
         m_data = newData;
      }
   }
 
   float Gamma() const
   {
      return m_data->gamma;
   }
 
   bool IsSRGB() const
   {
      return m_data->issRGB;
   }
 
   bool IsLinear() const
   {
      return m_data->isLinear;
   }
 
   const Vector& RGBToXYZMatrix() const
   {
      return m_data->M;
   }
 
   const Vector& XYZToRGBMatrix() const
   {
      return m_data->M_;
   }
 
   double CIEXNormalizationFactor() const
   {
      return m_data->mX;
   }
 
   double CIEZNormalizationFactor() const
   {
      return m_data->mZ;
   }
 
   double CIEaNormalizationOffset() const
   {
      return m_data->zA;
   }
 
   double CIEaNormalizationFactor() const
   {
      return m_data->mA;
   }
 
   double CIEbNormalizationOffset() const
   {
      return m_data->zB;
   }
 
   double CIEbNormalizationFactor() const
   {
      return m_data->mB;
   }
 
   double CIEcNormalizationFactor() const
   {
      return m_data->mC;
   }
 
   const FVector& ChromaticityXCoordinates() const
   {
      return m_data->x;
   }
 
   const FVector& ChromaticityYCoordinates() const
   {
      return m_data->y;
   }
 
   const FVector& LuminanceCoefficients() const
   {
      return m_data->Y;
   }
 
   friend bool operator ==( const RGBColorSystem& S1, const RGBColorSystem& S2 )
   {
      return S1.IsAliasOf( S2 ) || *S1.m_data == *S2.m_data;
   }
 
   void Assign( const RGBColorSystem& rgbws )
   {
      rgbws.m_data->Attach();
      DetachFromData();
      m_data = rgbws.m_data;
   }
 
   RGBColorSystem& operator =( const RGBColorSystem& rgbws )
   {
      Assign( rgbws );
      return *this;
   }
 
   sample Lightness( sample R, sample G, sample B ) const
   {
      XYZLab( R = m_data->CIEY( R, G, B ) );
      return sample( (1.16 * R) - 0.16 );
   }
 
   // ### Deprecated - retained for compatibility -> suppress in PCL 2.x
   sample Luminance( sample R, sample G, sample B ) const
   {
      return Lightness( R, G, B );
   }
 
   sample CIEL( sample R, sample G, sample B ) const
   {
      return Lightness( R, G, B );
   }
 
   void RGBToGray( sample& K, sample R, sample G, sample B ) const
   {
      K = Lightness( R, G, B );
   }
 
   sample Value( sample R, sample G, sample B ) const
   {
      return pcl::Max( pcl::Max( R, G ), B );
   }
 
   sample Intensity( sample R, sample G, sample B ) const
   {
      return sample( 0.5*(   pcl::Min( pcl::Min( R, G ), B )
                           + pcl::Max( pcl::Max( R, G ), B ) ) );
   }
 
   sample Hue( sample R, sample G, sample B ) const
   {
      sample max   =       pcl::Max( pcl::Max( R, G ), B );
      sample delta = max - pcl::Min( pcl::Min( R, G ), B );
      if ( delta != 0 )
      {
         sample H;
         if ( R == max )
            H = (G - B)/delta;      // between yellow & magenta
         else if ( G == max )
            H = 2 + (B - R)/delta;  // between cyan & yellow
         else
            H = 4 + (R - G)/delta;  // between magenta & cyan
 
         H /= 6;
         if ( H < 0 )
            H += 1;
         return H;
      }
 
      // Achromatic case: R = G = B
      //    Hue is undefined (H is set to 0 conventionally)
      return 0;
   }
 
   sample HSVSaturation( sample R, sample G, sample B ) const
   {
      sample max   =       pcl::Max( pcl::Max( R, G ), B );
      sample delta = max - pcl::Min( pcl::Min( R, G ), B );
      return sample( (1.0 + max != 1.0) ? delta/max : 0.0 );
   }
 
   sample HSISaturation( sample R, sample G, sample B ) const
   {
      sample min   = pcl::Min( pcl::Min( R, G ), B );
      sample max   = pcl::Max( pcl::Max( R, G ), B );
      sample delta = max - min;
      if ( delta != 0 )
      {
         sample sum = min + max;
         return delta/((sum <= 1) ? sum : 2-sum);
      }
      return sample( 0 );
   }
 
   sample Saturation( sample R, sample G, sample B ) const
   {
      return HSVSaturation( R, G, B );
   }
 
   static void RGBToHSV( sample& H, sample& S, sample& V, sample R, sample G, sample B )
   {
      V = pcl::Max( pcl::Max( R, G ), B ); // V = Value( R, G, B );
 
      sample delta = V - pcl::Min( pcl::Min( R, G ), B );
      if ( delta != 0 )
      {
         S = delta/V;
 
         if ( R == V )
            H = (G - B)/delta;      // between yellow & magenta
         else if ( G == V )
            H = 2 + (B - R)/delta;  // between cyan & yellow
         else
            H = 4 + (R - G)/delta;  // between magenta & cyan
 
         H /= 6;
         if ( H < 0 )
            H += 1;
      }
      else
      {
         // Achromatic case: R = G = B
         //    S = 0, and H is undefined (H is set to 0 conventionally)
         S = H = 0;
      }
   }
 
   static void RGBToHSI( sample& H, sample& S, sample& I, sample R, sample G, sample B )
   {
      sample min   = pcl::Min( pcl::Min( R, G ), B );
      sample max   = pcl::Max( pcl::Max( R, G ), B );
      sample delta = max - min;
      sample sum   = min + max;
 
      I = 0.5*sum;
 
      if ( delta != 0 )
      {
         S = delta/((sum <= 1) ? sum : 2-sum);
 
         if ( R == max )
            H = (G - B)/delta;      // between yellow & magenta
         else if ( G == max )
            H = 2 + (B - R)/delta;  // between cyan & yellow
         else
            H = 4 + (R - G)/delta;  // between magenta & cyan
 
         H /= 6;
         if ( H < 0 )
            H += 1;
      }
      else
      {
         // Achromatic case: R = G = B
         //    S = 0, and H is undefined (H is set to 0 conventionally)
         S = H = 0;
      }
   }
 
   void RGBToHSVL( sample& H, sample& S, sample& V, sample& L, sample R, sample G, sample B ) const
   {
      RGBToHSV( H, S, V, R, G, B );
      L = Lightness( R, G, B );
   }
 
   void RGBToHSIL( sample& H, sample& S, sample& I, sample& L, sample R, sample G, sample B ) const
   {
      RGBToHSI( H, S, I, R, G, B );
      L = Lightness( R, G, B );
   }
 
   void RGBToCIEXYZ( sample& X, sample& Y, sample& Z, sample R, sample G, sample B ) const
   {
      m_data->RGBToCIEXYZ( X, Y, Z, R, G, B );
   }
 
   void RGBToCIEXZ( sample& X, sample& Z, sample R, sample G, sample B ) const
   {
      m_data->RGBToCIEXZ( X, Z, R, G, B );
   }
 
   sample CIEX( sample R, sample G, sample B ) const
   {
      return m_data->CIEX( R, G, B );
   }
 
   sample CIEY( sample R, sample G, sample B ) const
   {
      return m_data->CIEY( R, G, B );
   }
 
   sample CIEZ( sample R, sample G, sample B ) const
   {
      return m_data->CIEZ( R, G, B );
   }
 
   sample CIEYToCIEL( sample Y ) const
   {
      XYZLab( Y );
      return 1.16*Y - 0.16;
   }
 
   sample CIELToCIEY( sample L ) const
   {
      L = (L + 0.16)/1.16;
      LabXYZ( L );
      return L;
   }
 
   void RGBToCIELab( sample& L, sample& a, sample& b, sample R, sample G, sample B ) const
   {
      sample X, Y, Z;
      m_data->RGBToCIEXYZ( X, Y, Z, R, G, B );
      XYZLab( X ); XYZLab( Y ); XYZLab( Z );
      L = m_data->Range( sample( (1.16 * Y) - 0.16 ) );
      a = m_data->Range( (5*(X - Y) + m_data->zA)/m_data->mA );
      b = m_data->Range( (2*(Y - Z) + m_data->zB)/m_data->mB );
   }
 
   void RGBToCIEab( sample& a, sample& b, sample R, sample G, sample B ) const
   {
      sample X, Y, Z;
      m_data->RGBToCIEXYZ( X, Y, Z, R, G, B );
      XYZLab( X ); XYZLab( Y ); XYZLab( Z );
      a = m_data->Range( (5*(X - Y) + m_data->zA)/m_data->mA );
      b = m_data->Range( (2*(Y - Z) + m_data->zB)/m_data->mB );
   }
 
   sample CIEa( sample R, sample G, sample B ) const
   {
      sample X, Y;
      m_data->RGBToCIEXY( X, Y, R, G, B );
      XYZLab( X ); XYZLab( Y );
      return m_data->Range( (5*(X - Y) + m_data->zA)/m_data->mA );
   }
 
   sample CIEb( sample R, sample G, sample B ) const
   {
      sample Y, Z;
      m_data->RGBToCIEYZ( Y, Z, R, G, B );
      XYZLab( Y ); XYZLab( Z );
      return m_data->Range( (2*(Y - Z) + m_data->zB)/m_data->mB );
   }
 
   sample CIEc( sample R, sample G, sample B ) const
   {
      sample X, Y, Z;
      m_data->RGBToCIEXYZ( X, Y, Z, R, G, B );
      XYZLab( X ); XYZLab( Y ); XYZLab( Z );
      sample a = 5*(X - Y);
      sample b = 2*(Y - Z);
      return m_data->Range( pcl::Sqrt( a*a + b*b )/m_data->mC );
   }
 
   sample CIEh( sample R, sample G, sample B ) const
   {
      return CIEhr( R, G, B )/Const<sample>::_2pi();
   }
 
   sample CIEhr( sample R, sample G, sample B ) const
   {
      sample X, Y, Z;
      m_data->RGBToCIEXYZ( X, Y, Z, R, G, B );
      XYZLab( X ); XYZLab( Y ); XYZLab( Z );
      sample h = ArcTan( 2*(Y - Z), 5*(X - Y) );
      if ( h < 0 )
         h += Const<sample>::_2pi();
      return h;
   }
 
   void RGBToCIELch( sample& L, sample& c, sample& h, sample R, sample G, sample B ) const
   {
      sample X, Y, Z;
      m_data->RGBToCIEXYZ( X, Y, Z, R, G, B );
      XYZLab( X ); XYZLab( Y ); XYZLab( Z );
      L = m_data->Range( sample( (1.16 * Y) - 0.16 ) );
      sample a = 5*(X - Y);
      sample b = 2*(Y - Z);
      c = m_data->Range( pcl::Sqrt( a*a + b*b )/m_data->mC );
      h = ArcTan( b, a );
      if ( h < 0 )
         h += Const<sample>::_2pi();
      h /= Const<sample>::_2pi();
   }
 
   void RGBToCIELabc( sample& L, sample& a, sample& b, sample& c, sample R, sample G, sample B ) const
   {
      sample X, Y, Z;
      m_data->RGBToCIEXYZ( X, Y, Z, R, G, B );
      XYZLab( X ); XYZLab( Y ); XYZLab( Z );
      L = m_data->Range( sample( (1.16 * Y) - 0.16 ) );
      a = m_data->Range( ((X = 5*(X - Y)) + m_data->zA)/m_data->mA );
      b = m_data->Range( ((Z = 2*(Y - Z)) + m_data->zB)/m_data->mB );
      c = m_data->Range( pcl::Sqrt( X*X + Z*Z )/m_data->mC );
   }
 
   static void HSVToRGB( sample& R, sample& G, sample& B, sample H, sample S, sample V )
   {
      if ( S != 0 )
      {
         H *= 6;  // degrees -> quadrant index
 
         int i = TruncInt( Floor( H ) ); // i = sector 0 to 5
         sample f = H - i;               // f = fractional part of H
         sample p = V*(1 - S);
         sample q = V*(1 - S*f);
         sample t = V*(1 - S*(1 - f));
 
         switch( i )
         {
         case 0: R = V; G = t; B = p; break;
         case 1: R = q; G = V; B = p; break;
         case 2: R = p; G = V; B = t; break;
         case 3: R = p; G = q; B = V; break;
         case 4: R = t; G = p; B = V; break;
         case 5: R = V; G = p; B = q; break;
         default: R = G = B = V; break; // out-of-range H argument
         }
      }
      else
         R = G = B = V; // achromatic
   }
 
   void HSVLToRGB( sample& R, sample& G, sample& B, sample H, sample S, sample V, sample L ) const
   {
      HSVToRGB( R, G, B, H, S, V );
#define a   H
#define b   S
      RGBToCIEab( a, b, R, G, B );
      CIELabToRGB( R, G, B, L, a, b );
#undef a
#undef b
   }
 
   static void HSIToRGB( sample& R, sample& G, sample& B, sample H, sample S, sample I )
   {
      if ( S != 0 )
      {
         sample v2 = (I < 0.5) ? I*(1 + S) : I + S - S*I;
         sample v1 = I+I - v2;
         R = HSIH2RGB( v1, v2, H+_1_3 );
         G = HSIH2RGB( v1, v2, H      );
         B = HSIH2RGB( v1, v2, H-_1_3 );
      }
      else
         R = G = B = I; // achromatic
   }
 
   void HSILToRGB( sample& R, sample& G, sample& B, sample H, sample S, sample I, sample L ) const
   {
      HSIToRGB( R, G, B, H, S, I );
#define a   H
#define b   S
      RGBToCIEab( a, b, R, G, B );
      CIELabToRGB( R, G, B, L, a, b );
#undef a
#undef b
   }
 
   void CIEXYZToRGB( sample& R, sample& G, sample& B, sample X, sample Y, sample Z ) const
   {
      m_data->CIEXYZToRGB( R, G, B, X, Y, Z );
   }
 
   void CIEXYZToCIELab( sample& L, sample& a, sample& b, sample X, sample Y, sample Z ) const
   {
      XYZLab( X ); XYZLab( Y ); XYZLab( Z );
      L = m_data->Range( sample( (1.16 * Y) - 0.16 ) );
      a = m_data->Range( (5*(X - Y) + m_data->zA)/m_data->mA );
      b = m_data->Range( (2*(Y - Z) + m_data->zB)/m_data->mB );
   }
 
   void CIELabToRGB( sample& R, sample& G, sample& B, sample L, sample a, sample b ) const
   {
      sample Y = sample( (L + 0.16)/1.16 );
      sample X = (m_data->mA*a - m_data->zA)/5 + Y;
      sample Z = Y - (m_data->mB*b - m_data->zB)/2;
      LabXYZ( X ); LabXYZ( Y ); LabXYZ( Z );
      m_data->CIEXYZToRGB( R, G, B, X, Y, Z );
   }
 
   void CIELabToCIEXYZ( sample& X, sample& Y, sample& Z, sample L, sample a, sample b ) const
   {
      Y = sample( (L + 0.16)/1.16 );
      X = (m_data->mA*a - m_data->zA)/5 + Y;
      Z = Y - (m_data->mB*b - m_data->zB)/2;
      LabXYZ( X ); LabXYZ( Y ); LabXYZ( Z );
      X = m_data->Range( X );
      Y = m_data->Range( Y );
      Z = m_data->Range( Z );
   }
 
   void CIELabToCIELch( sample& L, sample& c, sample& h, sample L0, sample a, sample b ) const
   {
      L = m_data->Range( L0 );
      a = m_data->mA*a - m_data->zA;
      b = m_data->mB*b - m_data->zB;
      c = m_data->Range( Sqrt( a*a + b*b )/m_data->mC );
      h = ArcTan( b, a )/Const<sample>::pi();
      if ( h < 0 )
         h += 1;
   }
 
   void CIELchToRGB( sample& R, sample& G, sample& B, sample L, sample c, sample h ) const
   {
      sample a, b;
      SinCos( h*Const<sample>::_2pi(), b, a );
      c *= m_data->mC;
      a *= c;
      b *= c;
      sample Y = sample( (L + 0.16)/1.16 );
      sample X = a/5 + Y;
      sample Z = Y - b/2;
      LabXYZ( X ); LabXYZ( Y ); LabXYZ( Z );
      m_data->CIEXYZToRGB( R, G, B, X, Y, Z );
   }
 
   void CIELchToCIELab( sample& L, sample& a, sample& b, sample L0, sample c, sample h ) const
   {
      L = m_data->Range( L0 );
      SinCos( h*Const<sample>::_2pi(), b, a );
      c *= m_data->mC;
      a = m_data->Range( (c*a + m_data->zA)/m_data->mA );
      b = m_data->Range( (c*b + m_data->zB)/m_data->mB );
   }
 
   static double SRGBToLinear( double x )
   {
      PCL_PRECONDITION( x >= 0 && x <= 1 )
      return (x > 0.04045) ? Pow( (x + 0.055)/1.055, 2.4 ) : x/12.92;
   }
 
   static double LinearToSRGB( double x )
   {
      PCL_PRECONDITION( x >= 0 && x <= 1 )
      return (x > 0.0031308) ? 1.055*Pow( x, sample( 1/2.4 ) ) - 0.055 : 12.92*x;
   }
 
protected:
 
   struct Data : public ReferenceCounter
   {
      float gamma, gammaInv;  // gamma, 1/gamma; ignored if issRGB=true
      bool issRGB;   // true if sRGB gamma function is being used
      bool isLinear; // true if gamma=1.0 and issRGB=false, for optimization
 
      /*
       * Chromaticity coordinates w.r.t. the D50 reference white.
       */
      FVector x, y;
 
      /*
       * Luminance coefficients w.r.t. the D50 reference white.
       */
      FVector Y;
 
      /*
       * RGB <-> CIE XYZ transformation matrices.
       */
      Vector M;  // RGB -> CIE XYZ
      Vector M_; // CIE XYZ -> RGB
 
      /*
       * Normalization of CIE X and Z components.
       */
      double mX, mZ; // scale factors
 
      /*
       * Normalization of CIE L*, a*, b* and c* components.
       */
      double mA, mB, mC; // scale factors
      double zA, zB;     // zero offsets
 
      Data( float, bool, const FVector&, const FVector&, const FVector& );
      Data( float, bool, const float*, const float*, const float* );
      Data( const Data& ) = default;
 
      void Initialize();
 
      bool operator ==( const RGBColorSystem::Data& data ) const
      {
         return gamma == data.gamma &&
                issRGB == data.issRGB &&
                Y == data.Y &&
                x == data.x && y == data.y;
      }
 
      /*
       * Primary gamma functions.
       */
 
      void LinearRGB( sample& x ) const
      {
         x = sample( issRGB ? SRGBToLinear( double( x ) ) : Pow( double( x ), double( gamma ) ) );
      }
 
      void GammaRGB( sample& x ) const
      {
         x = sample( issRGB ? LinearToSRGB( double( x ) ) : Pow( double( x ), double( gammaInv ) ) );
      }
 
      /*
       * Primary linear transformations.
       */
 
      void RGBToCIEXYZ( sample& X, sample& Y, sample& Z, sample R, sample G, sample B ) const
      {
         if ( !isLinear )
         {
            LinearRGB( R );
            LinearRGB( G );
            LinearRGB( B );
         }
 
         X = Range( (R*M[0] + G*M[1] + B*M[2])/mX );
         Y = Range(  R*M[3] + G*M[4] + B*M[5]     );
         Z = Range( (R*M[6] + G*M[7] + B*M[8])/mZ );
      }
 
      void CIEXYZToRGB( sample& R, sample& G, sample& B, sample X, sample Y, sample Z ) const
      {
         X *= mX;
         Z *= mZ;
         R = Range( X*M_[0] + Y*M_[1] + Z*M_[2] );
         G = Range( X*M_[3] + Y*M_[4] + Z*M_[5] );
         B = Range( X*M_[6] + Y*M_[7] + Z*M_[8] );
 
         if ( !isLinear )
         {
            GammaRGB( R );
            GammaRGB( G );
            GammaRGB( B );
         }
      }
 
      /*
       * Partial transformations for fast luminance/chrominance calculations.
       */
 
      sample CIEX( sample R, sample G, sample B ) const
      {
         if ( !isLinear )
         {
            LinearRGB( R );
            LinearRGB( G );
            LinearRGB( B );
         }
 
         return Range( (R*M[0] + G*M[1] + B*M[2])/mX );
      }
 
      sample CIEY( sample R, sample G, sample B ) const
      {
         if ( !isLinear )
         {
            LinearRGB( R );
            LinearRGB( G );
            LinearRGB( B );
         }
 
         return Range( R*M[3] + G*M[4] + B*M[5] );
      }
 
      sample CIEZ( sample R, sample G, sample B ) const
      {
         if ( !isLinear )
         {
            LinearRGB( R );
            LinearRGB( G );
            LinearRGB( B );
         }
 
         return Range( (R*M[6] + G*M[7] + B*M[8])/mZ );
      }
 
      void RGBToCIEXY( sample& X, sample& Y, sample R, sample G, sample B ) const
      {
         if ( !isLinear )
         {
            LinearRGB( R );
            LinearRGB( G );
            LinearRGB( B );
         }
 
         X = Range( (R*M[0] + G*M[1] + B*M[2])/mX );
         Y = Range(  R*M[3] + G*M[4] + B*M[5] );
      }
 
      void RGBToCIEYZ( sample& Y, sample& Z, sample R, sample G, sample B ) const
      {
         if ( !isLinear )
         {
            LinearRGB( R );
            LinearRGB( G );
            LinearRGB( B );
         }
 
         Y = Range(  R*M[3] + G*M[4] + B*M[5] );
         Z = Range( (R*M[6] + G*M[7] + B*M[8])/mZ );
      }
 
      void RGBToCIEXZ( sample& X, sample& Z, sample R, sample G, sample B ) const
      {
         if ( !isLinear )
         {
            LinearRGB( R );
            LinearRGB( G );
            LinearRGB( B );
         }
 
         X = Range( (R*M[0] + G*M[1] + B*M[2])/mX );
         Z = Range( (R*M[6] + G*M[7] + B*M[8])/mZ );
      }
 
      static bool ValidateParameters( const FVector& x, const FVector& y, const FVector& Y );
 
      // Ensure output values stay within the nominal [0,1] range.
      static sample Range( const sample& x )
      {
         return pcl::Range( x, sample( 0 ), sample( 1 ) );
      }
   };
 
   Data* m_data = nullptr;
 
   void DetachFromData()
   {
      if ( !m_data->Detach() )
         delete m_data;
   }
 
   /*
    * CIE XYZ -> Lab component transformation function.
    */
   static void XYZLab( sample& x )
   {
      x = (x > CIEEpsilon) ? Pow( x, sample( _1_3 ) ) : sample( CIEKappa116*x + _16_116 );
   }
 
   /*
    * CIE Lab -> XYZ component transformation function.
    */
   static void LabXYZ( sample& x )
   {
      sample x3 = x*x*x;
      x = (x3 > CIEEpsilon) ? x3 : sample( (x - _16_116)/CIEKappa116 );
   }
 
   /*
    * HSI hue angle to RGB component conversion function.
    */
   static sample HSIH2RGB( sample v1, sample v2, sample H )
   {
      if ( H < 0 )
         H += 1;
      else if ( H > 1 )
         H -= 1;
 
      if ( H < _1_6 )
         return v1 + 6*H*(v2 - v1);
 
      if ( H < 0.5 )
         return v2;
 
      if ( H < _2_3 )
         return v1 + 6*(_2_3 - H)*(v2 - v1);
 
      return v1;
   }
 
   friend struct Data;
 
public:
 
   static const float sRGB_x[ 3 ];
 
   static const float sRGB_y[ 3 ];
 
   static const float sRGB_Y[ 3 ];
 
   static const RGBColorSystem sRGB;
 
#ifdef __PCL_WITH_STANDARD_RGB_WORKING_SPACES
 
   /*
    * Adobe RGB 1998
    */
   static const float AdobeRGB1998_x[ 3 ];
   static const float AdobeRGB1998_y[ 3 ];
   static const float AdobeRGB1998_Y[ 3 ];
 
   /*
    * Apple RGB
    */
   static const float AppleRGB_x[ 3 ];
   static const float AppleRGB_y[ 3 ];
   static const float AppleRGB_Y[ 3 ];
 
   /*
    * Best RGB
    */
   static const float BestRGB_x[ 3 ];
   static const float BestRGB_y[ 3 ];
   static const float BestRGB_Y[ 3 ];
 
   /*
    * Beta RGB (by Bruce Lindbloom)
    */
   static const float BetaRGB_x[ 3 ];
   static const float BetaRGB_y[ 3 ];
   static const float BetaRGB_Y[ 3 ];
 
   /*
    * Bruce RGB
    */
   static const float BruceRGB_x[ 3 ];
   static const float BruceRGB_y[ 3 ];
   static const float BruceRGB_Y[ 3 ];
 
   /*
    * CIE RGB
    */
   static const float CIERGB_x[ 3 ];
   static const float CIERGB_y[ 3 ];
   static const float CIERGB_Y[ 3 ];
 
   /*
    * Color Match RGB
    */
   static const float ColorMatchRGB_x[ 3 ];
   static const float ColorMatchRGB_y[ 3 ];
   static const float ColorMatchRGB_Y[ 3 ];
 
   /*
    * NTSC RGB
    */
   static const float NTSCRGB_x[ 3 ];
   static const float NTSCRGB_y[ 3 ];
   static const float NTSCRGB_Y[ 3 ];
 
   /*
    * PAL/SECAM RGB
    */
   static const float PALSECAMRGB_x[ 3 ];
   static const float PALSECAMRGB_y[ 3 ];
   static const float PALSECAMRGB_Y[ 3 ];
 
   /*
    * ProPhoto RGB
    */
   static const float ProPhotoRGB_x[ 3 ];
   static const float ProPhotoRGB_y[ 3 ];
   static const float ProPhotoRGB_Y[ 3 ];
 
   /*
    * SMPTE-C RGB
    */
   static const float SMPTECRGB_x[ 3 ];
   static const float SMPTECRGB_y[ 3 ];
   static const float SMPTECRGB_Y[ 3 ];
 
   /*
    * Wide Gamut RGB
    */
   static const float WideGamutRGB_x[ 3 ];
   static const float WideGamutRGB_y[ 3 ];
   static const float WideGamutRGB_Y[ 3 ];
 
#endif   // __PCL_WITH_STANDARD_RGB_WORKING_SPACES
};
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#undef _1_3
#undef _1_6
#undef _2_3
#undef _16_116
#undef CIEEpsilon
#undef CIEKappa
#undef CIEKappa116
 
#endif   // __PCL_RGBColorSystem_h
 
// ----------------------------------------------------------------------------
// EOF pcl/RGBColorSystem.h - Released 2024-06-18T15:48:54Z