gralha-coverage

Search uses release 0.1.0.1 · 199 definitions

Releases (1)

0.1.0.1 indexed

Definitions (199)

cover.bend

def piece.eventsThe contributions of a line piece clipped to the row [y, y + 1).
def piece.keep
def pieces.rowThe row's pieces all go into the buffer and come back as a list (in any order); those the next row no longer reaches are retired afterwards.
def pieces.retire
def piece.lineA piece as a line shifted so the row starts at zero, for the sub-scanline scan of a row whose exact areas showed an overlap.
def pieces.lines
def line.bottom
def row.of
def counts.inc.got
def counts.inc
def soa.store.goStore each line at 4i and count its top row.
def counts.prefix.gotTurn counts into starting positions.
def counts.prefix
def counts.done
def soa.place.posPlace line i at its row's next position.
def soa.place.y1
def soa.place.y0
def soa.place
def soa.placed
def soa.stored
def soa.buildThe lines as (values, order) arrays, ordered by top row.
def soa.line.x1The lines back as a list in order, for the sub-scanline scans.
def soa.line.y1
def soa.line.y0
def soa.line.x0
def soa.line.pair
def soa.line.idx
def soa.lines.go
def soa.lines.done
def soa.lines
type PieceTakeLines whose top the row's bottom has passed become pieces; a horizontal one is skipped.
def piece.take.x1
def piece.take.x0
def piece.take.pick
def piece.take.y1
def piece.take.y0
def piece.take.idx
def piece.take.more
def piece.take
type XStateReading the runs off the buffer, touched cells only, from hi down to lo: a cell's coverage is the magnitude of its direct area minus the deltas to its right (a row's deltas cancel), clamped to one, and the untouched cells between two touched ones share the magnitude of those deltas.
def xrun.value
def xrow.delta
def xrow.direct
def xrow.cell
def xrow.bits
def xrow.word.if
def xrow.word
def xrow.word.of
def xrow.words
def xrow.doneA row's result: ((runs, overlap seen), the cleared buffer).
def xrow.count
def xrow.from
def xrow.runsThe runs of a row from its buffer, which comes back cleared.
type XDataThe scan state: the row buffer, the line arrays, and the rest as a record.
def rows.head
def xscan.fixA row whose exact areas showed an overlap is scanned again with the sub-scanlines over its own pieces; other rows keep their runs.
def xscan.push
def xscan.swept
def xscan.rowed
def xscan.taken
def xscan.row
def xscan.rows.go
def xscan.done
def xscan.rowsThe rows of runs of the lines (in their arrays, n of them) by exact areas, rows with an overlap done with `sub` scanlines.
type HalvesA row's runs cut at mid into the left and right halves, with the row's uniform value over [x0, x1): 0 for no runs, the value of a single run that spans the columns, -1 otherwise.
def halves.place
def halves.push
def runs.halves
type NodeA node's uniform value (2 before any row, -1 once rows disagree) and its quarters' rows; flat holds when the node is uniform (no rows means empty).
def node.push
def node.rowsRows past the end of the list are empty; row i of size is a top row when i < half.
def node.mark
def node.of
def node.value
def tree.node
type CovBox
def lines.bounds
def lines.shift
def mask.data
def mask.arrays
def mask.scanEven-odd fills rely on the winding parity, which only the sub-scanline scan follows.
def mask.build
def mask.box
def line.on.boxA closed rectangle on whole pixels: four axis-aligned lines on the box edges with integer coordinates (the usual viewport clip and the common rect), whose mask is a tree of full and empty leaves with no scan at all.
def lines.on.boxZero-length lines (a path's move and close) are ignored; the four real ones must lie on the box.
def whole
def rect.aligned
def tree.rect
def rect.rowsA full rectangle as rows: one run per row.
def rect.data
def mask.rect
def mask.shape
def maskRasterize closed contours given as directed lines in pixel coordinates of a width by height grid, with `sub` scanlines per pixel row; nonzero winding, or even-odd when `even` holds.
type CovLinesLines gathered with their bounds and count as they are made, so the mask needs no pass of its own over them; only a handful of lines can be a rectangle, so the others skip that test too.
def lines.empty
def lines.add
def mask.lined.pick
def mask.lined
def mask.scanned