al_Color.hpp

#ifndef INCLUDE_AL_COLOR_HPP
#define INCLUDE_AL_COLOR_HPP
 
/*  Allocore --
  Multimedia / virtual environment application class library
 
  Copyright (C) 2009. AlloSphere Research Group, Media Arts & Technology, UCSB.
  Copyright (C) 2012. The Regents of the University of California.
  All rights reserved.
 
  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
 
    Redistributions of source code must retain the above copyright notice,
    this list of conditions and the following disclaimer.
 
    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.
 
    Neither the name of the University of California nor the names of its
    contributors may be used to endorse or promote products derived from
    this software without specific prior written permission.
 
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) 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.
 
 
  File description:
  RGBA, HSV, CIE_XYZ, Lab, HCLab, Luv, and HCLuv color classes
 
  Color conversion code for CIE_XYZ, Lab, HCLab, Luv, HCLuv was adapted from
  psuedo-code and formulas found at http://www.easyrgb.com/ and
  http://brucelindbloom.com/
 
  File author(s):
  Lance Putnam, 2010, putnam.lance@gmail.com
  Owen Campbell, 2014, owen.campbell@gmail.com
*/
 
#include <cstdint>  // uint8_t
 
namespace al {
 
struct RGB;
struct HSV;
struct Color;
struct Colori;
 
struct CIE_XYZ;
struct Lab;
struct HCLab;
struct Luv;
struct HCLuv;
 
struct Color {
  union {
    struct {
      float r;  
      float g;  
      float b;  
      float a;  
    };
    float components[4];  
  };
 
  Color(float r, float g, float b, float a = 1.f) : r(r), g(g), b(b), a(a) {}
 
  template <class T>
  Color(const T *rgba) : r(rgba[0]), g(rgba[1]), b(rgba[2]), a(rgba[3]) {}
 
  Color(float gray = 1.f, float a = 1.f) : r(gray), g(gray), b(gray), a(a) {}
 
  Color(const Colori &c) { *this = c; }
 
  Color(const HSV &hsv, float a = 1.f) : a(a) { *this = hsv; }
 
  Color(const RGB &rgb, float a = 1.f) : a(a) { *this = rgb; }
 
  Color(const CIE_XYZ &xyz, float a = 1.f) : a(a) { *this = xyz; }
 
  Color(const Lab &lab, float a = 1.f) : a(a) { *this = lab; }
 
  Color(const HCLab &hclab, float a = 1.f) : a(a) { *this = hclab; }
 
  Color(const Luv &luv, float a = 1.f) : a(a) { *this = luv; }
 
  Color(const HCLuv &hcluv, float a = 1.f) : a(a) { *this = hcluv; }
 
  float &operator[](int i) { return components[i]; }
 
  const float &operator[](int i) const { return components[i]; }
 
  RGB &rgb() { return *(RGB *)(components); }
  const RGB &rgb() const { return *(const RGB *)(components); }
 
  Color &set(const Color &c, float al) {
    a = al;
    return set(c.r, c.g, c.b);
  }
 
  Color &set(float re, float gr, float bl, float al) {
    a = al;
    return set(re, gr, bl);
  }
 
  Color &set(float re, float gr, float bl) {
    r = re;
    g = gr;
    b = bl;
    return *this;
  }
 
  Color &set(float v) { return set(v, v, v); }
 
  Color &set(float v, float al) { return set(v, v, v, al); }
 
  template <class T>
  Color &set(const T *rgba) {
    return set(rgba[0], rgba[1], rgba[2], rgba[3]);
  }
 
  Color &operator=(float v) { return set(v); }
  Color &operator=(double v) { return set(static_cast<float>(v)); }
 
  Color &operator=(const Colori &v);
 
  Color &operator=(const HSV &v);
 
  Color &operator=(const RGB &v);
 
  Color &operator=(const CIE_XYZ &v);
 
  Color &operator=(const Lab &v);
 
  Color &operator=(const HCLab &v);
 
  Color &operator=(const Luv &v);
 
  Color &operator=(const HCLuv &v);
 
  bool operator==(const Color &v) const {
    return v.r == r && v.g == g && v.b == b && v.a == a;
  }
 
  bool operator!=(const Color &v) const { return !(*this == v); }
 
  Color &operator+=(const Color &v) {
    return set(r + v.r, g + v.g, b + v.b, a + v.a);
  }
  Color &operator-=(const Color &v) {
    return set(r - v.r, g - v.g, b - v.b, a - v.a);
  }
  Color &operator*=(const Color &v) {
    return set(r * v.r, g * v.g, b * v.b, a * v.a);
  }
  Color &operator/=(const Color &v) {
    return set(r / v.r, g / v.g, b / v.b, a / v.a);
  }
  Color &operator+=(float v) { return set(r + v, g + v, b + v, a + v); }
  Color &operator-=(float v) { return set(r - v, g - v, b - v, a - v); }
  Color &operator*=(float v) { return set(r * v, g * v, b * v, a * v); }
  Color &operator/=(float v) { return set(r / v, g / v, b / v, a / v); }
 
  Color operator-() const { return Color(-r, -g, -b, -a); }
  Color operator+(const Color &v) const { return Color(*this) += v; }
  Color operator-(const Color &v) const { return Color(*this) -= v; }
  Color operator*(const Color &v) const { return Color(*this) *= v; }
  Color operator/(const Color &v) const { return Color(*this) /= v; }
  Color operator+(float v) const { return Color(*this) += v; }
  Color operator-(float v) const { return Color(*this) -= v; }
  Color operator*(float v) const { return Color(*this) *= v; }
  Color operator/(float v) const { return Color(*this) /= v; }
 
  Color &clamp(float max = 1.f) {
    for (int i = 0; i < 4; ++i) {
      float &v = components[i];
      v < 0.f ? v = 0.f : (v > max ? v = max : 0);
    }
    return *this;
  }
 
  Color inverse() const { return Color(*this).invert(); }
 
  Color &invert();
 
  float luminance() const;
 
  Color blackAndWhite() const;  
 
  Color mix(const Color &c, float amt = 0.5f) const {
    return (c - *this) * amt + *this;
  }
 
 private:
  float tof(uint8_t v) { return float(v) * (1.f / 255.f); }
};
 
 
struct Colori {
  union {
    struct {
      uint8_t r;  
      uint8_t g;  
      uint8_t b;  
      uint8_t a;  
    };
    uint8_t components[4];  
    uint32_t rgba;          
  };
 
  Colori(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255)
      : r(r), g(g), b(b), a(a) {}
 
  template <class T>
  Colori(const T *rgba) : r(rgba[0]), g(rgba[1]), b(rgba[2]), a(rgba[3]) {}
 
  Colori(uint8_t gray = 255, uint8_t a = 255)
      : r(gray), g(gray), b(gray), a(a) {}
 
  Colori(const Color &c) { *this = c; }
 
  Colori(const HSV &hsv, uint8_t a = 255) : a(a) { *this = hsv; }
 
  Colori(const RGB &rgb, uint8_t a = 255) : a(a) { *this = rgb; }
 
  Colori(const CIE_XYZ &xyz, float a = 1.f) : a(static_cast<uint8_t>(a * 255)) {
    *this = xyz;
  }
 
  Colori(const Lab &lab, float a = 1.f) : a(static_cast<uint8_t>(a * 255)) {
    *this = lab;
  }
 
  Colori(const HCLab &hclab, float a = 1.f) : a(static_cast<uint8_t>(a * 255)) {
    *this = hclab;
  }
 
  Colori(const Luv &luv, float a = 1.f) : a(static_cast<uint8_t>(a * 255)) {
    *this = luv;
  }
 
  Colori(const HCLuv &hcluv, float a = 1.f) : a(static_cast<uint8_t>(a * 255)) {
    *this = hcluv;
  }
 
  uint8_t &operator[](int i) { return components[i]; }
 
  const uint8_t &operator[](int i) const { return components[i]; }
 
  Colori &operator=(const Color &v) {
    return set(toi(v.r), toi(v.g), toi(v.b), toi(v.a));
  }
 
  Colori &operator=(const HSV &v);
 
  Colori &operator=(const RGB &v);
 
  Colori &operator=(const CIE_XYZ &v);
 
  Colori &operator=(const Lab &v);
 
  Colori &operator=(const HCLab &v);
 
  Colori &operator=(const Luv &v);
 
  Colori &operator=(const HCLuv &v);
 
  Colori &set(uint8_t re, uint8_t gr, uint8_t bl) {
    r = re;
    g = gr;
    b = bl;
    return *this;
  }
 
  Colori &set(uint8_t re, uint8_t gr, uint8_t bl, uint8_t al) {
    a = al;
    return set(re, gr, bl);
  }
 
  Colori &set(uint8_t v) { return set(v, v, v); }
 
  Colori &set(uint8_t v, uint8_t al) { return set(v, v, v, al); }
 
  Colori inverse() const { return Colori(*this).invert(); }
 
  Colori &invert() { return set(255 - r, 255 - g, 255 - b); }
 
 private:
  uint8_t toi(float v) { return uint8_t(v * 255.f); }
};
 
struct HSV {
  union {
    struct {
      float h;  
      float s;  
      float v;  
    };
    float components[3];  
  };
 
  HSV(float h = 0, float s = 1, float v = 1) : h(h), s(s), v(v) {}
 
  template <class T>
  HSV(const T *hsv) : h(hsv[0]), s(hsv[1]), v(hsv[2]) {}
 
  HSV(const Color &v) { *this = v; }
 
  HSV(const Colori &v) { *this = v; }
 
  HSV(const RGB &v) { *this = v; }
 
  HSV(const CIE_XYZ &xyz) { *this = xyz; }
 
  HSV(const Lab &lab) { *this = lab; }
 
  HSV(const HCLab &hclab) { *this = hclab; }
 
  HSV(const Luv &luv) { *this = luv; }
 
  HSV(const HCLuv &hcluv) { *this = hcluv; }
 
  float &operator[](int i) { return components[i]; }
 
  const float &operator[](int i) const { return components[i]; }
 
  HSV &operator=(const Color &v) { return *this = v.rgb(); }
 
  HSV &operator=(const Colori &v) { return *this = Color(v); }
 
  HSV &operator=(const RGB &v);
 
  HSV &operator=(const CIE_XYZ &v);
 
  HSV &operator=(const Lab &v);
 
  HSV &operator=(const HCLab &v);
 
  HSV &operator=(const Luv &v);
 
  HSV &operator=(const HCLuv &v);
 
  HSV operator*(float a) const { return HSV(*this) *= a; }
 
  HSV &operator*=(float a) {
    v *= a;
    return *this;
  }
 
  HSV &rotateHue(float dh) {
    h += dh;
    return wrapHue();
  }
 
  HSV &wrapHue() {
    if (h > 1) {
      h -= int(h);
    } else if (h < 0) {
      h -= int(h) - 1;
    }
    return *this;
  }
};
 
 
#ifdef RGB /* Windows related fix */
#undef RGB
#endif
struct RGB {
  union {
    struct {
      float r;  
      float g;  
      float b;  
    };
    float components[3];  
  };
 
  RGB(float r, float g, float b) : r(r), g(g), b(b) {}
 
  template <class T>
  RGB(const T *rgb) : r(rgb[0]), g(rgb[1]), b(rgb[2]) {}
 
  RGB(float gray = 1.f) : r(gray), g(gray), b(gray) {}
 
  RGB(const Color &v) { *this = v; }
 
  RGB(const Colori &v) { *this = v; }
 
  RGB(const HSV &hsv) { *this = hsv; }
 
  RGB(const CIE_XYZ &xyz) { *this = xyz; }
 
  RGB(const Lab &lab) { *this = lab; }
 
  RGB(const HCLab &hclab) { *this = hclab; }
 
  RGB(const Luv &luv) { *this = luv; }
 
  RGB(const HCLuv &hcluv) { *this = hcluv; }
 
  float &operator[](int i) { return components[i]; }
 
  const float &operator[](int i) const { return components[i]; }
 
  RGB &set(const RGB &v) { return set(v.r, v.g, v.b); }
 
  RGB &set(float re, float gr, float bl) {
    r = re;
    g = gr;
    b = bl;
    return *this;
  }
 
  RGB &set(float v) { return set(v, v, v); }
 
  template <class T>
  RGB &set(const T *rgb) {
    return set(rgb[0], rgb[1], rgb[2]);
  }
 
  RGB &operator=(float v) { return set(v); }
  RGB &operator=(double v) { return set(static_cast<float>(v)); }
 
  RGB &operator=(const HSV &v);
 
  RGB &operator=(const Color &v) { return set(v.rgb()); }
 
  RGB &operator=(const Colori &v);
 
  RGB &operator=(const CIE_XYZ &v);
 
  RGB &operator=(const Lab &v);
 
  RGB &operator=(const HCLab &v);
 
  RGB &operator=(const Luv &v);
 
  RGB &operator=(const HCLuv &v);
 
  bool operator==(const RGB &v) const {
    return v.r == r && v.g == g && v.b == b;
  }
 
  bool operator!=(const RGB &v) const { return !(*this == v); }
 
  RGB &operator+=(const RGB &v) { return set(r + v.r, g + v.g, b + v.b); }
  RGB &operator-=(const RGB &v) { return set(r - v.r, g - v.g, b - v.b); }
  RGB &operator*=(const RGB &v) { return set(r * v.r, g * v.g, b * v.b); }
  RGB &operator/=(const RGB &v) { return set(r / v.r, g / v.g, b / v.b); }
  RGB &operator+=(float v) { return set(r + v, g + v, b + v); }
  RGB &operator-=(float v) { return set(r - v, g - v, b - v); }
  RGB &operator*=(float v) { return set(r * v, g * v, b * v); }
  RGB &operator/=(float v) { return set(r / v, g / v, b / v); }
 
  RGB operator-() const { return RGB(-r, -g, -b); }
  RGB operator+(const RGB &v) const { return RGB(*this) += v; }
  RGB operator-(const RGB &v) const { return RGB(*this) -= v; }
  RGB operator*(const RGB &v) const { return RGB(*this) *= v; }
  RGB operator/(const RGB &v) const { return RGB(*this) /= v; }
  RGB operator+(float v) const { return RGB(*this) += v; }
  RGB operator-(float v) const { return RGB(*this) -= v; }
  RGB operator*(float v) const { return RGB(*this) *= v; }
  RGB operator/(float v) const { return RGB(*this) /= v; }
 
  RGB &clamp(float max = 1.f) {
    for (int i = 0; i < 3; ++i) {
      float &v = components[i];
      v < 0.f ? v = 0.f : (v > max ? v = max : 0);
    }
    return *this;
  }
 
  RGB inverse() const { return RGB(*this).invert(); }
 
  RGB &invert() { return set(1.f - r, 1.f - g, 1.f - b); }
 
  float luminance() const { return r * 0.299f + g * 0.587f + b * 0.114f; }
 
  RGB mix(const RGB &v, float amt = 0.5f) const {
    return (v - *this) * amt + *this;
  }
};
 
struct CIE_XYZ {
  union {
    struct {
      float x;  
      float y;  
      float z;  
    };
    float components[3];  
  };
 
  CIE_XYZ(float x = 0, float y = 1, float z = 1) : x(x), y(y), z(z) {}
 
  template <class T>
  CIE_XYZ(const T *xyz) : x(xyz[0]), y(xyz[1]), z(xyz[2]) {}
 
  CIE_XYZ(const Color &v) { *this = v; }
 
  CIE_XYZ(const Colori &v) { *this = v; }
 
  CIE_XYZ(const RGB &v) { *this = v; }
 
  CIE_XYZ(const HSV &v) { *this = v; }
 
  CIE_XYZ(const Lab &v) { *this = v; }
 
  CIE_XYZ(const Luv &v) { *this = v; }
 
  float &operator[](int i) { return components[i]; }
 
  const float &operator[](int i) const { return components[i]; }
 
  CIE_XYZ &operator=(const Color &v) { return *this = v.rgb(); }
 
  CIE_XYZ &operator=(const Colori &v) { return *this = Color(v); }
 
  CIE_XYZ &operator=(const RGB &v);
 
  CIE_XYZ &operator=(const HSV &v) { return *this = RGB(v); }
 
  CIE_XYZ &operator=(const Lab &v);
 
  CIE_XYZ &operator=(const Luv &v);
};
 
struct Lab {
  union {
    struct {
      float l;  
      float a;  
      float b;  
    };
    float components[3];  
  };
 
  Lab(float l = 1, float a = 1, float b = 1) : l(l), a(a), b(b) {}
 
  template <class T>
  Lab(const T *Lab) : l(Lab[0]), a(Lab[1]), b(Lab[2]) {}
 
  Lab(const Color &v) { *this = v; }
 
  Lab(const Colori &v) { *this = v; }
 
  Lab(const RGB &v) { *this = v; }
 
  Lab(const HSV &v) { *this = v; }
 
  Lab(const CIE_XYZ &v) { *this = v; }
 
  Lab(const HCLab &v) { *this = v; }
 
  float &operator[](int i) { return components[i]; }
 
  const float &operator[](int i) const { return components[i]; }
 
  Lab &operator=(const Color &v) { return *this = v.rgb(); }
 
  Lab &operator=(const Colori &v) { return *this = Color(v); }
 
  Lab &operator=(const CIE_XYZ &v);
 
  Lab &operator=(const RGB &v) { return *this = CIE_XYZ(v); }
 
  Lab &operator=(const HSV &v) { return *this = CIE_XYZ(v); }
 
  Lab &operator=(const HCLab &v);
 
  Lab operator*(float c) const { return Lab(*this) *= c; }
 
  Lab &operator*=(float c) {
    l *= c;
    return *this;
  }
};
 
struct HCLab {
  union {
    struct {
      float h;  
      float c;  
      float l;  
    };
    float components[3];  
  };
 
  HCLab(float h = 1, float c = 1, float l = 1) : h(h), c(c), l(l) {}
 
  template <class T>
  HCLab(const T *HCLab) : h(HCLab[0]), c(HCLab[1]), l(HCLab[2]) {}
 
  HCLab(const Color &v) { *this = v; }
 
  HCLab(const Colori &v) { *this = v; }
 
  HCLab(const RGB &v) { *this = v; }
 
  HCLab(const HSV &v) { *this = v; }
 
  HCLab(const CIE_XYZ &v) { *this = v; }
 
  HCLab(const Lab &v) { *this = v; }
 
  float &operator[](int i) { return components[i]; }
 
  const float &operator[](int i) const { return components[i]; }
 
  HCLab &operator=(const Color &v) { return *this = v.rgb(); }
 
  HCLab &operator=(const Colori &v) { return *this = Color(v); }
 
  HCLab &operator=(const RGB &v) { return *this = Lab(v); }
 
  HCLab &operator=(const HSV &v) { return *this = Lab(v); }
 
  HCLab &operator=(const CIE_XYZ &v) { return *this = Lab(v); }
 
  HCLab &operator=(const Lab &v);
 
  HCLab operator*(float a) const { return HCLab(*this) *= a; }
 
  HCLab &operator*=(float a) {
    l *= a;
    return *this;
  }
 
  HCLab &rotateHue(float dh) {
    h += dh;
    return wrapHue();
  }
 
  HCLab &wrapHue() {
    if (h > 1) {
      h -= int(h);
    } else if (h < 0) {
      h -= int(h) - 1;
    }
    return *this;
  }
};
 
struct Luv {
  union {
    struct {
      float l;  
      float u;  
      float v;  
    };
    float components[3];  
  };
 
  Luv(float l = 1, float u = 1, float v = 1) : l(l), u(u), v(v) {}
 
  template <class T>
  Luv(const T *Luv) : l(Luv[0]), u(Luv[1]), v(Luv[2]) {}
 
  Luv(const Color &w) { *this = w; }
 
  Luv(const Colori &w) { *this = w; }
 
  Luv(const RGB &w) { *this = w; }
 
  Luv(const HSV &w) { *this = w; }
 
  Luv(const CIE_XYZ &w) { *this = w; }
 
  Luv(const HCLuv &w) { *this = w; }
 
  float &operator[](int i) { return components[i]; }
 
  const float &operator[](int i) const { return components[i]; }
 
  Luv &operator=(const Color &w) { return *this = w.rgb(); }
 
  Luv &operator=(const Colori &w) { return *this = Color(w); }
 
  Luv &operator=(const CIE_XYZ &w);
 
  Luv &operator=(const HCLuv &w);
 
  Luv &operator=(const RGB &w) { return *this = CIE_XYZ(w); }
 
  Luv &operator=(const HSV &w) { return *this = CIE_XYZ(w); }
 
  Luv operator*(float a) const { return Luv(*this) *= a; }
 
  Luv &operator*=(float a) {
    l *= a;
    return *this;
  }
};
 
struct HCLuv {
  union {
    struct {
      // ranges normalized to 8-bit RGB gamut using
      // 16million RGB color image from http://brucelindbloom.com
      float h;  
      float c;  
      float l;  
    };
    float components[3];  
  };
 
  HCLuv(float h = 1, float c = 1, float l = 1) : h(h), c(c), l(l) {}
 
  template <class T>
  HCLuv(const T *HCLuv) : h(HCLuv[0]), c(HCLuv[1]), l(HCLuv[2]) {}
 
  HCLuv(const Color &w) { *this = w; }
 
  HCLuv(const Colori &w) { *this = w; }
 
  HCLuv(const RGB &w) { *this = w; }
 
  HCLuv(const HSV &w) { *this = w; }
 
  HCLuv(const CIE_XYZ &w) { *this = w; }
 
  HCLuv(const Luv &w) { *this = w; }
 
  float &operator[](int i) { return components[i]; }
 
  const float &operator[](int i) const { return components[i]; }
 
  HCLuv &operator=(const Color &w) { return *this = w.rgb(); }
 
  HCLuv &operator=(const Colori &w) { return *this = Color(w); }
 
  HCLuv &operator=(const RGB &w) { return *this = Luv(w); }
 
  HCLuv &operator=(const HSV &w) { return *this = Luv(w); }
 
  HCLuv &operator=(const CIE_XYZ &w) { return *this = Luv(w); }
 
  HCLuv &operator=(const Luv &w);
 
  HCLuv operator*(float a) const { return HCLuv(*this) *= a; }
 
  HCLuv &operator*=(float a) {
    l *= a;
    return *this;
  }
 
  HCLuv &rotateHue(float dh) {
    h += dh;
    return wrapHue();
  }
 
  HCLuv &wrapHue() {
    if (h > 1) {
      h -= int(h);
    } else if (h < 0) {
      h -= int(h) - 1;
    }
    return *this;
  }
};
 
// Implementation --------------------------------------------------------------
 
inline RGB operator+(float s, const RGB &c) { return c + s; }
inline RGB operator-(float s, const RGB &c) { return -c + s; }
inline RGB operator*(float s, const RGB &c) { return c * s; }
inline RGB operator/(float s, const RGB &c) {
  return RGB(s / c.r, s / c.g, s / c.b);
}
 
inline RGB &RGB::operator=(const Colori &v) {
  return set(float(v.r) / 255.f, float(v.g) / 255.f, float(v.b) / 255.f);
}
 
inline Color operator+(float s, const Color &c) { return c + s; }
inline Color operator-(float s, const Color &c) { return -c + s; }
inline Color operator*(float s, const Color &c) { return c * s; }
inline Color operator/(float s, const Color &c) {
  return Color(s / c.r, s / c.g, s / c.b, s / c.a);
}
 
inline Color &Color::operator=(const Colori &v) {
  r = tof(v.r);
  g = tof(v.g);
  b = tof(v.b);
  a = tof(v.a);
  return *this;
}
 
inline Color &Color::operator=(const HSV &v) {
  rgb() = v;
  return *this;
}
inline Color &Color::operator=(const RGB &v) {
  rgb() = v;
  return *this;
}
 
inline Color &Color::invert() {
  rgb().invert();
  return *this;
}
 
inline float Color::luminance() const { return rgb().luminance(); }
 
inline Color Color::blackAndWhite() const {
  return Color(luminance() > 0.5f ? 1.f : 0.f);
}
 
inline Colori &Colori::operator=(const HSV &v) { return *this = RGB(v); }
 
inline Colori &Colori::operator=(const RGB &v) {
  return set(toi(v.r), toi(v.g), toi(v.b), 255);
}
 
inline HSV operator*(float s, const HSV &c) { return c * s; }
 
}  // namespace al
 
#endif