Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.6

0.7.6 / src / selecting / convert.lucb

## Selection kernels over a mesh's connectivity: converting bits between the
## point, corner, face and edge domains, and growing, shrinking, bordering
## and flood filling (the walkers are walkers.lucb). They read the topology
## caches (edges, point-face, point-edge and edge-corner lists), which every
## mesh with the same connectivity shares, and write fresh bits.

## Bits of `source` elements converted to `destination` elements. With `all`, an element
## is selected when every related element is (a face whose points all are);
## otherwise when any is (a point of any selected face). Faces relate to
## their corners, points and edges; edges to their two points, their corners
## and their faces; corners to their point, face and edge.
pub func converted(topology: const Topology*, bits: Bits, source: Domain, destination: Domain, all: bool) -> BitsBuilder!:
    let size = topology.size(destination)
    var out = try BitsBuilder.zeros(size)
    errdefer out.close()
    if source == destination:
        memory.copy(out.words(), bits.words, bits.words.length)
        return out
    if source == Domain.detail:
        if bits.get(0): out.set_range(0, size)
        return out
    if destination == Domain.detail:
        if (all and bits.population() == bits.count) or (not all and bits.any()): out.set(0)
        return out
    let hits = try new u32[size] --- in memory.heap
    defer free(hits) in memory.heap
    let totals = try new u32[size] --- in memory.heap
    defer free(totals) in memory.heap
    memory.set(u8[]((u8*)hits.data, size * 4), 0)
    memory.set(u8[]((u8*)totals.data, size * 4), 0)
    # Every relation is a list of (from, to) pairs over corners or edges.
    if (source == Domain.point and destination == Domain.edge) or (source == Domain.edge and destination == Domain.point):
        for edge in 0..<topology.edges():
            for side in 0..<(usize)2:
                let point = (usize)topology.edge_points[edge * 2 + side]
                relate(bits, source == Domain.point, point, edge, hits, totals)
    else:
        for corner in 0..<topology.corners.length:
            let a = element_of(topology, corner, source)
            let b = element_of(topology, corner, destination)
            let target = b
            totals[target] += 1
            if bits.get(a): hits[target] += 1
    for element in 0..<size:
        if totals[element] > 0 and (hits[element] == totals[element] if all else hits[element] > 0): out.set(element)
    return out

## Count one (point, edge) relation in the direction of the conversion.
func relate(bits: Bits, point_first: bool, point: usize, edge: usize, hits: u32[], totals: u32[]):
    let source = point if point_first else edge
    let target = edge if point_first else point
    totals[target] += 1
    if bits.get(source): hits[target] += 1

## The element of `domain` a corner belongs to.
func element_of(topology: const Topology*, corner: usize, domain: Domain) -> usize:
    match domain:
        .point: return (usize)topology.corners[corner]
        .face: return (usize)topology.corner_faces[corner]
        .edge: return (usize)topology.corner_edges[corner]
        _: return corner

## Neighbors across the domain's connector: faces through edges, points and
## edges through points, corners through points.
func connector(domain: Domain) -> Domain:
    return Domain.edge if domain == Domain.face else Domain.point

## Neighbors across faces instead (Blender's face step): faces through
## their points, points and edges through their faces.
func face_step_connector(domain: Domain) -> Domain:
    return Domain.point if domain == Domain.face else Domain.face

## `bits` and every element next to one of them, `steps` times.
pub func grown(topology: const Topology*, bits: Bits, domain: Domain, steps: usize) -> BitsBuilder!:
    return try grown_through(topology, bits, domain, connector(domain), steps)

## `bits` and every element sharing a `link` element with one, `steps`
## times.
pub func grown_through(topology: const Topology*, bits: Bits, domain: Domain, link: Domain, steps: usize) -> BitsBuilder!:
    var current = try BitsBuilder.copy_of(bits)
    errdefer current.close()
    for _ in 0..<steps:
        var linked = try converted(topology, current.view(), domain, link, false)
        defer linked.close()
        var next = try converted(topology, linked.view(), link, domain, false)
        current.close()
        current = next
    return current

## `bits` without the elements next to an unselected one, `steps` times.
pub func shrunk(topology: const Topology*, bits: Bits, domain: Domain, steps: usize) -> BitsBuilder!:
    return try shrunk_through(topology, bits, domain, connector(domain), steps)

## `bits` without the elements sharing a `link` element with an
## unselected one, `steps` times.
pub func shrunk_through(topology: const Topology*, bits: Bits, domain: Domain, link: Domain, steps: usize) -> BitsBuilder!:
    var current = try BitsBuilder.copy_of(bits)
    errdefer current.close()
    for _ in 0..<steps:
        var outside = try BitsBuilder.copy_of(current.view())
        defer outside.close()
        outside.invert()
        var reach = try grown_through(topology, outside.view(), domain, link, 1)
        defer reach.close()
        current.subtract(reach.view())
    return current

## The selected elements next to an unselected one.
pub func bordered(topology: const Topology*, bits: Bits, domain: Domain) -> BitsBuilder!:
    var outside = try BitsBuilder.copy_of(bits)
    defer outside.close()
    outside.invert()
    var reach = try grown(topology, outside.view(), domain, 1)
    errdefer reach.close()
    reach.intersect(bits)
    return reach

## Everything connected to `bits`: a breadth-first flood over faces sharing
## edges, or points and edges sharing points (corners through their points).
pub func connected(topology: const Topology*, bits: Bits, domain: Domain) -> BitsBuilder!:
    if domain == Domain.corner or domain == Domain.detail:
        var points = try converted(topology, bits, domain, Domain.point, false)
        defer points.close()
        var filled = try connected(topology, points.view(), Domain.point)
        defer filled.close()
        return try converted(topology, filled.view(), Domain.point, domain, false)
    var out = try BitsBuilder.copy_of(bits)
    errdefer out.close()
    let queue = try new u32[topology.size(domain)] --- in memory.heap
    defer free(queue) in memory.heap
    var head: usize = 0
    var tail: usize = 0
    for word in 0..<bits.words.length:
        var pending = bits.words[word]
        while pending != 0:
            queue[tail] = (u32)(word * 64 + (usize)trailing_zeros(pending))
            tail += 1
            pending = pending & (pending - 1)
    while head < tail:
        let element = (usize)queue[head]
        head += 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]]
                    if not out.view().get(face):
                        out.set(face)
                        queue[tail] = (u32)face
                        tail += 1
        else:
            # Points reach points through 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 next = edge
                    if domain == Domain.point:
                        let a = (usize)topology.edge_points[edge * 2]
                        next = (usize)topology.edge_points[edge * 2 + 1] if a == point else a
                    if not out.view().get(next):
                        out.set(next)
                        queue[tail] = (u32)next
                        tail += 1
    return out

let convert_parms: ParmSpec[2] = [
    ParmSpec("To", ParmKind.menu, 2.0, 0.0, 2.0, 1, "Points|Edges|Faces", "The component type the selection becomes."),
    ParmSpec("Rule", ParmKind.menu, 0.0, 0.0, 1.0, 1, "Touching|Contained", "Touching: every element the selection touches. Contained: only those all of whose points, edges or faces are selected.")]

func convert_rule() -> SelectRule:
    return SelectRule("Select Convert", "Convert", "", "The selection as points, edges or faces: those it touches, or only those it contains (Maya's Convert Selection)", "Convert", "select-convert",
                      "points edges faces", any_picks, convert_parms, select_convert)

func select_convert(input: const RuleInput*) -> RuleOutput!:
    let targets: Domain[3] = [Domain.point, Domain.edge, Domain.face]
    let target = targets[(usize)math.clamp(input.parms.at(0), 0.0, 2.0)]
    return RuleOutput(try converted(input.topology, input.group, input.domain, target, input.parms.at(1) != 0.0), target)