TIL_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.
 *
 * NAME:        TIL_Raster.h    (Tile Image Library, C++)
 *
 * COMMENTS:
 *      Defines a more generic raster for texture maps & display. This class
 *      is designed to be a raster container, not a raster manipulation class. 
 */
#ifndef TIL_RASTER_H
#define TIL_RASTER_H

#include "TIL_API.h"
#include "TIL_Defines.h"
#include <PXL/PXL_Raster.h>
#include <UT/UT_FilterType.h>
#include <UT/UT_VectorTypes.h>
#include <SYS/SYS_Types.h>


class IMG_Raster;
class UT_TokenString;

#define TIL_RASTER_COMPLETE     0
#define TIL_RASTER_INCOMPLETE   1
#define TIL_RASTER_CORRUPT     -1

class TIL_API TIL_Raster : public PXL_Raster
{
public:
                 TIL_Raster();
                 TIL_Raster(const TIL_Raster &raster);
                 TIL_Raster(const PXL_Raster &raster);
                 TIL_Raster(const IMG_Raster &raster, bool copy = true);
                 TIL_Raster(const TIL_Raster &raster,
                            exint x1, exint y1, exint x2, exint y2);
                 TIL_Raster(TIL_Packing p, TIL_DataFormat f,
                            exint xres = 0, exint yres = 0, int clear = 0,
                            int alloc = 1);
                ~TIL_Raster() override;

    int64               getMemoryUsage(bool inclusive) const override;

    // takes ownership.
    void                  setID(UT_TokenString *token);
    const UT_TokenString *getID() const { return myID; }

    void                copy(const PXL_Raster &src) override;

    /// copies only the raster properties (res, type, etc), not the data, nor
    /// does this method allocate memory for a raster.
    void                copyProperties(const PXL_Raster &src) override;

    /// Transfers the raster to a PXL_Raster. Data is moved and no longer owned.
    UT_UniquePtr<PXL_Raster>  moveToPXL();
    /// Grabs the raster from a PXL_Raster. Data is moved and no longer owned by
    /// 'raster'.
    static UT_UniquePtr<TIL_Raster> moveFromPXL(PXL_Raster *raster);

    // deletes the image memory. If full = 1, everything is reset - xres/yres
    // to 0, packing and format to invalid.
    void                reset(int full = 0) override;
    
    // Scale this raster to another output raster.
    // You can't do format conversions here.
    void                scaleFromRasterToSize(TIL_Raster *scaled,
                                              exint xres,exint yres,
                                        UT_FilterType flt=UT_FILTER_BOX,
                                        bool try_preserve_bit_values=false) const;
    
    void                scaleFromRasterToScale(TIL_Raster *scaled,
                                               float xsc,float ysc,
                                        UT_FilterType flt=UT_FILTER_BOX,
                                        bool try_preserve_bit_values=false) const;

    /// Scales the source raster window to the destination window size and
    /// inserts the result at (tox, toy) location of this raster. Incoming 
    /// coordinates and sizes should be compatible with the respective 
    /// rasters.
    /// You can't do format conversions here.
    void scaledInsertFromRaster(const PXL_Raster* source,
                                UT_FilterType ftype,
                                exint fromx, exint fromy,
                                exint fromsizex, exint fromsizey,
                                exint tox, exint toy,
                                exint tosizex, exint tosizey);


    static void         scaleRasterToSize(PXL_Raster *scaled,
                                    const PXL_Raster *source,
                                    exint xres, exint yres,
                                    UT_FilterType flt=UT_FILTER_BOX,
                                    bool try_preserve_bit_values=false);
    static void         scaleRasterToScale(PXL_Raster *scaled,
                                    const PXL_Raster *source,
                                    float xsc, float ysc,
                                    UT_FilterType flt=UT_FILTER_BOX);
                                    


    // applyEmulation is like applyLUT but does not use a look up table and
    // instead performs the calculations on each pixel.
    // It is currently only implemented for FLOAT32 rasters, for anything else
    // you should use applyLUT.
    void                applyEmulation(const TIL_Raster *src,
                                       float black, float white,
                                       float scale, float shift,
                                       float gamma, exint comp = -1);
    
    void                adjustGamma(float gamma,
                                    bool red   = true, 
                                    bool green = true, 
                                    bool blue  = true, 
                                    bool alpha = false);

    // Raster diff functions. Source rasters must be the same format, packing
    // and size as this raster.
    void                splitHRaster(const TIL_Raster *r1,
                                     const TIL_Raster *r2, float fract);
    void                splitVRaster(const TIL_Raster *r1,
                                     const TIL_Raster *r2, float fract);
    void                blendRaster(const TIL_Raster *r1,
                                    const TIL_Raster *r2, float fract);
    void                diffRaster(const TIL_Raster *r1,const TIL_Raster *r2);
    void                subRaster(const TIL_Raster *r1,const TIL_Raster *r2);
    void                highlightRaster(const TIL_Raster *r1,
                                        const TIL_Raster *r2, float threshold);
    
    void                 setUserData(void *data) { myUserData = data; }
    void                *getUserData()           { return myUserData; }

    // returns true if an edge > tolerance was found within distance pixels
    // of (x,y). The location of the edge is returned in (x,y). If dir and
    // pos are specified, points along the dir vector from pos are favoured.
    bool                 getClosestEdge(exint &x, exint &y, exint distance,
                                        float tolerance = 0.1f,
                                        UT_Vector2 *pos = 0,
                                        UT_Vector2 *dir = 0);
    
    // TIL_RASTER_COMPLETE  - raster is filled & okay
    // TIL_RASTER_INCOMPLETE- raster was user-interrupted during construction.
    // TIL_RASTER_CORRUPT   - an error occurred during construction.
    void                setIncomplete(int inc = 1);
    int                 isIncomplete() const { return myIncompleteState; }
    
protected:
    void                attemptRealloc(int64 size) override;
   
    void                initialize() override;

private:
    // optional.
    UT_TokenString      *myID = nullptr;
    void                *myUserData;
    int                  myIncompleteState;
};

#endif