<> <> <> <> <> <> <> <> <<>> <> <<>> DIRECTORY Feedback, GGBasicTypes, GGCoreTypes, GGInterfaceTypes, GGModelTypes, GGParent, GGSegmentTypes, GGSequence, GGSlice, GGSliceOps, GGTraj, GGUtility, Imager, Rope; GGSequenceImpl: CEDAR PROGRAM IMPORTS Feedback, GGParent, GGSequence, GGSlice, GGSliceOps, GGTraj, GGUtility EXPORTS GGSequence = BEGIN BezierDragRecord: TYPE = GGInterfaceTypes.BezierDragRecord; BitMatrix: TYPE = GGBasicTypes.BitMatrix; BitMatrixObj: TYPE = GGBasicTypes.BitMatrixObj; BitVector: TYPE = GGBasicTypes.BitVector; BitVectorObj: TYPE = GGBasicTypes.BitVectorObj; <> Color: TYPE = Imager.Color; ControlPointGenerator: TYPE = GGModelTypes.ControlPointGenerator; ControlPointGeneratorObj: TYPE = GGModelTypes.ControlPointGeneratorObj; EditConstraints: TYPE = GGModelTypes.EditConstraints; Joint: TYPE = GGModelTypes.Joint; JointGenerator: TYPE = GGModelTypes.JointGenerator; JointGeneratorObj: TYPE = GGModelTypes.JointGeneratorObj; JointWalkProc: TYPE = GGSequence.JointWalkProc; Point: TYPE = GGBasicTypes.Point; PointAndDone: TYPE = GGModelTypes.PointAndDone; PointWalkProc: TYPE = GGModelTypes.PointWalkProc; SegAndIndex: TYPE = GGSequence.SegAndIndex; Segment: TYPE = GGSegmentTypes.Segment; SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator; SegmentGeneratorObj: TYPE = GGModelTypes.SegmentGeneratorObj; SegmentWalkProc: TYPE = GGSequence.SegmentWalkProc; SelectionClass: TYPE = GGSegmentTypes.SelectionClass; SequenceGenerator: TYPE = GGSequence.SequenceGenerator; SequenceGeneratorObj: TYPE = GGSequence.SequenceGeneratorObj; SequenceOfReal: TYPE = GGCoreTypes.SequenceOfReal; Slice: TYPE = GGModelTypes.Slice; SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor; SliceParts: TYPE = GGModelTypes.SliceParts; StrokeEnd: TYPE = Imager.StrokeEnd; Traj: TYPE = GGModelTypes.Traj; TrajData: TYPE = GGModelTypes.TrajData; TrajEnd: TYPE = GGModelTypes.TrajEnd; TrajParts: TYPE = GGModelTypes.TrajParts; TrajPartsObj: TYPE = GGModelTypes.TrajPartsObj; TrajPartType: TYPE = GGModelTypes.TrajPartType; Problem: PUBLIC SIGNAL [msg: Rope.ROPE] = Feedback.Problem; <> CreateFromSegments: PUBLIC PROC [traj: TrajData, startSeg, endSeg: NAT] RETURNS [seq: TrajParts] = { < endSeg is allowed, in which case the segment sequence wraps around.>> <> <> segCount, temp: NAT; IF startSeg >= traj.segCount OR endSeg >= traj.segCount THEN ERROR; IF startSeg = endSeg THEN {seq _ CreateFromSegment[traj, startSeg]; RETURN}; IF traj.role = open THEN { IF startSeg > endSeg THEN {temp _ startSeg; startSeg _ endSeg; endSeg _ temp}; segCount _ endSeg - startSeg + 1; } ELSE { IF startSeg = (endSeg + 1) MOD traj.segCount THEN {seq _ CreateComplete[traj]; RETURN}; segCount _ ((endSeg - startSeg + traj.segCount) MOD traj.segCount) + 1; }; seq _ NEW[TrajPartsObj _ [ segments: NewBitVector[traj.segCount], joints: NewBitVector[GGTraj.HiJointTraj[traj] + 1], controlPoints: NewBitMatrix[traj], segCount: segCount, controlPointCount: 0, -- will be updated by FillInControlPoints jointCount: 0 -- will be updated by FillInJoints ]]; IF startSeg < endSeg THEN { FOR i: NAT IN [startSeg..endSeg] DO seq.segments[i] _ TRUE; ENDLOOP; FillInJoints[seq]; FillInControlPoints[seq]; } ELSE { FOR i: NAT IN [startSeg..traj.segCount) DO seq.segments[i] _ TRUE; ENDLOOP; FOR i: NAT IN [0..endSeg] DO seq.segments[i] _ TRUE; ENDLOOP; FillInJoints[seq]; FillInControlPoints[seq]; }; }; CreateJointToJoint: PUBLIC PROC [traj: TrajData, startJoint, endJoint: NAT] RETURNS [seq: TrajParts] = { <> temp, hiJoint: NAT; hiJoint _ GGTraj.HiJointTraj[traj]; IF traj.role = open AND startJoint = 0 AND endJoint = hiJoint THEN { seq _ CreateComplete[traj]; RETURN}; IF traj.role = open OR startJoint < endJoint THEN { IF startJoint > endJoint THEN {temp _ startJoint; startJoint _ endJoint; endJoint _ temp}; IF startJoint < 0 OR endJoint > hiJoint THEN ERROR; seq _ NEW[TrajPartsObj _ [ segments: NewBitVector[traj.segCount], joints: NewBitVector[hiJoint+1], controlPoints: NewBitMatrix[traj], segCount: endJoint - startJoint, controlPointCount: 0, -- initialized by FillInControlPoints jointCount: endJoint - startJoint + 1 ]]; FOR i: NAT IN [startJoint..endJoint) DO seq.segments[i] _ TRUE; seq.joints[i] _ TRUE; ENDLOOP; seq.joints[endJoint] _ TRUE; } ELSE { IF startJoint = endJoint THEN {seq _ CreateFromJoint[traj, startJoint]; RETURN}; <> seq _ NEW[TrajPartsObj _ [ segments: NewBitVector[traj.segCount], joints: NewBitVector[hiJoint+1], controlPoints: NewBitMatrix[traj], segCount: traj.segCount - startJoint + endJoint, controlPointCount: 0, jointCount: traj.segCount - startJoint + endJoint + 1 ]]; FOR i: NAT IN [startJoint..traj.segCount) DO seq.segments[i] _ TRUE; seq.joints[i] _ TRUE; ENDLOOP; FOR i: NAT IN [0..endJoint) DO seq.segments[i] _ TRUE; seq.joints[i] _ TRUE; ENDLOOP; seq.joints[endJoint] _ TRUE; }; FillInControlPoints[seq]; -- after all is said and done }; CreateEmpty: PUBLIC PROC [traj: TrajData] RETURNS [seq: TrajParts] = { seq _ NEW[TrajPartsObj _ [ segments: NewBitVector[traj.segCount], joints: NewBitVector[GGTraj.HiJointTraj[traj]+1], controlPoints: NewBitMatrix[traj], segCount: 0, controlPointCount: 0, jointCount: 0 ]]; }; CreateComplete: PUBLIC PROC [traj: TrajData] RETURNS [seq: TrajParts] = { <> jointCount: NAT _ GGTraj.HiJointTraj[traj] + 1; seq _ NEW[TrajPartsObj _ [ segments: NewBitVector[traj.segCount], joints: NewBitVector[jointCount], controlPoints: NewBitMatrix[traj], segCount: traj.segCount, controlPointCount: 0, -- set by FillInControlPoints jointCount: jointCount ]]; FOR i: NAT IN [0..GGTraj.HiSegmentTraj[traj]] DO seq.segments[i] _ TRUE; seq.joints[i] _ TRUE; ENDLOOP; seq.joints[jointCount-1] _ TRUE; -- will be redundant for open trajectories FillInControlPoints[seq]; -- after all is said and done }; CreateFromJoint: PUBLIC PROC [traj: TrajData, jointNum: NAT] RETURNS [seq: TrajParts] = { seq _ CreateEmpty[traj]; seq.joints[jointNum] _ TRUE; seq.jointCount _ 1; }; CreateFromSegment: PUBLIC PROC [traj: TrajData, segNum: NAT] RETURNS [seq: TrajParts] = { seq _ CreateEmpty[traj]; seq.segments[segNum] _ TRUE; seq.segCount _ 1; FillInJoints[seq]; FillInControlPoints[seq]; -- after all is said and done }; CreateSimpleFromSegment: PUBLIC PROC [traj: TrajData, segNum: NAT] RETURNS [seq: TrajParts] = { seq _ CreateEmpty[traj]; seq.segments[segNum] _ TRUE; seq.segCount _ 1; }; CreateFromControlPoint: PUBLIC PROC [traj: TrajData, segNum: NAT, controlPointNum: NAT] RETURNS [seq: TrajParts] = { seq _ CreateEmpty[traj]; seq.controlPoints[segNum][controlPointNum] _ TRUE; seq.controlPointCount _ 1; }; Copy: PUBLIC PROC [seq: TrajParts] RETURNS [copy: TrajParts] = { IF seq=NIL THEN RETURN[NIL]; <> copy _ NEW[TrajPartsObj _ [ segments: NewBitVector[seq.segments.len], joints: NewBitVector[seq.joints.len], controlPoints: NewBitMatrixFromSeq[seq], segCount: seq.segCount, controlPointCount: seq.controlPointCount, jointCount: seq.jointCount ]]; FOR i: NAT IN [0..seq.segments.len) DO copy.segments[i] _ seq.segments[i]; ENDLOOP; FOR i: NAT IN [0..seq.joints.len) DO copy.joints[i] _ seq.joints[i]; ENDLOOP; FOR i: NAT IN [0..seq.controlPoints.len) DO cpCount: NAT _ seq.controlPoints[i].len; FOR j: NAT IN [0..cpCount) DO copy.controlPoints[i][j] _ seq.controlPoints[i][j]; ENDLOOP; ENDLOOP; }; CreateEmptySeq: PRIVATE PROC [seq: TrajParts] RETURNS [copy: TrajParts] = { IF seq=NIL THEN RETURN[NIL]; copy _ NEW[TrajPartsObj _ [ segments: NewBitVector[seq.segments.len], joints: NewBitVector[seq.joints.len], controlPoints: NewBitMatrixFromSeq[seq], segCount: 0, controlPointCount: 0, jointCount: 0 ]]; }; <<>> <> <<>> <> <> <> <> <<};>> <<>> <> <> <> <> <> <> <<>> <> <> <> <> <> <> <> <<>> <> <> <> <> <> <> <> <> <<}>> <> <> <> <> <<};>> <<};>> <> <> <> <> <> <> <> <> <> <> <<};>> <> <<};>> <> <<};>> <> <> <> <> <> <> <<};>> <> <<};>> <<};>> <<>> <> <> <> <> <<>> <> <> <> <> <<>> <> <> <> <> <> <> <<};>> <> <<};>> <> <<};>> <<>> <> <> <> <> <> <> <> <> <> <> <> <> <<};>> <> < bBox.hiX THEN bBox.hiX _ hiX;>> <> < bBox.hiY THEN bBox.hiY _ hiY;>> <<};>> <<>> <> <<>> <> <> <> <> <> <> <> < { -- single segment selected. Describe it>> <> <> <> <<};>> < { -- single CP selected. Describe it>> <> <<[segNum, cpNum] _ GGSequence.NextSegNumAndCPNum[cpGen];>> <> <<};>> < { -- single joint selected. Describe it>> <> <> <<};>> < rope _ GGDescribe.DescribeSequence[seq];>> <<};>> <<};>> <<>> <> CopyInto: PUBLIC PROC [to: TrajParts, from: TrajParts] = { <> FOR i: NAT IN [0..from.segments.len) DO cpCount: NAT _ from.controlPoints[i].len; to.segments[i] _ from.segments[i]; FOR j: NAT IN [0..cpCount) DO to.controlPoints[i][j] _ from.controlPoints[i][j]; -- KAP. April 4, 1986 ENDLOOP; ENDLOOP; FOR i: NAT IN [0..from.joints.len) DO to.joints[i] _ from.joints[i]; ENDLOOP; to.segCount _ from.segCount; to.controlPointCount _ from.controlPointCount; to.jointCount _ from.jointCount; }; FillInJoints: PUBLIC PROC [seq: TrajParts] = { <> jointCount: NAT _ 0; IF seq.segCount=0 THEN RETURN; -- can't do anything. seq may have a single joint or CP IF seq.joints.len=seq.segments.len THEN { -- closed trajectory FOR i: NAT IN [0..seq.segments.len) DO IF seq.segments[i] THEN {seq.joints[i] _ TRUE; seq.joints[(i+1) MOD seq.segments.len] _ TRUE;}; ENDLOOP; } ELSE IF seq.joints.len=seq.segments.len+1 THEN { -- open trajectory FOR i: NAT IN [0..seq.segments.len) DO IF seq.segments[i] THEN {seq.joints[i] _ TRUE; seq.joints[i+1] _ TRUE}; ENDLOOP; } ELSE ERROR; -- KAP. November 20, 1987 4:42:37 pm PST FOR i: NAT IN [0..seq.joints.len) DO IF seq.joints[i] THEN jointCount _ jointCount + 1; ENDLOOP; seq.jointCount _ jointCount; }; FillInControlPoints: PUBLIC PROC [seq: TrajParts] = { -- a sequence with segs and joints filled in. IF there are segments then fill in all the control points for each segment in the sequence, and calculate the new control point count. cpCount: NAT; IF seq.segCount=0 THEN RETURN; -- can't do anything. seq may have a single joint or CP. seq.controlPointCount _ 0; FOR i: NAT IN [0..seq.segments.len) DO cpCount _ seq.controlPoints[i].len; IF seq.segments[i] THEN { FOR j: NAT IN [0..cpCount) DO -- fill them all in seq.controlPoints[i][j] _ TRUE; seq.controlPointCount _ seq.controlPointCount + 1; ENDLOOP; } ELSE { FOR j: NAT IN [0..cpCount) DO -- count the ones already there IF seq.controlPoints[i][j] THEN seq.controlPointCount _ seq.controlPointCount + 1; ENDLOOP; }; ENDLOOP; }; TrimSelectedParts: PUBLIC PROC [trimDescriptor: SliceDescriptor, selectedList: LIST OF SliceDescriptor] = { <> seq: TrajParts _ NARROW[trimDescriptor.parts]; selSeq: TrajParts _ FindPartsInList[trimDescriptor.slice, selectedList]; IF selSeq = NIL THEN RETURN; -- no selected parts, so nothing to trim FOR i: NAT IN [0..seq.segments.len) DO FOR j: NAT IN [0..seq.controlPoints[i].len) DO IF selSeq.controlPoints[i][j] AND seq.controlPoints[i][j] THEN { seq.controlPoints[i][j] _ FALSE; seq.controlPointCount _ seq.controlPointCount - 1; }; ENDLOOP; IF selSeq.segments[i] AND seq.segments[i] THEN { seq.segments[i] _ FALSE; seq.segCount _ seq.segCount - 1; }; ENDLOOP; FOR i: NAT IN [0..seq.joints.len) DO IF selSeq.joints[i] AND seq.joints[i] THEN { seq.joints[i] _ FALSE; seq.jointCount _ seq.jointCount -1; }; ENDLOOP; }; TrimSelectedJointSegments: PUBLIC PROC [trimDescriptor: SliceDescriptor, selectedList: LIST OF SliceDescriptor] = { <> SomeSelectedJoint: PROC [i: NAT] RETURNS [BOOL] = { RETURN[ selSeq.joints[i] OR selSeq.joints[GGTraj.FollowingJoint[trimDescriptor.slice, i]] ]; }; seq: TrajParts _ NARROW[trimDescriptor.parts]; selSeq: TrajParts _ FindPartsInList[trimDescriptor.slice, selectedList]; IF selSeq = NIL THEN RETURN; -- no joints selected, so nothing to trim FOR i: NAT IN [0..seq.segments.len) DO IF seq.segments[i] AND SomeSelectedJoint[i] THEN { seq.segments[i] _ FALSE; seq.segCount _ seq.segCount - 1; }; ENDLOOP; }; <> <> <> <> <> <> <> <<>> <> <<[runGen, runCount] _ RunsInSequence[seq];>> <> <> <> <> <> <> <> <> <> <> <> <> <> <<};>> <> <> <> <> <> <> <> <> <> <<};>> <> <<(seq.traj.role # open AND ((lastSegNum + 1) MOD seq.traj.segCount) # lastJointNum))>> <> <> <> <> <<};>> <> <<};>> <<>> <> <> <> <> <> <> <> <<};>> <> <> <> <> <> <<};>> <> <<};>> <<>> <> <> <> <> <> <<];>> <<};>> <> <> <> <> <<};>> <> <<};>> <<>> TrimSelectedControlPointSegments: PUBLIC PROC [trimDescriptor: SliceDescriptor, selectedList: LIST OF SliceDescriptor] = { <> SomeSelectedCP: PROC [i: NAT] RETURNS [BOOL] = { FOR j: NAT IN [0..selSeq.controlPoints[i].len) DO IF selSeq.controlPoints[i][j] THEN RETURN[TRUE]; ENDLOOP; RETURN[FALSE]; }; seq: TrajParts _ NARROW[trimDescriptor.parts]; selSeq: TrajParts _ FindPartsInList[trimDescriptor.slice, selectedList]; IF selSeq = NIL THEN RETURN; -- no CPs selected, so nothing to trim FOR i: NAT IN [0..seq.segments.len) DO IF seq.segments[i] AND SomeSelectedCP[i] THEN { seq.segments[i] _ FALSE; seq.segCount _ seq.segCount - 1; }; ENDLOOP; }; AddNonSelectedJointSegments: PROC [descriptor: SliceDescriptor, selected: TrajParts] = { <> SomeSelectedJoint: PROC [i: NAT] RETURNS [BOOL] = { RETURN[ selected.joints[i] OR selected.joints[GGTraj.FollowingJoint[descriptor.slice, i]] ]; }; seq: TrajParts _ NARROW[descriptor.parts]; IF selected = NIL THEN RETURN; -- no joints selected, so nothing to add FOR i: NAT IN [0..seq.segments.len) DO IF NOT seq.segments[i] AND NOT selected.segments[i] AND SomeSelectedJoint[i] THEN { seq.segments[i] _ TRUE; seq.segCount _ seq.segCount + 1; }; ENDLOOP; }; AddNonSelectedControlPointSegments: PROC [descriptor: SliceDescriptor, selected: TrajParts] = { <> SomeSelectedCP: PROC [i: NAT] RETURNS [BOOL] = { FOR j: NAT IN [0..selected.controlPoints[i].len) DO IF selected.controlPoints[i][j] THEN RETURN[TRUE]; ENDLOOP; RETURN[FALSE]; }; seq: TrajParts _ NARROW[descriptor.parts]; IF selected = NIL THEN RETURN; -- no CPs selected, so nothing to add FOR i: NAT IN [0..seq.segments.len) DO IF NOT seq.segments[i] AND NOT selected.segments[i] AND SomeSelectedCP[i] THEN { seq.segments[i] _ TRUE; seq.segCount _ seq.segCount + 1; }; ENDLOOP; }; AddConstrained: PROC [descriptor: SliceDescriptor, selected: TrajParts] = { <> SomeSelectedConstrainer: PROC [i: NAT] RETURNS [BOOL] = { previous, following: INT; previous _ GGTraj.PreviousSegmentNum[descriptor.slice, i]; following _ GGTraj.FollowingSegmentNum[descriptor.slice, i]; IF previous # -1 AND GGTraj.FetchSegment[descriptor.slice, previous].class.type = $Bezier AND selected.controlPoints[previous][1] THEN RETURN[TRUE]; IF following # -1 AND GGTraj.FetchSegment[descriptor.slice, following].class.type = $Bezier AND selected.controlPoints[following][0] THEN RETURN[TRUE]; RETURN[FALSE]; }; seq: TrajParts _ NARROW[descriptor.parts]; IF selected = NIL THEN RETURN; -- nothing to add FOR i: NAT IN [0..seq.segments.len) DO IF GGTraj.FetchSegment[descriptor.slice, i].class.type = $Bezier AND NOT seq.segments[i] AND NOT selected.segments[i] AND SomeSelectedConstrainer[i] THEN { seq.segments[i] _ TRUE; seq.segCount _ seq.segCount + 1; <> }; ENDLOOP; }; AddNewBezier: PROC [seq: TrajParts, selected: TrajParts, segNum: NAT] = { <> IF selected = NIL THEN RETURN; -- nothing to add IF NOT seq.segments[segNum] AND NOT selected.segments[segNum] THEN { seq.segments[segNum] _ TRUE; seq.segCount _ seq.segCount + 1; }; }; DDifference: PUBLIC PROC [mutable, negative: SliceDescriptor] = { IF mutable.slice.data # negative.slice.data THEN ERROR; -- different trajectories DDifferenceSeq[NARROW[mutable.parts, TrajParts], NARROW[negative.parts, TrajParts]] ; }; DDifferenceSeq: PRIVATE PROC [mutSeq, negSeq: TrajParts] = { <> hiJoint: NAT; <> FOR i: NAT IN [0..mutSeq.segments.len) DO cpCount: NAT _ mutSeq.controlPoints[i].len; mutSeq.segments[i] _ mutSeq.segments[i] AND NOT negSeq.segments[i]; FOR j: NAT IN [0..cpCount) DO mutSeq.controlPoints[i][j] _ mutSeq.controlPoints[i][j] AND NOT negSeq.controlPoints[i][j]; ENDLOOP; mutSeq.joints[i] _ mutSeq.joints[i] AND NOT negSeq.joints[i]; ENDLOOP; hiJoint _ mutSeq.joints.len-1; mutSeq.joints[hiJoint] _ mutSeq.joints[hiJoint] AND NOT negSeq.joints[hiJoint]; mutSeq.segCount _ CountSegments[mutSeq]; mutSeq.jointCount _ CountJoints[mutSeq]; mutSeq.controlPointCount _ CountControlPoints[mutSeq]; }; <<>> <> FindPartsInList: PUBLIC PROC [traj: Traj, selectedList: LIST OF SliceDescriptor] RETURNS [trajParts: TrajParts] = { trajD: SliceDescriptor; FOR sliceDList: LIST OF SliceDescriptor _ selectedList, sliceDList.rest UNTIL sliceDList = NIL DO sliceD: SliceDescriptor _ sliceDList.first; trajD _ IF GGSliceOps.GetType[sliceD.slice]=$Traj THEN sliceD ELSE IF GGSliceOps.GetType[sliceD.slice]=$Outline THEN GGParent.ChildDescriptorFromDescriptor[sliceD, traj] ELSE NIL; IF trajD#NIL THEN RETURN[NARROW[trajD.parts]]; ENDLOOP; RETURN[NIL]; }; NewBitMatrixFromSeq: PROC [seq: TrajParts] RETURNS [bitMatrix: BitMatrix] = { bitMatrix _ NEW[BitMatrixObj[seq.controlPoints.len]]; FOR j: NAT IN [0..seq.controlPoints.len) DO -- for each possible segment bitMatrix[j] _ NewBitVector[seq.controlPoints[j].len]; -- for all possible CPs in segment ENDLOOP; }; NewBitMatrix: PROC [traj: TrajData] RETURNS [bitMatrix: BitMatrix] = { j: NAT _ 0; segGen: SegmentGenerator _ GGSequence.SegmentsInTraj[traj]; bitMatrix _ NEW[BitMatrixObj[traj.segCount]]; FOR seg: Segment _ GGSequence.NextSegment[segGen], GGSequence.NextSegment[segGen] UNTIL seg = NIL DO bitMatrix[j] _ NewBitVector[seg.class.controlPointCount[seg]]; j _ j+1; ENDLOOP; }; NewBitVector: PROC [length: NAT] RETURNS [bitVec: BitVector] = { bitVec _ NEW[BitVectorObj[length]]; SetAllBits[bitVec, FALSE]; }; <<>> SetAllBits: PROC [bitVec: BitVector, bool: BOOL] = { FOR i: NAT IN [0..bitVec.len) DO bitVec[i] _ bool; ENDLOOP; }; SomeSegCPInSeq: PROC [segNum: NAT, seq: TrajParts] RETURNS [BOOL] = { cpCount: NAT _ seq.controlPoints[segNum].len; FOR j: NAT IN [0..cpCount) DO IF seq.controlPoints[segNum][j] THEN RETURN[TRUE]; ENDLOOP; RETURN[FALSE]; }; <> <<>> Union: PUBLIC PROC [a, b: SliceDescriptor] RETURNS [union: SliceDescriptor] = { hiJoint: NAT; uSeq: TrajParts; aSeq: TrajParts _ NARROW[a.parts]; aTraj: TrajData _ NARROW[a.slice.data]; bSeq: TrajParts _ NARROW[b.parts]; bTraj: TrajData _ NARROW[b.slice.data]; <> IF aTraj # bTraj THEN ERROR; IF aSeq = NIL THEN RETURN[b]; -- copy needed ?? IF bSeq = NIL THEN RETURN[a]; -- copy needed ?? IF IsEmpty[aSeq] THEN RETURN[b]; -- copy needed ?? IF IsEmpty[bSeq] THEN RETURN[a]; -- copy needed ?? IF IsComplete[aSeq] THEN RETURN[a]; -- copy needed ?? IF IsComplete[bSeq] THEN RETURN[b]; -- copy needed ?? uSeq _ CreateEmpty[aTraj]; FOR i: NAT IN [0..uSeq.segments.len) DO cpCount: NAT _ aSeq.controlPoints[i].len; uSeq.segments[i] _ aSeq.segments[i] OR bSeq.segments[i]; FOR j: NAT IN [0..cpCount) DO uSeq.controlPoints[i][j] _ aSeq.controlPoints[i][j] OR bSeq.controlPoints[i][j]; ENDLOOP; uSeq.joints[i] _ aSeq.joints[i] OR bSeq.joints[i]; ENDLOOP; hiJoint _ uSeq.joints.len-1; uSeq.joints[hiJoint] _ aSeq.joints[hiJoint] OR bSeq.joints[hiJoint]; uSeq.segCount _ CountSegments[uSeq]; uSeq.jointCount _ CountJoints[uSeq]; uSeq.controlPointCount _ CountControlPoints[uSeq]; union _ GGSlice.DescriptorFromParts[a.slice, uSeq]; }; Difference: PUBLIC PROC [a, b: SliceDescriptor] RETURNS [aMinusB: SliceDescriptor] = { hiJoint: NAT; <> dSeq: TrajParts; aSeq: TrajParts _ NARROW[a.parts]; aTraj: TrajData _ NARROW[a.slice.data]; bSeq: TrajParts _ NARROW[b.parts]; bTraj: TrajData _ NARROW[b.slice.data]; dSeq _ CreateEmpty[aTraj]; FOR i: NAT IN [0..aSeq.segments.len) DO cpCount: NAT _ aSeq.controlPoints[i].len; dSeq.segments[i] _ aSeq.segments[i] AND NOT bSeq.segments[i]; FOR j: NAT IN [0..cpCount) DO dSeq.controlPoints[i][j] _ aSeq.controlPoints[i][j] AND NOT bSeq.controlPoints[i][j]; ENDLOOP; dSeq.joints[i] _ aSeq.joints[i] AND NOT bSeq.joints[i]; ENDLOOP; hiJoint _ dSeq.joints.len-1; dSeq.joints[hiJoint] _ aSeq.joints[hiJoint] AND NOT bSeq.joints[hiJoint]; dSeq.segCount _ CountSegments[dSeq]; dSeq.jointCount _ CountJoints[dSeq]; dSeq.controlPointCount _ CountControlPoints[dSeq]; aMinusB _ GGSlice.DescriptorFromParts[a.slice, dSeq]; }; Intersection: PUBLIC PROC [a, b: SliceDescriptor] RETURNS [intersection: SliceDescriptor] = { hiJoint: NAT; <> iSeq: TrajParts; aSeq: TrajParts _ NARROW[a.parts]; aTraj: TrajData _ NARROW[a.slice.data]; bSeq: TrajParts _ NARROW[b.parts]; bTraj: TrajData _ NARROW[b.slice.data]; IF aTraj # bTraj THEN ERROR; iSeq _ CreateEmpty[aTraj]; IF aSeq = NIL OR IsEmpty[aSeq] THEN RETURN[GGSlice.DescriptorFromParts[a.slice, iSeq]]; IF bSeq = NIL OR IsEmpty[bSeq] THEN RETURN[GGSlice.DescriptorFromParts[a.slice, iSeq]]; IF IsComplete[aSeq] AND IsComplete[bSeq] THEN RETURN[a]; -- copy needed ?? FOR i: NAT IN [0..aSeq.segments.len) DO cpCount: NAT _ aSeq.controlPoints[i].len; iSeq.segments[i] _ aSeq.segments[i] AND bSeq.segments[i]; FOR j: NAT IN [0..cpCount) DO iSeq.controlPoints[i][j]_ aSeq.controlPoints[i][j] AND bSeq.controlPoints[i][j]; ENDLOOP; iSeq.joints[i] _ aSeq.joints[i] AND bSeq.joints[i]; ENDLOOP; hiJoint _ iSeq.joints.len-1; iSeq.joints[hiJoint] _ aSeq.joints[hiJoint] AND bSeq.joints[hiJoint]; iSeq.segCount _ CountSegments[iSeq]; iSeq.jointCount _ CountJoints[iSeq]; iSeq.controlPointCount _ CountControlPoints[iSeq]; intersection _ GGSlice.DescriptorFromParts[a.slice, iSeq]; }; TrajMovingParts: PUBLIC PROC [slice: Slice, parts: SliceParts, editConstraints: EditConstraints, bezierDrag: BezierDragRecord] RETURNS [background, overlay, rubber, drag: TrajParts] = { <> <> <> <> <> seq: TrajParts _ NARROW[parts]; traj: TrajData _ NARROW[slice.data]; background _ NIL; drag _ Copy[seq]; rubber _ FindRubberFromSelected[slice, parts, editConstraints, bezierDrag]; overlay _ CreateComplete[traj]; DDifferenceSeq[overlay, drag]; DDifferenceSeq[overlay, rubber]; }; FindRubberFromSelected: PROC [slice: Slice, parts: SliceParts, editConstraints: EditConstraints, bezierDrag: BezierDragRecord] RETURNS [rubber: TrajParts] = { rubberBabbyBuggyBumper: SliceDescriptor; trajParts: TrajParts _ NARROW[parts]; trajData: TrajData _ NARROW[slice.data]; rubber _ CreateEmpty[trajData]; rubberBabbyBuggyBumper _ GGSlice.DescriptorFromParts[slice, rubber]; AddNonSelectedControlPointSegments[rubberBabbyBuggyBumper, trajParts]; AddNonSelectedJointSegments[rubberBabbyBuggyBumper, trajParts]; IF editConstraints # none THEN AddConstrained[rubberBabbyBuggyBumper, trajParts]; IF bezierDrag.draggingBezier AND trajData = bezierDrag.traj.data THEN AddNewBezier[rubber, trajParts, bezierDrag.bezierNum]; -- For now until more general. }; Augment: PUBLIC PROC [descriptor: SliceDescriptor, trajEnd: TrajEnd, extend: BOOL] RETURNS [bigger: TrajParts] = { <> seq: TrajParts _ NARROW[descriptor.parts]; traj: TrajData _ NARROW[descriptor.slice.data]; IF traj.role = hole OR traj.role = fence THEN { bigger _ AugmentClosed[descriptor, extend]; RETURN; }; <> bigger _ CreateEmpty[traj]; bigger.segCount _ seq.segCount; bigger.controlPointCount _ seq.controlPointCount; bigger.jointCount _ seq.jointCount; IF trajEnd = hi THEN { FOR i: NAT IN [0..seq.segments.len) DO cpCount: NAT _ seq.controlPoints[i].len; bigger.segments[i] _ seq.segments[i]; bigger.joints[i] _ seq.joints[i]; FOR j: NAT IN [0..cpCount) DO bigger.controlPoints[i][j] _ seq.controlPoints[i][j]; ENDLOOP; ENDLOOP; <> IF seq.joints[seq.joints.len - 1] THEN { -- final joint included ?? bigger.joints[seq.joints.len - 1] _ TRUE; -- yes, so include it in bigger IF extend THEN { bigger.segments[seq.segments.len] _ TRUE; bigger.joints[seq.joints.len] _ TRUE; SetAllBits[bigger.controlPoints[seq.segments.len], TRUE]; bigger.segCount _ bigger.segCount + 1; bigger.jointCount _ bigger.jointCount + 1; bigger.controlPointCount _ bigger.controlPointCount + bigger.controlPoints[seq.segments.len].len }; }; } ELSE { FOR i: NAT IN [0..seq.segments.len) DO cpCount: NAT _ seq.controlPoints[i].len; bigger.segments[i+1] _ seq.segments[i]; bigger.joints[i+2] _ seq.joints[i+1]; FOR j: NAT IN [0..cpCount) DO bigger.controlPoints[i+1][j] _ seq.controlPoints[i][j]; ENDLOOP; ENDLOOP; <> IF seq.joints[0] THEN { -- first joint included ?? bigger.joints[1] _ TRUE; -- yes, so include it in bigger IF extend THEN { bigger.segments[0] _ TRUE; bigger.joints[0] _ TRUE; SetAllBits[bigger.controlPoints[0], TRUE]; bigger.segCount _ bigger.segCount + 1; bigger.jointCount _ bigger.jointCount + 1; bigger.controlPointCount _ bigger.controlPointCount + bigger.controlPoints[0].len }; }; }; }; AugmentClosed: PROC [descriptor: SliceDescriptor, extend: BOOL] RETURNS [bigger: TrajParts] = { <> seq: TrajParts _ NARROW[descriptor.parts]; traj: TrajData _ NARROW[descriptor.slice.data]; bigger _ NEW[TrajPartsObj _ [ segments: NewBitVector[seq.segments.len+1], joints: NewBitVector[seq.joints.len], controlPoints: NewBitMatrix[traj], -- new BitMatrix one segment bigger segCount: seq.segCount, controlPointCount: seq.controlPointCount, jointCount: seq.jointCount ]]; FOR i: NAT IN [0..seq.segments.len) DO cpCount: NAT _ seq.controlPoints[i].len; bigger.segments[i] _ seq.segments[i]; bigger.joints[i] _ seq.joints[i]; FOR j: NAT IN [0..cpCount) DO bigger.controlPoints[i][j] _ seq.controlPoints[i][j]; -- KAP. April 4, 1986 ENDLOOP; ENDLOOP; IF seq.joints[seq.joints.len - 1] THEN { -- final joint included ?? bigger.joints[seq.joints.len - 1] _ TRUE; -- yes, so include it in bigger <> IF extend THEN { bigger.segments[seq.segments.len] _ TRUE; SetAllBits[bigger.controlPoints[seq.segments.len], TRUE]; bigger.segCount _ bigger.segCount + 1; bigger.controlPointCount _ bigger.controlPointCount + bigger.controlPoints[seq.segments.len].len; }; }; }; <> IsObsolete: PUBLIC PROC [seq: TrajParts] RETURNS [BOOL] = { <> <> <> <> <> <> <> <> <> <> <> <> <<>> ERROR; }; IsEmpty: PUBLIC PROC [seq: TrajParts] RETURNS [BOOL] = { RETURN[seq=NIL OR (seq.jointCount = 0 AND seq.segCount = 0 AND seq.controlPointCount = 0)]; }; IsComplete: PUBLIC PROC [seq: TrajParts] RETURNS [BOOL] = { RETURN[seq#NIL AND seq.segCount = seq.segments.len AND (seq.jointCount = seq.joints.len)]; }; IsConstrained: PUBLIC PROC [descriptor: SliceDescriptor, segNum, cPNum: NAT, editConstraints: EditConstraints] RETURNS [BOOL] = { seq: TrajParts _ NARROW[descriptor.parts]; previous, following: INT; IF GGTraj.FetchSegment[descriptor.slice, segNum].class.type = $Bezier AND editConstraints # none THEN { IF cPNum = 0 THEN { previous _ GGTraj.PreviousSegmentNum[descriptor.slice, segNum]; IF previous # -1 AND GGTraj.FetchSegment[descriptor.slice, previous].class.type = $Bezier AND seq.controlPoints[previous][1] THEN RETURN[TRUE] } ELSE { following _ GGTraj.FollowingSegmentNum[descriptor.slice, segNum]; IF following # -1 AND GGTraj.FetchSegment[descriptor.slice, following].class.type = $Bezier AND seq.controlPoints[following][0] THEN RETURN[TRUE]; }; }; RETURN[FALSE]; }; Overlap: PUBLIC PROC [descriptor1, descriptor2: SliceDescriptor] RETURNS [BOOL] = { <> hiSegment, hiJoint: NAT; seq1: TrajParts _ NARROW[descriptor1.parts]; traj1: TrajData _ NARROW[descriptor1.slice.data]; seq2: TrajParts _ NARROW[descriptor2.parts]; traj2: TrajData _ NARROW[descriptor2.slice.data]; IF traj1 # traj2 THEN ERROR; <> hiSegment _ seq1.segments.len; FOR i: NAT IN [0..hiSegment) DO IF seq1.segments[i] AND seq2.segments[i] THEN RETURN[TRUE]; ENDLOOP; <> hiJoint _ seq1.joints.len; FOR i: NAT IN [0..hiJoint) DO IF seq1.joints[i] AND seq2.joints[i] THEN RETURN[TRUE]; ENDLOOP; FOR i: NAT IN [0..hiSegment) DO cpCount: NAT _ seq1.controlPoints[i].len; FOR j: NAT IN [0..cpCount) DO IF seq1.controlPoints[i][j] AND seq2.controlPoints[i][j] THEN RETURN[TRUE]; ENDLOOP; ENDLOOP; RETURN[FALSE]; }; CountSegments: PROC [seq: TrajParts] RETURNS [segCount: NAT _ 0] = { hiSegment: NAT _ seq.segments.len; FOR i: NAT IN [0..hiSegment) DO IF seq.segments[i] THEN segCount _ segCount + 1; ENDLOOP; }; CountJoints: PROC [seq: TrajParts] RETURNS [jointCount: NAT _ 0] = { hiJoint: NAT _ seq.joints.len; FOR i: NAT IN [0..hiJoint) DO IF seq.joints[i] THEN jointCount _ jointCount + 1; ENDLOOP; }; CountControlPoints: PROC [seq: TrajParts] RETURNS [count: NAT _ 0] = { hiSegment: NAT _ seq.segments.len; FOR i: NAT IN [0..hiSegment) DO cpCount: NAT _ seq.controlPoints[i].len; FOR j: NAT IN [0..cpCount) DO IF seq.controlPoints[i][j] THEN count _ count + 1; ENDLOOP; ENDLOOP; }; ContainsSegment: PUBLIC PROC [seq: TrajParts, segNum: NAT] RETURNS [BOOL] = { RETURN[seq.segments[segNum]]; }; ContainsSomeSegment: PUBLIC PROC [seq: TrajParts] RETURNS [BOOL] = { RETURN[seq.segCount > 0]; }; ContainsSegmentParts: PUBLIC PROC [seq: TrajParts, segNum: NAT] RETURNS [BOOL] = { <> RETURN [seq#NIL AND (seq.segments[segNum] OR NOT GGUtility.AllFalse[seq.controlPoints[segNum]] OR seq.joints[segNum] OR seq.joints[IF --seq.traj.role=open-- seq.segments.len#seq.joints.len THEN segNum+1 ELSE (segNum+1) MOD --seq.traj.segCount-- seq.segments.len]) ]; }; FirstSegment: PROC [seq: TrajParts] RETURNS [index: NAT] ~ { hiSegment: NAT _ seq.segments.len; <> IF --seq.traj.role = open-- seq.segments.len#seq.joints.len THEN { FOR i: NAT IN [0..hiSegment) DO IF seq.segments[i] THEN GOTO Found; REPEAT Found => index _ i; FINISHED => SIGNAL Problem[msg: "the first run begins with a segment."]; ENDLOOP; } ELSE { FOR i: NAT IN [0..hiSegment) DO IF NOT seq.segments[(i - 1 + hiSegment) MOD hiSegment] AND seq.joints[i] THEN GOTO Found; IF NOT seq.joints[i] AND seq.segments[i] THEN GOTO Found; REPEAT Found => index _ i; FINISHED => SIGNAL Problem[msg: "there is no break in the sequence."]; ENDLOOP; }; }; FirstSegNum: PUBLIC PROC [run: TrajParts] RETURNS [INT] = { <> IF run.segCount = 0 THEN RETURN[-1]; IF GGSequence.IsComplete[run] THEN RETURN[0]; --DJK, to make work with complete, closed sequences RETURN[FirstTransitionInRun[run]]; }; <> <> <> <> <> <<};>> <<>> LastSegNum: PUBLIC PROC [run: TrajParts, firstSegNum: INT] RETURNS [lastNum: INT] = { <> IF firstSegNum = -1 THEN RETURN[-1]; IF run.segments.len#run.joints.len THEN lastNum _ firstSegNum + run.segCount - 1 ELSE lastNum _ (firstSegNum + run.segCount - 1 + run.segments.len) MOD run.segments.len; }; ContainsJoint: PUBLIC PROC [seq: TrajParts, jointNum: NAT] RETURNS [BOOL] = { RETURN[seq.joints[jointNum]]; }; FirstJointNum: PUBLIC PROC [run: TrajParts] RETURNS [INT] = { <> firstSeg, nextJoint: NAT; IF run.jointCount = 0 THEN RETURN[-1]; firstSeg _ FirstTransitionInRun[run]; IF run.joints[firstSeg] THEN RETURN[firstSeg] ELSE { IF --run.traj.role = open-- run.segments.len#run.joints.len THEN { IF run.joints[firstSeg + 1] THEN RETURN[firstSeg + 1] ELSE ERROR Problem[msg: "Broken invariant."]; } ELSE { nextJoint _ FollowingJoint[run, firstSeg]; IF run.joints[nextJoint] THEN RETURN[nextJoint] ELSE ERROR Problem[msg: "Broken invariant."]; }; }; }; LastJointNum: PUBLIC PROC [run: TrajParts, firstJointNum: INT] RETURNS [lastNum: INT] = { IF firstJointNum = -1 THEN RETURN[-1]; IF --run.traj.role = open-- run.segments.len#run.joints.len THEN lastNum _ firstJointNum + run.jointCount - 1 ELSE lastNum _ (firstJointNum + run.jointCount - 1 + run.segments.len) MOD run.segments.len; }; LastSegAndJoint: PUBLIC PROC [traj: TrajData, trajEnd: TrajEnd] RETURNS [segAndJoint: TrajParts] = { segAndJoint _ CreateEmpty[traj]; IF traj.role = open THEN { segAndJoint.jointCount _ 1; segAndJoint.segCount _ 1; IF trajEnd = lo THEN { segAndJoint.segments[0] _ TRUE; segAndJoint.joints[0] _ TRUE; } ELSE { hiSegment: NAT _ --GGTraj.HiSegment[traj]-- segAndJoint.segments.len-1; segAndJoint.segments[hiSegment] _ TRUE; segAndJoint.joints[hiSegment+1] _ TRUE; }; } ELSE ERROR; }; FollowingJoint: PRIVATE PROC [seq: TrajParts, index: NAT] RETURNS [nextIndex: INT] = { open: BOOL _ seq.segments.len#seq.joints.len; segCount: NAT _ seq.segments.len; IF open THEN nextIndex _ IF index = segCount THEN -1 ELSE index + 1 ELSE nextIndex _ (index + 1) MOD segCount; }; UnpackOnePointSequence: PUBLIC PROC [seq: TrajParts] RETURNS [isACP: BOOL, segNum, cpNum, jointNum: NAT] = { <> hiSegment: NAT _ seq.segments.len; hiJoint: NAT _ seq.joints.len; FOR i: NAT IN [0..hiJoint) DO IF seq.joints[i] THEN { isACP _ FALSE; segNum _ 999; cpNum _ 999; jointNum _ i; RETURN; } ENDLOOP; FOR i: NAT IN [0..hiSegment) DO <> <> FOR j: NAT IN [0..seq.controlPoints[i].len) DO IF seq.controlPoints[i][j] THEN { isACP _ TRUE; segNum _ i; cpNum _ j; jointNum _ 999; RETURN; } ENDLOOP; ENDLOOP; ERROR; }; UnpackOneSegmentSequence: PUBLIC PROC [seq: TrajParts] RETURNS [segNum: NAT] = { hiSegment: NAT _ seq.segments.len; FOR i: NAT IN [0..hiSegment) DO IF seq.segments[i] THEN { segNum _ i; RETURN; } ENDLOOP; ERROR; }; UnpackSimpleSequence: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [success: BOOL _ FALSE, partType: TrajPartType _ none, traj: TrajData, joint: Joint _ NIL, jointNum: NAT _ 999, cp: Point _ [0,0], cpNum: NAT _ 999, seg: Segment _ NIL, segNum: NAT _ 999] = { jointFound, cpFound, segFound: BOOL _ FALSE; seq: TrajParts _ NARROW[parts]; seqTraj: TrajData _ NARROW[slice.data]; hiSegment: NAT _ seq.segments.len; hiJoint: NAT _ seq.joints.len; traj _ seqTraj; <> FOR i: NAT IN [0..hiJoint) DO IF seq.joints[i] THEN { IF jointFound THEN {success _ FALSE; RETURN}; jointNum _ i; joint _ GGTraj.FetchJoint[slice, i]; jointFound _ TRUE; partType _ joint; } ENDLOOP; FOR i: NAT IN [0..hiSegment) DO thisSeg: Segment _ GGTraj.FetchSegment[slice, i]; cpCount: NAT _ seq.controlPoints[i].len; FOR j: NAT IN [0..cpCount) DO IF seq.controlPoints[i][j] THEN { IF cpFound THEN {success _ FALSE; RETURN}; segNum _ i; seg _ thisSeg; cpNum _ j; cp _ thisSeg.class.controlPointGet[thisSeg, cpNum]; cpFound _ TRUE; partType _ controlPoint; } ENDLOOP; ENDLOOP; IF jointFound AND cpFound THEN {success _ FALSE; RETURN}; FOR i: NAT IN [0..hiSegment) DO IF seq.segments[i] THEN { IF segFound THEN {success _ FALSE; RETURN}; segNum _ i; seg _ GGTraj.FetchSegment[slice, i]; segFound _ TRUE; partType _ segment; } ENDLOOP; IF (jointFound AND segFound) OR (cpFound AND segFound) THEN {success _ FALSE; RETURN}; IF NOT jointFound AND NOT cpFound AND NOT segFound THEN ERROR; success _ TRUE; }; <<>> <> <<>> RunsInSequence: PUBLIC PROC [seq: TrajParts] RETURNS [seqGen: SequenceGenerator, runCount: NAT] = { <> <> IF --seq.traj.role = open-- seq.segments.len#seq.joints.len THEN [seqGen, runCount] _ RunsInSequenceOpen[seq] ELSE [seqGen, runCount] _ RunsInSequenceClosed[seq]; }; RunsInSequenceOpen: PROC [seq: TrajParts] RETURNS [seqGen: SequenceGenerator, runCount: NAT] = { in: BOOL _ FALSE; thisSeq: TrajParts; hiSegment: NAT _ seq.segments.len-1; -- GGTraj.HiSegment[seq.traj] hiJoint: NAT _ hiSegment + 1; seqGen _ NEW[SequenceGeneratorObj _ [NIL]]; runCount _ 0; IF IsEmpty[seq] THEN RETURN; FOR i: NAT IN [0..hiSegment] DO [in, seqGen.list, thisSeq, runCount] _ ConsiderJoint[in, seqGen.list, seq, thisSeq, runCount, i]; [in, seqGen.list, thisSeq, runCount] _ ConsiderSegment[in, seqGen.list, seq, thisSeq, runCount, i]; ENDLOOP; [in, seqGen.list, thisSeq, runCount] _ ConsiderJoint[in, seqGen.list, seq, thisSeq, runCount, hiJoint]; IF in THEN seqGen.list _ AppendToList[seqGen.list, CONS[thisSeq, NIL]]; }; RunsInSequenceClosed: PROC [seq: TrajParts] RETURNS [seqGen: SequenceGenerator, runCount: NAT] = { <> segCount: NAT _ seq.segments.len; in: BOOL _ FALSE; thisSeq: TrajParts; start: NAT; natGen: NATGenerator; seqGen _ NEW[SequenceGeneratorObj _ [NIL]]; runCount _ 0; IF ControlPointsOnly[seq] THEN RETURN; start _ FirstTransitionInRun[seq]; in _ FALSE; natGen _ NATsInInterval[start, segCount, segCount]; FOR i: INT _ NextNAT[natGen], NextNAT[natGen] UNTIL i = -1 DO [in, seqGen.list, thisSeq, runCount] _ ConsiderJoint[in, seqGen.list, seq, thisSeq, runCount, i]; [in, seqGen.list, thisSeq, runCount] _ ConsiderSegment[in, seqGen.list, seq, thisSeq, runCount, i]; ENDLOOP; IF in THEN seqGen.list _ AppendToList[seqGen.list, CONS[thisSeq, NIL]]; }; ControlPointsOnly: PROC [seq: TrajParts] RETURNS [BOOL] = { RETURN[seq#NIL AND seq.jointCount = 0 AND seq.segCount = 0]; }; NextSequence: PUBLIC PROC [seqGen: SequenceGenerator] RETURNS [seq: TrajParts] = { IF seqGen.list = NIL THEN RETURN[NIL]; seq _ seqGen.list.first; seqGen.list _ seqGen.list.rest; }; FirstRun: PUBLIC PROC [seq: TrajParts] RETURNS [runParts: TrajParts] = { <> runCount: NAT; seqGen: SequenceGenerator; [seqGen, runCount] _ RunsInSequence[seq]; runParts _ IF runCount = 0 THEN NIL ELSE NextSequence[seqGen]; }; FirstTransitionInRun: PROC [seq: TrajParts] RETURNS [transitionNum: NAT] = { < joint 2 returns 2. joint 1 -> segment (2) returns 2. Hence, if the first run has any segments at all, transitionNum will be the number of the first segment.>> hiSegment: NAT _ seq.segments.len-1; -- GGTraj.HiSegment[seq.traj]; IF --seq.traj.role = open-- seq.segments.len#seq.joints.len THEN { FOR i: NAT IN [0..hiSegment] DO IF seq.joints[i] THEN RETURN[i]; IF seq.segments[i] THEN RETURN[i]; ENDLOOP; IF seq.joints[hiSegment+1] THEN RETURN[hiSegment+1]; SIGNAL Problem[msg: "there is no break in the sequence."]; } ELSE { FOR i: NAT IN [0..hiSegment] DO IF NOT seq.segments[(i -1 + seq.segments.len) MOD seq.segments.len] AND seq.joints[i] THEN GOTO FoundStart; IF NOT seq.joints[i] AND seq.segments[i] THEN GOTO FoundStart; REPEAT FoundStart => transitionNum _ i; FINISHED => SIGNAL Problem[msg: "there is no break in the sequence."]; ENDLOOP; }; }; AppendToList: PROC [list1, list2: LIST OF TrajParts] RETURNS [result: LIST OF TrajParts] = { pos: LIST OF TrajParts; newCell: LIST OF TrajParts; <> IF list1 = NIL THEN RETURN[list2]; result _ CONS[list1.first, NIL]; pos _ result; FOR l: LIST OF TrajParts _ list1.rest, l.rest UNTIL l = NIL DO newCell _ CONS[l.first, NIL]; pos.rest _ newCell; pos _ newCell; ENDLOOP; pos.rest _ list2; }; ConsiderJoint: PROC [in: BOOL, list: LIST OF TrajParts, seq: TrajParts, thisSeq: TrajParts, runCount: NAT, i: NAT] RETURNS [newIn: BOOL, newList: LIST OF TrajParts, newThisSeq: TrajParts, newCount: NAT] = { newIn _ in; newList _ list; newThisSeq _ thisSeq; newCount _ runCount; SELECT TRUE FROM NOT seq.joints[i] AND NOT in => {}; NOT seq.joints[i] AND in => { newIn _ FALSE; newList _ AppendToList[list, CONS[thisSeq, NIL]]; newThisSeq _ NIL}; seq.joints[i] AND NOT in => { newIn _ TRUE; newThisSeq _ CreateEmptySeq[seq]; <> newCount _ newCount + 1; newThisSeq.joints[i] _ TRUE; newThisSeq.jointCount _ newThisSeq.jointCount + 1; }; seq.joints[i] AND in => { newThisSeq.joints[i] _ TRUE; newThisSeq.jointCount _ newThisSeq.jointCount + 1; }; ENDCASE => ERROR; }; ConsiderSegment: PROC [in: BOOL, list: LIST OF TrajParts, seq: TrajParts, thisSeq: TrajParts, runCount: NAT, i: NAT] RETURNS [newIn: BOOL, newList: LIST OF TrajParts, newThisSeq: TrajParts, newCount: NAT] = { newIn _ in; newList _ list; newThisSeq _ thisSeq; newCount _ runCount; SELECT TRUE FROM NOT seq.segments[i] AND NOT in => {}; NOT seq.segments[i] AND in => { newIn _ FALSE; newList _ AppendToList[list, CONS[thisSeq, NIL]]; newThisSeq _ NIL}; seq.segments[i] AND NOT in => { newIn _ TRUE; newThisSeq _ CreateEmptySeq[seq]; newCount _ newCount + 1; newThisSeq.segments[i] _ TRUE; newThisSeq.segCount _ newThisSeq.segCount + 1; ControlPointsTrue[newThisSeq, i]; }; seq.segments[i] AND in => { newThisSeq.segments[i] _ TRUE; newThisSeq.segCount _ newThisSeq.segCount + 1; ControlPointsTrue[newThisSeq, i]; }; ENDCASE => ERROR; }; ControlPointsTrue: PROC [seq: TrajParts, segNum: NAT] = { cpCount: NAT _ seq.controlPoints[segNum].len; FOR j: NAT IN [0..cpCount) DO IF NOT seq.controlPoints[segNum][j] THEN { seq.controlPoints[segNum][j] _ TRUE; seq.controlPointCount _ seq.controlPointCount + 1; }; ENDLOOP; }; NATGenerator: TYPE = REF NATGeneratorObj; NATGeneratorObj: TYPE = RECORD [ toGo: NAT, next: NAT, mod: NAT ]; NATsInInterval: PROC [start, length, mod: NAT] RETURNS [natGen: NATGenerator] = { natGen _ NEW[NATGeneratorObj _ [ toGo: length, next: start, mod: mod]]; }; NextNAT: PROC [natGen: NATGenerator] RETURNS [nextNAT: INT] = { IF natGen.toGo = 0 THEN RETURN[-1]; natGen.toGo _ natGen.toGo - 1; nextNAT _ natGen.next; natGen.next _ (natGen.next + 1) MOD natGen.mod; }; SegmentsInTraj: PUBLIC PROC [traj: TrajData] RETURNS [segGen: SegmentGenerator] = { <> segGen _ NEW[SegmentGeneratorObj _ [ traj: traj, toGo: traj.segCount, index: 0, seq: NIL, completeSeq: TRUE ]]; }; WalkSegmentsInTraj: PUBLIC PROC [traj: TrajData, walkProc: SegmentWalkProc] RETURNS [aborted: BOOL _ FALSE] = { <> seg: Segment; FOR i: NAT IN [0..GGTraj.HiSegmentTraj[traj]] DO seg _ GGTraj.FetchSegmentTraj[traj, i]; aborted _ walkProc[traj, seg, i]; IF aborted THEN RETURN; ENDLOOP; }; <<>> WalkSegmentsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts, walkProc: SegmentWalkProc] RETURNS [aborted: BOOL _ FALSE] = { <> seg: Segment; done: BOOL _ FALSE; toGo: NAT _ IF seq = NIL THEN 0 ELSE seq.segCount; segCount: NAT _ traj.segCount; index, touched: NAT _ 0; FOR i: NAT IN [1..toGo] DO UNTIL seq.segments[index] DO index _ (index + 1) MOD segCount; touched _ touched + 1; IF touched >= segCount THEN SIGNAL Problem[msg: "Broken invariant"]; ENDLOOP; seg _ GGTraj.FetchSegmentTraj[traj, index]; aborted _ walkProc[traj, seg, index]; IF aborted THEN RETURN; index _ (index + 1) MOD segCount; ENDLOOP; }; CountSegmentsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts] RETURNS [count: NAT] = { AddEmUp: PROC [traj: TrajData, seg: Segment, index: NAT] RETURNS [done: BOOL _ FALSE] = { count _ count + 1; }; count _ 0; [] _ WalkSegmentsInSequence[traj, seq, AddEmUp]; }; NextSegmentAndIndex: PUBLIC PROC [segGen: SegmentGenerator] RETURNS [next: SegAndIndex] = { <> <> <<1) When this procedure is called, seq.segments[segGen.index] has not yet been looked at OR segGen.toGo = 0.>> <<2) touched < segCount OR segGen.toGo = 0.>> segCount: NAT; seq: TrajParts _ segGen.seq; IF segGen.toGo = 0 THEN RETURN[[NIL, 999]]; segCount _ GGTraj.HiSegmentTraj[segGen.traj] + 1; IF NOT segGen.completeSeq THEN { -- If we are stepping through a complete traj, seq = NIL UNTIL seq.segments[segGen.index] DO segGen.index _ (segGen.index + 1) MOD segCount; segGen.touched _ segGen.touched + 1; IF segGen.touched >= segCount THEN SIGNAL Problem[msg: "Broken invariant"]; ENDLOOP; }; <<3) At this point in the procedure, seq.segments[segGen.index] is TRUE.>> <<4) At this point, touched < segCount.>> next.seg _ GGTraj.FetchSegmentTraj[segGen.traj, segGen.index]; next.index _ segGen.index; segGen.index _ (segGen.index + 1) MOD segCount; segGen.touched _ segGen.touched + 1; segGen.toGo _ segGen.toGo - 1; }; SegmentsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts] RETURNS [segGen: SegmentGenerator] = { <> IF IsComplete[seq] THEN { segGen _ SegmentsInTraj[traj]; RETURN; }; segGen _ NEW[SegmentGeneratorObj _ [ traj: IF seq=NIL THEN NIL ELSE traj, toGo: IF seq=NIL THEN 0 ELSE seq.segCount, index: 0, seq: seq, -- should we copy it? Bier January 27, 1986 5:37:01 pm PST completeSeq: FALSE ]]; }; OrderedSegmentsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts] RETURNS [segGen: SegmentGenerator] = { <> <> <> IF IsComplete[seq] THEN RETURN[SegmentsInTraj[traj]]; segGen _ NEW[SegmentGeneratorObj _ [ traj: traj, toGo: seq.segCount, index: IF seq.segCount=0 THEN 0 ELSE FirstSegment[seq], -- KAP December 22, 1986 seq: seq, -- should we copy it? Bier January 27, 1986 completeSeq: FALSE ]]; }; NextSegment: PUBLIC PROC [segGen: SegmentGenerator] RETURNS [next: Segment] = { <> <> <<1) When this procedure is called, seq.segments[segGen.index] has not yet been looked at OR segGen.toGo = 0.>> <<2) touched < segCount OR segGen.toGo = 0.>> segCount: NAT; seq: TrajParts _ segGen.seq; IF segGen.toGo = 0 THEN RETURN[NIL]; segCount _ GGTraj.HiSegmentTraj[segGen.traj] + 1; <> IF NOT segGen.completeSeq THEN { -- If we are stepping through a complete traj, seq = NIL UNTIL seq.segments[segGen.index] DO segGen.index _ (segGen.index + 1) MOD segCount; segGen.touched _ segGen.touched + 1; IF segGen.touched >= segCount THEN SIGNAL Problem[msg: "Broken invariant"]; ENDLOOP; }; <<3) At this point in the procedure, seq.segments[segGen.index] is TRUE.>> <<4) At this point, touched < segCount.>> next _ GGTraj.FetchSegmentTraj[segGen.traj, segGen.index]; segGen.index _ (segGen.index + 1) MOD segCount; segGen.touched _ segGen.touched + 1; segGen.toGo _ segGen.toGo - 1; }; ControlPointsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts] RETURNS [cpGen: ControlPointGenerator] = { <> <> cpGen _ NEW[ControlPointGeneratorObj _ [ traj: traj, seq: seq, toGo: IF seq=NIL THEN 0 ELSE seq.controlPointCount, segIndex: 0, cpIndex: 0 ]]; }; WalkControlPointsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts, walkProc: PointWalkProc] = { hiSegment: NAT _ seq.segments.len-1; seg: Segment; done: BOOL _ FALSE; FOR i: NAT IN [0..hiSegment] DO FOR j: NAT IN [0..seq.controlPoints[i].len) DO IF seq.controlPoints[i][j] THEN { seg _ GGTraj.FetchSegmentTraj[traj, i]; done _ walkProc[seg.class.controlPointGet[seg, j]]; IF done THEN RETURN; }; ENDLOOP; ENDLOOP; }; NextControlPoint: PUBLIC PROC [cpGen: ControlPointGenerator] RETURNS [next: PointAndDone] = { IF cpGen.toGo = 0 THEN RETURN[[[0,0], TRUE]] ELSE { trajParts: TrajParts _ cpGen.seq; seg: Segment; segIndex: NAT _ cpGen.segIndex; cpIndex: NAT _ cpGen.cpIndex; hiSegment: NAT _ trajParts.segments.len; FOR i: NAT IN [segIndex..hiSegment) DO FOR j: NAT IN [cpIndex..trajParts.controlPoints[i].len) DO IF trajParts.controlPoints[i][j] THEN { segIndex _ i; cpIndex _ j; GOTO Found; }; ENDLOOP; cpIndex _ 0; REPEAT Found => { seg _ GGTraj.FetchSegmentTraj[cpGen.traj, segIndex]; next.point _ seg.class.controlPointGet[seg, cpIndex]; next.done _ FALSE; }; FINISHED => ERROR; ENDLOOP; cpGen.segIndex _ segIndex; cpGen.cpIndex _ cpIndex + 1; cpGen.toGo _ cpGen.toGo - 1; }; }; NextSegNumAndCPNum: PUBLIC PROC [cpGen: ControlPointGenerator] RETURNS [segNum, cpNum: NAT, done: BOOL] = { IF cpGen.toGo = 0 THEN RETURN[0, 0, TRUE] ELSE { seq: TrajParts _ cpGen.seq; segIndex: NAT _ cpGen.segIndex; cpIndex: NAT _ cpGen.cpIndex; hiSegment: NAT _ seq.segments.len; FOR i: NAT IN [segIndex..hiSegment) DO FOR j: NAT IN [cpIndex..seq.controlPoints[i].len) DO IF seq.controlPoints[i][j] THEN { segIndex _ i; cpIndex _ j; GOTO Found; }; ENDLOOP; cpIndex _ 0; REPEAT Found => { segNum _ segIndex; cpNum _ cpIndex; done _ FALSE; }; FINISHED => ERROR; ENDLOOP; cpGen.segIndex _ segIndex; cpGen.cpIndex _ cpIndex + 1; cpGen.toGo _ cpGen.toGo - 1; }; }; JointsInSequence: PUBLIC PROC [seq: TrajParts] RETURNS [jointGen: JointGenerator] = { <> <> jointGen _ NEW[JointGeneratorObj _ [ -- this allocate is expensive too. traj: NIL, -- shouldn't be needed toGo: IF seq=NIL THEN 0 ELSE seq.jointCount, index: 0, seq: seq, completeSeq: FALSE -- for optimization. ]]; }; WalkJointPositionsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts, walkProc: JointWalkProc] = { <> jointPos: Point; done: BOOL _ FALSE; toGo: NAT _ IF seq = NIL THEN 0 ELSE seq.jointCount; hiJoint: NAT _ seq.joints.len; index: NAT _ 0; FOR i: NAT IN [1..toGo] DO UNTIL seq.joints[index] OR index > hiJoint DO index _ index + 1; ENDLOOP; IF index > hiJoint THEN ERROR; jointPos _ GGTraj.FetchJointPosTraj[traj, index]; done _ walkProc[traj, jointPos, index]; IF done THEN RETURN; index _ index + 1; ENDLOOP; }; WalkJointsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts, walkProc: PointWalkProc] = { <> jointPos: Point; done: BOOL _ FALSE; toGo: NAT _ IF seq = NIL THEN 0 ELSE seq.jointCount; hiJoint: NAT _ seq.joints.len; index: NAT _ 0; FOR i: NAT IN [1..toGo] DO UNTIL seq.joints[index] OR index > hiJoint DO index _ index + 1; ENDLOOP; IF index > hiJoint THEN ERROR; jointPos _ GGTraj.FetchJointPosTraj[traj, index]; done _ walkProc[jointPos]; IF done THEN RETURN; index _ index + 1; ENDLOOP; }; JointsInTraj: PUBLIC PROC [traj: TrajData] RETURNS [jointGen: JointGenerator] = { jointGen _ NEW[JointGeneratorObj _ [ traj: NIL, -- shouldn't be needed toGo: GGTraj.HiJointTraj[traj] + 1, index: 0, seq: NIL, completeSeq: TRUE ]]; }; NextJoint: PUBLIC PROC [jointGen: JointGenerator] RETURNS [next: INT] = { seq: TrajParts _ jointGen.seq; index: NAT _ jointGen.index; IF jointGen.toGo = 0 THEN RETURN[-1]; IF jointGen.completeSeq THEN { next _ index; } ELSE { <> hiJoint: NAT _ seq.joints.len; UNTIL seq.joints[index] OR index > hiJoint DO index _ index + 1; ENDLOOP; IF index > hiJoint THEN ERROR; next _ index; }; jointGen.index _ index + 1; jointGen.toGo _ jointGen.toGo - 1; }; END.