colormodel.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/list.h>
#include <promeki/array.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/ciepoint.h>
#include <promeki/matrix3x3.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class ColorModel {
        public:
                PROMEKI_DATATYPE(ColorModel, DataTypeColorModel, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<ColorModel> readFromStream(DataStream &s);
 
                enum ID {
                        Invalid = 0,           
                        sRGB = 1,              
                        LinearSRGB = 2,        
                        Rec709 = 3,            
                        LinearRec709 = 4,      
                        Rec601_PAL = 5,        
                        LinearRec601_PAL = 6,  
                        Rec601_NTSC = 7,       
                        LinearRec601_NTSC = 8, 
                        Rec2020 = 9,           
                        LinearRec2020 = 10,    
                        DCI_P3 = 11,           
                        LinearDCI_P3 = 12,     
                        AdobeRGB = 13,         
                        LinearAdobeRGB = 14,   
                        ACES_AP0 = 15,         
                        ACES_AP1 = 16,         
                        CIEXYZ = 17,           
                        CIELab = 18,           
                        HSV_sRGB = 19,         
                        HSL_sRGB = 20,         
                        YCbCr_Rec709 = 21,     
                        YCbCr_Rec601 = 22,     
                        YCbCr_Rec2020 = 23,    
                        // ---- HDR (BT.2100) ----
                        // Same chromaticity primaries as Rec2020 / BT.2020
                        // but different EOTF.  Carried as distinct
                        // ColorModel IDs so a PixelFormat / ImageDesc that
                        // says "PQ" wires the correct transfer through
                        // every consumer that reads ColorModel::toH273.
                        Rec2020_PQ = 24,       
                        Rec2020_HLG = 25,      
                        YCbCr_Rec2020_PQ = 26, 
                        YCbCr_Rec2020_HLG = 27,
                        DCI_P3_PQ = 28,        
                        UserDefined = 1024     
                };
 
                enum Type {
                        TypeInvalid = 0, 
                        TypeRGB,         
                        TypeXYZ,         
                        TypeLab,         
                        TypeYCbCr,       
                        TypeHSV,         
                        TypeHSL          
                };
 
                struct CompInfo {
                                String name;      
                                String abbrev;    
                                float  nativeMin; 
                                float  nativeMax; 
                };
 
                typedef double (*TransferFunc)(double);
 
                typedef Array<CIEPoint, 4> Primaries;
 
                using IDList = ::promeki::List<ID>;
 
                struct Data {
                                ID           id = Invalid;       
                                Type         type = TypeInvalid; 
                                String       name;               
                                String       desc;               
                                Primaries    primaries;          
                                CompInfo     comps[3] = {};      
                                TransferFunc oetf = nullptr;     
                                TransferFunc eotf = nullptr;     
                                bool         linear = false;     
                                ID           linearCounterpart = Invalid;    
                                ID           nonlinearCounterpart = Invalid; 
                                ID           parentModel = Invalid;          
                                Matrix3x3    rgbToXyz;                       
                                Matrix3x3    xyzToRgb;                       
                                Matrix3x3    toParentMatrix;                 
                                Matrix3x3    fromParentMatrix;               
                                float        toParentOffset[3] = {};         
                                float        fromParentOffset[3] = {};       
                                void (*toXYZFunc)(const Data *d, const float *src,
                                                  float *dst) = nullptr; 
                                void (*fromXYZFunc)(const Data *d, const float *src,
                                                    float *dst) = nullptr; 
                };
 
                static ID registerType();
 
                static void registerData(Data &&data);
 
                static IDList registeredIDs();
 
                static ColorModel lookup(const String &name);
 
                static Result<ColorModel> fromString(const String &name) {
                        ColorModel m = lookup(name);
                        if (!m.isValid()) return makeError<ColorModel>(Error::IdNotFound);
                        return makeResult(m);
                }
 
                struct H273 {
                                uint8_t primaries = 0; 
                                uint8_t transfer = 0;  
                                uint8_t matrix = 0;    
                };
 
                static H273 toH273(ID id);
 
                inline ColorModel(ID id = Invalid);
 
                ID id() const { return _d->id; }
 
                bool isValid() const { return _d != nullptr && _d->type != TypeInvalid; }
 
                bool operator==(const ColorModel &other) const { return _d == other._d; }
 
                bool operator!=(const ColorModel &other) const { return _d != other._d; }
 
                Type type() const { return _d->type; }
 
                const String &name() const { return _d->name; }
 
                String toString() const { return _d->name; }
 
                const String &desc() const { return _d->desc; }
 
                size_t compCount() const { return 3; }
 
                const CompInfo &compInfo(size_t index) const { return _d->comps[index < 3 ? index : 0]; }
 
                const Primaries &primaries() const { return _d->primaries; }
 
                const CIEPoint &whitePoint() const { return _d->primaries[3]; }
 
                bool isLinear() const { return _d->linear; }
 
                inline ColorModel linearCounterpart() const;
 
                inline ColorModel nonlinearCounterpart() const;
 
                double applyTransfer(double linear) const { return _d->oetf(linear); }
 
                double removeTransfer(double encoded) const { return _d->eotf(encoded); }
 
                inline ColorModel parentModel() const;
 
                void toXYZ(const float *src, float *dst) const { _d->toXYZFunc(_d, src, dst); }
 
                void fromXYZ(const float *src, float *dst) const { _d->fromXYZFunc(_d, src, dst); }
 
                float toNative(size_t comp, float normalized) const {
                        if (comp >= 3) return 0.0f;
                        const CompInfo &ci = _d->comps[comp];
                        return ci.nativeMin + normalized * (ci.nativeMax - ci.nativeMin);
                }
 
                float fromNative(size_t comp, float native) const {
                        if (comp >= 3) return 0.0f;
                        const CompInfo &ci = _d->comps[comp];
                        float           range = ci.nativeMax - ci.nativeMin;
                        if (range == 0.0f) return 0.0f;
                        return (native - ci.nativeMin) / range;
                }
 
                const Data *data() const { return _d; }
 
        private:
                const Data        *_d = nullptr;
                static const Data *lookupData(ID id);
};
 
// Deferred inline definitions that require the full class to be visible.
 
inline ColorModel::ColorModel(ID id) : _d(lookupData(id)) {}
 
inline ColorModel ColorModel::linearCounterpart() const {
        ID lcid = _d->linearCounterpart;
        return lcid != Invalid ? ColorModel(lcid) : *this;
}
 
inline ColorModel ColorModel::nonlinearCounterpart() const {
        ID nlid = _d->nonlinearCounterpart;
        return nlid != Invalid ? ColorModel(nlid) : *this;
}
 
inline ColorModel ColorModel::parentModel() const {
        return ColorModel(_d->parentModel);
}
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE