GB/GB_BezBasis.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 implements a piecewise Bezier spline basis.
 *
 * 
 */

#ifndef __GB_BezBasis_h__
#define __GB_BezBasis_h__

#include "GB_API.h"
#include <math.h>
#include "GB_Basis.h"

class UT_Vector4Array;

class GB_API GB_BezBasis : public GB_Basis {
public:
    // Class constructors. The basis is cubic by default and always valid in
    // terms of its order (therefore len >= 2).
    GB_BezBasis(unsigned len = 2, unsigned ord = 4) 
    : GB_Basis((len>1)?len:2,(ord>1)?ord:2)                     {}
    GB_BezBasis(float *bVec, unsigned len, unsigned ord = 4)
    : GB_Basis(bVec, (len>1)?len:2, (ord>1)?ord:2)              {}
    GB_BezBasis(fpreal bFirst, fpreal step, unsigned len, unsigned ord = 4)
    : GB_Basis(bFirst, step, (len>1)?len:2, (ord>1)?ord:2)      {}

    // Class destructor. Virtual by inheritance.
    virtual ~GB_BezBasis();

    // Evaluate on a specific domain interval, on which at least one
    // basis function is non-zero given domain point u.
    virtual void         evalInterval(fpreal u, int offset, int derv, 
                                      float *vals) const;

    // Evaluate the all the derivs of the basis from 0 to derv (inclusive).
    void                 evaluateDerivMatrix(fpreal u, int offset, int derv,
                                             float bmatx[][GB_MAXORDER])const;

    // Compute one basis function (ie. the one with the given index) 
    // value at u.
    virtual fpreal       computeBValue(int index, fpreal u) const;

    // Find out if two knot sequences are similar (ie if the knot spacings
    // are the same all over) and their knot count is the same. We assume
    // "b" is a BezBasis! For a Bezier basis, the similarity condition 
    // reduces to a simple knot count test.
    virtual int          isSimilar(const GB_Basis &b) const;

    // Find the breakpoint at index i, or the index of the breakpoint of
    // domain value 'param'. The second  function returns -1 if the paramenter
    // is less than the 0th breakpoint; if the parameter if greater than the 
    // last breakpoint, it returns the index of last bkp + 1.
    fpreal               breakpnt(int i) const  { return getVector()((unsigned)i); }
    int                  breakpnt(fpreal param) const;

    // Like breakpnt(param) except it is virtual.
    virtual int          findOffset(fpreal k, int startIdx=0) const;

    // Compute an array of breakpoints (i.e. unique knots) in the valid 
    // interval and return their number:
    virtual int          breakpoints(UT_FloatArray &arr) const;
    virtual int          breakpoints(UT_FloatArray &arr, fpreal tol) const;

    // Return the multiplicity of a domain point or -1 if outside the domain.
    // "uidx" is the index of the largest breakpoint <= u.
    virtual int          multiplicity(fpreal u, int &uidx) const;

    // Given a domain range in the valid interval, compute the range of CVs
    // that will be involved in the evaluation of the curve in that range.
    // Since the basis doesn't know about wrapping, the endcv index might
    // be higher than the spline's number of CVs.
    virtual void        cvRangeOfDomain(int  ustartidx, int  ustopidx,
                                        int &startcv,   int &endcv) const;
    virtual void        cvRangeOfDomain(fpreal ustart, fpreal ustop,
                                        int &startcv,   int &endcv) const;

    // Given valid breakpoint index, compute the range of CVs that have a 
    // non-zero influence at the knot of the breakpoint.  Since the basis
    // doesn't know about wrapping, the endcv index might be higher than the
    // spline's number of CVs.
    virtual void        cvRangeOfBreakpoint(int bkp, int &startcv,
                                            int &endcv) const;

    // Compute the idx'th greville abscissa of the breakpoint vector. The
    // function does not do boundary checking.
    virtual fpreal       greville(unsigned idx, int=1, int wrapped = 0) const;

    // Grow the length of the basis by one, and set the value of the new
    // breakpoint to something valid. A basis with length 0 gets a size of 2.
    // This method returns the index of the last element.
    virtual int          grow(int=0);

    // Shrink the basis by one unless the length of the basis is <= 2. 
    // Return the new length.
    virtual int          shrink(int=0);

    // Attach another basis to us and grow our basis as a result. The bases
    // must have the same type and order. Return 0 if successful and -1 
    // otherwise. If "overlap" is true, we overlap the beginning of b with 
    // our end. Spreading makes sense when you can have multiple knots in the
    // basis, and causes identical knots to be spread within range of the
    // neighbouring knots.
    virtual int          attach(const GB_Basis &b, int overlap = 1,
                                int spread = 0);

    // Change the size of the basis (and maybe some of its values too) to 
    // make it a valid basis for wrapped splines. The second method applies
    // the reversed processs:
    virtual void         wrap(void);
    virtual void         unwrap(void);

    // Reverse the breakpoints in the basis.
    virtual void         reverse(int);

    // Reparameterize the basis using the chord-length method, and clamp it
    // to the valid interval. The origin and length of the valid domain remains
    // unchanged.
    virtual void         chord(UT_Vector4Array &cvs);

    // Slide the knots found in the given range left or right by an amount at
    // most as large as the distance to the nearest knot outside the range.
    // The bias is a percentage value of the left-right distance, its default
    // value is 0.5 (i.e. don't change anything), and is clamped to [0,1].
    // The method returns 0 if OK and -1 if out of range.
    virtual int          slideRange(fpreal umin, fpreal umax, 
                                    fpreal ubias=0.5F);

    // Query functions redefined from the base class.
    virtual const char  *getName(void) const;
    virtual unsigned     getType(void) const;
    virtual int          getDimension(void) const;

    // Given the index of a knot (kidx) and two bounds in the knot sequence
    // (a and b) find out the index of the breakpoint that the knot represents
    // (relative to a), and possibly adjust kidx so that 
    // knot[kidx+1] > knot[kidx]. Return -1 if not found.
    virtual int          knotToBreakpoint(int &kidx,int a=0,int b=0) const;

    // Return the boundaries of the valid evaluation interval:
    virtual void         validInterval(int   &a,  int &b) const;

    // Return the number of breakpoints (ie. unique knots) in the knot
    // vector, in the valid interval.
    virtual int          breakCount(void) const;

    // Validate the basis given CV information: return 1 if OK, 0 if NOK.
    virtual bool         validate(int = 0);
    virtual bool         validate(int cvLen, int doesWrap) const;
    virtual bool         validate(int cvLen, int basisLen, int doesWrap) const;

    // Return the discontinuity information for the basis at the given
    // parameter value u.  If discont_derv is returned as -1, the curve
    // is infinitely differentiable here (of course, derivatives >= order
    // will be zero).  Otherwise, discont_derv contains the lowest derivative
    // number that is discontinuous at this point.  It also returns the u
    // value at the other side of the discontinuity, if such a discontinuity
    // exists.
    virtual void        getDiscontinuityInfo(fpreal u, int &discont_derv,
                                             float &prev_span_u,
                                             int wrapped=0) const;

    // Load the basis and build it to match the given parameters.
    virtual int          save(ostream &os, int wrapped = 0,
                                           int binary  = 0) const;
    virtual bool         load(UT_IStream &is, int cvs, int wrapped = 0);
protected:
    // Compute the values or the derivatives at a domain point in the 
    // correct interval. The calling functions must ensure the biCoeff
    // matrix is large enough!
    void        computeBezValues(fpreal u, int degree, float* vals) const;
    void        computeBezDerivs(fpreal u,int degree,int derv,float* vals) const;

private:
    // Nothing.
    
};

#endif

---