UT/UT_FitCubic.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:
 *      Rob Bairos
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_FitCubic (C++)
 *
 * COMMENTS:    Given a group within a detail, fit curves to
 *              each polygon.
 *
 */

#ifndef __UT_FitCubic_H__
#define __UT_FitCubic_H__


#include "UT_API.h"
#include "UT_Vector2.h"
typedef UT_Vector2 cubicCurve[4];

class UT_Interrupt;

// segment, last point will always
// match beginning of next segment

class UT_API utCubicSpan {
        
public:                  

    UT_Vector2           point[3];
    int                  isLinear;
    class utCubicSpan   *next;
};

enum utFitType
{
    UT_FIT_BEZIER       = 0,
    UT_FIT_CUBIC        = 1

};

enum utCurveType
{
    UT_FIT_CURVES       = 0,
    UT_FIT_POLYS        = 1,
    UT_FIT_BOTH         = 2
};

class UT_API UT_FitCubic {

public:

     UT_FitCubic();
    ~UT_FitCubic();

    int          fitCurve(UT_Vector2 *d, int nPts, int closed, fpreal error2,
                                                        bool preserveExtrema);

    const utCubicSpan   *getFirstSpan(void) const
                         { return myHead; }

    int          numSpans(void) const
                 { return myNSpans; }

    int          containsCurve(void)
                 { return myContainsCurve; }

    void         setCurveType(utCurveType type)
                 { myCurveType = type; }

    void         setType(utFitType type)
                 { myFitType = type; }

    static UT_Vector2    calcCubic(UT_Vector2 *V, fpreal t);

private:

    int          myContainsCurve;
    fpreal       myError2;
    utCubicSpan *myHead;

    void         destroySolution(void);


    utCubicSpan *appendCurve(cubicCurve fcurve, int islinear);


    int          fitLine(UT_Vector2 *d, int first, int last, 
                         utCubicSpan **head, utCubicSpan **tail,
                         int recurse);

    int          fitCubic(UT_Vector2 *d, int f, int l,UT_Vector2 tHat1,
                          UT_Vector2 tHat2, 
                          utCubicSpan **head, utCubicSpan **tail,
                          bool preserveExtrema, UT_Interrupt *boss);

    UT_Vector2   computeCenterTangent(UT_Vector2 *d, int center);

    float       *reparameterize(UT_Vector2 *d, int first, int last, 
                                float *u, cubicCurve fcurve);

    fpreal       newtonRaphsonRootFind(cubicCurve Q, UT_Vector2 P, fpreal u);

    UT_Vector2   calcBezier2(UT_Vector2 *V, fpreal t);
    UT_Vector2   calcBezier3(UT_Vector2 *V, fpreal t);


    fpreal       computeBezierError(UT_Vector2 *d, int first, int last, 
                        cubicCurve fcurve, float *u, int *splitPoint);

    fpreal       computeCubicError(UT_Vector2 *d, int first, int last, 
                                   cubicCurve fcurve, int *splitPoint,
                                   bool preserveExtrema);

    fpreal       computeLineError(UT_Vector2 *d, int first, int last, 
                        cubicCurve fcurve, float *u, int *splitPoint);

    float       *chordLengthParameterize(UT_Vector2 *d,int f,int l);

    void         generateBezier(UT_Vector2 *d, int first, int last, 
                               float *uPrime, UT_Vector2 tHat1, 
                               UT_Vector2 tHat2, cubicCurve fcurve);

    void         simpleCurve(UT_Vector2 *d, int first, int last,
                             UT_Vector2 tHat1, UT_Vector2 tHat2,
                             cubicCurve rcurve);

    void         findCorner(UT_Vector2 *d, int first, int last, 
                            int *splitPoint); 

    int          isSeamCorner(UT_Vector2 *d, int last);


    // inline multipliers

    fpreal       BEZ_MULT_0(fpreal u)
                 {
                     fpreal tmp = 1.0F - u;
                     return (tmp * tmp * tmp);
                 }

    fpreal       BEZ_MULT_1(fpreal u)
                 {
                     fpreal tmp = 1.0F - u;
                     return (3.0F * u * (tmp * tmp));
                 }

    fpreal       BEZ_MULT_2(fpreal u)
                 {
                     fpreal tmp = 1.0F - u;
                     return (3.0F * u * u * tmp);
                 }

    fpreal       BEZ_MULT_3(fpreal u)
                 {
                     return (u * u * u);

                 }

    int          myNumPoints;
    int          myClosed;
    int          myNSpans;

    utFitType    myFitType;
    utCurveType  myCurveType;


};

#endif

---