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"

class GEO_API GEO_VolumeSamplerVDBCache
{
public:
    GEO_VolumeSamplerVDBCache() {}
    virtual ~GEO_VolumeSamplerVDBCache() {}

    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 fpreal      getValueAtIndexF(int ix, int iy, int iz) = 0;
    virtual UT_Vector3D getValueV3(const UT_Vector3 &pos) = 0;
    virtual UT_Vector3D getValueAtIndexV3(int ix, int iy, int iz) = 0;
    virtual fpreal      getConstantIndexRegionF(UT_BoundingBox &indexbox, bool *isconstant, bool *isactive) = 0;
    virtual UT_Vector3D getConstantIndexRegionV3(UT_BoundingBox &indexbox, bool *isconstant, bool *isactive) = 0;
};

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

    GEO_VolumeSampler(const GEO_VolumeSampler &src)
    {
        myVDBCache = 0;
        bindPrim(src.myPrim);
    }
    ~GEO_VolumeSampler()
    {
        delete myVDBCache;
    }

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

        return *this;
    }

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

    void                bindPrim(const GEO_Primitive *prim)
    {
        delete myVDBCache;
        myVDBCache = 0;

        myPrim = prim;
        myVol = dynamic_cast<const GEO_PrimVolume *>(prim);
        myVdb = dynamic_cast<const GEO_PrimVDB *>(prim);
        myVectorSize = 0;
        if (myVol)
        {
            myHandle = myVol->getVoxelHandle();
            myVectorSize = 1;
        }
        if (myVdb)
        {
            myVectorSize = myVdb->getTupleSize();
            myVDBCache = createVDBCache(myVdb);

            if (!myVDBCache)
                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 (myVol)
            return myVol->isInsideStrict(pos, myHandle);
        if (myVdb)
            return myVDBCache->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 (myVol)
            return myHandle->isValidIndex(ix, iy, iz);
        if (myVdb)
            return myVDBCache->isActiveAtIndex(ix, iy, iz);

        return false;
    }

    inline fpreal                       getValueF(const UT_Vector3 &pos)
    {
        if (myVol)
            return myVol->getValue(pos, myHandle);
        if (myVdb)
            return myVDBCache->getValueF(pos);

        return 0;
    }

    inline fpreal                       getValueAtIndexF(int ix, int iy, int iz)
    {
        if (myVol)
            return myHandle->getValue(ix, iy, iz);
        if (myVdb)
            return myVDBCache->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_Vector3D                         getConstantIndexRegionV3(UT_BoundingBox &indexbox, bool *isconstant, bool *isactive);

    inline UT_Vector3D                  getValueV3(const UT_Vector3 &pos)
    {
        if (myVol)
            return UT_Vector3D(myVol->getValue(pos, myHandle), 0, 0);
        if (myVdb)
            return myVDBCache->getValueV3(pos);

        return UT_Vector3D(0, 0, 0);
    }
    
    inline UT_Vector3D                  getValueAtIndexV3(int ix, int iy, int iz)
    {
      if (myVol)
         return UT_Vector3D(myHandle->getValue(ix, iy, iz), 0, 0);
      if (myVdb)
         return myVDBCache->getValueAtIndexV3(ix, iy, iz);

      return UT_Vector3D(0, 0, 0);
    }

    /// 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)
    {
        UT_ASSERT_P(bbox.volume() <= size);
        
        constexpr bool IS_SCALAR = SYS_IsFloatingPoint_v<T>;

        static_assert(
                SYS_IsFloatingPoint_v<T> ||
                (UT_FixedVectorTraits<T>::isVectorType &&
                 (UT_FixedVectorTraits<T>::TupleSize == 3)),
                "Return value has to be scalar or three dimensional vector!");

        if (myVol)
        {
            if constexpr (IS_SCALAR){
                return myHandle->getValues(bbox, values, size);
            }
            else
            {
                static_assert(
                        sizeof(T) >= sizeof(float),
                        "This implementation assumes that sizeof(T) >= "
                        "sizeof(float). Memory leak happens otherwise.");
                const int n = bbox.volume();
                // This is a bit of a hack, re-using the space of `values` array.
                float * data = reinterpret_cast<float*>(values);
                const bool isconstant = myHandle->getValues(bbox, data, size);
                // Spreading out values stored under `data`
                for(int i=n-1; i>=0; i--){
                    values[i] = T{data[i], 0.f, 0.f};
                }
                return isconstant;
            }
        }

        if (myVdb)
        {
            int id = 0;
            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++)
                    {
                        if constexpr (IS_SCALAR)
                        {
                            values[id++] = myVDBCache->getValueAtIndexF(i,j, k);
                        }
                        else
                        {
                            values[id++] = myVDBCache->getValueAtIndexV3(i,j, k);
                        }
                    }
                }
            }
        }
        return false;
    }

    static GEO_VolumeSamplerVDBCache *createVDBCache(const GEO_PrimVDB *vdb);

protected:
    const GEO_Primitive                 *myPrim;
    const GEO_PrimVolume                *myVol;
    const GEO_PrimVDB                   *myVdb;
    UT_VoxelArrayReadHandleF             myHandle;
    int                                  myVectorSize;
    GEO_VolumeSamplerVDBCache           *myVDBCache;
};

#endif // __GEO_VOLUMESAMPLER_H_INCLUDED__