DIRECTORY
CodeTimer, Cubic2, CubicPathsExtras, GGAlign, GGBasicTypes, GGCaret, GGCircles, GGCoreTypes, GGInterfaceTypes, GGModelTypes, GGMultiGravity, GGParent, GGScene, GGSegmentTypes, GGSliceOps, GGState, GGUtility, Lines2d, Real, RealFns, Rope, Vectors2d;

GGMultiGravityImpl: CEDAR PROGRAM
IMPORTS CodeTimer, CubicPathsExtras, GGAlign, GGCaret, GGCircles, GGParent, GGScene, GGSliceOps, GGState, Lines2d, RealFns, Vectors2d
EXPORTS GGMultiGravity = BEGIN

AlignBag: TYPE = REF AlignBagObj;
AlignBagObj: TYPE = GGInterfaceTypes.AlignBagObj;
AlignmentCircle: TYPE = GGInterfaceTypes.AlignmentCircle;
AlignmentLine: TYPE = GGInterfaceTypes.AlignmentLine;
AlignmentPoint: TYPE = REF AlignmentPointObj;
AlignmentPointObj: TYPE = GGInterfaceTypes.AlignmentPointObj;
Arc: TYPE = GGBasicTypes.Arc;
Bezier: TYPE = Cubic2.Bezier;
BezierRef: TYPE = REF Bezier;
Caret: TYPE = GGInterfaceTypes.Caret;
Circle: TYPE = GGBasicTypes.Circle;
Edge: TYPE = GGBasicTypes.Edge;
FeatureCycler: TYPE = REF FeatureCyclerObj;
FeatureCyclerObj: TYPE = GGInterfaceTypes.FeatureCyclerObj;
FeatureData: TYPE = REF FeatureDataObj;
FeatureDataObj: TYPE = GGModelTypes.FeatureDataObj;
GGData: TYPE = GGInterfaceTypes.GGData;
GoodPoint: TYPE = REF GoodPointObj;
GoodPointObj: TYPE = GGInterfaceTypes.GoodPointObj;
GravityType: TYPE = GGInterfaceTypes.GravityType;
JointGenerator: TYPE = GGModelTypes.JointGenerator;
Line: TYPE = GGCoreTypes.Line;
NearVertexEdgeAndFaces: TYPE = REF NearVertexEdgeAndFacesObj;
NearVertexEdgeAndFacesObj: TYPE = GGInterfaceTypes.NearVertexEdgeAndFacesObj;
Point: TYPE = GGBasicTypes.Point;
PointPairAndDone: TYPE = GGModelTypes.PointPairAndDone;
PointPairGenerator: TYPE = GGModelTypes.PointPairGenerator;
Scene: TYPE = GGModelTypes.Scene;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
Sequence: TYPE = GGModelTypes.Sequence;
Slice: TYPE = GGModelTypes.Slice;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceDescriptorObj: TYPE = GGModelTypes.SliceDescriptorObj;
TriggerBag: TYPE = REF TriggerBagObj;
TriggerBagObj: TYPE = GGInterfaceTypes.TriggerBagObj;
Vector: TYPE = GGBasicTypes.Vector;

BestPoints: TYPE = REF BestPointsObj;
BestPointsObj: TYPE = RECORD [
size: NAT,
max, min: REAL,
maxIndex: NAT,
bestTossed: REAL, -- the distance of the closest object that has been thrown away
dTol: REAL, -- min + s
innerR: REAL, -- find all curves within this radius even if they are not neighbors of the nearest
s: REAL, -- the size of neighborhoods.  BestPoints should contain all objects that have been seen such that min <= dist(o, q) <= min+s, unless BestPoints overflows.
overflow: BOOL,
points: SEQUENCE len: NAT OF GoodPoint];

BestFaces: TYPE = REF BestFacesObj;
BestFacesObj: TYPE = RECORD [
size: NAT,
maxPriority, minPriority: INT,
minIndex: NAT,
bestPriorityTossed: INT,
priorityTol: INT, -- the farthest overlap level that we are interested in
overflow: BOOL,
faces: SEQUENCE len: NAT OF GoodPoint];

MultiGravityPool: TYPE = REF MultiGravityPoolObj;
MultiGravityPoolObj: TYPE = RECORD [
bestpoints: BestPoints,
bestcurves: BestPoints,
bestfaces: BestFaces
];

Problem: PUBLIC SIGNAL [msg: Rope.ROPE] = CODE;


Map: PUBLIC PROC [testPoint: Point, t: REAL, alignBag: AlignBag, sceneBag: TriggerBag, ggData: GGData, intersections: BOOL _ FALSE] RETURNS [resultPoint: Point, normal: Vector, feature: FeatureData, hitData: REF ANY] = {
ENABLE UNWIND => {
ggData.multiGravityPool _ NewMultiGravityPool[];
};
gravityType: GravityType _ GGState.GetGravityType[ggData];
CodeTimer.StartInt[$MultiMap, $Gargoyle];
IF GGState.GetGravity[ggData] THEN {
SELECT gravityType FROM
pointsPreferred =>
[resultPoint, normal, feature, hitData] _ PointsPreferred[testPoint, t, alignBag, sceneBag, ggData, intersections];
linesPreferred, facesPreferred =>
[resultPoint, normal, feature, hitData] _ LinesPreferred[testPoint, t, alignBag, sceneBag, ggData];
ENDCASE => ERROR;
}
ELSE {
resultPoint _ testPoint;
feature _ NIL;
normal _ [0,-1];
};
CodeTimer.StopInt[$MultiMap, $Gargoyle];
};
PointsPreferred: PUBLIC PROC [testPoint: Point, t: REAL, alignBag: AlignBag, sceneBag: TriggerBag, ggData: GGData, intersections: BOOL _ FALSE] RETURNS [resultPoint: Point, normal: Vector, feature: FeatureData, hitData: REF ANY] = {
count: NAT;
nearVEF: NearVertexEdgeAndFaces;
[nearVEF, count] _ MultiPointsPreferred[testPoint, t, alignBag, sceneBag, ggData, intersections];
IF count = 0 THEN RETURN [testPoint, [0,-1], NIL, NIL];
IF count = 1 THEN RETURN PrepareWinner[nearVEF, 0]
ELSE {
neighborCount: NAT _ 1;
s: REAL = 0.072; -- 1/1000 inches
nearestDist: REAL _ -1;
nearestDist _ nearVEF[0].dist;
FOR i: NAT IN [1..count) DO
IF nearVEF[i].dist - nearestDist < s THEN neighborCount _ neighborCount + 1;
ENDLOOP;
IF neighborCount = 1 THEN RETURN PrepareWinner[nearVEF, 0];
FOR i: NAT IN [0..neighborCount) DO
IF nearVEF[i].featureData.type = slice THEN {
RETURN PrepareWinner[nearVEF, i];
};
REPEAT
FINISHED => RETURN PrepareWinner[nearVEF, 0];
ENDLOOP;
};
};
LinesPreferred: PUBLIC PROC [testPoint: Point, t: REAL, alignBag: AlignBag, sceneBag: TriggerBag, ggData: GGData] RETURNS [resultPoint: Point, normal: Vector, feature: FeatureData, hitData: REF ANY] = {
nearVEF: NearVertexEdgeAndFaces;
count: NAT;
[nearVEF, count] _ MultiLinesPreferred[testPoint, t, alignBag, sceneBag, ggData];
IF count = 0 THEN RETURN [testPoint, [0,-1], NIL, NIL];
IF count = 1 THEN RETURN PrepareWinner[nearVEF, 0]
ELSE {
<<nearestDist: REAL _ -1;
bestSceneObject: INT _ -1;
neighborCount: NAT _ 1;
s: REAL = 0.072; -- 1/1000 inches
nearestDist _ nearVEF[0].dist;
FOR i: NAT IN [1..count) DO
IF nearVEF[i].dist - nearestDist < s THEN neighborCount _ neighborCount + 1;
ENDLOOP;
IF neighborCount = 1 THEN RETURN PrepareWinner[nearVEF, 0];
bestSceneObject _ -1;>>
RETURN PrepareWinner[nearVEF, 0];
};
};

FacesPreferred: PUBLIC PROC [testPoint: Point, t: REAL, alignBag: AlignBag, sceneBag: TriggerBag, ggData: GGData] RETURNS [resultPoint: Point, normal: Vector, feature: FeatureData, hitData: REF ANY] = {
nearVEF: NearVertexEdgeAndFaces;
count: NAT;

[nearVEF, count] _ MultiFacesPreferred[testPoint, t, alignBag, sceneBag, ggData];
IF count = 0 THEN RETURN [testPoint, [0,-1], NIL, NIL];
RETURN PrepareWinner[nearVEF, 0]
};

PrepareWinner: PROC [nearVEF: NearVertexEdgeAndFaces, index: NAT] RETURNS [resultPoint: Point, normal: Vector, feature: FeatureData, hitData: REF ANY] = {
goodPoint: GoodPoint _ nearVEF[index];
resultPoint _ goodPoint.point;
normal _ goodPoint.normal;
feature _ goodPoint.featureData;
hitData _ goodPoint.hitData;
};

EmptyCycler: PUBLIC PROC [testPoint: Point] RETURNS [featureCycler: FeatureCycler] = {
featureCycler _ NEW[FeatureCyclerObj _ [
nearVEF: NIL,
count: 0,
index: -1,
testPoint: testPoint
]];
};

MapCycler: PUBLIC PROC [testPoint: Point, t: REAL, alignBag: AlignBag, sceneBag: TriggerBag, ggData: GGData, intersections: BOOL _ FALSE] RETURNS [featureCycler: FeatureCycler] = {
ENABLE UNWIND => {
ggData.multiGravityPool _ NewMultiGravityPool[];
};
gravityType: GravityType _ GGState.GetGravityType[ggData];
IF GGState.GetGravity[ggData] THEN {
SELECT gravityType FROM
pointsPreferred =>
featureCycler _ PointsPreferredCycler[testPoint, t, alignBag, sceneBag, ggData, intersections];
linesPreferred, facesPreferred =>
featureCycler _ LinesPreferredCycler[testPoint, t, alignBag, sceneBag, ggData];
ENDCASE => ERROR;
}
ELSE {
featureCycler _ EmptyCycler[testPoint];
};
};

CopyVEF: PROC [vef: NearVertexEdgeAndFaces, count: NAT] RETURNS [copy: NearVertexEdgeAndFaces] = {
oldGoodPoint, newGoodPoint: GoodPoint;
copy _ NEW[NearVertexEdgeAndFacesObj[count]];
FOR i: NAT IN [0..count) DO
oldGoodPoint _ vef[i];
newGoodPoint _ NEW[GoodPointObj _ [
dist: oldGoodPoint.dist,
point: oldGoodPoint.point,
normal: oldGoodPoint.normal,
featureData: oldGoodPoint.featureData,
hitData: oldGoodPoint.hitData,
dimension: oldGoodPoint.dimension]];
copy[i] _ newGoodPoint;
ENDLOOP;
};

PointsPreferredCycler: PUBLIC PROC [testPoint: Point, t: REAL, alignBag: AlignBag, sceneBag: TriggerBag, ggData: GGData, intersections: BOOL _ FALSE, maxDimension: [0..1] _ 1] RETURNS [featureCycler: FeatureCycler] = {
count: NAT;
nearVEF: NearVertexEdgeAndFaces;
BEGIN
[nearVEF, count] _ MultiPointsPreferred[testPoint, t, alignBag, sceneBag, ggData, intersections];
IF count = 0 THEN RETURN[EmptyCycler[testPoint]];
IF count = 1 THEN GOTO MakeSimpleCycler
ELSE {
neighborCount: NAT _ 1;
s: REAL = 0.072; -- 1/1000 inches
nearestDist: REAL _ -1;

featureCycler _ NEW[FeatureCyclerObj _ [
nearVEF: NIL, -- will be filled in below
count: count,
index: -1,	-- will be filled in below
testPoint: testPoint
]];
nearestDist _ nearVEF[0].dist;
FOR i: NAT IN [1..count) DO
IF nearVEF[i].dist - nearestDist < s THEN neighborCount _ neighborCount + 1;
ENDLOOP;
IF neighborCount = 1 THEN GOTO MakeSimpleCycler;
featureCycler.nearVEF _ CopyVEF[nearVEF, count];
FOR i: NAT IN [0..neighborCount) DO
IF nearVEF[i].featureData.type = slice THEN {
featureCycler.index _ i;
RETURN;
};
REPEAT
FINISHED => featureCycler.index _ 0;
ENDLOOP;
};
EXITS
MakeSimpleCycler => {
featureCycler _ NEW[FeatureCyclerObj _ [
nearVEF: CopyVEF[nearVEF, count],
count: count,
index: 0,
testPoint: testPoint
]];
};
END;

};

LinesPreferredCycler: PUBLIC PROC [testPoint: Point, t: REAL, alignBag: AlignBag, sceneBag: TriggerBag, ggData: GGData] RETURNS [featureCycler: FeatureCycler] = {
nearVEF: NearVertexEdgeAndFaces;
count: NAT;
BEGIN
[nearVEF, count] _ MultiLinesPreferred[testPoint, t, alignBag, sceneBag, ggData];
IF count = 0 THEN RETURN[EmptyCycler[testPoint]];
IF count = 1 THEN GOTO MakeSimpleCycler
ELSE {
nearestDist: REAL _ -1;
bestSceneObject: INT _ -1;
neighborCount: NAT _ 1;
s: REAL = 0.072; -- 1/1000 inches
nearestDist _ nearVEF[0].dist;
FOR i: NAT IN [1..count) DO
IF nearVEF[i].dist - nearestDist < s THEN neighborCount _ neighborCount + 1;
ENDLOOP;
IF neighborCount = 1 THEN GOTO MakeSimpleCycler;
bestSceneObject _ -1;
featureCycler _ NEW[FeatureCyclerObj _ [
nearVEF: CopyVEF[nearVEF, count],
count: count,
index: 0,
testPoint: testPoint
]];
};
EXITS
MakeSimpleCycler => {
featureCycler _ NEW[FeatureCyclerObj _ [
nearVEF: CopyVEF[nearVEF, count],
count: count,
index: 0,
testPoint: testPoint
]];
};
END;
};

FacesPreferredCycler: PUBLIC PROC [testPoint: Point, t: REAL, alignBag: AlignBag, sceneBag: TriggerBag, ggData: GGData] RETURNS [featureCycler: FeatureCycler] = {
nearVEF: NearVertexEdgeAndFaces;
count: NAT;
BEGIN
[nearVEF, count] _ MultiFacesPreferred[testPoint, t, alignBag, sceneBag, ggData];
IF count = 0 THEN RETURN[EmptyCycler[testPoint]];
IF count = 1 THEN GOTO MakeSimpleCycler
ELSE {
GOTO MakeSimpleCycler;
<<nearestDist: REAL _ -1;
bestSceneObject: INT _ -1;
neighborCount: NAT _ 1;
s: REAL = 0.072; -- 1/1000 inches
nearestDist _ nearVEF[0].dist;
FOR i: NAT IN [1..count) DO
IF nearVEF[i].dist - nearestDist < s THEN neighborCount _ neighborCount + 1;
ENDLOOP;
IF neighborCount = 1 THEN GOTO MakeSimpleCycler;
bestSceneObject _ -1;
featureCycler _ NEW[FeatureCyclerObj _ [
nearVEF: CopyVEF[nearVEF, count],
count: count,
index: 0,
testPoint: testPoint
]];>>
};
EXITS
MakeSimpleCycler => {
featureCycler _ NEW[FeatureCyclerObj _ [
nearVEF: CopyVEF[nearVEF, count],
count: count,
index: 0,
testPoint: testPoint
]];
};
END;
};
FirstFeature: PUBLIC PROC [featureCycler: FeatureCycler] RETURNS [resultPoint: Point, normal: Vector, feature: FeatureData, hitData: REF ANY] = {
RETURN GetFeature[featureCycler, 0];
};

NextFeature: PUBLIC PROC [featureCycler: FeatureCycler] RETURNS [resultPoint: Point, normal: Vector, feature: FeatureData, hitData: REF ANY] = {
RETURN GetFeature[featureCycler, 1];
};

PreviousFeature: PUBLIC PROC [featureCycler: FeatureCycler] RETURNS [resultPoint: Point, normal: Vector, feature: FeatureData, hitData: REF ANY] = {
RETURN GetFeature[featureCycler, -1];
};

GetFeature: PUBLIC PROC [featureCycler: FeatureCycler, move: [-1..1]] RETURNS [resultPoint: Point, normal: Vector, feature: FeatureData, hitData: REF ANY] = {
IF featureCycler = NIL THEN { -- return a backdrop position
resultPoint _ [0.0, 0.0]; -- bogus
normal _ [0,-1];
feature _ NIL;
hitData _ NIL;
}
ELSE IF featureCycler.count = 0 THEN { -- return a backdrop position
resultPoint _ featureCycler.testPoint;
normal _ [0,-1];
feature _ NIL;
hitData _ NIL;
}
ELSE {
featureCycler.index _ (featureCycler.index + move + featureCycler.count) MOD featureCycler.count;
[resultPoint, normal, feature, hitData] _ PrepareWinner[featureCycler.nearVEF, featureCycler.index];
};
};

MultiMap: PUBLIC PROC [testPoint: Point, t: REAL, alignBag: AlignBag, sceneBag: TriggerBag, ggData: GGData, intersections: BOOL _ FALSE] RETURNS [nearVEF: NearVertexEdgeAndFaces, count: NAT] = {
ENABLE UNWIND => ggData.multiGravityPool _ NewMultiGravityPool[];  -- in case an ABORT happened while pool was in use
CodeTimer.StartInt[$MultiMap, $Gargoyle];
IF GGState.GetGravity[ggData] THEN {
SELECT GGState.GetGravityType[ggData] FROM
linesPreferred =>
[nearVEF, count] _ MultiLinesPreferred[testPoint, t, alignBag, sceneBag, ggData];
pointsPreferred =>
[nearVEF, count] _ MultiPointsPreferred[testPoint, t, alignBag, sceneBag, ggData, intersections];
ENDCASE => ERROR;
}
ELSE {
nearVEF _ NIL;
count _ 0;
};
CodeTimer.StopInt[$MultiMap, $Gargoyle];
};

MultiFacesPreferred: PUBLIC PROC [testPoint: Point, t: REAL, alignBag: AlignBag, sceneBag: TriggerBag, ggData: GGData] RETURNS [nearVEF: NearVertexEdgeAndFaces, count: NAT] = {
bestCurves, bestPoints: BestPoints;
bestFaces: BestFaces;
faceCount, curveCount, pointCount: NAT;

IF GGAlign.EmptyAlignBag[alignBag] AND GGAlign.EmptyTriggerBag[sceneBag] THEN RETURN[NIL, 0];

[bestFaces, faceCount] _ FacesInNeighborhoodPlus[alignBag, sceneBag, testPoint, ggData, t];
SortByOverlap[bestFaces, faceCount];

[bestCurves, curveCount] _ CurvesInNeighborhoodPlus[alignBag, sceneBag, testPoint, ggData, t, 0];

[bestPoints, pointCount] _ VertsInNeighborhoodPlus[bestCurves, curveCount, alignBag, sceneBag, testPoint, t, ggData, FALSE];
SortPoints[bestPoints, pointCount];

count _ MIN[pointCount + curveCount, MaxFeatures];
nearVEF _ NEW[NearVertexEdgeAndFacesObj[count]];
MergePointsAndCurves[bestPoints, pointCount, bestCurves, curveCount, nearVEF, count];
[nearVEF, count] _ MergeByOverlapAndDistance[bestFaces, faceCount, nearVEF, count];
};

MultiLinesPreferred: PUBLIC PROC [testPoint: Point, t: REAL, alignBag: AlignBag, sceneBag: TriggerBag, ggData: GGData] RETURNS [nearVEF: NearVertexEdgeAndFaces, count: NAT] = {
bestCurves: BestPoints;
bestPoints: BestPoints;
pointCount, curveCount: NAT;

IF GGAlign.EmptyAlignBag[alignBag] AND GGAlign.EmptyTriggerBag[sceneBag] THEN RETURN[NIL, 0];

[bestCurves, curveCount] _ CurvesInNeighborhoodPlus[alignBag, sceneBag, testPoint, ggData, t, 0];

[bestPoints, pointCount] _ VertsInNeighborhoodPlus[bestCurves, curveCount, alignBag, sceneBag, testPoint, t, ggData, FALSE];
SortPoints[bestPoints, pointCount];

count _ MIN[pointCount + curveCount, MaxFeatures];
nearVEF _ NEW[NearVertexEdgeAndFacesObj[count]];
MergePointsAndCurves[bestPoints, pointCount, bestCurves, curveCount, nearVEF, count];
};

MultiPointsPreferred: PUBLIC PROC [testPoint: Point, t: REAL, alignBag: AlignBag, sceneBag: TriggerBag, ggData: GGData, intersections: BOOL _ FALSE] RETURNS [nearVEF: NearVertexEdgeAndFaces, count: NAT] = {
bestCurves: BestPoints;
bestPoints: BestPoints;
pointCount, curveCount: NAT;
innerR: REAL _ t/2.0;
IF GGAlign.EmptyAlignBag[alignBag] AND GGAlign.EmptyTriggerBag[sceneBag] THEN RETURN[NIL, 0];

[bestCurves, curveCount] _ CurvesInNeighborhoodPlus[alignBag, sceneBag, testPoint, ggData, t, innerR];

[bestPoints, pointCount] _ VertsInNeighborhoodPlus[bestCurves, curveCount, alignBag, sceneBag, testPoint, t, ggData, intersections];
SortPoints[bestPoints, pointCount];

IF pointCount > 0 AND bestPoints[0].dist < innerR THEN {
count _ pointCount;
nearVEF _ NEW[NearVertexEdgeAndFacesObj[count]];
NearPointsFromPoints[bestPoints, pointCount, nearVEF];
}
ELSE {
count _ MIN[pointCount + curveCount, MaxFeatures];
nearVEF _ NEW[NearVertexEdgeAndFacesObj[count]];
MergePointsAndCurves[bestPoints, pointCount, bestCurves, curveCount, nearVEF, count];
};
};

VertsInNeighborhoodPlus: PROC [bestCurves: BestPoints, curveCount: NAT, alignBag: AlignBag, sceneBag: TriggerBag, q: Point, t: REAL, ggData: GGData, intersections: BOOL _ FALSE] RETURNS [h: BestPoints, pointCount: NAT] = {
thisPoint: GoodPoint;
ProcessPoint: PROC [thisPoint: GoodPoint, featureData: FeatureData] = { -- used for the anchor
dSquared: REAL;
dTolSquared: REAL _ dTol*dTol;
dSquared _ Vectors2d.DistanceSquared[thisPoint.point, q];
thisPoint.hitData _ NIL;
IF dSquared < dTolSquared THEN {
thisPoint.dist _ RealFns.SqRt[dSquared];
thisPoint.normal _ GGCaret.GetNormal[NARROW[featureData.shape]]; -- the anchor
IF Vectors2d.MagnitudeSquared[thisPoint.normal] = 0 THEN thisPoint.normal _ [0, -1];
thisPoint.featureData _ featureData;
thisPoint.priority _ -1;
dTol _ AddNeighbor[thisPoint, h, FALSE];
};
};
ProcessSlice: PROC [sliceD: SliceDescriptor, thisPoint: GoodPoint, featureData: FeatureData] = {
[thisPoint.point, thisPoint.dist, thisPoint.normal, thisPoint.hitData, success] _ sliceD.slice.class.closestPoint[sliceD, q, dTol];
IF success THEN {
IF thisPoint.dist < dTol THEN {
thisPoint.featureData _ featureData;
IF Vectors2d.MagnitudeSquared[thisPoint.normal] = 0 THEN  {
thisPoint.normal _ [0, -1];
};
thisPoint.priority _ GGScene.GetPriority[ggData.scene, sliceD.slice];
dTol _ AddNeighbor[thisPoint, h, FALSE];
};
};
};
DoForSliceTrigger: GGAlign.FeatureWalkProc = {
sliceD _ NARROW[feature.shape, SliceDescriptor];
ProcessSlice[sliceD, thisPoint, feature];
};

sliceD: SliceDescriptor;
featureData: FeatureData;
success: BOOL _ FALSE;
dTol: REAL _ t;
midpoints: BOOL _ GGState.GetMidpoints[ggData];

thisPoint _ NEW[GoodPointObj];
h _ BestPointsFromPool[ggData, t];

IF intersections THEN {
dTol _ FindIntersections[bestCurves, curveCount, thisPoint, q, dTol, h, ggData.scene];
IF midpoints THEN dTol _ FindMidpoints[bestCurves, curveCount, thisPoint, q, dTol, h, ggData.scene];
};

GGAlign.WalkSliceTriggers[sceneBag, DoForSliceTrigger];
featureData _ alignBag.anchor;
IF featureData # NIL THEN {
anchor: Caret _ NARROW[featureData.shape];
IF NOT GGCaret.Exists[anchor] THEN ERROR;
thisPoint.point _ GGCaret.GetPoint[anchor];
ProcessPoint[thisPoint, featureData];
};
pointCount _ h.size;
IF h.overflow THEN {
CodeTimer.StartInt[$PointOverflow, $Gargoyle];
CodeTimer.StopInt[$PointOverflow, $Gargoyle]; 
};
}; -- end of VertsInNeighborhoodPlus
FindIntersections: PROC [bestCurves: BestPoints, curveCount: NAT, thisPoint: GoodPoint, q: Point, tolerance: REAL, h: BestPoints, scene: Scene] RETURNS [dTol: REAL] = {
curveI, curveJ: GoodPoint;
theseIPoints: LIST OF Point;
thisTangency, tangentList: LIST OF BOOL;
success: BOOL _ FALSE;
dTol _ tolerance;
FOR i: NAT IN [0..curveCount) DO
curveI _ bestCurves[i];
IF curveI.dist > dTol THEN EXIT; -- this curve is too far away (and the rest are farther)
FOR j: NAT IN [0..i] DO
curveJ _ bestCurves[j];
IF curveJ.dist > dTol THEN LOOP; -- this curve is too far away to be worth considering
[theseIPoints, thisTangency] _ CurveMeetsCurve[curveI, curveJ];
tangentList _ thisTangency;
FOR list: LIST OF Point _ theseIPoints, list.rest UNTIL list = NIL DO
thisPoint.point _ list.first;
thisPoint.dist _ Vectors2d.Distance[thisPoint.point, q];
success _ thisPoint.dist <= dTol;
IF success THEN {
featureData: FeatureData _ NEW[FeatureDataObj];
alignmentPoint: AlignmentPoint _ NEW[AlignmentPointObj _ [
point: thisPoint.point,
tangent: tangentList.first,
curve1: curveI.featureData,
curve2: curveJ.featureData]];
featureData.type _ intersectionPoint;
featureData.shape _ alignmentPoint;
thisPoint.featureData _ featureData;
thisPoint.priority _ -1;
IF curveI.featureData.type = slice THEN {
sliceD: SliceDescriptor _ NARROW[curveI.featureData.shape];
slice: Slice _ sliceD.slice;
thisPoint.priority _ GGScene.GetPriority[scene, slice];
thisPoint.hitData _ curveI.hitData;
thisPoint.normal _ GGSliceOps.ClosestSegment[sliceD, q, dTol].bestNormal; -- find normal at nearest vertex.  Works for straight edges
}
ELSE IF curveJ.featureData.type = slice THEN {
sliceD: SliceDescriptor _ NARROW[curveJ.featureData.shape];
slice: Slice _ sliceD.slice;
thisPoint.priority _ MIN[thisPoint.priority, GGScene.GetPriority[scene, slice]];
thisPoint.hitData _ curveJ.hitData;
thisPoint.normal _ GGSliceOps.ClosestSegment[sliceD, q, dTol].bestNormal; -- find normal at nearest vertex.  Works for straight edges
}
ELSE thisPoint.hitData _ NIL;
IF Vectors2d.MagnitudeSquared[thisPoint.normal] = 0 THEN thisPoint.normal _ [0, -1];
dTol _ AddNeighbor[thisPoint, h, FALSE];
};
tangentList _ tangentList.rest;
ENDLOOP;
ENDLOOP;
ENDLOOP;
};

FindMidpoints: PROC [bestCurves: BestPoints, curveCount: NAT, thisPoint: GoodPoint, q: Point, tolerance: REAL, h: BestPoints, scene: Scene] RETURNS [dTol: REAL] = {
curve: GoodPoint;
midpoint: Point;
success: BOOL _ FALSE;
dTol _ tolerance;
FOR i: NAT IN [0..curveCount) DO
curve _ bestCurves[i];
IF curve.featureData.type#slice THEN LOOP;
[midpoint, success] _ ComputeMidpoint[curve];
IF NOT success THEN LOOP;
thisPoint.point _ midpoint;
thisPoint.dist _ Vectors2d.Distance[thisPoint.point, q];
success _ thisPoint.dist <= dTol;
IF success THEN {
sliceD: SliceDescriptor _ NARROW[curve.featureData.shape];
slice: Slice _ sliceD.slice;
featureData: FeatureData _ NEW[FeatureDataObj];
alignmentPoint: AlignmentPoint _ NEW[AlignmentPointObj _ [
point: thisPoint.point,
tangent: FALSE,
curve1: curve.featureData,
curve2: NIL]];
featureData.type _ midpoint;
featureData.shape _ alignmentPoint;
thisPoint.featureData _ featureData;
thisPoint.hitData _ curve.hitData;
thisPoint.normal _ GGSliceOps.ClosestSegment[sliceD, q, dTol].bestNormal; -- find normal at nearest vertex.  Works for edges
IF Vectors2d.MagnitudeSquared[thisPoint.normal] = 0 THEN thisPoint.normal _ [0, -1];
thisPoint.priority _ GGScene.GetPriority[scene, slice];
dTol _ AddNeighbor[thisPoint, h, FALSE];
};
ENDLOOP;
};

CurvesInNeighborhoodPlus: PROC [alignBag: AlignBag, sceneBag: TriggerBag, q: Point, ggData: GGData, t: REAL, innerR: REAL] RETURNS [h: BestPoints, curveCount: NAT] = {
ProcessLine: PROC [line: Line, thisCurve: GoodPoint, featureData: FeatureData] = {
thisCurve.dist _ Lines2d.LineDistance[q, line];
IF thisCurve.dist < dTol THEN {
thisCurve.featureData _ featureData;
thisCurve.point _ Lines2d.DropPerpendicular[q, line];
thisCurve.normal _ Vectors2d.Sub[q, thisCurve.point];
IF Vectors2d.MagnitudeSquared[thisCurve.normal] = 0 THEN  {
thisCurve.normal _ [0, -1];};
thisCurve.hitData _ NIL;
thisCurve.priority _ -1;
dTol _ AddNeighbor[thisCurve, h, TRUE];
}
};
ProcessCircle: PROC [circle: Circle, thisCurve: GoodPoint, featureData: FeatureData] = {
QProjectedOntoCircle: PUBLIC PROC  [] RETURNS [projectedPt: Point] = {
epsilon: REAL = 1.0e-5;
IF distQtoCenter < epsilon THEN projectedPt _ [circle.origin.x + circle.radius, circle.origin.y]
ELSE projectedPt _ Vectors2d.Add[circle.origin, Vectors2d.Scale[centerToQ, circle.radius/distQtoCenter]];
};
centerToQ: Vector _ Vectors2d.Sub[q, circle.origin];
distQtoCenter: REAL _ Vectors2d.Magnitude[centerToQ];
thisCurve.dist _ ABS[distQtoCenter-circle.radius];
IF thisCurve.dist < dTol THEN {
thisCurve.featureData _ featureData;
thisCurve.point _ QProjectedOntoCircle[];
IF thisCurve.dist = 0.0 THEN thisCurve.normal _ centerToQ
ELSE thisCurve.normal _ Vectors2d.Sub[q, thisCurve.point];
thisCurve.hitData _ NIL;
thisCurve.priority _ -1;
dTol _ AddNeighbor[thisCurve, h, TRUE];
};
};
ProcessSlice: PROC [sliceD: SliceDescriptor, thisCurve: GoodPoint, featureData: FeatureData] = {
success: BOOL _ FALSE;
[thisCurve.point, thisCurve.dist, thisCurve.normal, thisCurve.hitData, success] _ sliceD.slice.class.closestSegment[sliceD, q, dTol];
IF success THEN {
IF thisCurve.dist < dTol THEN {
thisCurve.featureData _ featureData;
IF Vectors2d.MagnitudeSquared[thisCurve.normal] = 0 THEN  {
thisCurve.normal _ [0, -1];
};
thisCurve.priority _ GGScene.GetPriority[ggData.scene, sliceD.slice];
dTol _ AddNeighbor[thisCurve, h, TRUE];
};
};
};
ProcessSlopeLine: GGAlign.FeatureWalkProc = {
line _ NARROW[feature.shape, AlignmentLine].line;
ProcessLine[line, thisCurve, feature];
};
DoForSceneSlice: GGAlign.FeatureWalkProc = {
sliceD _ NARROW[feature.shape, SliceDescriptor];
ProcessSlice[sliceD, thisCurve, feature];
};
line: Line;
circle: Circle;
sliceD: SliceDescriptor;
featureData: FeatureData;
added: BOOL _ FALSE;
thisCurve: GoodPoint _ NEW[GoodPointObj];
dTol: REAL _ t;
h _ BestCurvesFromPool[ggData, t, innerR];

GGAlign.WalkSlopeLines[alignBag, ProcessSlopeLine];
FOR angleLines: LIST OF FeatureData _ alignBag.angleLines, angleLines.rest UNTIL angleLines = NIL DO
featureData _ angleLines.first;
line _ NARROW[featureData.shape, AlignmentLine].line;
ProcessLine[line, thisCurve, featureData];
ENDLOOP;
FOR dLines: LIST OF FeatureData _ alignBag.distanceLines, dLines.rest UNTIL dLines = NIL DO
featureData _ dLines.first;
line _ NARROW[featureData.shape];
ProcessLine[line, thisCurve, featureData];
ENDLOOP;
FOR circles: LIST OF FeatureData _ alignBag.radiiCircles, circles.rest UNTIL circles = NIL DO
featureData _ circles.first;
circle _ NARROW[featureData.shape, AlignmentCircle].circle;
ProcessCircle[circle, thisCurve, featureData];
ENDLOOP;
GGAlign.WalkSliceTriggers[sceneBag, DoForSceneSlice];
curveCount _ h.size;
IF h.overflow THEN {
CodeTimer.StartInt[$CurveOverflow, $Gargoyle];
CodeTimer.StopInt[$CurveOverflow, $Gargoyle];
};
SortCurves[h, curveCount];
}; -- end CurvesInNeighborhoodPlus

FacesInNeighborhoodPlus: PROC [alignBag: AlignBag, sceneBag: TriggerBag, q: Point, ggData: GGData, t: REAL] RETURNS [h: BestFaces, faceCount: NAT] = {
sliceD: SliceDescriptor;
added: BOOL _ FALSE;
thisFace: GoodPoint _ NEW[GoodPointObj];
priorityTol: INT _ -1;

ProcessSlice: PROC [sliceD: SliceDescriptor, thisFace: GoodPoint, featureData: FeatureData] = {
hitData: REF ANY;
moreHitDatas: LIST OF REF ANY;
success: BOOL _ TRUE;
IF GGScene.GetPriority[ggData.scene, sliceD.slice] >= priorityTol THEN {
[hitData, moreHitDatas] _ GGSliceOps.FilledPathsUnderPoint[sliceD.slice, q, t];
IF hitData # NIL THEN {
thisFace.point _ q;
thisFace.priority _ GGScene.GetPriority[ggData.scene, sliceD.slice];
thisFace.normal _ [0, -1];
thisFace.hitData _ hitData;
thisFace.featureData _ featureData;
priorityTol _ AddFace[thisFace, h];
};
FOR list: LIST OF REF ANY _ moreHitDatas, list.rest UNTIL list = NIL DO
thisFace.point _ q;
thisFace.priority _ GGScene.GetPriority[ggData.scene, sliceD.slice];
thisFace.normal _ [0, -1];
thisFace.hitData _ list.first;
thisFace.featureData _ featureData;
priorityTol _ AddFace[thisFace, h];
ENDLOOP;
};
};
DoForSceneSlice: GGAlign.FeatureWalkProc = {
sliceD _ NARROW[feature.shape, SliceDescriptor];
ProcessSlice[sliceD, thisFace, feature];
};

h _ BestFacesFromPool[ggData];

GGAlign.WalkSliceTriggers[sceneBag, DoForSceneSlice];

faceCount _ h.size;
IF h.overflow THEN {
CodeTimer.StartInt[$FaceOverflow, $Gargoyle];
CodeTimer.StopInt[$FaceOverflow, $Gargoyle];
};
SortFaces[h, faceCount];
};

MaxFeatures: NAT _ 20;

BestFacesFromPool: PROC [ggData: GGData] RETURNS [h: BestFaces] = {
h _ NARROW[ggData.multiGravityPool, MultiGravityPool].bestfaces;
h.size _ 0;
h.maxPriority _ -1;
h.minIndex _ 9999;
h.minPriority _ LAST[INT];
h.bestPriorityTossed _ -1;
h.overflow _ FALSE;
FOR i: NAT IN [0..MaxFeatures) DO
h[i].dist _ Real.LargestNumber;
h[i].featureData _ NIL;
ENDLOOP;
};

BestCurvesFromPool: PROC [ggData: GGData, t: REAL, innerR: REAL] RETURNS [h: BestPoints] = {
h _ NARROW[ggData.multiGravityPool, MultiGravityPool].bestcurves;
h.size _ 0;
h.max _ 0.0;
h.maxIndex _ 9999;
h.min _ Real.LargestNumber;
h.dTol _ t;
h.innerR _ innerR;
h.s _ 0.072; -- 1/1000 inches
h.bestTossed _ Real.LargestNumber;
h.overflow _ FALSE;
FOR i: NAT IN [0..MaxFeatures) DO
h[i].dist _ Real.LargestNumber;
h[i].featureData _ NIL;
ENDLOOP;
};

BestPointsFromPool: PROC [ggData: GGData, t: REAL] RETURNS [h: BestPoints] = {
h _ NARROW[ggData.multiGravityPool, MultiGravityPool].bestpoints;
h.size _ 0;
h.max _ 0.0;
h.maxIndex _ 9999;
h.min _ Real.LargestNumber;
h.dTol _ t;
h.s _ 0.072; -- 1/1000 inches
h.bestTossed _ Real.LargestNumber;
h.overflow _ FALSE;
FOR i: NAT IN [0..MaxFeatures) DO
h[i].dist _ Real.LargestNumber;
h[i].featureData _ NIL;
ENDLOOP;
};

AddNeighbor: PROC [thisPoint: GoodPoint, h: BestPoints, curve: BOOL _ FALSE] RETURNS [dTol: REAL] = {
d: REAL _ thisPoint.dist;
n: NAT = MaxFeatures;
BEGIN
SELECT TRUE FROM
d > h.dTol => GOTO Toss; -- the caller is not taking our hints and is passing us trash
h.size < n => GOTO Add;
h.size = n => GOTO ReplaceOrOverflow;
ENDCASE => SIGNAL Problem[msg: "Impossible case."];
EXITS
Add => {
h[h.size]^ _ thisPoint^;
IF d > h.max THEN {h.max _ d; h.maxIndex _ h.size};
h.min _ MIN[h.min, d];
h.size _ h.size + 1;
IF curve THEN dTol _ h.dTol _ MAX[h.min+h.s, h.innerR]
ELSE dTol _ h.dTol _ h.min+h.s;
};
ReplaceOrOverflow => {
IF d < h.max THEN { -- do the replace
h[h.maxIndex]^ _ thisPoint^;
h.bestTossed _ MIN[h.bestTossed, h.max];
h.min _ MIN[h.min, d];
IF curve THEN dTol _ h.dTol _ MAX[h.min+h.s, h.innerR]
ELSE dTol _ h.dTol _ h.min+h.s;
h.overflow _ h.bestTossed <= dTol;
BEGIN
maxIndex: NAT _ 0;
maxDist: REAL _ 0.0;
FOR i: NAT IN [0..MaxFeatures) DO
IF h[i].dist > maxDist THEN {maxIndex _ i; maxDist _ h[i].dist};
ENDLOOP;
h.max _ maxDist;
h.maxIndex _ maxIndex;
END;
}
ELSE { -- toss the new item
dTol _ h.dTol;
h.bestTossed _ MIN[h.bestTossed, d];
h.overflow _ TRUE;
};
};
Toss => {
dTol _ h.dTol;
h.bestTossed _ MIN[h.bestTossed, d];
h.overflow _ h.bestTossed <= dTol;
};
END;
};

AddFace: PROC [thisFace: GoodPoint, h: BestFaces] RETURNS [priorityTol: INT] = {
d: INT _ thisFace.priority;
n: NAT = MaxFeatures;
BEGIN
SELECT TRUE FROM
d < h.priorityTol => GOTO Toss; -- the caller is passing us trash
h.size < n => GOTO Add;
h.size = n => GOTO ReplaceOrOverflow;
ENDCASE => SIGNAL Problem[msg: "Impossible case."];
EXITS
Add => {
h[h.size]^ _ thisFace^;
IF d < h.minPriority THEN {h.minPriority _ d; h.minIndex _ h.size};
h.maxPriority _ MAX[h.maxPriority, d];
h.size _ h.size + 1;
priorityTol _ h.priorityTol;
};
ReplaceOrOverflow => {
IF d > h.minPriority THEN { -- do the replace
h[h.minIndex]^ _ thisFace^;
h.bestPriorityTossed _ MAX[h.bestPriorityTossed, h.minPriority];
h.maxPriority _ MAX[h.maxPriority, d];
h.overflow _ TRUE;
BEGIN
minIndex: NAT _ 0;
minPriority: INT _ LAST[INT];
FOR i: NAT IN [0..MaxFeatures) DO
IF h[i].priority < minPriority THEN {minIndex _ i; minPriority _ h[i].priority};
ENDLOOP;
h.minPriority _ minPriority;
h.minIndex _ minIndex;
END;
priorityTol _ h.priorityTol _ h.minPriority;
}
ELSE { -- toss the new item
priorityTol _ h.priorityTol;
h.bestPriorityTossed _ MAX[h.bestPriorityTossed, d];
h.overflow _ TRUE;
};
};
Toss => {
priorityTol _ h.priorityTol;
h.bestPriorityTossed _ MAX[h.bestPriorityTossed, d];
h.overflow _ TRUE;
};
END;
};

NearPointsFromPoints: PROC [bestPoints: BestPoints, pointCount: NAT, nearVEF: NearVertexEdgeAndFaces] = {
FOR i: NAT IN [0..pointCount) DO
nearVEF[i] _ bestPoints[i];
ENDLOOP;
};

MergePointsAndCurves: PROC [bestPoints: BestPoints, pointCount: NAT, bestCurves: BestPoints, curveCount: NAT, nearVEF: NearVertexEdgeAndFaces, count: NAT] = {
pointIndex, curveIndex: NAT;
pointDist, curveDist: REAL;
pointIndex _ 0;
curveIndex _ 0;
FOR i: INTEGER IN [0..count) DO
IF pointIndex >= pointCount THEN GOTO NoMorePoints;
IF curveIndex >= curveCount THEN GOTO NoMoreCurves;
pointDist _ bestPoints[i].dist;
curveDist _ bestCurves[i].dist;
IF pointDist <= curveDist THEN {
nearVEF[i] _ bestPoints[pointIndex];
pointIndex _ pointIndex + 1;
}
ELSE {
nearVEF[i] _ bestCurves[curveIndex];
curveIndex _ curveIndex + 1;
};
REPEAT
NoMorePoints => { -- finish up with Curves data
FOR k: NAT _ i, k+1 UNTIL k >= count DO
nearVEF[k] _ bestCurves[curveIndex];
curveIndex _ curveIndex + 1;
ENDLOOP};
NoMoreCurves => { -- finish up with points data
FOR k: NAT _ i, k+1 UNTIL k >= count DO
nearVEF[k] _ bestPoints[pointIndex];
pointIndex _ pointIndex + 1;
ENDLOOP};
ENDLOOP;
};

MergeByOverlapAndDistance: PROC [faces: BestFaces, faceCount: NAT, curves: NearVertexEdgeAndFaces, curveCount: NAT] RETURNS [nearVEF: NearVertexEdgeAndFaces, total: NAT] = {
facePtr, curvePtr: NAT;

total _ MIN[curveCount+faceCount, MaxFeatures];
nearVEF _ NEW[NearVertexEdgeAndFacesObj[total]];
facePtr _ curvePtr _ 0;

FOR i: NAT IN[0..total) DO
IF curvePtr >= curveCount THEN GOTO CurvePtrWentOver;
IF facePtr >= faceCount THEN GOTO FacePtrWentOver;

BEGIN
SELECT faces[facePtr].priority - curves[curvePtr].priority FROM
= 0 => { -- they're part of the same slice
slice: Slice _ NARROW[faces[facePtr].featureData.shape, SliceDescriptor].slice;
IF GGParent.IsParent[slice] THEN {
facePath, curvePath: Slice;
faceHitData, curveHitData: REF ANY;
[facePath, faceHitData] _ GGParent.PathOfHitData[slice, faces[facePtr].hitData];
[curvePath, curveHitData] _ GGParent.PathOfHitData[slice, curves[curvePtr].hitData];
IF facePath = curvePath THEN GOTO RemoveDuplicate;
SELECT GGParent.ComparePriorities[facePath, curvePath] FROM
less => GOTO CurveIsCloser;
greater => GOTO FaceIsCloser;
equal => GOTO RemoveDuplicate;
ENDCASE => ERROR;
}
ELSE GOTO RemoveDuplicate;
};
> 0 => GOTO FaceIsCloser;
< 0 => GOTO CurveIsCloser;
ENDCASE => ERROR;
EXITS
RemoveDuplicate => {
nearVEF[i] _ curves[curvePtr];
curvePtr _ curvePtr + 1;
facePtr _ facePtr + 1;
total _ total - 1; -- a duplicate has been removed
};
FaceIsCloser => {
nearVEF[i] _ faces[facePtr];
facePtr _ facePtr + 1;
};
CurveIsCloser => {
nearVEF[i] _ curves[curvePtr];
curvePtr _ curvePtr + 1;
};
END;
REPEAT
CurvePtrWentOver => { -- finish up with faces
FOR k: NAT _ i, k+1 UNTIL k >= total DO
nearVEF[k] _ faces[facePtr];
facePtr _ facePtr + 1;
ENDLOOP};
FacePtrWentOver => { -- finish up with curves
FOR k: NAT _ i, k+1 UNTIL k >= total DO
nearVEF[k] _ curves[curvePtr];
curvePtr _ curvePtr + 1;
ENDLOOP};
ENDLOOP;
}; -- end of MergeByOverlapAndDistance

SortPoints: PROC [bestPoints: BestPoints, pointCount: NAT] = {
temp: GoodPoint;
FOR i: INTEGER IN [0..pointCount-2] DO
FOR j: INTEGER IN [1..pointCount-i) DO
IF bestPoints[j-1].dist > bestPoints[j].dist THEN {
temp _ bestPoints[j];
bestPoints[j] _ bestPoints[j-1];
bestPoints[j-1] _ temp;
};
ENDLOOP;
ENDLOOP;
};

SortCurves: PROC [bestCurves: BestPoints, curveCount: NAT] = {
temp: GoodPoint;
FOR i: INTEGER IN [0..curveCount-2] DO
FOR j: INTEGER IN [1..curveCount-i) DO
IF bestCurves[j-1].dist > bestCurves[j].dist THEN {
temp _ bestCurves[j];
bestCurves[j] _ bestCurves[j-1];
bestCurves[j-1] _ temp;
};
ENDLOOP;
ENDLOOP;
};

SortFaces: PROC [bestFaces: BestFaces, faceCount: NAT] = {
temp: GoodPoint;
FOR i: INTEGER IN [0..faceCount-2] DO
FOR j: INTEGER IN [1..faceCount-i) DO
IF bestFaces[j-1].priority < bestFaces[j].priority THEN {
temp _ bestFaces[j];
bestFaces[j] _ bestFaces[j-1];
bestFaces[j-1] _ temp;
};
ENDLOOP;
ENDLOOP;
};

SortByOverlap: PROC [faces: BestFaces, count: NAT] = {
temp: GoodPoint;
FOR i: INTEGER IN [0..count-2] DO
FOR j: INTEGER IN [1..count-i) DO
IF faces[j-1].priority < faces[j].priority THEN {
temp _ faces[j];
faces[j] _ faces[j-1];
faces[j-1] _ temp;
};
ENDLOOP;
ENDLOOP;
};
ComputeMidpoint: PROC [curve: GoodPoint] RETURNS [midpoint: Point, success: BOOL _ TRUE] = {
class: NAT;
simpleCurve: REF ANY;
[class, simpleCurve] _ ClassifyCurve[curve];
SELECT class FROM
3 => { -- edge
edge: Edge _ NARROW[simpleCurve];
midpoint _ Vectors2d.Scale[Vectors2d.Add[edge.start, edge.end], 0.5];
success _ TRUE;
};
4 => { -- arc
arc: Arc _ NARROW[simpleCurve];
midpoint _ Vectors2d.Scale[Vectors2d.Add[arc.p0, arc.p2], 0.5];
success _ TRUE;
};
ENDCASE => RETURN[[0,0], FALSE];
};

ClassifyCurve: PROC [curve: GoodPoint] RETURNS [class: NAT, simpleCurve: REF ANY] = {
feature: FeatureData _ curve.featureData;
SELECT feature.type FROM
slice => {
sliceD: SliceDescriptor _ NARROW[feature.shape];
hitData: REF ANY _ curve.hitData;
simpleCurve _ GGSliceOps.HitDataAsSimpleCurve[sliceD.slice, hitData];
IF simpleCurve = NIL THEN {
simpleCurve _ sliceD;
class _ 6;
RETURN;
};
};
radiiCircle => {
class _ 2;
simpleCurve _ NARROW[feature.shape, AlignmentCircle].circle;
RETURN;
};
slopeLine, angleLine => {
class _ 1;
simpleCurve _ NARROW[feature.shape, AlignmentLine].line;
RETURN;
};
distanceLine => {
class _ 1;
simpleCurve _ NARROW[feature.shape, Line];
RETURN;
};
ENDCASE => {class _ 0;  simpleCurve _ NIL; RETURN};
WITH simpleCurve SELECT FROM
circle: Circle => class _ 2;
edge: Edge => class _ 3;
arc: Arc => class _ 4;
cubic: BezierRef => class _ 5;
ENDCASE => ERROR;
};

CurveMeetsCurve: PROC [c1, c2: GoodPoint] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL] = {
typeOfCurve1, typeOfCurve2: NAT;
simpleCurve1, simpleCurve2: REF ANY;
[typeOfCurve1, simpleCurve1] _ ClassifyCurve[c1];
[typeOfCurve2, simpleCurve2] _ ClassifyCurve[c2];
IF typeOfCurve1 >= typeOfCurve2 THEN
[iPoints, tangency] _ ComputeIntersection[typeOfCurve1][typeOfCurve2][simpleCurve1, simpleCurve2]
ELSE
[iPoints, tangency] _ ComputeIntersection[typeOfCurve2][typeOfCurve1][simpleCurve2, simpleCurve1]
};

IntersectionProc: TYPE = PROC [c1, c2: REF ANY] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL];
ComputeIntersection: ARRAY [0..6] OF ARRAY [0..6] OF IntersectionProc = [
[NoOpI,	NIL, 	NIL, 	NIL,	NIL,	NIL,	NIL], -- 0) NoOp
[NoOpI,	LinLinI, 	NIL,	NIL,	NIL,	NIL,	NIL], -- 1) Line
[NoOpI,	CirLinI,	CirCirI,	NIL,	NIL,	NIL,	NIL], -- 2) Circle
[NoOpI, 	EdgLinI, 	EdgCirI,	EdgEdgI,	NIL,	NIL,	NIL], -- 3) Edge
[NoOpI,	ArcLinI,	ArcCirI,	ArcEdgI,	ArcArcI,	NIL,	NIL], -- 4) Arc
[NoOpI,	CubLinI,	NoOpI,	CubEdgI,	NoOpI,	NoOpI,	NIL], -- 5) Cubic
[NoOpI,	SlcLinI,	SlcCirI,	NoOpI,	NoOpI,	NoOpI,	NoOpI] -- 6) Slice
];	

NoOpI: IntersectionProc = {
iPoints _ NIL;
tangency _ NIL;
};

LinLinI: IntersectionProc = {
l1: Line _ NARROW[c1];
l2: Line _ NARROW[c2];
point: Point;
parallel: BOOL _ FALSE;
[point, parallel] _ Lines2d.LineMeetsLine[l1, l2];
IF NOT parallel THEN {iPoints _ LIST[point]; tangency _ LIST[FALSE]}
ELSE {iPoints _ NIL; tangency _ NIL};
};

CirLinI: IntersectionProc = {
circle: Circle _ NARROW[c1];
line: Line _ NARROW[c2];
points: ARRAY [1..2] OF Point;
hitCount: [0..2];
tangent: BOOL _ FALSE;
[points, hitCount, tangent] _ GGCircles.CircleMeetsLine[circle, line];
FOR i: NAT IN [1..hitCount] DO
iPoints _ CONS[points[i], iPoints];
tangency _ CONS[tangent, tangency];
ENDLOOP;
};

CirCirI: IntersectionProc = {
circle1: Circle _ NARROW[c1];
circle2: Circle _ NARROW[c2];
points: ARRAY [1..2] OF Point;
hitCount: [0..2];
tangent: BOOL _ FALSE;
[points, hitCount, tangent] _ GGCircles.CircleMeetsCircle[circle1, circle2];
FOR i: NAT IN [1..hitCount] DO
iPoints _ CONS[points[i], iPoints];
tangency _ CONS[tangent, tangency];
ENDLOOP;
};

EdgLinI: IntersectionProc = {
edge: Edge _ NARROW[c1];
line: Line _ NARROW[c2];
point: Point;
noHit: BOOL _ FALSE;
[point, noHit] _ Lines2d.LineMeetsEdge[line, edge];
IF NOT noHit THEN {iPoints _ LIST[point]; tangency _ LIST[FALSE]}
ELSE {iPoints _ NIL; tangency _ NIL};
};

EdgCirI: IntersectionProc = {
edge: Edge _ NARROW[c1];
circle: Circle _ NARROW[c2];
points: ARRAY [1..2] OF Point;
hitCount: [0..2];
tangent: BOOL _ FALSE;
[points, hitCount, tangent] _ GGCircles.CircleMeetsEdge[circle, edge];
FOR i: NAT IN [1..hitCount] DO
iPoints _ CONS[points[i], iPoints];
tangency _ CONS[tangent, tangency];
ENDLOOP;
};

EdgEdgI: IntersectionProc = {
e1: Edge _ NARROW[c1];
e2: Edge _ NARROW[c2];
point: Point;
noHit: BOOL _ FALSE;
[point, noHit] _ Lines2d.EdgeMeetsEdge[e1, e2];
IF NOT noHit THEN {iPoints _ LIST[point]; tangency _ LIST[FALSE]}
ELSE {iPoints _ NIL; tangency _ NIL};
};

ArcLinI: IntersectionProc = {
arc: Arc _ NARROW[c1];
line: Line _ NARROW[c2];
points: ARRAY [1..2] OF Point;
hitCount: [0..2];
tangent: BOOL _ FALSE;
[points, hitCount, tangent] _ GGCircles.ArcMeetsLine[arc, line];
FOR i: NAT IN [1..hitCount] DO
iPoints _ CONS[points[i], iPoints];
tangency _ CONS[tangent, tangency];
ENDLOOP;
};

ArcCirI: IntersectionProc = {
arc: Arc _ NARROW[c1];
circle: Circle _ NARROW[c2];
points: ARRAY [1..2] OF Point;
hitCount: [0..2];
tangent: BOOL _ FALSE;
[points, hitCount, tangent] _ GGCircles.CircleMeetsArc[circle, arc];
FOR i: NAT IN [1..hitCount] DO
iPoints _ CONS[points[i], iPoints];
tangency _ CONS[tangent, tangency];
ENDLOOP;
};

ArcEdgI: IntersectionProc = {
arc: Arc _ NARROW[c1];
edge: Edge _ NARROW[c2];
points: ARRAY [1..2] OF Point;
hitCount: [0..2];
tangent: BOOL _ FALSE;
[points, hitCount, tangent] _ GGCircles.ArcMeetsEdge[arc, edge];
FOR i: NAT IN [1..hitCount] DO
iPoints _ CONS[points[i], iPoints];
tangency _ CONS[tangent, tangency];
ENDLOOP;
};

ArcArcI: IntersectionProc = {
arc1: Arc _ NARROW[c1];
arc2: Arc _ NARROW[c2];
points: ARRAY [1..2] OF Point;
hitCount: [0..2];
tangent: BOOL _ FALSE;
[points, hitCount, tangent] _ GGCircles.ArcMeetsArc[arc1, arc2];
FOR i: NAT IN [1..hitCount] DO
iPoints _ CONS[points[i], iPoints];
tangency _ CONS[tangent, tangency];
ENDLOOP;
};

CubLinI: IntersectionProc = {
bezier: BezierRef _ NARROW[c1];
line: Line _ NARROW[c2];
points: ARRAY [0..2] OF Point;
hitCount: [0..3];
tangent: ARRAY [0..2] OF BOOL _ ALL[FALSE];
[points, hitCount, tangent] _ CubicPathsExtras.CubicMeetsLine[bezier^, -line.s, line.c, -line.d];
FOR i: NAT IN [0..hitCount) DO
iPoints _ CONS[points[i], iPoints];
tangency _ CONS[tangent[i], tangency];
ENDLOOP;
};

CubicMeetsEdge: PROC [bezier: BezierRef, edge: Edge] RETURNS [points: ARRAY [0..2] OF Point, hitCount: [0..3] _ 0, tangent: ARRAY [0..2] OF BOOL _ ALL[FALSE]] = {
linePoints: ARRAY [0..2] OF Point;
lineHitCount: [0..3];
lineTangents: ARRAY [0..2] OF BOOL _ ALL[FALSE];
[linePoints, lineHitCount, lineTangents] _ CubicPathsExtras.CubicMeetsLine[bezier^, -edge.line.s, edge.line.c, -edge.line.d];
FOR i: NAT IN [0..lineHitCount) DO
IF Lines2d.OnEdge[linePoints[i], edge] THEN {
points[hitCount] _ linePoints[i];
tangent[hitCount] _ lineTangents[i];
hitCount _ hitCount + 1;
};
ENDLOOP;
};

CubEdgI: IntersectionProc = {
IntersectionProc: TYPE = PROC [c1, c2: REF ANY] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL];
bezier: BezierRef _ NARROW[c1];
edge: Edge _ NARROW[c2];
points: ARRAY [0..2] OF Point;
hitCount: [0..3];
tangent: ARRAY [0..2] OF BOOL _ ALL[FALSE];
[points, hitCount, tangent] _ CubicMeetsEdge[bezier, edge];
FOR i: NAT IN [0..hitCount) DO
iPoints _ CONS[points[i], iPoints];
tangency _ CONS[tangent[i], tangency];
ENDLOOP;
};

SlcLinI: IntersectionProc = {
sliceD: SliceDescriptor _ NARROW[c1];
line: Line _ NARROW[c2];
[iPoints, ----] _ GGSliceOps.LineIntersection[sliceD, line];
FOR list: LIST OF Point _ iPoints, list.rest UNTIL list = NIL DO
tangency _ CONS[FALSE, tangency];
ENDLOOP;
};

SlcCirI: IntersectionProc = {
sliceD: SliceDescriptor _ NARROW[c1];
circle: Circle _ NARROW[c2];
[iPoints, ----] _ GGSliceOps.CircleIntersection[sliceD, circle];
FOR list: LIST OF Point _ iPoints, list.rest UNTIL list = NIL DO
tangency _ CONS[FALSE, tangency];
ENDLOOP;
};

NewMultiGravityPool: PUBLIC PROC [] RETURNS [REF]= { -- reuseable storage for BestPointAndCurve proc to avoid NEWs
pool: MultiGravityPool _ NEW[MultiGravityPoolObj];
pool.bestpoints _ NEW[BestPointsObj[MaxFeatures]];
pool.bestcurves _ NEW[BestPointsObj[MaxFeatures]];
pool.bestfaces _ NEW[BestFacesObj[MaxFeatures]];
FOR i: NAT IN [0..MaxFeatures) DO
pool.bestpoints[i] _ NEW[GoodPointObj];
pool.bestcurves[i] _ NEW[GoodPointObj];
pool.bestfaces[i] _ NEW[GoodPointObj];
ENDLOOP;
RETURN[pool];
};

END.

%DGGMultiGravityImpl.mesa
Copyright Σ 1986, 1987, 1989 by Xerox Corporation.  All rights reserved.
Contents:  Performs hit testing similar to uniGravity.  Instead of returning a single nearest feature, we return the N (or fewer) nearest features which are within a given tolerance distance from the test point.  The algorithm used is described in [Cyan]<Gargoyle>Documentation>MultiGravity.tioga.
Pier, February 18, 1992 5:16 pm PST
Bier, April 11, 1990 2:39:57 pm PDT
Eisenman, August 11, 1987 6:14:13 pm PDT
Doug Wyatt, December 18, 1989 2:38:04 pm PST

Arbitration
 [Artwork node; type 'ArtworkInterpress on' to command tool] 
We arbitrate between those points which are within an epsilon-width ring of the nearest point.
Dispatches to StrictDistance, PointsPreferred, or does nothing depending on the currently selected gravity type.  If intersections is TRUE, compute the intersections of the objects that are in the bags.
In case an ABORT happened while pool was in use

Calls MultiPointsPreferred and picks a single "best" feature.  If there are no good features within radius t of testPoint, then resultPoint = testPoint and feature = hitData = NIL.  If intersections is TRUE then compute all pair-wise intersections of gravity-active curves and count them as distinguished points.
Otherwise, let's do arbitration.
Prefer scene objects to alignment lines.
Later, we will prefer objects that say the testpoint is "inside" them.
Calls MultiLinesPreferred and picks a single "best" feature.  If there are no good features within radius t of testPoint, then resultPoint = testPoint and feature = hitData = NIL.
This code will be used when we wish to do more sophisticated arbitration:
We have more than one "equally close" features.  Now we choose on the following basis:
1) Prefer scene objects to alignment lines.
2) Prefer points to lines.
Later, we will prefer objects that say the testpoint is "inside" them to those that don't.
Calls MultiFacesPreferred and picks a single "best" feature.  If there is a filled region that contains the cursor point, it choose the nearest such filled region.  Otherwise, it behaves just like LinesPreferred gravity.

Cycling Gravity
In case an ABORT happened while pool was in use
Otherwise, let's do arbitration.  Find the nearest slice if one is close enough.  Otherwise, start with the nearest alignment object.
Start cycling at the first slice.
Find the nearest line and any that are almost as near, if any lines exist with radius t.  Choose one of these lines.  If the winner is an edge, use its curve normal.
If no object is found, use the cursor position.
Find how many nearest neighbors there are.
This may come in handy some day for extra arbitration
Find how many nearest neighbors there are.


Multi-Gravity Routines

facesPreferred =>
[nearVEF, count] _ MultiFacesPreferred[testPoint, t, alignBag, sceneBag, ggData];
Returns up to MaxFeatures closest features, their closest points, and their distances from the testpoint.  Features outside of criticalR, will not be included.  The results will be located in nearVEF[0] .. nearVEF[count-1].
Returns up to MaxFeatures closest features, their closest points, and their distances from the testpoint.  Features outside of criticalR, will not be included.  The results will be located in nearVEF[0] .. nearVEF[count-1].
Caution: bestCurves and bestPoints are allocated from a pool.  Copy them before returning them to the user (e.g. in a cycler).
Returns up to MaxFeatures closest features, their closest points, and their distances from the testpoint.  Features outside of criticalR, will not be included.  The results will be located in nearVEF[0] .. nearVEF[count-1].  If any points are within the inner radius innerR, then only points (e.g. vertices, control points, and intersection points) will be mentioned.  Otherwise, nearVEF may consist of a mixture of points and curves.
Caution: bestCurves and bestPoints are allocated from a pool.  Copy them before returning them to the user (e.g. in a cycler)
For each gravity active point, find its distance from the testpoint.  Package this information up into the thisPoint record.  Then call AddNeighbor, which will add this point to the list of best points, if appropriate.
When VertsInNeighborhoodPlus returns, h will contain a set of up to MaxFeatures points all of which are within a distance t of q.
If h.overflow is FALSE, h contains the nearest point in the scene (distance h.min from q) and all other points o such that dist(o, q) <= h.min + h.s, and dist(o, q) <= t.
If h.overflow is TRUE, there were more than MaxFeatures such points.  In this case, h includes the nearest n such points n = MaxFeatures.
thisPoint.normal _ [0,-1]; -- eventually this should just agree with the anchor orientation
FeatureWalkProc: TYPE = PROC [feature: FeatureData] RETURNS [done: BOOL _ FALSE];

largeTolerance: REAL = 9999.00;
largeTolerance: REAL = 9999.00;
thisPoint.normal _ [0, -1];     -- Should figure out midpoint's normal for slice.		-- Only edge and arc work now anyway.
Returns the curves in the near band in order of increasing distance from q.
For each gravity active object, find the distance of the gravity active object from the testpoint.  Package this information up into the thisCurve record.  Then call AddNeighbor, which will add this curve to the list of best curves, if appropriate.
When CurvesInNeighborhood returns, h should contain some number of curves such that they are all within t of q.
If h.overflow is FALSE, then h contains the closest curve (at distance h.min) and all other curves o such that dist(o, q) < MAX[h.min + h.s, innerR] and dist(o, q) < t.
If h.overflow is TRUE then it wasn't possible to include all such curves.  h contains the closest n such curves (where n = MaxFeatures).
FeatureWalkProc: TYPE = PROC [feature: FeatureData] RETURNS [done: BOOL _ FALSE];
FeatureWalkProc: TYPE = PROC [feature: FeatureData] RETURNS [done: BOOL _ FALSE];
Align Bag
Scene Bag.
FeatureWalkProc: TYPE = PROC [feature: FeatureData] RETURNS [done: BOOL _ FALSE];
Scene Bag.
Maintaining the Nearest-Neighbor Structure
AddNeighbor maintains these invariants:  There is valid data in h[0] up to h[size-1].  Call these the Elements of h.  All other components of h have dist = infinity.  h.min is the minimum value of dist(q, x) for x element of h.
If overflow is FALSE, then h contains all objects o, seen so far, such that
h.min <= dist(o, q) <= MAX[h.min+h.s, innerR], if curve is TRUE,
h.min <= dist(o, q) <= h.min+h.s, if curve is FALSE
h may contain other objects as well.
If overflow is TRUE, all objects in h satisfy
h.min <= dist(o, q) <= MAX[h.min+h.s, innerR], if curve is TRUE,
h.min <= dist(o, q) <= h.min+h.s, if curve is FALSE
but there are one or more objects that satisfy this property that are not in h.  Those objects that are not included are at least as far from q as the farthest object in h.
dTol is a hint to the caller that the caller need not pass in objects that are more than dTol units away from q, since AddNeighbor is just going to throw them away.
When AddNeighbor returns, h.dTol = t if h.size = 0,
h.dTol = MAX[h.min+h.s, innerR], if h.size > 0 and curve is TRUE,
h.dTol = h.min + h.s, if h.size > 0 and curve is FALSE.

Replace the worst element with the new one if the new is better.
Now, update h.max and h.maxIndex the hard way.
Replace the worst element with the new one if the new is better.
Now, update h.minPriority and h.minIndex the hard way.
Merge the bestPoints and the bestCurves.  There will be count elements in the result.
Merge the two sorted lists together classifying the segments by the AND of the Classifs for each segment
We have different paths within the same trajectory or cluster.  Choose whichever is closer in the overlap order of the cluster
Sort the points in order of increasing distance.  Since n is likely to be small, bubble sort is sensible.
Sort the curves in order of increasing distance.  Since n is likely to be small, bubble sort is sensible.
Sort the curves in order of descreasing priority.  Since n is likely to be small, bubble sort is sensible.
Sort the vertices, edges, and faces in order of decreasing priority.  Since n is likely to be small, bubble sort is sensible.

Computing Intersections

0) NoOp	1) Line	2) Circle	3) Edge	4) Arc	5) Cubic	6) Slice
IntersectionProc: TYPE = PROC [c1, c2: REF ANY] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL];
IntersectionProc: TYPE = PROC [c1, c2: REF ANY] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL];
IntersectionProc: TYPE = PROC [c1, c2: REF ANY] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL];
IntersectionProc: TYPE = PROC [c1, c2: REF ANY] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL];
IntersectionProc: TYPE = PROC [c1, c2: REF ANY] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL];
IntersectionProc: TYPE = PROC [c1, c2: REF ANY] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL];
IntersectionProc: TYPE = PROC [c1, c2: REF ANY] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL];
IntersectionProc: TYPE = PROC [c1, c2: REF ANY] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL];
IntersectionProc: TYPE = PROC [c1, c2: REF ANY] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL];
IntersectionProc: TYPE = PROC [c1, c2: REF ANY] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL];
[points, hitCount] _ GGCircles.ArcMeetsArc[arc1, arc2];
IntersectionProc: TYPE = PROC [c1, c2: REF ANY] RETURNS [iPoints: LIST OF Point, tangency: LIST OF BOOL];
Utilities
Κ>“–

"cedar" style•NewlineDelimiter

˜
codeš
œ™Kš
œH™HKšΟnœ‘™©Kš
œ#™#Kš
œ#™#Kš
œ(™(K™,—K™š
Οk	˜	Jš
œψ
˜ψ
—K˜Kšœžœ
ž˜!Kšžœ~˜…
Kšžœž˜˜Kšœ
žœžœ
˜!Kšœ
žœ ˜1Kšœžœ$˜9Kšœžœ"˜5Kšœžœžœ˜-Kšœžœ&˜=Kšœžœ˜Kšœžœ˜Kšœžœžœ˜Kšœžœ˜%Kšœžœ˜#Kšœžœ˜Kšœžœžœ˜+Kšœžœ%˜;Kšœ
žœžœ˜'Kšœžœ˜3Kšœžœ˜'Kšœžœžœ˜#Kšœžœ!˜3Kšœ
žœ ˜1Kšœžœ˜3Kšœžœ˜Kšœžœžœ˜=Kšœžœ.˜MKšœžœ˜!Kšœžœ!˜7Kšœžœ#˜;Kšœžœ˜!Kšœ	žœ˜'Kšœžœ!˜7Kšœ
žœ˜'Kšœžœ˜!Kšœžœ ˜5Kšœžœ#˜;Kšœžœžœ˜%Kšœžœ"˜5Kšœžœ˜#K˜Kšœžœžœ˜%šœžœžœ˜Kšœžœ
˜
Kšœ
žœ
˜Kšœ
žœ
˜KšœžœΟc?˜QKšœžœŸ
˜KšœžœŸS˜aKšœžœŸ›
˜€
Kšœ
žœ
˜Kšœžœžœ
žœ˜(K˜—Kšœžœžœ˜#šœžœžœ˜Kšœžœ
˜
Kšœžœ
˜Kšœ
žœ
˜Kšœžœ
˜Kšœ
žœŸ7˜IKšœ
žœ
˜Kšœžœžœ
žœ˜'—K˜Kšœžœžœ˜1šœžœžœ˜$Kš
œ˜Kš
œ˜K˜Kš
œ˜—K˜—Kš
œžœ
žœžœžœ
˜/K˜™I
artworkFigure–G91.72222 mm topLeading 91.72222 mm topIndent 1.411111 mm bottomLeading •Bounds60.0 mm xmin 0.0 mm ymin 93.83888 mm xmax 88.9 mm ymax •Artwork
Interpress•
Interpressš
Interpress/Xerox/3.0  f j k j‘₯“Δ
WB € ¨  ͺœ‘£Ι ’ ¨ r j 
Ί ’ ¨‘‘¨Δ
WB € ¨ r j‘₯“Δ
WB € ¨‘‘¨ r jΔWΑΑ €ΔDBCΔŒ5r ’ ₯ ¨‘‘¨Δ
ŒZ―“Ÿ ™‘ Ÿ ‘“‘Έ k ι r jΔ	Ω€ €Δ˜jeΔ[‹B ’ ₯ ¨ r j‘‘¨Ÿ ™‘ Ÿ ‘“‘‘ ‘™ k ι‘‘¨ΔI\―“Ÿ ™‘ Ÿ ‘“‘Έ k ι r jΔ	Ω€ €Δ.΅0ΔYΥ? ’ ₯ ¨ r j‘‘¨Ÿ ™‘ Ÿ ‘“‘‘ ‘™ k ι‘‘¨ΔI\―“Ÿ ™‘ Ÿ ‘“‘Έ k ι r jΔ	Ω€ €ΔΕ
Δ1 ’ ₯ ¨ r j‘‘¨Ÿ ™‘ Ÿ ‘“‘‘ ‘™ k ι‘‘¨ΔI\―“Ÿ ™‘ Ÿ ‘“‘Έ k ι r jΔ	Ω€ €ΔΗaSΔAh/ ’ ₯ ¨ r j‘‘¨Ÿ ™‘ Ÿ ‘“‘‘ ‘™ k ι‘‘¨ΔI\―“Ÿ ™‘ Ÿ ‘“‘Έ k ι r jΔ› €ΔDBCΔŒ5r ’ ₯ ¨‘‘¨Δ›Ž―“Ÿ ™‘ Ÿ ‘“‘Έ k ι r jΔ@Όρ €ΔDBCΔŒ5r ’ ₯ ¨‘‘¨Δρ ^―“Ÿ ™‘ Ÿ ‘“‘Έ k ι£―“   £‘ˆ‘‘ΕXeroxΕResearchΕ	RGBLinear£‘‘¦ η • ” η­“’·“’°“ΔUήUΥ™ΔDBCΔŒ5r—§Υ—˜ r jΔ
Δ
'εΉ ’ ¨ΕXeroxΕ
TiogaFontsΕHelvetica10£‘ “‘•‘ —‘‘¨  ŠΑTolerance Radius– k ι r j‘‘¨’·“‘―“‘‘¨ k ι r jΔV9^Δϊ^Ή ’ ¨ΕXeroxΕ
TiogaFontsΕHelvetica10£‘ “‘•‘ —‘‘¨  ŠΑNearest– k ι r j‘‘¨’·“‘―“‘‘¨ k ι r jΔ_?cΔ
μ ’ ¨ΕXeroxΕ
TiogaFontsΕHelvetica10£‘ “‘•‘ —‘‘¨  ŠΑCaret– k ι r j‘‘¨’·“‘―“‘‘¨ k ι r jΔ€Δm ’ ¨ΕXeroxΕ
TiogaFontsΕHelvetica10£‘ “‘•‘ —‘‘¨  ŠΑNearest + Epsilon– k ι r j‘‘¨’·“‘―“‘‘¨ k ι k ι k ι k gš
œ=™=IartworkCaption™^K˜—šœžœ
žœžœKžœžœžœEžœ
žœ˜ά
Kšœ†
žœ@™Κ
šžœ
žœ˜Kš
œ0˜0Kš
Ÿ/™/K˜—Kš
œ:˜:Kš
œ)˜)šžœžœ˜$šžœ
ž˜š
œ˜Kš
œs˜s—š
œ!˜!Kš
œc˜c—Kšžœžœ
˜—K˜
—šžœ˜Kš
œ˜Kšœ
žœ
˜Kš
œ˜K˜—Kš
œ(˜(K˜K™—šœžœ
žœžœKžœžœžœEžœ
žœ˜θ
Kšœ°
žœ…
™ΈKšœžœ
˜Kš
œ ˜ Kš
œa˜aKš
žœžœ
žœžœžœ˜7Kšžœžœ
žœ˜2šžœ˜Kš
Οb ™ Kšœžœ˜Kšœžœ
Ÿ˜!Kšœ
žœ˜Kš
œ˜šžœžœ
žœž˜Kšžœ#žœ#˜LKšžœ
˜—Kšžœžœ
žœ˜;Kš
 (™(Kš
 F™Fšžœžœ
žœž˜#šžœ%žœ˜-Kšžœ˜!K˜—š
ž˜Kšžœžœ˜-—Kšžœ
˜—K˜—K˜—šœžœ
žœžœ<žœEžœ
žœ˜Κ
Kš
œ³
™³
Kš
œ ˜ Kšœžœ
˜Kšœ œ+˜QKš
žœžœ
žœžœžœ˜7Kšžœžœ
žœ˜2šžœ˜Kš
 I™IKšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ
Ÿ˜!Kš
œ˜šžœžœ
žœž˜Kšžœ#žœ#˜LKšžœ
˜—šžœžœ
žœ˜;Kš
 V™VKš
 +™+Kš
 ™Kš
 Z™Z—K˜Kšžœ˜!K˜—K˜K˜—šœžœ
žœžœ<žœEžœ
žœ˜Κ
Kš
œά
™ά
Kš
œ ˜ Kšœžœ
˜K˜Kšœ œ+˜QKš
žœžœ
žœžœžœ˜7Kšžœ˜ K˜—K˜š
œžœ*žœžœEžœ
žœ˜š
Kš
œ&˜&Kš
œ˜Kš
œ˜Kš
œ ˜ Kš
œ˜K˜K˜—K™K™šœžœžœ#˜Všœžœ˜(Kšœ	žœ
˜
Kš
œ	˜	Kš
œ
˜
Kš
œ˜K˜—K˜K˜—š	œžœ
žœžœKžœžœ#˜΄
šžœ
žœ˜Kš
œ0˜0Kš
Ÿ/™/K˜—Kš
œ:˜:šžœžœ˜$šžœ
ž˜š
œ˜Kš
œ_˜_—š
œ!˜!Kš
œO˜O—Kšžœžœ
˜—K˜
—šžœ˜Kš
œ'˜'K˜—K˜K˜—šœžœ&žœžœ#˜bKš
œ&˜&Kšœžœ#˜-šžœžœ
žœž˜Jš
œ˜šœžœ˜#Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ&˜&Jš
œ˜Jš
œ$˜$Jš
œ˜—Jšžœ
˜—K˜K˜—šœžœ
žœžœKžœžœ#˜Ϊ
Kšœžœ
˜Kš
œ ˜ š
ž˜Kš
œa˜aKšžœžœ
žœ˜1Kšžœžœ
žœ˜'šžœ˜Kš  œe™…
Kšœžœ˜Kšœžœ
Ÿ˜!Kšœ
žœ˜K˜šœžœ˜(Kšœ	žœŸ˜(Kš
œ
˜
KšœŸ˜%K˜K˜—Kš
œ˜šžœžœ
žœž˜Kšžœ#žœ#˜LKšžœ
˜—Kšžœžœ
žœ˜0Kš
œ0˜0Kš
 !™!šžœžœ
žœž˜#šžœ%žœ˜-Kš
œ˜Kšžœ
˜K˜—š
ž˜Kšžœ˜$—Kšžœ
˜—K˜—š
ž˜˜šœžœ˜(Kš
œ!˜!Kš
œ
˜
Kš
œ	˜	K˜K˜—K˜——Kšžœ
˜—K˜K˜K˜—š
œžœ
žœžœ<žœ#˜’
K™₯
K™/Kš
œ ˜ Kšœžœ
˜š
ž˜Kšœ œ+˜QKšžœžœ
žœ˜1Kšžœžœ
žœ˜'šžœ˜Kšœ
žœ˜Kšœžœ˜Kšœžœ˜Kšœžœ
Ÿ˜!Kš
œ˜Kš
 *™*šžœžœ
žœž˜Kšžœ#žœ#˜LKšžœ
˜—Kšžœžœ
žœ˜0K˜šœžœ˜(Kš
œ!˜!Kš
œ
˜
Kš
œ	˜	Kš
œ˜K˜—K˜—š
ž˜š
œ˜šœžœ˜(Kš
œ!˜!Kš
œ
˜
Kš
œ	˜	Kš
œ˜K˜—K˜——Kšžœ
˜—K˜K˜—š
œžœ
žœžœ<žœ#˜’
Kš
œ ˜ Kšœžœ
˜š
ž˜Kšœ œ+˜QKšžœžœ
žœ˜1Kšžœžœ
žœ˜'šžœ˜Kšžœ˜Kš
 5™5Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ
Ÿ˜!Kš
œ˜Kš
 *™*šžœžœ
žœž˜Kšžœ#žœ#˜LKšžœ
˜—Kšžœžœ
žœ˜0K˜šœžœ˜(Kš
œ!˜!Kš
œ
˜
Kš
œ	˜	Kš
œ˜K˜—K˜—š
ž˜š
œ˜šœžœ˜(Kš
œ!˜!Kš
œ
˜
Kš
œ	˜	Kš
œ˜K˜—K˜——Kšžœ
˜—K˜K™—šœžœ
žœ žœEžœ
žœ˜‘
Kšžœ˜$K˜K˜—šœžœ
žœ žœEžœ
žœ˜
Kšžœ˜$K˜K˜—šœžœ
žœ žœEžœ
žœ˜”
Kšžœ˜%K˜K˜—š
œžœ
žœ/žœEžœ
žœ˜ž
šžœžœ
žœŸ˜;KšœŸ˜"Kš
œ˜Kšœ
žœ
˜Kšœ
žœ
˜K˜
—šžœžœŸ˜DKš
œ&˜&Kš
œ˜Kšœ
žœ
˜Kšœ
žœ
˜K˜
—šžœ˜KšœIžœ˜aKš
œd˜dK˜—K˜K˜—K™š
œ™K™—šœžœ
žœžœKžœžœ*žœ˜Β
Kšžœ
žœ6Ÿ2˜uKš
œ)˜)šžœž˜$šžœ ž˜*™Kš
œQ™Q—š
œ˜Kš
œQ˜Q—š
œ˜Kš
œa˜a—Kšžœžœ
˜K˜
——šžœ˜Kšœ
žœ
˜Kš
œ
˜
K˜—Kš
œ(˜(K˜K˜—šœžœ
žœžœ<žœ*žœ˜°
Kš
œί
™ί
Kš
œ#˜#Kš
œ˜Kšœ#žœ
˜'K˜šžœ!žœ#žœ
žœ˜]K˜—Kšœ œ+˜[Kš
œ$˜$K˜Kšœ œ.˜aK˜Kšœ œCžœ˜|Kš
œ#˜#K˜Kšœžœ'˜2Kšœ
žœ#˜0Kš œA˜UKšœ œ'˜SK˜K˜—šœžœ
žœžœ<žœ*žœ˜°
Kš
œί
™ί
Kš
œ˜Kš
œ˜Kšœžœ
˜K˜šžœ!žœ#žœ
žœ˜]K˜—Kš
 ~™~Kšœ œ.˜aK˜Kšœ œCžœ˜|Kš
œ#˜#K˜Kšœžœ'˜2Kšœ
žœ#˜0Kš œA˜UK˜K˜—šΠbn žœ
žœžœKžœžœ*žœ˜Ξ
Kš
œ²™²Kš
œ˜Kš
œ˜Kšœžœ
˜Kš Πbk 	˜Kš
žœ!žœ#žœ
žœ
žœ˜]K˜Kš
 }™}Kšœ œ3˜fK˜Kšœ œR˜„
Kš
œ#˜#K˜šžœžœžœ˜8Kš
œ˜Kšœ
žœ#˜0Kš
œ6˜6K˜
—šžœ˜Kšœžœ'˜2Kšœ
žœ#˜0Kš
œU˜UK˜—K˜K˜—šœžœ&žœ, 
œ	Οi
œžœ!žœžœžœ˜ή
Kš
œ˜Kš
œΪ
™Ϊ
Kš
œ
™
Kšœžœ”
™ͺ
Kšœžœt™‰
šœžœ6Ÿ˜^Kšœ
žœ
˜Kšœ
žœ
˜Kš
œ9˜9Kšœžœ
˜šžœžœ˜ Kš
œ(˜(KšœŸ@™[Kšœ%žœŸ
˜NKšžœ2žœ˜TKš
œ$˜$Kš
œ˜Kšœ!žœ˜(K˜—K˜—šœžœN˜`Kšœ œc˜ƒ
šžœ	žœ˜šžœžœ˜Kš
œ$˜$šžœ2žœ˜;Kš
œ˜Kš
œ˜—Kš
œE˜EKšœ!žœ˜(K˜—Kš
œ˜—K˜—šœ˜.Kšœžœžœžœžœžœ™QKšœ	žœ!˜0Kš
œ)˜)K˜K˜—K˜Kš
œ˜Kšœ	žœžœ
˜Kšœžœ˜Kšœžœ ˜/K˜Kšœžœ˜Kš
œ"˜"K˜šžœžœ˜Kšœ œ>˜VKšžœžœ 
œ>˜dK˜—K˜Kšœ$ œ˜7Kš
œ˜šžœžœ
žœ˜Kš œ
žœ˜*Kšžœ
žœžœ
žœ
˜)Kš
œ+˜+Kš
œ%˜%K˜—Kš
œ˜šžœžœ˜Kš
œ.˜.Kš
œ.˜.K˜—KšœŸ!˜$K™—šœžœ&žœ-žœžœžœ˜¨
Kšœžœ™Kš
œ˜Kšœžœ
žœ˜Kšœžœ
žœ
žœ
˜(Kšœ	žœžœ
˜Kš
œ˜šžœžœ
žœž˜ Kš
œ˜Kšžœžœ
žœŸœ˜Yšžœžœ
žœž˜Kš
œ˜Kšžœžœ
žœŸ5˜VKš
œ?˜?Kš
œ˜šžœžœ
žœ!žœžœ
ž˜EKš
œ˜Kš
œ8˜8Kš
œ!˜!šžœ	žœ˜Kšœžœ˜/šœ!žœ˜:Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ%˜%Kš
œ#˜#Kš
œ$˜$Kš
œ˜šžœ!žœ˜)Kšœžœ˜;Kš
œ˜Kš
œ7˜7Kš
œ#˜#KšœœŸ;˜…
K˜
—šžœ
žœ!žœ˜.Kšœžœ˜;Kš
œ˜Kšœžœ8˜PKš
œ#˜#KšœœŸ;˜…
K˜
—Kšžœžœ
˜Kšžœ2žœ˜TKšœ!žœ˜(K˜—Kš
œ˜Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—K˜K˜—š
œžœ&žœ-žœžœžœ˜€
Kšœžœ™Kš
œ˜Kš
œ˜Kšœ	žœžœ
˜Kš
œ˜šžœžœ
žœž˜ š
œ˜Kšžœžœ
žœ
˜*Kš
œ-˜-Kšžœ
žœ	žœ
žœ
˜Kš
œ˜Kš
œ8˜8Kš
œ!˜!šžœ	žœ˜Kšœžœ˜:Kš
œ˜Kšœžœ˜/šœ!žœ˜:Kš
œ˜Kšœ	žœ
˜Kš
œ˜Kšœžœ˜—Kš
œ˜Kš
œ#˜#Kš
œ$˜$Kš
œ"˜"Kš œŸ1œŸ%™xKšœœŸ2˜|Kšžœ2žœ˜TKš
œ7˜7Kšœ!žœ˜(K˜——Kšžœ
˜—K˜K˜—šœžœIžœ
žœžœžœ˜§
K™KKš
œψ
™ψ
Kš
œo™oKšœžœfžœ)™¨
Kšœžœs™ˆ
šœžœA˜RKš
œ/˜/šžœžœ˜Kš
œ$˜$Kš
œ5˜5Kš
œ5˜5šžœ1žœ˜;Kš
œ˜—Kšœžœ
˜Kš
œ˜Kšœ!žœ˜'K˜
—K˜—š
œžœE˜Xšœžœ
žœžœ˜FKšœ	žœ
˜KšžœžœA˜`Kšžœe˜iKš
œ˜—Kš
œ4˜4Kšœžœ"˜5Kšœžœ˜2šžœžœ˜Kš
œ$˜$Kš
œ)˜)Kšžœžœ˜9Kšžœ6˜:Kšœžœ
˜Kš
œ˜Kšœ!žœ˜'K˜—K˜—šœžœN˜`Kšœ	žœžœ
˜Kš
œ…
˜…
šžœ	žœ˜šžœžœ˜Kš
œ$˜$šžœ2žœ˜;Kš
œ˜Kš
œ˜—Kš
œE˜EKšœ!žœ˜'K˜—K˜—K˜—šœ˜-Kšœžœžœžœžœžœ™QKšœžœ$˜1Kš
œ&˜&K˜—šœ˜,Kšœžœžœžœžœžœ™QKšœ	žœ!˜0Kš
œ)˜)K˜—K˜K˜K˜Kš
œ˜Kšœžœžœ
˜Kšœžœ˜)Kšœžœ˜Kš
œ*˜*K˜Kš
 	™	Kš
œ3˜3š
žœ
 
œžœ
žœ4žœžœ
ž˜dKš
œ˜Kšœžœ(˜5Kš
œ*˜*Kšžœ
˜—š
žœ
 œžœ
žœ3žœ
žœ
ž˜[Kš
œ˜Kšœžœ˜!Kš
œ*˜*Kšžœ
˜—š
žœ
 œžœ
žœ3žœžœ
ž˜]Kš
œ˜Kšœ	žœ,˜;Kš
œ.˜.Kšžœ
˜—Kš
 
™
Kšœ$ œ˜5K˜šžœžœ˜Kš
œ.˜.Kš
œ-˜-K˜—Kš
œ˜KšœŸ˜"K˜—š
œžœIžœžœžœ˜–
K˜Kšœžœžœ
˜Kšœžœ˜(Kšœ
žœ˜K˜šœžœM˜_Kšœ	žœ
žœ
˜Kš	œžœ
žœ
žœ
žœ
˜Kšœ	žœžœ
˜šžœ@žœ˜HKš
œO˜Ošžœžœ
žœ˜Kš
œ˜K•StartOfExpansion:[scene: 
GGModelTypes.Scene, slice: 
GGModelTypes.Slice]š
œD˜DKš
œ˜Kš œ
˜Kš
œ#˜#Kšœ œ˜#K˜—šžœžœ
žœ
žœ
žœžœžœ
ž˜GKš
œ˜K–:[scene: 
GGModelTypes.Scene, slice: 
GGModelTypes.Slice]š
œD˜DKš
œ˜Kš œ
˜Kš
œ#˜#Kšœ œ˜#Jšžœ
˜—K˜—K˜—šœ˜,Kšœžœžœžœžœžœ™QKšœ	žœ!˜0Kš
œ(˜(K˜—K˜Kš
œ˜K˜Kš
 
™
Kšœ$ œ˜5K˜Kš
œ˜šžœžœ˜Kš
œ-˜-Kš
œ,˜,K˜—Kš
œ˜K˜—K˜K™*Kšœžœ˜K˜šœžœžœ˜CKšœžœ6˜@Kš
œ˜K˜K˜Kšœžœ
žœ˜Kš
œ˜Kšœ
žœ
˜šžœžœ
žœž˜!Jš
œ˜Jšœžœ
˜Jšžœ
˜—J˜J˜—š
œžœžœ
žœžœ˜\Kšœžœ7˜AKš
œ˜K˜K˜Kš
œ˜K˜Kš
œ˜Kšœ
Ÿ˜Kš
œ"˜"Kšœ
žœ
˜šžœžœ
žœž˜!Jš
œ˜Jšœžœ
˜Jšžœ
˜—J˜J˜—šœžœžœžœ˜NKšœžœ7˜AKš
œ˜K˜K˜Kš
œ˜K˜Kšœ
Ÿ˜Kš
œ"˜"Kšœ
žœ
˜šžœžœ
žœž˜!Jš
œ˜Jšœžœ
˜Jšžœ
˜—J˜—˜Kš
œγ
™γ
šœžœ7™KKšœžœ&™@Kš
œ3™3—Kš
œ$™$šœžœ™-Kšœžœ&™@Kš
œ3™3—Kš
œ¬
™¬
Kš
œ€
™€
š
œ3™3Kšœ	žœ5™AKš
œ7™7—K™—š
œžœ.žœžœžœ˜eKšœžœ˜Kšœžœ˜š
ž˜šžœ
žœ
ž˜KšœžœŸ=˜VKšœžœ˜Kšœžœ˜%Kšžœžœ"˜3—š
ž˜š
œ˜Kš
œ˜Kšžœžœ"˜3Kšœžœ˜Kš
œ˜Jšžœžœžœ˜6Jšžœ˜K˜—š
œ˜Kš
 @™@šžœžœžŸ˜%Jš
œ˜Jšœžœ˜(Kšœžœ˜Jšžœžœžœ˜6Jšžœ˜Jš
œ"˜"Kš
 .™.š
ž˜Kšœ
žœ˜Kšœ	žœ˜šžœžœ
žœž˜!Jšžœžœ%˜@Jšžœ
˜—Jš
œ˜Jš
œ˜Jšžœ
˜—J˜
—šžœŸ˜Jš
œ˜Jšœžœ˜$Jšœ
žœ
˜J˜—J˜—š
œ	˜	Jš
œ˜Jšœžœ˜$Jš
œ"˜"J˜——Jšžœ
˜—K˜K˜—šœžœ%žœžœ˜PKšœžœ˜Kšœžœ˜š
ž˜šžœ
žœ
ž˜KšœžœŸ!˜AKšœžœ˜Kšœžœ˜%Kšžœžœ"˜3—š
ž˜š
œ˜Kš
œ˜Kšžœžœ*˜CKšœžœ˜&Kš
œ˜Jš
œ˜K˜—š
œ˜Kš
 @™@šžœžœžŸ˜-Jš
œ˜Jšœžœ&˜@Kšœžœ˜&Jšœ
žœ
˜Kš
 6™6š
ž˜Kšœ
žœ˜Kšœ
žœžœ
žœ˜šžœžœ
žœž˜!Jšžœžœ-˜PJšžœ
˜—Jš
œ˜Jš
œ˜Jšžœ
˜—Jš
œ,˜,J˜
—šžœŸ˜Jš
œ˜Jšœžœ˜4Jšœ
žœ
˜J˜—J˜—š
œ	˜	Jš
œ˜Jšœžœ˜4Jšœ
žœ
˜J˜——Jšžœ
˜—K˜—K˜šœžœ&žœ&˜išžœžœ
žœž˜ Kš
œ˜Kšžœ
˜—K˜K˜—š
œžœ&žœ&žœ*žœ˜ž
Kš
 U™UKšœžœ
˜Kšœžœ
˜K˜K˜šžœžœ
žœž˜Iprocšžœžœ
žœ˜3Nšžœžœ
žœ˜3Nš
œ˜N˜šžœžœ˜ Nš
œ$˜$Nš
œ˜N˜
—šžœ˜Nš
œ$˜$N˜N˜—š
ž˜NšœŸ˜/šžœžœ
žœž˜'Nš
œ$˜$Nš
œ˜—Nšžœ˜	NšœŸ˜/šžœžœ
žœž˜'Nš
œ$˜$Nš
œ˜—Nšžœ˜	—Nšžœ
˜K˜K˜——šœžœžœ.žœžœ*žœ˜­
Nš
œh™hNšœžœ
˜N˜Kšœžœ$˜/Kšœ
žœ#˜0Nš
œ˜N˜šžœžœ
žœž˜Nšžœžœ
žœ˜5Nšžœžœ
žœ˜2N˜š
ž˜Nšžœ5ž˜?šœ	Ÿ!˜*šœžœ:˜Ošžœžœ˜"N˜Nšœžœ
žœ
˜#Nš
œP˜PNš
œT˜TNšžœžœ
žœ˜2N™~šžœ1ž˜;Nšœžœ˜Nšœžœ˜Nšœ	žœ˜Nšžœžœ
˜—N˜
—Nšžœ
žœ˜—N˜—Nšœžœ˜Nšœžœ˜Nšžœžœ
˜š
ž˜š
œ˜Nš
œ˜Nš
œ˜Nš
œ˜Nš œŸ˜2N˜—˜Nš
œ˜Nš
œ˜N˜—˜Nš
œ˜Nš
œ˜N˜——Nšžœ
˜——š
ž˜NšœŸ˜-šžœžœ
žœž˜'Nš
œ˜Nš
œ˜—Nšžœ˜	NšœŸ˜-šžœžœ
žœž˜'Nš
œ˜Nš
œ˜—Nšžœ˜	—Nšžœ
˜NšœŸ#˜&N˜—š
œžœ&žœ˜>K™iKš
œ˜šžœžœ
žœž˜&šžœžœ
žœž˜&šžœ+žœ˜3Kš
œ˜Kš
œ ˜ Kš
œ˜K˜—Kšžœ
˜—Kšžœ
˜—˜K˜——š
œžœ&žœ˜>K™iKš
œ˜šžœžœ
žœž˜&šžœžœ
žœž˜&šžœ+žœ˜3Kš
œ˜Kš
œ ˜ Kš
œ˜K˜—Kšžœ
˜—Kšžœ
˜—K˜K˜—š	œžœ#žœ˜:K™jKš
œ˜šžœžœ
žœž˜%šžœžœ
žœž˜%šžœ1žœ˜9Kš
œ˜Kš
œ˜Kš
œ˜K˜—Kšžœ
˜—Kšžœ
˜—K˜K˜—š
œžœžœ˜6K™}Kš
œ˜šžœžœ
žœž˜!šžœžœ
žœž˜!šžœ)žœ˜1Kš
œ˜Kš
œ˜Kš
œ˜K˜—Kšžœ
˜—Kšžœ
˜—K˜—K™™K™—š
œžœžœžœžœ˜\Kšœžœ
˜Kšœ
žœ
žœ
˜Kš
œ,˜,šžœž˜šœŸ˜Kšœ
žœ˜!Kš
œE˜EKšœ
žœ
˜K˜—šœŸ˜
Kšœžœ˜Kš
œ?˜?Kšœ
žœ
˜K˜—Kšžœžœžœ˜ —K˜K˜—š
œžœžœ	žœžœ
žœ˜UKš
œ)˜)šžœž˜š
œ
˜
Kšœžœ˜0Kšœ	žœ
žœ˜!Kš
œE˜Ešžœžœ
žœ˜Kš
œ˜Kš
œ
˜
Kšžœ
˜K˜—Kš
œ˜—š
œ˜Kš
œ
˜
Kšœžœ(˜<Kšžœ
˜K˜—š
œ˜Kš
œ
˜
Kšœžœ$˜8Kšžœ
˜K˜—š
œ˜Kš
œ
˜
Kšœžœ˜*Kšžœ
˜K˜—Kšžœžœžœ˜3—šžœ
žœ
ž˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœžœ
˜—K˜K˜—šœžœžœžœ
žœžœ
žœ
žœ˜fKšœžœ
˜ Kšœžœ
žœ
˜$Kš
œ1˜1Kš
œ1˜1šžœž˜$Kš
œa˜a—š
ž˜Kš
œa˜a—K˜K˜—Kšœžœžœ
žœ
žœžœžœ
žœžœ
žœ
žœ˜iš
œžœžœ
žœžœ˜IK™:KšœžœžœžœžœžœžœŸ
˜3Kšœ œžœžœžœžœ
žœŸ
˜6Kšœ œ œžœžœžœžœŸ˜;Kšœ	 œ œ
 œžœžœ
žœŸ
˜?Kšœ œ œ œ œžœžœŸ	˜@Kš	œ œ	 œžœŸœ˜@Kšœ œ œŸ˜AKš
œ˜K˜—šœ˜Kšœ
žœ
˜Kšœžœ
˜K˜K˜—š‘œ˜Kšœžœžœ
žœ
žœžœžœ
žœžœ
žœ
žœ™iKšœžœ˜Kšœžœ˜K˜
Kšœ
ž
˜Kš
œ2˜2Kšžœ
žœ
žœžœžœ
žœ˜DKšžœžœ
žœ˜%J˜J˜—š‘œ˜Kšœžœžœ
žœ
žœžœžœ
žœžœ
žœ
žœ™iKšœžœ˜Kšœ
žœ˜Kšœžœžœ˜Kš
œ˜Kšœ	ž
˜Kš
œF˜Fšžœžœ
žœž˜Kšœ
žœ˜#Kšœžœ˜#Kšžœ
˜—J˜J˜—š‘œ˜Kšœžœžœ
žœ
žœžœžœ
žœžœ
žœ
žœ™iKšœžœ˜Kšœžœ˜Kšœžœžœ˜Kš
œ˜Kšœ	ž
˜Kš
œL˜Lšžœžœ
žœž˜Kšœ
žœ˜#Kšœžœ˜#Kšžœ
˜—J˜J˜—š‘œ˜Kšœžœžœ
žœ
žœžœžœ
žœžœ
žœ
žœ™iKšœ
žœ˜Kšœ
žœ˜K˜
Kšœž
˜Kš
œ3˜3Kšžœ
žœžœžœžœ
žœ˜AKšžœžœ
žœ˜%J˜J˜—š‘œ˜Kšœžœžœ
žœ
žœžœžœ
žœžœ
žœ
žœ™iKšœ
žœ˜Kšœžœ˜Kšœžœžœ˜Kš
œ˜Kšœ	ž
˜Kš
œF˜Fšžœžœ
žœž˜Kšœ
žœ˜#Kšœžœ˜#Kšžœ
˜—J˜J˜—š‘œ˜Kšœžœžœ
žœ
žœžœžœ
žœžœ
žœ
žœ™iKšœžœ˜Kšœžœ˜K˜
Kšœž
˜Kš
œ/˜/Kšžœ
žœžœžœžœ
žœ˜AKšžœžœ
žœ˜%J˜J˜—š‘œ˜Kšœžœžœ
žœ
žœžœžœ
žœžœ
žœ
žœ™iKšœžœ˜Kšœ
žœ˜Kšœžœžœ˜Kš
œ˜Kšœ	ž
˜Kš
œ@˜@šžœžœ
žœž˜Kšœ
žœ˜#Kšœžœ˜#Kšžœ
˜—J˜J˜—š‘œ˜Kšœžœžœ
žœ
žœžœžœ
žœžœ
žœ
žœ™iKšœžœ˜Kšœžœ˜Kšœžœžœ˜Kš
œ˜Kšœ	ž
˜Kš
œD˜Dšžœžœ
žœž˜Kšœ
žœ˜#Kšœžœ˜#Kšžœ
˜—J˜J˜—š‘œ˜Kšœžœžœ
žœ
žœžœžœ
žœžœ
žœ
žœ™iKšœžœ˜Kšœ
žœ˜Kšœžœžœ˜Kš
œ˜Kšœ	ž
˜Kš
œ@˜@šžœžœ
žœž˜Kšœ
žœ˜#Kšœžœ˜#Kšžœ
˜—J˜J˜—š‘œ˜Kšœžœžœ
žœ
žœžœžœ
žœžœ
žœ
žœ™iKšœžœ˜Kšœžœ˜Kšœžœžœ˜Kš
œ˜Kšœ	žœ
˜Kš
œ7™7Kš
œ@˜@šžœžœ
žœž˜Kšœ
žœ˜#Kšœžœ˜#Kšžœ
˜—J˜K˜—š‘œ˜Kšœžœžœ
žœ
žœžœžœ
žœžœ
žœ
žœ™iKšœžœ˜Kšœ
žœ˜Kšœžœžœ˜Kš
œ˜Kšœ	žœžœ
žœžœ
žœ˜+Kš
œa˜ašžœžœ
žœž˜Kšœ
žœ˜#Kšœžœ˜&Kšžœ
˜—J˜J˜—šœžœ!žœ
žœžœ'žœžœ
žœžœ
žœ˜’
Kšœžœžœ˜"K˜Kšœžœžœ
žœžœ
žœ˜0Kš
œ}˜}šžœžœ
žœž˜"šžœ%žœ˜-Jš
œ!˜!Jš
œ$˜$Jš
œ˜J˜—Jšžœ
˜—K˜K˜—šœ˜Kšœžœžœ
žœ
žœžœžœ
žœžœ
žœ
žœ˜iKšœžœ˜Kšœ
žœ˜Kšœžœžœ˜Kš
œ˜Kšœ	žœžœ
žœžœ
žœ˜+Kš
œ;˜;šžœžœ
žœž˜Kšœ
žœ˜#Kšœžœ˜&Kšžœ
˜—J˜J˜—šœ˜Kšœžœ˜%Kšœ
žœ˜Jšœ
Ÿœ.˜<šžœžœ
žœžœžœ
ž˜@Kšœžœ
žœ˜!Kšžœ
˜—K˜K˜—šœ˜Kšœžœ˜%Kšœžœ˜Jšœ
Ÿœ2˜@šžœžœ
žœžœžœ
ž˜@Kšœžœ
žœ˜!Kšžœ
˜—K˜—K˜K™	šœžœ
žœžœžœŸ=˜rKšœžœ˜2Kšœžœ˜2Kšœžœ˜2Kšœžœ˜0šžœžœ
žœž˜!Kšœžœ˜'Kšœžœ˜'Kšœžœ˜&Kšžœ
˜—Kšžœ˜
K˜—K˜Kšžœ
˜J˜—…—©ΐ
—