dymokomi/luce-cad
Source of release 0.9.2
## Editing a set's CAD models through what the viewport picks on. The pick
## mesh is the models' display tessellations joined, each polygon tagged
## with its model (`cad_model`) and B-rep face (`cad_face`), each edge with
## the B-rep edge it lies on (`cad_edge`, -1 inside a face), that edge's
## model (`cad_edge_model`) and, for named models, its reference
## (`cad_edge_reference`); group expressions on it name what a step edits.
## Whole models move and go; faces go (a model losing every face goes with
## them); models are added or replaced (a feature on picked edges).
import interop
import memory
from luce_std import math
from luce_geocore.geocore import Mesh, Vector3, Matrix4, invalid, GeometrySet
from luce_geocore.core.growing import Growing
from luce_geocore.kernel import ComponentTransform, MeshPart, concatenated, group_bits_of, Domain, TableBuilder, text_attribute, append_text
from model import CadModel
from cad_geometry import set_models, with_models
from modeling import reference_lines
from luce_std import sort
## Luce's CAD editing operations (Edit CAD).
pub struct CadEdits:
let reserved: u8 = 0
## What Edit CAD's Object, Faces and Edges levels pick on (the models'
## kept display tessellations, so nothing is meshed again).
pub static func pick_mesh(set: interop.Reference[GeometrySet]) -> interop.Reference[Mesh]!:
let models = set_models(try set.get())
if models.length == 0: error(invalid, "the geometry has no CAD models")
var owners = Growing[interop.Reference[Mesh]]()
defer:
for owner in owners.view(): owner.release()
owners.close()
var parts = Growing[MeshPart]()
defer parts.close()
var owning = Growing[f64]()
defer owning.close()
for index in 0..<models.length:
let model = models[index].value()
let shown = try model.tessellate(16, 0.0, none, model.supports_curvature())
owners.push(shown) catch failure:
shown.release()
error(failure.code, failure.message)
try parts.push(MeshPart(shown.value(), Matrix4()))
for face in 0..<shown.value().face_count(): try owning.push((f64)index)
let joined = try concatenated(parts.view())
defer joined.release()
let tagged = try joined.value().with_attribute("cad_model", 2, 1, owning.view(), true)
defer tagged.release()
var edges = Growing[f64]()
defer edges.close()
var edge_models = Growing[i64]()
defer edge_models.close()
try edge_owners(tagged.value(), owning.view(), models, &edges, &edge_models)
let numbered = try tagged.value().with_attribute("cad_edge", 4, 1, edges.view(), true)
defer numbered.release()
var owners_of_edges = Growing[f64]()
defer owners_of_edges.close()
for model in edge_models.view(): try owners_of_edges.push((f64)model)
let owned = try numbered.value().with_attribute("cad_edge_model", 4, 1, owners_of_edges.view(), true)
let referenced = try with_references(owned, models, edges.view(), edge_models.view())
return try with_face_names(referenced, models, owning.view())
## `set` with the models `group` names on `pick` (whole models only)
## moved by Transform Components' numbers: translate, rotate (degrees),
## scale, pivot (0 their centroid, 1 the origin, 2 the custom point).
pub static func transformed_parts(set: interop.Reference[GeometrySet], pick: interop.Reference[Mesh], group: str, numbers: const f64[]) -> interop.Reference[GeometrySet]!:
let source = try set.get()
let models = set_models(source)
var chosen = try Chosen.of(try pick.get(), group, models)
defer chosen.close()
for index in 0..<models.length:
if chosen.faces.items[index] > 0 and chosen.faces.items[index] < chosen.totals.items[index]:
error(invalid, "only whole CAD models move: pick them at the Object level (faces move with their control vertices)")
let transform = try ComponentTransform.of(numbers, chosen.centroid)
let matrix = transform.matrix(transform.translation)
var result = Growing[interop.Reference[CadModel]]()
defer:
for model in result.view(): model.release()
result.close()
for index in 0..<models.length:
let next = (try models[index].value().placed(matrix)) if chosen.faces.items[index] > 0 else models[index].clone()
result.push(next) catch failure:
next.release()
error(failure.code, failure.message)
return try with_models(source, result.view())
## `set` without the faces `group` names on `pick`; a model left with
## none goes.
pub static func without_parts(set: interop.Reference[GeometrySet], pick: interop.Reference[Mesh], group: str) -> interop.Reference[GeometrySet]!:
let source = try set.get()
let models = set_models(source)
let mesh = try pick.get()
var chosen = try Chosen.of(mesh, group, models)
defer chosen.close()
var result = Growing[interop.Reference[CadModel]]()
defer:
for model in result.view(): model.release()
result.close()
var kept = Growing[i64]()
defer kept.close()
for index in 0..<models.length:
let model = models[index].value()
if chosen.faces.items[index] == 0:
try result.push(models[index].clone())
continue
kept.clear()
for face in 0..<model.face_count():
if not chosen.named(index, face): try kept.push(face)
if kept.count == 0: continue
let rest = try model.subset(kept.view())
result.push(rest) catch failure:
rest.release()
error(failure.code, failure.message)
return try with_models(source, result.view())
## The references of the B-rep edges of model `model` that edge group
## `group` of `pick` names, apart by `;` ("" when it names none of that
## model's): what a feature on picked edges (Fillet) takes.
pub static func model_edges(pick: interop.Reference[Mesh], group: str, model: i64) -> interop.Owned[str]!:
let mesh = try pick.get()
let owner = mesh.find_attribute("cad_edge_model", 4)
let texts = mesh.find_attribute("cad_edge_reference", 4)
if owner < 0: error(invalid, "the pick mesh lost its CAD tags")
if texts < 0: error(invalid, "these edges have no names to keep: they are on a model made without them")
var bits = try group_bits_of(mesh, group, Domain.edge)
defer bits.bits.release()
let words = bits.bits.view()
var joined = Growing[u8]()
defer joined.close()
var seen = Growing[str]()
defer seen.close()
for edge in 0..<(try mesh.edge_count()):
if (words[(usize)edge >> 6] >> (u64)((usize)edge & 63)) & 1 == 0: continue
if (i64)(try mesh.attribute_value(owner, edge)) != model: continue
let reference = try mesh.attribute_text(texts, edge)
if reference == "": continue
var known = false
for other in seen.view(): known = known or other == reference
if known: continue
try seen.push(reference)
if joined.count > 0: try append_text(&joined, ";")
try append_text(&joined, reference)
return try interop.copy_text((str)joined.view())
## `set` with model `index` replaced by `model`.
pub static func replaced(set: interop.Reference[GeometrySet], index: i64, model: interop.Reference[CadModel]) -> interop.Reference[GeometrySet]!:
let source = try set.get()
let models = set_models(source)
if index < 0 or index >= (i64)models.length: error(invalid, "no such CAD model")
var all = Growing[interop.Reference[CadModel]]()
defer all.close()
for at in 0..<models.length: try all.push(model if (i64)at == index else models[at])
return try with_models(source, all.view())
## `set` with `model` added after its models.
pub static func with_model(set: interop.Reference[GeometrySet], model: interop.Reference[CadModel]) -> interop.Reference[GeometrySet]!:
let source = try set.get()
let models = set_models(source)
var all = Growing[interop.Reference[CadModel]]()
defer all.close()
for existing in models: try all.push(existing)
try all.push(model)
return try with_models(source, all.view())
## What a face group names, per model: its polygons' models and B-rep faces.
struct Chosen:
## Selected polygons and all polygons, per model.
var faces: Growing[usize]
var totals: Growing[usize]
## (model, B-rep face) pairs named, as model * 2^32 + face, sorted.
var named_faces: Growing[i64]
var centroid: Vector3
static func of(mesh: const Mesh*, group: str, models: const interop.Reference[CadModel][]) -> Chosen!:
var result = Chosen(Growing[usize](), Growing[usize](), Growing[i64](), Vector3())
errdefer result.close()
try result.faces.fill(models.length, 0)
try result.totals.fill(models.length, 0)
let owner = mesh.find_attribute("cad_model", 2)
let source = mesh.find_attribute("cad_face", 2)
if owner < 0 or source < 0: error(invalid, "the pick mesh lost its CAD tags")
var bits = try group_bits_of(mesh, group, Domain.face)
defer bits.bits.release()
let words = bits.bits.view()
var sum = Vector3()
var count = 0.0
for face in 0..<mesh.face_count():
let model = (usize)(try mesh.attribute_value(owner, face))
if model >= models.length: error(invalid, "the pick mesh does not match its models")
result.totals.items[model] += 1
if (words[(usize)face >> 6] >> (u64)((usize)face & 63)) & 1 == 0: continue
result.faces.items[model] += 1
try result.named_faces.push((i64)model * 4294967296 + (i64)(try mesh.attribute_value(source, face)))
sum = sum.add(try mesh.face_center(face))
count += 1.0
if count > 0.0: result.centroid = sum.multiply_scalar(1.0 / count)
sort.sort(result.named_faces.items[..<result.named_faces.count])
return result
## Whether B-rep face `face` of model `model` is named.
func named(model: usize, face: i64) -> bool:
let key = (i64)model * 4294967296 + face
var low: usize = 0
var high = self.named_faces.count
while low < high:
let middle = (low + high) // 2
if self.named_faces.items[middle] < key: low = middle + 1
else: high = middle
return low < self.named_faces.count and self.named_faces.items[low] == key
func close():
self.faces.close()
self.totals.close()
self.named_faces.close()
## The B-rep edge under every edge of `mesh` (-1 inside a face or on a
## seam): an edge between polygons of two B-rep faces lies on the B-rep edge
## those faces share, the nearest one when they share several. `owning` is
## each polygon's model.
func edge_owners(mesh: const Mesh*, owning: const f64[], models: const interop.Reference[CadModel][], out: Growing[f64]*, out_models: Growing[i64]*) -> !:
let ends = try mesh.edge_span()
let edges = ends.length // 2
try out.fill(edges, -1.0)
try out_models.fill(edges, -1)
let source = mesh.find_attribute("cad_face", 2)
if source < 0: return
let faces = try mesh.attribute_entry(source)
let offsets = mesh.offset_span()
let corner_edges = try mesh.corner_edge_span()
# The two polygons of each mesh edge.
let sides = try new i64[edges * 2] --- in memory.heap
defer free(sides) in memory.heap
for at in 0..<sides.length: sides[at] = -1
for face in 0..<offsets.length - 1:
for corner in (usize)offsets[face]..<(usize)offsets[face + 1]:
let edge = (usize)corner_edges[corner]
if sides[edge * 2] < 0: sides[edge * 2] = (i64)face
elif sides[edge * 2 + 1] < 0: sides[edge * 2 + 1] = (i64)face
var pairs = Growing[FacePairs]()
defer:
for at in 0..<pairs.count: pairs.items[at].close()
pairs.close()
for model in models: try pairs.push(try FacePairs.of(model.value()))
let points = mesh.point_span()
let origin = mesh.position_origin()
# Consecutive mesh edges follow one B-rep edge: the last pair's answer.
var last_key: i64 = -1
var last_edge: i64 = -1
for edge in 0..<edges:
let p = sides[edge * 2]
let q = sides[edge * 2 + 1]
if p < 0 or q < 0: continue
let model = (usize)owning[(usize)p]
if model != (usize)owning[(usize)q] or model >= models.length: continue
let a = (i64)faces.number((usize)p, 0)
let b = (i64)faces.number((usize)q, 0)
if a == b: continue
let key = (i64)model * 1099511627776 + (a if a < b else b) * 1048576 + (b if a < b else a)
let index = &pairs.items[model]
out_models.items[edge] = (i64)model
if key == last_key and index.single(a, b):
out.items[edge] = (f64)last_edge
continue
let middle = points[(usize)ends[edge * 2]].vector().add(points[(usize)ends[edge * 2 + 1]].vector()).multiply_scalar(0.5).add(origin)
last_key = key
last_edge = try index.nearest(models[model].value(), a, b, middle)
out.items[edge] = (f64)last_edge
## Takes `mesh`: with each edge's B-rep edge reference (modeling's names:
## the edge's faces and where it is) in text attribute
## `cad_edge_reference`, when a model has names. That is what a feature
## keeps of picked edges, since their numbers change with anything upstream.
func with_references(mesh: interop.Reference[Mesh], models: const interop.Reference[CadModel][], edges: const f64[], edge_models: const i64[]) -> interop.Reference[Mesh]!:
var strings = TableBuilder()
defer strings.close()
# Each model's B-rep edge's string (-1 none), after the earlier models'.
var ids = Growing[i32]()
defer ids.close()
var firsts = Growing[usize]()
defer firsts.close()
var lines = Growing[u8]()
defer lines.close()
var any = false
for model in models:
try firsts.push(ids.count)
try reference_lines(model.value(), &lines)
let bytes = lines.view()
var start: usize = 0
var line: i64 = 0
let count = model.value().edge_count()
for at in 0..<bytes.length + 1:
if at < bytes.length and bytes[at] != 10: continue
if line < count:
let text = (str)bytes[start..<at]
try ids.push((try strings.intern(text)) if text != "" else -1)
any = any or text != ""
line += 1
start = at + 1
while (i64)(ids.count - firsts.items[firsts.count - 1]) < count: try ids.push(-1)
if not any: return mesh
defer mesh.release()
let values = try new i32[edges.length] --- in memory.heap
defer free(values) in memory.heap
for at in 0..<edges.length:
let model = edge_models[at]
values[at] = ids.items[firsts.items[(usize)model] + (usize)edges[at]] if model >= 0 and edges[at] >= 0.0 else -1
return try mesh.value().with_attribute_entry(try text_attribute("cad_edge_reference", Domain.edge, edges.length, &strings, values))
## Takes `mesh`: with each polygon's B-rep face name (modeling's: what made
## it) in text attribute `cad_face_name`, when a model has names: what a
## sketch on a picked face keeps, as its number changes with anything
## upstream. `owning` is each polygon's model.
func with_face_names(mesh: interop.Reference[Mesh], models: const interop.Reference[CadModel][], owning: const f64[]) -> interop.Reference[Mesh]!:
let source = mesh.value().find_attribute("cad_face", 2)
if source < 0: return mesh
var strings = TableBuilder()
defer strings.close()
# Each model's B-rep face's string (-1 none), after the earlier models'.
var ids = Growing[i32]()
defer ids.close()
var firsts = Growing[usize]()
defer firsts.close()
var any = false
for model in models:
try firsts.push(ids.count)
for face in 0..<model.value().face_count():
let name = try model.value().face_name(face)
try ids.push((try strings.intern(name)) if name != "" else -1)
any = any or name != ""
if not any: return mesh
defer mesh.release()
let faces = try mesh.value().attribute_entry(source)
let count = (usize)mesh.value().face_count()
let values = try new i32[count] --- in memory.heap
defer free(values) in memory.heap
for at in 0..<count:
let model = (usize)owning[at]
let face = (usize)faces.number(at, 0)
values[at] = ids.items[firsts.items[model] + face] if model < models.length and firsts.items[model] + face < ids.count else -1
return try mesh.value().with_attribute_entry(try text_attribute("cad_face_name", Domain.face, count, &strings, values))
## A model's B-rep edges by the pair of faces using them: sorted keys
## (low face * 2^20 + high face) and their edges.
struct FacePairs:
var keys: Growing[i64]
static func of(model: const CadModel*) -> FacePairs!:
var result = FacePairs(Growing[i64]())
errdefer result.close()
let edges = (usize)model.edge_count()
let first = try new i64[edges] --- in memory.heap
defer free(first) in memory.heap
for at in 0..<edges: first[at] = -1
for face in 0..<model.face_count():
for use in 0..<(try model.face_edge_count(face)):
let id = try model.face_edge_id(face, use)
if id < 0 or (usize)id >= edges: continue
let other = first[(usize)id]
if other < 0:
first[(usize)id] = face
elif other != face:
let low = other if other < face else face
let high = face if other < face else other
# Key in the high bits, edge in the low 24.
try result.keys.push((low * 1048576 + high) * 16777216 + id)
sort.sort(result.keys.items[..<result.keys.count])
return result
## The range of entries for faces `a` and `b`.
func range(a: i64, b: i64) -> (usize, usize):
let pair = (a if a < b else b) * 1048576 + (b if a < b else a)
var low: usize = 0
var high = self.keys.count
while low < high:
let middle = (low + high) // 2
if self.keys.items[middle] >> 24 < pair: low = middle + 1
else: high = middle
var end = low
while end < self.keys.count and self.keys.items[end] >> 24 == pair: end += 1
return (low, end)
## Whether faces `a` and `b` share exactly one edge.
func single(a: i64, b: i64) -> bool:
let (low, end) = self.range(a, b)
return end == low + 1
## The edge faces `a` and `b` share nearest to `point` (-1: none).
func nearest(model: const CadModel*, a: i64, b: i64, point: Vector3) -> i64!:
let (low, end) = self.range(a, b)
if end == low: return -1
if end == low + 1: return self.keys.items[low] & 16777215
var found: i64 = -1
var best = 1e300
for at in low..<end:
let id = self.keys.items[at] & 16777215
for use in 0..<(try model.face_edge_count(a)):
if (try model.face_edge_id(a, use)) != id: continue
var distance = 1e300
for step in 0..<17:
distance = math.min(distance, (try model.face_edge_point(a, use, (f64)step / 16.0)).subtract(point).length())
if distance < best:
best = distance
found = id
return found
func close():
self.keys.close()