Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.3

0.9.3 / src / tessellation / brep_mesh.lucb

## A B-rep's display mesh (internal): edges sampled and every face's
## layout planned together (trim_layout, planar_preflight), the faces
## meshed in parallel jobs (face_jobs) and kept between models that share
## them (face_cache), then joined with shading normals and curvature
## (surface_curvature). face_mesh meshes one face alone.
##
## This file: the whole pipeline, from records to one mesh.
import interop
import memory
import thread
import ownership
import sync
import strings
from luce_std import math, parallel
from luce_geocore.geocore import Vector3, Mesh, MeshBuilder, invalid
from geometry import Curve, Surface, BrepFace, Samples, edge_index, surface_plane, surface_cylinder, surface_cone, surface_spline, copied, chart_parameter, basis_derivatives, surface_sphere, surface_torus
from luce_geocore.kernel import TableBuilder, Domain, text_attribute, append_text
from strings import format
from layout import curve_intervals, compact_seams, PatchSides, patch_sides, Stations, GridLayout, initialize_rows, bind, equalize_counts, cut_impossible, regularize_circles, classify, ArcMetric, close_metrics, measure_curves, space_curves, UVChain, NormalCache, check_grid_size, fill, fill_plane, refine_axis, refine_cells, balance, Settled, rail_axis, bounds, include_conics, redistribute, regularize_extrusions, cached, chain_face, accept_plane_row, accept_extruded_row, prefers_clipping, trim_rails, row_endpoint, extrusion_axis, affine_axis, refine_pitch, accept_pitch_row, FaceErrors, TrimMemo, intersection, speculate, first_above, grazes, absorb_crossing, edge_demands, snap_lines, edge_stations, axis_stations
from meshing import mesh_face, model_normals, mapped_patch, face_normals
from luce_geocore.core.growing import Growing
from luce_std import sort

## 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 measure_curves(edges)
    defer close_metrics(metrics)
    try space_curves(metrics, edges, faces, surfaces)
    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)
    try parallel.for_each_range(edges.length, 64, (void*)&counting, count_edges)
    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)
    # Curved faces raise their edges' counts to their interior targets
    # before the samples are shared, so no face's interior refinement has
    # to chase a boundary coarser than it may be.
    try edge_demands(edges, surfaces, faces, metrics, counts, divisions, tolerance)
    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_rows(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(edge_stations)
        for step in 0..<counts[at] + 1: _ = try baseline_cuts[at].insert(metrics[at].station((f64)step / (f64)counts[at]), 1e-12)
    try regularize_circles(edges, surfaces, faces, sides, plans, baseline_cuts, divisions, tolerance)
    for at in 0..<edges.length:
        try cuts[at].open(edge_stations)
        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, &notes, 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(&notes, 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 reported_done(progress, try with_notes(try with_curvature(shaded, &mesh, original, faces, surfaces, tolerance, curvature, directions), &notes))
    let shaded = try islands.value().with_attribute("N", 1, 3, normals, false, true)
    return try reported_done(progress, try with_notes(try with_curvature(shaded, &mesh, original, faces, surfaces, tolerance, curvature, directions), &notes))

## Takes `made`: `progress` told the work is done (1), then `made`.
func reported_done(progress: interop.Callback[f64, unit]?, made: interop.Reference[Mesh]) -> interop.Reference[Mesh]!:
    errdefer made.release()
    if let report = progress:
        let outcome = report.invoke(1.0)
        defer outcome.release()
        try outcome.get()
    return made

## 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 texts = TableBuilder()
    defer texts.close()
    var index: i32[1] = [try texts.intern(text)]
    return try mesh.with_attribute_entry(try text_attribute(name, Domain.detail, 1, &texts, 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: 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, worker: usize):
    let work = (EdgeCounts*)context
    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: 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()