GEO/GEO_PrimVolume.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:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        GEO_PrimVolume.h ( GEO Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GEO_PrimVolume__
#define __GEO_PrimVolume__

#include <UT/UT_VoxelArray.h>

#include "GEO_API.h"
#include "GEO_Vertex.h"
#include "GEO_Primitive.h"

enum GEO_VolumeBorder
{
    GEO_VOLUMEBORDER_CONSTANT,
    GEO_VOLUMEBORDER_REPEAT,
    GEO_VOLUMEBORDER_STREAK,
    GEO_VOLUMEBORDER_SDF,
    NUM_GEO_VOLUMEBORDERS
};

enum GEO_VolumeVis
{
    GEO_VOLUMEVIS_SMOKE,
    GEO_VOLUMEVIS_RAINBOW,
    GEO_VOLUMEVIS_ISO,
    GEO_VOLUMEVIS_INVISIBLE,
    NUM_GEO_VOLUMEVIS
};

class GEO_API GEO_PrimVolume : public GEO_Primitive
{
public:
              GEO_PrimVolume(GEO_Detail *d);
     virtual ~GEO_PrimVolume();

//
//  Methods common to all primitives.
    virtual unsigned             getPrimitiveId() const;
    virtual int                  getBBox(UT_BoundingBox *bbox) const;
    virtual void                 addToBSphere(UT_BoundingSphere *bsphere) const;
    virtual UT_Vector3           baryCenter() const;
    virtual UT_Vector3           computeNormal() const;
    virtual int                  save(ostream &os, int binary) const;
    virtual bool                 load(UT_IStream &is);

    virtual bool        evaluatePoint(GEO_Vertex &result,
                                    GEO_AttributeHandleList &hlist,
                                    fpreal u, fpreal v, uint du, uint dv) const;

    // Transforms the matrix associated with this primitive.  The
    // translate component is ignored: Translate the vertices of
    // the primitive to translate the primitive.
    // This only works with quadrics (sphere, tube, metaballs) and volumes.
    virtual void                 transform(const UT_Matrix4 &mat);

    virtual void                 untransform(void);
    virtual GEO_Primitive       *copy(int preserve_shared_pts = 0) const;
    virtual void        copyPrimitive(const GEO_Primitive *src, 
                                GEO_Point **ptredirect);
    virtual void        addPointRefToGroup(GB_PointGroup &grp) const;

    void                changePointRef(GB_Element *from, GB_Element *to);
    virtual int         vertexApply(int (*a)(GB_Vertex &, void *), void *);
    virtual int         vertexApply(int (*a)(const GB_Vertex &, void *),
                                    void *) const;
    virtual void        reverse(void); 

    virtual unsigned             getVertexCount() const;
    virtual const GEO_Vertex    &getVertex(unsigned idx = 0) const;
    virtual GEO_Vertex          &getVertex(unsigned idx = 0);

    // Take the whole set of points into consideration when applying the
    // point removal operation to this primitive. The method returns 0 if
    // successful, -1 if it failed because it would have become degenerate,
    // and -2 if it failed because it would have had to remove the primitive
    // altogether.
    virtual int          detachPoints (GB_PointGroup &grp);

    virtual int          isDegenerate() const;

    // Map the normalized length (distance value [0,1]) parameter to the unit 
    // parameterization of the primitve
    virtual void         unitLengthToUnitPair(float  ulength, float  vlength,
                                              float &uparm,  float &vparm)const;

    virtual void         unitToUnitLengthPair(float  uparm,   float  vparm,
                                              float &ulength, float &vlength)
                                                                        const;

    virtual float        calcVolume(UT_Vector3 &refpt) const;
    virtual float        calcArea() const;

//
//  Methods unique to PrimVolume.

    void                 setVertex(GEO_Point *ppt)
                         {
                             myVertex.setPt(ppt);
                         }

    // Have we been deactivated and stashed?
    virtual              void   stashed(int onoff);

    const UT_Matrix3    &getTransform(void) const { return myXform; }
    void                 setTransform(const UT_Matrix3 &m) 
                         { myXform = m; 
                           myInverseXform = m;
                           myInverseXform.invert();
                         }

    void                 getTransform4(      UT_Matrix4 &matx) const;
    void                 setTransform4(const UT_Matrix4 &matx);

    /// Converts from world space to local space.
    const UT_Matrix3    &getInverseTransform() const { return myInverseXform; }
    void                 getInverseTransform4(UT_Matrix4 &matx) const;

    /// Convertes from world space to 0..1 voxel space.
    UT_Vector3           toVoxelSpace(const UT_Vector3 &pos) const;
    /// Convertse from 0..1 voxel space to world space.
    UT_Vector3           fromVoxelSpace(const UT_Vector3 &pos) const;

    /// Copies the given voxel array and makes it our own voxel array.
    void                 setVoxels(UT_VoxelArrayF *vox);
    void                 setVoxels(UT_VoxelArrayHandleF handle);

    /// Takes ownership of the voxel array, caller should not refer
    /// to vox any more.
    void                 stealVoxels(UT_VoxelArrayF *vox);

    /// Returns a handle to a voxel array containing our data.
    /// This is should be thought of a copy of the data - changing
    /// it will not change the underlying data, casting this to
    /// a write handle will write to the newly created handle, not
    /// the one stored in this volume.
    UT_VoxelArrayHandleF        getVoxelHandle() const;

    /// This is a handle that you can write to and affect the volume.
    UT_VoxelArrayWriteHandleF   getVoxelWriteHandle();

    /// Convert an index in the voxel array into the corresponidng worldspace 
    /// location
    bool                 indexToPos(int x, int y, int z, UT_Vector3 &pos) const;

    /// Convert a 3d position into the closest index value.  Returns
    /// false if the resulting index was out of range (but still sets it)
    bool                 posToIndex(UT_Vector3 pos, int &x, int &y, int &z) const;      

    /// Evaluate the voxel value at the given world space position.
    fpreal               getValue(const UT_Vector3 &pos) const;
    UT_Vector3           getGradient(const UT_Vector3 &pos) const;

    /// By passing in a specific read handle and inverse transform
    /// we can accelerate the getValue()
    fpreal               getValue(const UT_Vector3 &pos, const UT_VoxelArrayReadHandleF &handle) const;

    /// Evaluate the specific voxel indexed from 0,0,0.
    fpreal               getValueAtIndex(int ix, int iy, int iz) const;
    /// Returns the resolution of the voxel array.
    void                 getRes(int &rx, int &ry, int &rz) const;
    /// Computes the voxel diameter by taking a step in x, y, and z
    /// converting to world space and taking the length of that vector.
    fpreal               getVoxelDiameter() const;

    /// Computes the total density of the volume, scaled by
    /// the volume's size.  Negative values will be ignored.
    fpreal               calcPositiveDensity() const;

    /// Compute useful aggregate properties of the volume.
    fpreal               calcMinimum() const;
    fpreal               calcMaximum() const;
    fpreal               calcAverage() const;

    /// Determines if we should be treated as an SDF.  This means
    /// our function will continue to increase outside of the bounding
    /// box according to the distance to the bounding box.
    bool                 isSDF() const { return myIsSDF; }

    /// Get the border options in terms of GEO's values.
    static const char           *getBorderToken(GEO_VolumeBorder border);
    void                 setBorder(GEO_VolumeBorder border, fpreal val);
    GEO_VolumeBorder     getBorder() const;
    fpreal               getBorderValue() const;

    /// Control the compression of these objects.
    fpreal               getCompressionTolerance() const;
    void                 setCompressionTolerance(fpreal tol);
    void                 recompress();

    /// Control how we display this in the viewport
    static const char           *getVisualizationToken(GEO_VolumeVis vis);
    void                 setVisualization(GEO_VolumeVis vis, fpreal iso, fpreal density);
    fpreal               getVisIso() const { return myVisIso; }
    fpreal               getVisDensity() const { return myVisDensity; }
    GEO_VolumeVis        getVisualization() const { return myVisMode; }

protected:
    // Methods for finding out about point references
    virtual void        copyOffsetPrimitive(const GEO_Primitive *src,
                                            int basept);
    virtual int         savePrivate(ostream &os, int binary) const;
    virtual bool        loadPrivate(UT_IStream &is);
    virtual int         pointCanDelete(GB_Element *) const;
    virtual void        pointDeleted(GB_Element *pt);
    virtual int         isPointUsed(GB_Element *pt) const;
    virtual int         isPointGroupUsed(const GB_PointGroup &grp) const;

    // A versioned loading method.
    bool                loadVoxelData(UT_IStream &is, UT_VoxelArrayWriteHandleF voxels, int version);

    UT_VoxelArrayHandleF         myVoxelHandle;
private:
    GEO_Vertex          myVertex;       // My vertex
    UT_Matrix3          myXform;        // My Transform
    UT_Matrix3          myInverseXform; // My inverse transform
    bool                myIsSDF : 1;    // Are we a signed distance field?

    GEO_VolumeVis       myVisMode;
    fpreal              myVisIso;
    fpreal              myVisDensity;

    friend ostream      &operator<<(ostream &os, const GEO_PrimVolume &d)
                        {
                            d.save(os, 0);
                            return os;
                        }
    // This is used to track whether we are stashed.  That tells us
    // if we need to tell update our detail's count of the number
    // of yucky quadric-like primitives.
    bool                myStashedState : 1;
};

#endif

---