DIRECTORY
Basics USING [BITSHIFT, bitsPerWord, LongMult],
ImagerManhattan USING [BoundingBox, CountRuns, CreateFromBox, CreateFromRuns, Destroy, MapRuns, Polygon],
ImagerMasks USING [DevicePath, DeviceRectangle, Function, ManhattanPolygon, Mask, PixelMap, Tile, Transformation],
ImagerPixelArrays USING [PixelArray, PixelArrayRep],
ImagerPixelMaps USING [Clear, Clip, Fill, Intersect, PixelMap, PixelMapRep, Reshape, ShiftMap, Transfer, TransferTile, Trim],
ImagerScanConverter USING [BoundingBox, ConvertToPixels, ConvertToRuns, NumberOfRuns],
ImagerTransform USING [IntRectangle, TransformIntRectangle],
Real USING [];

ImagerMasksImpl: CEDAR PROGRAM
IMPORTS Basics, ImagerManhattan, ImagerPixelMaps, ImagerTransform, ImagerScanConverter
EXPORTS ImagerMasks
~ BEGIN OPEN ImagerMasks;

PixelArray: TYPE ~ ImagerPixelArrays.PixelArray;
PixelArrayRep: TYPE ~ ImagerPixelArrays.PixelArrayRep;

bitsPerWord: NAT ~ Basics.bitsPerWord;

FromRectangle: PUBLIC PROC[box: DeviceRectangle] RETURNS[Mask] ~ {
IF box.sSize = 0 OR box.fSize = 0 THEN RETURN [NIL]
ELSE RETURN [ImagerManhattan.CreateFromBox[box]]
};

FromManhattanPolygon: PUBLIC PROC[polygon: ImagerManhattan.Polygon] RETURNS[Mask] ~ {
RETURN [polygon]
};

FromBitmap: PUBLIC PROC [pixelMap: PixelMap] RETURNS [Mask] ~ {
IF pixelMap.refRep.lgBitsPerPixel # 0 THEN ERROR;
IF pixelMap.sSize = 0 OR pixelMap.fSize = 0 THEN RETURN [NIL]
ELSE RETURN [NEW[PixelMap _ ImagerPixelMaps.Trim[pixelMap]]];
};

FromDevicePath: PUBLIC PROC[devicePath: DevicePath] RETURNS[Mask] ~ {
RETURN [devicePath];
};

FromPixelArray: PUBLIC PROC[pixelArray: PixelArray, compositeTransformation: Transformation]
RETURNS [Mask] ~ {
IF compositeTransformation = pixelArray.m THEN RETURN [pixelArray]
ELSE {
copy: PixelArray _ NEW[PixelArrayRep _ pixelArray^];
copy.m _ compositeTransformation;
RETURN [copy]
};
};

BBList: PUBLIC PROC [mask: Mask] RETURNS [LIST OF DeviceRectangle] ~ {
RETURN [LIST[BoundingBox[mask]]]
};

BoundingBox: PUBLIC PROC [mask: Mask] RETURNS [DeviceRectangle] ~ {
WITH mask SELECT FROM
polygon: ManhattanPolygon => RETURN [ImagerManhattan.BoundingBox[polygon]];
bitmap: REF PixelMap => RETURN [[bitmap.sOrigin+bitmap.sMin, bitmap.fOrigin+bitmap.fMin, bitmap.sSize, bitmap.fSize]];
devicePath: DevicePath => RETURN [ImagerScanConverter.BoundingBox[devicePath]];
pixelArray: PixelArray => {
bb: ImagerTransform.IntRectangle _ pixelArray.m.TransformIntRectangle[
[0, 0, pixelArray.sPixels, pixelArray.fPixels]];
RETURN [[bb.x, bb.y, bb.w, bb.h]];
};
ENDCASE => RETURN [[0, 0, 0, 0]];
};

CountRuns: PUBLIC PROC [mask: Mask] RETURNS [numberOfRuns: INT] ~ {
WITH mask SELECT FROM
polygon: ManhattanPolygon => RETURN [ImagerManhattan.CountRuns[polygon]];
devicePath: DevicePath => RETURN [ImagerScanConverter.NumberOfRuns[devicePath]];
ENDCASE => {
RunProc: PROC [sMin, fMin: INTEGER, fSize: NAT] ~
{numberOfRuns _ numberOfRuns+1};
t1: ManhattanPolygon _ ImagerManhattan.CreateFromBox[BoundingBox[mask]];
numberOfRuns _ 0;
GenerateRuns[mask, t1, RunProc, 0, 0];
ImagerManhattan.Destroy[t1];
};
};

GenerateRuns: PUBLIC PROC [mask, clipper: Mask, runProc: PROC [sMin, fMin: INTEGER, fSize: NAT], sTranslate, fTranslate: INTEGER] ~ {
clipPoly: ManhattanPolygon _ WITH clipper SELECT FROM
polygon: ManhattanPolygon => polygon,
ENDCASE => ToManhattanPolygon[clipper, BBList[clipper], 0, 0];
remainder: ManhattanPolygon _ clipPoly;
TranslateAndClipRunProc: PROC [sMin, fMin: INTEGER, fSize: NAT] ~ {
sMin _ sMin + sTranslate;
fMin _ fMin + fTranslate;
WHILE remainder # NIL AND remainder.first.sMin + remainder.first.sSize <= sMin DO
remainder _ remainder.rest;
ENDLOOP;
FOR l: LIST OF DeviceRectangle _ remainder, l.rest UNTIL l = NIL OR l.first.sMin > sMin DO
fMinRun: INTEGER ~ MAX[l.first.fMin, fMin];
fMaxRun: INTEGER ~ MIN[l.first.fMin+l.first.fSize, fMin+fSize];
IF fMaxRun > fMinRun THEN runProc [sMin, fMinRun, fMaxRun-fMinRun];
ENDLOOP;
};
WITH mask SELECT FROM
polygon: ManhattanPolygon => ImagerManhattan.MapRuns[polygon, TranslateAndClipRunProc];
bitmap: REF PixelMap => {
IF clipPoly # NIL AND clipPoly.rest = NIL THEN {
BitmapGenerateRuns[bitmap^.ShiftMap[sTranslate, fTranslate].Clip[clipPoly.first], runProc];
}
ELSE BitmapGenerateRuns[bitmap^, TranslateAndClipRunProc];
};
devicePath: DevicePath => {
IF clipPoly # NIL AND clipPoly.rest = NIL AND sTranslate = 0 AND fTranslate = 0 THEN {
devicePath.ConvertToRuns[runProc, clipPoly.first];
}
ELSE {
devicePath.ConvertToRuns[TranslateAndClipRunProc, ImagerManhattan.BoundingBox[clipPoly]];
};
};
ENDCASE => {IF mask # NIL THEN ERROR};
IF clipPoly # clipper THEN ImagerManhattan.Destroy[clipPoly];
};

BitmapGenerateRuns: PROC [bitmap: PixelMap, runProc: PROC [sMin, fMin: INTEGER, fSize: NAT]] ~ TRUSTED {
refRep: REF ImagerPixelMaps.PixelMapRep _ bitmap.refRep;
rast: NAT _ refRep.rast;
s: INTEGER _ bitmap.sOrigin + MAX[bitmap.sMin, 0];
sMax: INTEGER _ MIN[bitmap.sOrigin + bitmap.sMin + bitmap.sSize, bitmap.sOrigin + refRep.lines];
linePtr: LONG POINTER TO CARDINAL _ refRep.pointer + Basics.LongMult[s-bitmap.sOrigin, rast];
fFirst: NAT _ MAX[bitmap.fMin, 0];
fEnd: NAT _ MAX[MIN[bitmap.fMin+bitmap.fSize, rast*bitsPerWord], 0];
fFirstWord: CARDINAL _ fFirst / bitsPerWord;
fFirstBit: CARDINAL _ fFirst MOD bitsPerWord;
IF refRep.lgBitsPerPixel # 0 THEN ERROR;
WHILE s < sMax DO
wordPtr: LONG POINTER TO CARDINAL _ linePtr+fFirstWord;
wordsWorth: CARDINAL _ Basics.BITSHIFT[wordPtr^, fFirstBit];
goodBitCount: INTEGER _ bitsPerWord-fFirstBit;
f: CARDINAL _ fFirst;
someRuns: BOOLEAN _ FALSE;
WHILE f < fEnd DO
fStart: CARDINAL;
WHILE f < fEnd DO
IF goodBitCount = bitsPerWord AND wordsWorth = 0 THEN f _ f + bitsPerWord
ELSE {
f _ f + goodBitCount;
WHILE goodBitCount > 0 AND wordsWorth <= LAST[NAT] DO
goodBitCount _ goodBitCount-1;
wordsWorth _ wordsWorth*2;
ENDLOOP;
f _ f - goodBitCount;
IF goodBitCount > 0 THEN EXIT;
goodBitCount _ bitsPerWord;
};
wordPtr _ wordPtr + 1;
wordsWorth _ wordPtr^;
ENDLOOP;
fStart _ f;
WHILE f < fEnd DO
IF goodBitCount = bitsPerWord AND wordsWorth = LAST[CARDINAL] THEN f _ f + bitsPerWord
ELSE {
f _ f + goodBitCount;
WHILE goodBitCount > 0 AND wordsWorth > LAST[NAT] DO
goodBitCount _ goodBitCount-1;
wordsWorth _ wordsWorth*2;
ENDLOOP;
f _ f - goodBitCount;
IF goodBitCount > 0 THEN EXIT;
goodBitCount _ bitsPerWord;
};
wordPtr _ wordPtr + 1;
wordsWorth _ wordPtr^;
ENDLOOP;
f _ MIN[f, fEnd];
IF f > fStart THEN runProc[s, fStart+bitmap.fOrigin, f-fStart];
ENDLOOP;
s _ s + 1;
linePtr _ linePtr + rast;
ENDLOOP;
};

ApplyTile: PUBLIC PROC [mask, clipper: Mask, dest: PixelMap, tile: Tile, function: Function _ [null, null], sTranslate, fTranslate: INTEGER] ~ {
RunProc: PROC [sMin, fMin: INTEGER, fSize: NAT] ~ {
dest.Clip[[sMin, fMin, 1, fSize]].TransferTile[tile, function];
};
GenerateRuns[mask, clipper, RunProc, sTranslate, fTranslate];
};

ApplyConstant: PUBLIC PROC [mask, clipper: Mask, dest: PixelMap, value: CARDINAL, function: Function _ [null, null], sTranslate, fTranslate: INTEGER] ~ {
RunProc: PROC [sMin, fMin: INTEGER, fSize: NAT] ~ {
dest.Fill[[sMin, fMin, 1, fSize], value, function];
};
clipPoly: ManhattanPolygon _ WITH clipper SELECT FROM
polygon: ManhattanPolygon => polygon,
ENDCASE => ToManhattanPolygon[clipper, BBList[clipper], 0, 0];
WITH mask SELECT FROM
polygon: ManhattanPolygon => {
IF clipPoly # NIL AND clipPoly.rest = NIL THEN {
clippedDest: PixelMap _ dest.Clip[clipPoly.first];
FOR l: LIST OF DeviceRectangle _ polygon, l.rest UNTIL l=NIL DO
ImagerPixelMaps.Fill[clippedDest, [l.first.sMin+sTranslate, l.first.fMin+fTranslate, l.first.sSize, l.first.fSize], value, function];
ENDLOOP;
}
ELSE GenerateRuns[mask, clipPoly, RunProc, sTranslate, fTranslate];
};
devicePath: DevicePath => {
IF clipPoly # NIL AND clipPoly.rest = NIL AND sTranslate = 0 AND fTranslate = 0 THEN {
devicePath.ConvertToPixels[pixelMap: dest.Clip[clipPoly.first], value: value, function: function];
}
ELSE GenerateRuns[mask, clipPoly, RunProc, sTranslate, fTranslate];
};
bitmap: REF PixelMap => {
IF clipPoly # NIL AND clipPoly.rest = NIL THEN {
SELECT TRUE FROM
dest.refRep.lgBitsPerPixel = 0 AND function = [null, null] => {
pixelMap: PixelMap _ bitmap^;
pixelMap.sOrigin _ pixelMap.sOrigin + sTranslate;
pixelMap.fOrigin _ pixelMap.fOrigin + fTranslate;
IF value MOD 2 = 1 THEN function _ [or, null]
ELSE function _ [and, complement];
dest.Clip[clipPoly.first].Transfer[pixelMap, function];
};
bitmap.refRep.lgBitsPerPixel = 0 AND function = [xor, null] => {
pixelMap: PixelMap _ bitmap^;
IF value MOD 2 = 0 THEN RETURN;
pixelMap.sOrigin _ pixelMap.sOrigin + sTranslate;
pixelMap.fOrigin _ pixelMap.fOrigin + fTranslate;
dest.Clip[clipPoly.first].Transfer[pixelMap, function];
};
ENDCASE => GenerateRuns[mask, clipPoly, RunProc, sTranslate, fTranslate];
}
ELSE GenerateRuns[mask, clipPoly, RunProc, sTranslate, fTranslate];
};
ENDCASE => {
GenerateRuns[mask, clipPoly, RunProc, sTranslate, fTranslate];
};
IF clipPoly # clipper THEN ImagerManhattan.Destroy[clipPoly];
};

ToPixelMap: PUBLIC PROC [mask, clipper: Mask, sTranslate, fTranslate: INTEGER, scratch: REF ImagerPixelMaps.PixelMapRep]
RETURNS [pixelMap: PixelMap] ~ {
bb: DeviceRectangle _ BoundingBox[mask];
bb.sMin _ bb.sMin + sTranslate;
bb.fMin _ bb.fMin + fTranslate;
bb _ ImagerPixelMaps.Intersect[bb, BoundingBox[clipper]];
pixelMap _ ImagerPixelMaps.Reshape[scratch, 0, bb];
ImagerPixelMaps.Clear[pixelMap];
ApplyConstant[mask, clipper, pixelMap, 1, [null, null], sTranslate, sTranslate];
};

ToManhattanPolygon: PUBLIC PROC [mask, clipper: Mask, sTranslate, fTranslate: INTEGER] RETURNS [manhattanPolygon: ManhattanPolygon] ~ {
Runs: PROC [
run: PROC [sMin, fMin: INTEGER, fSize: NAT],
repeat: PROC [timesToRepeatScanline: NAT]
] ~ {
GenerateRuns[mask, clipper, run, sTranslate, fTranslate];
};
manhattanPolygon _ ImagerManhattan.CreateFromRuns[Runs];
};

END.

,4ImagerMasksImpl.mesa
Copyright c 1984 Xerox Corporation.  All rights reserved.
Michael Plass, January 16, 1984 2:14 pm
Doug Wyatt, August 10, 1984 4:56:21 pm PDT
pixelArray: PixelArray => {
m: ImagerTransform.TransformationRec _ ImagerTransform.Contents[pixelArray.m];
X: PROC [x, y: REAL] RETURNS [REAL] ~ {
RETURN [m.a * x + m.b * y + m.c + sTranslate]
};
Y: PROC [x, y: REAL] RETURNS [REAL] ~ {
RETURN [m.d * x + m.e * y + m.f + fTranslate]
};
PathMap: ImagerScanConverter.PathProc ~ {
move[X[0, 0], Y[0, 0]];
line[X[0, pixelArray.yPixels], Y[0, pixelArray.yPixels]];
line[X[pixelArray.xPixels, pixelArray.yPixels], Y[pixelArray.xPixels, pixelArray.yPixels]];
line[X[pixelArray.xPixels, 0], Y[pixelArray.xPixels, 0]];
};
devicePath: DevicePath _ ImagerScanConverter.CreatePath[PathMap, BoundingBox[clipPoly]];
clipPoly _ ToManhattanPolygon[devicePath, clipPoly, 0, 0];
PixelArrayGenerateRuns[pixelArray, runProc, clipPoly];
};
PixelArrayGenerateRuns: PROC [pixelArray: PixelArray, runProc: PROC [sMin, fMin: INTEGER, fSize: NAT], area: Mask] ~ {
buffer: ImagerBasic.PixelBuffer _ NEW[ImagerBasic.PixelBufferRep[BoundingBox[area].fSize+1]];
inverseM: Transformation ~ ImagerTransform.Invert[pixelArray.m];
nextPixel: ImagerBasic.Pair _ ImagerTransform.TransformVec[[0, 1], inverseM];
xDeltaPixel: Scaled.Value _ Scaled.FromReal[nextPixel.x];
yDeltaPixel: Scaled.Value _ Scaled.FromReal[nextPixel.y];
DoRun: PROC [sMin, fMin: INTEGER, fSize: CARDINAL] ~ {
start: ImagerBasic.Pair _ ImagerTransform.Transform[[0.5+sMin, 0.5+fMin], inverseM];
xStart: Scaled.Value _ Scaled.FromReal[start.x];
yStart: Scaled.Value _ Scaled.FromReal[start.y];
runStart: NAT _ 0;
fRel: NAT _ 0;
pixelArray.get[pixelArray, buffer, fSize, 0, xStart, yStart, xDeltaPixel, yDeltaPixel];
WHILE fRel < fSize DO
buffer[fSize] _ 0;
WHILE buffer[fRel] # 0 DO fRel _ fRel + 1 ENDLOOP;
IF fRel > runStart THEN {runProc[sMin, fMin + runStart, fRel - runStart]};
buffer[fSize] _ 1;
WHILE buffer[fRel] = 0 DO fRel _ fRel + 1 ENDLOOP;
runStart _ fRel;
ENDLOOP;
};
GenerateRuns[area, area, DoRun, 0, 0];
};

PixelArrayFromPixelMap: PUBLIC PROC [pixelMap: PixelMap] RETURNS [pixelArray: PixelArray] ~ {
pixelArray _ NEW[ImagerBasic.PixelArrayRep];
pixelArray.xPixels _ pixelMap.sSize;
pixelArray.yPixels _ pixelMap.fSize;
pixelArray.samplesPerPixel _ 1;
pixelArray.m _ ImagerTransform.Rotate[0];
pixelArray.data _ NEW[ImagerPixelMaps.PixelMap _ pixelMap];
SELECT pixelMap.refRep.lgBitsPerPixel FROM
0 => {
pixelArray.maxSampleValue _ 1;
pixelArray.get _ GetOne;
};
1 => {
pixelArray.maxSampleValue _ 3;
pixelArray.get _ GetTwo;
};
2 => {
pixelArray.maxSampleValue _ 15;
pixelArray.get _ GetFour;
};
3 => {
pixelArray.maxSampleValue _ 255;
pixelArray.get _ GetEight;
};
4 => {
pixelArray.maxSampleValue _ LAST[CARDINAL];
pixelArray.get _ GetSixteen;
};
ENDCASE => ERROR;
};

GetOne: PROC [self: ImagerBasic.PixelArray, buffer: ImagerBasic.PixelBuffer, nSamples: NAT, layer: INT, xStart, yStart: Scaled.Value, xDelta, yDelta: Scaled.Value] ~ {
pixelArrayRef: REF ImagerPixelMaps.PixelMap ~ NARROW[self.data];
pixelArray: ImagerPixelMaps.PixelMap ~ pixelArrayRef^;
IF layer#0 THEN ERROR;
FOR i: NAT IN [0..nSamples) DO
WHILE yStart.Floor < 0 DO
yStart _ yStart.PLUS[Scaled.FromInt[pixelArray.fSize]];
ENDLOOP;
WHILE yStart.Floor >= pixelArray.fSize DO
yStart _ yStart.MINUS[Scaled.FromInt[pixelArray.fSize]];
ENDLOOP;
WHILE xStart.Floor < 0 DO
xStart _ xStart.PLUS[Scaled.FromInt[pixelArray.sSize]];
ENDLOOP;
WHILE xStart.Floor >= pixelArray.sSize DO
xStart _ xStart.MINUS[Scaled.FromInt[pixelArray.sSize]];
ENDLOOP;
buffer[i] _ pixelArray.GetBit[xStart.Floor, yStart.Floor];
xStart _ xStart.PLUS[xDelta];
yStart _ yStart.PLUS[yDelta];
ENDLOOP;
};

GetTwo: PROC [self: ImagerBasic.PixelArray, buffer: ImagerBasic.PixelBuffer, nSamples: NAT, layer: INT, xStart, yStart: Scaled.Value, xDelta, yDelta: Scaled.Value] ~ {
pixelArrayRef: REF ImagerPixelMaps.PixelMap ~ NARROW[self.data];
pixelArray: ImagerPixelMaps.PixelMap ~ pixelArrayRef^;
IF layer#0 THEN ERROR;
FOR i: NAT IN [0..nSamples) DO
WHILE yStart.Floor < 0 DO
yStart _ yStart.PLUS[Scaled.FromInt[pixelArray.fSize]];
ENDLOOP;
WHILE yStart.Floor >= pixelArray.fSize DO
yStart _ yStart.MINUS[Scaled.FromInt[pixelArray.fSize]];
ENDLOOP;
WHILE xStart.Floor < 0 DO
xStart _ xStart.PLUS[Scaled.FromInt[pixelArray.sSize]];
ENDLOOP;
WHILE xStart.Floor >= pixelArray.sSize DO
xStart _ xStart.MINUS[Scaled.FromInt[pixelArray.sSize]];
ENDLOOP;
buffer[i] _ pixelArray.Get2Bits[xStart.Floor, yStart.Floor];
xStart _ xStart.PLUS[xDelta];
yStart _ yStart.PLUS[yDelta];
ENDLOOP;
};

GetFour: PROC [self: ImagerBasic.PixelArray, buffer: ImagerBasic.PixelBuffer, nSamples: NAT, layer: INT, xStart, yStart: Scaled.Value, xDelta, yDelta: Scaled.Value] ~ {
pixelArrayRef: REF ImagerPixelMaps.PixelMap ~ NARROW[self.data];
pixelArray: ImagerPixelMaps.PixelMap ~ pixelArrayRef^;
IF layer#0 THEN ERROR;
FOR i: NAT IN [0..nSamples) DO
WHILE yStart.Floor < 0 DO
yStart _ yStart.PLUS[Scaled.FromInt[pixelArray.fSize]];
ENDLOOP;
WHILE yStart.Floor >= pixelArray.fSize DO
yStart _ yStart.MINUS[Scaled.FromInt[pixelArray.fSize]];
ENDLOOP;
WHILE xStart.Floor < 0 DO
xStart _ xStart.PLUS[Scaled.FromInt[pixelArray.sSize]];
ENDLOOP;
WHILE xStart.Floor >= pixelArray.sSize DO
xStart _ xStart.MINUS[Scaled.FromInt[pixelArray.sSize]];
ENDLOOP;
buffer[i] _ pixelArray.Get4Bits[xStart.Floor, yStart.Floor];
xStart _ xStart.PLUS[xDelta];
yStart _ yStart.PLUS[yDelta];
ENDLOOP;
};

GetEight: PROC [self: ImagerBasic.PixelArray, buffer: ImagerBasic.PixelBuffer, nSamples: NAT, layer: INT, xStart, yStart: Scaled.Value, xDelta, yDelta: Scaled.Value] ~ {
pixelArrayRef: REF ImagerPixelMaps.PixelMap ~ NARROW[self.data];
pixelArray: ImagerPixelMaps.PixelMap ~ pixelArrayRef^;
IF layer#0 THEN ERROR;
FOR i: NAT IN [0..nSamples) DO
WHILE yStart.Floor < 0 DO
yStart _ yStart.PLUS[Scaled.FromInt[pixelArray.fSize]];
ENDLOOP;
WHILE yStart.Floor >= pixelArray.fSize DO
yStart _ yStart.MINUS[Scaled.FromInt[pixelArray.fSize]];
ENDLOOP;
WHILE xStart.Floor < 0 DO
xStart _ xStart.PLUS[Scaled.FromInt[pixelArray.sSize]];
ENDLOOP;
WHILE xStart.Floor >= pixelArray.sSize DO
xStart _ xStart.MINUS[Scaled.FromInt[pixelArray.sSize]];
ENDLOOP;
buffer[i] _ pixelArray.Get8Bits[xStart.Floor, yStart.Floor];
xStart _ xStart.PLUS[xDelta];
yStart _ yStart.PLUS[yDelta];
ENDLOOP;
};

GetSixteen: PROC [self: ImagerBasic.PixelArray, buffer: ImagerBasic.PixelBuffer, nSamples: NAT, layer: INT, xStart, yStart: Scaled.Value, xDelta, yDelta: Scaled.Value] ~ {
pixelArrayRef: REF ImagerPixelMaps.PixelMap ~ NARROW[self.data];
pixelArray: ImagerPixelMaps.PixelMap ~ pixelArrayRef^;
IF layer#0 THEN ERROR;
FOR i: NAT IN [0..nSamples) DO
WHILE yStart.Floor < 0 DO
yStart _ yStart.PLUS[Scaled.FromInt[pixelArray.fSize]];
ENDLOOP;
WHILE yStart.Floor >= pixelArray.fSize DO
yStart _ yStart.MINUS[Scaled.FromInt[pixelArray.fSize]];
ENDLOOP;
WHILE xStart.Floor < 0 DO
xStart _ xStart.PLUS[Scaled.FromInt[pixelArray.sSize]];
ENDLOOP;
WHILE xStart.Floor >= pixelArray.sSize DO
xStart _ xStart.MINUS[Scaled.FromInt[pixelArray.sSize]];
ENDLOOP;
buffer[i] _ pixelArray.Get16Bits[xStart.Floor, yStart.Floor];
xStart _ xStart.PLUS[xDelta];
yStart _ yStart.PLUS[yDelta];
ENDLOOP;
};

ApplyConstantUsingRuns: PROC [mask: Mask, dest: PixelMap, value: CARDINAL, function: Function] ~ TRUSTED {
lgBitsPerPixel: INTEGER ~ dest.refRep.lgBitsPerPixel;
lgPixelsPerWord: INTEGER ~ lgBitsPerWord-lgBitsPerPixel;
rast: CARDINAL ~ dest.refRep.rast;
sMinClip: INTEGER ~ MAX[
INT[mask.sOrigin]+mask.sMin,
INT[dest.sOrigin]+dest.sMin,
dest.sOrigin
];
sMaxClip: INTEGER ~ MIN[
INT[mask.sOrigin]+mask.sMin+mask.sSize,
INT[dest.sOrigin]+dest.sMin+dest.sSize,
dest.sOrigin+dest.refRep.lines
];
fMinClip: INTEGER ~ MAX[
INT[mask.fOrigin]+mask.fMin,
INT[dest.fOrigin]+dest.fMin,
dest.fOrigin
];
fMaxClip: INTEGER ~ MIN[
INT[mask.fOrigin]+mask.fMin+mask.fSize,
INT[dest.fOrigin]+dest.fMin+dest.fSize,
INT[dest.fOrigin]+Shift[rast, lgBitsPerWord-lgBitsPerPixel]
];
IF sMaxClip>sMinClip AND fMaxClip>fMinClip THEN {
fMinBufferLimit: INTEGER ~ MAX[dest.fMin, 0];
fMaxBufferLimit: INTEGER ~ MIN[dest.fMin+dest.fSize, Shift[rast, lgBitsPerWord-lgBitsPerPixel]];
replicatedPixel: CARDINAL _ Basics.BITAND[value, Shift[1, Shift[1, lgBitsPerPixel]]-1] * replicator[lgBitsPerPixel];
bbTableSpace: BitBlt.BBTableSpace;
bb: BitBlt.BBptr _ BitBlt.AlignedBBTable[@bbTableSpace];
bitMask: CARDINAL _ Shift[1, lgPixelsPerWord]-1;
s: INTEGER _ sMinClip;
linePtr: LONG POINTER _ dest.refRep.pointer+Basics.LongMult[rast, sMinClip-dest.sOrigin];
RunProc: PROC [sMin, fMin: INTEGER, fSize: NAT] ~ TRUSTED {
fMinBuffer: NAT _ fMin-dest.fOrigin;
IF fMin + fSize > fMaxClip THEN ERROR;
IF NOT (sMin IN [s..sMaxClip)) THEN ERROR;
WHILE s<sMin DO
linePtr _ linePtr + rast;
s _ s + 1;
ENDLOOP;
bb.dst.word _ linePtr + Shift[fMinBuffer, -lgPixelsPerWord];
bb.dst.bit _ Basics.BITAND[fMinBuffer, bitMask];
bb.width _ Shift[fSize, lgBitsPerPixel];
BitBlt.BITBLT[bb];
};
bb^ _ [
dst: [word: NIL, bit: 0],
dstBpl: rast*bitsPerWord,
src: [word: @replicatedPixel, bit: 0],
srcDesc: [gray[[yOffset: 0, widthMinusOne: 0, heightMinusOne: 0]]],
height: 1,
width: 0,
flags: [direction: forward, disjoint: TRUE, disjointItems: TRUE, gray: TRUE, srcFunc: function.srcFunc, dstFunc: function.dstFunc]
];
mask.sSize _ sMaxClip-sMinClip;
mask.fSize _ fMaxClip-fMinClip;
mask.sMin _ sMinClip - mask.sOrigin;
mask.fMin _ fMinClip - mask.fOrigin;
mask.class.generateRuns[mask, RunProc];
};
};


BitmapApplyConstant: PROC [mask: Mask, dest: PixelMap, value: CARDINAL, function: Function] ~ TRUSTED {
WITH mask.data SELECT FROM
refRep: REF ImagerPixelMaps.PixelMapRep => {
IF dest.refRep.lgBitsPerPixel = 0 THEN {
sMin: INTEGER ~ MAX[dest.sOrigin+MAX[dest.sMin, 0], mask.sOrigin+MAX[mask.sMin, 0]];
sMax: INTEGER ~ MIN[dest.sOrigin+MIN[dest.sMin+dest.sSize, dest.refRep.lines], mask.sOrigin+MIN[mask.sMin+mask.sSize, refRep.lines]];
fMin: INTEGER ~ MAX[dest.fOrigin+MAX[dest.fMin, 0], mask.fOrigin+MAX[mask.fMin, 0]];
fMax: INTEGER ~ MIN[dest.fOrigin+MIN[dest.fMin+dest.fSize, dest.refRep.rast * bitsPerWord], mask.fOrigin+MIN[mask.fMin+mask.fSize, refRep.rast * bitsPerWord]];
bbTableSpace: BitBlt.BBTableSpace;
bb: BitBlt.BBptr ~ BitBlt.AlignedBBTable[@bbTableSpace];
fMinDest: NAT ~ fMin - dest.fOrigin;
fMinSource: NAT ~ fMin - mask.fOrigin;
sStartDest: NAT ~ sMin-dest.sOrigin;
sStartSource: NAT ~ sMin-mask.sOrigin;
srcFunc: BitBlt.SrcFunc _ null;
dstFunc: BitBlt.DstFunc _ or;
IF function.srcFunc = complement THEN value _ 1-value;
IF value MOD 2 = 0 THEN {
IF function.dstFunc = xor THEN RETURN;
srcFunc _ complement; dstFunc _ and;
};
IF function.dstFunc = xor THEN dstFunc _ xor;
IF sMin<sMax AND fMin<fMax THEN {
bb^ _ [
dstBpl: dest.refRep.rast*bitsPerWord,
srcDesc: [srcBpl[refRep.rast*bitsPerWord]],
height: sMax-sMin,
width: fMax-fMin,
flags: [direction: forward, disjoint: TRUE, disjointItems: TRUE, gray: FALSE, srcFunc: srcFunc, dstFunc: dstFunc]
];
bb.dst _ [word: dest.refRep.pointer + Basics.LongMult[sStartDest, dest.refRep.rast] + fMinDest/bitsPerWord, bit: fMinDest MOD bitsPerWord];
bb.src _ [word: refRep.pointer + Basics.LongMult[sStartSource, refRep.rast] + fMinSource/bitsPerWord, bit: fMinSource MOD bitsPerWord];
BitBlt.BITBLT[bb];
};
}
ELSE ApplyConstantUsingRuns[mask, dest, value, function];
};
ENDCASE => ERROR;
};

�ʘ™Jšœ
Ïm
œ.™9J™'J™*—J˜š
Ïk	˜	Jšœžœžœ˜/JšœžœT˜iJšœžœa˜rJšœžœ˜4Jšœžœh˜}Jšœžœ=˜VJšœžœ'˜<Jšœžœ˜J˜—Jšœž
˜JšžœO˜VJšžœ˜Jšœžœ
žœ
˜J˜Jšœžœ ˜0Jšœžœ#˜6J˜šœ
žœ˜&J˜—šÏn
œžœ
žœžœ
˜BJš
žœžœžœ
žœžœ
˜3Jšžœ
žœ%˜0Jš
œ˜J˜—šŸœžœ
žœ#žœ
˜UJšžœ
˜Jš
œ˜J˜—šŸ
œžœ
žœžœ˜?Jšžœ$žœ
žœ
˜1Jš
žœžœžœ
žœžœ
˜=Jšžœ
žœžœ-˜=Jš
œ˜J˜—šŸœžœ
žœžœ
˜EJšžœ˜Jš
œ˜J˜—šŸœžœ
žœA˜\Jšžœ˜Jšžœ(žœ
žœ
˜Bšžœ˜Jšœžœ˜4Jš
œ!˜!Jšžœ˜
Jš
œ˜—Jš
œ˜J˜—šŸœžœ
žœžœžœ
žœ˜FJšžœžœ˜ Jš
œ˜J˜—šŸœžœ
žœžœ˜Cšžœžœ
ž˜Jšœžœ(˜KJšœžœ
žœX˜vJšœžœ/˜Oš
œ˜š
œF˜FJš
œ0˜0—Jšžœ˜"Jš
œ˜—Jšžœžœ˜!—Jš
œ˜J˜—š
Ÿ	œžœ
žœžœžœ˜Cšžœžœ
ž˜Jšœžœ&˜IJšœžœ0˜Pšžœ˜šŸœžœžœ	žœ˜1Jš
œ ˜ —Jš
œH˜HJš
œ˜Jš
œ&˜&Jš
œ˜Jš
œ˜——Jš
œ˜J˜—šŸœžœ
žœ žœžœ	žœžœ˜…
šœžœ	žœ
ž˜5J˜%Jšžœ7˜>—Jš
œ'˜'šŸœžœžœ	žœ˜CJš
œ˜Jš
œ˜šžœ
žœ
žœ6ž˜QJš
œ˜Jš
ž˜—š
žœžœ
žœ%žœžœ
žœž˜ZJšœ	žœžœ˜+Jšœ	žœžœ)˜?Jšžœžœ*˜CJš
ž˜—Jš
œ˜—šžœžœ
ž˜Jš
œW˜Wšœžœ˜š
žœžœ
žœžœ
žœ˜0Jš
œ[˜[Jš
œ
˜
—Jšžœ6˜:Jš
œ˜—š
œ˜šžœžœ
žœžœ
žœžœžœ˜VJš
œ2˜2Jš
œ
˜
—šžœ˜Jš
œY˜YJš
œ˜—Jš
œ˜—š
œ™Jš
œN™Nš
Ÿ
œžœžœžœžœ™'Jšžœ'™-Jš
œ™—š
Ÿ
œžœžœžœžœ™'Jšžœ'™-Jš
œ™—šŸœ"™)Jš
œ™Jš
œ9™9Jš
œ[™[Jš
œ9™9Jš
œ™—Jš
œX™XJš
œ:™:Jš
œ6™6Jš
œ™—Jš
žœžœžœ
žœ
žœ˜&—Jšžœžœ#˜=Jš
œ˜J˜—šŸœžœžœžœ	žœžœ˜hJšœžœ-˜8Jšœžœ˜Jšœžœžœ˜2JšœžœžœM˜`Jš	œ	žœ
žœ
žœ
žœ<˜]Jšœžœžœ˜"Jšœžœžœ
žœ1˜DJšœžœ˜,Jšœžœ
žœ
˜-Jšžœžœ
žœ
˜(šžœ
ž˜Jš	œ	žœ
žœ
žœ
žœ˜7Jšœžœ
žœ˜<Jšœžœ˜.Jšœžœ
˜Jšœ
žœžœ
˜šžœ
ž˜Jšœžœ
˜šžœ
ž˜Jšžœžœžœ˜Išžœ˜Jš
œ˜š	žœžœžœ
žœž˜5Jš
œ˜Jš
œ˜Jšžœ
˜—Jš
œ˜Jšžœžœ
žœ
˜Jš
œ˜Jš
œ˜—Jš
œ˜Jš
œ˜Jšžœ
˜—Jš
œ˜šžœ
ž˜Jš
žœžœžœ
žœžœ˜Všžœ˜Jš
œ˜š	žœžœžœ
žœž˜4Jš
œ˜Jš
œ˜Jšžœ
˜—Jš
œ˜Jšžœžœ
žœ
˜Jš
œ˜Jš
œ˜—Jš
œ˜Jš
œ˜Jšžœ
˜—Jšœžœ
˜Jšžœžœ-˜?Jšžœ
˜—J˜
Jš
œ˜Jšžœ
˜—Jš
œ˜J˜—š
Ÿœžœ#žœžœ	žœ™vJšœ"žœ8™]Jš
œ@™@Jš
œM™MJš
œ9™9Jš
œ9™9šŸœžœžœ	žœ™6Jš
œT™TJš
œ0™0Jš
œ0™0Jšœ
žœ™Jšœžœ™Jš
œW™Wšžœž™Jš
œ™Jšžœžœžœ
™2Jšžœžœ3™JJš
œ™Jšžœžœžœ
™2Jš
œ™Jšžœ
™—Jš
œ™—Jš
œ&™&J™J™—šŸ	œžœ
žœnžœ˜�
šŸœžœžœ	žœ˜3Jš
œ?˜?Jš
œ˜—Jš
œ=˜=Jš
œ˜J˜—š
Ÿ
œžœ
žœ.žœ=žœ˜™
šŸœžœžœ	žœ˜3Jš
œ3˜3Jš
œ˜—šœžœ	žœ
ž˜5J˜%Jšžœ7˜>—šžœžœ
ž˜š
œ˜š
žœžœ
žœžœ
žœ˜0Jš
œ2˜2šžœžœ
žœ#žœžœ
ž˜?Jš
œ…
˜…
Jš
ž˜—Jš
œ
˜
—Jšžœ?˜CJš
œ˜—š
œ˜šžœžœ
žœžœ
žœžœžœ˜VJš
œb˜bJ˜
—Jšžœ>ž
˜CJš
œ˜—šœžœ˜š
žœžœ
žœžœ
žœ˜0šžœ
žœ
ž˜šœžœ˜?Jš
œ˜Jš
œ1˜1Jš
œ1˜1Jšžœžœžœ˜-Jšžœ˜"Jš
œ7˜7Jš
œ˜—šœ!žœ˜@Jš
œ˜Jšžœžœžœ
žœ
˜Jš
œ1˜1Jš
œ1˜1Jš
œ7˜7Jš
œ˜—JšžœB˜I—Jš
œ
˜
—Jšžœ?˜CJš
œ˜—šžœ˜Jš
œ>˜>Jš
œ˜——Jšžœžœ#˜=Jš
œ˜J˜—š
Ÿ
œžœ
žœ/žœžœ˜xJšžœ˜ Jš
œ(˜(Jš
œ˜Jš
œ˜Jš
œ9˜9Jš
œ3˜3Jš
œ ˜ Jš
œP˜PJš
œ˜J˜—š
Ÿœžœ
žœ/žœžœ)˜‡
šŸœžœ˜Jšœžœžœ	žœ˜,Jšœžœžœ
˜)Jš
œ˜Jš
œ9˜9Jš
œ˜—Jš
œ8˜8Jš
œ˜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™—šŸœžœKžœ	žœA™§
Jšœžœžœ™@Jš
œ6™6Jšžœ	žœ
žœ
™šžœžœ
žœž™šžœž™Jšœžœ#™7Jšžœ
™—šžœ"ž™)Jšœžœ#™8Jšžœ
™—šžœž™Jšœžœ#™7Jšžœ
™—šžœ"ž™)Jšœžœ#™8Jšžœ
™—Jš
œ:™:Jšœžœ	™Jšœžœ	™Jšžœ
™—J™J™—šŸœžœKžœ	žœA™§
Jšœžœžœ™@Jš
œ6™6Jšžœ	žœ
žœ
™šžœžœ
žœž™šžœž™Jšœžœ#™7Jšžœ
™—šžœ"ž™)Jšœžœ#™8Jšžœ
™—šžœž™Jšœžœ#™7Jšžœ
™—šžœ"ž™)Jšœžœ#™8Jšžœ
™—Jš
œ<™<Jšœžœ	™Jšœžœ	™Jšžœ
™—J™J™—šŸœžœKžœ	žœA™¨
Jšœžœžœ™@Jš
œ6™6Jšžœ	žœ
žœ
™šžœžœ
žœž™šžœž™Jšœžœ#™7Jšžœ
™—šžœ"ž™)Jšœžœ#™8Jšžœ
™—šžœž™Jšœžœ#™7Jšžœ
™—šžœ"ž™)Jšœžœ#™8Jšžœ
™—Jš
œ<™<Jšœžœ	™Jšœžœ	™Jšžœ
™—J™J™—šŸœžœKžœ	žœA™©
Jšœžœžœ™@Jš
œ6™6Jšžœ	žœ
žœ
™šžœžœ
žœž™šžœž™Jšœžœ#™7Jšžœ
™—šžœ"ž™)Jšœžœ#™8Jšžœ
™—šžœž™Jšœžœ#™7Jšžœ
™—šžœ"ž™)Jšœžœ#™8Jšžœ
™—Jš
œ<™<Jšœžœ	™Jšœžœ	™Jšžœ
™—J™J™—šŸ
œžœKžœ	žœA™«
Jšœžœžœ™@Jš
œ6™6Jšžœ	žœ
žœ
™šžœžœ
žœž™šžœž™Jšœžœ#™7Jšžœ
™—šžœ"ž™)Jšœžœ#™8Jšžœ
™—šžœž™Jšœžœ#™7Jšžœ
™—šžœ"ž™)Jšœžœ#™8Jšžœ
™—Jš
œ=™=Jšœžœ	™Jšœžœ	™Jšžœ
™—J™J™—šžœ
˜J˜šŸœžœ%žœžœ™jJšœžœ™5Jšœžœ ™8Jšœžœ™"šœ
žœžœ
™Jšžœ™Jšžœ™Jš
œ™Jš
œ™—šœ
žœžœ
™Jšžœ$™'Jšžœ$™'Jš
œ™Jš
œ™—šœ
žœžœ
™Jšžœ™Jšžœ™Jš
œ™Jš
œ™—šœ
žœžœ
™Jšžœ$™'Jšžœ$™'Jšžœ8™;Jš
œ™—šžœžœžœ™1Jšœžœžœ™-JšœžœžœB™`Jšœžœ
žœK™tJ™"Jš
œ8™8Jšœ	žœ™0Jšœžœ™Jšœ	žœ
žœD™Yš
Ÿœžœžœ	žœžœ™;Jšœžœ™$Jšžœžœ
žœ
™&Jš
žœ
žœžœžœ
žœ
™*šžœž™J™J™
Jšžœ
™—Jš
œ<™<Jšœžœ™0Jš
œ(™(Jšœžœ™Jš
œ™—š
œ™Jšœžœ
™Jš
œ™Jš
œ&™&Jš
œC™CJš
œ
™
Jš
œ	™	Jšœ&žœžœžœ7™‚
J™—J™J™J™$J™$Jš
œ'™'Jš
œ™—Jš
œ™J™J™—šŸœžœ%žœžœ™gšžœžœ
ž™šœžœ!™,šžœ žœ™(Jš	œžœžœžœžœ™TJš	œžœžœžœ8žœ&™…
Jš	œžœžœžœžœ™TJš	œžœžœžœEžœ3™Ÿ
J™"Jš
œ8™8Jšœ
žœ™$Jšœžœ™&Jšœžœ™$Jšœžœ™&Jš
œ™Jš
œ™Jšžœžœ™6šžœžœžœ™Jšžœžœ
žœ
™&Jš
œ$™$Jš
œ™—Jšžœžœ™-šžœžœžœ™!š
œ™Jš
œ%™%Jš
œ+™+Jš
œ™Jš
œ™Jšœ&žœžœžœ%™qJ™—Jšœzžœ™‹
Jšœvžœ™‡
Jšœžœ™J™—Jš
œ
™
—Jšžœ5™9Jš
œ™—Jšžœžœ
™—Jš
œ™J™———…—&Fi‰