Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.2

0.9.2 / tests / contracts / layout_envelope_contract.lucb

## Affine extrusion endpoints may terminate at oblique stopped trims. They are
## still exact cut-polygon corners, not compulsory surface-wide grid stations.
from luce_std import math
import memory
from luce_geocore.geocore import Vector3, invalid
from geometry import Surface, BrepFace, Curve, evaluate
from polygons import TrimGrid
from layout import UVChain, GridLayout, Stations, extrusion_axis, affine_axis, trim_rails, row_endpoint, cached
from tessellation import reconcile

pub func layout_envelope_contract() -> !:
    for scale in [0.001, 1.0, 1000.0]:
        for swapped in [false, true]:
            for reverse in [false, true]:
                for variant in 0..<4: try elevated_support(scale, swapped, reverse, variant)
            for variant in 0..<3:
                let s = try support(scale, swapped, variant)
                defer s.close()
                let along = 0 if swapped else 1
                if extrusion_axis(s, along) != (variant == 0): error(invalid, "extrusion proof accepted a warped or reweighted control net")
                if extrusion_axis(s, 1 - along) or extrusion_axis(s, -1): error(invalid, "curved or invalid axes cannot suppress endpoint stations")
            for reverse in [false, true]:
                for smooth in [false, true]:
                    for pitched in [false, true]: try reconcile_endpoints(scale, swapped, reverse, smooth, pitched)
                for origin in 0..<(usize)4:
                    for smooth in [false, true]:
                        for oblique in [false, true]: try endpoint(scale, swapped, reverse, origin, smooth, oblique)

func support(scale: f64, swapped: bool, variant: i64) -> Surface!:
    var points = [Vector3(), Vector3(), Vector3(), Vector3(), Vector3(), Vector3()]
    var weights = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
    for u in 0..<(usize)3:
        for v in 0..<(usize)2:
            let at = v * 3 + u if swapped else u * 2 + v
            points[at] = Vector3((f64)u * 0.5, 20.0 * (f64)v, 0.3 if u == 1 else 0.0).multiply_scalar(scale)
            weights[at] = 0.7 if u == 1 else 1.0
            if u == 1 and v == 1:
                if variant == 1: points[at] = points[at].add(Vector3(0.0, 0.0, 0.01 * scale))
                if variant == 2: weights[at] *= 1.01
    let quadratic = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0]
    let linear = [0.0, 0.0, 1.0, 1.0]
    return try Surface(3, Vector3(), Vector3(), Vector3(), 0.0, 0.0, points, weights,
                       linear[..<4] if swapped else quadratic[..<6], quadratic[..<6] if swapped else linear[..<4],
                       2 if swapped else 3, 3 if swapped else 2, 1 if swapped else 2, 2 if swapped else 1)

## A cubic with nonuniform inserted knots is still the same affine extrusion.
## Merely collinear controls are insufficient: a nonlinear parameterization,
## a warped control point, or changing rail weights must fail the proof.
func elevated_support(scale: f64, swapped: bool, reverse: bool, variant: i64) -> !:
    let knots = [-3.0, -3.0, -3.0, -3.0, -2.6, -1.4, -1.4, -1.0, -1.0, -1.0, -1.0]
    let profile_knots = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0]
    let points = try new Vector3[21] --- in memory.heap
    defer free(points) in memory.heap
    let weights = try new f64[21] --- in memory.heap
    defer free(weights) in memory.heap
    for across in 0..<(usize)3:
        for along in 0..<(usize)7:
            let fraction = (knots[along + 1] + knots[along + 2] + knots[along + 3] + 9.0) / 6.0
            let at = along * 3 + across if swapped else across * 7 + along
            points[at] = Vector3((f64)across * 0.5, 20.0 * (1.0 - fraction if reverse else fraction), 0.3 if across == 1 else 0.0).multiply_scalar(scale)
            weights[at] = 0.7 if across == 1 else 1.0
            if along == 2:
                if variant == 1 and across == 1: points[at].z += 0.01 * scale
                if variant == 2: weights[at] *= 1.01
                if variant == 3: points[at].y += 0.01 * scale
    let s = try Surface(3, Vector3(), Vector3(), Vector3(), 0.0, 0.0, points, weights,
                        knots[..<11] if swapped else profile_knots[..<6], profile_knots[..<6] if swapped else knots[..<11],
                        7 if swapped else 3, 3 if swapped else 7, 3 if swapped else 2, 2 if swapped else 3)
    defer s.close()
    if affine_axis(s, 0 if swapped else 1) != (variant == 0): error(invalid, "elevated extrusion proof must check every Greville position and rail weight")
    if affine_axis(s, 1 if swapped else 0): error(invalid, "degree elevation must not make the curved profile affine")
    if extrusion_axis(s, 0 if swapped else 1): error(invalid, "extended recognition must not silently change clipped layout policy")
    if variant != 0: return
    for profile in [0.0, 0.2, 0.5, 0.8, 1.0]:
        let a = try evaluate(s, Vector3(0.0, profile, 0.0) if swapped else Vector3(profile, 0.0, 0.0))
        let b = try evaluate(s, Vector3(1.0, profile, 0.0) if swapped else Vector3(profile, 1.0, 0.0))
        for along in [0.0, 0.1, 0.37, 0.8, 1.0]:
            let p = try evaluate(s, Vector3(along, profile, 0.0) if swapped else Vector3(profile, along, 0.0))
            if p.subtract(a.multiply_scalar(1.0 - along).add(b.multiply_scalar(along))).length() > scale * 1e-10:
                error(invalid, "proven degree-elevated axis did not evaluate as an affine extrusion")

func endpoint(scale: f64, swapped: bool, reverse: bool, origin: usize, smooth: bool, oblique: bool) -> !:
    let s = try support(scale, swapped, 0)
    defer s.close()
    var p = [Vector3(0.0, 0.2, 0.0), Vector3(1.0, 0.21 if oblique else 0.2, 0.0), Vector3(1.0, 1.0, 0.0), Vector3(0.0, 1.0, 0.0)]
    if swapped:
        for at in 0..<(usize)4: p[at] = Vector3(p[at].y, p[at].x, 0.0)
    var a = [p[0], p[1]]
    var b = [p[1], p[2]]
    var c = [p[2], p[3]]
    var d = [p[3], p[0]]
    var source = [UVChain(), UVChain(), UVChain(), UVChain()]
    source[0].points = a[..<2]
    source[1].points = b[..<2]
    source[2].points = c[..<2]
    source[3].points = d[..<2]
    var chains = [UVChain(), UVChain(), UVChain(), UVChain()]
    var uses = [0, 0, 0, 0]
    var flow = [false, false, false, false]
    for at in 0..<(usize)4:
        let edge = (origin + (3 - at if reverse else at)) % 4
        uses[at] = -((i64)edge + 1) if reverse else (i64)edge + 1
        chains[at] = source[edge]
        flow[at] = edge != 0 or smooth
    let face = try BrepFace(0, uses, [4], not reverse)
    defer face.close()
    let low = Vector3(0.2, 0.0, 0.0) if swapped else Vector3(0.0, 0.2, 0.0)
    let rails = try trim_rails(s, chains, low, Vector3(1.0, 1.0, 0.0), 1e-7, scale * 1e-6)
    for side in 0..<(usize)4:
        let expected = not oblique or side != (0 if swapped else 2)
        if rails[side] != expected: error(invalid, "a trim envelope extremum was mistaken for a mandatory rail")
    for at in 0..<(usize)4:
        let edge = (origin + (3 - at if reverse else at)) % 4
        if edge != 1 and edge != 3: continue
        for start in [false, true]:
            let stopped = oblique and not smooth and ((edge == 1 and start) or (edge == 3 and not start))
            let required = try row_endpoint(s, face, chains, flow, at, 0 if swapped else 1, start, 1e-7, scale * 1e-6)
            if required == stopped: error(invalid, "stopped trim endpoint station depends on loop winding or origin")

## Exercise the real inheritance path as well as the endpoint classifier. The
## exact trim is retained by clipping, without extending its two unequal end
## coordinates across the whole chart. Smooth neighbors retain that contract.
func reconcile_endpoints(scale: f64, swapped: bool, reverse: bool, smooth: bool, pitched: bool) -> !:
    let p = [Vector3(0.0, 0.2, 0.0), Vector3(1.0, 0.21, 0.0), Vector3(1.0, 1.0, 0.0), Vector3(0.0, 1.0, 0.0)]
    var vertices = [Vector3(), Vector3(), Vector3(), Vector3()]
    for at in 0..<(usize)4: vertices[at] = Vector3(p[at].x, p[at].y * 20.0, 0.0).multiply_scalar(scale)
    let edges = [try line(vertices, 0), try line(vertices, 1), try line(vertices, 2), try line(vertices, 3)]
    defer:
        for edge in edges: edge.close()
    let controls = [Vector3(), Vector3(0.0, 20.0 * scale, 0.0), Vector3(scale, 0.0, 0.0), Vector3(scale, 20.0 * scale, 0.0)]
    let points = [controls[0], controls[2], controls[1], controls[3]] if swapped else controls
    let s = try Surface(3, Vector3(), Vector3(), Vector3(), 0.0, 0.0, points, [1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0], 2, 2, 1, 1)
    defer s.close()
    let face = try BrepFace(0, [-4, -3, -2, -1] if reverse else [1, 2, 3, 4], [4], not reverse)
    defer face.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)
        for t in [0.0, 1.0]: _ = try cuts[at].insert(t, 1e-12)
    _ = try cuts[1].insert(0.25, 1e-12)
    var plan = GridLayout()
    defer plan.close()
    plan.valid = true
    plan.cut_first = true
    plan.epsilon = 1e-9
    plan.pitch_axes[0 if swapped else 1] = pitched
    plan.chains = try new UVChain[4] --- in memory.heap
    plan.flow = try new bool[4] --- in memory.heap
    for use in 0..<(usize)4:
        let edge = 3 - use if reverse else use
        plan.flow[use] = edge != 0 or smooth
        plan.chains[use] = UVChain()
        _ = try cached(&plan.chains[use], s, vertices, edges[edge], cuts[edge], scale * 1e-8)
    try plan.u.open(128)
    try plan.v.open(128)
    for u in [0.0, 0.25, 0.5, 0.75, 1.0]:
        if swapped: _ = try plan.v.insert(u, 1e-9)
        else: _ = try plan.u.insert(u, 1e-9)
    for v in [0.19, 0.4, 0.6, 0.8, 1.0]:
        if swapped: _ = try plan.u.insert(v, 1e-9)
        else: _ = try plan.v.insert(v, 1e-9)
    for pass in 0..<4: _ = try reconcile(&plan, face, s, vertices, edges, cuts, scale * 1e-8, true)
    let along = plan.u if swapped else plan.v
    if along.count != (5 if pitched else (8 if smooth else (usize)6)): error(invalid, "hard-trim endpoint or incompatible late phase propagated through an affine extrusion")
    var kept_late = false
    for value in cuts[1].values[..<cuts[1].count]: kept_late = kept_late or value == 0.25
    if not kept_late: error(invalid, "phase ownership discarded an exact shared boundary sample")
    let uv = try new Vector3[128] --- in memory.heap
    defer free(uv) in memory.heap
    var count: usize = 0
    for use in 0..<(usize)4:
        let edge = 3 - use if reverse else use
        if cuts[edge].values[0] != 0.0 or cuts[edge].values[cuts[edge].count - 1] != 1.0:
            error(invalid, "endpoint policy moved a canonical edge endpoint")
        let chain = try cached(&plan.chains[use], s, vertices, edges[edge], cuts[edge], scale * 1e-8)
        for at in 0..<chain.length - 1:
            uv[count] = chain[chain.length - 1 - at if reverse else at]
            count += 1
    let clipped = try TrimGrid.clip(uv[..<count], [(i64)count], plan.u.values[..<plan.u.count], plan.v.values[..<plan.v.count])
    defer clipped.release()
    for at in 0..<count:
        if (try clipped.value().point((i64)at)).subtract(uv[at]).length() != 0.0:
            error(invalid, "endpoint termination changed the Boolean trim")
    var area: f64 = 0.0
    for tri in 0..<clipped.value().index_count() // 3:
        var corners = [Vector3(), Vector3(), Vector3()]
        for at in 0..<(usize)3:
            let index = clipped.value().index(tri * 3 + (i64)at)
            defer index.release()
            corners[at] = try clipped.value().point(try clipped.value().corner_point(try index.get()))
        let signed = corners[1].subtract(corners[0]).cross(corners[2].subtract(corners[0])).z * 0.5
        if signed <= 0.0: error(invalid, "extrusion cut produced an inverted display triangle")
        area += signed
    if math.abs(area - 0.795) > 1e-9: error(invalid, "extrusion cut changed trimmed area")

func line(p: const Vector3[], at: usize) -> Curve!:
    var numbers: f64[]
    return try Curve(0, (i64)at, (i64)((at + 1) % 4), Vector3(), Vector3(), Vector3(), 0.0, [p[at], p[(at + 1) % 4]], numbers, numbers, 0, true)