GEO/GEO_Hull.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:
 *      Mark Elendt
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Geometry Library (C++)
 *
 * COMMENTS:
 *      This class is used as a base class for all patch types supported.
 *      The vertex list management is handled by this class, however, all
 *      other function should be handled by the subclass.
 *      The insertRow and insertCol are meant to be virtual since it
 *      may be possible for the patch type to insert a row or column
 *      without distorting the shape of the patch (as in NURBs or MESH)
 *
 */

#ifndef __GEO_Hull_H__
#define __GEO_Hull_H__

#include "GEO_API.h"
#include <UT/UT_RefMatrix.h>
#include "GEO_Primitive.h"
#include "GEO_SurfaceType.h"
#include "GEO_Vertex.h"

class UT_BitArray;
class GEO_Point;
class GEO_Detail;
class GB_Edge;
class GB_EdgeGroup;

class GEO_API GEO_HullFlags {
public:
        GEO_HullFlags()
        {
                wrapu = 0;
                wrapv = 0;
        }
    unsigned    wrapu:1,
                wrapv:1;
    bool        loadBinary( UT_IStream &is );
    int         saveBinary( ostream &os ) const;
};

class GEO_API GEO_SubHullFlags {
public:
        GEO_SubHullFlags()
        {
                wrapu       = 0;        wrapv       = 0;
                dupTop      = 0;        dupLeft     = 0;
                dupBottom   = 0;        dupRight    = 0;
                breakThread = 0;        breakBridge = 0;
                recurse     = 1;
        }

    unsigned    wrapu:1,
                wrapv:1,
                dupTop:1,
                dupLeft:1,
                dupBottom:1,
                dupRight:1,
                breakThread:1,
                breakBridge:1,
                recurse:1;
};

class GEO_API GEO_SubHullPart
{
public:
                GEO_SubHullPart() { h_edge = v_edge = d_edge = flags = 0; }

    int         h_edge;
    int         v_edge;
    int         d_edge;
    int         flags;
                // `flags' is used as follows:
                // Bit 0 - horizontal edge is used to break into a subhull
                // Bit 1 - vertical edge        "               "
                // Bit 2 - diagonal edge        "               "

    unsigned    operator==(const GEO_SubHullPart &p) const
    {   return( (h_edge==p.h_edge) && 
                (v_edge==p.v_edge) && 
                (d_edge==p.d_edge) &&
                (flags ==p.flags )   );
    }
};

class GEO_API GEO_SubHull
{
public:
                GEO_SubHull() : mat() {}

    UT_RefMatrix<GEO_SubHullPart>        mat;
    int                                  v_rows, v_cols;
    int                                  h_rows, h_cols;
    int                                  d_rows, d_cols;
};

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

    virtual unsigned    getPrimitiveId() const = 0;

    // Compute the location of the breakpoint. Return 0 if OK, else -1.
    virtual int         evaluateBreakpoint(int uidx, int vidx,
                                           UT_Vector4 &pos,
                                           int du=0, int dv=0) const = 0;

    // Evaluate one point (when du=dv=0), or the du-th dv-th derivative.
    // Return 0 if successful, and -1 otherwise.
    virtual bool        evaluateIndex(fpreal u, fpreal v, GEO_Vertex &result,
                                GEO_AttributeHandleList &hlist,
                                unsigned du, unsigned dv) const;
    virtual int         evaluateIndex(float iu, float iv, UT_Vector4 &pos, 
                                unsigned du=0, unsigned dv=0) const;
    virtual int         evaluateIndexWAttrib(float iu, float iv,
                                UT_Vector4 &pos, GB_AttributeData &adata,
                                const GB_FloatOffsets &foffsets,
                                unsigned du=0, unsigned dv=0) const;

    // Evaluate the normal using unit u and v coordinates (i.e. in [0,1]).
    // The normal is not normalized. The method does NOT fail if the point
    // attribute is missing. We return 0 if OK and -1 if error.
    virtual int          evaluateNormalVector(UT_Vector3 &nml, float u,
                                        float v = 0) const;

    // Evaluate the normal at real (u,v). The method fails if the point normal
    // attribute is missing. Return 0 if successful, and -1 otherwise.
    virtual int         evaluateNormal(float u,float v, UT_Vector3 &nml) const;
    virtual int         normalIndex(float iu, float iv, UT_Vector3 &nml) const;

    virtual int         uMinValidIndex(void) const;
    virtual int         uMaxValidIndex(void) const;
    virtual int         vMinValidIndex(void) const;
    virtual int         vMaxValidIndex(void) const;

    virtual int         save(ostream &os, int binary) const;
    virtual bool        load(UT_IStream &is);
    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 void        copyPrimitive(const GEO_Primitive *src, 
                                    GEO_Point **ptredirect);
    virtual GEO_Primitive       *copy(int preserve_shared_pts = 0) const;

    virtual void        addPointRefToGroup(GB_PointGroup &grp) const;

    virtual void        changePointRef(GB_Element *from, GB_Element *to);

    // Reverse rows (V) and/or columns (U):
    virtual void        reverse (void);
    virtual void        reverseU(void);
    virtual void        reverseV(void);

    // Shift the array of vertices by an offset and wrap around. The offset
    // can be either negative or positive.  Cycles in complete rows/cols
    virtual int         cycleU(int amount, int = 1);
    virtual int         cycleV(int amount, int = 1);

    // All current rows and columns will be reinitialized
    int                 setRowCol(unsigned int r, unsigned int c);
    virtual int         insertRow(unsigned int beforeWhich, int appendPts=1);
    int                 appendRow(int appendPts=1)
                        {
                            return insertRow(vtxMatx.usedRows(), appendPts);
                        }
    virtual int         insertCol(unsigned int beforeWhich, int appendPts=1);
    int                 appendCol(int appendPts=1)
                        {
                            return insertCol(vtxMatx.usedCols(), appendPts);
                        }

    virtual int         deleteRow(unsigned int which);
    virtual int         deleteCol(unsigned int which);

    // 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);

    // Given a parameter in the domain, insert as many CVs as necessary to
    // create a discontinuity at the corresponding point on the curve.The shape
    // of the curve should NOT change. Return u's index upon success and -1
    // otherwise.
    virtual int         subdivideU(fpreal u, GEO_AttributeHandleList &hlist);
    virtual int         subdivideU(float u);
    virtual int         subdivideUWAttrib(float u,
                                          const GB_FloatOffsets &foffsets);
    virtual int         subdivideV(float u, GEO_AttributeHandleList &hlist);
    virtual int         subdivideV(float u);
    virtual int         subdivideVWAttrib(float u,
                                          const GB_FloatOffsets &foffsets);

    virtual void        subdivide(int numdivs, GB_PointGroup *ptgroup=0);

    // Warp the hull at u,v by the given delta. Change 1 or 4 Cvs and possibly
    // insert a knot once or more as well. If a knot is inserted or we happen
    // to land exactly on a knot, we change only one CV. The bias makes sense
    // only when changing 4 CVs, and will be ignored altogether if < 0.
    // We return the CV index in warpU/V and 0 in warp() if OK; -1 otherwise.
    virtual int          warpU(float u, const UT_Vector3 &delta,
                               GEO_AttributeHandleList &hlist,
                               float sharpness = 0.0f, float bias = -1.0f) = 0;
    virtual int          warpV(float v, const UT_Vector3 &delta,
                               GEO_AttributeHandleList &hlist,
                               float sharpness = 0.0f, float bias = -1.0f) = 0;
    virtual int          warp (float u, float v, const UT_Vector3 &delta,
                               GEO_AttributeHandleList &hlist,
                               float usharpness = 0.0f, float vsharpness = 0.f,
                               float ubias = -1.0f, float vbias = -1.0f) = 0;

    virtual int          warpU(float u, const UT_Vector3 &delta,
                               GB_FloatOffsets *foffsets = 0,
                               float sharpness = 0.0f, float bias = -1.0f) = 0;
    virtual int          warpV(float v, const UT_Vector3 &delta,
                               GB_FloatOffsets *foffsets = 0,
                               float sharpness = 0.0f, float bias = -1.0f) = 0;
    virtual int          warp (float u, float v, const UT_Vector3 &delta,
                               GB_FloatOffsets *foffsets = 0,
                               float usharpness = 0.0f, float vsharpness = 0.f,
                               float ubias = -1.0f, float vbias = -1.0f) = 0;

    // Warp the hull along its normal at u,v. We warp u if the flag is 0,
    // warp v if flag is 1, and warp both if flag is 2.
    // We return 0 if OK, or -1 if there's an error.
    int                  warpAlongNormal (float u, float v, float distance,
                                          GEO_AttributeHandleList &hlist,
                                          float usharpness, float vsharpness,
                                          float ubias, float vbias,
                                          int u_v_both);
    int                  warpAlongNormal (float u, float v, float distance,
                                          GB_FloatOffsets *foffsets,
                                          float usharpness, float vsharpness,
                                          float ubias, float vbias,
                                          int u_v_both);

    // Append another hull to us in one of two ways: blend the two endpoints
    // or connect them straight or rounded. The bias ranges from 0 to 1 and is
    // relevant only to blending. The tolerance for blending: if 0, the two
    // endpoints will merge into one point with a discontinuity; if less than
    // 1, we insert knots into the hulls to minimize the affected areas; if 1,
    // no refinement is done. For the non-blend case, the tolerance will
    // generate a span whose shape goes from round to straight; 0 tolerance
    // means straight connection. If unrefine is on, we'll try to reduce the
    // complexity of the hull if we're connecting rounded. We return 0 if OK
    // and -1 if error. Both hulls must be open and have the same order.
    virtual int         attachU(const GEO_Hull &hull, int blend = 1,
                                float bias = 0.5f, float tolerance = 1.0f,
                                int unrefine=1, GB_PointGroup *ptgroup=0) = 0;
    virtual int         attachV(const GEO_Hull &hull, int blend = 1,
                                float bias = 0.5f, float tolerance = 1.0f,
                                int unrefine=1, GB_PointGroup *ptgroup=0) = 0;

    // Change the multiplicity of the domain value by inserting it after
    // checking its current multiplicity.  Return -1 if invalid, otherwise
    // return the index of the inserted knot

    virtual int                 refineU(float k,
                                        GEO_AttributeHandleList &hlist,
                                        int i=0);

    virtual int                 refineU         ( float k, int=0);
    virtual int                 refineUWAttrib  ( float k, 
                                      const GB_FloatOffsets &foffsets, int=0);
    virtual int                 refineUWAttrib  ( float k, 
                                          const GB_FloatOffsets *ptoffsets,
                                          const GB_FloatOffsets *vtxoffsets,
                                          int=0);
    virtual int                 refineV(float k,
                                        GEO_AttributeHandleList &hlist,
                                        int i=0);
    virtual int                 refineV         ( float k, int=0);
    virtual int                 refineVWAttrib  ( float k, 
                                      const GB_FloatOffsets &foffsets, int=0);
    virtual int                 refineVWAttrib  ( float k, 
                                          const GB_FloatOffsets *ptoffsets,
                                          const GB_FloatOffsets *vtxoffsets,
                                          int=0);

    // Refine numdivs times in each span.
    virtual void                spanRefineU(GEO_AttributeHandleList &hlist,
                                            int numdivs=1) = 0;
    virtual void                spanRefineU        ( int numdivs=1)     = 0;
    virtual void                spanRefineUWAttrib ( const GB_FloatOffsets
                                      &foffsets, int numdivs=1)         = 0;
    virtual void                spanRefineV(GEO_AttributeHandleList &hlist,
                                            int numdivs=1) = 0;
    virtual void                spanRefineV        ( int numdivs=1)     = 0;
    virtual void                spanRefineVWAttrib ( const GB_FloatOffsets
                                      &foffsets, int numdivs=1)         = 0;

    // Remove rows and or columns based on a curvature tolerance. Return 1 of
    // something was removed, else 0.
    virtual int                 unrefineU(int kidx, GEO_AttributeHandleList &h,
                                        int mult=0, fpreal tol=1e-4f,
                                        GB_PointGroup *delgroup=0);
    virtual int                 unrefineU       (int kidx, int mult = 0,
                                                 float tol = 1e-4F,
                                                 GB_PointGroup *delgroup = 0);
    virtual int                 unrefineUWAttrib(int kidx, 
                                                 const GB_FloatOffsets &foffets,
                                                 int mult=0, float tol = 1e-4F,
                                                 GB_PointGroup *delgroup = 0);
    virtual int                 unrefineV(int kidx, GEO_AttributeHandleList &h,
                                        int mult=0, fpreal tol=1e-4f,
                                        GB_PointGroup *delgroup=0);
    virtual int                 unrefineV       (int kidx, int mult = 0,
                                                 float tol = 1e-4F,
                                                 GB_PointGroup *delgroup = 0);
    virtual int                 unrefineVWAttrib(int kidx, 
                                                 const GB_FloatOffsets &foffets,
                                                 int mult=0, float tol = 1e-4F,
                                                 GB_PointGroup *delgroup = 0);

    // If the hull is wrapped in U and/or V, explicitly add the wrapped vertex
    // and open the hull in the direction(s) it's wrapped in.
    virtual void        fixSeamsU(void);
    virtual void        fixSeamsV(void);

    // Apply row-column texture. If the offset if negative, the methods find it
    // and create the attribute if necessary. If ptattrib is 1 we deal with
    // points, else with vertices.Return the texture offset or -1 if problems.
    int                 rowColTexture(int txtoff = -1, int ptattrib = 1);

    int                 getNumRows() const { return (int)vtxMatx.usedRows(); }
    int                 getNumCols() const { return (int)vtxMatx.usedCols(); }

    // Subscript operators. The const version does not check the boundaries.
    // For safer but slower use, call getVertex() and setVertex().
    const GEO_Vertex    &operator()(unsigned int r, unsigned int c) const
                        {
                            return vtxMatx(r, c);
                        }
    GEO_Vertex          &operator()(unsigned int r, unsigned int c)
                        {
                            return vtxMatx(r, c);
                        }

    const GEO_Vertex    &getVertex(unsigned int r, unsigned int c) const;
    void                setVertex(unsigned int r, unsigned int c, GEO_Point *pt)
                        {
                            if(r < vtxMatx.usedRows() && c < vtxMatx.usedCols())
                                vtxMatx(r, c).setPt(pt);
                        }

    GEO_SurfaceType     getSurfaceType() const           { return surfaceType; }
    void                setSurfaceType(GEO_SurfaceType t) { surfaceType = t; }

    unsigned            isWrappedU() const { return flags.wrapu; }
    unsigned            isWrappedV() const { return flags.wrapv; }

    virtual void        wrapU(int rounded = 1, int preserveShape = 0);
    virtual void        openU(int preserveShape = 0, int safe = 0);
    virtual void        wrapV(int rounded = 1, int preserveShape = 0);
    virtual void        openV(int preserveShape = 0, int safe = 0);
    
    virtual short       isClampedU(void) const;
    virtual short       isClampedV(void) const;

    // Assuming the hull is closed in u/v, "unroll" it so that the CVs that are
    // shared to form a wrapped surface are made unique. Also, the hull becomes
    // open. The base class method only flips the open flag. If the face is
    // not closed, the method returns -1. Otherwise it returns 0.
    virtual int         unrollU(int append_pts = 1);
    virtual int         unrollV(int append_pts = 1);

    virtual int         isPointUsed(GB_Element *pt) const;
    virtual int         isPointGroupUsed(const GB_PointGroup &grp) const;
    virtual int         hasEdge(const GEO_Point &a, const GEO_Point &b) const;
    virtual int         hasEdge(const GB_Edge &edge) const;

    // Check degenerate condition by testing face area in u and v
    virtual int         isDegenerate() const;

    // Delete the vertex that uses the point.
    virtual int         ifDetachPoint(GB_Element *ppt) const;

    ///
    // Methods to handle vertex attributes for the attribute dictionary
    ///
    virtual int         vertexApply(int (*apply)(GB_Vertex &vtx, void *),
                                    void  *data = 0);
    virtual int         vertexApply(int (*apply)(const GB_Vertex &vtx, void *),
                                    void  *data = 0) const;
    virtual void        edgeApply(GEO_EdgeApplyFunc apply, void  *data = 0);
    virtual void        edgeApplyIndex(GEO_EdgeApplyIndexFunc apply,
                                       void  *data = 0);

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

    // Raise the number of CVs to match the newcount. The shape of the face
    // (especially if parametric) should NOT change. Return 0 upon success
    // and -1 otherwise.  start and stop define which indices to examine
    // if newcount is negative it is taken as a relative value.
    virtual int         loftU(int newcount, int start=-1, int stop=-1) = 0;
    virtual int         loftV(int newcount, int start=-1, int stop=-1) = 0;


    // Convert the real domain values of the primitive to unit values to be
    // used in the common evaluation methods:
    virtual void         realToUnitPair(float  ureal, float  vreal,
                                        float &uunit, float &vunit) const;
    // and vice versa
    virtual void         unitToRealPair(float  uunit, float  vunit,
                                        float &ureal, float &vreal) const;

    // Go from a normalized domain ([0,1]) to the real domain or vice versa.
    // In the base class (i.e. here) the real domain ranges from 0 to
    // vertexcount - 1 + isWrapped() for u and v respectively.
    virtual void        unitToRealDomain(float  u_unit, float  v_unit,
                                         float &u_real, float &v_real) const;
    virtual void        realToUnitDomain(float  u_real, float  v_real,
                                         float &u_unit, float &v_unit) const;

    // Calculate the real domains for n consecutive operations on the domain
    // given n normalized domains and the operation

    virtual void        unitToRealSequenceU(float *uunit, float *ureal, 
                                        int ulen) const;
    virtual void        unitToRealSequenceV(float *vunit, float *vreal, 
                                        int vlen) const;

    // Finds the vertex#'s of the end points of an edge.
    // returns 0 if it fails (the edge is not on the hull) , 1 if it succeeds
    virtual int         findEdgePoints(const GB_Edge &edge,
                                       int *pr0, int *pc0, 
                                       int *pr1, int *pc1) const;

    virtual int         findEdgePoints(const GEO_Point &a, const GEO_Point &b,
                                       int *pr0, int *pc0, 
                                       int *pr1, int *pc1) const;

    // This method fills the horizontal and vertical edge matrices
    // based on the input linked list.  An element of the matrix is
    // non-zero if one of the selected edges exists on that spot on the
    // hull, and zero otherwise.  It returns 0 if no edges are on the hull,
    // and 1 if at least one edge matches.
    int                  makeEdgeMatrix(const GB_EdgeGroup &edges,
                                        GEO_SubHull &subhull);

    // Express the points in homogeneous coordinates or vice-versa. endcv can
    // be greater than the number of rows or cols, or smaller than startcv. In 
    // both these cases we will wrap the index.
    void                homogenize(GEO_AttributeHandleList &hlist,
                                    int startrow=0, int endrow=-1,
                                    int startcol=0, int endcol=-1);
    void                dehomogenize(GEO_AttributeHandleList &hlist,
                                    int startrow=0, int endrow=-1,
                                    int startcol=0, int endcol=-1);

    void                homogenize  (int startrow = 0, int endrow = -1,
                                     int startcol = 0, int endcol = -1);
    void                dehomogenize(int startrow = 0, int endrow = -1,
                                     int startcol = 0, int endcol = -1);
    void                homogenizeWAttrib(const GB_FloatOffsets &foffsets,
                                     int startrow = 0, int endrow = -1,
                                     int startcol = 0, int endcol = -1);
    void                dehomogenizeWAttrib(const GB_FloatOffsets &foffsets,
                                     int startrow = 0, int endrow = -1,
                                     int startcol = 0, int endcol = -1);
    void                homogenizeWAttrib(const GB_FloatOffsets *ptoffsets,
                                     const GB_FloatOffsets *vtxoffsets,
                                     int startrow = 0, int endrow = -1,
                                     int startcol = 0, int endcol = -1);
    void                dehomogenizeWAttrib(const GB_FloatOffsets *foffsets,
                                     const GB_FloatOffsets *vtxoffsets,
                                     int startrow = 0, int endrow = -1,
                                     int startcol = 0, int endcol = -1);

    // Append n points equally spaced between the 1st and last vertex.
    void                sampleEndsU(int n);
    void                sampleEndsV(int n);

    // Return the bounds of the valid evaluation interval in domain space:
    // For meshes this refers to cv indices.
    virtual void        validURange(float &ua, float &ub) const;
    virtual void        validVRange(float &va, float &vb) const;
    virtual void        validUInterval(int &a, int &b) const;
    virtual void        validVInterval(int &a, int &b) const;

    // Find enclosing integral values(c1, c2) which validly enclose c
    // and return the distance to c1
    float               getIndices(float c, int &c1, int &c2,
                                   int maxIndex, int wrap) const;

    // Reverse the roles of rows and columns
    virtual void        transpose();

    // Return the surrounding values of the real-space u,v parameters.
    // Returns 1 if succesful, 0 if out-of-range.
    virtual int         parametricBBox(float u, float v,
                                       float *u0, float *u1,
                                       float *v0, float *v1);

    // Find distance in parameter space, aware of wrapping.
    virtual float        uvDist(float u1, float v1, float u2, float v2) const;

    virtual void         weights(unsigned short onOff);

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

protected:
    virtual void        copyOffsetPrimitive(const GEO_Primitive *src, int base);

    // The following three methods are used by removeEdges to
    // remove all possible selected edges from a hull.


    // This computes where the hull needs to be split, recursing downwards
    // if necessary.  It calls getSubHull to split the hulls.  Returns 1 if
    // the hull needs to be deleted as a result of breaking.
    int                  breakHull(GEO_SubHull &subhull, 
                                   int top, int left, int bottom, int right,
                                   GEO_SubHullFlags break_flags);

    // This figures out which edges were actually used in the edge deletion.
    // It returns 1 if all the selected edges were used, 0 if some were not
    int                  checkUsedEdges(UT_BitArray *remove_edges,
                                        const GEO_SubHull &subhull);

    // Implemented in GU.  Gets a part of this hull, creating a new one
    // if break_flags.recurse is set.
    virtual GEO_Hull    *getSubHull(int top, int left, int bottom, int right,
                                    GEO_SubHullFlags break_flags) = 0;

    // Speacial save and load methods for the sub-classes:
    virtual int         savePrivate(ostream &os, int binary) const = 0;
    virtual bool        loadPrivate(UT_IStream &is) = 0;
    virtual int         saveExtra  (ostream &os, int binary) const = 0;
    virtual bool        loadExtra  (UT_IStream &is) = 0;

    // Methods for finding out about point references
    virtual int         pointCanDelete(GB_Element *pt) const;
    virtual void        pointDeleted(GB_Element *pt);

    // Check the validity of the data. Meant to be called especially at loading
    // time. The method returns 1 if OK and 0 if trouble.
    virtual bool        validate(void) const = 0;

    // Clip or wrap c to find enclosing integral values(c1, c2)
    // and return the distance to c1 
    float               getLRIndex(float c, int &c1, int &c2, 
                                   int minIndex, int maxIndex, int wrap) const;


    UT_RefMatrix<GEO_Vertex>    vtxMatx;
    GEO_HullFlags               flags;
    GEO_SurfaceType             surfaceType;


private:

    friend ostream      &operator<<(ostream &os, const GEO_Hull &d)
                        {
                            d.save(os, 0);
                            return os;
                        }
    void                increaseDensityInRows(GEO_AttributeHandleList &h,
                                        int numdivs, GB_PointGroup *pgp);
    void                increaseDensityInCols(GEO_AttributeHandleList &h,
                                        int numdivs, GB_PointGroup *pgp);
};
#endif

---