Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.3

0.9.3 / tests / contracts / intersection_contract.lucb

## A nearly tangent trim must cross a grid side even inside row-spacing epsilon.
from luce_std import math
import memory
from luce_geocore.geocore import Vector3, invalid
from geometry import Surface, Curve, BrepFace, surface_point
from polygons import TrimGrid
from layout import GridLayout, Stations, UVChain, cached, align, graze_budget
from tessellation import reconcile

pub func intersection_contract() -> !:
    for delta in [1e-8, 4e-8, 1e-7]:
        for swap in [false, true]:
            for reverse in [false, true]:
                for tolerance in [1e-9, 0.01, 0.1]: try shallow_crossing(delta, swap, reverse, tolerance)
    for scale in [0.001, 1.0, 1000.0]:
        for delta in [-2e-8, 2e-8]: try monotone_crossing(scale, delta)

## A nearby point on a monotone run remains the crossing representative.
## Blindly admitting every sub-tolerance root creates duplicate row phases.
func monotone_crossing(scale: f64, delta: f64) -> !:
    var empty_points: Vector3[]
    var empty_numbers: f64[]
    let vertices = [Vector3(), Vector3(scale, 0.0, 0.0), Vector3(scale, scale, 0.0), Vector3(0.0, scale, 0.0)]
    let edges = try new Curve[4] --- in memory.heap
    var built: usize = 0
    defer:
        for at in 0..<built: edges[at].close()
        free(edges) in memory.heap
    for at in 0..<(usize)4:
        edges[at] = try Curve(0, (i64)at, (i64)((at + 1) % 4), Vector3(), Vector3(), Vector3(), 0.0, [vertices[at], vertices[(at + 1) % 4]], empty_numbers, empty_numbers, 0, true)
        built += 1
    let face = try BrepFace(0, [1, 2, 3, 4], [4], true)
    defer face.close()
    let s = try Surface(0, Vector3(), Vector3(1.0, 0.0, 0.0), Vector3(0.0, 0.0, 1.0), 0.0, 0.0, empty_points, empty_numbers, empty_numbers, empty_numbers, 0, 0, 0, 0)
    defer s.close()
    var cuts = [Stations(), Stations(), Stations(), Stations()]
    defer:
        for cut in cuts: cut.close()
    for at in 0..<(usize)4:
        try cuts[at].open(16)
        cuts[at].epsilon = 1e-12
        for t in [0.0, 1.0]: _ = try cuts[at].insert(t, 1e-12)
    _ = try cuts[0].insert(0.5 + delta, 1e-12)
    var plan = GridLayout()
    defer plan.close()
    plan.epsilon = scale * 1e-7
    plan.chains = try new UVChain[4] --- in memory.heap
    for at in 0..<(usize)4: plan.chains[at] = UVChain()
    try plan.u.open(8)
    try plan.v.open(8)
    for x in [-0.1, 0.5, 1.1]: _ = try plan.u.insert(x * scale, scale * 1e-12)
    for y in [-0.1, 1.1]: _ = try plan.v.insert(y * scale, scale * 1e-12)
    let tolerance = scale * 1e-4
    _ = try reconcile(&plan, face, s, vertices, edges, cuts, tolerance, false)
    if cuts[0].count != 3 or cuts[0].values[1] != 0.5 + delta:
        error(invalid, "a monotone crossing introduced a redundant near-coincident root")
    let points = try new Vector3[6] --- in memory.heap
    defer free(points) in memory.heap
    let canonical = try new Vector3[6] --- in memory.heap
    defer free(canonical) in memory.heap
    let ids = [0, 1, 2, 3, 4, 5]
    var count: usize = 0
    for at in 0..<(usize)4:
        let chain = try cached(&plan.chains[at], s, vertices, edges[at], cuts[at], tolerance)
        for k in 0..<chain.length - 1:
            if count >= 6: error(invalid, "monotone crossing duplicated a boundary point")
            points[count] = chain[k]
            canonical[count] = try edges[at].at(cuts[at].values[k])
            count += 1
    if count != 6: error(invalid, "monotone crossing lost a boundary point")
    try align(points, [6], ids, canonical, s, plan, tolerance)
    if points[1].x != scale * 0.5 or canonical[1].x != scale * (0.5 + delta):
        error(invalid, "monotone incidence must align only the chart, not canonical geometry")
    let mesh = try TrimGrid.clip_identified(points, [6], plan.u.values[..<plan.u.count], plan.v.values[..<plan.v.count], ids)
    defer mesh.release()
    if mesh.value().face_count() != 2 or mesh.value().point_count() != 6:
        error(invalid, "monotone incidence did not produce the two regular cells")

func shallow_crossing(delta: f64, swap: bool, reverse: bool, tolerance: f64) -> !:
    var empty_points: Vector3[]
    var empty_numbers: f64[]
    let radius = 0.5 + delta
    let vertices = [Vector3(0.0, -delta, 0.0), Vector3(1.0, -delta, 0.0), Vector3(1.0, 1.0 + delta, 0.0), Vector3(0.0, 1.0 + delta, 0.0)]
    let line0 = try Curve(0, 0, 1, Vector3(), Vector3(), Vector3(), 0.0, [vertices[0], vertices[1]], empty_numbers, empty_numbers, 0, true)
    defer line0.close()
    let arc = try Curve(1, 1, 2, Vector3(1.0, 0.5, 0.0), Vector3(1.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), radius, empty_points, empty_numbers, empty_numbers, 0, true, -math.pi * 0.5, -math.pi)
    defer arc.close()
    let line2 = try Curve(0, 2, 3, Vector3(), Vector3(), Vector3(), 0.0, [vertices[2], vertices[3]], empty_numbers, empty_numbers, 0, true)
    defer line2.close()
    let line3 = try Curve(0, 3, 0, Vector3(), Vector3(), Vector3(), 0.0, [vertices[3], vertices[0]], empty_numbers, empty_numbers, 0, true)
    defer line3.close()
    let edges = [line0, arc, line2, line3]
    let uses = [-4, -3, -2, -1] if reverse else [1, 2, 3, 4]
    let face = try BrepFace(0, uses, [4], not reverse)
    defer face.close()
    let s = try Surface(0, Vector3(), Vector3(0.0, 1.0, 0.0) if swap else Vector3(1.0, 0.0, 0.0), Vector3(0.0, 0.0, 1.0), 0.0, 0.0, empty_points, empty_numbers, empty_numbers, empty_numbers, 0, 0, 0, 0)
    defer s.close()
    var cuts = [Stations(), Stations(), Stations(), Stations()]
    defer:
        for cut in cuts: cut.close()
    for at in 0..<(usize)4:
        try cuts[at].open(128)
        cuts[at].epsilon = 1e-12
        for t in [0.0, 1.0]: _ = try cuts[at].insert(t, 1e-12)
    for t in [0.25, 0.5, 0.75]: _ = try cuts[1].insert(t, 1e-12)
    var plan = GridLayout()
    defer plan.close()
    plan.epsilon = 1e-6
    plan.chains = try new UVChain[4] --- in memory.heap
    for at in 0..<(usize)4: plan.chains[at] = UVChain()
    try plan.u.open(16)
    try plan.v.open(16)
    let xs = [-0.1, 0.0, 0.5, 1.0, 1.1]
    let ys = [-0.1, -delta, 0.25, 0.75, 1.0 + delta, 1.1]
    # Swapping the chart's X direction rotates V to negative world X.
    for value in xs:
        if swap: _ = try plan.v.insert(-value, 1e-12)
        else: _ = try plan.u.insert(value, 1e-12)
    for value in ys:
        if swap: _ = try plan.u.insert(value, 1e-12)
        else: _ = try plan.v.insert(value, 1e-12)
    # A cap deeper than the graze budget keeps both roots, even if the
    # modelling tolerance's sample separation is larger than their distance
    # to the intervening extremum: a root and the extremum are not two
    # estimates of the same incidence. A shallower cap is a tangency within
    # fitting precision: no roots, and alignment lands the extremum on the
    # line instead (trim_crossings.grazes).
    let spacing = (try arc.at(0.5)).subtract(try arc.at(0.25)).length()
    let grazing = delta <= graze_budget(spacing, tolerance)
    _ = try reconcile(&plan, face, s, vertices, edges, cuts, tolerance, false)
    let frozen = cuts[1].count
    _ = try reconcile(&plan, face, s, vertices, edges, cuts, tolerance, false)
    if cuts[1].count != frozen: error(invalid, "reconciling exact arc intersections must be idempotent")
    var before: usize = 0
    var after: usize = 0
    for t in cuts[1].values[..<cuts[1].count]:
        let p = try arc.at(t)
        if math.abs(p.x - 0.5) < 1e-11:
            if t < 0.5: before += 1
            else: after += 1
    let roots: usize = 0 if grazing else 1
    if before != roots or after != roots: error(invalid, "shallow trim crossings must register on both sides of a cut tangent, and not at all on a grazed one")
    # Use the frozen shared chain unchanged. Clipping must produce a valid cell
    # arrangement, not force the entire patch through the constrained fallback.
    let points = try new Vector3[512] --- in memory.heap
    defer free(points) in memory.heap
    let canonical = try new Vector3[512] --- in memory.heap
    defer free(canonical) in memory.heap
    let ids = try new i64[512] --- in memory.heap
    defer free(ids) in memory.heap
    var length: usize = 0
    var extremum: usize = 0
    for use in 0..<(usize)4:
        let signed = uses[use]
        let index = (usize)(-signed - 1 if signed < 0 else signed - 1)
        let uv = try cached(&plan.chains[use], s, vertices, edges[index], cuts[index], tolerance)
        for at in 0..<uv.length - 1:
            let sample = at if signed > 0 else uv.length - 1 - at
            let p = uv[sample]
            if index == 1 and cuts[1].values[sample] == 0.5: extremum = length
            points[length] = p
            canonical[length] = try surface_point(s, p)
            ids[length] = (i64)length
            length += 1
    # The same alignment as clipped_patch. It moves the chart only: the cut
    # tangent keeps its extremum beyond the line, the grazed one lands on it.
    let original = points[extremum]
    try align(points[..<length], [(i64)length], ids[..<length], canonical[..<length], s, plan, tolerance)
    if (points[extremum].subtract(original).length() != 0.0) != grazing:
        error(invalid, "only a grazed extremum aligns onto its tangent line")
    let mesh = try TrimGrid.clip(points[..<length], [(i64)length], plan.u.values[..<plan.u.count], plan.v.values[..<plan.v.count])
    defer mesh.release()
    for at in 0..<length:
        if (try mesh.value().point((i64)at)).subtract(points[at]).length() != 0.0:
            error(invalid, "cut cells must not weld the shallow trim crossings")
    var expected: f64 = 0.0
    for at in 0..<length: expected += points[at].cross(points[(at + 1) % length]).z * 0.5
    var area: f64 = 0.0
    for triangle in 0..<mesh.value().index_count() // 3:
        var p = [Vector3(), Vector3(), Vector3()]
        for at in 0..<(usize)3:
            let index = mesh.value().index(triangle * 3 + (i64)at)
            defer index.release()
            p[at] = try mesh.value().point(try mesh.value().corner_point(try index.get()))
        let signed = p[1].subtract(p[0]).cross(p[2].subtract(p[0])).z * 0.5
        if signed <= 0.0: error(invalid, "shallow crossing produced a reversed display triangle")
        area += signed
    if math.abs(area - math.abs(expected)) > 1e-11: error(invalid, "shallow crossing changed polygon area")