PathEditor,

PEAlgebra USING [ClosestPointOnLineSegment, DistanceSquared],

PEBezier USING [Bezier, BezierToSegment, SegmentToBezier, SplitBezier],

PEConstraints USING [Constrain, ContinuousAt],

PEDisplay USING [DrawControlPoints, DrawSegment, DrawSegmentAndVertices, DrawVertex, DrawVertices],

PEFileOps USING [ReadTrajectoryFile, WriteTrajectoryFile],

PEHitTest USING [SegmentHitTest, TrajectoryHitTest, VertexHitTest],

PERefresh USING [CreateRefreshProcess, DestroyRefreshProcess, DisableSegmentRefresh, DisableTrajectoryRefresh, EnableSegmentRefresh, NewRefreshData, RefreshData, RequestRefresh],

PETrajectoryOps USING [FollowingVertex, ForAllSegments, ForAllTrajectories, ForAllVertices, FreeSegmentList, FreeTrajectoryList, InsertSegment, InsertTrajectory, InsertVertex, IsAKnot, IsAControlPoint, IsFirstSegment, IsLastSegment, LastSegmentNode, LastTrajectoryNode, LastVertexNode, PrecedingVertex, RemoveSegment, RemoveTrajectory, RemoveVertex, SegmentProc, SwapSegments, TrajectoryProc, VertexListAppend, VertexListLength, VertexListNthElement, VertexProc],

PETypes,

PEViewer USING [BuildViewer, ButtonProc, DrawInViewer, DrawProc, QuitProc, RedrawProc],

Rope USING [ROPE],

ViewerClasses USING [Viewer];

IMPORTS PEAlgebra, PEBezier, PEConstraints, PEDisplay, PEFileOps, PEHitTest, PERefresh, PETrajectoryOps, PEViewer

EXPORTS PathEditor =

This routine creates a viewer for the Path Editor. The viewer is created with the supplied name and menu labels. Client supplied routines are called to process button hits and when the entire viewer must be redrawn for some reason. This routine must be called before any others. It returns a pointer to Path Editor data which must be passed in all subsequent calls from the client.

handle: Handle← NEW[PathEditorRec];

handle.buttonProc ← buttonProc;

handle.redrawProc ← redrawProc;

handle.pathViewer ← BuildViewer[

handle.refreshData ← CreateRefreshProcess[handle.pathViewer, handle.redrawProc];

pathData ← handle;

};

This routine handles re-draw requests from the PEViewer package.

handle: Handle ← NARROW[clientData];

Redraw[pathData: clientData, erase: TRUE];

};

This routine cleans up upon program termination.

handle: Handle ← NARROW[clientData];

DestroyRefreshProcess[handle.refreshData];

Break all the back links.

FreeTrajectoryList[handle.trajectoryList];

};

This routine handles menu and mouse button hits in the Path Editor viewer.

handle: Handle ← NARROW[clientData];

IF handle.buttonProc # NIL THEN handle.buttonProc[event: event, x: x, y: y];

};

This routine calls the client supplied routine with the Path Editor viewer's context so it can draw in the Path Editor's viewer.

handle: Handle ← NARROW[pathData];

DrawInViewer[handle.pathViewer, drawProc];

};

This routine redraws the entire image. The viewer may be erased first, if desired.

handle: Handle ← NARROW[pathData];

RequestRefresh[handle.refreshData, erase];

};

This routine flushes the contents of the image, so the client can start over.

handle: Handle ← NARROW[pathData];

DoDrawTrajectory: TrajectoryProc = {

ForAllTrajectories[handle.trajectoryList, DoDrawTrajectory];

FreeTrajectoryList[handle.trajectoryList];

handle.trajectoryList ← NIL;

NewTrajectory[pathData];

InvalidateHitCache[handle];

};

This routine creates a new trajectory and makes it the active trajectory. The trajectory is not actually created until an operation is performed which gives it some contents (e.g. AddKnotToFront). That is this routine indicates the intent to start a new trajectory.

handle: Handle ← NARROW[pathData];

handle.newTrajectory ← TRUE;

DoSetActiveTrajectory[handle, NIL];

};

This routine makes the trajectory which is closest to the specified point the active trajectory. A trajectory must be made active before its contents can be edited. When a trajectory is first set active, the active vertex or active segment are unset (i.e. NIL). The specified position must be "close to" (i.e. whithin a certain minimum distance of) a trajectory in order for the operation to be carried out. This routine returns an indication of whether the active trajectory was in fact set and the position of the point on the active trajectory which is closest to the specified point.

handle: Handle ← NARROW[pathData];

hitTrajectory: TrajectoryNode;

[hitTrajectory, hitPoint] ← TrajectoryHitTest[handle.trajectoryList, where];

DoSetActiveTrajectory[handle, hitTrajectory];

activeTrajectorySet ← hitTrajectory # NIL;

};

This routine sets the active trajectory to be the specified trajectory node. This routine also unsets the active vertex and active segment (i.e. sets them to NIL).

DrawAsBackground: SegmentProc = {

DrawAsForeground: SegmentProc = {

DoSetActiveVertex[handle, NIL, NIL];

IF handle.activeTrajectory # activeTrajectory THEN {

};

This routine determines if the active trajectory currently has any contents.

handle: Handle ← NARROW[pathData];

RETURN [handle.activeTrajectory = NIL OR handle.activeTrajectory.first.segments = NIL];

};

This routine deletes the active trajectory.

handle: Handle ← NARROW[pathData];

UnDraw: SegmentProc = {

DisableTrajectoryRefresh[handle.activeTrajectory.first];

ForAllSegments[handle.activeTrajectory.first.segments, UnDraw];

[handle.trajectoryList,] ← RemoveTrajectory[handle.trajectoryList, handle.activeTrajectory];

DoSetActiveTrajectory[handle, NIL];

};

This routine enumerates all the segments in the all the trajectories. Client specified routines are called for each line segment, and bezier curve in each trajectory. The moveToProc is called for the first point (FP) of each trajectory.

handle: Handle ← NARROW[pathData];

EnumerateTrajectory: TrajectoryProc = {

saveActiveTrajectory: TrajectoryNode ← handle.activeTrajectory;

ForAllTrajectories[handle.trajectoryList, EnumerateTrajectory];

handle.activeTrajectory ← saveActiveTrajectory;

};

This routine extends the active trajectory by adding a knot (and thus a segment) to its front end.

handle: Handle ← NARROW[pathData];

knot: Vertex ← NEW[VertexRec ← [point: position]];

newSegment: Segment ← NEW[SegmentRec ← [type: moveTo]];

newTrajectory: Trajectory;

IF handle.activeTrajectory = NIL AND handle.newTrajectory THEN {

IF handle.activeTrajectory = NIL THEN RETURN;

IF handle.activeTrajectory.first.segments # NIL THEN {

[newSegment.vertices,] ← InsertVertex[newSegment.vertices, knot, NIL];

[handle.activeTrajectory.first.segments,] ← InsertSegment[handle.activeTrajectory.first.segments, newSegment, NIL];

Constrain[pathViewer: handle.pathViewer, vertex: handle.activeTrajectory.first.segments.first.vertices, segment: handle.activeTrajectory.first.segments, newPosition: position];

DoSetActiveVertex[handle, handle.activeTrajectory.first.segments.first.vertices, handle.activeTrajectory.first.segments];

InvalidateHitCache[handle];

};

This routine adds a cubic curve segment to the front of the active trajectory. The cubic is defined by the bezier vertices: knot, cp2, cp1, FP, where FP is the first knot in the original path.

handle: Handle ← NARROW[pathData];

knotVertex: Vertex ← NEW[VertexRec ← [point: knot]];

cp1Vertex: Vertex ← NEW[VertexRec ← [point: cp1]];

cp2Vertex: Vertex ← NEW[VertexRec ← [point: cp2]];

newSegment: Segment ← NEW[SegmentRec ← [type: moveTo]];

IF handle.activeTrajectory = NIL THEN RETURN;

IF handle.activeTrajectory.first.segments # NIL THEN {

DoSetActiveVertex[handle, NIL, NIL];

InvalidateHitCache[handle];

};

This routine extends the active trajectory by adding a knot (and thus a segment) to its rear end.

handle: Handle ← NARROW[pathData];

knot: Vertex ← NEW[VertexRec ← [point: position]];

newSegment: Segment ← NEW[SegmentRec];

newSegmentNode: SegmentNode;

IF handle.activeTrajectory = NIL OR handle.activeTrajectory.first.segments = NIL THEN AddKnotToFront[pathData, position]

ELSE {

};

This routine adds a cubic curve segment to the rear (end) of the active trajectory. The cubic is defined by the bezier vertices: LP, cp1, cp2, knot, where LP is the last knot in the original path.

handle: Handle ← NARROW[pathData];

knotVertex: Vertex ← NEW[VertexRec ← [point: knot]];

cp1Vertex: Vertex ← NEW[VertexRec ← [point: cp1]];

cp2Vertex: Vertex ← NEW[VertexRec ← [point: cp2]];

newSegment: Segment ← NEW[SegmentRec ← [type: moveTo]];

newSegmentNode: SegmentNode;

IF handle.activeTrajectory = NIL THEN RETURN;

IF handle.activeTrajectory.first.segments # NIL THEN {

DoSetActiveVertex[handle, NIL, NIL];

InvalidateHitCache[handle];

};

This routine splits the segment in the active trajectory which is nearest the specified position at the point which is closest to the specified position. The specified position must be "close to" (i.e. whithin a certain minimum distance of) a segment of the active trajectory in order for the operation to be carried out. This routine also updates the display to reflect the two new segments and saves appropriate information for reversing the action. A call to this routine may be followed by zero or more calls to AdjustSegmentSplit. Finally, ConfirmSegmentSplit must be called to clean up the display.

handle: Handle ← NARROW[pathData];

segment: SegmentNode;

point: Point;

t: REAL;

originalBezier: Bezier;

b1, b2: Bezier;

IF handle.activeTrajectory = NIL THEN RETURN;

[segment, point, t] ← SegmentHitTest[handle.activeTrajectory.first.segments, where];

originalBezier ← SegmentToBezier[segment.first];

[b1, b2] ← SplitBezier[originalBezier, t];

[handle.splitReplacements,] ← InsertSegment[NIL, BezierToSegment[b1], NIL];

handle.splitReplacements.first.fp ← segment.first.fp;

[handle.splitReplacements,] ← InsertSegment[handle.splitReplacements, BezierToSegment[b2], handle.splitReplacements];

handle.splitReplacements.rest.first.fp ← VertexListNthElement[handle.splitReplacements.first.vertices, -1];

handle.splitReplacements.rest.first.fp.fixed ← TRUE;

DisableSegmentRefresh[handle.splitReplacements.first];

DisableSegmentRefresh[handle.splitReplacements.rest.first];

[handle.activeTrajectory.first.segments, handle.splitSegment] ← SwapSegments[handle.activeTrajectory.first.segments, handle.splitReplacements, segment];

DrawControlPoints[pathViewer: handle.pathViewer, segment: segment.first, undo: TRUE];

DrawVertices[pathViewer: handle.pathViewer, segment: handle.splitReplacements.first];

DrawControlPoints[pathViewer: handle.pathViewer, segment: handle.splitReplacements.rest.first];

DoSetActiveVertex[handle, NIL, NIL];

InvalidateHitCache[handle];

};

This routine moves the knot at which a bezier segment is split into two segments.

handle: Handle ← NARROW[pathData];

hitSegment: SegmentNode;

hitPoint: Point;

hitT: REAL;

IF handle.activeTrajectory = NIL THEN RETURN;

IF handle.splitSegment # NIL THEN {

[hitSegment, hitPoint, hitT] ← SegmentHitTest[handle.activeTrajectory.first.segments, where];

IF handle.splitSegment # NIL THEN {

IF hitSegment = NIL THEN handle.splitSegment ← NIL

ELSE SplitSegment[pathData: pathData, where: where];

DoRequestRefresh[handle];

DoSetActiveVertex[handle, NIL, NIL];

InvalidateHitCache[handle];

};

This routine confirms a segment split. That is, it makes it permanent. This routine basically cleans up the display a bit.

handle: Handle ← NARROW[pathData];

IF handle.activeTrajectory = NIL THEN RETURN;

IF handle.splitSegment # NIL THEN {

InvalidateHitCache[handle];

};

This routine adds a control point to the specified segment (the segment in the active trajectory which is closest to "where"). Position specifies the position of the new control point. If the segment already contained one control point, the new control point is added before or after the current one depending on the the distance from "where" to the line segments defined by the existing control point and the two knots of the segment. If "where" is closer to the line segment defined by the existing control point and the first knot, the new control point is inserted before the existing one; otherwise it is inserted following the existing control point in the segment. If the segment already contains two control points, no action is performed.

handle: Handle ← NARROW[pathData];

vertex: Vertex ← NEW[VertexRec ← [point: position]];

newVertexNode: VertexNode ← NIL;

hitSegment: SegmentNode;

hitPoint: Point;

hitT: REAL;

numberVertices, maxNumberVertices: CARDINAL;

segmentFull: BOOLEAN;

precedingVertex: VertexNode;

d0, d1: REAL;

IF handle.activeTrajectory = NIL THEN RETURN;

[hitSegment, hitPoint, hitT] ← SegmentHitTest[handle.activeTrajectory.first.segments, where];

IF hitSegment # NIL THEN {

DoSetActiveVertex[handle, newVertexNode, hitSegment];

};

This routine makes the active trajectory a closed trajectory.

handle: Handle ← NARROW[pathData];

fp: VertexNode;

IF handle.activeTrajectory = NIL THEN RETURN;

IF handle.activeTrajectory.first.segments.first.type = moveTo THEN {

DoSetActiveVertex[handle, NIL, NIL];

};

This routine makes the active trajectory an open trajectory.

handle: Handle ← NARROW[pathData];

lastVertex: VertexNode;

DoDeleteVertex: VertexProc = {

IF handle.activeTrajectory = NIL THEN RETURN;

IF handle.activeTrajectory.first.segments.first.type # moveTo THEN {

DoSetActiveVertex[handle, NIL, NIL];

};

This routine deletes the vertex (which may be a knot or a control point) in the active trajectory which is closest to the specified point. The specified point must be "close to" (i.e. whithin a certain minimum distance of) a vertex in the active trajectory in order for the operation to be carried out.

handle: Handle ← NARROW[pathData];

closestVertex, pVertex, fVertex: VertexNode;

closestSegment, pSegment, fSegment: SegmentNode;

IF handle.activeTrajectory = NIL THEN RETURN;

[closestVertex, closestSegment] ← VertexHitTest[handle.activeTrajectory.first.segments, vertex];

[pVertex, pSegment] ← PrecedingVertex[closestVertex, closestSegment];

[fVertex, fSegment] ← FollowingVertex[closestVertex, closestSegment];

IF closestVertex # NIL THEN {

DoSetActiveVertex[handle, NIL, NIL];

InvalidateHitCache[handle];

};

This routine merges the specified segment with the one following it in the segment list, deleting the common knot and the control points surrounding the common knot. The second of the two segments is the one which is actually removed from the segment list. If no segment follows the specified segment in the segment list, then no action is performed by this routine.

DeleteVertex: VertexProc = {

vertexNode: VertexNode;

vertexList: VertexList;

IF IsLastSegment[segmentNode] THEN RETURN;

DisableSegmentRefresh[segment: segmentNode.first];

DisableSegmentRefresh[segment: segmentNode.rest.first];

DrawSegment[pathViewer: handle.pathViewer, segment: segmentNode.first, undo: TRUE];

DrawSegment[pathViewer: handle.pathViewer, segment: segmentNode.rest.first, undo: TRUE];

vertexNode ← segmentNode.first.vertices;

IF vertexNode.rest # NIL THEN vertexNode ← vertexNode.rest;

ForAllVertices[vertexNode, DeleteVertex];

vertexList ← segmentNode.rest.first.vertices;

segmentNode.rest.first.vertices ← NIL;

IF VertexListLength[vertexList] > 2 THEN {

segmentNode.first.vertices ← VertexListAppend[segmentNode.first.vertices, vertexList];

[handle.activeTrajectory.first.segments,] ← RemoveSegment[handle.activeTrajectory.first.segments, segmentNode.rest];

DrawSegment[pathViewer: handle.pathViewer, segment: segmentNode.first];

EnableSegmentRefresh[segment: segmentNode.first];

};

This routine makes the vertex of the active trajectory which is closest to the specified point the active vertex. A vertex must be made active before it can be moved. The specified position must be "close to" (i.e. whithin a certain minimum distance of) a segment in the active trajectory in order for the operation to be carried out. This routine returns an indication of whether the active vertex was in fact set and the position of the active vertex. The routines for adding knots and control points also set the active vertex. The NewImage, DeleteVertex and AddCubic routines unset the active vertex.

handle: Handle ← NARROW[pathData];

activeVertex: VertexNode;

activeSegment: SegmentNode;

IF handle.activeTrajectory = NIL THEN activeVertex ← NIL

ELSE [activeVertex, activeSegment] ← VertexHitTest[handle.activeTrajectory.first.segments, where];

DoSetActiveVertex[handle, activeVertex, activeSegment];

activeVertexSet ← activeVertex # NIL;

IF activeVertexSet THEN vertex ← activeVertex.first.point;

};

This routine sets up all of the information necessary for moving a vertex around. activeVertex is the vertex to be moved around. activeSegment is the first segment containing activeVertex.

IF activeVertex = NIL THEN {

ELSE {

};

This routine returns an indication of whether the active vertex is set and the position of the active vertex.

handle: Handle ← NARROW[pathData];

activeVertexSet ← handle.activeVertex # NIL;

IF activeVertexSet THEN vertex ← handle.activeVertex.first.point;

};

This routine moves the active vertex (which may be a knot or a control point) closest to the specified point to the specfied new position.

handle: Handle ← NARROW[pathData];

IF handle.activeVertex # NIL THEN {

InvalidateHitCache[handle];

};

This routine sets the continuity requirements at the vertex in the active trajectory which is closest to the specified location. The specified point (knot) must be "close to" (i.e. within a certain minimum distance of) a vertex in the active trajectory in order for the operation to be carried out. This operation only applies to knots. The client can specify that continuity is required (on), that continuity is not required (off), or that the current continuity requirement setting is to be toggled. When continuity is requested, the positions of some vertices may be altered to satisfy the request.

handle: Handle ← NARROW[pathData];

hitVertex: VertexNode;

hitSegment: SegmentNode;

IF handle.activeTrajectory = NIL THEN RETURN;

[hitVertex, hitSegment] ← VertexHitTest[handle.activeTrajectory.first.segments, knot];

IF IsAKnot[hitVertex] THEN {

};

This routine sets the indicator of whether the vertex in the active trajectory which is closest to the specified location is fixed (i.e. may not be moved unless explicitly requested by the client) or not fixed (i.e. may be moved without a client request in order to satisfy continuity requirements at some other vertex). The specified point (knot) must be "close to" (i.e. within a certain minimum distance of) a vertex in the active trajectory in order for the operation to be carried out. This operation only applies to control points. The client can specify that the vertex be fixed (on), that the vertex can be moved (off), of that the current setting is to be toggled.

handle: Handle ← NARROW[pathData];

hitVertex: VertexNode;

hitSegment: SegmentNode;

IF handle.activeTrajectory = NIL THEN RETURN;

[hitVertex, hitSegment] ← VertexHitTest[handle.activeTrajectory.first.segments, controlPoint];

IF hitVertex # NIL AND ~IsAKnot[hitVertex] THEN {

};

This routine enumerates all the segments in the active trajectory. Client specified routines are called for each line segment, and bezier curve in the trajectory. The moveToProc is called for the first point (FP) of the active trajectory.

handle: Handle ← NARROW[pathData];

EnumerateSegment: SegmentProc = {

IF handle.activeTrajectory = NIL THEN RETURN;

ForAllSegments[handle.activeTrajectory.first.segments, EnumerateSegment];

};

This routine determines the vertex in the active trajectory which is closest to the specified point. Only those vertices which are in the active trajectory and within a threshold distance of the point are considered. This routine returns an indication of whether the point is close to a vertex, and if so, the position of the closest vertex and its type.

handle: Handle ← NARROW[pathData];

hitVertex: VertexNode;

hitSegment: SegmentNode;

IF handle.vertexHit.hitCached AND where = handle.vertexHit.where THEN {

ELSE {

};

This routine determines the curve segment in the active trajectory which is closest to the specified point. Only those segments which are in the active trajectory and within a threshold distance of the point are considered. This routine returns an indication of whether the point is close to a curve segment, and if so, the position of the vertices of the segment, its type, and the point on the curve closest to the specified point.

handle: Handle ← NARROW[pathData];

hitT: REAL;

hitSegment: SegmentNode;

numberVertices: CARDINAL;

bezier: Bezier;

IF handle.curveHit.hitCached AND where = handle.curveHit.where THEN {

ELSE {

};

This routine invalidates the contents of the vertex and curve hit caches. This routine is called whenever an operation is performed which may cause the contents to be out of date and inaccurate.

handle.vertexHit.hitCached ← FALSE;

handle.curveHit.hitCached ← FALSE;

};