UT/UT_Color.h

Go to the documentation of this file.

#ifndef _UT_Color_
#define _UT_Color_

#include "UT_API.h"
#include <iostream.h>
#include <SYS/SYS_Types.h>

class UT_IStream;

//
// Each color space has its own range for each of the three parameters.
//
// RGB: 0..1, 0..1, 0..1
// HSL: 0..360, 0..1, 0..1
// HSV: 0..360, 0..1, 0..1
// XYZ: 0..1, 0..1, 0..1 work well 
// LAB: 0..100, a/b are unbounded but TIFF uses [-128, 127]

enum UT_ColorType {
        UT_HSL, UT_HSV, UT_RGB, UT_XYZ, UT_LAB
};

enum UT_ColorRamp {
    UT_COLORRAMP_FALSE,         // False colour
    UT_COLORRAMP_PINK,          // White-red
    UT_COLORRAMP_MONO,          // Black-white
    UT_COLORRAMP_BLACKBODY,     // Black-red-yellow-white
    UT_COLORRAMP_NUMMODES       // Illegal value.
};

class UT_Color;
class UT_Vector3;

//
//  Filter functions useable with UI_Vector class:
//
UT_API extern void              UT_RGBtoHSV(float *values, int nvalues);
UT_API extern void              UT_HSVtoRGB(float *values, int nvalues);

#define UT_BLACK        (UT_Color::getConstantColor(0))
#define UT_BLUE         (UT_Color::getConstantColor(1))
#define UT_GREEN        (UT_Color::getConstantColor(2))
#define UT_RED          (UT_Color::getConstantColor(3))
#define UT_CYAN         (UT_Color::getConstantColor(4))
#define UT_MAGENTA      (UT_Color::getConstantColor(5))
#define UT_YELLOW       (UT_Color::getConstantColor(6))
#define UT_WHITE        (UT_Color::getConstantColor(7))
#define UT_GREY1        (UT_Color::getConstantColor(8))
#define UT_GREY2        (UT_Color::getConstantColor(9))
#define UT_GREY3        (UT_Color::getConstantColor(10))
#define UT_GREY4        (UT_Color::getConstantColor(11))
#define UT_GREY5        (UT_Color::getConstantColor(12))
#define UT_GREY6        (UT_Color::getConstantColor(13))
#define UT_GREY7        (UT_Color::getConstantColor(14))
#define UT_GREY8        (UT_Color::getConstantColor(15))
#define UT_GREY9        (UT_Color::getConstantColor(16))

/*
 *  UT_Color is the base class for colors in one of the above color spaces
 */

class UT_API UT_Color {
public:
    UT_Color();
    UT_Color(UT_ColorType t);
    UT_Color(UT_ColorType t, fpreal x, fpreal y, fpreal z);
    UT_Color(const UT_Color &c);
    UT_Color(const char *colorname);

    virtual ~UT_Color();

    UT_ColorType getType() const { return type; }
    
    void         getValue(float &x, float &y, float &z) const
                    { x = u; y = v; z = w;}
    void         getValue(fpreal64 &x, fpreal64 &y, fpreal64 &z) const
                    { x = fpreal64(u); y = fpreal64(v); z = fpreal64(w);}
    virtual void getRGB(float *r, float *g, float *b) const
                 {
                     // Small optimization since we work in RGB most times.
                     if(type == UT_RGB) { *r = u; *g=v; *b = w; }
                     else               getRGBConvert(r,g,b);
                 }

    virtual void getHSV(float *h, float *s, float *v) const;
    virtual void getHSL(float *h, float *s, float *l) const;
    virtual void getXYZ(float *x, float *y, float *z) const;
    virtual void getLAB(float *l, float *a, float *b) const;
    void         getColor(UT_Color &c) const { c = *this; }
    
    /// luminance() actually returns "luma", an approximation of luminance
    /// derived from the gamma corrected rgb values. So if you have linear
    /// rgb values and call this function, you will get the wrong result.
    fpreal       luminance() const;

    /// relativeLuminance() returns relative luminance [0,1] assuming the color
    /// is in linear RGB.
    fpreal       relativeLuminance() const;

    void         setType(UT_ColorType t);
    void         setValue(fpreal x, fpreal y, fpreal z) { u = x; v = y; w = z; }
    virtual void setRGB(fpreal r, fpreal g, fpreal b);
    virtual void setHSV(fpreal h, fpreal s, fpreal v);
    virtual void setHSL(fpreal h, fpreal s, fpreal l);
    virtual void setXYZ(fpreal x, fpreal y, fpreal z);
    virtual void setLAB(fpreal l, fpreal a, fpreal b);
    virtual void setLABluminance(fpreal l);
    
    virtual void setColorByName(const char *colorname);
        
    void        clampToLegal();

    void ghost( fpreal gfactor = 0.75f );

    void operator=(const UT_Color &c);

    int         operator==(const UT_Color &color) const;
    uint32      hash() const;

    void        brighten(fpreal amount);        // *this *= clr
    void        tintRGB(const UT_Color &clr);   // *this *= clr;
    void        addHSV(const UT_Color &clr);    // *this += clr
    void        addRGB(const UT_Color &clr);    // *this += clr
    void        subRGB(const UT_Color &clr);    // *this -= clr

    // *this = lerp(*this, clr, bias) = (1-bias)*this + bias*clr
    void        blendRGB(const UT_Color &clr, fpreal bias=0.5);

    // Class I/O methods.  Return 0 if successful, -1 if not
    int          save(ostream &os, int binary) const;
    bool         load(UT_IStream &is);

    const char  *className() const;

    /// Computes a ramp colour from the predefined ramp enums.
    static void getRampColor(UT_ColorRamp ramp, fpreal val,
                        float *r, float *g, float *b);

    /// A mapping from integers to colours that tries to ensure
    /// that the chosen colours are well separated and aesthetically
    /// pleasing.
    static void getUniqueColor(int64 idx,
                        float *r, float *g, float *b);

    // Returns the standard color at index i.
    static const UT_Color &getConstantColor(int i);

    /// Obtain a random color that is contrasting to the specified other color.
    /// If null is passed for other color, a random color is returned.
    static void getRandomContrastingColor( const UT_Vector3 * contrast_to,
        unsigned color_index, UT_Vector3 &color );

protected:

    // modifies the color with a random luminance
    // (rand_num is a uniformly distributed random number between 0 and 1)
    // NB: - we can only handle colors with at least 1 zero component
    //     - black colors are un-modified
    static void assignRandomLuminance( UT_Vector3 &color );


protected:
    UT_ColorType         type;
    float                u;
    float                v;
    float                w;
    void                 convertToType(UT_ColorType type);
    void                 convertToHSL();
    void                 convertToHSV();
    void                 convertToRGB();
    void                 convertToXYZ();
    void                 convertToLAB();
    
    void                 getRGBConvert(float *r, float *g, float *b) const;

private:
    //To allow proper and safe saving for a UT_Color in UT_OptionFile, we 
    //override these operators. They simply call save/load respectively.
    friend UT_API ostream       &operator<<(ostream &os, const UT_Color &color);
};

#endif

---