BRAY_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:        BRAY_Raster.h (BRAY Library, C++)
 *
 * COMMENTS:
 */

#ifndef __BRAY_Raster__
#define __BRAY_Raster__

#include "BRAY_API.h"
#include <PXL/PXL_Common.h>
#include <UT/UT_Assert.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_Rect.h>
#include <UT/UT_Vector2.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector4.h>
#include <SYS/SYS_TypeDecorate.h>
#include <algorithm>

class PXL_Raster;
class UT_JSONWriter;
class UT_JSONParser;

/// Simple raster container.
class BRAY_API BRAY_Raster
{
public:
    /// Construct a raster.  It's possible to have a reference to external
    /// raster data instead of allocating a raster.
    BRAY_Raster()
        : myRaster(nullptr)
    {
        setRes(0, 0, PACK_RGB, PXL_FLOAT32);
    }
    BRAY_Raster(exint xres, exint yres,
            PXL_Packing pack, PXL_DataFormat fmt,
            const void *raster = nullptr)
        : myRaster(reinterpret_cast<const char *>(raster))
    {
        setRes(xres, yres, pack, fmt);
        if (!myRaster)
            allocate();
    }
    ~BRAY_Raster()
    {
        freeRaster();
    }
    /// Set up a PXL_Raster to reference the data in this raster.  If you need
    /// to write to the PXL_Raster, @c for_write should be true.  This will
    /// assert that @c isWritable() is also true.
    void        setupReference(PXL_Raster &rp, bool for_write) const;

    static int64        memoryUsed();
    static int64        peakMemoryUsed();

    /// Clear storage
    void        freeRaster();
    void        resize(exint xres, exint yres,
                                PXL_Packing pack, PXL_DataFormat fmt)
    {
        if (myXres == xres && myYres == yres
                && myPacking == pack && myDataFormat == fmt)
        {
            return;
        }
        freeRaster();
        setRes(xres, yres, pack, fmt);
        allocate();
    }
    void        createFrom(const BRAY_Raster &rp)
    {
        resize(rp.xres(), rp.yres(), rp.packing(), rp.dataFormat());
        if (isValid())
            copyDataFrom(rp);
    }
    void        copyPropertiesFrom(const BRAY_Raster &rp)
    {
        UT_ASSERT(!rp.xres() && !rp.yres() && !xres() && !yres());
        myNChannels = rp.myNChannels;
        myBPChan = rp.myBPChan;
        myBPPixel = rp.myBPPixel;
        myBPScan = rp.myBPScan;
        myDataFormat = rp.myDataFormat;
        myPacking = rp.myPacking;
    }
    void        copyDataFrom(const BRAY_Raster &rp)
    {
        if (&rp != this)
        {
            UT_ASSERT((!rp.isValid() && !isValid())
                    || (myBuffer && imageBytes() == rp.imageBytes()));
            memcpy(myBuffer.get(), rp.raster(), rp.imageBytes());
        }
    }
    void        copyDataFrom(const PXL_Raster &rp);
    void        zeroPixels()
    {
        UT_ASSERT(myBuffer.get() || !imageBytes());

        //std::fill(myBuffer.get(), myBuffer.get()+imageBytes(), 0);
        memset(myBuffer.get(), 0, imageBytes()); // should be faster than fill
    }

    void        clearToFloat(float val)
    {
        if (val == 0.f)
        {
            zeroPixels();
            return;
        }

#define CLEAR_TO_FLOAT(FORMAT_T)                                        \
        {                                                               \
            using T = PXL_TypeResolver< FORMAT_T >::T;                  \
            T* buffer = writeRasterAs<T>();                             \
            T tval = (T)val;                                            \
            std::fill(                                                  \
                buffer,                                                 \
                buffer + (myXres * myYres * myNChannels),               \
                tval);                                                  \
        }                                                               \
        /* end macro */

        switch(myDataFormat)
        {
        case PXL_INT32:     CLEAR_TO_FLOAT(PXL_INT32);      break;
        case PXL_FLOAT32:   CLEAR_TO_FLOAT(PXL_FLOAT32);    break;
        default:
            UT_ASSERT(0);   // other types TODO, probably require PXL_Pixel
            break;
        }

#undef CLEAR_TO_FLOAT
    }

    /// Read access to the raster
    const void  *raster() const { return myRaster; }
    /// Read access to the raster as a given type
    template <typename T>
    const T     *rasterAs() const
    {
        UT_ASSERT_P(PXL_DataFormatResolver<T>::format == myDataFormat);
        return reinterpret_cast<const T *>(myRaster);
    }
    /// Write access to the raster
    void        *writeRaster()
    {
        UT_ASSERT(myBuffer);
        return myBuffer.get();
    }
    /// Write access to the raster as a given type
    template <typename T>
    T           *writeRasterAs()
    {
        UT_ASSERT(myBuffer);
        UT_ASSERT_P(PXL_DataFormatResolver<T>::format == myDataFormat);
        return reinterpret_cast<T *>(myBuffer.get());
    }

    /// Read access to a given scanline
    const void  *scanline(exint y) const { return myRaster+byteOffset(y); }

    /// Read access to a given pixel
    const void  *pixel(exint x, exint y) const
                    { return myRaster + byteOffset(x, y); }
    /// Read access to a given pixel as a given type
    template <typename T>
    const T     *pixelAs(exint x, exint y) const
    {
        UT_ASSERT_P(PXL_DataFormatResolver<T>::format == myDataFormat);
        return reinterpret_cast<const T *>(pixel(x, y));
    }

    /// Write access to a given pixel
    void        *writePixel(exint x, exint y) const
    {
        UT_ASSERT(myBuffer.get());
        return myBuffer.get() + byteOffset(x, y);
    }
    /// Write access to a given pixel as a given type
    template <typename T>
    T   *writePixelAs(exint x, exint y) const
    {
        UT_ASSERT_P(PXL_DataFormatResolver<T>::format == myDataFormat);
        return reinterpret_cast<T *>(writePixel(x, y));
    }

#define VECTOR_ACCESS(VEC, NAME) \
    const VEC   *rasterAs##NAME() const { \
        UT_ASSERT_P(VEC::tuple_size == nchannels()); \
        UT_ASSERT_P(PXL_DataFormatResolver<VEC::value_type>::format == myDataFormat); \
        return reinterpret_cast<const VEC *>(myRaster); \
    } \
    VEC         *writeRasterAs##NAME() const { \
        UT_ASSERT_P(VEC::tuple_size == nchannels()); \
        UT_ASSERT_P(PXL_DataFormatResolver<VEC::value_type>::format == myDataFormat); \
        UT_ASSERT(myBuffer.get()); \
        return reinterpret_cast<VEC *>(myBuffer.get()); \
    } \
    const VEC   *pixelAs##NAME(exint x, exint y) const { \
        UT_ASSERT_P(VEC::tuple_size == nchannels()); \
        UT_ASSERT_P(PXL_DataFormatResolver<VEC::value_type>::format == myDataFormat); \
        return reinterpret_cast<const VEC *>(pixel(x, y)); \
    } \
    VEC         *writePixelAs##NAME(exint x, exint y) const { \
        UT_ASSERT_P(VEC::tuple_size == nchannels()); \
        UT_ASSERT_P(PXL_DataFormatResolver<VEC::value_type>::format == myDataFormat); \
        UT_ASSERT(myBuffer.get()); \
        return reinterpret_cast<VEC *>(writePixel(x, y)); \
    } \
    /* end macro */
    VECTOR_ACCESS(UT_Vector2, Vec2)
    VECTOR_ACCESS(UT_Vector3, Vec3)
    VECTOR_ACCESS(UT_Vector4, Vec4)
    VECTOR_ACCESS(UT_Vector2F, Vec2f)
    VECTOR_ACCESS(UT_Vector3F, Vec3f)
    VECTOR_ACCESS(UT_Vector4F, Vec4f)
    VECTOR_ACCESS(UT_Vector2H, Vec2h)
    VECTOR_ACCESS(UT_Vector3H, Vec3h)
    VECTOR_ACCESS(UT_Vector4H, Vec4h)
#undef VECTOR_ACCESS

    bool        isValid() const { return myRaster && myXres > 0 && myYres > 0; }
    bool        isWritable() const { return myBuffer.get() != nullptr; }
    void        makeWriteable();

    PXL_Packing         packing() const { return myPacking; }
    PXL_DataFormat      dataFormat() const { return myDataFormat; }
    exint               npixels() const { return myXres*myYres; }
    exint               nchannels() const { return myNChannels; }
    exint               xres() const { return myXres; }
    exint               yres() const { return myYres; }
    exint               pixelBytes() const { return myBPPixel; }
    exint               scanBytes() const { return myBPScan; }
    exint               imageBytes() const { return myBPScan*myYres; }

    void                setStorage(PXL_Packing pack, PXL_DataFormat fmt)
    {
        UT_ASSERT(!myRaster && myXres == 0 && myYres == 0);
        setRes(myXres, myYres, pack, fmt);
    }

    void        dump() const;
    void        dump(UT_JSONWriter &w) const;

    bool        checkpoint(UT_JSONWriter &w) const;
    bool        loadCheckpoint(UT_JSONParser &p);

    /// Find the window where non-zero data exists
    UT_InclusiveRect    findDataWindow() const;

    int64       getMemoryUsage() const
    {
        return myYres*myBPScan;
    }

    bool        save(const char *filename) const;

private:
    void        allocate();
    exint       byteOffset(exint y) const
    {
        return myBPScan * y;
    }
    exint       byteOffset(exint x, exint y) const
    {
        return myBPPixel * (y*myXres + x);
    }
    void        setRes(exint xres, exint yres,
                        PXL_Packing pack, PXL_DataFormat fmt)
    {
        UT_ASSERT(pack != PACK_DUAL);
        myXres = xres;
        myYres = yres;
        myDataFormat = fmt;
        myPacking = pack;
        myNChannels = PXLpackingComponents(pack);
        myBPChan = PXLformatDepth(fmt);
        myBPPixel = myBPChan * myNChannels;
        myBPScan = myBPPixel * myXres;
    }
    UT_UniquePtr<char[]>         myBuffer;
    const char                  *myRaster; // Raster
    exint                        myXres;
    exint                        myYres;
    exint                        myNChannels; // Number of channels
    exint                        myBPChan; // Bytes per channel
    exint                        myBPPixel; // Bytes per pixel
    exint                        myBPScan; // Bytes per scanline
    PXL_DataFormat               myDataFormat;
    PXL_Packing                  myPacking;
};

SYS_DECLARE_LEGACY_TR(BRAY_Raster)

#endif