dymokomi/luce-geocore
Source of release 0.7.6
0.7.6 / src / curves / groups.lucb
## The group language on curves: the same programs (groups/program.lucb)
## evaluated over curve points and curves (the primitive domain). Numbers,
## names, `@` tests and name filters work as on meshes; conversions go
## point -> curve when all its points are members, curve -> point for every
## point of a member curve. grow and shrink walk along curves, border is the
## ends of each run of members, connected takes whole curves. Edge forms and
## loop/ring have no meaning on curves and fail.
## Bits of `target` (point or curve domain) selected by `text` on `curves`;
## empty text selects everything.
pub func curve_group_bits(curves: const Curves*, text: str, target: Domain, report: GroupReport*) -> BitsBuilder!:
if target != Domain.point and target != curve_domain: error(errors.invalid, "curve groups are point or primitive groups")
let size = curves.point_count() if target == Domain.point else curves.curve_count()
if is_blank(text): return try BitsBuilder.ones(size)
var program = try GroupProgram.parse(text)
defer program.close()
var run = CurveEvaluation(&program, curves, report)
return try run.terms(program.top_first, program.top_count, target)
## The domain an expression's first name or attribute lives on, else
## `fallback` (Houdini's "guess from group"). Blank text guesses nothing;
## text that does not parse is an error, as on meshes.
pub func guess_curve_domain(curves: const Curves*, text: str, fallback: Domain) -> Domain!:
if is_blank(text): return fallback
var program = try GroupProgram.parse(text)
defer program.close()
for index in program.top_first..<program.top_first + program.top_count:
let term = &program.terms.items[(usize)index]
if term.kind != AtomKind.name and term.kind != AtomKind.attribute: continue
let name = program.text(term)
if name == "ptnum" or name == "P": return Domain.point
if name == "primnum": return curve_domain
for at in 0..<curves.attributes.count():
let entry = curves.attributes.entry(at)
if entry.domain != Domain.point and entry.domain != curve_domain: continue
if term.kind == AtomKind.name and entry.is_group() and glob(name, entry.name()): return entry.domain
if term.kind == AtomKind.attribute and entry.name() == name: return entry.domain
return fallback
struct CurveEvaluation:
let program: const GroupProgram*
let curves: const Curves*
let report: GroupReport*
func size(domain: Domain) -> usize:
return self.curves.point_count() if domain == Domain.point else self.curves.curve_count()
func terms(first: u32, count: u32, target: Domain) -> BitsBuilder!:
var result = try BitsBuilder.zeros(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!:
match term.kind:
.all: return try BitsBuilder.ones(self.size(target))
.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: error(errors.invalid, "group syntax: curves have no edge groups")
_: return try self.call(term, target)
func range(term: const Term*, target: Domain) -> BitsBuilder!:
let size = self.size(target)
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 bits
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 bits
## Groups matching `pattern` on the target, else on the other domain,
## converted.
func name(pattern: str, target: Domain) -> BitsBuilder!:
let order: Domain[2] = [target, Domain.point if target == curve_domain else curve_domain]
for domain in order:
var bits = try BitsBuilder.zeros(self.size(domain))
var found = false
for index in 0..<self.curves.attributes.count():
let entry = self.curves.attributes.entry(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: return bits
defer bits.close()
self.report.converted = true
return try convert_curve_bits(self.curves, bits.view(), domain, target)
self.report.unknown_names += 1
return try BitsBuilder.zeros(self.size(target))
## `@name op values` on the target, else on the attribute's own domain,
## converted. `@ptnum`, `@primnum`, `@elemnum` and `@P` are built in.
func attribute(term: const Term*, target: Domain) -> BitsBuilder!:
let name = self.program.text(term)
var kind: u8 = 3
var domain = target
var entry: const Attribute*? = none
if name == "ptnum":
kind = 1
domain = Domain.point
elif name == "primnum":
kind = 1
domain = curve_domain
elif name == "elemnum" or name == "intrinsic:indexorder":
kind = 1
elif name == "P":
kind = 2
domain = Domain.point
else:
let order: Domain[3] = [target, Domain.point if target == curve_domain else curve_domain, Domain.detail]
for candidate in order:
if let found = self.curves.find(name, candidate):
if entry == none:
entry = found
domain = target if candidate == Domain.detail else candidate
if entry == none: error(errors.invalid, "group syntax: no such attribute")
var bits = try self.tested(term, kind, entry, domain)
if domain == target: return bits
defer bits.close()
self.report.converted = self.report.converted or kind != 1
return try convert_curve_bits(self.curves, bits.view(), domain, target)
func tested(term: const Term*, kind: u8, entry: const Attribute*?, domain: Domain) -> BitsBuilder!:
let size = self.size(domain)
var bits = try BitsBuilder.zeros(size)
errdefer bits.close()
let component = (usize)(term.component if term.component >= 0 else 0)
if let attribute = entry:
if attribute.kind == DataType.text:
for element in 0..<size:
let text = attribute.text_at(element)
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
if hit: bits.set(element)
return bits
if component >= attribute.width: error(errors.invalid, "group syntax: the attribute has fewer components")
elif kind == 2 and component >= 3:
error(errors.invalid, "group syntax: the attribute has fewer components")
let values = self.program.numbers.view()[(usize)term.first..<(usize)term.first + (usize)term.count * 2]
let positions = self.curves.positions.view()
for element in 0..<size:
var value = (f64)element
if kind == 2:
let p = positions[element]
value = (f64)p.x + self.curves.origin.x if component == 0 else ((f64)p.y + self.curves.origin.y if component == 1 else (f64)p.z + self.curves.origin.z)
elif kind == 3:
let attribute = entry else trap("attribute")
value = attribute.number(0 if attribute.storage == Storage.single or attribute.domain == Domain.detail else element, component)
if term.compare.passes(values, value): bits.set(element)
return bits
func call(term: const Term*, target: Domain) -> BitsBuilder!:
let steps = (usize)math.max(0.0, term.argument)
match term.function:
.loop, .ring: error(errors.invalid, "group syntax: loop and ring need polygon edges")
.convert:
var inner = try self.terms(term.first, term.count, target)
return inner
_:
var inner = try self.terms(term.first, term.count, Domain.point)
defer inner.close()
var walked = try BitsBuilder.copy_of(inner.view())
defer walked.close()
match term.function:
.grow:
for step in 0..<steps: try step_along(self.curves, &walked, true)
.shrink:
for step in 0..<steps: try step_along(self.curves, &walked, false)
.border: try border_points(self.curves, &walked)
_:
var whole = try convert_curve_bits(self.curves, walked.view(), Domain.point, curve_domain, false)
defer whole.close()
walked.close()
walked = try convert_curve_bits(self.curves, whole.view(), curve_domain, Domain.point)
if target == Domain.point: return try BitsBuilder.copy_of(walked.view())
return try convert_curve_bits(self.curves, walked.view(), Domain.point, target)
## Point bits as curve bits (a curve when all its points are members, or any
## when not `all`), or curve bits as the bits of their points.
pub func convert_curve_bits(curves: const Curves*, bits: Bits, source: Domain, destination: Domain, all: bool = true) -> BitsBuilder!:
if source == destination: return try BitsBuilder.copy_of(bits)
let count = curves.curve_count()
if source == Domain.point:
var result = try BitsBuilder.zeros(count)
errdefer result.close()
for curve in 0..<count:
let (first, size) = curves.range(curve)
var every = size > 0
var some = false
for at in first..<first + size:
let member = bits.get(at)
every = every and member
some = some or member
if (every if all else some): result.set(curve)
return result
var result = try BitsBuilder.zeros(curves.point_count())
errdefer result.close()
for curve in 0..<count:
if not bits.get(curve): continue
let (first, size) = curves.range(curve)
result.set_range(first, first + size)
return result
## One step of grow (members' neighbors along the curve join) or shrink
## (members with a non-member or missing neighbor leave).
func step_along(curves: const Curves*, bits: BitsBuilder*, grow: bool) -> !:
var before = try BitsBuilder.copy_of(bits.view())
defer before.close()
for curve in 0..<curves.curve_count():
let (first, size) = curves.range(curve)
let cyclic = curves.settings(curve).cyclic
for at in 0..<size:
let previous = (at + size - 1) % size if cyclic or at > 0 else size
let next = (at + 1) % size if cyclic or at + 1 < size else size
let here = before.view().get(first + at)
let left = previous < size and before.view().get(first + previous)
let right = next < size and before.view().get(first + next)
if grow and not here and (left or right): bits.set(first + at)
if not grow and here and not (left and right): bits.clear(first + at)
## Members with a non-member or missing neighbor: the ends of each run.
func border_points(curves: const Curves*, bits: BitsBuilder*) -> !:
var inner = try BitsBuilder.copy_of(bits.view())
defer inner.close()
try step_along(curves, &inner, false)
bits.subtract(inner.view())