dymokomi/luce-cad
Source of release 0.9.1
## Shared edge discretization and surface-specific conforming meshing.
## Logical four-sided patches keep quads; constrained trims preserve holes.
import interop
import memory
from luce_std import math
from luce_geocore.core import parallel
from patch_dispatch import mesh_face
from face_jobs import mesh_faces, FaceNotes, note_failure
from edge_sampling import curve_intervals, compact_seams
from surface_normals import model_normals
from surface_curvature import model_curvatures
from patch_sides import PatchSides, patch_sides
from layout_types import Stations, GridLayout
from layout_rows import initialize, bind
from layout_counts import equalize_counts
from layout_feasibility import cut_impossible
from circular_lattice import regularize
from seam_flow import classify
from trim_layout import plan_layouts
import curve_spacing as spacing
from luce_geocore.geocore import Vector3, Mesh, MeshBuilder, invalid
from brep_types import Curve, Surface, BrepFace, Samples
from face_cache import FaceCache
from luce_geocore.kernel import TableBuilder, Domain, text_attribute
from strings import format
## Plan shared boundaries, run independent face jobs, and assemble provenance.
## A face no mesher can follow is left out and named in the result
## (with_notes); only running out of memory, or every face failing, fails.
## With `curvature`, corner attributes curvature.k1/k2 hold the principal
## curvatures (surface_curvature); `directions` adds curvature.d1/d2.
pub func tessellate(vertices: const Vector3[], edges: const Curve[], surfaces: const Surface[], faces: const BrepFace[], divisions: i64, tolerance: f64, edge_size: f64, progress: interop.Callback[f64, unit]? = none, selected: i64 = -1, curvature: bool = false, directions: bool = false, cache: FaceCache*? = none) -> interop.Reference[Mesh]!:
if divisions < 1 or divisions > 64 or faces.length == 0:
error(invalid, "B-rep tessellation requires faces and 1..64 divisions")
if selected < -1 or selected >= (i64)faces.length: error(invalid, "CAD face index out of range")
var mesh = try MeshBuilder(precise = true)
defer mesh.close()
for point in vertices:
_ = try mesh.point(point)
let samples = try new Samples[edges.length] --- in memory.heap
defer free(samples) in memory.heap
var allocated: usize = 0
defer release_samples(samples[..<allocated])
let counts = try new usize[edges.length] --- in memory.heap
defer free(counts) in memory.heap
let cuts = try new Stations[edges.length] --- in memory.heap
defer free(cuts) in memory.heap
for at in 0..<cuts.length: cuts[at] = Stations()
defer close_cuts(cuts)
let plans = try new GridLayout[faces.length] --- in memory.heap
defer free(plans) in memory.heap
for at in 0..<plans.length: plans[at] = GridLayout()
defer close_plans(plans)
let metrics = try spacing.measure(edges)
defer spacing.close(metrics)
let compact = try compact_seams(faces, edges.length)
defer free(compact) in memory.heap
# Each edge's interval count on its own (in parallel); a failing edge is
# counted again here, so its error is the serial one.
var counting = EdgeCounts(edges, metrics, compact, counts, divisions, tolerance, edge_size, 0)
parallel.parallel_for(edges.length, 64, count_edges, (void*)&counting)
if counting.failed.load(.acquire) != 0:
for index in 0..<edges.length: counts[index] = try edge_count(edges[index], &metrics[index], compact[index], divisions, tolerance, edge_size)
let sides = try new PatchSides[faces.length] --- in memory.heap
defer free(sides) in memory.heap
for at in 0..<faces.length:
sides[at] = patch_sides(faces[at], surfaces[(usize)faces[at].surface], edges, tolerance) catch failure:
if failure.code != invalid: error(failure.code, failure.message)
recover PatchSides()
let seams = try classify(edges, surfaces, faces, plans, tolerance)
defer free(seams) in memory.heap
try initialize(edges, surfaces, faces, sides, counts, seams, metrics, plans, divisions, tolerance)
_ = try cut_impossible(faces, surfaces, sides, plans, edges.length)
try equalize_counts(edges, faces, sides, metrics, plans, counts)
let baseline_cuts = try new Stations[edges.length] --- in memory.heap
defer free(baseline_cuts) in memory.heap
for at in 0..<baseline_cuts.length: baseline_cuts[at] = Stations()
defer close_cuts(baseline_cuts)
for at in 0..<edges.length:
try baseline_cuts[at].open(1025)
for step in 0..<counts[at] + 1: _ = try baseline_cuts[at].insert(metrics[at].station((f64)step / (f64)counts[at]), 1e-12)
try regularize(edges, surfaces, faces, sides, plans, baseline_cuts, divisions, tolerance)
for at in 0..<edges.length:
try cuts[at].open(1025)
counts[at] = baseline_cuts[at].count - 1
cuts[at].baseline = counts[at]
for value in baseline_cuts[at].values[..<baseline_cuts[at].count]: _ = try cuts[at].insert(value, 1e-12)
try plan_layouts(vertices, edges, surfaces, faces, sides, cuts, metrics, plans, divisions, tolerance, edge_size)
for index in 0..<edges.length:
let edge = edges[index]
let count = cuts[index].count - 1
let ids = try new i64[count + 1] --- in memory.heap
let baseline = new i64[counts[index] + 1] --- in memory.heap catch failure:
free(ids) in memory.heap
error(failure.code, failure.message)
samples[index] = Samples(ids, baseline)
allocated += 1
ids[0] = edge.start
ids[count] = edge.end
for at in 1..<count:
ids[at] = try mesh.point(try edge.at(cuts[index].values[at]))
var station: usize = 0
for at in 0..<baseline.length:
let t = baseline_cuts[index].values[at]
while station + 1 < cuts[index].count and cuts[index].values[station] < t - 1e-12: station += 1
if math.abs(cuts[index].values[station] - t) > 1e-12: error(invalid, "layout lost an original edge sample")
baseline[at] = ids[station]
try bind(faces, cuts, samples, plans)
var normals: f64[]
defer free(normals) in memory.heap
var notes = FaceNotes()
defer notes.close()
# Face jobs on the pool (and the per-face cache, when given); small
# models without a cache mesh here, in order.
let pooled = selected < 0 and (faces.length >= 16 or cache != none)
notes.shared_points = mesh.np
if pooled:
normals = try mesh_faces(&mesh, edges, surfaces, faces, samples, plans, divisions, tolerance, edge_size, progress, mesh_face, ¬es, cache)
# Planned-face diagnostics keep ALL shared sampling/layout work above.
# Only the final face jobs are restricted, unlike independent previews.
let first_face = (usize)selected if selected >= 0 else 0
let last_face = first_face + 1 if selected >= 0 else (0 if pooled else faces.length)
var failed: usize = 0
var first_buffer: u8[1024]
var first_failure = ""
for face_id in first_face..<last_face:
if let report = progress:
let outcome = report.invoke((f64)face_id / (f64)faces.length * 0.9)
defer outcome.release()
try outcome.get()
let face = faces[face_id]
let first = mesh.nf
let first_point = mesh.np
let first_corner = mesh.nc
let surface = surfaces[(usize)face.surface]
var meshed = true
mesh_face(&mesh, face, surface, edges, samples, plans[face_id], divisions, tolerance, edge_size) catch failure:
# A planned-face diagnostic reports its face's failure.
if selected >= 0 or failure.code != invalid: error(failure.code, failure.message)
mesh.np = first_point
mesh.nf = first
mesh.nc = first_corner
meshed = false
var context: u8[1024]
let message = format(context, f"CAD face {face_id}: {failure.message}") catch exhausted: recover failure.message
try note_failure(¬es, surface.edited, message)
if failed == 0: first_failure = format(first_buffer, f"{message}") catch exhausted: recover "a CAD face does not mesh"
failed += 1
recover ()
if not meshed: continue
for index in first..<mesh.nf:
mesh.face_parents[index] = (i64)face_id
if failed == faces.length: error(invalid, first_failure)
if not pooled: normals = try model_normals(&mesh, faces, surfaces, plans, tolerance)
let original = try new Vector3[mesh.np] --- in memory.heap
defer free(original) in memory.heap
# The CAD face that last placed each point. Its own polygons would place
# it again identically, so only a different face re-transforms and checks.
let placed = try new i64[mesh.np] --- in memory.heap
defer free(placed) in memory.heap
for index in 0..<mesh.np:
original[index] = mesh.points[index]
placed[index] = -1
var corner: usize = 0
for face in 0..<mesh.nf:
let parent = mesh.face_parents[face]
let matrix = faces[(usize)parent].placement
for at in 0..<(usize)mesh.sizes[face]:
let point = (usize)mesh.corners[corner + at]
if placed[point] == parent: continue
let p = matrix.transform_point(original[point])
if placed[point] >= 0 and p.subtract(mesh.points[point]).length() > tolerance:
error(invalid, "shared CAD point has inconsistent assembly placements")
mesh.points[point] = p
placed[point] = parent
corner += (usize)mesh.sizes[face]
if let report = progress:
let outcome = report.invoke(0.92)
defer outcome.release()
try outcome.get()
let raw = try mesh.finish()
defer raw.release()
let values = try new f64[mesh.nf] --- in memory.heap
defer free(values) in memory.heap
for index in 0..<mesh.nf:
values[index] = (f64)mesh.face_parents[index]
let parents = try raw.value().with_attribute("cad_face", 2, 1, values, true)
defer parents.release()
for index in 0..<mesh.nf:
let plan = plans[(usize)mesh.face_parents[index]]
values[index] = 1.0 if plan.applied.length > 0 and plan.applied[0] else 0.0
let tagged = try parents.value().with_attribute("cad_trim_grid", 2, 1, values, true)
defer tagged.release()
for index in 0..<mesh.nf: values[index] = (f64)plans[(usize)mesh.face_parents[index]].method[0]
let methods = try tagged.value().with_attribute("cad_mesher", 2, 1, values, true)
defer methods.release()
for index in 0..<mesh.nf: values[index] = (f64)plans[(usize)mesh.face_parents[index]].island
let islands = try methods.value().with_attribute("cad_flow_island", 2, 1, values, true)
defer islands.release()
var has_colors = false
for face in faces:
has_colors = has_colors or face.colored
if has_colors:
let colors = try new f64[mesh.nf * 3] --- in memory.heap
defer free(colors) in memory.heap
for index in 0..<mesh.nf:
let color = faces[(usize)mesh.face_parents[index]].color
colors[index * 3] = color.x
colors[index * 3 + 1] = color.y
colors[index * 3 + 2] = color.z
let colored = try islands.value().with_attribute("Cd", 2, 3, colors)
defer colored.release()
let shaded = try colored.value().with_attribute("N", 1, 3, normals, false, true)
return try with_notes(try with_curvature(shaded, &mesh, original, faces, surfaces, tolerance, curvature, directions), ¬es)
let shaded = try islands.value().with_attribute("N", 1, 3, normals, false, true)
return try with_notes(try with_curvature(shaded, &mesh, original, faces, surfaces, tolerance, curvature, directions), ¬es)
## Takes `made`; records the shared points (.cad_shared_points: every
## point below it is a vertex, an edge sample or a layout row; a quick
## preview keeps them), how many edited faces no longer meshed
## (.cad_dropped_faces, which CadGeometry.dropped_faces reads) and the faces
## skipped because no mesher could follow them (.cad_skipped_faces, one
## "Skipped CAD face i: reason" line each, which CadGeometry.skipped_faces
## reads).
func with_notes(made: interop.Reference[Mesh], notes: const FaceNotes*) -> interop.Reference[Mesh]!:
let shared = try with_count(made, ".cad_shared_points", notes.shared_points, true)
let dropped = try with_count(shared, ".cad_dropped_faces", notes.dropped)
if notes.skipped == 0: return dropped
defer dropped.release()
return try with_lines(dropped.value(), ".cad_skipped_faces", (str)notes.lines.view())
## Takes `mesh`; with detail attribute `name` holding `count` (unless it is
## zero and not `always`).
func with_count(mesh: interop.Reference[Mesh], name: str, count: usize, always: bool = false) -> interop.Reference[Mesh]!:
if count == 0 and not always: return mesh
defer mesh.release()
var value: f64[1] = [(f64)count]
return try mesh.value().with_attribute(name, 3, 1, value[..<1], true)
## `mesh` with detail text attribute `name` holding `text`.
func with_lines(mesh: const Mesh*, name: str, text: str) -> interop.Reference[Mesh]!:
var strings = TableBuilder()
defer strings.close()
var index: i32[1] = [try strings.intern(text)]
return try mesh.with_attribute_entry(try text_attribute(name, Domain.detail, 1, &strings, index[..<1]))
## Takes `shaded`; adds the requested curvature columns as f32 (off by
## default: the analysis shading asks for them, ordinary tessellation pays
## nothing).
func with_curvature(shaded: interop.Reference[Mesh], mesh: MeshBuilder*, original: const Vector3[], faces: const BrepFace[], surfaces: const Surface[], tolerance: f64, curvature: bool, directions: bool) -> interop.Reference[Mesh]!:
if not curvature and not directions: return shaded
defer shaded.release()
let columns = try model_curvatures(mesh, original, faces, surfaces, tolerance, directions)
defer columns.close()
let first = try shaded.value().with_attribute("curvature.k1", 1, 1, columns.k1, false, true)
defer first.release()
let both = try first.value().with_attribute("curvature.k2", 1, 1, columns.k2, false, true)
if not directions: return both
defer both.release()
let major = try both.value().with_attribute("curvature.d1", 1, 3, columns.d1, false, true)
defer major.release()
return try major.value().with_attribute("curvature.d2", 1, 3, columns.d2, false, true)
struct EdgeCounts:
let edges: const Curve[]
let metrics: spacing.ArcMetric[]
let compact: const bool[]
let counts: usize[]
let divisions: i64
let tolerance: f64
let edge_size: f64
var failed: @u32
func count_edges(context: void*?, first: usize, end: usize):
let work = (EdgeCounts*)(context else return)
for index in first..<end:
work.counts[index] = edge_count(work.edges[index], &work.metrics[index], work.compact[index], work.divisions, work.tolerance, work.edge_size) catch failure:
_ = failure
work.failed.store(1, .relaxed)
return
## An edge's interval count: its curvature's, raised to the target edge size.
func edge_count(edge: Curve, metric: spacing.ArcMetric*, compact: bool, divisions: i64, tolerance: f64, edge_size: f64) -> usize!:
var count = try curve_intervals(edge, divisions, tolerance, metric, compact)
if edge_size > 0.0:
var length: f64 = 0.0
var previous = try edge.at(0.0)
for step in 1..<17:
let current = try edge.at((f64)step / 16.0)
length += current.subtract(previous).length()
previous = current
let needed = math.ceil(length / edge_size)
if needed > 256.0:
error(invalid, "edge size requires more than 256 intervals on an edge; increase it")
count = (usize)math.max((f64)count, needed)
return count
func release_samples(samples: const Samples[]):
for sample in samples:
free(sample.ids) in memory.heap
free(sample.baseline) in memory.heap
func close_cuts(cuts: const Stations[]):
for cut in cuts: cut.close()
func close_plans(plans: const GridLayout[]):
for plan in plans: plan.close()