dymokomi/luce-geocore
Source of release 0.7.4
0.7.4 / 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)