GU/GU_Detail.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 and Dale Ducharme
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        program name (C++)
 *
 * COMMENTS:
 *      Header file for GU_Detail class...
 *
 */

#ifndef __GU_Detail_h__
#define __GU_Detail_h__

#include "GU_API.h"
#include <UT/UT_PtrArray.h>
#include <UT/UT_PtrMatrix.h>
#include <UT/UT_Matrix3.h>
#include <UT/UT_RefArray.h>
#include <UT/UT_RefMatrix.h>

#include <UT/UT_BitArray.h>
#include <GEO/GEO_Detail.h>
#include <GEO/GEO_PrimType.h>
#include <GEO/GEO_SurfaceType.h>
#include <GEO/GEO_Primitive.h>
#include <GB/GB_NUBBasis.h>
#include <GB/GB_Parameterization.h>

#include "GU_Types.h"
#include "GU_Prim.h"
#include "GU_Error.h"
#include "GU_ClothSeam.h"

class IMG_Raster;
class UT_Interrupt;
class UT_StringArray;

class GB_BreakpointGroup;
class GB_EdgeGroup;
class GB_VertexGroup;
class GEO_Face;
class GEO_PrimMesh;
class GEO_PrimPoly;
class GEO_SoftTransformPointCache;
class GEO_SoftTransformVertexCache;
class GEO_TPSurf;
class GEO_Hull;
class GEO_AttributeHandle;
class GEO_IOTranslator;
class GEO_PointRefArray;

class GU_SplitLoc;
class GU_Curve;
class GU_MetaSurfCache;
class GU_Selection;
class GU_SelectionList;
class GU_OldOBBTree;
class GU_TPSurf;

class GU_PrimPoly;
class GU_PrimMesh;
class GU_PrimPart;
class GU_PrimSphere;
class GU_PrimTube;
class GU_PrimBlob;
class GU_PrimNURBCurve;
class GU_PrimNURBSurf;
class GU_PrimRBezSurf;

// Parameter classes for methods
class GU_AlignParms;
class GU_ArmParms;
class GU_ArmAngles;
class GU_CameraParms;
class GU_CapParms;
class GU_CapOptions;
class GU_ConvertParms;
class GU_CreepParms;
class GU_CurveClayParms;
class GU_CurveNetworkParms;
class GU_EdgeCreaseParms;
class GU_ExtrudeParms;
class GU_FilletParms;
class GU_GridParms;
class GU_JoinParms;
class GU_JointParms;
class GU_LimbAngles;
class GU_LimbParms;
class GU_LoftParms;
class GU_LSystemParms;
class GU_MagnetParms;
class GU_ClothMatchSeamsParms;
class GU_MetaConvertParms;
class GU_MetaSurfCacheParms;
class GU_OffsetParms;
class GU_PolyExtrudeParms;
class GU_PolypatchParms;
class GU_PolyReduceParms;
class GU_PolysplineParms;
class GU_RailParms;
class GU_RevolveParms;
class GU_RoundFilletParms;
class GU_RuledParms;
class GU_SkinParms;
class GU_SkinCache;
class GU_StitchParms;
class GU_SuperQuadParms;
class GU_SweepParms;
class GU_TorusParms;
class GU_TraceParms;
class GU_TriMeshCache;
class GU_TriMeshCacheParms;
class GU_TrimFilletParms;
class GU_TriStripParms;
class GU_TwistParms;
class GU_WarpParms;

typedef UT_PtrArray<GU_SplitLoc *>      GU_SplitLocPtrArray;

#define FOR_ALL_ADDED_POINTS(gdp, firstpt, ppt) \
    for(ppt = firstpt; ppt; ppt = gdp->points().next(ppt))

#define FOR_ALL_ADDED_PRIMS(gdp, firstprim, lastprim, pprim) \
    for(pprim = firstprim; pprim && pprim != lastprim; \
        pprim = gdp->primitives().next(pprim))

class GU_API GU_DetailFlags
{
public:
    GU_DetailFlags()   {
                cached          = 0;
                cacheable       = 1; // YES, cacheable by default
    }
    unsigned    cached:1,       // has any cache been built since last clear?
                cacheable:1;    // should we build the cache before displaying?
};

extern "C" {
    SYS_VISIBILITY_EXPORT extern void   newGeometryIO(void *);
}

class GU_API GU_Detail : public GEO_Detail 
{
public:
                 GU_Detail() : GEO_Detail()
                 {
                     mySelection        = 0;
                     myMetaSurfCache    = 0;
                     myCacheableCount   = 0;
                     myMetaCacheCount   =-1;
                     myMetaCacheEnable  = 1;
                     myTriMeshCache     = 0;
                 }
     explicit    GU_Detail(GU_Detail *src, GB_PrimitiveGroup *primGroup)
                    : GEO_Detail()
                 {
                     mySelection        = 0;
                     myMetaSurfCache    = 0;
                     myCacheableCount   = 0;
                     myMetaCacheCount   =-1;
                     myMetaCacheEnable  = 1;
                     myTriMeshCache     = 0;
                     merge(*src, primGroup);
                 }
     explicit    GU_Detail(const GU_Detail *src)
                    : GEO_Detail()
                 {
                     mySelection        = 0;
                     myMetaSurfCache    = 0;
                     myCacheableCount   = 0;
                     myMetaCacheCount   =-1;
                     myMetaCacheEnable  = 1;
                     myTriMeshCache     = 0;
                     copy(*src, GB_COPY_ONCE,
                          /*collapse_on_end*/false,
                          /*keep_internal_groups*/true);
                 }

    virtual     ~GU_Detail();

    virtual void         clearAndDestroy();

    void                 duplicate(const GU_Detail& gdp, int doselection = 0);

    // Methods for the display cache:
    int                  cached(void) const     { return myFlags.cached;  }
    void                 cached(int onoff=1)    { myFlags.cached = onoff; }
    int                  cacheable(void) const  { return myFlags.cacheable;  }
    void                 cacheOn(void)          { myFlags.cacheable = 1;  }
    void                 cacheOff(void)         { myFlags.cacheable = 0;  }

    void                 destroyCache(void);
    void                 notifyCache(int type);
    void                 notifyCache(int type, const GEO_Point &ppt);
    void                 notifyCache(int type, const GB_PointGroup &grp);

    void                 setTriMeshCache(GU_TriMeshCache *cache)
                                                { myTriMeshCache = cache; }
    GU_TriMeshCache     *getTriMeshCache() const { return myTriMeshCache; }

    // Methods to handle meta surface caching.
    void                 notifyMetaSurfCache(int type);
    void                 notifyMetaSurfCache(int type, const GEO_Point &ppt);
    void                 notifyMetaSurfCache(int type, const GB_PointGroup &);

    int                  buildMetaSurfCache(GU_MetaSurfCacheParms &parms);
    GU_MetaSurfCache    *getMetaSurfCache() const { return myMetaSurfCache; }
                                 
    void                 incrementCacheables()    { myCacheableCount++; }
    void                 decrementCacheables()    { myCacheableCount--; }
    int                  getNumCacheables() const { return myCacheableCount; }

    void                 incrementMetaCacheCount() { myMetaCacheCount++; }
    int                  getMetaCacheCount() const { return myMetaCacheCount; }

    int                  metaCacheEnable() const   { return myMetaCacheEnable;}
    void                 metaCacheEnable(int onoff)
                         { myMetaCacheEnable = (char)onoff;}

    // This initializes the passed in int array so it is 0 where
    // points are a boundary and 1 where they are not a boundary.
    // This handles meshes, etc, properly.  It doesn't handle non-manifold
    // properly.  The checkuv flag determines if it should check uv
    // boundaries, if set, it will mark as 1 any points which have
    // differing UV texture coordinates in their vertices.
    void                 findBoundaryPoints(UT_IntArray &isboundary,
                                            bool checkuv);

    // This takes an array which should be the same size as the number
    // of points, and has 1 wherever a point is to be considered
    // selected.  It then initializes & sets 1 in the isboundary array
    // any point which is on the 8-way boundary of the selection.
    void                 findSelectionBoundaryPoints(
                                const UT_IntArray &pointselection,
                                UT_IntArray &isboundary);

    // These build various sorts of connectivity information.
    void                 buildRingZeroPoints(
                            UT_PtrArray<UT_PtrArray<GEO_Point *> *> &ringzero,
                            UT_IntArray *ringvalence) const;
    void                 buildRingZeroPoints(
                            const GB_PointGroup *ptgroup,
                            UT_PtrArray<UT_PtrArray<GEO_Point *> *> &ringzero,
                            UT_IntArray *ringvalence) const;

    void                 buildRingZeroPrimitives(
                            UT_PtrArray<UT_IntArray *> &ringzero) const;

    //
    // Build various geometries. Returns the first primitive of the new
    // geometry.
    //

    // cube
    GU_PrimPoly         *cube(float xmin = -1, float xmax = 1, 
                              float ymin = -1, float ymax = 1, 
                              float zmin = -1, float zmax = 1,
                              int xdiv = 0, int ydiv = 0, int zdiv = 0,
                              int enforcementBars = 0, 
                              int doConsolidatePoints = 0);

    GU_PrimNURBSurf    *nurbCube(int xdiv, int ydiv, int zdiv,
                                  int orderx = 4, int ordery = 4, int orderz=4,
                                  float xmin = -0.5F, float xmax = 0.5F, 
                                  float ymin = -0.5F, float ymax = 0.5F,
                                  float zmin = -0.5F, float zmax = 0.5F,
                                  GEO_SurfaceType type = GEO_PATCH_QUADS,
                                  bool consolidate = false);

    GU_PrimRBezSurf    *bezCube(int xdiv, int ydiv, int zdiv,
                                int orderx = 4, int ordery = 4, int orderz=4,
                                float xmin = -0.5F, float xmax = 0.5F, 
                                float ymin = -0.5F, float ymax = 0.5F,
                                float zmin = -0.5F, float zmax = 0.5F,
                                GEO_SurfaceType type = GEO_PATCH_QUADS,
                                bool consolidate = false);
    
    GU_PrimMesh        *meshCube(int xdiv, int ydiv, int zdiv,
                                 float xmin = -0.5F, float xmax = 0.5F, 
                                 float ymin = -0.5F, float ymax = 0.5F,
                                 float zmin = -0.5F, float zmax = 0.5F,
                                 GEO_SurfaceType type = GEO_PATCH_QUADS,
                                 bool consolidate = false);
    
    GU_PrimPoly        *polymeshCube(int xdiv, int ydiv, int zdiv,
                                 float xmin = -0.5F, float xmax = 0.5F, 
                                 float ymin = -0.5F, float ymax = 0.5F,
                                 float zmin = -0.5F, float zmax = 0.5F,
                                 GEO_SurfaceType type = GEO_PATCH_QUADS,
                                 bool consolidate = false);
    
    // grids
    GEO_Primitive       *buildGrid(GU_GridParms &parms, 
                                   GU_GridType type = GU_GRID_MESH);

    GU_PrimPoly         *polyGrid(int rows, int cols, 
                                float xsize=1, float ysize=1,
                                float xc = 0, float yc = 0, float zc = 0,
                                GU_OrientationType = GU_PLANE_XY,
                                GEO_SurfaceType type = GEO_PATCH_QUADS);
    GU_PrimMesh         *meshGrid(int rows, int cols,
                                float xsize=1, float ysize=1,
                                float xc = 0, float yc = 0, float zc = 0,
                                GU_OrientationType = GU_PLANE_XY,
                                GEO_SurfaceType type = GEO_PATCH_QUADS,
                                int wrapu = 0, int wrapv = 0);
    GU_PrimNURBSurf     *nurbGrid(int rows, int cols, 
                                int orderu = 4, int orderv = 4,
                                int interpEndsU = 1, int interpEndsV = 1,
                                float xsize=1, float ysize=1, 
                                float xc = 0, float yc = 0, float zc = 0,
                                GU_OrientationType = GU_PLANE_XY,
                                GEO_SurfaceType type = GEO_PATCH_QUADS,
                                int wrapu = 0, int wrapv = 0);
    GU_PrimRBezSurf     *bezGrid(int rows, int cols, 
                                int orderu = 4, int orderv = 4,
                                float xsize=1, float ysize=1, 
                                float xc = 0, float yc = 0, float zc = 0,
                                GU_OrientationType = GU_PLANE_XY,
                                GEO_SurfaceType type = GEO_PATCH_QUADS,
                                int wrapu = 0, int wrapv = 0);
    // torus
    void                 torus(unsigned type, GU_TorusParms &parms);

    // poly-iso surfaces
    GU_PrimPoly         *polyIsoSurface(float (*ptOutside)(const UT_Vector3 &),
                                        const UT_BoundingBox &bbox, 
                                        int xdiv, int ydiv, int zdiv);

    /// When building a meta-surface, the new surface is built in this
    /// gdp.  If desired, src can be "this" as well...
    void                 buildMetaSurface(GU_Detail *src, float lod,
                                          GB_PrimitiveGroup *primGroup = 0);

    void                 buildMetaSurface(GU_Detail *src,
                                          int divx, int divy, int divz,
                                          GB_PrimitiveGroup *primGroup = 0);

    /// A faster way of conversion is to build cross sections.  However, this
    /// doesn't build real surfaces
    void                buildMetaXsection(GU_Detail *src, int nsections,
                                        int axis = 2, int maxdepth = 4,
                                        GB_PrimitiveGroup *primGroup = 0);

    //
    // Geometry filters
    //


    /// orient all the polygonal faces to have the same winding direction
    void                orient(const GB_PrimitiveGroup *group = 0);

    /// inset and extrude a face
    void                extrude(GU_ExtrudeParms &parms);

    /// create a weighted sum of two source inputs
    void                blend(const GU_Detail *source, float weight,
                                bool doPos, bool doClr, bool doNml, bool doTxt,
                                bool doVoxels, 
                                const char *ptidattr, const char *primidattr);


    /// create a weighted sum of size source inputs
    /// Return 1 if at least one pasted surface was involved in the blend,
    /// else 0.
    int                 blend(const GU_Detail *gdps[], const float weights[],
                                int size, bool doPos, bool doClr,
                                bool doNml, bool doTxt,
                                bool doVoxels, 
                                const char *ptidattr, const char *primidattr,
                                const GB_PointGroup *ptGroup);

    /// Transform points to follow surface of path input        
    void                creep(GU_CreepParms &parms);

    /// Consolidate points within a specified distance (returns num done)
    /// If a point group is specified, then, only points in that
    /// group are consolidated.  If the forceConsAll flag is set then
    /// all points will be consolidated in a greedy fashion using a 
    /// branch and bound algorithm.
    int                  consolidatePoints(float distance, 
                                           const GB_PointGroup *ptGrp=0, 
                                           int forceConsAll = 0, int mark = 0);
    
    /// Performs fast consolidation by calling onlyConsolidatePoints.
    /// By default, calls removeUnused when done to remove any unused points
    /// When deleteConsOnly is set, then only consolidated points are removed.
    int                  fastConsolidatePoints(float distance, 
                                               const GB_PointGroup *ptGrp=0, 
                                               int mark = 0);

    // Specifies methods by which points after consolidation will
    // get their group names. ONLYCONS_GRP_PROP_LEAST means that the
    // points will belong to the same group as the original point
    // with least point number. ONLYCONS_GRP_PROP_UNION means that the
    // points will belong to the full set of groups represented 
    // by the original points (so if orig. point 1 is in group A, B and
    // orig. point 2 is in group B, C, the final point will be in A B C).
    // INTERSECT means the point will only belong in groups that are common
    // to all original points. With the example above, it will belong in
    // B.
    enum OnlyConsGroupPropagateType
    {
        ONLYCONS_GRP_PROP_LEAST = 0,
        ONLYCONS_GRP_PROP_UNION,
        ONLYCONS_GRP_PROP_INTERSECT
    };
    /// This does fast consolidation but does *not* call removeUnused when
    /// done.  This means that degenerate primitives will be left along
    /// with orphaned points. If deleteconsolidated is set, the consolidated
    /// points only will be deleted. grouppropagate controls which groups
    /// the new points will belong to. 
    int                  onlyConsolidatePoints(float distance,
                                                const GB_PointGroup *ptgrp = 0,
                                                int mark = 0,
                                                bool deleteconsolidated = false,
                                                OnlyConsGroupPropagateType 
                                                grouppropagate = 
                                                ONLYCONS_GRP_PROP_LEAST);

    int                  consolidateNormals(float distance, 
                                            const GB_PointGroup *ptGrp=0, 
                                            int forceConsAll = 0);
    int                  fastConsolidateNormals(float distance,
                                            const GB_PointGroup *ptGrp = 0);
    /// Consolidate UV attributes within a specified distance.
    ///   This distance can be in UV space or XYZ space.
    ///   There are various methods of placing the consolidated UVs.
    ///
    ///         metric:         0 => UV space
    ///                         1 => XYZ space
    ///
    ///         method:         0 => Average
    ///                         1 => First in Group
    ///                         2 => Specify uvw coordinate
    int                  fastConsolidatePointUVs(float distance,
                                                 const GB_PointGroup &ptGrp,
                                                 const GU_MetricType metric,
                                                 int method,
                                                 UT_Vector3 &uvw);
    int                  fastConsolidateVertexUVs(float distance,
                                                  const GB_VertexGroup &vtxGrp,
                                                  const GU_MetricType metric,
                                                  int method,
                                                  UT_Vector3 &uvw);

    /// Snap points within a specified distance (returns num done)
    /// If a point group is specified, then, only points in that
    /// group are consolidated.  
    /// Snapping doesn't fuse the points together, just makes their
    /// positions match.
    /// The type is 0 for average, 1 for round to lowest point number
    /// and 2 for highest point number.
    /// snappointpos controls whether the point positions will be
    /// snapped.
    /// snapptattribs can be set to indicate that point attributes
    /// are to be snapped.
    /// ptattribhandles is a list of attribute handles for the
    /// attributes that will be snapped.
    int                  snapPoints(int type, float distance, 
                                    const GB_PointGroup *ptgrp=0,
                                    bool snapptpos = true,
                                    bool snapptattribs = false,
                                    UT_PtrArray<GEO_AttributeHandle *>
                                    *ptattribhandles = 0);

    // Methods for snapping attributes (for use with snapAttributes).
    // SNAP_ATTRIBUTE_AVERAGE averages the attributes together.
    // SNAP_ATTRIBUTE_INDEX tells snapAttributes to use an index
    // into the list of snapped points to set the attributes for
    // other points.
    enum SnapAttributesType 
    {
        SNAP_ATTRIBUTES_AVERAGE = 0,
        SNAP_ATTRIBUTES_INDEX
    };
    
    /// For each point in snaplist, snap the attributes in
    /// attribhandles using the method specified in type
    /// Type can be SNAP_ATTRIBUTES_AVERAGE (averages the values)
    /// or SNAP_ATTRIBUTES_INDEX which causes all points in snapList to
    /// conform to the specified attribute values from snapList(snapIndex).
    /// This is done because snapPointAttributes is called from 
    /// snapPoints, which already sorts points based on point number.
    void                snapPointAttributes(const UT_PtrArray<GEO_Point *> 
                                       &snaplist,
                                       const UT_PtrArray<GEO_AttributeHandle *>
                                       &attribhandles,
                                       SnapAttributesType type,
                                       int snapindex = 0);

    /// This version of snapping snaps onto grid coordinates.  You specify
    /// the number of lines per HUnit, so "2" for example will snap to 0.5
    /// boundaries.
    /// type is 0 for round nearest, 1 for round down, 2 for round up.
    /// 0.5 rounds up in nearest.
    void                 snapGrid(int type, 
                                  float xlines, float ylines, float zlines,
                                  float xoff, float yoff, float zoff,
                                  float tol,
                                  const GB_PointGroup *ptGrp=0);
    // Same as before, but with UVs...
    void                 snapGridPointUVs(int type,
                                  float xlines, float ylines, float zlines,
                                  float xoff, float yoff, float zoff,
                                  float tol,
                                  const GB_PointGroup *ptGrp=0);
    void                 snapGridVertexUVs(int type,
                                  float xlines, float ylines, float zlines,
                                  float xoff, float yoff, float zoff,
                                  float tol,
                                  const GB_VertexGroup *vtxGrp=0);

    /// Build holes in the geometry by bridging the holes to their outlines
    /// The angle should be specified as the angle (in degrees) between
    /// the normals.
    int                  buildHoles(float dist = 0.001F, float angle = 0.2F,
                                int snapFace=0,
                                const GB_PrimitiveGroup *primGroup=0);

    /// Remove bridged holes from other than polygons
    void                 unHole(const GB_PrimitiveGroup *primGroup=0);

    /// Unique all points in the detail.  If a point group is specified,
    /// then only points in that group are uniqued
    /// If a primitive group is specified, only those primitives will
    /// have their points uniqued.
    void                 uniquePoints(const GB_Group *group=0, int useMark=0);

    /// Unique all the points that are in this primitive, even if referenced
    /// by other primitives.
    void                 uniquePrimitive(GEO_Primitive *prim);

    /// Remove repeated references of vertices in the faces, then remove all
    /// degenerate primitives regardless of their type.
    /// Set removeRepPoints flag to remove the repeat points as well and
    /// the deletePoints flag to delete the points that were part of the 
    /// degenerate primitive.
    int                  cleanData     (const GB_PrimitiveGroup *primGrp=0,
                                        int removeRepPoints = 0,
                                        float tol = 0.001F, bool deletePoints = false);

    /// Identify dirty data, which is the degenerate primitives that would
    /// be deleted by cleanData.  Return them in the returnGrp, and return
    /// the number of dirty primitives.  If returnGrp is NULL then only
    /// return the count.
    int                  getDirtyData  (GB_PrimitiveGroup *returnGrp,
                                        const GB_PrimitiveGroup *primGrp=0,
                                        int checkRepPoints = 0,
                                        float tol = 0.001F);

    /// Add and compute normal attributes.  Returns the normal offset.
    /// If given a primgroup, only points within the selection are used
    /// in the calculation, all others are zeroed.
    virtual GB_AttributeRef     normal(int internal=0, 
                                    GB_PrimitiveGroup *primgroup = 0);
    virtual void                normal(UT_Vector3Array &output,
                                    bool use_internaln = true) const;


    /// If the applyToVertex is less than 0, the "natural" place will be use,
    /// otherwise 0 = point attrib, 1 = vertex attrib
    void                 applyTexture(GU_TextureType type, GU_AxisType axis,
                                const GB_PrimitiveGroup *primGroup=0,
                                int applyToVertex = -1, int fixPolySeams = 0,
                                const GU_CameraParms *userData = 0);
    /// The scaleTexture() and rotateTexture() methods are depreciated.  Please
    /// use the GU_MODIFY_TEX projection and simply create the approprate
    /// post-transform.
    void                 scaleTexture(float umult = 1, float uoff = 0,
                                      float vmult = 1, float voff = 0,
                                      float wmult = 1, float woff = 0,
                                      const GB_PrimitiveGroup *primGroup=0);
    void                 rotateTexture(float angle,
                                      const GB_PrimitiveGroup *primGroup=0);

    /// Methods for transforming point and vertex texture attributes:
    void                transformPointTexture(const UT_Matrix4& mat,
                                const GB_PointGroup *ptGroup,
                                GEO_Delta *geodelta=0);

    /// Precompute a list of points to soft transform, along with
    /// the distance (squared) to the closest "hard" point.
    /// The metric specifies how distance is measured in space.
    void                computeSoftTransformPointTextureCache(
                                GEO_SoftTransformPointCache &cache,
                                const GB_PointGroup *ptgroup,
                                const GEO_Rolloff &rolloff,
                                const GU_MetricType metric);
    void                softTransformPointTexture(
                                const UT_XformOrder &order,
                                float tx, float ty, float tz,
                                float rx, float ry, float rz,
                                float sx, float sy, float sz,
                                float s_xy, float s_xz, float s_yz,
                                float px, float py, float pz,
                                const GEO_SoftTransformPointCache &cache,
                                const GEO_Rolloff &rolloff,
                                GEO_Delta *geodelta = 0);

    void                transformVertexTexture(const UT_Matrix4& mat,
                                const GB_VertexGroup *vertexGroup,
                                GEO_Delta *geodelta=0);

    // Precompute a list of vertices to soft transform, along with
    // the distance (squared) to the closest "hard" point.
    // The metric specifies how distance is measured in space.
    // ignore_uv_connectivity controls whether we affect vertices
    // which are not in the same uvw-wise connected component.
    void                computeSoftTransformVertexTextureCache(
                                GEO_SoftTransformVertexCache &cache,
                                const GB_VertexGroup *vtxgroup,
                                const GEO_Rolloff &rolloff,
                                const GU_MetricType metric,
                                bool ignore_uv_connectivity);
    void                softTransformVertexTexture(
                                const UT_XformOrder &order,
                                float tx, float ty, float tz,
                                float rx, float ry, float rz,
                                float sx, float sy, float sz,
                                float s_xy, float s_xz, float s_yz,
                                float px, float py, float pz,
                                const GEO_SoftTransformVertexCache &cache,
                                const GEO_Rolloff &rolloff,
                                GEO_Delta *geodelta = 0);

    /// Reverse polygons 
    void                 reversePolys(const GB_PrimitiveGroup *prmGrp=0);

    /// Conversion Routines - to convert from one primitive to another
    /// @{
    void                 convert(GU_ConvertParms &parms);
    void                 convertNew(GU_ConvertParms &parms);
    /// @}

    /// This routine only converts metaballs using a more comprehensive set
    /// of parameters.
    void                 convertMetaballs(GU_MetaConvertParms& parms, const GB_PrimitiveGroup* prim_grp = NULL);


    //
    // SORTING 
    //

    // dominant axis sort 
    void                 sortPoints(UT_PtrArray<GB_Element *>& array,
                                        GU_AxisType axis = GU_XAXIS);
    void                 sortVertices(UT_PtrArray<GEO_Vertex *>& array,
                                        GU_AxisType axis = GU_XAXIS);
    void                 sortPrims(UT_PtrArray<GB_Element *>& array,
                                        GU_AxisType axis = GU_XAXIS);
    void                 sortPointList(GU_AxisType axis)
                         {
                             sortPoints(points(), axis);
                             renumberPoints();
                         }
    void                 sortPrimitiveList(GU_AxisType axis)
                         {
                             sortPrims(primitives(), axis);
                             renumberPrimitives();
                         }

    // sort along an arbitrary vector 
    void                 sortPoints(UT_PtrArray<GB_Element *>& array,
                                    const UT_Vector3 &o, const UT_Vector3 &d);
    void                 sortPrims(UT_PtrArray<GB_Element *>& array,
                                    const UT_Vector3 &o, const UT_Vector3 &d);
    void                 sortPointList(const UT_Vector3 &o, const UT_Vector3 &d)
                         {
                             sortPoints(points(), o, d);
                             renumberPoints();
                         }
    void                 sortPrimitiveList(const UT_Vector3 &o, 
                                           const UT_Vector3 &d)
                         {
                             sortPrims(primitives(), o, d);
                             renumberPrimitives();
                         }

    // random sort 
    void                 sortPoints(UT_PtrArray<GB_Element *>&array, int seed); 
    void                 sortPrims(UT_PtrArray<GB_Element *>&array, int seed); 
    void                 sortPointList(int seed)
                         {
                             sortPoints(points(), seed);
                             renumberPoints();
                         } 
    void                 sortPrimitiveList(int seed)
                         {
                             sortPrims(primitives(), seed);
                             renumberPrimitives();
                         }

    // Sorting according to a provided value list:
    void                 sortElements(UT_PtrArray<GB_Element *>&array, 
                                    float *order);
    void                 sortPointList(float *order)
                         {
                             sortElements(points(), order);
                             renumberPoints();
                         }
    void                 sortPrimitiveList(float *order)
                         {
                             sortElements(primitives(), order);
                             renumberPrimitives();
                         }

    // shift
    void                 shift(int uoffset, int voffset, 
                                GB_PrimitiveGroup *group=0); //verts
    void                 shiftPoints(UT_PtrArray<GB_Element *>&, int offset);
    void                 shiftPrims(UT_PtrArray<GB_Element *>&, int offset);
    void                 shiftPointList(int aoffset)
                         {
                             shiftPoints(points(), aoffset);
                             renumberPoints();
                         } 
    void                 shiftPrimitiveList(int aoffset)
                         {
                             shiftPrims(primitives(), aoffset);
                             renumberPrimitives();
                         }

    // reverse 
    void                 reverse(GB_PrimitiveGroup *group=0); // vertices
    void                 reversePoints(UT_PtrArray<GB_Element *>& array);
    void                 reversePrims(UT_PtrArray<GB_Element *>& array);
    void                 reversePointList()
                         {
                             reversePoints(points());
                             renumberPoints();
                         } 
    void                 reversePrimitiveList()
                         {
                             reversePrims(primitives());
                             renumberPrimitives();
                         }

    // proximity 
    void                 proximityPoints(UT_PtrArray<GB_Element*>& array, 
                                        const UT_Vector3 &point);
    void                 proximityPrims(UT_PtrArray<GB_Element*>& array, 
                                        const UT_Vector3 &point);
    void                 proximityToPointList(const UT_Vector3 &point)
                         {
                             proximityPoints(points(), point);
                             renumberPoints();
                         } 
    void                 proximityToPrimitiveList(const UT_Vector3 &point)
                         {
                             proximityPrims(primitives(), point);
                             renumberPrimitives();
                         }

    void                 vertexOrder(UT_PtrArray<GB_Element*>& array);
    void                 sortByVertexOrder()
                         {
                             vertexOrder(points());
                             renumberPoints();
                         }

#ifdef OTHERSORTS 
    // vertex sort 
    void                 sortPoints(UT_PtrArray<GB_Element *>& array, 
                              GU_VertexOrder vert);
    // proximity sort 
    void                 sortPoints(UT_PtrArray<GB_Element *>&, int prox = 0);
#endif

//
//  Super quadric construction methods
    void        superEllipsoid(const GU_SuperQuadParms &parms);

#if 0
    // Use GU_PrimPoly::isConvex()
    unsigned    isPolyConvex(GU_PrimPoly *pp);
#endif

    // Test if all polygons in this primGroup 
    // (or the entire detail if primGroup = 0) for convexity.
    unsigned    isPolyConvex(GB_PrimitiveGroup*primGroup = 0) const;

//
//  Polygon convexing:  By default, the convexers will triangulate 
    void        convexPoly(GU_PrimPoly *pp, unsigned maxpts = 3, const GU_Detail *restgdp=0);
    void        convex(unsigned maxpts=3, GB_PrimitiveGroup *primGroup=0, const GU_Detail *restgdp=0);

//
//  Non-planar polygon checking
    int         findNonPlanar(GB_PrimitiveGroup *group, float tol = 0.0001F,
                              GB_PrimitiveGroup *primGroup = 0);

//
//  Polygon clipping
    void        clip(UT_Vector3 &normal, float d = 0, int normlize = 0,
                     const GB_PrimitiveGroup *primGroup = 0);

//
//  Polygon creasing
    void        crease(UT_Vector3 &normal, float d = 0, 
                       int normlize = 0, int outputGroups = 0,
                       GB_PrimitiveGroup *above = 0,
                       GB_PrimitiveGroup *below = 0,
                       const GB_PrimitiveGroup *creaseGroup = 0);
//
// fractals
    void        fractalize(int seed = 1, float roughness = 0.6F, 
                           float scaleby=1, int divs=1, 
                           int fixedBoundry = 1, int useVtxNorms = 0,
                           float nx = 0, float ny = 0, float nz = 1,
                           const GB_PrimitiveGroup *fractalGroup = 0);

//
// Twist operations. The method returns 0 if everything goes OK, else -1.
// "pasted" returns 1 if at least one pasted surface was involved in
// the deformation, else 0.
    int          nonLinearDeform(GU_DeformType type,const GU_TwistParms &parms,
                                 int &pasted);

    // Creates an offset surface from the specified surface & radus.
    GEO_Hull    *offset(const GU_OffsetParms &parms);
    
    // Create a Gordon surface out of the given bi-linear network of faces.
    // The faces don't have to be the same type or order or anything.
    // We return the surface if OK and 0 otherwise. If the u or v faces 
    // contain only one face, we automatically generate a final curve. If
    // both u faces and vfaces have 1 curve or one has 2 and the other 1,
    // we generate a Coons surface. "accurate" is used when the curves do not
    // intersect (i.e. when we must compute their min distances).
    GEO_Hull    *gordon(GEO_SurfaceType surftype, int accurate,
                        const GB_PrimitiveGroup &ufaces,
                        const GB_PrimitiveGroup &vfaces,
                        int reparameterize = 0);
    GEO_Hull    *gordon(GEO_SurfaceType surftype, int accurate,
                      const UT_PtrArray<GEO_Primitive*> &uprims_in,
                      const UT_PtrArray<GEO_Primitive*> &vprims_in,
                      GU_SkinCache& skin_cache, 
                      int reparameterize = 0);

    // Generate a Coons surface out of up to 4 boundary curves. Return a 
    // pointer to the surface if successful and 0 otherwise. The faces do
    // not have to have the same type or order.
    GEO_Hull    *coons(GEO_SurfaceType surftype,
                       const GEO_Face &uface1, const GEO_Face &vface1,
                       const GEO_Face *uface2 = 0, const GEO_Face *vface2 = 0);

    // Generate a skinned surface out of a set of cross-sections. The faces
    // don't have to be the same type or order. We return the surface is OK
    // and 0 otherwise. Specifying a vorder of 0 tells the method to
    // come up with a legal default value for the surface. If "doskin" is
    // true, the cross-sections will be right on the surface; otherwise, we
    // build a ruled surface, which simply steals the curves' CVs and assigns
    // them to the surface.
    GEO_Hull    *skin(GU_SkinParms &parms, GU_SkinCache& skin_cache);

    // This restrictive skinning method assumes the faces are of the same type
    // and have the same number of CVs. order 0 means pick most suitable one.
    // If doskin is false, we build a ruled surface. nprims is the number
    // of faces in the group; we compute it if -1. We return the resulting
    // surface and do not delete the input faces. We also assume that if
    // nprims > 2 and vorder != 2 and doskin, all the faces are nonrational.
    // Finally, the provided vParmValues if given specifies what v coordinate
    // each of the provided faces should interpolate.
    GEO_Hull    *skin(const GB_PrimitiveGroup &ucfaces,
                      GEO_SurfaceType surftype = GEO_PATCH_QUADS,
                      unsigned vorder = 0, int vwrap = 0,
                      int doskin = 1, int nprims = -1,
                      const UT_Vector *vParmValues = 0);
    GEO_Hull    *skin(const UT_PtrArray<GEO_Primitive*> & prims_in, GU_SkinCache& skin_cache, 
                      GEO_SurfaceType surftype = GEO_PATCH_QUADS,
                      unsigned vorder = 0, int vwrap = 0,
                      int doskin = 1, int nprims = -1,
                      const UT_Vector *vParmValues = 0);

    // See GU_Ruled.h for the various closure and interpolation types
    // which are valid. Specifying an orderv of 0 makes the routine
    // come up with a legal default value for the surface.
    int         ruled( GEO_Hull *&surface, const GU_RuledParms &p,
                        const GU_CapOptions &caps);

    // See GU_CurveNetwork.h for parameter types. This method generates
    // a skinned surface, a Coons surface, or a Gordon surface depending on
    // the primitive groups it is given. Specifying an orderv of 0 makes the
    // routine come up with a legal default value for the surface.
    int         curveNetwork(GEO_Hull *&hull, GU_CurveNetworkParms &p, 
                            int &count, GU_SkinCache& skin_cache);

    GU_ERROR    sweep( GU_SweepParms parms );
    void        rails( GU_RailParms parms );

    // Join more faces or surfaces together.
    GEO_Primitive       *join( GU_JoinParms &p, int &count);

    // Generate a fillet between two curves on surfaces:
    GEO_Hull            *filletTrims(GU_TrimFilletParms &parms, int &count);

    // Generate a rounded fillet:
    GEO_Hull            *filletRound(GU_RoundFilletParms &parms);
    void                 filletRoundNetwork(UT_RefMatrix<void*>, 
                                            GU_RoundFilletParms &parms);

    // Create skeleton-compatible joints between each pair of circles
    void                 joint(const GU_JointParms &p);


    // Fillet a set of faces/hulls
    // Return 0 if OK, -1 otherwise (non face/hull types)

    int                  fillet(GU_FilletParms &parms, int &count);

    // Loft (stitch) a number of polygons together without changing the number
    // of points in the detail.  Return 0 if successful and -1 otherwise.
    int                  loft(GU_LoftParms &p, const GB_PointGroup &g1,
                                               const GB_PointGroup &g2);

    int                  loft(GU_LoftParms &p,
                              const GB_PrimitiveGroup *group = 0);

    // Revolves all curves in the given gdp (or only curves in the 
    // group if the group is given) around a line given by the center 
    // and axis. Only polygonal curves use the divisions. NURBS and
    // Bezier curves are revolved a special way to create a perfectly
    // round surface with a minimum number of revolution copies.
    int         revolve( const GU_RevolveParms &parms,
                         const GU_CapOptions &caps, int &count);

    // Warp curves or surfaces. Return 0 if successful and -1 otherwise.
    int         warp(GU_WarpParms &parms);

    // Curve Clay it!
    GU_ERROR    curveClay(const GU_CurveClayParms &ccparm);

    // This puts endcaps on the specified hull
    int         endCap(GEO_Hull &hull, const GU_CapParms &parms);
    int         endCap(GEO_Face &face, const GU_CapParms &parms);

    // This places all caps on the hull
    int         setCaps(GEO_Hull &hull, const GU_CapOptions &parms, int &count);
    int         setCaps(GEO_Face &face, const GU_CapOptions &parms, int &count);

 
    // Creates a deformed copy of a source detail given a pair of 
    // rest and deform details. Return 1 if a pasted surface was deformed,
    // else 0. If 'deform_history' is passed in, every time we deform a point 
    // from our source, we mark this by setting the bit in 'deform_history' 
    // whose index corresponds to the point's number to 1. Useful if you want
    // to know which points we deformed.
    int         lattice(const GU_Detail *source, const GU_Detail *rest, 
                        const GU_Detail *deform, int xdiv, int ydiv, int zdiv,
                        const GB_PointGroup *ptgroup = 0,
                        UT_BitArray *deform_history = NULL,
                        GU_LatticeType type = GU_LATTICE_BEZIER);

    // All points of the gdp are deformed according to the meta source
    // field that surrounds it.  The deformation is controlled by a 
    // transformation matrix.
    int         magnet( const GU_MagnetParms &parms );

    // trace a raster image to form closed polygons
    float       trace(GU_TraceParms *parms);

    // add point texture attributes to traced geometry
    void        applyTraceTexture(float xres, float yres, float resolution);


    // fit a sequence of discrete points to a series of bezier curves
    void        fit2DCurve(const GU_Detail *source, float error_squared,
                           GB_PrimitiveGroup *primGroup = 0);
    
    // Fit a curve through its breakpoints
    GU_Curve    *interpCurveBreakpoints(const GEO_Face &face,
                            unsigned type=GEOPRIMNURBCURVE,
                            int order=4,
                            GB_ParmType parmType=GB_PARM_CHORD);
    GU_Curve    *interpCurveBreakpoints(const UT_PtrArray<GEO_Point*> &gpData,
                            unsigned type=GEOPRIMNURBCURVE,
                            int order=4, int wrapped=0,
                            GB_ParmType parmType=GB_PARM_CHORD);
    GU_Curve    *interpCurveBreakpoints(const UT_Vector4Array &v4Data,
                            unsigned type=GEOPRIMNURBCURVE,
                            int order=4, int wrapped=0,
                            GB_ParmType parmType=GB_PARM_CHORD);

    // interpolation data points
    GU_Curve    *interpCurveGlobal(const GEO_Face &face, 
                            unsigned type=GEOPRIMNURBCURVE, 
                            int order=4, 
                            GB_ParmType parmType=GB_PARM_CHORD,
                            GB_KnotSpaceType knotSpaceType=GB_KNOT_AVERAGING);
    GU_Curve    *interpCurveGlobal(const UT_PtrArray<GEO_Point *> &gpData, 
                            unsigned type=GEOPRIMNURBCURVE, 
                            int order=4, int wrapped=0,
                            GB_ParmType parmType=GB_PARM_CHORD,
                            GB_KnotSpaceType knotSpaceType=GB_KNOT_AVERAGING);
    GU_Curve    *interpCurveGlobal(const UT_Vector4Array &v4Data, 
                            unsigned type=GEOPRIMNURBCURVE, 
                            int order=4, int wrapped=0, 
                            GB_ParmType parmType=GB_PARM_CHORD,
                            GB_KnotSpaceType knotSpaceType=GB_KNOT_AVERAGING);
    GU_Curve    *interpCurveLocal(const GEO_Face &face,
                            unsigned type=GEOPRIMBEZCURVE,
                            int order = 4, int corner=0);
    GU_Curve    *interpCurveLocal(const UT_PtrArray<GEO_Point *> &gpData, 
                            unsigned type=GEOPRIMBEZCURVE,
                            int order = 4, int wrapped=0, int corner=0);
    GU_Curve    *interpCurveLocal(const UT_Vector4Array &v4Data, 
                            unsigned type=GEOPRIMBEZCURVE,
                            int order = 4, int wrapped=0, int corner=0);

    GU_TPSurf   *interpSurfGlobal(const GEO_Hull &mesh,
                          unsigned type=GEOPRIMNURBSURF,
                          int uOrder=4, int vOrder=4,
                          GEO_SurfaceType sType=GEO_PATCH_QUADS,
                          GB_ParmType uParmType=GB_PARM_CHORD,
                          GB_ParmType vParmType=GB_PARM_CHORD,
                          GB_KnotSpaceType uKnotSpaceType=GB_KNOT_AVERAGING,
                          GB_KnotSpaceType vKnotSpaceType=GB_KNOT_AVERAGING,
                          const UT_Vector *uParmValues = 0,
                          const UT_Vector *vParmValues = 0);

    GU_TPSurf   *interpSurfGlobal(const UT_PtrMatrix<GEO_Point *> &gpMesh,
                          unsigned type=GEOPRIMNURBSURF,
                          int uOrder=4, int vOrder=4,
                          int uWrapped=0, int vWrapped=0,
                          GEO_SurfaceType sType=GEO_PATCH_QUADS,
                          GB_ParmType uParmType=GB_PARM_CHORD,
                          GB_ParmType vParmType=GB_PARM_CHORD,
                          GB_KnotSpaceType uKnotSpaceType=GB_KNOT_AVERAGING,
                          GB_KnotSpaceType vKnotSpaceType=GB_KNOT_AVERAGING,
                          const UT_Vector *uParmValues = 0,
                          const UT_Vector *vParmValues = 0);

    GU_TPSurf   *interpSurfBreakpoints(const GEO_Hull &mesh,
                          unsigned type=GEOPRIMNURBSURF,
                          int uOrder=4, int vOrder=4,
                          GEO_SurfaceType sType=GEO_PATCH_QUADS,
                          GB_ParmType uParmType=GB_PARM_CHORD,
                          GB_ParmType vParmType=GB_PARM_CHORD,
                          GB_KnotSpaceType uKnotSpaceType=GB_KNOT_AVERAGING,
                          GB_KnotSpaceType vKnotSpaceType=GB_KNOT_AVERAGING,
                          const UT_Vector *uParmValues = 0,
                          const UT_Vector *vParmValues = 0);

    GU_TPSurf   *interpSurfBreakpoints(const UT_PtrMatrix<GEO_Point *> &gpMesh,
                          unsigned type=GEOPRIMNURBSURF,
                          int uOrder=4, int vOrder=4,
                          int uWrapped=0, int vWrapped=0,
                          GEO_SurfaceType sType=GEO_PATCH_QUADS,
                          GB_ParmType uParmType=GB_PARM_CHORD,
                          GB_ParmType vParmType=GB_PARM_CHORD,
                          GB_KnotSpaceType uKnotSpaceType=GB_KNOT_AVERAGING,
                          GB_KnotSpaceType vKnotSpaceType=GB_KNOT_AVERAGING,
                          const UT_Vector *uParmValues = 0,
                          const UT_Vector *vParmValues = 0);

    // Approximate data points given a tolerance.
    // Only for open endinterpolated surface.

    GU_Curve    *approxCurveGlobal(const GEO_Face &face,
                                   unsigned type=GEOPRIMNURBCURVE, 
                                   int order=4, 
                                   float tol=1e-1F, float smooth=0.0F,
                                   int noMultipleKnots=1);
    GU_Curve    *approxCurveGlobal(const UT_Vector4Array &v4Data,
                                   unsigned type=GEOPRIMNURBCURVE, 
                                   int order=4, int wrapped=0,
                                   float tol=1e-1F, float smooth=0.0F,
                                   int noMultipleKnots=1);

    GU_TPSurf   *approxSurfGlobal(const GEO_Hull &mesh,
                                  unsigned type=GEOPRIMNURBSURF,
                                  int uOrder=4, int vOrder=4,
                                  GEO_SurfaceType sType=GEO_PATCH_QUADS,
                                  float tol=1e-1F, float smooth=0.0F,
                                  int uNoMultipleKnots=1,
                                  int vNoMultipleKnots=1);
    GU_TPSurf   *approxSurfGlobal(const UT_PtrMatrix<GEO_Point *> &gpMesh,
                                  unsigned type=GEOPRIMNURBSURF,
                                  int uOrder=4, int vOrder=4,
                                  int uWrapped=0, int vWrapped=0,
                                  GEO_SurfaceType sType=GEO_PATCH_QUADS,
                                  float tol=1e-1F, float smooth=0.0F,
                                  int uNoMultipleKnots=1,
                                  int vNoMultipleKnots=1);

    
    // methods to refine face and hull types

    void        refine(float *uunit, int ulen,
                       float *vunit, int vlen,
                       int countu=1, int countv=1, 
                       int arcspacing = 0,
                       const GB_PrimitiveGroup *primGroup = 0);

    void        unrefine(float umin, float umax,
                         float vmin, float vmax,
                         int countu=1, int countv=1,
                         float utol=0.001F, float vtol=0.001F, 
                         const GB_PrimitiveGroup *primGroup = 0);

    void        subdivide(float *uunit, int ulen,
                          float *vunit, int vlen,
                          int arcspacing = 0,
                          const GB_PrimitiveGroup *primGroup = 0);

    // op = {0 = isoparms, 1 = points, 2 = profiles}
    int         extract(float *uunit, int ulen,
                        float *vunit, int vlen,
                        const GB_PrimitiveGroup *primGroup = 0,
                        GB_PointGroup *newPoints = 0,
                        int op = 0, int keepOriginal = 0,
                        int atbreakpoints = 0, int use_arc_length = 0);

    void        extractIsoParms(float *uunit, int ulen,
                                float *vunit, int vlen,
                                GB_PrimitiveGroup *newPrims = 0,
                                const GB_PrimitiveGroup *primGroup = 0);

    void        extractPoints(float *uunit, int ulen,
                              float *vunit, int vlen,
                              GB_PointGroup *newPoints = 0,
                              const GB_PrimitiveGroup *primGroup = 0);

    void        extractProfiles(float *uunit, int ulen,
                                float *vunit, int vlen, 
                                const GB_PrimitiveGroup *primGroup = 0);

    void        extractIsoParmsAtBreak(float *uunit, int ulen,
                                       float *vunit, int vlen,
                                       GB_PrimitiveGroup *newPrims = 0,
                                       const GB_PrimitiveGroup *primGroup = 0);

    void        extractPointsAtBreak(float *uunit, int ulen,
                                     float *vunit, int vlen,
                                     GB_PointGroup *newPoints = 0,
                                     const GB_PrimitiveGroup *primGroup = 0);

    void        extractProfilesAtBreak(float *uunit, int ulen,
                                       float *vunit, int vlen, 
                                       const GB_PrimitiveGroup *primGroup = 0);


    int         cut(float *uunit, int ulen,
                    float *vunit, int vlen,
                    const GB_PrimitiveGroup *primGroup = 0,
                    int keepin=1, int keepout=0, int atbreakpoints = 0,
                    int allU = 0, int allV = 0, int use_arc_length = 0);


    // approximate a spline by using polygonal hull inputs
    void        polySpline(GU_PolysplineParms &parms, 
                           const GB_PrimitiveGroup *primGroup = 0,
                           bool deleteAll = true); // whether or not to delete
                                                   // the existing polygons

    // approximate a patch by using polygonal or mesh hull inputs
    int         polyPatch(GU_PolypatchParms &parms, 
                          const GB_PrimitiveGroup *primGroup = 0);

    // reduce the number of polygons in a detail:
    int         polyReduce(GU_PolyReduceParms &parms,
                            const GB_PrimitiveGroup *primGroup = 0,
                            int *pointIndexTable = 0);

    // triangle strip
    int         triStrip( GU_TriStripParms &parms );

    // Create geometry through premise and rule substitution
    void        lsystem(GU_LSystemParms &lp);

    // Get information about a GU_Detail
    // If overridememusage is positive, it will be used rather than the
    // getMemoryUsage().
    int         info(ostream &os, int maxlines = 15, int64 overridememusage = -1) const;
    int64       getMemoryUsage(void) const;


    //
    //  intersectRay will find the closest intersection with a primitive
    //  in the detail.  If the dist pointer is nil, then the first intersection
    //  found will be returned (instead of the closest).  The nml will contain
    //  the normal for the primitive at the point of intersection.
    // Accuracy of 0 is inaccurate, 1 is normal, 2 engages Algebraic pruning
    // where available.
    //
    GEO_Primitive       *intersectRay(const UT_Vector3 &o, const UT_Vector3 &d,
                                float tmax = 1E17F, float tol = 1E-12F,
                                float *dist = 0, UT_Vector3 *pos = 0, 
                                UT_Vector3 *nml = 0, int accurate = 0, 
                                float *u = 0, float *v = 0, 
                                int ignoretrim = 1) const;

    //
    // Figure out the parameters of the face/surface that all the given
    // faces/surfaces should have in order to be fully compatible with one
    // another. Return 0 if all the primitive types are faces/surfaces,
    // and -1 otherwise.
    //
    int                  commonFaceConfig(const GB_PrimitiveGroup &faceGroup,
                                unsigned &type, int &order, int &open,
                                int &ends) const;
    int                  commonFaceConfig(const UT_PtrArray<GEO_Primitive*> &faces_in,
                                unsigned &type, int &order, int &open,
                                int &ends) const;
    int                  commonSurfaceConfig(const GB_PrimitiveGroup &surfs,
                                unsigned &type, int &orderu, int &orderv,
                                int &openu, int &openv, int &endsu,
                                int &endsv) const;

    // Incompatible faces in infaces are made compatible and set in outfaces.
    // Return 0 of OK, -1 otherwise. If extratype is not nil and the highest
    // face type of the infaces is less than *extratype, replace the common
    // type by *extratype. In the method that takes 2 input groups, we make
    // sure that the primitives in the 2 groups have the same type. Set 
    // equalcvs to 1 make them all have the same number of CVs too.
    int                  makeFacesCompatible(const GB_PrimitiveGroup &infaces,
                                             GB_PrimitiveGroup &outfaces,
                                             int mustopen=0, int mustends=0,
                                             int nonrational=0,
                                             unsigned *extratype = 0,
                                             int equalcvs = 1);
    int                  makeFacesCompatible(const UT_PtrArray<GEO_Primitive*> &prims_in,
                                            UT_PtrArray<GEO_Primitive*>& prims_out,
                                            int mustopen=0, int mustends=0,
                                            int nonrational=0,
                                            unsigned *extratype = 0,
                                            int equalcvs = 1);
    int                  makeFacesCompatible(const GB_PrimitiveGroup &infacesU,
                                             const GB_PrimitiveGroup &infacesV,
                                             GB_PrimitiveGroup &outfacesU,
                                             GB_PrimitiveGroup &outfacesV,
                                             int mustopen=0, int mustends=0,
                                             int nonrational=0,
                                             unsigned *extratype = 0,
                                             int equalcvs = 1);
    int                  makeFacesCompatible(const UT_PtrArray<GEO_Primitive*> &ufaces_array,
                                             const UT_PtrArray<GEO_Primitive*> &vfaces_array,
                                             UT_PtrArray<GEO_Primitive*> &ucfaces_array,
                                             UT_PtrArray<GEO_Primitive*> &vcfaces_array,
                                             int mustopen=0, int mustends=0,
                                             int nonrational=0,
                                             unsigned *extratype = 0,
                                             int equalcvs = 1);

    // Loft a subsection of each hull and update the vertex indices where
    // the subsection occurs. Does partial nurb merging if the bases is given
    // Assumes the two hulls have been properly reconfigured.

    static int           loftHulls(GEO_Hull *left, GEO_Hull *right,
                                   float lwidth1, float lwidth2, 
                                   float rwidth1, float rwidth2,
                                   int sharp, int &lstart, int &rstart, 
                                   int &lmax, int &rmax,
                                   int loftU, GB_NUBBasis *nubbasis);

    //
    // Refine the hull at the unit domain value and return the
    // row/col index where it occurs

    static int           getSubdividedCV(GEO_Hull *hull, int udir, float unit);
    static int           getSubdividedCV(GEO_Face *face, float unit);
    
    // Methods for registering and unregistering geometry io converters.
    static void          registerIOTranslator(GEO_IOTranslator *trans);
    static void          unregisterIOTranslator(GEO_IOTranslator *trans);

    //
    //  Stream I/O METHODS.
    //  Inherited from GEO_Detail.
    //
    virtual int          save(const char *, int binary,
                                const UT_Options  *options) const;
    virtual int          save(ostream& os, int binary,
                                const UT_Options *options) const;
    virtual int          load(const char *, const UT_Options *options);
    virtual bool         load(UT_IStream &is, const UT_Options *options);

    /// Returns true if filename is a recognized extension.
    static bool          isFormatSupported(const char *filename);

    // 
    // Align a set of primitives by rotation and translation
    void                 align(GU_AlignParms &parms);   

    // Align a set of faces/hulls at optional levels of continuity.
    // face/hull pre/posttranslate + row stitching + row tangent
    // Faces are aligned with faces, hulls with hulls. 
    // Return 0 if OK, -1 otherwise (non face/hull types)

    int                  stitch(GU_StitchParms &parms); 


    // Create an IK chain of primitive circles.  ret_angles are filled in
    // with the resulting angles for the humerous, ulna and hand
    int                  arm(GU_ArmParms &parms, GU_ArmAngles &ret_angles);

    // Create an IK chain of primitive circles.  ret_angles are filled in
    // with the resulting angles for the hip, thigh, shin and foot
    void                 limb(GU_LimbParms &parms, GU_LimbAngles &ret_angles);

    // Incompatible surfaces in insurfs are made compatible and set in outsurfs.
    // Return 0 of OK, -1 otherwise. If extratype is not nil and the highest
    // surface type of the insurfs is less than *extratype, replace the common
    // type by *extratype. Set equalcvs to 1 make them all have the same number
    // of CVs too.
    int                  makeSurfacesCompatible(
                                             const GB_PrimitiveGroup &insurfs,
                                             GB_PrimitiveGroup &outsurfs,
                                             int mustopenu=0, int mustopenv=0,
                                             int mustendsu=0, int mustendsv=0,
                                             int equalcvsu=1, int equalcvsv=1,
                                             unsigned *extratype = 0);
    //
    // Convenience wrappers for several common pasting operations. The last
    // method destroys both groups:
    //
    GB_PrimitiveGroup   *getPastedSurfaces(const char *n = "__gu_all_pasted__");
    GB_PrimitiveGroup   *getPastedSurfaces(GB_PrimitiveGroup *&used,
                                           const char *n = "__gu_all_pasted__",
                                           const char *u = "__gu_used_pasted__");
    void                 updatePastedDisplacement(const GEO_Point &ppt,
                                                const GB_PrimitiveGroup *all,
                                                GB_PrimitiveGroup *used);
    int                  updatePastedDisplacements(void);
    int                  updatePastedDependents(GB_PrimitiveGroup *all,
                                                GB_PrimitiveGroup *used);

    //
    // Error Routines
    //

    GU_ERROR             error() const
                         {
                             return UTgetErrorManager()->getSeverity();
                         }

    void                 addMessage(GU_ErrorCodes code, 
                                    const char *msg = 0) const
                         {
                             UTgetErrorManager()->addMessage("GU", code, msg);
                         }
    void                 addWarning(GU_ErrorCodes code, 
                                    const char *msg = 0) const
                         {
                             UTgetErrorManager()->addWarning("GU", code, msg);
                         }
    void                 addError(GU_ErrorCodes code, const char *msg = 0) const
                         {
                             UTgetErrorManager()->addError("GU", code, msg);
                         }

    // Set or query the selection pointer. WARNING: when destroyed, this gdp
    // will also delete the selection, so make sure the current selection is
    // not deleted or the pointer to it is 0.
    void                 selection(GU_Selection *s)     { mySelection = s; }
    GU_Selection        *selection(void) const          { return mySelection;}
    void                 destroySelection();

    // While the primary selection is typically set by a SOP when it cooks
    // to indicate the affected geometry, the selection lists provide a set
    // of selections for temporary use.  These are used to select from a gdp
    // when choosing the input to another sop.  An entry in a list is allowed
    // to be nil, but note that using the [] operator doesn't set inbetween
    // entries to nil, so be careful.  Like the main selection, the gdp will
    // delete the contents of the selection lists when destroyed. Each gdp
    // can have any number of selection lists, called "instances". This name
    // is because one SOP's geometry may be instanced many times (by DOP
    // geometry or instancing at the object level). Each one of these
    // instances needs to hold a different set of selections.
    GU_SelectionList            &getOrCreateSelectionList(int &instance);
    const GU_SelectionList      &getSelectionList(int instance) const;
    int                          getNumSelectionListInstances() const;
    void                         destroySelectionLists();

    // Copy all the temp selections from the given gdp into the current one.
    // Any previously existing temp selections will be removed first.
    void                 copySelectionLists(const GU_Detail &src_gdp);

    // Add the cook selection from the given gdp to our temp selection.
    void                 addSelectionToTemp(const GU_Detail &src_gdp,
                                            const GU_Selection &src_sel,
                                            int &sel_inst, int sel_index,
                                            bool dirty_gdp = true);

    // Notify all selections of topology changes so that they can rebuild any
    // associated cached structures, when and if necessary.
    void                 dirtySelectionTopologyData();

    /// Deprecated in favour of GEO_Primitive::copyGroupMembership()
    void SYS_DEPRECATED preserveGroups(const GEO_Primitive *oldprim,
                                       const GEO_Primitive *newprim);
    /// Deprecated in favour of GEO_Primitive::copyGroupMembership()
    void SYS_DEPRECATED preservePrimitiveGroups(const GEO_Primitive *oldprim,
                                                const GEO_Primitive *newprim);

    // Remove points from polygons if they lie on (within a tolerance)
    // the line connecting the previous and next points.
    void                removeInlinePoints(float tol,
                                           const GB_PrimitiveGroup *prims);

    // Create (if necessary or requested) and return OBBTree, and
    // inertial tensor and inverse of inertial tensor
    void                getRBDParams( GU_OldOBBTree &tree,
                                      UT_Matrix3 &ibody,
                                      UT_Matrix3 &ibodyinv,
                                      int samples,
                                      float lod ) const;

    // Remove zero area polygons
    // Returns number of polygons removed
    int                 removeZeroAreaFaces(GB_PrimitiveGroup *grpp,
                                            int   ignoreOpenFaces = 0,
                                            float tolerance = 0.001F,
                                            int   onlyPolys = 1);
    int                 removeZeroAreaFaces(const UT_IntArray &primlist,
                                            int   ignoreOpenFaces = 0,
                                            float tolerance = 0.001F,
                                            int   onlyPolys = 1);
    
    // Deletes the geometry in the given group, unlike deleteEdges,
    // it doesn't repair the holes left behind.
    void                deleteGroupGeometry(GB_BaseGroup &group);
    
    // Deletes edge geometry
    void                deleteEdges(GB_EdgeGroup &edgegroup,
                                    bool del_inline_points,
                                    float inlinetol,
                                    bool del_unused_points = true,
                                    bool del_bridges = true);

    // Flips edges
    void                flipEdges(GB_EdgeGroup &edgegroup, int rotations = 1,
                                  bool rotattribs = false, 
                                  GB_EdgeGroup *outedges = 0);
    // Splits edges
    // This is the main method for the PolySplit SOP.  The splitlocs are
    // the positions along which you wish to split polygons.  When quadcut
    // is false, the Shortest Path algorithm is used, otherwise the Quad Cut
    // algorithm is used.  The forcecut flag is used with the Shortest Path
    // algorithm to force it to perform cuts where the initial cut has failed.
    // To form a complete path of edges, supply the first location again as
    // the last location in the splitlocs array.
    void                edgeSplit(const GU_SplitLocPtrArray &splitlocs, 
                                  bool quadcut = false,
                                  bool forcecut = true,
                                  GB_EdgeGroup *outedges = 0,
                                  float tolerance = FP32_TOLERANCE);

    // Inserts points on edges
    void                divideEdges(GB_EdgeGroup &edgegroup, int numdivs = 1,
                                    bool applytoall = true,
                                    bool use_shared_points = false,
                                    GB_EdgeGroup *outedges = 0,
                                    UT_PtrArray<GEO_Point*> *new_points = 0,
                                    GEO_PointRefArray *prefarr = 0,
                                    bool preserve_edge_dir = false);
    void                divideEdges(GB_EdgeGroup &edgegroup,
                                    int numdivs,
                                    bool applytoall,
                                    bool use_shared_points,
                                    GB_EdgeGroup *outedges,
                                    UT_PtrArray<GEO_Point*> *new_points,
                                    GEO_PointRefArray *prefarr,
                                    bool preserve_edge_dir,
                                    float fraction);

    // Transform breakpoints
    void                transformBreakpoints(const UT_Matrix4 &mat,
                                             const GB_BreakpointGroup *grp = 0,
                                             int quickxform = 0);


    // Smooth (fair)
    void                smoothNonPolygons(int iterations, GU_WeightingType type,
                                        float lambda, float mu, 
                                        const GB_PrimitiveGroup *primgrp,
                                        bool useptattribs,
                                        const GB_AttributeRef &attriboffset,
                                        int  attribsize);

    // Extrude faces, uses local face spaces and tries to mirror extrusions.
    void                polyExtrude(const GU_PolyExtrudeParms &parms);

    // Collapse Edges
    void                edgeCollapse(const GB_EdgeGroup &edgegroup,
                                     bool removedegen = true,
                                     bool updatenmls  = true,
                                     GB_PointGroup *outpoints = 0);

    // Adds crease weights to edges
    void                edgeCrease(const GU_EdgeCreaseParms &parms); 

    // Insets points
    void                pointInset(const GB_PointGroup *ptgroup,
                                   float insetdist, float nmldist);

    // Find the oriented bounding box that contains the given primitives.
    // The box is returned as a rotate+translate matrix to the box's
    // orientation and centre, and a vector containing the boxes extents
    // along its primary axes.  The extents are radii, ie, one-half
    // of what a bounding box size() would be.
    //
    // Returns zero radii if the group contains no primitives.
    void                getOBBox(const GB_PrimitiveGroup *grp,
                                 UT_Matrix4 &transform,
                                 UT_Vector3 &radii) const;

    // Make each primitive planar, returns the number of primitives xformed
    int                 makePrimsPlanar(const GB_PrimitiveGroup *grp = 0);

    // Cloth seam-related methods:
    // -----------------------------------------------------------------------
    // Creates cloth seams between ordered point groups.
    void                setSeamPointAttributes(const GB_PointGroup &group_a,
                                               const GB_PointGroup &group_b);
    // Get the number of cloth seams.
    int                  getNumClothSeams() const;
    // Get the attribute names for a seam, given the seam index and which
    // half of the seam it is (0 or 1).
    void                 getClothSeamAttribName(UT_WorkBuffer& attrib_name,
                                                int seam_number,
                                                int seam_half) const;
    // Find the point attribute name for the specified half of the specified
    // seam and return its offset.  A negative offset means the attribute
    // doesn't exist.
    GB_AttributeRef      getClothSeamAttribOffset(int seam_number,
                                                  int seam_half) const;
    // Append the points on the specified half of the specified seam to a
    // group.
    void                 appendSeamPoints(
                                UT_RefArray<GU_ClothStitchPair> &seam_points,
                                int seam_number) const;
    // Match the topology of cloth seams by inserting points.  Optionally
    // refine the seams too.
    void                 matchClothSeams(const GU_ClothMatchSeamsParms &parms);

    static void          loadIODSOs();

protected:
    GEO_Primitive       *newPrimitive(unsigned type);

private:
    // Gets the specified number of points that are "inside" the object
    void                 getPointsInGeo (UT_Vector3 *ptArray,
                                         int numpts) const;
    
    int                  twist          (const GU_TwistParms &parms, int &p);
    int                  bend           (const GU_TwistParms &parms, int &p);
    int                  squashStretch  (const GU_TwistParms &parms, int &p);
    int                  shear          (const GU_TwistParms &parms, int &p);
    int                  taper          (const GU_TwistParms &parms, int &p);
    int                  linearTaper    (const GU_TwistParms &parms, int &p);

    void                 fillGrid(GEO_Hull &hull, int rows, int cols, 
                                  float x_size, float y_size,
                                  float x_center, float y_center, 
                                  float z_center,
                                  GU_OrientationType plane);

    void                 convertPolysToHull(GU_ConvertParms &parms,
                                            int convertNew);

    void                 convertVolumesToPolys(GU_ConvertParms &parms,
                                             bool convertnew);

    void                 convertMetasToPolys(GU_ConvertParms &parms, 
                                             int convertNew);
                                            
    void                 doConversion(GU_ConvertParms &parms, 
                                      int convertNew);

    void                 orientPoly(GEO_PointRefArray &ptRefArray, 
                                    GEO_PrimPoly *poly, 
                                    UT_BitArray &process,
                                    UT_BitArray &reverse);

    GEO_Primitive       *surfCube(int xdiv, int ydiv, int zdiv,
                                  int orderx, int ordery, int orderz,
                                  float xmin, float xmax, 
                                  float ymin, float ymax,
                                  float zmin, float zmax, 
                                  GEO_SurfaceType type, int kind,
                                  bool consolidate); 

    // Checks if a single primitive is dirty (see getDirtyData).
    bool                 isDirtySinglePrimitive(GEO_Primitive *prim,
                                                int checkRepPoints,
                                                float tol);

    void                 lodConvert(GB_PrimitiveGroup *grp, 
                                        UT_BoundingBox &box, int cluster, float lod);
    void                 divisionConvert(GB_PrimitiveGroup *grp, int adjust,
                                        UT_BoundingBox &box, int divx, int divy, 
                                        int divz, GB_BitArray *barray, int bsize);
    int                  adjustStepBox(float &min, float &max, float step);
    void                 stepSizeConvert(GB_PrimitiveGroup *grp, int adjust, 
                                        UT_BoundingBox &box, float sx, float sy, float sz,
                                        GB_BitArray *barray, int bsize);

    GU_Detail(const GU_Detail &src);    // prohibited

    GU_Selection        *mySelection;           // geometry selection
    GU_MetaSurfCache    *myMetaSurfCache;       // cache for all metasurfaces
    GU_TriMeshCache     *myTriMeshCache;        // Cache for trimeshes.
    GU_DetailFlags       myFlags;               // various gdp options
    int                  myCacheableCount;      // number of cacheable prims

    // secondary, temp. selections, stored on a per-instance basis.
    UT_PtrArray<GU_SelectionList *>      mySelectionLists;

    int                  myMetaCacheCount;
    char                 myMetaCacheEnable;

    // makes a single primitive planar (see makePrimsPlanar)
    int                  primToPlane(GEO_Primitive *pprim,
                                        UT_Vector4Array* fixedPoints = 0);
};

#endif

---