GEO_VolumeSampler.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:        GEO_VolumeSampler.h (GEO Library, C++)
 *
 * COMMENTS:
 *      This is an adapter class that lets you efficiently
 *      sample both PrimVolumes and PrimVDBs.
 *
 *      It is *not* threadsafe to use the same volume sampler
 *      from multiple threads!
 */

#ifndef __GEO_VOLUMESAMPLER_H_INCLUDED__
#define __GEO_VOLUMESAMPLER_H_INCLUDED__

#include <UT/UT_VoxelArray.h>

#include "GEO_API.h"
#include "GEO_PrimVolume.h"
#include "GEO_PrimVDB.h"

/// Sampler cache for PrimVolume and PrimVDB.
/// Converts to the requested tuple, possibly truncating or padding with zeros.
class GEO_API GEO_VolumeSamplerCache
{
public:
    GEO_VolumeSamplerCache() {}
    virtual ~GEO_VolumeSamplerCache() {}

    virtual bool        isActive(const UT_Vector3 &pos) = 0;
    virtual bool        isActiveAtIndex(int ix, int iy, int iz) = 0;

    virtual fpreal      getValueF(const UT_Vector3 &pos) = 0;
    virtual UT_Vector2D getValueV2(const UT_Vector3 &pos) = 0;
    virtual UT_Vector3D getValueV3(const UT_Vector3 &pos) = 0;
    virtual UT_Vector4D getValueV4(const UT_Vector3 &pos) = 0;
    virtual exint       getValueI(const UT_Vector3 &pos) = 0;

    template <typename BASE>
    BASE                getValueByType(const UT_Vector3 &pos)
    {
        if constexpr (SYS_IsSame_v<UT_Vector4, BASE>)
            return getValueV4(pos);
        if constexpr (SYS_IsSame_v<UT_Vector3, BASE>)
            return getValueV3(pos);
        if constexpr (SYS_IsSame_v<UT_Vector2, BASE>)
            return getValueV2(pos);
        if constexpr (SYS_IsSame_v<float, BASE>)
            return getValueF(pos);
        if constexpr (SYS_IsSame_v<int64, BASE>)
            return getValueI(pos);
    }

    virtual fpreal      getValueAtIndexF(int ix, int iy, int iz) = 0;
    virtual UT_Vector2D getValueAtIndexV2(int ix, int iy, int iz) = 0;
    virtual UT_Vector3D getValueAtIndexV3(int ix, int iy, int iz) = 0;
    virtual UT_Vector4D getValueAtIndexV4(int ix, int iy, int iz) = 0;
    virtual exint       getValueAtIndexI(int ix, int iy, int iz) = 0;

    virtual fpreal      getConstantIndexRegionF(UT_BoundingBox &indexbox, bool *isconstant, bool *isactive) = 0;
    virtual UT_Vector2D getConstantIndexRegionV2(UT_BoundingBox &indexbox, bool *isconstant, bool *isactive) = 0;
    virtual UT_Vector3D getConstantIndexRegionV3(UT_BoundingBox &indexbox, bool *isconstant, bool *isactive) = 0;
    virtual UT_Vector4D getConstantIndexRegionV4(UT_BoundingBox &indexbox, bool *isconstant, bool *isactive) = 0;
    virtual exint       getConstantIndexRegionI(UT_BoundingBox &indexbox, bool *isconstant, bool *isactive) = 0;

    /// Null if the PrimVolume type does not match, or if it's a PrimVDB.
    virtual UT_VoxelArrayReadHandleF getHandleF() = 0;
    virtual UT_VoxelArrayReadHandleV2 getHandleV2() = 0;
    virtual UT_VoxelArrayReadHandleV3 getHandleV3() = 0;
    virtual UT_VoxelArrayReadHandleV4 getHandleV4() = 0;
    virtual UT_VoxelArrayReadHandleI getHandleI() = 0;
};

using GEO_VolumeSamplerVDBCache = GEO_VolumeSamplerCache;

class GEO_API GEO_VolumeSampler
{
public:
    GEO_VolumeSampler()
    {
        bindPrim(0);
    }
    GEO_VolumeSampler(const GEO_Primitive *prim)
    {
        bindPrim(prim);
    }

    GEO_VolumeSampler(const GEO_VolumeSampler &src)
    {
        bindPrim(src.myPrim);
    }
    ~GEO_VolumeSampler()
    {
    }

    GEO_VolumeSampler &operator=(const GEO_VolumeSampler &src)
    {
        bindPrim(src.myPrim);

        return *this;
    }

    bool        isBound()
    {
        return myVol != NULL || myVdb != NULL;
    }

    bool        storesIntegers()
    {
        if (myVol)
        {
            return myVol->getStoresIntegers();
        }
        else if (myVdb)
        {
            UT_VDBType vdbtype = myVdb->getStorageType();
            return vdbtype == UT_VDB_INT32 ||
                   vdbtype == UT_VDB_INT64 ||
                   vdbtype == UT_VDB_VEC3I;
        }

        return false;
    }

    void                bindPrim(const GEO_Primitive *prim)
    {
        mySamplerCache.reset();
        myPrim = prim;
        myVol = dynamic_cast<const GEO_PrimVolume *>(prim);
        myVdb = dynamic_cast<const GEO_PrimVDB *>(prim);
        myVectorSize = 0;
        if (myVol)
        {
            myVectorSize = myVol->getTupleSize();
            mySamplerCache = createVolumeCache(myVol);

            if (!mySamplerCache)
                myVol = 0;
        }
        if (myVdb)
        {
            myVectorSize = myVdb->getTupleSize();
            mySamplerCache = createVDBCache(myVdb);

            if (!mySamplerCache)
                myVdb = 0;
        }
    }

    int                         getVectorSize() const { return myVectorSize; }

    /// Convert an index in the voxel array into the corresponding worldspace
    /// location
    void indexToPos(int x, int y, int z, UT_Vector3 &pos) const
    {
        if(myVol)
            myVol->indexToPos(x,y,z,pos);
        if(myVdb)
            myVdb->indexToPos(x,y,z,pos);
    }
    void findexToPos(UT_Vector3 index, UT_Vector3 &pos) const
    {
        if(myVol)
            myVol->findexToPos(index, pos);
        if(myVdb)
            myVdb->findexToPos(index, pos);
    }
    void indexToPos(exint x, exint y, exint z, UT_Vector3D &pos) const
    {
        if(myVol)
            myVol->indexToPos(x,y,z,pos);
        if(myVdb)
            myVdb->indexToPos(x,y,z,pos);
    }
    void findexToPos(UT_Vector3D index, UT_Vector3D &pos) const
    {
        if(myVol)
            myVol->findexToPos(index,pos);
        if(myVdb)
            myVdb->findexToPos(index,pos);
    }
    
    /// Convert a 3d position into the closest index value.
    void posToIndex(UT_Vector3 pos, int &x, int &y, int &z) const
    {
        if(myVol)
            myVol->posToIndex(pos,x,y,z);
        if(myVdb)
            myVdb->posToIndex(pos,x,y,z);
    }
    void posToIndex(UT_Vector3 pos, UT_Vector3 &index) const
    {
        if(myVol)
            myVol->posToIndex(pos,index);
        if(myVdb)
            myVdb->posToIndex(pos,index);
    }
    void posToIndex(UT_Vector3D pos, exint &x, exint &y, exint &z) const
    {
        if(myVol)
            myVol->posToIndex(pos,x,y,z);
        if(myVdb)
            myVdb->posToIndex(pos,x,y,z);
    }
    void posToIndex(UT_Vector3D pos, UT_Vector3D &index) const
    {
        if(myVol)
            myVol->posToIndex(pos,index);
        if(myVdb)
            myVdb->posToIndex(pos,index);
    }

    GEO_PrimVolumeXform  getSpaceTransform() const{
        if(myVol)
            return myVol->getSpaceTransform();
        if(myVdb)
            return myVdb->getSpaceTransform();
        return {};
    }

    GEO_PrimVolumeXform getIndexSpaceTransform() const
    {
        if (myVol)
            return myVol->getIndexSpaceTransform();
        if (myVdb)
            return myVdb->getIndexSpaceTransform();
        return {};
    }

    /// Checks whether the given location falls within the volume's active
    /// region.
    inline bool             isActive(const UT_Vector3 &pos)
    {
        if (mySamplerCache)
            return mySamplerCache->isActive(pos);

        return false;
    }

    /// Checks whether the given index is within the volume's active
    /// region.
    inline bool             isActiveAtIndex(int ix, int iy, int iz)
    {
        if (mySamplerCache)
            return mySamplerCache->isActiveAtIndex(ix, iy, iz);

        return false;
    }

    inline fpreal                       getValueF(const UT_Vector3 &pos)
    {
        if (mySamplerCache)
            return mySamplerCache->getValueF(pos);

        return 0;
    }

    inline fpreal                       getValueAtIndexF(int ix, int iy, int iz)
    {
        if (mySamplerCache)
            return mySamplerCache->getValueAtIndexF(ix, iy, iz);

        return 0;
    }

    /// Conservatively determines if a box [minvec, maxvec] in index space
    /// is constant or inactive.   If there is doubt, it is reported as
    /// non-constant and active.
    ///
    /// isconstant is true only if all voxels in the region have the same value
    /// isactive is false only if all the voxels in the region are inactive.
    /// 
    /// if isconstant is true, the returned value will the constant value.
    fpreal                              getConstantIndexRegionF(UT_BoundingBox &indexbox, bool *isconstant, bool *isactive);
    UT_Vector2D                         getConstantIndexRegionV2(UT_BoundingBox &indexbox, bool *isconstant, bool *isactive);
    UT_Vector3D                         getConstantIndexRegionV3(UT_BoundingBox &indexbox, bool *isconstant, bool *isactive);
    UT_Vector4D                         getConstantIndexRegionV4(UT_BoundingBox &indexbox, bool *isconstant, bool *isactive);
    exint                               getConstantIndexRegionI(UT_BoundingBox &indexbox, bool *isconstant, bool *isactive);

    inline UT_Vector2D                  getValueV2(const UT_Vector3 &pos)
    {
        if (mySamplerCache)
            return mySamplerCache->getValueV2(pos);

        return UT_Vector2D(0, 0);
    }
    
    inline UT_Vector2D                  getValueAtIndexV2(int ix, int iy, int iz)
    {
        if (mySamplerCache)
            return mySamplerCache->getValueAtIndexV2(ix, iy, iz);

      return UT_Vector2D(0, 0);
    }

    inline UT_Vector3D                  getValueV3(const UT_Vector3 &pos)
    {
        if (mySamplerCache)
            return mySamplerCache->getValueV3(pos);

        return UT_Vector3D(0, 0, 0);
    }
    
    inline UT_Vector3D                  getValueAtIndexV3(int ix, int iy, int iz)
    {
        if (mySamplerCache)
            return mySamplerCache->getValueAtIndexV3(ix, iy, iz);

      return UT_Vector3D(0, 0, 0);
    }

    inline UT_Vector4D                  getValueV4(const UT_Vector3 &pos)
    {
        if (mySamplerCache)
            return mySamplerCache->getValueV4(pos);

        return UT_Vector4D(0, 0, 0, 0);
    }
    
    inline UT_Vector4D                  getValueAtIndexV4(int ix, int iy, int iz)
    {
        if (mySamplerCache)
            return mySamplerCache->getValueAtIndexV4(ix, iy, iz);

      return UT_Vector4D(0, 0, 0, 0);
    }

    inline exint                        getValueI(const UT_Vector3 &pos)
    {
        if (mySamplerCache)
            return mySamplerCache->getValueI(pos);

        return 0;
    }
    
    inline exint                        getValueAtIndexI(int ix, int iy, int iz)
    {
        if (mySamplerCache)
            return mySamplerCache->getValueAtIndexI(ix, iy, iz);

      return 0;
    }

    template <typename BASE>
    BASE                getValueByType(const UT_Vector3 &pos)
    {
        if constexpr (SYS_IsSame_v<UT_Vector4, BASE>)
            return getValueV4(pos);
        if constexpr (SYS_IsSame_v<UT_Vector3, BASE>)
            return getValueV3(pos);
        if constexpr (SYS_IsSame_v<UT_Vector2, BASE>)
            return getValueV2(pos);
        if constexpr (SYS_IsSame_v<float, BASE>)
            return getValueF(pos);
        if constexpr (SYS_IsSame_v<int64, BASE>)
            return getValueI(pos);
    }

    /// Gets values in the box [bbox.minvec(), bbox.maxvec())
    /// Values are stored in the array `values` of size `size` that has to be at least `bbox.volume()`
    /// The order of values is give by: `i + bbox.xsize() * (j + bbox.ysize() * k)`
    /// 
    /// If returns true, values in `bbox` are constant and only values[0] is guaranteed to be assigned.
    template <class T>
    bool getValues(const UT_BoundingBoxI &bbox, T * values, const exint size)
    {
        constexpr int tuplesize = UT_FixedVectorTraits<T>::TupleSize;
        SYS_STATIC_ASSERT(tuplesize >= 1 && tuplesize <= 4);
        UT_ASSERT_P(bbox.volume() <= size);

        if (mySamplerCache)
        {
            UT_VoxelArrayReadHandle<T> vox;
            if constexpr (SYS_IsSame_v<T, fpreal32>)
                vox = mySamplerCache->getHandleF();
            if constexpr (SYS_IsSame_v<T, UT_Vector2F>)
                vox = mySamplerCache->getHandleV2();
            if constexpr (SYS_IsSame_v<T, UT_Vector3F>)
                vox = mySamplerCache->getHandleV3();
            if constexpr (SYS_IsSame_v<T, UT_Vector4F>)
                vox = mySamplerCache->getHandleV4();
            if constexpr (SYS_IsSame_v<T, exint>)
                vox = mySamplerCache->getHandleI();

            // Fast path if we match.
            if (vox.get())
                return vox->getValues(bbox, values, size);

            int idx = 0;
            bool allconstant = true;

            for (int k = bbox.zmin(); k < bbox.zmax(); k++)
            {
                for (int j = bbox.ymin(); j < bbox.ymax(); j++)
                {
                    for (int i = bbox.xmin(); i < bbox.xmax(); i++, idx++)
                    {
                        if constexpr (tuplesize == 1)
                        {
                            if constexpr (SYS_IsIntegral_v<T>)
                                values[idx] = mySamplerCache->getValueAtIndexI(i, j, k);
                            else
                                values[idx] = mySamplerCache->getValueAtIndexF(i, j, k);
                        }
                        if constexpr (tuplesize == 2)
                            values[idx] = mySamplerCache->getValueAtIndexV2(i, j, k);
                        if constexpr (tuplesize == 3)
                            values[idx] = mySamplerCache->getValueAtIndexV3(i, j, k);
                        if constexpr (tuplesize == 4)
                            values[idx] = mySamplerCache->getValueAtIndexV4(i, j, k);

                        allconstant &= (values[0] == values[idx]);
                    }
                }
            }

            return allconstant;
        }
        
        return false;
    }

    static UT_UniquePtr<GEO_VolumeSamplerCache> createVolumeCache(const GEO_PrimVolume *vol);
    static UT_UniquePtr<GEO_VolumeSamplerCache> createVDBCache(const GEO_PrimVDB *vdb);

protected:
    const GEO_Primitive                 *myPrim;
    const GEO_PrimVolume                *myVol;
    const GEO_PrimVDB                   *myVdb;
    int                                  myVectorSize;
    UT_UniquePtr<GEO_VolumeSamplerCache> mySamplerCache;
};

#endif // __GEO_VOLUMESAMPLER_H_INCLUDED__