DIRECTORY Commander, Convert, FS, IO, Imager, ImagerBasic, ImagerConic, Real, Rope, UFFileManager, UFPressFontReader, SDtoSF; SDtoSFImpl: CEDAR PROGRAM IMPORTS Commander, Convert, FS, IO, ImagerConic, Real, Rope, UFFileManager, UFPressFontReader EXPORTS SDtoSF SHARES Imager ~ BEGIN ROPE: TYPE ~ Rope.ROPE; Pair: TYPE ~ ImagerBasic.Pair; Trajectory: TYPE ~ Imager.Trajectory; TrajectoryRep: TYPE ~ Imager.TrajectoryRep; Outline: TYPE ~ Imager.Outline; Polygon: TYPE ~ Imager.Polygon; Coeffs: TYPE ~ RECORD [c0, c1, c2, c3: ImagerBasic.Pair]; Sub: PROC [a: Pair, b: Pair] RETURNS [Pair] ~ INLINE { RETURN[[a.x-b.x, a.y-b.y]] }; Add: PROC [a: Pair, b: Pair] RETURNS [Pair] ~ INLINE { RETURN[[a.x+b.x, a.y+b.y]] }; Mul: PROC [a: Pair, s: REAL] RETURNS [Pair] ~ INLINE { RETURN[[a.x*s, a.y*s]] }; BezierToCoeffs: PROC [bezier: ImagerBasic.Bezier] RETURNS[coeffs: Coeffs] ~ { t: Pair _ Mul[Sub[bezier.b2,bezier.b1],3]; coeffs.c0 _ bezier.b0; coeffs.c1 _ Mul[Sub[bezier.b1, bezier.b0], 3]; coeffs.c2 _ Sub[t, coeffs.c1]; coeffs.c3 _ Sub[bezier.b3, Add[bezier.b0, t]]; RETURN [coeffs]; }; MapTrajectory: ImagerBasic.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: ImagerBasic.PathMapType = { FOR x: LIST OF Trajectory _ NARROW[data], x.rest UNTIL x = NIL DO MapTrajectory[x.first, move, line, curve, conic] ENDLOOP; }; MapPolygon: ImagerBasic.PathMapType = { p: Polygon = NARROW[data]; IF p.length>0 THEN { move[p[0]]; FOR i: NAT IN[1..MIN[p.length, p.maxLength]) DO line[p[i]] ENDLOOP; }; }; SDCharToRope: PUBLIC PROC [sdName: ROPE, charCode: NAT, fiducial: INT] RETURNS [ROPE] ~ { stream: IO.STREAM _ IO.ROS[]; SDCharToStream[stream, sdName, charCode, fiducial]; RETURN [IO.RopeFromROS[stream]]; }; SDCharToStream: PUBLIC PROC [dest: IO.STREAM, sdName: ROPE, charCode: NAT, fiducial: INT] ~ { fontKey: UFPressFontReader.FontKey _ [UFFileManager.KeyOf[sdName], 0]; charInfo: UFPressFontReader.CharInfo _ UFPressFontReader.GetCharInfo[fontKey, VAL[charCode]]; pathMap: ImagerBasic.PathMapType; pathData: REF; [pathMap, pathData] _ UFPressFontReader.GetCharPath[fontKey, VAL[charCode]]; PathToStream[dest, pathMap, pathData, UFPressFontReader.Family[fontKey], DecodeFace[UFPressFontReader.Face[fontKey]], VAL[charCode], charInfo.widthX, charInfo.widthY, fiducial]; }; DecodeFace: PROC [faceCode: [0..255]] RETURNS [face: ROPE] ~ { IF faceCode IN [0..18) THEN { slope: ROPE ~ IF (faceCode MOD 2) = 0 THEN "Roman" ELSE "Italic"; weight: ROPE ~ SELECT (faceCode/2 MOD 3) FROM 0 => "Medum", 1 => "Bold", 2 => "Light", ENDCASE => ERROR; expansion: ROPE ~ SELECT (faceCode/6 MOD 3) FROM 0 => "Regular", 1 => "Condensed", 2 => "Expanded", ENDCASE => ERROR; face _ weight.Cat[" ", slope, " ", expansion]; } ELSE face _ Convert.RopeFromInt[faceCode]; }; OutlineToRope: PUBLIC PROC [outline: REF, family: ROPE, face: ROPE, charCode: NAT, widthx: REAL, widthy: REAL, fiducial: INT] RETURNS [ROPE] ~ { stream: IO.STREAM _ IO.ROS[]; OutlineToStream[stream, outline, family, face, charCode, widthx, widthy, fiducial]; RETURN [IO.RopeFromROS[stream]]; }; OutlineToStream: PUBLIC PROC [dest: IO.STREAM, outline: REF, family: ROPE, face: ROPE, charCode: NAT, widthx: REAL, widthy: REAL, fiducial: INT] ~ { WITH outline SELECT FROM o: Outline => PathToStream[dest, MapTrajectoryList, o.list, family, face, charCode, widthx, widthy, fiducial]; list: LIST OF Trajectory => PathToStream[dest, MapTrajectoryList, list, family, face, charCode, widthx, widthy, fiducial]; t: Trajectory => PathToStream[dest, MapTrajectory, t, family, face, charCode, widthx, widthy, fiducial]; p: Polygon => PathToStream[dest, MapPolygon, p, family, face, charCode, widthx, widthy, fiducial]; ENDCASE => ERROR; }; PathToStream: PUBLIC PROC [dest: IO.STREAM, pathMap: ImagerBasic.PathMapType, pathData: REF, family: ROPE, face: ROPE, charCode: NAT, widthx: REAL, widthy: REAL, fiducial: INT] ~ { Grid: PROC [vec: Pair] RETURNS [gridVec: Pair] ~ { gridVec.x _ Real.RoundLI[(vec.x)*fiducial]; gridVec.y _ Real.RoundLI[(vec.y)*fiducial]; }; CountCon: PROC RETURNS [maxBeziers: NAT _ 0] ~ { beziers: NAT _ 0; p0: Pair _ [0, 0]; Move: PROC [p: Pair] ~ {maxBeziers _ MAX[maxBeziers, beziers]; beziers _ 0; p0 _ Grid[p]}; Line: PROC [p: Pair] ~ {beziers _ beziers+1; p0 _ Grid[p]}; Curve: PROC [p1, p2, p3: Pair] ~ {beziers _ beziers+1; p0 _ Grid[p3]}; Conic: PROC [p1, p2: Pair, r: REAL] ~ {ImagerConic.ToCurves[p0, p1, p2, r, Curve]}; pathMap[pathData, Move, Line, Curve, Conic]; maxBeziers _ MAX[maxBeziers, beziers]; }; BezierSequenceRec: TYPE ~ RECORD[SEQUENCE length: NAT OF ImagerBasic.Bezier]; bezier: REF BezierSequenceRec _ NEW[BezierSequenceRec[CountCon[]]]; k: NAT _ 0; p0: Pair _ [0, 0]; Move: PROC [p: Pair] ~ { WriteCurrentOutline[]; p0 _ Grid[p]; }; Line: PROC [p: Pair] ~ { p _ Grid[p]; bezier[k] _ [ b0: p0, b1: [(p0.x+p0.x+p.x)/3, (p0.y+p0.y+p.y)/3], b2: [(p0.x+p.x+p.x)/3, (p0.y+p.y+p.y)/3], b3: p ]; k _ k+1; p0 _ p; }; Curve: PROC [p1, p2, p3: Pair] ~ { p1 _ Mul[p1, fiducial]; p2 _ Mul[p2, fiducial]; p3 _ Grid[p3]; bezier[k] _ [b0: p0, b1: p1, b2: p2, b3: p3]; k _ k+1; p0 _ p3; }; Conic: PROC [p1, p2: Pair, r: REAL] ~ {ImagerConic.ToCurves[p0, p1, p2, r, Curve]}; WriteCurrentOutline: SAFE PROC ~ CHECKED { IF k=0 THEN RETURN; dest.PutF["\n ((%d (", IO.int[k+1]]; FOR i: NAT IN [0..k) DO dest.PutF["(%d %d) ", IO.int[Real.RoundLI[bezier[i].b0.x]], IO.int[Real.RoundLI[bezier[i].b0.y]]]; ENDLOOP; dest.PutF["(%d %d)", IO.int[Real.RoundLI[bezier[0].b0.x]], IO.int[Real.RoundLI[bezier[0].b0.y]]]; dest.PutRope[")\n NIL ("]; FOR i: NAT IN [0..k) DO coeffs: Coeffs _ BezierToCoeffs[bezier[i]]; IF i>0 THEN dest.PutRope[" "]; dest.PutF["(%g %g", IO.real[coeffs.c1.x], IO.real[coeffs.c1.y]]; dest.PutF[" %g %g", IO.real[coeffs.c2.x*2.0], IO.real[coeffs.c2.y*2.0]]; dest.PutF[" %g %g)", IO.real[coeffs.c3.x*6.0], IO.real[coeffs.c3.y*6.0]]; ENDLOOP; dest.PutRope[")\n NATURAL))"]; k _ 0; }; dest.PutRope["\n((FAMILY "]; dest.PutRope[family]; dest.PutRope[") "]; dest.PutF[" (CHARACTER %d)\n", IO.int[charCode]]; dest.PutRope[" (FACE "]; dest.PutRope[face]; dest.PutRope[")\n"]; dest.PutF[" (WIDTH %d %d)\n", IO.int[Real.RoundLI[widthx*fiducial]], IO.int[Real.RoundLI[widthy*fiducial]]]; dest.PutF[" (FIDUCIAL %d %d)\n", IO.int[fiducial], IO.int[fiducial]]; dest.PutRope[" (SPLINES"]; pathMap[data: pathData, move: Move, line: Line, curve: Curve, conic: Conic]; WriteCurrentOutline[]; dest.PutRope["))\n"]; }; ConvertFile: PUBLIC PROC [sdName: ROPE, sfName: ROPE] ~ { fontKey: UFPressFontReader.FontKey _ [UFFileManager.KeyOf[sdName], 0]; dest: IO.STREAM _ FS.StreamOpen[sfName, $create]; bc, ec: CHAR; [bc, ec] _ UFPressFontReader.Range[fontKey]; FOR c: CHAR IN [bc..ec] DO SDCharToStream[dest, sdName, VAL[c], 15840]; ENDLOOP; dest.PutRope["\nSTOP\n"]; IO.Close[dest]; }; Break: PROC [char: CHAR] RETURNS [IO.CharClass] = { IF char = '_ OR char = '; THEN RETURN [break]; IF char = ' OR char = ' OR char = ', OR char = '\n THEN RETURN [sepr]; RETURN [other]; }; GetToken: PROC [stream: IO.STREAM] RETURNS [rope: ROPE _ NIL] = { rope _ stream.GetTokenRope[Break ! IO.EndOfStream => CONTINUE].token; }; SDtoSFCommand: Commander.CommandProc ~ { stream: IO.STREAM _ IO.RIS[cmd.commandLine]; outputName: ROPE _ GetToken[stream]; gets: ROPE _ GetToken[stream]; inputName: ROPE _ GetToken[stream]; IF NOT gets.Equal["_"] THEN { cmd.out.PutRope["Specify output _ input, please\n"]; RETURN; }; ConvertFile[inputName, outputName]; }; Commander.Register["SDtoSF", SDtoSFCommand, "Convert SD file to SF format (output _ input)"]; END. μSDtoSFImpl.mesa Michael Plass, January 13, 1984 10:20 am Compute the cubic coefficients from the Bezier points. c0 _ b0; c1 _ 3(b1-b0); c2 _ 3(b0-2b1+b2); [ = 3(b2-b1) - c1 ] c3 _ -b0 +3(b1-b2) + b3; [ = b3 - (b0 + 3(b2-b1)) ] Κ ϊ– "cedar" style˜Jšœ™šœ(™(J™—šΟk œœœY˜}J˜—šœ œ˜Jšœœœ;˜]Jšœ˜šœ ˜J˜——šœœœ˜J˜—Jšœœ˜Jšœ œ˜%Jšœœ˜+Jšœ œ˜šœ œ˜J˜J˜—Jšœœœ$˜9Jš Οnœœœ œœ˜TJš žœœœ œœ˜TJš žœœœœ œœ˜Pšžœœœ˜MJšœ6™6Jšœ™Jšœ™Jšœ&™&Jšœ3™3J˜*J˜J˜.J˜J˜.Jšœ ˜J˜J˜—šœ*˜*Jšœœ˜J˜ šœœœ˜1J˜šœœ˜Jšœœ!˜'Jšœœ/˜5Jšœœ.˜4Jšœœœ˜$Jšœœ˜—Jšœ˜—J˜J˜—šœ.˜.š œœœœœœ˜AJ˜0Jšœ˜—J˜J˜—šœ'˜'Jšœ œ˜šœ œ˜J˜ Jš œœœœœ œ˜CJ˜—J˜J˜—šž œœœ œ œ œœœ˜YJš œœœœœ˜Jšœ3˜3Jšœœ˜ Jšœ˜J˜—šžœœœœœ œ œ œ˜]JšœF˜FJšœNœ ˜]Jšœ!˜!Jšœ œ˜Jšœ=œ ˜LJšœvœ8˜±Jšœ˜J˜—šž œœœœ˜>šœ œ œ˜Jš œœœ œœ œ ˜Ašœœœ œ˜-Jšœ ˜ Jšœ ˜ Jšœ ˜ Jšœœ˜—šœ œœ œ˜0Jšœ˜Jšœ˜Jšœ˜Jšœœ˜—Jšœ.˜.Jšœ˜—Jšœ&˜*Jšœ˜J˜—šž œœœ œ œœ œ œ œ œœœ˜Jš œœœœœ˜JšœS˜SJšœœ˜ Jšœ˜J™—šžœœœœœ œ œœ œ œ œ œ˜”šœ œ˜Jšœn˜nJšœœœm˜zJšœh˜hJšœb˜bJšœœ˜—Jšœ˜J™—šž œœœœœ.œ œœ œ œ œ œ˜΄šžœœ œ˜2Jšœ+˜+Jšœ+˜+J˜—šžœœœœ ˜0Jšœ œ˜Jšœ˜Jšžœœœ2˜ZJšžœœ1˜;Jšžœœ;˜FJšžœœœ1˜SJšœ,˜,Jšœ œ˜&J˜—Jš œœœœ œœ˜MJšœœœ ˜CJšœœ˜ Jšœ˜šžœœ˜Jšœ˜Jšœ ˜ Jšœ˜—šžœœ˜Jšœ ˜ šœ ˜ Jšœ˜Jšœ+˜+Jšœ)˜)Jšœ˜Jšœ˜—J˜Jšœ˜Jšœ˜—šžœœ˜"Jšœ˜Jšœ˜Jšœ˜Jšœ-˜-J˜Jšœ˜Jšœ˜—Jšžœœœ1˜Sšžœœœœ˜*Jšœœœ˜Jšœœ ˜&šœœœ˜Jšœœ$œ$˜bJšœ˜—Jšœœ$œ$˜aJ˜šœœœ˜Jšœ+˜+Jšœœ˜Jšœœœ˜@Jšœœœ˜HJšœœœ˜IJšœ˜—J˜ J˜Jšœ˜—JšœF˜FJšœœ˜1JšœA˜AJšœœ%œ%˜lJšœ!œœ˜EJšœ˜JšœL˜LJšœ˜Jšœ˜Jšœ˜J˜—š ž œœœ œ œ˜9JšœF˜FJšœœœœ˜1Jšœœ˜ Jšœ,˜,šœœœ ˜Jšœœ ˜,Jšœ˜—J˜Jšœ ˜Jšœ˜J˜—– "cedar" styleš žœœœœœ˜3Jšœ œ œœ ˜.Jš œ œ œ œ œœ˜HJšœ ˜Jšœ˜J˜—– "cedar" stylešžœœ œœœœœ˜AJšœ#œœ˜EJšœ˜J˜—šž œ˜(Jš œœœœœ˜,Jšœ œ˜$Jšœœ˜Jšœ œ˜#šœœœ˜Jšœ4˜4Jšœ˜Jšœ˜—Jšœ#˜#Jšœ˜J˜—šœ]˜]J˜—Jšœ˜J˜—…—¦)Œ