GD/GD_Curve.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:
 *      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 curves of arbitrary degree.
 *      The Face class maintains the control vertices for the curve.
 *
 */

#ifndef __GD_Curve_h__
#define __GD_Curve_h__

#include "GD_API.h"
#include <GB/GB_Basis.h>
#include "GD_Face.h"
#include "GD_PrimType.h"

class UT_Vector3;
class UT_Vector2;

class GD_API GD_Curve : public GD_Face
{
public:
    // Constructor that attaches this curve to detail "d". 
    GD_Curve(GD_Detail *d);

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

    // Overwrite this curve with the data from src. Virtual by inheritance.
    virtual GD_Primitive *copy(int preserve_shared_pts = 0) const;
    virtual int           copy(const GD_Primitive &src, int ptoffset);


    // Return the bounds of the valid evaluation interval in domain space:
    virtual void        validInterval(int   &a,  int   &b ) const;
    virtual void        validRange   (float &ua, float &ub) const;

    // Evaluate one point (when du=0), or the du-th derivative.
    // Return 0 if successful, and -1 otherwise.
    virtual int         evaluate(float u, UT_Vector3 &pos,
                                 unsigned du=0, int uOffset=-1) const;

    // Given a domain value (u), store all the basis derivatives (from 0 to du
    // inclusive) into bmatx. Return the min and max index of the CVs needed
    // for the linear combination. The indices may exceed the number of
    // vertices if the curve is wrapped, so remember to use % getVertexCount().
    virtual int         evaluateBasisDerivs(float u,float bmatx[][GB_MAXORDER],
                                            int &cvoffset, unsigned du = 0,
                                            int uoffset = -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
    // index may exceed the number of vertices if the curve is wrapped,
    // so remember to use modulus (%). This method handles both rational and
    // non-rational curves.
    virtual int         evaluateBasis(float u,float *ubvals, int &cvoffset,
                                      unsigned du=0, int uoffset=-1) const = 0;

    // Return the value of the i'th basis at parameter u. This method handles
    // both rational an non-rational curves.
    float               computeBValue(float u, int i) const;

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

    // Evaluate the curve betw. breakpoints by taking a start and a stop index
    // in the valid knot domain and an lod representing number of points to
    // be interpolated between every two breakpoints. The methods ALWAYS
    // interpolate the encountered breakpoints (aka "edit points").They return
    // the number of points in the list or -1 if unsuccessful. Please save
    // yourself headaches and pass VALID start and end indices (see the
    // method validInterval() in GB_Basis).
    virtual int         evaluateBreakSegm(int uStartIdx, int uStopIdx,
                            int lod, UT_Vector3 *pos, unsigned du=0) const;

    // 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 cvidx, int &mink,
                                        int &maxk) const = 0;

    // Take the weights into consideration or don't. If you do, the curve
    // 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 curve 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.
    virtual void        weights(unsigned short onOff);

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

    // Homogenize the curve and disable the "rational" flag. Use the method
    // cvRangeOfDomain() to figure out the cv range given a domain range.
    void                makeHomogeneous(int startcv = 0, int endcv = -1)
                        {
                            homogenize(startcv, endcv);
                            theRational = 0;
                        }
    void                makeNonHomogeneous(int startcv = 0, int endcv = -1)
                        {
                            dehomogenize(startcv, endcv);
                            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.0F, float *neworigin = 0)
                        {
                            uBasis->normalize(len, neworigin);
                        }

    // Set or query the basis. The "set" function  overwrites the current
    // basis pointer, so use with care; it returns -1 if the basis is invalid.
    int                 setBasis(GB_Basis *ub)
                        {
                            if (ub && ub->validate((int)getVertexCount(),(int)isClosed()))
                            {
                                delete uBasis; uBasis = ub;
                                return 0;
                            }
                            else return -1;
                        }
    GB_Basis*           getBasis(void) const    { return uBasis; }
    void                setAnyBasis(GB_Basis *ub) // Use with care!
                        {
                            delete uBasis; uBasis = ub;
                        }

    // Query the order and the dimension of the basis.
    virtual unsigned    getOrder(void) const;
    unsigned            getDim(void) const  { return (unsigned)uBasis->getDimension(); }

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

    // Reverses the vertices of a given face. It's virtual because some faces,
    // such as rational splines, need to be aware of it.
    virtual void        reverse();

    // Dehomogenize data:
    static void         dehomogenizeData(UT_Vector3 *pos, int count);

protected:
    // The basis. Not const because we want to be able to (re)set it at
    // initialization time or elsewhere. It must be assigned an object
    // allocated from the heap so that we can delete it when calling this
    // class's destructor.
    GB_Basis            *uBasis;
      
    // Load and save functions redefined from the parent class.
    virtual int          savePrivate(ostream &os, int binary) const;
    virtual bool         loadPrivate(UT_IStream &is);

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

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

    // Set the order of the basis:
    void                 setOrder(unsigned ord) { uBasis->setOrder(ord); }

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

    // Build the vextex list, and optionally append points to the detail.
    // Return 0 if OK, and -1 if error.
    int                 create(GD_Curve *crv, int nelems, int closed,
                                              int appendPoints = 1);
    virtual int         breakCount() const;


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

    // Evaluate one point of a RATIONAL curve (when du=0), or the du-th
    // derivative. Return 0 if successful, and -1 otherwise.
    int                 evaluateRational(float u, UT_Vector3 &pos,
                                 unsigned du=0, int uOffset=-1) const;

    // Given a derivative count (du), 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 OK and -1  otherwise.
    int                  linearCombine(float bmatx[][GB_MAXORDER],
                                unsigned du, int cvoffset, UT_Vector3 *aders,
                                float *wders) const;

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

#endif

---