Color.h

Go to the documentation of this file.

#ifndef COLOR_H
#define COLOR_H
 
#include <iostream> //cerr
#include <array> //array
#include <regex> //regex
#include <unordered_map> //unordered_map
#include <cmath> //log
 
#include <sstream>
#include <iomanip>
 
#include "DataStructure.h" //string, using std
#include <JSONutil.h>
 
namespace bridges {
    namespace datastructure {
        class Color {
            private:
                // The named colors' rgba channel value mappings
                static const unordered_map<string, const array<int, 4 >> &
                ColorNames() {
                    static unordered_map<string, const array<int, 4 >> cn {
 
                        {   {"aliceblue", {{240, 248, 255, 255}}},
                            {"antiquewhite", {{250, 235, 215, 255}}},
                            {"cyan", {{0, 255, 255, 255}}},
                            {"aquamarine", {{127, 255, 212, 255}}},
                            {"azure", {{240, 255, 255, 255}}},
                            {"beige", {{245, 245, 220, 255}}},
                            {"bisque", {{255, 228, 196, 255}}},
                            {"black", {{0, 0, 0, 255}}},
                            {"blanchedalmond", {{255, 235, 205, 255}}},
                            {"blue", {{0, 0, 255, 255}}},
                            {"blueviolet", {{138, 43, 226, 255}}},
                            {"brown", {{165, 42, 42, 255}}},
                            {"burlywood", {{222, 184, 135, 255}}},
                            {"cadetblue", {{95, 158, 160, 255}}},
                            {"chartreuse", {{127, 255, 0, 255}}},
                            {"chocolate", {{210, 105, 30, 255}}},
                            {"coral", {{255, 127, 80, 255}}},
                            {"cornflowerblue", {{100, 149, 237, 255}}},
                            {"cornsilk", {{255, 248, 220, 255}}},
                            {"crimson", {{220, 20, 60, 255}}},
                            {"darkblue", {{0, 0, 139, 255}}},
                            {"darkcyan", {{0, 139, 139, 255}}},
                            {"darkgoldenrod", {{184, 134, 11, 255}}},
                            {"darkgrey", {{169, 169, 169, 255}}},
                            {"darkgreen", {{0, 100, 0, 255}}},
                            {"darkkhaki", {{189, 183, 107, 255}}},
                            {"darkmagenta", {{139, 0, 139, 255}}},
                            {"darkolivegreen", {{85, 107, 47, 255}}},
                            {"darkorange", {{255, 140, 0, 255}}},
                            {"darkorchid", {{153, 50, 204, 255}}},
                            {"darkred", {{139, 0, 0, 255}}},
                            {"darksalmon", {{233, 150, 122, 255}}},
                            {"darkseagreen", {{143, 188, 143, 255}}},
                            {"darkslateblue", {{72, 61, 139, 255}}},
                            {"darkslategrey", {{47, 79, 79, 255}}},
                            {"darkturquoise", {{0, 206, 209, 255}}},
                            {"darkviolet", {{148, 0, 211, 255}}},
                            {"deeppink", {{255, 20, 147, 255}}},
                            {"deepskyblue", {{0, 191, 255, 255}}},
                            {"dimgrey", {{105, 105, 105, 255}}},
                            {"dodgerblue", {{30, 144, 255, 255}}},
                            {"firebrick", {{178, 34, 34, 255}}},
                            {"floralwhite", {{255, 250, 240, 255}}},
                            {"forestgreen", {{34, 139, 34, 255}}},
                            {"magenta", {{255, 0, 255, 255}}},
                            {"gainsboro", {{220, 220, 220, 255}}},
                            {"ghostwhite", {{248, 248, 255, 255}}},
                            {"gold", {{255, 215, 0, 255}}},
                            {"goldenrod", {{218, 165, 32, 255}}},
                            {"grey", {{128, 128, 128, 255}}},
                            {"green", {{0, 128, 0, 255}}},
                            {"greenyellow", {{173, 255, 47, 255}}},
                            {"honeydew", {{240, 255, 240, 255}}},
                            {"hotpink", {{255, 105, 180, 255}}},
                            {"indianred", {{205, 92, 92, 255}}},
                            {"indigo", {{75, 0, 130, 255}}},
                            {"ivory", {{255, 255, 240, 255}}},
                            {"khaki", {{240, 230, 140, 255}}},
                            {"lavender", {{230, 230, 250, 255}}},
                            {"lavenderblush", {{255, 240, 245, 255}}},
                            {"lawngreen", {{124, 252, 0, 255}}},
                            {"lemonchiffon", {{255, 250, 205, 255}}},
                            {"lightblue", {{173, 216, 230, 255}}},
                            {"lightcoral", {{240, 128, 128, 255}}},
                            {"lightcyan", {{224, 255, 255, 255}}},
                            {"lightgoldenrodyellow", {{250, 250, 210, 255}}},
                            {"lightgrey", {{211, 211, 211, 255}}},
                            {"lightgreen", {{144, 238, 144, 255}}},
                            {"lightpink", {{255, 182, 193, 255}}},
                            {"lightsalmon", {{255, 160, 122, 255}}},
                            {"lightseagreen", {{32, 178, 170, 255}}},
                            {"lightskyblue", {{135, 206, 250, 255}}},
                            {"lightslategrey", {{119, 136, 153, 255}}},
                            {"lightsteelblue", {{176, 196, 222, 255}}},
                            {"lightyellow", {{255, 255, 224, 255}}},
                            {"lime", {{0, 255, 0, 255}}},
                            {"limegreen", {{50, 205, 50, 255}}},
                            {"linen", {{250, 240, 230, 255}}},
                            {"maroon", {{128, 0, 0, 255}}},
                            {"mediumaquamarine", {{102, 205, 170, 255}}},
                            {"mediumblue", {{0, 0, 205, 255}}},
                            {"mediumorchid", {{186, 85, 211, 255}}},
                            {"mediumpurple", {{147, 112, 219, 255}}},
                            {"mediumseagreen", {{60, 179, 113, 255}}},
                            {"mediumslateblue", {{123, 104, 238, 255}}},
                            {"mediumspringgreen", {{0, 250, 154, 255}}},
                            {"mediumturquoise", {{72, 209, 204, 255}}},
                            {"mediumvioletred", {{199, 21, 133, 255}}},
                            {"midnightblue", {{25, 25, 112, 255}}},
                            {"mintcream", {{245, 255, 250, 255}}},
                            {"mistyrose", {{255, 228, 225, 255}}},
                            {"moccasin", {{255, 228, 181, 255}}},
                            {"navajowhite", {{255, 222, 173, 255}}},
                            {"navy", {{0, 0, 128, 255}}},
                            {"oldlace", {{253, 245, 230, 255}}},
                            {"olive", {{128, 128, 0, 255}}},
                            {"olivedrab", {{107, 142, 35, 255}}},
                            {"orange", {{255, 165, 0, 255}}},
                            {"orangered", {{255, 69, 0, 255}}},
                            {"orchid", {{218, 112, 214, 255}}},
                            {"palegoldenrod", {{238, 232, 170, 255}}},
                            {"palegreen", {{152, 251, 152, 255}}},
                            {"paleturquoise", {{175, 238, 238, 255}}},
                            {"palevioletred", {{219, 112, 147, 255}}},
                            {"papayawhip", {{255, 239, 213, 255}}},
                            {"peachpuff", {{255, 218, 185, 255}}},
                            {"peru", {{205, 133, 63, 255}}},
                            {"pink", {{255, 192, 203, 255}}},
                            {"plum", {{221, 160, 221, 255}}},
                            {"powderblue", {{176, 224, 230, 255}}},
                            {"purple", {{128, 0, 128, 255}}},
                            {"red", {{255, 0, 0, 255}}},
                            {"rosybrown", {{188, 143, 143, 255}}},
                            {"royalblue", {{65, 105, 225, 255}}},
                            {"saddlebrown", {{139, 69, 19, 255}}},
                            {"salmon", {{250, 128, 114, 255}}},
                            {"sandybrown", {{244, 164, 96, 255}}},
                            {"seagreen", {{46, 139, 87, 255}}},
                            {"seashell", {{255, 245, 238, 255}}},
                            {"sienna", {{160, 82, 45, 255}}},
                            {"silver", {{192, 192, 192, 255}}},
                            {"skyblue", {{135, 206, 235, 255}}},
                            {"slateblue", {{106, 90, 205, 255}}},
                            {"slategrey", {{112, 128, 144, 255}}},
                            {"snow", {{255, 250, 250, 255}}},
                            {"springgreen", {{0, 255, 127, 255}}},
                            {"steelblue", {{70, 130, 180, 255}}},
                            {"tan", {{210, 180, 140, 255}}},
                            {"teal", {{0, 128, 128, 255}}},
                            {"thistle", {{216, 191, 216, 255}}},
                            {"tomato", {{255, 99, 71, 255}}},
                            {"turquoise", {{64, 224, 208, 255}}},
                            {"violet", {{238, 130, 238, 255}}},
                            {"wheat", {{245, 222, 179, 255}}},
                            {"white", {{255, 255, 255, 255}}},
                            {"whitesmoke", {{245, 245, 245, 255}}},
                            {"yellow", {{255, 255, 0, 255}}},
                            {"yellowgreen", {{154, 205, 50, 255}}}
                        }
                    };
                    return cn;
                }
 
                // The rgba channel values of this Color
                array<int, 4> channels{{255, 255, 255, 255}};
            public:
                Color() {
                    setRed(0);
                    setGreen(0);
                    setBlue(0);
                    setAlpha(255);
                }
                Color(const int r, const int g, const int b, const int a = 255) {
                    setValue(r, g, b, a);
                }
                Color(const string& name) {
                    setValue(name);
                }
                bool operator==(const Color& that) const {
                    return channels == that.channels;
                }
                bool operator!=(const Color& that) const {
                    return channels != that.channels;
                }
                bool isOpaque()  const {
                    return getAlpha() == 255;
                }
                bool isTransparent() const {
                    return getAlpha() == 0;
                }
 
                int getRed() const {
                    return channels.at(0);
                }
                int getGreen() const {
                    return channels.at(1);
                }
                int getBlue()  const {
                    return channels.at(2);
                }
                int getAlpha() const {
                    return channels.at(3);
                }
 
                string getHexValue() const {
                    std::stringstream ss;
                    ss << "#";
                    ss << std::hex << std::setfill('0') << std::setw(2) << getRed();
                    ss << std::hex << std::setfill('0') << std::setw(2) << getGreen();
                    ss << std::hex << std::setfill('0') << std::setw(2) << getBlue();
                    ss << std::hex << std::setfill('0') << std::setw(2) << getAlpha();
 
                    return ss.str();
                }
                void setRed(int r) {
                    setChannel(r, 0);
                }
                void setGreen(int g) {
                    setChannel(g, 1);
                }
                void setBlue(int b) {
                    setChannel(b, 2);
                }
                void setAlpha(int a) {
                    setChannel(a, 3);
                }
 
                void setValue(int r, int g, int b, int a = 255) {
                    setRed(r);
                    setGreen(g);
                    setBlue(b);
                    setAlpha(a);
                }
                void setValue(string name) {
                    //marking static to avoid rebuilding the regexp every time.
                    //greedy, so checks for 8(RRGGBBAA), then 6(RRGGBB) then 4(RGBA) then 3(RGB)
                    static const regex HEX_RANGE("^#([[:xdigit:]]{8}|[[:xdigit:]]{6}|[[:xdigit:]]{3,4})$");
 
                    for (char& c : name) {
                        c = (char) tolower((unsigned char)c);   //convert to lowercase
                    }
                    auto it = ColorNames().find(name);
 
                    if (it != ColorNames().end()) {
                        channels = it->second;   //Named value
                    }
                    else if (regex_match(name, HEX_RANGE)) { //#Hex value
                        name.erase(0, 1); //removes "#"
                        // alpha value, overwritten if present by loop number
                        // of chars representing a channel
                        channels.at(3) = 255;
                        const int chanChars = (name.size() == 3 || name.size() == 4) ? 1 : 2;
                        //unit place scale factor, handles channel size variance
                        const int chanMultiplier = (chanChars == 1) ? 17 : 1;
                        for (size_t i = 0; i < name.size() / chanChars; i++) {
                            //converts and save hex val to rgba val
                            channels.at(i) = (int) strtol(name.substr(i * chanChars,
                                        chanChars).c_str(), nullptr, 16) * chanMultiplier;
                        }
                    }
                    else { //invalid color
                        string errStr = "Invalid Color: " + name + "\nMust be a hexadecimal(#RRGGBBAA, #RRGGBB, #RGBA, or #RGB) color representation\nOr one of these supported named colors: ";
                        for (const auto& p : ColorNames()) {
                            errStr += " \"" + p.first + "\"";
                        }
                        errStr += "\n";
                        throw errStr;
                    }
                }
                const string getRepresentation () const {
                    return string(
                            "[" +   to_string(getRed()) + "," +
                            to_string(getGreen()) + "," +
                            to_string(getBlue()) + "," +
                            to_string(getAlpha()) +
                            "]");
                }
                const string getCSSRepresentation() const {
                    using bridges::JSONUtil::JSONencode;
                    if (this->isTransparent()) {
                        //leaves off other channels if transparent
                        return "[0, 0, 0, 0.0]";
                    }
                    const string strCSS =
                        JSONencode(this->getRed()) + "," +
                        JSONencode(this->getGreen()) + "," +
                        JSONencode(this->getBlue()) + "," +
                        JSONencode( ((float) (this->getAlpha()) / 255.0f));
 
                    return OPEN_BOX + strCSS + CLOSE_BOX;
                }
                const void getCSSRepresentation(rapidjson::Document& d) const {
 
                    using namespace rapidjson;
                    double r = 0, g = 0, b = 0, alpha = 0;
                    Value v;
                    d.SetObject();
                    Document::AllocatorType& allocator = d.GetAllocator();
                    Value col_arr(kArrayType);
                    if (this->isTransparent()) {
                        //leaves off other channels if transparent
                        //  d.AddMember("color", v.SetString("[0, 0, 0, 0]"),
                        //                              allocator);
                        col_arr.PushBack(0., allocator);
                        col_arr.PushBack(0., allocator);
                        col_arr.PushBack(0., allocator);
                        col_arr.PushBack(0., allocator);
                    }
                    else {
                        col_arr.PushBack(v.SetDouble(this->getRed()), allocator);
                        col_arr.PushBack(v.SetDouble(this->getGreen()), allocator);
                        col_arr.PushBack(v.SetDouble(this->getBlue()), allocator);
                        col_arr.PushBack(v.SetDouble(this->getAlpha()), allocator);
                    }
                    d.AddMember("color", col_arr, allocator);
                }
 
            private:
 
                void setChannel(const int& value, const int& channel) {
                    (value < 0 || 255 < value)
                    ? throw "Invalid channel parameter: " + to_string(value) +
                    " Must be in the [0,255] range"
                    : channels.at(channel) = value;
                }
        };//end of color class
    }
};//end of bridge namespace
#endif