-- BitTunerCmds.mesa
DIRECTORY AIS, Graphics, GraphicsOps, CGScreen, Inline, JaMBasic, JaMInternal, JaMOps, Rope, Real, TJaMGraphics, TJaMGraphicsContexts, Runtime;
BitTunerCmds: PROGRAM
IMPORTS AIS, Graphics, GraphicsOps, CGScreen, Inline, JaMOps, Rope, Real, TJaMGraphics, TJaMGraphicsContexts, Runtime
= BEGIN
ROPE: TYPE = Rope.ROPE;
Frame: TYPE = JaMInternal.Frame;
PopRope: PROCEDURE [f: Frame] RETURNS [rope: ROPE] = {
s: string JaMBasic.Object _ JaMOps.PopString[f.opstk];
C: PROC[c: CHAR] RETURNS [BOOLEAN] =
{t[t.length]_c; t.length _ t.length+1; RETURN[FALSE]};
t: REF TEXT _ NEW[TEXT[s.length]];
t.length _ 0;
JaMOps.StringForAll[s, C];
rope _ Rope.FromRefText[t];
};
PushRope: PROCEDURE [f: Frame, rope: ROPE] = {
JaMOps.Push[
f.opstk,
JaMOps.MakeString[LOOPHOLE[rope.ToRefText[], LONG STRING]]
];
};
AllocateBitmap: PROCEDURE [f: Frame] = {
side: NAT;
side _ JaMOps.PopInteger[f.opstk];
bitImage _ GraphicsOps.NewBitmap[side, side];
bitImageDescriptor _ DescriptorFor[bitImage];
};
DrawBitmap: PROCEDURE [f: Frame] = {
Paint: PROCEDURE [context: Graphics.Context] = {
GraphicsOps.DrawBitmap[self: context, bitmap: bitImage, w: bitImage.width, h: bitImage.height, x: 0, y: 0, xorigin: 0, yorigin: bitImage.height];
};
TJaMGraphics.Painter[Paint];
};
image: Graphics.ImageRef _ NIL;
AISName: Rope.Text _ "AISTemp$";
otherAISName: Rope.Text _ "AISTemp$$";
PingPongNames: PROCEDURE = {
temp: Rope.Text _ AISName;
AISName _ otherAISName;
otherAISName _ temp;
};
StoreAIS: PROCEDURE [f: Frame] = {
mapNumber: NAT _ JaMOps.PopInteger[f.opstk];
fileName: ROPE _ PopRope[f];
map: Wordmap _ wordmap[mapNumber];
aisFile: AIS.FRef;
aisWindow: AIS.WRef;
raster: AIS.RasterPart;
raster.scanCount _ map.side;
raster.scanLength _ map.side;
raster.scanMode _ rd;
raster.bitsPerPixel _ 8;
raster.linesPerBlock _ -1;
raster.paddingPerBlock _ 0;
aisFile _ AIS.CreateFile[name: LOOPHOLE[fileName], raster: @raster, overwrite: TRUE];
aisWindow _ AIS.OpenWindow[aisFile];
FOR i: NAT IN [0..map.side) DO
FOR j: NAT IN [0..map.side) DO
sample: INT _ map[i*map.side+j];
sample _ MAX[0, MIN[map.unit, sample]];
AIS.WriteSample[aisWindow, 255 - 255*sample/map.unit, i, j];
ENDLOOP
ENDLOOP; 
AIS.CloseWindow[aisWindow];
AIS.CloseFile[aisFile];
};
DrawMap: PROCEDURE [f: Frame] = {
mapNumber: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapNumber];
aisFile: AIS.FRef;
aisWindow: AIS.WRef;
raster: AIS.RasterPart;
raster.scanCount _ map.side;
raster.scanLength _ map.side;
raster.scanMode _ rd;
raster.bitsPerPixel _ 8;
raster.linesPerBlock _ -1;
raster.paddingPerBlock _ 0;
aisFile _ AIS.CreateFile[name: LOOPHOLE[AISName], raster: @raster, overwrite: TRUE];
aisWindow _ AIS.OpenWindow[aisFile];
FOR i: NAT IN [0..map.side) DO
FOR j: NAT IN [0..map.side) DO
sample: INT _ map[i*map.side+j];
sample _ MAX[0, MIN[map.unit, sample]];
AIS.WriteSample[aisWindow, 255 - 255*sample/map.unit, i, j];
ENDLOOP
ENDLOOP; 
AIS.CloseWindow[aisWindow];
AIS.CloseFile[aisFile];
image _ GraphicsOps.NewAisImage[LOOPHOLE[AISName]];
PingPongNames[]; -- to fool the cache in CGAISImageImpl.
ReDrawMap[f];
};
ReDrawMap: PROCEDURE [f: Frame] = {
Paint: PROCEDURE [context: Graphics.Context] = {
Graphics.DrawImage[self: context, image: image];
};
TJaMGraphics.Painter[Paint];
};
BitImageContext: PROCEDURE RETURNS[Graphics.Context] = {
bitImageContext _ GraphicsOps.NewContextFromBitmap[bitImage];
RETURN [bitImageContext];
};
UseBitmap: PROCEDURE [f: Frame] = {
TJaMGraphicsContexts.AddContext[f, BitImageContext, $BitTunerCmds, TRUE, TRUE];
TJaMGraphicsContexts.DisableViewer[f];
};
UseScreen: PROCEDURE [f: Frame] = {
TJaMGraphicsContexts.DisableContext[f, $BitTunerCmds];
TJaMGraphicsContexts.EnableViewer[f];
};
GetBit: PROCEDURE [f: Frame] = {ENABLE Runtime.BoundsFault => CONTINUE;
x, y: NAT;
bit: NAT _ 0;
y _ JaMOps.PopInteger[f.opstk];
x _ JaMOps.PopInteger[f.opstk];
bit _ bitImageDescriptor[bitImage.height-1-y][x];
JaMOps.PushInteger[f.opstk, bit];
};
PutBit: PROCEDURE [f: Frame] = {ENABLE Runtime.BoundsFault => CONTINUE;
x, y: NAT;
bit: NAT _ JaMOps.PopInteger[f.opstk];
y _ JaMOps.PopInteger[f.opstk];
x _ JaMOps.PopInteger[f.opstk];
bitImageDescriptor[bitImage.height-1-y][x] _ bit;
};
LoadFromBitmap: PROCEDURE [f: Frame] = {
mapNumber: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap;
index: NAT _ 0;
IF wordmap[mapNumber] = NIL OR wordmap[mapNumber].side # bitImage.width THEN wordmap[mapNumber] _ NewWordmap[bitImage.width];
map _ wordmap[mapNumber];
map.unit _ 65536;
FOR i: NAT IN [0..map.side) DO
FOR j: NAT IN [0..map.side) DO
map[index] _ bitImageDescriptor[i][j]*map.unit;
index _ index + 1;
ENDLOOP
ENDLOOP
};
Div2: PROCEDURE [a: INT] RETURNS [b: INT] = INLINE {
b _ LOOPHOLE[LongNumberDiv2[LOOPHOLE[a]]]
};
LongNumberDiv2: PROCEDURE [a: Inline.LongNumber] RETURNS [b: Inline.LongNumber] = INLINE {
b.highbits _ Inline.BITSHIFT[a.highbits, -1] + Inline.BITAND[a.highbits, 100000B];
b.lowbits _ Inline.BITSHIFT[a.lowbits, -1] + Inline.BITSHIFT[a.highbits, 15];
};
ConvolveLeft: PROCEDURE [f: Frame] = {
mapNumber: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapNumber];
index: NAT _ 0;
side: NAT _ map.side;
limit: NAT _ side-1;
FOR i: NAT IN [0..side) DO
p: LONG POINTER TO INT _ @map[index];
FOR j: NAT IN [0..limit) DO
p^ _ Div2[p^ + (p+SIZE[INT])^];
p _ p+SIZE[INT];
ENDLOOP;
index _ index + side;
ENDLOOP;
};
ConvolveUp: PROCEDURE [f: Frame] = {
mapNumber: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapNumber];
index: NAT _ 0;
side: NAT _ map.side;
delta: NAT _ SIZE[INT]*side;
FOR i: NAT IN [0..side-1) DO
p: LONG POINTER TO INT _ @map[index];
FOR j: NAT IN [0..side) DO
p^ _ Div2[p^ + (p+delta)^];
p _ p+SIZE[INT];
ENDLOOP;
index _ index + side;
ENDLOOP;
};
ConvolveRight: PROCEDURE [f: Frame] = {
mapNumber: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapNumber];
index: NAT _ map.length;
side: NAT _ map.side;
FOR i: NAT DECREASING IN [0..side) DO
p: LONG POINTER TO INT _ @map[index-1];
FOR j: NAT DECREASING IN [1..side) DO
p^ _ Div2[p^ + (p-SIZE[INT])^];
p _ p-SIZE[INT];
ENDLOOP;
index _ index - side;
ENDLOOP;
};
ConvolveDown: PROCEDURE [f: Frame] = {
mapNumber: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapNumber];
index: NAT _ map.length;
side: NAT _ map.side;
delta: NAT _ SIZE[INT]*side;
FOR i: NAT DECREASING IN [1..side) DO
p: LONG POINTER TO INT _ @map[index-1];
FOR j: NAT DECREASING IN [1..side) DO
p^ _ Div2[p^ + (p-delta)^];
p _ p-SIZE[INT];
ENDLOOP;
index _ index - side;
ENDLOOP;
};

Copy: PROCEDURE [f: Frame] = {
source: NAT _ JaMOps.PopInteger[f.opstk];
dest: NAT _ JaMOps.PopInteger[f.opstk];
destMap: Wordmap _ wordmap[dest];
sourceMap: Wordmap _ wordmap[source];
IF destMap = NIL OR destMap.side # sourceMap.side THEN destMap _ wordmap[dest] _ NewWordmap[sourceMap.side];
destMap.unit _ sourceMap.unit;
FOR index: NAT IN [0..sourceMap.length) DO
destMap[index] _ sourceMap[index];
ENDLOOP;
};
Add: PROCEDURE [f: Frame] = {
source: NAT _ JaMOps.PopInteger[f.opstk];
dest: NAT _ JaMOps.PopInteger[f.opstk];
destMap: Wordmap _ wordmap[dest];
sourceMap: Wordmap _ wordmap[source];
IF destMap.unit # sourceMap.unit OR destMap.side # sourceMap.side THEN ERROR;
FOR index: NAT IN [0..sourceMap.length) DO
destMap[index] _ destMap[index] + sourceMap[index];
ENDLOOP;
};
Subtract: PROCEDURE [f: Frame] = {
source: NAT _ JaMOps.PopInteger[f.opstk];
dest: NAT _ JaMOps.PopInteger[f.opstk];
destMap: Wordmap _ wordmap[dest];
sourceMap: Wordmap _ wordmap[source];
IF destMap.unit # sourceMap.unit OR destMap.side # sourceMap.side THEN ERROR;
FOR index: NAT IN [0..sourceMap.length) DO
destMap[index] _ destMap[index] - sourceMap[index];
ENDLOOP;
};
AddShifted: PROCEDURE [f: Frame] = {
scale: REAL _ JaMOps.PopReal[f.opstk];
deltaY: INTEGER _ JaMOps.PopInteger[f.opstk];
deltaX: INTEGER _ JaMOps.PopInteger[f.opstk];
source: NAT _ JaMOps.PopInteger[f.opstk];
dest: NAT _ JaMOps.PopInteger[f.opstk];
destMap: Wordmap _ wordmap[dest];
sourceMap: Wordmap _ wordmap[source];
index: NAT _ 0;
IF destMap.unit # sourceMap.unit THEN ERROR;
FOR i: NAT IN [0..sourceMap.side) DO IF i-deltaY IN [0..destMap.side) THEN {
row: NAT _ (i-deltaY)*destMap.side;
FOR j: NAT IN [0..sourceMap.side) DO
IF j+deltaX IN [0..destMap.side) THEN destMap[row+j+deltaX] _ destMap[row+j+deltaX] + Real.RoundLI[sourceMap[index]*scale];
index _ index + 1;
ENDLOOP;
} ENDLOOP;
};
SubSample: PROCEDURE [f: Frame] = {
scaleDownFactor: NAT _ JaMOps.PopInteger[f.opstk];
source: NAT _ JaMOps.PopInteger[f.opstk];
dest: NAT _ JaMOps.PopInteger[f.opstk];
sourceMap: Wordmap _ wordmap[source];
destMap: Wordmap _ NewWordmap[sourceMap.side/scaleDownFactor];
destMap.unit _ sourceMap.unit;
FOR i: NAT IN [0..destMap.side) DO
FOR j: NAT IN [0..destMap.side) DO
destMap[destMap.side*i+j] _ sourceMap[(sourceMap.side*i+j)*scaleDownFactor];
ENDLOOP;
ENDLOOP;
};
Biggest: PROCEDURE [f: Frame] = {
mapno: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapno];
max: INT _ FIRST[INT];
besti, bestj: NAT;
index: NAT _ 0;
FOR i: NAT IN [0..map.side) DO
FOR j: NAT IN [0..map.side) DO
IF map[index] > max THEN {max _ map[index]; besti _ i; bestj _ j};
index _ index + 1;
ENDLOOP;
ENDLOOP;
JaMOps.PushInteger[f.opstk, bestj];
JaMOps.PushInteger[f.opstk, map.side-1-besti];
};
Abs: PROCEDURE [f: Frame] = {
mapno: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapno];
FOR index: NAT IN [0..map.length) DO
map[index] _ ABS[map[index]];
ENDLOOP;
};
Sqr: PROCEDURE [f: Frame] = {
mapno: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapno];
FOR index: NAT IN [0..map.length) DO
int: INT _ map[index];
map[index] _ int*int/map.unit;
ENDLOOP;
};
Scale: PROCEDURE [f: Frame] = {
scale: REAL _ JaMOps.PopReal[f.opstk];
mapno: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapno];
FOR index: NAT IN [0..map.length) DO
map[index] _ Real.RoundLI[map[index]*scale];
ENDLOOP;
};
Threshold: PROCEDURE [f: Frame] = {
threshold: REAL _ JaMOps.PopReal[f.opstk];
mapno: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapno];
t: INT _ Real.RoundLI[map.unit*threshold];
FOR index: NAT IN [0..map.length) DO
map[index] _ IF map[index] > t THEN map.unit ELSE 0;
ENDLOOP;
};
Clip: PROCEDURE [f: Frame] = {
max: REAL _ JaMOps.PopReal[f.opstk];
min: REAL _ JaMOps.PopReal[f.opstk];
mapno: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapno];
imax: INT _ Real.RoundLI[map.unit*max];
imin: INT _ Real.RoundLI[map.unit*min];
FOR index: NAT IN [0..map.length) DO
map[index] _ MAX[imin, MIN[imax, map[index]]];
ENDLOOP;
};
Mask: PROCEDURE [f: Frame] = {
source: NAT _ JaMOps.PopInteger[f.opstk];
dest: NAT _ JaMOps.PopInteger[f.opstk];
destMap: Wordmap _ wordmap[dest];
sourceMap: Wordmap _ wordmap[source];
IF destMap.unit # sourceMap.unit OR destMap.side # sourceMap.side THEN ERROR;
FOR index: NAT IN [0..sourceMap.length) DO
IF sourceMap[index] = 0 THEN destMap[index] _ 0;
ENDLOOP;
};
Fixate: PROCEDURE [f: Frame] = {
max: REAL _ JaMOps.PopReal[f.opstk];
center: REAL _ JaMOps.PopReal[f.opstk];
min: REAL _ JaMOps.PopReal[f.opstk];
imageno: NAT _ JaMOps.PopInteger[f.opstk];
maskno: NAT _ JaMOps.PopInteger[f.opstk];
image: Wordmap _ wordmap[imageno];
mask: Wordmap _ wordmap[maskno];
imax: INT _ Real.RoundLI[image.unit*max];
icenter: INT _ Real.RoundLI[image.unit*center];
imin: INT _ Real.RoundLI[image.unit*min];
IF image.side # mask.side THEN ERROR;
FOR index: NAT IN [0..image.length) DO
sample: INT _ image[index];
IF mask[index]#0 AND imin <= sample AND sample <= imax THEN {
image[index] _ icenter;
mask[index] _ 0;
}
ENDLOOP;
};
Twiddle: PROCEDURE [f: Frame] = {
max: REAL _ JaMOps.PopReal[f.opstk];
min: REAL _ JaMOps.PopReal[f.opstk];
unit: REAL _ JaMOps.PopReal[f.opstk];
imageno: NAT _ JaMOps.PopInteger[f.opstk];
changeno: NAT _ JaMOps.PopInteger[f.opstk];
change: Wordmap _ wordmap[changeno];
image: Wordmap _ wordmap[imageno];
imax: INT _ Real.RoundLI[change.unit*max];
imin: INT _ Real.RoundLI[change.unit*min];
iunit: INT _ Real.RoundLI[change.unit*unit];
IF image.side # change.side THEN ERROR;
FOR index: NAT IN [0..image.length) DO
IF change[index]<=imin THEN {
image[index] _ 0;
};
IF change[index]>=imax THEN {
image[index] _ iunit;
};
ENDLOOP;
};
Histogram: PROCEDURE [f: Frame] = {
mapNumber: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapNumber];
count: ARRAY [0..256] OF INT;
Paint: PROCEDURE [context: Graphics.Context] = {
FOR index: NAT IN [0..256] DO
Graphics.DrawBox[context, [index, 0, index+1, count[index]]];
ENDLOOP;
};
FOR index: NAT IN [0..256] DO
count[index] _ 0;
ENDLOOP;
FOR index: NAT IN [0..map.length) DO
sample: INT _ MAX[0, MIN[256, map[index]*256/map.unit]];
count[sample] _ count[sample] + 1;
ENDLOOP;
TJaMGraphics.Painter[Paint];
};
Statistics: PROCEDURE [f: Frame] = {
mapNumber: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapNumber];
min: INT _ LAST[INT];
max: INT _ FIRST[INT];
sum: INT _  0;
unit: REAL _ map.unit;
FOR index: NAT IN [0..map.length) DO
sample: INT _ map[index];
min _ MIN[min, sample];
max _ MAX[max, sample];
sum _ sum + sample;
ENDLOOP;
JaMOps.PushReal[f.opstk, min/unit];
JaMOps.PushReal[f.opstk, max/unit];
JaMOps.PushReal[f.opstk, sum/(unit*map.length)];
};
SumOfSquares: PROCEDURE [f: Frame] = {
mapNumber: NAT _ JaMOps.PopInteger[f.opstk];
map: Wordmap _ wordmap[mapNumber];
sumsqr: REAL _  0;
unit: REAL _ map.unit;
FOR index: NAT IN [0..map.length) DO
realSample: REAL _ map[index]/unit;
sumsqr _ sumsqr + realSample*realSample;
ENDLOOP;
JaMOps.PushReal[f.opstk, sumsqr];
};
Wordmap: TYPE = REF WordmapRec;
WordmapRec: TYPE = RECORD[unit: INT _ 1, side: NAT, words: SEQUENCE length: NAT OF INT];
NewWordmap: PROCEDURE [side: NAT] RETURNS [wordmap: Wordmap] = {
wordmap _ NEW[WordmapRec[side*side]];
wordmap.side _ side;
};
wordmap: ARRAY [0..9] OF Wordmap;
bitImage: GraphicsOps.BitmapRef;
bitImageDescriptor: BitmapDescriptor;
bitImageContext: Graphics.Context;
BitmapDescriptor: PUBLIC TYPE = REF READONLY BitmapDescriptorRec;
BitmapDescriptorRec: PUBLIC TYPE = RECORD[
bitmapRef: GraphicsOps.BitmapRef,
lines: SEQUENCE height: NAT OF LONG DESCRIPTOR FOR PACKED ARRAY OF [0..1]
];
DescriptorFor: PUBLIC PROCEDURE [bitmap: GraphicsOps.BitmapRef]
RETURNS [BitmapDescriptor] = {
bitmapDescriptor: REF BitmapDescriptorRec _ NEW[BitmapDescriptorRec[bitmap.height]];
raster: NAT _ bitmap.raster;
p: LONG POINTER _ LOOPHOLE[bitmap.base];
IF p=NIL THEN [base: p, raster: raster] _ CGScreen.Bits[];
FOR i:NAT IN [0..bitmap.height) DO
bitmapDescriptor[i] _ DESCRIPTOR[p, bitmap.width];
p _ p + raster;
ENDLOOP;
bitmapDescriptor.bitmapRef _ bitmap;
RETURN[bitmapDescriptor];
};
DescBase: PUBLIC PROCEDURE [d: LONG DESCRIPTOR FOR PACKED ARRAY OF [0..1]]
RETURNS [LONG POINTER] = {RETURN[BASE[d]]};
DescLength: PUBLIC PROCEDURE [d: LONG DESCRIPTOR FOR PACKED ARRAY OF [0..1]]
RETURNS [INT] = {RETURN[LENGTH[d]]};

JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.AllocateBitmap", AllocateBitmap];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.DrawBitmap", DrawBitmap];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.StoreAIS", StoreAIS];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.DrawMap", DrawMap];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.ReDrawMap", ReDrawMap];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.GetBit", GetBit];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.PutBit", PutBit];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.ConvolveLeft", ConvolveLeft];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.ConvolveRight", ConvolveRight];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.ConvolveUp", ConvolveUp];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.ConvolveDown", ConvolveDown];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Copy", Copy];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.LoadFromBitmap", LoadFromBitmap];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.UseBitmap", UseBitmap];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.UseScreen", UseScreen];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Add", Add];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Subtract", Subtract];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.AddShifted", AddShifted];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.SubSample", SubSample];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Biggest", Biggest];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Abs", Abs];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Sqr", Sqr];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Scale", Scale];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Threshold", Threshold];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Clip", Clip];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Mask", Mask];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Histogram", Histogram];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Fixate", Fixate];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Twiddle", Twiddle];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.Statistics", Statistics];
JaMOps.RegisterExplicit[JaMOps.defaultFrame, "bt.SumOfSquares", SumOfSquares];
END.


	l-- Written by Michael Plass on September 8, 1982 9:15 am
-- Last edit by Michael Plass on November 3, 1982 12:10 pm
-- allocates storage of the requested size.
This module implements some operations on images that consist of two-dimensional arrays of intensities.  Thses images are called maps.  The model is a 10-register machine, with each register capable of holding a map.  The registers are numbered 0 thru 9.  In addition, there is a bitmap that can be hooked up to Graphics to capture a binary image.  Operations on maps take one or two register numbers to specify the operands.  The first of these is always the destination. 
<size: integer> -> . Allocates a size x size bitmap
-> . Draws the bitmap
<fileName: string> <register> -> . Saves the map in an AIS file
<register> -> . Draws the map
-> . redisplays the last image shown with DrawMap
<x: integer> <y: integer> -> <value: integer> . Gets a bit out of the bitmap
<bit: integer> <x: integer> <y: integer> -> . Puts a bit into the bitmap
<register> -> . Simple neighbor-averaging convolutions
<dest: register> <source: register> -> . Copies the image
<dest: register> -> . Makes a map from the bitmap
-> . Makes graphics ops go to the bitmap.
-> . Makes graphics ops go to the screen.
<dest: register> <source: register> -> . Adds corresponding samples.
<dest: register> <source: register> -> . dest _ dest - source.
<dest: register> <source: register> <deltaX: integer> <deltaY: integer> <scale: number> -> . Takes map from source, moves it by (deltaX, deltaY), scales each element, and adds the image to dest.
<dest: register> <source: register> <k: integer> -> . Extracts every kth sample of source to make dest 
<register> -> <x: integer> <y: integer>. Finds coordinates of largest sample.
<register> -> . Replaces each sample by its absolute value.
<register> -> . Replaces each sample by its square.
<register> <scale: number> -> . Multiplies each sample by scale.
<register> <threshold: number> -> . Makes a binary image based on the threshold.
<register> <min: number> <max: number> -> . Clips the samples to lie in the given range.
<dest: register> <source: register> -> . Forces dest to 0 whereever source is 0. 
<register> -> . 
<mask: register> <image: register> <min: number> <center: number> <max: number> -> .
you figure it out.
<register> -> <min: number> <max: number> <mean: number> .
<register> -> <sumOfSquares: number> .
ΚΧ–

"cedar" style˜JšΟcœ˜Jš
8™8Jšœœ™:JšΟk	œ†
˜
šœž˜Jšžœn˜uJšœž˜Jšžœžœžœ
˜Jšœžœ˜ 
procšΟnœž	œžœžœ˜6Jš
œ6˜6š
ž
œžœžœžœžœ˜$Jšœ'žœ
žœ˜6—Jš	œžœ
žœžœ
žœ˜"J˜
Jšœž
œ˜J˜J˜—šŸœž	œžœ˜.˜J˜Jšœžœžœ
žœ˜:J˜—J˜—šŸœž	œ˜(Jš
+™+Jšœžœ
˜
Jš
œ"˜"Jš
œ-˜-Jš
œ-˜-J˜—šŸ
œž	œ˜$šŸœž	œ ˜0Jš
œ‘
˜‘
J˜—Jš
œ˜J˜—Kšœžœ
˜K˜ K˜&šŸ
œž	œ˜J˜J˜J˜J˜—šŸœž	œ˜"Jšœžœ˜,Jšœ
žœ˜Jš
œ"˜"J˜J˜J˜Jš
œ˜Jš
œ˜J˜J˜J˜J˜Jš
œU˜UJ˜$šžœž˜šžœžœž˜Jš
œ ˜ Jš
œ'˜'Jš
œ<˜<Jš
ž˜—Jšžœ
˜	—J˜J˜J˜—šŸœž	œ˜!Jšœžœ˜,Jš
œ"˜"J˜J˜J˜Jš
œ˜Jš
œ˜J˜J˜J˜J˜J˜TJ˜$šžœž˜šžœžœž˜Jš
œ ˜ Jš
œ'˜'Jš
œ<˜<Jš
ž˜—Jšžœ
˜	—J˜J˜Jš
œ3˜3J˜8Jš
œ
˜
J˜—šŸ	œž	œ˜#šŸœž	œ ˜0Jš
œ0˜0J˜—Jš
œ˜J˜—šŸœž	œ
žœ˜8Jš
œ=˜=Jšžœ˜Jš
œ˜—šŸ	œž	œ˜#JšœCžœžœ˜OJš
œ&˜&J˜—šŸ	œž	œ˜#Jš
œ6˜6Jš
œ%˜%J˜—šŸœž	œ6˜GJ˜
J˜
J˜J˜Jš
œ1˜1Jš
œ!˜!J˜—šŸœž	œ6˜GJ˜
J˜&J˜J˜Jš
œ1˜1J˜—šŸœž	œ˜(Jšœžœ˜,J˜
Jšœžœ˜Jšžœžœ
žœ*žœ1˜}Jš
œ˜Jš
œ˜šžœžœ
žœž˜šžœžœ
žœž˜Jš
œ/˜/J˜Jš
ž˜—Jš
ž˜—Jš
œ˜—š
Ÿœž	œžœžœžœ˜4Jšœžœžœ˜)J˜—šŸœž	œžœ"˜ZJš
œR˜RJš
œM˜MJ˜—šŸœž	œ˜&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š	œžœ
žœ
žœ
žœ˜'šžœžœ
ž
œž˜%Jšœžœ
žœ˜Jšœžœ
žœ˜Jšžœ
˜—Jš
œ˜Jšžœ
˜—J˜—šŸœž	œ˜&Jšœžœ˜,Jš
œ"˜"Jšœžœ˜Jšœžœ˜Jšœžœžœ
žœ˜š	žœžœ
ž
œ
žœž˜%Jš	œžœ
žœ
žœ
žœ˜'šžœžœ
ž
œž˜%Jš
œ˜Jšœžœ
žœ˜Jšžœ
˜—Jš
œ˜Jšžœ
˜—J˜—J˜šŸœž	œ˜Jšœžœ˜)Jšœžœ˜'Jš
œ!˜!Jš
œ%˜%Jšžœžœ
žœžœ6˜lJš
œ˜šžœžœ
žœž˜*Jš
œ"˜"Jš
ž˜—J˜—šŸœž	œ˜Jšœžœ˜)Jšœžœ˜'Jš
œ!˜!Jš
œ%˜%Jšžœžœžœ
žœ
˜Mšžœžœ
žœž˜*Jš
œ3˜3Jš
ž˜—J˜—šŸœž	œ˜"Jšœžœ˜)Jšœžœ˜'Jš
œ!˜!Jš
œ%˜%Jšžœžœžœ
žœ
˜Mšžœžœ
žœž˜*Jš
œ3˜3Jš
ž˜—J˜—šŸ
œž	œ˜$Jšœžœ˜&Jšœžœ˜-Jšœžœ˜-Jšœžœ˜)Jšœžœ˜'Jš
œ!˜!Jš
œ%˜%Jšœžœ˜Jšžœžœ
žœ
˜,šžœžœ
žœžœ
žœžœ˜LJšœžœ˜#šžœžœ
žœž˜$JšžœžœV˜{Jš
œ˜Jš
ž˜—Jš
ž
˜
—J˜—šŸ	œž	œ˜#Jšœžœ˜2Jšœžœ˜)Jšœžœ˜'Jš
œ%˜%Jš
œ>˜>Jš
œ˜šžœžœ
žœž˜"šžœžœ
žœž˜"Jš
œL˜LJš
ž˜—Jš
ž˜—J˜—šŸœž	œ˜!Jšœžœ˜(Jš
œ˜J˜Jšœžœ
˜Jšœžœ˜šžœžœ
žœž˜šžœžœ
žœž˜Jšžœžœ*˜BJš
œ˜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šœ
žœžœ
žœ˜4Jš
ž˜—J˜—šŸœž	œ˜Jšœžœ˜$Jšœžœ˜$Jšœžœ˜(Jš
œ˜Jšœžœ˜'Jšœžœ˜'šžœžœ
žœž˜$Jšœ
žœžœ˜.Jšžœ
˜—J˜—šŸœž	œ˜Jšœžœ˜)Jšœžœ˜'Jš
œ!˜!Jš
œ%˜%Jšžœžœžœ
žœ
˜Mšžœžœ
žœž˜*Jšœžœ˜0Jš
ž˜—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šžœžœ
žœ
˜'šžœžœ
žœž˜&šžœžœ˜Jš
œ˜Jš
œ˜—šžœžœ˜Jš
œ˜Jš
œ˜—Jšžœ
˜—J˜—šŸ	œž	œ˜#Jšœžœ˜,Jš
œ"˜"J˜šŸœž	œ ˜0šžœžœ
žœ
ž˜Jš
œ=˜=Jšžœ
˜—J˜—šžœžœ
žœ
ž˜Jš
œ˜Jšžœ
˜—šžœžœ
žœž˜$Jš
œ8˜8Jš
œ"˜"Jšžœ
˜—J˜J˜—šŸ
œž	œ˜$Jšœžœ˜,Jš
œ"˜"J˜J˜J˜J˜šžœžœ
žœž˜$Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšžœ
˜—Jš
œ#˜#Jš
œ#˜#Jš
œ0˜0J˜—šŸœž	œ˜&Jšœžœ˜,Jš
œ"˜"J˜J˜šžœžœ
žœž˜$Jš
œ#˜#Jš
œ(˜(Jšžœ
˜—Jš
œ!˜!J˜—Kšœ	žœžœ˜Kšœžœžœžœžœ	žœ	žœ
žœ
žœ˜XšŸ
œž	œžœžœ˜@Jšœ
žœ˜%Jš
œ˜J˜—Kšœ	žœžœ	˜!Kš
œ ˜ Kš
œ%˜%Kš
œ"˜"Kš	œžœ
žœžœ
žœ˜Ašœžœ
žœžœ
˜*Jš
œ!˜!Jšœžœ	žœ
žœ
žœ
ž
œ
žœ
žœ
žœ
žœ˜IJ˜—šŸ
œžœ
ž	œ ˜?Jšžœ˜Jšœžœžœ%˜TJšœžœ˜Jšœžœ
žœžœ˜(Jšžœžœ
žœ-˜:šžœžœ
žœž˜"Jšœž
œ˜2Jš
œ˜Jš
ž˜—Jš
œ$˜$Jšžœ˜J˜—šŸœžœ
ž	œžœ
ž
œ
žœ
žœ
žœ
žœ˜JJš
žœžœ
žœžœ
žœ˜+—šŸ
œžœ
ž	œžœ
ž
œ
žœ
žœ
žœ
žœ˜LJšžœžœžœ
žœ˜$—J˜Jš
Ω™Ω˜RJš
œ3™3—˜JJš
œ™—˜FJš
œ?™?—˜DJš
œ™—˜HJš
œ1™1—˜BJš
œL™L—˜BJš
œH™H—J˜NJ˜PJ˜J˜NJš
œ6™6—˜>Jš
œ9™9—š
œR˜RJš
1™1—š
œH˜HJš
œ)™)—˜HJš
)™)—˜<Jš
œD™D—˜FJš
>™>—š
œJ˜JJš
Β
™Β
—š
œH˜HJš
g™g—š
œD˜DJš
M™M—˜<Jš
;™;—˜<Jš
3™3—˜@Jš
@™@—˜HJš
P™P—˜>Jš
X™X—˜>Jš
Q™Q—˜HJš
™—˜BJš
T™T—˜DJš
™—˜JJš
:™:—˜NJš$œ™&—Jšžœ
˜—J˜J˜—…—Bb_₯