Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.4

0.9.4 / 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)) > surface.trims_within(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))])