DIRECTORY
SampleArrayDisplay,
Basics USING [bitsPerByte, bitsPerWord, RawWords],
ImagerPixelMap USING [DeviceRectangle, Intersect, PixelMap],
ImagerSample USING [UnsafeSamples],
PrincOpsUtils USING [BITAND, BITOR, LongCopy],
Real USING [FixLI],
RealOps USING [RoundC],
SampleArrays USING [GetSamples, SampleArray],
SampleMapOps USING [Buffer, Create, Fill, Get, GetPointer, ObtainBuffer, Put, SampleMap, UnsafeCreate],
Terminal USING [Current, FrameBuffer, GetColorFrameBufferA, GetColorFrameBufferB, GetColorMode, ModifyColorFrame, Virtual],
Vector2 USING [VEC],
ViewerClasses USING [Viewer],
ViewerOps USING [UserToScreenCoords];

SampleArrayDisplayImpl: CEDAR MONITOR
IMPORTS SampleArrays, ImagerPixelMap, PrincOpsUtils, Real, RealOps, SampleMapOps, Terminal, ViewerOps
EXPORTS SampleArrayDisplay
= BEGIN
OPEN SampleArrayDisplay;

SampleArray: TYPE ~ SampleArrays.SampleArray;
PixelMap: TYPE ~ ImagerPixelMap.PixelMap;
SampleMap: TYPE ~ SampleMapOps.SampleMap;
UnsafeSamples: TYPE ~ ImagerSample.UnsafeSamples;
VEC: TYPE ~ Vector2.VEC;

bitsPerWord: NAT ~ Basics.bitsPerWord;
bitsPerByte: NAT ~ Basics.bitsPerByte;

term: Terminal.Virtual ~ Terminal.Current[];
sb1: SampleMapOps.Buffer ~ SampleMapOps.ObtainBuffer[4096];
sbRed: SampleMapOps.Buffer ~ SampleMapOps.ObtainBuffer[4096];
sbGreen: SampleMapOps.Buffer ~ SampleMapOps.ObtainBuffer[4096];
sbBlue: SampleMapOps.Buffer ~ SampleMapOps.ObtainBuffer[4096];
sbMask: SampleMapOps.Buffer ~ SampleMapOps.ObtainBuffer[4096];
scratch: SampleMap ~ SampleMapOps.Create[1, 1, 1];
Display: PUBLIC PROC [screen: Screen, rect: DeviceRectangle, sa: SampleArray _ NIL, sm: SampleMap _ NIL, slow, fast: Sampler, picRect, onlyPaintIn: DeviceRectangle _ nullRectangle] ~ {
vt: Terminal.Virtual ~ Terminal.Current[];
FullColor: PROC RETURNS [BOOL] ~ INLINE {RETURN [Terminal.GetColorMode[vt].full]};
SELECT TRUE FROM
screen=bw => DisplayLF[rect, sa, sm, slow, fast, picRect, onlyPaintIn];
FullColor[] => Display24Bit[rect, sa, sm, slow, fast, picRect, onlyPaintIn];
ENDCASE => DisplayNBit[rect, sa, sm, slow, fast, picRect, onlyPaintIn];
};
ViewerInformation: PUBLIC PROC [v: ViewerClasses.Viewer] RETURNS [screen: Screen, rect: DeviceRectangle] ~ {
x1, x2, y1, y2: INTEGER;
vt: Terminal.Virtual ~ Terminal.Current[];
screenHeight: INT;
screen _ IF v.column=color THEN color ELSE bw;
screenHeight _ IF screen=bw THEN vt.bwHeight ELSE vt.colorHeight;
[x1, y1] _ ViewerOps.UserToScreenCoords[self: v];
[x2, y2] _ ViewerOps.UserToScreenCoords[self: v, vx: v.cw-1, vy: v.ch-1];
y1 _ screenHeight - y1;
y2 _ screenHeight - y2;
rect _ [sMin: MIN[y1, y2], fMin: MIN[x1, x2], sSize: ABS[y1-y2]+1, fSize: ABS[x1-x2]+1];
};
fillValue: CARDINAL _ 100200B;
Display24Bit: ENTRY PROC [rect: DeviceRectangle, sa: SampleArray _ NIL, sm: SampleMap _ NIL, slow, fast: Sampler, picRect, onlyPaintIn: DeviceRectangle] ~ TRUSTED {
paintPixels: BOOL ~ sa#NIL;
paintMask: BOOL ~ sm#NIL;
red, green, blue: NAT;
frameA: Terminal.FrameBuffer ~ Terminal.GetColorFrameBufferA[term];
frameB: Terminal.FrameBuffer ~ Terminal.GetColorFrameBufferB[term];
smB: SampleMap ~ SampleMapOps.UnsafeCreate[sSize: frameB.height, fSize: frameB.width, bitsPerSample: 8, bitsPerLine: frameB.wordsPerLine*Basics.bitsPerWord, base: [word: frameB.base, bit: 0], nWords: LONG[frameB.wordsPerLine]*LONG[frameB.height], ref: NIL];
smRG: SampleMap ~ SampleMapOps.UnsafeCreate[sSize: frameA.height, fSize: frameA.width*2, bitsPerSample: 8, bitsPerLine: frameA.wordsPerLine*Basics.bitsPerWord, base: [word: frameA.base, bit: 0], nWords: LONG[frameA.wordsPerLine]*LONG[frameA.height], ref: NIL];
smBMask: SampleMap ~ SampleMapOps.UnsafeCreate[sSize: frameB.height, fSize: frameB.width*8, bitsPerSample: 1, bitsPerLine: frameB.wordsPerLine*Basics.bitsPerWord, base: [word: frameB.base, bit: 0], nWords: LONG[frameB.wordsPerLine]*LONG[frameB.height], ref: NIL];
smRGMask: SampleMap ~ SampleMapOps.UnsafeCreate[sSize: frameA.height, fSize: frameA.width*16, bitsPerSample: 1, bitsPerLine: frameA.wordsPerLine*Basics.bitsPerWord, base: [word: frameA.base, bit: 0], nWords: LONG[frameA.wordsPerLine]*LONG[frameA.height], ref: NIL];
ClearScreen: PROC ~ TRUSTED {
red _ 0;
green _ MIN[1, sa.n-1];
blue _ MIN[2, sa.n-1];
SampleMapOps.Fill[dest: [smB, [onlyPaintIn.sMin, onlyPaintIn.fMin], [onlyPaintIn.sSize, onlyPaintIn.fSize]], value: fillValue, function: [null, null]];
SampleMapOps.Fill[dest: [smRG, [onlyPaintIn.sMin, 2*onlyPaintIn.fMin], [onlyPaintIn.sSize, 2*onlyPaintIn.fSize]], value: fillValue, function: [null, null]];
};
PaintScreen: PROC ~ TRUSTED {
lastLine: CARDINAL _ CARDINAL.LAST;	--Line # of line currently buffered
fastOffset: INTEGER ~ onlyPaintIn.fMin - picRect.fMin;
size: NAT ~ onlyPaintIn.fSize;
rMin: NAT ~ 16*onlyPaintIn.fMin+7;
gMin: NAT ~ rMin+8;
bMin: NAT ~ 8*onlyPaintIn.fMin+7;
fMin: NAT ~ MIN[fast.samples[fastOffset], fast.samples[fastOffset+size-1]];
fMax: NAT ~ MAX[fast.samples[fastOffset], fast.samples[fastOffset+size-1]];
fCount: NAT ~ fMax-fMin+1;

FOR scan: NAT IN [onlyPaintIn.sMin .. onlyPaintIn.sMin+onlyPaintIn.sSize) DO
line: CARDINAL ~ slow.samples[scan - picRect.sMin];
IF line#lastLine THEN {	--Load the buffer
sb1Ptr: UnsafeSamples ~ SampleMapOps.GetPointer[buffer: sb1, start: fMin, count: fCount];
lastLine _ line;
IF paintMask THEN {
SampleMapOps.Get[buffer: sb1, start: fMin, count: fCount, sampleMap: sm, s: line, f: fMin];
SubsampleSamples[from: sb1, to: sbMask, s: fast, min: fastOffset, size: size];
};
IF paintPixels THEN {
SampleArrays.GetSamples[buffer: sb1, start: fMin, count: fCount, sa: sa, i: red, s: line, f: fMin];	--Red
IF paintMask THEN SubsampleSamplesWithMask[from: sb1, mask: sbMask, to: sbRed, s: fast, min: fastOffset, size: size] ELSE SubsampleSamples[from: sb1, to: sbRed, s: fast, min: fastOffset, size: size];

SampleArrays.GetSamples[buffer: sb1, start: fMin, count: fCount, sa: sa, i: green, s: line, f: fMin];	--Green
IF paintMask THEN SubsampleSamplesWithMask[from: sb1, mask: sbMask, to: sbGreen, s: fast, min: fastOffset, size: size] ELSE SubsampleSamples[from: sb1, to: sbGreen, s: fast, min: fastOffset, size: size];

SampleArrays.GetSamples[buffer: sb1, start: fMin, count: fCount, sa: sa, i: blue, s: line, f: fMin];	--Blue
IF paintMask THEN SubsampleSamplesWithMask[from: sb1, mask: sbMask, to: sbBlue, s: fast, min: fastOffset, size: size] ELSE SubsampleSamples[from: sb1, to: sbBlue, s: fast, min: fastOffset, size: size];
};
};
IF paintPixels THEN {
SampleMapOps.Put[buffer: sbRed, count: onlyPaintIn.fSize, sampleMap: smRG, s: scan, f: onlyPaintIn.fMin+onlyPaintIn.fMin, df: 2, function: [null, null]];
SampleMapOps.Put[buffer: sbGreen, count: onlyPaintIn.fSize, sampleMap: smRG, s: scan, f: onlyPaintIn.fMin+onlyPaintIn.fMin+1, df: 2, function: [null, null]];
SampleMapOps.Put[buffer: sbBlue, count: onlyPaintIn.fSize, sampleMap: smB, s: scan, f: onlyPaintIn.fMin, function: [null, null]];
};
IF paintMask AND ~paintPixels THEN {
SampleMapOps.Put[buffer: sbMask, count: onlyPaintIn.fSize, sampleMap: smRGMask, s: scan, f: rMin, df: 16, function: [null, null]];
SampleMapOps.Put[buffer: sbMask, count: onlyPaintIn.fSize, sampleMap: smRGMask, s: scan, f: gMin, df: 16, function: [null, null]];
SampleMapOps.Put[buffer: sbMask, count: onlyPaintIn.fSize, sampleMap: smBMask, s: scan, f: bMin, df: 8, function: [null, null]];
};
ENDLOOP;
};

onlyPaintIn _ IF onlyPaintIn=nullRectangle THEN rect ELSE ImagerPixelMap.Intersect[rect, onlyPaintIn];

IF paintPixels AND onlyPaintIn.sSize>0 AND onlyPaintIn.fSize>0 THEN Terminal.ModifyColorFrame[vt: term, action: ClearScreen, xmin: onlyPaintIn.fMin, ymin: onlyPaintIn.sMin, xmax: onlyPaintIn.fMin+onlyPaintIn.fSize, ymax: onlyPaintIn.sMin+onlyPaintIn.sSize];	--Only clear the screen if we're repainting the bits

picRect _ ImagerPixelMap.Intersect[rect, picRect];
onlyPaintIn _ ImagerPixelMap.Intersect[picRect, onlyPaintIn];

IF onlyPaintIn.sSize>0 AND onlyPaintIn.fSize>0 THEN Terminal.ModifyColorFrame[vt: term, action: PaintScreen, xmin: onlyPaintIn.fMin, ymin: onlyPaintIn.sMin, xmax: onlyPaintIn.fMin+onlyPaintIn.fSize, ymax: onlyPaintIn.sMin+onlyPaintIn.sSize];

};

DisplayNBit: PROC [rect: DeviceRectangle, sa: SampleArray _ NIL, sm: SampleMap _ NIL, slow, fast: Sampler, picRect, onlyPaintIn: DeviceRectangle] ~ {
};

DisplayLF: PROC [rect: DeviceRectangle, sa: SampleArray _ NIL, sm: SampleMap _ NIL, slow, fast: Sampler, picRect, onlyPaintIn: DeviceRectangle] ~ {
};
SubsampleSamples: UNSAFE PROC [from, to: SampleMapOps.Buffer, s: Sampler, min, size: NAT] ~ UNCHECKED {
SELECT s.form FROM
offset => {		--> s.samples[i] = s.offset+i
PrincOpsUtils.LongCopy[
from: SampleMapOps.GetPointer[from, s.offset+min, size],
to: SampleMapOps.GetPointer[to, 0, size],
nwords: size
]
};
reduce => {		--> s.samples[i] = s.offset + reduce*i
CopyWords[
src: SampleMapOps.GetPointer[buffer: from, start: s.offset + s.reduce*min, count: size],
dest: SampleMapOps.GetPointer[buffer: to, start: 0, count: 0],
count: size,
delta: s.reduce
];
};
ENDCASE => {
FOR sample: NAT IN [0 .. size) DO
to[sample] _ from[s.samples[sample+min]];
ENDLOOP;
};
};
SubsampleSamplesWithMask: UNSAFE PROC [from, mask, to: SampleMapOps.Buffer, s: Sampler, min, size: NAT] ~ UNCHECKED {
SELECT s.form FROM
offset => TRUSTED {		--> s.samples[i] = s.offset+i
sm: SampleMap ~ SampleMapOps.UnsafeCreate[sSize: 1, fSize: 16*size, bitsPerSample: 1, bitsPerLine: 16*size, base: [word: SampleMapOps.GetPointer[buffer: to, start: 0, count: size], bit: 0], nWords: size, ref: NIL, scratchDescriptor: scratch];
PrincOpsUtils.LongCopy[
from: SampleMapOps.GetPointer[from, s.offset+min, size],
to: SampleMapOps.GetPointer[to, 0, size],
nwords: size
];
SampleMapOps.Put[buffer: mask, count: size, sampleMap: sm, f: 15, df: 16];
};
reduce => TRUSTED {		--> s.samples[i] = s.offset + reduce*i
sm: SampleMap ~ SampleMapOps.UnsafeCreate[sSize: 1, fSize: 16*size, bitsPerSample: 1, bitsPerLine: 16*size, base: [word: SampleMapOps.GetPointer[buffer: to, start: 0, count: size], bit: 0], nWords: size, ref: NIL, scratchDescriptor: scratch];
CopyWords[
src: SampleMapOps.GetPointer[buffer: from, start: s.offset + s.reduce*min, count: size],
dest: SampleMapOps.GetPointer[buffer: to, start: 0, count: 0],
count: size,
delta: s.reduce
];
SampleMapOps.Put[buffer: mask, count: size, sampleMap: sm, f: 15, df: 16];
};
ENDCASE => {
FOR sample: NAT IN [0 .. size) DO
to[sample] _ PrincOpsUtils.BITOR[
PrincOpsUtils.BITAND[376B, from[s.samples[sample+min]]],
mask[sample]
];
ENDLOOP;
};
};
CopyWords: UNSAFE PROC [src, dest: LONG POINTER TO Basics.RawWords, count, delta: CARDINAL] ~ UNCHECKED {
delta2: CARDINAL _ delta+delta;
delta3: CARDINAL _ delta2+delta;
delta4: CARDINAL _ delta3+delta;
delta5: CARDINAL _ delta4+delta;
delta6: CARDINAL _ delta5+delta;
delta7: CARDINAL _ delta6+delta;
delta8: CARDINAL _ delta7+delta;
THROUGH [0 .. count/8) DO
dest[0] _ src[0];
dest[1] _ src[delta];
dest[2] _ src[delta2];
dest[3] _ src[delta3];
dest[4] _ src[delta4];
dest[5] _ src[delta5];
dest[6] _ src[delta6];
dest[7] _ src[delta7];
dest _ dest+8;
src _ src+delta8;
ENDLOOP;
FOR k: NAT IN [0 .. count MOD 8) DO
dest[k] _ src[0];
src _ src+delta;
ENDLOOP;
};
BuildSampler: PUBLIC PROC [min, size: NAT, m, b: REAL] RETURNS [s: Sampler] ~ {
Round: PROC [arg: REAL] RETURNS [CARDINAL] ~ INLINE {
RETURN [RealOps.RoundC[arg+0.5, [round: rm]]]
};

s _ NEW[SamplerRep[size]];
s.min _ min;
FOR sample: NAT IN [min .. min+size) DO
i: NAT _ sample-min;
s.samples[i] _ Round[m*sample + b];
ENDLOOP;
[numerator: s.reduce, denominator: s.expand] _ RealToRational[m ! ANY => {s.reduce _ s.expand _ 0; CONTINUE}];
s.offset _ s.samples[0];
SELECT TRUE FROM
s.reduce=1 AND s.expand=1 => {	--An offset type
s.form _ offset;
};
s.expand=1 => {		--A reduce type
s.form _ reduce;
};
s.reduce=1 => {		--An expand type
s.form _ expand;
};
ENDCASE;
};
RealToRational: PROC [r: REAL] RETURNS [numerator, denominator: INT] ~ {
b: REAL _ 0;
c: REAL _ 1;
d: REAL _ ABS[r - Real.FixLI[r]];
UNTIL r*c = Real.FixLI[r*c] DO
e: REAL _ 1/d;
oldC: REAL _ c;
c _ Real.FixLI[e]*c+b;
b _ oldC;
d _ e - Real.FixLI[e];
ENDLOOP;
RETURN [numerator: Real.FixLI[r*c], denominator: Real.FixLI[c]];
};

END.
äSampleArrayDisplayImpl.mesa
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
Provides facilities for blasting pictures onto the screen.
Created Thursday, August 9, 1984 2:13 pm PDT
Last edited by Eric Nickell, January 7, 1986 11:45:20 am PST

The basic attack is to set up pointer to the two channels (A channel has red and green, and B channel has blue).  Then the three colors are put on the screen.
rMin, gMin, and bMin are the places in each scan line where we need to blast the bits
fMin, fMax, and fCount are used as follows:  fMin represents the lowest f position in the pixel which will be examined during the subsampling operation.  fMax, correspondingly is the highest.  Thus, if we get the buffer correct for values in the range [fMin .. fMax] then we need not worry about the rest of the buffer.  fCount is a convenience.




So, we need to set to[k] _ from[s.offset+k+min]], k IN [0..size).
So, we need to set to[k] _ from[s.offset + reduce*min + reduce*k], k IN [0..size).
So, we need to set to[k] _ from[s.offset+k+min]], k IN [0..size).
So, we need to set to[k] _ from[s.offset + reduce*min + reduce*k], k IN [0..size).
Has the following effect:
FOR k: NAT IN [0 .. count) DO
dest[k] _ src[k*delta];
ENDLOOP;

�ʘš
œ™Icodešœ
Ïm
œ7™BKš
œ:™:Kš
œ,™,K™<K™—š
Ïk	˜	Kš
œ˜Kšœžœ&˜2Kšœžœ(˜<Kšœ
žœ˜#Kšœžœžœžœ˜.Kšœžœ	˜Kšœžœ
˜Kšœ
žœ˜-Kšœ
žœU˜gKšœ	žœm˜{Kšœžœžœ˜Kšœžœ
˜Kšœ
žœ˜%K˜—šœžœ
ž˜%Kšžœ^˜eKšžœ˜Kšœž˜Kšžœ˜K˜Kšœ
žœ˜-Kšœ
žœ˜)Kšœžœ˜)Kšœžœ˜1Kšžœžœžœ
˜K˜Kšœ
žœ˜&Kšœ
žœ˜&K˜K˜,Kš
œ;˜;Kš
œ=˜=Kš
œ?˜?Kš
œ>˜>K˜>K˜2
code2š
Ïnœžœ
žœ;žœžœQ˜¸
K˜*LšŸ	œžœ
žœžœžœžœ#˜Ršžœ
žœ
ž˜K˜GK•StartOfExpansion[]˜LKšžœ@˜G—K˜—šŸœžœžœ,˜lJšœžœ
˜J˜*Kšœžœ
˜Kšœ	žœžœžœ˜.Kšœžœžœ
žœ˜AJ–D[self: 
ViewerClasses.Viewer, vx: 
INTEGER _ 0, vy: 
INTEGER _ 0]˜1J–D[self: 
ViewerClasses.Viewer, vx: 
INTEGER _ 0, vy: 
INTEGER _ 0]˜IJ˜J˜Jš	œžœžœžœžœ˜XK˜—Lšœžœ˜šŸœžœ
žœ+žœžœ@žœ˜¤
K™ž
Kšœ
žœžœ
˜Kšœžœžœ
˜Kšœžœ
˜Kš
œC˜CKš
œC˜CK–Í
[sSize: 
CARDINAL, fSize: 
CARDINAL, bitsPerSample: 
[0..16], bitsPerLine: 
NAT, base: 
PrincOps.BitAddress, nWords: 
LONG CARDINAL, ref: 
REF ANY, scratchDescriptor: 
SampleMapOps.SampleMap _ NIL]šœÈ
žœžœžœ˜�K–Í
[sSize: 
CARDINAL, fSize: 
CARDINAL, bitsPerSample: 
[0..16], bitsPerLine: 
NAT, base: 
PrincOps.BitAddress, nWords: 
LONG CARDINAL, ref: 
REF ANY, scratchDescriptor: 
SampleMapOps.SampleMap _ NIL]šœË
žœžœžœ˜„K–Í
[sSize: 
CARDINAL, fSize: 
CARDINAL, bitsPerSample: 
[0..16], bitsPerLine: 
NAT, base: 
PrincOps.BitAddress, nWords: 
LONG CARDINAL, ref: 
REF ANY, scratchDescriptor: 
SampleMapOps.SampleMap _ NIL]šœÎ
žœžœžœ˜‡K–Í
[sSize: 
CARDINAL, fSize: 
CARDINAL, bitsPerSample: 
[0..16], bitsPerLine: 
NAT, base: 
PrincOps.BitAddress, nWords: 
LONG CARDINAL, ref: 
REF ANY, scratchDescriptor: 
SampleMapOps.SampleMap _ NIL]šœÐ
žœžœžœ˜‰šŸœžœžœ˜K˜Kšœžœ˜Kšœžœ˜Kš
œ—
˜—
K–x[dest: 
SampleMapOps.SubMap, value: 
CARDINAL, function: 
SampleMapOps.Function _ [dstFunc: 
null, srcFunc: 
null]]š
œœ
˜œ
K˜—šŸœžœžœ˜Kšœ
žœžœ
žœÏc#˜GKšœžœ#˜6Kšœžœ˜Kš
œU™UKšœžœ˜"Kšœžœ
˜Kšœžœ˜!Kš
œÙ™ÙKšœžœžœ<˜KKšœžœžœ<˜KKšœžœ˜K˜šžœžœ
žœ:ž˜LKšœžœ%˜3šžœžœ ˜)K–;[buffer: 
SampleMapOps.Buffer, start: 
NAT, count: 
NAT]˜YK˜šžœžœ˜K–®
[buffer: 
SampleMapOps.Buffer, start: 
NAT _ 0, count: 
NAT _ 32767, sampleMap: 
SampleMapOps.SampleMap, s: 
NAT _ 0, f: 
NAT _ 0, ds: 
INTEGER _ 0, df: 
INTEGER _ 1]š
œ[˜[Kš
œN˜NKš
œ˜—–z[pa: 
ImagerPixelArrayDefs.PixelArray, i: 
NAT, s: 
INT, f: 
INT, samples: 
ImagerSample.UnsafeSamples, count: 
NAT]šžœ
žœ˜K–«
[buffer: 
SampleMapOps.Buffer, start: 
NAT _ 0, count: 
NAT _ 32767, sa: 
SampleArrays.SampleArray, i: 
NAT, s: 
NAT _ 0, f: 
NAT _ 0, ds: 
NAT _ 0, df: 
NAT _ 1]šœd ˜iK–;[buffer: 
SampleMapOps.Buffer, start: 
NAT, count: 
NAT]šžœžœdžœN˜Ç
K–z[pa: 
ImagerPixelArrayDefs.PixelArray, i: 
NAT, s: 
INT, f: 
INT, samples: 
ImagerSample.UnsafeSamples, count: 
NAT]˜K–«
[buffer: 
SampleMapOps.Buffer, start: 
NAT _ 0, count: 
NAT _ 32767, sa: 
SampleArrays.SampleArray, i: 
NAT, s: 
NAT _ 0, f: 
NAT _ 0, ds: 
NAT _ 0, df: 
NAT _ 1]šœf ˜mK–;[buffer: 
SampleMapOps.Buffer, start: 
NAT, count: 
NAT]šžœžœfžœP˜Ë
K–z[pa: 
ImagerPixelArrayDefs.PixelArray, i: 
NAT, s: 
INT, f: 
INT, samples: 
ImagerSample.UnsafeSamples, count: 
NAT]˜K–«
[buffer: 
SampleMapOps.Buffer, start: 
NAT _ 0, count: 
NAT _ 32767, sa: 
SampleArrays.SampleArray, i: 
NAT, s: 
NAT _ 0, f: 
NAT _ 0, ds: 
NAT _ 0, df: 
NAT _ 1]šœe ˜kK–;[buffer: 
SampleMapOps.Buffer, start: 
NAT, count: 
NAT]šžœžœežœO˜É
Kš
œ˜—Kš
œ˜—–ö
[buffer: 
SampleMapOps.Buffer, start: 
NAT _ 0, count: 
NAT _ 32767, sampleMap: 
SampleMapOps.SampleMap, s: 
NAT _ 0, f: 
NAT _ 0, ds: 
INTEGER _ 0, df: 
INTEGER _ 1, function: 
SampleMapOps.Function _ [dstFunc: 
null, srcFunc: 
null]]šžœ
žœ˜Kš
Ϫ
˜™
K–ö
[buffer: 
SampleMapOps.Buffer, start: 
NAT _ 0, count: 
NAT _ 32767, sampleMap: 
SampleMapOps.SampleMap, s: 
NAT _ 0, f: 
NAT _ 0, ds: 
INTEGER _ 0, df: 
INTEGER _ 1, function: 
SampleMapOps.Function _ [dstFunc: 
null, srcFunc: 
null]]š
œ�
˜�
K–ö
[buffer: 
SampleMapOps.Buffer, start: 
NAT _ 0, count: 
NAT _ 32767, sampleMap: 
SampleMapOps.SampleMap, s: 
NAT _ 0, f: 
NAT _ 0, ds: 
INTEGER _ 0, df: 
INTEGER _ 1, function: 
SampleMapOps.Function _ [dstFunc: 
null, srcFunc: 
null]]š
œ�
˜�
Kš
œ˜—šžœžœžœ˜$Kš
œ‚
˜‚
K–ö
[buffer: 
SampleMapOps.Buffer, start: 
NAT _ 0, count: 
NAT _ 32767, sampleMap: 
SampleMapOps.SampleMap, s: 
NAT _ 0, f: 
NAT _ 0, ds: 
INTEGER _ 0, df: 
INTEGER _ 1, function: 
SampleMapOps.Function _ [dstFunc: 
null, srcFunc: 
null]]š
œ‚
˜‚
K–ö
[buffer: 
SampleMapOps.Buffer, start: 
NAT _ 0, count: 
NAT _ 32767, sampleMap: 
SampleMapOps.SampleMap, s: 
NAT _ 0, f: 
NAT _ 0, ds: 
INTEGER _ 0, df: 
INTEGER _ 1, function: 
SampleMapOps.Function _ [dstFunc: 
null, srcFunc: 
null]]š
œ€
˜€
Kš
œ˜—Kšžœ
˜—K˜—K–�
[dest: 
ImagerPixelMap.PixelMap, area: 
ImagerPixelMap.DeviceRectangle, value: 
CARDINAL, function: 
ImagerPixelMap.Function]˜K–x[dest: 
SampleMapOps.SubMap, value: 
CARDINAL, function: 
SampleMapOps.Function _ [dstFunc: 
null, srcFunc: 
null]]šœžœžœžœ-˜fK˜K–t[vt: 
Terminal.Virtual, action: 
PROC, xmin: 
NAT _ 0, ymin: 
NAT _ 0, xmax: 
NAT _ 32767, ymax: 
NAT _ 32767]š	žœ
žœžœžœ¿
 4˜¶K˜K–J[a: 
ImagerPixelMap.DeviceRectangle, b: 
ImagerPixelMap.DeviceRectangle]˜2K–J[a: 
ImagerPixelMap.DeviceRectangle, b: 
ImagerPixelMap.DeviceRectangle]˜=K˜K–t[vt: 
Terminal.Virtual, action: 
PROC, xmin: 
NAT _ 0, ymin: 
NAT _ 0, xmax: 
NAT _ 32767, ymax: 
NAT _ 32767]šžœžœžœ¾
˜ñ
K˜K˜K˜—šŸœžœ+žœžœA˜•
K™K˜K˜—šŸ	œžœ+žœžœA˜“
K™K˜—š
Ÿœžœ
žœ8žœž	œ˜gšžœž˜šœ
 ˜*Kšœ4žœ™A˜K˜8K˜)K˜K˜
—Kš
œ˜—šœ
 &˜3Kšœ  œ œžœ™Rš
œ
˜
K–;[buffer: 
SampleMapOps.Buffer, start: 
NAT, count: 
NAT]š
œX˜XK–;[buffer: 
SampleMapOps.Buffer, start: 
NAT, count: 
NAT]˜>K˜K˜Kš
œ˜—Kš
œ˜—šžœ˜šžœ	žœ
žœ
ž˜!K˜)Kšžœ
˜—Kš
œ˜——K˜—š
Ÿœžœ
žœ>žœž	œ˜ušžœž˜šœ
žœ ˜2Kšœ4žœ™AKšœÑ
žœ˜ò
˜K˜8K˜)K˜K˜—K˜JKš
œ˜—šœ
žœ &˜;Kšœ  œ œžœ™RKšœÑ
žœ˜ò
š
œ
˜
K–;[buffer: 
SampleMapOps.Buffer, start: 
NAT, count: 
NAT]š
œX˜XK–;[buffer: 
SampleMapOps.Buffer, start: 
NAT, count: 
NAT]˜>K˜K˜Kš
œ˜—K˜JKš
œ˜—šžœ˜šžœ	žœ
žœ
ž˜!šœžœ
˜!Kšœžœ$˜8K˜K˜—Kšžœ
˜—Kš
œ˜——K˜—šŸ	œžœ
žœ
žœ
žœ
žœ žœž	œ˜iK™šžœžœ
žœž™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˜—šŸœžœ
žœ
žœžœžœ˜OšŸœžœžœžœžœžœ˜5Kšžœ'˜-K˜—K˜Kšœžœ˜Kš
œ˜šžœ	žœ
žœž˜'Kšœžœ˜K˜#Kšžœ
˜—KšœBžœžœ˜nK˜šžœ
žœ
ž˜šœžœ ˜/K˜Kš
œ˜—šœ ˜ K˜Kš
œ˜—šœ ˜!K˜Kš
œ˜—Kšžœ
˜—K˜—š
Ÿœžœžœžœžœ˜HKšœžœ˜Kšœžœ˜Kšœžœžœ˜!šžœž˜Kšœžœ˜Kšœžœ˜K˜K˜	K˜Kšžœ
˜—Kšžœ:˜@K˜—K˜Kšžœ
˜——…—/RPP