---

Image.h

Go to the documentation of this file.

/*
    File:       Image.h

    Function:   Defines an image: a 2D array of pixels. Provides common
                operations on images.
                    
    Author(s):  Andrew Willmott

    Copyright:  (c) 1997-2000, Andrew Willmott
 */


#ifndef __Image__
#define __Image__

#include "gcl/Colour.h"
#include "cl/FileName.h"

// --- Useful enums -----------------------------------------------------------

enum ImgChannel
{
    chMono,
    chRed,
    chGreen,
    chBlue,
    chAlpha,
    chMatte,
    chDepth,
    chMax = 16
};

enum ImgStoreType
{
    imgByte,
    imgUInt16,
    imgUInt32,
    imgFloat,
    imgDouble,
    imgFloat3,
    imgDouble3,
    imgStoreMax
};

enum 
{
    rgba_R = 0,
    rgba_G = 1,
    rgba_B = 2,
    rgba_A = 3
};

struct RGBAPixel
{
    Byte    ch[4];
};

// Ward's RGB + exponent format
typedef RGBAPixel RGBEPixel;

enum ImgTag
{
    imgRGBATag,
    imgByteTag,
    imgRGBETag,
    imgChannelTag,
    imgMaxTags
};

// --- Generic image class ----------------------------------------------------

class Image 
{
public:
    Image(ImgTag it) : width(0), height(0), tag(it) {};

    virtual Void    SetSize(Int width, Int height) = 0;

    Int             Height() const { return(height); };
    Int             Width() const { return(width); };

    virtual Void    Clear(const Colour &c) = 0;
    virtual Void    CopyFrom(Int x, Int y, Image &i);

    virtual Void    GammaCorrect(ClrReal gamma = 2.2);
    virtual Void    Scale(ClrReal scale);
    virtual ClrReal MaxComponent();
    virtual Colour  AverageColour();
    virtual Void    FindComponentBounds(Colour &min, Colour &max);
    virtual Void    Transform(const ClrTrans &trans);
    virtual Void    Over(Int x, Int y, Image &i);
    virtual Void    DownSample(Image &out);

// pixel operations
    virtual Void    SetPixel(Int x, Int y, const Colour &c) = 0;
    virtual Colour  GetPixel(Int x, Int y) const = 0;

    virtual Void    SetRealPixel(Int x, Int y, ClrReal r,
                                 ImgChannel channel = chMono);
    virtual ClrReal GetRealPixel(Int x, Int y, 
                                 ImgChannel channel = chMono) const;

// span operations
    virtual Void    SetSpan(Int row, Int start, Int length, 
                            const Colour *src) = 0;
    virtual Void    GetSpan(Int row, Int start, Int length, 
                            Colour *dst) const = 0;

    virtual Void    SetRGBASpan(Int row, Int start, Int length,
                                const RGBAPixel *src);
    virtual Void    GetRGBASpan(Int row, Int start, Int length, 
                                RGBAPixel *dst) const;

    virtual Void    SetRealSpan(Int row, Int start, Int length,
                                const ClrReal *src, ImgChannel channel = chMono);
    virtual Void    GetRealSpan(Int row, Int start, Int length,
                                ClrReal *dst, ImgChannel channel = chMono) const;

    virtual Void    SetByteSpan(Int row, Int start, Int length,
                                const Byte *src, ImgChannel channel = chMono);
    virtual Void    GetByteSpan(Int row, Int start, Int length, 
                                Byte *dst, ImgChannel channel = chMono) const;
 
    // generic load/save : type is inferred from the extension
    Int             Save(FileName &filename);
    Int             Load(FileName &filename);
    static Void     PrintSupportedFormats(ostream &s);
    
    // specialised load/save
    Int             SavePPM(const Char *filename);
    Int             LoadPPM(const Char *filename);     
    Int             SaveTIFF(const Char *filename);
    Int             LoadTIFF(const Char *filename);
    Int             SaveJPEG(const Char *filename);
    Int             LoadJPEG(const Char *filename);
    Int             SaveGIF(const Char *filename);
    Int             LoadGIF(const Char *filename);

    ImgTag          Tag() const { return(tag); };
    
    static Int      sJPEGQuality;   // 0..100, default = 90

protected:
    Int             width;
    Int             height;
    ImgTag          tag;
};


// --- Specific image classes -------------------------------------------------

class RGBAImage : public Image
{
public:
    RGBAImage() : Image(imgRGBATag), data(0) {};
    
    Void    SetSize(Int width, Int height);

    Void    Clear(const Colour &c);
    Void    SetPixel(Int x, Int y, const Colour &c);
    Colour  GetPixel(Int x, Int y) const;
    Void    SetSpan(Int row, Int start, Int length, const Colour *src);
    Void    GetSpan(Int row, Int start, Int length, Colour *dst) const;
    Void    SetRGBASpan(Int row, Int start, Int length, const RGBAPixel *src);
    Void    GetRGBASpan(Int row, Int start, Int length, RGBAPixel *dst) const;

    RGBAPixel
            *RGBAData() const {return(data);};

protected:
    RGBAPixel   *data;
};

class ByteImage : public Image
{
public:
    ByteImage() : Image(imgByteTag), data(0) {};
    
    Void    SetSize(Int width, Int height);

    Void    Clear(const Colour &c);
    Void    SetPixel(Int x, Int y, const Colour &c);
    Colour  GetPixel(Int x, Int y) const;
    Void    SetRealPixel(Int x, Int y, ClrReal r, ImgChannel channel = chMono);
    ClrReal GetRealPixel(Int x, Int y, ImgChannel channel = chMono) const;

    Void    SetSpan(Int row, Int start, Int length, const Colour *src);
    Void    GetSpan(Int row, Int start, Int length, Colour *dst) const;
    Void    SetByteSpan(Int row, Int start, Int length,
                    const Byte *src, ImgChannel channel = chMono);
    Void    GetByteSpan(Int row, Int start, Int length, 
                    Byte *dst, ImgChannel channel = chMono) const;

    Byte    *ByteData() const {return(data);};

protected:
    Byte    *data;
};

class RGBEImage : public Image
{
public:
    RGBEImage() : Image(imgRGBETag), data(0) {};
    
    Void    SetSize(Int width, Int height);

    Void    Clear(const Colour &c);
    Void    SetPixel(Int x, Int y, const Colour &c);
    Colour  GetPixel(Int x, Int y) const;
    Void    SetSpan(Int row, Int start, Int length, const Colour *src);
    Void    GetSpan(Int row, Int start, Int length, Colour *dst) const;

    Int     SavePIC(const Char *filename);
    Int     LoadPIC(const Char *filename);

    RGBEPixel
            *RGBEData() const {return(data);};

protected:
    RGBEPixel   *data;
};

Colour      RGBEToColour(RGBEPixel rgbe);
RGBEPixel   ColourToRGBE(const Colour &c);


// --- Channel-based image ----------------------------------------------------

#ifdef UNFINISHED
class ChannelImage : public Image
{
public:
    ChannelImage();

    SetImageType();
    SetImageLayer();

protected:
    Void            *chData[chMax];
    ImgStoreType    chType[chMax];
}
#endif


// --- Conversion routines ----------------------------------------------------

inline Colour RGBAToColour(RGBAPixel rgba)
{
    Colour result;
    result[0] = rgba.ch[rgba_R] / 255.0;
    result[1] = rgba.ch[rgba_G] / 255.0;
    result[2] = rgba.ch[rgba_B] / 255.0;
    return(result); 
}

inline RGBAPixel ColourToRGBA(const Colour &c)
{
    RGBAPixel result;
    result.ch[rgba_R] = (Byte) (c[0] * 255.0);
    result.ch[rgba_G] = (Byte) (c[1] * 255.0);
    result.ch[rgba_B] = (Byte) (c[2] * 255.0);
    return(result); 
}

inline Colour ByteToColour(Byte b)
{
    Colour  result;
    ClrReal temp = b / 255.0;

    result[0] = temp;
    result[1] = temp;
    result[2] = temp;
    return(result); 
}

inline Byte ColourToByte(const Colour &c)
{
    ClrReal temp;

    temp = c[0] + c[1] + c[2];
    return((Byte) (temp * (255.0 / 3.0)));
}

#endif

---