dymokomi/luce-cad
Source of release 0.9.2
0.9.2 / tests / contracts / layout_feasibility_contract.lucb
## Mapped count cycles must terminate without raising counts indefinitely.
import memory
from luce_geocore.geocore import Vector3, invalid
from geometry import Surface, Curve, BrepFace, edge_index
from layout import PatchSides, GridLayout, Stations, cut_impossible, equalize_counts, balance, Settled, close_metrics, measure_curves
from tessellation import plan_layouts
pub func layout_feasibility_contract() -> !:
try retain_cut_owner()
for rotation in 0..<(usize)6:
for reverse in [false, true]:
for hard in [false, true]:
for variant in 0..<4: try cycle(rotation, reverse, hard, variant)
func cycle(rotation: usize, reverse: bool, hard: bool, variant: i64) -> !:
var numbers: f64[]
var points: Vector3[]
let surface = try Surface(4 if variant == 3 else 0, Vector3(), Vector3(1.0, 0.0, 0.0), Vector3(0.0, 0.0, 1.0), 1.0, 0.0, points, numbers, numbers, numbers, 0, 0, 0, 0)
defer surface.close()
let compound = variant == 1 or variant == 2
let first_uses = [1, 2, 3, 4, 5, 6]
let second_uses = [-2, 7, -6, 8] if compound else [-2, 7, -5, 8]
let third_uses = [-3, 9, -5, 10]
let faces = [try oriented(first_uses[..<(6 if compound else (usize)5)], rotation, reverse),
try oriented(second_uses, rotation, reverse), try oriented(third_uses, rotation, reverse)]
defer:
for face in faces: face.close()
var original = PatchSides()
original.valid = true
original.starts = [0, 1, 3, 4] if compound else [0, 1, 2, 3]
original.lengths = [1, 2, 1, 2] if compound else [1, 1, 1, 2]
var simple = PatchSides()
simple.valid = true
simple.starts = [0, 1, 2, 3]
simple.lengths = [1, 1, 1, 1]
var sides = [reindex(original, faces[0].uses.length, rotation, reverse),
reindex(simple, 4, rotation, reverse), reindex(simple, 4, rotation, reverse)]
# Variant 1 leaves N+A=N+B, which is feasible and must not be cut.
# Variant 2 also joins A/B through the third patch: exact cancellation.
if variant != 2: sides[2].valid = false
var plans = [GridLayout(), GridLayout(), GridLayout()]
defer:
for plan in plans: plan.close()
for at in 0..<(usize)3:
plans[at].flow = try new bool[faces[at].uses.length] --- in memory.heap
plans[at].rows = try new Stations[faces[at].uses.length] --- in memory.heap
for use in 0..<faces[at].uses.length: plans[at].rows[use] = Stations()
for use in 0..<faces[at].uses.length:
let index = edge_index(faces[at].uses[use])
plans[at].flow[use] = not (hard and index == 1) and (at != 2 or variant == 2)
try plans[at].rows[use].open(1025)
for t in [0.0, 0.5, 1.0]: _ = try plans[at].rows[use].insert(t, 1e-12)
let expected = variant == 0 and not hard
let changed = try cut_impossible(faces, [surface], sides, plans, 10)
if changed != (1 if expected else (usize)0) or plans[0].cut_first != expected:
error(invalid, "mapped count proof confused a positive cycle with feasible or stopped flow")
if plans[1].cut_first or plans[2].cut_first: error(invalid, "mapped count proof cut an unrelated patch")
if try cut_impossible(faces, [surface], sides, plans, 10) != 0: error(invalid, "mapped count proof is not idempotent")
for at in 0..<(usize)3:
for use in 0..<faces[at].uses.length:
let row = plans[at].rows[use]
let index = edge_index(faces[at].uses[use])
let flow = not (hard and index == 1) and (at != 2 or variant == 2)
if plans[at].flow[use] != flow or row.count != 3 or row.values[0] != 0.0 or row.values[1] != 0.5 or row.values[2] != 1.0:
error(invalid, "mapped feasibility changed a seam classification or existing station")
if not expected: return
let edges = try new Curve[10] --- in memory.heap
defer free(edges) in memory.heap
var created: usize = 0
defer close_edges(edges[..<created])
let cuts = try new Stations[10] --- in memory.heap
defer free(cuts) in memory.heap
var counts: usize[10]
for at in 0..<(usize)10: cuts[at] = Stations()
defer:
for row in cuts: row.close()
for at in 0..<(usize)10:
edges[at] = try Curve(0, (i64)at, (i64)at + 1, Vector3(), Vector3(), Vector3(), 0.0, [Vector3(), Vector3(1.0, 0.0, 0.0)], numbers, numbers, 0, true)
created += 1
counts[at] = 2
try cuts[at].open(1025)
for t in [0.0, 0.5, 1.0]: _ = try cuts[at].insert(t, 1e-12)
let metrics = try measure_curves(edges)
defer close_metrics(metrics)
try equalize_counts(edges, faces, sides, metrics, plans, counts)
let settled = try new Settled[faces.length] --- in memory.heap
defer free(settled) in memory.heap
for at in 0..<settled.length: settled[at] = Settled()
try balance(faces, edges, sides, cuts, metrics, plans, 1e-6, settled)
for at in 0..<(usize)10:
if counts[at] != 2 or cuts[at].count != 3: error(invalid, "a rejected count cycle resumed during count/phase propagation")
func oriented(uses: const i64[], rotation: usize, reverse: bool) -> BrepFace!:
let shifted = try new i64[uses.length] --- in memory.heap
defer free(shifted) in memory.heap
for at in 0..<uses.length:
shifted[at] = -uses[(rotation + uses.length - at) % uses.length] if reverse else uses[(rotation + at) % uses.length]
return try BrepFace(0, shifted, [(i64)uses.length], not reverse)
func reindex(original: PatchSides, count: usize, rotation: usize, reverse: bool) -> PatchSides:
var result = original
for axis in 0..<(usize)4:
let old = (original.starts[axis] + original.lengths[axis] - 1) % count if reverse else original.starts[axis]
let new_axis = (4 - axis) % 4 if reverse else axis
result.starts[new_axis] = (rotation + count - old) % count if reverse else (old + count - rotation % count) % count
result.lengths[new_axis] = original.lengths[axis]
return result
func close_edges(edges: const Curve[]):
for edge in edges: edge.close()
func retain_cut_owner() -> !:
# A prior topology decision owns the cut path even if the later local
# geometry-only policy considers this rectangle perfectly mappable.
let p = [Vector3(), Vector3(1.0, 0.0, 0.0), Vector3(1.0, 1.0, 0.0), Vector3(0.0, 1.0, 0.0)]
var numbers: f64[]
var no_points: Vector3[]
let surface = try Surface(0, Vector3(), Vector3(1.0, 0.0, 0.0), Vector3(0.0, 0.0, 1.0), 0.0, 0.0, no_points, numbers, numbers, numbers, 0, 0, 0, 0)
defer surface.close()
let face = try BrepFace(0, [1, 2, 3, 4], [4], true)
defer face.close()
let edges = try new Curve[4] --- in memory.heap
defer free(edges) in memory.heap
var created: usize = 0
defer close_edges(edges[..<created])
var cuts = [Stations(), Stations(), Stations(), Stations()]
defer:
for cut in cuts: cut.close()
var plans = [GridLayout()]
defer plans[0].close()
plans[0].cut_first = true
plans[0].flow = try new bool[4] --- in memory.heap
plans[0].rows = try new Stations[4] --- in memory.heap
for at in 0..<(usize)4: plans[0].rows[at] = Stations()
for at in 0..<(usize)4:
edges[at] = try Curve(0, (i64)at, (i64)((at + 1) % 4), Vector3(), Vector3(), Vector3(), 0.0, [p[at], p[(at + 1) % 4]], numbers, numbers, 0, true)
created += 1
plans[0].flow[at] = false
try plans[0].rows[at].open(1025)
try cuts[at].open(1025)
for t in [0.0, 0.5, 1.0]:
_ = try plans[0].rows[at].insert(t, 1e-12)
_ = try cuts[at].insert(t, 1e-12)
var side = PatchSides()
side.valid = true
side.starts = [0, 1, 2, 3]
side.lengths = [1, 1, 1, 1]
let metrics = try measure_curves(edges)
defer close_metrics(metrics)
try plan_layouts(p, edges, [surface], [face], [side], cuts, metrics, plans, 16, 1e-6, 0.0)
if not plans[0].valid or not plans[0].cut_first: error(invalid, "local chart policy discarded an existing topology cut owner")