DIRECTORY
--Feedback, --GGBasicTypes, GGBoundBox, GGInterfaceTypes, GGModelTypes, GGSegmentTypes, GGSelect, GGShapes, Imager, ImagerTransformation, Lines2d, Real, RealFns, Vectors2d;

GGBoundBoxImpl: CEDAR PROGRAM
IMPORTS --Feedback,-- GGBoundBox, GGSelect, GGShapes, Imager, ImagerTransformation, Lines2d, RealFns, Vectors2d
EXPORTS GGBoundBox = BEGIN

BoundBox: TYPE = REF BoundBoxObj;
BoundBoxObj: TYPE = GGBasicTypes.BoundBoxObj;
Circle: TYPE = GGBasicTypes.Circle;
Edge: TYPE = GGBasicTypes.Edge;
Joint: TYPE = GGModelTypes.Joint;
Line: TYPE = GGBasicTypes.Line;
MaskArray: TYPE = GGBoundBox.MaskArray;
Outline: TYPE = GGModelTypes.Outline;
OutlineDescriptor: TYPE = GGModelTypes.OutlineDescriptor;
Point: TYPE = GGBasicTypes.Point;
Scene: TYPE = GGModelTypes.Scene;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
Sequence: TYPE = GGModelTypes.Sequence;
Slice: TYPE = GGModelTypes.Slice;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceDescriptorGenerator: TYPE = GGModelTypes.SliceDescriptorGenerator;
SliceParts: TYPE = GGModelTypes.SliceParts;
Traj: TYPE = GGModelTypes.Traj;
TrajGenerator: TYPE = GGModelTypes.TrajGenerator;
Vector: TYPE = GGBasicTypes.Vector;

emptyBoundBox: PUBLIC BoundBox _ NEW[GGBasicTypes.BoundBoxObj _ [loX: Real.LargestNumber, loY: Real.LargestNumber, hiX: Real.SmallestNormalizedNumber, hiY: Real.SmallestNormalizedNumber, null: TRUE, infinite: FALSE] ];



CreateBoundBox: PUBLIC PROC [loX, loY, hiX, hiY: REAL, null: BOOL _ FALSE, infinite: BOOL _ FALSE] RETURNS [bBox: BoundBox] = {
bBox _ NEW[BoundBoxObj _ [loX, loY, hiX, hiY, null, infinite]];
};

NullBoundBox: PUBLIC PROC [] RETURNS [bBox: BoundBox] = {
bBox _ NEW[BoundBoxObj _ [0,0,0,0, TRUE, FALSE]];
};

CopyBoundBox: PUBLIC PROC [bBox: BoundBox] RETURNS [copy: BoundBox] = {
copy _ NEW[BoundBoxObj _ [bBox.loX, bBox.loY, bBox.hiX, bBox.hiY, bBox.null, bBox.infinite]];
};

UpdateCopyBoundBox: PUBLIC PROC [bBox: BoundBox, from: BoundBox] = {
bBox^ _ from^;
};

BoundBoxOfBoxes: PUBLIC PROC [list: LIST OF BoundBox] RETURNS [bigBox: BoundBox] = {
bigBox _ NEW[BoundBoxObj];
WHILE list # NIL AND list.first.null DO list _ list.rest ENDLOOP;
IF list = NIL THEN {bigBox.null _ TRUE; bigBox.infinite _ FALSE; RETURN};
CopyContents[bigBox, list.first];
FOR bBoxList: LIST OF BoundBox _ list.rest, bBoxList.rest UNTIL bBoxList = NIL DO
IF bBoxList.first.infinite THEN {bigBox.null _ FALSE;  bigBox.infinite _ TRUE; RETURN};
EnlargeByBox[bBox: bigBox, by: bBoxList.first];
ENDLOOP;
};

BoundBoxOfBoundBox: PUBLIC PROC [box: BoundBox, transform: ImagerTransformation.Transformation] RETURNS [newBox: BoundBox] = {
rect: Imager.Rectangle _ RectangleFromBoundBox[box];
rect _ ImagerTransformation.TransformRectangle[transform, rect];
newBox _ BoundBoxFromRectangle[rect];
};

UpdateBoundBoxOfBoundBox: PUBLIC PROC [bBox: BoundBox, localBox: BoundBox, transform: ImagerTransformation.Transformation] = {
rect: Imager.Rectangle _ RectangleFromBoundBox[localBox];
rect _ ImagerTransformation.TransformRectangle[transform, rect];
UpdateBoundBoxFromRectangle[bBox, rect];
};

BoundBoxFromRectangle: PUBLIC PROC [rect: Imager.Rectangle] RETURNS [bBox: BoundBox] = {
bBox _ NEW[BoundBoxObj _ [rect.x, rect.y, rect.x + rect.w, rect.y + rect.h, FALSE, FALSE]];
};

UpdateBoundBoxFromRectangle: PUBLIC PROC [bBox: BoundBox, rect: Imager.Rectangle] = {
bBox^ _ [rect.x, rect.y, rect.x + rect.w, rect.y + rect.h, FALSE, FALSE];
};

RectangleFromBoundBox: PUBLIC PROC [bBox: BoundBox] RETURNS [rect: Imager.Rectangle] = {
IF bBox.infinite THEN ERROR;
IF bBox.null THEN rect _ [bBox.loX, bBox.loY, 0.0, 0.0]
ELSE rect _ [bBox.loX, bBox.loY, bBox.hiX - bBox.loX, bBox.hiY - bBox.loY];
};

BoundBoxOfPixelArray: PUBLIC PROC [pa: Imager.PixelArray] RETURNS [bBox: BoundBox] = {
xPixels, yPixels: REAL;
xPixels _ pa.sSize;
yPixels _ pa.fSize;
bBox _ GGBoundBox.CreateBoundBox[0, 0, xPixels, yPixels];
bBox _ GGBoundBox.BoundBoxOfBoundBox[bBox, pa.m];
};
BoundBoxOfBitMap: PUBLIC PROC [base: LONG POINTER, wordsPerLine: NAT, 
sMin, fMin, sSize, fSize: NAT, tx, ty: INTEGER _ 0] RETURNS [bBox: BoundBox] = {

};

AllowForJoints: PUBLIC PROC [box: BoundBox] = {
cpHalf: REAL _ GGModelTypes.halfJointSize + 1;
box^ _ [loX: box.loX-cpHalf, loY: box.loY-cpHalf, hiX: box.hiX+cpHalf, hiY: box.hiY+cpHalf, null: box.null, infinite: box.infinite];
};

EnlargeByBox: PUBLIC PROC [bBox: BoundBox, by: BoundBox] = {
IF bBox.infinite OR by.null THEN RETURN;
IF by.infinite THEN {bBox.infinite _ TRUE; bBox.null _ FALSE; RETURN};
IF bBox.null THEN {CopyContents[to: bBox, from: by]; RETURN};
bBox.loX _ MIN[bBox.loX, by.loX];
bBox.hiX _ MAX[bBox.hiX, by.hiX];
bBox.loY _ MIN[bBox.loY, by.loY];
bBox.hiY _ MAX[bBox.hiY, by.hiY];
};

EnlargeByPoint: PUBLIC PROC [bBox: BoundBox, point: Point] = {
IF bBox.infinite THEN RETURN;
IF bBox.null THEN {
bBox.loX _ bBox.hiX _ point.x;
bBox.loY _ bBox.hiY _ point.y;
bBox.null _ FALSE;
RETURN;
};
bBox.loX _ MIN[bBox.loX, point.x];
bBox.hiX _ MAX[bBox.hiX, point.x];
bBox.loY _ MIN[bBox.loY, point.y];
bBox.hiY _ MAX[bBox.hiY, point.y];
};

EnlargeByVector: PUBLIC PROC [bBox: BoundBox, vector: Vector] = {
IF bBox.null OR bBox.infinite THEN RETURN;
IF vector.x <0.0
THEN bBox.loX _ bBox.loX + vector.x
ELSE bBox.hiX _ bBox.hiX + vector.x;
IF vector.y <0.0
THEN bBox.loY _ bBox.loY + vector.y
ELSE bBox.hiY _ bBox.hiY + vector.y;
};

EnlargeByOffset: PUBLIC PROC [bBox: BoundBox, offset: REAL] = {
IF bBox.null OR bBox.infinite THEN RETURN;
bBox.loX _ bBox.loX - offset;
bBox.hiX _ bBox.hiX + offset;
bBox.loY _ bBox.loY - offset;
bBox.hiY _ bBox.hiY + offset;
};

UpdateBoundBox: PUBLIC PROC [bBox: BoundBox, loX, loY, hiX, hiY: REAL] = {
bBox.loX _ loX;
bBox.loY _ loY;
bBox.hiX _ hiX;
bBox.hiY _ hiY;
bBox.null _ FALSE;
bBox.infinite _ FALSE;
};



PointIsInBox: PUBLIC PROC [test: Point, box: GGBasicTypes.BoundBoxObj] RETURNS [BOOL] = {
RETURN[ NOT (test.x < box.loX OR test.x > box.hiX OR test.y < box.loY OR test.y > box.hiY) ];
};


BoundBoxOfSelected: PUBLIC PROC [scene: Scene, selectClass: GGInterfaceTypes.SelectionClass _ normal] RETURNS [bigBox: BoundBox] = {
nextBox: BoundBox;
sliceDescGen: SliceDescriptorGenerator _ GGSelect.SelectedSlices[scene, selectClass];
bigBox _ GGBoundBox.NullBoundBox[];
FOR sliceD: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen], GGSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD=NIL DO
nextBox _ sliceD.slice.class.getBoundBox[sliceD.slice, sliceD.parts];
EnlargeByBox[bBox: bigBox, by: nextBox];
ENDLOOP;
};

useSelected: BOOL _ FALSE;
BoundBoxOfMoving: PUBLIC PROC [scene: Scene, selectClass: GGInterfaceTypes.SelectionClass _ normal] RETURNS [bigBox: BoundBox] = {

nextBox: BoundBox;
sliceDescGen: SliceDescriptorGenerator _ GGSelect.SelectedSlices[scene, selectClass];
IF useSelected THEN RETURN[BoundBoxOfSelected[scene, selectClass]];
bigBox _ GGBoundBox.NullBoundBox[];
FOR sliceD: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen], GGSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD=NIL DO
overlay, rubber, drag, movingParts: SliceDescriptor;
[----, overlay, rubber, drag] _ sliceD.slice.class.movingParts[sliceD.slice, sliceD.parts];
movingParts _ sliceD.slice.class.unionParts[overlay, rubber];
movingParts _ sliceD.slice.class.unionParts[movingParts, drag];
nextBox _ sliceD.slice.class.getBoundBox[sliceD.slice, movingParts.parts];
EnlargeByBox[bBox: bigBox, by: nextBox];
ENDLOOP;
};

CopyContents: PROC [to: BoundBox, from: BoundBox] = {
to^ _ [from.loX, from.loY, from.hiX, from.hiY, from.null, from.infinite];
};

DrawBoundBox: PUBLIC PROC [dc: Imager.Context, bBox: BoundBox] = {
GGShapes.DrawRectangle[dc, bBox.loX, bBox.loY, bBox.hiX, bBox.hiY];
};

EraseWithinBoundBox: PUBLIC PROC [dc: Imager.Context, bBox: BoundBox] = {
EraseWithinBoundBoxAux: PROC = {
rect: Imager.Rectangle _ [x: bBox.loX, y: bBox.loY, w: bBox.hiX-bBox.loX, h: bBox.hiY-bBox.loY];
Imager.SetColor[dc, Imager.white];
Imager.MaskRectangle[dc, rect];
};
IF bBox.null OR bBox.infinite THEN RETURN;
Imager.DoSaveAll[dc, EraseWithinBoundBoxAux];
};

Clip: PUBLIC PROC [dc: Imager.Context, bBox: BoundBox] = {
IF bBox.null THEN ERROR;
IF bBox.infinite THEN RETURN;
Imager.ClipRectangle[dc, [bBox.loX, bBox.loY, (bBox.hiX-bBox.loX), (bBox.hiY-bBox.loY)]];
};

NearestPoint: PUBLIC PROC [bBox: BoundBox, testPoint: Point, tolerance: REAL _ 1E6, mask: MaskArray _ ALL[TRUE] ] RETURNS [bestDist: REAL, bestJoint: NAT, bestPoint: Point, success: BOOL] = {
thisPoint: Point;
thisDist2, bestDist2: REAL;
tolerance2: REAL _ tolerance*tolerance;
index: NAT _ 0;
IF bBox.null OR bBox.infinite THEN
RETURN[bestDist: 99999.0, bestJoint: 999, bestPoint: [-1.0, -1.0], success: FALSE];
bestPoint _ [-1.0, -1.0];
bestDist2 _ 1E12; -- better be big enough
bestJoint _ 9999;
success _ FALSE;
FOR index IN [0..4) DO
IF mask[index] THEN {
thisPoint _ BoxPoint[bBox, index];
thisDist2 _ Vectors2d.DistanceSquared[thisPoint, testPoint];
IF thisDist2 < bestDist2 THEN {
bestDist2 _ thisDist2;
bestJoint _ index;
bestPoint _ thisPoint;
IF bestDist2 < tolerance2 THEN success _ TRUE;
};
};
ENDLOOP;
bestDist _ RealFns.SqRt[bestDist2];
};

NearestSegment: PUBLIC PROC [bBox: BoundBox, testPoint: Point, tolerance: REAL _ 1E6, mask: MaskArray _ ALL[TRUE] ] RETURNS [bestDist: REAL, bestSeg: NAT, bestPoint: Point, success: BOOL] = {
thisDist2, bestDist2: REAL;
thisPoint: Point;
tolerance2: REAL _ tolerance*tolerance;
index: NAT _ 0;
IF bBox.null OR bBox.infinite THEN
RETURN[bestDist: 99999.0, bestSeg: 999, bestPoint: [-1.0, -1.0], success: FALSE];
bestPoint _ [-1.0, -1.0];
bestDist2 _ 1E12; -- better be big enough
bestSeg _ 9999;
success _ FALSE;
FOR index IN [0..4) DO
IF mask[index] THEN {
FillBoxEdge[globalBoxEdge, bBox, index];
thisPoint _ Lines2d.NearestPointOnEdge[testPoint, globalBoxEdge];
thisDist2 _ Vectors2d.DistanceSquared[thisPoint, testPoint];
IF thisDist2 < bestDist2 THEN {
bestDist2 _ thisDist2;
bestSeg _ index;
bestPoint _ thisPoint;
IF thisDist2 < tolerance2 THEN success _ TRUE;
};
};
ENDLOOP;
bestDist _ RealFns.SqRt[bestDist2];
};

LineMeetsBoundBox: PUBLIC PROC [bBox: BoundBox, line: Line] RETURNS [points: LIST OF Point, pointCount: NAT] = {
noHit: BOOL;
hits: ARRAY[0..3] OF BOOL;
hitPoints: ARRAY[0..3] OF Point;
hitPoint: Point;
epsilon: REAL = 0.072;
points _ NIL;
pointCount _ 0;
FOR i: NAT IN [0..3] DO hits[i] _ FALSE; ENDLOOP;
FOR i: NAT IN [0..2] DO
FillBoxEdge[globalEdge, bBox, i];
[hitPoints[i], noHit] _ Lines2d.LineMeetsEdge[line, globalEdge]; -- global scratch edge
IF noHit THEN LOOP;
IF i>0 AND hits[i-1] THEN {
IF ABS[hitPoints[i].x - hitPoints[i-1].x] < epsilon THEN LOOP;
IF ABS[hitPoints[i].y - hitPoints[i-1].y] < epsilon THEN LOOP;
};
points _ CONS[hitPoint, points];
pointCount _ pointCount + 1;
hits[i] _ TRUE;
REPEAT
FINISHED => {
FillBoxEdge[globalEdge, bBox, 3];
[hitPoints[3], noHit] _ Lines2d.LineMeetsEdge[line, globalEdge];
IF noHit THEN GOTO End;
IF hits[2] THEN {
IF ABS[hitPoints[3].x - hitPoints[2].x] < epsilon THEN GOTO End;
IF ABS[hitPoints[3].y - hitPoints[2].y] < epsilon THEN GOTO End;
};
IF hits[0] THEN {
IF ABS[hitPoints[3].x - hitPoints[0].x] < epsilon THEN GOTO End;
IF ABS[hitPoints[3].y - hitPoints[0].y] < epsilon THEN GOTO End;
};
points _ CONS[hitPoint, points];
pointCount _ pointCount + 1;
hits[3] _ TRUE;
EXITS
End => NULL;
};
ENDLOOP;
IF pointCount > 2 THEN ERROR;
};

CircleMeetsBoundBox: PUBLIC PROC [bBox: BoundBox, circle: Circle] RETURNS [points: LIST OF Point, pointCount: NAT] = {
RETURN[NIL, 0];
};

BoxPoint: PROC [bBox: BoundBox, index: NAT] RETURNS [point: Point] ~ {
IF bBox.null OR bBox.infinite THEN ERROR;
SELECT index FROM
0 => point _ [bBox.loX, bBox.loY];
1 => point _ [bBox.loX, bBox.hiY];
2 => point _ [bBox.hiX, bBox.hiY];
3 => point _ [bBox.hiX, bBox.loY];
ENDCASE => ERROR;
};

FillBoxEdge: PRIVATE PROC [edge: Edge, bBox: BoundBox, index: NAT] = {
IF bBox.null OR bBox.infinite THEN ERROR;
SELECT index FROM
0 => Lines2d.FillEdge[[bBox.loX, bBox.loY], [bBox.loX, bBox.hiY], edge];
1 => Lines2d.FillEdge[[bBox.loX, bBox.hiY], [bBox.hiX, bBox.hiY], edge];
2 => Lines2d.FillEdge[[bBox.hiX, bBox.hiY], [bBox.hiX, bBox.loY], edge];
3 => Lines2d.FillEdge[[bBox.hiX, bBox.loY], [bBox.loX, bBox.loY], edge];
ENDCASE => ERROR;
};

globalEdge: Edge;
globalBoxEdge: Edge;

Init: PROC [] = {
globalEdge _ Lines2d.CreateEmptyEdge[];
globalBoxEdge _ Lines2d.CreateEmptyEdge[];
};

Init[];

END.
ήGGBoundBoxImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Last edited by Bier on March 9, 1987 9:08:56 pm PST
Contents:  Procedures for creating and combining bounding boxes for refresh efficiency.
Pier, May 12, 1987 5:28:18 pm PDT
David Kurlander August 23, 1986 5:04:15 pm PDT

Routines which create a new boundBox.
Computes a bounding box in units of screen dots for the given bit map.  The lower left corner will be [0,0].

Routines which modify or return an existing boundBox.
Update bBox to be the bounding box of itself and itself offset by vector.  Useful to take drop shadows into account, for instance.
Enlarges bBox to include a border of width offset around bBox.  Useful to allow for stroke width of a segment, for instance.
Routines which operate on BoundBoxObj (which is presumably allocated on the execution stack).
Routines which require knowledge of Gargoyle data structures.

routine called to calculate the boundBox of all objects that are about to move; that is, all selected slices, selected CPs, selected joints AND the dangling segments of selected joints AND the segments of selected CPs.
In the common case, drag will be the only non-null descriptor.
Utilities

AllowForArrowHeads: PROC [bBox: BoundBox, traj: Traj] = {
arrowHeight, arrowHalfWidth, firstWidth, lastWidth, delta: REAL;

firstWidth _ GGTraj.FetchSegment[traj, 0].strokeWidth;
lastWidth _ GGTraj.FetchSegment[traj, GGTraj.HiSegment[traj]].strokeWidth;
[arrowHeight, arrowHalfWidth] _ GGShapes.ArrowSize[MAX[firstWidth, lastWidth]];
IF arrowHalfWidth > GGModelTypes.halfJointSize THEN {
delta _ arrowHalfWidth - GGModelTypes.halfJointSize;
bBox.loX _ bBox.loX - delta;
bBox.hiX _ bBox.hiX + delta;
bBox.loY _ bBox.loY - delta;
bBox.hiY _ bBox.hiY + delta;
};
};


Drawing BoundBoxes.

Hit Testing BoundBoxes.

Finds the corner of bBox which is in mask and nearest to testPoint (and its distance from testPoint).  Number the corners of a bBox 0..3 clockwise starting with the lower left corner.
Finds the segment of bBox which is in mask and nearest to testPoint (and its distance from testPoint).  Number the segments of a bBox 0..3 clockwise starting with the left edge.
Find the intersections of the given line with bBox.  pointCount will be at most 2.
Find the intersections of the given circle with bBox.  pointCount will be at most 8.
SIGNAL Feedback.Problem[msg: "Not yet implemented"];
 [Artwork node; type 'ArtworkInterpress on' to command tool] 
Number the joints 0..3 clockwise starting at the lower left hand corner.  Return the requested point.
BoxEdge: PRIVATE PROC [bBox: BoundBox, index: NAT] RETURNS [edge: Edge] = {
IF bBox.null OR bBox.infinite THEN ERROR;
SELECT index FROM
0 => edge _ Lines2d.CreateEdge[[bBox.loX, bBox.loY], [bBox.loX, bBox.hiY]];
1 => edge _ Lines2d.CreateEdge[[bBox.loX, bBox.hiY], [bBox.hiX, bBox.hiY]];
2 => edge _ Lines2d.CreateEdge[[bBox.hiX, bBox.hiY], [bBox.hiX, bBox.loY]];
3 => edge _ Lines2d.CreateEdge[[bBox.hiX, bBox.loY], [bBox.loX, bBox.loY]];
ENDCASE => ERROR;
};

ΚΓ˜
codeš
œ™Kš
œ<™<Kš
œ3™3Kš
œW™WK™!Kš
œ.™.—K™š
Οk	˜	Jš
œ¬
˜¬
K˜—šΟnœœ
˜Kšœh˜oKšœ
˜—˜Kšœ
œœ
˜!Kšœ
œ˜-Kšœœ˜#Kšœœ˜Kšœœ˜!Kšœœ˜Kšœœ˜'Kšœ	œ˜%Kšœœ"˜9Kšœœ˜!Kšœœ˜!Kšœ	œ˜'Kšœœ!˜7Kšœ
œ˜'Kšœœ˜!Kšœœ ˜5Kšœœ)˜GKšœœ˜+Kšœœ˜Kšœœ˜1Kšœœ˜#—K˜Kš	œœœ
œœ˜Ϊ
K˜K˜Kš
œ%™%K˜šžœœ
œœœœœœœ˜Kšœœ5˜?K˜K˜—šžœœ
œœ˜9Kšœœœœ˜1K˜K˜—šžœœ
œœ˜GKšœœS˜]K˜K˜—šžœœ
œ%˜DKš
œ˜K˜K˜—šžœœ
œœ
œœ˜TKšœ	œ˜Kš
œœ
œœœ
˜AKšœœ
œœœœ˜IKš
œ!˜!šœœ
œ%œœ
˜QKš
œœœœœ˜WKš
œ/˜/Kšœ
˜—K˜K˜—šžœœ
œAœ˜~Kš
œ4˜4Kš
œ@˜@Kš
œ%˜%K˜K˜—šžœœ
œY˜~Kš
œ9˜9Kš
œ@˜@Kš
œ(˜(K˜K˜—šžœœ
œœ˜XKšœœBœœ˜[K˜K˜—šžœœ
œ-˜UKšœ;œœ˜IK˜K˜—šžœœ
œœ˜XKšœœ
œ
˜Kšœœ&˜7KšœG˜KK˜K˜—šžœœ
œœ˜VKšœœ
˜Kš
œ˜Kš
œ˜Kš
œ9˜9Kš
œ1˜1K˜—šžœœ
œœ
œœœ
œœ˜—
K™lK˜K˜K™—Kš
œ5™5K˜šžœœ˜/Kšœœ"˜.Kš
œ„
˜„
K˜K˜—šžœœ
œ#˜<Kšœœ	œ
œ
˜(Kš
œ
œœœœ˜FKšœœ$œ˜=Kšœœ˜!Kšœœ˜!Kšœœ˜!Kšœœ˜!K˜K˜—šžœœ
œ#˜>Kšœœ
œ
˜šœœ˜Kš
œ˜Kš
œ˜Kšœœ
˜Kšœ
˜K˜—Kšœœ˜"Kšœœ˜"Kšœœ˜"Kšœœ˜"K˜K˜—šžœœ
œ%˜AK™‚
Kšœœœ
œ
˜*šœ˜Kšœ˜#Kšœ ˜$—šœ˜Kšœ˜#Kšœ ˜$—K˜K˜—šžœœ
œœ˜?Kš
œ|™|Kšœœœ
œ
˜*Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜—šžœœ
œ&œ˜JKš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœœ
˜Kšœœ
˜K˜K˜—K˜Kš
œ]™]K˜šžœœ.œœ˜YKš
œœœœœ˜]K˜K˜—K˜Kš
œ=™=K™šžœœ
œGœ˜„
Kš
œ˜Kš
œU˜UKš
œ#˜#šœrœœ
˜ˆ
Kš
œE˜EKš
œ(˜(Kšœ
˜—K˜K˜—Kšœ
œœ
˜šžœœ
œGœ˜‚
K™Ϊ
K˜Kš
œ˜Kš
œU˜UKšœ
œ
œ)˜CKš
œ#˜#šœrœœ
˜ˆ
Kš
Οb>™>Kš
œ4˜4Kš
œ[˜[Kš
œ=˜=Kš
œ?˜?Kš
œJ˜JKš
œ(˜(Kšœ
˜—K˜K˜—K™	K™šžœœ#˜5Kš
œI˜IK˜K˜—šžœœ!™9Kšœ;œ
™@K™K™6K™JKšœ3œ™Ošœ-œ™5Kš
œ4™4Kš
œ™Kš
œ™Kš
œ™Kš
œ™K™—K™K™—K™Kš
œ™K™šžœœ
œ)˜BKš
œC˜CK˜K˜—šžœœ
œ)˜Išžœœ˜ Kš
œ`˜`Kš
œ"˜"Kš
œ˜K˜—Kšœœœ
œ
˜*Kš
œ-˜-K˜K˜—šžœœ
œ)˜:Kšœœ
œ
˜Kšœœ
œ
˜Kš
œY˜YK˜—K˜Kš
œ™K™šžœœ
œ/œœ
œœœ
œœ˜Ώ
Kš
œ·
™·
Kš
œ˜Kšœœ
˜Kšœœ˜'Kšœœ˜šœœ˜"KšœFœ˜S—Kš
œ˜KšœΟc˜)Kš
œ˜Kšœ
œ
˜šœœ˜šœœ˜Kš
œ"˜"Kš
œ<˜<šœœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœœœ
˜.K˜—K˜—Kšœ
˜—Kš
œ#˜#K˜K˜—šžœœ
œ/œœ
œ

œœœœœ˜Ώ
Kš
ϱ
™±
Kšœœ
˜Kš
œ˜Kšœœ˜'Kšœœ˜šœœ˜"KšœDœ˜Q—Kš
œ˜Kšœ ˜)Kš
œ˜Kšœ
œ
˜šœœ˜šœœ˜Kš
œ(˜(Kš
œA˜AKš
œ<˜<šœœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœœœ
˜.K˜—K˜—Kšœ
˜—Kš
œ#˜#K˜K˜—šžœœ
œœ
œ
œœ˜pKšœœ
˜Kšœœœ
œ
˜Kšœœœ˜ Kš
œ˜Kšœ	œ	˜Kš
œR™RKšœ	œ
˜
Kš
œ˜Kšœœ
œœœœ
˜1šœœ
œ˜Kš
œ!˜!KšœA ˜WKšœœ
œ
˜šœœœ˜Kšœ
œ.œ
œ
˜>Kšœ
œ.œ
œ
˜>K˜—Kšœ	œ˜ Kš
œ˜Kšœ
œ
˜š
˜šœ˜
Kš
œ!˜!Kš
œ@˜@Kšœœ
œ˜šœ	œ˜Kšœ
œ,œ
œ˜@Kšœ
œ,œ
œ˜@K˜—šœ	œ˜Kšœ
œ,œ
œ˜@Kšœ
œ,œ
œ˜@K˜—Kšœ	œ˜ Kš
œ˜Kšœ
œ
˜š
˜Kšœœ
˜—K˜——Kšœ
˜—Kšœœ
œ
˜K˜K˜—šžœœ
œ"œ
œ
œœ˜vKš
œT™TKšœ.™4Kšœ
œ˜K˜—K˜šžœœœœ˜F
center•
Interpress…Interpress/Xerox/3.0  f j k j‘₯“Δ
WB € ¨  <ϋ‘£2 ’ ¨ ζ ’ ¨‘‘¨Δ
WB € ¨ r j‘₯“Δ
WB € ¨‘‘¨ΕXeroxΕ
PressFontsΕ
Helvetica-mrr£‘ “ͺ € ” •  —JŠΑHexagon– ‘¨Tή™Δfυ
ΔY_ŽޏTŽ‘‘‘‘™‘―“‘‘¨TήTΔfυ
‘Ή‘―“‘‘¨TΔfυ
ΔY_Δfυ
‘Ή‘―“‘‘¨ΔY_Δfυ
ΔY_ή‘Ή‘―“‘‘¨ΔY_ήTή‘Ή‘―“  —JيΑ
1–  —L
ŠΑ
2–  —˜
ŠΑ
3–  —˜يΑ
4– k ι k g•Artwork
Interpress•Bounds:0.0 mm xmin 0.0 mm ymin 55.03333 mm xmax 32.10278 mm ymax –C34.925 mm topLeading 34.925 mm topIndent 1.411111 mm bottomLeading š
œ=™=Icaption™e—Kšœœœ
œ
˜)Kšœ˜Kš
œ"˜"Kš
œ"˜"Kš
œ"˜"Kš
œ"˜"Kšœœ
˜K˜K˜—š
žœœ
œœœ™KKšœœœ
œ
™)Kšœ™Kš
œK™KKš
œK™KKš
œK™KKš
œK™KKšœœ
™K™K™—šžœœ
œ%œ˜FKšœœœ
œ
˜)Kšœ˜Kš
œH˜HKš
œH˜HKš
œH˜HKš
œH˜HKšœœ
˜K˜—K˜K˜K˜K˜šžœœ˜Kš
œ'˜'Kš
œ*˜*K˜K˜—K˜K˜Kšœ
˜—…—0jN