DIRECTORY CtBasic, CtTransform, G2dBasic, Random, Real, RealFns, SF;

CtTransformImpl: CEDAR PROGRAM
IMPORTS CtBasic, Random, Real, RealFns, SF
EXPORTS CtTransform

~ BEGIN
RGBProc:					TYPE ~ CtBasic.RGBProc;
SampleMaps:				TYPE ~ CtBasic.SampleMaps;
ValueProc:				TYPE ~ CtBasic.ValueProc;
IntegerPair:				TYPE ~ G2dBasic.IntegerPair;
IntegerSequenceRep:	TYPE ~ G2dBasic.IntegerSequenceRep;
Box:						TYPE ~ SF.Box;

EscherData:				TYPE ~ CtTransform.EscherData;
BugeyeData:				TYPE ~ CtTransform.BugeyeData;
ShuffleData:				TYPE ~ CtTransform.ShuffleData;
STLaplaceData:			TYPE ~ CtTransform.STLaplaceData;
PopularityData:			TYPE ~ CtTransform.PopularityData;
EdgesData:				TYPE ~ CtTransform.EdgesData;
WoodcutData:			TYPE ~ CtTransform.WoodcutData;
SpinData:					TYPE ~ CtTransform.SpinData;
BlockData:				TYPE ~ CtTransform.BlockData;

EscherSetup: PUBLIC PROC [exp: REAL, maps: SampleMaps] RETURNS [d: REF EscherData] ~ {
d ¬ NEW[EscherData];
d.display ¬ DisplayData[maps];
d.rad ¬ MIN[SF.SizeF[d.display.box], SF.SizeS[d.display.box]]/2;
d.x ¬ d.exponent ¬ exp;
d.scl ¬ 1.0/Power[d.rad, d.x-1.0];
d.p ¬ 0.5*d.x;
};

EscherPoint: PROC [x, y: INTEGER, d: REF EscherData] RETURNS [IntegerPair] ~ {
dx: INTEGER ¬ x-d.display.center.x;
dy: INTEGER ¬ y-d.display.center.y;
r2: REAL ¬ (dx*dx)+(dy*dy);
newr: REAL ¬ d.scl*Power[r2, d.p];
theta: REAL ¬ RealFns.ArcTan[dy, dx];
newx: INTEGER ¬ Real.Round[d.display.center.x+(newr*RealFns.Cos[theta])];
newy: INTEGER ¬ Real.Round[d.display.center.y+(newr*RealFns.Sin[theta])];
RETURN[IF SF.In[[newy, newx], d.display.box] THEN [newx, newy] ELSE [x, y]];
};

EscherRGB: PUBLIC RGBProc ~ {
d: REF EscherData ¬ NARROW[clientData];
p: IntegerPair ¬ EscherPoint[x, y, d];
RETURN[[d.display.rpa[p.y][p.x], d.display.gpa[p.y][p.x], d.display.bpa[p.y][p.x]]];
};

EscherValue: PUBLIC ValueProc ~ {
d: REF EscherData ¬ NARROW[clientData];
p: IntegerPair ¬ EscherPoint[x, y, d];
value ¬ d.display.vpa[p.y][p.x];
};
BugeyeSetup: PUBLIC PROC [xSize, ySize: INTEGER, maps: SampleMaps]
RETURNS [d: REF BugeyeData]
~ {
d ¬ NEW[BugeyeData];
d.display ¬ DisplayData[maps];
d.xSize2 ¬ xSize/2;
d.ySize2 ¬ ySize/2;
};

BugeyePoint: PROC [x, y: INTEGER, d: REF BugeyeData] RETURNS [IntegerPair] ~ {
new: IntegerPair ¬ [x+(x MOD d.xSize)-d.xSize2, y+(y MOD d.ySize)-d.ySize2];
RETURN[IF SF.In[[new.y, new.x], d.display.box] THEN new ELSE [x, y]];
};

BugeyeRGB: PUBLIC RGBProc ~ {
d: REF BugeyeData ¬ NARROW[clientData];
p: IntegerPair ¬ BugeyePoint[x, y, d];
RETURN[[d.display.rpa[p.y][p.x], d.display.gpa[p.y][p.x], d.display.bpa[p.y][p.x]]]
};

BugeyeValue: PUBLIC ValueProc ~ {
d: REF BugeyeData ¬ NARROW[clientData];
p: IntegerPair ¬ BugeyePoint[x, y, d];
RETURN [d.display.vpa[p.y][p.x]];
};
ShuffleSetup: PUBLIC PROC [xSize, ySize: INTEGER, maps: SampleMaps]
RETURNS [d: REF ShuffleData]
~ {
offset: INTEGER ¬ 0;
d ¬ NEW[ShuffleData];
d.display ¬ DisplayData[maps];
d.wid ¬ SF.SizeF[d.display.box];
d.hgt ¬ SF.SizeS[d.display.box];
d.xShuf ¬ NEW[IntegerSequenceRep[d.hgt+1]];
d.yShuf ¬ NEW[IntegerSequenceRep[d.wid+1]];
FOR x: INTEGER IN [0..d.wid] DO 
offset ¬ offset+(IF GetRandom[] > 0.5 THEN d.ySize ELSE -d.ySize);
d.yShuf[x] ¬ offset;
ENDLOOP;
offset ¬ 0;
FOR y: INTEGER IN [0..d.hgt] DO 
offset ¬ offset+(IF GetRandom[] > 0.5 THEN d.xSize ELSE -d.xSize);
d.xShuf[y] ¬ offset;
ENDLOOP;
};

ShufflePoint: PROC [x, y: INTEGER, d: REF ShuffleData] RETURNS [IntegerPair] ~ {
lx: INTEGER ¬ x-d.display.box.min.f;
ly: INTEGER ¬ y-d.display.box.min.s;
xp: INTEGER ¬ (lx+d.xShuf[ly]) MOD d.wid;
yp: INTEGER ¬ (ly+d.yShuf[xp]) MOD d.hgt;
new: IntegerPair ¬ [d.display.box.min.f+xp, d.display.box.min.s+yp];
RETURN[IF SF.In[[new.y, new.x], d.display.box] THEN new ELSE [x, y]];
};

ShuffleRGB: PUBLIC RGBProc ~ {
d: REF ShuffleData ¬ NARROW[clientData];
p: IntegerPair ¬ ShufflePoint[x, y, d];
RETURN[[d.display.rpa[p.y][p.x], d.display.gpa[p.y][p.x], d.display.bpa[p.y][p.x]]];
};

ShuffleValue: PUBLIC ValueProc ~ {
d: REF ShuffleData ¬ NARROW[clientData];
p: IntegerPair ¬ ShufflePoint[x, y, d];
RETURN[d.display.vpa[p.y][p.x]];
};
STLaplaceSetup: PUBLIC PROC [threshold, dif: INTEGER, maps: SampleMaps]
RETURNS [d: REF STLaplaceData]
~ {
d ¬ NEW[STLaplaceData ¬ [dif: dif, threshold: threshold]];
d.display ¬ DisplayData[maps];
};

STLaplaceRGB: PUBLIC RGBProc ~ {
d: REF STLaplaceData ¬ NARROW[clientData];
sumr, sumg, sumb, difr, difg, difb, pr, pg, pb: INTEGER ¬ 0;
IF x <= d.display.box.min.f THEN x ¬ d.display.box.min.f+1;
IF x >= d.display.box.max.f THEN x ¬ d.display.box.max.f-1;
IF y <= d.display.box.min.s THEN y ¬ d.display.box.min.s+1;
IF y >= d.display.box.max.s THEN y ¬ d.display.box.max.s-1;
pr ¬ d.display.rpa[y][x];
pg ¬ d.display.gpa[y][x];
pb ¬ d.display.bpa[y][x];
FOR newy: INTEGER IN [y-1..y+1] DO
FOR newx: INTEGER IN [x-1..x+1] DO
sumr ¬ sumr+d.display.rpa[newy][newx];
sumg ¬ sumg+d.display.gpa[newy][newx];
sumb ¬ sumb+d.display.bpa[newy][newx];
ENDLOOP;
ENDLOOP;
sumr ¬ sumr-pr;
sumg ¬ sumg-pg;
sumb ¬ sumb-pb;
difr ¬ ABS[sumr-(d.threshold*pr)];
difg ¬ ABS[sumg-(d.threshold*pg)];
difb ¬ ABS[sumb-(d.threshold*pb)];
sumr ¬ IF difr > d.dif THEN 255 ELSE 0;
sumg ¬ IF difg > d.dif THEN 255 ELSE  0;
sumb ¬ IF difb > d.dif THEN 255 ELSE 0;
RETURN[[sumr, sumg, sumb]];
};

STLaplaceValue: PUBLIC ValueProc ~ {
d: REF STLaplaceData ¬ NARROW[clientData];
sumv, difv, pv: INTEGER ¬ 0;
IF x <= d.display.box.min.f THEN x ¬ d.display.box.min.f+1;
IF x >= d.display.box.max.f THEN x ¬ d.display.box.max.f-1;
IF y <= d.display.box.min.s THEN y ¬ d.display.box.min.s+1;
IF y >= d.display.box.max.s THEN y ¬ d.display.box.max.s-1;
pv ¬ d.display.vpa[y][x];
FOR newy: INTEGER IN [y-1..y+1] DO
FOR newx: INTEGER IN [x-1..x+1] DO
sumv ¬ sumv+d.display.vpa[newy][newx];
ENDLOOP;
ENDLOOP;
difv ¬ ABS[sumv-pv-(d.threshold*pv)];
RETURN[IF difv > d.dif THEN 255 ELSE 0];
};
PopularitySetup: PUBLIC PROC [diameter: INTEGER, maps: SampleMaps]
RETURNS [d: REF PopularityData]
~ {
d ¬ NEW[PopularityData ¬ [diameter: diameter]];
d.display ¬ DisplayData[maps];
d.idiameter ¬ 1.0/(d.diameter*d.diameter);
d.lowd ¬ Real.Floor[(d.diameter-1)/2.0];
d.highd ¬ Real.Floor[d.diameter/2.0];
};

PopularityRGB: PUBLIC RGBProc ~ {
d: REF PopularityData ¬ NARROW[clientData];
rval, gval, bval, rbest, gbest, bbest: INTEGER ¬ 0;
rpop, gpop, bpop: ARRAY [0..255] OF INTEGER ¬ ALL[0];
FOR ly: INTEGER IN [y-d.lowd..y+d.highd] DO 
FOR lx: INTEGER IN [x-d.lowd..x+d.highd] DO 
IF SF.In[[ly, lx], d.display.box]
THEN {
rpop[d.display.rpa[ly][lx]] ¬ rpop[d.display.rpa[ly][lx]]+1;
gpop[d.display.gpa[ly][lx]] ¬ gpop[d.display.gpa[ly][lx]]+1;
bpop[d.display.bpa[ly][lx]] ¬ bpop[d.display.bpa[ly][lx]]+1;
}
ELSE {
rpop[d.display.rpa[y][x]] ¬ rpop[d.display.rpa[y][x]]+1;
gpop[d.display.gpa[y][x]] ¬ gpop[d.display.gpa[y][x]]+1;
bpop[d.display.bpa[y][x]] ¬ bpop[d.display.bpa[y][x]]+1;
};
ENDLOOP;
ENDLOOP;
FOR i: INTEGER IN [0..255] DO
IF rpop[i] > rbest THEN {rbest ¬ rpop[i]; rval ¬ i};
IF gpop[i] > gbest THEN {gbest ¬ gpop[i]; gval ¬ i};
IF bpop[i] > bbest THEN {bbest ¬ bpop[i]; bval ¬ i};
ENDLOOP;
RETURN[[rval, gval, bval]];
};

PopularityValue: PUBLIC ValueProc ~ {
d: REF PopularityData ¬ NARROW[clientData];
vval, vbest: INTEGER ¬ 0;
FOR i: INTEGER IN [0..255] DO d.vpop[i] ¬ 0; ENDLOOP;
FOR ly: INTEGER IN [y-d.lowd..y+d.highd] DO 
FOR lx: INTEGER IN [x-d.lowd..x+d.highd] DO 
vval ¬ IF SF.In[[ly, lx], d.display.box]
THEN d.display.vpa[ly][lx]
ELSE d.display.vpa[y][x];
d.vpop[vval] ¬ d.vpop[vval]+1;
ENDLOOP;
ENDLOOP;
vval ¬ 0;
FOR i: INTEGER IN [0..255] DO
IF d.vpop[i] > vbest THEN {vbest ¬ d.vpop[i]; vval ¬ i};
ENDLOOP;
RETURN[vval];
};
EdgesSetup: PUBLIC PROC [xSize, ySize: INTEGER, maps: SampleMaps]
RETURNS [d: REF EdgesData]
~ {
d ¬ NEW[EdgesData ¬ [xSize: xSize, ySize: ySize]];
d.display ¬ DisplayData[maps];
};

EdgesRGB: PUBLIC RGBProc ~ {
d: REF EdgesData ¬ NARROW[clientData];
newx: INTEGER ¬ x+d.xSize;
newy: INTEGER ¬ y+d.ySize;
IF SF.In[[newy, newx], d.display.box]
THEN {
newr: INT ¬ MAX[0, MIN[255, d.display.rpa[y][x]+(128-d.display.rpa[newy][newx])]];
newg: INT ¬ MAX[0, MIN[255, d.display.gpa[y][x]+(128-d.display.gpa[newy][newx])]];
newb: INT ¬ MAX[0, MIN[255, d.display.bpa[y][x]+(128-d.display.bpa[newy][newx])]];
RETURN[[newr, newg, newb]];
}
ELSE RETURN[[d.display.rpa[y][x], d.display.gpa[y][x], d.display.bpa[y][x]]];
};

EdgesValue: PUBLIC ValueProc ~ {
d: REF EdgesData ¬ NARROW[clientData];
newx: INTEGER ¬ x+2;
newy: INTEGER ¬ y+2;
IF SF.In[[newy, newx], d.display.box]
THEN RETURN[MAX[0, MIN[255, d.display.vpa[y][x]+(128-d.display.vpa[newy][newx])]]]
ELSE RETURN[d.display.vpa[y][x]];
};
WoodcutSetup: PUBLIC PROC [
height, blend: INT,
threshold: REAL,
clamp: BOOL,
maps: SampleMaps]
RETURNS [d: REF WoodcutData]
~ {
d ¬ NEW[WoodcutData ¬
[cutHeight: height, cutBlend: blend, threshold: threshold, clamp: clamp]];
d.display ¬ DisplayData[maps];
d.height2 ¬ Real.Floor[d.cutHeight/2.0];
d.maxsum ¬ 255*((2*d.height2)+1)*((2*d.cutBlend)+1);
d.sumscl ¬ d.threshold*d.height2/d.maxsum;
d.yMax ¬ d.display.box.min.s-1;		-- guarantees we'll go for box first time
d.vbarscl ¬ 1.0/((2.0*d.height2)+1);
};

WoodcutRGB: PUBLIC RGBProc ~ {
d: REF WoodcutData ¬ NARROW[clientData];
rv, gv, bv: INTEGER;
yPrime: INTEGER ¬ 
Real.Floor[d.height2+d.display.box.min.s+
(Real.Floor[(y-d.display.box.min.s)/d.cutHeight]*d.cutHeight)];
vert: INTEGER ¬ ABS[yPrime-y];
del, barh: REAL;
ravg, gavg, bavg: INTEGER;
rsum, gsum, bsum: INTEGER ¬ 0;
IF d.yMax < y THEN {
IF d.rsums = NIL THEN
d.rsums ¬ NEW[IntegerSequenceRep[1+d.display.box.max.f]];
IF d.gsums = NIL THEN
d.gsums ¬ NEW[IntegerSequenceRep[1+d.display.box.max.f]];
IF d.bsums = NIL THEN
d.bsums ¬ NEW[IntegerSequenceRep[1+d.display.box.max.f]];
FOR xv: INTEGER IN [d.display.box.min.f..d.display.box.max.f] DO
rsum¬ gsum ¬ bsum ¬ 0;
FOR yv: INTEGER IN [yPrime-d.height2..yPrime+d.height2] DO
 IF SF.In[[yv, xv], d.display.box]
THEN {
rsum ¬ rsum+d.display.rpa[yv][xv];
gsum ¬ gsum+d.display.gpa[yv][xv];
bsum ¬ bsum+d.display.bpa[yv][xv];
}
ELSE {
rsum ¬ rsum+d.display.rpa[y][x];
gsum ¬ gsum+d.display.gpa[y][x];
bsum ¬ bsum+d.display.bpa[y][x];
};
ENDLOOP;
d.rsums[xv] ¬ rsum;
d.gsums[xv] ¬ gsum;
d.bsums[xv] ¬ bsum;
ENDLOOP;
d.yMax ¬ yPrime+d.height2;
};
rsum ¬ gsum ¬ bsum ¬ 0;
FOR xv: INTEGER IN [x-d.cutBlend..x+d.cutBlend] DO
IF xv >= d.display.box.min.f AND xv <= d.display.box.max.f
THEN {
rsum ¬ rsum+d.rsums[xv];
gsum ¬ gsum+d.gsums[xv];
bsum ¬ bsum+d.bsums[xv];
}
ELSE {
rsum ¬ rsum+d.rsums[x];
gsum ¬ gsum+d.gsums[x];
bsum ¬ bsum+d.bsums[x];
};
ENDLOOP;
IF d.clamp = TRUE
THEN ravg ¬ gavg ¬ bavg ¬ 255
ELSE {
ravg ¬ Real.Round[d.rsums[x]*d.vbarscl]; 
gavg ¬ Real.Round[d.gsums[x]*d.vbarscl]; 
bavg ¬ Real.Round[d.bsums[x]*d.vbarscl]; 
};
barh ¬ d.sumscl*rsum;
del ¬ barh - vert;
rv ¬ IF vert = Real.Floor[barh]
THEN Real.Round[ravg*(barh-vert)]
ELSE IF vert < barh THEN ravg ELSE 0;
barh ¬ d.sumscl*gsum;
del ¬ barh - vert;
gv ¬ IF vert = Real.Floor[barh]
THEN Real.Round[gavg*(barh-vert)]
ELSE IF vert < barh THEN gavg ELSE 0;
barh ¬ d.sumscl*bsum;
del ¬ barh - vert;
bv ¬ IF vert = Real.Floor[barh]
THEN Real.Round[bavg*(barh-vert)]
ELSE IF vert < barh THEN bavg ELSE 0;
RETURN[[rv, gv, bv]];
};

WoodcutValue: PUBLIC ValueProc ~ {
d: REF WoodcutData ¬ NARROW[clientData];
yPrime: INTEGER ¬ 
Real.Floor[d.height2+d.display.box.min.s+
(Real.Floor[(y-d.display.box.min.s)/d.cutHeight]*d.cutHeight)];
vert: INTEGER ¬ ABS[yPrime-y];
del, barh: REAL;
pvavg, sum: INTEGER ¬ 0;
IF d.yMax < y THEN {
IF d.rsums = NIL THEN
d.rsums ¬ NEW[IntegerSequenceRep[1+d.display.box.max.f]];
FOR xv: INTEGER IN [d.display.box.min.f..d.display.box.max.f] DO
sum ¬ 0;
FOR yv: INTEGER IN [yPrime-d.height2..yPrime+d.height2] DO
 IF SF.In[[yv, xv], d.display.box]
THEN sum ¬ sum+d.display.vpa[yv][xv]
ELSE sum ¬ sum+d.display.vpa[y][x];
ENDLOOP;
d.rsums[xv] ¬ sum;
ENDLOOP;
d.yMax ¬ yPrime+d.height2;
};
sum ¬ 0;
FOR xv: INTEGER IN [x-d.cutBlend..x+d.cutBlend] DO
sum ¬ IF xv >= d.display.box.min.f AND xv <= d.display.box.max.f
THEN sum+d.rsums[xv]
ELSE sum+d.rsums[x];
ENDLOOP;
barh ¬ d.sumscl*sum;
del ¬ barh-vert;
pvavg ¬ IF d.clamp = TRUE THEN 255 ELSE Real.Round[d.rsums[x]*d.vbarscl]; 
IF vert = Real.Floor[barh] THEN RETURN[Real.Round[pvavg*(barh-vert)]];
IF vert < barh THEN RETURN [pvavg];
RETURN[0];
};
SpinSetup: PUBLIC PROC [cycles: REAL, maps: SampleMaps] RETURNS [d: REF SpinData] ~ {
d ¬ NEW[SpinData ¬ [cycles: cycles]];
d.display ¬ DisplayData[maps];
d.rad ¬ Real.Round[MIN[SF.SizeF[d.display.box], SF.SizeS[d.display.box]]/2.0];
d.thetaScl ¬ IF d.rad # 0.0 THEN 2.0*3.1415926535*d.cycles/d.rad ELSE 0.0;
};

SpinPoint: PROC [x, y: INTEGER, d: REF SpinData] RETURNS [IntegerPair] ~ {
dx: INTEGER ¬ x-d.display.center.x;
dy: INTEGER ¬ y-d.display.center.y;
r: REAL ¬ RealFns.SqRt[(dx*dx)+(dy*dy)];
newTheta: REAL ¬ (r*d.thetaScl)+RealFns.ArcTan[dy, dx];
newx: INTEGER ¬ Real.Round[d.display.center.x+(r*RealFns.Cos[newTheta])];
newy: INTEGER ¬ Real.Round[d.display.center.y+(r*RealFns.Sin[newTheta])];
RETURN[IF SF.In[[newy, newx], d.display.box] THEN [newx, newy] ELSE [x, y]];
};

SpinRGB: PUBLIC RGBProc ~ {
d: REF SpinData ¬ NARROW[clientData];
p: IntegerPair ¬ SpinPoint[x, y, d];
RETURN[[d.display.rpa[p.y][p.x], d.display.gpa[p.y][p.x], d.display.bpa[p.y][p.x]]]
};

SpinValue: PUBLIC ValueProc ~ {
d: REF SpinData ¬ NARROW[clientData];
p: IntegerPair ¬ SpinPoint[x, y, d];
RETURN[d.display.vpa[p.y][p.x]];
};
BlockSetup: PUBLIC PROC [xSize, ySize: INTEGER, maps: SampleMaps]
RETURNS [d: REF BlockData]
~ {
d ¬ NEW[BlockData ¬ [xSize: xSize, ySize: ySize, yMax: -1]];
d.display ¬ DisplayData[maps];
};

BlockRGB: PUBLIC RGBProc ~ {
d: REF BlockData ¬ NARROW[clientData];
xPrime: INTEGER ¬ Real.Floor[(x-d.display.box.min.f)/d.xSize];
IF d.yMax < y THEN {
entry, cnt, rsum, gsum, bsum: INTEGER ¬ 0;
xv: INTEGER ¬ d.display.box.min.f;
IF d.rsums = NIL THEN
d.rsums ¬ NEW[IntegerSequenceRep[1+d.display.box.max.f]];
IF d.gsums = NIL THEN
d.gsums ¬ NEW[IntegerSequenceRep[1+d.display.box.max.f]];
IF d.bsums = NIL THEN
d.bsums ¬ NEW[IntegerSequenceRep[1+d.display.box.max.f]];
FOR i: INTEGER IN [0..d.display.box.max.f] DO
d.rsums[i] ¬ d.gsums[i] ¬ d.bsums[i] ¬ 0;
ENDLOOP;
WHILE xv < d.display.box.max.f DO
cnt ¬ rsum ¬ gsum ¬ bsum ¬ 0;
FOR ty: INTEGER IN [y..y+d.ySize] DO
IF ty >= d.display.box.min.s AND ty < d.display.box.max.s THEN 
FOR tx: INTEGER IN [xv..xv+d.xSize] DO
IF tx >= d.display.box.min.f AND tx < d.display.box.max.f THEN { 
rsum ¬ rsum+d.display.rpa[ty][tx]; 
gsum ¬ gsum+d.display.gpa[ty][tx]; 
bsum ¬ bsum+d.display.bpa[ty][tx]; 
cnt ¬ cnt+1;
};
ENDLOOP;		-- tx
ENDLOOP;		-- ty
d.rsums[entry] ¬ IF cnt # 0 THEN Real.Round[(1.0*rsum)/cnt] ELSE rsum;
d.gsums[entry] ¬ IF cnt # 0 THEN Real.Round[(1.0*gsum)/cnt] ELSE gsum;
d.bsums[entry] ¬ IF cnt # 0 THEN Real.Round[(1.0*bsum)/cnt] ELSE bsum;
entry ¬ entry+1;
xv ¬ xv + d.xSize;
ENDLOOP;		-- xv
d.yMax ¬ y+d.ySize;
};
RETURN[[d.rsums[xPrime], d.gsums[xPrime], d.bsums[xPrime]]];
};

BlockValue: PUBLIC ValueProc ~ {
d: REF BlockData ¬ NARROW[clientData];
xPrime: INTEGER ¬ Real.Floor[(x-d.display.box.min.f)/d.xSize];
IF d.yMax < y THEN {
entry, cnt, sum: INTEGER ¬ 0;
xv: INTEGER ¬ d.display.box.min.f;
IF d.rsums = NIL THEN d.rsums ¬ NEW[IntegerSequenceRep[1+d.display.box.max.f]];
FOR i: INTEGER IN [0..d.display.box.max.f] DO d.rsums[i] ¬ 0; ENDLOOP;
WHILE xv < d.display.box.max.f DO
cnt ¬ sum ¬ 0;
FOR ty: INTEGER IN [y..y+d.ySize] DO
IF ty >= d.display.box.min.s AND ty < d.display.box.max.s THEN 
FOR tx: INTEGER IN [xv..xv+d.xSize] DO
IF tx >= d.display.box.min.f AND tx < d.display.box.max.f THEN { 
sum ¬ sum+d.display.vpa[ty][tx]; 
cnt ¬ cnt+1;
};
ENDLOOP;		-- tx
ENDLOOP;		-- ty
d.rsums[entry] ¬ IF cnt # 0 THEN Real.Round[(1.0*sum)/cnt] ELSE sum;
entry ¬ entry+1;
xv ¬ xv+d.xSize;
ENDLOOP;		-- xv
d.yMax ¬ y+d.ySize;
};
RETURN[d.rsums[xPrime]];
};
DisplayData: PROC [maps: SampleMaps] RETURNS [d: CtTransform.Display] ~ {
b: SF.Box ¬ d.box ¬ maps.box;
SELECT d.bpp ¬ maps.bpp FROM
8 => d.vpa ¬ CtBasic.PixelArrayFromSampleMap[maps[0].map];
24 => {
d.rpa ¬ CtBasic.PixelArrayFromSampleMap[maps[0].map];
d.gpa ¬ CtBasic.PixelArrayFromSampleMap[maps[1].map];
d.bpa ¬ CtBasic.PixelArrayFromSampleMap[maps[2].map];
};
ENDCASE;
d.center ¬ [Real.Round[0.5*(b.min.f+b.max.f)], Real.Round[0.5*(b.min.s+b.max.s)]]; 
};

Power: PROC [a, b: REAL] RETURNS [c: REAL] ~ {
d: REAL;
IF a < 1e-11 THEN RETURN [0.0];
IF b = 1.0 THEN RETURN [a];
d ¬ b * RealFns.Ln[a];
IF d < -20.0 		-- less than about .000000002 = 2.0e-9
THEN RETURN [0.0] 
ELSE RETURN [RealFns.Exp[d]];
};

GetRandom: PROC RETURNS [v: REAL] ~ {
scl: REAL ~ 4.656613e-10; -- scl ¬ 1.0/(1.0*LAST[INT])
RETURN[Random.NextInt[randomStream]*scl];
};
randomStream: Random.RandomStream ¬ Random.Create[];

END.

L
CtTransformImpl.mesa
Copyright Σ 1985, 1992 by Xerox Corporation.  All rights reserved.
Glassner, November 14, 1990 4:56 pm PST
Jules Bloomenthal July 3, 1992 1:31 pm PDT

Types
Escher
Given maximum radius R (rad), current radius r, and exponent x, we want to find rnew:
rnew _ R * Power[r/R, x] = (1/Power[R, x-1])*Power[r2, (ex/2)]
so we can find r2 and pre-compute scl = 1/(Rx-1) and p = ex/2, so rnew _ scl*Power[r2, p]
Bugeye
Shuffle
STLaplace
Popularity
gather popularity
find most popular
gather popularity
find most popular
Edges
Woodcut
Spin
Block
Support Code
Start Code
Κί–
"cedarcode" style•NewlineDelimiter

™™Jšœ	Οeœ6™BJ™'J™*J™—JšΟk	œ8žœ
˜DJ˜šΡblnœžœ
ž˜Jšžœ#˜*Jšžœ˜—J˜Jšœž˜
headš
Οl™Jšœ
žœ˜$Jšœžœ˜)Jšœžœ˜'Jšœžœ˜,Jšœžœ˜7šœ
žœžœ˜J˜—Jšœžœ˜-Jšœžœ˜-Jšœžœ˜/Jšœžœ˜2Jšœžœ˜4Jšœžœ˜+Jšœžœ˜.Jšœžœ˜*Jšœžœ˜+—š
 ™š
œU™UJšœ4Οu
œ	™>Jšœ‘
œ‘œ%‘
œ™Y—J˜šΟnœžœ
žœžœžœžœ˜VJšœžœ
˜J˜Jšœžœ
žœžœ˜@J˜J˜"J˜J˜J˜—š
’œžœžœžœ
žœ˜NJšœžœ˜#Jšœžœ˜#Jšœžœ˜Jšœžœ˜"Jšœžœ˜%Jšœžœ<˜IJšœžœ<˜IJš
žœ
žœ
žœ!žœžœ	˜LJ˜J˜—š’	œžœ˜Jšœžœžœ
˜'J˜&JšžœN˜TJ˜J˜—š’œžœ˜!Jšœžœžœ
˜'J˜&J˜ J˜——š
 ™š’œžœ
žœžœ˜BJšžœžœ˜Jš
œ˜Jšœžœ
˜J˜J˜J˜J˜J˜—š
’œžœžœžœ
žœ˜NJšœžœžœ˜LJš
žœ
žœ
žœ#žœžœ	˜EJ˜J˜—š’	œžœ˜Jšœžœžœ
˜'J˜&JšžœM˜SJ˜J˜—š’œžœ˜!Jšœžœžœ
˜'J˜&Jšžœ˜!J˜——š
 ™š’œžœ
žœžœ˜CJšžœžœ
˜Jš
œ˜Jšœžœ˜Jšœžœ˜J˜Jšœžœ˜ Jšœžœ˜ Jšœ
žœ˜+Jšœ
žœ˜+šžœžœ
žœžœ
˜ Jšœžœžœ	žœ˜BJ˜Jšžœ
˜—J˜šžœžœ
žœžœ
˜ Jšœžœžœ	žœ˜BJ˜Jšžœ
˜—J˜J˜—š
’œ
žœžœžœžœ˜PJšœžœ˜$Jšœžœ˜$Jšœžœžœ˜)Jšœžœžœ˜)J˜DJš
žœ
žœ
žœ#žœžœ	˜EJ˜J˜—š’
œžœ˜Jšœžœžœ
˜(J˜'JšžœN˜TJ˜J˜—š’œžœ˜"Jšœžœžœ
˜(J˜'Jšžœ˜ J˜——š
 	™	š’œžœ
žœžœ˜GJšžœžœ˜Jš
œ˜Jšœžœ3˜:J˜J˜J˜—š’œžœ˜ Jšœžœžœ
˜*Jšœ0žœ˜<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˜——š
 
™
š’œžœ
žœžœ˜BJšžœžœ˜Jš
œ˜Jšœžœ(˜/J˜J˜*J˜(J˜%J˜J˜—š’
œžœ˜!Jšœžœžœ
˜+Jšœ'žœ˜3Jš	œžœ
žœ
žœžœ˜5Jš
œ™šžœžœ
žœžœ
˜,šžœžœ
žœžœ
˜,šžœ
žœ˜!šžœ˜J˜<J˜<J˜<J˜
—šžœ˜J˜8J˜8J˜8J˜——Jšžœ
˜—Jšžœ
˜—Jš
œ™šžœžœ
žœ
ž˜Jšžœžœ˜4Jšžœžœ˜4Jšžœžœ˜4Jšžœ
˜—Jšžœ˜J˜J˜—š’œžœ˜%Jšœžœžœ
˜+Jšœ
žœ˜Jš
œ™Jš
žœžœ
žœ
žœžœ
˜5šžœžœ
žœžœ
˜,šžœžœ
žœžœ
˜,šœžœ
žœ˜(Jšžœ˜Jšžœ˜—J˜Jšžœ
˜—Jšžœ
˜—Jš
œ™J˜	šžœžœ
žœ
ž˜Jšžœžœ˜8Jšžœ
˜—Jšžœ˜
J˜——š
 ™š’
œžœ
žœžœ˜AJšžœžœ˜Jš
œ˜Jšœžœ+˜2J˜J˜J˜—š’œžœ˜Jšœžœ
žœ
˜&Jšœžœ
˜Jšœžœ
˜šžœ
žœ ˜%šžœ˜Jšœžœžœžœ<˜RJšœžœžœžœ<˜RJšœžœžœžœ<˜RJšžœ˜Jš
œ
˜
—Jšžœ
žœB˜M—J˜J˜—š’
œžœ˜ Jšœžœ
žœ
˜&Jšœžœ˜Jšœžœ˜šžœ
žœ ˜%Jš	žœ
žœ
žœžœ;ž
˜RJšžœ
žœ˜!—J˜——š
 ™š’œžœ
žœ˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jš
œ˜Jšžœžœ
˜J˜šœžœ˜Jš
œJ˜J—J˜J˜(J˜4J˜*Jšœ!Οc)˜JJ˜$J˜—J˜š’
œžœ˜Jšœžœžœ
˜(Jšœžœ
˜šœžœ˜J˜)J˜?—Jšœžœžœ˜Jšœžœ
˜Jšœžœ
˜Jšœžœ˜šžœžœ˜šžœžœ
ž˜Jšœ
žœ,˜9—šžœžœ
ž˜Jšœ
žœ,˜9—šžœžœ
ž˜Jšœ
žœ,˜9—šžœžœ
žœ,ž˜@J˜šžœžœ
žœ&ž˜:šœ
žœ
žœ˜"šžœ˜J˜"J˜"J˜"J˜
—šžœ˜J˜ J˜ J˜ J˜——Jšžœ
˜—J˜J˜J˜Jšžœ
˜J˜—J˜—J˜šžœžœ
žœž˜2šžœžœ˜:šžœ˜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šœ
žœ,˜9—šžœžœ
žœ,ž˜@J˜šžœžœ
žœ&ž˜:šœ
žœ
žœ˜"Jšžœ ˜$Jšžœ˜#—Jšžœ
˜—J˜Jšžœ
˜J˜—J˜—J˜šžœžœ
žœž˜2šœžœžœ˜@Jšžœ˜Jšžœ˜—Jšžœ
˜—J˜J˜Jšœžœž	œžœ#˜JJšžœžœ
žœ ˜FJšžœ
žœ
žœ	˜#Jšžœ˜
J˜——š
 ™š’	œžœ
žœ
žœžœžœ˜UJšœžœ˜%J˜Jšœžœ
žœžœ˜NJšœ
žœ
žœ!žœ˜JJ˜J˜—š
’	œžœžœžœžœ˜JJšœžœ˜#Jšœžœ˜#Jšœžœ!˜(Jšœ
žœ)˜7Jšœžœ<˜IJšœžœ<˜IJš
žœ
žœ
žœ!žœžœ	˜LJ˜J˜—š’œžœ˜Jšœžœžœ
˜%J˜$JšžœM˜SJ˜J˜—š’	œžœ˜Jšœžœžœ
˜%J˜$Jšžœ˜ J˜——š
 ™š’
œžœ
žœžœ˜AJšžœžœ˜Jš
œ˜Jšœžœ5˜<J˜J˜J˜—š’œžœ˜Jšœžœ
žœ
˜&Jšœžœ/˜>šžœžœ˜Jšœžœ˜*Jšœžœ˜"šžœžœ
ž˜Jšœ
žœ,˜9—šžœžœ
ž˜Jšœ
žœ,˜9—šžœžœ
ž˜Jšœ
žœ,˜9—šžœžœ
žœž˜-J˜)Jšžœ
˜—šžœž˜!J˜šžœžœ
žœž˜$šžœžœžœ
˜?šžœžœ
žœž˜&šžœžœžœ˜AJ˜#J˜#J˜#J˜J˜—Jšžœ£˜——Jšžœ£˜—Jšœžœ	žœžœ˜FJšœžœ	žœžœ˜FJšœžœ	žœžœ˜FJ˜J˜Jšžœ£˜—J˜J˜—Jšžœ6˜<J˜J˜—š’
œžœ˜ Jšœžœ
žœ
˜&Jšœžœ/˜>šžœžœ˜Jšœžœ˜Jšœžœ˜"Jšžœžœ
žœžœ,˜OJš
žœžœ
žœžœžœ
˜Fšžœž˜!J˜šžœžœ
žœž˜$šžœžœžœ
˜?šžœžœ
žœž˜&šžœžœžœ˜AJ˜!J˜J˜—Jšžœ£˜——Jšžœ£˜—Jšœžœ	žœžœ˜DJ˜J˜Jšžœ£˜—J˜J˜—Jšžœ˜J˜——š
 ™š’œžœžœ˜IJšœžœ˜šžœž˜J˜:˜J˜5J˜5J˜5J˜—Jšžœ
˜—J˜SJ˜J˜—š
’œžœžœžœžœ˜.Jšœžœ
˜Jšžœžœ
žœ˜Jšžœ	žœ
žœ˜J˜šžœ
£&˜5Jšžœ
žœ˜Jšžœ
žœ˜—J˜J˜—š’	œžœ
žœžœ˜%Jšœžœ£œ
£˜6Jšžœ#˜)J˜——š
 
™
J˜4J˜—Jšžœ
˜J˜—…—AX7