DIRECTORY AIS, ColorDisplay, ColorTrixBasics, ColorTrixFile, Commander, FileNames, FS, Imager, ImagerBackdoor, ImagerColorOperator, ImagerPixelArray, ImagerPixelMap, ImagerSample, ImagerTransformation, Interpress, IO, PixelMapOps, Process, ProcessProps, RefText, Rope, Terminal, Vector2;

ColorTrixFileImpl: CEDAR PROGRAM
IMPORTS AIS, ColorDisplay, ColorTrixBasics, FileNames, FS, Imager, ImagerBackdoor, ImagerColorOperator, ImagerPixelArray, ImagerPixelMap, ImagerSample, ImagerTransformation, Interpress, IO, PixelMapOps, Process, ProcessProps, RefText, Rope
EXPORTS ColorTrixFile

~ BEGIN
	
ROPE:					TYPE ~ Rope.ROPE;
Context:				TYPE ~ Imager.Context;
FileType: 			TYPE = ColorTrixFile.FileType;

PixelMap:				TYPE ~ ColorTrixBasics.PixelMap;
PixelMapMisc:		TYPE ~ ColorTrixBasics.PixelMapMisc;
DeviceRectangle:	TYPE ~ ImagerPixelMap.DeviceRectangle;

SampleBuffer:		TYPE ~ ImagerSample.SampleBuffer;
UnsafeSamples:		TYPE ~ ImagerSample.UnsafeSamples;
WritePmMiscToAIS: PUBLIC PROC [pmMisc: ColorTrixBasics.PixelMapMisc, name: Rope.ROPE]
~ {
RedAndGrnFromRG: PROC [rg: PixelMap] RETURNS [red, grn: PixelMap] ~ {
bufferSize: INTEGER _ rg.fMin+rg.fSize;
redLine: SampleBuffer ~ ImagerSample.ObtainScratchBuffer[1, bufferSize];
grnLine: SampleBuffer ~ ImagerSample.ObtainScratchBuffer[1, bufferSize];
rgLine: SampleBuffer ~ ImagerSample.ObtainScratchBuffer[1, bufferSize];
w: DeviceRectangle _ ImagerPixelMap.BoundedWindow[rg];

red _ ImagerPixelMap.Create[3, w];
grn _ ImagerPixelMap.Create[3, w];

FOR y: NAT IN [w.sMin..w.sMin+w.sSize) DO
Process.CheckForAbort[];
PixelMapOps.GetF[rg, y, w.fMin, rgLine, 0, 0, w.fSize];
FOR x: NAT IN [0..w.fSize) DO
redLine[x] _ rgLine[x]/256;
grnLine[x] _ rgLine[x] MOD 256;
ENDLOOP;
PixelMapOps.PutF[red, y, w.fMin, redLine, 0, 0, w.fSize, null, null];
PixelMapOps.PutF[grn, y, w.fMin, grnLine, 0, 0, w.fSize, null, null];
ENDLOOP;

ImagerSample.ReleaseScratchBuffer[redLine];
ImagerSample.ReleaseScratchBuffer[grnLine];
ImagerSample.ReleaseScratchBuffer[rgLine];
};

SELECT pmMisc.bpp FROM
8 => PixelMapOps.StoreAIS[name, [pmMisc.bw, FALSE, NIL]];
24 => {
r, g: PixelMap;
b: PixelMap _ pmMisc.b;
[r, g] _ RedAndGrnFromRG[pmMisc.rg];
PixelMapOps.StoreAIS[Rope.Concat[name, "-red.ais"], [r, FALSE, NIL]];
PixelMapOps.StoreAIS[Rope.Concat[name, "-grn.ais"], [g, FALSE, NIL]];
PixelMapOps.StoreAIS[Rope.Concat[name, "-blu.ais"], [b, FALSE, NIL]];
};
ENDCASE => NULL;
};
ReadFile: PUBLIC PROC [
baseName: ROPE,
aisX, aisY: CARDINAL _ 0,
aisW, aisH: CARDINAL _ LAST[CARDINAL]]
RETURNS [pmMisc: PixelMapMisc] ~ {
r, g, b: ROPE;
type: FileType;
[type, r, g, b] _ Parse[FileNames.ResolveRelativePath[baseName]];
SELECT type FROM
bw => pmMisc _ Read8BitFile[r, aisX, aisY, aisW, aisH];
color => pmMisc _ Read24BitFile[r, g, b, aisX, aisY, aisW, aisH]
ENDCASE;
};

Read8BitFile: PUBLIC PROC [
name: ROPE,
aisX, aisY: CARDINAL _ 0,
aisW, aisH: CARDINAL _ LAST[CARDINAL]]
RETURNS [pmMisc: PixelMapMisc] ~ {
ais: AIS.FRef _ AIS.OpenFile[name];
IF (pmMisc.bpp _ AIS.ReadRaster[ais].bitsPerPixel) = 8 THEN  {
wRef: AIS.WRef _ AIS.OpenWindow[ais, aisY, aisY+aisH-1, aisX, aisX+aisW-1];
w: INTEGER _ pmMisc.w _ wRef.lastPixel-wRef.firstPixel+1;
h: INTEGER _ pmMisc.h _ wRef.lastScan-wRef.firstScan+1;
linePm: PixelMap _ ImagerPixelMap.Create[3, [0, 0, 1, w]];
lineBuf: AIS.Buffer _ [linePm.refRep.words, linePm.refRep.pointer];
pmMisc.bw _ ImagerPixelMap.Create[3, [0, 0, h, w]];
FOR i: INT IN [0..h) DO
TRUSTED {AIS.UnsafeReadLine[wRef, lineBuf, i]};
ImagerPixelMap.Transfer[pmMisc.bw, ImagerPixelMap.ShiftMap[linePm, i, 0]];
Process.CheckForAbort[];
ENDLOOP;
AIS.CloseWindow[wRef];
};
AIS.CloseFile[ais];
};

Read24BitFile: PUBLIC PROC [
rName, gName, bName: ROPE,
aisX, aisY: CARDINAL _ 0,
aisW, aisH: CARDINAL _ LAST[CARDINAL]]
RETURNS [pmMisc: PixelMapMisc] ~ {
rAis: AIS.FRef _ AIS.OpenFile[rName];
gAis: AIS.FRef _ AIS.OpenFile[gName];
raster: AIS.Raster _ AIS.ReadRaster[rAis];
temp: PixelMapMisc _ Read8BitFile[bName, aisX, aisY, aisW, aisH];
IF temp.bpp = 8 AND raster.bitsPerPixel = 8 AND raster^ = AIS.ReadRaster[gAis]^ 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];
w: INTEGER _ pmMisc.w _ rWRef.lastPixel-rWRef.firstPixel+1;
h: INTEGER _ pmMisc.h _ rWRef.lastScan-rWRef.firstScan+1;
rSampleBuffer: SampleBuffer _ ImagerSample.ObtainScratchBuffer[1, w];
gSampleBuffer: SampleBuffer _ ImagerSample.ObtainScratchBuffer[1, w];
rgSampleBuffer: SampleBuffer _ ImagerSample.ObtainScratchBuffer[1, w];
rPm: PixelMap _ ImagerPixelMap.Create[3, [0, 0, 1, w]];
gPm: PixelMap _ ImagerPixelMap.Create[3, [0, 0, 1, w]];
rBuf: AIS.Buffer _ [rPm.refRep.words, rPm.refRep.pointer];
gBuf: AIS.Buffer _ [gPm.refRep.words, gPm.refRep.pointer];
rgPm: PixelMap _ ImagerPixelMap.Create[4, [0, 0, 1, w]];
pmMisc.bpp _ 24;
pmMisc.b _ temp.bw;
pmMisc.rg _ ImagerPixelMap.Create[4, [0, 0, h, w]];
FOR i: INT IN [0..h) DO
TRUSTED {AIS.UnsafeReadLine[rWRef, rBuf, i]};
TRUSTED {AIS.UnsafeReadLine[gWRef, gBuf, i]};
PixelMapOps.GetF[rPm, 0, 0, rSampleBuffer, 0, 0, w];
PixelMapOps.GetF[gPm, 0, 0, gSampleBuffer, 0, 0, w];
TRUSTED {
rPtr: UnsafeSamples ~ ImagerSample.GetPointer[rSampleBuffer, 0, 0, w];
gPtr: UnsafeSamples ~ ImagerSample.GetPointer[gSampleBuffer, 0, 0, w];
rgPtr: UnsafeSamples ~ ImagerSample.GetPointer[rgSampleBuffer, 0, 0, w];
FOR j: INT IN [0..w) DO rgPtr[j] _ 256*rPtr[j]+gPtr[j]; ENDLOOP;
};
PixelMapOps.PutF[rgPm, 0, 0, rgSampleBuffer, 0, 0, w];
ImagerPixelMap.Transfer[pmMisc.rg, ImagerPixelMap.ShiftMap[rgPm, i, 0]];
Process.CheckForAbort[];
ENDLOOP;
AIS.CloseWindow[rWRef];
AIS.CloseWindow[gWRef];
};
AIS.CloseFile[rAis];
AIS.CloseFile[gAis];
};
ViewFile: PUBLIC PROC [
cd: PixelMapMisc,
baseName: ROPE,
center: BOOL _ FALSE,
aisX, aisY: CARDINAL _ 0,
aisW, aisH: CARDINAL _ LAST[CARDINAL]]
RETURNS [error: ROPE _ NIL] ~ {
r, g, b: ROPE;
type: FileType;
[type, r, g, b] _
Parse[FileNames.StripVersionNumber[FileNames.ResolveRelativePath[baseName]]];
error _ SELECT type FROM
ip => ViewIpFile[r],
bw => IF cd.bpp = 24
THEN View24BitFile[cd, r, r, r, center, aisX, aisY, aisW, aisH]
ELSE View8BitFile[cd.bw, r, center, aisX, aisY, aisW, aisH],
color => IF cd.bpp = 24
THEN View24BitFile[cd, r, g, b, center, aisX, aisY, aisW, aisH]
ELSE ViewColorFiles[r, g, b],
ENDCASE	=> Rope.Cat["Bad name: ", baseName];
};

View8BitFile: PUBLIC PROC [
cd: PixelMap,
name: ROPE,
center: BOOL _ FALSE,
aisX, aisY: CARDINAL _ 0,
aisW, aisH: CARDINAL _ LAST[CARDINAL]]
RETURNS [error: ROPE _ NIL] ~ {
err: ROPE _ NIL;
ais: AIS.FRef;
ais _ AIS.OpenFile[name ! FS.Error => {err _ error.explanation; CONTINUE}];
IF err # NIL THEN {error _ err; RETURN};
IF AIS.ReadRaster[ais].bitsPerPixel = 8
THEN  {
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;
linePm: PixelMap _ ImagerPixelMap.Create[3, [0, 0, 1, w]];
lineBuf: AIS.Buffer _ [linePm.refRep.words, linePm.refRep.pointer];
IF center THEN cd _ ImagerPixelMap.ShiftMap[cd, (h-cd.sSize)/2, (w-cd.fSize)/2];
FOR i: INT IN [0..h) DO
TRUSTED {AIS.UnsafeReadLine[wRef, lineBuf, i]};
ImagerPixelMap.Transfer[cd, ImagerPixelMap.ShiftMap[linePm, cd.sMin+i, cd.fMin]];
Process.CheckForAbort[];
ENDLOOP;
AIS.CloseWindow[wRef];
}
ELSE error _ "Error in viewing file.";
AIS.CloseFile[ais];
};

View24BitFile: PUBLIC PROC [
cd: PixelMapMisc,
rName, gName, bName: ROPE,
center: BOOL _ FALSE,
aisX, aisY: CARDINAL _ 0,
aisW, aisH: CARDINAL _ LAST[CARDINAL]]
RETURNS [error: ROPE _ NIL] ~ {
rAis: AIS.FRef _ AIS.OpenFile[rName];
gAis: AIS.FRef _ AIS.OpenFile[gName];
bAis: AIS.FRef _ AIS.OpenFile[bName];
r: AIS.Raster _ AIS.ReadRaster[rAis];
IF r.bitsPerPixel = 8 AND r^ = AIS.ReadRaster[gAis]^ AND r^ = AIS.ReadRaster[gAis]^
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;
rSampleBuffer: SampleBuffer _ ImagerSample.ObtainScratchBuffer[1, w];
gSampleBuffer: SampleBuffer _ ImagerSample.ObtainScratchBuffer[1, w];
bSampleBuffer: SampleBuffer _ ImagerSample.ObtainScratchBuffer[1, w];
rgSampleBuffer: SampleBuffer _ ImagerSample.ObtainScratchBuffer[1, w];
rPm: PixelMap _ ImagerPixelMap.Create[3, [0, 0, 1, w]];
gPm: PixelMap _ ImagerPixelMap.Create[3, [0, 0, 1, w]];
bPm: PixelMap _ ImagerPixelMap.Create[3, [0, 0, 1, w]];
rgPm: PixelMap _ ImagerPixelMap.Create[4, [0, 0, 1, w]];
rBuf: AIS.Buffer _ [rPm.refRep.words, rPm.refRep.pointer];
gBuf: AIS.Buffer _ [gPm.refRep.words, gPm.refRep.pointer];
bBuf: AIS.Buffer _ [bPm.refRep.words, bPm.refRep.pointer];
IF center THEN {
cd.rg _ ImagerPixelMap.ShiftMap[cd.rg, (h-cd.rg.sSize)/2, (w-cd.rg.fSize)/2];
cd.b _ ImagerPixelMap.ShiftMap[cd.b, (h-cd.b.sSize)/2, (w-cd.b.fSize)/2];
};
FOR i: INT IN [0..h) DO
TRUSTED {AIS.UnsafeReadLine[rWRef, rBuf, i]};
TRUSTED {AIS.UnsafeReadLine[gWRef, gBuf, i]};
TRUSTED {AIS.UnsafeReadLine[bWRef, bBuf, i]};
PixelMapOps.GetF[rPm, 0, 0, rSampleBuffer, 0, 0, w];
PixelMapOps.GetF[gPm, 0, 0, gSampleBuffer, 0, 0, w];
PixelMapOps.GetF[bPm, 0, 0, bSampleBuffer, 0, 0, w];
TRUSTED {
rPtr: UnsafeSamples ~ ImagerSample.GetPointer[rSampleBuffer, 0, 0, w];
gPtr: UnsafeSamples ~ ImagerSample.GetPointer[gSampleBuffer, 0, 0, w];
rgPtr: UnsafeSamples ~ ImagerSample.GetPointer[rgSampleBuffer, 0, 0, w];
FOR j: INT IN [0..w) DO rgPtr[j] _ 256*rPtr[j]+gPtr[j]; ENDLOOP;
};
PixelMapOps.PutF[rgPm, 0, 0, rgSampleBuffer, 0, 0, w];
ImagerPixelMap.Transfer[
cd.rg,ImagerPixelMap.ShiftMap[rgPm, cd.rg.sMin+i, cd.rg.fMin]];
ImagerPixelMap.Transfer[
cd.b, ImagerPixelMap.ShiftMap[bPm, cd.b.sMin+i, cd.b.fMin]];
Process.CheckForAbort[];
ENDLOOP;
AIS.CloseWindow[rWRef];
AIS.CloseWindow[gWRef];
AIS.CloseWindow[bWRef];
}
ELSE error _ "Error in viewing file.";
AIS.CloseFile[rAis];
AIS.CloseFile[gAis];
AIS.CloseFile[bAis];
};

Display: PUBLIC PROC [
cd: Context, pa: ImagerPixelArray.PixelArray, op: ImagerColorOperator.ColorOperator]
~ {
r1: ImagerTransformation.Rectangle _ ViewRectangle[pa];
r2: ImagerTransformation.Rectangle _ ImagerBackdoor.GetBounds[cd];
Inner: PROC ~ {
x: REAL ~ (r2.w-r1.w)/2;
y: REAL ~ (r2.h-r1.h)/2;
Imager.TranslateT[cd, [x, y]];
Imager.SetSampledColor[cd, pa, ViewPort[], op];
Imager.MaskRectangle[cd, ViewRectangle[pa]];							
};

Process.CheckForAbort[];
Imager.DoSave[cd, Inner];
};
ViewRectangle: PROC [pa: ImagerPixelArray.PixelArray]
RETURNS [rect: ImagerTransformation.Rectangle] ~ {
rect _ ImagerTransformation.TransformRectangle[pa.m, [0, 0, pa.sSize, pa.fSize]];
};

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

ViewDitherFile: PUBLIC PROC [fileName: ROPE, cd: Context _ NIL, center, cmapInit: BOOL]
RETURNS [error: ROPE _ NIL] ~ {
pa: ImagerPixelArray.PixelArray;

pa _ ImagerPixelArray.FromAIS[fileName !
FS.Error, ImagerPixelArray.Error => {error _ "Couldn't make dither array"; CONTINUE}];
IF error # NIL THEN RETURN;
IF cd = NIL THEN cd _ ColorTrixBasics.InitCd[gray, TRUE, TRUE, cmapInit];
Display[cd, pa, ImagerColorOperator.GrayLinearColorModel[255, 0]];
};

ViewGrayFile: PUBLIC PROC [fileName: ROPE, cd: Context _ NIL, center, cmapInit: BOOL]
RETURNS [error: ROPE _ NIL] ~ {
pa: ImagerPixelArray.PixelArray;

pa _ ImagerPixelArray.FromAIS[fileName !
FS.Error, ImagerPixelArray.Error => {error _ "Couldn't make gray array"; CONTINUE}];
IF error # NIL THEN RETURN;
IF cd = NIL THEN cd _ ColorTrixBasics.InitCd[gray, TRUE, TRUE, cmapInit];
Display[cd, pa, ImagerColorOperator.GrayLinearColorModel[255, 0]];
};

ViewColorFiles: PUBLIC PROC [r, g, b: ROPE, cmapInit: BOOL _ TRUE]
RETURNS [error: ROPE _ NIL] ~ {
pa: ImagerPixelArray.PixelArray;

pa _ ImagerPixelArray.Join3AIS[r, g, b !
FS.Error, ImagerPixelArray.Error => {error _ "Couldn't make color array"; CONTINUE}];
IF error = NIL THEN Display[ColorTrixBasics.InitCd[color, TRUE, TRUE, cmapInit], pa, ImagerColorOperator.RGBLinearColorModel[255]];
};
IpOpenFailed: ERROR = CODE;

LogError: PUBLIC Interpress.LogProc ~ {
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;
};

OpenInterpress: PUBLIC PROC [name: ROPE] RETURNS [master: Interpress.Master] ~ {
master _ Interpress.Open[name, LogError ! IpOpenFailed => {master _ NIL; CONTINUE}];
};

ViewIpFile: PUBLIC PROC [name: ROPE, cmapInit: BOOL _ TRUE] RETURNS [error: ROPE _ NIL]
~ {
type: ColorTrixBasics.CdType ~ IF
ColorDisplay.GetColorDisplayStatus[].gray OR
ColorDisplay.GetColorDisplayStatus[].bpp = 24 THEN smooth ELSE color;
cd: Context ~ ColorTrixBasics.InitCd[type, FALSE, FALSE, cmapInit];

master: Interpress.Master ~ OpenInterpress[name];
IF master = NIL THEN error _ "Nil interpress master";

IF error = NIL THEN FOR page: INT IN [1..master.pages] DO
Action: PROC ~ {Interpress.DoPage[master, page, cd, LogError]};
Process.CheckForAbort[];
Imager.SetColor[cd, Imager.black];
Imager.DoSaveAll[cd, Action];
ENDLOOP;
};
Parse: PUBLIC PROC [name: ROPE]
RETURNS [type: ColorTrixFile.FileType _ bad, name1, name2, name3: ROPE _ NIL] ~ {
ok: BOOL;
ext: ROPE _ GetSuffix[name];
Test: PROC [x: ROPE] RETURNS [BOOL] ~ {RETURN[Rope.Equal[ext, x, FALSE]]};

IF (Test["ip"] OR Test["interpress"]) AND TestIpName[name] THEN RETURN[ip, name];
IF Test["ais"] AND FileExists[name] THEN RETURN [bw, name];
[ok, name1, name2, name3] _ GetColorNames[name]; IF ok THEN {type _ color; RETURN};
IF TestIpName[name.Cat["ip"]] THEN RETURN[ip, name.Cat["ip"],,];
IF TestIpName[name.Cat["interpress"]] THEN RETURN[ip, name.Cat["interpress"]];
IF ext = NIL AND FileExists[name] THEN RETURN [bw, name];
};

GetSuffix: PUBLIC PROC [rope: ROPE] RETURNS [ROPE] ~ {
n, len: INT;
n _ len _ rope.Length[]-1;
WHILE n >= 0 AND rope.Fetch[n] # '. DO n _ n-1; ENDLOOP;
RETURN[IF n = len OR n = -1 THEN NIL ELSE rope.Substr[n+1, len]];
};

TestIpName: PROC [name: ROPE] RETURNS [ok: BOOL _ TRUE] ~ {
s: FS.STREAM;
ipText: REF TEXT ~ "Interpress/";
text: REF TEXT _ NEW[TEXT[ipText.length]];

IF NOT FileExists[name] THEN RETURN[FALSE];
s _ FS.StreamOpen[name ! FS.Error => { ok _ FALSE; CONTINUE}];
IF NOT ok THEN RETURN;
[] _ IO.GetBlock[s, text];
ok _ RefText.Equal[ipText, text, FALSE];
IO.Close[s];
};

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

GetColorNames: PROC [name: ROPE] RETURNS [ok: BOOL, red, grn, blu: ROPE] ~ {
red _ FileChoice[name, "red", "r"];
IF red = NIL THEN {ok _ FALSE; RETURN};
grn _ FileChoice[name, "grn", "green", "g"];
IF grn = NIL THEN {ok _ FALSE; RETURN};
blu _ FileChoice[name, "blu", "blue", "b"];
ok _ blu # NIL;
};

END.

ถColorTrixFileImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Plass and Bloomenthal, December 4, 1986 11:54:00 am PST
File Write Operations
File Read Operations:
Display Operations:
For 512 by 480 image, Preview and ViewColorFiles[] take ~ 23 secs; this takes ~ 12 secs.
Can save ~ 0.5 secs if call View8BitFile for blue: slightly reduces jerkiness, but it's 2 pass.

Interpress Operations
Parsing Procedures:
ส˜š
œ™Jšœ
ฯm
œ1™<J™7—J˜Jšฯk
œ:ž
œ	žœ
žœG˜ŸJ˜šะblœžœ
ž˜ Jšžœ,žœ
žœ3˜๏
Jšžœ˜—J˜šœž˜J˜
Jšžœ
ž	œžœ
˜Jšœ	žœ˜"Jšœ
žœ˜+J˜Jšœ	žœ˜-Jšœ
žœ ˜3Jšœžœ"˜7J˜Jšœžœ˜0Jšœžœ˜2—
headš
œ™šฯnœžœ
žœ3žœ
˜UJš
œ˜šะbnœžœžœ˜EJšœžœ˜'Jš
œH˜HJš
œH˜HJš
œG˜GJš
œ6˜6J˜J˜"Jš
œ"˜"J˜
codešžœžœ
žœž˜)Lš
œ˜Jš
œ7˜7šžœžœ
žœž˜Lš
œ˜Lšœžœ˜Lšžœ
˜—Jš
œE˜EJš
œE˜E—Jšžœ
˜J˜Lš
œ+˜+Lš
œ+˜+Lš
œ*˜*J˜J˜—
cedaršžœž˜Mšœ,žœžœ˜9˜M˜M˜Mš
œ$˜$Mšœ8žœžœ˜EMšœ8žœžœ˜EMšœ8žœžœ˜EM˜—Mšžœžœ
˜—Jš
œ˜——š
œ™š œžœ
žœ˜Jšœ
žœ
˜Jšœžœ˜Jšœžœžœ
žœ˜&Jšžœ˜"Jšœ	žœ
˜Jš
œ˜Jš
œA˜Ašžœž˜Jš
œ7˜7Jš
œ@˜@Jšžœ
˜—J˜J˜—š œžœ
žœ˜Jšœžœ
˜Jšœžœ˜Jšœžœžœ
žœ˜&Jšžœ˜"Jšœžœžœ˜#šžœžœ#žœ˜>Jšœžœžœ7˜KJšœžœ/˜9Jšœžœ-˜7Jš
œ:˜:Jšœ	žœ7˜CJš
œ3˜3šžœžœ
žœž˜Jšžœžœ#˜/Jš
œJ˜JJ˜Jšžœ
˜—Jšžœ˜Jš
œ˜—Jšžœ˜J˜J˜—š 
œžœ
žœ˜Jšœžœ
˜Jšœžœ˜Jšœžœžœ
žœ˜&Jšžœ˜"Jšœžœžœ˜%Jšœžœžœ˜%Jšœžœ
žœ˜*J˜Aš
žœžœžœžœžœ˜VJšœžœžœ8˜MJšœžœžœ8˜MJšœžœ1˜;Jšœžœ/˜9Jš
œE˜EJš
œE˜EJš
œF˜FJš
œ7˜7Jš
œ7˜7Jšœžœ1˜:Jšœžœ1˜:Jš
œ8˜8J˜J˜J˜3šžœžœ
žœž˜Jšžœžœ!˜-Jšžœžœ!˜-J•StartOfExpansionŠ
[pixelMap: 
ImagerPixelMap.PixelMap, s: 
INTEGER, f: 
INTEGER, buffer: 
ImagerSample.SampleBuffer, bi: 
NAT, bj: 
NAT, count: 
NAT]š
œ4˜4J–Š
[pixelMap: 
ImagerPixelMap.PixelMap, s: 
INTEGER, f: 
INTEGER, buffer: 
ImagerSample.SampleBuffer, bi: 
NAT, bj: 
NAT, count: 
NAT]š
œ4˜4šžœ˜	L–G[buffer: 
ImagerSample.SampleBuffer, i: 
NAT, j: 
NAT, count: 
NAT]š
œF˜FL–G[buffer: 
ImagerSample.SampleBuffer, i: 
NAT, j: 
NAT, count: 
NAT]š
œF˜FL–G[buffer: 
ImagerSample.SampleBuffer, i: 
NAT, j: 
NAT, count: 
NAT]š
œH˜HLš
žœžœ
žœžœ žœ
˜@Lš
œ˜—J–า
[pixelMap: 
ImagerPixelMap.PixelMap, s: 
INTEGER, f: 
INTEGER, buffer: 
ImagerSample.SampleBuffer, bi: 
NAT, bj: 
NAT, count: 
NAT, srcFunc: 
PrincOps.SrcFunc _ null, dstFunc: 
PrincOps.DstFunc _ null]š
œ6˜6Jš
œH˜HJ˜Jšžœ
˜—Jšžœ˜Jšžœ˜Jš
œ˜—Jšžœ˜Jšžœ˜J˜——š
œ™š œžœ
žœ˜Jš
œ˜Jšœ
žœ
˜Jšœžœžœ
˜Jšœžœ˜Jšœžœžœ
žœ˜&Jšžœ	žœžœ˜Jšœ	žœ
˜Jš
œ˜š
œ˜Jš
œM˜M—šœžœž˜Jš
œ˜šœžœ˜Jšžœ;˜?Jšžœ8˜<—šœ	žœ˜Jšžœ;˜?Jšžœ˜—Jšžœ%˜,—J˜J˜—š œžœ
žœ˜Jš
œ
˜
Jšœžœ
˜Jšœžœžœ
˜Jšœžœ˜Jšœžœžœ
žœ˜&Jšžœ	žœžœ˜Jšœžœžœ
˜Jšœžœ˜Jšœžœžœ$žœ˜KJšžœžœ
žœžœ˜(šžœ
žœ!˜'šžœ˜Jšœžœžœ7˜KJšœžœ$˜.Jšœžœ"˜,Jš
œ:˜:Jšœ	žœ7˜CJšžœžœB˜Pšžœžœ
žœž˜Jšžœžœ#˜/Jš
œQ˜QJ˜Jšžœ
˜—Jšžœ˜Jš
œ
˜
—Jšžœ"˜&—Jšžœ˜J˜J˜—š 
œžœ
žœ˜Jš
œ˜Jšœžœ
˜Jšœžœžœ
˜Jšœžœ˜Jšœžœžœ
žœ˜&Jšžœ	žœžœ˜J™XJ™_Jšœžœžœ˜%Jšœžœžœ˜%Jšœžœžœ˜%Jšœžœ
žœ˜%š
žœžœžœžœžœ˜Sšžœ˜Jšœžœžœ8˜MJšœžœžœ8˜MJšœžœžœ8˜MJšœžœ&˜0Jšœžœ$˜.Jš
œE˜EJš
œE˜EJš
œE˜EJš
œF˜FJš
œ7˜7Jš
œ7˜7Jš
œ7˜7Jš
œ8˜8Jšœžœ1˜:Jšœžœ1˜:Jšœžœ1˜:šžœžœ˜Jš
œM˜MJš
œI˜IJ˜—šžœžœ
žœž˜Jšžœžœ!˜-Jšžœžœ!˜-Jšžœžœ!˜-J–Š
[pixelMap: 
ImagerPixelMap.PixelMap, s: 
INTEGER, f: 
INTEGER, buffer: 
ImagerSample.SampleBuffer, bi: 
NAT, bj: 
NAT, count: 
NAT]š
œ4˜4J–Š
[pixelMap: 
ImagerPixelMap.PixelMap, s: 
INTEGER, f: 
INTEGER, buffer: 
ImagerSample.SampleBuffer, bi: 
NAT, bj: 
NAT, count: 
NAT]š
œ4˜4J–Š
[pixelMap: 
ImagerPixelMap.PixelMap, s: 
INTEGER, f: 
INTEGER, buffer: 
ImagerSample.SampleBuffer, bi: 
NAT, bj: 
NAT, count: 
NAT]š
œ4˜4šžœ˜	L–G[buffer: 
ImagerSample.SampleBuffer, i: 
NAT, j: 
NAT, count: 
NAT]š
œF˜FL–G[buffer: 
ImagerSample.SampleBuffer, i: 
NAT, j: 
NAT, count: 
NAT]š
œF˜FL–G[buffer: 
ImagerSample.SampleBuffer, i: 
NAT, j: 
NAT, count: 
NAT]š
œH˜HLš
žœžœ
žœžœ žœ
˜@Lš
œ˜—J–า
[pixelMap: 
ImagerPixelMap.PixelMap, s: 
INTEGER, f: 
INTEGER, buffer: 
ImagerSample.SampleBuffer, bi: 
NAT, bj: 
NAT, count: 
NAT, srcFunc: 
PrincOps.SrcFunc _ null, dstFunc: 
PrincOps.DstFunc _ null]š
œ6˜6š
œ˜Jš
œ?˜?—š
œ˜Jš
œ<˜<—J˜Jšžœ
˜—Jšžœ˜Jšžœ˜Jšžœ˜J˜
—Jšžœ"˜&—Jšžœ˜Jšžœ˜Jšžœ˜J˜J˜—š œ
žœ˜Jš
œT˜TJš
œ˜Jš
œ7˜7Jš
œB˜Bšฯbœžœ˜Jšœžœ˜Jšœžœ˜J˜Jš
œ/˜/Jš
œ3˜3J˜J˜—J˜J˜J˜—J™š 
œžœ"˜5Jšžœ+˜2Jš
œQ˜QJš
œ˜—J˜š œžœ
žœ*˜@Jšžœ ˜&J˜—J˜š œžœ
žœžœžœžœ
˜WJšžœ	žœžœ˜Jš
œ ˜ J˜š
œ(˜(JšžœIžœ˜V—Jšžœ	žœ
žœ
žœ
˜Jš
žœžœ
žœ#žœžœ˜IJš
œB˜BJ˜J˜—š œžœ
žœžœžœžœ
˜UJšžœ	žœžœ˜Jš
œ ˜ J˜š
œ(˜(JšžœGžœ˜T—Jšžœ	žœ
žœ
žœ
˜Jš
žœžœ
žœ#žœžœ˜IJš
œB˜BJ˜—J˜š œžœ
žœžœžœžœ
˜BJšžœ	žœžœ˜Jš
œ ˜ J˜š
œ(˜(JšžœHžœ˜U—Jš
žœ	žœ
žœ'žœžœ?˜ƒ
J˜——š
œ™Jšœžœžœ
˜J˜šกœžœ˜'šžœ(žœ
ž˜7š
œ˜LšžœE˜G—Lšžœžœ
˜—Jšžœžœ
žœ˜%Jš
œ˜—J˜š œ
žœžœ
žœ ˜PJšœDžœžœ˜TJ˜—J˜šก
œžœ
žœžœžœžœžœ	žœžœ
˜WJš
œ˜šœž˜!Jšœ*ž˜,Jšœ.žœžœ˜E—Jšœ+žœžœ˜CJ˜Jš
œ1˜1Jšžœ
žœ
žœ!˜5J˜š
žœ	žœ
žœ
žœžœ
žœž˜9Jšขœžœ3˜?J˜Jš
œ"˜"Jš
œ˜Jšžœ
˜—Jš
œ˜——š
œ™š œžœžœ
˜Jšžœ;žœžœ˜QJšœžœ
˜	Jšœžœ˜Jš œžœžœžœžœžœžœ˜JJ˜Jš
žœ
žœžœžœ
žœ˜QJšžœ
žœžœ
žœ˜;Jšœ1žœžœžœ˜SJšžœžœ
žœ˜@Jšžœ$žœ
žœ˜NJš
žœžœ
žœžœ
žœ˜9Jš
œ˜J˜—š 	œžœ
žœžœžœžœ˜6Jšœžœ
˜Jš
œ˜Jšžœžœžœ
žœ
˜8Jšžœ
žœ	žœžœ
žœ
žœ˜AJ˜—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˜šก
œžœžœžœžœžœ˜LJš
œ#˜#Jš
žœžœ
žœžœžœ˜'Jš
œ,˜,Jš
žœžœ
žœžœžœ˜'Jš
œ+˜+Jšœžœ
˜J˜——J˜Jšžœ
˜—…—<Uแ