dymokomi/luce-cad
Source of release 0.9.3
0.9.3 / src / meshing / patch_dispatch.lucb
## Transactional face meshing: mapped quads, clipped cells, constrained fallback.
## A face's polygons, or its failure: every face either meshes or says
## why not (the tessellator names it), none is left out silently.
pub func mesh_face(mesh: MeshBuilder*, face: BrepFace, surface: Surface, edges: const Curve[], full_samples: const Samples[], plan: GridLayout, divisions: i64, tolerance: f64, edge_size: f64) -> !:
let first = mesh.nf
try dispatch_face(mesh, face, surface, edges, full_samples, plan, divisions, tolerance, edge_size)
if mesh.nf == first: error(invalid, "no mesher made a polygon of it")
## Each failed strategy rewinds scratch before the next strategy runs.
func dispatch_face(mesh: MeshBuilder*, face: BrepFace, surface: Surface, edges: const Curve[], full_samples: const Samples[], plan: GridLayout, divisions: i64, tolerance: f64, edge_size: f64) -> !:
# Hard oblique trims use an independent support grid. Compatible mapped
# seams retain their shared row contract and continuous quad strips.
let mapped_np = mesh.np
let mapped_nf = mesh.nf
let mapped_nc = mesh.nc
# A sphere triangle (a rounded corner): a barycentric grid.
if sphere_triangle(face, surface, edges, tolerance):
var meshed = true
barycentric_sphere(mesh, face, surface, full_samples, tolerance, divisions) catch failure:
mesh.np = mapped_np
mesh.nf = mapped_nf
mesh.nc = mapped_nc
if failure.code != invalid: error(failure.code, failure.message)
meshed = false
recover ()
if meshed:
if plan.method.length > 0: plan.method[0] = 7
return
# A cone's side closing at its apex: rings and an apex fan.
if apex_cone(face, surface, edges):
try conical_fan(mesh, face, surface, edges, full_samples, tolerance)
if plan.method.length > 0: plan.method[0] = 6
return
if plan.valid and plan.cut_first and (try attempt_clip(mesh, face, surface, full_samples, plan, tolerance, divisions)): return
var mapped = true
mapped_rows(mesh, face, surface, edges, full_samples, plan, tolerance, divisions) catch failure:
mesh.np = mapped_np
mesh.nf = mapped_nf
mesh.nc = mapped_nc
if failure.code != invalid: error(failure.code, failure.message)
mapped = false
recover ()
if mapped:
plan.method[0] = 1
return
# Never bypass an available boundary-terminating layout merely because the
# first mapped candidate's warped n-gons could not be displayed safely.
if plan.valid and not plan.cut_first and (try attempt_clip(mesh, face, surface, full_samples, plan, tolerance, divisions)): return
# Warped boundary n-gons may not have a support-consistent triangulation.
# Retry the shared-row map transactionally before constrained fallbacks.
mapped = true
mapped_full(mesh, face, surface, edges, full_samples, tolerance, divisions) catch failure:
mesh.np = mapped_np
mesh.nf = mapped_nf
mesh.nc = mapped_nc
if failure.code != invalid: error(failure.code, failure.message)
mapped = false
recover ()
if mapped:
plan.method[0] = 3
return
let first_point = mesh.np
let first_face = mesh.nf
let first_corner = mesh.nc
var accepted = true
constrained_checked(mesh, face, surface, edges, full_samples, divisions, tolerance, edge_size) catch failure:
if failure.code != invalid: error(failure.code, failure.message)
accepted = false
mesh.np = first_point
mesh.nf = first_face
mesh.nc = first_corner
recover ()
if accepted:
plan.method[0] = 4
return
let samples = try new Samples[full_samples.length] --- in memory.heap
defer free(samples) in memory.heap
for use in face.uses:
let index = edge_index(use)
samples[index] = Samples(full_samples[index].baseline)
try constrained_face(mesh, face, surface, edges, samples, divisions, tolerance, edge_size)
try conform_seams(mesh, face, full_samples, first_face, first_corner)
try validate(mesh, first_face, first_corner)
plan.method[0] = 5
func attempt_clip(mesh: MeshBuilder*, face: BrepFace, surface: Surface, samples: const Samples[], plan: GridLayout, tolerance: f64, divisions: i64) -> bool!:
let np = mesh.np
let nf = mesh.nf
let nc = mesh.nc
clipped_patch(mesh, face, surface, samples, plan, tolerance, divisions) catch failure:
mesh.np = np
mesh.nf = nf
mesh.nc = nc
if failure.code != invalid: error(failure.code, failure.message)
return false
plan.applied[0] = true
plan.method[0] = 2
return true
func mapped_rows(mesh: MeshBuilder*, face: BrepFace, s: Surface, edges: const Curve[], full_samples: const Samples[], plan: GridLayout, tolerance: f64, divisions: i64) -> !:
let nf = mesh.nf
let nc = mesh.nc
let samples = try new Samples[full_samples.length] --- in memory.heap
defer free(samples) in memory.heap
var conform = false
for use in 0..<face.uses.length:
let index = edge_index(face.uses[use])
let ids = plan.row_ids[use].values
samples[index] = Samples(ids)
conform = conform or ids.length != full_samples[index].ids.length
try mapped_patch(mesh, face, s, edges, samples, tolerance, divisions)
if conform:
for use in 0..<face.uses.length:
let index = edge_index(face.uses[use])
samples[index] = Samples(full_samples[index].ids, plan.row_ids[use].values)
try conform_seams(mesh, face, samples, nf, nc)
validate_conformed(mesh, nf, nc, face, s, tolerance) catch failure:
if failure.code != invalid: error(failure.code, failure.message)
try conform_display(mesh, nf, nc, face, s, tolerance, divisions)
recover ()
else: try validate(mesh, nf, nc)
func mapped_full(mesh: MeshBuilder*, face: BrepFace, s: Surface, edges: const Curve[], samples: const Samples[], tolerance: f64, divisions: i64) -> !:
let nf = mesh.nf
let nc = mesh.nc
try mapped_patch(mesh, face, s, edges, samples, tolerance, divisions)
try validate(mesh, nf, nc)
func constrained_checked(mesh: MeshBuilder*, face: BrepFace, s: Surface, edges: const Curve[], samples: const Samples[], divisions: i64, tolerance: f64, edge_size: f64) -> !:
let nf = mesh.nf
let nc = mesh.nc
try constrained_face(mesh, face, s, edges, samples, divisions, tolerance, edge_size, true)
try validate(mesh, nf, nc)
func constrained_face(mesh: MeshBuilder*, face: BrepFace, surface: Surface, edges: const Curve[], samples: const Samples[], divisions: i64, tolerance: f64, edge_size: f64, mapped_tried: bool = false) -> !:
if surface.kind == surface_plane:
if mapped_tried:
try planar(mesh, face, surface, samples, tolerance, edge_size, divisions)
return
let np = mesh.np
let nf = mesh.nf
let nc = mesh.nc
mapped_patch(mesh, face, surface, edges, samples, tolerance, divisions) catch failure:
mesh.np = np
mesh.nf = nf
mesh.nc = nc
if failure.code != invalid: error(failure.code, failure.message)
try planar(mesh, face, surface, samples, tolerance, edge_size, divisions)
recover ()
return
let np = mesh.np
let nf = mesh.nf
let nc = mesh.nc
structured(mesh, face, surface, edges, samples, tolerance, mapped_tried, divisions) catch failure:
mesh.np = np
mesh.nf = nf
mesh.nc = nc
if failure.code != invalid: error(failure.code, failure.message)
try nurbs_trim(mesh, face, surface, samples, divisions, edge_size, tolerance)
recover ()
func structured(mesh: MeshBuilder*, face: BrepFace, surface: Surface, edges: const Curve[], samples: const Samples[], tolerance: f64, mapped_tried: bool, divisions: i64) -> !:
if mapped_tried:
if surface.kind == surface_spline: try ruled(mesh, face, surface, edges, samples, tolerance)
else: try periodic_band(mesh, face, surface, edges, samples, tolerance)
return
let np = mesh.np
let nf = mesh.nf
let nc = mesh.nc
mapped_patch(mesh, face, surface, edges, samples, tolerance, divisions) catch failure:
mesh.np = np
mesh.nf = nf
mesh.nc = nc
if failure.code != invalid: error(failure.code, failure.message)
if surface.kind == surface_spline:
try ruled(mesh, face, surface, edges, samples, tolerance)
else:
try periodic_band(mesh, face, surface, edges, samples, tolerance)
recover ()
## The number of boundary samples around `face` (each use's samples but its
## last, which the next use starts with).
func boundary_samples(face: BrepFace, samples: const Samples[]) -> usize:
var count: usize = 0
for use in face.uses: count += samples[edge_index(use)].ids.length - 1
return count
func nurbs_trim(mesh: MeshBuilder*, face: BrepFace, surface: Surface, samples: const Samples[], divisions: i64, edge_size: f64, tolerance: f64) -> !:
let ids = try new i64[boundary_samples(face, samples)] --- in memory.heap
defer free(ids) in memory.heap
let sizes = try new i64[face.sizes.length] --- in memory.heap
defer free(sizes) in memory.heap
var count: usize = 0
var offset: usize = 0
for loop in 0..<face.sizes.length:
let first = count
for at in 0..<(usize)face.sizes[loop]:
let use = face.uses[offset + at]
let sample = samples[edge_index(use)].ids
for item in 0..<sample.length - 1:
ids[count] = sample[item if use > 0 else sample.length - 1 - item]
count += 1
sizes[loop] = (i64)(count - first)
offset += (usize)face.sizes[loop]
if surface.kind == surface_spline:
try mesh_trim(mesh, ids[..<count], sizes, surface, face.sense, divisions, edge_size, tolerance)
else:
try analytic_trim(mesh, ids[..<count], sizes, surface, face.sense, divisions, tolerance, edge_size)
func planar(mesh: MeshBuilder*, face: BrepFace, surface: Surface, samples: const Samples[], tolerance: f64, edge_size: f64, divisions: i64) -> !:
let boundary = boundary_samples(face, samples)
let points = try new Vector3[boundary] --- in memory.heap
defer free(points) in memory.heap
# Boundary ids, then (after triangulation) the ids of the part's own points.
var ids = try new i64[boundary] --- in memory.heap
defer free(ids) in memory.heap
let sizes = try new i64[face.sizes.length] --- in memory.heap
defer free(sizes) in memory.heap
var count: usize = 0
var offset: usize = 0
for loop in 0..<face.sizes.length:
let first = count
for at in 0..<(usize)face.sizes[loop]:
let use = face.uses[offset + at]
let sample = samples[edge_index(use)].ids
for item in 0..<sample.length - 1:
let id = sample[item if use > 0 else sample.length - 1 - item]
let position = mesh.points[(usize)id]
if math.abs(position.subtract(surface.origin).dot(surface.z)) > tolerance:
error(invalid, "B-rep boundary is not on its plane")
ids[count] = id
points[count] = position.subtract(surface.z.multiply_scalar(position.subtract(surface.origin).dot(surface.z)))
count += 1
sizes[loop] = (i64)(count - first)
offset += (usize)face.sizes[loop]
let normal = surface.z.multiply_scalar(1.0 if face.sense else -1.0)
if sizes.length == 1 and count == 4 and edge_size == 0.0:
var convex = true
var sign: f64 = 0.0
for at in 0..<4:
let a = points[at]
let b = points[(at + 1) % 4]
let c = points[(at + 2) % 4]
let turn = b.subtract(a).cross(c.subtract(b)).dot(normal)
if math.abs(turn) < 0.0000000001 or (at > 0 and turn * sign < 0.0):
convex = false
sign = turn
if convex:
try mesh.face(4)
for at in 0..<4:
try mesh.corner(ids[at if sign > 0.0 else 3 - at])
return
var spacing = edge_size
var vertical = edge_size
if edge_size == 0.0 and count > 8:
# Complex planar trims need interior support too: do not connect every
# fine hole/border sample to a far-away corner of the outer boundary.
let reference = Vector3(1.0, 0.0, 0.0) if math.abs(normal.x) < 0.9 else Vector3(0.0, 1.0, 0.0)
let u = try reference.subtract(normal.multiply_scalar(reference.dot(normal))).normalized()
let v = normal.cross(u)
var low = Vector3()
var high = Vector3()
for p in points[..<count]:
let relative = p.subtract(points[0])
low = Vector3(math.min(low.x, relative.dot(u)), math.min(low.y, relative.dot(v)), 0.0)
high = Vector3(math.max(high.x, relative.dot(u)), math.max(high.y, relative.dot(v)), 0.0)
let resolution = math.min(math.max(32.0, (f64)divisions), math.max((f64)divisions, (f64)count / 4.0))
spacing = (high.x - low.x) / resolution
vertical = (high.y - low.y) / resolution
let part = try TrimPolygon.quadrangulate_seams(points[..<count], sizes, normal, ids[..<count], spacing, vertical)
defer part.release()
let all = try new i64[(usize)part.value().point_count()] --- in memory.heap
memory.copy(all, ids, count)
free(ids) in memory.heap
ids = all
for index in count..<(usize)part.value().point_count():
ids[index] = try mesh.point(try part.value().point((i64)index))
for index in 0..<part.value().face_count():
let corners = try part.value().face_size(index)
try mesh.face(corners)
for corner in 0..<corners:
try mesh.corner(ids[(usize)(try part.value().face_point(index, corner))])