dymokomi/luced-3d
Source of release 0.11.2
0.11.2 / src / sheet_rows.lucb
## Geometry spreadsheet rows kept in Base. Unfiltered rows are an identity
## range with no storage; a permutation exists only for a filter or a sort,
## and is sorted when the sort changes, not on every refresh. A Luce list of
## a CAD mesh's 707k rows and its merge sort cost 313 ms per click.
import interop
import memory
import ownership
from luce_geocore.geocore import Mesh
from luce_geocore.kernel import group_bits_of, Domain, popcount, Selection, selection_bits, trailing_zeros
from luce_3d.graphics import invalid
pub struct SheetRows:
var order: i64[]
var total: usize = 0
var identity: bool = true
var source: interop.Reference[Mesh]?
pub func init():
var empty: i64[]
self.order = empty
self.total = 0
self.identity = true
self.source = none
pub func count() -> i64:
return (i64)self.total
pub func row(at: i64) -> i64!:
if at < 0 or (usize)at >= self.total: error(invalid, "spreadsheet row is out of range")
return at if self.identity else self.order[(usize)at]
## True when `mesh` differs from the mesh these rows were built for. The
## previous mesh stays retained, so its address cannot be reused meanwhile.
pub func retarget(mesh: interop.Reference[Mesh]?) -> bool!:
var changed = false
if let next = mesh:
if let current = self.source:
changed = current.value() != (try next.get())
else:
changed = true
if changed:
if let current = self.source: current.release()
self.source = next.clone()
elif let current = self.source:
current.release()
self.source = none
changed = true
return changed
## Every row, in ID order.
pub func all(count: i64):
self.identity = true
self.total = (usize)count
## The rows a group expression names (luce-geocore's group language).
pub func select(mesh: interop.Reference[Mesh], expression: str, domain: i64) -> !:
let geometry = try mesh.get()
if domain < 0 or domain > 4: error(invalid, "unknown spreadsheet domain")
var result = try group_bits_of(geometry, expression, Domain((u8)domain))
defer result.bits.release()
let words = result.bits.view()
let count = (usize)(try geometry.domain_count(domain))
var total: usize = 0
for word in words: total += (usize)popcount(word)
try self.reserve(total)
self.identity = false
self.total = 0
for element in 0..<count:
if (words[element >> 6] >> (u64)(element & 63)) & 1 != 0:
self.order[self.total] = (i64)element
self.total += 1
## The rows of `selection` (on `domain`) that `expression` also names
## ("" or "*": every selected row), in ID order.
pub func selected(mesh: interop.Reference[Mesh], selection: interop.Reference[Selection], expression: str, domain: i64) -> !:
let geometry = try mesh.get()
if domain < 0 or domain > 4: error(invalid, "unknown spreadsheet domain")
let chosen = selection_bits(try selection.get()).words
var result = try group_bits_of(geometry, expression if expression != "" else "*", Domain((u8)domain))
defer result.bits.release()
let named = result.bits.view()
let words = chosen.length if chosen.length < named.length else named.length
var total: usize = 0
for word in 0..<words: total += (usize)popcount(chosen[word] & named[word])
try self.reserve(total)
self.identity = false
self.total = 0
for word in 0..<words:
var pending = chosen[word] & named[word]
while pending != 0:
self.order[self.total] = (i64)(word * 64 + (usize)trailing_zeros(pending))
self.total += 1
pending = pending & (pending - 1)
## Rows whose value of `attribute` (component 0) is nonzero: `@name` groups.
pub func nonzero(mesh: interop.Reference[Mesh], domain: i64, attribute: i64) -> !:
let geometry = try mesh.get()
let count = (usize)(try geometry.domain_count(domain))
try self.reserve(count)
self.identity = false
self.total = 0
for id in 0..<count:
if (try geometry.attribute_value(attribute, (i64)id)) != 0.0:
self.order[self.total] = (i64)id
self.total += 1
## Stable sort by a column; attribute -1 is a built-in column, and
## `by_id` sorts by the row ID itself.
pub func sort(mesh: interop.Reference[Mesh], domain: i64, attribute: i64, component: i64, by_id: bool, descending: bool) -> !:
if by_id and not descending and self.identity: return
let geometry = try mesh.get()
let count = self.total
if self.identity:
try self.reserve(count)
for at in 0..<count: self.order[at] = (i64)at
self.identity = false
let keys = try new f64[count * 2] --- in memory.heap
defer free(keys) in memory.heap
let scratch = try new i64[count] --- in memory.heap
defer free(scratch) in memory.heap
for at in 0..<count:
let row = self.order[at]
keys[at] = (f64)row if by_id else (try cell(geometry, domain, attribute, component, row))
# Bottom-up merge sort of (key, row) pairs; ties keep their order.
let rows = self.order[..<count]
let values = keys[..<count]
let spare = keys[count..<count * 2]
var width: usize = 1
var from_rows = rows
var from_keys = values
var to_rows = scratch
var to_keys = spare
while width < count:
var base: usize = 0
while base < count:
let middle = base + width if count - base > width else count
let end = middle + width if count - middle > width else count
var a = base
var b = middle
for out in base..<end:
let left = a < middle and (b >= end or (from_keys[a] >= from_keys[b] if descending else from_keys[a] <= from_keys[b]))
to_rows[out] = from_rows[a] if left else from_rows[b]
to_keys[out] = from_keys[a] if left else from_keys[b]
if left: a += 1
else: b += 1
base = end
let rows_swap = from_rows
from_rows = to_rows
to_rows = rows_swap
let keys_swap = from_keys
from_keys = to_keys
to_keys = keys_swap
width *= 2
if from_rows.data != rows.data: memory.copy(rows, from_rows, count)
func reserve(count: usize) -> !:
if count <= self.order.length: return
let grown = try new i64[count] --- in memory.heap
if self.order.length > 0: free(self.order) in memory.heap
self.order = grown
pub func close():
if self.order.length > 0: free(self.order) in memory.heap
var empty: i64[]
self.order = empty
self.total = 0
if let current = self.source: current.release()
self.source = none
func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
if let current = self.source: current.trace(visit, context)
pub let sheet_rows_type: interop.Type[SheetRows] = interop.Type[SheetRows]("SheetRows", SheetRows.close, SheetRows.trace, closeable = true, main_thread = true)
## One spreadsheet cell. Built-in columns: points P.x/P.y/P.z; vertices point,
## primitive; faces vertices, N.x/N.y/N.z; detail the four element counts.
pub func sheet_value(mesh: interop.Reference[Mesh], domain: i64, attribute: i64, component: i64, row: i64) -> f64!:
return try cell(try mesh.get(), domain, attribute, component, row)
func cell(mesh: const Mesh*, domain: i64, attribute: i64, component: i64, row: i64) -> f64!:
if attribute >= 0: return try mesh.attribute_value(attribute, row, component)
if domain == 0:
let point = try mesh.point(row)
return point.x if component == 0 else (point.y if component == 1 else point.z)
if domain == 1:
return (f64)(try mesh.corner_point(row) if component == 0 else try mesh.corner_face(row))
if domain == 2:
if component == 0: return (f64)(try mesh.face_size(row))
let normal = try mesh.face_normal(row)
return normal.x if component == 1 else (normal.y if component == 2 else normal.z)
let counts: i64[4] = [mesh.point_count(), mesh.vertex_count(), mesh.face_count(), (try mesh.edge_count())]
return (f64)counts[(usize)component]