GU/GU_TPSurf.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:
 *      Dale Ducharme
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        GU_TPSurf.h (C++)
 *
 * COMMENTS:
 *      Header file for GU_TPSurf.h class...
 * 
 */

#ifndef __GU_TPSurf_h__
#define __GU_TPSurf_h__

#include "GU_API.h"
#include <GEO/GEO_TPSurf.h>
#include "GU_Prim.h"

class UT_FloatArray;
class UT_Vector2;
class UT_Vector3;
class UT_Vector3Array;
class UT_Vector4Array;
class UT_LinkList;
class GD_Primitive;
class GEO_Face;
class GEO_Curve;
class GU_TPSurfCache;
class GU_PrimPoly;
class GU_RayCache;
class GU_RayInfo;
class GU_Detail;
class GU_TPSurf;
class GU_ConvertMethod;
class GU_IsectCurveSet;

// Project Function Pointers
typedef int     (GU_TPSurf::*GU_PFP)(UT_Vector3 &, float&, float&,
                                     const UT_Vector3 &);

class GU_API GU_ProjectParms
{
public:
    GU_ProjectParms();

    int                 type;   // by vector (0) or by parametric (1) mapping

    UT_Vector3          axis;   // projection axis if projecting along vector   
    int                 fnorm;  // use face normal for projection axis
    int                 side;   // closest (0), farthest (1) , or all sides (2)
    int                 sdivs;  // number of divisions per 3D curve span
    float               rtol;   // ray intersection tolerance
    float               ftol;   // 2D tolerance for fitting
    float               uvgap;  // max % uv distance for joining profiles
    int                 sharp;  // maintain sharpness when fitting
    int                 order;  // 2D spline order for the fit
    int                 ignoretrim;     // If true, ignores trimming info
    int                 algebraic;      // If true, uses Algebraic Pruning.

    UT_Axis3::axis      uaxis;  // u axis for parametric mapping
    UT_Axis3::axis      vaxis;  // v axis for parametric mapping
    int                 range;  // use the range below to map the curve into
    float               umin;   // 0 <= umin <= 1
    float               umax;   // 0 <= umax <= 1
    float               vmin;   // 0 <= vmin <= 1
    float               vmax;   // 0 <= vmax <= 1
    int                 unif;   // uniform (1) or arc length (0) mapping
};

/////////////////////////////////////////////////////////////
//                                                         //
// Class:     GU_TPSurf                                    //
// Descr:     This class is responsible for general type   //
//       of operations on nurbs and the surf  classes.     //
//                                                         //
/////////////////////////////////////////////////////////////

class GU_API GU_TPSurf : public GU_Primitive
{
public:
    ~GU_TPSurf(); 

    // Conversion Methods 

     GEO_Primitive      *convert(GU_ConvertParms &parms,
                                 GB_PointGroup *usedpts = 0);
     GEO_Primitive      *convertNew(GU_ConvertParms &parms);

     virtual int         intersectRay(const UT_Vector3 &o, const UT_Vector3 &d,
                                      float tmax = 1E17F, float tol = 1E-12F,
                                      float *distance = 0, UT_Vector3 *pos = 0,
                                      UT_Vector3 *nml = 0, int accurate = 0,
                                      float *u = 0, float *v = 0,
                                      int ignoretrim = 1) const;
     int                 intersectSurf(GU_Primitive &prim, 
                                   GU_IsectCurveSet &curveset, 
                                   float worldtol = 1e-4F,
                                   float domaintol = 1e-2F,
                                   int steps = 100,
                                   int docompact = 1);
     int                 doesIntersect(GU_Primitive &prim,
                                   float worldtol = 1e-4F, int nontrivial = 0);

     // Send a ray to see if it intersects the surface. The hitinfo should
     // contain all the needed info, such as tolerance and find farthest.
     // The hit info is updated if a hit is found, and 1 is returned. The
     // (u,v) intersection point is also set in hitinfo.
     int                 rayHit(const UT_Vector3 &o, const UT_Vector3 &dir,
                                GU_RayInfo &hitinfo) const;

     // This is more powerful than convertNew. It always returns a NEW
     // object, so free it when you're done with it. It may return a mesh,
     // a NURB surface or a Bezier surface depending on the type.
     virtual GEO_Hull   *reconfigure(unsigned type, int orderu, int orderv,
                                     int openu, int openv,
                                     int endsu, int endsv) const = 0;

     void                normal(int noff) const;
     void                normal(UT_Vector3Array &output) const;

    // Construct a curve that has our characteristics in u or v. The
    // CVs of the new curve are not set.
    virtual GEO_Curve   *buildRowCurve(int appendPoints = 1,
                                       GU_Detail *parent = 0) const = 0;
    virtual GEO_Curve   *buildColCurve(int appendPoints = 1,
                                       GU_Detail *parent = 0) const = 0;

    // Compute the CVs of the U or V isoparametric curve running through
    // the given parametric value. The number of resulting CVs equals the
    // number or rows (if v = const.) or cols (if u = const.) respectively.
    // We return the extracted curve if successful and 0 otherwise.
    GEO_Curve           *extractUIsoparm(float u, int uoffset=-1,
                                         GU_Detail *parent=0) const;
    GEO_Curve           *extractUIsoparmWAttrib(float u,
                                         const GB_FloatOffsets &foffsets,
                                         int uoffset=-1) const;
    GEO_Curve           *extractUIsoparm(float u, GEO_AttributeHandleList &hl,
                                int uoffset=-1, GU_Detail *parent=0) const;
    GEO_Curve           *extractVIsoparm(float v, int voffset=-1,
                                         GU_Detail *parent=0) const;
    GEO_Curve           *extractVIsoparmWAttrib(float v,
                                         const GB_FloatOffsets &foffsets,
                                         int voffset=-1) const;
    GEO_Curve           *extractVIsoparm(float u, GEO_AttributeHandleList &hl,
                                int uoffset=-1, GU_Detail *parent=0) const;

    // remove a single curve in the domain of the hull
    GEO_Curve           *extractU(float unitu, GU_Detail *parent=0);
    GEO_Curve           *extractV(float unitv, GU_Detail *parent=0);

    // Project the face or the group of faces onto the surface to create a
    // curve on surface. Return 0 if OK and -1 otherwise.
    // If the projection type is set to parametric mapping, the group method
    // maps the faces in sequence rather than one on top of each other. Also,
    // if the gdp pointer is zero, we assume the faces live in our gdp.
    int                  project(const GEO_Face &f, const GU_ProjectParms &p);
    int                  project(const GB_PrimitiveGroup &faces,
                                 const GU_ProjectParms &p, GU_Detail *gdp = 0);

    // Extract one or more (if not fully inside the domain) 3D curve(s) out of
    // a profile's image onto the surface. Return the first 3D curve if
    // successful and 0 otherwise. Only one (the first visible piece of the
    // curve) will be extracted if only_first_visible_part is set.
    // The second extract doeas a parametric extract, so the whole profile will
    // be extracted regardless of its visibility. The resulting 3D curve will
    // be a planar XY curve at the given z elevation.
    GEO_Curve           *extract(const GD_Primitive &profile, int smooth = 1,
                                 int sdivs = 20, float tol = 0.001F,
                                 int sharp = 1, int order = 4,
                                 int only_first_visible_part = 0) const;
    GEO_Face            *extract(const GD_Primitive &profile, float z=0) const;

    // Methods to handle caching.
    virtual GU_DisplayCache     *getDisplayCache(void) const;
    virtual int                  buildDisplayCache(GU_CacheParms &parms);

    virtual GU_DisplayMesh      *getDisplayMesh(int, float);

    virtual GU_RayIntersect     *getRayCache(void) const;
    virtual int                  buildRayCache(void);

    // Persistent is true if the returned cache is not to be deleted by
    // the caller.
    virtual GU_RayIntersect     *createRayCache(int &persistent);

    virtual void         destroyCache(void);
    virtual void         notifyCache(int type);
    virtual void         notifyCache(int type, const GEO_Point &ppt);
    virtual void         notifyCache(int type, const GB_PointGroup &grp);
    virtual void         notifyCache(int type, const UT_Matrix4 &xform, 
                                     int push);
    virtual void         notifyCache(int type, const UT_Vector3 &delta);

    static void          compute4PtNormal(UT_Vector4 &p1,UT_Vector4 &p2,
                                          UT_Vector4 &p3,UT_Vector4 &p4, 
                                          UT_Vector3 &n1,UT_Vector3 &n2,
                                          UT_Vector3 &n3,UT_Vector3 &n4);


    // Cut a wedge of the primitive given a domain range
    // ind1 and ind2 are indices to the refined values
    // They are updated if negative on input, else used as is.
    // If keep is zero the curve is only refined and the indices
    // updated.

    virtual GU_TPSurf   *cutU(float u1, float u2, int &ind1, int &ind2,
                                int keep) = 0;

    virtual GU_TPSurf   *cutV(float v1, float v2, int &ind1, int &ind2,
                                int keep) = 0;

    // Open the primitive at the given domain value
    virtual void         openAtU(float u) = 0;
    virtual void         openAtV(float v) = 0;


     // Elevate the curve to the given order. Return 0 if OK and -1 otherwise.
    int                 elevateOrderU(int order);
    int                 elevateOrderV(int order);

    // Finds the points on the surface that is minimums to the points on the 
    // face.  We will find the points so that the face is divided into 
    // "numdivs" segments.  Returns via the UT_RefArray.  Returns the actual
    // number of points in the domain.
    int                  findMins(const GEO_Face &face, int numdivs,
                                  UT_Vector3Array &domain,
                                  const GEO_Face *dface = 0,
                                  UT_Vector4Array *displaces = 0);
    // Projects points from the face to the surface in the direction of
    // projdir.  We will find the points so that the face is divided into 
    // "numdivs" segments.  Returns the (u,v) pairs of the domain via the 
    // UT_RefArray.  Returns the actual number of points added.
    int                  findProjects(GEO_Face& face, int numdivs,
                                      const UT_Vector3 &projdir,
                                      UT_Vector3Array &domain,
                                      const GEO_Face *dface = 0,
                                      UT_Vector4Array *displaces = 0);

    // Puts the position of the breakpoint at (uidx, vidx) in p
    // Returns 1 if uidx and vidx are both valid, 0 otherwise.
    int                  interpretBreakpoint(int uidx, int vidx, UT_Vector3 &p);


protected:
    // We don't want anybody to instantiate a GU_TPSurf.
    GU_TPSurf() : GU_Primitive() { theDisplayCache = 0; theRayCache = 0;} 

    // Fill the hull with row and column data. Return 0 if OK, and -1 if error.
    int                 create(GEO_TPSurf *tp, int rows, int cols, 
                               GEO_SurfaceType type, int wrapu, int wrapv,
                               int appendPoints = 1);

    // Trust us that is is the pointer to use to access the actual surface.
    void                setSurface(GEO_TPSurf *tp)      { theSurf = tp;   }

public: // Warning: getSurface() is really meant to be private.
    GEO_TPSurf         *getSurface(void) const          { return theSurf; }
protected:

    static void          compute2PtNormal(UT_Vector4 &p1, 
                                          UT_Vector4 &p2, 
                                          UT_Vector3 &nml)
                         {
                             nml.x() += (p1.z() + p2.z()) * (p2.y() - p1.y()); 
                             nml.y() += (p1.x() + p2.x()) * (p2.z() - p1.z()); 
                             nml.z() += (p1.y() + p2.y()) * (p2.x() - p1.x());
                         }

    // Return the start and and knots for a full uniform evaluation of the
    // mesh.
    void                 evaluationInterval(float lodu, float lodv, 
                                 float &ustart, float &ustop, int &nu,
                                 float &vstart, float &vstop, int &nv) const;

    // Fill with values within the valid uv interval. Return 0 if OK and -1
    // otherwise.
public:
    int                  evaluateSurface(GU_ConvertMethod &method,
                                         UT_Vector4Array &pos,
                                         int &nu, int &nv,
                                         UT_FloatArray *uval = 0,
                                         UT_FloatArray *vval = 0) const;
protected:
    int                  evaluateSurface(GU_ConvertMethod &method,
                                         UT_Vector4Array &pos,
                                          GB_AttributeData *&aptdata, 
                                          GB_AttributeData *&avtxdata,
                                          int &nu, int &nv) const;

    void                 compute2PtNormal(GEO_Point *p1,
                                          GEO_Point *p2, UT_Vector3 &nml) const;

    void                 quadNormal(GEO_Point *p1, GEO_Point *p2,GEO_Point *p3,
                                    GEO_Point *p4, int noff) const;
    void                 quadNormal(GEO_Point *p1, GEO_Point *p2,GEO_Point *p3,
                                    GEO_Point *p4, UT_Vector3Array &output) const;

private:
    
    GEO_TPSurf          *theSurf;               // the "real" surface
    GU_TPSurfCache      *theDisplayCache;       // display cache
    GU_RayCache         *theRayCache;           // display cache

    GEO_Primitive       *convertToPoly(GU_ConvertParms &parms);

    // Helpers for curve-on-surface projections:
    GU_PrimPoly         *projectOnePoint(const UT_Vector3 &orig,
                               const UT_Vector3 &dir, float uvgap,
                               GU_RayInfo &hitinfo, GU_Detail &polygdp,
                               float &pdot, int &pclose, int &projcount,
                               GU_PrimPoly *&poly,
                               GU_PrimPoly *&pfirst, GU_PrimPoly *&nfirst,
                               const GEO_Face &face, int cridx, int lod,
                               int numdiv=4);
    GU_PrimPoly         *projectOnePoint(const UT_Vector3 &orig,
                               const UT_Vector3 &dir, float uvgap,
                               GU_RayInfo &hitinfo, GU_Detail &polygdp,
                               UT_LinkList &polys, int &projcount);
    int                  projectOnSide(const UT_Vector4Array &pos,
                               const UT_Vector3 &dir, const UT_Vector3 &ndir,
                               int myfar, float rtol, float uvgap, int cls,
                               GU_Detail &pgdp, const GEO_Face &face, int lod,
                               int algebraic, int ignoretrim);
    int                  projectOnAllSides(const UT_Vector4Array &pos,
                               const UT_Vector3 &dir, const UT_Vector3 &ndir,
                               float rtol, float uvgap, int cls,
                               GU_Detail &pgdp, const GEO_Face &face, int lod,
                               int algebraic, int ignoretrim);
    int                  projectAlongMinimum(const UT_Vector4Array &pos,
                                             int closed, float uvgap,
                                             GU_Detail &polygdp);
    void                 processSideHit(GU_PrimPoly *pinpoly,
                               GU_PrimPoly *&poutpoly, GU_PrimPoly *&pfirst,
                               GU_PrimPoly *ninpoly, GU_PrimPoly *&noutpoly,
                               GU_PrimPoly *&nfirst, float uvgap,
                               GU_Detail &polygdp, int &pstartidx, 
                               int &nstartidx, int cridx);
    void                 processEndHit(GU_Detail &polygdp, GU_PrimPoly &poly,
                               GU_PrimPoly *first, float uvgap, int close);
    void                 joinHits(GU_PrimPoly &apoly, GU_PrimPoly &bpoly,
                               GU_PrimPoly *&pfirst, GU_PrimPoly *&nfirst);
    int                  connectToEdge(GU_PrimPoly *poly, GU_Detail &polygdp, 
                               float uvgap, int isfirst);
    int                  projectAddBisectPoints(GU_PrimPoly *poly,
                               GU_Detail &polygdp, const GEO_Face &face,
                               int lod, int index, int isfirst, 
                               const UT_Vector3 &dir, GU_RayInfo &hitinfo, 
                               float uvgap, float pdot, int numdiv);

    // Functions as input for findMinOrProj
    int                  minimumFunction(UT_Vector3 &from, float &u, float &v,
                                         const UT_Vector3 &);
    int                  projectFunction(UT_Vector3 &from, float &u, float &v,
                                         const UT_Vector3 &projdir);
    // Finds the points on the surface that is minimums to the points on the 
    // face.  We will find the points so that the face is divided into 
    // "numdivs" segments.  Returns via the UT_RefArray.  Returns the actual
    // number of points in the domain.
    int                  findMinsOrProj(GU_PFP fp, const GEO_Face &face, 
                                        int numdivs, const UT_Vector3 &projdir,
                                        UT_Vector3Array &domain,
                                        const GEO_Face *dface = 0,
                                        UT_Vector4Array *displaces = 0);

};

#endif

---