color.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <promeki/colormodel.h>
#include <promeki/list.h>
#include <promeki/namespace.h>
#include <promeki/result.h>
#include <promeki/string.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class Color {
        public:
                PROMEKI_DATATYPE(Color, DataTypeColor, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<Color> readFromStream(DataStream &s);
 
                enum StringFormat {
                        ModelFormat, 
                        HexFormat,   
                        CSVFormat,   
                        FloatFormat, 
                };
 
                enum AlphaMode {
                        AlphaAuto,   
                        AlphaAlways, 
                        AlphaNever,  
                };
 
                static const Color Black;       
                static const Color White;       
                static const Color Red;         
                static const Color Green;       
                static const Color Blue;        
                static const Color Yellow;      
                static const Color Cyan;        
                static const Color Magenta;     
                static const Color DarkGray;    
                static const Color LightGray;   
                static const Color Orange;      
                static const Color Transparent; 
                static const Color Ignored;     
 
                // --- Static factory helpers (one per well-known model) ---
 
                static Color srgb(float r, float g, float b, float a = 1.0f) {
                        return Color(ColorModel::sRGB, r, g, b, a);
                }
 
                static Color linearSrgb(float r, float g, float b, float a = 1.0f) {
                        return Color(ColorModel::LinearSRGB, r, g, b, a);
                }
 
                static Color rec709(float r, float g, float b, float a = 1.0f) {
                        return Color(ColorModel::Rec709, r, g, b, a);
                }
 
                static Color hsv(float h, float s, float v, float a = 1.0f) {
                        return Color(ColorModel::HSV_sRGB, h, s, v, a);
                }
 
                static Color hsl(float h, float s, float l, float a = 1.0f) {
                        return Color(ColorModel::HSL_sRGB, h, s, l, a);
                }
 
                static Color ycbcr709(float y, float cb, float cr, float a = 1.0f) {
                        return Color(ColorModel::YCbCr_Rec709, y, cb, cr, a);
                }
 
                static Color ycbcr601(float y, float cb, float cr, float a = 1.0f) {
                        return Color(ColorModel::YCbCr_Rec601, y, cb, cr, a);
                }
 
                static Color xyz(float x, float y, float z, float a = 1.0f) {
                        return Color(ColorModel::CIEXYZ, x, y, z, a);
                }
 
                static Color lab(float l, float a, float b, float alpha = 1.0f) {
                        return Color(ColorModel::CIELab, l, a, b, alpha);
                }
 
                static Color fromHex(const String &hex);
 
                static Result<Color> fromString(const String &str);
 
                static Color fromNative(const ColorModel &model, float n0, float n1, float n2, float n3 = 1.0f);
 
                // --- Constructors ---
 
                Color() = default;
 
                Color(const ColorModel &model, float c0, float c1, float c2, float c3 = 1.0f)
                    : _c{c0, c1, c2, c3}, _model(model) {}
 
                Color(ColorModel::ID id, float c0, float c1, float c2, float c3 = 1.0f)
                    : _c{c0, c1, c2, c3}, _model(id) {}
 
                Color(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255)
                    : _c{r / 255.0f, g / 255.0f, b / 255.0f, a / 255.0f}, _model(ColorModel::sRGB) {}
 
                // --- State ---
 
                bool isValid() const { return _model.isValid(); }
 
                const ColorModel &model() const { return _model; }
 
                // --- Generic component access ---
 
                float comp(size_t index) const { return index < 4 ? _c[index] : 0.0f; }
 
                void setComp(size_t index, float val) {
                        if (index < 4) _c[index] = val;
                }
 
                float alpha() const { return _c[3]; }
 
                float a() const { return _c[3]; }
 
                void setAlpha(float val) { _c[3] = val; }
 
                void setA(float val) { _c[3] = val; }
 
                // --- RGB accessors (model must be TypeRGB) ---
 
                float r() const { return _c[0]; }
 
                float g() const { return _c[1]; }
 
                float b() const { return _c[2]; }
 
                void setR(float val) { _c[0] = val; }
 
                void setG(float val) { _c[1] = val; }
 
                void setB(float val) { _c[2] = val; }
 
                // --- 8-bit sRGB accessors (convert to sRGB if needed) ---
 
                uint8_t r8() const;
 
                uint8_t g8() const;
 
                uint8_t b8() const;
 
                uint8_t a8() const;
 
                // --- HSV accessors ---
 
                float h() const { return _c[0]; }
 
                float s() const { return _c[1]; }
 
                float v() const { return _c[2]; }
 
                float l() const { return _c[0]; }
 
                // --- YCbCr accessors ---
 
                float y() const { return _c[0]; }
 
                float cb() const { return _c[1]; }
 
                float cr() const { return _c[2]; }
 
                // --- Conversion ---
 
                Color convert(const ColorModel &target) const;
 
                Color toRGB() const;
 
                Color toLinearRGB() const;
 
                Color toHSV() const;
 
                Color toHSL() const;
 
                Color toYCbCr709() const;
 
                Color toXYZ() const;
 
                Color toLab() const;
 
                // --- String conversion ---
 
                String toString(StringFormat fmt = ModelFormat, AlphaMode alpha = AlphaAuto) const;
 
                String toHex(bool includeAlpha = false) const;
 
                // --- Color operations ---
 
                Color lerp(const Color &other, double t) const;
 
                Color inverted() const;
 
                double luminance() const;
 
                Color contrastingBW() const;
 
                Color complementary() const;
 
                float toNative(size_t comp) const;
 
                bool isClose(const Color &other, float epsilon = 1e-5f) const;
 
                bool operator==(const Color &other) const {
                        return _model == other._model && _c[0] == other._c[0] && _c[1] == other._c[1] &&
                               _c[2] == other._c[2] && _c[3] == other._c[3];
                }
 
                bool operator!=(const Color &other) const { return !(*this == other); }
 
                using List = ::promeki::List<Color>;
 
                size_t nearestPaletteIndex(const Color *palette, size_t n) const;
 
                size_t nearestPaletteIndex(const List &palette) const {
                        return nearestPaletteIndex(palette.data(), palette.size());
                }
 
                Color nearestPaletteColor(const List &palette) const {
                        if (palette.isEmpty()) return Color();
                        return palette[nearestPaletteIndex(palette)];
                }
 
        private:
                float      _c[4] = {0.0f, 0.0f, 0.0f, 0.0f};
                ColorModel _model;
 
                // Helper: get sRGB version of this color (for string/hex output)
                Color ensureSRGB() const;
};
 
inline const Color Color::Black{(uint8_t)0, (uint8_t)0, (uint8_t)0};
inline const Color Color::White{(uint8_t)255, (uint8_t)255, (uint8_t)255};
inline const Color Color::Red{(uint8_t)255, (uint8_t)0, (uint8_t)0};
inline const Color Color::Green{(uint8_t)0, (uint8_t)255, (uint8_t)0};
inline const Color Color::Blue{(uint8_t)0, (uint8_t)0, (uint8_t)255};
inline const Color Color::Yellow{(uint8_t)255, (uint8_t)255, (uint8_t)0};
inline const Color Color::Cyan{(uint8_t)0, (uint8_t)255, (uint8_t)255};
inline const Color Color::Magenta{(uint8_t)255, (uint8_t)0, (uint8_t)255};
inline const Color Color::DarkGray{(uint8_t)64, (uint8_t)64, (uint8_t)64};
inline const Color Color::LightGray{(uint8_t)192, (uint8_t)192, (uint8_t)192};
inline const Color Color::Orange{(uint8_t)255, (uint8_t)165, (uint8_t)0};
inline const Color Color::Transparent{(uint8_t)0, (uint8_t)0, (uint8_t)0, (uint8_t)0};
inline const Color Color::Ignored{};
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::Color);
 
#endif // PROMEKI_ENABLE_CORE