TraceRegion Class Reference

#include <tracergn.h>

Inheritance diagram for TraceRegion:

List of all members.

Public Member Functions
	TraceRegion ()
	Sets intial values up.
	~TraceRegion ()
	Destructs object.
BOOL	UseBitmap (KernelBitmap *pBitmap)
	Points the TraceRegion at a particular bitmap and claims the relevant size buffers.
BOOL	UsePath (Path *pPath)
	Specifies we should use a particular path. The path is initialised, cleared etc.
BOOL	Trace (INT32 InitialX, INT32 InitialY, BfxPixelOp *thepBfxPixelOp)
	Does a single boundary trace.
BOOL	SetParams (double *pPixelError=NULL)
	Sets the tracing parameters.
BOOL	GetParams (double *pPixelError=NULL)
	Sets the tracing parameters.
Static Public Member Functions
static void	Test (UndoableOperation *Op)
	Internal test routine.
Protected Member Functions
BOOL	TraceBoundary (DocCoord Origin, DocCoord Point1, DocCoord Point2)
	Does a single boundary trace.
BOOL	FillBoundaryBuffer (BOOL *End)
	Fills up the boundary buffer.
BOOL	ProcessBoundaryBuffer (BOOL Done=FALSE)
	Empties the boundary buffer.
BOOL	FindInitialPoint (BOOL *End)
	Finds an initial point to start at.
void	FitCubic (INT32 FirstPoint, INT32 LastPoint, TraceBoundaryPoint Tangent1, TraceBoundaryPoint Tangent2, BOOL IsStartCusp, BOOL IsEndCusp)
	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, TraceBoundaryPoint Tangent1, TraceBoundaryPoint Tangent2, TraceBoundaryPoint *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.
TraceBoundaryPoint	BezierPoint (TraceBoundaryPoint *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.
BOOL	CalcMaxError (INT32 LeftPoint, INT32 RightPoint, TraceBoundaryPoint *Bezier, INT32 *SplitPoint, double *MaxDist, INT32 Level)
	Finds out how good a fit the bezier curve we have created is when compared with the data points Scope: private.
void	Parameterize (INT32 FirstPoint, INT32 LastPoint)
	This function determines the TPoints which will be fitted (i.e. the trace boundary points we use) and the TValues which will be assigned to them (i.e. the t values along the chord length to which the points correspond). Scope: private.
TraceBoundaryPoint	LeftTangent (INT32 Start, INT32 Points)
	Finds the Left tangent at the given point in the path Scope: private.
TraceBoundaryPoint	RightTangent (INT32 End, INT32 Points)
	Finds the Right tangent at the given point in the path Scope: private.
TraceBoundaryPoint	CentreTangent (INT32 Centre, INT32 Points)
	Finds the tangent at the centre of the path Scope: private.
void	InsertBezier (TraceBoundaryPoint *Bezier, BOOL IsStartCusp, BOOL IsEndCusp)
	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, BOOL IsStartCusp, BOOL IsEndCusp)
	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.
double	Bezier0 (double u)
double	Bezier1 (double u)
double	Bezier2 (double u)
double	Bezier3 (double u)
BOOL	IsCuspDirectionChange (INT32 dir1, INT32 dir2)
Protected Attributes
TraceBoundaryPoint *	BoundaryBuffer
BfxPixelOp *	pBfxPixelOp
KernelBitmap *	Bitmap
INT32	xsize
INT32	ysize
TraceBoundaryPoint	InitialPoint
TraceBoundaryPoint	HeadPoint
INT32	InitialDirection
INT32	TailDirection
INT32	HeadDirection
TraceBoundaryPoint	FirstBufferPoint
INT32	BoundaryTail
INT32	BoundaryHead
INT32	BoundaryRingMask
INT32	BoundaryRingSize
double	Error
double	PixelError
BOOL	VirginBuffer
BOOL	VirginPath
BOOL	AtCusp
BOOL	TailCusp
Path *	ThePath
TraceBoundaryPoint	Directions [(0x7)+1]
TraceBoundaryPoint	DirectionPoint [(0x7)+1][(0x7)+1][4]
double	TValues [10+1]
INT32	TPoints [10+1]
TraceBoundaryPoint	Q1 [3]
TraceBoundaryPoint	Q2 [2]
INT32	NumTPoints
Private Member Functions
	CC_DECLARE_DYNCREATE (TraceRegion)

---

Detailed Description

Definition at line 318 of file tracergn.h.

---

Constructor & Destructor Documentation

TraceRegion::TraceRegion (   )

Sets intial values up. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: none  [INPUTS] (constructs  object) [OUTPUTS] Returns: none Errors: None Scope: Public See also: - Definition at line 165 of file tracergn.cpp. { pBfxPixelOp = NULL; BoundaryBuffer = NULL; BoundaryRingSize = 0; BoundaryRingMask =0; Bitmap = NULL; xsize = 1; ysize = 1; VirginBuffer = TRUE; AtCusp = FALSE; TailCusp = FALSE; TailDirection = -1; ThePath = NULL; double TheError = 1.00; SetParams(&TheError); /* In each direction of travel we always leave with a particular corner of the pixel set. In some directinos of travel, we have to set 2 edges. Here goes: ->1-X | | This is how an east going trace is represented. The top edge is the one we need to fill in. | | ---- ->1- | V This is how a SE going trace is represented. We have 2 edges to fill in this time. | 2 ---- When there is a change in direction, things become more complex. Let us assume that the current direction is east, then note (for the following new directions) how will fill be buffer in: Current direction East Current direction south east: ->1-X ->1-X | | E | | E | | | | ---- ---- ->1- ->1- | V SE | V SE | 2 | 2 ----X ----X ->1-C ->1- | V S | V S | 2 | 2 ----X ----X ->1-C ->1- | V SW | V SW | 2 | 2 X-<3- X-<3-C ->1-C ->1- | V W | V W | 2 | 2 X-<3-(C) X-<3-C X---- ->1- | | NW (theoretically impossible - no edges) 4 V NW | | ^ 2 ---- -<3-C C---- X---- | | N (no edges (correct place)) | | N (theoretically impossible) | | | | ---- ---- ->1- ->1-X | | NE | | NE | | | | ---- ---- Note how strikingly similar these are! We use the RH column one as that's generic for both sides. */ // Grrr... This should be static but lovely C++ wont let me compile it. Thanks a lot C++ // Heh what's 128 bytes when you have a bitmap to trace Directions[0].Init( (1<<8), (0<<8)); // East Directions[1].Init( (1<<8),-(1<<8)); // South East Directions[2].Init( (0<<8),-(1<<8)); // South Directions[3].Init(-(1<<8),-(1<<8)); // South West Directions[4].Init(-(1<<8), (0<<8)); // West Directions[5].Init(-(1<<8), (1<<8)); // North West Directions[6].Init( (0<<8), (1<<8)); // North Directions[7].Init( (1<<8), (1<<8)); // North East // First sort out the non-diagonal table DirectionPoint[0][0][0].Init( (1<<7), (1<<7)); // East to East DirectionPoint[0][0][1].Init( -1, -1); // No point 2 DirectionPoint[0][0][2].Init( -1, -1); // No point 3 DirectionPoint[0][0][3].Init( -1, -1); // No point 4 DirectionPoint[0][1][0].Init( (1<<7), (1<<7)); // East to SE DirectionPoint[0][1][1].Init( (1<<7),-(1<<7)); // point 2 DirectionPoint[0][1][2].Init( -1, -1); // No point 3 DirectionPoint[0][1][3].Init( -1, -1); // No point 4 DirectionPoint[0][2][0].Init( (1<<7), (1<<7)); // East to S DirectionPoint[0][2][1].Init( -1, 2); // No point 2, go south DirectionPoint[0][2][2].Init( -1, -1); // No point 3 DirectionPoint[0][2][3].Init( -1, -1); // No point 4 DirectionPoint[0][3][0].Init( (1<<7), (1<<7)); // East to SW DirectionPoint[0][3][1].Init( -1, 3); // No point 2, go SW DirectionPoint[0][3][2].Init( -1, -1); // point 3 DirectionPoint[0][3][3].Init( -1, -1); // No point 4 DirectionPoint[0][4][0].Init( (1<<7), (1<<7)); // East to W DirectionPoint[0][4][1].Init( -1, 2); // No point 2, go S DirectionPoint[0][4][2].Init( -1, -1); // point 3 DirectionPoint[0][4][3].Init( -1, -1); // No point 4 DirectionPoint[0][5][0].Init( (1<<7), (1<<7)); // South East to NW DirectionPoint[0][5][1].Init( (1<<7),-(1<<7)); // point 2 DirectionPoint[0][5][2].Init( -1, 5); // No point 3, go NW DirectionPoint[0][5][3].Init( -1, -1); // No point 4 DirectionPoint[0][6][0].Init( -1, 6); // No point 1, go N DirectionPoint[0][6][1].Init( -1, -1); // No point 2 DirectionPoint[0][6][2].Init( -1, -1); // No point 3 DirectionPoint[0][6][3].Init( -1, -1); // No point 4 DirectionPoint[0][7][0].Init( (1<<7), (1<<7)); // East to NE DirectionPoint[0][7][1].Init( -1, -1); // No point 2 DirectionPoint[0][7][2].Init( -1, -1); // No point 3 DirectionPoint[0][7][3].Init( -1, -1); // No point 4 DirectionPoint[1][0][0].Init( (1<<7), (1<<7)); // South East to East DirectionPoint[1][0][1].Init( -1, -1); // No point 2 DirectionPoint[1][0][2].Init( -1, -1); // No point 3 DirectionPoint[1][0][3].Init( -1, -1); // No point 4 DirectionPoint[1][1][0].Init( (1<<7), (1<<7)); // South East to SE DirectionPoint[1][1][1].Init( (1<<7),-(1<<7)); // point 2 DirectionPoint[1][1][2].Init( -1, -1); // No point 3 DirectionPoint[1][1][3].Init( -1, -1); // No point 4 DirectionPoint[1][2][0].Init( (1<<7), (1<<7)); // South East to S DirectionPoint[1][2][1].Init( (1<<7),-(1<<7)); // point 2 DirectionPoint[1][2][2].Init( -1, -1); // No point 3 DirectionPoint[1][2][3].Init( -1, -1); // No point 4 DirectionPoint[1][3][0].Init( (1<<7), (1<<7)); // South East to SW DirectionPoint[1][3][1].Init( (1<<7), (0<<7)); // point 3 DirectionPoint[1][3][2].Init( -1, 3); // No point 4, go SW DirectionPoint[1][3][3].Init( -1, -1); // No point 4 DirectionPoint[1][4][0].Init( (1<<7), (1<<7)); // South East to W DirectionPoint[1][4][1].Init( (1<<7),-(1<<7)); // point 2 DirectionPoint[1][4][2].Init( -1, 4); // No point 3, go W DirectionPoint[1][4][3].Init( -1, -1); // No point 4 DirectionPoint[1][5][0].Init( (1<<7), (1<<7)); // South East to NW DirectionPoint[1][5][1].Init( (1<<7),-(1<<7)); // point 2 DirectionPoint[1][5][2].Init( -1, 5); // No point 3, go NW DirectionPoint[1][5][3].Init( -1, -1); // No point 4 DirectionPoint[1][6][0].Init( -1, 6); // No point 1, go N DirectionPoint[1][6][1].Init( -1, -1); // No point 2 DirectionPoint[1][6][2].Init( -1, -1); // No point 3 DirectionPoint[1][6][3].Init( -1, -1); // No point 4 DirectionPoint[1][7][0].Init( (0<<7), (1<<7)); // South East to NE DirectionPoint[1][7][1].Init( -1, 7); // No point 2, go NE DirectionPoint[1][7][2].Init( -1, -1); // No point 3 DirectionPoint[1][7][3].Init( -1, -1); // No point 4 INT32 i; INT32 j; INT32 k; for (i=2; i<=7; i+=1) for (j=0; j<=7; j++) for (k=0; k<=3; k++) { // Go from direction i to direction j, i even INT32 j2 = (j-(i & 0x6)) & TR_NUMDIRECTIONMASK; DirectionPoint[i][j][k]=DirectionPoint[i & 0x1][j2][k]; if (DirectionPoint[i][j][k].x != -1) { DirectionPoint[i][j][k].RotateDirection(Directions[(i & 0x6)]); } else { if (DirectionPoint[i][j][k].y != -1) DirectionPoint[i][j][k].y = (((INT32)(DirectionPoint[(i & 0x1)][j2][k].y) + (i & 0x6)) & TR_NUMDIRECTIONMASK); } } TraceBoundaryPoint Centre; Centre.Init((1<<7),(1<<7)); for (i=0; i<=7; i+=1) for (j=0; j<=7; j++) for (k=0; k<=3; k++) { if (DirectionPoint[i][j][k].x != -1) { DirectionPoint[i][j][k].translate(Centre); } } }

TraceRegion::~TraceRegion (   )

Destructs object. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: none  [INPUTS] (destructs  object) [OUTPUTS] Returns: none Errors: None Scope: Public See also: - This frees the boundary buffer it is is present. Definition at line 505 of file tracergn.cpp. { if (BoundaryBuffer) CCFree(BoundaryBuffer); // Clear some hanging pointers BoundaryBuffer = NULL; Bitmap = NULL; ThePath = NULL; }

---

Member Function Documentation

double TraceRegion::Bezier0 (  double  u  )  [inline, protected]

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

double TraceRegion::Bezier1 (  double  u  )  [inline, protected]

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

double TraceRegion::Bezier2 (  double  u  )  [inline, protected]

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

double TraceRegion::Bezier3 (  double  u  )  [inline, protected]

Definition at line 376 of file tracergn.h. { return (u*u*u); }

TraceBoundaryPoint TraceRegion::BezierPoint (  TraceBoundaryPoint *  Bez, double  u )  [protected]

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> & Alex 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: TraceRegion::CalcMaxError Definition at line 1383 of file tracergn.cpp. { double OneMinus = 1.0-u; double uSquared = u*u; double OneMinusSquared = OneMinus*OneMinus; TraceBoundaryPoint 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; }

BOOL TraceRegion::CalcMaxError (  INT32  LeftPoint, INT32  RightPoint, TraceBoundaryPoint *  Bezier, INT32 *  SplitPoint, double *  MaxDist, INT32  Level )  [protected]

Finds out how good a fit the bezier curve we have created is when compared with the data points Scope: private. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/94 Parameters: LeftPoint,RightPoint  - the index of the start and send of the section - note these are indexes [INPUTS] into the T Array Bezier - the control points of the bezier we have fitted to the points Level - a recursion level counter SplitPoint  - the point to split the curve at if the error is too great [OUTPUTS] MaxDist - The biggest distance Returns: TRUE if the bezier should be split This is done by recursive splitting of the line (as the largest error terms are likely to be in the middle we are extremely likely to only do one split). However, in order to find the maximum error point we force 3 levels of recursion. Cunningly we move the TValues about if we think they are salvageable. Definition at line 1426 of file tracergn.cpp. { TraceBoundaryPoint Q_t, Q1_t, Q2_t; // t evaluated at Q, Q' & Q'' INT32 MidPoint = (LeftPoint + RightPoint+1)/2; // where we are going to evaluate it double Distance; if (!((MidPoint == LeftPoint) || (MidPoint==RightPoint))) { for (INT32 iterations=1; iterations<=3; iterations++) { double t = TValues[MidPoint]; TraceBoundaryPoint pt = BoundaryBuffer[TPoints[MidPoint]]; // Calculate where the curve actually is and find the distance from where we want it Distance = (BezierPoint(Bezier, t) - pt).SquaredLength(); if ((Distance > *MaxDist) && (Distance < Error * 2.0)) // If this is would be the new winner, and it's salvageable (less than twice as far away as we // we want), recalculate a better TValue { // Evaluate Q, Q' & Q'' double OneMinus = 1.0-t; double tSquared = t*t; double OneMinusSquared = OneMinus*OneMinus; Q_t = Bezier[0] *(OneMinusSquared*OneMinus) + Bezier[1]*(3.0*t*OneMinusSquared) +Bezier[2] *(3.0*tSquared*OneMinus) + Bezier[3]*(tSquared*t); Q1_t = Q1[0]*(OneMinusSquared) + Q1[1]*(2.0*t*OneMinus) + Q1[2]*(tSquared); Q2_t = Q2[0]*(OneMinus) + Q2[1]*(t); // Now Newton Raphson tprime = t - f(t)/f'(t) TraceBoundaryPoint QtMinuspt = Q_t - pt; // changed by Ed Cornes 31/10/95 in an attempt to remove an itermittent floating point exception in the tracer // t = t - ( (QtMinuspt.x)*(Q1_t.x) + (QtMinuspt.y) * (Q1_t.y) ) / // ( Q1_t.SquaredLength() + ((QtMinuspt.x) * (Q2_t.x) + (QtMinuspt.y) * (Q2_t.y)) ); double denom = Q1_t.SquaredLength() + ((QtMinuspt.x) * (Q2_t.x) + (QtMinuspt.y) * (Q2_t.y)); if (fabs(denom)<1e-50) denom = (denom<0) ? -1e-50 : 1e-50; t = t - ( (QtMinuspt.x)*(Q1_t.x) + (QtMinuspt.y) * (Q1_t.y) ) / denom; if (t<0) t=0; if (t>1) t=1; //TRACEUSER( "Alex", _T("Point %f moves to %f\n"),TValues[MidPoint],t); TValues[MidPoint] = t; } else break; // Leave 'for' loop - point OK or point not salvageable } if ( Distance >= *MaxDist) { *MaxDist = Distance; *SplitPoint = MidPoint; } // If we haven't got a point to split at yet, or if we're in the 4 first points, // recurse down. This ensures we do 8 points. if ((*MaxDist<=Error) || (Level<3)) CalcMaxError(LeftPoint, MidPoint, Bezier, SplitPoint, MaxDist, Level+1); if ((*MaxDist<=Error) || (Level<3)) CalcMaxError(MidPoint, RightPoint, Bezier, SplitPoint, MaxDist, Level+1); } return(*MaxDist>Error); }

TraceRegion::CC_DECLARE_DYNCREATE (  TraceRegion   )  [private]

TraceBoundaryPoint TraceRegion::CentreTangent (  INT32  Centre, INT32  Points )  [protected]

Finds the tangent at the centre of the path Scope: private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> & Alex Date: 7/3/94 Parameters: Centre  - the index of the split point in the path [INPUTS] Points - the max number of points that can be scanned Returns: The tangent at the point Centre Definition at line 1595 of file tracergn.cpp. { TraceBoundaryPoint Left, Right; TraceBoundaryPoint Tangent(0,0); Points = 1+MIN (Points/2,MAXTANGENTPOINTS); if (Points<2) Points=2; // Make sure that is not of zero length while ((Tangent.x==0) && (Tangent.y==0)) { if ((--Points)>0) { // Calc right tangent Left.x = BoundaryBuffer[Centre-Points].x - BoundaryBuffer[Centre].x; Left.y = BoundaryBuffer[Centre-Points].y - BoundaryBuffer[Centre].y; // Calc left tangent Right.x = BoundaryBuffer[Centre].x - BoundaryBuffer[Centre+Points].x; Right.y = BoundaryBuffer[Centre].y - BoundaryBuffer[Centre+Points].y; // Average to get the centre tangent Tangent.x = (Left.x + Right.x) / 2; Tangent.y = (Left.y + Right.y) / 2; } else { ERROR3("Tangent was a zero length vector in the curve fitter (Centre)"); Tangent.x = -1; } } return Tangent; }

BOOL TraceRegion::FillBoundaryBuffer (  BOOL *  End  )  [protected]

Fills up the boundary buffer. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: End  ptr to BOOL to return in [INPUTS] End  set TRUE if last point else set FALSE [OUTPUTS] Returns: TRUE if worked, FALSE & error set if failed Errors: Error2 & Error3 (various) Scope: Protected See also: TraceRegion::ProcessBoundaryBuffer This routine fills the boundary buffer up with some more points. It stops if the buffer becomes nearly full. It also stops if it meets a cusp, or the intial point in the initial direction. Definition at line 824 of file tracergn.cpp. { INT32 NewDirection; INT32 Turns; ERROR2IF((!Bitmap),FALSE,"TraceRegion incorrectly initialised"); *End=FALSE; while (BoundaryHead<BoundaryRingSize - 6) // there is enough room in buffer { // Calculate the new direction. We start looking at direction-2 but as we add one before we start // we have -3. If we're at a cusp we know the NewDirection set to HeadDirection is the correct place, // i.e. we want +0, but because we add one before we start, we want -1. NewDirection = (HeadDirection-(AtCusp?1:3)) & TR_NUMDIRECTIONMASK; //NewDirection = (HeadDirection-3) & TR_NUMDIRECTIONMASK; Turns=0; TraceBoundaryPoint NewPoint=HeadPoint; // Initialisation unnecessary but quiets the compiler do { // This should only return(TRUE) if asked to trace a // one pixel shape - else we must have got to this pixel some how. if ((Turns++)==8) { *End=TRUE; // We want to force it to be the 4 corner case NewDirection=((HeadDirection & 0x6) + 6) & TR_NUMDIRECTIONMASK; ERROR3("One pixel regions NYI"); // The above won't work properly because it's not properly entered. I think we need a horrible // goto here. break; } // Find next direction NewDirection = (NewDirection + 1) & TR_NUMDIRECTIONMASK; NewPoint = HeadPoint; // Calculate the new point NewPoint.translate(Directions[NewDirection]); } while (!pBfxPixelOp->IsInRegion(((INT32)(NewPoint.x))>>8, ((INT32)(NewPoint.y))>>8)); if (VirginBuffer) InitialDirection = TailDirection = NewDirection; // stick point in ring buffer // Limit is such that we know we can fit the maximum of 4 points in INT32 HintPoint=0; if (!VirginBuffer) { if (AtCusp) { // Only put the last point in if at a cusp while ((DirectionPoint[HeadDirection][NewDirection][HintPoint].x != -1) // sufficient check && (HintPoint<4)) {HintPoint++;} // Don't inc at final point BoundaryBuffer[BoundaryHead] = HeadPoint; BoundaryBuffer[BoundaryHead++].translate(DirectionPoint[HeadDirection][NewDirection][HintPoint-1]); // HintPoint still points at terminator } else { // Put all points in while ((DirectionPoint[HeadDirection][NewDirection][HintPoint].x != -1) // sufficient check && (HintPoint<4)) { BoundaryBuffer[BoundaryHead] = HeadPoint; BoundaryBuffer[BoundaryHead++].translate(DirectionPoint[HeadDirection][NewDirection][HintPoint++]); } } } else while ((DirectionPoint[HeadDirection][NewDirection][HintPoint].x != -1) // sufficient check && (HintPoint<4)) {HintPoint++;} // Don't inc at final point if (DirectionPoint[HeadDirection][NewDirection][HintPoint].y !=-1) { HeadDirection = (INT32)(DirectionPoint[HeadDirection][NewDirection][HintPoint].y); // HeadPoint = NewPoint; AtCusp = TRUE; if (TailDirection == -1) TailDirection = HeadDirection; // VirginBuffer = FALSE; return (TRUE); } // check for cusp a with dirty unsigned arithmetic and return NOW if we are there. // AtCusp = ( ( ((unsigned)(Turns-2)) >=3) && (!AtCusp)); AtCusp = FALSE; //if (AtCusp) return (TRUE); // cusp return if ( (HeadPoint == InitialPoint) && (NewDirection == InitialDirection) && !VirginBuffer ) { *End = TRUE; VirginBuffer = FALSE; return (TRUE); } VirginBuffer = FALSE; if (TailDirection == -1) TailDirection = NewDirection; // Set up member vars HeadPoint = NewPoint; HeadDirection = NewDirection; } return(TRUE); // Out of buffer space, go process some & come back }

BOOL TraceRegion::FindInitialPoint (  BOOL *  End  )  [protected]

Finds an initial point to start at. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: None  [INPUTS] End  set if no points [OUTPUTS] Returns: TRUE if succeeded else FALSE and error set Errors: Various Scope: Protected See also: - This routine is currently a horrible bodge creature. The boundary buffer is cleared. An initial point will be found if possible and End cleared. If one is not found, End will be set. Definition at line 650 of file tracergn.cpp. { INT32 x; INT32 y; ERROR2IF((!Bitmap),FALSE,"How about giving us a bitmap first then?"); InitialDirection = 0; // East VirginBuffer = TRUE; BoundaryHead =0; BoundaryTail =0; TailDirection = -1; HeadDirection = 0; AtCusp=FALSE; TailCusp = FALSE; *End = FALSE; for (y = ysize-1; y>=0; y--) for (x = 0; x < xsize; x++) if (pBfxPixelOp->IsInRegion(x,y)) { InitialPoint.x = x<<8; InitialPoint.y = y<<8; HeadPoint = InitialPoint; return (TRUE); } *End = TRUE; // Oh dear, no initial point return(TRUE); }

void TraceRegion::FitCubic (  INT32  FirstPoint, INT32  LastPoint, TraceBoundaryPoint  Tangent1, TraceBoundaryPoint  Tangent2, BOOL  IsStartCusp, BOOL  IsEndCusp )  [protected]

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> & Alex 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: TraceRegion::GenerateBezier; TraceRegion::CalcMaxError Definition at line 1029 of file tracergn.cpp. { // Will need space for a Bezier curve TraceBoundaryPoint Bezier[4]; TraceBoundaryPoint CentTangent; INT32 NumPoints = LastPoint - FirstPoint + 1; INT32 SplitPoint, Split; // If we have the flexibility, recalculate the tangents to the left and right if (IsStartCusp) Tangent1 = LeftTangent(FirstPoint, NumPoints); if (IsEndCusp) Tangent2 = RightTangent(LastPoint, NumPoints); // The following is actually legal if we start on a cusp // ERROR3IF(NumPoints<2,"Too few points to fit a cubic"); if (NumPoints<2) return; #if 0 // if this segment only has 2 points in it then do the special case if ( NumPoints == 2 ) { InsertLine( DocCoord((INT32)(BoundaryBuffer[FirstPoint].x), (INT32)(BoundaryBuffer[FirstPoint].y)), DocCoord((INT32)(BoundaryBuffer[LastPoint].x), (INT32)(BoundaryBuffer[FirstPoint].y)), IsStartCusp, IsEndCusp); return; } #endif /* Due to a bug in the algorithm we also have to consider 3 points a special case. Here's what Mathematica reckons is the formula for a bezier A B C D that passes through a point Q with tangents tx & ty 4 t1x (Ay t2x + Dy t2x - 2 Qy t2x - Ax t2y - Dx t2y + 2 Qx t2y) {{Bx -> Ax - ---------------------------------------------------------------, 3 (t1y t2x - t1x t2y) 4 t1y (Ay t2x + Dy t2x - 2 Qy t2x - Ax t2y - Dx t2y + 2 Qx t2y) By -> Ay - ---------------------------------------------------------------, 3 (t1y t2x - t1x t2y) (12 (Ay + Dy - 2 Qy) t1x - 12 (Ax + Dx - 2 Qx) t1y) t2x Cx -> Dx - -------------------------------------------------------, 9 (-(t1y t2x) + t1x t2y) 4 (Ay t1x + Dy t1x - 2 Qy t1x - Ax t1y - Dx t1y + 2 Qx t1y) t2y Cy -> Dy + ---------------------------------------------------------------, 3 (t1y t2x - t1x t2y) I reckon I can rewrite this better: F -> (4/3) (A + D - 2 Q) / (t2x t1y - t2y t1x) B -> Fy t2x - Fx t2y C -> Fx t1y - Fy t1x Bx -> Ax - B t1x By -> Ay - B t1y Cx -> Dx - C t2x Cy -> Dy - C t2y This is all very well and good, but when does it occur? Here's an example: A B .... .... ...T1 T2....C Here A is is the FistPoint with tangent T1, and C is the last point with tangent T2. The only bezier that fits through B as well with tangents specified is a loop that goes left from C, back under it and up through T1. Though all the maths is fine, and we can even detect this case, it's just not worth it. We just miss out point B. Oh well, so much for the beaury of mathematics. (PS - the real soln is to introduce 1 or more extra points. But that's getting silly). */ #if 0 // Never appears to run to completion anyway :-( if (NumPoints == 3) { INT32 MidPoint = FirstPoint+1; double Bottom = 0.75 * (Tangent2.x * Tangent1.y - Tangent2.y * Tangent1.x); if (Abs(Bottom)>0.001) // Else ignore middle point - this happens if the tangents are nearly parallel { TraceBoundaryPoint F = (BoundaryBuffer[FirstPoint]+BoundaryBuffer[LastPoint]-BoundaryBuffer[MidPoint]*2.0)/Bottom; double B = F.y * Tangent2.x - F.x * Tangent2.y; double C = F.x * Tangent1.y - F.y * Tangent1.x; if ((B<0.0) && (C<0.0)) // Not generating a loop { Tangent1 = -(Tangent1 * B); Tangent2 = -(Tangent2 * C); // Don't worry - we just need their directions for the fallback case // Max distance is ((1<<8)/2)^2 = (1<<14) if ((Tangent1.SquaredLength()<(1<<14)) && (Tangent2.SquaredLength()<(1<<14))) { Bezier[0] = BoundaryBuffer[FirstPoint]; Bezier[3] = BoundaryBuffer[LastPoint]; Bezier[1] = BoundaryBuffer[FirstPoint] + Tangent1; Bezier[2] = BoundaryBuffer[LastPoint] + Tangent2; InsertBezier(Bezier, IsStartCusp, IsEndCusp); return; } } } } #endif // We must consider 2 points (or unhandled 3 point cases) as a special case if ( NumPoints <=2) { // With 3 points the distance is always 2. INT32 Distance = (1<<8)*2/3; // store the end points Bezier[0] = BoundaryBuffer[FirstPoint]; Bezier[3] = BoundaryBuffer[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; } if (NumPoints ==3) { Split = FirstPoint + 1; // Midpoint } else { // Create a Bezier curve from the segemnt and see if it is a good fit Parameterize(FirstPoint, LastPoint); GenerateBezier(FirstPoint, LastPoint, Tangent1, Tangent2, Bezier); SplitPoint=NumTPoints-1; double MaxError = 0; if (!CalcMaxError(0, NumTPoints, Bezier, &SplitPoint, &MaxError, 0)) { // The mapping was good, so output the curve segment //TRACEUSER( "Alex", _T(" OK FP=%d, LP=%d, ME=%f\n"),FirstPoint,LastPoint,MaxError); InsertBezier(Bezier, IsStartCusp, IsEndCusp); return; } Split = TPoints[SplitPoint]; } //TRACEUSER( "Alex", _T("Split FP=%d, SP=%d, LP=%d\n"),FirstPoint,Split,LastPoint); // fitting failed -- split at max error point and fit recursively CentTangent = CentreTangent(Split, MIN(Split-FirstPoint+1,LastPoint-Split+1)); //Tangent1=LeftTangent(FirstPoint,SplitPoint-FirstPoint+1); FitCubic(FirstPoint, Split, Tangent1, CentTangent, IsStartCusp, FALSE); CentTangent = -CentTangent; //Tangent2=RightTangent(LastPoint,LastPoint-SplitPoint+1); FitCubic(Split, LastPoint, CentTangent, Tangent2, FALSE, IsEndCusp); }

void TraceRegion::GenerateBezier (  INT32  FirstPoint, INT32  LastPoint, TraceBoundaryPoint  Tangent1, TraceBoundaryPoint  Tangent2, TraceBoundaryPoint *  Bezier )  [protected]

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> & Alex 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] Note the differential & 2nd differential are also generated Definition at line 1261 of file tracergn.cpp. { INT32 pos; INT32 i; // INT32 NumPoints = LastPoint - FirstPoint + 1; // Build a matrix type of thing that contains the tangents scaled by the offsets TraceBoundaryPoint A[FIT_STEPS+1][2]; // Vector2 (*A)[2] = new Vector2[NumPoints+1][2]; // Chord length parameterisation for (pos=0; pos<=NumTPoints; pos++) { // Fill the matrix A A[pos][0] = Tangent1.SetLength( Bezier1(TValues[pos]) ); A[pos][1] = Tangent2.SetLength( Bezier2(TValues[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; TraceBoundaryPoint FirstCoord = BoundaryBuffer[FirstPoint]; TraceBoundaryPoint LastCoord = BoundaryBuffer[LastPoint]; TraceBoundaryPoint ThisCoord, Combo; for (pos=0; pos<=NumTPoints; pos++) { 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 = BoundaryBuffer[TPoints[pos]]; Combo = ThisCoord - ((FirstCoord * Bezier0(TValues[pos])) + (FirstCoord * Bezier1(TValues[pos])) + (LastCoord * Bezier2(TValues[pos])) + (LastCoord * Bezier3(TValues[pos]))); // Combine it with the other points X[0] += A[pos][0].Dot( Combo ); X[1] += A[pos][1].Dot( Combo ); } // 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] = BoundaryBuffer[FirstPoint]; Bezier[3] = BoundaryBuffer[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 = ((LastPoint - FirstPoint)<<8) / 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); } // Calculate Q1 (differential) for (i = 0; i<=2; i++) { Q1[i]= (Bezier[i+1]-Bezier[i]) * 3.0; } // Calculate Q2 (2nd differential) for (i = 0; i<=1; i++) { Q2[i] = (Q1[i+1]-Q1[i]) * 2.0; } }

BOOL TraceRegion::GetParams (  double *  pPixelError = NULL  )

Sets the tracing parameters. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 17/1/95 Parameters: None  [INPUTS] ^double  values of parameters to read May be set to NULL to not read them [OUTPUTS] Returns: TRUE on success, FALSE (& error set) on failure Errors: mainly memory. Scope: Public See also: - Definition at line 419 of file tracergn.cpp. { if (pPixelError) *pPixelError = PixelError; return TRUE; }

void TraceRegion::InsertBezier (  TraceBoundaryPoint *  Bezier, BOOL  IsStartCusp, BOOL  IsEndCusp )  [protected]

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> & Alex 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 1648 of file tracergn.cpp. { // Prepare some flags PathFlags Flags; Flags.IsSelected = FALSE; Flags.IsSmooth = FALSE; Flags.IsRotate = TRUE; // Add this Bezier curve into the path ThePath->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 = ThePath->GetFlagArray(); INT32 NumCoords = ThePath->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 TraceRegion::InsertLine (  const DocCoord &  Start, const DocCoord &  End, BOOL  IsStartCusp, BOOL  IsEndCusp )  [protected]

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> & Alex 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 IsStartCusp - TRUE if the start of this bezier is at a cusp IsEndCusp - TRUE if the End of this bezier is at a cusp I've simplified the maths in this somewhat since over the FitCurve implementation. Definition at line 1706 of file tracergn.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 DocCoord StartPos; DocCoord EndPos; StartPos.x = (2 * Start.x + End.x) /3; StartPos.y = (2 * Start.y + End.y) /3; EndPos.x = (Start.x + 2 * End.x) /3; EndPos.y = (Start.y + 2 * End.y) /3; // Add the line to the curve ThePath->InsertCurveTo( (DocCoord) StartPos, (DocCoord) EndPos, (DocCoord) End, &Flags); // Patch up the path PathVerb * AllVerbs = ThePath->GetVerbArray(); PathFlags* AllFlags = ThePath->GetFlagArray(); INT32 NumCoords = ThePath->GetNumCoords(); ERROR3IF(NumCoords<4,"No initial moveto ?!"); AllFlags[NumCoords-1].IsRotate = !IsEndCusp; // Endpoint AllFlags[NumCoords-2].IsRotate = !IsEndCusp; // 2nd ctl if (AllVerbs[NumCoords-4] == PT_MOVETO) { AllFlags[NumCoords-3].IsRotate = FALSE; AllFlags[NumCoords-4].IsRotate = FALSE; } else { //BOOL IsStartCusp = AllFlags[NumCoords-5].IsRotate; AllFlags[NumCoords-3].IsRotate = !IsStartCusp; AllFlags[NumCoords-4].IsRotate = !IsStartCusp; } }

void TraceRegion::InsertStraightLine (  const DocCoord &  End  )  [protected]

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> & Alex & Alex Date: 25/4/94 Parameters: End  - the coord of the end point of the line [INPUTS] Definition at line 1770 of file tracergn.cpp. { // Prepare some flags PathFlags Flags; Flags.IsSelected = FALSE; Flags.IsRotate = FALSE; Flags.IsSmooth = FALSE; // Insert the line ThePath->InsertLineTo((DocCoord) End, &Flags); }

BOOL TraceRegion::IsCuspDirectionChange (  INT32  dir1, INT32  dir2 )  [inline, protected]

Definition at line 423 of file tracergn.h. { return (((dir1-dir2+TR_NUMDIRECTIONMASK+2) & TR_NUMDIRECTIONMASK)>2); }

TraceBoundaryPoint TraceRegion::LeftTangent (  INT32  Start, INT32  Points )  [protected]

Finds the Left tangent at the given point in the path Scope: private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> & Alex Date: 7/3/94 Parameters: Start  - the index of the point at the start of the segment to fit [INPUTS] Points - the max number of points that can be scanned Returns: The tangent at the point Start Definition at line 1514 of file tracergn.cpp. { TraceBoundaryPoint Tangent(0,0); Points = 1+MIN (Points/2,MAXTANGENTPOINTS); if (Points<2) Points=2; // Make sure that is not of zero length while ((Tangent.x==0) && (Tangent.y==0)) { if ((--Points)>0) { Tangent.x = BoundaryBuffer[Start+Points].x - BoundaryBuffer[Start].x; Tangent.y = BoundaryBuffer[Start+Points].y - BoundaryBuffer[Start].y; } else { ERROR3("Tangent was a zero length vector in the curve fitter (Left)"); Tangent.x = -1; } } return Tangent; }

void TraceRegion::Parameterize (  INT32  FirstPoint, INT32  LastPoint )  [protected]

This function determines the TPoints which will be fitted (i.e. the trace boundary points we use) and the TValues which will be assigned to them (i.e. the t values along the chord length to which the points correspond). Scope: private. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/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 Fills  up TValues & TPoints array [OUTPUTS] Definition at line 1215 of file tracergn.cpp. { INT32 pos, i; INT32 NumPoints = LastPoint-FirstPoint; // Chord length parameterisation NumTPoints = MIN(NumPoints, FIT_STEPS); for (pos=0; pos<=NumTPoints; pos++) { i = (INT32)(((double)pos/(double)NumTPoints*(double)(NumPoints))+0.5); // In this loop, TValues[pos] = ((double)i)/((double)NumPoints); TPoints[pos] = (i+FirstPoint); } // These should algorithmically never happen ERROR3IF(TPoints[0]!=FirstPoint,"TraceRegion::Parameterize fouled up first point"); ERROR3IF(TPoints[NumTPoints]!=LastPoint,"TraceRegion::Parameterize fouled up last point"); return; }

BOOL TraceRegion::ProcessBoundaryBuffer (  BOOL  Done = FALSE  )  [protected]

Empties the boundary buffer. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: Done  TRUE to set last point to FirstBufferPoint [INPUTS] none  [OUTPUTS] Returns: TRUE if worked, FALSE & error set if failed Errors: Error2 & Error3 (various) Scope: Protected See also: TraceRegion::ProcessBoundaryBuffer This routine empties the boundary buffer. It leaves exactly one coordinate in it. The buffer must be non-empty. Definition at line 951 of file tracergn.cpp. { BoundaryTail = 0; // ERROR3IF( (((BoundaryHead - BoundaryTail) & BoundaryRingMask) <=0 ), // "Boundary ring buffer is empty"); if (((BoundaryHead - BoundaryTail) & BoundaryRingMask) <=0 ) return TRUE; if (VirginPath) { ThePath->FindStartOfPath(); ThePath->InsertMoveTo(DocCoord((INT32)(BoundaryBuffer[BoundaryTail].x), (INT32)(BoundaryBuffer[BoundaryTail].y))); VirginPath = FALSE; FirstBufferPoint=BoundaryBuffer[BoundaryTail]; } // Patch up initial hinting (done on inadequate information) if (Done) { BoundaryBuffer[BoundaryHead-1]=FirstBufferPoint; if (BoundaryBuffer[BoundaryHead-2]==FirstBufferPoint) BoundaryHead=(BoundaryHead-1)&BoundaryRingMask; if (((BoundaryHead - BoundaryTail) & BoundaryRingMask) <=0 ) return TRUE; } #if 0 while (BoundaryTail != (BoundaryHead-1)) { InsertLine(DocCoord((INT32)(BoundaryBuffer[BoundaryTail].x),(INT32)(BoundaryBuffer[BoundaryTail].y)), DocCoord((INT32)(BoundaryBuffer[BoundaryTail=(BoundaryTail + 1) & BoundaryRingMask].x), (INT32)(BoundaryBuffer[BoundaryTail].y)), TRUE, TRUE); } #else // This case should never occur, but does very very occasionally - not sure why (Alex) // we ignore buffers with only one point in if (((BoundaryHead-1) & BoundaryRingMask)==BoundaryTail) return TRUE; // Just have to fit a curve from the last cusp to the end of the path TraceBoundaryPoint Tangent1 = LeftTangent(BoundaryTail,BoundaryHead-BoundaryTail); TraceBoundaryPoint Tangent2 = RightTangent(BoundaryHead-1,BoundaryHead-BoundaryTail); // and do a load of maths that will hopefully fit a nice curve on it FitCubic(BoundaryTail, BoundaryHead-1, Tangent1, Tangent2, TailCusp, AtCusp); #endif BoundaryBuffer[0]=BoundaryBuffer[BoundaryHead-1]; BoundaryTail = 0; BoundaryHead = 1; TailDirection = -1; TailCusp = AtCusp; return (TRUE); }

TraceBoundaryPoint TraceRegion::RightTangent (  INT32  End, INT32  Points )  [protected]

Finds the Right tangent at the given point in the path Scope: private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> & Alex Date: 7/3/94 Parameters: End  - the index of the point at the end of the segment to fit [INPUTS] Points - the max number of points that can be scanned Returns: The tangent at the point End Definition at line 1554 of file tracergn.cpp. { TraceBoundaryPoint Tangent(0,0); Points = 1+MIN (Points/2,MAXTANGENTPOINTS); if (Points<2) Points=2; // Make sure that is not of zero length while ((Tangent.x==0) && (Tangent.y==0)) { if ((--Points)>0) { Tangent.x = BoundaryBuffer[End-Points].x - BoundaryBuffer[End].x; Tangent.y = BoundaryBuffer[End-Points].y - BoundaryBuffer[End].y; } else { ERROR3("Tangent was a zero length vector in the curve fitter (Right)"); Tangent.x = -1; } } return Tangent; }

BOOL TraceRegion::SetParams (  double *  pPixelError = NULL  )

Sets the tracing parameters. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 17/1/95 Parameters: ^double  values of parameters to set. May be set to NULL to not change them [INPUTS] None  [OUTPUTS] Returns: TRUE on success, FALSE (& error set) on failure Errors: mainly memory. Scope: Public See also: - Definition at line 393 of file tracergn.cpp. { if (pPixelError) PixelError = *pPixelError; Error = PixelError; Error *= 256.0; // For shift Error *= Error; // Squared return TRUE; }

void TraceRegion::Test (  UndoableOperation *  Op  )  [static]

Internal test routine. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: ^Op  [INPUTS] none  [OUTPUTS] Returns: nothing Errors: none See also: - A test routine Definition at line 1802 of file tracergn.cpp. { BOOL CarryOn=TRUE; Range Sel(*(GetApplication()->FindSelection())); Node* FirstSelectedNode = Sel.FindFirst(); if (FirstSelectedNode != NULL) // No nodes selected so End { Node* CurrentNode = FirstSelectedNode; Node* NextCurrent; // Do all bitmaps while ((CurrentNode != NULL) && CarryOn) { NextCurrent = Sel.FindNext(CurrentNode); if ( (CurrentNode->IsSelected()) && (CurrentNode->GetRuntimeClass() == CC_RUNTIME_CLASS(NodeBitmap)) ) { KernelBitmap * pBitmap = ((NodeBitmap *)(CurrentNode))->GetBitmap(); BitmapInfo BMInfo; UINT32 bpp; pBitmap->ActualBitmap->GetInfo(&BMInfo); bpp=BMInfo.PixelDepth; TRACEUSER( "Alex", _T("Bitmap found %d bpp\n"),bpp); if ((bpp==32) || TRUE) { CarryOn = FALSE; // NodeBitmap *pNodeBitmap = new NodeBitmap; // if ((pNodeBitmap == NULL) || (!pNodeBitmap->SetUpPath(12,12))) // return; Spread *pSpread; DocCoord Origin; // For now, position Draw objects on 1st page of spread 1 Node *pNode = (Document::GetSelected())->GetFirstNode()->FindNext()->FindFirstChild(); while ((pNode != NULL) && (!pNode->IsKindOf(CC_RUNTIME_CLASS(Chapter)))) pNode = pNode->FindNext(); ENSURE(pNode->IsKindOf(CC_RUNTIME_CLASS(Chapter)), "Filter::GetFirstSpread(): Could not find Chapter"); Chapter *pChapter = (Chapter *) pNode; // pSpread is a child of pChapter pSpread = (Spread *) pChapter->FindFirstChild(); ENSURE(pSpread->IsKindOf(CC_RUNTIME_CLASS(Spread)), "Filter::GetFirstSpread(): Could not find Spread"); Page *pPage = (Page *) pSpread->FindFirstPageInSpread(); ENSURE(pPage->IsKindOf(CC_RUNTIME_CLASS(Page)), "BaseBitmapFilter::DoImport(): Could not find first Page"); // Use bottom left of page as origin DocRect PageRect = pPage->GetPageRect(); Origin = PageRect.lo; NodePath * pNewNode; pNewNode = new NodePath; TraceRegion TR; // if ((pNode = TR->Trace(pBitmap,((NodeBitmap *)(CurrentNode))->Parallel)) == NULL) {return;} TR.UseBitmap(pBitmap); TR.UsePath(&(pNewNode->InkPath)); TR.TraceBoundary(((NodeBitmap * )CurrentNode)->Parallel[3], ((NodeBitmap * )CurrentNode)->Parallel[2], ((NodeBitmap * )CurrentNode)->Parallel[0]); // Insert the node, but don't invalidate its region if (!Op->DoInsertNewNode(pNewNode, pSpread, FALSE)) { // It didn't work - delete the sub-tree we just created, and report error. delete pNewNode; return; } // Invalidate the region Op->DoInvalidateNodeRegion(pNewNode, TRUE, FALSE); } } CurrentNode = NextCurrent; } } // if (CarryOn) BitmapEffectSILT::RunA(); return; }

BOOL TraceRegion::Trace (  INT32  InitialX, INT32  InitialY, BfxPixelOp *  thepBfxPixelOp )

Does a single boundary trace. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: Initial  coordinates and pixel contour to trace [INPUTS] None  [OUTPUTS] Returns: TRUE if succeeded else FALSE and error set Errors: Various Scope: Protected See also: - Definition at line 743 of file tracergn.cpp. { BOOL Done=FALSE; ERROR2IF((!Bitmap),FALSE,"How about giving us a bitmap first then?"); pBfxPixelOp = thepBfxPixelOp; ERROR2IF( ((!pBfxPixelOp->IsInRegion(InitialX,InitialY))), FALSE, "Initial point not in region" ); BOOL Bottom=FALSE; while (!Bottom) { Bottom=TRUE; if (pBfxPixelOp->IsInRegion(InitialX-1,InitialY-1)) { InitialY--; InitialX--; Bottom=FALSE; } if (pBfxPixelOp->IsInRegion(InitialX,InitialY-1)) { InitialY--; Bottom=FALSE; } if (pBfxPixelOp->IsInRegion(InitialX-1,InitialY)) { InitialX--; Bottom=FALSE; } } InitialDirection = 4; // West VirginBuffer = TRUE; BoundaryHead =0; BoundaryTail =0; TailDirection = -1; HeadDirection = 4; AtCusp=FALSE; TailCusp = FALSE; InitialPoint.x = InitialX<<8; InitialPoint.y = InitialY<<8; HeadPoint = FirstBufferPoint = InitialPoint; do { if (!FillBoundaryBuffer(&Done)) return (FALSE); if (!VirginBuffer) { if (!ProcessBoundaryBuffer(Done)) return (FALSE); } else BoundaryHead=0; } while (!Done); ERROR2IF(VirginPath, FALSE, "We've just traced a path that wasn't a path. Very odd"); ThePath->CloseSubPath(); ThePath->IsFilled = TRUE; // What lovely encapsulation & abstraction... return (TRUE); }

BOOL TraceRegion::TraceBoundary (  DocCoord  Origin, DocCoord  Point1, DocCoord  Point2 )  [protected]

Does a single boundary trace. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: 3  points describing parallelogram [INPUTS] None  [OUTPUTS] Returns: TRUE if succeeded else FALSE and error set Errors: Various Scope: Protected See also: - This function is now defunct and is used to test porpoises only Definition at line 699 of file tracergn.cpp. { BOOL Done; ERROR2IF((!Bitmap),FALSE,"How about giving us a bitmap first then?"); // First find the initial point if (!(FindInitialPoint(&Done))) return (FALSE); if (Done) return (TRUE); do { if (!FillBoundaryBuffer(&Done)) return (FALSE); if (!ProcessBoundaryBuffer(Done)) return (FALSE); } while (!Done); ThePath->CloseSubPath(); ThePath->IsFilled = TRUE; // What lovely encapsulation & abstraction... Matrix tMatrix(Div32By32(Point1.x-Origin.x,xsize<<8),Div32By32(Point2.x-Origin.x,xsize<<8), Div32By32(Point1.y-Origin.y,ysize<<8),Div32By32(Point2.y-Origin.y,ysize<<8), Origin.x,Origin.y); Trans2DMatrix Trans(tMatrix); Trans.Transform( (DocCoord*)ThePath->GetCoordArray(), ThePath->GetNumCoords() ); return (TRUE); }

BOOL TraceRegion::UseBitmap (  KernelBitmap *  pBitmap  )

Points the TraceRegion at a particular bitmap and claims the relevant size buffers. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: pBitmap  = pointer to bitmap object to use or NULL for none [INPUTS] (sets  object up) [OUTPUTS] Returns: TRUE if succeeded else FALSE and error set Errors: None Scope: Public See also: - The TraceRegion is set up with a new boundary buffer of an appropriate size. If NULL is passed in the buffers are removed. Note (surprisingly, perhaps) we don't actually ever refer to pixels within this bitmap. Only its size is used. The BfxPixelOp does all the poking around and it may be referencing a different (but same sized) bitmap elsewhere. Definition at line 538 of file tracergn.cpp. { if (BoundaryBuffer) { CCFree(BoundaryBuffer); BoundaryBuffer = NULL; } xsize=1; ysize=1; Bitmap = NULL; if (pBitmap) { INT32 MaxDimension; BitmapInfo BMInfo; pBitmap->ActualBitmap->GetInfo(&BMInfo); // Max dimension is 8 times the largest of the width and height (enough to fit a bezier // curve of maximal usefulness into half the buffer) MaxDimension = ((BMInfo.PixelWidth>BMInfo.PixelHeight)?BMInfo.PixelWidth:BMInfo.PixelHeight)*8; ERROR2IF(MaxDimension<=0, FALSE, "Bitmap info structure is dead"); BoundaryRingSize = 1; if (MaxDimension<80) MaxDimension=80; // Get next highest power of 2 & mask while (BoundaryRingSize < MaxDimension) BoundaryRingSize = BoundaryRingSize<<1; BoundaryRingMask = BoundaryRingSize -1; // Allocate memory (CCMalloc sets error) if (NULL== (BoundaryBuffer=(TraceBoundaryPoint *)CCMalloc(sizeof(TraceBoundaryPoint) * BoundaryRingSize)) ) return FALSE; // // fill the memory up with +S-NAN // for (INT32 i=0; i<BoundaryRingSize; i++) // { // INT32* p = (INT32*)&(BoundaryBuffer[i].x); // *p++ = 0xFFFFFFFF; // *p++ = 0x7FF7FFFF; // p = (INT32*)&(BoundaryBuffer[i].y); // *p++ = 0xFFFFFFFF; // *p++ = 0x7FF7FFFF; // } xsize = BMInfo.PixelWidth; ysize = BMInfo.PixelHeight; Bitmap=pBitmap; VirginBuffer = TRUE; TailDirection = -1; BoundaryHead =0; BoundaryTail =0; TailDirection = 0; HeadDirection = 0; InitialDirection = 0; AtCusp = FALSE; TailCusp = FALSE; } return (TRUE); }

BOOL TraceRegion::UsePath (  Path *  pPath  )

Specifies we should use a particular path. The path is initialised, cleared etc. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: pPath  = pointer to Path object to use or NULL for none [INPUTS] (sets  object up) [OUTPUTS] Returns: TRUE if succeeded else FALSE and error set Errors: None Scope: Public See also: - Definition at line 615 of file tracergn.cpp. { ThePath = NULL; VirginPath = TRUE; if (pPath) { // if (!pPath->Initialise()) return FALSE; if (!pPath->ClearPath()) return FALSE; ThePath = pPath; } return (TRUE); }

---

Member Data Documentation

BOOL TraceRegion::AtCusp [protected]

Definition at line 408 of file tracergn.h.

KernelBitmap* TraceRegion::Bitmap [protected]

Definition at line 386 of file tracergn.h.

TraceBoundaryPoint* TraceRegion::BoundaryBuffer [protected]

Definition at line 383 of file tracergn.h.

INT32 TraceRegion::BoundaryHead [protected]

Definition at line 399 of file tracergn.h.

INT32 TraceRegion::BoundaryRingMask [protected]

Definition at line 400 of file tracergn.h.

INT32 TraceRegion::BoundaryRingSize [protected]

Definition at line 401 of file tracergn.h.

INT32 TraceRegion::BoundaryTail [protected]

Definition at line 398 of file tracergn.h.

TraceBoundaryPoint TraceRegion::DirectionPoint[(0x7)+1][(0x7)+1][4] [protected]

Definition at line 414 of file tracergn.h.

TraceBoundaryPoint TraceRegion::Directions[(0x7)+1] [protected]

Definition at line 413 of file tracergn.h.

double TraceRegion::Error [protected]

Definition at line 403 of file tracergn.h.

TraceBoundaryPoint TraceRegion::FirstBufferPoint [protected]

Definition at line 396 of file tracergn.h.

INT32 TraceRegion::HeadDirection [protected]

Definition at line 394 of file tracergn.h.

TraceBoundaryPoint TraceRegion::HeadPoint [protected]

Definition at line 391 of file tracergn.h.

INT32 TraceRegion::InitialDirection [protected]

Definition at line 392 of file tracergn.h.

TraceBoundaryPoint TraceRegion::InitialPoint [protected]

Definition at line 390 of file tracergn.h.

INT32 TraceRegion::NumTPoints [protected]

Definition at line 419 of file tracergn.h.

BfxPixelOp* TraceRegion::pBfxPixelOp [protected]

Definition at line 384 of file tracergn.h.

double TraceRegion::PixelError [protected]

Definition at line 404 of file tracergn.h.

TraceBoundaryPoint TraceRegion::Q1[3] [protected]

Definition at line 418 of file tracergn.h.

TraceBoundaryPoint TraceRegion::Q2[2] [protected]

Definition at line 418 of file tracergn.h.

BOOL TraceRegion::TailCusp [protected]

Definition at line 409 of file tracergn.h.

INT32 TraceRegion::TailDirection [protected]

Definition at line 393 of file tracergn.h.

Path* TraceRegion::ThePath [protected]

Definition at line 411 of file tracergn.h.

INT32 TraceRegion::TPoints[10+1] [protected]

Definition at line 417 of file tracergn.h.

double TraceRegion::TValues[10+1] [protected]

Definition at line 416 of file tracergn.h.

BOOL TraceRegion::VirginBuffer [protected]

Definition at line 406 of file tracergn.h.

BOOL TraceRegion::VirginPath [protected]

Definition at line 407 of file tracergn.h.

INT32 TraceRegion::xsize [protected]

Definition at line 387 of file tracergn.h.

INT32 TraceRegion::ysize [protected]

Definition at line 388 of file tracergn.h.

---

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

• Kernel/tracergn.h (r1785/r1282)
• Kernel/tracergn.cpp (r1785/r1282)

---