colour_management.h

Go to the documentation of this file.

#ifndef LWPP_COLORSPACE_H
#define LWPP_COLORSPACE_H

#include <lwpp/storeable.h>
#include <lwpp/wrapper.h>

namespace lwpp
{

#define LWPP_COLORSPACEFUNCS_GLOBAL "LWColorSpace"

  enum LWColourSpace {
    lwcs_linear = 0,                
    lwcs_sRGB,                      
    lwcs_rec709,                    
    lwcs_cineon,                    
    lwcs_ciexyz,                    
    lwcs_sizeof
  };

  enum LWColorSpaceType {
    lwcst_viewer = 0,               
    lwcst_surface_color,            
    lwcst_light_color, 
    lwcst_palette_files,            
    lwcst_8bit_files,               
    lwcst_float_files,              
    lwcst_alpha_files,              
    lwcst_output,                   
    lwcst_output_alpha,             
    lwcst_sizeof
  };

  enum LWColourSpaceConversion {
    lwcsc_colorspaceToLinear = 0,   
    lwcsc_linearToColorspace,       
    lwcsc_sizeof
  };

  enum LWColourSpaceLayer {
    lwcsl_RGB = 0,                  
    lwcsl_Alpha,                    
    lwcsl_sizeof
  };

  struct st_lwimagelookup;
  typedef void LWPixelConversionRGBFunc(   struct st_lwimagelookup *, float *, float * ); 
  typedef void LWPixelConversionAlphaFunc( struct st_lwimagelookup *, float *, float * ); 
  typedef struct st_lwcolorspacefuncs {

    /* These function are used to get the color space of a loaded converter or load one from the disk. */

    LWColourSpace            (*nameToColorSpace       )( char * );               
    LWColourSpace            (*loadPixelLookupTable   )( char * );               
    /* These functions are used to get the pixel conversion functions. */

    LWPixelConversionRGBFunc   *(*getPixelConversionRGB  )( LWColourSpace, LWColourSpaceConversion, struct st_lwimagelookup ** );
    LWPixelConversionAlphaFunc *(*getPixelConversionAlpha)( LWColourSpace, LWColourSpaceConversion, struct st_lwimagelookup ** );

    /* These functions are used to get color space names and file names, based on type. */

    const char             *(*colorSpaceName         )( LWColorSpaceType );    
    const char             *(*colorSpaceFile         )( LWColorSpaceType );    
    /* These functions are used in pop-ups. */

    int                     (*numberOfColorSpaces    )( LWColourSpaceLayer );    
    const char             *(*nameOfColorSpaces      )( LWColourSpaceLayer, int);
    LWColourSpace            (*indexToColorSpace      )( LWColourSpaceLayer, int);
    int                     (*colorSpaceToIndex      )( LWColourSpaceLayer, LWColourSpace );

    /* This functions is to change the currently selected color space. */

    int                     (*setColorSpace          )( LWColorSpaceType, LWColourSpace );

  } LWColorSpaceFuncs;

  
  
  class ColourManager : public PopUpCallback, public Storeable, public GlobalBase<LWColorSpaceFuncs>
  {
    LWPixelConversionRGBFunc *toLinear, *toColourSpace;
    st_lwimagelookup *ilt, *ilf;
    char *fileLUT;
    LWColorSpaceType type;
    LWColourSpace cSpace;
    LWColourSpaceLayer mLayer;    
    bool useDefault;
    bool Standalone;
    bool supportLUT;
  protected:

    virtual size_t popCount();

    virtual const char *popName(int n);
  public:
    ColourManager(LWColorSpaceType _type, LWColourSpaceLayer layer = lwcsl_RGB, bool _supportLUT = false);

    ColourManager(LWColourSpace _cspace = lwcs_linear, LWColourSpaceLayer layer = lwcsl_RGB);
    
    ColourManager(ColourManager const& f);
    
    ColourManager& operator= (ColourManager const& f);

    bool operator!=(const ColourManager &comp) const;

    void Update();

    void convertToLinear(float *from, float *to)
    {
      if (toLinear)
      {
        toLinear(ilt, from, to);
      }
    }
    void convertToColourSpace(float *from, float *to)
    {
      if (toColourSpace)
      {
        toColourSpace(ilf, from, to);
      }
    }
    
    void convertToLinear(float *from)
    {
      if (toLinear)
      {
        toLinear(ilt, from, from);
      }
    }
    void convertToColourSpace(float *from)
    {
      if (toColourSpace)
      {
        toColourSpace(ilf, from, from);
      }
    }    
    
    float convertToLinear(float from)
    {
      if (toLinear)
      {
        float rgb[]= {from, 0.0, 0.0};
        toLinear(ilt, rgb, rgb);
        return rgb[0];
      }
      return from;
    }
    float convertToColourSpace(float from)
    {
      if (toColourSpace)
      {
        float rgb[]= {from, 0.0, 0.0};
        toColourSpace(ilf, rgb, rgb);
        return rgb[0];
      }
      return from;
    }
    
    int getIndex();

    void setIndex(int idx);

    virtual LWError Load(const LoadState &ls );

    virtual LWError Save(const SaveState &ss );
    
    LWColourSpace getColourSpace() const {return cSpace;}

  };

}
#endif // LWPP_COLORPSPACE_H