<> <> 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] }; }.