Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.4

0.7.4 / src / geometries / polygon / groups.lucb

## Groups and text attributes. A group is a flagged boolean attribute on the
## point, corner, face or edge domain; adding one shares every other column.
## Edges are numbered by connectivity alone, so an edge group is exact while
## the topology is; its durable form is the sorted point pairs of its edges,
## which survive a re-derivation of the edges (`edge_pairs`,
## `edge_bits_from_pairs`).

extend Mesh:
    ## Whether attribute `index` is a group.
    pub func attribute_group(index: i64) -> bool!:
        try checked(index, self.attributes.count())
        return self.attributes.entry((usize)index).is_group()

    ## The text of `element` of text attribute `index` ("" for other kinds).
    pub func attribute_text(index: i64, element: i64) -> str!:
        try checked(index, self.attributes.count())
        let entry = self.attributes.entry((usize)index)
        try checked(element, (try self.domain_size(entry.domain)))
        return entry.text_at((usize)element)

    ## The distinct strings of text attribute `index`, and string `at`.
    pub func attribute_string_count(index: i64) -> i64!:
        try checked(index, self.attributes.count())
        return (i64)table_count(self.attributes.entry((usize)index).table.view())

    pub func attribute_string(index: i64, at: i64) -> str!:
        try checked(index, self.attributes.count())
        let table = self.attributes.entry((usize)index).table.view()
        try checked(at, table_count(table))
        return table_text(table, (usize)at)

    ## A snapshot with group `name` on `domain` whose members are `members`.
    pub func with_group(name: str, domain: i64, members: const i64[]) -> interop.Reference[Mesh]!:
        let count = try self.domain_count(domain)
        var bits = try BitsBuilder.zeros((usize)count)
        defer bits.close()
        for member in members:
            try checked(member, (usize)count)
            bits.set((usize)member)
        return try self.with_attribute_entry(try Attribute.group_of(name, Domain((u8)domain), (usize)count, bits.view().words))

    ## One text value for a whole domain (single storage, O(1)).
    pub func with_text(name: str, domain: i64, value: str) -> interop.Reference[Mesh]!:
        let count = try self.domain_count(domain)
        var table = TableBuilder()
        defer table.close()
        let index: i32[1] = [try table.intern(value)]
        var column = try table.finish()
        defer column.release()
        return try self.with_attribute_entry(try Attribute.text(name, Domain((u8)domain), (usize)count, column, index, Storage.single))

    ## A text attribute: element i is line `values[i]` of `lines` (strings
    ## separated by newlines), or "" for -1.
    pub func with_text_values(name: str, domain: i64, lines: str, values: const i64[]) -> interop.Reference[Mesh]!:
        let count = (usize)(try self.domain_count(domain))
        if values.length != count: error(errors.invalid, "text values must cover their domain")
        var table = TableBuilder()
        defer table.close()
        var start: usize = 0
        let bytes = lines.bytes
        for at in 0..<bytes.length + 1:
            if at == bytes.length or bytes[at] == 10:
                _ = try table.intern((str)bytes[start..<at])
                start = at + 1
        let indices = try new i32[count] --- in memory.heap
        defer free(indices) in memory.heap
        for at in 0..<count:
            let value = values[at]
            if value < -1 or value >= (i64)table.count(): error(errors.invalid, "text value names no line")
            indices[at] = (i32)value
        var column = try table.finish()
        defer column.release()
        return try self.with_attribute_entry(try Attribute.text(name, Domain((u8)domain), count, column, indices))

    ## Members of group `name` on `domain`, or -1 when there is no such group.
    pub func group_size(name: str, domain: i64) -> i64:
        let index = self.find_attribute(name, domain)
        if index < 0 or not self.attributes.entry((usize)index).is_group(): return -1
        let entry = self.attributes.entry((usize)index)
        return (i64)Bits.of_bytes(entry.data.view(), entry.elements).population()

    ## The edge between points `a` and `b`, or -1.
    pub func find_edge(a: i64, b: i64) -> i64!:
        let points = self.positions.count()
        if a < 0 or b < 0 or (usize)a >= points or (usize)b >= points: return -1
        let edges = try self.edge_arrays()
        let incidence = try self.incidence()
        return edge_between(self.offsets.view(), self.corners.view(), edges.1, incidence.0, incidence.1, (i32)a, (i32)b)

## The bits of group attribute `index`, for Base kernels.
pub func group_bits(mesh: const Mesh*, index: i64) -> Bits!:
    let entry = try mesh.attribute_entry(index)
    if entry.kind != DataType.boolean: error(errors.invalid, "a group is a boolean attribute")
    return Bits.of_bytes(entry.data.view(), entry.elements)

## A snapshot of `mesh` with group `name` on `domain` holding `bits`.
pub func with_group_bits(mesh: const Mesh*, name: str, domain: Domain, bits: Bits) -> interop.Reference[Mesh]!:
    let count = try mesh.domain_size(domain)
    if bits.count != count: error(errors.invalid, "group bits must cover their domain")
    return try mesh.with_attribute_entry(try Attribute.group_of(name, domain, count, bits.words))

## The edge of points a and b: a corner at `a` whose next or previous corner
## is at `b` names it. -1 when they share no edge.
func edge_between(offsets: const i32[], corners: const i32[], corner_edges: const i32[], face_starts: const i32[], point_faces: const i32[], a: i32, b: i32) -> i64:
    for at in (usize)face_starts[(usize)a]..<(usize)face_starts[(usize)a + 1]:
        let face = (usize)point_faces[at]
        let start = (usize)offsets[face]
        let end = (usize)offsets[face + 1]
        for corner in start..<end:
            if corners[corner] != a: continue
            let next = corner + 1 if corner + 1 < end else start
            if corners[next] == b: return (i64)corner_edges[corner]
            let previous = corner - 1 if corner > start else end - 1
            if corners[previous] == b: return (i64)corner_edges[previous]
    return -1

## The durable form of edge bits: a (low, high) point pair per member edge,
## in edge order, appended to `out`.
pub func edge_pairs(mesh: const Mesh*, edges: Bits, out: Growing[i32]*) -> !:
    let points = (try mesh.edge_arrays()).0
    if edges.count != points.length // 2: error(errors.invalid, "edge bits must cover the mesh's edges")
    try out.reserve(out.count + edges.population() * 2)
    for word in 0..<edges.words.length:
        var bits = edges.words[word]
        while bits != 0:
            let edge = word * 64 + (usize)trailing_zeros(bits)
            out.items[out.count] = points[edge * 2]
            out.items[out.count + 1] = points[edge * 2 + 1]
            out.count += 2
            bits = bits & (bits - 1)

## Set the bits of the edges named by point pairs; pairs that match no edge
## (the points were renumbered) are counted and returned.
pub func edge_bits_from_pairs(mesh: const Mesh*, pairs: const i32[], out: BitsBuilder*) -> usize!:
    let edges = try mesh.edge_arrays()
    let incidence = try mesh.incidence()
    if out.count != edges.0.length // 2: error(errors.invalid, "edge bits must cover the mesh's edges")
    let points = (i32)mesh.positions.count()
    var misses: usize = 0
    for at in 0..<pairs.length // 2:
        let a = pairs[at * 2]
        let b = pairs[at * 2 + 1]
        let edge = -1 if a < 0 or b < 0 or a >= points or b >= points else edge_between(mesh.offsets.view(), mesh.corners.view(), edges.1, incidence.0, incidence.1, a, b)
        if edge < 0: misses += 1
        else: out.set((usize)edge)
    return misses