colors.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <string>
 
namespace qualpal {
 
enum class WhitePoint
{
  D65, 
  D50, 
  D55, 
  A,   
  E    
};
 
std::array<double, 3>
whitePointToXYZ(WhitePoint wp);
 
namespace colors {
 
// forward declarations
class HSL;
class XYZ;
class Lab;
class DIN99d;
class LCHab;
 
class RGB
{
private:
  double r_value;
  double g_value;
  double b_value;
 
public:
  RGB();
 
  RGB(const double r, const double g, const double b);
 
  RGB(const std::array<double, 3> rgb);
 
  RGB(const std::string& hex);
 
  RGB(const char* hex)
    : RGB(std::string(hex)) {};
 
  RGB(const HSL& hsl);
 
  RGB(const XYZ& xyz);
 
  RGB(const Lab& lab);
 
  RGB(const LCHab& lch);
 
  bool operator==(const RGB& other) const
  {
    return (r_value == other.r_value) && (g_value == other.g_value) &&
           (b_value == other.b_value);
  }
 
  bool operator!=(const RGB& other) const { return !(*this == other); }
 
  std::string hex() const;
 
  double r() const { return r_value; }
  double g() const { return g_value; }
  double b() const { return b_value; }
};
 
class HSL
{
private:
  double h_value;
  double s_value;
  double l_value;
 
public:
  HSL();
 
  HSL(const double h, const double s, const double l);
 
  HSL(const RGB& rgb);
 
  HSL(const XYZ& xyz);
 
  HSL(const Lab& lab);
 
  HSL(const LCHab& lch);
 
  bool operator==(const HSL& other) const
  {
    return (h_value == other.h_value) && (s_value == other.s_value) &&
           (l_value == other.l_value);
  }
 
  bool operator!=(const HSL& other) const { return !(*this == other); }
 
  double h() const { return h_value; }
  double s() const { return s_value; }
  double l() const { return l_value; }
};
 
class XYZ
{
private:
  double x_value;
  double y_value;
  double z_value;
 
public:
  XYZ();
 
  XYZ(const double x, const double y, const double z);
 
  XYZ(const RGB& rgb);
 
  XYZ(const Lab& lab,
      const std::array<double, 3>& white_point = { 0.95047, 1, 1.08883 });
 
  XYZ(const HSL& hsl);
 
  XYZ(const LCHab& lch,
      const std::array<double, 3>& white_point = { 0.95047, 1, 1.08883 });
 
  bool operator==(const XYZ& other) const
  {
    return (x_value == other.x_value) && (y_value == other.y_value) &&
           (z_value == other.z_value);
  }
 
  bool operator!=(const XYZ& other) const { return !(*this == other); }
 
  double x() const { return x_value; }
  double y() const { return y_value; }
  double z() const { return z_value; }
};
 
class DIN99d
{
private:
  double l_value;
  double a_value;
  double b_value;
 
public:
  DIN99d();
 
  DIN99d(const double l, const double a, const double b);
 
  DIN99d(const RGB& rgb);
 
  DIN99d(const HSL& hsl);
 
  DIN99d(const Lab& lab);
 
  DIN99d(const XYZ& xyz,
         const std::array<double, 3>& white_point = { 0.95047, 1, 1.08883 });
 
  bool operator==(const DIN99d& other) const
  {
    return (l_value == other.l_value) && (a_value == other.a_value) &&
           (b_value == other.b_value);
  }
 
  bool operator!=(const DIN99d& other) const { return !(*this == other); }
 
  double l() const { return l_value; }
  double a() const { return a_value; }
  double b() const { return b_value; }
};
 
class Lab
{
private:
  double l_value;
  double a_value;
  double b_value;
 
public:
  Lab();
 
  Lab(const double l, const double a, const double b);
 
  Lab(const RGB& rgb);
 
  Lab(const HSL& hsl);
 
  Lab(const XYZ& xyz,
      const std::array<double, 3>& white_point = { 0.95047, 1, 1.08883 });
 
  Lab(const LCHab& lch);
 
  bool operator==(const Lab& other) const
  {
    return (l_value == other.l_value) && (a_value == other.a_value) &&
           (b_value == other.b_value);
  }
 
  double l() const { return l_value; }
  double a() const { return a_value; }
  double b() const { return b_value; }
};
 
class LCHab
{
private:
  double l_value;
  double c_value;
  double h_value;
 
public:
  LCHab();
 
  LCHab(const double l, const double c, const double h);
 
  LCHab(const Lab& lab);
 
  LCHab(const RGB& rgb);
 
  LCHab(const HSL& hsl);
 
  LCHab(const XYZ& xyz,
        const std::array<double, 3>& white_point = { 0.95047, 1, 1.08883 });
 
  bool operator==(const LCHab& other) const
  {
    return (l_value == other.l_value) && (c_value == other.c_value) &&
           (h_value == other.h_value);
  }
 
  bool operator!=(const LCHab& other) const { return !(*this == other); }
 
  double l() const { return l_value; }
  double c() const { return c_value; }
  double h() const { return h_value; }
};
 
} // namespace colors
} // namespace qualpal