idomfunction.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2025 Global Graphics Software Ltd. All rights reserved.
 */
 
#ifndef EDLIDOMFUNCTION_H
#define EDLIDOMFUNCTION_H
 
#include <jawsmako/pdfobjects.h>
#include <edl/edltypes.h>
#include <edl/iedlobject.h>
#include <edl/edlstream.h>
#include <edl/isession.h>
#include <edl/edlvector.h>
#include <edl/idomhashable.h>
 
_BEGIN_EDL_DOM_NAMESPACE

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

    typedef enum
    {
        eFTSampled,
        eFTExponential,
        eFTStitching,
        eFTGrouping,
        eFTPostScriptCalculator
    } eFunctionType;

    virtual eFunctionType getFunctionType() const = 0;

    virtual uint32 getNumInputValues() const = 0;

    virtual uint32 getNumOutputValues() const  = 0;
 
#ifdef SWIG
    %apply float &OUTPUT { float &low };
    %apply float &OUTPUT { float &high };
#endif
    virtual void getInputDomain(uint32 inputNum, float &low, float &high) const = 0;

    virtual bool getOutputRange(uint32 outputNum, float &low, float &high) const = 0;
#ifdef SWIG
    %clear float &low;
    %clear float &high;
#endif
 
#ifdef SWIG
#if SWIGJAVA
    %apply float[]  { const float *inputValues };
    %apply float[]  { float *outputValues };
#endif
#if SWIGCSHARP
    %apply float INPUT  []  { const float *inputValues };
    %apply float OUTPUT []  { float *outputValues };
#endif
#endif
    virtual void evaluate (const float *inputValues, float *outputValues) const = 0;
#ifdef SWIG
    %clear const float *inputValues;
    %clear float *outputValues;
#endif
 
#ifdef SWIG
#if SWIGJAVA
    %apply int32_t[] { const int32 *inputValues };
    %apply float[]   { float *outputValues };
#endif
#if SWIGCSHARP
    %apply int32_t INPUT  [] { const int32 *inputValues };
    %apply float   OUTPUT [] { float *outputValues };
#endif
#endif
    virtual void evaluate (const int32 *inputValues, float *outputValues) const = 0;
#ifdef SWIG
    %clear const int32 *inputValues;
    %clear float *outputValues;
#endif
};
 
DECL_SMART_PTR(IDOMFunction);
#define edlobj2IDOMFunction(src) edl_cast((IDOMFunction *)NULL, src)
 
typedef CEDLVector<IDOMFunctionPtr> CFunctionVector;
 

class IDOMSampledFunction : public IDOMFunction
{
#define IDOMSampledFunctionClassID 0x4f107645, 0x3bad4e88, 0xb28abc9d, 0x77fdc5ac
public:
 
    virtual ~IDOMSampledFunction() {}

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

    typedef enum
    {
        eLinearInterpolation,
        eCubicInterpolation
    } eInterpolationMethod;

    class Data : public CClassParams
    {
    public:
        Data(): numInputs(0), numOutputs(0),bitsPerSample(0),
            interpolationMethod(eLinearInterpolation)
        {}
        uint32               numInputs;
        CEDLVector<float>    domain;
        uint32               numOutputs;
        CEDLVector<float>    range;
        CEDLVector<uint32>   size;
        uint8                bitsPerSample;
        eInterpolationMethod interpolationMethod;
        CEDLVector<float>    encode;
        CEDLVector<float>    decode;
        CEDLVector<uint8>    table;
    };

    virtual uint32 getTableDimension(uint32 inputNum) const = 0;

    virtual uint8 getBitsPerSample() const = 0;

    virtual eInterpolationMethod getInterpolationMethod() const = 0;
 
#ifdef SWIG
    %apply float &OUTPUT { float &low  };
    %apply float &OUTPUT { float &high };
#endif
    virtual void getInputEncode(uint32 inputNum, float &low, float &high) const = 0;

    virtual void getOutputDecode(uint32 outputNum, float &low, float &high) const = 0;
#ifdef SWIG
    %clear float &low;
    %clear float &high;
#endif

    virtual const CEDLVector<uint8> &getTableData() const = 0;
 
};
 
DECL_SMART_PTR(IDOMSampledFunction);
#define edlobj2IDOMSampledFunction(src) edl_cast((IDOMSampledFunction *)NULL, src)

class IDOMExponentialFunction : public IDOMFunction
{
#define IDOMExponentialFunctionClassID 0x2daf61c4, 0x7e1e11dc, 0x83140800, 0x200c9a66
public:
 
    virtual ~IDOMExponentialFunction() {}

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

    class Data : public CClassParams
    {
    public:
        Data(): numOutputs(0), exponent(1.0)
        {
        }
        CEDLVector<float> domain;
        uint32            numOutputs;
        CEDLVector<float> range;
        CEDLVector<float> c0;
        CEDLVector<float> c1;
        float             exponent;
    };

    virtual float getOutputC0(uint32 outputNum) const = 0;

    virtual float getOutputC1(uint32 outputNum) const = 0;

    virtual float getExponent() const = 0;
 
};
 
DECL_SMART_PTR(IDOMExponentialFunction);
#define edlobj2IDOMExponentialFunction(src) edl_cast((IDOMExponentialFunction *)NULL, src)
 

class IDOMStitchingFunction : public IDOMFunction
{
#define IDOMStitchingFunctionClassID 0x565924fc, 0x7e2011dc, 0x83140800, 0x200c9a66
public:
 
    virtual ~IDOMStitchingFunction() {}

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

    class Data : public CClassParams
    {
    public:
        Data(): domain(0), numOutputs(0), range(0),
            bounds(0), encode(0)
        {
        }
        CEDLVector<float> domain;
        uint32            numOutputs;
        CEDLVector<float> range;
        CEDLVector<float> bounds;
        CEDLVector<float> encode;
        CFunctionVector   functions;
    };

    virtual uint32 getNumFunctions() const = 0;

    virtual IDOMFunctionPtr getFunctionAtIndex(uint32 index) const = 0;

    virtual const CEDLVector<float> &getBoundsVector() const = 0;

    virtual const CEDLVector<float> &getEncodeVector() const = 0;
 
};
 
DECL_SMART_PTR(IDOMStitchingFunction);
#define edlobj2IDOMStitchingFunction(src) edl_cast((IDOMStitchingFunction *)NULL, src)

class IDOMGroupingFunction : public IDOMFunction
{
#define IDOMGroupingFunctionClassID 0x77077047, 0x5d4a4d47, 0xb4b08719, 0x25b1b24f
public:
 
    virtual ~IDOMGroupingFunction() {}

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

    class Data : public CClassParams
    {
    public:
        CFunctionVector functions;
    };

    virtual uint32 getNumFunctions() const = 0;

    virtual IDOMFunctionPtr getFunctionAtIndex(uint32 index) const = 0;
 
};
DECL_SMART_PTR(IDOMGroupingFunction);
#define edlobj2IDOMGroupingFunction(src) edl_cast((IDOMGroupingFunction *)NULL, src)
 

class IDOMPostScriptCalculatorFunction : public IDOMFunction
{
#define IDOMPostScriptCalculatorFunctionClassID 0x220a9a6c, 0x7e2511dc, 0x83140800, 0x200c9a66
public:
 
    virtual ~IDOMPostScriptCalculatorFunction() {}

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

    class Data : public CClassParams
    {
    public:
        Data(): numInputs(1), domain(0), numOutputs(0), range(0), pFactory (NULL)
        {
        }
        CEDLVector<float>      domain;
        uint32                 numInputs;
        uint32                 numOutputs;
        CEDLVector<float>      range;
        JawsMako::IPDFArrayPtr proc;
        IEDLClassFactory      *pFactory;
    };

    virtual IInputStreamPtr getCalculatorAsPostScriptStream() const = 0;

    virtual JawsMako::IPDFArrayPtr getCalculator () const = 0;
};
 
DECL_SMART_PTR(IDOMPostScriptCalculatorFunction);
#define edlobj2IDOMPostScriptCalculatorFunction(src) edl_cast((IDOMPostScriptCalculatorFunction *)NULL, src)
 
 
_END_EDL_DOM_NAMESPACE
 
#endif /* EDLIDOMFUNCTION_H */