idomcolorspace.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2025 Global Graphics Software Ltd. All rights reserved.
 */
 
#ifndef EDLIDOMCOLORSPACE_H
#define EDLIDOMCOLORSPACE_H
 
#include <stdarg.h>
#include <edl/idomfunction.h>
#include <edl/edlrenderingintent.h>
#include <edl/edlblackpointcompensation.h>
#include <edl/edlmath.h>
#include <edl/edltypes.h>
#include <edl/iedlobject.h>
#include <edl/idomresources.h>
#include <edl/edlvector.h>
#include <edl/idomhashable.h>
#include <edl/edlerrors.h>
 
_BEGIN_EDL_DOM_NAMESPACE
 
class IDOMColorSpace;
DECL_SMART_PTR(IDOMColorSpace);
 

class IDOMColorSpace : public IEDLObject, public IDOMHashable
{
  public:
    virtual ~IDOMColorSpace() {}

    typedef enum {
        eDeviceRGB,     
        eDeviceGray,    
        eDeviceCMYK,    
        esRGB,          
        esGray,         
        escRGB,         
        eICCBased,      
        eIndexed,       
        eDeviceN,       
        eLAB,           
        eDeviceCMY,     
        eNumColorSpaceTypes = 11
    } eColorSpaceType;

    virtual eColorSpaceType getColorSpaceType() = 0;

    virtual uint8 getNumComponents() = 0;

    virtual bool getComponentsHaveSameRange() = 0;
 
#ifdef SWIG
    %apply float &OUTPUT { float &low  };
    %apply float &OUTPUT { float &high };
#endif
    virtual bool getComponentRange(int component, float &low, float &high) = 0;
#ifdef SWIG
    %clear float &low;
    %clear float &high;
#endif

    virtual eRenderingIntent getDefaultRenderingIntent() = 0;

    virtual EDLRawString getColorantName(uint8 component) const = 0;

    virtual bool equals(const IDOMColorSpacePtr &colorSpace, bool exact = false) = 0;

    virtual bool similar(const IDOMColorSpacePtr &colorSpace, eRenderingIntent intent, eBlackPointCompensation bpc) = 0;
};
#define edlobj2IDOMColorSpace(src) edl_cast((IDOMColorSpace *)NULL, src)
 
 
class IDOMColorSpacesRGB;
DECL_SMART_PTR(IDOMColorSpacesRGB);

class IDOMColorSpacesRGB : public IDOMColorSpace
{
#define IDOMColorSpacesRGBClassID 0xbc9883fc, 0x15d34522, 0xa339ae75, 0xba783f1a
  public:
    virtual ~IDOMColorSpacesRGB() {}

    static EDL_API IDOMColorSpacesRGBPtr create(IEDLClassFactory *pFactory);

    static const CClassID &classID()
    {
        static CClassID id(IDOMColorSpacesRGBClassID);
        return id;
    };
};
#define edlobj2IDOMColorSpacesRGB(src) edl_cast((IDOMColorSpacesRGB *)NULL, src)
 
 
class IDOMColorSpacesGray;
DECL_SMART_PTR(IDOMColorSpacesGray);

class IDOMColorSpacesGray : public IDOMColorSpace
{
#define IDOMColorSpacesGrayClassID 0x21164cec, 0x039345e2, 0xbd7d2a20, 0x91116c09
  public:
    virtual ~IDOMColorSpacesGray() {}

    static EDL_API IDOMColorSpacesGrayPtr create(IEDLClassFactory *pFactory);

    static const CClassID &classID()
    {
        static CClassID id(IDOMColorSpacesGrayClassID);
        return id;
    };
 
};
#define edlobj2IDOMColorSpacesGray(src) edl_cast((IDOMColorSpacesGray *)NULL, src)
 
 
class IDOMColorSpacescRGB;
DECL_SMART_PTR(IDOMColorSpacescRGB);

class IDOMColorSpacescRGB : public IDOMColorSpace
{
#define IDOMColorSpacescRGBClassID 0xdf8fb57c, 0xd20e11db, 0x9fdeecb6, 0x55d89593
  public:
    virtual ~IDOMColorSpacescRGB() {}

    static EDL_API IDOMColorSpacescRGBPtr create(IEDLClassFactory *pFactory);

    static const CClassID &classID()
    {
        static CClassID id(IDOMColorSpacescRGBClassID);
        return id;
    };
 
};
#define edlobj2IDOMColorSpacescRGB(src) edl_cast((IDOMColorSpacescRGB *)NULL, src)
 
 
class IDOMColorSpaceDeviceRGB;
DECL_SMART_PTR(IDOMColorSpaceDeviceRGB);

class IDOMColorSpaceDeviceRGB : public IDOMColorSpace
{
#define IDOMColorSpaceDeviceRGBClassID 0x5A615EA5, 0xFBF2440D, 0xAE04C3BD, 0xF0758C02
  public:
    virtual ~IDOMColorSpaceDeviceRGB() {}

    static EDL_API IDOMColorSpaceDeviceRGBPtr create(IEDLClassFactory *pFactory);

    static const CClassID &classID()
    {
        static CClassID id(IDOMColorSpaceDeviceRGBClassID);
        return id;
    };
 
};
#define edlobj2IDOMColorSpaceDeviceRGB(src) edl_cast((IDOMColorSpaceDeviceRGB *)NULL, src)
 
 
class IDOMColorSpaceDeviceGray;
DECL_SMART_PTR(IDOMColorSpaceDeviceGray);

class IDOMColorSpaceDeviceGray : public IDOMColorSpace
{
#define IDOMColorSpaceDeviceGrayClassID 0x8FB5ECD1, 0x18C2447E, 0x91ABB50F, 0xE4E70A0D
  public:
    virtual ~IDOMColorSpaceDeviceGray() {}

    static EDL_API IDOMColorSpaceDeviceGrayPtr create(IEDLClassFactory *pFactory);

    static const CClassID &classID()
    {
        static CClassID id(IDOMColorSpaceDeviceGrayClassID);
        return id;
    };
 
};
#define edlobj2IDOMColorSpaceDeviceGray(src) edl_cast((IDOMColorSpaceDeviceGray *)NULL, src)
 
 
class IDOMColorSpaceDeviceCMYK;
DECL_SMART_PTR(IDOMColorSpaceDeviceCMYK);

class IDOMColorSpaceDeviceCMYK : public IDOMColorSpace
{
#define IDOMColorSpaceDeviceCMYKClassID 0x6F31A7BC, 0x4B994A3C, 0x9FFE836F, 0xE5C07FBB
  public:
    virtual ~IDOMColorSpaceDeviceCMYK() {}

    static EDL_API IDOMColorSpaceDeviceCMYKPtr create(IEDLClassFactory *pFactory);

    static const CClassID &classID()
    {
        static CClassID id(IDOMColorSpaceDeviceCMYKClassID);
        return id;
    };
 
};
#define edlobj2IDOMColorSpaceDeviceCMYK(src) edl_cast((IDOMColorSpaceDeviceCMYK *)NULL, src)
 
 
class IDOMColorSpaceDeviceCMY;
DECL_SMART_PTR(IDOMColorSpaceDeviceCMY);

class IDOMColorSpaceDeviceCMY : public IDOMColorSpace
{
#define IDOMColorSpaceDeviceCMYClassID 0x27849B58, 0x9E584782, 0x876CE042, 0x5A91C168
 
  public:
    virtual ~IDOMColorSpaceDeviceCMY() {}

    static EDL_API IDOMColorSpaceDeviceCMYPtr create(IEDLClassFactory *pFactory);

    static const CClassID &classID()
    {
        static CClassID id(IDOMColorSpaceDeviceCMYClassID);
        return id;
    };
 
};
#define edlobj2IDOMColorSpaceDeviceCMY(src) edl_cast((IDOMColorSpaceDeviceCMY *)NULL, src)
 
 
 
class IDOMColorSpaceICCBased;
DECL_SMART_PTR(IDOMColorSpaceICCBased);

class IDOMColorSpaceICCBased : public IDOMColorSpace
{
#define IDOMColorSpaceICCBasedClassID 0xd67937e4, 0x7a1d4f5f, 0xb950bc30, 0x38474418
  public:
    virtual ~IDOMColorSpaceICCBased() {}

    static EDL_API IDOMColorSpaceICCBasedPtr create(IEDLClassFactory *pFactory, const IDOMICCProfilePtr &profile, const IDOMColorSpacePtr &alternate = IDOMColorSpacePtr());

    class Data : public CClassParams
    {
    public:
        Data()
        {}
        Data(IDOMICCProfilePtr &pICCProfile):
        m_pICCProfile(pICCProfile), m_AlternateSpace(0)
        {}
        Data(IDOMICCProfilePtr &pICCProfile, IDOMColorSpacePtr &pAlt):
        m_pICCProfile(pICCProfile), m_AlternateSpace(pAlt)
        {}
        IDOMICCProfilePtr m_pICCProfile;
        IDOMColorSpacePtr m_AlternateSpace;  /* PDF alternate color space */
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMColorSpaceICCBasedClassID);
        return id;
    };

    virtual IDOMICCProfilePtr getICCProfile() = 0;

    virtual void setICCProfile(const IDOMICCProfilePtr &profile) = 0;

    virtual IDOMColorSpacePtr getAlternateColorSpace() const = 0;

    virtual bool getIsLabColorSpace() const = 0;

    virtual bool getIsDeviceLink() const = 0;
};
 
#define edlobj2IDOMColorSpaceICCBased(src) edl_cast((IDOMColorSpaceICCBased *)NULL, src)
 
 
class IDOMColorSpaceIndexed;
DECL_SMART_PTR(IDOMColorSpaceIndexed);

class IDOMColorSpaceIndexed : public IDOMColorSpace
{
#define IDOMColorSpaceIndexedClassID 0x0ef4de20, 0x5f914784, 0x9b607760, 0x6ae02137
  public:
    virtual ~IDOMColorSpaceIndexed() {}

    static EDL_API IDOMColorSpaceIndexedPtr create(IEDLClassFactory *pFactory, const IDOMColorSpacePtr &underlying, const IDOMFunctionPtr &mappingFunction);

    static EDL_API IDOMColorSpaceIndexedPtr create(IEDLClassFactory *pFactory, const IDOMColorSpacePtr &underlying, const CEDLVector<uint8> &table);

    class Data : public CClassParams
    {
      public:
        Data() {}
        Data(IDOMColorSpacePtr &pUnderlying, IDOMFunctionPtr &pMapping):
        pUnderlyingSpace(pUnderlying), pMappingFunction(pMapping)
        {}
        IDOMColorSpacePtr pUnderlyingSpace;
        IDOMFunctionPtr   pMappingFunction;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMColorSpaceIndexedClassID);
        return id;
    };

    virtual IDOMColorSpacePtr getUnderlyingColorSpace() = 0;

    virtual IDOMFunctionPtr getMappingFunction() = 0;
 
};
#define edlobj2IDOMColorSpaceIndexed(src) edl_cast((IDOMColorSpaceIndexed *)NULL, src)
 

class IDOMDeviceNColorant : public IEDLObject, public IDOMHashable
{
#define IDOMDeviceNColorantClassID 0x78fad1cd, 0x07cd43c8, 0x96f7e4cf, 0xd1f98d63
  public:
    virtual ~IDOMDeviceNColorant() {}

    class Data : public CClassParams
    {
    public:
        Data() : hasSolidity(false), solidity(0.0)
        {}
        EDLRawString      name;
        bool              hasSolidity;
        float             solidity;
        IDOMFunctionPtr   pDotGainFunction;
        IDOMColorSpacePtr pAlternateSpace;
        IDOMFunctionPtr   pTintTransform;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMDeviceNColorantClassID);
        return id;
    };

    virtual const EDLRawString& getName() = 0;
 
#ifdef SWIG
    %apply float &OUTPUT { float &solidity };
#endif
    virtual bool getSolidity(float &solidity) = 0;
#ifdef SWIG
    %clear float &solidity;
#endif

    virtual IDOMFunctionPtr getTintTransform() = 0;

    virtual IDOMFunctionPtr getDotGainFunction() = 0;

    virtual IDOMColorSpacePtr getAlternateColorSpace() = 0;
};
 
DECL_SMART_PTR(IDOMDeviceNColorant);
#define edlobj2IDOMDeviceNColorant(src) edl_cast((IDOMDeviceNColorant *) NULL, src)
typedef CEDLVector<IDOMDeviceNColorantPtr> CDeviceNColorantVect;
 
class IDOMColorSpaceDeviceN;
DECL_SMART_PTR(IDOMColorSpaceDeviceN);

class IDOMColorSpaceDeviceN : public IDOMColorSpace
{
#define IDOMColorSpaceDeviceNClassID 0x30404cc4, 0xa1d940ea, 0xb396c3b3, 0xa84d4bf7
  public:
    virtual ~IDOMColorSpaceDeviceN() {}

    static EDL_API IDOMColorSpaceDeviceNPtr create(IEDLClassFactory *pFactory, const CEDLRawStringVect &colorants,
                                                   const IDOMColorSpacePtr &alternate, const IDOMFunctionPtr &tintTransform,
                                                   const IDOMColorSpacePtr &processColorSpace = IDOMColorSpacePtr());

    static EDL_API IDOMColorSpaceDeviceNPtr create(IEDLClassFactory *pFactory, const CDeviceNColorantVect &colorants,
                                                   const IDOMColorSpacePtr &alternate, const IDOMFunctionPtr &tintTransform,
                                                   const IDOMColorSpacePtr &processColorSpace = IDOMColorSpacePtr(),
                                                   const CEDLRawStringVect &processComponents = CEDLRawStringVect (),
                                                   const CEDLRawStringVect &printingOrder = CEDLRawStringVect (),
                                                   bool isNChannel = false);
 
    class CColorantInfo
    {
      public:
        CColorantInfo() {}
 
        MAKO_DEPRECATED_FUNC(CColorantInfo(const EDLRawString &_name, uint32 numComponents, ...), "Please use initializer list instead of variable arguments.")
        {
            va_list argPtr;
            name = _name;
            components.reserve(numComponents);
 
            va_start(argPtr, numComponents);
            for (uint32 i = 0; i < numComponents; i++)
            {
                components.append((float) va_arg(argPtr, double));
            }
            va_end(argPtr);
        }
 
        MAKO_DEPRECATED_FUNC(CColorantInfo(const EDLRawString &_name, const IDOMColorSpacePtr &_alternate, uint32 numComponents, ...), "Please use initializer list instead of variable arguments.")
        {
            va_list argPtr;
            name = _name;
            alternate = _alternate;
            if (alternate && alternate->getNumComponents() != numComponents)
            {
                throwEDLError(EDL_ERR_BAD_ARGUMENTS);
            }
            components.reserve(numComponents);
 
            va_start(argPtr, numComponents);
            for (uint32 i = 0; i < numComponents; i++)
            {
                components.append((float) va_arg(argPtr, double));
            }
            va_end(argPtr);
        }
 
        CColorantInfo (const EDLRawString& _name, const std::initializer_list<double> & _components)
        {
            name = _name;
            components.reserve ((uint32_t) _components.size ());
            for (auto val : _components)
                components.append ((float) val);
        }
 
        CColorantInfo (const EDLRawString& _name, const IDOMColorSpacePtr& _alternate, const std::initializer_list<double> & _components)
        {
            name = _name;
            alternate = _alternate;
 
            components.reserve ((uint32_t) _components.size ());
            for (auto val : _components)
                components.append ((float) val);
 
            if (alternate && alternate->getNumComponents () != components.size ())
            {
                throwEDLError (EDL_ERR_BAD_ARGUMENTS);
            }
        }
 
        CColorantInfo (const EDLRawString& _name, const CEDLVector<double> & _components)
        {
            name = _name;
            components.reserve (_components.size ());
            for (auto val : _components)
                components.append ((float) val);
        }
 
        CColorantInfo (const EDLRawString& _name, const IDOMColorSpacePtr& _alternate, const CEDLVector<double> & _components)
        {
            name = _name;
            alternate = _alternate;
 
            components.reserve (_components.size ());
            for (auto val : _components)
                components.append ((float) val);
 
            if (alternate && alternate->getNumComponents () != components.size ())
            {
                throwEDLError (EDL_ERR_BAD_ARGUMENTS);
            }
        }
 
        EDLRawString      name;
        CEDLVector<float> components;
        IDOMColorSpacePtr alternate; // If null, the colorants are in terms of the DeviceN alternate color space.
 
        bool operator== (const CColorantInfo &other) const
        {
            return      (other.name         == name)
            &&  (other.components   == components);
        }
 
        bool operator!= (const CColorantInfo &other) const
        {
            return ! (*this == other);
        }
    };
    typedef CEDLVector<CColorantInfo> CColorantInfoVect;

    static EDL_API CColorantInfoVect getExtendedGamutColorants(IEDLClassFactory *pFactory,
                                                               const IDOMICCProfilePtr &extendedGamutProfile,
                                                               const IDOMColorSpacePtr &alternate);

    static EDL_API IDOMColorSpaceDeviceNPtr create(IEDLClassFactory *pFactory, const CColorantInfoVect &colorants,
                                                   const IDOMColorSpacePtr &alternate,
                                                   const IDOMColorSpacePtr &processColorSpace = IDOMColorSpacePtr());

    class Data : public CClassParams
    {
      public:
        Data() : nChannel(false) {}
        bool                     nChannel;
        IDOMColorSpacePtr        pAlternateSpace;
        IDOMFunctionPtr          pTintTransform;
        CDeviceNColorantVect     pColorants;
        IDOMColorSpacePtr        pProcessColorSpace;
        CEDLRawStringVect        pProcessComponentNames;
        CEDLRawStringVect        pPrintingOrder;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMColorSpaceDeviceNClassID);
        return id;
    };

    virtual bool getIsNChannel() const = 0;

    virtual IDOMColorSpacePtr getAlternateColorSpace() const = 0;

    virtual bool getHasRealColorant() const = 0;

    virtual IDOMFunctionPtr getTintTransform() const = 0;

    virtual IDOMDeviceNColorantPtr getColorant(uint8 component) const = 0;

    virtual IDOMColorSpacePtr getProcessColorSpace() const = 0;

    virtual const CEDLRawStringVect &getProcessComponentNames() const = 0;

    virtual const CEDLRawStringVect &getPrintingOrder() const = 0;

    virtual CColorantInfoVect getColorantInfo(IEDLClassFactory *factory, const IDOMColorSpacePtr &colorantSpace = IDOMColorSpacePtr()) const = 0;
};
#define edlobj2IDOMColorSpaceDeviceN(src) edl_cast((IDOMColorSpaceDeviceN *)NULL, src)
 
 
class IDOMColorSpaceLAB;
DECL_SMART_PTR(IDOMColorSpaceLAB);

class IDOMColorSpaceLAB : public IDOMColorSpace
{
#define IDOMColorSpaceLABClassID 0x0d9f95d3, 0x4f2d4882, 0xb4293528, 0xea287840
  public:
    virtual ~IDOMColorSpaceLAB() {}

    static EDL_API IDOMColorSpaceLABPtr create(IEDLClassFactory *pFactory, float whitePointX, float whitePointY, float whitePointZ,
                                               float blackPointX = 0.0f, float blackPointY = 0.0f, float blackPointZ = 0.0f,
                                               float rangeALo = -100.0f, float rangeAHi = 100.0f, float rangeBLo = -100.0f, float rangeBHi = 100.0f);

    class Data : public CClassParams
    {
    public:
        Data()
        {
            rangeAB[0] = rangeAB[2] = -100.0f;
            rangeAB[1] = rangeAB[3] =  100.0f;
            blackPoint[0] = blackPoint[1] = blackPoint[2] = 0.0f;
            whitePoint[0] = whitePoint[1] = whitePoint[2] = 1.0f;
        }
        float rangeAB[4];
        float whitePoint[3];
        float blackPoint[3];
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMColorSpaceLABClassID);
        return id;
    };
 
#ifdef SWIG
    %apply float &OUTPUT { float &lowA };
    %apply float &OUTPUT { float &lowB };
    %apply float &OUTPUT { float &highA };
    %apply float &OUTPUT { float &highB };
#endif
    virtual void getRangeAB(float &lowA, float &highA,
                            float &lowB, float &highB) = 0;
#ifdef SWIG
    %clear float &lowA;
    %clear float &lowB;
    %clear float &highA;
    %clear float &highB;
#endif
 
#ifdef SWIG
    %apply float &OUTPUT { float &x };
    %apply float &OUTPUT { float &y };
    %apply float &OUTPUT { float &z };
#endif
    virtual void getWhitePoint(float &x, float &y, float &z) = 0;

    virtual void getBlackPoint(float &x, float &y, float &z) = 0;
#ifdef SWIG
    %clear float &x;
    %clear float &y;
    %clear float &z;
#endif
 
};
#define edlobj2IDOMColorSpaceLAB(src) edl_cast((IDOMColorSpaceLAB *)NULL, src)
 
 
 
 
_END_EDL_DOM_NAMESPACE
 
#endif /* EDLIDOMCOLORSPACE_H */