LumiverseColor.h

Go to the documentation of this file.

#ifndef _LUMIVERSECOLOR_H_
#define _LUMIVERSECOLOR_H_
#pragma once

#include <map>
#include <unordered_map>
#include <cmath>
#include <mutex>
#include <memory>
#include <float.h>
#include "lib/Eigen/Dense"
#include "../LumiverseType.h"
#include "LumiverseColorLib.h"

using namespace std;

namespace Lumiverse {
  enum ColorMode {
    ADDITIVE,    
    SUBTRACTIVE, 
    BASIC_RGB,   
    BASIC_CMY    
  };

#ifdef USE_C11_MAPS

  static unordered_map<int, string> ColorModeToString =
  {
    { ADDITIVE, "ADDITIVE" }, { SUBTRACTIVE, "SUBTRACTIVE" },
    { BASIC_RGB, "BASIC_RGB" }, { BASIC_CMY, "BASIC_CMY" }
  };

  static unordered_map<string, ColorMode> StringToColorMode =
  {
    { "ADDITIVE", ADDITIVE }, { "SUBTRACTIVE", SUBTRACTIVE },
    { "BASIC_RGB", BASIC_RGB }, { "BASIC_CMY", BASIC_CMY }
  };
#else
  static string ColorModeToString(ColorMode m) {
    unordered_map<int, string> ColorModeToString;
    ColorModeToString[ADDITIVE] = "ADDITIVE";
    ColorModeToString[SUBTRACTIVE] = "SUBTRACTIVE";
    ColorModeToString[BASIC_RGB] = "BASIC_RGB";
    ColorModeToString[BASIC_CMY] = "BASIC_CMY";

    return ColorModeToString[m];
  }

  static ColorMode StringToColorMode(string s) {
    unordered_map<string, ColorMode> StringToColorMode;
    StringToColorMode["ADDITIVE"] = ADDITIVE;
    StringToColorMode["SUBTRACTIVE"] = SUBTRACTIVE;
    StringToColorMode["BASIC_RGB"] = BASIC_RGB;
    StringToColorMode["BASIC_CMY"] = BASIC_CMY;

    return StringToColorMode[s];  
  }
#endif

  class LumiverseColor : public LumiverseType {
  public:
    LumiverseColor(ColorMode mode = ADDITIVE);

    LumiverseColor(map<string, Eigen::Vector3d> basis, ColorMode mode = ADDITIVE);

    LumiverseColor(unordered_map<string, double> params, map<string, Eigen::Vector3d> basis, ColorMode mode, double weight);

    LumiverseColor(LumiverseType* other);

    LumiverseColor(LumiverseColor* other);

    LumiverseColor(const LumiverseColor& other);

    virtual ~LumiverseColor();

    virtual string getTypeName() { return "color"; }

    virtual void reset();

    virtual JSONNode toJSON(string name);

    virtual string asString();

    double getX();

    double getY();

    double getZ();

    Eigen::Vector3d getXYZ() { return Eigen::Vector3d(getX(), getY(), getZ()); }

    double getx();

    double gety();

    double getz();

    void setRGB(double r, double g, double b, double weight = 1.0, RGBColorSpace cs = sRGB);

    Eigen::Vector3d getRGB(RGBColorSpace cs = sRGB);


    void setxy(double x, double y, double weight = 1.0);

    Eigen::Vector3d getxyY();

    Eigen::Vector3d getLab(ReferenceWhite refWhite);

    Eigen::Vector3d getLab(Eigen::Vector3d refWhite);

    Eigen::Vector3d getLCHab(ReferenceWhite refWhite);

    Eigen::Vector3d getLCHab(Eigen::Vector3d refWhite);

    Eigen::Vector2d getupvp();

    Eigen::Vector2d getuv();

    Eigen::Vector3d getHSV(RGBColorSpace cs = sRGB);

    Eigen::Vector2d getCCT();

    bool addColorChannel(string name);

    bool deleteColorChannel(string name);

    bool setColorChannel(string name, double val);

    double getColorChannel(string name) { return m_deviceChannels[name] * m_weight; }
      
    double& operator[](string name);

    void setWeight(double weight);

    bool setRGBRaw(double r, double g, double b, double weight = 1.0);

    bool setHSV(double H, double S, double V, double weight = 1.0);

    unordered_map<string, double> getColorParams() { return m_deviceChannels; }

    double getWeight() { return m_weight; }

    // Arithmetic overrides
    void operator=(LumiverseColor& other);

    LumiverseColor& operator+=(double val);            

    LumiverseColor& operator-=(double val);

    LumiverseColor& operator*=(double val);
    
    LumiverseColor& operator/=(double val);

    shared_ptr<LumiverseType> lerp(LumiverseColor* rhs, float t);

    bool isEqual(LumiverseColor& other);

    int cmpHue(LumiverseColor& other, ReferenceWhite refWhite = D65);

    virtual bool isDefault();

    void changeMode(ColorMode newMode);

    ColorMode getMode() { return m_mode; }

    void setBasisVector(string channel, double x, double y, double z);

    void removeBasisVector(string channel);

    Eigen::Vector3d getBasisVector(string channel);

    const map<string, Eigen::Vector3d>& getBasisVectors() { return m_basisVectors; }

    size_t numBasisVectors() { return m_basisVectors.size(); }

  private:
    double m_weight;

    ColorMode m_mode;

    mutex m_mapMutex;

    unordered_map<string, double> m_deviceChannels;

    map<string, Eigen::Vector3d> m_basisVectors;

    bool m_XYZupdated;

    Eigen::Vector3d m_XYZ;

    void initMode();

    double sumComponent(int i);

    Eigen::Vector3d RGBtoXYZ(double r, double g, double b, RGBColorSpace cs);

    void matchChroma(double x, double y, double weight = 1.0);

    void updateXYZ();

    inline bool doubleEq(double a, double b) {
      return (abs(a - b) < DBL_EPSILON);
    }
  };

  // Operators time!
  inline bool operator==(LumiverseColor& a, LumiverseColor& b) {
    if (a.getTypeName() != "color" || b.getTypeName() != "color")
      return false;

    return a.isEqual(b);
  }
}

#endif