GEO/GEO_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:
 *      Mark Elendt and Cristin Barghiel
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Geometry Library (C++)
 *
 * COMMENTS:
 *      This class handles tensor product (TP) surfaces of arbitrary degree.
 *      The Hull class maintains the hull for the surface.
 *
 * 
 */

#ifndef __GEO_TPSurf_h__
#define __GEO_TPSurf_h__

#include "GEO_API.h"
#include <UT/UT_RefMatrix.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_Interval.h>
#include <GB/GB_Basis.h>
#include <GB/GB_Parameterization.h>
#include "GEO_Hull.h"
#include "GEO_PrimType.h"
#include "GEO_Greville.h"

class UT_Vector3;
class UT_Vector4;
class UT_FloatArray;
class UT_BoundingRect;
class GB_AttributeData;
class GB_FloatOffsets;
class GEO_WorkVertexBuffer;
class GEO_Profiles;
class GEO_PasteSurf;
class GEO_Delta;

class GEO_API GEO_TPSurf : public GEO_Hull {
public:
    // Constructor that attaches this surface to detail "d". You can optionally
    // specify the number of rows and columns.
    GEO_TPSurf(GEO_Detail *d, int m = 0, int n = 0);

    // Class destructor, virtual by inheritance. It assumes it is OK to
    // delete the bases, so make sure you always set the bases with objects
    // allocated from the heap.
    virtual ~GEO_TPSurf();

    // Return any dependent elements (GD_Primitive profiles)
    virtual GB_Element  *getSecondary(int );
    virtual unsigned     numSecondary(void);

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

    // Overwrite this surface with the data from src. Virtual by inheritance.
    virtual void                 copyPrimitive( const GEO_Primitive *src,
                                            GEO_Point **ptredirect);
    virtual GEO_Primitive       *copy(int preserve_shared_pts = 0) const;

    // Merge tpsurf's profiles into ours. Skin invisible ones if you want.
    void                         mergeProfiles(const GEO_TPSurf &tpsurf,
                                               int onlyvisible = 0);


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

    // Given a domain value (u,v), store all the basis derivatives 
    // (from 0 to du and from 0 to dv inclusive) into ubmatx and vbmatx
    // respectively. Return the min indices of the CVs needed
    // for the linear combination. The indices may exceed the number of
    // vertices if the surface is wrapped, so remember to use modulus (%).
    virtual int         evaluateBasisDerivs(float u, float v,
                                     float ubmatx[][GB_MAXORDER],
                                     float vbmatx[][GB_MAXORDER],
                                     int &rowoffset, int &coloffset,
                                     unsigned du=0, unsigned dv=0,
                                     int uoffset=-1, int voffset=-1) const = 0;

    // Evaluate the basis at the given point in the domain and also return
    // the index of the first CV to linearly combine the basis with. The CV
    // indices may exceed the number of vertices if the surface is wrapped,
    // so remember to use modulus (%).
    virtual int         evaluateBasis(float u, float v, float *ubvals,
                                     float *vbvals, int &rowoffset,
                                     int &coloffset,
                                     unsigned du=0, unsigned dv=0,
                                     int uoffset=-1, int voffset=-1) const = 0;
    virtual int         evaluateUBasis(float u, float *ubvals, int &coloffset,
                                     unsigned du=0, int uoffset=-1) const = 0;
    virtual int         evaluateVBasis(float v, float *vbvals, int &rowoffset,
                                     unsigned dv=0, int voffset=-1) const = 0;

    // Return the value of the i'th u/vbasis at parameter u or v, or both.
    // This method handles both rational an non-rational surfaces. You need
    // to specify the row and column index only if the surface is rational,
    // so that we know whose weights to use.
    float               computeUBValue(float u, int uoff, int row = 0) const;
    float               computeVBValue(float v, int voff, int col = 0) const;
    float               computeBValue (float u,float v,int uoff,int voff)const;

    // Two flavours of a bulk surface evaluator that computes points or
    // derivatives inside a parametric rectangle determined by:
    // a) the u and v values specified in uArr and vArr respectively. The
    // length of the parameter arrays is arrLen.
    // b) uStart, uStop, vStart, and vStop.
    // The functions return  0 if successful, and -1 otherwise.
    virtual int         evaluateMesh(float *uArr, unsigned uArrLen, 
                                     float *vArr, unsigned vArrLen, 
                                     UT_Vector4 *pos,
                                     unsigned du=0, unsigned dv=0
                                    ) const;
    virtual bool        evaluateMesh(float uStart, float uStop, 
                                     unsigned nu, float vStart, float vStop, 
                                     unsigned nv, GEO_Vertex **results,
                                     GEO_AttributeHandleList &hlist,
                                     unsigned du=0, unsigned dv=0) const;
    virtual int         evaluateMesh(float uStart, float uStop, unsigned nu,
                                     float vStart, float vStop, unsigned nv,
                                     UT_Vector4 *pos,
                                     unsigned du=0, unsigned dv=0) const;
    virtual int         evaluateMeshWAttrib(float uStart, float uStop, 
                                     unsigned nu, float vStart, float vStop, 
                                     unsigned nv, UT_Vector4 *pos,
                                     GB_AttributeData *adata,
                                     const GB_FloatOffsets &foffsets,
                                     unsigned du=0, unsigned dv=0) const;

    // Similar to evaluateMesh(), only it does between breakpoints. 'lod' is
    // the number of points between two breakpoints in u or v. The methods
    // compute the number of spans in v if vspans is -1. The number of isoparms
    // computed in v is returned if OK; else -1. Pass in the bkpoint index of
    // the startidx knot if you know it.
    // The optional float array is filled with the actual u and v parameter
    // values the mesh was set to.
    virtual int         fillBreakMesh(int ustartidx, int ustopidx,
                                    int vstartidx, int vstopidx,
                                    int ulod, int vlod,
                                    UT_Vector4 *pos, int &vspans /* = -1 */,
                                    int vbreakidx = -1,
                                    unsigned du = 0, unsigned dv = 0,
                                    UT_FloatArray *uval = 0,
                                    UT_FloatArray *vval = 0) const;
    virtual int         fillBreakMesh(int ustartidx, int ustopidx,
                                    int vstartidx, int vstopidx,
                                    int ulod, int vlod,
                                    GEO_Vertex **results,
                                    GEO_AttributeHandleList &hlist,
                                    int &vspans, int vbreakidx = -1,
                                    unsigned du = 0, unsigned dv = 0) const;
    virtual int         fillBreakMeshWAttrib(int ustartidx, int ustopidx,
                                    int vstartidx, int vstopidx,
                                    int ulod, int vlod,
                                    UT_Vector4 *pos, GB_AttributeData *adata,
                                    const GB_FloatOffsets &foffsets,
                                    int &vspans /* = -1 */, int vbreakidx = -1,
                                    unsigned du = 0, unsigned dv = 0) const;

    // Fill pos with isoparametric curves, one curve per breakpoint. It is
    // possible to compute a subpart of each curve by specifying interior
    // knot indices. These methods evaluate across whole spans. They compute
    // the number of spans in the direction of the curve unless given. They
    // will compute the breakpoint index of startidx unless you pass it in.
    // They return the number of spans in the other direction or -1. "lod" 
    // represents the number of points to be evaluated between two breakpoints.
    virtual int         fillUCurves(int ustartidx, int ustopidx,
                                    int vstartidx, int vstopidx, int lod,
                                    UT_Vector4 *pos, int &uspans /* = -1 */,
                                    int ubreakidx = -1,
                                    unsigned du = 0, unsigned dv = 0) const;
    virtual int         fillVCurves(int ustartidx, int ustopidx,
                                    int vstartidx, int vstopidx, int lod,
                                    UT_Vector4 *pos, int &vspans /* = -1 */,
                                    int vbreakidx = -1,
                                    unsigned du = 0, unsigned dv = 0) const;
    virtual int         fillUCurves(int ustartidx, int ustopidx,
                                    int vstartidx, int vstopidx, int lod,
                                    GEO_Vertex **results,
                                    GEO_AttributeHandleList &hlist,
                                    int &uspans /* = -1 */, int ubreakidx = -1,
                                    unsigned du = 0, unsigned dv = 0) const;
    virtual int         fillVCurves(int ustartidx, int ustopidx,
                                    int vstartidx, int vstopidx, int lod,
                                    GEO_Vertex **results,
                                    GEO_AttributeHandleList &hlist,
                                    int &vspans /* = -1 */, int vbreakidx = -1, 
                                    unsigned du = 0, unsigned dv = 0) const;
    virtual int         fillUCurvesWAttrib(int ustartidx, int ustopidx,
                                    int vstartidx, int vstopidx, int lod,
                                    UT_Vector4 *pos, GB_AttributeData *adata,
                                    const GB_FloatOffsets &foffsets,
                                    int &uspans /* = -1 */, int ubreakidx = -1,
                                    unsigned du = 0, unsigned dv = 0) const;
    virtual int         fillVCurvesWAttrib(int ustartidx, int ustopidx,
                                    int vstartidx, int vstopidx, int lod,
                                    UT_Vector4 *pos, GB_AttributeData *adata,
                                    const GB_FloatOffsets &foffsets,
                                    int &vspans /* = -1 */, int vbreakidx = -1, 
                                    unsigned du = 0, unsigned dv = 0) const;

    // Similar to fillBreakMesh(), only it passes a function to do whatever
    // at every u,v pair instead of explicitly evaluating. 'lod' is
    // the number of points between two breakpoints in u or v. The method
    // computes the number of spans in v if vspans is -1. The # of isoparms
    // computed in v is returned if OK; else -1. Pass in the bkpoint index of
    // the startidx knot if you know it. If apply() returns a valus < 0 we
    // break and exit with that return code. If the surface is rational and
    // you need to work in homog. coords, you must homogenize and dehomog.
    // the rationals yourself.
    int                 applyBreakMesh(int ustartidx, int ustopidx,
                                       int vstartidx, int vstopidx,
                                       int ulod, int vlod, int &vspans /*=-1*/,
                                       int (*apply)(float ucrt, float vcrt,
                                                     int arridx, void *data),
                                       void *data=0, int vbreakidx=-1) const;

    // 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 0 if successful and -1 otherwise. Use these methods to
    // extract isoparms.
    int                 computeUConstCVs(float u, GEO_Vertex **results,
                                         GEO_AttributeHandleList &hlist,
                                         int uoffset=-1) const;
    int                 computeUConstCVs(float u, UT_Vector4 *cvs, 
                                         int uoffset=-1) const;
    int                 computeUConstCVsWAttrib(float u, UT_Vector4 *cvs, 
                                         GB_AttributeData *acvs,
                                         const GB_FloatOffsets &foffsets,
                                         int uoffset=-1) const;
    int                 computeVConstCVs(float u, GEO_Vertex **results,
                                         GEO_AttributeHandleList &hlist,
                                         int uoffset=-1) const;
    int                 computeVConstCVs(float v, UT_Vector4 *cvs, 
                                         int voffset=-1) const;
    int                 computeVConstCVsWAttrib(float v, UT_Vector4 *cvs, 
                                         GB_AttributeData *acvs,
                                         const GB_FloatOffsets &foffsets,
                                         int voffset=-1) const;

    // Create a profile curve (curve on surface) at the given isopam value:
    // Return 0 if successful and -1 otherwise. growtip is a value by which
    // we grow the tips of the iso line. It's useful to have it non-zero
    // when trimming.
    int                 createUConstProfile(float u, float growtip = 0.0f);
    int                 createVConstProfile(float v, float growtip = 0.0f);

    // Map the given value, defined in our domain, to a value in a chord/arc
    // length domain computed from our columns (u) or rows (v). Return -1 if
    // failed and 0 if successful. u and v must live in the valid interval.
    // Compute the chord-length parameterized basis in U or V for a given
    // location in our valid interval. Return 0 if OK and -1 otherwise. ubasis
    // and vbasis will be resized inside these methods if necessary.
    int                 chordUBasis(float v, GB_Basis &ub, int voff=-1) const;
    int                 chordVBasis(float u, GB_Basis &vb, int uoff=-1) const;

    // Evaluate one point (when du=dv=0), or the du-th dv-th derivative.
    // Return 0 if successful, and -1 otherwise.
    // The difference between this method and evaluate() is that this one
    // treats u and v as values between 2 knot indices, while evaluate()
    // sees them as actual domain values.

    virtual bool        evaluateIndex(fpreal iu, fpreal iv,
                                GEO_Vertex &result,
                                GEO_AttributeHandleList &hlist,
                                unsigned du, unsigned dv) const;
    virtual int         evaluateIndex(float iu, float iv, UT_Vector4 &pos, 
                                 unsigned du=0, unsigned dv=0) const;
    virtual int         evaluateIndexWAttrib(float iu, float iv,
                                 UT_Vector4 &pos, GB_AttributeData &adata,
                                 const GB_FloatOffsets &foffsets,
                                 unsigned du=0, unsigned dv=0) const;

    // Evaluate the position or the derivative at domain point (u,v), where
    // u and v MUST be in [0,1]. "v" and "dv" will be ignored when dealing
    // with one-dimensional types such as circles and polygons. Return 0 if
    // OK and -1 otherwise.
    virtual bool         evaluatePoint( GEO_Vertex &result,
                                    GEO_AttributeHandleList &hlist,
                                    fpreal u, fpreal v, uint du, uint dv) const;
    virtual int          evaluatePoint( UT_Vector4 &pos, float u, float v = 0,
                                        unsigned du=0, unsigned dv=0) const;
    virtual int          evaluatePointWAttrib(UT_Vector4 &pos,
                                        GB_AttributeData &adata,
                                        const GB_FloatOffsets &foffsets,
                                        float u, float v = 0, unsigned du = 0,
                                        unsigned dv = 0) const;

    // Evaluate the unit normal at (u,v) or at basis indices (iu,iv).
    // Return 0 if successful, and -1 otherwise.
    virtual int         evaluateNormal(float u,float v, UT_Vector3 &nml) const;
    virtual int         normalIndex(float iu, float iv, UT_Vector3 &nml) const;

    // Evaluate the curvature at (u,v).
    // Return 0 if successful, and -1 otherwise.
    int                 curvature(float u, float v, float &curv) const;

    // Evaluate the arc length of the surface within a range. If the
    // values are invalid, return -1. divs means divisions per span.
    float               arcLength(float u0, float v0, float u1, float v1,
                                  int divs = 10) const;

    // Evaluate the surface over the valid parametric interval in both 
    // directions, and place the points in the pos array. 
    // Return 0 if successful, and -1 otherwise.
    virtual int         fillMesh(int nu, int nv, UT_Vector4 *pos) const=0;

    // Given a CV index figure out the min/max indicies of the knots between
    // which the curve needs to be re-evaluated if the CV changes. If not
    // given a valid CV index, the method returns -1. Otherwise it returns 0.
    virtual int         domainRangeOfCV(int i, int j, int &minuk,int &maxuk,
                                        int &minvk,int &maxvk) const=0;

    // Given a CV index figure out the min/max breakpoints which are
    // affected if the CV changes.  If not given a valid CV index, the
    // method returns -1.  Otherwise it returns 0.  Also returns -1 if
    // no breakpoints are affected.
    // NOTE: use % breakCount since maxbkp may be >= breakCount
    virtual int         breakpointRangeOfCV(int i, int j, int &minbkpu,
                                            int &maxbkpu, int &minbkpv,
                                            int &maxbkpv) const = 0;

    // Reparameterize the surface by changing its basis. This type of 
    // reparameterization is generally NOT shape preserving:
    virtual void        reparameterizeU(GB_ParmType ptype) = 0;
    virtual void        reparameterizeV(GB_ParmType ptype) = 0;

    // Reverse rows (V) or columns (U). Reversing in either direction will
    // flip the normal.
    virtual void        reverseU(void);
    virtual void        reverseV(void);

    // Remap the basis and possibly the profiles too. The origin and length
    // apply to the whole length of the basis, not just to the valid interval.
    void                mapUBasis(float orig, float len);
    void                mapVBasis(float orig, float len);

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

    // Compute the texture coordinates either uniformly of chord length. If
    // the offset if negative, the methods find it and create the attribute
    // if necessary. If ptattrib is 1 we deal with points, else with vertices.
    // Return the texture offset or -1 if problems.
    int                 uniformTexture (int txtoff = -1, int ptattrib = 1);
    int                 grevilleTexture(int txtoff = -1, int ptattrib = 1);
    int                 chordLenTexture(int txtoff = -1, int ptattrib = 1);

    // Recompute the image of Greville point[r,c] on the surface.  The
    // second function updates all the Grevilles in case you have made
    // massive CV updates. Both functions return -1 if unsuccessful.
    int                 setGreville(unsigned int r, unsigned int c); 
    int                 setGrevilles(void); 

    // Refine for all spans with specified number of divisions per span.
    virtual void        spanRefineU(GEO_AttributeHandleList &hl, int ndivs=1);
    virtual void        spanRefineU(int numdivs=1);
    virtual void        spanRefineUWAttrib(const GB_FloatOffsets &offsets,
                                           int numdivs = 1);
    virtual void        spanRefineV(GEO_AttributeHandleList &hl, int ndivs=1);
    virtual void        spanRefineV(int numdivs=1);
    virtual void        spanRefineVWAttrib(const GB_FloatOffsets &offsets,
                                           int numdivs = 1);

    // At startup (or after a refinement) compute the UV anc CV images of 
    // each Greville point. resize is expensive: try to avoid it if possible.
    // The function returns -1 if unsuccessful.
    int                 buildGreville (unsigned r, unsigned c);
    int                 buildGrevilles(int resize = 1);

    // Delete all the Grevilles and indicate that the Greville matrix need 
    // not be updated anymore:
    void                clearGrevilles(void) { grevMatx.resize(0,0); }

    // Fast greville retriever: does _not_ check for boundary overflow!
    const GEO_Greville& getGreville(unsigned int r, unsigned int c) const
                        {
                            return grevMatx(r,c); 
                        }

    // Find out whether the Grevillle info is being computed or not. 
    // (Sometimes we don't need it).
    unsigned            hasGreville(void) const { return grevMatx.usedRows()>0;}

    // Compute the _approximate_ first order derivative at 
    // greville[uIdx,vIdx]. None of these methods checks the boundary 
    // conditions on the two indices, so be careful. They return -1 in
    // case of failure, and 0 otherwise.
    int         duApprox(int uIdx, int vIdx, UT_Vector3 &du,
                         int normalize=1, float precision=0.008F) const;
    int         dvApprox(int uIdx, int vIdx, UT_Vector3 &du,
                         int normalize=1, float precision=0.008F) const;

    // Set the coordinates of cv[r,c] and call recordChanges() to notify those
    // interested. The method returns 0 if OK and -1 if the indices are wrong.
    int                 setCV(unsigned r, unsigned c, const UT_Vector4 &v);

    // Take the weights into consideration or don't. If you do, the surface
    // becomes a rational, and possibly different algorithms apply. If 'onOff'
    // is true, this function first checks if any two weights are different
    // before setting the rational flag to TRUE; if they are all the same,
    // the surface is set to non-rational (=> faster evaluation). weights()
    // calls normalizeWeights() to bring the weights to standard form, and
    // invokes recordChanges() if necessary. Weights that are <= 0 are bumped
    // up to FLT_EPSILON.
    void                weights(unsigned short onOff);

    // Set the weight of cv[r,c] to w. If the indices are out of bounds, it
    // returns -1; otherwise it returns 0. Weights that are <= 0 are bumped
    // up to FLT_EPSILON. This method calls recordChange() if appropriate.
    int                 setWeight(unsigned int r, unsigned int c, float w);

    // Get the weight of cv[r,c]. Return -1 if indices are wrong.
    float               getWeight(unsigned int r, unsigned int c) const;

    // Find out whether the surface is currently computed as a rational:
    int                 isRational(void) const { return (int) theRational; }

    // Go from a normalized domain ([0,1]) to the real domain or vice versa.
    // We look only at the valid interval.
    virtual void        unitToRealDomain(float  u_unit, float  v_unit,
                                         float &u_real, float &v_real) const;
    virtual void        realToUnitDomain(float  u_real, float  v_real,
                                         float &u_unit, float &v_unit) const;

    // Calculate the real domains for n consecutive operations on the domain
    // given n normalized domains and the operation
    virtual void        unitToRealSequenceU(float *uunit, float *ureal, 
                                int ulen) const;

    virtual void        unitToRealSequenceV(float *vunit, float *vreal, 
                                int vlen) const;


    // Homogenize the surface and disable the "rational" flag. Use the method
    // cvRangeOfDomain() to figure out the cv range given a domain range.
    void                makeHomogeneous(int startrow = 0, int endrow = -1,
                                        int startcol = 0, int endcol = -1)
                        {
                            homogenize(startrow, endrow, startcol, endcol);
                            theRational = 0;
                        }
    void                makeHomogeneous(GEO_AttributeHandleList &hlist,
                                        int startrow = 0, int endrow = -1,
                                        int startcol = 0, int endcol = -1)
                        {
                            homogenize(hlist, startrow, endrow,
                                                startcol, endcol);
                            theRational = 0;
                        }
    void                makeHomogeneousWAttrib(const GB_FloatOffsets &foffsets,
                                        int startrow = 0, int endrow = -1,
                                        int startcol = 0, int endcol = -1)
                        {
                            homogenizeWAttrib(foffsets, startrow, endrow,
                                                        startcol, endcol);
                            theRational = 0;
                        }
    void                makeNonHomogeneous(int startrow = 0, int endrow = -1,
                                           int startcol = 0, int endcol = -1)
                        {
                            dehomogenize(startrow, endrow, startcol, endcol);
                            theRational = 1;
                        }
    void                makeNonHomogeneous(GEO_AttributeHandleList &hlist,
                                        int startrow = 0, int endrow = -1,
                                        int startcol = 0, int endcol = -1)
                        {
                            dehomogenize(hlist, startrow, endrow,
                                                  startcol, endcol);
                            theRational = 1;
                        }
    void                makeNonHomogeneousWAttrib(
                                        const GB_FloatOffsets &foffsets,
                                        int startrow = 0, int endrow = -1,
                                        int startcol = 0, int endcol = -1)
                        {
                            dehomogenizeWAttrib(foffsets, startrow, endrow,
                                                          startcol, endcol);
                            theRational = 1;
                        }

    // Normalize the weights of the control mesh so that edge weights are 1,
    // and all weights are >= 0 (those that are <= 0 are bumped up to 
    // FLT_EPSILON).
    void                normalizeWeights();

    // Normalize the domain and optionally shift it to a new origin. Use the 
    // given length if greater than 0.
    void                normalizeDomain(float len = 0.F,float *newuorigin = 0,
                                                        float *newvorigin = 0);

    // Notify those interested of a change in cv[r,c]'s weight or coordinates
    // (in recordChange()), or a change of more CV's and possibly bases (in
    // recordChanges()). If 'basisChange' is true, the basis composition must
    // have been affected. If 'sizeChange' is true, the basis and mesh 
    // dimension have been altered. If they are both zero, it must have been a
    // simple CV displacement or weight adjustment.
    // Currently, recordChanges() only updates the Greville matrix if present.
    virtual int         recordChange(unsigned r, unsigned c);
    virtual int         recordChanges(unsigned short basisChange = 0,
                                      unsigned short sizeChange = 0);

    // This function will refine the area bounded by "rect" to have divisions
    // at least the size of "tol". "rect" passes in the boundary of the 
    // surface that contains the curve to be deformed, and it passes out the 
    // boundary that was actually defined (the latter is slightly bigger).
    // It returns (via reference parameters uunits, vunits, udivs, vdivs) the
    // float arrays and the size of the float array.  Please delete the
    // array pointed to by uunits and vunits after use.  It also returns an
    // array of original breakpoints (via uunrefineranges and vunrefineranges)
    // where all the original breakpoints with some newly inserted nodes between
    // them are returned.
    void                refineRange(const UT_BoundingRect &rect, float tol, 
                                    float *&uunits, float *&vunits, 
                                    int &udivs, int &vdivs,
                                    UT_FloatArray &uunrefineranges,
                                    UT_FloatArray &vunrefineranges);

    // Refine an area around the boundary of the surface, called the "belt".
    void                refineBelt(float ubwidth = 0.4F, float vbwidth = 0.4F,
                                   int   ubdivs  = 2,   int   vbdivs  = 2);

    // Another notification method. This one's intended to be heard by the
    // geometry cache.
    virtual void        changedVertices(void) = 0;

    // Set or query the U and V bases respectively. The "set" functions 
    // overwrite the current basis pointer, so use with care; they return
    // -1 if the bases are invalid.
    int                 setUBasis(GB_Basis *ub)
                        {
                            if (ub && ub->validate((int)getNumCols(), (int)isWrappedU()))
                            {
                                delete uBasis; uBasis = ub;
                                return 0;
                            }
                            else return -1;
                        }
    int                 setVBasis(GB_Basis *vb)
                        {
                            if (vb && vb->validate((int)getNumRows(), (int)isWrappedV()))
                            {
                                delete vBasis; vBasis = vb;
                                return 0;
                            }
                            else return -1;
                        }
    GB_Basis*           getUBasis(void) const   { return uBasis; }
    GB_Basis*           getVBasis(void) const   { return vBasis; }

    // Query the order of the u and respectively v bases.
    unsigned            getUOrder(void) const   { return (unsigned)uBasis->getOrder(); }
    unsigned            getVOrder(void) const   { return (unsigned)vBasis->getOrder(); }

    // Query the dimension of the u and respectively v bases.
    unsigned            getUDim(void) const { return (unsigned)uBasis->getDimension(); }
    unsigned            getVDim(void) const { return (unsigned)vBasis->getDimension(); }

    // Gets the current U and V grevilles of the surface
    // User Beware: If the surface is subsequently changed, i.e. if the basis
    //              changed, refined, etc., the results from this method
    //              will be useless.
    void                getUGrevilles(UT_FloatArray &ugrevilles);
    void                getVGrevilles(UT_FloatArray &vgrevilles);

    // Inherited from the base class: just checks the validity of the bases.
    virtual int         isDegenerate(void) const;

    // Get the bounding box for a specific range of u and v
    virtual void        getRangeBBox(const UT_Interval &u, 
                                        const UT_Interval &v, 
                                        UT_BoundingBox &bbox) const = 0;

    // Dehomogenize data (with attributes):
    static void         dehomogenizeData(GEO_Vertex **vertices,
                                    GEO_AttributeHandleList &hlist,
                                    int count);
    static void         dehomogenizeData(UT_Vector4 *pos, int count);
    static void         dehomogenizeDataWAttrib(UT_Vector4 *pos,
                                         GB_AttributeData *adata,
                                         const GB_FloatOffsets &foffsets,
                                         int count);

    // Increase the order. Return 0 if successful, -1 otherwise (eg.
    // order cannot be increased because it's >= MAXORDER).
    virtual int         raiseOrderU       (int neworder) = 0;
    virtual int         raiseOrderU(int neworder,
                                GEO_AttributeHandleList &hlist) = 0;
    virtual int         raiseOrderUWAttrib(int neworder,
                                const GB_FloatOffsets &foffsets) = 0;
    virtual int         raiseOrderV       (int neworder) = 0;
    virtual int         raiseOrderV(int neworder,
                                GEO_AttributeHandleList &hlist) = 0;
    virtual int         raiseOrderVWAttrib(int neworder,
                                const GB_FloatOffsets &foffsets) = 0;

    // Translate the CVs such that the given breakpoint change positions by
    // the given delta.  Return -1 if something goes wrong, 0 if translation
    // was successful.
    // NOTE: Cannot contain any duplicates.  If the surface is wrapped,
    //       the first and last breakpoint are considered the same.
    virtual int         translateBreakpoints(const UT_IntArray &uindices,
                                             const UT_IntArray &vindices,
                                             const UT_Vector3 &delta,
                                             int fixbkpts = 1,
                                             GB_PointGroup *ptgroup=NULL,
                                             GEO_Delta *geodelta = 0) = 0;

    virtual int         transformBreakpoints(const UT_IntArray &uindices,
                                             const UT_IntArray &vindices,
                                             const UT_Matrix4 &matx,
                                             int fixbkpts = 1,
                                             GB_PointGroup *ptgroup=NULL,
                                             GEO_Delta *geodelta = 0) = 0;

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

    // If [ustart,ustop] and [vstart,vstop] are in the valid interval, return
    // the part of the surface delimited by those values in a new primitive.
    // Return 0 if a problem is encountered.
    virtual GEO_TPSurf          *extract(float ustart, float ustop,
                                         float vstart, float vstop) const = 0;

    // Derived from the base class. Here we just want to preserve our basis.
    virtual void        subdivide(int numdivs, GB_PointGroup *ptgroup=0);

    // Return the surrounding values of the real-space u,v parameters.
    // Returns 1 if succesful, 0 if out-of-range.
    virtual int         parametricBBox(float u, float v,
                                       float *u0, float *u1,
                                       float *v0, float *v1);
    
    // Find out if the surface has any profiles in its domain:
    int                 hasProfiles(void) const;

    // Get the profiles detail. Create the detail if not there if the create
    // option is true.
    GEO_Profiles        *profiles(int create = 1); 
    GEO_Profiles        *profiles(void) const   { return theProfiles; } 

    // find out if the surface is pasted:
    int                 isPasted(void) const    { return thePasteSurf != 0; }

    // Get or set the pasted image of this surface:
    GEO_PasteSurf       *pastedSurface(void) const { return thePasteSurf; }
    void                 pastedSurface(GEO_PasteSurf *p) { thePasteSurf = p; }

    // Update the displacement of the CV(s) whose point is ppt if the
    // surface is pasted. This method wil not update the pasted dependents
    // unless you want it to. Return 1 of found and 0 otherwise.
    int                  updateDisplacement(const GEO_Point &ppt,
                                            int updatekids = 1);

    virtual void         isolate(void);

    // Constraint based manipulation.
    // If the parameterization and derivative constraints do not change and
    // the curve's basis and order don't change, then the system only needs to
    // be solved once.  The solution can then be applied multiple times,
    // with different changes at the given parameters.

    // Return 0 if the resulting system is overdetermined (or otherwise
    //          unsolvable).
    //        1 if ok.
    int                  solveConstraints(const UT_Vector &uparam,
                                          const UT_Vector &vparam,
                                          const UT_IntArray &udervs,
                                          const UT_IntArray &vdervs,
                                          UT_Matrix &soln,
                                          UT_IntArray &cv_idx);

    // Return 0 if the given data is invalid (incorrect dimensions or indices).
    //        1 if ok.
    // The changes matrix is an n x 3 matrix, with each of the columns
    // corresponding to the x, y, and z coordinates.
    // If the surface is rational, the changes matrix will be modified.
    int                  applyConstraints(UT_Matrix &changes,
                                          const UT_Vector &uparam,
                                          const UT_Vector &vparam,
                                          const UT_IntArray &udervs,
                                          const UT_IntArray &vdervs,
                                          const UT_IntArray &cv_index,
                                          const UT_Matrix &soln);

    // Return 0 if the resulting system is overdetermined.
    //        1 if ok.
    // Only call this method when the solution cannot be reused.
    // If the surface is rational, the changes matrix will be modified.
    int                  solveAndApplyConstraints(const UT_Vector &uparam,
                                                  const UT_Vector &vparam,
                                                  const UT_IntArray &udervs,
                                                  const UT_IntArray &vdervs,
                                                  UT_Matrix &changes);

protected:
    // The bases in each parametric direction. Not const because we want
    // to be able to (re)set them at initialization time or elsewhere.
    // They must be set with objects allocated from the heap so that we can
    // delete them when calling this class's destructor.
    GB_Basis           *uBasis;
    GB_Basis           *vBasis;
      
    // PROTECTED METHODS:
    virtual void                 copyOffsetPrimitive(const GEO_Primitive *src,
                                                int basept);

    // Load and save functions redefined from the parent class.
    virtual int         savePrivate(ostream &os, int binary) const;
    virtual int         saveExtra  (ostream &, int binary) const;
    virtual bool        loadPrivate(UT_IStream &is);
    virtual bool        loadExtra  (UT_IStream &);

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

    // Used by the derived classes in their attach() methods.
    void                mergeAttachProfilesU(const GEO_TPSurf &tpsurf);
    void                mergeAttachProfilesV(const GEO_TPSurf &tpsurf);

    // Compute an evalution stepsize that is surely valid.
    float               stepSize(float start, float stop, int count) const
                        {
                            return (count > 0) ? ((stop - start)/(float)count)
                                               : 0.0F;
                        }

    // Turn the rational flag on or off. Use with discretion.
    void                rational(int yesno)     { theRational = (unsigned short)yesno; }

    // Get a new basis of a type that matches our type:
    virtual GB_Basis    *newBasis(void) const = 0;


private:
    // Method to copy the basis of the source to me
    void                         copyBasisAndProfiles(const GEO_TPSurf *src);

    // The matrix of Greville abscissae. Its number of rows and cols
    // must match that of the control vertex matrix (defined in the base
    // class).  We will want to define a flag to tell us whether
    // we should be interested in building and updating the Greville 
    // matrix or not.
    UT_RefMatrix<GEO_Greville>   grevMatx;

    // Flag that indicates whether the CV weights should be taken into 
    // account when evaluating the surface or otherwise affecting its
    // geometry.
    unsigned short               theRational;

    // Detail of (trimming) profiles:
    GEO_Profiles                *theProfiles;

    // The pasted image:
    GEO_PasteSurf               *thePasteSurf;



    // PRIVATE METHODS:

    // Evaluate one point (when du=dv=0), or the du-th dv-th derivative of
    // a RATIONAL surface. Return 0 if successful, and -1 otherwise.
    bool                evaluateRational(fpreal u, fpreal v, GEO_Vertex &result,
                                GEO_AttributeHandleList &hlist,
                                unsigned du=0, unsigned dv=0,
                                int uoffset=-1, int voffset=-1) const;
    int                 evaluateRational(float u, float v, UT_Vector4 &pos, 
                                 unsigned du=0, unsigned dv=0,
                                 int uoffset=-1, int voffset=-1) const;
    int                 evaluateRationalWAttrib(float u, float v,
                                 UT_Vector4 &pos, GB_AttributeData &adata,
                                 const GB_FloatOffsets &foffsets,
                                 unsigned du=0, unsigned dv=0,
                                 int uoffset=-1, int voffset=-1) const;

    // These methods are meant to be used with fillU/VCurves. For the "U"
    // mehtods: given a const knot index in v and two bounds in u, fill
    // a complete (or just a portion of) the isocurve through v. Return
    // the number of u spans encountered or -1. The methods aren't VIRTUAL.
    int                 fillUCurve(float v,int vidx, int ustartidx,int ustopidx,
                                   int density, UT_Vector4 *pos, int puoffset,
                                   int rbound, unsigned du, unsigned dv) const;
    int                 fillVCurve(float u,int uidx, int vstartidx,int vstopidx,
                                   int density, UT_Vector4 *pos, int pvoffset,
                                   int rbound, unsigned du, unsigned dv) const;
    int                 fillUCurve(float v, int vidx, int ustartidx,
                                   int ustopidx, int density,
                                   GEO_Vertex **results,
                                   GEO_AttributeHandleList &hlist,
                                   int puoffset, int rbound,
                                   unsigned du, unsigned dv) const;
    int                 fillVCurve(float u, int uidx, int vstartidx,
                                   int vstopidx, int density,
                                   GEO_Vertex **results,
                                   GEO_AttributeHandleList &hlist,
                                   int pvoffset, int rbound,
                                   unsigned du, unsigned dv) const;
    int                 fillUCurveWAttrib(float v, int vidx, int ustartidx,
                                   int ustopidx, int density, UT_Vector4 *pos,
                                   GB_AttributeData *adata,
                                   const GB_FloatOffsets &foffsets,
                                   int puoffset, int rbound,
                                   unsigned du, unsigned dv) const;
    int                 fillVCurveWAttrib(float u, int uidx, int vstartidx,
                                   int vstopidx, int density, UT_Vector4 *pos,
                                   GB_AttributeData *adata,
                                   const GB_FloatOffsets &foffsets,
                                   int pvoffset, int rbound,
                                   unsigned du, unsigned dv) const;

    // Given a derivative count (du,dv), compute the numerator (aders) and
    // denominator (wders) of the expression that gives the curve value
    // for all derivatives from 0 to du. Return 0 if successful and -1
    // otherwise.
    int                  linearCombine(float ubmatx[][GB_MAXORDER],
                                float vbmatx[][GB_MAXORDER],
                                unsigned du, unsigned dv,
                                int rowoffset, int coloffset,
                                GEO_WorkVertexBuffer &vbuffer,
                                GEO_AttributeHandleList &hlist,
                                float wders[][GB_MAXORDER]) const;
    int                  linearCombine(float ubmatx[][GB_MAXORDER],
                                float vbmatx[][GB_MAXORDER],
                                unsigned du, unsigned dv,
                                int rowoffset, int coloffset,
                                UT_Vector4 aders[][GB_MAXORDER],
                                float      wders[][GB_MAXORDER]) const;
    int                  linearCombineWAttrib(float bmatx[][GB_MAXORDER],
                                float vbmatx[][GB_MAXORDER],
                                unsigned du, unsigned dv,
                                int rowoffset, int coloffset,
                                UT_Vector4 aders[][GB_MAXORDER],
                                float      wders[][GB_MAXORDER],
                                GB_AttributeData attr_aders[][GB_MAXORDER],
                                const GB_FloatOffsets &foffsets) const;

    friend ostream      &operator<<(ostream &os, const GEO_TPSurf &d)
                        {
                            d.save(os, 0);
                            return os;
                        }
};

#endif

---