DIRECTORY
Imager,
ImagerBasic,
ImagerDefault,
ImagerPrivate,
ImagerTransform,
Real;

ImagerDefaultImpl: CEDAR PROGRAM
IMPORTS Imager, ImagerTransform, Real
EXPORTS ImagerDefault
SHARES Imager
~ BEGIN OPEN ImagerDefault;

Trajectory: TYPE ~ Imager.Trajectory;
TrajectoryRep: TYPE ~ Imager.TrajectoryRep;

InitialStateRep: ImagerBasic.StateRep ~ [
cpx: 0.0,
cpy: 0.0,
correctMX: 0.0,
correctMY: 0.0,
correctMaskCount: 0,
correctMaskX: 0.0,
correctMaskY: 0.0,
correctSumX: 0.0,
correctSumY: 0.0,
correctSpaceX: 0.0,
correctSpaceY: 0.0,
correctcpx: 0.0,
correctcpy: 0.0,
correctTargetX: 0.0,
correctTargetY: 0.0,
T: ImagerTransform.Create[1,0,0,0,1,0],
priorityImportant: 0,
mediumXSize: 0,
mediumYSize: 0,
fieldXMin: 0,
fieldYMin: 0,
fieldXMax: 0,
fieldYMax: 0,
showVec: NIL,
color: NIL,
noImage: 0,
strokeWidth: 0.0,
strokeEnd: 0,
underlineStart: 0.0,
amplifySpace: 1.0,
correctPass: 0,
correctShrink: 0.5,
correctTX: 0.0,
correctTY: 0.0,
clipper: NIL,
propertyList: NIL
];

InitState: PUBLIC PROC [context: Context] ~ {
state: State _ NEW[ImagerBasic.StateRep _ InitialStateRep];
state.color _ Imager.black;
context.state _ state;
};

ISet: PUBLIC PROC [context: Context, n: Name, x: REF] ~ {
WITH context.state SELECT FROM
state: State => {
SELECT n FROM
T => WITH x SELECT FROM
t: REF ImagerBasic.Transformation => {state.T _ t^};
ENDCASE => ERROR Imager.Error[$WrongType];
showVec => state.showVec _ x;
color => WITH x SELECT FROM
color: ImagerBasic.Color => {state.color _ color};
ENDCASE => ERROR Imager.Error[$WrongType];
clipOutline => state.clipper _ NARROW[x];
ENDCASE => ERROR Imager.Error[$BadSelector];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

ISetReal: PUBLIC PROC [context: Context, n: Name, x: REAL] ~ {
WITH context.state SELECT FROM
state: State => {
SELECT n FROM
DCScpx => state.cpx _ x;
DCScpy => state.cpy _ x;
correctMX => state.correctMX _ x;
correctMY => state.correctMY _ x;
mediumXSize => state.mediumXSize _ x;
mediumYSize => state.mediumYSize _ x;
fieldXMin => state.fieldXMin _ x;
fieldYMin => state.fieldYMin _ x;
fieldXMax => state.fieldXMax _ x;
fieldYMax => state.fieldYMax _ x;
strokeWidth => state.strokeWidth _ x;
underlineStart => state.underlineStart _ x;
amplifySpace => state.amplifySpace _ x;
correctShrink => state.correctShrink _ x;
correctTX => state.correctTX _ x;
correctTY => state.correctTY _ x;
ENDCASE => ERROR Imager.Error[$BadSelector];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

ISetInt: PUBLIC PROC [context: Context, n: Name, x: INT] ~ {
WITH context.state SELECT FROM
state: State => {
SELECT n FROM
priorityImportant => state.priorityImportant _ x;
noImage => state.noImage _ x;
strokeEnd => state.strokeEnd _ x;
correctPass => state.correctPass _ x;
ENDCASE => ERROR Imager.Error[$BadSelector];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

SetSampledColor: PUBLIC PROC[context: Context, pa: PixelArray, pixelT: Transformation, colorOperator: ATOM] ~ {
state: State _ NARROW[context.state];
color: ImagerBasic.SampledColor ~ NEW[ImagerBasic.ColorRep.sampled _ [sampled[
transparent: FALSE,
pa: pa,
m: pixelT.Concat[state.T],
colorOperator: colorOperator
]]];
state.color _ color;
};

SetSampledBlack: PUBLIC PROC[context: Context, pa: PixelArray, pixelT: Transformation, transparent: BOOLEAN] ~ {
state: State _ NARROW[context.state];
color: ImagerBasic.SampledColor ~ NEW[ImagerBasic.ColorRep.sampled _ [sampled[
transparent: transparent,
pa: pa,
m: pixelT.Concat[state.T],
colorOperator: $SampledBlack
]]];
state.color _ color;
};

DoSave: PUBLIC PROC [context: Context, body: PROC] ~ {
state: State _ NARROW[context.state];
T: Transformation _ state.T;
priorityImportant: INT _ state.priorityImportant;
mediumXSize: REAL _ state.mediumXSize;
mediumYSize: REAL _ state.mediumYSize;
fieldXMin: REAL _ state.fieldXMin;
fieldYMin: REAL _ state.fieldYMin;
fieldXMax: REAL _ state.fieldXMax;
fieldYMax: REAL _ state.fieldYMax;
showVec: REF _ state.showVec;
color: Color _ state.color;
noImage: INT _ state.noImage;
strokeWidth: REAL _ state.strokeWidth;
strokeEnd: INT _ state.strokeEnd;
underlineStart: REAL _ state.underlineStart;
amplifySpace: REAL _ state.amplifySpace;
correctPass: INT _ state.correctPass;
correctShrink: REAL _ state.correctShrink;
correctTX: REAL _ state.correctTX;
correctTY: REAL _ state.correctTY;
clipper: ClientClipper _ state.clipper;
propertyList: REF _ state.propertyList;
Restore: PROC ~ {
state.T _ T;
state.priorityImportant _ priorityImportant;
state.mediumXSize _ mediumXSize;
state.mediumYSize _ mediumYSize;
state.fieldXMin _ fieldXMin;
state.fieldYMin _ fieldYMin;
state.fieldXMax _ fieldXMax;
state.fieldYMax _ fieldYMax;
state.showVec _ showVec;
state.color _ color;
state.noImage _ noImage;
state.strokeWidth _ strokeWidth;
state.strokeEnd _ strokeEnd;
state.underlineStart _ underlineStart;
state.amplifySpace _ amplifySpace;
state.correctPass _ correctPass;
state.correctShrink _ correctShrink;
state.correctTX _ correctTX;
state.correctTY _ correctTY;
state.clipper _ clipper;
state.propertyList _ propertyList;
};
body[! UNWIND => Restore[]];
Restore[];
};

DoSaveAll: PUBLIC PROC [context: Context, body: PROC] ~ {
state: State _ NARROW[context.state];
stateRep: ImagerBasic.StateRep _ state^;
Restore: PROC ~ {
state^ _ stateRep;
};
body[! UNWIND => Restore[]];
Restore[];
};

ConcatT: PUBLIC PROC [context: Context, m: Transformation] ~ {
WITH context.state SELECT FROM
state: State => {
state.T _ ImagerTransform.Concat[m, state.T];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

TranslateT: PUBLIC PROC [context: Context, x, y: REAL] ~ {
WITH context.state SELECT FROM
state: State => {
state.T _ ImagerTransform.PreTranslate[x, y, state.T];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

RotateT: PUBLIC PROC [context: Context, a: REAL] ~ {
WITH context.state SELECT FROM
state: State => {
state.T _ ImagerTransform.PreRotate[a, state.T];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

ScaleT: PUBLIC PROC [context: Context, s: REAL] ~ {
WITH context.state SELECT FROM
state: State => {
state.T _ ImagerTransform.PreScale[s, state.T];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

Scale2T: PUBLIC PROC [context: Context, sx, sy: REAL] ~ {
WITH context.state SELECT FROM
state: State => {
state.T _ ImagerTransform.PreScale2[sx, sy, state.T];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

Move: PUBLIC PROC [context: Context] ~ {
WITH context.state SELECT FROM
state: State => {
new: Pair _ [state.cpx, state.cpy];
t: ImagerTransform.TransformationRec _ state.T.Contents;
state.T _ ImagerTransform.Create[t.a, t.b, new.x, t.d, t.e, new.y];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

Trans: PUBLIC PROC [context: Context] ~ {
WITH context.state SELECT FROM
state: State => {
new: Pair _ Imager.DRound[[state.cpx, state.cpy]];
t: ImagerTransform.TransformationRec _ state.T.Contents;
state.T _ ImagerTransform.Create[t.a, t.b, new.x, t.d, t.e, new.y];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

SetXY: PUBLIC PROC [context: Context, p: Pair] ~ {
WITH context.state SELECT FROM
state: State => {
[[state.cpx, state.cpy]] _ ImagerTransform.Transform[p, state.T];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

IntegerSetXY: PUBLIC PROC [context: Context, x, y: INTEGER] ~ {
WITH context.state SELECT FROM
state: State => {
[[state.cpx, state.cpy]] _ ImagerTransform.Transform[[x, y], state.T];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

SetXYRel: PUBLIC PROC [context: Context, v: Pair] ~ {
WITH context.state SELECT FROM
state: State => {
delta: Pair ~ ImagerTransform.TransformVec[v, state.T];
state.cpx _ state.cpx + delta.x;
state.cpy _ state.cpy + delta.y;
};
ENDCASE => ERROR Imager.Error[$Bug];
};

IntegerSetXYRel: PUBLIC PROC [context: Context, x, y: INTEGER] ~ {
WITH context.state SELECT FROM
state: State => {
delta: Pair ~ ImagerTransform.TransformVec[[x, y], state.T];
state.cpx _ state.cpx + delta.x;
state.cpy _ state.cpy + delta.y;
};
ENDCASE => ERROR Imager.Error[$Bug];
};

GetCP: PUBLIC PROC [context: Context] RETURNS [cp: Pair] ~ {
WITH context.state SELECT FROM
state: State => {
cp _ ImagerTransform.InverseTransform[[state.cpx, state.cpy], state.T];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

GetCPRounded: PUBLIC PROC [context: Context] RETURNS [cp: Pair] ~ {
WITH context.state SELECT FROM
state: State => {
cp _ ImagerTransform.InverseTransform[[Real.RoundLI[state.cpx], Real.RoundLI[state.cpy]], state.T];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

MaskVector: PUBLIC PROC [context: Context, x1, y1, x2, y2: REAL] ~ {
WITH context.state SELECT FROM
state: State => {
class: ImagerPrivate.Class ~ NARROW[context.class];
strokeEnd: StrokeEnd ~ SELECT state.strokeEnd FROM
0 => square, 1 => butt, 2 => round, 
ENDCASE => ERROR Imager.Error[$InvalidStrokeEnd];
MapVector: PathMapType = { move[[x1, y1]]; line[[x2, y2]] };
class.MaskStroke[context, MapVector, NIL, state.strokeWidth, strokeEnd];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

IntegerMaskVector: PUBLIC PROC [context: Context, x1, y1, x2, y2: INTEGER] ~ {
MaskVector[context, x1, y1, x2, y2];
};

StartUnderline: PUBLIC PROC [context: Context] ~ {
WITH context.state SELECT FROM
state: State => {
cp: Pair ~ ImagerTransform.InverseTransform[[state.cpx, state.cpy], state.T];
state.underlineStart _ cp.x;
};
ENDCASE => ERROR Imager.Error[$Bug];
};

MaskUnderline: PUBLIC PROC [context: Context, dy, h: REAL] ~ {
SimpleCO: PROC ~ {
WITH context.state SELECT FROM
state: State => {
cp: Pair ~ ImagerTransform.InverseTransform[[state.cpx, state.cpy], state.T];
Imager.SetXY[context, [state.underlineStart, cp.y-dy-h]];
Imager.Trans[context];
Imager.MaskRectangle[context, 0, 0, cp.x-state.underlineStart, h];
};
ENDCASE => ERROR Imager.Error[$Bug];
};
Imager.DoSaveAll[context, SimpleCO];
};

IntegerMaskUnderline: PUBLIC PROC [context: Context, dy, h: INTEGER] ~ {
MaskUnderline[context, dy, h];
};

ClipOutline: PUBLIC PROC [context: Context, pathMap: PathMapType, pathData: REF] ~ {
WITH context.state SELECT FROM
state: State => {
trans: ImagerTransform.TransformationRec ~ state.T.Contents;
XForm: PROC [p: Pair] RETURNS [Pair] ~ {
RETURN [[trans.a*p.x+trans.b*p.y+trans.c, trans.d*p.x+trans.e*p.y+trans.f]]
};
tList: LIST OF Trajectory _ NIL;
Move: PROC [p: Pair] ~ {tList _ CONS[Imager.MoveTo[XForm[p]], tList]};
Line: PROC [p: Pair] ~ {tList.first _ tList.first.LineTo[XForm[p]]};
Curve: PROC [p1, p2, p3: Pair] ~ {
tList.first _ tList.first.CurveTo[XForm[p1], XForm[p2], XForm[p3]]
};
Conic: PROC [p1, p2: Pair, r: REAL] ~ {
tList.first _ tList.first.ConicTo[XForm[p1], XForm[p2], r]
};
pathMap[pathData, Move, Line, Curve, Conic];
state.clipper _ CONS[[exclude: FALSE, easyRectangle: FALSE, pathMap: MapTrajectoryList, pathData: tList], state.clipper];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

MapTrajectory: PathMapType = {
t: Trajectory = NARROW[data];
move[t.lp];
FOR x: Trajectory _ t, x.prev UNTIL x.prev=NIL DO
p0: Pair = x.prev.lp;
WITH x SELECT FROM
x: REF TrajectoryRep[line] => line[p0];
x: REF TrajectoryRep[curve] => curve[x.p2, x.p1, p0];
x: REF TrajectoryRep[conic] => conic[x.p1, p0, x.r];
x: REF TrajectoryRep[move] => ERROR;
ENDCASE => ERROR;
ENDLOOP;
};

MapTrajectoryList: PathMapType = {
FOR x: LIST OF Trajectory _ NARROW[data], x.rest UNTIL x = NIL DO
MapTrajectory[x.first, move, line, curve, conic]
ENDLOOP;
};

ExcludeOutline: PUBLIC PROC [context: Context, pathMap: PathMapType, pathData: REF] ~ {
WITH context.state SELECT FROM
state: State => {
ClipOutline[context, pathMap, pathData];
state.clipper.first.exclude _ TRUE;
};
ENDCASE => ERROR Imager.Error[$Bug];
};

ClipRectangle: PUBLIC PROC [context: Context, x, y, w, h: REAL] ~ {
WITH context.state SELECT FROM
state: State => {
pathMap: PathMapType ~ {
move[[x, y]]; line[[x+w, y]]; line[[x+w, y+h]]; line[[x, y+h]];
};
t: ImagerTransform.TransformationRec ~ state.T.Contents;
ClipOutline[context, pathMap, NIL];
state.clipper.first.easyRectangle _ (t.a = 0 AND t.e = 0) OR (t.b = 0 AND t.d = 0);
};
ENDCASE => ERROR Imager.Error[$Bug];
};

ExcludeRectangle: PUBLIC PROC [context: Context, x, y, w, h: REAL] ~ {
WITH context.state SELECT FROM
state: State => {
ClipRectangle[context, x, y, w, h];
state.clipper.first.exclude _ TRUE;
};
ENDCASE => ERROR Imager.Error[$Bug];
};

IntegerClipRectangle: PUBLIC PROC [context: Context, x, y, w, h: INTEGER] ~ {
ClipRectangle[context, x, y, w, h];
};

IntegerExcludeRectangle: PUBLIC PROC [context: Context, x, y, w, h: INTEGER] ~ {
ExcludeRectangle[context, x, y, w, h];
};

CorrectMask: PUBLIC PROC [context: Context] ~ {
WITH context.state SELECT FROM
state: State => {
SELECT state.correctPass FROM
1 => state.correctMaskCount _ state.correctMaskCount + 1;
2 => IF state.correctMaskCount > 0 THEN {
spx: REAL ~ state.correctMaskX/state.correctMaskCount;
spy: REAL ~ state.correctMaskY/state.correctMaskCount;
state.correctMaskX _ state.correctMaskX - spx;
state.correctMaskY _ state.correctMaskY - spy;
state.correctMaskCount _ state.correctMaskCount - 1;
state.cpx _ state.cpx + spx;
state.cpy _ state.cpy + spy;
};
ENDCASE => NULL;
};
ENDCASE => ERROR Imager.Error[$Bug];
};

CorrectSpace: PUBLIC PROC [context: Context, v: Pair] ~ {
WITH context.state SELECT FROM
state: State => 
CorrectSpaceView[context, ImagerTransform.TransformVec[v, state.T]];
ENDCASE => ERROR Imager.Error[$Bug];
};

CorrectSpaceView: PUBLIC PROC [context: Context, v: Pair] ~ {
WITH context.state SELECT FROM
state: State => {
SELECT state.correctPass FROM
1 => {
state.correctSumX _ state.correctSumX + v.x;
state.correctSumY _ state.correctSumY + v.y;
};
2 => {
Div: PROC [num, denom: REAL] RETURNS [REAL] ~ {
IF denom = 0.0 THEN {
IF num = 0.0 THEN RETURN [0.0]
ELSE ERROR Imager.Error[$ZeroDivideInCorrectSpace]
}
ELSE RETURN [num/denom]
};
spx: REAL ~ Div[v.x*state.correctSpaceX, state.correctSumX];
spy: REAL ~ Div[v.y*state.correctSpaceY, state.correctSumY];
state.correctSumX _ state.correctSumX - v.x;
state.correctSumY _ state.correctSumY - v.y;
state.correctSpaceX _ state.correctSpaceX - spx;
state.correctSpaceY _ state.correctSpaceY - spy;
state.cpx _ state.cpx + spx;
state.cpy _ state.cpy + spy;
};
ENDCASE => NULL;
};
ENDCASE => ERROR Imager.Error[$Bug];
};

SetCorrectMeasure: PUBLIC PROC [context: Context, v: Pair] ~ {
WITH context.state SELECT FROM
state: State => {
[[state.correctMX, state.correctMY]] _ ImagerTransform.TransformVec[v, state.T];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

SetCorrectTolerance: PUBLIC PROC [context: Context, v: Pair] ~ {
WITH context.state SELECT FROM
state: State => {
[[state.correctTX, state.correctTY]] _ ImagerTransform.TransformVec[v, state.T];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

Space: PUBLIC PROC [context: Context, x: REAL] ~ {
WITH context.state SELECT FROM
state: State => {
v: Pair ~ ImagerTransform.TransformVec[[x, 0], state.T];
state.cpx _ state.cpx + v.x;
state.cpy _ state.cpy + v.y;
SELECT state.correctPass FROM
1 => {
state.correctSumX _ state.correctSumX + v.x;
state.correctSumY _ state.correctSumY + v.y;
};
2 => IF state.correctMaskCount > 0 THEN {
Div: PROC [num, denom: REAL] RETURNS [REAL] ~ {
IF denom = 0.0 THEN {
IF num = 0.0 THEN RETURN [0.0]
ELSE ERROR Imager.Error[$ZeroDivideInCorrectSpace]
}
ELSE RETURN [num/denom]
};
spx: REAL ~ Div[v.x*state.correctSpaceX, state.correctSumX];
spy: REAL ~ Div[v.y*state.correctSpaceY, state.correctSumY];
state.correctSumX _ state.correctSumX - v.x;
state.correctSumY _ state.correctSumY - v.y;
state.correctSpaceX _ state.correctSpaceX - spx;
state.correctSpaceY _ state.correctSpaceY - spy;
state.cpx _ state.cpx + spx;
state.cpy _ state.cpy + spy;
};
ENDCASE => NULL;
};
ENDCASE => ERROR Imager.Error[$Bug];
};

IntegerSpace: PUBLIC PROC [context: Context, x: INTEGER] ~ {
Imager.Space[context, x];
};

Correct: PUBLIC PROC [context: Context, body: PUBLIC PROC] ~ {
WITH context.state SELECT FROM
state: State => {
Length: PROC [x, y: REAL] RETURNS [REAL] ~ {
RETURN [Real.SqRt[x*x + y*y]];
};
state.correctcpx _ state.cpx;
state.correctcpy _ state.cpy;
state.noImage _ 1;
state.correctMaskCount _ 0;
state.correctSumX _ state.correctSpaceY _ 0;
state.correctPass _ 1;
Imager.DoSave[context, body];
state.correctTargetX _ state.correctcpx + state.correctMX;
state.correctTargetY _ state.correctcpy + state.correctMY;
state.correctMaskX _ state.correctMaskY _ 0;
state.correctMaskCount _ state.correctMaskCount - 1;
state.correctSpaceX _ state.correctTargetX - state.cpx;
state.correctSpaceY _ state.correctTargetY - state.cpy;
CHECKED {
IF (
Length[state.correctSpaceX, state.correctSpaceY] > state.correctShrink*Length[state.correctSumX, state.correctSumY]
AND
Length[state.correctcpx - state.correctTargetX, state.correctcpy - state.correctTargetY] <
Length[state.correctcpx - state.cpx, state.correctcpy - state.cpy]
)
THEN {
state.correctMaskX _ state.correctSpaceX + state.correctShrink*state.correctSumX;
state.correctMaskY _ state.correctSpaceY + state.correctShrink*state.correctSumY;
state.correctSpaceX _ state.correctSpaceX - state.correctMaskX;
state.correctSpaceY _ state.correctSpaceY - state.correctMaskY;
};
IF state.correctSumX = 0 AND state.correctSpaceX # 0 THEN {
state.correctMaskX _ state.correctSpaceX;
state.correctSpaceX _ 0;
};
IF state.correctSumY = 0 AND state.correctSpaceY # 0 THEN {
state.correctMaskY _ state.correctSpaceY;
state.correctSpaceY _ 0;
};
};
state.cpx _ state.correctcpx;
state.cpy _ state.correctcpy;
state.noImage _ 0;
state.correctPass _ 2;
Imager.DoSave[context, body];
state.correctPass _ 0;
IF Length[state.correctTargetX - state.cpx, state.correctTargetY - state.cpy] > Length[state.correctTX, state.correctTY] THEN ERROR Imager.Error[$UnableToProperlyAdjustMaskPositions];
state.cpx _ state.correctTargetX;
state.cpy _ state.correctTargetY;
};
ENDCASE => ERROR Imager.Error[$Bug];
};

Reset: PUBLIC PROC [context: Context] ~ {
WITH context.state SELECT FROM
state: State => {
propertyList: REF _ state.propertyList;
state^ _ InitialStateRep;
state.color _ Imager.black;
state.propertyList _ propertyList;
};
ENDCASE => ERROR Imager.Error[$Bug];
};

DrawBitmap: PUBLIC PROC [context: Context, base: LONG POINTER, raster: CARDINAL, area: IntRectangle] ~ {
ERROR Imager.Error[$NotYetImplemented];
};

MaskBits: PUBLIC PROC [context: Context, base: LONG POINTER, raster: CARDINAL, tile: IntRectangle, area: IntRectangle] ~ {
ERROR Imager.Error[$NotYetImplemented];
};

GetSurfaceBounds: PUBLIC PROC [context: Context] RETURNS [IntRectangle] ~ {
WITH context.state SELECT FROM
state: State => {
ERROR Imager.Error[$NotYetImplemented];
};
ENDCASE => ERROR Imager.Error[$Bug];
};

END.

¦ImagerDefaultImpl.mesa
Doug Wyatt, November 23, 1983 2:02 pm
Michael Plass, April 12, 1984 3:08:20 pm PST
Equivalent to {SetXYRel[context, [x, 0]]; CorrectSpace[context, [x, 0]]}
The interpress document asks that this be the length in meters, but since it is only used for comparisons, view coordinates should work as well.  If the view coordinates had non-uniform scaling, this would have to be accounted for here.
�ʘJ™J™%J™,J˜š
Ïk	˜	Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—Jšœ�œ
�˜ Jš�œ˜%Jš�œ˜Jš�œ˜
šœ�œ
�œ˜J˜—Jšœ�œ˜%šœ�œ˜+J˜—š
œ)˜)Jš
œ	˜	Jš
œ	˜	Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ'˜'Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ
˜
Jš
œ
˜
Jš
œ
˜
Jš
œ
˜
Jšœ	�œ
˜
Jšœ�œ
˜Jš
œ˜Jš
œ˜Jš
œ
˜
Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ	�œ
˜
Jšœ�˜Jš
œ˜J˜—šÏn	œ�œ˜-Jšœ�œ)˜;Jš
œ˜Jš
œ˜Jš
œ˜J˜—šžœ�œ �œ˜9š�œ�œ
�˜š
œ˜š�œ�˜
šœ�œ�œ
�˜Jšœ�œ.˜4Jš�œ�œ˜*—Jš
œ˜šœ	�œ�œ
�˜Jšœ(�œ˜2Jš�œ�œ˜*—Jšœ�œ˜)Jš�œ�œ˜,—Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ �œ˜>š�œ�œ
�˜š
œ˜š�œ�˜
Jš
œ˜Jš
œ˜Jš
œ!˜!Jš
œ!˜!Jš
œ%˜%Jš
œ%˜%Jš
œ!˜!Jš
œ!˜!Jš
œ!˜!Jš
œ!˜!Jš
œ%˜%Jš
œ+˜+Jš
œ'˜'Jš
œ)˜)Jš
œ!˜!Jš
œ!˜!Jš�œ�œ˜,—Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ �œ˜<š�œ�œ
�˜š
œ˜š�œ�˜
Jš
œ1˜1Jš
œ˜Jš
œ!˜!Jš
œ%˜%Jš�œ�œ˜,—Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ
�œJ�œ˜oJšœ�œ˜%šœ"�œ)˜NJšœ
�œ
˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—Jš
œ˜Jš
œ˜J˜—šžœ�œ
�œH�œ˜pJšœ�œ˜%šœ"�œ)˜NJš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—Jš
œ˜Jš
œ˜J˜—šžœ�œ
�œ�œ˜6Jšœ�œ˜%Jš
œ˜Jšœ�œ˜1Jšœ
�œ˜&Jšœ
�œ˜&Jšœ�œ˜"Jšœ�œ˜"Jšœ�œ˜"Jšœ�œ˜"Jšœ	�œ˜Jš
œ˜Jšœ	�œ˜Jšœ
�œ˜&Jšœ�œ˜!Jšœ�œ˜,Jšœ�œ˜(Jšœ
�œ˜%Jšœ�œ˜*Jšœ�œ˜"Jšœ�œ˜"Jš
œ'˜'Jšœ�œ˜'šžœ�œ˜Jš
œ˜Jš
œ,˜,Jš
œ ˜ Jš
œ ˜ Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ ˜ Jš
œ˜Jš
œ&˜&Jš
œ"˜"Jš
œ ˜ Jš
œ$˜$Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ˜—Jšœ�œ˜J˜
Jš
œ˜J˜—šž	œ�œ
�œ�œ˜9Jšœ�œ˜%Jš
œ(˜(šžœ�œ˜Jš
œ˜Jš
œ˜—Jšœ�œ˜J˜
Jš
œ˜J˜—šžœ�œ*˜>š�œ�œ
�˜š
œ˜Jš
œ-˜-Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šž
œ�œ�œ˜:š�œ�œ
�˜š
œ˜Jš
œ6˜6Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ�œ˜4š�œ�œ
�˜š
œ˜Jš
œ0˜0Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ�œ˜3š�œ�œ
�˜š
œ˜Jš
œ/˜/Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ�œ˜9š�œ�œ
�˜š
œ˜Jš
œ5˜5Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ˜(š�œ�œ
�˜š
œ˜Jš
œ#˜#Jš
œ8˜8Jš
œC˜CJš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ˜)š�œ�œ
�˜š
œ˜Jš
œ2˜2Jš
œ8˜8Jš
œC˜CJš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ ˜2š�œ�œ
�˜š
œ˜Jš
œA˜AJš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ�œ˜?š�œ�œ
�˜š
œ˜Jš
œF˜FJš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ ˜5š�œ�œ
�˜š
œ˜Jš
œ7˜7Jš
œ ˜ Jš
œ ˜ Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ�œ˜Bš�œ�œ
�˜š
œ˜Jš
œ<˜<Jš
œ ˜ Jš
œ ˜ Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ�œ˜<š�œ�œ
�˜š
œ˜Jš
œG˜GJš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ�œ˜Cš�œ�œ
�˜š
œ˜Jš
œc˜cJš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šž
œ�œ
�œ$�œ˜Dš�œ�œ
�˜š
œ˜Jšœ�œ˜3šœ�œ�˜2Jš
œ$˜$Jš�œ�œ!˜1—Jš
œ<˜<Jšœ%�œ ˜HJš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ
�œ$�œ˜NJš
œ$˜$Jš
œ˜J˜—šžœ�œ
�œ˜2š�œ�œ
�˜š
œ˜Jš
œM˜MJš
œ˜Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šž
œ�œ�œ˜>šžœ�œ˜š�œ�œ
�˜š
œ˜Jš
œM˜MJš
œ9˜9Jš
œ˜Jš
œB˜BJš
œ˜—Jš�œ�œ˜$—Jš
œ˜—Jš
œ$˜$Jš
œ˜J˜—šžœ�œ�œ˜HJš
œ˜Jš
œ˜J˜—šžœ�œ4�œ˜Tš�œ�œ
�˜š
œ˜Jš
œ<˜<šžœ�œ�œ˜(Jš�œE˜KJš
œ˜—Jšœ�œ
�œ�œ
˜ Jšžœ�œ�œ"˜FJšžœ�œ:˜Dšžœ�œ˜"Jš
œB˜BJš
œ˜—šžœ�œ�œ˜'Jš
œ:˜:Jš
œ˜—Jš
œ,˜,Jšœ�œ�œ�œ?˜yJš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜šž
œ˜Jšœ�œ˜J˜š�œ�œ�œ
�˜1J˜š�œ�œ
�˜Jšœ�œ!˜'Jšœ�œ/˜5Jšœ�œ.˜4Jšœ�œ�œ
˜$Jš�œ�œ
˜—Jš�œ
˜—J˜J˜—šžœ˜"š
�œ�œ
�œ�œ�œ�œ
�˜AJ˜0Jš�œ
˜—J˜—J˜—šžœ�œ4�œ˜Wš�œ�œ
�˜š
œ˜Jš
œ(˜(Jšœ�œ
˜#Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šž
œ�œ �œ˜Cš�œ�œ
�˜š
œ˜š
œ˜Jš
œ?˜?Jš
œ˜—Jš
œ8˜8Jšœ�œ˜#Jšœ-�œ
�œ
�œ
˜SJš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ �œ˜Fš�œ�œ
�˜š
œ˜Jš
œ#˜#Jšœ�œ
˜#Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ �œ˜MJš
œ#˜#Jš
œ˜J˜—šžœ�œ �œ˜PJš
œ&˜&Jš
œ˜J˜—šžœ�œ˜/š�œ�œ
�˜š
œ˜š�œ�˜Jš
œ9˜9šœ�œ�œ˜)Jšœ�œ-˜6Jšœ�œ-˜6Jš
œ.˜.Jš
œ.˜.Jš
œ4˜4Jš
œ˜Jš
œ˜Jš
œ˜—Jš�œ�œ
˜—Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ ˜9š�œ�œ
�˜š
œ˜Jš
œD˜D—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ ˜=š�œ�œ
�˜š
œ˜š�œ�˜š
œ˜Jš
œ,˜,Jš
œ,˜,J˜—š
œ˜š
žœ�œ�œ�œ�œ˜/š�œ
�œ˜Jš�œ�œ
�œ˜Jš�œ
�œ(˜2Jš
œ
˜
—Jš�œ
�œ˜Jš
œ˜—Jšœ�œ3˜<Jšœ�œ3˜<Jš
œ,˜,Jš
œ,˜,Jš
œ0˜0Jš
œ0˜0Jš
œ˜Jš
œ˜Jš
œ˜—Jš�œ�œ
˜—Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ ˜>š�œ�œ
�˜š
œ˜Jš
œP˜PJš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ ˜@š�œ�œ
�˜š
œ˜Jš
œP˜PJš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ�œ˜2Jš
œH™Hš�œ�œ
�˜š
œ˜Jš
œ8˜8Jš
œ˜Jš
œ˜š�œ�˜š
œ˜Jš
œ,˜,Jš
œ,˜,J˜—šœ�œ�œ˜)š
žœ�œ�œ�œ�œ˜/š�œ
�œ˜Jš�œ�œ
�œ˜Jš�œ
�œ(˜2Jš
œ
˜
—Jš�œ
�œ˜Jš
œ˜—Jšœ�œ3˜<Jšœ�œ3˜<Jš
œ,˜,Jš
œ,˜,Jš
œ0˜0Jš
œ0˜0Jš
œ˜Jš
œ˜Jš
œ˜—Jš�œ�œ
˜—Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ�œ˜<Jš
œ˜Jš
œ˜J˜—šžœ�œ�œ˜>š�œ�œ
�˜š
œ˜š
žœ�œ�œ�œ�œ˜,J™ì
Jš�œ˜Jš
œ˜—Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ,˜,Jš
œ˜Jš
œ˜Jš
œ:˜:Jš
œ:˜:Jš
œ,˜,Jš
œ4˜4Jš
œ7˜7Jš
œ7˜7š�œ˜	š�œ˜Jš
œs˜sš
�˜Jš
œZ˜ZJš
œB˜B—J˜
—š�œ˜Jš
œQ˜QJš
œQ˜QJš
œ?˜?Jš
œ?˜?Jš
œ˜—š�œ�œ�œ˜;Jš
œ)˜)Jš
œ˜Jš
œ˜—š�œ�œ�œ˜;Jš
œ)˜)Jš
œ˜Jš
œ˜—Jš
œ˜—Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš�œw�œ
�œ4˜·
Jš
œ!˜!Jš
œ!˜!Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—šžœ�œ˜)š�œ�œ
�˜š
œ˜Jšœ�œ˜'Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—š
ž
œ�œ�œ
�œ
�œ˜hJš�œ"˜'Jš
œ˜J˜—š
žœ�œ�œ
�œ
�œ-˜zJš�œ"˜'Jš
œ˜J˜—šžœ�œ�œ˜Kš�œ�œ
�˜š
œ˜Jš�œ"˜'Jš
œ˜—Jš�œ�œ˜$—Jš
œ˜J˜—Jš�œ
˜—…—H(`Ó