DIRECTORY
Complex USING [Mul, VEC],
Cubic USING [Bezier],
FitBasic USING [Handle, LinkHandle, SampleHandle, SListHandle, TrajHandle],
FitIO USING [Context, Feedback],
FitState USING [GetClosed, Handle],
FitStateUtils USING [ForAllLinks, ForAllOtherSLists, ForAllOtherTrajs, ForAllSamples, LinkProc, SampleProc, SListProc, TrajProc],
Imager USING [Context, DoSave, MaskFill, MaskStroke, MaskStrokeTrajectory, MaskVector, SetColor, SetStrokeEnd, SetStrokeWidth, SetXY, Trans, white],
ImagerPath USING [CurveTo, LineTo, MapTrajectoryList, MoveTo, PathProc, Trajectory],
IO USING [char, Close, CR, int, Put, real, rope, SP, STREAM],
RealFns USING [],
Rope USING [ROPE],
Vector USING [Unit];

FitIOImpl: CEDAR PROGRAM
IMPORTS Imager, ImagerPath, IO, Complex, Vector, FitStateUtils, FitState 
EXPORTS FitIO = { OPEN FitIO;

Trajectory: TYPE ~ ImagerPath.Trajectory;

Handle: TYPE = FitState.Handle;
SetFeedback: PUBLIC PROC[ctx: Context, feedback: Feedback] = {
ctx.feedback _ feedback;
IF ctx.logActions THEN {	--print feedback
SELECT feedback.color FROM
Imager.white => PrintRope[ctx, "white "];
ENDCASE=> PrintRope[ctx, "black"];
PrintLine[ctx, "FB.color"];
PrintReal[ctx, feedback.sampleSize]; PrintLine[ctx, "Fit.sampleSize"];
PrintReal[ctx, feedback.jointSize]; PrintLine[ctx, "Fit.jointSize"];
PrintReal[ctx, feedback.nodeLength]; PrintLine[ctx, "Fit.nodeLength"];
PrintReal[ctx, feedback.nodeLineWidth]; PrintLine[ctx, "Fit.nodeLineWidth"];
PrintReal[ctx, feedback.lineWidth]; PrintLine[ctx, "Fit.lineWidth"];
};
};

DrawSamples: PUBLIC PROC [ctx: Context, handle: Handle, all: BOOLEAN _ FALSE, fill: BOOLEAN _ FALSE] = {
list: LIST OF Trajectory;
traj: Trajectory _ PathFromSList[ctx, handle.slist];
IF traj=NIL THEN RETURN ELSE list _ CONS[traj,list];
Imager.SetColor[ctx.imager, ctx.feedback.color];
IF all THEN {
makeList: FitStateUtils.SListProc = {list _ CONS[PathFromSList[ctx, slist],list]};
FitStateUtils.ForAllOtherSLists[handle,makeList];
};
IF fill THEN MaskFill[ctx,list]
ELSE
IF FitState.GetClosed[handle] THEN MaskStrokeClosed[ctx,list]
ELSE MaskStroke[ctx,list];
IF ctx.logActions THEN PrintLine[ctx, "\n"];
};

DrawContour: PUBLIC PROC [ctx: Context, handle: Handle, all: BOOLEAN _ FALSE, fill: BOOLEAN _ FALSE] = {
traj: Trajectory _ PathFromTraj[ctx, handle.traj];
list: LIST OF Trajectory;
IF traj=NIL THEN RETURN ELSE list _ CONS[traj,list];
Imager.SetColor[ctx.imager, ctx.feedback.color];
IF all THEN {
makeList: FitStateUtils.TrajProc = {list _ CONS[PathFromTraj[ctx, traj, fill],list]};
FitStateUtils.ForAllOtherTrajs[handle,makeList];
};
IF fill THEN MaskFill[ctx, list]
ELSE
IF FitState.GetClosed[handle] OR all THEN MaskStrokeClosed[ctx, list]
ELSE MaskStroke[ctx, list];
IF ctx.logActions THEN PrintLine[ctx, "\n"];
};

DrawCubic: PUBLIC PROC[ctx: Context, cubic: Cubic.Bezier] = {
list: LIST OF Trajectory;
traj: Trajectory _ MoveTo[ctx, cubic.b0];
traj _ CurveTo[ctx, traj,cubic.b1,cubic.b2,cubic.b3];
MaskStroke[ctx, CONS[traj,list]];
};

PathFromSList: PROC [ctx: Context, slist: FitBasic.SListHandle] RETURNS [path: Trajectory] = {
first: BOOLEAN _ TRUE;
do: FitStateUtils.SampleProc = {
IF first THEN {path _ MoveTo[ctx, s.xy]; first _ FALSE}
ELSE path_ LineTo[ctx, path,s.xy];
};
FitStateUtils.ForAllSamples[slist, do];
IF ctx.logActions AND path#NIL THEN PrintLine[ctx, "\n"];
RETURN[path];
};

PathFromTraj: PROC [ctx: Context, traj: FitBasic.TrajHandle, moveToNext: BOOLEAN _ FALSE] RETURNS [path: Trajectory] = {
first: BOOLEAN _ TRUE;
do: FitStateUtils.LinkProc = {
IF first THEN {path _ MoveTo[ctx, l.cubic.b0, moveToNext]; first _ FALSE};
path _ CurveTo[ctx, path,l.cubic.b1,l.cubic.b2,l.cubic.b3];
};
FitStateUtils.ForAllLinks[traj, do];
IF ctx.logActions AND path#NIL THEN PrintLine[ctx, "\n"];
};

MarkSamples: PUBLIC PROC [ctx: Context, handle: Handle, all: BOOLEAN _ FALSE] = {
markSample: FitStateUtils.SampleProc = {MarkSample[ctx, s]};
markSamples: FitStateUtils.SListProc = {FitStateUtils.ForAllSamples[slist, markSample]};
[] _ markSamples[handle.slist];
IF all THEN FitStateUtils.ForAllOtherSLists[handle, markSamples];
IF ctx.logActions THEN PrintLine[ctx, "\n"];
};

MarkNodes: PUBLIC PROC [ctx: Context, handle: Handle, all: BOOLEAN _ FALSE] = {
markNode: FitStateUtils.SampleProc = {MarkNode[ctx, s]};
markNodes: FitStateUtils.SListProc = {FitStateUtils.ForAllSamples[slist, markNode]};
[] _ markNodes[handle.slist];
IF all THEN FitStateUtils.ForAllOtherSLists[handle, markNodes];
IF ctx.logActions THEN PrintLine[ctx, "\n"];
};

MarkJoints: PUBLIC PROC [ctx: Context, handle: Handle, all: BOOLEAN _ FALSE] ={
--joints between the cubic pieces
do: FitStateUtils.TrajProc = {MarkTrajJoints[ctx, traj]};
[] _ MarkTrajJoints[ctx, handle.traj];
IF all THEN FitStateUtils.ForAllOtherTrajs[handle, do];
IF ctx.logActions THEN PrintLine[ctx, "\n"];
};

MarkTrajJoints: PROC[ctx: Context, traj: FitBasic.TrajHandle] = {
first: BOOLEAN _ TRUE;
do: FitStateUtils.LinkProc = {
IF first THEN {MarkJoint[ctx, l.cubic.b0]; first _ FALSE};
MarkJoint[ctx, l.cubic.b3];
};
FitStateUtils.ForAllLinks[traj, do];
IF ctx.logActions THEN PrintLine[ctx, "\n"];
};



MarkNode: PUBLIC PROC [ctx: Context, s: FitBasic.SampleHandle] = {
pt: Complex.VEC _ MagnifyPoint[ctx, s.xy];
drawProc: PROC = {
drawTan: PROC[t: Complex.VEC, d: REAL] = {
t _ Complex.Mul[Vector.Unit[t],[0,d]];
IF t = [0,0] THEN {  --draw a box
w: REAL _ d/2.0;
path: ImagerPath.PathProc ~ {
moveTo[[-w,-w]]; lineTo[[-w,+w]]; lineTo[[+w,+w]]; lineTo[[+w,-w]];
};
Imager.MaskStroke[context: ctx.imager, path: path, closed: TRUE];
}
ELSE {  --draw a line
Imager.MaskVector[ctx.imager, [-t.x,-t.y], [t.x,t.y]];
};
};
Imager.SetXY[ctx.imager, pt];
Imager.Trans[ctx.imager];
Imager.SetStrokeWidth[ctx.imager, ctx.feedback.nodeLineWidth];
drawTan[t: s.tanIn, d: ctx.feedback.nodeLength];
drawTan[t: s.tanOut, d: ctx.feedback.nodeLength*1.5];
IF s.jointType=forced THEN {  --draw diamond dot
w: REAL _ ctx.feedback.nodeLength/2.0;
path: ImagerPath.PathProc ~ {
moveTo[[-w, 0]]; lineTo[[0,w]]; lineTo[[w,0]]; lineTo[[0,-w]];
};
Imager.MaskStroke[context: ctx.imager, path: path, closed: TRUE];
Imager.MaskFill[context: ctx.imager, path: path];
};
};
IF s.jointType=none THEN RETURN;
Imager.DoSave[ctx.imager, drawProc];
IF ctx.logActions THEN {
PrintPoint[ctx, pt];
PrintPoint[ctx, s.tanIn];
PrintPoint[ctx, s.tanOut];
IF s.jointType=forced THEN PrintRope[ctx, "Fit.forcedJoint "] ELSE PrintRope[ctx, "Fit.joint "];
};
};

MarkSample: PUBLIC PROC [ctx: Context, s: FitBasic.SampleHandle] = {
size: REAL _ ctx.feedback.sampleSize;
pt: Complex.VEC _ MagnifyPoint[ctx, s.xy];
draw: PROC = {
dot: ImagerPath.PathProc ~ { moveTo[[0, 0]] };
Imager.SetXY[ctx.imager, pt];
Imager.Trans[ctx.imager];
Imager.SetStrokeWidth[ctx.imager, size];
Imager.SetStrokeEnd[ctx.imager, round];
Imager.MaskStroke[ctx.imager, dot];
};
Imager.DoSave[ctx.imager, draw];
IF ctx.logActions THEN {PrintPoint[ctx, pt]; PrintRope[ctx, "Fit.mark "]};
};

MarkJoint: PUBLIC PROC[ctx: Context, pt: Complex.VEC] = {
size: REAL _ ctx.feedback.jointSize;
dot: ImagerPath.PathProc ~ { moveTo[pt] };
pt _ MagnifyPoint[ctx, pt];
Imager.SetStrokeWidth[ctx.imager, size];
Imager.SetStrokeEnd[ctx.imager, round];
Imager.MaskStroke[ctx.imager, dot];
IF ctx.logActions THEN {PrintPoint[ctx, pt]; PrintRope[ctx, "Fit.joint "]};
};

MoveTo: PROC[ctx: Context, p: Complex.VEC, moveToNext: BOOLEAN _ FALSE]  RETURNS [path: Trajectory]= {
p _ MagnifyPoint[ctx, p];
path _ ImagerPath.MoveTo[[p.x,p.y]];
IF ctx.logActions THEN {
PrintPoint[ctx, p];
IF moveToNext THEN PrintRope[ctx, "Fit.movetonext "]
ELSE PrintRope[ctx, "Fit.moveto "]};
RETURN[path];
};

LineTo: PROC[ctx: Context, path: Trajectory, p: Complex.VEC] RETURNS [Trajectory]= {
p _ MagnifyPoint[ctx, p];
path _ ImagerPath.LineTo[path, [p.x,p.y]];
IF ctx.logActions THEN {PrintPoint[ctx, p]; PrintRope[ctx, "Fit.lineto "]};
RETURN[path];
};

CurveTo: PROC[ctx: Context, path: Trajectory, p1,p2,p3: Complex.VEC] RETURNS [Trajectory] = {
p1 _ MagnifyPoint[ctx, p1];
p2 _ MagnifyPoint[ctx, p2];
p3 _ MagnifyPoint[ctx, p3];
path _ ImagerPath.CurveTo[path,[p1.x,p1.y],[p2.x,p2.y],[p3.x,p3.y]];
IF ctx.logActions THEN {
PrintPoint[ctx, p1];
PrintPoint[ctx, p2];
PrintPoint[ctx, p3];
PrintLine[ctx, "Fit.curveto "];
};
RETURN[path];
};

MaskStroke: PROC[ctx: Context, list: LIST OF Trajectory] = {
width: REAL _ ctx.feedback.lineWidth;
count: INT _ 0;
Imager.SetStrokeWidth[ctx.imager, width];
FOR l: LIST OF Trajectory _ list, l.rest UNTIL l=NIL DO
Imager.MaskStrokeTrajectory[ctx.imager,l.first];
count _ count+1;
ENDLOOP; 
IF ctx.logActions THEN {PrintInt[ctx, count]; PrintLine[ctx, "Fit.maskstroke"]};
};

MaskStrokeClosed: PROC[ctx: Context, list: LIST OF Trajectory] = {
width: REAL _ ctx.feedback.lineWidth;
count: INT _ 0;
Imager.SetStrokeWidth[ctx.imager, width];
FOR l: LIST OF Trajectory _ list, l.rest UNTIL l=NIL DO
Imager.MaskStrokeTrajectory[ctx.imager,l.first, TRUE];
count _ count+1;
ENDLOOP; 
IF ctx.logActions THEN {PrintInt[ctx, count]; PrintLine[ctx, "Fit.maskstrokeclosed"]};
};

MaskFill: PROC[ctx: Context, list: LIST OF Trajectory] = {
path: ImagerPath.PathProc ~ {
ImagerPath.MapTrajectoryList[list, moveTo, lineTo, curveTo, conicTo, arcTo];
};
Imager.MaskFill[ctx.imager, path];
IF ctx.logActions THEN { 
count: INT _ 0;
FOR l: LIST OF Trajectory _ list, l.rest UNTIL l=NIL DO
count _ count+1;
ENDLOOP; 
PrintInt[ctx, count];
PrintLine[ctx, "Fit.maskfill"];
};
};

NoLog: PUBLIC SIGNAL = CODE;

StartLog: PUBLIC PROC [ctx: Context, stream: IO.STREAM _ NIL] = {
IF ctx.log#NIL THEN IO.Close[ctx.log];
ctx.log _ stream;
ctx.logActions _ TRUE;
};

StopLog: PUBLIC PROC[ctx: Context, close: BOOLEAN _ TRUE] = {
IF close THEN IO.Close[ctx.log];
ctx.logActions _ FALSE;
};

PrintReal: PROC[ctx: Context, r: REAL] = {OPEN IO; Put[ctx.log,real[r],char[SP]]};
PrintRope: PROC[ctx: Context, s: Rope.ROPE] = {OPEN IO; Put[ctx.log,rope[s]]};
PrintLine: PROC[ctx: Context, s: Rope.ROPE] = {OPEN IO; Put[ctx.log,rope[s],char[CR]]};
PrintInt: PROC[ctx: Context, i: INT] = {OPEN IO; Put[ctx.log,int[i],char[SP]]};
PrintPoint: PROC[ctx: Context, pt: Complex.VEC] = {PrintReal[ctx, pt.x]; PrintReal[ctx, pt.y]};


MagnifyPoint: PUBLIC PROC [ctx: Context, p: Complex.VEC] RETURNS[Complex.VEC] = {
--magnify and position
vt: Complex.VEC;
vt.x _ p.x*ctx.magnify+ctx.position.x;
vt.y _ p.y*ctx.magnify+ctx.position.y;
RETURN[vt]
};

UnMagnifyPoint: PUBLIC PROC [ctx: Context, p: Complex.VEC] RETURNS[Complex.VEC] = {
--undo magnify and position
vt: Complex.VEC;
vt.x _ (p.x-ctx.position.x)/ctx.magnify;
vt.y _ (p.y-ctx.position.y)/ctx.magnify;
RETURN[vt]
};


}.
0FitIOImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Maureen Stone March 14, 1985 6:25:19 pm PST
Doug Wyatt, September 5, 1985 2:24:33 pm PDT
treat samples as vertices of a polygon or a broken line
treat samples as vertices of a polygon or a broken line
convert my trajectory to an imager.trajectory
FeedbackRec: TYPE=RECORD [
color: Imager.Color _ black,
sampleSize: REAL _ 1,
jointSize: REAL _ 2,
nodeLength: REAL _ 2,
nodeLineWidth: REAL _ 0,
lineWidth: REAL _ 0	--for DrawSamples and DrawContour
];

Imager.MaskRectangle[ctx.imager,pt.x-size/2,pt.y-size/2,size,size];
Imager.MaskRectangle[ctx.imager,pt.x,pt.y,size,size];
IF stream=NIL uses previous stream.  Otherwise, closes previous stream (if any) and sets current output stream to stream.
IF close=FALSE just disables logging.
Κ·˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ+™+K™,—K˜š
Οk	˜	Kšœžœžœ˜Kšœžœ
˜Kšœ	žœ=˜KKšœžœ˜ Kšœ	žœ˜#Kšœžœn˜
Kšœžœˆ
˜”
KšœžœD˜TKš
žœ
žœžœžœžœ˜=Kšœžœ˜Kšœžœžœ˜Kšœžœ˜—K˜KšΠbl	œžœ
ž˜Kšžœžœ+˜IKšžœžœ˜K˜Kšœžœ˜)K˜Kšœžœ˜šΟnœžœ
žœ&˜>Kš
œ˜šžœžœΟc˜)šžœž˜K˜)Kšžœ˜"—K˜K˜FK˜DK˜FKš
œL˜LKš
œD˜DK˜—K˜K˜—š œžœ%žœžœžœžœ˜hKš
‘7™7Kšœžœ
žœ˜Kš
œ4˜4Kšžœžœ
žœ
žœ
žœžœ˜4K˜0šžœžœ˜
Kšœ,žœ"˜RK˜1Kš
œ˜—Kšžœžœ˜š
ž˜Kšžœžœ˜=Kšžœ˜—Kšžœžœ˜,K˜K˜—š œžœ%žœžœžœžœ˜hKš
œ2˜2Kšœžœ
žœ˜Kšžœžœ
žœ
žœ
žœžœ˜4K˜0šžœžœ˜
Kšœ+žœ&˜UK˜0Kš
œ˜—Kšžœžœ˜ š
ž˜Kšžœžœžœ˜EKšžœ˜—Kšžœžœ˜,K˜K˜—š 	œžœ'˜=Kšœžœ
žœ˜Kš
œ)˜)Kš
œ5˜5Kšœžœ
˜!K˜K˜—š 
œžœ-žœ˜^Kš
‘7™7Kšœžœžœ
˜˜ Kšžœžœ$žœ
˜7Kšžœ˜"K˜—K˜'Kšžœžœžœ
žœ˜9Kšžœ˜
K˜K˜—š
 œžœ7žœžœžœ˜xKš
‘-™-Kšœžœžœ
˜˜Kšžœžœ6žœ˜JKš
œ;˜;K˜—K˜$Kšžœžœžœ
žœ˜9K˜K˜—š œžœ%žœžœ˜QK˜<K˜XK˜Kšžœžœ6˜AKšžœžœ˜,Kš
œ˜K˜—š 	œžœ%žœžœ˜OK˜8K˜TK˜Kšžœžœ4˜?Kšžœžœ˜,Kš
œ˜K˜—š 
œžœ%žœžœ˜OKš
‘!˜!Kš
œ9˜9K˜&Kšžœžœ,˜7Kšžœžœ˜,Kš
œ˜K˜—šΟbœžœ-˜AKšœžœžœ
˜˜Kšžœžœ&žœ˜:Kš
œ˜K˜—K˜$Kšžœžœ˜,K˜K˜K˜—šœ
žœ
žœ™K™Kšœžœ™Kšœžœ™Kšœžœ™Kšœžœ™Kšœžœž
‘!™5K™K™—K˜š’œžœ-˜BKšœžœ˜*šœ
žœ˜šœ	žœžœžœ˜*K˜&šžœžœ‘˜!Kšœžœ	˜˜K˜CK˜—Kšœ;žœ˜AKš
œ
˜
—šžœ‘
˜Kš
œ6˜6Kš
œ˜—K˜—K˜K˜Kš
œ>˜>Kš
œ0˜0Kš
œ5˜5šžœžœ‘˜0Kšœžœ˜&˜K˜>K˜—Kšœ;žœ˜AK˜1K˜—K˜—Kšžœžœ
žœ
˜ K˜$šžœž˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœžœ$žœ˜`K˜—˜K˜——š 
œžœ,˜DKšœžœ˜%Kšœžœ˜*šœžœ˜K˜.K˜K˜K˜(K˜'K˜#K™CK˜—Kš
œ ˜ Kšžœžœ4˜JK˜K˜—š 	œžœžœ˜9Kšœžœ˜$K˜*Kš
œ˜K˜(K˜'K˜#K™5Kšžœžœ5˜KK˜K˜—š œžœžœžœžœžœ˜fKš
œ˜K˜$šžœžœ˜Kš
œ˜Kšžœžœ"˜4Kšžœ ˜$—Kšžœ˜
K˜K˜—š œžœ,žœžœ˜TKš
œ˜Kš
œ*˜*Kšžœžœ5˜KKšžœ˜
K˜K˜—š œžœ3žœžœ˜]Kš
œ˜Kš
œ˜Kš
œ˜Kš
œD˜Dšžœžœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜—Kšžœ˜
K˜K˜—š 
œžœžœ
žœ˜<Kšœžœ˜%Kšœžœ˜Kš
œ)˜)šžœžœ
žœžœžœ
ž˜7Kš
œ0˜0K˜Kšžœ˜	—Kšžœžœ:˜PK˜K˜—š œžœžœ
žœ˜BKšœžœ˜%Kšœžœ˜Kš
œ)˜)šžœžœ
žœžœžœ
ž˜7Kšœ0žœ˜6K˜Kšžœ˜	—Kšžœžœ@˜VK˜K˜—š œžœžœ
žœ˜:˜K˜LK˜—Kš
œ"˜"šžœžœ˜Kšœžœ˜šžœžœ
žœžœžœ
ž˜7K˜Kšžœ˜	—Kš
œ˜Kš
œ˜Kš
œ˜—K˜—K˜šœžœ
˜K˜—š
 œžœžœ
žœžœ˜AKšžœžœl™yKšžœ	žœ
žœ
žœ˜&Kš
œ˜Kšœžœ
˜Kš
œ˜K˜—š œžœ
žœž
œžœžœ˜=K™%Kšžœžœ
žœ˜ Kšœžœ
˜K˜K˜—Kš 	œžœžœžœ
žœžœ˜RKš
 	œžœžœžœ
žœ˜NKš 	œžœžœžœ
žœžœ˜WKš œžœžœžœ
žœžœ˜OKš 
œžœžœ1˜_K˜K˜š
 œžœžœžœ	žœ˜QKš
‘˜Kšœžœ
˜K˜&K˜&Kšžœ˜
K˜K˜—š
 œžœžœžœ	žœ˜SKš
‘˜Kšœžœ
˜K˜(K˜(Kšžœ˜
K˜K˜—K˜K˜—…—)L83