Basics,

ImagerManhattan USING [CreateFromBoxes],

ImagerPath USING [ConicToProc, CurveToProc, LineToProc, MoveToProc, PathProc, Transform],

ImagerSample USING [EdgeAction, FillBoxes, SampleMap],

ImagerScanConverter USING [],

ImagerScanConverterExtras USING [],

ImagerScanConverterPrivate USING [Area, AreaRep, AreaState, Edge, EdgeRep, Edges, ExternalHalfPlane, Pair, RealBox, Region],

ImagerTransformation USING [Transformation],

RealFns USING [SqRt],

RealInline,

ImagerScaled,

SF USING [Box, BoxAction, BoxGenerator, Intersect, maxBox, Nonempty],

Vector2 USING [VEC];

Enables some consistency checks that shouldn't be needed when the bugs are out.

Change to a compile-time FALSE for production.

RETURN [RealInline.Abs[x - y]];

};

Used to control "flatness" in Flat[] and relatives

IF millis IN [0..10000] THEN

};

devicePath.mode ¬ mode

};

RETURN [LOOPHOLE[Basics.BITOR[LOOPHOLE[a], LOOPHOLE[b]]]];

};

RETURN [VAL[LOOPHOLE[i, CARDINAL] MOD 2]]

};

signAndExpt: [0..200H),

fraction: [0..CARD32.LAST/200H]

];

This rounds r, breaking ties toward plus infinity.

A fast case for an interesting range [3.90625e-3 .. 8388608) ...

f: IEEEFloat ~ LOOPHOLE[r];

c: CARDINAL ~ LOOPHOLE[149 - f.signAndExpt];

Valid: TYPE ~ [0..31);

IF c < 31 THEN {

IF LOOPHOLE[r, CARD] > 0 THEN RETURN [0];

Fallback for negative and huge numbers.

RETURN [RealInline.MCFloor[r+0.5]] -- Note this would give the wrong answer for r = 0.5-ulp, because adding 0.5 causes a roundup.

};

Valid: TYPE ~ [0..31);

f: IEEEFloat ~ LOOPHOLE[r];

c: CARDINAL ¬ LOOPHOLE[(f.signAndExpt + 16) - 150];

IF c < 8 THEN {

c ¬ Basics.BITNOT[c];

IF c < 31 THEN {

IF LOOPHOLE[r, INT] >= 0 THEN RETURN LOOPHOLE[0];

RETURN LOOPHOLE[RealInline.MCFloor[r*65536.0+0.5]]

};

depthExceededCounter ¬ depthExceededCounter + 1; -- Set break here to tinker.

RETURN [stop AND NOT nonStop]

};

RETURN[IF limit > 0 THEN FALSE ELSE DepthExceeded[]];

};

area: Area ¬ NIL;

SELECT TRUE FROM

area.tolerance ¬ defaultTolerance;

area.mode ¬ ORD[ImagerSwitches.BoolValue[scanFatSwitch]];

RETURN [area]

};

IF devicePath # NIL THEN {

};

IF edges # NIL THEN {

};

area: Area ~ devicePath;

IF box.min.s < -32767 THEN box.min.s ¬ -32767;

IF box.max.s < box.min.s THEN box.max.s ¬ box.min.s;

IF box.max.s > 32767 THEN box.max.s ¬ 32767;

IF box.min.f < -32767 THEN box.min.f ¬ -32767;

IF box.max.f < box.min.f THEN box.max.f ¬ box.min.f;

IF box.max.f > 32767 THEN box.max.f ¬ 32767;

area.bounds ¬ box;

area.realBounds ¬ [min: [s: box.min.s, f: box.min.f], max: [s: box.max.s, f: box.max.f]];

area.tightBounds ¬ [min: [s: LAST[INTEGER], f: LAST[INTEGER]], max: [s: FIRST[INTEGER], f: FIRST[INTEGER]]];

area.state ¬ awaitMove;

area.moveCount ¬ 0;

area.firstPt ¬ [0, 0];

area.lastPt ¬ [0, 0];

area.totalCrossings ¬ 0;

area.increasingEdges ¬ FreeEdges[area, area.increasingEdges];

area.decreasingEdges ¬ FreeEdges[area, area.decreasingEdges];

area.cLimit ¬ dLimit;

area.pLimit ¬ dLimit;

};

region: Region ~ [

RETURN [region]

};

area: Area ~ devicePath;

Close[area];

area.firstPt ¬ area.lastPt ¬ pt;

area.firstRegion ¬ area.lastRegion ¬ RegionOf[area, pt];

area.state ¬ awaitLine;

area.moveCount ¬ area.moveCount + 1;

};

IF area.state = awaitLine THEN LineTo[area, area.firstPt];

area.state ¬ awaitMove;

};

Just like LineTo, but conserves a register window if whole segment is visible

IF area.lastRegion = ALL[FALSE]

};

RETURN [r*0.5]

};

RETURN [[Half[p.s+q.s], Half[p.f+q.f]]];

};

old ¬ Round[defaultTolerance*100.0];

defaultTolerance ¬ i/100.0;

};

This procedure predicts up front how many subdivisions of a parabolic segment are needed to render it with reasonable accuracy. This works by taking advantage of the fact that the area of the control triangle decreases by a factor of 8 for each subdivision step (and hence the aggregate area of all the control triangles decreases by a factor of 4). The first stage decreases the area by a larger factor, because we use the two-segment that minimizes the absolute area between the approximation and the parabola.

s01: REAL ~ p0.s-p1.s;

f01: REAL ~ p0.f-p1.f;

s21: REAL ~ p2.s-p1.s;

f21: REAL ~ p2.f-p1.f;

i: CARDINAL ¬ 0;

a: REAL ¬ ABS[s01*f21-f01*s21]; -- twice the area of control triangle

budget: REAL ¬ area.tolerance * RealInline.AbsMax[p2.s-p0.s, p2.f-p0.f];

IF budget < 0.25 THEN budget ¬ 0.25; -- A minimum budget, for real small stuff.

IF a > budget THEN {

WHILE a > budget AND i < maxd DO

IF i < 4 AND s01*s21 + f01*f21 > 0.0 THEN {

RETURN [i]

};

area: Area ~ devicePath;

p0: Pair ¬ area.lastPt;

stack: ARRAY [0..maxd) OF ARRAY [0..1] OF Pair;

n: ARRAY [0..maxd) OF CARDINAL; -- This array could be eliminated by working out the right invariants.

i: CARDINAL[0..maxd) ¬ 1;

r0: Region ~ area.lastRegion;

r1: Region ~ RegionOf[area, p1];

r2: Region ~ RegionOf[area, p2];

allVisible: BOOLEAN ~ Union[Union[r0, r1], r2] = ALL[FALSE];

n[0] ¬ ParToDepth[area, p0, p1, p2];

IF n[0] = 0

stack[0] ¬ [p2, p1];

WHILE i # 0 DO

};

area: Area ~ devicePath;

R: PROC [p, q: REAL] RETURNS [REAL] ~ INLINE { RETURN [q + Half[q-p]] };

Ext: PROC [p, q: Pair] RETURNS [Pair] ~ INLINE { RETURN [[R[p.s, q.s], R[p.f, q.f]]] };

p0: Pair ~ area.lastPt;

q1: Pair ~ Ext[p0, p1];

q2: Pair ~ Ext[p3, p2];

IF RealAbsDif[q1.s, q2.s]+RealAbsDif[q1.f, q2.f] < flatHack OR TooDeep[area.cLimit]

};

area: Area ~ devicePath;

SELECT r FROM

};

num: Basics.LongNumber ¬ LOOPHOLE[s];

num.li ¬ num.li * c;

RETURN [LOOPHOLE[num]]

};

c ¬ appendSegCount;

appendSegCount ¬ 0;

};

IF area.mode # 0

};

AppendSegInner[area, point0, point1, wrapUnit];

IF point0.s > point1.s THEN {

BEGIN

};

This returns the low-order 32 bits of the double precision floating point number d.

RETURN [LOOPHOLE[d, PACKED ARRAY [0..1] OF INT32][1]];

};

scaleMagic: DREAL ¬ 3;

QRound: PROC [r: REAL] RETURNS [INT] ~ {

UNTIL QRound[1] = unit DO

RETURN [scaleMagic]

};

p0, p1: POINTER TO Pair,

scaleMagic: POINTER TO ARRAY [0..1] OF DREAL,

sAdjust: POINTER TO ARRAY [0..1] OF SCALED, -- inputs

fAdjust: POINTER TO ARRAY [0..1] OF SCALED -- outputs

] RETURNS [SCALED] ~ UNCHECKED INLINE {

num: DREAL ~ DREAL[p1.f]-DREAL[p0.f];

denom: DREAL ~ DREAL[p1.s]-DREAL[p0.s];

slope: DREAL ~ num/denom;

magic0: DREAL ~ scaleMagic[0];

p: DREAL ¬ slope + scaleMagic[1];

scaledSlope: SCALED ~ Low32[p];

p ¬ slope*sAdjust[0] + magic0;

fAdjust[0] ¬ Low32[p];

p ¬ slope*sAdjust[1] + magic0;

fAdjust[1] ¬ Low32[p];

RETURN [scaledSlope];

};

Another version of ScaledSlope - it avoids quite a few memory references, but should do exactly the same thing.

"+static int MCScaledSlope (p0, p1, scaleMagic, sAdjust, fAdjust) float p0[]; float p1[]; double scaleMagic[]; int sAdjust[]; int fAdjust[]; {

.MCScaledSlope";

};

sMin: INTEGER ¬ Round[p0.s];

sMax: INTEGER ¬ Round[p1.s];

appendSegCount ¬ appendSegCount + 1;

IF sMin > sMax THEN {

IF sMin < sMax THEN {

};

This procedure attempts to improve the numeric stability of the result by calculating the intersection from the closer of the two endpoints. We assume x1#x0.

dx0: REAL ~ x-x0;

dx1: REAL ~ x1-x;

IF checking THEN Check[ (x IN [x0..x1] OR x IN [x1..x0]) ];

IF RealInline.Abs[dx0] <= RealInline.Abs[dx1]

IF checking THEN Check[ (y IN [y0..y1] OR y IN [y1..y0]) ];

};

sRegion: Region ~ [sLo: TRUE, sHi: TRUE, fLo: FALSE, fHi: FALSE];

clip: ARRAY ExternalHalfPlane OF REAL ~ [

FOR b: ExternalHalfPlane IN ExternalHalfPlane DO

IF checking THEN Check[ (Union[r0, r1] = ALL[FALSE]) ];

AppendSeg[area, p0, p1]

};

Sort by increasing sMin

RETURN [MSort[e: e, sCompare: TRUE, terminator: NIL]];

};

Does a list-merge sort on e, by either s or f; terminator is used as the list terminator, and must be reachable from e.

n: INT ¬ 0;

x: Edges ¬ e;

y: Edges ¬ terminator;

tail: Edges ¬ e;

WHILE x # terminator DO

IF n <= 10 THEN RETURN [ISort[e, sCompare, terminator]];

x ¬ e;

y ¬ tail.link;

tail.link ¬ terminator;

x ¬ MSort[x, sCompare, terminator];

y ¬ MSort[y, sCompare, terminator];

Finally, merge the two sorted lists

RETURN [Merge[x, y, sCompare, terminator]]

};

GT: PROC [a, b: Edge] RETURNS [BOOL] ~ INLINE {

new: Edges ¬ x;

tail: Edges ¬ terminator;

IF x = terminator THEN RETURN [y];

IF y = terminator THEN RETURN [x];

IF GT[x, y] THEN {new ¬ y; y ¬ x; x ¬ new};

DO

};

Sort the head of e (punctuated by terminator) by increasing sMin or f0

unconsumed: Edges ¬ e;

new: Edges ¬ terminator;

WHILE unconsumed # terminator DO

RETURN [new];

};

Sort the head of e (those at front of list with sMin = s) by increasing f0

n: INT ¬ 0;

null: Edges ¬ e;

WHILE null # NIL AND null.sMin = s DO null ¬ null.link; n ¬ n + 1 ENDLOOP;

IF n <= 10 THEN RETURN [ISort[e: e, sCompare: FALSE, terminator: null]];

RETURN [MSort[e: e, sCompare: FALSE, terminator: null]];

};

WHILE e#NIL DO n ¬ n + e.sCount; e ¬ e.link ENDLOOP;

};

sSize: INT ¬ 0;

IF area.state = awaitLine THEN Close[area];

sSize ¬ area.tightBounds.max.s-area.tightBounds.min.s;

IF sSize <= 0 OR (area.moveCount = 1 AND area.totalCrossings = sSize+sSize)

area.increasingEdges ¬ SortS[area.increasingEdges];

area.decreasingEdges ¬ SortS[area.decreasingEdges];

IF checking AND CountCrossings[area.increasingEdges] # CountCrossings[area.decreasingEdges] THEN ERROR;

};

WHILE e.sMin+e.sCount <= s AND e.link#NIL DO

IF e.sMin+e.sCount <= s

RETURN [e];

};

head: Edges ~ IF area.freeEdges = NIL THEN NEW[EdgeRep] ELSE area.freeEdges;

last: Edges ¬ head;

WHILE src # NIL DO

{

};

WHILE p # NIL AND p.sMin < bbMinS DO

};

-- This is to call from the dubugger; it can be commented out for production.

nCross: PACKED ARRAY [0..500] OF INTEGER ¬ ALL[0];

s: INT ¬ INT.FIRST;

FOR e: Edges ¬ area.increasingEdges, e.link UNTIL e = NIL DO

s ¬ INT.FIRST;

FOR e: Edges ¬ area.decreasingEdges, e.link UNTIL e = NIL DO

FOR i: INT IN [0..500] DO IF nCross[i] # 0 THEN ERROR ENDLOOP;

s ¬ INT.FIRST;

};

RETURN [[sMin: FIRST[INTEGER], sCount: 0, f0: ImagerScaled.zero, df: ImagerScaled.zero, wrapDelta: 0, link: edges]]

};

bb: SF.Box ~ SF.Intersect[clipBox, area.tightBounds];

e: ARRAY [0..1] OF EdgeRep ¬ [

s: INTEGER ¬ e[0].sMin;

assert: BOOL[TRUE..TRUE] ¬ (s = e[1].sMin);

currentBox: SF.Box ¬ [];

WHILE s < bb.max.s DO

IF SF.Nonempty[currentBox] THEN boxAction[currentBox];

};

boxes: SF.BoxGenerator ~ { BoxesFromArea[area, boxAction, SF.maxBox, oddWrap] };

ImagerSample.FillBoxes[dst, boxes];

};