dymokomi/luce-geocore
Source of release 0.7.9
0.7.9 / src / groups / evaluate.lucb
## Running a group program on a mesh: every term to bits on the target
## domain, combined left to right. Ranges are word fills, names share their
## group's bits, `@` tests run over the elements in parallel, and edge forms,
## conversions and the functions use the topology caches (built only when a
## term needs them).
## What evaluation noticed without failing: numbers or point pairs that name
## no element (Houdini ignores them; nodes warn), group names that matched
## nothing, and names or attributes read from another domain and converted.
pub struct GroupReport:
pub var misses: usize = 0
pub var unknown_names: usize = 0
pub var converted: bool = false
## Whether a conversion to `destination` needs "all" related elements: a face is in
## a point or edge group when all its points or edges are; an edge when both
## its points are; a point or corner when any of its faces or edges is.
pub func strict_conversion(source: Domain, destination: Domain) -> bool:
if destination == Domain.face: return true
return destination == Domain.edge and source == Domain.point
## The domain an expression's names and attributes live on (Houdini's
## "guess from group"): that of its first named group or attribute, the edge
## domain for edge forms, else `fallback`.
pub func guess_domain(mesh: const Mesh*, text: str, fallback: Domain) -> Domain!:
var program = try GroupProgram.parse(text)
defer program.close()
var report = GroupReport()
let run = Evaluation(&program, mesh, none, &report)
return run.guess(program.top_first, program.top_count, fallback)
pub func evaluate(program: const GroupProgram*, mesh: const Mesh*, target: Domain, report: GroupReport*) -> BitsBuilder!:
var run = Evaluation(program, mesh, none, report)
return try run.terms(program.top_first, program.top_count, target)
struct Evaluation:
let program: const GroupProgram*
let mesh: const Mesh*
var topology: Topology?
let report: GroupReport*
func connectivity() -> Topology!:
if let known = self.topology: return known
let built = try Topology.of(self.mesh)
self.topology = built
return built
func size(domain: Domain) -> usize!:
return try self.mesh.domain_size(domain)
## Terms first..<first + count combined into bits of `target`.
func terms(first: u32, count: u32, target: Domain) -> BitsBuilder!:
var result = try BitsBuilder.zeros(try self.size(target))
errdefer result.close()
for index in first..<first + count:
let term = &self.program.terms.items[(usize)index]
var atom = try self.atom(term, target)
defer atom.close()
match term.combine:
.add: result.unite(atom.view())
.add_complement: result.unite_complement(atom.view())
.remove: result.subtract(atom.view())
_: result.intersect(atom.view())
return result
func atom(term: const Term*, target: Domain) -> BitsBuilder!:
let size = try self.size(target)
match term.kind:
.all: return try BitsBuilder.ones(size)
.range: return try self.range(term, target)
.name: return try self.name(self.program.text(term), target)
.names: return try self.terms(term.first, term.count, target)
.attribute: return try self.attribute(term, target)
.point_edges, .face_edge:
var edges = try self.edge_atom(term)
defer edges.close()
return try self.convert(edges.view(), Domain.edge, target, strict_conversion(Domain.edge, target))
_: return try self.call(term, target)
## Numbers name elements of the target; on edges they name faces, whose
## edges are taken (Houdini's edge groups).
func range(term: const Term*, target: Domain) -> BitsBuilder!:
let domain = Domain.face if target == Domain.edge else target
let size = try self.size(domain)
var bits = try BitsBuilder.zeros(size)
errdefer bits.close()
let numbers = self.program.numbers.view()[(usize)term.first..<(usize)(term.first + term.count)]
let first = numbers[0]
var last = numbers[1]
if last < 0.0: last = (f64)size - 1.0
let keep = (usize)numbers[2]
let step = (usize)numbers[3]
if last < first:
self.report.misses += 1
return try self.convert_owned(bits, domain, target)
let end = (usize)last + 1
if end > size: self.report.misses += (end - (usize)math.max(first, (f64)size) + step - 1) // step
if (usize)first < size: bits.set_stride((usize)first, end if end < size else size, keep, step)
return try self.convert_owned(bits, domain, target)
## `bits` of `source` as bits of `destination` (the builder is taken).
func convert_owned(bits: BitsBuilder, source: Domain, destination: Domain) -> BitsBuilder!:
var owned = bits
if source == destination: return owned
defer owned.close()
return try self.convert(owned.view(), source, destination, false)
func convert(bits: Bits, source: Domain, destination: Domain, all: bool) -> BitsBuilder!:
if source == destination: return try BitsBuilder.copy_of(bits)
let topology = try self.connectivity()
return try converted(&topology, bits, source, destination, all)
## Groups whose names match `pattern` on the target domain; when none
## does, the first domain where some do, converted.
func name(pattern: str, target: Domain) -> BitsBuilder!:
let order: Domain[5] = [target, Domain.point, Domain.face, Domain.edge, Domain.corner]
for at in 0..<order.length:
let domain = order[at]
if at > 0 and domain == target: continue
var bits = try BitsBuilder.zeros(try self.size(domain))
var found = false
for index in 0..<(usize)self.mesh.attribute_count():
let entry = try self.mesh.attribute_entry((i64)index)
if not entry.is_group() or entry.domain != domain or not glob(pattern, entry.name()): continue
bits.unite(Bits.of_bytes(entry.data.view(), entry.elements))
found = true
if not found:
bits.close()
continue
if domain != target: self.report.converted = true
defer bits.close()
return try self.convert(bits.view(), domain, target, strict_conversion(domain, target))
self.report.unknown_names += 1
return try BitsBuilder.zeros(try self.size(target))
## `@name[component] op values`: an attribute on the target domain, else
## on its own domain and converted (any element of a face, and so on).
func attribute(term: const Term*, target: Domain) -> BitsBuilder!:
let name = self.program.text(term)
var source = Source(kind = 0, domain = target)
if name == "ptnum": source = Source(kind = 1, domain = Domain.point)
elif name == "primnum": source = Source(kind = 1, domain = Domain.face)
elif name == "vtxnum": source = Source(kind = 1, domain = Domain.corner)
elif name == "elemnum" or name == "intrinsic:indexorder": source = Source(kind = 1, domain = target)
elif name == "P": source = Source(kind = 2, domain = Domain.point)
else:
let found = self.find_attribute(name, target)
if found >= 0:
let entry = try self.mesh.attribute_entry(found)
source = Source(kind = 3, domain = entry.domain, entry = entry)
elif name == "N":
source = Source(kind = 4, domain = Domain.face)
else:
error(errors.invalid, "group syntax: no such attribute")
# A detail value applies to every element of the target.
let domain = target if source.domain == Domain.detail else source.domain
var bits = try self.tested(term, &source, domain)
if domain == target: return bits
defer bits.close()
self.report.converted = self.report.converted or (source.kind != 1)
return try self.convert(bits.view(), domain, target, false)
## An attribute of `name` on the target domain, else point, face, corner,
## edge, detail; -1 when there is none.
func find_attribute(name: str, target: Domain) -> i64:
let order: Domain[6] = [target, Domain.point, Domain.face, Domain.corner, Domain.edge, Domain.detail]
for domain in order:
let found = self.mesh.attribute_on(name, domain)
if found >= 0: return found
return -1
## Elements of `domain` whose value passes the term's test, in parallel.
func tested(term: const Term*, source: const Source*, domain: Domain) -> BitsBuilder!:
let size = try self.size(domain)
var bits = try BitsBuilder.zeros(size)
errdefer bits.close()
if let entry = source.entry:
if entry.kind == DataType.text:
try self.test_text(term, entry, domain, &bits)
return bits
let component = (usize)(term.component if term.component >= 0 else 0)
if let entry = source.entry:
if component >= entry.width: error(errors.invalid, "group syntax: the attribute has fewer components")
elif source.kind == 2 or source.kind == 4:
if component >= 3: error(errors.invalid, "group syntax: the attribute has fewer components")
var work = TestWork(self.program.numbers.view()[(usize)term.first..<(usize)term.first + (usize)term.count * 2], term.compare, source.kind, component,
self.mesh.point_span(), self.mesh.position_origin(), self.mesh.face_normal_span(), source.entry, is_detail(source), bits.words(), size)
try parallel.for_each_range(work.words.length, 256, (void*)&work, test_words)
return bits
## Text attributes: `=` and `==` match any glob, `!=` none; no operator
## means a nonempty text.
func test_text(term: const Term*, entry: const Attribute*, domain: Domain, bits: BitsBuilder*) -> !:
let table = entry.table.view()
let hits = try new bool[table_count(table)] --- in memory.heap
defer free(hits) in memory.heap
for index in 0..<hits.length:
let text = table_text(table, index)
var hit = text.length > 0
if term.compare != Compare.exists:
hit = false
for span in term.spans_first..<term.spans_first + term.spans_count:
hit = hit or glob(self.program.span(span), text)
if term.compare == Compare.not_equal: hit = not hit
elif term.compare != Compare.equal: error(errors.invalid, "group syntax: text attributes compare with = or !=")
hits[index] = hit
let values = attribute_ops.typed[i32](entry.data.view())
let count = bits.count
for element in 0..<count:
let value = values[0 if entry.storage == Storage.single else element]
if value >= 0 and (usize)value < hits.length and hits[(usize)value]: bits.set(element)
## `p a`, `p a-b-c…` and `f e m` on the edge domain.
func edge_atom(term: const Term*) -> BitsBuilder!:
let topology = try self.connectivity()
var bits = try BitsBuilder.zeros(topology.edges())
errdefer bits.close()
let numbers = self.program.numbers.view()[(usize)term.first..<(usize)(term.first + term.count)]
if term.kind == AtomKind.face_edge:
let face = numbers[0]
let side = numbers[1]
if face >= (f64)topology.faces():
self.report.misses += 1
return bits
let start = (usize)topology.offsets[(usize)face]
let size = (usize)topology.offsets[(usize)face + 1] - start
if side >= (f64)size:
self.report.misses += 1
return bits
bits.set((usize)topology.corner_edges[start + (usize)side])
return bits
if numbers.length == 1:
let point = numbers[0]
if point >= (f64)topology.points:
self.report.misses += 1
return bits
for at in (usize)topology.point_edge_offsets[(usize)point]..<(usize)topology.point_edge_offsets[(usize)point + 1]:
bits.set((usize)topology.point_edges[at])
return bits
for at in 0..<numbers.length - 1:
let edge = try self.mesh.find_edge((i64)numbers[at], (i64)numbers[at + 1])
if edge < 0: self.report.misses += 1
else: bits.set((usize)edge)
return bits
## A function: convert, or a select rule run on the argument group
## (evaluated on the target domain when the rule takes it, else on the
## rule's first level) and converted to the target.
func call(term: const Term*, target: Domain) -> BitsBuilder!:
if term.function == Function.convert:
let domain = self.guess(term.first, term.count, target)
var inner = try self.terms(term.first, term.count, domain)
defer inner.close()
return try self.convert(inner.view(), domain, target, term.argument == 0.0)
if term.rule < 0: error(errors.invalid, "group syntax: this function has no polygon rule")
let rule = rule_at((usize)term.rule)
let domain = target if rule.takes(target) else rule.first_domain()
var inner = try self.terms(term.first, term.count, domain)
defer inner.close()
let numbers = self.program.numbers.view()[(usize)term.args_first..<(usize)(term.args_first + term.args_count)]
var made = try run_rule(&rule, self.mesh, inner.view(), domain, numbers)
defer made.bits.close()
return try self.convert(made.bits.view(), made.domain, target, strict_conversion(made.domain, target))
## The domain the first named group or attribute of some terms lives on.
func guess(first: u32, count: u32, fallback: Domain) -> Domain:
for index in first..<first + count:
let term = &self.program.terms.items[(usize)index]
if term.kind == AtomKind.name:
for at in 0..<(usize)self.mesh.attribute_count():
let entry = self.mesh.attribute_entry((i64)at) catch failure: return fallback
if entry.is_group() and glob(self.program.text(term), entry.name()): return entry.domain
elif term.kind == AtomKind.attribute:
let found = self.find_attribute(self.program.text(term), fallback)
if found >= 0:
let entry = self.mesh.attribute_entry(found) catch failure: return fallback
return entry.domain
elif term.kind == AtomKind.point_edges or term.kind == AtomKind.face_edge:
return Domain.edge
return fallback
func is_detail(source: const Source*) -> bool:
let entry = source.entry else return false
return entry.domain == Domain.detail
## Where a test reads its values: 0 unused, 1 element numbers, 2 positions,
## 3 an attribute, 4 face normals.
struct Source:
let kind: u8
let domain: Domain
let entry: const Attribute*? = none
struct TestWork:
let values: const f64[]
let compare: Compare
let kind: u8
let component: usize
let positions: const Float3[]
let origin: Vector3
let normals: const Float3[]
let entry: const Attribute*?
## One value (a detail attribute) for every element.
let single: bool
let words: u64[]
let count: usize
func test_words(context: void*, first: usize, end: usize, worker: usize):
let work = (TestWork*)context
for word in first..<end:
var bits: u64 = 0
let stop = word * 64 + 64 if work.count > word * 64 + 64 else work.count
for element in word * 64..<stop:
if work.compare.passes(work.values, value_of(work, 0 if work.single else element)):
bits = bits | ((u64)1 << (u64)(element & 63))
work.words[word] = bits
func value_of(work: const TestWork*, element: usize) -> f64:
match work.kind:
1: return (f64)element
2:
let p = work.positions[element]
let c = work.component
return (f64)p.x + work.origin.x if c == 0 else ((f64)p.y + work.origin.y if c == 1 else (f64)p.z + work.origin.z)
4:
let n = work.normals[element]
return (f64)n.x if work.component == 0 else ((f64)n.y if work.component == 1 else (f64)n.z)
_:
let entry = work.entry else return 0.0
return entry.number(element, work.component)