PXL/PXL_Raster.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Alexander
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        PXL_Raster.h    (Pixel Library, C++)
 *
 * COMMENTS:
 *      Defines a more generic raster for texture maps & display. 
 *      
 */
#ifndef PXL_RASTER_H
#define PXL_RASTER_H

#include <iostream.h>
#include <UT/UT_Rect.h>
#include "PXL_API.h"
#include "PXL_Common.h"
#include <UT/UT_SmallObject.h>

class UT_IStream;

#define PXL_ROFF        16

enum PXL_StreakComponents {
    PXL_STREAK_ALL  = 0,
    PXL_STREAK_RGB,
    PXL_STREAK_A
};

class PXL_API PXL_Raster
    : public UT_SmallObject<PXL_Raster,
                            UT_SMALLOBJECT_CLEANPAGES_OFF, 250,
                            UT_SMALLOBJECT_THREADSAFE_ON>
{
public:
                 PXL_Raster();
                 PXL_Raster(const PXL_Raster &);
                 PXL_Raster(const PXL_Raster &,
                            int x1, int y1, int x2, int y2);
                 PXL_Raster(PXL_Packing p, PXL_DataFormat f,
                            int xres = 0, int yres = 0, int clear = 0,
                            int alloc = 1);
    virtual     ~PXL_Raster();
    
    // Copy over all the information and data from the src.  This allocates a
    // new raster (rather than doing a shallow copy).
    virtual void        copy(const PXL_Raster &src);

    // initializes the raster (destroys any previous image data). If you call
    // any of these methods, call init() after to reallocate the raster.
    void                setPacking(PXL_Packing p);
    void                setFormat(PXL_DataFormat f);
    void                setRes(int x, int y);
    void                setBWPoints(float black, float white);
    
    void                init();
    
    // sets the raster data to r, optionally giving this class ownership of it.
    // make sure it's the right packing type, res & format!
    void                setRaster(void *r, bool give_ownership = true,
                                  bool use_offset = false);

    // steals ownership from this raster. Returns NULL if this raster doesn't
    // own the image.
    void *              steal();
    
    // packing, format & xres/yres must be set for the raster to be valid.
    int                 isValid() const    { return myRaster ? 1 : 0; }
    // accessers.
    int                 getXres() const    { return myXres; }
    int                 getYres() const    { return myYres; }
    int                 getNumPixels() const { return myXres * myYres; }
    int64               getStride() const  { return myStride; }
    int64               getSize() const    { return myRasterSize; }
    PXL_DataFormat      getFormat() const  { return myFormat; }
    PXL_Packing         getPacking() const { return myPacking; }
    void                getBWPoints(float &black, float &white) const;

    // data window
    void                setDataWindow(const UT_DimRect &new_rect);
    const UT_DimRect &  getDataWindow() const
                        { return myDataWindow; }
    bool                hasDataWindow() const
                        { return !myDataWindow.isEmpty(); }

    // returns the min/max values. black & white specify the black & white
    // of the raster, comp specifies an optional component to get the range
    // from. If ignore_farthest is true, 'max' will contain the 2nd largest
    // value. Good for ignoring the background.
    void                getRange(float &min, float &max,
                                 float black = 0.0f, float white = 1.0f,
                                 int comp = -1,
                                 bool ignore_farthest = false) const;

    // leave 2 pixels to draw grey single channels (R,G,B)
    void *              getPixels()
                        { return (unsigned char *)myRaster+myRasterOffset; }
    
    const void *        getPixels() const
                        { return (unsigned char *)myRaster+myRasterOffset; }

    // this is for drawing single greyscale R,G,B images.
    const void *        getRawPixels() const
                        { return myRaster; }

    // x/y coords, + comp# for Non-interleaved data (0-2 for RGB, 0-3 RGBA). 
    void *              getPixel(int x, int y, int comp = 0);
    const void *        getPixel(int x, int y, int comp = 0) const;

    void                getPixelValue(int x, int y, float *vals) const;

    // returns 1 if interleaved (RGBRGB), 0 otherwise. 
    int                 isInterleaved() const;

    // returns 1 if this raster can have its components rendered separately.
    int                 areComponentsRenderable() const;
    
    // if not interleaved, returbs the size of 1 channel's data. 
    int64               getNonInterleavedSize() const;
    
    // simple operations.

    // clears the raster to 0, unless color is not null; it assumes it points
    // to 8/16/32 bit int or float single/triple/quad value, depending on
    // packing type & data format. 
    void                clear(void *color = 0);
    void                clearNormal(float *color,
                                    unsigned ib = 0,
                                    unsigned iw = 0);


    // reads a scanline from the raster. THe buffer must be big enough to
    // hold a single scanline at the data format and packing of the raster.
    void                readFromRow(int y, void *data) const;
    
    // Writes a scanline to the raster. The data format and packing are
    // assumed to match the raster's. 
    void                writeToRow(int y, const void *data);
    
    // instead of writing a scanline, this writes a column of data. The
    // data format and packing are assumed to match the raster's, and
    // have yres pixels. Useful for flopping images.
    void                writeToColumn(int x, const void *data);

    // deletes the image memory. If full = 1, everything is reset - xres/yres
    // to 0, packing and format to invalid.
    virtual void        reset(int full = 0);

    void                extract(const PXL_Raster &from,
                                int x1, int y1, int x2, int y2);

    void                applyLUT(const PXL_Raster *src, float *lptr[4], 
                                 int comp, float lstart, float lend);
    // of the raster. The rectangle can go outside of the raster.
    void                streakEdges(int x1,int y1, int x2,int y2,
                           PXL_StreakComponents streak_comps = PXL_STREAK_ALL);
    void                convert8Bit(unsigned b, unsigned w);

    void                adjustSaturation(float sat);

    bool                 load(UT_IStream &is);
    int                  save(ostream &os, int binary = 1) const;
    
    int                  getProxyIndex() const { return myProxyIndex; }
    
    void                 setDataWritten(bool written = true)
                         { myWriteFlag = written; }
    bool                 getDataWritten() const { return myWriteFlag; }

    void                 setTextureID(unsigned int id) { myTextureID = id; }
    unsigned int         getTextureID() const;
    void                 clearTextureID();

    // dither the image in a subdued way for mplay's render over previous.
    // If a crop region is provided, only pixels inside the crop will be
    // dimmed.
    void                dither(const UT_DimRect &crop);
    void                dither();

protected:
    virtual void        initialize();
    void                allocRaster(int alloc_mem = 1);

    void                applyLUT8(const PXL_Raster *src, float *lptr[4], 
                                   int comp, float lscale, float lshift,
                                   int size);
    void                applyLUT16(const PXL_Raster *src, float *lptr[4], 
                                   int comp, float lscale, float lshift,
                                   int size);

    virtual void        attemptRealloc(int64 size);
   
    PXL_DataFormat      myFormat;
    PXL_Packing         myPacking;
    unsigned int        myRasterOffset;
    int                 myXres, myYres;
    int64               myStride;
    int64               myRasterSize;
    float               myBlack, myWhite;
    void                *myRaster;
    bool                myAmOwner;
    int                 myProxyIndex;
    bool                myWriteFlag;
    unsigned int        myTextureID;

    UT_DimRect          myDataWindow;           // (0,0) is lower-left corner
};
#endif

---