CurveFitObject Class Reference

Fits bezier curves to a serious of coordinates. Call the constructor, Initialise and finally FitCurve to fit a bezier curve to the coords. More...

#include <fitcurve.h>

List of all members.

Public Member Functions
	CurveFitObject (Path *LongPath, double Error)
	Constructs a Curve Fitting Object and gives it some data that it will need during the fit.
	~CurveFitObject ()
	Destroys the curve fitter when it is done, freeing any memory that was allocated in the Initialise() function.
BOOL	Initialise (Path *CopyPath, INT32 NumPoints)
	Gets memory to store all the coords in and starts going through the path extracting the relavent points. It also calculates the distance along the path of each of the points it stores, which are needed extensivly when checking the accuracy of the fit. This function also empties the path object ready for the fitted version to be added.
void	FitCurve ()
	Actually fits the curve and places the results back in the path object declared in the constructor. This function walks through all the data points trying to find cusps in the path and fits curves between them by calling the FitCubic member of the CurveFitObject.
Private Member Functions
	CC_DECLARE_MEMDUMP (CurveFitObject)
void	FitCubic (INT32 FirstPoint, INT32 LastPoint, FitPoint Tangent1, FitPoint Tangent2, BOOL IsStartCusp=TRUE, BOOL IsEndCusp=TRUE)
	This function is recursive. It tries to fit a cubic function to the coordinates in the path between FirstPoint and LastPoint. It then compares this function with the actual coordinates to determine how good a fit it has found. If the fit is good it is added to the path object. If the fit is bad then it is split at the point where the fit is at its worst and FitCubic is called again for the left and right halves. Scope: private.
void	GenerateBezier (INT32 FirstPoint, INT32 LastPoint, FitPoint Tangent1, FitPoint Tangent2, FitPoint *Bezier)
	This function supplies the maths to try and fit a cubic function to a set of points. It spends its time trying to come up with good lengths for the two tangents passed in to maximise the closeness of the fit. If it fails to come up with realistic results it simply sets the tangent lengths to be 1/3 of the distance between the start point and the end point. Scope: private.
FitPoint	BezierPoint (FitPoint *Bez, double u)
	This function simply evaluates the bezier function for a given position and is used to help when determining how good a fit we have obtained Scope: private.
double	CalcMaxError (INT32 FirstPoint, INT32 LastPoint, FitPoint *Bezier, INT32 *SplitPoint)
	Finds out how good a fit the bezier curve we have created is when compared with the data points Scope: private.
FitPoint	LeftTangent (INT32 Start)
	Finds the Left tangent at the given point in the path Scope: private.
FitPoint	RightTangent (INT32 End)
	Finds the Right tangent at the given point in the path Scope: private.
FitPoint	CentreTangent (INT32 Centre)
	Finds the tangent at the centre of the path Scope: private.
double	Bezier0 (double u)
double	Bezier1 (double u)
double	Bezier2 (double u)
double	Bezier3 (double u)
void	InsertBezier (FitPoint *Bezier, BOOL, BOOL)
	Adds the bezier curve to the path. If it is that last curve in the fitting (ie Depth is 0) then the rotate flag will not be set Scope: private.
void	InsertLine (const DocCoord &Start, const DocCoord &End, FitPoint Tangent1, FitPoint Tangent2, BOOL, BOOL)
	Inserts a straight curve into the path. It keeps it as a curve so that the path will continue to look smooth after it is edited. If this is the last Path element in the fit, (ie Depth is zero) then the rotate flag will not be set. Scope: private.
void	InsertStraightLine (const DocCoord &End)
	Inserts a straight Line into the path. This is used in cases where the Line segment must be kept as a straight line (ie by using Straight Line Mode of the FreeHand tool) Scope: private.
Private Attributes
Path *	LongPath
DocCoord *	PathArray
INT32 *	LineArray
INT32 *	Distances
double	Error
INT32	TotalCoords
INT32	TotalStraightLines

---

Detailed Description

Fits bezier curves to a serious of coordinates. Call the constructor, Initialise and finally FitCurve to fit a bezier curve to the coords.

Author:

Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>

Date:

22/9/94

See also:

FitPoint

Definition at line 182 of file fitcurve.h.

---

Constructor & Destructor Documentation

CurveFitObject::CurveFitObject (  Path *  ThePath, double  MaxError )

Constructs a Curve Fitting Object and gives it some data that it will need during the fit. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/94 Parameters: ThePath  - A Pointer to a path object that we are to simplify [INPUTS] MaxError - The Square of the distance that we are prepared to let the fitted path stray from the original data See also: CurveFitObject::Initialise Definition at line 305 of file fitcurve.cpp. { // Make a note of info we have got LongPath = ThePath; Error = MaxError; // And set defaults to the rest Distances = NULL; PathArray = NULL; LineArray = NULL; TotalStraightLines = 0; TotalCoords = 0; }

CurveFitObject::~CurveFitObject (   )

Destroys the curve fitter when it is done, freeing any memory that was allocated in the Initialise() function. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/94 See also: CurveFitObject::Initialise Definition at line 333 of file fitcurve.cpp. { if (Distances!=NULL) delete Distances; if (PathArray!=NULL) delete PathArray; if (LineArray!=NULL) delete LineArray; }

---

Member Function Documentation

double CurveFitObject::Bezier0 (  double  u  )  [inline, private]

Definition at line 217 of file fitcurve.h. { double t=1.0-u; return (t*t*t); }

double CurveFitObject::Bezier1 (  double  u  )  [inline, private]

Definition at line 218 of file fitcurve.h. { double t=1.0-u; return (3*u*t*t); }

double CurveFitObject::Bezier2 (  double  u  )  [inline, private]

Definition at line 219 of file fitcurve.h. { double t=1.0-u; return (3*u*u*t); }

double CurveFitObject::Bezier3 (  double  u  )  [inline, private]

Definition at line 220 of file fitcurve.h. { return (u*u*u); }

FitPoint CurveFitObject::BezierPoint (  FitPoint *  Bez, double  u )  [private]

This function simply evaluates the bezier function for a given position and is used to help when determining how good a fit we have obtained Scope: private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/94 Parameters: Bez  - The control points of a bezier curve [INPUTS] u - the normalised distance along the bezier that we are interested in Returns: The coord of the point that is a distance u into the bezier. for example, if u = 0.5 then the coord of the point half way along the bezier will be returned See also: CurveFitObject::CalcMaxError Definition at line 808 of file fitcurve.cpp. { double OneMinus = 1.0-u; double uSquared = u*u; double OneMinusSquared = OneMinus*OneMinus; FitPoint Coord; Coord = Bez[0]*(OneMinusSquared*OneMinus); Coord = Coord + Bez[1]*(3.0*u*OneMinusSquared); Coord = Coord + Bez[2]*(3.0*uSquared*OneMinus); Coord = Coord + Bez[3]*(uSquared*u); return Coord; }

double CurveFitObject::CalcMaxError (  INT32  FirstPoint, INT32  LastPoint, FitPoint *  Bezier, INT32 *  SplitPoint )  [private]

Finds out how good a fit the bezier curve we have created is when compared with the data points Scope: private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/94 Parameters: FirstPoint,LastPoint  - The index at the start and end of the curve section [INPUTS] we have just fit Bezier - the control points of the bezier we have fitted to the points SplitPoint  - the point to split the curve at if the error is too great [OUTPUTS] Returns: The maximum distance between the bezier curve and the original data points Definition at line 843 of file fitcurve.cpp. { double Distance; double MaxDist = 0.0; double RTotalLength = 1.0/(Distances[LastPoint] - Distances[FirstPoint]); FitPoint Point; // Start out by putting the split point in the middle of the curve segment INT32 NumPoints = LastPoint - FirstPoint + 1; *SplitPoint = NumPoints / 2; INT32 step = (NumPoints+ERROR_STEP) / ERROR_STEP; // Loop though the points, visiting a fixed number of them for (INT32 i=FirstPoint+1; i<LastPoint; i+=step) { // Calculate the offset at this point double Offset = Distances[i] - Distances[FirstPoint]; Offset *= RTotalLength; // Calculate where the curve actually is and find the distance from where we want it FitPoint Coord = PathArray[i]; Point = BezierPoint(Bezier, Offset); Distance = (Point - Coord).SquaredLength(); if ( Distance >= MaxDist) { MaxDist = Distance; *SplitPoint = i; } } return MaxDist; }

CurveFitObject::CC_DECLARE_MEMDUMP (  CurveFitObject   )  [private]

FitPoint CurveFitObject::CentreTangent (  INT32  Centre  )  [private]

Finds the tangent at the centre of the path Scope: private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/94 Parameters: Centre  - the index of the split point in the path [INPUTS] Returns: The tangent at the point Centre Definition at line 977 of file fitcurve.cpp. { DocCoord Left, Right; FitPoint CentreTang; // check for empty point array if (TotalCoords == 0) { CentreTang.x = 1; CentreTang.y = 0; return CentreTang; } // check for centre outside the array if ((Centre >= TotalCoords) || (Centre < 0)) Centre = TotalCoords / 2; // Find out which point to look to INT32 Forward = Centre+2; if (Forward > TotalCoords-1) Forward = TotalCoords-1; // Find out which point to look to INT32 Backward = Centre-2; if (Backward < 0) Backward = 0; // Calc right tangent Left.x = PathArray[Backward].x - PathArray[Centre].x; Left.y = PathArray[Backward].y - PathArray[Centre].y; // Calc left tangent Right.x = PathArray[Centre].x - PathArray[Forward].x; Right.y = PathArray[Centre].y - PathArray[Forward].y; // Average to get the centre tangent CentreTang.x = (Left.x + Right.x) / 2.0; CentreTang.y = (Left.y + Right.y) / 2.0; // Make sure that is not of zero length if ((CentreTang.x==0) && (CentreTang.y==0)) { TRACEALL( _T("Tangent was a zero length vector in the curve fitter (Cent)\n")); CentreTang.x = 1; } // return it return CentreTang; }

void CurveFitObject::FitCubic (  INT32  FirstPoint, INT32  LastPoint, FitPoint  Tangent1, FitPoint  Tangent2, BOOL  IsStartCusp = TRUE, BOOL  IsEndCusp = TRUE )  [private]

This function is recursive. It tries to fit a cubic function to the coordinates in the path between FirstPoint and LastPoint. It then compares this function with the actual coordinates to determine how good a fit it has found. If the fit is good it is added to the path object. If the fit is bad then it is split at the point where the fit is at its worst and FitCubic is called again for the left and right halves. Scope: private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/94 Parameters: FirstPoint  - the index of the coordinate in the path to start fitting from [INPUTS] LastPoint - the index of the coordinate in the path to stop fitting at Tangent1 - The tangent of the curve at the first point Tangent2 - the tangent of the curve at the last point IsStartCusp - TRUE if FirstPoint is next to a cusp IsEndCusp - TRUE of EndPoint is next to a cusp See also: CurveFitObject::GenerateBezier; CurveFitObject::CalcMaxError Definition at line 612 of file fitcurve.cpp. { // Will need space for a Bezier curve FitPoint Bezier[4]; INT32 NumPoints = LastPoint - FirstPoint + 1; // if this segment only has 2 points in it then do the special case if ( NumPoints == 2 ) { InsertLine(PathArray[FirstPoint], PathArray[LastPoint], Tangent1, Tangent2, IsStartCusp, IsEndCusp); return; } // Due to a bug in the algorithm we also have to consider 3 points as a special case if ( NumPoints == 3 ) { INT32 Distance = (Distances[LastPoint] - Distances[FirstPoint]) / 3; // store the end points Bezier[0] = PathArray[FirstPoint]; Bezier[3] = PathArray[LastPoint]; // calc the control points Bezier[1] = Bezier[0] + Tangent1.SetLength(Distance); Bezier[2] = Bezier[3] + Tangent2.SetLength(Distance); // add it to the path InsertBezier(Bezier, IsStartCusp, IsEndCusp); return; } // Create a Bezier curve from the segemnt and see if it is a good fit INT32 SplitPoint; GenerateBezier(FirstPoint, LastPoint, Tangent1, Tangent2, Bezier); double MaxError = CalcMaxError(FirstPoint, LastPoint, Bezier, &SplitPoint); if (MaxError < Error) { // The mapping was good, so output the curve segment InsertBezier(Bezier, IsStartCusp, IsEndCusp); return; } // fitting failed -- split at max error point and fit recursively FitPoint CentTangent = CentreTangent(SplitPoint); FitCubic(FirstPoint, SplitPoint, Tangent1, CentTangent, IsStartCusp, FALSE); CentTangent = -CentTangent; FitCubic(SplitPoint, LastPoint, CentTangent, Tangent2, FALSE, IsEndCusp); }

void CurveFitObject::FitCurve (   )

Actually fits the curve and places the results back in the path object declared in the constructor. This function walks through all the data points trying to find cusps in the path and fits curves between them by calling the FitCubic member of the CurveFitObject. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/94 See also: CurveFitObject::FitCubic Definition at line 503 of file fitcurve.cpp. { FitPoint Tangent1, Tangent2; double Angle1, Angle2; INT32 Start = 0; INT32 StraightLinePos = 0; for (INT32 i=1; i<TotalCoords-1; i++) { if ((TotalStraightLines>0) && (i==LineArray[StraightLinePos])) { // if we have a section to the path that needs fitting before we do this then do it if (Start != (i-1)) { // calculate the tangents off the end of the path Tangent1 = LeftTangent(Start); Tangent2 = RightTangent(i-1); // Fit a curve up to the straight line section FitCubic(Start, i-1, Tangent1, Tangent2); } // And draw in the straight line section InsertStraightLine(PathArray[i]); StraightLinePos++; Start = i; } else { // Go find the angle between a group of points Angle1 = atan2((double)PathArray[i].y-PathArray[i-1].y, (double)PathArray[i].x-PathArray[i-1].x); Angle2 = atan2((double)PathArray[i+1].y-PathArray[i].y, (double)PathArray[i+1].x-PathArray[i].x); // Get them in a sensible range if (Angle1 < -PI) Angle1 += 2*PI; if (Angle1 > PI) Angle1 -= 2*PI; if (Angle2 < -PI) Angle2 += 2*PI; if (Angle2 > PI) Angle2 -= 2*PI; // See if this point is a cusp in the curve if ((fabs(Angle2-Angle1) > (PI/2)) && (fabs(Angle2-Angle1) <= PI)) { // calculate the tangents off the end of the path Tangent1 = LeftTangent(Start); Tangent2 = RightTangent(i); // and do a load of maths that will hopefully fit a nice curve on it FitCubic(Start, i, Tangent1, Tangent2); Start = i; } } } INT32 End = TotalCoords-1; if ((TotalStraightLines>0) && (End==LineArray[StraightLinePos])) { // if we have a section to the path that needs fitting before we do this then do it if (Start != (End-1)) { // calculate the tangents off the end of the path Tangent1 = LeftTangent(Start); Tangent2 = RightTangent(End-1); // Fit a curve up to the straight line section FitCubic(Start, End-1, Tangent1, Tangent2); } // And draw in the straight line section InsertStraightLine(PathArray[End]); } else { // Just have to fit a curve from the last cusp to the end of the path Tangent1 = LeftTangent(Start); Tangent2 = RightTangent(End); // and do a load of maths that will hopefully fit a nice curve on it FitCubic(Start, End, Tangent1, Tangent2); } }

void CurveFitObject::GenerateBezier (  INT32  FirstPoint, INT32  LastPoint, FitPoint  Tangent1, FitPoint  Tangent2, FitPoint *  Bezier )  [private]

This function supplies the maths to try and fit a cubic function to a set of points. It spends its time trying to come up with good lengths for the two tangents passed in to maximise the closeness of the fit. If it fails to come up with realistic results it simply sets the tangent lengths to be 1/3 of the distance between the start point and the end point. Scope: private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/94 Parameters: FirstPoint  - the index of the coordinate in the path to start fitting from [INPUTS] LastPoint - the index of the coordinate in the path to stop fitting at Tangent1 - The tangent of the curve at the first point Tangent2 - the tangent of the curve at the last point Bezier  - A pointer to a Bezier Curve [OUTPUTS] Definition at line 688 of file fitcurve.cpp. { INT32 NumPoints = LastPoint - FirstPoint + 1; // Build a matrix type of thing that contains the tangents scaled by the offsets FitPoint A[STEP_SIZE+1][2]; // Vector2 (*A)[2] = new Vector2[NumPoints+1][2]; double Offsets[STEP_SIZE+1]; INT32 step = (NumPoints+STEP_SIZE) / STEP_SIZE; INT32 i, pos = 0; // Chord length parameterisation const INT32 DistToEnd = Distances[LastPoint] - Distances[FirstPoint]; for (i=FirstPoint; i<LastPoint+1; i+=step) { Offsets[pos] = Distances[i] - Distances[FirstPoint]; Offsets[pos] /= DistToEnd; // Fill the matrix A A[pos][0] = Tangent1.SetLength( Bezier1(Offsets[pos]) ); A[pos][1] = Tangent2.SetLength( Bezier2(Offsets[pos]) ); // Move to the next element in the path pos++; } // For a detailed description of the maths used here, please see Graphics Gems I // I have made some changes to the basic algorithm used there - the main one is // that this block of maths is only performed on a small selection of the points // in the data set, where-as the one in the book uses all the points double C[2][2]; double X[2]; C[0][0] = 0.0; C[0][1] = 0.0; C[1][0] = 0.0; C[1][1] = 0.0; X[0] = 0.0; X[1] = 0.0; FitPoint FirstCoord = PathArray[FirstPoint]; FitPoint LastCoord = PathArray[LastPoint]; FitPoint ThisCoord, Combo; pos = 0; for (i=0; i<NumPoints; i+=step) { C[0][0] += A[pos][0].SquaredLength(); C[0][1] += A[pos][0].Dot(A[pos][1]); // Point C[1][0] is the same as C[0][1] and is set outside the loop below C[1][1] += A[pos][1].SquaredLength(); // Go ahead and build a vector based on the bezier functions ThisCoord = PathArray[FirstPoint+i]; Combo = ThisCoord - ((FirstCoord * Bezier0(Offsets[pos])) + (FirstCoord * Bezier1(Offsets[pos])) + (LastCoord * Bezier2(Offsets[pos])) + (LastCoord * Bezier3(Offsets[pos]))); // Combine it with the other points X[0] += A[pos][0].Dot( Combo ); X[1] += A[pos][1].Dot( Combo ); pos++; } // This point in the matrix is the same, so we do not need to do it in the loop C[1][0] = C[0][1]; // calc the determinants of C and X double det_C0_C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1]; double det_C0_X = C[0][0] * X[1] - C[0][1] * X[0]; double det_X_C1 = X[0] * C[1][1] - X[1] * C[0][1]; // finally, derive the length of the ideal tangents if (det_C0_C1 == 0.0) det_C0_C1 = (C[0][0] * C[1][1]) * 10e-12; // oh err, whats it up to here then! double AlphaLeft = det_X_C1 / det_C0_C1; double AlphaRight = det_C0_X / det_C0_C1; Bezier[0] = PathArray[FirstPoint]; Bezier[3] = PathArray[LastPoint]; // if alpha negative, the set the tangent length to a third of the distance between // the start and the end points of the curve segment if ( AlphaLeft < 0.0 || AlphaRight < 0.0) { INT32 Distance = (Distances[LastPoint] - Distances[FirstPoint]) / 3; Bezier[1] = Bezier[0] + Tangent1.SetLength(Distance); Bezier[2] = Bezier[3] + Tangent2.SetLength(Distance); } else { Bezier[1] = Bezier[0] + Tangent1.SetLength(AlphaLeft); Bezier[2] = Bezier[3] + Tangent2.SetLength(AlphaRight); } }

BOOL CurveFitObject::Initialise (  Path *  CopyPath, INT32  NumPoints )

Gets memory to store all the coords in and starts going through the path extracting the relavent points. It also calculates the distance along the path of each of the points it stores, which are needed extensivly when checking the accuracy of the fit. This function also empties the path object ready for the fitted version to be added. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/94 Parameters: CopyPath  - The path to copy the MoveTo Data from [INPUTS] NumPoints - the number of points in the path object Returns: TRUE if the CurveFitter was properly initialised or FALSE if it failed to get the memory that it needs Definition at line 365 of file fitcurve.cpp. { // Here we must try and get some memory for the path array PathArray = new DocCoord[NumPoints]; if (PathArray==NULL) return FALSE; // copy the data out of the path and into the array. Only copy points of interest CopyPath->FindStartOfPath(); DocCoord* Coords = CopyPath->GetCoordArray(); // Deal with the flags - We have to look for Spare1 being true, meaning that the previous // Lineto was meant to stay as a straight line PathFlags* Flags = CopyPath->GetFlagArray(); TotalStraightLines = 0; for (INT32 i=0; i<NumPoints; i++) { if (Flags[i].Spare1==TRUE) TotalStraightLines++; } // Get some memory to store the positions of the line breaks in if (TotalStraightLines>0) { LineArray = new INT32[TotalStraightLines]; if (LineArray==NULL) { delete PathArray; PathArray = NULL; return FALSE; } } // copy the MoveTo out of the path and into our array PathArray[0].x = Coords[0].x; PathArray[0].y = Coords[0].y; INT32 IncludePoint = 1; INT32 StraightLinePos = 0; for (INT32 i=1; i<NumPoints; i++) { // If this is one of the straight line bits, then make a note of its position if (Flags[i].Spare1==TRUE) { LineArray[StraightLinePos] = IncludePoint; StraightLinePos++; } // Check to see if this coordinate is really needed (last point is always needed) if ((Coords[i].x != PathArray[IncludePoint-1].x) || (Coords[i].y != PathArray[IncludePoint-1].y) && (i!=NumPoints-1)) { // This point is not the same as the one before, so add it into the array PathArray[IncludePoint].x = Coords[i].x; PathArray[IncludePoint].y = Coords[i].y; IncludePoint++; } } // Add the last point in the track data to the path array if it is not already there if ((PathArray[IncludePoint-1].x != Coords[NumPoints-1].x) || (PathArray[IncludePoint-1].y != Coords[NumPoints-1].y)) { PathArray[IncludePoint].x = Coords[NumPoints-1].x; PathArray[IncludePoint].y = Coords[NumPoints-1].y; IncludePoint++; } // increment the Include count (as we have just added a point to the array) and then // set the true number of points properly. NumPoints = IncludePoint; if (NumPoints<2) { delete PathArray; delete LineArray; PathArray = NULL; LineArray = NULL; return FALSE; } // Build an array of the distances along the path Distances = new INT32[NumPoints]; if (Distances==NULL) { delete PathArray; delete LineArray; PathArray = NULL; LineArray = NULL; return FALSE; } Distances[0] = 0; INT32 dx, dy, min; for (INT32 i=1; i<NumPoints; i++) { // This is doing an approximation to a Square Root // It is about 250 times faster on a machine without FPU // find the difference between the last 2 points dx = abs(PathArray[i].x - PathArray[i-1].x); dy = abs(PathArray[i].y - PathArray[i-1].y); // Find out half the smallest of dx and dy if (dx>dy) min = dy>>1; else min = dx>>1; Distances[i] = Distances[i-1] + dx + dy - min; } // Now we can delete the Path Data in the path we are to put the smoothed path in LongPath->ClearPath(); LongPath->FindStartOfPath(); LongPath->InsertMoveTo(PathArray[0]); // Store the total number of coords in the array for future reference TotalCoords = NumPoints; return TRUE; }

void CurveFitObject::InsertBezier (  FitPoint *  Bezier, BOOL  IsStartCusp, BOOL  IsEndCusp )  [private]

Adds the bezier curve to the path. If it is that last curve in the fitting (ie Depth is 0) then the rotate flag will not be set Scope: private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/94 Parameters: Bezier  - the control points of the bezier curve to add to the path [INPUTS] IsStartCusp - TRUE if the start of this bezier is at a cusp IsEndCusp - TRUE if the End of this bezier is at a cusp Definition at line 1045 of file fitcurve.cpp. { // Prepare some flags PathFlags Flags; Flags.IsSelected = FALSE; Flags.IsSmooth = FALSE; Flags.IsRotate = TRUE; // Add this Bezier curve into the path LongPath->InsertCurveTo( DocCoord( (INT32)Bezier[1].x, (INT32)Bezier[1].y), DocCoord( (INT32)Bezier[2].x, (INT32)Bezier[2].y), DocCoord( (INT32)Bezier[3].x, (INT32)Bezier[3].y), &Flags); // Deal with cusps if (IsStartCusp || IsEndCusp) { // Go find out about the path PathFlags* AllFlags = LongPath->GetFlagArray(); INT32 NumCoords = LongPath->GetNumCoords(); if (IsStartCusp) { // Patch up the flags of the bits near that start AllFlags[NumCoords-3].IsRotate = FALSE; } if (IsEndCusp) { // Patch up the flags of the bits near that end AllFlags[NumCoords-2].IsRotate = FALSE; AllFlags[NumCoords-1].IsRotate = FALSE; } } }

void CurveFitObject::InsertLine (  const DocCoord &  Start, const DocCoord &  End, FitPoint  Tangent1, FitPoint  Tangent2, BOOL  IsStartCusp, BOOL  IsEndCusp )  [private]

Inserts a straight curve into the path. It keeps it as a curve so that the path will continue to look smooth after it is edited. If this is the last Path element in the fit, (ie Depth is zero) then the rotate flag will not be set. Scope: private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/94 Parameters: Start  - the coord of the start point of the line [INPUTS] End - the coord of the end point of the line Tangent1, Tangent2 - The tangents to the curve at the start and end points IsStartCusp - TRUE if the start of this bezier is at a cusp IsEndCusp - TRUE if the End of this bezier is at a cusp Definition at line 1102 of file fitcurve.cpp. { // Prepare some flags PathFlags Flags; Flags.IsSelected = FALSE; Flags.IsSmooth = FALSE; Flags.IsRotate = TRUE; // Find out a third of the distance between the two points FitPoint StartPos(Start); FitPoint EndPos(End); FitPoint DistanceVect = EndPos - StartPos; INT32 Length = (INT32)DistanceVect.Length() / 3; // Make the tangents the right length Tangent1 = Tangent1.SetLength(Length); Tangent2 = Tangent2.SetLength(Length); // Work out the position of the control points StartPos = StartPos + Tangent1; EndPos = EndPos + Tangent2; // Add the line to the curve LongPath->InsertCurveTo( DocCoord( (INT32)StartPos.x, (INT32)StartPos.y ), DocCoord( (INT32)EndPos.x, (INT32)EndPos.y ), End, &Flags); // Deal with cusps if (IsStartCusp || IsEndCusp) { // Go find out about the path PathFlags* AllFlags = LongPath->GetFlagArray(); INT32 NumCoords = LongPath->GetNumCoords(); if (IsStartCusp) { // Patch up the flags of the bits near that start AllFlags[NumCoords-3].IsRotate = FALSE; } if (IsEndCusp) { // Patch up the flags of the bits near that end AllFlags[NumCoords-2].IsRotate = FALSE; AllFlags[NumCoords-1].IsRotate = FALSE; } } }

void CurveFitObject::InsertStraightLine (  const DocCoord &  End  )  [private]

Inserts a straight Line into the path. This is used in cases where the Line segment must be kept as a straight line (ie by using Straight Line Mode of the FreeHand tool) Scope: private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 25/4/94 Parameters: End  - the coord of the end point of the line [INPUTS] Definition at line 1169 of file fitcurve.cpp. { // Prepare some flags PathFlags Flags; Flags.IsSelected = FALSE; Flags.IsRotate = FALSE; Flags.IsSmooth = FALSE; // Insert the line LongPath->InsertLineTo(End, &Flags); }

FitPoint CurveFitObject::LeftTangent (  INT32  Start  )  [private]

Finds the Left tangent at the given point in the path Scope: private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/94 Parameters: Start  - the index of the point at the start of the segment to fit [INPUTS] Returns: The tangent at the point Start Definition at line 890 of file fitcurve.cpp. { FitPoint Tangent; // check for empty point array if (TotalCoords == 0) { Tangent.x = 1; Tangent.y = 0; return Tangent; } // check for start outside the array if ((Start >= TotalCoords) || (Start < 0)) Start = TotalCoords / 2; // Find out which point to look to INT32 Forward = Start+2; if (Forward > TotalCoords-1) Forward = TotalCoords-1; // Calc the tangent from the left of the curve segment Tangent.x = PathArray[Forward].x - PathArray[Start].x; Tangent.y = PathArray[Forward].y - PathArray[Start].y; // Make sure that is not of zero length if ((Tangent.x==0) && (Tangent.y==0)) { TRACEALL( _T("Tangent was a zero length vector in the curve fitter (left)\n")); Tangent.x = 1; } return Tangent; }

FitPoint CurveFitObject::RightTangent (  INT32  End  )  [private]

Finds the Right tangent at the given point in the path Scope: private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/94 Parameters: End  - the index of the point at the end of the segment to fit [INPUTS] Returns: The tangent at the point End Definition at line 940 of file fitcurve.cpp. { FitPoint Tangent; // Find out which point to look to INT32 Backward = End-2; if (Backward<0) Backward = 0; Tangent.x = PathArray[Backward].x - PathArray[End].x; Tangent.y = PathArray[Backward].y - PathArray[End].y; // Make sure that is not of zero length if ((Tangent.x==0) && (Tangent.y==0)) { TRACEALL( _T("Tangent was a zero length vector in the curve fitter (Right)\n")); Tangent.x = -1; } return Tangent; }

---

Member Data Documentation

INT32* CurveFitObject::Distances [private]

Definition at line 236 of file fitcurve.h.

double CurveFitObject::Error [private]

Definition at line 240 of file fitcurve.h.

INT32* CurveFitObject::LineArray [private]

Definition at line 233 of file fitcurve.h.

Path* CurveFitObject::LongPath [private]

Definition at line 231 of file fitcurve.h.

DocCoord* CurveFitObject::PathArray [private]

Definition at line 232 of file fitcurve.h.

INT32 CurveFitObject::TotalCoords [private]

Definition at line 243 of file fitcurve.h.

INT32 CurveFitObject::TotalStraightLines [private]

Definition at line 244 of file fitcurve.h.

---

The documentation for this class was generated from the following files:

• Kernel/fitcurve.h (r1785/r751)
• Kernel/fitcurve.cpp (r1785/r1282)

---