color.h

Go to the documentation of this file.

#ifndef NOVASVG_COLOR_H
#define NOVASVG_COLOR_H
 
// Self-contained on purpose (see NOVASVG_MAX() usage below): this header
// is included standalone by tests/cpp/test_novacolor.cpp, not just via
// the novasvg.h umbrella. novasvg.h defines these same two macros before
// it includes this file, so the guards below are a no-op in that path;
// here they're what makes plain `#include "novasvg/detail/color.h"` work
// on its own too.
#ifndef NOVASVG_MAX
#define NOVASVG_MAX(a, b) ((a) > (b) ? (a) : (b))
#endif
#ifndef NOVASVG_MIN
#define NOVASVG_MIN(a, b) ((a) < (b) ? (a) : (b))
#endif
 
#include <stdexcept>
#include <string>
#include <cstdint>
#include <math.h>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cctype>
#include <ostream>
#include <utility>
#include <type_traits>
 
namespace novasvg {
struct ColorBlend;
 
class Color {
private:
    uint8_t r;  
    uint8_t g;  
    uint8_t b;  
    uint8_t a;  
 
public:
    // ==================== Constructors ====================
 
    explicit Color(uint8_t r = 0, uint8_t g = 0, uint8_t b = 0, uint8_t a = 255)
        : r(r), g(g), b(b), a(a) {}
 
    Color(const std::string& str) : Color(fromString(str)) {}
 
    // ==================== Interop with Other Color Types ====================
 
    template <typename OtherColor,
              typename = decltype(std::declval<const OtherColor&>().red()),
              typename = decltype(std::declval<const OtherColor&>().green()),
              typename = decltype(std::declval<const OtherColor&>().blue()),
              typename = decltype(std::declval<const OtherColor&>().alpha())>
    constexpr Color(const OtherColor& other)
        : r(static_cast<uint8_t>(other.red())),
          g(static_cast<uint8_t>(other.green())),
          b(static_cast<uint8_t>(other.blue())),
          a(static_cast<uint8_t>(other.alpha())) {}
 
    template <typename OtherColor>
    constexpr OtherColor as() const {
        return OtherColor(r, g, b, a);
    }
 
    // ==================== Getters & Setters ====================
 
    uint8_t getR() const { return r; }
    
    uint8_t getG() const { return g; }
    
    uint8_t getB() const { return b; }
    
    uint8_t getA() const { return a; }
 
    void setR(uint8_t value) { r = value; }
    
    void setG(uint8_t value) { g = value; }
    
    void setB(uint8_t value) { b = value; }
    
    void setA(uint8_t value) { a = value; }
 
    // ==================== Engine-Facing Additions ====================
    // The methods below are additions for the SVG rendering engine's
    // internal use (float 0..1 channel access, opacity checks, deriving
    // a new color with a different alpha) -- your original getters/
    // setters/static factories above are untouched.
 
    float getRF() const { return r / 255.f; }
    float getGF() const { return g / 255.f; }
    float getBF() const { return b / 255.f; }
    float getAF() const { return a / 255.f; }
 
    bool isOpaque() const { return a == 255; }
    bool isVisible() const { return a > 0; }
 
    Color opaqueColor() const { return Color(r, g, b, 255); }
 
    Color colorWithAlpha(float opacity) const {
        return Color(r, g, b, static_cast<uint8_t>(a * opacity));
    }
 
    // ==================== Value Conversion ====================
 
    uint32_t value() const {
        return (static_cast<uint32_t>(r) << 24) |
               (static_cast<uint32_t>(g) << 16) |
               (static_cast<uint32_t>(b) << 8) |
               static_cast<uint32_t>(a);
    }
 
    friend bool operator==(const Color& lhs, const Color& rhs) {
        return lhs.r == rhs.r &&
            lhs.g == rhs.g &&
            lhs.b == rhs.b &&
            lhs.a == rhs.a;
    }
 
    friend bool operator!=(const Color& lhs, const Color& rhs) {
        return !(lhs == rhs);
    }
 
    // ==================== String Conversion ====================
 
    operator std::string() const { return toString(); }
 
    std::string toString() const {
        std::ostringstream oss;
        oss << "Color(r=" << static_cast<int>(r) 
            << ", g=" << static_cast<int>(g) 
            << ", b=" << static_cast<int>(b) 
            << ", a=" << static_cast<int>(a) << ")";
        return oss.str();
    }
 
    // ==================== Blend Operators ====================
 
    ColorBlend operator|(int percentage) const;
 
    Color operator|(const Color& other) const {
        return blend(other, 50);
    }
 
    Color blend(const Color& other, int percentage) const {
        int pct = NOVASVG_MAX(0, NOVASVG_MIN(100, percentage));
        double p = pct / 100.0;
        double q = 1.0 - p;
 
        return Color(
            static_cast<uint8_t>(std::ceil(r * q + other.r * p)),
            static_cast<uint8_t>(std::ceil(g * q + other.g * p)),
            static_cast<uint8_t>(std::ceil(b * q + other.b * p)),
            static_cast<uint8_t>(std::ceil(a * q + other.a * p))
        );
    }
 
    // ==================== Static Factory Methods ====================
 
    static Color fromString(const std::string& str) {
        if (str.empty()) {
            throw std::invalid_argument("Empty string provided");
        }
        bool is_hex = std::all_of(str.begin(), str.end(), [](unsigned char c) { return std::isxdigit(c); });
        return (str[0] == '#') ? fromHash(str) : ( is_hex ? fromHash("#" + str) : fromName(str));
    }
 
    static Color rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) {
        return Color(r, g, b, a);
    }
 
    static Color fromHash(const std::string& hex_code) {
        if (hex_code.empty() || hex_code[0] != '#') {
            throw std::invalid_argument("Hex color string must start with '#'");
        }
 
        std::string hex_body = hex_code.substr(1);
        
        if (hex_body.length() != 3 && hex_body.length() != 4 &&
            hex_body.length() != 6 && hex_body.length() != 8) {
            throw std::invalid_argument("Invalid hex color format");
        }
 
        // Expand shorthand: #RGB -> #RRGGBB
        if (hex_body.length() == 3) {
            hex_body = std::string() + hex_body[0] + hex_body[0] 
                              + hex_body[1] + hex_body[1] 
                              + hex_body[2] + hex_body[2];
        }
        // Expand shorthand with alpha: #RGBA -> #RRGGBBAA
        else if (hex_body.length() == 4) {
            hex_body = std::string() + hex_body[0] + hex_body[0] 
                              + hex_body[1] + hex_body[1] 
                              + hex_body[2] + hex_body[2]
                              + hex_body[3] + hex_body[3];
        }
 
        uint8_t r = static_cast<uint8_t>(std::stoi(hex_body.substr(0, 2), nullptr, 16));
        uint8_t g = static_cast<uint8_t>(std::stoi(hex_body.substr(2, 2), nullptr, 16));
        uint8_t b = static_cast<uint8_t>(std::stoi(hex_body.substr(4, 2), nullptr, 16));
        uint8_t a = (hex_body.length() == 8) 
            ? static_cast<uint8_t>(std::stoi(hex_body.substr(6, 2), nullptr, 16))
            : 255;
 
        return Color(r, g, b, a);
    }
 
    static Color fromName(const std::string& name) {
        std::string name_lower = name;
        for (char& c : name_lower) c = static_cast<char>(std::tolower(c));
 
        if (name_lower == "black")       return black();
        if (name_lower == "white")       return white();
        if (name_lower == "red")         return red();
        if (name_lower == "green")       return green();
        if (name_lower == "lime")        return lime();
        if (name_lower == "blue")        return blue();
        if (name_lower == "yellow")      return yellow();
        if (name_lower == "cyan")        return cyan();
        if (name_lower == "magenta")     return magenta();
        if (name_lower == "silver")      return silver();
        if (name_lower == "gray" || name_lower == "grey") return gray();
        if (name_lower == "maroon")      return maroon();
        if (name_lower == "olive")       return olive();
        if (name_lower == "purple")      return purple();
        if (name_lower == "teal")        return teal();
        if (name_lower == "navy")        return navy();
        if (name_lower == "orange")      return orange();
        if (name_lower == "pink")        return pink();
        if (name_lower == "brown")       return brown();
        if (name_lower == "transparent") return transparent();
 
        throw std::invalid_argument("Unknown color name: '" + name + "'");
    }
 
    static Color fromValue(uint32_t value) {
        uint8_t r = static_cast<uint8_t>((value >> 24) & 0xFF);
        uint8_t g = static_cast<uint8_t>((value >> 16) & 0xFF);
        uint8_t b = static_cast<uint8_t>((value >> 8) & 0xFF);
        uint8_t a = static_cast<uint8_t>(value & 0xFF);
        return Color(r, g, b, a);
    }
 
    // ==================== Predefined Colors ====================
 
    static Color black()       { return Color(0, 0, 0); }
 
    static Color white()       { return Color(255, 255, 255); }
 
    static Color red()         { return Color(255, 0, 0); }
 
    static Color green()       { return Color(0, 128, 0); }
 
    static Color lime()        { return Color(0, 255, 0); }
 
    static Color blue()        { return Color(0, 0, 255); }
 
    static Color yellow()      { return Color(255, 255, 0); }
 
    static Color cyan()        { return Color(0, 255, 255); }
 
    static Color magenta()     { return Color(255, 0, 255); }
 
    static Color silver()      { return Color(192, 192, 192); }
 
    static Color gray()        { return Color(128, 128, 128); }
 
    static Color maroon()      { return Color(128, 0, 0); }
 
    static Color olive()       { return Color(128, 128, 0); }
 
    static Color purple()      { return Color(128, 0, 128); }
 
    static Color teal()        { return Color(0, 128, 128); }
 
    static Color navy()        { return Color(0, 0, 128); }
 
    static Color orange()      { return Color(255, 165, 0); }
 
    static Color pink()        { return Color(255, 192, 203); }
 
    static Color brown()       { return Color(165, 42, 42); }
 
    static Color transparent() { return Color(0, 0, 0, 0); }
 
    // Static member-variable form, distinct from the black()/white()/
    // transparent() factory functions above (used pervasively as
    // default values through the SVG engine, e.g. `Color::Transparent`).
    static const Color Black;
    static const Color White;
    static const Color Transparent;
};
 
inline const Color Color::Black(0, 0, 0, 255);
inline const Color Color::White(255, 255, 255, 255);
inline const Color Color::Transparent(0, 0, 0, 0);
 
// ==================== ColorBlend ====================
 
struct ColorBlend {
    Color baseColor;   
    int percentage;    
 
    ColorBlend(const Color& base, int percent)
        : baseColor(base), percentage(percent) {}
 
    Color operator|(const Color& other) const {
        return baseColor.blend(other, percentage);
    }
 
    ColorBlend operator|(const ColorBlend& other) const {
        // First blend: baseColor | percentage → transparent
        Color intermediate = baseColor.blend(Color::transparent(), percentage);
        // Second blend: intermediate | other.percentage → other.baseColor
        return ColorBlend(intermediate, other.percentage);
    }
 
    operator Color() const {
        return baseColor.blend(Color::transparent(), percentage);
    }
};
 
inline ColorBlend Color::operator|(int percentage) const {
    return ColorBlend(*this, percentage);
}
 
// ==================== Non-Member Operators ====================
 
inline std::ostream& operator<<(std::ostream& os, const Color& color) {
    os << color.toString();
    return os;
}
 
inline std::ostream& operator<<(std::ostream& os, const ColorBlend& blend) {
    os << static_cast<Color>(blend);
    return os;
}
 
} // namespace novasvg
 
// ==================== Color Literals Namespace ====================
 
namespace novasvg::color_literals {
 
inline novasvg::Color operator""_c(const char* str, std::size_t len) {
    return novasvg::Color::fromString(std::string(str, len));
}
 
} // namespace novasvg::color_literals
 
#endif // NOVASVG_COLOR_H