DIRECTORY
CD,
CDBasics,
CDCommandOps,
CDDefaultProcs,
CDExtras,
CDIO,
CDViewer,
CDPolygons,
CDMenus,
CDOps,
CDOrient,
CDProperties,
CDSequencer,
CDValue,
GraphicsBasic,
CGArea,
CGClipper,
CGReducer,
Commander,
CornerStitching,
Imager,
IO,
PDFileFormat,
PDFileWriter,
Process,
Real,
Rope,
TerminalIO,
ViewerClasses,
ViewerSpecs;

CDColorPDPlot: CEDAR PROGRAM
IMPORTS CD, CDBasics, CDCommandOps, CDDefaultProcs, CDExtras, CDIO, CDMenus, CDValue, CDViewer, CDOps, CDOrient, CDPolygons, CDProperties, CDSequencer, CGArea, CGClipper, CGReducer, Commander, CornerStitching, Imager, IO, PDFileWriter, Process, Real, TerminalIO =
BEGIN

plottingInProgress: BOOL _ FALSE;


Toner: TYPE = PDFileFormat.Toner;  -- {black, cyan, magenta, yellow, .. 15};
TonerKeys: TYPE = ARRAY Toner OF REF;
LoadArray: TYPE = ARRAY Toner OF PDFileWriter.LoadReference;
ColorDescription: TYPE = ARRAY CD.Layer OF REF LoadArray _ ALL[NIL];

whiteLoadRef: PDFileWriter.LoadReference = LAST[PDFileWriter.LoadReference]; 

tonerToKeyKeys: REF TonerKeys = NEW[TonerKeys _ ALL[NIL]];

deviceCode: PDFileFormat.DeviceCode _ last;  
sRes: CARDINAL _ 200;  -- resolution (slow directition), pixels / inch
fRes: CARDINAL _ 200;  -- resolution (fast direction), pixels / inch
scanLineWidth: CARDINAL _ 8000; --for the wide-bed Versatec, length in the "fast" direction;
toners: PDFileWriter.TonerSet _ ALL[FALSE];
leftOverMode: BOOL _ FALSE;

bandSSize: CARDINAL _ 64;  -- number chosen because of buffer-size of versatec
overLap: CARDINAL _ 300;  -- number of pixels by which to overlap strips
maxPixPerLambda: NAT _ 20; -- maximum # of pixels to make lambda

paged: BOOL _ FALSE;
slowLimited: BOOL _ FALSE; --only interesting if ~paged
pageSlowSize: CARDINAL _ 0; --only interesting if paged or slowLimited

stippleKey: ATOM _ $CDxVersatec;
tonerToKey: REF TonerKeys _ NIL;


ColorVersatec: PROC [] =
BEGIN
deviceCode _ last;   --does not yet has an assigned value, use "last"
sRes _ 200;  -- resolution (slow directition), pixels / inch
fRes _ 200;  -- resolution (fast direction), pixels / inch
scanLineWidth _ 8000; --for the wide-bed Versatec, length in the "fast" direction;
toners _ ALL[FALSE];
toners[black] _ TRUE;
toners[cyan] _ TRUE;
toners[magenta] _ TRUE;
toners[yellow] _ TRUE;
bandSSize _ 64;  -- number chosen because of buffer-size of versatec
overLap _ 300;  -- number of pixels by which to overlap strips
maxPixPerLambda _ 20; -- maximum # of pixels to make lambda
paged _ slowLimited _ FALSE;
leftOverMode _ FALSE;
stippleKey _ $CDxVersatec;
TerminalIO.WriteRope["color versatec"];
END;

InkJetC150: PROC [] =
BEGIN
deviceCode _ VAL[10];  
sRes _ 120;  -- resolution (slow directition), pixels / inch
fRes _ 120;  -- resolution (fast direction), pixels / inch
scanLineWidth _ 1020; 
toners _ ALL[FALSE];
toners[black] _ TRUE;
toners[cyan] _ TRUE;
toners[magenta] _ TRUE;
toners[yellow] _ TRUE;
bandSSize _ 48;  -- 
overLap _ 30;  -- number of pixels by which to overlap strips
maxPixPerLambda _ 20; -- maximum # of pixels to make lambda
paged _ FALSE;
slowLimited _ TRUE;
pageSlowSize _ 1020;
leftOverMode _ FALSE;
stippleKey _ $CDxVersatec;
TerminalIO.WriteRope["ink jet"];
END;

Color400: PROC [] =
BEGIN
deviceCode _ VAL[9];  
sRes _ 400;  -- resolution (slow directition), pixels / inch
fRes _ 400;  -- resolution (fast direction), pixels / inch
scanLineWidth _ 4096; 
toners _ ALL[FALSE];
toners[black] _ TRUE;
toners[cyan] _ TRUE;
toners[magenta] _ TRUE;
toners[yellow] _ TRUE;
bandSSize _ 50;  -- 
overLap _ 30;  -- number of pixels by which to overlap strips
maxPixPerLambda _ 240; -- maximum # of pixels to make lambda
paged _ TRUE;
pageSlowSize _ 5500;
leftOverMode _ FALSE;
stippleKey _ $CDxC400;
TerminalIO.WriteRope["Color400"];
END;

Puffin: PROC [] =
BEGIN
deviceCode _ PDFileFormat.DeviceCode[puffin];  
sRes _ 384;  -- resolution (slow directition), pixels / inch
fRes _ 384;  -- resolution (fast direction), pixels / inch
scanLineWidth _ fRes * 17 / 2; 
toners _ ALL[FALSE];
toners[black] _ FALSE;
toners[cyan] _ TRUE;
toners[magenta] _ TRUE;
toners[yellow] _ TRUE;
bandSSize _ 16;  -- 
overLap _ 30;  -- number of pixels by which to overlap strips
maxPixPerLambda _ 20; -- maximum # of pixels to make lambda
paged _ TRUE;
pageSlowSize _ sRes*11;
leftOverMode _ TRUE;
stippleKey _ $CDxPuffin;
TerminalIO.WriteRope["Puffin"];
END;

PlateMaker: PROC [] =
BEGIN
deviceCode _ PDFileFormat.DeviceCode[last];  
sRes _ 1200;  -- resolution (slow directition), pixels / inch
fRes _ 1200;  -- resolution (fast direction), pixels / inch
scanLineWidth _ fRes * 17 / 2; 
toners _ ALL[FALSE];
toners[black] _ TRUE;
toners[cyan] _ FALSE;
toners[magenta] _ FALSE;
toners[yellow] _ FALSE;
bandSSize _ 16;  -- 
overLap _ 30;  -- number of pixels by which to overlap strips
maxPixPerLambda _ 20; -- maximum # of pixels to make lambda
paged _ TRUE;
pageSlowSize _ sRes*11;
leftOverMode _ TRUE;
stippleKey _ $CDxRaven;
TerminalIO.WriteRope["Raven or platemaker"];
END;


technologyPropertyKey: REF _ $CDxLastTechnology; --a property of the stippleKey

abortPlot: REF BOOL _ NEW[BOOL _ FALSE];

PlotStateRef: TYPE = REF PlotState;
PlotState: TYPE = RECORD [
tes: ARRAY CD.Layer OF REF CornerStitching.Tesselation _ ALL[NIL], 
scale: REAL _ 1.0, -- pixels per CD.Number
totalPlotClip, bandClip: CD.Rect _ [0, 0, 0, 0],
pdState: PDFileWriter.PDState,
colorLoads: REF ColorDescription,
anouncedLayer: INT _ -1
];

pdy: CARDINAL _ 0; 	-- top of band in pixel coords
stripClip: CD.Rect;		-- clip for a page; not reduced to real design clip
plotScale: REAL;  
imageSSize: CARDINAL;
imageFSize: CARDINAL;

ps: PlotStateRef;

PrepareContextFilter: PROC [] =
BEGIN
contextFilter^ _ ALL[NIL];
FOR l: CD.Layer IN CD.Layer DO
FOR toner: Toner IN Toner DO
IF tonerToKey[toner]#NIL AND CDProperties.GetPropFromLayer[from: l, prop: tonerToKey[toner]]#NIL THEN {
contextFilter^[l] _ Imager.black;
EXIT
};
ENDLOOP;
ENDLOOP;
END;

CheckStipples: PROC [technology: CD.Technology] =
BEGIN
x: REF _ CDValue.Fetch[technology, stippleKey];
WITH x SELECT FROM
r: Rope.ROPE => TerminalIO.WriteRopes["color stipples used: [", r, "]\n"];
ENDCASE => {
TerminalIO.WriteRope["**color stipples are not defined\n"];
ERROR ABORTED
};
IF technology.key#CDProperties.GetPropFromAtom[stippleKey, technologyPropertyKey] THEN
TerminalIO.WriteRope["**Warning: another technology registered in the meantime; the technology independent stipples are redefined\n"];
tonerToKey _ NEW[TonerKeys _ ALL[NIL]];
FOR t: PDFileWriter.Toner IN PDFileWriter.Toner DO
tonerToKey^[t] _ CDProperties.GetPropFromAtom[stippleKey, tonerToKeyKeys[t]];
IF ~toners[t] OR tonerToKey^[t]=NIL THEN {
toners[t] _ FALSE;
tonerToKey^[t] _ NEW[INT];
} 
ENDLOOP;
PrepareContextFilter[];
END;

ClipArea: PROC [comm: CDSequencer.Command] RETURNS [plotClip: CD.Rect] =
BEGIN
SELECT TerminalIO.RequestSelection["Plot", LIST["complete design", "rectangle"]] FROM
2 => {
plotClip _ CDBasics.ToRect[comm.pos, comm.sPos];
TerminalIO.WriteRope["plot rectangle\n"];
};
ENDCASE => {
plotClip _ CDExtras.BoundingBox[comm.design];
TerminalIO.WriteRope["plot all\n"];
};
IF plotClip.x1>=plotClip.x2 OR plotClip.y1>=plotClip.y2 THEN {
TerminalIO.WriteRope["**cannot plot empty area\n"];
ERROR ABORTED
};
END;

ProtectedPlotDesign: PROC [comm: CDSequencer.Command] =
BEGIN
design: CD.Design = comm.design;
plotClip: CD.Rect;
plotSize: CD.Position;
s: IO.STREAM _ NIL;
strips: INT;
plottingInProgress _ TRUE;
TerminalIO.WriteRope["Starting Color plot for "];
SELECT comm.a FROM
$VersatecColorPlot => ColorVersatec[];
$C150ColorPlot => InkJetC150[];
$PuffinColorPlot => Puffin[];
$PlatemakerColorPlot => PlateMaker[];
$Color400Plot => Color400[];
ENDCASE => ERROR;
TerminalIO.WriteLn[];
CheckStipples[design.technology];
plotClip _ ClipArea[comm];
plotSize _ CDBasics.SizeOfRect[plotClip];
TRUSTED {Process.SetPriority[Process.priorityBackground]};
strips _ 1;
IF ~paged AND ~slowLimited THEN {
IF TerminalIO.Confirm[label: "plot multiple vertical strips", choice: "yes"] THEN
strips _ TerminalIO.RequestInt["How many vertical strips? [1..10] "];
};
strips _ MAX[1, MIN[10, strips]];
BEGIN 
ENABLE { -- for ERRORs
UNWIND => {
s _ AbortFile[s];  
CDViewer.RemoveArrow[design]; 
TerminalIO.WriteRope[" ** plot aborted ** "]
};
};
dr: CD.DrawRef = CD.CreateDrawRef[design]; 
scale: REAL _ MIN[
REAL[maxPixPerLambda] / design.technology.lambda,
REAL[(scanLineWidth-overLap)*strips+overLap] / plotSize.x
];
pageStep: CD.Position;
pageWidth: CD.Position;

imageFSize _ scanLineWidth;
imageSSize _ Real.FixC[plotSize.y*scale]+1;
IF paged THEN {
imageSSize _ MIN[imageSSize, pageSlowSize];
scale _ MIN[scale, REAL[pageSlowSize]/(plotSize.y+1)];
};

ps _ NEW[PlotState _ [
scale: scale,
totalPlotClip: plotClip,
colorLoads: NEW[ColorDescription _ ALL[NIL]]
]];
pageStep _ [plotSize.x/strips, plotSize.y];
pageWidth _ [Real.Round[scanLineWidth/scale], plotSize.y];
plotScale _ scale;
dr.minimalSize _ 0;
dr.stopFlag _ abortPlot;
dr.drawRect _ NoteRectangle;
dr.drawContext _ DrawContext;
dr.contextFilter _ contextFilter;
dr.devicePrivate _ ps;
FOR strip: INT IN [0..strips) DO
localFileName: Rope.ROPE = CDIO.MakeName[wDir: "///temp/", base: "plot", modifier: IO.PutFR["%d", IO.int[strip+1]], ext: "pd"];
TerminalIO.WriteRopes["Recording strip on file ", localFileName, "\n"];
stripClip _ [ --but not yet intersected with complete design clip
x1:  plotClip.x1+strip*pageStep.x,
y1:  plotClip.y1,
x2:  plotClip.x1+strip*pageStep.x+pageWidth.x,
y2:  plotClip.y2
];
ps.pdState _ PDFileWriter.Create[
fileName: localFileName, 
deviceCode: deviceCode, 
sResolution: sRes, 
fResolution: fRes, 
imageSSize: imageSSize, 
imageFSize: imageFSize, 
bandSSize: bandSSize, 
leftOverMode: leftOverMode
];
ps.colorLoads^ _ ALL[NIL];
PDFileWriter.StartImage[pdState: ps.pdState, toners: toners];
FOR bandYtop: INT _ 0, bandYtop+bandSSize WHILE bandYtop<imageSSize DO
dc: CD.Rect; --clip for band in design coordinates; little larger than band
IF abortPlot^ THEN GOTO AbortPlot;
pdy _ bandYtop;
dc _ CDBasics.NormalizeRect[[
x1: stripClip.x1-1, 
y1: stripClip.y2-Real.Fix[(bandYtop+bandSSize)/scale]-1, 
x2: stripClip.x1+Real.Fix[scanLineWidth/scale]+1, 
y2: stripClip.y2-Real.Fix[bandYtop/scale]+1
]] ;
dr.interestClip _ ps.bandClip _ CDBasics.Intersection[plotClip, dc];
CDViewer.ShowArrow[design: design, pos: [
x: (dr.interestClip.x1+dr.interestClip.x2)/2, 
y: (dr.interestClip.y1+dr.interestClip.y2)/2]
];
ps.anouncedLayer _ -1;
FOR l: CD.Layer IN CD.Layer DO
IF ps.tes[l]#NIL THEN
CornerStitching.ChangeRect[plane: ps.tes[l], rect: CDBasics.universe, newValue: NIL];
ENDLOOP;
CDOps.DrawDesign[design, dr]; -- build tesselations of the relevant design rectangle
AnalyzeTesselations[ps]; --will actually draw
TerminalIO.WriteRope["."];
ENDLOOP;  -- for each band in the strip
PDFileWriter.EndPage[ps.pdState];
PDFileWriter.Close[ps.pdState];
TerminalIO.WriteRope["*\n"];
ENDLOOP;  -- for each strip
TerminalIO.WriteRope[" finished plot(s)\n"];
CDViewer.RemoveArrow[design: design];
plottingInProgress _ FALSE;
EXITS
AbortPlot => {
s _ AbortFile[s]; 
CDViewer.RemoveArrow[design]; 
TerminalIO.WriteRope[" ** plot aborted ** "]; 
};
END;  -- enable
END;  -- PlotDesign

NoteRectangle: PROC [r: CD.Rect, l: CD.Layer, pr: CD.DrawRef] =
BEGIN
ps: PlotStateRef = NARROW[pr.devicePrivate];
IF CDBasics.NonEmpty[r] THEN {
IF ps.tes[l]=NIL THEN ps.tes[l] _ CornerStitching.NewTesselation[];
ps.tes[l].ChangeRect[rect: r, newValue: $covered];
};
END;

SetColor: PROC [ps: PlotStateRef, lev: CD.Layer] =
BEGIN
Stipple16: TYPE = ARRAY[0..16) OF CARDINAL;
Stipple8: TYPE = ARRAY[0..8) OF [0..256);
Stipple4: TYPE = ARRAY[0..4) OF [0..16);

ToTexture: PROC [pattern: REF ANY] RETURNS [texture: Stipple16] =
BEGIN
IF pattern=NIL THEN RETURN[Stipple16[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]; -- should not occur
WITH pattern SELECT FROM
s16: REF Stipple16 => texture _ s16^;
s8: REF Stipple8 => 
FOR  i: [0..8) IN [0..8) DO
texture[i] _ texture[i+8] _ (256+1)*s8[i];
ENDLOOP;
s4: REF Stipple4 =>
FOR  i: [0..4) IN [0..4) DO
texture[i] _ texture[i+4] _ texture[i+8] _ texture[i+12] _ s4[i]*1111H;
ENDLOOP;
ENDCASE => RETURN[Stipple16[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0FFFFH]];  -- error texture
RETURN [texture]
END; -- ToTexture

MakeLoadref: PROC [pattern: REF ANY] RETURNS [loadRef: PDFileWriter.LoadReference] =
TRUSTED BEGIN
texture: Stipple16 _ ToTexture[pattern];
loadRef _ PDFileWriter.LoadContiguousColorTile[pdState: ps.pdState, phase: 0, sMin: 0, fMin: 0, sSize: 16, fSize: 16, bitsPtr: @texture];
END;  -- MakeLoadref

MakeLoad: PROC [ps: PlotStateRef, lev: CD.Layer] =
BEGIN
IF ps.colorLoads^[lev]=NIL THEN {
ps.colorLoads^[lev] _ NEW[LoadArray];
FOR toner: Toner IN Toner DO
tex: REF _ CDProperties.GetPropFromLayer[from: lev, prop: tonerToKey[toner]];
IF tex=NIL THEN ps.colorLoads^[lev][toner] _ whiteLoadRef
ELSE ps.colorLoads^[lev][toner] _ MakeLoadref[tex]
ENDLOOP;
};
END; --MakeLoad

IF ps.anouncedLayer=lev THEN RETURN;
IF ps.colorLoads^[lev]=NIL THEN MakeLoad[ps, lev];
FOR toner: Toner IN Toner DO
IF ps.colorLoads^[lev][toner] = whiteLoadRef THEN 
PDFileWriter.SetColorOff[ps.pdState, toner]
ELSE
PDFileWriter.SetColorTile[ps.pdState, toner, ps.colorLoads^[lev][toner], transparent];
ENDLOOP;
ps.anouncedLayer _ lev
END;

contextFilter: REF CD.ContextFilter = NEW[CD.ContextFilter_ALL[Imager.black]];

PlotPolygon: PROC [ob: CD.Object, pos: CD.Position, orient: CD.Orientation] =
BEGIN

OutputTrapezoid: PROCEDURE [xbotL: REAL, xbotR: REAL, ybot: REAL, xtopL: REAL, xtopR: REAL, ytop: REAL] =
BEGIN
PDFileWriter.MaskTrapezoid[
pdState: ps.pdState, 
sMin: Real.RoundC[ybot], 
sSize: Real.RoundC[ytop-ybot], 
fMin: Real.RoundC[xbotL], 
fSize: Real.RoundC[xbotR-xbotL], 
fMinLast: Real.RoundC[xtopL], 
fSizeLast: Real.RoundC[xtopR-xtopL]
];
END; --OutputTrapezoid

pp: CDPolygons.PolygonPtr = NARROW[ob.specificRef];
polygon: CGReducer.Ref = CGReducer.New[size: 8];
tiling: CGArea.Ref = CGArea.New[size: 4];
clipRef: CGClipper.Ref = CGClipper.New[size: 4];
clip: GraphicsBasic.Box _ [
xmin: 0, 
ymin: pdy, 
xmax: MIN[(ps.bandClip.x2-stripClip.x1)*plotScale, imageFSize], 
ymax: MIN[pdy+bandSSize, imageSSize]
];
CGClipper.SetBox[self: clipRef, box: clip];
CGClipper.Load[self: clipRef, reducer: polygon];
FOR p: LIST OF CD.Position _ pp.points, p.rest WHILE p#NIL DO
at: CD.Position = CDOrient.MapPoint[
pointInCell: p.first,
cellSize: ob.size,
cellInstOrient: orient,
cellInstPos: pos
];
CGReducer.Vertex[self: polygon, v: [
x: (at.x-stripClip.x1)*plotScale, 
y: (stripClip.y2-at.y)*plotScale
]]
ENDLOOP;
CGReducer.Close[polygon];
CGReducer.Generate[self: polygon, area: tiling];
UNTIL CGArea.Empty[tiling] DO
t: GraphicsBasic.Trap = CGArea.Remove[tiling];
OutputTrapezoid[t.xbotL, t.xbotR, t.ybot, t.xtopL, t.xtopR, t.ytop];
ENDLOOP;
END; --PlotPolygon

DrawContext: PROC [pr: CD.DrawRef, proc: CD.DrawContextLayerProc, ob: CD.Object, pos: CD.Position, orient: CD.Orientation, layer: CD.Layer] =
BEGIN
IF CDPolygons.IsPolygon[ob] THEN {
SetColor[ps, layer];
PlotPolygon[ob, pos, orient];
}
ELSE CDDefaultProcs.DrawContext[pr, proc, ob, pos, orient, layer]
END;

AnalyzeTesselations: PROC [ps: PlotStateRef] =
BEGIN
FOR lev: CD.Layer IN CD.Layer DO
IF ps.tes[lev]#NIL THEN {
SetColor[ps, lev];
CornerStitching.EnumerateArea[plane: ps.tes[lev], rect: ps.bandClip, perTile: ProcessTile, data: ps];
};
ENDLOOP;
END;

ProcessTile: PROCEDURE [tile: REF CornerStitching.Tile, data: REF ANY] =
BEGIN 
IF tile.Value = $covered THEN {
rightBound, xStart, xStop, yStart, yStop: INT;
cxStart, cxStop, cyStop, cyStart: CARDINAL;
sSize, fSize: CARDINAL;
ps: PlotStateRef = NARROW[data];
r: CD.Rect = tile.Area;
xStart _ Real.Round[(r.x1-stripClip.x1)*plotScale];
yStop _ Real.Round[(stripClip.y2-r.y1)*plotScale]; 
xStop _ Real.Round[(r.x2-stripClip.x1)*plotScale];
yStart _ Real.Round[(stripClip.y2-r.y2)*plotScale];  
rightBound _ Real.Round[(ps.bandClip.x2-stripClip.x1)*plotScale];
IF xStart>rightBound OR xStop<0 THEN RETURN;
IF yStop<pdy OR yStart>MIN[imageSSize, pdy+bandSSize] THEN RETURN;
cxStart _ MAX[xStart, 0];
cxStop _ MIN[xStop, rightBound, imageFSize];
cyStart _ MAX[yStart, pdy];
cyStop _ MIN[yStop, pdy+bandSSize, imageSSize];
fSize _ cxStop - cxStart;
sSize _ cyStop - cyStart;
IF sSize>0 AND fSize>0 THEN PDFileWriter.MaskRectangle[pdState: ps.pdState, sMin: cyStart, fMin: cxStart, sSize: sSize, fSize: fSize];
};
END;

AbortFile: PROC [s: IO.STREAM] RETURNS [IO.STREAM] = {
IF s#NIL THEN s.Close[abort: TRUE]; 	
RETURN[NIL]
};
PDColorPlotComm: PROC [comm: CDSequencer.Command] =
BEGIN 
TerminalIO.WriteRope["Color plot\n"]; 
[] _ CDCommandOps.CallWithResource[ProtectedPlotDesign, comm, $ColorPlot, abortPlot];
END;

WaitPlotFinishedCommand: Commander.CommandProc = 
BEGIN
prio: Process.Priority = Process.GetPriority[];
IF ~plottingInProgress THEN { 
IO.PutRope[cmd.out, "  waiting for plot to start"];
WHILE ~plottingInProgress DO
Process.Pause[Process.SecondsToTicks[1]];
ENDLOOP;
IO.PutRope[cmd.out, ". plot started...\n"]
};
Process.SetPriority[Process.priorityBackground];
WHILE plottingInProgress DO
Process.Pause[Process.SecondsToTicks[2]];
ENDLOOP;
Process.SetPriority[prio];
IO.PutRope[cmd.out, "  finished\n"]
END;

Init: PROC [] = 
BEGIN
tonerToKeyKeys[black] _ $CDxColorPDPlotBlack;
tonerToKeyKeys[cyan] _ $CDxColorPDPlotCyan;
tonerToKeyKeys[magenta] _ $CDxColorPDPlotMagenta;
tonerToKeyKeys[yellow] _ $CDxColorPDPlotYellow;
CDSequencer.ImplementCommand[a: $VersatecColorPlot, p: PDColorPlotComm, queue: doQueue];
CDSequencer.ImplementCommand[a: $C150ColorPlot, p: PDColorPlotComm, queue: doQueue];
CDSequencer.ImplementCommand[a: $Color400Plot, p: PDColorPlotComm, queue: doQueue];
CDSequencer.ImplementCommand[a: $PuffinColorPlot, p: PDColorPlotComm, queue: doQueue];
CDSequencer.ImplementCommand[a: $PlatemakerColorPlot, p: PDColorPlotComm, queue: doQueue];
CDMenus.CreateEntry[$HardCopyMenu, "PD Color Versatec", $VersatecColorPlot];
CDMenus.CreateEntry[$HardCopyMenu, "PD C150", $C150ColorPlot];
CDMenus.CreateEntry[$HardCopyMenu, "PD Puffin, (1 page)", $PuffinColorPlot];
CDMenus.CreateEntry[$HardCopyMenu, "PD Platemaker", $PlatemakerColorPlot];
CDMenus.CreateEntry[$HardCopyMenu, "PD Color400", $Color400Plot];
Commander.Register[
key: "CDWaitPlotFinished", 
proc: WaitPlotFinishedCommand,
doc: "waits until ChipNDale pd plotting is finished"
];
TerminalIO.WriteRope["ChipNDale color plot program loaded\n"];
END;

Init[];
END. 


ώCDColorPDPlot.mesa  
Jacobi, February 28, 1986 5:18:25 pm PST

Copyright c 1983, 1985 by Xerox Corporation.  All rights reserved.
written by E. McCreight,  August 1, 1983  2:00 PM
Last Edited by: McCreight,  November 23, 1983 4:58 pm
Last Edited by: Jacobi,  October 27, 1983 12:36 pm
Last Edited by: Jacobi,  April 11, 1985 3:21:48 pm PST
Last Edited by: Kimr,  October 29, 1984 9:49:48 am PST
--handling colors
-- used to identify tiles without toner so that you can avoid recording them
--gives a key to get the keys to get the color stipple as property of the layers 

--device description
--gives a key to get the color stipple as property of the layers 
--state of the plot
--rectangles in design space touching all geometry in the plot, or this band
xoffset: INT _ -stripClip.x1*scale; 
yoffset: INT _ stripClip.y2*scale; 
--ENABLE UNWIND => plottingInProgress _ FALSE; 
--dont, we better wait longer...
--Center the x range of the selected area of the design on the plotter bed, with at most maxPixPerLambda pixels per lambda. If multiple strips are called for, overlap adjacent ones by "overLap" pixels.
-- total number of pixels across plot = REAL[scanLineWidth]+REAL[scanLineWidth-overLap]*(strips-1))
-- For each band in the strip
-- Determine coordinate transformations
--Display current band under consideration to pacify user
-- clear previous tessalations 
--tries to convert pattern to a texture stipple
--makes the load if it does not already exist
--SetColor
--lower left x, lower right x, lower y, upper left x, upper right x, upper y
--global variables ps, stripClip, plotScale, imageFSize, imageSSize, pdy
--x-Fast
--y-Slow
--PlotPolygon
--CornerStitching.PerTileProc 
-- calculate device coords of rectangle
-- clip device rectangle
-- print device rectangle

Κ˜
codeš
œ™K™(K™Kšœ
Οm
œ7™BKš
œ1™1Kš
œ5™5K™2K™6K™6—K˜š
Οk	˜	Kšžœ
˜Kš
œ	˜	Kš
œ
˜
Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ
˜
Kš
œ˜š
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ
˜
—Kš
œ
˜
Kš
œ˜Kš
œ˜Kšžœ
˜K˜
K˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜šΠbl
œžœ
ž˜Kšžœ
žœAΟc
œŒ
žœ+˜‡—Kš
ž˜K˜Kšœžœžœ
˜!K˜Kš
Οb™K˜Kšœžœ )˜LKš	œžœžœžœ
žœ
˜%Kšœžœžœžœ˜<Kšœžœžœ
žœžœ
žœ
žœ
žœ˜DK˜šœ+žœ˜MKš
œL™L—K˜š	œžœ
žœ
žœ
žœ˜:Kš
œQ™Q—K™Kš
‘™K˜Kš
œ-˜-Kšœžœ	 /˜FKšœžœ	 -˜DKšœžœ	 ;œ
˜\Kšœ žœ
žœ˜+Kšœžœžœ
˜K˜Kšœžœ 3˜NKšœ	žœ	 .˜HKšœžœ %˜@K˜Kšœžœžœ
˜šœ
žœžœ ˜7Kšœžœ *˜F—K˜Kšœžœ˜ šœžœ
žœ
˜ Kš
œA™A—K˜K˜šΟn
œžœ˜Kš
ž˜Kšœ 0˜EKšœ
 /˜<Kšœ
 -˜:Kšœ ;œ
˜RKšœ	žœ
žœ˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœ 3˜DKšœ .˜>Kšœ %˜;Kšœžœ
˜Kšœžœ
˜Kš
œ˜Kš
œ'˜'Kšžœ
˜—K˜š’
œžœ˜Kš
ž˜Kšœ
žœ˜Kšœ
 /˜<Kšœ
 -˜:Kš
œ˜Kšœ	žœ
žœ˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœ ˜Kšœ .˜=Kšœ %˜;Kšœžœ
˜Kšœžœ
˜Kš
œ˜Kšœžœ
˜Kš
œ˜Kš
œ ˜ Kšžœ
˜—K˜š’œžœ˜Kš
ž˜Kšœ
žœ˜Kšœ
 /˜<Kšœ
 -˜:Kš
œ˜Kšœ	žœ
žœ˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœ ˜Kšœ .˜=Kšœ %˜<Kšœžœ
˜
Kš
œ˜Kšœžœ
˜Kš
œ˜Kš
œ!˜!Kšžœ
˜—K˜š’œžœ˜Kš
ž˜Kš
œ/˜/Kšœ
 /˜<Kšœ
 -˜:Kš
œ˜Kšœ	žœ
žœ˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœ ˜Kšœ .˜=Kšœ %˜;Kšœžœ
˜
Kš
œ˜Kšœžœ
˜Kš
œ˜Kš
œ˜Kšžœ
˜—K˜š’
œžœ˜Kš
ž˜Kš
œ-˜-Kšœ /˜=Kšœ -˜;Kš
œ˜Kšœ	žœ
žœ˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœ ˜Kšœ .˜=Kšœ %˜;Kšœžœ
˜
Kš
œ˜Kšœžœ
˜Kš
œ˜Kš
œ,˜,Kšžœ
˜—K˜Kš
‘™K˜Kšœžœ ˜OK˜Kšœžœ
žœžœ
žœžœ˜(K˜Kšœžœžœ˜#šœžœžœ˜Kš
œžœ
žœžœ
žœžœ
žœ˜CKšœžœ ˜*šœžœ˜0Kš
œL™L—K˜Kšœžœ˜!Kšœžœ˜Kš
œ˜—K˜šœžœ ˜2Kš
œ$™$Kš
œ#™#—Kšœžœ 3˜HKšœžœ˜Kšœžœ
˜Kšœžœ
˜K˜Kš
œ˜K˜š’œžœ˜Kš
ž˜Kšœžœ
žœ˜š	žœžœžœ
žœž˜šžœžœž˜š
žœžœ
žœAžœ
žœ˜gKš
œ!˜!Kš
ž˜K˜—Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—K˜š’
œžœžœ˜1Kš
ž˜Kšœžœ)˜/šžœžœ
ž˜Kšœžœ>˜Jšžœ˜Kš
œ;˜;Kšžœ
ž˜
K˜——šžœPž˜VKš
Ϡ
˜†
—Kšœ
žœ
žœ
žœ˜'šžœžœž˜2Kš
œM˜Mšžœžœžœ
žœ˜*Kšœžœ
˜Kšœžœ
žœ˜K˜—Kšžœ
˜—Kš
œ˜Kšžœ
˜—K˜š’œžœžœžœ˜HKš
ž˜šžœ%žœ"ž˜U˜Kš
œ0˜0Kš
œ)˜)K˜—šžœ˜Kš
œ-˜-Kš
œ#˜#K˜——šžœžœžœ˜>Kš
œ3˜3Jšžœ
ž˜
K˜—Kšžœ
˜—K˜š’œžœ˜7š
ž˜Kš
œ/™/Kš
œ ™ —Kšœžœ˜ Kšœ
žœ˜Kšœ
žœ
˜Kšœžœ
žœžœ
˜Kšœžœ
˜Kšœžœ
˜Kš
œ1˜1šžœž˜Kš
œ&˜&Kš
œ˜Kš
œ˜Kš
œ%˜%Kš
œ˜Kšžœžœ
˜—Kš
œ˜Kš
œ!˜!Kš
œ˜Kš
œ)˜)Kšžœ3˜:Kš
œ˜šžœžœžœ˜!šžœKž˜QKš
œE˜E—K˜—Kšœ	žœžœ˜!šžœ
˜šžœ
 
˜šžœ˜Kš
œ˜Kš
œ˜Kš
œ,˜,Kš
œ˜—Kš
œ˜—Kšœžœžœ˜+šœžœžœ
˜Kšžœ-˜1Kšžœ5˜9Kš
œ˜Kš
œΙ
™Ι
Kšœ(žœžœ#™c—K˜K˜K˜Kš
œ˜Kš
œ+˜+šžœžœ˜Kšœ
žœ˜+Kšœžœžœ˜6Kš
œ˜—K˜šœžœ˜Kš
œ
˜
Kš
œ˜Kšœžœžœ
žœ˜,Kš
œ˜—Kš
œ+˜+Kš
œ:˜:Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ!˜!K˜šžœžœ
žœ
ž˜ Kš	œžœžœ4žœ
žœ˜K˜Gšœ 3˜AKš
œ"˜"Kš
œ˜Kš
œ.˜.Kš
œ˜Kš
œ˜—š
œ!˜!Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kšœžœ
žœ˜Kš
œ=˜=K™šžœžœžœž˜FKšœžœ >˜KKšžœžœ
žœ˜"K™'K˜š
œ˜Kš
œ˜Kš
œ9˜9Kš
œ2˜2Kš
œ+˜+Kš
œ˜—Kš
œD˜DK™9š
œ)˜)Kš
œ.˜.Kš
œ-˜-Kš
œ˜—Kš
œ™Kš
œ˜š	žœžœžœ
žœž˜šžœžœ
ž˜KšœPžœ˜U—Kšžœ
˜—Kšœ 6˜TKšœ ˜-Kš
œ˜Kšžœ ˜'—K˜!K˜Kš
œ˜Kšžœ ˜—Kš
œ,˜,Kš
œ%˜%Kšœžœ
˜š
ž˜š
œ˜Kš
œ˜Kš
œ˜Kš
œ.˜.Kš
œ˜——Kšžœ 	˜—Kšžœ 
˜K˜—š
’
œžœžœ
žœžœ˜?Kš
ž˜Kšœžœ˜,šžœžœ˜Kšžœžœ
žœ.˜CKš
œ2˜2Kš
œ˜—Kšžœ
˜—K˜š’œžœžœ	˜2Kš
ž˜Kš	œžœžœžœ
žœ
˜+Kšœ
žœžœžœ
˜)Kšœ
žœžœžœ	˜(K˜š
’	œžœžœ
žœžœ˜AKš
œ/™/Kš
ž˜Kš	žœ	žœ
žœ
žœ. ˜[šžœ	žœ
ž˜Kšœžœ˜%šœžœ
˜šžœžœž˜Kš
œ*˜*Kšžœ
˜——šœžœ˜šžœžœž˜Kš
œG˜GKšžœ
˜——Kšžœžœ4 ˜U—Kšžœ
˜Kšžœ ˜—K˜š
’œžœžœ
žœžœ(˜TKšžœ
ž˜
Kš
œ(˜(Kš
œ‰
˜‰
Kšžœ ˜—K˜š’œžœžœ	˜2Kš
œ-™-Kš
ž˜šžœžœ
žœ˜!Kšœžœ˜%šžœžœž˜KšœžœE˜MKšžœžœ
žœ*˜9Kšžœ.˜2Kšžœ
˜—K˜—Kšžœ 
˜—K˜Kš
œ
™
Kšžœžœ
žœ
˜$Kšžœžœ
žœ˜2šžœžœž˜šžœ+žœ
˜2Kš
œ+˜+—š
ž˜Kš
œV˜V—Kšžœ
˜—Kš
œ˜Kšžœ
˜—K˜Kšœžœ
žœžœ
žœžœ˜NK˜š
’œžœžœžœžœ˜MKš
ž˜K˜š’œž	œ	žœ	žœžœ	žœ	žœžœ˜iKš
œL™LKš
ž˜Kš
œH™HKš
œ™Kš
œ™š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ!˜!Kš
œ˜Kš
œ#˜#K˜—Kšžœ ˜K˜—Kš
œ
™
Kšœžœ˜3Kš
œ0˜0Kš
œ)˜)Kš
œ0˜0š
œ˜Kš
œ	˜	Kš
œ˜Kšœžœ7˜@Kšœžœ˜$Kš
œ˜—Kš
œ+˜+Kš
œ0˜0š
žœžœ
žœ
žœžœžœ
ž˜=šœžœ˜$Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—š
œ$˜$Kš
œ"˜"Kš
œ ˜ Kš
œ˜—Kšžœ
˜—Kš
œ˜Kš
œ0˜0šžœž˜Kš
œ.˜.Kš
œD˜DKšžœ
˜—Kšžœ 
˜—K˜š’œžœžœžœžœžœžœžœ	˜
Kš
ž˜šžœžœ˜"Kš
œ˜Kš
œ˜K˜
—Kšžœ=˜AKšžœ
˜—K˜š’œžœ˜.Kš
ž˜š	žœžœžœ
žœž˜ šžœ
žœ
žœ˜Kš
œ˜Kš
œe˜eKš
œ˜—Kšžœ
˜—Kšžœ
˜K˜—š
’œž	œžœžœ
žœ˜HKš
œ™Kšžœ
˜šžœžœ˜Kšœ*žœ
˜.Kšœ"žœ
˜+Kšœžœ
˜Kšœžœ˜ Kšœžœ˜Kš
œ'™'Kš
œ3˜3Kš
œ3˜3Kš
œ2˜2Kš
œ5˜5Kš
œ™Kš
œA˜AKšžœžœ	žœ
žœ
˜,Kš
žœžœžœžœ
žœ
˜BKš
œ™Kšœ
žœ˜Kšœ	žœ ˜,Kšœ
žœ˜Kšœ	žœ#˜/K˜Kš
œ˜Kšžœ	žœ	žœk˜†
Kš
œ˜—Kšžœ
˜K˜—š’	œžœžœ
žœžœžœ
žœ˜6Kš	žœžœ
žœžœž
˜%Kšžœ
žœ
˜Kš
œ˜—K™š’œžœ˜3Kšžœ
˜Kš
œ&˜&Kš
œU˜UKšžœ
˜K˜—š‘œ˜1Kš
ž˜Kš
œ/˜/šžœžœ˜Kšžœ1˜3šžœž˜Kš
œ)˜)Kš
ž˜—Kšžœ(˜*K˜—Kš
œ0˜0šžœž˜Kš
œ)˜)Kšžœ
˜—Kš
œ˜Kšžœ!˜#Kšžœ
˜—K˜š’œžœ˜Kš
ž˜Kš
œ-˜-Kš
œ+˜+Kš
œ1˜1Kš
œ/˜/Kš
œX˜XKš
œT˜TKš
œS˜SKš
œV˜VKš
œZ˜ZKš
œL˜LKš
œ>˜>Kš
œL˜LKš
œJ˜JKš
œA˜Aš
œ˜Kš
œ˜Kš
œ˜Kš
œ4˜4Kš
œ˜—Kš
œ>˜>Kšžœ
˜K˜—Kš
œ˜Kšžœ˜K˜K˜—…—G˜e°