Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.7

0.7.7 / src / selecting / patterns.lucb

## Pattern rules: Checker keeps a repeating pattern of the group (a run of
## selected elements, then a run of deselected ones, counted outward across
## each connected island of the group, Blender's Checker Deselect); Random
## keeps a share of it.

let checker_parms: ParmSpec[3] = [
    ParmSpec("Selected", ParmKind.integer, 1.0, 1.0, 100.0, 1, "", "Elements kept selected in a row."),
    ParmSpec("Deselected", ParmKind.integer, 1.0, 1.0, 100.0, 1, "", "Elements deselected in a row, after each selected run."),
    ParmSpec("Offset", ParmKind.integer, 0.0, 0.0, 100.0, 1, "", "Shift the pattern along by this many elements.")]

let checker_picks: PickSpec[1] = [PickSpec("Components", "points edges faces", "Select the region to thin out")]

func checker_rule() -> SelectRule:
    return SelectRule("Select Checker", "Checker", "checker", "Keep a checker pattern of the group: runs of selected and deselected elements across each island", "Pattern", "select-checker",
                      "points edges faces", checker_picks, checker_parms, select_checker)

## Each group element's step count from where its island starts (its lowest
## element), walking only through the group: faces across their edges,
## edges through their points, points along their edges. An element is
## kept when (steps + offset) mod (selected + deselected) < selected.
func select_checker(input: const RuleInput*) -> RuleOutput!:
    let domain = input.domain
    let kept = (usize)input.parms.at(0)
    let period = kept + (usize)input.parms.at(1)
    let offset = (usize)input.parms.at(2)
    let topology = input.topology
    let size = topology.size(domain)
    let steps = try new u32[size] --- in memory.heap
    defer free(steps) in memory.heap
    let queue = try new u32[size] --- in memory.heap
    defer free(queue) in memory.heap
    var visited = try BitsBuilder.zeros(size)
    defer visited.close()
    var chosen = try BitsBuilder.zeros(size)
    errdefer chosen.close()
    let group = input.group
    for word in 0..<group.words.length:
        var pending = group.words[word]
        while pending != 0:
            let start = word * 64 + (usize)trailing_zeros(pending)
            pending = pending & (pending - 1)
            if visited.view().get(start): continue
            # A breadth-first walk over the island from `start`.
            visited.set(start)
            steps[start] = 0
            queue[0] = (u32)start
            var head: usize = 0
            var tail: usize = 1
            while head < tail:
                let element = (usize)queue[head]
                head += 1
                if (((usize)steps[element] + offset) % period) < kept: chosen.set(element)
                tail = checker_neighbors(topology, group, domain, element, steps, queue, tail, &visited)
    return RuleOutput(chosen, domain)

## Queue `element`'s unvisited neighbors in the group one step further on;
## the queue's new end.
func checker_neighbors(topology: const Topology*, group: Bits, domain: Domain, element: usize, steps: u32[], queue: u32[], tail: usize, visited: BitsBuilder*) -> usize:
    var end = tail
    let next = steps[element] + 1
    if domain == Domain.face:
        for corner in (usize)topology.offsets[element]..<(usize)topology.offsets[element + 1]:
            let edge = (usize)topology.corner_edges[corner]
            for at in (usize)topology.edge_corner_offsets[edge]..<(usize)topology.edge_corner_offsets[edge + 1]:
                let face = (usize)topology.corner_faces[(usize)topology.edge_corners[at]]
                end = reached(group, face, next, steps, queue, end, visited)
        return end
    # Points reach points along their edges; edges reach edges through
    # their points.
    let ends: usize[2] = [element, 0] if domain == Domain.point else [(usize)topology.edge_points[element * 2], (usize)topology.edge_points[element * 2 + 1]]
    let count: usize = 1 if domain == Domain.point else 2
    for side in 0..<count:
        let point = ends[side]
        for at in (usize)topology.point_edge_offsets[point]..<(usize)topology.point_edge_offsets[point + 1]:
            let edge = (usize)topology.point_edges[at]
            var other = edge
            if domain == Domain.point:
                let a = (usize)topology.edge_points[edge * 2]
                other = (usize)topology.edge_points[edge * 2 + 1] if a == point else a
            end = reached(group, other, next, steps, queue, end, visited)
    return end

## Queue `element` at `step` when it is in the group and not yet visited.
func reached(group: Bits, element: usize, step: u32, steps: u32[], queue: u32[], tail: usize, visited: BitsBuilder*) -> usize:
    if not group.get(element) or visited.view().get(element): return tail
    visited.set(element)
    steps[element] = step
    queue[tail] = (u32)element
    return tail + 1

let random_parms: ParmSpec[2] = [
    ParmSpec("Ratio", ParmKind.number, 0.5, 0.0, 1.0, 1, "", "The share of the group kept selected."),
    ParmSpec("Seed", ParmKind.integer, 0.0, 0.0, 100000.0, 1, "", "Another seed, another pattern.", soft = 100.0)]

func random_rule() -> SelectRule:
    return SelectRule("Select Random", "Random", "random", "A random share of the group: each element kept with the Ratio's chance, the same for the same seed", "Pattern", "select-random",
                      "points edges faces", checker_picks, random_parms, select_random)

func select_random(input: const RuleInput*) -> RuleOutput!:
    let size = input.topology.size(input.domain)
    var out = try BitsBuilder.zeros(size)
    errdefer out.close()
    let ratio = input.parms.at(0)
    let seed = (u64)input.parms.at(1)
    for element in 0..<size:
        if input.group.get(element) and chance(seed, (u64)element) < ratio: out.set(element)
    return same_domain(input, out)

## A number in 0..<1 from `seed` and `element` (SplitMix64's finalizer):
## the same pair, the same number on every machine.
func chance(seed: u64, element: u64) -> f64:
    var z = element *% 0x9E3779B97F4A7C15 +% seed *% 0xBF58476D1CE4E5B9 +% 0x632BE59BD9B4E019
    z = (z ^ (z >> 30)) *% 0xBF58476D1CE4E5B9
    z = (z ^ (z >> 27)) *% 0x94D049BB133111EB
    z = z ^ (z >> 31)
    return (f64)(z >> 11) / 9007199254740992.0