PathStroker Class Reference

Abstract Base class Converts a Trapezoid (See ProcessPathToTrapezoids, pathtrap.h) stroke definition into an output path. More...

#include <pathstrk.h>

Inheritance diagram for PathStroker:

List of all members.

Public Member Functions
	PathStroker ()
	Default Constructor - DO NOT USE THIS FORM!
	PathStroker (ValueFunction *WidthFunction, INT32 LineWidth, LineCapType CapType)
	Constructor.
virtual	~PathStroker ()
virtual BOOL	StrokePath (TrapsList *pTraps, Path *pOutput)
	"Strokes" a path according to the "style" set in construction.
virtual BOOL	StrokeSmoothPath (TrapsList *pTraps, Path *pOutput)
	"Strokes" a path as above, but SMOOTHS its forwards and backwards paths to reduce points
Protected Member Functions
BOOL	MapLineForwards (TrapEdgeList *Traps, Path *pOutput)
	Maps points along the trapezoids, generating an outline path for the "forwards" side of the stroke.
void	RecursiveMapLineForwards (TrapEdge *pEdge1, DocCoord &Point1, TrapEdge *pEdge2, DocCoord &Point2, Path *pOutput)
	Recursive method which maps points within a given trapezoid by recursively "flattening" the curve between the two trapezoid edges.
BOOL	MapLineBackwards (TrapEdgeList *Traps, Path *pOutput)
	Maps points along the trapezoids, generating an outline path for the "Backwards" side of the stroke.
void	RecursiveMapLineBackwards (TrapEdge *pEdge1, DocCoord &Point1, TrapEdge *pEdge2, DocCoord &Point2, Path *pOutput)
	Recursive method which maps points within a given trapezoid by recursively "flattening" the curve between the two trapezoid edges.
BOOL	MapLineCap (LineCapType CapType, TrapEdge *pEdge, BOOL IsStartCap, Path *pOutput)
	Maps a line cap onto the path by appending appropriate extra path elements to the end of it.
Protected Attributes
ValueFunction *	pWidthFunction
INT32	MaxWidth
LineCapType	CapStyle
INT32	RecursionDepth
Private Member Functions
	CC_DECLARE_MEMDUMP (PathStroker)

---

Detailed Description

Abstract Base class Converts a Trapezoid (See ProcessPathToTrapezoids, pathtrap.h) stroke definition into an output path.

Author:

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

Date:

30/12/96

The base class strokes a path with variable-width

Definition at line 133 of file pathstrk.h.

---

Constructor & Destructor Documentation

PathStroker::PathStroker (   )

Default Constructor - DO NOT USE THIS FORM! Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/12/96 Definition at line 155 of file pathstrk.cpp. { ERROR3("Please don't use this PathStroker constructor again"); }

PathStroker::PathStroker (  ValueFunction *  WidthFunction, INT32  LineWidth, LineCapType  CapType )

Constructor. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/12/96 Parameters: WidthFunction  - NULL, or a pointer to a width function for the stroke [INPUTS] LineWidth - The maximum width, in millipoints, of the stroke CapType - The cap style (LineCapButt, LineCapRound, or LineCapSquare) Definition at line 176 of file pathstrk.cpp. { ERROR3IF(WidthFunction == NULL, "Illegal NULL param"); pWidthFunction = WidthFunction; MaxWidth = LineWidth / 2; // MaxWidth is the RADIUS of the "brush", not diameter CapStyle = CapType; RecursionDepth = 0; // Reset recursion depth counter to 0 }

virtual PathStroker::~PathStroker (   )  [inline, virtual]

Definition at line 140 of file pathstrk.h. { }

---

Member Function Documentation

PathStroker::CC_DECLARE_MEMDUMP (  PathStroker   )  [private]

BOOL PathStroker::MapLineBackwards (  TrapEdgeList *  pTraps, Path *  pOutput )  [protected]

Maps points along the trapezoids, generating an outline path for the "Backwards" side of the stroke. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/12/96 Parameters: pTraps  - A pointer to a trapezoid-descriptiuon of the path being stroked [INPUTS] (May not be NULL) pOutput  - A pointer to a path in which the output will be generated [OUTPUTS] (May not be NULL) Returns: FALSE if it fails. (No error will be set at this level) Notes: Expects the first point on this edge to have been written (as a LINETO) to the output path before this function was called. Definition at line 490 of file pathstrk.cpp. { TrapEdge *pEdge = NULL; TrapEdge *pLastEdge = NULL; INT32 Width; DocCoord LastPoint; DocCoord NewPoint; for (INT32 Index = pTraps->GetNumEdges() - 1; Index >= 0; Index--) { pLastEdge = pEdge; pEdge = pTraps->GetTrapEdge(Index); Width = (INT32) (MaxWidth * pWidthFunction->GetValue(pEdge->Position)); NewPoint.x = pEdge->Centre.x - (INT32) (pEdge->Normal.x * Width); NewPoint.y = pEdge->Centre.y - (INT32) (pEdge->Normal.y * Width); // The first point has already been added by the caller. The first iteration // of this loop is just to calculate the first "LastPoint" value. if (pLastEdge != NULL) { RecursionDepth = 0; // Reset recursion depth counter to 0 RecursiveMapLineBackwards(pLastEdge, LastPoint, pEdge, NewPoint, pOutput); } LastPoint = NewPoint; } return(TRUE); }

BOOL PathStroker::MapLineCap (  LineCapType  CapType, TrapEdge *  pEdge, BOOL  IsStartCap, Path *  pOutput )  [protected]

Maps a line cap onto the path by appending appropriate extra path elements to the end of it. Parameters: CapType  - The cap style (LineCapButt, LineCapRound, or LineCapSquare) [INPUTS] pEdge - A pointer to the end trapezoid for this end of the stroke (May not be NULL) IsStartCap - TRUE if this is the start cap, FALSE if it's the end cap. This lets us get the cap orientation right pOutput  - A pointer to a path in which the output will be generated [OUTPUTS] (May not be NULL) Returns: FALSE if it fails. (No error will be set at this level) Notes: This maps points from the end of the backward outline to the start of the forward outline. It is expected that the StartPoint of the cap (the end point of the backward outline) has been written to the output immediately beforehand. e.g. for the "leftmost" round cap, we have a situation like this: EndPoint +----> forward outline / | (MidPoint) + + ----centreline (pEdge->Centre) | \ StartPoint +<---- backward outline Definition at line 662 of file pathstrk.cpp. { ERROR3IF(pEdge == NULL || pOutput == NULL, "Illegal NULL params"); // Work out dx,dy. These are tangential (dx) and perpendicular (dy) to the centreline // Orientation of the End cap is in the opposite direction to that of the start cap const INT32 Width = (INT32) (MaxWidth * pWidthFunction->GetValue(pEdge->Position)); const INT32 Orientation = (IsStartCap) ? 1 : -1; const INT32 dx = Orientation * (INT32) (pEdge->Normal.x * Width); const INT32 dy = Orientation * (INT32) (pEdge->Normal.y * Width); // Calculate the point at the "end" of the cap outline DocCoord EndPoint(pEdge->Centre.x + dx, pEdge->Centre.y + dy); // Last point on cap switch (CapType) { case LineCapButt: // Simply join the 2 outlines with a straight line pOutput->AddLineTo(EndPoint); break; case LineCapRound: { // We are adding a semicircular arc onto the end of the stroke. This is done // as two quarter circles: from the end of the outline to the extended centreline, // then from the centreline to the start of the opposite outline. DocCoord StartPoint(pEdge->Centre.x - dx, pEdge->Centre.y - dy); // 1st point on cap DocCoord MidPoint(pEdge->Centre.x - dy, pEdge->Centre.y + dx); // midpoint on the arc // Determine the distance the control points should be away from the endpoints // to get a reasonable circular arc out of the bezier curve. const INT32 CPdx = (INT32) ( ((double)dx) * 0.552 ); const INT32 CPdy = (INT32) ( ((double)dy) * 0.552 ); // Draw an arc from the backward outline of the stroke to the centreline DocCoord Control1(StartPoint.x - CPdy, StartPoint.y + CPdx); DocCoord Control2(MidPoint.x - CPdx, MidPoint.y - CPdy); pOutput->AddCurveTo(Control1, Control2, MidPoint); // Draw an arc from the centreline to the start of the forward stroke DocCoord Control3(MidPoint.x + CPdx, MidPoint.y + CPdy); DocCoord Control4(EndPoint.x - CPdy, EndPoint.y + CPdx); pOutput->AddCurveTo(Control3, Control4, EndPoint); } break; case LineCapSquare: { // Add 3 lines making up a half square centred on the centreline endpoint DocCoord StartPoint(pEdge->Centre.x - dx, pEdge->Centre.y - dy); // 1st point on cap pOutput->AddLineTo(DocCoord(StartPoint.x - dy, StartPoint.y + dx)); pOutput->AddLineTo(DocCoord(EndPoint.x - dy, EndPoint.y + dx)); pOutput->AddLineTo(EndPoint); } break; default: ERROR3("Unknown line cap style"); break; } return(TRUE); }

BOOL PathStroker::MapLineForwards (  TrapEdgeList *  pTraps, Path *  pOutput )  [protected]

Maps points along the trapezoids, generating an outline path for the "forwards" side of the stroke. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/12/96 Parameters: pTraps  - A pointer to a trapezoid-descriptiuon of the path being stroked [INPUTS] (May not be NULL) pOutput  - A pointer to a path in which the output will be generated [OUTPUTS] (May not be NULL) Returns: FALSE if it fails. (No error will be set at this level) Notes: Expects the first point on this edge to have been written (as a MOVETO) to the output path before this function was called. Definition at line 334 of file pathstrk.cpp. { TrapEdge *pEdge = NULL; TrapEdge *pLastEdge = NULL; INT32 Width; DocCoord LastPoint; DocCoord NewPoint; for (UINT32 Index = 0; Index < pTraps->GetNumEdges(); Index++) { pLastEdge = pEdge; pEdge = pTraps->GetTrapEdge(Index); Width = (INT32) (MaxWidth * pWidthFunction->GetValue(pEdge->Position)); NewPoint.x = pEdge->Centre.x + (INT32) (pEdge->Normal.x * Width); NewPoint.y = pEdge->Centre.y + (INT32) (pEdge->Normal.y * Width); // The first point has already been added by the caller. The first iteration // of this loop is just to calculate the first "LastPoint" value. if (pLastEdge != NULL) { RecursionDepth = 0; // Reset recursion depth counter to 0 RecursiveMapLineForwards(pLastEdge, LastPoint, pEdge, NewPoint, pOutput); } LastPoint = NewPoint; } return(TRUE); }

void PathStroker::RecursiveMapLineBackwards (  TrapEdge *  pEdge1, DocCoord &  Point1, TrapEdge *  pEdge2, DocCoord &  Point2, Path *  pOutput )  [protected]

Recursive method which maps points within a given trapezoid by recursively "flattening" the curve between the two trapezoid edges. Parameters: pEdge1,Point1  - The source TrapEdge and coordinate of the first point [INPUTS] (which must have already been added to the output path) pEdge2, Point2 - The source TrapEdge and coordinate of the second point (which must NOT have been added to the output path) Parameters: pOutput  - A pointer to a path in which the output will be generated [OUTPUTS] (May not be NULL) It inserts extra mapped points between the two original points passed in to it, until the flatness criteria is met. Definition at line 548 of file pathstrk.cpp. { ERROR3IF(pEdge1 == NULL || pEdge2 == NULL || pOutput == NULL, "Illegal NULL params"); // --- Calculate the midpoint of the curve we are mapping // Calculate the midpoint "position" value TrapEdge MidEdge; MidEdge.Position = (pEdge1->Position + pEdge2->Position) / 2.0; // Calculate the midpoint normal vector MidEdge.Normal.x = (pEdge1->Normal.x + pEdge2->Normal.x) / 2.0; MidEdge.Normal.y = (pEdge1->Normal.y + pEdge2->Normal.y) / 2.0; // (Note in the 'backwards' case the "PrevTrap" flag is in pEdge1) MidEdge.PrevTrapJoin = pEdge1->PrevTrapJoin; if (MidEdge.PrevTrapJoin == TrapJoin_MitredOrBevelled) { // Work out if this on the inside or outside of the join double Val = (pEdge1->Normal.x * pEdge2->Normal.y) - (pEdge1->Normal.y * pEdge2->Normal.x); if (Val > 0.0) { // We are doing the inside of a join // If this is the special mitre join edge then just skip it // This removes the artifacts from the inside of mitre joins if (fabs(pEdge2->Normal.GetLength() - 1.0) > 0.0001) return; MidEdge.Normal.Normalise(); } } else { MidEdge.Normal.Normalise(); } // Calculate the (approximate) centreline midpoint MidEdge.Centre.x = (pEdge1->Centre.x / 2) + (pEdge2->Centre.x / 2); MidEdge.Centre.y = (pEdge1->Centre.y / 2) + (pEdge2->Centre.y / 2); // Now, calculate the mapped midpoint const INT32 Width = (INT32) (MaxWidth * pWidthFunction->GetValue(MidEdge.Position)); DocCoord MidPoint(MidEdge.Centre); MidPoint.x -= (INT32) (MidEdge.Normal.x * Width); MidPoint.y -= (INT32) (MidEdge.Normal.y * Width); // --- Calculate the midpoint of the straight line segment DocCoord ApproximateMidPoint(Point1.x/2 + Point2.x/2, Point1.y/2 + Point2.y/2); // --- Calculate the error in the midpoint position const double dx = MidPoint.x - ApproximateMidPoint.x; const double dy = MidPoint.y - ApproximateMidPoint.y; const double Dist2 = dx * dx + dy * dy; RecursionDepth++; // --- If the straight-line approximation is not close enough to the curve, recurse, // Don't bother to recurse for mitred or bevelled joins as they should be straight lines if ( MidEdge.PrevTrapJoin!=TrapJoin_MitredOrBevelled && (Dist2>Flatness2 || RecursionDepth<=pWidthFunction->GetMinimumRecursionDepth()) && RecursionDepth<=MaxRecursionDepth ) { // Recurse on the left and right sides of the new midpoint RecursiveMapLineBackwards(pEdge1, Point1, &MidEdge, MidPoint, pOutput); RecursiveMapLineBackwards(&MidEdge, MidPoint, pEdge2, Point2, pOutput); } else { pOutput->AddLineTo(Point2); } RecursionDepth--; }

void PathStroker::RecursiveMapLineForwards (  TrapEdge *  pEdge1, DocCoord &  Point1, TrapEdge *  pEdge2, DocCoord &  Point2, Path *  pOutput )  [protected]

Recursive method which maps points within a given trapezoid by recursively "flattening" the curve between the two trapezoid edges. Parameters: pEdge1,Point1  - The source TrapEdge and coordinate of the first point [INPUTS] (which must have already been added to the output path) pEdge2, Point2 - The source TrapEdge and coordinate of the second point (which must NOT have been added to the output path) Parameters: pOutput  - A pointer to a path in which the output will be generated [OUTPUTS] (May not be NULL) It inserts extra mapped points between the two original points passed in to it, until the flatness criteria is met. Definition at line 392 of file pathstrk.cpp. { ERROR3IF(pEdge1 == NULL || pEdge2 == NULL || pOutput == NULL, "Illegal NULL params"); // --- Calculate the midpoint of the curve we are mapping // Calculate the midpoint "position" value TrapEdge MidEdge; MidEdge.Position = (pEdge1->Position + pEdge2->Position) / 2.0; // Calculate the midpoint normal vector MidEdge.Normal.x = (pEdge1->Normal.x + pEdge2->Normal.x) / 2.0; MidEdge.Normal.y = (pEdge1->Normal.y + pEdge2->Normal.y) / 2.0; MidEdge.PrevTrapJoin = pEdge2->PrevTrapJoin; if (MidEdge.PrevTrapJoin == TrapJoin_MitredOrBevelled) { // Work out if this on the inside or outside of the join double Val = (pEdge1->Normal.x * pEdge2->Normal.y) - (pEdge1->Normal.y * pEdge2->Normal.x); if (Val > 0.0) { // We are doing the inside of a join // If this is the special mitre join edge then just skip it // This removes the artifacts from the inside of mitre joins if (fabs(pEdge2->Normal.GetLength() - 1.0) > 0.0001) return; MidEdge.Normal.Normalise(); } } else { MidEdge.Normal.Normalise(); } // Calculate the (approximate) centreline midpoint MidEdge.Centre.x = (pEdge1->Centre.x / 2) + (pEdge2->Centre.x / 2); MidEdge.Centre.y = (pEdge1->Centre.y / 2) + (pEdge2->Centre.y / 2); // Now, calculate the mapped midpoint const INT32 Width = (INT32) (MaxWidth * pWidthFunction->GetValue(MidEdge.Position)); DocCoord MidPoint(MidEdge.Centre); MidPoint.x += (INT32) (MidEdge.Normal.x * Width); MidPoint.y += (INT32) (MidEdge.Normal.y * Width); // --- Calculate the midpoint of the straight line segment DocCoord ApproximateMidPoint(Point1.x/2 + Point2.x/2, Point1.y/2 + Point2.y/2); // --- Calculate the error in the midpoint position const double dx = MidPoint.x - ApproximateMidPoint.x; const double dy = MidPoint.y - ApproximateMidPoint.y; const double Dist2 = dx * dx + dy * dy; RecursionDepth++; // --- If the straight-line approximation is not close enough to the curve, recurse, // Don't bother to recurse for mitred or bevelled joins as they should be straight lines if ( MidEdge.PrevTrapJoin!=TrapJoin_MitredOrBevelled && (Dist2>Flatness2 || RecursionDepth<=pWidthFunction->GetMinimumRecursionDepth()) && RecursionDepth<=MaxRecursionDepth ) { // Recurse on the left and right sides of the new midpoint RecursiveMapLineForwards(pEdge1, Point1, &MidEdge, MidPoint, pOutput); RecursiveMapLineForwards(&MidEdge, MidPoint, pEdge2, Point2, pOutput); } else { pOutput->AddLineTo(Point2); } RecursionDepth--; }

BOOL PathStroker::StrokePath (  TrapsList *  pTraps, Path *  pOutput )  [virtual]

"Strokes" a path according to the "style" set in construction. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/12/96 Parameters: pTraps  - A trapezoidal description of the path to be stroked [INPUTS] (May not be NULL) pOutput  - This path is filled in with a "filled outline" of the stroke [OUTPUTS] It's IsFilled flag will be TRUE, IsStroked will be FALSE. Returns: FALSE if it fails. (No error will be set at this level) This is the second stage in the stroking process (the first stage being breaking a path down into a trapezoidal description). Stroking is achieved by mapping the intersections of trapezoid edges with the width function, and then recursively flattening the mapped curve between those points until required "flatness" is achieved. The stroke outline is built up of 5 main components: A MOVETO point 1 1+---------------+2 A mapped outline between 1 & 2 ("FORWARDS") | | A line cap between 2 & 3 4+---------------+3 A mapped outline between 3 & 4 ("BACKWARDS") A line cap between 4 & 1 The distance between points on the forwards & backwards outlines (the stroke width) is governed by the LineWidth and WidthFunction passed to the constructor. See also: PathStroker::MapLineForwards; PathStroker::MapLineBackwards; PathStroker::MapLineCap Reimplemented in PathStrokerVector. Definition at line 231 of file pathstrk.cpp. { ERROR3IF(pTraps == NULL || pOutput == NULL, "Illegal NULL params"); // For each trapezoid list generated, add a subpath to the pOutput path for (UINT32 Index = 0; Index < pTraps->GetNumTraps(); Index++) { TrapEdgeList *pTrapEdges = pTraps->GetTrapEdgeList(Index); if (pTrapEdges->GetNumEdges() < 2) { ERROR3("No map traps when stroking! Subpath stripped\n"); continue; } #if FALSE // Useful bit of code to dump out the TrapEdges { for (UINT32 i = 0; i < pTrapEdges->GetNumEdges(); i++) { TrapEdge *pEdge = pTrapEdges->GetTrapEdge(i); TRACE(_T("Edge % 5d Position = %g Type = %s Centre = (%d, %d) Normal = (%g, %g)\n"), i, pEdge->Position, (pEdge->PrevTrapJoin == TrapJoin_None ? _T("N") : pEdge->PrevTrapJoin == TrapJoin_Round ? _T("R") : pEdge->PrevTrapJoin == TrapJoin_MitredOrBevelled ? _T("M") : _T("U")), pEdge->Centre.x, pEdge->Centre.y, pEdge->Normal.x, pEdge->Normal.y); } } #endif // Check if this subpath is closed (ends in a join). If so, we must remove the line caps! LineCapType CapType = CapStyle; TrapEdge *pEdge = pTrapEdges->GetLastTrapEdge(); if (pEdge->PrevTrapJoin != TrapJoin_None) CapType = LineCapButt; // Start a new sub-path with a MoveTo to the first point pEdge = pTrapEdges->GetTrapEdge(0); INT32 Width = (INT32) (MaxWidth * pWidthFunction->GetValue(pEdge->Position)); INT32 dx = (INT32) (pEdge->Normal.x * Width); INT32 dy = (INT32) (pEdge->Normal.y * Width); DocCoord StartPoint(pEdge->Centre.x + dx, pEdge->Centre.y + dy); pOutput->AddMoveTo(StartPoint); // Map the "forwards" outline MapLineForwards(pTrapEdges, pOutput); // Add the line cap at the end of the line MapLineCap(CapType, pTrapEdges->GetLastTrapEdge(), FALSE, pOutput); // Map the "backwards" outline MapLineBackwards(pTrapEdges, pOutput); // Add the line cap at the end of the line, and we should meet back at the start! MapLineCap(CapType, pTrapEdges->GetTrapEdge(0), TRUE, pOutput); // And set the PT_CLOSEFIGURE flag on the last point, just to be safe INT32 indCoord = pOutput->GetNumCoords() - 1; PathVerb *pVerbs = pOutput->GetVerbArray(); pVerbs[indCoord] |= PT_CLOSEFIGURE; } pOutput->IsFilled = TRUE; pOutput->IsStroked = FALSE; #ifdef _DEBUG if(pTraps && pTraps->GetNumTraps() > 0 && pOutput) { TRACEUSER( "Matt", _T("Path stroked: %ld subpaths, (1st is %ld Traps) -> %ld Coords\n"), pTraps->GetNumTraps(), pTraps->GetTrapEdgeList(0)->GetNumEdges(), pOutput->GetNumCoords()); } #endif return(TRUE); }

BOOL PathStroker::StrokeSmoothPath (  TrapsList *  pTraps, Path *  pOutput )  [virtual]

"Strokes" a path as above, but SMOOTHS its forwards and backwards paths to reduce points Author: Priestley (Xara Group Ltd) <camelotdev@xara.com> - totally ripped from Jason above Date: 18/11/2000 Parameters: pTraps  - A trapezoidal description of the path to be stroked (May not be NULL) [INPUTS] pOutput  - This path is filled in with a "filled outline" of the stroke [OUTPUTS] It's IsFilled flag will be TRUE, IsStroked will be FALSE. Returns: FALSE if it fails. (No error will be set at this level) Definition at line 749 of file pathstrk.cpp. { ERROR3IF(pTraps == NULL || pOutput == NULL, "Illegal NULL params"); // For each trapezoid list generated, add a subpath to the pOutput path for (UINT32 Index = 0; Index < pTraps->GetNumTraps(); Index++) { TrapEdgeList *pTrapEdges = pTraps->GetTrapEdgeList(Index); if (pTrapEdges->GetNumEdges() < 2) { ERROR3("No map traps when stroking! Subpath stripped\n"); continue; } // Check if this subpath is closed (ends in a join). If so, we must remove the line caps! LineCapType CapType = CapStyle; TrapEdge *pEdge = pTrapEdges->GetLastTrapEdge(); if (pEdge->PrevTrapJoin != TrapJoin_None) CapType = LineCapButt; // Start a new sub-path with a MoveTo to the first point pEdge = pTrapEdges->GetTrapEdge(0); INT32 Width = (INT32) (MaxWidth * pWidthFunction->GetValue(pEdge->Position)); INT32 dx = (INT32) (pEdge->Normal.x * Width); INT32 dy = (INT32) (pEdge->Normal.y * Width); DocCoord StartPoint(pEdge->Centre.x + dx, pEdge->Centre.y + dy); pOutput->AddMoveTo(StartPoint); INT32 first = 0; INT32 last = -1; // Map the "forwards" outline MapLineForwards(pTrapEdges, pOutput); pOutput->SmoothSection(first, &last, 1.25 * Flatness/*2500*/, 0); // Add the line cap at the end of the line (if the height at this point of the value function is greater // than some threshold above zero). double height = pWidthFunction->GetValue(1); if (height > 0.05) { MapLineCap(CapType, pTrapEdges->GetLastTrapEdge(), FALSE, pOutput); } // Map the "backwards" outline first = pOutput->GetNumCoords() - 1; MapLineBackwards(pTrapEdges, pOutput); last = -1l; pOutput->SmoothSection(first, &last, 1.25 * Flatness/*2500*/, 0); INT32 indCoord; PathVerb *pVerbs = pOutput->GetVerbArray(); // Check all but the last verb to see if the path has been closed - if so, UNclose it!!! for( indCoord = 0; indCoord < pOutput->GetNumCoords() - 2; indCoord++ ) { pVerbs[indCoord] &= ~PT_CLOSEFIGURE; } indCoord = pOutput->GetNumCoords() - 1; // Check to see if the last verb in the array has a CLOSEFIGURE type - if so then don't close it again!!! if (!(pVerbs[indCoord] & PT_CLOSEFIGURE)) { // Add the line cap at the end of the line, and we should meet back at the start! MapLineCap(CapType, pTrapEdges->GetTrapEdge(0), TRUE, pOutput); // And set the PT_CLOSEFIGURE flag on the last point, just to be safe indCoord = pOutput->GetNumCoords() - 1; PathVerb *pVerbs = pOutput->GetVerbArray(); pVerbs[indCoord] |= PT_CLOSEFIGURE; } } pOutput->IsFilled = TRUE; pOutput->IsStroked = FALSE; TRACEUSER( "Matt", _T("Path SMOOTHLY stroked: %ld subpaths, (1st is %ld Traps) -> %ld Coords\n"), pTraps->GetNumTraps(), pTraps->GetTrapEdgeList(0)->GetNumEdges(), pOutput->GetNumCoords()); return(TRUE); }

---

Member Data Documentation

LineCapType PathStroker::CapStyle [protected]

Definition at line 167 of file pathstrk.h.

INT32 PathStroker::MaxWidth [protected]

Definition at line 166 of file pathstrk.h.

ValueFunction* PathStroker::pWidthFunction [protected]

Definition at line 165 of file pathstrk.h.

INT32 PathStroker::RecursionDepth [protected]

Definition at line 168 of file pathstrk.h.

---

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

• Kernel/pathstrk.h (r1785/r1282)
• Kernel/pathstrk.cpp (r1785/r1516)

---