DIRECTORY
ImagerBasic,
Imager USING [Context, CurveTo, LineTo, MoveTo, MaskStroke, MaskStrokeClosed, MaskFill, Trajectory, MaskVector, SetColor, white],
FitIO,
FitStateUtils,
FitBasic USING[SampleHandle, SListHandle, Handle, LinkHandle, TrajHandle],
FitState USING [Handle],
Complex USING [Vec, Mul, Sub, Add],
Vector USING [Unit],
Rope USING [ROPE],
IO USING [STREAM, Close, Put, real, char, int, rope, SP, CR];

FitIOImpl: CEDAR PROGRAM
IMPORTS Imager, IO, Complex, Vector, FitStateUtils 
EXPORTS FitIO = { OPEN FitIO;
Handle: TYPE = FitState.Handle;
current: Context;
GetContext: PUBLIC PROC RETURNS [Context] = {RETURN[current]};
SetContext: PUBLIC PROC[context: Context] = {current _ context};
SetFeedback: PUBLIC PROC[feedback: Feedback] = {
current.feedback _ feedback;
IF current.logActions THEN {	--print feedback
SELECT feedback.color FROM
Imager.white => PrintRope["white "];
ENDCASE=> PrintRope["black"];
PrintLine["FB.color"];
PrintReal[feedback.sampleSize]; PrintLine["Fit.sampleSize"];
PrintReal[feedback.jointSize]; PrintLine["Fit.jointSize"];
PrintReal[feedback.nodeLength]; PrintLine["Fit.nodeLength"];
PrintReal[feedback.nodeLineWidth]; PrintLine["Fit.nodeLineWidth"];
PrintReal[feedback.lineWidth]; PrintLine["Fit.lineWidth"];
};
};
DrawSamples: PUBLIC PROC [handle: Handle, all: BOOLEAN _ FALSE, fill: BOOLEAN _ FALSE] = {
list: LIST OF Imager.Trajectory;
traj: Imager.Trajectory _ PathFromSList[handle.slist];
IF traj=NIL THEN RETURN ELSE list _ CONS[traj,list];
Imager.SetColor[current.imager, current.feedback.color];
IF all THEN {
makeList: FitStateUtils.SListProc = {list _ CONS[PathFromSList[slist],list]};
FitStateUtils.ForAllOtherSLists[handle,makeList];
};
IF fill THEN MaskFill[list]
ELSE
IF handle.closed THEN MaskStrokeClosed[list]
ELSE MaskStroke[list];
IF current.logActions THEN PrintLine["\n"];
};
DrawContour: PUBLIC PROC [handle: Handle, all: BOOLEAN _ FALSE, fill: BOOLEAN _ FALSE] = {
traj: Imager.Trajectory _ PathFromTraj[handle.traj];
list: LIST OF Imager.Trajectory;
IF traj=NIL THEN RETURN ELSE list _ CONS[traj,list];
Imager.SetColor[current.imager, current.feedback.color];
IF all THEN {
makeList: FitStateUtils.TrajProc = {list _ CONS[PathFromTraj[traj],list]};
FitStateUtils.ForAllOtherTrajs[handle,makeList];
};
IF fill THEN MaskFill[list]
ELSE
IF handle.closed OR all THEN MaskStrokeClosed[list]
ELSE MaskStroke[NARROW[list]];
IF current.logActions THEN PrintLine["\n"];
};
PathFromSList: PROC [slist: FitBasic.SListHandle] RETURNS [path: Imager.Trajectory] = {
first: BOOLEAN _ TRUE;
do: FitStateUtils.SampleProc = {
IF first THEN {path _ MoveTo[s.xy]; first _ FALSE}
ELSE path_ LineTo[path,s.xy];
};
FitStateUtils.ForAllSamples[slist, do];
IF current.logActions AND path#NIL THEN PrintLine["\n"];
RETURN[path];
};
PathFromTraj: PROC [traj: FitBasic.TrajHandle] RETURNS [path: Imager.Trajectory] = {
first: BOOLEAN _ TRUE;
do: FitStateUtils.LinkProc = {
IF first THEN {path _ MoveTo[l.cubic.b0]; first _ FALSE};
path _ CurveTo[path,l.cubic.b1,l.cubic.b2,l.cubic.b3];
};
FitStateUtils.ForAllLinks[traj, do];
IF current.logActions AND path#NIL THEN PrintLine["\n"];
};
MarkSamples: PUBLIC PROC [handle: Handle, all: BOOLEAN _ FALSE] = {
markSamples: FitStateUtils.SListProc = {FitStateUtils.ForAllSamples[slist, MarkSample]};
[] _ markSamples[handle.slist];
IF all THEN FitStateUtils.ForAllOtherSLists[handle, markSamples];
IF current.logActions THEN PrintLine["\n"];
}; 
MarkNodes: PUBLIC PROC [handle: Handle, all: BOOLEAN _ FALSE] = {
markNodes: FitStateUtils.SListProc = {FitStateUtils.ForAllSamples[slist, MarkNode]};
[] _ markNodes[handle.slist];
IF all THEN FitStateUtils.ForAllOtherSLists[handle, markNodes];
IF current.logActions THEN PrintLine["\n"];
}; 

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

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



MarkNode: PUBLIC FitStateUtils.SampleProc = {
d:REAL _ current.feedback.nodeLength;
width: REAL _ current.feedback.nodeLineWidth;
pt: Complex.Vec _ MagnifyPoint[s.xy];
IF current.logActions THEN PrintPoint[pt];
IF s.isCusp THEN d _ 1.5*d;
IF s.tangent = [0,0] THEN {
x: REAL _ s.xy.x;
y: REAL _ s.xy.y;
Imager.MaskVector[current.imager, [x+d,y+d], [x-d,y-d], width];
Imager.MaskVector[current.imager, [x-d,y+d], [x+d,y-d], width];
}
ELSE {
t: Complex.Vec _ Complex.Mul[Vector.Unit[s.tangent],[0,2*d]];
mdt: Complex.Vec _ Complex.Sub[s.xy,t];
adt: Complex.Vec _ Complex.Add[s.xy,t];
Imager.MaskVector[current.imager, [mdt.x, mdt.y], [adt.x,adt.y], width];
IF s.isCusp THEN {
t _ Complex.Mul[Vector.Unit[s.tanOut],[0,2*d]];
mdt _ Complex.Sub[s.xy,t];
adt _ Complex.Add[s.xy,t];
Imager.MaskVector[current.imager, [mdt.x, mdt.y],[adt.x,adt.y],width];
IF current.logActions THEN PrintRope["Fit.cusp "];
}
ELSE {IF current.logActions THEN PrintRope["Fit.node "]};
};
};

MarkSample: PUBLIC FitStateUtils.SampleProc = {
size: REAL _ current.feedback.sampleSize;
pt: Complex.Vec _ MagnifyPoint[s.xy];
traj: Imager.Trajectory _ Imager.MoveTo[[pt.x, pt.y]];
traj _ Imager.LineTo[traj,[pt.x, pt.y]];
Imager.MaskStroke[current.imager,traj, size, round];
IF current.logActions THEN {PrintPoint[pt]; PrintRope["Fit.mark "]};
};

MarkJoint: PROC[pt: Complex.Vec] = {
size: REAL _ current.feedback.jointSize;
traj: Imager.Trajectory;
pt _ MagnifyPoint[pt];
traj _ Imager.MoveTo[[pt.x, pt.y]];
traj _ Imager.LineTo[traj,[pt.x, pt.y]];
Imager.MaskStroke[current.imager,traj, size, round];
IF current.logActions THEN {PrintPoint[pt]; PrintRope["Fit.joint "]};
};

MoveTo: PROC[p: Complex.Vec]  RETURNS [path: Imager.Trajectory]= {
p _ MagnifyPoint[p];
path _ Imager.MoveTo[[p.x,p.y]];
IF current.logActions THEN {PrintPoint[p]; PrintRope["Fit.moveto"]};
RETURN[path];
};

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

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

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

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

MaskFill: PROC[list: LIST OF Imager.Trajectory] = {
Imager.MaskFill[current.imager,list];
IF current.logActions THEN { 
count: INT _ 0;
FOR l: LIST OF Imager.Trajectory _ list, list.rest UNTIL l=NIL DO
count _ count+1;
ENDLOOP; 
PrintInt[count];
PrintLine["Fit.maskfill"];
};
};

NoLog: PUBLIC SIGNAL = CODE;

StartLog: PUBLIC PROC [stream: IO.STREAM _ NIL] = {
IF current.log#NIL THEN IO.Close[current.log];
current.log _ stream;
current.logActions _ TRUE;
};    
StopLog: PUBLIC PROC[close: BOOLEAN _ TRUE] = {
IF close THEN IO.Close[current.log];
current.logActions _ FALSE;
};
PrintReal: PROC[r: REAL] = {OPEN IO; Put[current.log,real[r],char[SP]]};
PrintRope: PROC[s: Rope.ROPE] = {OPEN IO; Put[current.log,rope[s]]};
PrintLine: PROC[s: Rope.ROPE] = {OPEN IO; Put[current.log,rope[s],char[CR]]};
PrintInt: PROC[i: INT] = {OPEN IO; Put[current.log,int[i],char[SP]]};
PrintPoint: PROC[pt: Complex.Vec] = {PrintReal[pt.x]; PrintReal[pt.y]};


MagnifyData: PUBLIC PROC[scale: REAL] = {current.magnify _ scale};
PositionData: PUBLIC PROC[trans: Complex.Vec]= {current.position _ trans};
MagnifyPoint: PUBLIC PROC [p: Complex.Vec] RETURNS[Complex.Vec] = {
--magnify and position
vt: Complex.Vec;
vt.x _ p.x*current.magnify+current.position.x;
vt.y _ p.y*current.magnify+current.position.y;
RETURN[vt]
};
UnMagnifyPoint: PUBLIC PROC [p: Complex.Vec] RETURNS[Complex.Vec] = {
--undo magnify and position
vt: Complex.Vec;
vt.x _ p.x*(p.x-current.position.x)/current.magnify;
vt.y _ p.y*(p.y+current.position.y)/current.magnify;
RETURN[vt]
};
}.

FitIOImpl.mesa
Maureen Stone July 3, 1984 12:26:46 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[current.imager,pt.x,pt.y,size,size];
Imager.MaskRectangle[current.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.
scales the view of the data but not the marks, linewidth or distance from data to the origin
This is an absolute number with respect to the data.  Reset the magnify by MagnifyData[1];
Positions the data with respect to the origin of the context.
This is an absolute with respect to the Imager client coordinates.
Reset by PositionData[0,0];
�Ê
˜Jš
œ™Jš
œ*™*š
Ïk	˜	Jš
œ˜Jšœ�œu˜�
J˜J˜Jšœ	�œ<˜JJšœ	�œ
˜Jšœ�œ˜#Jšœ�œ˜Jšœ�œ�œ˜Jš�œ
�œ�œ-˜=J˜—šœ�œ
�˜Jš�œ	�œ!˜3Jš�œ�œ˜—Jšœ�œ˜J˜JšÏn
œ�œ
�œ�œ˜>Jšž
œ�œ)˜@šžœ�œ˜0Jš
œ˜š�œ�œÏc˜-š�œ�˜J˜$Jš�œ˜—J˜J˜<J˜:J˜<Jš
œB˜BJš
œ:˜:J˜—J˜—šžœ�œ�œ�œ�œ�œ˜ZJš
Ÿ7™7Jšœ�œ
�œ˜ Jš
œ6˜6Jš�œ�œ
�œ
�œ
�œ�œ˜4J˜8š�œ�œ˜
Jšœ,�œ˜MJ˜1Jš
œ˜—Jš�œ�œ˜š
�˜Jš�œ�œ˜,Jš�œ˜—Jš�œ�œ˜+J˜—šžœ�œ�œ�œ�œ�œ˜ZJš
œ4˜4Jšœ�œ
�œ˜ Jš�œ�œ
�œ
�œ
�œ�œ˜4J˜8š�œ�œ˜
Jšœ+�œ˜JJ˜0Jš
œ˜—Jš�œ�œ˜š
�˜Jš�œ�œ�œ˜3Jš�œ�œ˜—Jš�œ�œ˜+J˜—šž
œ�œ�œ˜WJš
Ÿ7™7Jšœ�œ�œ
˜˜ Jš�œ�œ�œ
˜2Jš�œ˜J˜—J˜'Jš�œ�œ�œ
�œ˜8Jš�œ˜
J˜—šžœ�œ�œ˜TJš
Ÿ-™-Jšœ�œ�œ
˜˜Jš�œ�œ%�œ˜9Jš
œ6˜6J˜—J˜$Jš�œ�œ�œ
�œ˜8J˜—šžœ�œ�œ�œ˜CJ˜XJ˜Jš�œ�œ6˜AJš�œ�œ˜+Jš
œ˜—šž	œ�œ�œ�œ˜AJ˜TJ˜Jš�œ�œ4˜?Jš�œ�œ˜+Jš
œ˜J˜—šž
œ�œ�œ�œ˜AJš
Ÿ!˜!J˜!Jš�œ�œ8˜CJš�œ�œ˜+Jš
œ˜J˜—šÏbœ˜*Jšœ�œ�œ
˜˜Jš�œ�œ!�œ˜5Jš
œ˜J˜—J˜$Jš�œ�œ˜+J˜J˜J˜—šœ
�œ
�œ™J™Jšœ�œ™Jšœ�œ™Jšœ�œ™Jšœ�œ™Jšœ�œ�
Ÿ!™5J™J™—J˜šžœ�œ˜-Jšœ�œ˜%Jšœ�œ"˜-J˜%Jš�œ�œ˜*Jš�œ
�œ˜š�œ�˜Jšœ�œ
˜Jšœ�œ
˜J˜?J˜?Jš
�
˜
—š
�˜J˜=J˜'J˜'J˜Hš�œ
�œ˜J˜/J˜J˜J˜FJš�œ�œ˜2J˜
—Jš�œ�œ�œ˜9Jš
�˜—J˜J˜—šž
œ�œ˜/Jšœ�œ˜)J˜%J˜6J˜(J˜4J™9Jš�œ�œ*˜DJ˜J˜—šž	œ�œ˜$Jšœ�œ˜(J˜J˜J˜#J˜(J˜4J™9Jš�œ�œ+˜EJ˜J˜—šžœ�œ�œ˜BJ˜J˜ Jš�œ�œ*˜DJš�œ˜
J˜J˜—šžœ�œ*�œ˜TJ˜Jš
œ&˜&Jš�œ�œ+˜EJš�œ˜
J˜J˜—šžœ�œ1�œ˜]J˜J˜J˜Jš
œ@˜@š�œ�œ˜J˜J˜J˜J˜J˜—Jš�œ˜
J˜J˜—šž
œ�œ�œ
�œ˜5Jšœ�œ˜)Jšœ�œ˜š�œ�œ
�œ%�œ�œ
�˜AJš
œ0˜0J˜Jš�œ˜	—Jš�œ�œ0˜JJ˜J˜—šžœ�œ�œ
�œ˜;Jšœ�œ˜)Jšœ�œ˜š�œ�œ
�œ%�œ�œ
�˜AJš
œ6˜6J˜Jš�œ˜	—Jš�œ�œ6˜PJ˜J˜—šžœ�œ�œ
�œ˜3Jš
œ%˜%š�œ�œ˜Jšœ�œ˜š�œ�œ
�œ%�œ�œ
�˜AJ˜Jš�œ˜	—Jš
œ˜Jš
œ˜Jš
œ˜—J˜—J˜šœ�œ
˜J˜—š
žœ�œ
�œ
�œ�œ˜3Jš�œ�œl™yJš�œ
�œ
�œ
�œ˜.Jš
œ˜Jšœ�œ
˜Jš
œ˜—šžœ�œ�œ�œ˜/J™%Jš�œ�œ
�œ˜$Jšœ�œ
˜J˜—Jšž	œ�œ�œ�œ
�œ�œ˜HJš
ž	œ�œ	�œ�œ
�œ˜DJšž	œ�œ	�œ�œ
�œ�œ˜MJšžœ�œ�œ�œ
�œ�œ˜EJšž
œ�œ7˜GJ˜J˜šžœ�œ�œ˜BJš
Ÿ\™\J™Z—šžœ�œ1˜JJš
Ÿ=™=J™BJ™—šžœ�œ�œ˜CJš
Ÿ˜J˜J˜.J˜.Jš�œ˜
J˜—šžœ�œ�œ˜EJš
Ÿ˜J˜J˜4J˜4Jš�œ˜
J˜—J˜J˜—…—"Â0Ý