DIRECTORY
Imager, ImagerPath, SVPadGraphics, Real, RealFns, SV2d, SVLines2d, SVVector2d;

SVPadGraphicsImpl: CEDAR PROGRAM
IMPORTS Imager, ImagerPath, Real, RealFns, SVLines2d, SVVector2d
EXPORTS SVPadGraphics =

BEGIN

Path: TYPE = SV2d.Path;
Point2d: TYPE = SV2d.Point2d;
Polygon: TYPE = SV2d.Polygon;
Vector2d: TYPE = SV2d.Vector2d;

squareSide: REAL _ 6.0;
globalOutline: Imager.Trajectory;

ScreenToPad: PUBLIC PROC [screenPoint: Point2d, origin: Point2d, scalar: REAL _ 1] RETURNS [padPoint: Point2d] = {
padPoint[1] _ screenPoint[1] - origin[1];
padPoint[2] _ screenPoint[2] - origin[2];
padPoint _ SVVector2d.Scale[padPoint, 1/scalar];
};
PadToScreen: PUBLIC PROC [padPoint: Point2d, origin: Point2d, scalar: REAL _ 1] RETURNS [screenPoint: Point2d] = {
padPoint _ SVVector2d.Scale[padPoint, scalar];
screenPoint[1] _ padPoint[1] + origin[1];
screenPoint[2] _ padPoint[2] + origin[2];
};

MoveTo: PUBLIC PROC [dc: Imager.Context, padPoint: Point2d, origin: Point2d] = {
screenPoint: Point2d;
screenPoint _ PadToScreen[padPoint, origin];
globalOutline _ ImagerPath.MoveTo[[screenPoint[1], screenPoint[2]]];
};
DrawTo: PUBLIC PROC [dc: Imager.Context, padPoint: Point2d, origin: Point2d] = {
screenPoint: Point2d;
screenPoint _ PadToScreen[padPoint, origin];
globalOutline _ ImagerPath.LineTo[globalOutline, [screenPoint[1], screenPoint[2]]];
Imager.SetStrokeWidth[dc, 1];
Imager.SetStrokeEnd[dc, square];
Imager.MaskStrokeTrajectory[dc, globalOutline];
};
MirrorMoveTo: PUBLIC PROC [dc: Imager.Context, padPoint: Point2d, origin: Point2d] = {
screenPoint: Point2d;
padPoint[1] _ -padPoint[1];
screenPoint _ PadToScreen[padPoint, origin];
globalOutline _ ImagerPath.MoveTo[[screenPoint[1], screenPoint[2]]];
};
MirrorDrawTo: PUBLIC PROC [dc: Imager.Context, padPoint: Point2d, origin: Point2d] = {
screenPoint: Point2d;
padPoint[1] _ -padPoint[1];
screenPoint _ PadToScreen[padPoint, origin];
globalOutline _ ImagerPath.LineTo[globalOutline, [screenPoint[1], screenPoint[2]]];
Imager.SetStrokeWidth[dc, 1];
Imager.SetStrokeEnd[dc, square];
Imager.MaskStrokeTrajectory[dc, globalOutline];
};

DrawPathNeighborHood: PUBLIC PROC [dc: Imager.Context, path: Path, index: NAT, origin: Point2d] = {
DrawSquare[dc, squareSide, path[index], origin];
IF index>0 THEN {
MoveTo[dc, path[index-1], origin];
DrawTo[dc, path[index], origin];
};
IF index<path.len-1 THEN {
MoveTo[dc, path[index+1], origin];
DrawTo[dc, path[index], origin];
};
};
MirrorDrawPathNeighborHood: PUBLIC PROC [dc: Imager.Context, path: Path, index: NAT, origin: Point2d] = {
MirrorDrawSquare[dc, squareSide, path[index], origin];
IF index>0 THEN {
MirrorMoveTo[dc, path[index-1], origin];
MirrorDrawTo[dc, path[index], origin];
};
IF index<path.len-1 THEN {
MirrorMoveTo[dc, path[index+1], origin];
MirrorDrawTo[dc, path[index], origin];
};
};
DrawPolyNeighborHood: PUBLIC PROC [dc: Imager.Context, poly: Polygon, index: NAT, origin: Point2d] = {
indexPlusOne, indexMinusOne: NAT;
indexPlusOne _ IF index = poly.len-1 THEN 0 ELSE index + 1;
indexMinusOne _ IF index = 0 THEN poly.len-1 ELSE index - 1;
DrawSquare[dc, squareSide, poly[index], origin];
IF poly.len = 1 THEN RETURN;
MoveTo[dc, poly[indexPlusOne], origin];
DrawTo[dc, poly[index], origin];
IF poly.len = 2 THEN RETURN;
MoveTo[dc, poly[indexMinusOne], origin];
DrawTo[dc, poly[index], origin];
};
MirrorDrawPolyNeighborHood: PUBLIC PROC [dc: Imager.Context, poly: Polygon, index: NAT, origin: Point2d] = {
indexPlusOne, indexMinusOne: NAT;
indexPlusOne _ IF index = poly.len-1 THEN 0 ELSE index + 1;
indexMinusOne _ IF index = 0 THEN poly.len-1 ELSE index - 1;
MirrorDrawSquare[dc, squareSide, poly[index], origin];
IF poly.len = 1 THEN RETURN;
MirrorMoveTo[dc, poly[indexPlusOne], origin];
MirrorDrawTo[dc, poly[index], origin];
IF poly.len = 2 THEN RETURN;
MirrorMoveTo[dc, poly[indexMinusOne], origin];
MirrorDrawTo[dc, poly[index], origin];
};

DrawPath: PUBLIC PROC [dc: Imager.Context, path: Path, origin: Point2d, scalar: REAL _ 1] = {
outline: Imager.Trajectory;
screenPoint: Point2d;
IF path.len <= 1 THEN RETURN;
screenPoint _ PadToScreen[path[0], origin, scalar];
outline _ ImagerPath.MoveTo[[screenPoint[1], screenPoint[2]]];
FOR i: NAT IN [1..path.len) DO
screenPoint _ PadToScreen[path[i], origin, scalar];
outline _ ImagerPath.LineTo[outline, [screenPoint[1], screenPoint[2]]];
ENDLOOP;
Imager.SetStrokeWidth[dc, 1];
Imager.SetStrokeEnd[dc, round];
Imager.MaskStrokeTrajectory[dc, outline];
};
DrawPolygon: PUBLIC PROC [dc: Imager.Context, poly: Polygon, origin: Point2d, scalar: REAL _ 1] = {
screenPoint0, screenPoint1, screenPoint2: Point2d;
IF poly.len <= 1 THEN RETURN;
screenPoint0 _ screenPoint1 _ PadToScreen[poly[0], origin, scalar];
FOR i: NAT IN [1..poly.len) DO
screenPoint2 _ PadToScreen[poly[i], origin, scalar];
LineSandwich[dc, screenPoint1[1], screenPoint1[2], screenPoint2[1], screenPoint2[2]];
screenPoint1 _ screenPoint2;
ENDLOOP;
LineSandwich[dc, screenPoint1[1], screenPoint1[2], screenPoint0[1], screenPoint0[2]];
};

CrossHairs: PUBLIC PROC [dc: Imager.Context, origin: Point2d] = {
leftPoint, rightPoint, topPoint, bottomPoint, screenPoint: Point2d;
leftPoint _ [-1000, 0];
rightPoint _ [1000, 0];
topPoint _ [0, 1000];
bottomPoint _ [0, -1000];
screenPoint _ PadToScreen[leftPoint, origin];
globalOutline _ ImagerPath.MoveTo[[screenPoint[1], screenPoint[2]]];
screenPoint _ PadToScreen[rightPoint, origin];
globalOutline _ ImagerPath.LineTo[globalOutline, [screenPoint[1], screenPoint[2]]];
Imager.SetStrokeWidth[dc, 1];
Imager.SetStrokeEnd[dc, square];
Imager.MaskStrokeTrajectory[dc, globalOutline];

screenPoint _ PadToScreen[topPoint, origin];
globalOutline _ ImagerPath.MoveTo[[screenPoint[1], screenPoint[2]]];
screenPoint _ PadToScreen[bottomPoint, origin];
globalOutline _ ImagerPath.LineTo[globalOutline, [screenPoint[1], screenPoint[2]]];
Imager.SetStrokeWidth[dc, 1];
Imager.SetStrokeEnd[dc, square];
Imager.MaskStrokeTrajectory[dc, globalOutline];
};

DrawSquare: PUBLIC PROC [dc: Imager.Context, side: REAL, center: Point2d, origin: Point2d] = {
delta: REAL _ side/2.0;
screenPoint: Point2d;
square: Imager.Trajectory;
screenPoint _ PadToScreen[[center[1]-delta, center[2]-delta], origin];
square _ ImagerPath.MoveTo[[screenPoint[1], screenPoint[2]]];
screenPoint _ PadToScreen[[center[1]-delta, center[2]+delta], origin];
square _ ImagerPath.LineTo[square, [screenPoint[1], screenPoint[2]]];
screenPoint _ PadToScreen[[center[1]+delta, center[2]+delta], origin];
square _ ImagerPath.LineTo[square, [screenPoint[1], screenPoint[2]]];
screenPoint _ PadToScreen[[center[1]+delta, center[2]-delta], origin];
square _ ImagerPath.LineTo[square, [screenPoint[1], screenPoint[2]]];
Imager.SetStrokeWidth[dc, 1];
Imager.MaskStrokeTrajectory[dc, square, TRUE];
};
MirrorDrawSquare: PUBLIC PROC [dc: Imager.Context, side: REAL, center: Point2d, origin: Point2d] = {
delta: REAL _ side/2.0;
screenPoint: Point2d;
square: Imager.Trajectory;
center[1] _ -center[1];
screenPoint _ PadToScreen[[center[1]-delta, center[2]-delta], origin];
square _ ImagerPath.MoveTo[[screenPoint[1], screenPoint[2]]];
screenPoint _ PadToScreen[[center[1]-delta, center[2]+delta], origin];
square _ ImagerPath.LineTo[square, [screenPoint[1], screenPoint[2]]];
screenPoint _ PadToScreen[[center[1]+delta, center[2]+delta], origin];
square _ ImagerPath.LineTo[square, [screenPoint[1], screenPoint[2]]];
screenPoint _ PadToScreen[[center[1]+delta, center[2]-delta], origin];
square _ ImagerPath.LineTo[square, [screenPoint[1], screenPoint[2]]];
Imager.SetStrokeWidth[dc, 1];
Imager.MaskStrokeTrajectory[dc, square, TRUE];
};

Draw2dVector: PUBLIC PROC [dc: Imager.Context, vec: Vector2d, at: Point2d, origin: Point2d] = {
unitVec, vec50: Vector2d;
mag: REAL;
mag _ RealFns.SqRt[vec[1]*vec[1] + vec[2]*vec[2]];
unitVec[1] _ vec[1]/mag;
unitVec[2] _ vec[2]/mag;
vec50[1] _ unitVec[1]*50;
vec50[2] _ unitVec[2]*50;
MoveTo[dc, at, origin];
DrawTo[dc, [at[1]+vec50[1], at[2]+vec50[2]], origin];
}; -- end of Draw2dVector

Circle: PUBLIC PROC [dc: Imager.Context, originX, originY, radius: REAL] = {
cosine, sine, rcosine, rsine, lastRsine, lastRcosine: REAL;
z: REAL = 0.5;
deltaTheta, theta, lastTheta: REAL;
numberOfTimesGoesIn: NAT;
cosine _ 1-z/radius;
sine _ RealFns.SqRt[1-cosine*cosine];
deltaTheta _ RealFns.ArcTanDeg[sine, cosine];
numberOfTimesGoesIn _ Real.Fix[45.0/deltaTheta];
deltaTheta _ 45.0/(numberOfTimesGoesIn + 1);
lastTheta _ 0;
lastRsine _ 0;
lastRcosine _ radius;

FOR i: NAT IN [1..numberOfTimesGoesIn+1] DO
theta _ lastTheta + deltaTheta;
rsine _ radius*RealFns.SinDeg[theta];
rcosine _ radius*RealFns.CosDeg[theta];
DrawLine[dc, originX + lastRcosine, originY + lastRsine,
 originX + rcosine,    originY + rsine];
DrawLine[dc, originX + lastRsine, originY + lastRcosine,
 originX + rsine, originY + rcosine];
DrawLine[dc, originX + lastRcosine, originY - lastRsine,
 originX + rcosine, originY - rsine];
DrawLine[dc, originX + lastRsine, originY - lastRcosine,
 originX + rsine, originY - rcosine];
DrawLine[dc, originX - lastRcosine, originY + lastRsine,
 originX - rcosine, originY + rsine];
DrawLine[dc, originX - lastRsine, originY + lastRcosine,
 originX - rsine, originY + rcosine];
DrawLine[dc, originX - lastRcosine, originY - lastRsine,
 originX - rcosine, originY - rsine];
DrawLine[dc, originX - lastRsine, originY - lastRcosine,
 originX - rsine, originY - rcosine];
lastTheta _ theta;
lastRsine _ rsine;
lastRcosine _ rcosine;
ENDLOOP;
}; -- end of Circle

centerLine: SV2d.TrigLine _ SVLines2d.CreateEmptyTrigLine[];

LineSandwich: PUBLIC PROC [dc: Imager.Context, fromX, fromY, toX, toY: REAL] = {
leftFirst, leftSecond, rightFirst, rightSecond: Point2d;
SVLines2d.FillTrigLineFromPoints[[fromX, fromY], [toX, toY], centerLine];
leftFirst _  SVLines2d.PointLeftOfTrigLine[1, [fromX, fromY], centerLine];
leftSecond _ SVLines2d.PointLeftOfTrigLine[1, [toX, toY], centerLine];
rightFirst _ SVVector2d.Add[SVVector2d.Sub[[fromX, fromY], leftFirst], [fromX, fromY]];
rightSecond _ SVVector2d.Add[SVVector2d.Sub[[toX, toY], leftSecond], [toX, toY]];
Imager.SetColor[dc, Imager.black]; -- black
globalOutline _ ImagerPath.MoveTo[[leftFirst[1], leftFirst[2]]];
globalOutline _ ImagerPath.LineTo[globalOutline, [leftSecond[1], leftSecond[2]]];
Imager.SetStrokeWidth[dc, 1];
Imager.SetStrokeEnd[dc, butt];
Imager.MaskStrokeTrajectory[dc, globalOutline];
Imager.SetColor[dc, Imager.white]; -- white
globalOutline _ ImagerPath.MoveTo[[fromX, fromY]];
globalOutline _ ImagerPath.LineTo[globalOutline, [toX, toY]];
Imager.MaskStrokeTrajectory[dc, globalOutline];
Imager.SetColor[dc, Imager.black]; -- black
globalOutline _ ImagerPath.MoveTo[[rightFirst[1], rightFirst[2]]];
globalOutline _ ImagerPath.LineTo[globalOutline, [rightSecond[1], rightSecond[2]]];
Imager.MaskStrokeTrajectory[dc, globalOutline];
};

DrawLine: PRIVATE PROC [dc: Imager.Context, fromX, fromY, toX, toY: REAL] = {
globalOutline _ ImagerPath.MoveTo[[fromX, fromY]];
globalOutline _ ImagerPath.LineTo[globalOutline, [toX, toY]];
Imager.SetStrokeWidth[dc, 1];
Imager.SetStrokeEnd[dc, square];
Imager.MaskStrokeTrajectory[dc, globalOutline];
};

END.

bFile: SVPadGraphicsImpl.mesa
Last edited by Bier on May 31, 1984 3:29:44 pm PDT
Author: Eric Bier on February 4, 1987 7:32:14 pm PST
Contents: Simple 2d graphics package for the scratchpad
origin is the pad origin in screen coordintates
draw three points and 2 edges corresponding to the neighborhood of path[index];
path is in pad coordinates.
if index is one of the two ends of the path then draw 2 points and 1 edge.
draw three points and 2 edges corresponding to the neighborhood of path[index];
path is in pad coordinates.
if index is one of the two ends of the path then draw 2 points and 1 edge.
draw three points and 2 edges corresponding to the neighborhood of poly[index];
poly is in pad coordinates.
poly.len = 2 then draw both points and the edge joining them.
if poly.len = 1 then just draw a point.
draw three points and 2 edges corresponding to the neighborhood of poly[index];
poly is in pad coordinates.
poly.len = 2 then draw both points and the edge joining them.
if poly.len = 1 then just draw a point.
poly is in Pad coordinates
transform each point to screen coordinates and draw using Imager.
 _ Graphics.NewPath[path.len];
poly is in Pad coordinates
transform each point to screen coordinates and draw using Imager.
square: Graphics.Path _ Graphics.NewPath[4];
square: Graphics.Path _ Graphics.NewPath[4];
Draw 1/8 of a circle carefully and get the rest by mirroring around vertical, horizontal, and 45 degree axes.
as an exercise in flatness tests, I declared that a straight line adequately approximates an arc of the circle if the maximum deviation of the line from the circle is less than z pixel heights.  Given a circle of radius r (r in pixel heights), an arc of angle theta, starts and ends on a line of distance r*cos(theta/2) from the origin, reaches a maximum distance r-r*cos(theta/2) from this line and returns.  Hence, we must chose theta so that r*(1-cos(theta/2) < z.  Theta is clearly less than 90 degrees so 0 < cos(theta/2) < 1, hence 0 < (1 - cos(theta/2)) < 1.  Also, r >0, so
(1-cos(theta/2) < z/r.  -cos(theta/2) < z/r - 1.  cos(theta/2) > (1 - z/r).  Theta/2 < ArcCos[1 - z/r].  Theta < 2*ArcCos[1 - z/r].  Let z = 0.5.
Now find a deltaTheta smaller than this which goes evenly into 45 degrees.
Draw three parallel lines, 2 black with 1 white in between so that the total width is three screen dots.  This requires that we calculate the points with are 1 unit from the given central line segment and normal to that line segment.
Find the left and right segments given the center segment
Now draw the left line
Now draw the center line
Finally, draw the right line
Just a private utility used by Circle.
ส	ฎ–

"cedar" style˜Iheadš
œ™Iprocš
œ2™2Lš
œ4™4Lš
œ7™7L˜š
ฯk	˜	Lš
œN˜N—L˜Lšœ
˜ Lšœ9˜@Lšœ˜L˜Lš
˜˜Lš
œ˜Lšœ	œ˜Lš
œ˜Lšœ
œ˜L˜Lš
œ˜L˜!L˜—šฯnœœ
œ;œ˜rLš
œ/™/Lš
œ)˜)Lš
œ)˜)Lš
œ0˜0Lš
œ˜—šžœœ
œ8œ˜rLš
œ.˜.Lš
œ)˜)Lš
œ)˜)Lš
œ˜—L˜šžœœ
œ=˜PLš
œ˜Lš
œ,˜,Lš
œD˜DLš
œ˜—šžœœ
œ=˜PLš
œ˜Lš
œ,˜,Lš
œS˜SJ˜Jš
œ ˜ Jš
œ/˜/Lš
œ˜—šžœœ
œ=˜VLš
œ˜Lš
œ˜Lš
œ,˜,Lš
œD˜DLš
œ˜—šžœœ
œ=˜VLš
œ˜Lš
œ˜Lš
œ,˜,Lš
œS˜SJ˜Jš
œ ˜ Jš
œ/˜/Lš
œ˜—L˜šžœœ
œ)œ˜cLš
œO™OLš
œ™Lš
œJ™JLš
œ0˜0šœ	œ˜Lš
œ"˜"Lš
œ ˜ Lš
œ˜—šœœ˜Lš
œ"˜"Lš
œ ˜ Lš
œ˜—Lš
œ˜—šžœœ
œ)œ˜iLš
œO™OLš
œ™Lš
œJ™JLš
œ6˜6šœ	œ˜Lš
œ(˜(Lš
œ&˜&Lš
œ˜—šœœ˜Lš
œ(˜(Lš
œ&˜&Lš
œ˜—Lš
œ˜—šžœœ,œ˜fLš
œO™OLš
œ™Lš
œ=™=Lš
œ'™'Lš
œ!˜!Lš
œ;˜;Lš
œ<˜<Lš
œ0˜0Lš
œ˜Lš
œ'˜'Lš
œ ˜ Lš
œ˜Lš
œ(˜(Lš
œ ˜ Lš
œ˜—šžœœ,œ˜lLš
œO™OLš
œ™Lš
œ=™=Lš
œ'™'Lš
œ!˜!Lš
œ;˜;Lš
œ<˜<Lš
œ6˜6Lš
œ˜Lš
œ-˜-Lš
œ&˜&Lš
œ˜Lš
œ.˜.Lš
œ&˜&Lš
œ˜—L˜šžœœ
œ;œ	˜]Lš
œ™Lš
œA™ALš
œ˜Lš
œ™Lš
œ˜Lšœœ
œ
˜Lš
œ3˜3Lš
œ>˜>šœœ
œ˜Lš
œ3˜3Lš
œG˜G—Lšœ
˜J˜Jš
œ˜Jš
œ)˜)Lš
œ˜—šžœœ
œK˜cLš
œ™Lš
œA™ALš
œ2˜2Lšœœ
œ
˜Lš
œC˜Cšœœ
œ˜Lš
œ4˜4Lš
œU˜ULš
œ˜—Lšœ
˜Lš
œU˜ULš
œ˜—L˜šž
œœ
œ*˜ALš
œC˜CLš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ-˜-Lš
œD˜DLš
œ.˜.Lš
œS˜SJ˜Jš
œ ˜ Jš
œ/˜/J˜Lš
œ,˜,Lš
œD˜DLš
œ/˜/Lš
œS˜SJ˜Jš
œ ˜ Jš
œ/˜/Lš
œ˜—L˜šž
œœ
œœ'˜^Lšœœ˜Lš
œ˜Lš
œ˜Lš
œ,™,Lš
œF˜FLš
œ=˜=Lš
œF˜FLš
œE˜ELš
œF˜FLš
œE˜ELš
œF˜FLš
œE˜EJ˜Jšœ(œ˜.Lš
œ˜—šžœœ
œœ'˜dLšœœ˜Lš
œ˜Lš
œ˜Lš
œ,™,Lš
œ˜Lš
œF˜FLš
œ=˜=Lš
œF˜FLš
œE˜ELš
œF˜FLš
œE˜ELš
œF˜FLš
œE˜EJ˜Jš
œ.˜.Lš
œ˜—L˜šžœœ
œF˜_Lš
œ˜Lšœœ
˜
Lš
œ2˜2Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ5˜5Lš
œ˜—šžœœ
œ0œ˜LJš
œm™mJš
œล™ลJš
œ‘
™‘
Jšœ6œ
˜;Jšœœ˜Jšœœ
˜#Jšœœ
˜Jš
œ˜Jš
œ%˜%Jš
œ-˜-Jš
œJ™JJš
œ0˜0Jš
œ,˜,Jš
œ˜Jš
œ˜Jš
œ˜J˜šœœ
œ˜+Jš
œ˜Jš
œ%˜%Jš
œ'˜'Jš
œ8˜8Jš
œ(˜(Jš
œ8˜8Jš
œ%˜%Jš
œ8˜8Jš
œ%˜%Jš
œ8˜8Jš
œ%˜%Jš
œ8˜8Jš
œ%˜%Jš
œ8˜8Jš
œ%˜%Jš
œ8˜8Jš
œ%˜%Jš
œ8˜8Jš
œ%˜%Jš
œ˜Jš
œ˜Jš
œ˜—Jšœ
˜Jš
œ˜—Jšœ<ž
˜=šžœœ
œ.œ˜Pš
œ8˜8Jš
œ้
™้
Jš
œ9™9—Jš
œI˜IJš
œJ˜JJš
œF˜FJš
œW˜Wš
œQ˜QJš
œ™—Jš
œ+˜+Jš
œ@˜@Jš
œQ˜QJ˜Jš
œ˜š
œ/˜/Jš
œ™—Jš
œ+˜+Jš
œ2˜2Jš
œ=˜=š
œ/˜/Jš
œ™—Jš
œ+˜+Jš
œB˜BJš
œS˜SJš
œ/˜/Jš
œ˜—šžœœ.œ˜M™&Jš
œ2˜2Jš
œ=˜=J˜Jš
œ ˜ Jš
œ/˜/Jš
œ˜——L˜Lšœ
˜—…—+V?f