gralha-coverage

Search uses release 0.1.0.1 · 199 definitions

Releases (1)

0.1.0.1 indexed

Definitions (199)

cover.bend

type CovLineA directed line in pixel coordinates of the target grid.
type CovTreeCoverage over a power-of-two square: uniform cells collapse to one leaf.
type RunA run of cells [x0, x1) of one nonzero coverage value in a row.
type CovDataA mask's coverage: rows of runs (top first, ascending runs), which a fill is painted from directly, or the tree, which clip masks and sampled tiles need for block and pixel queries.
type CovMaskA mask placed at pixel (x, y) of its grid, size = 2^depth cells on a side.
def mask.none
def runs.atCoverage of a cell from rows of runs; a slow path for masks built without a tree.
def rows.at
def mask.present
def tree.at
def data.at
def mask.at.in
def mask.atCoverage of the pixel containing (px, py), in grid pixel coordinates; the reads branch through matches, not lambdas, since they run once per pixel.
def tree.same.asCoverage over the cell rectangle [x0, x1) by [y0, y1) of a node's square at (nx, ny) of side size, when every cell in it holds the same value; -1 otherwise.
def tree.overlaps
def tree.uniform
def runs.overThe mask's coverage over the grid rectangle [x0, x1) by [y0, y1) when it is uniform (2 means "unvisited", so an empty rectangle reads as uniform 0), else -1.
def rows.over
def data.uniform
def mask.uniform.in
def mask.uniform
def line.split
def lines.append
def lines.split
def lines.clampPieces left of 0 or right of w become vertical lines on that boundary, which keeps the winding of every cell inside [0, w) intact.
def lines.clipThe clipped lines, in no particular order, with their count.
def line.pushOne pass over the lines: shift by the mask's origin, split at the grid's left and right edges and clamp the pieces to it, counting them.
def line.cut.atSplit at x = at when the line crosses it, pushing the piece before the crossing; the rest continues.
def line.cut
def line.prepare.last
def line.prepare.right
def lines.prepare
def line.top
type ActA line on the scanlines: x at the current one is cur; slope is dx/dy.
type InsInsert into a list descending by cur, after the elements not below it.
def act.ins.pick
def act.insert.go
def act.insert
def act.reverse
def act.keepThe line as it will stand on scanline sy, placed into the descending list.
def act.addA line covers [top, bottom) so a shared vertex counts once; a horizontal line never crosses.
type TakeLines from the sorted pending list whose top the scanline sy has reached.
def take.pick
def take.go
type CovEv
def ev.push.if
def ev.push
def span.events.cells
def span.eventsEvents of the span [xa, xb) when it is inside; both ends lie within [0, width].
def winding.inside
type StepOne scanline: walk the ascending list, emit the inside spans' events, and build the descending list for the next scanline sy2.
def step
type EvOrderMerge two descending event lists, larger cells first.
def ev.cell
def ev.order.pick
def ev.order
def ev.merge.go
def ev.merge
def run.snapSums of a weight's multiples cancel exactly for power-of-two sub counts and to within rounding otherwise; noise below a millionth reads as empty.
def runs.emit.join
def runs.emit.some
def runs.emitPrepend the run [x0, x1) of value v, extending the head when they meet with one value.
type SweepSweep state: sum is the total delta at cells >= upper, the runs so far cover cells >= upper, and the open group collects the events of cell c.
def sweep.flushClose the group at c: the gap (c, upper) holds -sum, cell c adds its directs.
def sweep.step
def sweep
def row.runsThe runs of a row of width w from its descending events.
type LineOrder
def lines.order.pick
def lines.order
def lines.merge.go
def lines.merge
type LineSplit
def lines.deal
def lines.sort.go
def lines.sort
type Subs
def subs.done
def subs.after
def subs.step
def scan.subs
type Scan
def scan.row.done
def scan.row
def scan.rows.go
def rows.reverse
def scan.done
def scan.start
def scan.rowsThe rows of runs (top first) of the lines, sorted by top, over a width by height grid.
def depth.for
type PieceA line for the exact scan: x = x0 + (y - y0) * slope over [top, bottom).
def piece.of
def piece.bottom
def buf.add.got
def buf.add
def bits.set.got
def bits.set
def buf.putA cut's direct area goes to its cell (dropped at or past the width, which lies outside the row) and its delta to the next cell, capped at the width so every delta still counts in the sum.
def buf.put.if
def piece.cuts