DIRECTORY AISFileFormat, AISIO, Basics, CtBasic, CtFile, Commander, FileNames, FS, Imager, ImagerBackdoor, ImagerBox, ImagerColor, ImagerPixel, ImagerPixelArray, ImagerSample, ImagerTransformation, InterpressInterpreter, IO, MessageWindow, Process, RefText, Rope, SF;

CtFileImpl: CEDAR PROGRAM
IMPORTS AISIO, Basics, CtBasic, FileNames, FS, ImagerSample, IO, MessageWindow, Process, RefText, Rope, SF
EXPORTS CtFile

~ BEGIN
	
SampleMap:			TYPE ~ CtBasic.SampleMap;
SampleMaps:			TYPE ~ CtBasic.SampleMaps;
PixelArray:			TYPE ~ CtBasic.PixelArray;
RealPair:				TYPE ~ CtBasic.RealPair;
FileInfo: 				TYPE ~ CtFile.FileInfo;
FileType: 			TYPE ~ CtFile.FileType;
Context:				TYPE ~ Imager.Context;
Box:					TYPE ~ ImagerSample.Box;
Vec:					TYPE ~ ImagerSample.Vec;
SampleBuffer:		TYPE ~ ImagerSample.SampleBuffer;
RasterSampleMap:	TYPE ~ ImagerSample.RasterSampleMap;
STREAM:				TYPE ~ IO.STREAM;
ROPE:					TYPE ~ Rope.ROPE;
WriteMapsToAIS: PUBLIC PROC [maps: SampleMaps, name: ROPE, stream: STREAM ¬ NIL] ~ {
saving: ROPE ¬ IO.PutFLR["Saving (%g %g %g %g) ",
LIST[IO.int[maps.x], IO.int[maps.y], IO.int[maps.w], IO.int[maps.h]]];
SELECT maps.bpp FROM
1, 8 => {
IF stream # NIL THEN IO.PutF[stream, "%g%g . . . ", IO.rope[saving], IO.rope[name]];
SaveSampleMapToFile[maps[0].map, name];
IF stream # NIL THEN IO.PutRope[stream, "done\n"];
};
24 => {
IF stream # NIL THEN IO.PutRope[stream, saving];
IF stream # NIL THEN IO.PutF1[stream, "%g-red.ais . . . ", IO.rope[name]];
SaveSampleMapToFile[maps[0].map, Rope.Concat[name, "-red.ais"]];
IF stream # NIL THEN IO.PutF1[stream, "%g-grn.ais . . . ", IO.rope[name]];
SaveSampleMapToFile[maps[1].map, Rope.Concat[name, "-grn.ais"]];
IF stream # NIL THEN IO.PutF1[stream, "%g-blu.ais . . . ", IO.rope[name]];
SaveSampleMapToFile[maps[2].map, Rope.Concat[name, "-blu.ais"]];
IF stream # NIL THEN IO.PutRope[stream, "done\n"];
};
ENDCASE => NULL;
};
SaveSampleMapToFile: PUBLIC PROC [
source: SampleMap,
aisFileName: ROPE,
comment: ROPE ¬ NIL]
~ {
AISIO.Write[aisFileName, source, NIL, NIL, LIST[comment]];
};
Error: PUBLIC ERROR [reason: ROPE] = CODE;

ReadFile: PUBLIC PROC [
baseName: ROPE,
aisX, aisY: CARDINAL ¬ 0,
aisW, aisH: CARDINAL ¬ LAST[CARDINAL],
maps: SampleMaps ¬ NIL]
RETURNS [ret: SampleMaps]
~ {
i: FileInfo ¬ Parse[baseName];
ret ¬ SELECT i.type FROM
bw => Read8BitFile[i.names[0], aisX, aisY, aisW, aisH, maps],
color => Read24BitFile[i.names[0], i.names[1], i.names[2], aisX, aisY, aisW, aisH, maps],
ENDCASE => NIL;
};

ReadFileAndClip: PROC [name: ROPE, x, y, w, h: CARDINAL] RETURNS [map: SampleMap] ~ {
V: PROC [c: AISFileFormat.Card16] RETURNS [CARD] ~ {RETURN[Basics.Card16FromH[c]]};
i: AISIO.Info ¬ AISIO.ReadInfo[name];
w ¬ MIN[w, V[i.raster.scanLength]];
h ¬ MIN[h, V[i.raster.scanCount]];
map ¬ ImagerSample.ZeroOrigin[ImagerSample.Clip[AISIO.Read[name], [[y, x], [y+h, x+w]]]];
};

Read8BitFile: PUBLIC PROC [
name: ROPE,
aisX, aisY: CARDINAL ¬ 0,
aisW, aisH: CARDINAL ¬ LAST[CARDINAL],
maps: SampleMaps ¬ NIL]
RETURNS [ret: SampleMaps]
~ {
bw: SampleMap ¬ ReadFileAndClip[name, aisX, aisY, aisW, aisH];
size: SF.Vec ¬ ImagerSample.GetSize[bw];
IF (ret ¬ maps) = NIL OR maps.w < size.f OR maps.h < size.s
THEN ret ¬ CtBasic.CreateMaps[8, 0, 0, size.f, size.s];
ImagerSample.BasicTransfer[ret[0].map, bw, ret.box.min,, size];
};

Read24BitFile: PUBLIC PROC [
rName, gName, bName: ROPE,
aisX, aisY: CARDINAL ¬ 0,
aisW, aisH: CARDINAL ¬ LAST[CARDINAL],
maps: SampleMaps ¬ NIL]
RETURNS [ret: SampleMaps]
~ {
Union: PROC [box1, box2: Box] RETURNS [u: Box] ~ {
u ¬ [SF.Min[box1.min, box2.min], SF.Max[box1.max, box2.max]];
};
GetBox: PROC [m: SampleMap] RETURNS [b: Box] ~ {b ¬ ImagerSample.GetBox[m]};
red: SampleMap ¬ ReadFileAndClip[rName, aisX, aisY, aisW, aisH];
grn: SampleMap ¬ ReadFileAndClip[gName, aisX, aisY, aisW, aisH];
blu: SampleMap ¬ ReadFileAndClip[bName, aisX, aisY, aisW, aisH];
size: SF.Vec ¬ SF.Size[Union[GetBox[red], Union[GetBox[grn], GetBox[blu]]]];
IF (ret ¬ maps) = NIL OR maps.bpp # 24 OR maps.w < size.f OR maps.h < size.s
THEN ret ¬ CtBasic.CreateMaps[24, 0, 0, size.f, size.s];
ImagerSample.BasicTransfer[ret[0].map, red, ret.box.min,, size];
ImagerSample.BasicTransfer[ret[1].map, grn, ret.box.min,, size];
ImagerSample.BasicTransfer[ret[2].map, blu, ret.box.min,, size];
};

ReadPixelArray: PUBLIC PROC [aisFileName: ROPE] RETURNS [pa: PixelArray] ~ {
pa ¬ CtBasic.PixelArrayFromSampleMap[AISIO.Read[aisFileName]];
};
ReadDumpFile: PUBLIC PROC [
fileName: ROPE,
maps: SampleMaps ¬ NIL,
ascii: BOOL ¬ FALSE,
nChannels: NAT ¬ 0,
width, height: NAT ¬ 0,
contiguous: BOOL ¬ TRUE]
RETURNS [SampleMaps]
~ {
LineStatus: PROC [y: NAT] ~ {
Process.CheckForAbort[];
IF y MOD 10 = 0 OR y = height-1 THEN
MessageWindow.Append[IO.PutFR["line %g/%g", IO.int[y], IO.int[height-1]], TRUE];
};
ReadLine: PROC [y: NAT, b: SampleBuffer, m: SampleMap] ~ {
LineStatus[y];
IF ascii
THEN FOR x: NAT IN [0..width) DO b[x] ¬ IO.GetInt[s]; ENDLOOP
ELSE FOR x: NAT IN [0..width) DO b[x] ¬ IO.GetByte[s]; ENDLOOP;
ImagerSample.PutSamples[m, [y, 0],, b,, width];
};
box: SF.Box;
bw, r, g, b: SampleBuffer;
bwMap, rMap, gMap, bMap: SampleMap;
s: STREAM ¬ FS.StreamOpen[fileName ! FS.Error => Error["Can't open file."]];
IF s = NIL THEN Error["Can't open file."];
IF nChannels = 0 OR width = 0 OR height = 0 THEN {
IF ascii
THEN {
nChannels ¬ IO.GetInt[s];
width ¬ IO.GetInt[s];
height ¬ IO.GetInt[s];
}
ELSE {
nChannels ¬ INT[Basics.Card16FromH[IO.GetHWord[s]]];
width ¬ INT[Basics.Card16FromH[IO.GetHWord[s]]];
height ¬ INT[Basics.Card16FromH[IO.GetHWord[s]]];
};
};
box ¬ [[0, 0], [height, width]];
IF maps = NIL OR maps.w < width OR maps.h < height OR maps.nChannels # nChannels
THEN maps ¬ CtBasic.CreateMaps[nChannels*8, 0, 0, width, height];
IF nChannels = 1
THEN {
bwMap ¬ ImagerSample.ObtainScratchMap[box, 8];
bw ¬ ImagerSample.NewSamples[width];
}
ELSE {
rMap ¬ ImagerSample.ObtainScratchMap[box, 8];
gMap ¬ ImagerSample.ObtainScratchMap[box, 8];
bMap ¬ ImagerSample.ObtainScratchMap[box, 8];
r ¬ ImagerSample.NewSamples[width];
b ¬ ImagerSample.NewSamples[width];
g ¬ ImagerSample.NewSamples[width];
};
SELECT TRUE FROM
nChannels = 1 =>
FOR y: NAT IN [0..height) DO ReadLine[y, bw, bwMap]; ENDLOOP;
nChannels = 3 AND contiguous =>
FOR y: NAT IN [0..height) DO
LineStatus[y];
IF ascii
THEN
FOR x: NAT IN [0..width) DO
r[x] ¬ IO.GetInt[s];
g[x] ¬ IO.GetInt[s];
b[x] ¬ IO.GetInt[s];	
ENDLOOP
ELSE
FOR x: NAT IN [0..width) DO
r[x] ¬ IO.GetByte[s];
g[x] ¬ IO.GetByte[s];
b[x] ¬ IO.GetByte[s];	
ENDLOOP;
ImagerSample.PutSamples[rMap, [y, 0],, r,, width];
ImagerSample.PutSamples[gMap, [y, 0],, g,, width];
ImagerSample.PutSamples[bMap, [y, 0],, b,, width];
ENDLOOP;
nChannels = 3 AND NOT contiguous => {
FOR y: NAT IN [0..height) DO ReadLine[y, r, rMap]; ENDLOOP;
FOR y: NAT IN [0..height) DO ReadLine[y, g, gMap]; ENDLOOP;
FOR y: NAT IN [0..height) DO ReadLine[y, b, bMap]; ENDLOOP;
};
ENDCASE;
IF nChannels = 1
THEN {
ImagerSample.Transfer[dst: maps[0].map, src: bwMap];
ImagerSample.ReleaseScratchMap[bwMap];
}
ELSE {
ImagerSample.Transfer[maps[0].map, rMap];
ImagerSample.Transfer[maps[1].map, gMap];
ImagerSample.Transfer[maps[2].map, bMap];
ImagerSample.ReleaseScratchMap[rMap];
ImagerSample.ReleaseScratchMap[gMap];
ImagerSample.ReleaseScratchMap[bMap];
};
RETURN[maps];
};
ViewFile: PUBLIC PROC [
maps: SampleMaps,
baseName: ROPE,
center, noPlace: BOOL ¬ FALSE,
aisX, aisY: CARDINAL ¬ 0,
aisW, aisH: CARDINAL ¬ LAST[CARDINAL]]
RETURNS [error: ROPE ¬ NIL] ~ {
};

View8BitFile: PUBLIC PROC [
maps: SampleMaps,
name: ROPE,
center, noPlace: BOOL ¬ FALSE,
aisX, aisY: CARDINAL ¬ 0,
aisW, aisH: CARDINAL ¬ LAST[CARDINAL]]
RETURNS [error: ROPE ¬ NIL]
~ {
};

View24BitFile: PUBLIC PROC [
maps: SampleMaps,
rName, gName, bName: ROPE,
center, noPlace: BOOL ¬ FALSE,
aisX, aisY: CARDINAL ¬ 0,
aisW, aisH: CARDINAL ¬ LAST[CARDINAL]]
RETURNS [error: ROPE ¬ NIL]
~ {
};

Display: PUBLIC PROC [
context: Context,
pa: ImagerPixelArray.PixelArray,
op: ImagerColor.ColorOperator,
center: BOOL ¬ TRUE]
~ {
};
ViewDitherFile: PUBLIC PROC [
fileName: ROPE,
context: Context ¬ NIL,
center, cmapInit: BOOL]
RETURNS [error: ROPE ¬ NIL] ~ {
};

ViewGrayFile: PUBLIC PROC [fileName: ROPE, context: Context ¬ NIL, center, cmapInit: BOOL]
RETURNS [error: ROPE ¬ NIL] ~ {
};

ViewColorFiles: PUBLIC PROC [r, g, b: ROPE, center, cmapInit: BOOL ¬ TRUE]
RETURNS [error: ROPE ¬ NIL]
~ {
};

LogError: PUBLIC InterpressInterpreter.LogProc ~ {
};

OpenInterpress: PUBLIC PROC [name: ROPE] RETURNS [master: InterpressInterpreter.Master] ~ {
};

ViewIpFile: PUBLIC PROC [
name: ROPE,
scale: RealPair ¬ [1.0, 1.0],
shift: RealPair ¬ [0.0, 0.0],
cmapInit: BOOL ¬ TRUE]
RETURNS [error: ROPE ¬ NIL]
~ {
};
Parse: PUBLIC PROC [fileName: ROPE] RETURNS [i: FileInfo] ~ {
SuffixIs: PROC [r: ROPE] RETURNS [BOOL] ~ {RETURN[Rope.Equal[suffix, r, FALSE]]};
name: ROPE ¬ FileNames.ResolveRelativePath[fileName];
suffix: ROPE ¬ FileNames.Tail[FileNames.StripVersionNumber[name], '.];
IF (SuffixIs["ip"] OR SuffixIs["interpress"]) AND TestIpName[name]
THEN {i.type ¬ ip; i.names[0] ¬ name; RETURN};
IF SuffixIs["ais"] AND FileExists[name] THEN {i.type ¬ bw; i.names[0] ¬ name; RETURN};
i.names ¬ GetColorAISNames[name];
IF i.names[0] # NIL AND i.names[1] # NIL AND i.names[2] # NIL THEN {
i.type ¬ color;
RETURN;
};
IF FileExists[Rope.Concat[name, ".ais"]]
THEN {i.type ¬ bw; i.names[0] ¬ Rope.Concat[name, ".ais"]; RETURN};
IF TestIpName[Rope.Concat[name, ".ip"]]
THEN {i.type ¬ ip; i.names[0] ¬ Rope.Concat[name, ".ip"]; RETURN};
IF TestIpName[Rope.Concat[name, ".interpress"]]
THEN {i.type ¬ bw; i.names[0] ¬ Rope.Concat[name, ".interpress"]; RETURN};
IF FileExists[name] THEN {i.type ¬ bw; i.names[0] ¬ name};
};

TestIpName: PROC [name: ROPE] RETURNS [ok: BOOL ¬ FALSE] ~ {
IF FileExists[name] THEN {
ipText: REF TEXT ~ "Interpress/";
text: REF TEXT ¬ NEW[TEXT[ipText.length]];
s: FS.STREAM ¬ FS.StreamOpen[name ! FS.Error => GOTO BadFile];
[] ¬ IO.GetBlock[s, text];
ok ¬ RefText.Equal[ipText, text, FALSE];
IO.Close[s];
};
EXITS BadFile => RETURN[FALSE];
};

FileExists: PROC [name: ROPE] RETURNS [ok: BOOL ¬ TRUE] ~ {
[] ¬ FS.FileInfo[name ! FS.Error => {ok ¬ FALSE; CONTINUE}];
};

AisSuffix: PROC [base, suffix: ROPE] RETURNS [name: ROPE] ~ {
name ¬ IO.PutFR["%g-%g.ais", IO.rope[base], IO.rope[suffix]];
};

FileChoice: PROC [r: ROPE, a: ROPE ¬ NIL, b: ROPE ¬ NIL, c: ROPE ¬ NIL]
RETURNS [result: ROPE] ~ {
IF FileExists[result ¬ AisSuffix[r, a]] THEN RETURN;
IF b = NIL THEN RETURN[NIL];
IF FileExists[result ¬ AisSuffix[r, b]] THEN RETURN;
IF c = NIL THEN RETURN[NIL];
IF NOT FileExists[result ¬ AisSuffix[r, c]] THEN RETURN[NIL];
};

GetColorAISNames: PUBLIC PROC [name: ROPE] RETURNS [names: ARRAY [0..3) OF ROPE] ~ {
names[0] ¬ FileChoice[name, "red", "r"];
names[1] ¬ FileChoice[name, "grn", "green", "g"];
names[2] ¬ FileChoice[name, "blu", "blue", "b"];
};

END.

#*
CtFileImpl.mesa
Copyright Σ 1985, 1992 by Xerox Corporation.  All rights reserved.
Plass and Bloomenthal, July 4, 1992 11:21 am PDT
Glassner, July 9, 1991 2:10 pm PDT
File Write Operations

File Read Operations
Dump File Operations
pm: ImagerPixel.PixelMap _ ImagerPixel.MakePixelMap[rMap, gMap, gMap];
pa: ImagerPixelArray.PixelArray_ImagerPixelArray.FromPixelMap[pm,box,[right,down]];
ImagerPixelArray.Transfer[pa: pa, dst: maps[0].map];
Display Operations
Action: PROC ~ {
r, g, b: ROPE;
type: FileType;
[type, r, g, b] _ Parse[baseName];
error _ SELECT type FROM
ip => ViewIpFile[r],
bw => IF maps.bpp = 24
THEN View24BitFile[maps, r, r, r, center, noPlace, aisX, aisY, aisW, aisH]
ELSE View8BitFile[maps[0].map, r, center, noPlace, aisX, aisY, aisW, aisH],
color => IF maps.bpp = 24
THEN View24BitFile[maps, r, g, b, center, noPlace, aisX, aisY, aisW, aisH]
ELSE ViewColorFiles[r, g, b],
ENDCASE	=> Rope.Cat["Bad name: ", baseName];
};
Terminal.ModifyColorFrame[Terminal.Current[], Action]
box: Box _ ImagerSample.GetBox[map];
size: SF.Vec _ SF.Size[box];
ais: AIS.FRef _ AISOpenFile[name ! Error => {error _ reason; GOTO Bad}];
bpp: NAT _ AIS.ReadRaster[ais].bitsPerPixel;
place: AIS.Placement _ AIS.ReadPlacement[ais];
IF noPlace THEN place _ NIL;
SELECT bpp FROM
1, 8 =>  {
ENABLE AIS.Error => {error _ "Error opening file."; GOTO Bad};
wRef: AIS.WRef _ AIS.OpenWindow[ais, aisY, aisY+aisH-1, aisX, aisX+aisW-1];
w: INTEGER _ wRef.lastPixel-wRef.firstPixel+1;
h: INTEGER _ wRef.lastScan-wRef.firstScan+1;
lineMap: RasterSampleMap _ ImagerSample.NewSampleMap[[[0, 0], [1, w]], bpp, bpp*w];
lineBuf: AIS.Buffer _ LineBufferFromRasterSampleMap[lineMap];
shift: Vec _ [0, 0];
SELECT TRUE FROM
center => shift _ [(h-size.s)/2, (w-size.f)/2];
place # NIL => map _ ImagerSample.Shift[map, [-place.yBottom, -place.xLeft]];
ENDCASE;
IF shift.f < 0 THEN {map	_ ImagerSample.Shift[map, [0, shift.f]]; shift.f _ 0};
IF shift.s < 0 THEN {map	_ ImagerSample.Shift[map, [shift.s, 0]]; shift.s _ 0};
FOR i: INT IN [0..h) WHILE i <= size.s DO
TRUSTED {AIS.UnsafeReadLine[wRef, lineBuf, i+shift.s]};
ImagerSample.Transfer[map,ImagerSample.Shift[lineMap,[box.min.s+i,box.min.f-shift.f]]];
Process.CheckForAbort[];
ENDLOOP;
AIS.CloseWindow[wRef];
};
ENDCASE => error _ "File isn't 1 or 8 bits per pixel.";
AIS.CloseFile[ais];
EXITS Bad => NULL;
For 512 by 480 image, Preview and ViewColorFiles[] take ~ 23 secs.
The previous method of separating 16 bpp red/green (see bottom of this file) took ~ 14.3 secs.
The current method (using delta of [0, 2]) takes ~ 10.3 secs.
ENABLE Error => {error _ reason; GOTO Bad};
rAis: AIS.FRef _ AISOpenFile[rName];
gAis: AIS.FRef _ AISOpenFile[gName];
bAis: AIS.FRef _ AISOpenFile[bName];
placement: AIS.Placement _ AIS.ReadPlacement[rAis];
r: AIS.Raster _ AIS.ReadRaster[rAis];
IF noPlace THEN placement _ NIL;
IF r.bitsPerPixel = 8 AND r^ = AIS.ReadRaster[gAis]^ AND r^ = AIS.ReadRaster[bAis]^
THEN {
rWRef: AIS.WRef _ AIS.OpenWindow[rAis, aisY, aisY+aisH-1, aisX, aisX+aisW-1];
gWRef: AIS.WRef _ AIS.OpenWindow[gAis, aisY, aisY+aisH-1, aisX, aisX+aisW-1];
bWRef: AIS.WRef _ AIS.OpenWindow[bAis, aisY, aisY+aisH-1, aisX, aisX+aisW-1];
w: INTEGER _ rWRef.lastPixel-rWRef.firstPixel+1;
h: INTEGER _ rWRef.lastScan-rWRef.firstScan+1;
rSampleBuf: SampleBuffer _ ImagerSample.ObtainScratchSamples[w];
gSampleBuf: SampleBuffer _ ImagerSample.ObtainScratchSamples[w];
bSampleBuf: SampleBuffer _ ImagerSample.ObtainScratchSamples[w];
rMap: RasterSampleMap _ ImagerSample.NewSampleMap[[[0, 0], [1, w]], 8, 8*w];
gMap: RasterSampleMap _ ImagerSample.NewSampleMap[[[0, 0], [1, w]], 8, 8*w];
bMap: RasterSampleMap _ ImagerSample.NewSampleMap[[[0, 0], [1, w]], 8, 8*w];
rgMap: SampleMap _ CtBasic.GetRedGrn[maps[0].map];
rAISBuf: AIS.Buffer _ LineBufferFromRasterSampleMap[rMap];
gAISBuf: AIS.Buffer _ LineBufferFromRasterSampleMap[gMap];
bAISBuf: AIS.Buffer _ LineBufferFromRasterSampleMap[bMap];
shift: Vec _ [0, 0];
SELECT TRUE FROM
center => shift _ [(h-maps.size.s)/2, (w-maps.size.f)/2];
placement # NIL => {
rgMap _ ImagerSample.Shift[rgMap, [-placement.yBottom, -2*placement.xLeft]];
maps[1].map	_ImagerSample.Shift[maps[1].map,[-placement.yBottom,-placement.xLeft]];
};
ENDCASE;
IF shift.f < 0 THEN {
rgMap	_ ImagerSample.Shift[rgMap, [0, 2*shift.f]];
maps[1].map	_ ImagerSample.Shift[maps[1].map, [0, shift.f]];
shift.f _ 0;
};
IF shift.s < 0 THEN {
rgMap	_ ImagerSample.Shift[rgMap, [shift.s, 0]];
maps[1].map	_ ImagerSample.Shift[maps[1].map, [shift.s, 0]];
shift.s _ 0;
};
FOR i: INT IN [0..MIN[h, maps.size.s]) DO
y: NAT _ i+shift.s;
TRUSTED {AIS.UnsafeReadLine[rWRef, rAISBuf, y]};	-- file to rMap (rAISBuf)
TRUSTED {AIS.UnsafeReadLine[gWRef, gAISBuf, y]};	-- file to gMap (gAISBuf)
TRUSTED {AIS.UnsafeReadLine[bWRef, bAISBuf, y]};	-- file to bMap (bAISBuf)
ImagerSample.GetSamples[rMap, [0, shift.f],, rSampleBuf, 0, maps.size.f]; -- rSampleBuf
ImagerSample.GetSamples[gMap, [0, shift.f],, gSampleBuf, 0, maps.size.f]; -- gSampleBuf
ImagerSample.GetSamples[bMap, [0, shift.f],, bSampleBuf, 0, maps.size.f]; -- bSampleBuf
Write the red, starting at 0, with delta.f = 2, thus writing the even bytes:
ImagerSample.PutSamples[rgMap, [i+maps.y, 2*maps.x], [0, 2], rSampleBuf, 0, maps.w];
Write the green, starting at 1, with delta.f = 2, thus writing the odd bytes:
ImagerSample.PutSamples[rgMap, [i+maps.y, 1+2*maps.x], [0, 2], gSampleBuf, 0, maps.w];
Write the blue:
ImagerSample.Transfer[maps[1].map, ImagerSample.Shift[bMap, [maps.y+i, maps.x+-shift.f]]];
Process.CheckForAbort[];
ENDLOOP;
AIS.CloseWindow[rWRef];
AIS.CloseWindow[gWRef];
AIS.CloseWindow[bWRef];
ImagerSample.ReleaseScratchSamples[rSampleBuf];
ImagerSample.ReleaseScratchSamples[gSampleBuf];
ImagerSample.ReleaseScratchSamples[bSampleBuf];
TRUSTED {
ImagerSample.ReleaseDescriptor[rMap];
ImagerSample.ReleaseDescriptor[gMap];
ImagerSample.ReleaseDescriptor[bMap];
ImagerSample.ReleaseDescriptor[rgMap];
};
}
ELSE error _ "Error in viewing file.";
AIS.CloseFile[rAis];
AIS.CloseFile[gAis];
AIS.CloseFile[bAis];
EXITS Bad => NULL;
r1: ImagerBox.Rectangle _ ViewRectangle[pa];
r2: ImagerBox.Rectangle _ ImagerBackdoor.GetBounds[context];
Inner: PROC ~ {
IF center
THEN Imager.TranslateT[context, [(r2.w-r1.w)/2, (r2.h-r1.h)/2]]
ELSE Imager.TranslateT[context, [0.0, r2.h-r1.h]];
Imager.SetSampledColor[context, pa, ViewPort[], op];
Imager.MaskRectangle[context, ViewRectangle[pa]];							
};
Process.CheckForAbort[];
Imager.DoSave[context, Inner];

ViewRectangle: PROC [pa: ImagerPixelArray.PixelArray]
RETURNS [rect: ImagerBox.Rectangle] ~ {
rect _ ImagerTransformation.TransformRectangle[pa.m, [0, 0, pa.sSize, pa.fSize]];
};

ViewPort: PROC RETURNS [ImagerTransformation.Transformation] ~ {
RETURN[ImagerTransformation.Scale[1]];
};

pa: ImagerPixelArray.PixelArray;
pa _ ImagerPixelArray.FromAIS[fileName !
FS.Error, ImagerPixelArray.Error => {error _ "Couldn't make dither array"; CONTINUE}];
IF error # NIL THEN RETURN;
IF context = NIL THEN context _ CtBasic.InitCd[gray, TRUE, TRUE, cmapInit];
Display[context, pa, ImagerColor.NewColorOperatorGrayLinear[255, 0], center];
pa: ImagerPixelArray.PixelArray;
pa _ ImagerPixelArray.FromAIS[fileName !
FS.Error, ImagerPixelArray.Error => {error _ "Couldn't make gray array"; CONTINUE}];
IF error # NIL THEN RETURN;
IF context = NIL THEN context _ CtBasic.InitCd[gray, TRUE, TRUE, cmapInit];
Display[context, pa, ImagerColor.NewColorOperatorGrayLinear[255, 0], center];
type: ATOM _ ColorDisplayManager.NextState[].type;
pa: ImagerPixelArray.PixelArray;
IF type # $Dither8 AND type # $FullColor THEN
RETURN["To view color files, set display mode (using 'Ct On') to 24 or Dither"];
pa _ ImagerPixelArray.Join3AIS[r, g, b !
FS.Error, ImagerPixelArray.Error => {error _ "Couldn't make color array"; CONTINUE}];
IF error = NIL THEN Display[
CtBasic.InitCd[color, TRUE, TRUE, cmapInit],
pa,
ImagerColor.NewColorOperatorRGB[255],
center];
Interpress Operations
IpOpenFailed: ERROR = CODE;
WITH ProcessProps.GetProp[$CommanderHandle] SELECT FROM
cmd: Commander.Handle =>
IO.PutRope[cmd.err, Rope.Concat["\n Interpress error: ", explanation]];
ENDCASE => NULL;
IF class = 0 THEN ERROR IpOpenFailed;
master _ InterpressInterpreter.Open[name, LogError
! IpOpenFailed => {master _ NIL; CONTINUE}];
type: CtBasic.CdType ~
IF CtBasic.GetColorDisplayBpp[] = 24 THEN smooth ELSE color;
context: Context ~ CtBasic.InitCd[type, FALSE, FALSE, cmapInit];
master: InterpressInterrpeter.Master ~ OpenInterpress[name];
IF master = NIL THEN error _ "Nil interpress master";
IF error # NIL THEN RETURN;
Imager.Scale2T[context, scale];
Imager.TranslateT[context, shift];
FOR page: INT IN [1..master.pages] DO
Action1: PROC ~ {
Imager.SetColor[context, Imager.white];
Imager.MaskRectangle[context, ImagerBackdoor.GetBounds[context]];
};
Action2: PROC ~ {InterpressInterpreter.DoPage[master, page, context, LogError]};
Process.CheckForAbort[];
Imager.DoSaveAll[context, Action1];
Imager.DoSaveAll[context, Action2];
ENDLOOP;
InterpressInterpreter.Close[master];
Parsing Procedures
Κβ•NewlineDelimiter

–
"cedarcode" style™™Jšœ	Οeœ6™BJ™0J™"—J˜Jš
Οk	œžœ1žœŒ
žœ)žœ
˜‹J˜šΡbln
œžœ
ž˜Jšžœ
žœžœžœ+˜jJšžœ˜—J˜šœž˜J˜
Jšœ
žœ˜&Jšœžœ˜(Jšœžœ˜(Jšœ
žœ˜%Jšœžœ˜%Jšœ
žœ˜$Jšœžœ˜"Jšœ	žœ˜!Jšœ	žœ˜!Jšœžœ˜0Jšœžœ ˜5Jšžœžœžœ
žœ
˜Jšžœžœžœ
˜—
headš
Οl™šΟnœžœ
žœžœ
žœžœ˜Tšœžœžœ ˜1Jš
žœ
žœžœžœžœ˜F—šžœ
ž˜˜	Jšžœ
žœ
žœ
žœžœžœ
˜TJ˜'Jšžœ
žœ
žœ
žœ˜2J˜—˜Jšžœ
žœ
žœ
žœ˜0Jš
žœ
žœ
žœ
žœ$žœ
˜JJ˜@Jš
žœ
žœ
žœ
žœ$žœ
˜JJ˜@Jš
žœ
žœ
žœ
žœ$žœ
˜JJ˜@Jšžœ
žœ
žœ
žœ˜2J˜—Jšžœžœ
˜—J˜J™—š‘œžœ
žœ˜"Jš
œ˜Jšœ
žœ
˜Jšœ	žœžœ
˜Jš
œ˜Jšžœžœžœžœ˜:J˜——š
 ™š
‘œžœ
žœ
žœžœ
˜*J˜—š‘œžœ
žœ˜Jšœ
žœ
˜Jšœžœ˜Jšœžœžœ
žœ˜&Jšœžœ
˜Jšžœ˜Jš
œ˜J˜šœžœž˜J˜=J˜YJšžœžœ
˜—J˜J˜—š
‘œžœžœžœžœ˜UJš‘
œ
Οs
ž’
œ’
œ’
ž’
œ
žœžœ˜SJšœžœžœ˜%Jšœžœ˜#Jšœžœ˜"Jšœ0žœ’
œ’
œ˜YJ˜J˜—š‘œžœ
žœ˜Jšœžœ
˜Jšœžœ˜Jšœžœžœ
žœ˜&Jšœžœ
˜Jšžœ˜J˜Jšœ
’
œ0˜>Jšœžœ ˜(šžœžœ
žœžœ˜;Jšžœ3˜7—Jšœ&’
œ’
œ
’
œ˜?J˜J˜—š‘
œžœ
žœ˜Jšœžœ
˜Jšœžœ˜Jšœžœžœ
žœ˜&Jšœžœ
˜Jšžœ˜J˜š‘œžœžœ
˜2Jšœžœžœ˜=J˜—Jš‘œžœžœ)˜LJšœ’
œ1˜@Jšœ’
œ1˜@Jšœ’
œ1˜@Jšœžœžœ;˜Lš
žœžœ
žœžœžœ˜LJšžœ4˜8—Jšœ&’
œ’
œ
’
œ˜@Jšœ&’
œ’
œ
’
œ˜@Jšœ&’
œ’
œ
’
œ˜@J˜J˜—š
‘œžœ
žœžœžœ˜LJšœ%žœ˜>J˜——š
 ™šΠbnœžœ
žœ˜Jšœ
žœ
˜Jšœžœ
˜Jšœžœžœ
˜Jšœžœ˜Jšœžœ˜Jšœžœžœ
˜Jšžœ
˜Jš
œ˜š‘
œžœžœ˜J˜šžœžœžœž˜$Jš	œžœžœ	žœžœ˜P—J˜—š‘œžœžœ$˜:Jš
œ˜šžœ˜Jš
žœ
žœžœ
žœžœžœž˜=Jšžœ
žœžœ
žœžœžœ
žœ
˜?—Jš
œ/˜/J˜—Jšœžœ˜J˜J˜#Jšœžœžœžœ%˜LJšžœžœ
žœ˜*šžœžœžœžœ˜2šžœ˜šžœ˜Jšœžœ˜Jšœžœ˜Jšœ	žœ˜Jš
œ
˜
—šžœ˜Jšœžœžœ˜4Jšœžœžœ˜0Jšœ	žœžœ˜1J˜——J˜—J˜ š
žœžœ
žœžœžœ˜PJšžœ=˜A—šžœ˜šžœ˜J˜.J˜$J˜
—šžœ˜J˜-J˜-J˜-J˜#J˜#J˜#J˜——šžœ
žœ
ž˜˜Jš
žœžœ
žœ
žœžœ
˜=—šœžœ˜šžœžœ
žœ
ž˜Jš
œ˜šžœ˜š
ž˜šžœžœ
žœž˜Jšœžœ˜Jšœžœ˜Jšœžœ˜Jš
ž˜——š
ž˜šžœžœ
žœž˜Jšœžœ˜Jšœžœ˜Jšœžœ
˜Jšžœ
˜———Jš
œ2˜2Jš
œ2˜2Jš
œ2˜2Jšžœ
˜——šœžœ
žœ˜%Jš
žœžœ
žœ
žœžœ
˜;Jš
žœžœ
žœ
žœžœ
˜;Jš
žœžœ
žœ
žœžœ
˜;J˜—Jšžœ
˜—šžœ˜šžœ˜J˜4J˜&J˜
—šžœ˜Jš
œF™FJ™SJ™4J˜)J˜)J˜)Jš
œ%˜%Jš
œ%˜%Jš
œ%˜%J˜——Jšžœ˜
J˜——š
 ™š‘œžœ
žœ˜J˜Jšœ
žœ
˜Jšœžœžœ
˜Jšœžœ˜Jšœžœžœ
žœ˜&Jšžœ	žœžœ˜š‘œžœ™Jšœ	žœ
™J™J™"šœžœž™J™šœžœ™JšžœF™JJšžœG™K—šœ	žœ™JšžœF™JJšžœ™—Jšžœ%™,—J™—Jš
œ5™5J˜J˜—š‘œžœ
žœ˜J˜Jšœžœ
˜Jšœžœžœ
˜Jšœžœ˜Jšœžœžœ
žœ˜&Jšžœ	žœžœ
˜J˜J™$Jšœžœžœ™Jšœžœ5žœ™HJšœžœžœ™,Jšœžœ
žœ™.Jšžœ	žœ	žœ
™šžœž™š
œ
™
Jšžœ
žœ*žœ™>Jšœžœžœ7™KJšœžœ$™.Jšœžœ"™,J•StartOfExpansionX[box: 
SF.Box, bitsPerSample: 
ImagerSample.BitsPerSample _ 1, bitsPerLine: 
INT _ 0]šœ9’
œ’
œ™SJšœ	žœ1™=Jš
œ™šžœ
žœ
ž™Jš
œ/™/JšœžœB™MJšžœ
™—Jšžœ
žœ<™OJšžœ
žœ<™Oš	žœžœ
žœžœ
ž™)Jšžœžœ+™7J™WJ™Jšžœ
™—Jšžœ™J™—Jšžœ0™7—Jšžœ™Jšžœžœ
™J˜J˜—š‘
œžœ
žœ˜J˜Jšœžœ
˜Jšœžœžœ
˜Jšœžœ˜Jšœžœžœ
žœ˜&Jšžœ	žœžœ
˜J˜J™BJ™^Jš
Οb=™=Jšžœžœ™+Jšœžœ™$Jšœžœ™$Jšœžœ™$Jšœžœ
žœ™3Jšœžœ
žœ™%Jšžœ	žœ
žœ
™ š
žœžœžœžœžœ™Sšžœ™Jšœžœžœ8™MJšœžœžœ8™MJšœžœžœ8™MJšœžœ&™0Jšœžœ$™.J™@J™@J™@J™LJ™LJ™LJš
œ2™2Jšœ	žœ.™:Jšœ	žœ.™:Jšœ	žœ.™:Jš
œ™šžœ
žœ
ž™Jš
œ9™9šœžœ™Jš
œL™LJšœ’
œG™SJ™—Jšžœ
™—šžœ
žœ™Jš
œ2™2J™<J™J™—šžœ
žœ™Jš
œ0™0J™<J™J™—š	žœžœ
žœžœž™)Jšœžœ
™Jšžœžœ$Οc™JJšžœžœ%₯™JJšžœžœ%₯™JJ–Š
[pixelMap: 
ImagerPixelMap.PixelMap, s: 
INTEGER, f: 
INTEGER, buffer: 
ImagerSample.SampleBuffer, bi: 
NAT, bj: 
NAT, count: 
NAT]šœJ₯
™WJ–Š
[pixelMap: 
ImagerPixelMap.PixelMap, s: 
INTEGER, f: 
INTEGER, buffer: 
ImagerSample.SampleBuffer, bi: 
NAT, bj: 
NAT, count: 
NAT]šœJ₯
™WJ–Š
[pixelMap: 
ImagerPixelMap.PixelMap, s: 
INTEGER, f: 
INTEGER, buffer: 
ImagerSample.SampleBuffer, bi: 
NAT, bj: 
NAT, count: 
NAT]šœJ₯
™WJšœ
€œ?™LJš
œT™TJšœ
€œ>™MJš
œV™VJšœ
€œ
™J™ZJ™Jšžœ
™—Jšžœ™Jšžœ™Jšžœ™J™/J™/J™/šžœ™	J™%J™%J™%J™&J™—J™
—Jšžœ"™&—Jšžœ™Jšžœ™Jšžœ™Jšžœžœ
™J˜J˜—š‘œžœ
žœ˜J˜J˜ J˜Jšœžœžœ
˜J˜J™,J™<š€œžœ™šžœ™	Jšžœ;™?Jšžœ.™2—J™4J™8J™—J™J™J˜J™—š‘
œžœ"™5Jšžœ ™'J™QJ™J™—š‘œžœ
žœ*™@Jšžœ ™&J™J™—š‘œžœ
žœ˜Jšœ
žœ
˜Jšœžœ
˜Jšœžœ
˜Jšžœ	žœžœ˜J™ ™(JšžœIžœ™V—Jšžœ	žœ
žœ
žœ
™Jš
žœžœ
žœ žœžœ™KJ™M˜J˜——š‘œžœ
žœžœžœžœ
˜ZJšžœ	žœžœ˜J™ ™(JšžœGžœ™T—Jšžœ	žœ
žœ
žœ
™Jš
žœžœ
žœ žœžœ™KJ™MJ˜J˜—š‘œžœ
žœžœžœžœ
˜JJšžœ	žœžœ
˜J˜Jšœžœ(™2J™ šžœžœž™-JšžœJ™P—™(JšžœHžœ™U—šžœ	žœ
žœ	™Jšœžœžœ™,J™J™%J™—J˜——š
 ™šœžœžœ
™J˜—š£œžœ"˜2šžœ(žœ
ž™7™JšžœE™G—Jšžœžœ
™—Jšžœžœ
žœ™%J˜J˜—š
‘œžœ
žœžœžœ+˜[™2Jšœžœžœ™,—J˜J˜—š£
œžœ
žœ˜Jšœžœ
˜J˜J˜Jšœ
žœžœ
˜Jšžœ	žœžœ
˜J˜™Jšžœ#žœžœ™<—Jšœ(žœžœ™@J™<Jšžœ
žœ
žœ!™5Jšžœ	žœ
žœ
žœ
™J™J™"šžœžœ
žœž™%š€œžœ™J™'J™AJ™—Jš€œžœC™PJ™J™#J™#Jšžœ
™—J™$J˜——š
 ™š
‘œžœ
žœžœžœ˜=Jš‘œžœžœžœžœžœžœ˜QJšœžœ+˜5Jšœžœ:˜Fšž’
œ’
ž’
œ’
ž’
œ˜BJšž’
œ!žœ˜.—Jšžœžœžœ"žœ˜VJ˜!šžœžœ
žœžœ
žœžœ
žœ˜DJ˜Jšžœ
˜Jš
œ˜—šžœ&˜(Jšžœ7žœ˜C—šžœ%˜'Jšžœ6žœ˜B—šž’
œ’
œ˜/Jšž’
œ=žœ˜J—Jšžœžœ"˜:˜J˜——š‘
œžœžœžœžœžœ˜<šžœžœ˜Jšœžœ
žœ˜!Jš	œžœ
žœžœ
žœ˜*Jšœžœ
žœžœžœ
žœ
˜>Jšœžœ˜Jšœ!žœ˜(Jšžœ
˜J˜—Jšžœžœ
žœ˜J˜J˜—š‘
œžœžœžœžœžœ˜;Jš	œžœžœžœžœ˜<J˜J˜—š
‘	œžœžœžœžœ˜=Jšœžœžœ
žœ˜=J˜J˜—š‘
œžœžœžœžœžœžœžœžœ
˜GJšžœ
žœ˜Jšžœ&žœ
žœ
˜4Jš
žœžœ
žœ
žœ
žœ˜Jšžœ&žœ
žœ
˜4Jš
žœžœ
žœ
žœ
žœ˜Jš
žœ
žœ&žœ
žœ
žœ˜=J˜J˜—š£œžœ
žœžœžœ	žœžœ
žœ˜TJ˜(J˜1J˜0J˜——J˜Jšžœ
˜J˜—…—*DfP