Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.3

0.9.3 / tests / contracts / cut_sliver_contract.lucb

## Sub-tolerance cleanup uses physical lengths, not arbitrary chart scale.
from luce_std import math
from luce_geocore.geocore import Vector3, Matrix4, MeshBuilder, Mesh, invalid
from meshing import coalesce, append_repaired

pub func cut_sliver_contract() -> !:
    try long_boundary()
    for scale in [0.001, 1.0]:
        for chart_scale in [0.01, 1000.0]:
            for wide in [false, true]:
                for reverse in [false, true]:
                    for tilted in [false, true]:
                        try check(scale, chart_scale, wide, reverse, tilted)
                        for shape in 0..<3:
                            try skewed_boundary(scale, chart_scale, wide, reverse, tilted, shape)
                        if not wide:
                            for roundoff in [false, true]: try collapsed_chain(scale, chart_scale, reverse, tilted, roundoff)

## Width between 5% and 100% of import tolerance is not enough by itself:
## admit a severely skewed trim triangle, but retain well-angled thin quads,
## above-tolerance features and interior cells. Display triangles are invariant.
func skewed_boundary(scale: f64, chart_scale: f64, wide: bool, reverse: bool, tilted: bool, shape: i64) -> !:
    # The wide triangle still passes area/length < tolerance, so rejection
    # specifically needs the actual lifted strip-width check.
    let height = 0.014 if wide else 0.004
    let points = [Vector3(), Vector3(1.0, 0.0, 0.0), Vector3(0.5 if shape == 0 else (1.0 if shape == 1 else 0.9), height, 0.0), Vector3(0.4 if shape == 2 else 0.0, height, 0.0), Vector3(1.0, -1.0, 0.0), Vector3(0.0, -1.0, 0.0)]
    let placement = Matrix4.compose(Vector3(3.0, -7.0, 11.0), Vector3(math.pi * 0.5 if tilted else 0.0, 0.0, 0.0), Vector3(scale, scale, scale))
    var positions = [Vector3(), Vector3(), Vector3(), Vector3(), Vector3(), Vector3()]
    var builder = try MeshBuilder(precise = true)
    defer builder.close()
    for at in 0..<points.length:
        _ = try builder.point(points[at].multiply_scalar(chart_scale))
        positions[at] = placement.transform_point(points[at])
    let count: usize = 3 if shape == 0 else 4
    try builder.face((i64)count)
    for at in 0..<count: try builder.corner((i64)(count - 1 - at if reverse else at))
    try builder.face(4)
    let neighbor = [1, 0, 5, 4]
    for at in 0..<(usize)4: try builder.corner(neighbor[3 - at if reverse else at])
    let source = try builder.finish()
    defer source.release()
    for boundary in [(usize)1, (usize)4]:
        let merged = not wide and shape != 1 and boundary == 4
        let result = try coalesce(source, boundary, scale * 0.01, positions)
        defer result.release()
        let mesh = result.value()
        if mesh.face_count() != (1 if merged else 2): error(invalid, "skewed trim cleanup must distinguish physical uncertainty from healthy narrow rows")
        if mesh.point_count() != 6 or (try mesh.edge_count()) != (i64)count + (2 if merged else 3): error(invalid, "skewed trim cleanup changed boundary identities")
        for at in 0..<6:
            if (try mesh.point(at)) != points[(usize)at].multiply_scalar(chart_scale): error(invalid, "skewed trim cleanup moved a point")
        try same_triangles(source.value(), mesh)

func same_triangles(before: const Mesh*, after: const Mesh*) -> !:
    if before.index_count() != after.index_count(): error(invalid, "trim cleanup changed display triangle count")
    for triangle in 0..<before.index_count() // 3:
        var matches: i64 = 0
        for candidate in 0..<after.index_count() // 3:
            for rotation in 0..<3:
                var same = true
                for at in 0..<3:
                    let a = before.index(triangle * 3 + at)
                    defer a.release()
                    let b = after.index(candidate * 3 + (at + rotation) % 3)
                    defer b.release()
                    if (try before.corner_point(try a.get())) != (try after.corner_point(try b.get())): same = false
                if same: matches += 1
        if matches != 1: error(invalid, "trim cleanup replaced or reversed a display triangle")

## Two microscopic chart cells lift to one straight boundary chain. The first
## sliver's spanning neighbor is SMALLER, so ordinary area-ratio selection
## would absorb it sideways into the healthy triangle and create a backtrack.
func collapsed_chain(scale: f64, chart_scale: f64, reverse: bool, tilted: bool, roundoff: bool) -> !:
    let uv = [Vector3(0.0, 0.1, 0.0), Vector3(0.1, 0.9, 0.0), Vector3(1e-12, 0.9, 0.0), Vector3(-1e-12, 0.0, 0.0), Vector3(1e-12, 1.0, 0.0), Vector3(-1.0, 0.5, 0.0)]
    let placement = Matrix4.compose(Vector3(3.0, -7.0, 11.0), Vector3(math.pi * 0.5 if tilted else 0.0, 0.0, 0.0), Vector3(scale, scale, scale))
    var chart = try MeshBuilder(precise = true)
    defer chart.close()
    var lifted = try MeshBuilder(precise = true)
    defer lifted.close()
    var normals = [Vector3(), Vector3(), Vector3(), Vector3(), Vector3(), Vector3()]
    for at in 0..<uv.length:
        _ = try chart.point(uv[at].multiply_scalar(chart_scale))
        var p = uv[at]
        if at == 2 or at == 3 or at == 4: p.x = 0.0
        if roundoff and at == 2: p.x = 4e-16 / scale
        if roundoff and at == 4: p.x = -4e-16 / scale
        _ = try lifted.point(placement.transform_point(p))
        normals[at] = try placement.transform_normal(Vector3(0.0, 0.0, 1.0))
    let indices = [3, 0, 2, 3, 2, 4, 3, 4, 5, 0, 1, 2]
    for face in 0..<(usize)4:
        try chart.face(3)
        for at in 0..<(usize)3: try chart.corner(indices[face * 3 + (2 - at if reverse else at)])
    let source = try chart.finish()
    defer source.release()
    let cleaned = try coalesce(source, 6, scale * 0.01, lifted.points[..<lifted.np])
    defer cleaned.release()
    let part = cleaned.value()
    if part.point_count() != 6 or part.face_count() != 2 or (try part.edge_count()) != 7:
        error(invalid, "collapsed ribbon did not merge into its spanning neighbor")
    var triangle = false
    for face in 0..<part.face_count():
        if try part.face_size(face) != 3: continue
        triangle = true
        for at in 0..<3:
            if try part.face_point(face, at) > 2: error(invalid, "collapsed ribbon contaminated the healthy triangle")
    if not triangle: error(invalid, "collapsed ribbon removed a healthy triangle")
    for at in 0..<6:
        if (try part.point(at)) != uv[(usize)at].multiply_scalar(chart_scale): error(invalid, "collapsed ribbon moved a chart vertex")
    let repaired = try append_repaired(&lifted, cleaned, not reverse, normals)
    defer repaired.release()
    let result = try lifted.finish()
    defer result.release()
    if result.value().face_count() != 2: error(invalid, "collapsed ribbon changed during display repair")

func check(scale: f64, chart_scale: f64, wide: bool, reverse: bool, tilted: bool) -> !:
    let uv = [Vector3(), Vector3(0.5, 0.0001 * chart_scale, 0.0), Vector3(1.0, 0.0, 0.0), Vector3(1.0, -chart_scale, 0.0), Vector3(0.0, -chart_scale, 0.0)]
    let placement = Matrix4.compose(Vector3(3.0, -7.0, 11.0), Vector3(math.pi * 0.5 if tilted else 0.0, 0.0, 0.0), Vector3(scale, scale, scale))
    var positions = [Vector3(), Vector3(), Vector3(), Vector3(), Vector3()]
    var builder = try MeshBuilder(precise = true)
    defer builder.close()
    for at in 0..<uv.length:
        _ = try builder.point(uv[at])
        positions[at] = placement.transform_point(Vector3(uv[at].x, 0.1 if wide and at == 1 else uv[at].y / chart_scale, 0.0))
    try builder.face(3)
    let triangle = [0, 2, 1]
    for at in 0..<(usize)3: try builder.corner(triangle[2 - at if reverse else at])
    try builder.face(4)
    let quad = [2, 0, 4, 3]
    for at in 0..<(usize)4: try builder.corner(quad[3 - at if reverse else at])
    let source = try builder.finish()
    defer source.release()
    for boundary in [(usize)1, (usize)3]:
        let merged = not wide and boundary == 3
        let cleaned = try coalesce(source, boundary, scale * 0.01, positions)
        defer cleaned.release()
        if cleaned.value().face_count() != (1 if merged else 2): error(invalid, "cut sliver cleanup used UV size or removed a non-boundary cell")
        if cleaned.value().point_count() != 5 or (try cleaned.value().edge_count()) != (5 if merged else 6): error(invalid, "cut sliver cleanup changed its boundary topology")
        for at in 0..<5:
            if (try cleaned.value().point(at)) != uv[(usize)at]: error(invalid, "cut sliver cleanup moved a canonical chart vertex")
        for edge in 0..<(try cleaned.value().edge_count()):
            let a = try cleaned.value().edge_point(edge, 0)
            let b = try cleaned.value().edge_point(edge, 1)
            if merged and a == 0 and b == 2: error(invalid, "sliver's internal chord was not dissolved")

## One small sliver per boundary interval is ordinary on a densely sampled CAD
## trim. Complete the strip rather than stopping after only its first 32 cells.
func long_boundary() -> !:
    var builder = try MeshBuilder(precise = true)
    defer builder.close()
    for y in [0.0001, 0.0, -1.0]:
        for at in 0..<65: _ = try builder.point(Vector3((f64)at / 64.0, y, 0.0))
    for row in 0..<2:
        for col in 0..<64:
            let a = row * 65 + col
            try builder.face(4)
            for id in [a, a + 65, a + 66, a + 1]: try builder.corner(id)
    let source = try builder.finish()
    defer source.release()
    let result = try coalesce(source, 65, 0.01, builder.points[..<builder.np])
    defer result.release()
    if result.value().face_count() != 64 or result.value().point_count() != 195:
        error(invalid, "a dense boundary strip was only partly coalesced")
    for face in 0..<64:
        if try result.value().face_size(face) != 6: error(invalid, "boundary strip must retain both collinear side corners")
    for at in 0..<195:
        if (try result.value().point(at)) != builder.points[(usize)at]: error(invalid, "boundary strip moved a vertex")