Color.H

Go to the documentation of this file.

#ifndef COLOR_H
#define COLOR_H

// Gluebase includes
#define OUTSIDE_GLUE_CORE
#include <std/strings.H>
#include <math.h>

namespace InSpace {

#define MIN_L 0.0
#define MAX_L 100.0
#define MIN_A -86.18717193603515625
#define MAX_A 98.2308502197265625
#define MIN_B -107.85298919677734375
#define MAX_B 94.485137939453125
#define MIN_SATURATION 0.0
#define MAX_SATURATION 15.22387409210205078125 // recomputed using indexed values for chroma
#define MIN_CHROMA 0.0
#define MAX_CHROMA 133.8037872314453125

#define INITIAL_INTERVAL 4.0

#define INTERVAL_FACTOR 8.0
#define MIN_INTERVAL 0.0078125

#define MIN_INTERVAL_FAILURE 0.25

class Color {
public:
  
  Color() {
    for (int i=0;i<4;i++)
      _col[i] = 1.0;
  };

  Color(const Color& c){
    _col[0]=c[0];
    _col[1]=c[1];
    _col[2]=c[2];
    _col[3]=c[3];
  };

  Color(const float r,const float g,const float b,const float a=1.0) {
    _col[0] = r;
    _col[1] = g;
    _col[2] = b;
    _col[3] = a;
  };
  
  Color(str_ptr colstr) {
    for (int i=0;i<4;i++)
      _col[i] = 1.0;
    set(colstr);
  };
  
  virtual ~Color() {};

  void set(const float r,const float g,const float b,const float a=1.0) {
    _col[0] = r;
    _col[1] = g;
    _col[2] = b;
    _col[3] = a;
  };

  void set(str_ptr colstr);

  float r() const { return _col[0]; };
  float g() const { return _col[1]; };
  float b() const { return _col[2]; };
  float a() const { return _col[3]; };

  void setHLS(const float h, const float l, const float s, const float a=1.0);
  
  void getHLS(float &h, float &l, float &s);
  
  /*
    CIELAB used with D65 whitepoint
    L measures lightness that ranges from 0 (black) to 100 (white).
    a defines redness (positive a) or greenness (negative a) -- ranges from MIN_A to MAX_A
    b defines yellowness (positive b) or blueness (negative b) -- ranges from MIN_B to MAX_B
    a and b approach zero for neutral colors
    NOTE: not all valid LAB coordinates translate to a valid RGB value--all functions assume valid LAB values
  */
  
  bool setLAB(const float L,const float a,const float b, const float alpha=1.0);
  
  void getLAB(float &L, float &a, float &b);
  
  static float getLABChroma(const float L, const float a, const float b);

  static float getLABSaturation(const float L, const float a, const float b);
  
  static float getLABHue(const float L, const float a, const float b);
  
  static void setLABLightnessChromaHue(const float L, float &a, float &b, const float chroma, const float hue);
  static void setLABChromaSaturationHue(float &L, float &a, float &b, const float chroma, const float saturation, const float hue);
  static void setLABLightnessSaturationHue(const float L, float &a, float &b, const float saturation, const float hue);
  static void setLABSaturationAB(float &L, const float a, const float b, const float saturation);
  
  static float getLABColorDifference(const float L1, const float a1, const float b1, const float L2, const float a2, const float b2);
  
  void getXYZ(float &X, float &Y, float &Z);
  
  void LABtoXYZ(const float L, const float A, const float B, float &X, float &Y, float &Z);
  
  static bool findMaxL_LAB(float &L, const float a, const float b, const float minL = MIN_L, const float maxL = MAX_L, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMinL_LAB(float &L, const float a, const float b, const float minL = MIN_L, const float maxL = MAX_L, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMaxA_LAB(const float L, float &a, const float b, const float minA = MIN_A, const float maxA = MAX_A, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMinA_LAB(const float L, float &a, const float b, const float minA = MIN_A, const float maxA = MAX_A, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMaxB_LAB(const float L, const float a, float &b, const float minB = MIN_B, const float maxB = MAX_B, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMinB_LAB(const float L, const float a, float &b, const float minB = MIN_B, const float maxB = MAX_B, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  
  /*
    the following functions find max/min values with two variable values and one constant value
    for instance, findMaxL_LA_LAB() finds the maximum value of 'L' with a constant 'b' value
    maximum 'L' and corresponding 'a' returned
  */
  static bool findMaxL_LA_LAB(float &L, float &a, const float b,const float minL = MIN_L, const float maxL = MAX_L, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMinL_LA_LAB(float &L, float &a, const float b,const float minL = MIN_L, const float maxL = MAX_L, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMaxA_LA_LAB(float &L, float &a, const float b,const float minA = MIN_A, const float maxA = MAX_A, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMinA_LA_LAB(float &L, float &a, const float b,const float minA = MIN_A, const float maxA = MAX_A, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMaxL_LB_LAB(float &L, const float a, float &b,const float minL = MIN_L, const float maxL = MAX_L, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMinL_LB_LAB(float &L, const float a, float &b,const float minL = MIN_L, const float maxL = MAX_L, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMaxB_LB_LAB(float &L, const float a, float &b,const float minB = MIN_B, const float maxB = MAX_B, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMinB_LB_LAB(float &L, const float a, float &b,const float minB = MIN_B, const float maxB = MAX_B, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMaxA_AB_LAB(const float L, float &a, float &b,const float minA = MIN_A, const float maxA = MAX_A, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMinA_AB_LAB(const float L, float &a, float &b,const float minA = MIN_A, const float maxA = MAX_A, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMaxB_AB_LAB(const float L, float &a, float &b,const float minB = MIN_B, const float maxB = MAX_B, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  static bool findMinB_AB_LAB(const float L, float &a, float &b,const float minB = MIN_B, const float maxB = MAX_B, const float interval = INITIAL_INTERVAL, const bool recursiveSuccess = false);
  
  float* array() { return _col; };
  
  // color constants
  static const Color     black;
  static const Color     white;
  static const Color      grey;
  static const Color       red;
  static const Color     green;
  static const Color    yellow;
  static const Color      blue;
  static const Color   magenta;
  static const Color      cyan;
  static const Color      pink;
  static const Color     brown;
  static const Color       tan;
  static const Color    orange;
  static const Color firebrick;

  // matrices for converting to and from XYZ
  static const double RGBtoXYZarray[3][3];
  static const double XYZtoRGBarray[3][3];


  bool operator ==(const Color &c) const { 
    return (_col[0]==c._col[0] && _col[1]==c._col[1] && 
        _col[2]==c._col[2] && _col[3]==c._col[3]);
  }
  float  operator [](const int index)  const { return _col[index]; }
  float& operator [](const int index)        { return _col[index]; }

 protected:
  
  float _col[4];

  
  static double value(double n1, double n2, double hue);

  static inline double Labf(const double ratio);
  static inline double Labfinv(const double ratio);


};

inline ostream &
operator <<(ostream &os, const Color &c)
{ 
  return os << c[0] << " " << c[1] << " " << c[2] << " " << c[3];
}

inline istream &
operator >>(istream &is, Color &c)
{
  return is >> c[0] >> c[1] >> c[2] >> c[3];
}

} // namespace


#endif

/*
values attained by cycling through rgb values via floats, for more precision consider using doubles
The RGB interval was: 0.001953125
Min L: 0 Max L: 100
  Minimum: 
      R: 0 G: 0 B: 0
      L: 0 a: 0 b: 0
  Maximum 
      R: 1 G: 1 B: 1
      L: 100 a: -0.007732189260423183441162109375 b: 0.002583012916147708892822265625
Min A: -86.18717193603515625 Max A: 98.2308502197265625
  Minimum: 
      R: 0 G: 1 B: 0
      L: 87.7355194091796875 a: -86.18717193603515625 b: 83.1878509521484375
  Maximum 
      R: 1 G: 0 B: 1
      L: 60.32273101806640625 a: 98.2308502197265625 b: -60.82642364501953125
Min B: -107.85298919677734375 Max B: 94.485137939453125
  Minimum: 
      R: 0 G: 0 B: 1
      L: 32.300872802734375 a: 79.190826416015625 b: -107.85298919677734375
  Maximum 
      R: 1 G: 1 B: 0
      L: 97.13855743408203125 a: -21.5671787261962890625 b: 94.485137939453125
Min Chroma: 0 Max Chroma: 133.8037872314453125
  Minimum: 
      R: 0 G: 0 B: 0
      L: 0 a: 0 b: 0
  Maximum 
      R: 0 G: 0 B: 1
      L: 32.300872802734375 a: 79.190826416015625 b: -107.85298919677734375
Min Saturation: 0 Max Saturation: 20.370121002197265625
  Minimum: 
      R: 0 G: 0 B: 0
      L: 0 a: 0 b: 0
  Maximum 
      R: 0 G: 0 B: 0.005859375
      L: 0.382094204425811767578125 a: 2.6848618984222412109375 b: -7.305570125579833984375
*/

---