Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.7

0.7.7 / src / groups / selection.lucb

## A component selection: bits over one domain of one mesh's topology, the
## interaction state the viewport edits and tools read (points, edges, faces
## or corners). It never enters node stamps. Every operation returns a new
## selection sharing nothing mutable; setting a million bits costs a word
## fill, and a click copies 88 KB for a 700k-face mesh.

pub struct Selection:
    var bits: Column[u64]
    var elements: usize
    var domain_value: Domain
    ## The connectivity hash of the mesh the bits index (a durable guard).
    var topology: u64
    var report: GroupReport
    ## The element picked last (-1: none): where a shortest path starts, and
    ## the loop a partial loop runs along.
    var active_element: i64

    ## Nothing selected on `domain` of `mesh`.
    pub static func empty(mesh: interop.Reference[Mesh], domain: i64) -> interop.Reference[Selection]!:
        let geometry = try mesh.get()
        let target = try domain_of(domain)
        var bits = try BitsBuilder.zeros((usize)(try geometry.domain_count(domain)))
        return try adopt_selection(bits.finish(), bits.count, target, (u64)geometry.topology_hash(), GroupReport())

    ## The elements of `domain` a group expression names.
    pub static func of(mesh: interop.Reference[Mesh], expression: str, domain: i64) -> interop.Reference[Selection]!:
        let geometry = try mesh.get()
        let target = try domain_of(domain)
        var result = try group_bits(geometry, expression, target)
        let elements = (usize)(geometry.domain_count(domain) catch failure:
            result.bits.release()
            error(failure.code, failure.message))
        return try adopt_selection(result.bits, elements, target, (u64)geometry.topology_hash(), result.report)

    ## 0 points, 1 corners, 2 faces, 4 edges.
    pub func domain() -> i64:
        return (i64)(u8)self.domain_value

    ## The bits' identity: equal keys are equal selections (renderers skip
    ## rebuilding for an unchanged one).
    pub func key() -> u64:
        return self.bits.id() ^ (u64)self.elements

    ## The element picked last, or -1.
    pub func active() -> i64:
        return self.active_element

    ## The same bits with `element` as the active one (-1: none).
    pub func with_active(element: i64) -> interop.Reference[Selection]!:
        var bits = try BitsBuilder.copy_of(self.view())
        return try adopt_selection(bits.finish(), self.elements, self.domain_value, self.topology, GroupReport(), element)

    ## Elements selected, and elements there are.
    pub func count() -> i64:
        return (i64)self.view().population()

    pub func size() -> i64:
        return (i64)self.elements

    pub func contains(element: i64) -> bool:
        return element >= 0 and (usize)element < self.elements and self.view().get((usize)element)

    ## Whether the bits index `mesh` (same element count and connectivity).
    pub func fits(mesh: interop.Reference[Mesh]) -> bool!:
        let geometry = try mesh.get()
        return (usize)(try geometry.domain_count(self.domain())) == self.elements and (u64)geometry.topology_hash() == self.topology

    ## What evaluating an expression noticed: numbers that named nothing,
    ## unknown group names, and whether anything came from another domain.
    pub func misses() -> i64:
        return (i64)self.report.misses

    pub func unknown_names() -> i64:
        return (i64)self.report.unknown_names

    pub func converted() -> bool:
        return self.report.converted

    ## The `index`-th selected element (ascending), or -1.
    pub func member(index: i64) -> i64:
        var remaining = index
        let words = self.bits.view()
        for word in 0..<words.length:
            let count = (i64)popcount(words[word])
            if remaining >= count:
                remaining -= count
                continue
            var bits = words[word]
            for _ in 0..<remaining: bits = bits & (bits - 1)
            return (i64)(word * 64 + (usize)trailing_zeros(bits))
        return -1

    ## The first selected element after `element` (-1: from the start), or
    ## -1: `while (at = s.next(at)) >= 0` visits the members in O(n) total.
    pub func next(element: i64) -> i64:
        let words = self.bits.view()
        var at = (usize)(element + 1) if element >= -1 else 0
        while at < self.elements:
            let word = words[at >> 6] >> (u64)(at & 63)
            if word != 0: return (i64)(at + (usize)trailing_zeros(word))
            at = (at | 63) + 1
        return -1

    ## The selected elements into `out` (which holds `count()` of them).
    pub func members(out: i64[]) -> !:
        if out.length != self.view().population(): error(errors.invalid, "members needs room for every selected element")
        self.view().indices(out)

    # -- New selections.

    ## With `element` set, cleared or flipped (op 0, 1, 2), or only it
    ## selected (op 3); an element set becomes the active one. Elements out
    ## of range change nothing.
    pub func changed(element: i64, operation: i64) -> interop.Reference[Selection]!:
        var bits = try BitsBuilder.copy_of(self.view())
        var active = self.active_element
        if element >= 0 and (usize)element < self.elements:
            let at = (usize)element
            if operation == 3:
                bits.close()
                bits = try BitsBuilder.zeros(self.elements)
                bits.set(at)
            elif operation == 0 or (operation == 2 and not self.view().get(at)): bits.set(at)
            else: bits.clear(at)
            active = element if bits.view().get(at) else (-1 if active == element else active)
        return try adopt_selection(bits.finish(), self.elements, self.domain_value, self.topology, GroupReport(), active)

    ## Every element, or none.
    pub func filled(all: bool) -> interop.Reference[Selection]!:
        var bits = (try BitsBuilder.ones(self.elements)) if all else (try BitsBuilder.zeros(self.elements))
        return try self.with_bits(bits.finish())

    pub func inverted() -> interop.Reference[Selection]!:
        var bits = try BitsBuilder.copy_of(self.view())
        bits.invert()
        return try self.with_bits(bits.finish())

    ## Also the elements of `expression` (0 add, 1 remove, 2 intersect).
    pub func combined(mesh: interop.Reference[Mesh], expression: str, operation: i64) -> interop.Reference[Selection]!:
        let geometry = try mesh.get()
        var result = try group_bits(geometry, expression, self.domain_value)
        defer result.bits.release()
        var bits = try BitsBuilder.copy_of(self.view())
        let other = Bits(result.bits.view(), self.elements)
        if operation == 0: bits.unite(other)
        elif operation == 1: bits.subtract(other)
        else: bits.intersect(other)
        return try self.with_bits(bits.finish())

    ## Also `other`'s elements (0 add, 1 remove, 2 intersect); `other` is a
    ## selection of the same domain and mesh. The active element is kept.
    pub func joined(other: interop.Reference[Selection], operation: i64) -> interop.Reference[Selection]!:
        let given = try other.get()
        if given.domain_value != self.domain_value or given.elements != self.elements: error(errors.invalid, "selections of different components do not join")
        var bits = try BitsBuilder.copy_of(self.view())
        if operation == 0: bits.unite(given.view())
        elif operation == 1: bits.subtract(given.view())
        else: bits.intersect(given.view())
        return try self.with_bits(bits.finish())

    ## Select rule `name` (its verb's name: "Select Loop") run on these
    ## components with `numbers` as its parameters: the selection it makes,
    ## on its own domain (Boundary Loop of faces gives edges), active
    ## element kept. The Select tools and the viewport's gestures run this.
    pub func ruled(mesh: interop.Reference[Mesh], name: str, numbers: const f64[]) -> interop.Reference[Selection]!:
        let index = rule_named(name)
        if index < 0: error(errors.invalid, "no such select rule")
        let rule = rule_at((usize)index)
        var made = try run_rule(&rule, try mesh.get(), self.view(), self.domain_value, numbers)
        let count = made.bits.count
        return try adopt_selection(made.bits.finish(), count, made.domain, self.topology, GroupReport(), self.active_element)

    ## The same components on another domain (see `converted` in convert:
    ## `all` needs every related element, else any).
    pub func on_domain(mesh: interop.Reference[Mesh], domain: i64, all: bool) -> interop.Reference[Selection]!:
        let geometry = try mesh.get()
        let target = try domain_of(domain)
        let topology = try Topology.of(geometry)
        var bits = try converted(&topology, self.view(), self.domain_value, target, all)
        let count = bits.count
        return try adopt_selection(bits.finish(), count, target, self.topology, GroupReport())

    ## The points of the selected components, for point tools.
    pub func points(mesh: interop.Reference[Mesh]) -> interop.Reference[Selection]!:
        return try self.on_domain(mesh, 0, false)

    ## A group expression that names exactly these components (see encode).
    pub func expression(mesh: interop.Reference[Mesh]) -> interop.Owned[str]!:
        var text = Growing[u8]()
        defer text.close()
        try encode(try mesh.get(), self.view(), self.domain_value, &text)
        return try interop.copy_text((str)text.view())

    ## The average of the selected components' points; `none` selected: the
    ## bounds center.
    pub func center(mesh: interop.Reference[Mesh]) -> Vector3!:
        let geometry = try mesh.get()
        let topology = try Topology.of(geometry)
        var points = try converted(&topology, self.view(), self.domain_value, Domain.point, false)
        defer points.close()
        let positions = geometry.point_span()
        var sum = Vector3()
        var count: usize = 0
        let words = points.view().words
        for word in 0..<words.length:
            var pending = words[word]
            while pending != 0:
                let point = word * 64 + (usize)trailing_zeros(pending)
                pending = pending & (pending - 1)
                sum = sum.add(positions[point].vector())
                count += 1
        if count == 0:
            let box = geometry.bounds()
            return box.minimum.add(box.maximum).multiply_scalar(0.5)
        return sum.multiply_scalar(1.0 / (f64)count).add(geometry.position_origin())

    ## The box around the selected components' points; `none` selected: the
    ## mesh's bounds (framing a selection).
    pub func bounds(mesh: interop.Reference[Mesh]) -> Bounds!:
        let geometry = try mesh.get()
        let topology = try Topology.of(geometry)
        var points = try converted(&topology, self.view(), self.domain_value, Domain.point, false)
        defer points.close()
        let positions = geometry.point_span()
        var low = Float3(0.0, 0.0, 0.0)
        var high = low
        var any = false
        let words = points.view().words
        for word in 0..<words.length:
            var pending = words[word]
            while pending != 0:
                let p = positions[word * 64 + (usize)trailing_zeros(pending)]
                pending = pending & (pending - 1)
                if not any:
                    low = p
                    high = p
                    any = true
                    continue
                low = Float3(p.x if p.x < low.x else low.x, p.y if p.y < low.y else low.y, p.z if p.z < low.z else low.z)
                high = Float3(p.x if p.x > high.x else high.x, p.y if p.y > high.y else high.y, p.z if p.z > high.z else high.z)
        if not any: return geometry.bounds()
        let origin = geometry.position_origin()
        return Bounds(low.vector().add(origin), high.vector().add(origin))

    func view() -> Bits:
        return Bits(self.bits.view(), self.elements)

    func with_bits(column: Column[u64]) -> interop.Reference[Selection]!:
        return try adopt_selection(column, self.elements, self.domain_value, self.topology, GroupReport(), self.active_element)

    pub func close():
        self.bits.release()

pub let selection_type: interop.Type[Selection] = interop.Type[Selection]("Selection", Selection.close, closeable = true)

## A selection owning `column` (taken, released on failure).
pub func adopt_selection(column: Column[u64], elements: usize, domain: Domain, topology: u64, report: GroupReport, active: i64 = -1) -> interop.Reference[Selection]!:
    var owned = column
    let storage = new Selection[1] --- in memory.heap catch failure:
        owned.release()
        error(failure.code, failure.message)
    storage[0] = Selection(owned, elements, domain, topology, report, active)
    return try interop.Reference[Selection].adopt(storage.data, selection_type, memory.heap)

## The bits of a selection, for Base kernels (verbs, overlays).
pub func selection_bits(selection: const Selection*) -> Bits:
    return selection.view()

## What a verb's group names (a node's Group Type): its domain, or a guess
## from the expression. Corners are Houdini's vertices.
pub enum GroupType as u8:
    guess = 0
    points = 1
    edges = 2
    faces = 3
    corners = 4

    ## A Group Type menu's value (0..4).
    pub static func of(value: i64) -> GroupType!:
        if value < 0 or value > 4: error(errors.invalid, "a group type is 0 (guess), 1 (points), 2 (edges), 3 (faces) or 4 (corners)")
        return GroupType((u8)value)

    ## The mesh domain this names; `fallback` when it is a guess.
    pub func domain(fallback: Domain) -> Domain:
        match self:
            .guess: return fallback
            .points: return Domain.point
            .edges: return Domain.edge
            .faces: return Domain.face
            _: return Domain.corner

pub func domain_of(value: i64) -> Domain!:
    if value < 0 or value > 4 or value == 3: error(errors.invalid, "a selection is of points (0), corners (1), faces (2) or edges (4)")
    return Domain((u8)value)

## Group expressions from Luce, beyond selections.
pub struct Groups:
    let reserved: u8 = 0

    ## "" when `expression` parses, else the error, with its byte offset.
    pub static func check(expression: str) -> interop.Owned[str]!:
        var program = GroupProgram.parse(expression) catch failure:
            return try interop.copy_text(failure.message)
        program.close()
        return interop.Owned[str]("")

    ## A snapshot of `mesh` with group `name` holding what `expression`
    ## names on `domain` (the Group node).
    pub static func with_group(mesh: interop.Reference[Mesh], name: str, domain: i64, expression: str) -> interop.Reference[Mesh]!:
        let geometry = try mesh.get()
        let target = try domain_of(domain)
        var result = try group_bits(geometry, expression, target)
        defer result.bits.release()
        return try with_group_bits(geometry, name, target, Bits(result.bits.view(), (usize)(try geometry.domain_count(domain))))

    ## Elements `expression` names on `domain`.
    pub static func count(mesh: interop.Reference[Mesh], expression: str, domain: i64) -> i64!:
        let geometry = try mesh.get()
        var result = try group_bits(geometry, expression, try domain_of(domain))
        defer result.bits.release()
        return (i64)Bits(result.bits.view(), (usize)(try geometry.domain_count(domain))).population()