Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.9

0.7.9 / src / set_verbs / attributes.lucb

## Attribute nodes on the components meshes do not cover: curves (points,
## vertices as points, primitives as curves, detail) and point clouds
## (points and detail), and Blast or Delete on point clouds. A cloud's group
## expressions are read through a mesh of its points (`cloud_group_bits`),
## so numbers, names, `@` tests and `@P` mean what they mean on a mesh. luced-3d runs the mesh kernels on the mesh and these
## on the rest, so an attribute node acts on every component with the
## domain. Domains are the node's menu values: 0 points, 1 vertices,
## 2 primitives, 3 detail.

pub struct SetAttributes:
    let reserved: u8 = 0

    ## Whether the set has curves or a point cloud of its own.
    pub static func present(geometry: interop.Reference[GeometrySet]) -> bool!:
        let set = try geometry.get()
        return set_curves(set) != none or set.find(&points_component) != none

    ## Whether the set's curves (or else point cloud) have attribute `name`
    ## on `domain` (0 points, 2 curves, 3 detail).
    pub static func has(geometry: interop.Reference[GeometrySet], name: str, domain: i64) -> bool!:
        let set = try geometry.get()
        let wanted = Domain.point if domain == 0 or domain == 1 else (curve_domain if domain == 2 else Domain.detail)
        if let lines = set_curves(set): return lines.find(name, wanted) != none
        if let data = set.find(&points_component): return cloud_store((const PointCloud*)data).find(name, wanted) >= 0
        return false

    ## `name` = `values` (1..4 components) on `domain`, optionally scaled per
    ## element by the mesh kernel's deterministic hash of the element id.
    pub static func filled(geometry: interop.Reference[GeometrySet], name: str, domain: i64, values: const f64[], integer: bool, randomize: bool, seed: f64) -> interop.Reference[GeometrySet]!:
        let edit = AttributeEdit(0, name, "", domain, values, integer, randomize, seed, "")
        return try adopt_set(try edited(try geometry.get(), &edit))

    ## Without attribute `name` on `domain`.
    pub static func removed(geometry: interop.Reference[GeometrySet], name: str, domain: i64) -> interop.Reference[GeometrySet]!:
        var none_values: f64[]
        let edit = AttributeEdit(1, name, "", domain, none_values, false, false, 0.0, "")
        return try adopt_set(try edited(try geometry.get(), &edit))

    ## Attribute `name` on `domain` called `replacement`.
    pub static func renamed(geometry: interop.Reference[GeometrySet], name: str, replacement: str, domain: i64) -> interop.Reference[GeometrySet]!:
        var none_values: f64[]
        let edit = AttributeEdit(2, name, replacement, domain, none_values, false, false, 0.0, "")
        return try adopt_set(try edited(try geometry.get(), &edit))

    ## A group `name` of the curves' elements `expression` selects on
    ## `domain` (0 points, 2 curves; menu value 4 edges does not apply).
    pub static func grouped(geometry: interop.Reference[GeometrySet], name: str, domain: i64, expression: str) -> interop.Reference[GeometrySet]!:
        var none_values: f64[]
        let edit = AttributeEdit(3, name, "", domain, none_values, false, false, 0.0, expression)
        return try adopt_set(try edited(try geometry.get(), &edit))

    ## Attribute `name` moved from `domain` to `target` (0 points, 3 detail) on the
    ## point cloud: to the detail as the points' mean (an integer takes the first
    ## point's), to the points as the detail's value. Curves pass through.
    pub static func promoted(geometry: interop.Reference[GeometrySet], name: str, domain: i64, target: i64) -> interop.Reference[GeometrySet]!:
        var none_values: f64[]
        let edit = AttributeEdit(4, name, "", domain, none_values, false, false, (f64)target, "")
        return try adopt_set(try edited(try geometry.get(), &edit))

    ## The set without the point cloud's points `expression` selects (blank: all of
    ## them), or with only those when `keep`.
    pub static func deleted(geometry: interop.Reference[GeometrySet], expression: str, keep: bool) -> interop.Reference[GeometrySet]!:
        return try adopt_set(try without_points(try geometry.get(), expression, keep))

## A copy of `set` whose point cloud keeps the points `expression` does not
## select (or, with `keep`, only those it does).
func without_points(set: const GeometrySet*, expression: str, keep: bool) -> GeometrySet*!:
    let storage = try set.storage()
    errdefer dispose_set(storage)
    let data = set.find(&points_component) else return storage
    let cloud = (const PointCloud*)data
    var report = GroupReport()
    var bits = try cloud_group_bits(cloud, expression, &report)
    defer bits.close()
    if not keep: bits.invert()
    try storage.put(&points_component, (void*)(try cloud_subset(cloud, bits.view())))
    return storage

## Bits over `cloud`'s points that group expression `text` selects (blank: every
## point), evaluated on a mesh of its points; misses add to `report`.
pub func cloud_group_bits(cloud: const PointCloud*, text: str, report: GroupReport*) -> BitsBuilder!:
    if is_blank(text): return try BitsBuilder.ones(cloud.count())
    let mesh = try cloud_mesh(cloud)
    defer mesh_dispose(mesh)
    var result = try group_bits(mesh, text, Domain.point)
    defer result.bits.release()
    report.misses += result.report.misses
    report.unknown_names += result.report.unknown_names
    return try BitsBuilder.copy_of(Bits(result.bits.view(), cloud.count()))

## One attribute edit: 0 fill, 1 remove, 2 rename, 3 group, 4 promote (the
## target domain in `seed`).
struct AttributeEdit:
    let kind: u8
    let name: str
    let replacement: str
    let domain: i64
    let values: const f64[]
    let integer: bool
    let randomize: bool
    let seed: f64
    let expression: str

## A copy of `set` with the edit applied to its curves and point cloud.
func edited(set: const GeometrySet*, edit: const AttributeEdit*) -> GeometrySet*!:
    let storage = try set.storage()
    errdefer dispose_set(storage)
    # Promotion is for clouds: curves pass through.
    let curve_part: const Curves*? = set_curves(set) if edit.kind != 4 else none
    if let found_curves = curve_part:
        let lines = found_curves
        # Curve vertices are their points; primitives are curves.
        let domain = Domain.point if edit.domain == 0 or edit.domain == 1 else (curve_domain if edit.domain == 2 else Domain.detail)
        let sizes: usize[3] = [lines.point_count(), lines.curve_count(), 1]
        let size = sizes[0 if domain == Domain.point else (1 if domain == curve_domain else 2)]
        var store = try lines.store().shared()
        errdefer store.close()
        if edit.kind == 3:
            var report = GroupReport()
            var bits = try curve_group_bits(lines, edit.expression if edit.expression.length > 0 else "*", domain, &report)
            defer bits.close()
            try store.put(try Attribute.group_of(edit.name, domain, size, bits.view().words))
        else:
            try apply_edit(&store, edit, domain, size)
        let handed = store
        store = AttributeStore()
        try storage.put(curves_type(), (void*)(try curves_with_store(lines, handed)))
    if let data = set.find(&points_component):
        let cloud = (const PointCloud*)data
        if edit.domain == 0 or (edit.domain == 3 and edit.kind != 3):
            let domain = Domain.point if edit.domain == 0 else Domain.detail
            let count = cloud_positions(cloud).length
            var store = try cloud_store(cloud).shared()
            errdefer store.close()
            if edit.kind == 3:
                var report = GroupReport()
                var bits = try cloud_group_bits(cloud, edit.expression, &report)
                defer bits.close()
                try store.put(try Attribute.group_of(edit.name, Domain.point, count, bits.view().words))
            elif edit.kind == 4:
                try promote(&store, edit.name, domain, Domain.point if edit.seed == 0.0 else Domain.detail, count)
            else:
                try apply_edit(&store, edit, domain, count if domain == Domain.point else 1)
            let handed = store
            store = AttributeStore()
            try storage.put(&points_component, (void*)(try cloud_with_store(cloud, handed)))
    return storage

func apply_edit(store: AttributeStore*, edit: const AttributeEdit*, domain: Domain, size: usize) -> !:
    let found = store.find(edit.name, domain)
    match edit.kind:
        1:
            if found >= 0: store.remove((usize)found)
        2:
            if found < 0: return
            let renamed = try store.entry((usize)found).renamed(edit.replacement)
            store.remove((usize)found)
            try store.put(renamed)
        _:
            let width = edit.values.length
            if width < 1 or width > 4: error(errors.invalid, "an attribute value has 1..4 components")
            if not edit.randomize:
                var rounded: f64[4]
                for component in 0..<width:
                    rounded[component] = math.floor(edit.values[component]) if edit.integer else edit.values[component]
                var attribute = try Attribute.from_numbers(edit.name, domain, width, rounded[..<width], edit.integer, Storage.single)
                attribute.elements = size
                try store.put(attribute)
                return
            let generated = try new f64[size * width] --- in memory.heap
            defer free(generated) in memory.heap
            for id in 0..<size:
                for component in 0..<width:
                    let random = math.sin((f64)(id * 7 + component) * 12.9898 + edit.seed * 78.233) * 43758.5453
                    let value = edit.values[component] * (random - math.floor(random))
                    generated[id * width + component] = math.floor(value) if edit.integer else value
            try store.put(try Attribute.from_numbers(edit.name, domain, width, generated, edit.integer))

## Move `name` from `domain` to `target` (point or detail) within a cloud's
## store of `count` points: the points' mean (an integer: the first point's) or the
## detail's value on every point. Text and array attributes stay where they are.
func promote(store: AttributeStore*, name: str, domain: Domain, target: Domain, count: usize) -> !:
    if domain == target: return
    let found = store.find(name, domain)
    if found < 0: error(errors.invalid, "attribute to promote does not exist")
    let source = store.entry((usize)found)
    if source.kind == DataType.text or source.is_ragged(): error(errors.invalid, "text and array attributes are not promoted on point clouds")
    let width = source.width
    var values: f64[4]
    let integer = source.integer()
    if target == Domain.detail:
        for component in 0..<width:
            if integer:
                values[component] = source.number(0, component) if count > 0 else 0.0
                continue
            var total: f64 = 0.0
            for element in 0..<count: total += source.number(element, component)
            values[component] = total / (f64)count if count > 0 else 0.0
        var made = try Attribute.from_numbers(name, Domain.detail, width, values[..<width], integer)
        made.role = source.role
        store.remove((usize)found)
        try store.put(made)
        return
    for component in 0..<width: values[component] = source.number(0, component)
    var made = try Attribute.from_numbers(name, Domain.point, width, values[..<width], integer, Storage.single)
    made.elements = count
    made.role = source.role
    store.remove((usize)found)
    try store.put(made)