GGTrajImpl.mesa
Copyright © 1986 by Xerox Corporation. All rights reserved.
Last edited by Bier on November 13, 1986 5:03:39 pm PST
Contents: Procedures to implement the Traj Slice Class. Trajectories consist of Segments. One motivation for creating this module now is the GGOutlineImpl is too big to compile.
DIRECTORY
Atom, Feedback, GGBasicTypes, GGBoundBox, GGDescribe, GGInterfaceTypes, GGModelTypes, GGOutline, GGParseIn, GGParseOut, GGSegment, GGSegmentTypes, GGSelect, GGSequence, GGShapes, GGTraj, GGTransform, GGUtility, Imager, ImagerColorPrivate, ImagerTransformation, IO, RealFns, Rope, Rosary, Vectors2d;
GGTrajImpl: CEDAR PROGRAM
IMPORTS Atom, Feedback, GGBoundBox, GGDescribe, GGOutline, GGParseIn, GGParseOut, GGSegment, GGSelect, GGSequence, GGShapes, GGTransform, GGUtility, Imager, ImagerColorPrivate, ImagerTransformation, IO, RealFns, Rope, Rosary, Vectors2d
EXPORTS GGTraj =
BEGIN
BitVector: TYPE = GGBasicTypes.BitVector;
BoundBox: TYPE = GGBasicTypes.BoundBox;
CameraData: TYPE = GGModelTypes.CameraData;
Color: TYPE = Imager.Color;
HitType: TYPE = GGModelTypes.TrajPartType;
StrokeEnd: TYPE = Imager.StrokeEnd;
StrokeJoint: TYPE = Imager.StrokeJoint;
FeatureData: TYPE = GGInterfaceTypes.FeatureData;
FenceHoleOpen: TYPE = GGModelTypes.FenceHoleOpen;
GGData: TYPE = GGInterfaceTypes.GGData;
Joint: TYPE = REF JointObj;
JointObj: TYPE = GGSegmentTypes.JointObj;
JointGenerator: TYPE = GGModelTypes.JointGenerator;
Outline: TYPE = GGModelTypes.Outline;
Point: TYPE = GGBasicTypes.Point;
PointGenerator: TYPE = GGModelTypes.PointGenerator;
PointPairGenerator: TYPE = GGModelTypes.PointPairGenerator;
Scene: TYPE = GGModelTypes.Scene;
SegAndIndex: TYPE = GGSequence.SegAndIndex;
SegmentClass: TYPE = GGSegmentTypes.SegmentClass;
SelectionClass: TYPE = GGInterfaceTypes.SelectionClass;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
Sequence: TYPE = GGModelTypes.Sequence;
SequenceGenerator: TYPE = GGModelTypes.SequenceGenerator;
SequenceOfReal: TYPE = GGBasicTypes.SequenceOfReal;
TriggerBag: TYPE = GGInterfaceTypes.TriggerBag;
Traj: TYPE = REF TrajObj;
TrajObj: TYPE = GGModelTypes.TrajObj;
TrajEnd: TYPE = GGModelTypes.TrajEnd;
Vector: TYPE = GGBasicTypes.Vector;
Problem: ERROR [msg: Rope.ROPE] = Feedback.Problem;
Trajectory-Only Routines
CreateTraj: PUBLIC PROC [point: Point] RETURNS [traj: Traj] = {
firstJoint: Joint ← NEW[JointObj ← [point: point]];
bBox: BoundBox ← GGBoundBox.CreateBoundBox[point.x, point.y, point.x, point.y];
traj ← NEW[TrajObj ← [open, 0, NIL, Rosary.FromItem[firstJoint], NIL, NIL, bBox, FALSE]];
};
AddSegment: PUBLIC PROC [traj: Traj, trajEnd: TrajEnd, seg: Segment, segEnd: TrajEnd] RETURNS [success: BOOL ← TRUE] = {
diff: Vector;
loJoint, hiJoint: Joint;
outline: Outline;
Moves seg so that the specified end of seg coincides with the specified end of traj. In other words, seg is translated.
IF traj.role = fence OR traj.role = hole THEN {success ← FALSE; RETURN};
Prepare the Segment
IF trajEnd = segEnd THEN GGSegment.ReverseSegment[seg];
diff ← IF trajEnd = lo THEN Vectors2d.Sub[FetchJointPos[traj, 0], seg.hi]
ELSE Vectors2d.Sub[FetchJointPos[traj, traj.segCount], seg.lo];
GGSegment.TranslateSegment[seg, diff];
Adding to an Empty Traj
IF traj.segCount = 0 THEN {
traj.segments ← Rosary.FromItem[seg];
loJoint ← NEW[JointObj ← [point: seg.lo]];
hiJoint ← NEW[JointObj ← [point: seg.hi]];
traj.joints ← Rosary.FromList[LIST[loJoint, hiJoint]];
traj.segCount ← 1;
traj.boundBox ← GGBoundBox.CopyBoundBox[seg.class.boundBox[seg]];
}
Adding to an Existing Traj
ELSE {
IF trajEnd = lo THEN {
loJoint ← NEW[JointObj ← [point: seg.lo]];
traj.joints ← Rosary.Concat[Rosary.FromItem[loJoint], traj.joints];
traj.segments ← Rosary.Concat[Rosary.FromItem[seg], traj.segments];
}
ELSE {
hiJoint ← NEW[JointObj ← [point: seg.hi]];
traj.joints ← Rosary.Concat[traj.joints, Rosary.FromItem[hiJoint]];
traj.segments ← Rosary.Concat[traj.segments, Rosary.FromItem[seg]];
};
traj.segCount ← traj.segCount + 1;
GGBoundBox.EnlargeByBox[traj.boundBox, seg.class.boundBox[seg]];
outline ← GGOutline.OutlineOfTraj[traj];
IF outline#NIL THEN GGOutline.UpdateBoundBox[outline];
};
};
CloseWithSegment: PUBLIC PROC [traj: Traj, seg: Segment, segEnd: TrajEnd] = {
Like AddSegment, except that here we rotate, scale, and translate seg as needed so that both of its endpoints coincide with the endpoints of traj (which must not already be closed). The endpoint correspondence is made so that the hi end of traj touches the named (segEnd) end of seg.
diff: Vector;
outline: Outline;
IF traj.segCount = 0 THEN ERROR Problem[msg: "single closed segment not implemented"];
For now, just translate into place and assume size is ok.
IF segEnd = hi THEN GGSegment.ReverseSegment[seg];
diff ← Vectors2d.Sub[LastJointPos[traj], seg.lo];
GGSegment.TranslateSegment[seg, diff];
traj.segments ← Rosary.Concat[traj.segments, Rosary.FromItem[seg]];
traj.segCount ← traj.segCount + 1;
traj.role ← fence;
GGBoundBox.EnlargeByBox[traj.boundBox, seg.class.boundBox[seg]];
outline ← GGOutline.OutlineOfTraj[traj];
IF outline#NIL THEN GGOutline.UpdateBoundBox[outline];
};
CloseByDistorting: PUBLIC PROC [traj: Traj, distortEnd: TrajEnd] = {
Move either the first joint or the last joint (depending on the distortEnd argument) to coincide with the other end. This will reduce the number of joints in the trajectory by one (making all sequences which refer to this trajectory obsolete. Usually, no distortion will actually occur. The client is expected to call this routine when the joints already coincide.
seg: Segment;
loJoint, hiJoint: Joint;
outline: Outline;
loJoint ← FetchJoint[traj, 0];
hiJoint ← FetchJoint[traj, HiJoint[traj]];
SELECT distortEnd FROM
lo => {
seg ← FetchSegment[traj, 0];
loJoint.point ← hiJoint.point;
seg.lo ← hiJoint.point;
seg.class.endPointMoved[seg, TRUE, hiJoint.point];
};
hi => {
seg ← FetchSegment[traj, HiSegment[traj]];
hiJoint.point ← loJoint.point;
seg.hi ← loJoint.point;
seg.class.endPointMoved[seg, FALSE, loJoint.point];
};
ENDCASE => ERROR;
traj.joints ← Rosary.Substr[traj.joints, 0, HiJoint[traj]];
traj.role ← fence;
GGBoundBox.EnlargeByBox[traj.boundBox, seg.class.boundBox[seg]];
outline ← GGOutline.OutlineOfTraj[traj];
IF outline#NIL THEN GGOutline.UpdateBoundBox[outline];
};
OnlyChild: PUBLIC PROC [traj: Traj] RETURNS [BOOL] = {
RETURN[traj.parent.children.rest = NIL];
};
Building Trajectories from Parts
CopyTrajFromRun: PUBLIC PROC [seq: Sequence] RETURNS [copy: Traj] = {
seq should be a run (a single consecutive set of segments and joints).
originalSegments: Rosary.ROSARY ← seq.traj.segments;
desiredSegments: Rosary.Segment;
loSegments, hiSegments, extractedSegments: Rosary.ROSARY;
originalJoints: Rosary.ROSARY ← seq.traj.joints;
desiredJoints: Rosary.Segment;
loJoints, hiJoints, extractedJoints: Rosary.ROSARY;
segGen: SegmentGenerator;
next: GGSequence.SegAndIndex;
s1, len1, s2, len2: INT;
jointCount: NAT;
newRole: GGModelTypes.FenceHoleOpen;
CopyEachSegment: PROC[q: PROC[item: Rosary.Item, repeat: INT ← 1]] = {
CopySegmentAndBuild: PROC [item: Rosary.Item] RETURNS [quit: BOOLEAN ← FALSE] = {
copy, oldSeg: Segment;
oldSeg ← NARROW[item];
copy ← GGSegment.CopySegment[oldSeg];
q[copy, 1];
};
[] ← Rosary.Map[desiredSegments, CopySegmentAndBuild];
};
CopyEachJoint: PROC[q: PROC[item: Rosary.Item, repeat: INT ← 1]] = {
CopyJointAndBuild: PROC [item: Rosary.Item] RETURNS [quit: BOOLEAN ← FALSE] = {
copy, oldJoint: Joint;
oldJoint ← NARROW[item];
copy ← CopyJoint[oldJoint];
q[copy, 1];
};
[] ← Rosary.Map[desiredJoints, CopyJointAndBuild];
};
segGen ← GGSequence.OrderedSegmentsInSequence[seq];
next ← GGSequence.NextSegmentAndIndex[segGen];
[s1, len1, s2, len2] ← GGUtility.BreakIntervalMODLen[next.index, seq.segCount, seq.traj.segCount];
IF s2 # -1 THEN {
desiredSegments ← [originalSegments, s1, len1];
loSegments ← Rosary.FromProcProc[CopyEachSegment];
desiredSegments ← [originalSegments, s2, len2];
hiSegments ← Rosary.FromProcProc[CopyEachSegment];
extractedSegments ← Rosary.Concat[hiSegments, loSegments];
}
ELSE {
desiredSegments ← [originalSegments, next.index, seq.segCount];
extractedSegments ← Rosary.FromProcProc[CopyEachSegment];
};
jointCount ← seq.segCount + 1; -- ignore the joint information in the sequence. We just want all of the segments to have a joint on each side. This distinction is particularly important when a single joint of a closed trajectory is being deleted.
[s1, len1, s2, len2] ← GGUtility.BreakIntervalMODLen[next.index, jointCount, HiJoint[seq.traj]+1];
IF s2 # -1 THEN {
desiredJoints ← [originalJoints, s1, len1];
loJoints ← Rosary.FromProcProc[CopyEachJoint];
desiredJoints ← [originalJoints, s2, len2];
hiJoints ← Rosary.FromProcProc[CopyEachJoint];
extractedJoints ← Rosary.Concat[hiJoints, loJoints];
}
ELSE {
desiredJoints ← [originalJoints, next.index, jointCount];
extractedJoints ← Rosary.FromProcProc[CopyEachJoint];
};
newRole ← IF GGSequence.IsComplete[seq] AND seq.traj.role # open THEN fence ELSE open;
copy ← NEW[TrajObj ← [newRole, seq.segCount, extractedSegments, extractedJoints, NIL, NIL, NIL, seq.traj.visibleJoints, seq.traj.strokeJoint ]];
copy.boundBox ← GGBoundBox.NullBoundBox[];
UpdateBoundBox[copy];
};
CopyTrajFromRange: PUBLIC PROC [original: Traj, start: INT, len: INT] RETURNS [piece: Traj] = {
First we pick out the desired subsection. Then, Rosary will call CopyEachSegment, which in turn maps CopySegmentAndBuild to each of the desired elements. The copies are made and are passed to procedure q of Rosary, which assembles them into a new Rosary.
originalSegments: Rosary.ROSARY ← original.segments;
desiredSegments: Rosary.Segment ← [originalSegments, start, len];
extractedSegments: Rosary.ROSARY;
originalJoints: Rosary.ROSARY ← original.joints;
desiredJoints: Rosary.Segment ← [originalJoints, start, len];
extractedJoints: Rosary.ROSARY;
CopyEachSegment: PROC[q: PROC[item: Rosary.Item, repeat: INT ← 1]] = {
CopySegmentAndBuild: PROC [item: Rosary.Item] RETURNS [quit: BOOLEAN ← FALSE] = {
copy, oldSeg: Segment;
oldSeg ← NARROW[item];
copy ← GGSegment.CopySegment[oldSeg];
q[copy, 1];
};
[] ← Rosary.Map[desiredSegments, CopySegmentAndBuild];
};
CopyEachJoint: PROC[q: PROC[item: Rosary.Item, repeat: INT ← 1]] = {
CopyJointAndBuild: PROC [item: Rosary.Item] RETURNS [quit: BOOLEAN ← FALSE] = {
copy, oldJoint: Joint;
oldJoint ← NARROW[item];
copy ← CopyJoint[oldJoint];
q[copy, 1];
};
[] ← Rosary.Map[desiredJoints, CopyJointAndBuild];
};
extractedSegments ← Rosary.FromProcProc[CopyEachSegment];
extractedJoints ← Rosary.FromProcProc[CopyEachJoint];
piece ← NEW[TrajObj ← [fence, len, extractedSegments, extractedJoints, NIL, NIL, NIL, original.visibleJoints, original.strokeJoint ]];
I must create a new outline and copy the extrapoints as well.
piece.boundBox ← GGBoundBox.NullBoundBox[];
UpdateBoundBox[piece];
};
Concat: PUBLIC PROC [fixed: Traj, fixedEnd: TrajEnd, moving: Traj, movingEnd: TrajEnd] RETURNS [longer: Traj] = {
Moves moving so that the specified end moving coincides with the specified end fixed. In other words, moving is translated.
diff: Vector;
fixed ← CopyTraj[fixed];
moving ← CopyTraj[moving];
IF fixedEnd = movingEnd THEN ReverseTraj[moving];
IF fixedEnd = hi THEN {
diff ← Vectors2d.Sub[FetchJointPos[fixed, HiJoint[fixed]], FetchJointPos[moving, 0]];
TranslateTraj[moving, diff];
longer ← NEW[TrajObj ← [
role: open,
segCount: fixed.segCount + moving.segCount,
segments: Rosary.Concat[fixed.segments, moving.segments],
joints: Rosary.Concat[fixed.joints, Rosary.Substr[moving.joints, 1]],
extraPoints: NIL,
parent: NIL,
boundBox: NIL,
visibleJoints: fixed.visibleJoints,
strokeJoint: fixed.strokeJoint,
selectedInPart: [FALSE, FALSE, FALSE]
]];
longer.boundBox ← GGBoundBox.NullBoundBox[];
UpdateBoundBox[longer];
}
ELSE { -- fixedEnd = lo
diff ← Vectors2d.Sub[FetchJointPos[fixed, 0], FetchJointPos[moving, HiJoint[moving]]];
TranslateTraj[moving, diff];
longer ← NEW[TrajObj ← [
role: open,
segCount: fixed.segCount + moving.segCount,
segments: Rosary.Concat[moving.segments, fixed.segments],
joints: Rosary.Concat[moving.joints, Rosary.Substr[fixed.joints, 1]],
extraPoints: NIL,
parent: NIL,
boundBox: NIL,
visibleJoints: fixed.visibleJoints,
strokeJoint: fixed.strokeJoint,
selectedInPart: [FALSE, FALSE, FALSE]
]];
longer.boundBox ← GGBoundBox.NullBoundBox[];
UpdateBoundBox[longer];
};
};
SpliceIn: PUBLIC PROC [run: Sequence, traj: Traj] RETURNS [newTraj: Traj] = {
oldOutline: Outline ← GGOutline.OutlineOfTraj[run.traj];
SELECT run.traj.role FROM
hole => {
newTraj ← SpliceInClosed[run, traj];
newTraj.role ← hole;
[] ← GGOutline.ReplaceHole[oldOutline, run.traj, newTraj];
};
open => {
newTraj ← SpliceInOpen[run, traj];
newTraj.role ← open;
[] ← GGOutline.CreateOutline[newTraj, oldOutline.fillColor];
};
fence => {
newTraj ← SpliceInClosed[run, traj];
newTraj.role ← fence;
[] ← GGOutline.ReplaceFence[oldOutline, newTraj];
};
ENDCASE => ERROR;
A hack to get arrows to work reasonably for now.
newTraj.loArrow ← run.traj.loArrow;
newTraj.hiArrow ← run.traj.hiArrow;
};
IncludesLoEnd: PROC [run: Sequence] RETURNS [BOOL] = {
RETURN[run.segments[0]];
};
ResetEndSelectionBits: PROC [traj: Traj, lo, hi: BOOL ← TRUE] = {
joint: Joint;
IF lo THEN {
joint ← FetchJoint[traj, 0];
joint.TselectedInFull.active ← FALSE;
};
IF hi THEN {
joint ← FetchJoint[traj, HiJoint[traj]];
joint.TselectedInFull.active ← FALSE;
};
};
SpliceInOpen: PROC [run: Sequence, traj: Traj] RETURNS [newTraj: Traj] = {
runGen: SequenceGenerator;
wholeSeq, remainder, run1, run2, run3: Sequence;
traj1, traj2: Traj;
firstJointNum, lastJointNum: NAT;
joint: Joint;
wholeSeq ← GGSequence.CreateComplete[run.traj];
remainder ← GGSequence.Difference[wholeSeq, run];
GGSequence.FillInJoints[remainder];
[runGen,----] ← GGSequence.RunsInSequence[remainder];
run1 ← GGSequence.NextSequence[runGen];
run2 ← GGSequence.NextSequence[runGen];
run3 ← GGSequence.NextSequence[runGen];
IF run3 # NIL THEN ERROR;
SELECT TRUE FROM
run1 = NIL => {
newTraj ← traj;
};
run2 = NIL => {
traj1 ← CopyTrajFromRun[run1];
IF IncludesLoEnd[run] THEN {
ResetEndSelectionBits[traj: traj1, lo: TRUE, hi: FALSE];
newTraj ← Concat[traj, hi, traj1, lo]; -- order is important. traj1's lo joint is kept
}
ELSE {
ResetEndSelectionBits[traj: traj1, lo: FALSE, hi: TRUE];
newTraj ← Concat[traj, lo, traj1, hi]; -- order is important. traj1's hi joint is kept
};
};
ENDCASE => {
[Artwork node; type 'ArtworkInterpress on' to command tool]
traj1 ← CopyTrajFromRun[run1];
ResetEndSelectionBits[traj: traj1, lo: FALSE, hi: TRUE];
traj2 ← CopyTrajFromRun[run2];
ResetEndSelectionBits[traj: traj2, lo: TRUE, hi: FALSE];
newTraj ← Concat[traj, lo, traj1, hi];
newTraj ← Concat[newTraj, hi, traj2, lo];
};
To make sure the algorithm terminates, make sure the end joints of the run are not active selected. They can be normal or hot selected.
};
SpliceInClosed: PROC [run: Sequence, traj: Traj] RETURNS [newTraj: Traj] = {
wholeSeq, remainder, run1, run2: Sequence;
runGen: SequenceGenerator;
traj1: Traj;
firstJointNum, lastJointNum: INT;
joint: Joint;
IF GGSequence.IsComplete[run] THEN RETURN[traj]; -- no need to splice.
wholeSeq ← GGSequence.CreateComplete[run.traj];
remainder ← GGSequence.Difference[wholeSeq, run];
GGSequence.FillInJoints[remainder];
[runGen, ----] ← GGSequence.RunsInSequence[remainder];
run1 ← GGSequence.NextSequence[runGen];
run2 ← GGSequence.NextSequence[runGen];
IF run1 = NIL OR run2 # NIL THEN ERROR;
traj1 ← CopyTrajFromRun[run1];
ResetEndSelectionBits[traj1];
newTraj ← Concat[traj, lo, traj1, hi]; -- order is important because traj1's joints are kept.
CloseByDistorting[newTraj, lo];
[Artwork node; type 'ArtworkInterpress on' to command tool]
To make sure the algorithm terminates, make sure the end joints of the run are not active selected. They can be normal or hot selected.
};
Orientation
ReverseTraj: PUBLIC PROC [traj: Traj] = {
newSegments: Rosary.ROSARY ← NIL;
newJoints: Rosary.ROSARY ← NIL;
seg: Segment;
joint: Joint;
IF traj.role # open THEN SIGNAL Problem["not yet implemented"];
FOR i: NAT IN [0..traj.segCount) DO
seg ← FetchSegment[traj, i];
GGSegment.ReverseSegment[seg];
newSegments ← Rosary.Concat[Rosary.FromItem[seg], newSegments];
ENDLOOP;
FOR i: NAT IN [0..traj.segCount] DO
joint ← IF traj.role=open THEN FetchJoint[traj, i] ELSE FetchJoint[traj, (i MOD traj.segCount)];
newJoints ← Rosary.Concat[Rosary.FromItem[joint], newJoints];
ENDLOOP;
traj.segments ← newSegments;
traj.joints ← newJoints;
};
IsClockwiseTraj: PUBLIC PROC [traj: Traj] RETURNS [BOOL] = {
RETURN [SignedArea[traj]>0];
};
IsClockwiseTrajTransformSeq: PUBLIC PROC [seq: Sequence, transform: ImagerTransformation.Transformation] RETURNS [BOOL] = {
RETURN [SignedAreaTransformSeq[seq, transform]>0];
};
Fundamental Routines
The lifetime of a trajectory goes something like this: It begins as a single point. The sole purpose of this point is to be an "endpoint" to which the first segment can be attached. Subsequent segments are also added to endpoints, so this unifies the creation process. In Gargoyle, trajectories never appear at the top level of a scene; they are always part of an outline. It is suggested, then that each CreateTraj call be followed immediately by a CreateOutline call.
GetBoundBox: PUBLIC PROC [traj: Traj] RETURNS [bBox: BoundBox] = {
UpdateBoundBox[traj];
RETURN[traj.boundBox];
};
UpdateBoundBox: PUBLIC PROC [traj: Traj] = {
Computes it from segment boxes.
segGen: SegmentGenerator;
segGen ← GGSequence.SegmentsInTraj[traj];
traj.boundBox^ ← GGBoundBox.emptyBoundBox^;
FOR seg: Segment ← GGSequence.NextSegment[segGen], GGSequence.NextSegment[segGen] UNTIL seg = NIL DO
GGBoundBox.EnlargeByBox[bBox: traj.boundBox, by: seg.class.boundBox[seg]];
ENDLOOP;
IF traj.parent#NIL THEN GGOutline.UpdateBoundBox[traj.parent];
};
CopyTraj: PUBLIC PROC [original: Traj] RETURNS [copy: Traj] = {
Rosary will call CopyEachSegment, which in turn maps CopySegmentAndBuild to each of the desired elements. The copies are made and are passed to procedure q of Rosary, which assembles them into a new Rosary.
originalSegments: Rosary.ROSARY ← original.segments;
desiredSegments: Rosary.Segment ← [originalSegments, 0, original.segCount];
extractedSegments: Rosary.ROSARY;
originalJoints: Rosary.ROSARY ← original.joints;
desiredJoints: Rosary.Segment ← [originalJoints, 0, HiJoint[original] + 1];
extractedJoints: Rosary.ROSARY;
CopyEachSegment: PROC[q: PROC[item: Rosary.Item, repeat: INT ← 1]] = {
CopySegmentAndBuild: PROC [item: Rosary.Item] RETURNS [quit: BOOLEAN ← FALSE] = {
copy, oldSeg: Segment;
oldSeg ← NARROW[item];
copy ← GGSegment.CopySegment[oldSeg];
q[copy, 1];
};
[] ← Rosary.Map[desiredSegments, CopySegmentAndBuild];
};
CopyEachJoint: PROC[q: PROC[item: Rosary.Item, repeat: INT ← 1]] = {
CopyJointAndBuild: PROC [item: Rosary.Item] RETURNS [quit: BOOLEAN ← FALSE] = {
copy, oldJoint: Joint;
oldJoint ← NARROW[item];
copy ← CopyJoint[oldJoint];
q[copy, 1];
};
[] ← Rosary.Map[desiredJoints, CopyJointAndBuild];
};
extractedSegments ← Rosary.FromProcProc[CopyEachSegment];
extractedJoints ← Rosary.FromProcProc[CopyEachJoint];
copy ← NEW[TrajObj ← [original.role, original.segCount, extractedSegments, extractedJoints, NIL, NIL, NIL, original.visibleJoints, original.strokeJoint, original.loArrow, original.hiArrow]];
copy.boundBox ← GGBoundBox.NullBoundBox[];
UpdateBoundBox[copy];
};
Drawing
DrawTraj: PUBLIC PROC [dc: Imager.Context, traj: Traj] = {
Let Q be a logical variable corresponding to <ggData.camera.quality = quality>.
Let S correspond to <segment J is selected>.
Let O correspond to <segment J is on the overlay plane>.
Then segment J is drawn thick when: qSo.
Segment J is drawn thin otherwise (i.e. when Q + s + O).
DrawTrajAux: PROC [dc: Imager.Context, traj: Traj] = {
Imager.SetStrokeJoint[dc, traj.strokeJoint];
FOR i: INT IN [0..HiSegment[traj]] DO
seg ← FetchSegment[traj, i];
IF seg.strokeWidth#0 AND seg.color#NIL THEN {
Imager.SetStrokeWidth[dc, seg.strokeWidth];
Imager.SetStrokeEnd[dc, seg.strokeEnd];
Imager.SetColor[dc, seg.color];
MaskStroke[dc, seg];
};
ENDLOOP;
};
seg: Segment;
IF AllStrokePropsAndColorsEqual[traj] THEN DrawSingleStrokeTraj[dc, traj]
ELSE DrawTrajAux[dc, traj]; -- why no DoSaveAll here ??
};
DrawSingleStrokeTraj: PROC [dc: Imager.Context, traj: Traj] = {
BuildPath: Imager.PathProc = {
seg: Segment;
firstPoint: Point ← FetchJointPos[traj, 0];
moveTo[firstPoint];
FOR i: INT IN [0..HiSegment[traj]] DO
seg ← FetchSegment[traj, i];
seg.class.buildPath[seg, lineTo, curveTo, conicTo, arcTo];
ENDLOOP;
};
PatternProc: PROC [i: NAT] RETURNS [REAL] = {
RETURN[pattern[i]];
};
firstSeg: Segment ← FetchSegment[traj, 0];
strokeWidth: REAL ← firstSeg.strokeWidth;
pattern: SequenceOfReal ← firstSeg.pattern;
IF strokeWidth = 0.0 OR firstSeg.color=NIL THEN RETURN;
Imager.SetStrokeWidth[dc, strokeWidth];
Imager.SetStrokeEnd[dc, firstSeg.strokeEnd];
Imager.SetStrokeJoint[dc, traj.strokeJoint];
Imager.SetColor[dc, firstSeg.color];
IF firstSeg.dashed THEN Imager.MaskDashedStroke[dc, BuildPath, pattern.len, PatternProc, firstSeg.offset, firstSeg.length]
ELSE Imager.MaskStroke[dc, BuildPath, traj.role = fence OR traj.role = hole];
}; -- end DrawSingleStrokeTraj
DrawTrajSeq: PROC [dc: Imager.Context, seq: Sequence] = {
cpCount: NAT;
seg: Segment;
IF AllStrokePropsAndColorsEqual[seq.traj] THEN DrawSingleStrokeTrajSeq[dc, seq, transform]
ELSE {
point: Point;
Imager.SetStrokeJoint[dc, seq.traj.strokeJoint];
FOR i: INT IN [0..HiSegment[selSeq.traj]] DO
seg ← FetchSegment[seq.traj, i];
IF seg.strokeWidth=0 OR seg.color=NIL THEN LOOP;
IF seq.segments[i] THEN {
Imager.SetStrokeWidth[dc, seg.strokeWidth];
Imager.SetStrokeEnd[dc, seg.strokeEnd];
Imager.SetColor[dc, seg.color];
SegMaskStroke[dc, seg];
cpCount ← seg.class.controlPointCount[seg];
FOR j: NAT IN [0..cpCount) DO
IF seq.controlPoints[i][j] THEN GGShapes.DrawCP[dc, seg.class.controlPointGet[seg, j]];
ENDLOOP;
};
ENDLOOP;
};
};
DrawSingleStrokeTrajSeq: PROC [dc: Imager.Context, seq: Sequence] = {
BuildPath: Imager.PathProc = {
FOR i: INT IN [0..HiSegment[seq.traj]] DO
IF seq.segments[i] THEN {
seg: Segment ← FetchSegment[seq.traj, i];
moveTo[seg.lo];
seg.class.buildPath[seg, lineTo, curveTo, conicTo, arcTo];
};
ENDLOOP;
};
PatternProc: PROC [i: NAT] RETURNS [REAL] = {
RETURN[pattern[i]];
};
firstSeg: Segment ← FetchSegment[seq.traj, 0];
pattern: SequenceOfReal ← firstSeg.pattern;
IF firstSeg.strokeWidth = 0.0 OR firstSeg.color=NIL THEN RETURN;
Imager.SetStrokeWidth[dc, firstSeg.strokeWidth];
Imager.SetStrokeEnd[dc, firstSeg.strokeEnd];
Imager.SetStrokeJoint[dc, seq.traj.strokeJoint];
Imager.SetColor[dc, firstSeg.color];
IF firstSeg.dashed THEN Imager.MaskDashedStroke[dc, BuildPath, pattern.len, PatternProc, firstSeg.offset, firstSeg.length]
ELSE Imager.MaskStroke[dc, BuildPath, seq.traj.role = fence OR seq.traj.role = hole];
}; -- end DrawSingleStrokeTrajSeq
DrawTrajTransformSeq: PUBLIC PROC [dc: Imager.Context, selSeq: Sequence, transform: ImagerTransformation.Transformation] = {
cpCount: NAT;
seg: Segment;
IF AllStrokePropsAndColorsEqual[selSeq.traj] THEN DrawSingleStrokeTrajTransformSeq[dc, selSeq, transform]
ELSE {
point: Point;
Imager.SetStrokeJoint[dc, selSeq.traj.strokeJoint];
FOR i: INT IN [0..HiSegment[selSeq.traj]] DO
seg ← FetchSegment[selSeq.traj, i];
Imager.SetStrokeWidth[dc, (IF seg.strokeWidth#0 THEN seg.strokeWidth ELSE 1)];
Imager.SetStrokeEnd[dc, seg.strokeEnd];
Imager.SetColor[dc, IF seg.color#NIL THEN seg.color ELSE Imager.black];
MaskStrokeTransform[dc, seg, transform, selSeq.segments[i], selSeq.joints[i], selSeq.joints[IF selSeq.traj.role=open THEN (i+1) ELSE (i+1) MOD selSeq.traj.segCount], selSeq.controlPoints[i]];
cpCount ← seg.class.controlPointCount[seg];
FOR j: NAT IN [0..cpCount) DO
IF selSeq.controlPoints[i][j] THEN {
point ← ImagerTransformation.Transform[transform, seg.class.controlPointGet[seg, j]];
GGShapes.DrawCP[dc, point];
}
ELSE {
point ← seg.class.controlPointGet[seg, j];
GGShapes.DrawCP[dc, point];
};
ENDLOOP;
ENDLOOP;
};
};
DrawSingleStrokeTrajTransformSeq: PROC [dc: Imager.Context, selSeq: Sequence, transform: ImagerTransformation.Transformation] = {
BuildPath: Imager.PathProc = {
seg: Segment;
entire, lo, hi: BOOL;
controlPoints: BitVector;
firstPoint: Point;
entire ← selSeq.segments[0];
lo ← selSeq.joints[0];
firstPoint ← FetchJointPos[selSeq.traj, 0];
IF entire OR lo THEN firstPoint ← ImagerTransformation.Transform[transform, firstPoint];
moveTo[firstPoint];
FOR i: INT IN [0..HiSegment[selSeq.traj]] DO
seg ← FetchSegment[selSeq.traj, i];
entire ← selSeq.segments[i];
lo ← selSeq.joints[i];
hi ← selSeq.joints[IF selSeq.traj.role=open THEN (i+1) ELSE (i+1) MOD selSeq.traj.segCount];
controlPoints ← selSeq.controlPoints[i];
seg.class.buildPathTransform[seg, transform, entire, lo, hi, controlPoints, lineTo, curveTo, conicTo, arcTo];
ENDLOOP;
};
PatternProc: PROC [i: NAT] RETURNS [REAL] = {
RETURN[pattern[i]];
};
firstSeg: Segment ← FetchSegment[selSeq.traj, 0];
strokeWidth: REAL ← firstSeg.strokeWidth;
pattern: SequenceOfReal ← firstSeg.pattern;
IF strokeWidth = 0.0 OR firstSeg.color=NIL THEN RETURN;
Imager.SetStrokeWidth[dc, strokeWidth];
Imager.SetStrokeEnd[dc, firstSeg.strokeEnd];
Imager.SetStrokeJoint[dc, selSeq.traj.strokeJoint];
Imager.SetColor[dc, firstSeg.color];
IF firstSeg.dashed THEN Imager.MaskDashedStroke[dc, BuildPath, pattern.len, PatternProc, firstSeg.offset, firstSeg.length]
ELSE Imager.MaskStroke[dc, BuildPath, selSeq.traj.role = fence OR selSeq.traj.role = hole];
}; -- end DrawSingleStrokeTrajTransformSeq
DrawSelectionFeedback: PUBLIC PROC [traj: Traj, selectedParts, hotParts: Sequence, dc: Imager.Context, camera: CameraData, dragInProgress, caretIsMoving, hideHot, quick: BOOL] = {
DoDrawFeedback: PROC = {
segGen: GGModelTypes.SegmentGenerator;
jointGen: GGModelTypes.JointGenerator;
seg: Segment;
someNormal, someHot, thisCPisHot, thisCPisSelected: BOOL;
point: Point;
Draw the joints.
jointGen ← GGSequence.JointsInTraj[traj];
FOR i: INT ← GGSequence.NextJoint[jointGen], GGSequence.NextJoint[jointGen] UNTIL i = -1 DO
thisCPisHot ← hotParts#NIL AND hotParts.joints[i];
thisCPisSelected ← selectedParts#NIL AND selectedParts.joints[i];
point ← FetchJointPos[traj, i];
IF thisCPisHot THEN GGShapes.DrawSelectedJoint[dc, point, hot];
IF thisCPisSelected THEN GGShapes.DrawSelectedJoint[dc, point, normal];
IF NOT thisCPisHot AND NOT thisCPisSelected THEN GGShapes.DrawJoint[dc, point];
ENDLOOP;
Draw the control points.
someNormal ← GGSequence.ContainsSegmentParts[selectedParts, i];
someHot ← GGSequence.ContainsSegmentParts[hotParts, i];
someNormal ← selectedParts # NIL;
someHot ← hotParts # NIL;
segGen ← GGSequence.SegmentsInTraj[traj];
FOR next: GGSequence.SegAndIndex ← GGSequence.NextSegmentAndIndex[segGen], GGSequence.NextSegmentAndIndex[segGen] UNTIL next.seg = NIL DO
i: NAT ← next.index;
seg ← next.seg;
IF someNormal OR someHot THEN {
FOR j: INT IN [0..seg.class.controlPointCount[seg]) DO
thisCPisHot ← hotParts#NIL AND hotParts.controlPoints[i][j];
thisCPisSelected ← selectedParts#NIL AND selectedParts.controlPoints[i][j];
point ← seg.class.controlPointGet[seg, j];
IF thisCPisHot THEN GGShapes.DrawSelectedJoint[dc, point, hot];
IF thisCPisSelected THEN GGShapes.DrawSelectedJoint[dc, point, normal];
IF NOT thisCPisHot AND NOT thisCPisSelected THEN GGShapes.DrawCP[dc, point];
ENDLOOP;
};
ENDLOOP;
};
IF caretIsMoving OR dragInProgress THEN RETURN;
IF selectedParts = NIL AND hotParts = NIL THEN RETURN;
IF camera.quality # quality THEN Imager.DoSaveAll[dc, DoDrawFeedback];
};
Drawing Utilities
MaskStroke: PROC [dc: Imager.Context, seg: Segment] = {
MaskPath: Imager.PathProc = {
moveTo[seg.lo];
seg.class.buildPath[seg, lineTo, curveTo, conicTo, arcTo];
};
PatternProc: PROC [i: NAT] RETURNS [REAL] = {
RETURN[pattern[i]];
};
pattern: SequenceOfReal ← seg.pattern;
IF seg.dashed THEN Imager.MaskDashedStroke[dc, MaskPath, pattern.len, PatternProc, seg.offset, seg.length]
ELSE Imager.MaskStroke[dc, MaskPath, FALSE];
};
SegMaskStroke: PROC [dc: Imager.Context, seg: Segment] = {
MaskPath: Imager.PathProc = {
[moveTo: ImagerPath.MoveToProc, lineTo: ImagerPath.LineToProc, curveTo: ImagerPath.CurveToProc, conicTo: ImagerPath.ConicToProc, arcTo: ImagerPath.ArcToProc]
moveTo[seg.lo];
seg.class.buildPath[seg, lineTo, curveTo, conicTo, arcTo];
};
PatternProc: PROC [i: NAT] RETURNS [REAL] = {
RETURN[pattern[i]];
};
pattern: SequenceOfReal ← seg.pattern;
IF seg.dashed THEN Imager.MaskDashedStroke[dc, MaskPath, pattern.len, PatternProc, seg.offset, seg.length]
ELSE Imager.MaskStroke[dc, MaskPath, FALSE];
};
MaskStrokeTransform: PROC [dc: Imager.Context, seg: Segment, transform: ImagerTransformation.Transformation, entire, lo, hi: BOOL, controlPoints: BitVector] = {
MaskPath: Imager.PathProc = {
[moveTo: ImagerPath.MoveToProc, lineTo: ImagerPath.LineToProc, curveTo: ImagerPath.CurveToProc, conicTo: ImagerPath.ConicToProc, arcTo: ImagerPath.ArcToProc]
loPoint: Point;
loPoint ← IF entire OR lo THEN ImagerTransformation.Transform[transform, seg.lo] ELSE seg.lo;
moveTo[loPoint];
seg.class.buildPathTransform[seg, transform, entire, lo, hi, controlPoints, lineTo, curveTo, conicTo, arcTo];
};
PatternProc: PROC [i: NAT] RETURNS [REAL] = {
RETURN[pattern[i]];
};
pattern: SequenceOfReal ← seg.pattern;
IF seg.dashed THEN Imager.MaskDashedStroke[dc, MaskPath, pattern.len, PatternProc, seg.offset, seg.length]
ELSE Imager.MaskStroke[dc, MaskPath, FALSE];
};
EqualSequence: PROC [s1, s2: SequenceOfReal] RETURNS [BOOL] = {
IF s1.len # s2.len THEN RETURN[FALSE];
FOR i: NAT IN [0..s1.len) DO
IF s1[i] # s2[i] THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};
AllStrokePropsAndColorsEqual: PUBLIC PROC [traj: Traj] RETURNS [BOOL] = {
firstSeg: Segment ← FetchSegment[traj, 0];
seg: Segment;
width: REAL ← firstSeg.strokeWidth;
end: StrokeEnd ← firstSeg.strokeEnd;
color: Color ← firstSeg.color;
dashed: BOOL ← firstSeg.dashed;
pattern: SequenceOfReal ← firstSeg.pattern;
offset: REAL ← firstSeg.offset;
length: REAL ← firstSeg.length;
FOR i: INT IN [1..HiSegment[traj]] DO
seg ← FetchSegment[traj, i];
IF seg.dashed # dashed THEN RETURN[FALSE];
IF seg.strokeEnd # end THEN RETURN[FALSE];
IF seg.strokeWidth # width THEN RETURN[FALSE];
IF NOT GGUtility.EquivalentColors[color, seg.color] THEN RETURN[FALSE];
IF NOT dashed THEN LOOP;
IF seg.offset # offset THEN RETURN[FALSE];
IF seg.length # length THEN RETURN[FALSE];
IF NOT EqualSequence[seg.pattern, pattern] THEN RETURN[FALSE];
REPEAT
FINISHED => RETURN[TRUE];
ENDLOOP;
};
AllStrokeWidthsEqual: PROC [traj: Traj] RETURNS [width: REAL] = {
firstSeg: Segment ← FetchSegment[traj, 0];
seg: Segment;
width ← firstSeg.strokeWidth;
FOR i: INT IN [1..HiSegment[traj]] DO
seg ← FetchSegment[traj, i];
IF seg.strokeWidth # width THEN RETURN[-1.0];
ENDLOOP;
};
AllStrokeEndsEqual: PROC [traj: Traj] RETURNS [allEqual: BOOL, end: StrokeEnd] = {
firstSeg: Segment ← FetchSegment[traj, 0];
seg: Segment;
end ← firstSeg.strokeEnd;
FOR i: INT IN [1..HiSegment[traj]] DO
seg ← FetchSegment[traj, i];
IF seg.strokeEnd # end THEN RETURN[FALSE, round];
ENDLOOP;
allEqual ← TRUE;
};
AllStrokeColorsEqual: PROC [traj: Traj] RETURNS [allEqual: BOOL, color: Color] = {
firstSeg: Segment ← FetchSegment[traj, 0];
seg: Segment;
color ← firstSeg.color;
FOR i: INT IN [1..HiSegment[traj]] DO
seg ← FetchSegment[traj, i];
IF seg.color # color THEN RETURN[FALSE, NIL]; NONSENSE !!
IF NOT GGUtility.EquivalentColors[color, seg.color] THEN RETURN[FALSE, NIL];
ENDLOOP;
allEqual ← TRUE;
};
AllDashesEqual: PROC [traj: Traj] RETURNS [allEqual: BOOL, dashed: BOOL ← FALSE, pattern: SequenceOfReal ← NIL, offset, length: REAL ← 0.0] = {
firstSeg: Segment ← FetchSegment[traj, 0];
seg: Segment;
dashed ← firstSeg.dashed;
pattern ← firstSeg.pattern;
offset ← firstSeg.offset;
length ← firstSeg.length;
FOR i: INT IN [1..HiSegment[traj]] DO
seg ← FetchSegment[traj, i];
IF seg.dashed # dashed THEN RETURN[FALSE];
IF NOT dashed THEN LOOP;
IF NOT EqualSequence[seg.pattern, pattern] THEN RETURN[FALSE];
IF seg.offset # offset THEN RETURN[FALSE];
IF seg.length # length THEN RETURN[FALSE];
ENDLOOP;
allEqual ← TRUE;
};
SegmentSelected: PROC [segNum: NAT, selectedSeq: Sequence] RETURNS [BOOL] = {
RETURN[selectedSeq.segments[segNum]];
};
DrawSequenceFeedback: PUBLIC PROC [dc: Imager.Context, seq: Sequence, normalSeq: Sequence, camera: CameraData, quick: BOOL ← FALSE, selectClass: SelectionClass ← normal] = {
segGen: SegmentGenerator;
color: Imager.Color;
IF camera.quality = quality THEN RETURN;
segGen ← GGSequence.SegmentsInSequence[seq];
Imager.SetColor[dc, Imager.black];
IF NOT quick THEN { -- draw full selection feedback
Imager.SetStrokeJoint[dc, seq.traj.strokeJoint];
FOR next: SegAndIndex ← GGSequence.NextSegmentAndIndex[segGen], GGSequence.NextSegmentAndIndex[segGen] UNTIL next.seg = NIL DO
IF SegmentSelected[next.index, normalSeq] THEN {
Imager.SetStrokeWidth[dc, 2.0*(IF next.seg.strokeWidth#0 THEN next.seg.strokeWidth ELSE 1.0)];
Imager.SetStrokeEnd[dc, next.seg.strokeEnd];
color ← IF (next.seg.color=NIL OR ImagerColorPrivate.GrayFromColor[NARROW[next.seg.color]] < 0.2) THEN Imager.black ELSE next.seg.color;
Imager.SetColor[dc, color]; -- want to always see feedback, even if stroke is white or NIL colored
MaskStroke[dc, next.seg];
};
ENDLOOP;
};
};
DrawThemJoints: PROC [dc: Imager.Context, traj: Traj, segNum: NAT, normalSeq: Sequence, hotSeq: Sequence] = {
drewLo, drewHi: BOOL ← FALSE;
seg: Segment ← FetchSegment[traj, segNum];
nextJoint: NAT ← FollowingJoint[traj, segNum];
IF hotSeq # NIL THEN {
IF hotSeq.joints[segNum] THEN {
GGShapes.DrawSelectedJoint[dc, seg.lo, hot];
drewLo ← TRUE;
};
IF hotSeq.joints[nextJoint] THEN {
GGShapes.DrawSelectedJoint[dc, seg.hi, hot];
drewHi ← TRUE;
};
};
IF normalSeq # NIL THEN {
IF normalSeq.joints[segNum] THEN {
GGShapes.DrawSelectedJoint[dc, seg.lo, normal];
drewLo ← TRUE;
};
IF normalSeq.joints[nextJoint] THEN {
GGShapes.DrawSelectedJoint[dc, seg.hi, normal];
drewHi ← TRUE;
};
};
IF seg.lo#seg.hi THEN { -- joints are not coincident
IF NOT drewLo THEN GGShapes.DrawJoint[dc, seg.lo];
IF NOT drewHi THEN GGShapes.DrawJoint[dc, seg.hi];
}
ELSE IF NOT (drewLo OR drewHi) THEN GGShapes.DrawJoint[dc, seg.hi];
};
Transforming
TranslateTraj: PUBLIC PROC [traj: Traj, vector: Vector] = {
A convenience routine which does a TransformTraj, where transform is a simple translation.
transform: ImagerTransformation.Transformation;
transform ← ImagerTransformation.Translate[[vector.x, vector.y]];
TransformTraj[traj, transform];
};
TransformTraj: PUBLIC PROC [traj: Traj, transform: ImagerTransformation.Transformation] = {
Individually translates each joint and control point of the trajectory.
seg: Segment;
joint: Joint;
FOR i: NAT IN [0..HiSegment[traj]] DO
seg ← FetchSegment[traj, i];
GGSegment.TransformSegment[seg, transform];
ENDLOOP;
FOR i: NAT IN [0..HiJoint[traj]] DO
joint ← NARROW[Rosary.Fetch[traj.joints, i]];
joint.point ← GGTransform.Transform[transform, joint.point];
ENDLOOP;
UpdateBoundBox[traj];
GGOutline.UpdateBoundBox[traj.parent];
};
TransformSequence: PUBLIC PROC [seq: Sequence, transform: ImagerTransformation.Transformation] = {
A tricky operation. All selected segments are transformed. Then, all segments which are not selected but which touch a selected joint are told that the joint has moved.
joint: Joint;
seg: Segment;
SELECT seq.traj.role FROM
open => TransformSequenceOpen[seq, transform];
fence, hole => TransformSequenceClosed[seq, transform];
ENDCASE => ERROR;
FOR i: NAT IN [0..HiJoint[seq.traj]] DO
IF seq.joints[i] THEN {
joint ← NARROW[Rosary.Fetch[seq.traj.joints, i]];
joint.point ← GGTransform.Transform[transform, joint.point];
};
ENDLOOP;
FOR i: NAT IN [0..HiSegment[seq.traj]] DO
cpCount: NAT ← seq.controlPoints[i].len;
FOR j: NAT IN [0..cpCount) DO
IF seq.controlPoints[i][j] AND NOT seq.segments[i] THEN {
seg ← NARROW[Rosary.Fetch[seq.traj.segments, i]];
seg.class.controlPointMoved[seg, transform, j];
};
ENDLOOP;
ENDLOOP;
UpdateBoundBox[seq.traj];
GGOutline.UpdateBoundBox[seq.traj.parent];
};
TransformSequenceOpen: PUBLIC PROC [seq: Sequence, transform: ImagerTransformation.Transformation] = {
seg: Segment;
FOR i: NAT IN [0..HiSegment[seq.traj]] DO
seg ← FetchSegment[seq.traj, i];
IF seq.segments[i] THEN {
GGSegment.TransformSegment[seg, transform];
}
ELSE {
IF seq.joints[i] THEN GGSegment.MoveEndPointSegment[seg, TRUE, GGTransform.Transform[transform, seg.lo]];
IF seq.joints[i+1] THEN GGSegment.MoveEndPointSegment[seg, FALSE, GGTransform.Transform[transform, seg.hi]];
};
ENDLOOP;
};
TransformSequenceClosed: PUBLIC PROC [seq: Sequence, transform: ImagerTransformation.Transformation] = {
A tricky operation. All selected segments are transformed. Then, all segments which are not selected but which touch a selected joint are told that the joint has moved.
seg: Segment;
hiSeg: NAT ← HiSegment[seq.traj];
FOR i: NAT IN [0..hiSeg-1] DO
seg ← FetchSegment[seq.traj, i];
IF seq.segments[i] THEN {
GGSegment.TransformSegment[seg, transform];
}
ELSE {
IF seq.joints[i] THEN GGSegment.MoveEndPointSegment[seg, TRUE, GGTransform.Transform[transform, seg.lo]];
IF seq.joints[i+1] THEN GGSegment.MoveEndPointSegment[seg, FALSE, GGTransform.Transform[transform, seg.hi]];
};
ENDLOOP;
seg ← FetchSegment[seq.traj, hiSeg];
IF seq.segments[hiSeg] THEN {
GGSegment.TransformSegment[seg, transform];
}
ELSE {
IF seq.joints[hiSeg] THEN GGSegment.MoveEndPointSegment[seg, TRUE, GGTransform.Transform[transform, seg.lo]];
IF seq.joints[0] THEN GGSegment.MoveEndPointSegment[seg, FALSE, GGTransform.Transform[transform, seg.hi]];
};
};
Textual Description
DescribeHit: PUBLIC PROC [traj: Traj, hitType: HitType, segNum, cpNum, jointNum: INT] RETURNS [rope: Rope.ROPE] = {
SELECT hitType FROM
joint => rope ← GGDescribe.DescribeJoint[traj, jointNum];
controlPoint => rope ← GGDescribe.DescribeControlPoint[traj, segNum, cpNum];
segment => rope ← GGDescribe.DescribeSegment[traj, segNum];
ENDCASE => ERROR;
};
GetArrowCode: PROC [traj: Traj] RETURNS [code: NAT] = {
code ←
IF NOT traj.hiArrow THEN
IF NOT traj.loArrow THEN 0
ELSE 1
ELSE
IF NOT traj.loArrow THEN 2
ELSE 3;
};
Fileout: PUBLIC PROC [f: IO.STREAM, traj: Traj] = {
roleRope: Rope.ROPE ← RoleToRope[traj.role];
strokeWidth, offset, length: REAL;
strokeOK, endsOK, colorOK, dashOK, dashed: BOOL;
pattern: SequenceOfReal;
color: Color;
point: Point;
end: StrokeEnd;
className: Rope.ROPE;
seg: Segment;
arrowCode: NAT;
hiJoint: NAT ← HiJoint[traj];
Properties of the whole trajectory.
arrowCode ← GetArrowCode[traj];
f.PutF["Traj (%g) [%g] arrows: %g ", [rope[roleRope]], [integer[hiJoint]], [integer[arrowCode]]];
f.PutRope["j: "]; -- traj Joint
GGParseOut.WriteStrokeJoint[f, traj.strokeJoint];
individual segments the same ??
[endsOK, end] ← AllStrokeEndsEqual[traj];
f.PutRope[" e: "];
GGParseOut.WriteBOOL[f, endsOK];
f.PutChar[IO.SP];
GGParseOut.WriteStrokeEnd[f, end];
f.PutChar[IO.SP];
strokeWidth ← AllStrokeWidthsEqual[traj];
strokeOK ← strokeWidth >= 0.0;
f.PutF["w: %g ", [real[strokeWidth]]];
[colorOK, color] ← AllStrokeColorsEqual[traj];
f.PutRope["c: "];
GGParseOut.WriteBOOL[f, colorOK];
f.PutChar[IO.SP];
GGParseOut.WriteColor[f, color];
f.PutChar[IO.SP];
[dashOK, dashed, pattern, offset, length] ← AllDashesEqual[traj];
f.PutRope["d: "];
GGParseOut.WriteBOOL[f, dashOK];
IF dashOK THEN {
f.PutChar[IO.SP];
GGParseOut.WriteBOOL[f, dashed];
f.PutChar[IO.SP];
IF dashed THEN {
GGParseOut.WriteArrayOfReal[f, pattern];
f.PutF[" %g %g", [real[offset]], [real[length]]];
};
};
f.PutChar[IO.CR];
Now fileout the segment data.
point ← FetchJointPos[traj, 0];
GGParseOut.WritePoint[f, point];
FOR index: NAT IN [1..hiJoint] DO
seg ← FetchSegment[traj, index - 1];
className ← Atom.GetPName[seg.class.type];
IF strokeOK THEN f.PutF[" (%g ", [rope[className]]]
ELSE f.PutF[" (%g %g ", [rope[className]], [real[seg.strokeWidth]]];
IF NOT endsOK THEN {
GGParseOut.WriteStrokeEnd[f, seg.strokeEnd];
f.PutChar[IO.SP];
};
IF NOT colorOK THEN {
GGParseOut.WriteColor[f, seg.color];
f.PutChar[IO.SP];
};
IF NOT dashOK THEN {
GGParseOut.WriteBOOL[f, seg.dashed]; f.PutChar[IO.SP];
IF seg.dashed THEN {
GGParseOut.WriteArrayOfReal[f, seg.pattern]; f.PutChar[IO.SP];
f.PutF[" %g %g ", [real[seg.offset]], [real[seg.length]]];
};
};
seg.class.fileOut[seg, f];
GGParseOut.WriteProps[f, seg.props];
f.PutRope[") "];
point ← FetchJointPos[traj, index];
GGParseOut.WritePoint[f, point];
ENDLOOP;
IF (traj.role = fence OR traj.role = hole) THEN {
seg ← FetchSegment[traj, hiJoint];
className ← Atom.GetPName[seg.class.type];
IF strokeOK THEN f.PutF[" (%g ", [rope[className]]]
ELSE f.PutF[" (%g %g ", [rope[className]], [real[seg.strokeWidth]]];
IF NOT endsOK THEN {
GGParseOut.WriteStrokeEnd[f, seg.strokeEnd];
f.PutChar[IO.SP];
};
IF NOT colorOK THEN {
GGParseOut.WriteColor[f, seg.color];
f.PutChar[IO.SP];
};
IF NOT dashOK THEN {
GGParseOut.WriteBOOL[f, seg.dashed]; f.PutChar[IO.SP];
IF seg.dashed THEN {
GGParseOut.WriteArrayOfReal[f, seg.pattern]; f.PutChar[IO.SP];
f.PutF[" %g %g ", [real[seg.offset]], [real[seg.length]]];
};
};
seg.class.fileOut[seg, f];
GGParseOut.WriteProps[f, seg.props];
f.PutRope[")"];
};
f.PutChar[IO.CR];
};
Filein: PUBLIC PROC [f: IO.STREAM, version: REAL] RETURNS [traj: Traj, hasCircle: BOOL ← FALSE] = {
hiJoint, arrowCode: NAT;
role: FenceHoleOpen;
roleName, className: Rope.ROPE;
pFirst, p0, p1: Point;
seg: Segment;
class: SegmentClass;
strokeWidth, offset, length: REAL;
pattern: SequenceOfReal;
strokeColor: Color;
strokeEnd: StrokeEnd;
strokeJoint: StrokeJoint;
success, colorOK, widthOK, endsOK, dashOK, dashed, good: BOOL;
Traj (fence) [3] arrows: 0:
GGParseIn.ReadBlankAndRope[f, "Traj"];
GGParseIn.ReadBlankAndRope[f, "("];
roleName ← GGParseIn.ReadBlankAndWord[f];
role ← RoleFromRope[roleName];
GGParseIn.ReadBlankAndRope[f, ")"];
GGParseIn.ReadBlankAndRope[f, "["];
hiJoint ← GGParseIn.ReadBlankAndNAT[f];
GGParseIn.ReadBlankAndRope[f, "]"];
IF version >= 8607.22 THEN {
GGParseIn.ReadBlankAndRope[f, "arrows:"];
arrowCode ← GGParseIn.ReadBlankAndNAT[f];
}
ELSE arrowCode ← 0;
IF version >= 8702.26 THEN {
GGParseIn.ReadBlankAndRope[f, "j:"];
strokeJoint ← GGParseIn.ReadStrokeJoint[f];
GGParseIn.ReadBlankAndRope[f, "e:"];
[endsOK, good] ← GGParseIn.ReadBOOL[f, version];
IF NOT good THEN ERROR;
strokeEnd ← GGParseIn.ReadStrokeEnd[f];
}
ELSE {
strokeJoint ← round;
endsOK ← FALSE;
};
IF version >= 8701.135 THEN {
good: BOOL;
GGParseIn.ReadBlankAndRope[f, "w:"];
strokeWidth ← GGParseIn.ReadBlankAndReal[f];
widthOK ← strokeWidth>= 0.0;
GGParseIn.ReadBlankAndRope[f, "c:"];
[colorOK, good] ← GGParseIn.ReadBOOL[f, version];
IF NOT good THEN ERROR;
strokeColor ← GGParseIn.ReadColor[f, version];
}
ELSE {
GGParseIn.ReadBlankAndRope[f, ":"];
widthOK ← FALSE;
colorOK ← FALSE;
};
IF version >= 8701.23
THEN {
GGParseIn.ReadBlankAndRope[f, "d:"];
[dashOK, good] ← GGParseIn.ReadBOOL[f, version];
IF NOT good THEN ERROR;
IF dashOK THEN {
[dashed, good] ← GGParseIn.ReadBOOL[f, version];
IF NOT good THEN ERROR;
IF dashed THEN {
pattern ← GGParseIn.ReadArrayOfReal[f];
offset ← GGParseIn.ReadBlankAndReal[f];
length ← GGParseIn.ReadBlankAndReal[f];
};
};
}
ELSE {
dashOK ← TRUE;
dashed ← FALSE;
};
Now read the Segment data.
pFirst ← p0 ← GGParseIn.ReadPoint[f];
traj ← CreateTraj[p0];
traj.strokeJoint ← strokeJoint;
FOR index: NAT IN [1..hiJoint] DO
GGParseIn.ReadBlankAndRope[f, "("];
className ← GGParseIn.ReadBlankAndWord[f];
IF NOT widthOK THEN strokeWidth ← GGParseIn.ReadBlankAndReal[f];
IF version >= 8702.26 THEN {
IF NOT endsOK THEN strokeEnd ← GGParseIn.ReadStrokeEnd[f];
}
ELSE strokeEnd ← round;
IF version >= 8607.30 THEN {
IF NOT colorOK THEN strokeColor ← GGParseIn.ReadColor[f, version];
}
ELSE strokeColor ← Imager.black;
IF NOT dashOK THEN {
[dashed, good] ← GGParseIn.ReadBOOL[f, version];
IF NOT good THEN ERROR;
IF dashed THEN {
pattern ← GGParseIn.ReadArrayOfReal[f];
offset ← GGParseIn.ReadBlankAndReal[f];
length ← GGParseIn.ReadBlankAndReal[f];
};
};
class ← GGSegment.FetchSegmentClass[Atom.MakeAtom[className]];
seg ← class.fileIn[f, p0, [0.0, 0.0], version];
IF version >= 8610.29 THEN {
lor: LIST OF Rope.ROPE;
lor ← GGParseIn.ReadListOfRope[f]; -- ReadListOfRope cheats and terminates at ') as well as at IO.CR
FOR next: LIST OF Rope.ROPE ← lor, next.rest UNTIL next=NIL DO
seg.props ← CONS[next.first, seg.props];
ENDLOOP;
};
GGParseIn.ReadBlankAndRope[f, ")"];
p1 ← GGParseIn.ReadPoint[f];
seg.hi ← p1;
seg.class.endPointMoved[seg, FALSE, p1];
seg.strokeWidth ← strokeWidth;
seg.strokeEnd ← strokeEnd;
seg.color ← strokeColor;
seg.dashed ← dashed;
seg.pattern ← pattern;
seg.offset ← offset;
seg.length ← length;
IF class.type=$Circle OR class.type=$Disc THEN {
fake it with a closed arc segment
p: Point ← Vectors2d.Sub[seg.hi, seg.lo];
newJoint: Point ← [seg.lo.x-p.x, seg.lo.y-p.y];
newCp: Point ← [seg.lo.x+p.x, seg.lo.y+p.y];
success ← AddSegment[traj, hi, GGSegment.MakeArc[newJoint, newCp, newJoint, NIL], lo];
CloseByDistorting[traj, lo];
hasCircle ← TRUE;
}
ELSE success ← AddSegment[traj, hi, seg, lo];
IF NOT success THEN ERROR;
p0 ← p1;
ENDLOOP;
IF (role = fence OR role = hole) THEN {
GGParseIn.ReadBlankAndRope[f, "("];
className ← GGParseIn.ReadBlankAndWord[f];
IF NOT widthOK THEN strokeWidth ← GGParseIn.ReadBlankAndReal[f];
IF version >= 8702.26 THEN {
IF NOT endsOK THEN strokeEnd ← GGParseIn.ReadStrokeEnd[f];
}
ELSE strokeEnd ← round;
IF version >= 8607.30 THEN {
IF NOT colorOK THEN strokeColor ← GGParseIn.ReadColor[f, version];
}
ELSE strokeColor ← Imager.black;
IF NOT dashOK THEN {
[dashed, good] ← GGParseIn.ReadBOOL[f, version];
IF NOT good THEN ERROR;
IF dashed THEN {
pattern ← GGParseIn.ReadArrayOfReal[f];
offset ← GGParseIn.ReadBlankAndReal[f];
length ← GGParseIn.ReadBlankAndReal[f];
};
};
class ← GGSegment.FetchSegmentClass[Atom.MakeAtom[className]];
seg ← class.fileIn[f, p0, pFirst, version];
IF version >= 8610.29 THEN {
lor: LIST OF Rope.ROPE;
lor ← GGParseIn.ReadListOfRope[f]; -- ReadListOfRope cheats and terminates at ') as well as at IO.CR
FOR next: LIST OF Rope.ROPE ← lor, next.rest UNTIL next=NIL DO
seg.props ← CONS[next.first, seg.props];
ENDLOOP;
};
GGParseIn.ReadBlankAndRope[f, ")"];
seg.strokeWidth ← strokeWidth;
seg.color ← strokeColor;
seg.strokeEnd ← strokeEnd;
seg.dashed ← dashed;
seg.pattern ← pattern;
seg.offset ← offset;
seg.length ← length;
IF traj.segCount=0 THEN { -- special case of closed single segment trajectory
success ← AddSegment[traj, hi, seg, lo];
IF NOT success THEN ERROR;
CloseByDistorting[traj, lo];
}
ELSE CloseWithSegment[traj, seg, lo];
};
};
RoleFromRope: PROC [roleName: Rope.ROPE] RETURNS [role: FenceHoleOpen] = {
SELECT TRUE FROM
Rope.Equal[roleName, "fence"] => role ← fence;
Rope.Equal[roleName, "hole"] => role ← hole;
Rope.Equal[roleName, "open"] => role ← open;
ENDCASE => ERROR;
};
RoleToRope: PROC [role: FenceHoleOpen] RETURNS [roleName: Rope.ROPE] = {
SELECT role FROM
fence => roleName ← "fence";
hole => roleName ← "hole";
open => roleName ← "open";
ENDCASE => ERROR;
};
Accessing Parts
FetchSegment: PUBLIC PROC [traj: Traj, index: NAT] RETURNS [seg: Segment] = {
seg ← NARROW[Rosary.Fetch[traj.segments, index]];
};
FetchJoint: PUBLIC PROC [traj: Traj, index: NAT] RETURNS [joint: Joint] = {
joint ← NARROW[Rosary.Fetch[traj.joints, index]];
};
FetchJointPos: PUBLIC PROC [traj: Traj, index: NAT] RETURNS [point: Point] = {
joint: Joint;
IF index < 0 OR index > HiJoint[traj] THEN ERROR;
joint ← NARROW[Rosary.Fetch[traj.joints, index]];
point ← joint.point
};
LastJointPos: PUBLIC PROC [traj: Traj] RETURNS [point: Point] = {
joint: Joint ← NARROW[Rosary.Fetch[traj.joints, traj.segCount]];
point ← joint.point
};
SetJointPos: PUBLIC PROC [traj: Traj, index: NAT, newPos: Point] = {
Moves the given joint and tells all interested segments that it has moved.
joint: Joint ← NARROW[Rosary.Fetch[traj.joints, index]];
segLeft, segRight: Segment;
joint.point ← newPos;
IF index > 0 THEN {
segLeft ← FetchSegment[traj, index-1];
segLeft.hi ← newPos;
};
IF index < traj.segCount THEN {
segRight ← FetchSegment[traj, index];
segRight.lo ← newPos;
};
};
HiSegment: PUBLIC PROC [traj: Traj] RETURNS [highestIndex: NAT] = {
highestIndex ← traj.segCount - 1;
};
HiJoint: PUBLIC PROC [traj: Traj] RETURNS [highestIndex: NAT] = {
SELECT traj.role FROM
open => highestIndex ← traj.segCount;
fence, hole => highestIndex ← traj.segCount -1;
ENDCASE => ERROR;
};
PreviousSegment: PUBLIC PROC [traj: Traj, segNum: NAT] RETURNS [prev: Segment] = {
IF traj.role = open THEN {
IF segNum = 0 THEN RETURN[NIL]
ELSE prev ← FetchSegment[traj, segNum - 1];
}
ELSE {
prev ← FetchSegment[traj, (segNum-1+traj.segCount) MOD traj.segCount];
};
};
PreviousSegmentNum: PUBLIC PROC [traj: Traj, segNum: NAT] RETURNS [prevNum: INT] = {
prevNum ← IF traj.role = open THEN segNum - 1 ELSE (segNum-1+traj.segCount) MOD traj.segCount;
};
FollowingSegmentNum: PUBLIC PROC [traj: Traj, segNum: NAT] RETURNS [followNum: INT] = {
IF traj.role = open THEN followNum ← IF segNum = HiSegment[traj] THEN -1 ELSE segNum + 1
ELSE followNum ← (segNum+1) MOD traj.segCount;
};
FollowingJoint: PUBLIC PROC [traj: Traj, index: NAT] RETURNS [nextIndex: INT] = {
SELECT traj.role FROM
open => nextIndex ← IF index = traj.segCount THEN -1 ELSE index + 1;
fence, hole => nextIndex ← (index + 1) MOD traj.segCount;
ENDCASE => ERROR;
};
IsEndJoint: PUBLIC PROC [traj: Traj, index: NAT] RETURNS [BOOL] = {
SELECT traj.role FROM
open => RETURN[index = 0 OR index = traj.segCount];
fence, hole => RETURN[FALSE];
ENDCASE => ERROR;
};
Use sparingly
Parts
SetTrajPartField: PROC [traj: Traj, selected: BOOL, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => traj.selectedInPart.normal ← selected;
hot => traj.selectedInPart.hot ← selected;
active => traj.selectedInPart.active ← selected;
ENDCASE;
};
SetSelectedFields: PUBLIC PROC [seq: Sequence, selected: BOOL, selectClass: SelectionClass] = {
joint: Joint;
jointGen: JointGenerator;
segGen: SegmentGenerator;
SetTrajPartField[seq.traj, selected, selectClass];
jointGen ← GGSequence.JointsInSequence[seq];
Joint Fields.
FOR jointNum: INT ← GGSequence.NextJoint[jointGen], GGSequence.NextJoint[jointGen] UNTIL jointNum = -1 DO
joint ← FetchJoint[seq.traj, jointNum];
SetJointField[joint, selected, selectClass];
ENDLOOP;
Segment Fields.
segGen ← GGSequence.SegmentsInSequence[seq];
FOR seg: Segment ← GGSequence.NextSegment[segGen], GGSequence.NextSegment[segGen] UNTIL seg = NIL DO
SetSegmentField[seg, selected, selectClass];
ENDLOOP;
};
SaveSelection: PUBLIC PROC [traj: Traj, selectClass: SelectionClass, scene: Scene] = {
seq: Sequence ← GGSelect.FindSelectedSequence[traj, scene, selectClass];
IF seq=NIL THEN ClearSelection[traj, selectClass]
ELSE SaveSelectionInSequence[seq, selectClass];
};
SaveSelectionInSequence: PUBLIC PROC [seq: Sequence, selectClass: SelectionClass] = {
seg: Segment;
joint: Joint;
FOR i: NAT IN [0..HiSegment[seq.traj]] DO
seg ← FetchSegment[seq.traj, i];
SetSegmentField[seg, seq.segments[i], selectClass];
FOR j: NAT IN [0..seg.class.controlPointCount[seg]-1] DO
SetControlPointField[seg, j, seq.controlPoints[i][j], selectClass];
ENDLOOP;
ENDLOOP;
FOR i: NAT IN [0..HiJoint[seq.traj]] DO
joint ← FetchJoint[seq.traj, i];
SetJointField[joint, seq.joints[i], selectClass];
ENDLOOP;
};
ClearSelection: PUBLIC PROC [traj: Traj, selectClass: SelectionClass] = {
seg: Segment;
joint: Joint;
FOR i: NAT IN [0..HiSegment[traj]] DO
seg ← FetchSegment[traj, i];
SetSegmentField[seg, FALSE, selectClass];
FOR j: NAT IN [0..seg.class.controlPointCount[seg]-1] DO
SetControlPointField[seg, j, FALSE, selectClass];
ENDLOOP;
ENDLOOP;
FOR i: NAT IN [0..HiJoint[traj]] DO
joint ← FetchJoint[traj, i];
SetJointField[joint, FALSE, selectClass];
ENDLOOP;
};
RemakeSelection: PUBLIC PROC [traj: Traj, scene: Scene, selectClass: SelectionClass] = {
seq: Sequence ← GGSequence.CreateEmpty[traj];
seg: Segment;
joint: Joint;
FOR i: NAT IN [0..HiSegment[traj]] DO
seg ← FetchSegment[traj, i];
seq.segments[i] ← GetSegmentField[seg, selectClass];
IF seq.segments[i] THEN seq.segCount ← seq.segCount + 1;
FOR j: NAT IN [0..seg.class.controlPointCount[seg]-1] DO
seq.controlPoints[i][j] ← GetControlPointField[seg, j, selectClass];
IF seq.controlPoints[i][j] THEN seq.controlPointCount ← seq.controlPointCount + 1;
ENDLOOP;
ENDLOOP;
FOR i: NAT IN [0..HiJoint[traj]] DO
joint ← FetchJoint[traj, i];
seq.joints[i] ← GetJointField[joint, selectClass];
IF seq.joints[i] THEN seq.jointCount ← seq.jointCount + 1;
ENDLOOP;
GGSelect.SelectSequence[seq, scene, selectClass];
};
SetControlPointField: PUBLIC PROC [seg: Segment, cpNum: NAT, selected: BOOL, selectClass: SelectionClass] = {
seg.class.controlPointFieldSet[seg, cpNum, selected, selectClass];
};
GetControlPointField: PUBLIC PROC [seg: Segment, cpNum: NAT, selectClass: SelectionClass] RETURNS [selected: BOOL] = {
selected ← seg.class.controlPointFieldGet[seg, cpNum, selectClass];
};
GetJointField: PUBLIC PROC [joint: Joint, selectClass: SelectionClass] RETURNS [selected: BOOL] = {
SELECT selectClass FROM
normal => selected ← joint.TselectedInFull.normal;
hot => selected ← joint.TselectedInFull.hot;
active => selected ← joint.TselectedInFull.active;
ENDCASE;
};
GetSegmentField: PUBLIC PROC [seg: Segment, selectClass: SelectionClass] RETURNS [selected: BOOL] = {
SELECT selectClass FROM
normal => selected ← seg.TselectedInFull.normal;
hot => selected ← seg.TselectedInFull.hot;
active => selected ← seg.TselectedInFull.active;
ENDCASE;
};
SetJointField: PUBLIC PROC [joint: Joint, selected: BOOL, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => joint.TselectedInFull.normal ← selected;
hot => joint.TselectedInFull.hot ← selected;
active => joint.TselectedInFull.active ← selected;
ENDCASE;
};
SetSegmentField: PUBLIC PROC [seg: Segment, selected: BOOL, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => seg.TselectedInFull.normal ← selected;
hot => seg.TselectedInFull.hot ← selected;
active => seg.TselectedInFull.active ← selected;
ENDCASE;
};
Utilities
CopyJoint: PROC [joint: Joint] RETURNS [copy: Joint] = {
copy ← NEW[JointObj ← [point: joint.point, TselectedInFull: joint.TselectedInFull] ];
};
Hit Testing
TrajPointGeneratorData: TYPE = REF TrajPointGeneratorDataObj;
TrajPointGeneratorDataObj: TYPE = RECORD [
jointsDone: BOOL,
jointGen: JointGenerator,
cpGen: GGModelTypes.ControlPointGenerator
];
TrajPointPairGeneratorData: TYPE = REF TrajPointPairGeneratorDataObj;
TrajPointPairGeneratorDataObj: TYPE = RECORD [
segGen: SegmentGenerator
];
PointsInDescriptor: PUBLIC PROC [seq: Sequence] RETURNS [pointGen: GGModelTypes.PointGenerator] = {
pgd: TrajPointGeneratorData;
jointGen: JointGenerator;
cpGen: GGModelTypes.ControlPointGenerator;
jointGen ← GGSequence.JointsInSequence[seq];
cpGen ← GGSequence.ControlPointsInSequence[seq];
pgd ← NEW[TrajPointGeneratorDataObj ← [FALSE, jointGen, cpGen]];
pointGen ← NEW[GGModelTypes.PointGeneratorObj ← [NIL, 0, 0, pgd]];
};
PointPairsInDescriptor: PUBLIC PROC [seq: Sequence] RETURNS [pointPairGen: GGModelTypes.PointPairGenerator] = {
pgd: TrajPointPairGeneratorData;
segGen: SegmentGenerator;
segGen ← GGSequence.SegmentsInSequence[seq];
pgd ← NEW[TrajPointPairGeneratorDataObj ← [segGen]];
pointPairGen ← NEW[GGModelTypes.PointPairGeneratorObj ← [NIL, 0, 0, pgd]];
};
NextPoint: PUBLIC PROC [pointGen: GGModelTypes.PointGenerator] RETURNS [pointAndDone: GGModelTypes.PointAndDone] = {
pgd: TrajPointGeneratorData ← NARROW[pointGen.classSpecific];
IF NOT pgd.jointsDone THEN {
nextJoint: INT ← GGSequence.NextJoint[pgd.jointGen];
IF nextJoint = -1 THEN {
pgd.jointsDone ← TRUE;
}
ELSE {
pointAndDone.point ← FetchJointPos[pgd.jointGen.seq.traj, nextJoint];
pointAndDone.done ← FALSE;
RETURN;
};
};
Time to look at the control points.
pointAndDone ← GGSequence.NextControlPoint[pgd.cpGen];
};
NextPointPair: PUBLIC PROC [pointGen: GGModelTypes.PointPairGenerator] RETURNS [pointPairAndDone: GGModelTypes.PointPairAndDone] = {
pgd: TrajPointPairGeneratorData ← NARROW[pointGen.classSpecific];
seg: Segment;
seg ← GGSequence.NextSegment[pgd.segGen];
IF seg = NIL THEN RETURN[[[0,0], [0,0], TRUE]]
ELSE RETURN[[seg.lo, seg.hi, FALSE]];
};
Style
SetArrows: PUBLIC PROC [traj: Traj, loArrow, hiArrow: BOOL] = {
Will there be an arrowhead on the lo end of traj? On the hi end?
traj.loArrow ← loArrow;
traj.hiArrow ← hiArrow;
};
SetTrajStrokeJoint: PUBLIC PROC [traj: Traj, strokeJoint: StrokeJoint] = {
traj.strokeJoint ← strokeJoint;
};
GetTrajStrokeJoint: PUBLIC PROC [traj: Traj] RETURNS [strokeJoint: StrokeJoint] = {
RETURN[traj.strokeJoint];
};
Utilities
Vector3D: TYPE = ARRAY [1..3] OF REAL;
PointToVector: PROC [point: Point] RETURNS [vector: Vector3D] = {
vector[1] ← point.x;
vector[2] ← point.y;
vector[3] ← 0;
};
CrossProduct: PROC [v1: Vector3D, v2: Vector3D] RETURNS [prodV: Vector3D] = {
| i j k |
| v1x v1y v1z |=(v1y*v2z - v1z*v2y) i + (v1z*v2x - v1x*v2z) j
| v2x v2y v2z |(v1x*v2y - v1y*v2x) k
prodV[1] ← v1[2]*v2[3] - v1[3]*v2[2];
prodV[2] ← v1[3]*v2[1] - v1[1]*v2[3];
prodV[3] ← v1[1]*v2[2] - v1[2]*v2[1];
};
GetPartialArea: PROC [pt1: Point, pt2: Point] RETURNS [partial: REAL] = {
D1: Vector3D ← PointToVector[pt1];
D2: Vector3D ← PointToVector[pt2];
areaVector: Vector3D ← CrossProduct[D2, D1];-- will only have a z component
RETURN [areaVector[3]];
};
SignedArea: PROC [traj: Traj] RETURNS [area: REAL ← 0.0] = {
Choose an arbitrary point P in the plane. Choose two consecutive joints (v1, v2) on the polygon described by the traj. Call the vector P to v1, D1. Call the distance P to v2, D2. The area of the triangle made by these three points is |D1|*|D2|*sin(angle between D1 and D2)/2.
This is just D2 x D1 where "x" is the cross product operator.
This will be positive if D2 is clockwise of D1.
If P is in the interior of poly for poly convex, and if we add up all of the areas we get by taking vertices pairwise in clockwise order, area will be positive. If we take them in counter-clockwise order, area will be negative. This turns out to be true whatever the position of P and even if poly is concave part of the time.
lastPoint, thisPoint: Point ← FetchJointPos[traj, 0];
hiSeg: NAT ← HiSegment[traj];
thisSeg: Segment;
FOR index: NAT IN [0..hiSeg] DO
thisSeg ← FetchSegment[traj, index];
FOR cpIndex: NAT IN [0..thisSeg.class.controlPointCount[thisSeg]) DO
area ← area + GetPartialArea[lastPoint, (thisPoint ← thisSeg.class.controlPointGet[thisSeg, cpIndex])];
lastPoint ← thisPoint;
ENDLOOP;
area ← area + GetPartialArea[lastPoint, (thisPoint ← FetchJointPos[traj, IF index=hiSeg THEN 0 ELSE index+1])];
lastPoint ← thisPoint;
ENDLOOP;
}; -- end of SignedArea
SignedAreaTransformSeq: PROC [seq: Sequence, transform: ImagerTransformation.Transformation] RETURNS [area: REAL ← 0.0] = {
lastPoint, thisPoint: Point;
hiSeg: NAT ← HiSegment[seq.traj];
thisSeg: Segment;
lastPoint ← FetchJointPos[seq.traj, 0];
IF seq.joints[0] THEN lastPoint ← ImagerTransformation.Transform[transform, lastPoint];
FOR index: NAT IN [0..hiSeg] DO
thisSeg ← FetchSegment[seq.traj, index];
FOR cpIndex: NAT IN [0..thisSeg.class.controlPointCount[thisSeg]) DO
thisPoint ← thisSeg.class.controlPointGet[thisSeg, cpIndex];
IF seq.controlPoints[index][cpIndex] THEN thisPoint ← ImagerTransformation.Transform[transform, thisPoint];
area ← area + GetPartialArea[lastPoint, thisPoint];
lastPoint ← thisPoint;
ENDLOOP;
thisPoint ← FetchJointPos[seq.traj, IF index=hiSeg THEN 0 ELSE index+1];
IF seq.joints[IF index=hiSeg THEN 0 ELSE index+1] THEN thisPoint ← ImagerTransformation.Transform[transform, thisPoint];
area ← area + GetPartialArea[lastPoint, thisPoint];
lastPoint ← thisPoint;
ENDLOOP;
}; -- end of SignedAreaTransformSeq
useBBox: BOOL = TRUE;
maxDistance: REAL = 99999.0;
noJoint: NAT = 9999;
noCP: NAT = 8888;
noSeg: NAT = 7777;
NearestSegment: PUBLIC PROC [testPoint: Point, seq: Sequence, tolerance: REAL] RETURNS [bestDist: REAL, bestSeg: NAT, bestPoint: Point, success: BOOL] = {
thisDist2, bestDist2: REAL;
thisPoint: Point;
segGen: SegmentGenerator;
thisSuccess: BOOL;
next: GGSequence.SegAndIndex;
bigBox: GGBasicTypes.BoundBoxObj;
success ← FALSE;
IF useBBox THEN {
bigBox ← [seq.boundBox.loX-tolerance, seq.boundBox.loY-tolerance, seq.boundBox.hiX+tolerance, seq.boundBox.hiY+tolerance, FALSE, FALSE];
IF NOT GGBoundBox.PointIsInBox[testPoint, bigBox] THEN RETURN; -- success=FALSE
};
segGen ← GGSequence.SegmentsInSequence[seq];
next ← GGSequence.NextSegmentAndIndex[segGen];
IF next.seg = NIL THEN { -- The sequence is a single joint
bestDist ← maxDistance; -- magic number for debugging
bestSeg ← noSeg; -- magic number meaning no segment
bestPoint ← [-1.0, -1.0];
RETURN;
};
[bestPoint, thisSuccess] ← next.seg.class.closestPoint[next.seg, testPoint, tolerance];
IF NOT thisSuccess THEN {
bestDist2 ← maxDistance;
bestSeg ← noSeg;
bestPoint ← [-1.0, -1.0];
}
ELSE {
bestDist2 ← Vectors2d.DistanceSquared[bestPoint, testPoint];
bestSeg ← next.index;
success ← TRUE;
};
FOR next ← GGSequence.NextSegmentAndIndex[segGen], GGSequence.NextSegmentAndIndex[segGen] UNTIL next.seg = NIL DO
[thisPoint, thisSuccess] ← next.seg.class.closestPoint[next.seg, testPoint, tolerance];
IF NOT thisSuccess THEN {
thisDist2 ← maxDistance;
thisPoint ← [-1.0, -1.0];
}
ELSE {
thisDist2 ← Vectors2d.DistanceSquared[thisPoint, testPoint];
success ← TRUE;
};
IF success AND thisDist2 < bestDist2 THEN {
bestDist2 ← thisDist2;
bestSeg ← next.index;
bestPoint ← thisPoint;
};
ENDLOOP;
bestDist ← RealFns.SqRt[bestDist2];
};
NearestJoint: PUBLIC PROC [testPoint: Point, seq: Sequence, tolerance: REAL] RETURNS [bestDist: REAL, bestJoint: NAT, bestPoint: Point, success: BOOL ← FALSE] = {
Finds the nearest joint of traj to testPoint (and its distance from testPoint).
tolerance2: REAL ← tolerance*tolerance;
thisDist2, bestDist2: REAL;
thisPoint: Point;
jointGen: JointGenerator;
index: INT;
bigBox: GGBasicTypes.BoundBoxObj;
IF useBBox THEN {
bigBox ← [seq.boundBox.loX-tolerance, seq.boundBox.loY-tolerance, seq.boundBox.hiX+tolerance, seq.boundBox.hiY+tolerance, FALSE, FALSE];
IF NOT GGBoundBox.PointIsInBox[testPoint, bigBox] THEN RETURN; -- success=FALSE
};
jointGen ← GGSequence.JointsInSequence[seq];
index ← GGSequence.NextJoint[jointGen];
IF index = -1 THEN {
bestDist ← maxDistance;
bestJoint ← noJoint;
bestPoint ← [-1.0, -1.0];
RETURN;
};
bestPoint ← FetchJointPos[seq.traj, index];
bestDist2 ← Vectors2d.DistanceSquared[bestPoint, testPoint];
bestJoint ← index;
IF bestDist2 < tolerance2 THEN success ← TRUE;
FOR index ← GGSequence.NextJoint[jointGen], GGSequence.NextJoint[jointGen] UNTIL index = -1 DO
thisPoint ← FetchJointPos[seq.traj, index];
thisDist2 ← Vectors2d.DistanceSquared[thisPoint, testPoint];
IF thisDist2 < tolerance2 THEN success ← TRUE;
IF success AND thisDist2 < bestDist2 THEN {
bestDist2 ← thisDist2;
bestJoint ← index;
bestPoint ← thisPoint;
};
ENDLOOP;
bestDist ← RealFns.SqRt[bestDist2];
};
NearestControlPoint: PUBLIC PROC [testPoint: Point, seq: Sequence, tolerance: REAL] RETURNS [bestDist: REAL, bestSeg: NAT, bestControlPoint: NAT, bestPoint: Point, success: BOOL] = {
Finds the nearest control point of seq (within tolerance) to testPoint (and its distance from testPoint).
SomeCP: PROC [i: NAT] RETURNS [BOOL] = {
cpCount: NAT ← seq.controlPoints[i].len;
FOR j: NAT IN [0..cpCount) DO
IF seq.controlPoints[i][j] THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE];
};
tolerance2: REAL ← tolerance*tolerance;
thisDist2, bestDist2: REAL;
thisControlPoint: NAT;
thisPoint: Point;
segGen: SegmentGenerator;
thisSuccess: BOOL;
next: GGSequence.SegAndIndex;
bigBox: GGBasicTypes.BoundBoxObj;
success ← FALSE;
IF useBBox THEN {
bigBox ← [seq.boundBox.loX-tolerance, seq.boundBox.loY-tolerance, seq.boundBox.hiX+tolerance, seq.boundBox.hiY+tolerance, FALSE, FALSE];
IF NOT GGBoundBox.PointIsInBox[testPoint, bigBox] THEN RETURN; -- success=FALSE
};
segGen ← GGSequence.SegmentsInSequence[seq];
next ← GGSequence.NextSegmentAndIndex[segGen];
WHILE next.seg#NIL AND NOT SomeCP[next.index] DO
next ← GGSequence.NextSegmentAndIndex[segGen];
ENDLOOP;
IF next.seg = NIL THEN { -- The sequence has no control points
bestDist ← maxDistance; -- magic number meaning no segment
bestControlPoint ← noCP; -- magic number meaning no CP
bestPoint ← [-1.0, -1.0];
RETURN;
};
[bestPoint, thisControlPoint, thisSuccess] ← next.seg.class.closestControlPoint[next.seg, testPoint, tolerance];
IF NOT thisSuccess THEN {
bestDist2 ← maxDistance;
bestSeg ← noSeg;
bestControlPoint ← noCP;
bestPoint ← [-1.0, -1.0];
}
ELSE {
bestDist2 ← Vectors2d.DistanceSquared[bestPoint, testPoint];
bestSeg ← next.index;
bestControlPoint ← thisControlPoint;
success ← TRUE;
};
FOR next ← GGSequence.NextSegmentAndIndex[segGen], GGSequence.NextSegmentAndIndex[segGen] UNTIL next.seg = NIL DO
IF SomeCP[next.index] THEN {
[thisPoint, thisControlPoint, thisSuccess] ← next.seg.class.closestControlPoint[next.seg, testPoint, tolerance];
IF NOT thisSuccess THEN {
thisDist2 ← maxDistance;
thisPoint ← [-1.0, -1.0];
}
ELSE {
thisDist2 ← Vectors2d.DistanceSquared[thisPoint, testPoint];
success ← TRUE;
};
IF success AND thisDist2 < bestDist2 THEN {
bestDist2 ← thisDist2;
bestSeg ← next.index;
bestControlPoint ← thisControlPoint;
bestPoint ← thisPoint;
};
};
ENDLOOP;
bestDist ← RealFns.SqRt[bestDist2];
};
Use sparingly:
IndexOfJoint: PUBLIC PROC [joint: Joint, traj: Traj] RETURNS [index: INT] = {
Returns -1 if it doesn't exist.
thisJoint: Joint;
FOR i: NAT IN [0..HiJoint[traj]] DO
thisJoint ← FetchJoint[traj, i];
IF thisJoint = joint THEN RETURN[i];
ENDLOOP;
RETURN[-1];
};
IndexOfSegment: PUBLIC PROC [segment: Segment, traj: Traj] RETURNS [index: INT] = {
Returns -1 if it doesn't exist.
thisSeg: Segment;
FOR i: NAT IN [0..HiSegment[traj]] DO
thisSeg ← FetchSegment[traj, i];
IF thisSeg = segment THEN RETURN[i];
ENDLOOP;
RETURN[-1];
};
END.