1b-agent/OneCAD
1
0 Fork 0
forked from 1b-agent/solidcraft-upstream
Code Pull Requests Activity
Files
fbd8ada754de2ff84a75f243157ded43c870f28e
OneCAD/crates/sketch/src/construct_tests.rs
T
NOWN-DEV 24974e6f37 fix: a dimension from linked geometry keeps its side when the source moves past it (#614) 
A point dimensioned from linked geometry (projected, included or intersected) keeps its side when a parameter moves the link's source past it: the solve reads sides and turns from the stored state instead of from beside the moved line, both on recompute and when editing the sketch.

Co-authored-by: NOWN-DEV <[email protected]>
2026-10-13 05:15:15 -04:00

1091 lines
50 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Harness for the constructive seed: branch preservation on dimension edits, no freezing of
//! points that keep a degree of freedom, drag continuity, and hostile input. Deterministic
//! (fixed LCG seeds), no timing.
use solidcraft_geom::Vec2;
use crate::construct::{Placement, seed};
use crate::decompose::Budget;
use crate::solver::points_on_curves;
use crate::tests::{Lcg, given, seed_of, seeded, v};
use crate::*;
fn orientation(a: Vec2, b: Vec2, c: Vec2) -> f64 {
(b - a).cross(c - a).signum()
}
/// Fan-triangulated k-gon (diagonals from vertex 0), vertices 0 and 1 fixed, every other
/// dimension scaled by a factor in `lo..hi`; only edits where every fan triangle still exists
/// are kept, so an orientation-preserving solution always exists. Returns (failed, mirrored)
/// over 500 edits.
fn fan(rnd: &mut Lcg, k: usize, lo: f64, hi: f64, on: bool) -> (usize, usize) {
let (mut failed, mut mirrored, mut kept) = (0, 0, 0);
while kept < 500 {
let mut sk = Sketch::new();
let ids: Vec<usize> = (0..k)
.map(|i| {
let t = i as f64 / k as f64 * std::f64::consts::TAU;
let r = 30.0 + rnd.next() * 10.0;
sk.add_point(v(r * t.cos(), r * t.sin()), None).unwrap()
})
.collect();
let pos = |sk: &Sketch, i: usize| sk.points[ids[i]].pos;
let orient = |sk: &Sketch| (1..k - 1).map(|i| orientation(pos(sk, 0), pos(sk, i), pos(sk, i + 1))).collect::<Vec<_>>();
let before = orient(&sk);
let mut dist = std::collections::HashMap::new();
for i in 1..k {
let j = (i + 1) % k;
dist.insert((i, j), pos(&sk, i).dist(pos(&sk, j)) * (lo + rnd.next() * (hi - lo)));
}
dist.insert((0, 1), pos(&sk, 0).dist(pos(&sk, 1)));
for i in 2..k {
dist.insert((0, i), pos(&sk, 0).dist(pos(&sk, i)) * (lo + rnd.next() * (hi - lo)));
}
dist.insert((0, k - 1), dist[&(k - 1, 0)]);
let feasible = (1..k - 1).all(|i| {
let (a, b, c) = (dist[&(0, i)], dist[&(i, i + 1)], dist[&(0, i + 1)]);
a + b > c * 1.02 && a + c > b * 1.02 && b + c > a * 1.02
});
if !feasible {
continue;
}
kept += 1;
for &p in &ids[..2] {
sk.add_constraint(ConstraintKind::Fix { p }, None).unwrap();
}
for i in 1..k {
let j = (i + 1) % k;
sk.add_constraint(ConstraintKind::Distance { p: ids[i], q: ids[j], value: dist[&(i, j)] }, None).unwrap();
}
for i in 2..k - 1 {
sk.add_constraint(ConstraintKind::Distance { p: ids[0], q: ids[i], value: dist[&(0, i)] }, None).unwrap();
}
let rep = seeded(on, || solve(&mut sk));
if !rep.ok() {
failed += 1;
} else if orient(&sk) != before {
mirrored += 1;
}
}
(failed, mirrored)
}
fn fan_table(on: bool) -> Vec<(f64, f64, usize, usize, usize)> {
let mut rnd = Lcg(99);
let mut out = Vec::new();
for (lo, hi) in [(0.9, 1.15), (0.7, 1.6), (0.5, 2.5)] {
for k in [4usize, 5, 6, 8, 12] {
let (failed, mirrored) = fan(&mut rnd, k, lo, hi, on);
out.push((lo, hi, k, failed, mirrored));
}
}
out
}
#[test]
fn fan_polygons_keep_every_triangle_on_dimension_edits() {
let table = fan_table(true);
for (lo, hi, k, failed, mirrored) in &table {
eprintln!("seed on {lo}–{hi}× {k:>2}-gon: {failed} failed, {mirrored}/500 mirrored");
}
assert!(table.iter().all(|row| row.3 == 0 && row.4 == 0), "{table:?}");
}
/// The measurement the seed is judged against: without it, LM mirrors fan triangles.
#[test]
fn fan_polygons_mirror_without_the_seed() {
let table = fan_table(false);
for (lo, hi, k, failed, mirrored) in &table {
eprintln!("seed off {lo}–{hi}× {k:>2}-gon: {failed} failed, {mirrored}/500 mirrored");
}
let wide_12 = table.iter().find(|r| r.0 == 0.5 && r.2 == 12).map(|r| r.4).unwrap();
assert!(wide_12 > 100, "{table:?}");
}
/// Base fixed, apex near the base, both sides edited; also far from the origin.
fn triangle_edits(on: bool) -> Vec<(f64, usize, usize)> {
let mut rnd = Lcg(99);
let mut out = Vec::new();
for off in [0.0, 1e4, 1e6] {
let (mut flips, mut fails) = (0, 0);
for _ in 0..2000 {
let o = v(off, off);
let mut sk = Sketch::new();
let a = sk.add_point(o, None).unwrap();
let b = sk.add_point(o + v(40.0, 0.0), None).unwrap();
let c = sk.add_point(o + v(5.0 + rnd.next() * 30.0, 0.05 + rnd.next() * 3.0), None).unwrap();
for p in [a, b] {
sk.add_constraint(ConstraintKind::Fix { p }, None).unwrap();
}
let pc = sk.points[c].pos;
sk.add_constraint(ConstraintKind::Distance { p: a, q: c, value: pc.dist(o) }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: b, q: c, value: pc.dist(o + v(40.0, 0.0)) }, None).unwrap();
let (r1, r2) = loop {
let (r1, r2) = (5.0 + rnd.next() * 60.0, 5.0 + rnd.next() * 60.0);
if r1 + r2 > 41.0 && (r1 - r2).abs() < 39.0 {
break (r1, r2);
}
};
sk.constraints[2].kind.set_value(r1);
sk.constraints[3].kind.set_value(r2);
if !seeded(on, || solve(&mut sk)).ok() {
fails += 1;
} else if sk.points[c].pos.y < off {
flips += 1;
}
}
out.push((off, flips, fails));
}
out
}
#[test]
fn triangle_edits_keep_the_apex_side_far_from_the_origin() {
for on in [false, true] {
for (off, flips, fails) in triangle_edits(on) {
eprintln!("seed {} triangle at offset {off:e}: {flips}/2000 mirrored, {fails} failed", if on { "on " } else { "off" });
if on {
assert_eq!((flips, fails), (0, 0), "offset {off:e}");
}
}
}
}
/// Two triangles joined by three links: no point beyond the first triangle has two loci on
/// placed points, so the seed must leave them to LM (projecting each onto its one locus would
/// freeze a point that still has a degree of freedom).
fn linkage() -> (Sketch, Vec<usize>) {
const TRUE: [(f64, f64); 6] = [(0.0, 0.0), (40.0, 0.0), (18.0, 30.0), (8.0, 55.0), (52.0, 48.0), (30.0, 80.0)];
const PAIRS: [(usize, usize); 9] = [(0, 1), (1, 2), (2, 0), (3, 4), (4, 5), (5, 3), (0, 3), (1, 4), (2, 5)];
let mut sk = Sketch::new();
let ids: Vec<usize> = TRUE
.iter()
.enumerate()
.map(|(i, p)| {
let at = if i == 0 { *p } else { (p.0 + 1.5 * ((i * 7 % 5) as f64 - 2.0), p.1 - 1.2 * ((i * 3 % 4) as f64 - 1.5)) };
sk.add_point(v(at.0, at.1), None).unwrap()
})
.collect();
sk.add_constraint(ConstraintKind::Fix { p: ids[0] }, None).unwrap();
let l = sk.add_line_pts(ids[0], ids[1], None).unwrap();
sk.add_constraint(ConstraintKind::Horizontal { l }, None).unwrap();
for (a, b) in PAIRS {
let value = v(TRUE[a].0, TRUE[a].1).dist(v(TRUE[b].0, TRUE[b].1));
sk.add_constraint(ConstraintKind::Distance { p: ids[a], q: ids[b], value }, None).unwrap();
}
(sk, ids)
}
/// Two triangles joined by three links (as [`linkage`]), every distance scaled by 0.5–2.5×.
fn edited_linkage(rnd: &mut Lcg) -> Sketch {
let (mut sk, _) = linkage();
for c in sk.constraints.iter_mut() {
if let Some(v) = c.kind.value() {
c.kind.set_value(v * (0.5 + rnd.next() * 2.0));
}
}
sk
}
/// Pinning the base triangle exactly can leave LM stuck on the rest where the plain start
/// solves; the solve then falls back to the plain start, so the seed never loses a solution.
#[test]
fn edited_linkages_never_fail_where_the_plain_start_solves() {
let mut rnd = Lcg(7);
let (mut lost, mut gained) = (Vec::new(), Vec::new());
for i in 0..500 {
let sk = edited_linkage(&mut rnd);
let (mut a, mut b) = (sk.clone(), sk.clone());
let on = seeded(true, || solve(&mut a)).ok();
let off = seeded(false, || solve(&mut b)).ok();
if off && !on {
lost.push(i);
}
if on && !off {
gained.push(i);
}
}
eprintln!("edited linkages: seeded solves {} the plain start does not ({gained:?}), loses {lost:?}", gained.len());
assert!(lost.is_empty(), "{lost:?}");
}
/// An edited linkage (case 28 of the family above) where LM from the seeded start alone fails
/// and the plain start solves.
#[test]
fn edited_linkage_the_seeded_start_alone_cannot_solve() {
let (mut sk, _) = linkage();
let values = [
46.108603805595436,
66.03877723361462,
44.29474034815241,
49.872556594908566,
70.62035270311223,
42.30949365900061,
95.95247718421143,
62.63491114263336,
39.69273507189351,
];
for (c, v) in sk.constraints.iter_mut().filter(|c| c.kind.value().is_some()).zip(values) {
c.kind.set_value(v);
}
let rep = solve(&mut sk);
assert!(rep.ok(), "{rep:?}");
}
#[test]
fn triconnected_linkage_still_solves_exactly() {
let (mut sk, ids) = linkage();
let s = seed_of(&sk);
assert_eq!(s.placed_by[ids[0]], Some(Placement::Given));
assert!(matches!(s.placed_by[ids[1]], Some(Placement::TwoLoci { transversal: true, .. })));
assert!(matches!(s.placed_by[ids[2]], Some(Placement::TwoLoci { transversal: true, .. })));
for &p in &ids[3..] {
assert_eq!(s.placed_by[p], None, "point {p} has one locus only");
}
let rep = solve(&mut sk);
assert!(rep.ok(), "{rep:?}");
assert_eq!(rep.dof, 0);
let worst = sk
.constraints
.iter()
.filter_map(|c| match c.kind {
ConstraintKind::Distance { p, q, value } => Some((sk.points[p].pos.dist(sk.points[q].pos) - value).abs()),
_ => None,
})
.fold(0.0, f64::max);
eprintln!("linkage: {} iterations, worst distance error {worst:e}", rep.iterations);
assert!(worst < 1e-9, "{worst}");
}
/// n×n grid, origin fixed, every row and column edge horizontal/vertical with a distance,
/// started ±1 mm off.
fn grid(n: usize) -> Sketch {
let mut sk = Sketch::new();
let mut rnd = Lcg(12345);
let mut id = vec![vec![0; n]; n];
for (r, row) in id.iter_mut().enumerate() {
for (c, slot) in row.iter_mut().enumerate() {
let j = if r == 0 && c == 0 { v(0.0, 0.0) } else { v(rnd.next() * 2.0 - 1.0, rnd.next() * 2.0 - 1.0) };
*slot = sk.add_point(v(c as f64 * 10.0, r as f64 * 10.0) + j, None).unwrap();
}
}
sk.add_constraint(ConstraintKind::Fix { p: id[0][0] }, None).unwrap();
let rows = id.iter().flat_map(|row| row.windows(2).map(|w| (w[0], w[1], true)));
let cols = (0..n).flat_map(|c| id.windows(2).map(move |w| (w[0][c], w[1][c], false)));
for (p, q, horizontal) in rows.chain(cols).collect::<Vec<_>>() {
let l = sk.add_line_pts(p, q, None).unwrap();
sk.add_constraint(if horizontal { ConstraintKind::Horizontal { l } } else { ConstraintKind::Vertical { l } }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p, q, value: 10.0 }, None).unwrap();
}
sk
}
#[test]
fn grid_from_a_perturbed_start_is_constructed_whole() {
let mut sk = grid(20);
let s = seed_of(&sk);
// Point 0 is the sketch origin, point 1 the fixed grid corner.
assert_eq!(s.placed_by[1], Some(Placement::Given));
assert!(s.placed_by.iter().skip(2).all(|p| matches!(p, Some(Placement::TwoLoci { transversal: true, .. }))));
let rep = solve(&mut sk);
assert!(rep.ok(), "{rep:?}");
assert_eq!(rep.dof, 0);
eprintln!("20×20 grid ±1 mm: {} iterations", rep.iterations);
for (i, p) in sk.points.iter().enumerate().skip(1) {
let (r, c) = ((i - 1) / 20, (i - 1) % 20);
assert!(p.pos.dist(v(c as f64 * 10.0, r as f64 * 10.0)) < 1e-9, "{i}: {:?}", p.pos);
}
}
/// Every grid point is constructed transversally from two loci and its rows hold there: LM
/// gets no variable, and the rank analysis eliminates them all.
#[test]
fn constructed_grid_leaves_nothing_to_lm() {
let sk = grid(20);
let mut solved = sk.clone();
crate::solver::lm_vars::take();
let rep = seeded(true, || solve(&mut solved));
assert_eq!(crate::solver::lm_vars::take(), 0);
assert!(rep.ok() && rep.dof == 0 && rep.point_determined.iter().all(|d| *d), "{rep:?}");
// Without the seed LM solves all of them, to the same outcome.
let mut plain = sk.clone();
let without = seeded(false, || solve(&mut plain));
assert_eq!(crate::solver::lm_vars::take(), 2 * (20 * 20 - 1));
assert_eq!((without.status, without.dof, &without.point_determined), (rep.status, rep.dof, &rep.point_determined));
for (a, b) in solved.points.iter().zip(&plain.points) {
assert!(a.pos.dist(b.pos) < 1e-6, "{:?} {:?}", a.pos, b.pos);
}
}
/// A point the construction cannot place (one locus only) is all LM iterates on: the
/// constructed grid it hangs off stays where the seed put it, as constants.
#[test]
fn lm_iterates_on_what_the_construction_leaves() {
let mut sk = grid(8);
let corner = sk.points.len() - 1;
let q = sk.add_point(sk.points[corner].pos + v(7.0, 0.0), None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: corner, q, value: 5.0 }, None).unwrap();
crate::solver::lm_vars::take();
let rep = seeded(true, || solve(&mut sk.clone()));
assert_eq!(crate::solver::lm_vars::take(), 2, "only the hanging point");
assert!(rep.ok() && rep.dof == 1, "{rep:?}");
assert!(!rep.point_determined[q] && rep.point_determined[corner]);
// The outcome is the one of the unseeded solve, which iterates on every point.
solve(&mut sk);
}
/// A pinned solve that fails is followed by one whole-component solve, from where the
/// component would have started without the seed: never again from the seeded start it failed
/// from. Here the hanging point is held at two distances from one corner.
#[test]
fn a_failed_pinned_solve_is_retried_once() {
let mut sk = grid(4);
let corner = sk.points.len() - 1;
let q = sk.add_point(sk.points[corner].pos + v(7.0, 0.0), None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: corner, q, value: 5.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: corner, q, value: 9.0 }, None).unwrap();
crate::solver::lm_vars::runs();
let rep = seeded(true, || solve(&mut sk.clone()));
assert!(!rep.ok(), "{rep:?}");
assert_eq!(crate::solver::lm_vars::runs(), 2, "the pinned solve and the unseeded retry");
}
/// Move point `q` to `to` holding it, as a drag does; `reference` from before the move.
fn drag(sk: &mut Sketch, q: usize, to: Vec2, with_reference: bool) -> bool {
let before: Vec<Vec2> = sk.points.iter().map(|p| p.pos).collect();
let mut t = sk.clone();
t.points[q].pos = to;
let hold = Hold { points: vec![q], radii: vec![] };
let ok = solve_with(&mut t, &hold, with_reference.then_some(before.as_slice()), Analysis::Full, None).ok();
if ok {
*sk = t;
}
ok
}
#[test]
fn dragging_a_base_across_and_back_returns_to_the_start() {
let mut sk = Sketch::new();
let a = sk.add_point(v(0.0, 0.0), None).unwrap();
let b = sk.add_point(v(40.0, 0.0), None).unwrap();
let c = sk.add_point(v(20.0, 15.0), None).unwrap();
sk.add_constraint(ConstraintKind::Fix { p: a }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: a, q: c, value: 25.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: b, q: c, value: 25.0 }, None).unwrap();
let start = sk.points[c].pos;
let side = |sk: &Sketch| orientation(sk.points[a].pos, sk.points[b].pos, sk.points[c].pos);
for with_reference in [true, false] {
let mut t = sk.clone();
assert!(drag(&mut t, b, v(-40.0, 0.0), with_reference));
// Measured on the moved base, the apex has already changed side: only the reference
// knows which side it was on.
if with_reference {
assert_eq!(side(&t), side(&sk), "the apex kept its side of the base");
}
assert!(drag(&mut t, b, v(40.0, 0.0), with_reference));
assert!(t.points[c].pos.dist(start) < 1e-7, "{:?}", t.points[c].pos);
}
}
/// Two-link arm: shoulder fixed, hand held at the cursor, one-jump drags along paths clear of
/// the arm's singular poses. The links are dimensioned, or (`equal`) the upper arm is and the
/// forearm is held equal to it. Returns elbow flips over 1000 drags.
fn elbow_flips(with_reference: bool, on: bool, equal: bool) -> usize {
let mut rnd = Lcg(11);
let (a, b) = if equal { (25.0, 25.0) } else { (30.0, 20.0) };
let (lo, hi) = ((a - b) + 3.0, a + b - 3.0);
let (mut flips, mut kept) = (0, 0);
while kept < 1000 {
let th1 = rnd.next() * std::f64::consts::TAU;
let bend = (0.4 + rnd.next() * 2.2) * if rnd.next() < 0.5 { 1.0 } else { -1.0 };
let v2 = Vec2::from_angle(th1) * a;
let v3 = v2 + Vec2::from_angle(th1 + bend) * b;
let tr = lo + rnd.next() * (hi - lo);
let to = Vec2::from_angle(rnd.next() * std::f64::consts::TAU) * tr;
if !(0..=100).all(|i| (lo..=hi).contains(&v3.lerp(to, i as f64 / 100.0).len())) {
continue;
}
kept += 1;
let mut sk = Sketch::new();
let p1 = sk.add_point(Vec2::ZERO, None).unwrap();
let p2 = sk.add_point(v2, None).unwrap();
let p3 = sk.add_point(v3, None).unwrap();
sk.add_constraint(ConstraintKind::Fix { p: p1 }, None).unwrap();
let upper = sk.add_line_pts(p1, p2, None).unwrap();
let fore = sk.add_line_pts(p2, p3, None).unwrap();
if equal {
sk.add_constraint(ConstraintKind::Length { l: upper, value: a }, None).unwrap();
sk.add_constraint(ConstraintKind::Equal { a: upper, b: fore }, None).unwrap();
} else {
sk.add_constraint(ConstraintKind::Distance { p: p1, q: p2, value: a }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: p2, q: p3, value: b }, None).unwrap();
}
let side = |sk: &Sketch| orientation(sk.points[p1].pos, sk.points[p3].pos, sk.points[p2].pos);
let before = side(&sk);
seeded(on, || drag(&mut sk, p3, to, with_reference));
if side(&sk) != before {
flips += 1;
}
}
flips
}
#[test]
fn one_jump_drag_keeps_the_elbow_with_the_reference() {
let off = elbow_flips(false, false, false);
let current = elbow_flips(false, true, false);
let reference = elbow_flips(true, true, false);
eprintln!("two-link arm, one jump: {off}/1000 flips without seed, {current} seeded on current positions, {reference} seeded on the reference");
assert_eq!(reference, 0);
}
/// The forearm's length comes from an Equal to the dimensioned upper arm: the seed reads it,
/// so a one-jump drag keeps the elbow too.
#[test]
fn one_jump_drag_keeps_an_equal_linked_elbow() {
let off = elbow_flips(true, false, true);
let reference = elbow_flips(true, true, true);
eprintln!("equal-linked arm, one jump: {off}/1000 flips without seed, {reference} seeded on the reference");
assert_eq!(reference, 0);
}
/// A fillet in a corner: L1 horizontal from a fixed end, arc tangent to L1 and L2, radius 5.
fn fillet() -> (Sketch, usize, usize, usize) {
let mut sk = Sketch::new();
let l1 = sk.add_line(v(40.0, 0.0), v(5.0, 0.0), None, None, None).unwrap();
let (s1, e1) = sk.curves[l1].kind.ends().unwrap();
let l2 = sk.add_line(v(0.0, 5.0), v(0.0, 80.0), None, None, None).unwrap();
let (s2, e2) = sk.curves[l2].kind.ends().unwrap();
let arc = sk.add_arc(v(5.0, 5.0), v(0.0, 5.0), v(5.0, 0.0), [None, Some(s2), Some(e1)], None).unwrap();
let CurveKind::Arc { c, .. } = sk.curves[arc].kind else { panic!() };
sk.add_constraint(ConstraintKind::Fix { p: s1 }, None).unwrap();
sk.add_constraint(ConstraintKind::Horizontal { l: l1 }, None).unwrap();
sk.add_constraint(ConstraintKind::Radius { c: arc, value: 5.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Tangent { a: l1, b: arc }, None).unwrap();
sk.add_constraint(ConstraintKind::Tangent { a: l2, b: arc }, None).unwrap();
(sk, c, e2, s2)
}
#[test]
fn solved_fillet_stays_put_and_stays_in_its_corner_while_dragged() {
let (mut sk, c, e2, s2) = fillet();
let before = sk.points.clone();
assert!(solve(&mut sk).ok());
for (p, q) in sk.points.iter().zip(&before) {
assert!(p.pos.dist(q.pos) < 1e-9, "{} moved to {:?}", p.id, p.pos);
}
let inside = |sk: &Sketch| {
let (cc, s, e) = (sk.points[c].pos, sk.points[s2].pos, sk.points[e2].pos);
cc.y > 0.0 && (e - s).cross(cc - s) < 0.0
};
for to in [v(-30.0, 75.0), v(20.0, 75.0), v(-60.0, 40.0), v(0.0, 80.0)] {
for with_reference in [false, true] {
let mut t = sk.clone();
for k in 1..=10 {
let at = t.points[e2].pos.lerp(to, k as f64 / 10.0);
drag(&mut t, e2, at, with_reference);
assert!(inside(&t), "centre left the corner dragging to {to:?}: {:?}", t.points[c].pos);
}
}
}
}
#[test]
fn hostile_input_neither_panics_nor_changes_the_report() {
let base = || {
let mut sk = Sketch::new();
let a = sk.add_point(v(10.0, 0.0), None).unwrap();
let b = sk.add_point(v(5.0, 8.0), None).unwrap();
let l = sk.add_line_pts(0, a, None).unwrap();
sk.add_constraint(ConstraintKind::Horizontal { l }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: 0, q: a, value: 10.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: 0, q: b, value: 9.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: a, q: b, value: 9.0 }, None).unwrap();
(sk, a, b, l)
};
let push = |sk: &mut Sketch, kind: ConstraintKind| {
sk.constraints.push(Constraint { id: format!("h{}", sk.constraints.len()), kind, param: None, driven: false, text: None })
};
let cases: Vec<Box<dyn Fn(&mut Sketch, usize, usize, usize)>> = vec![
Box::new(|sk, _, _, _| sk.constraints[1].kind.set_value(f64::NAN)),
Box::new(|sk, _, _, _| sk.constraints[2].kind.set_value(f64::INFINITY)),
Box::new(|sk, _, _, _| sk.constraints[3].kind.set_value(1e300)),
Box::new(|sk, _, _, _| sk.constraints[2].kind.set_value(-4.0)),
Box::new(|sk, _, _, _| sk.constraints[3].kind.set_value(0.0)),
Box::new(|sk, _, b, _| sk.points[b].pos = v(f64::NAN, 1.0)),
Box::new(|sk, a, _, _| sk.points[a].pos = v(f64::INFINITY, 0.0)),
Box::new(|sk, _, b, _| sk.points[b].pos = v(1e300, -1e300)),
Box::new(move |sk, _, b, _| push(sk, ConstraintKind::Distance { p: b, q: 999, value: 3.0 })),
Box::new(move |sk, a, _, _| push(sk, ConstraintKind::DistanceX { p: a, q: usize::MAX, value: 3.0 })),
Box::new(move |sk, _, _, _| push(sk, ConstraintKind::Horizontal { l: 77 })),
Box::new(move |sk, _, b, _| push(sk, ConstraintKind::Coincident { p: b, q: b })),
Box::new(move |sk, _, _, l| push(sk, ConstraintKind::Length { l, value: f64::NAN })),
Box::new(move |sk, a, b, _| push(sk, ConstraintKind::DistanceY { p: a, q: b, value: f64::NEG_INFINITY })),
];
// Every solve here runs through the crate-wide seed-on/seed-off comparison (`solve_from`).
for (i, case) in cases.iter().enumerate() {
let (mut sk, a, b, l) = base();
case(&mut sk, a, b, l);
let mut mask = given(&sk);
mask.push(true);
let s = seed(&sk, &mask, Some(&[v(f64::NAN, 0.0)]), false, &points_on_curves(&sk), &mut Budget::full());
assert!(s.pos.iter().flatten().all(|p| p.is_finite()), "case {i}: {s:?}");
let n = sk.points.len();
for reference in [None, Some(vec![Vec2::ZERO; 1]), Some(vec![v(f64::NAN, f64::INFINITY); n]), Some(vec![Vec2::ZERO; n + 3])] {
let hold = Hold { points: vec![usize::MAX], radii: vec![usize::MAX] };
let mut t = sk.clone();
match &reference {
Some(r) => solve_with(&mut t, &hold, Some(r), Analysis::Full, None),
None => solve_with(&mut t, &hold, None, Analysis::Full, None),
};
}
}
}
/// A point whose second anchor is placed after it was first examined (it comes earlier in the
/// point list than that anchor) is examined again and placed.
#[test]
fn points_out_of_dependency_order_are_seeded() {
let mut sk = Sketch::new();
let a = sk.add_point(v(0.0, 0.0), None).unwrap();
let d = sk.add_point(v(-10.0, 25.0), None).unwrap();
let b = sk.add_point(v(40.0, 0.0), None).unwrap();
let c = sk.add_point(v(20.0, 15.0), None).unwrap();
for p in [a, b] {
sk.add_constraint(ConstraintKind::Fix { p }, None).unwrap();
}
sk.add_constraint(ConstraintKind::Distance { p: a, q: c, value: 26.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: b, q: c, value: 26.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: a, q: d, value: 28.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: c, q: d, value: 30.0 }, None).unwrap();
let s = seed_of(&sk);
assert!(matches!(s.placed_by[c], Some(Placement::TwoLoci { transversal: true, .. })), "{s:?}");
assert_eq!(s.placed_by[d], Some(Placement::TwoLoci { a, b: c, transversal: true }), "{s:?}");
}
/// Tangency and concentricity are judged on the loci's own size, not on how far from the
/// origin they are.
#[test]
fn far_from_the_origin_a_flat_triangle_still_has_two_branches() {
// Apex 0.05 mm above a 40 mm base, 1e5 mm from the origin.
let o = v(1e5, 1e5);
let mut sk = Sketch::new();
let a = sk.add_point(o, None).unwrap();
let b = sk.add_point(o + v(40.0, 0.0), None).unwrap();
let c = sk.add_point(o + v(20.0, 0.05), None).unwrap();
for p in [a, b] {
sk.add_constraint(ConstraintKind::Fix { p }, None).unwrap();
}
let r = v(20.0, 0.05).len();
sk.add_constraint(ConstraintKind::Distance { p: a, q: c, value: r }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: b, q: c, value: r }, None).unwrap();
let s = seed_of(&sk);
assert_eq!(s.placed_by[c], Some(Placement::TwoLoci { a, b, transversal: true }));
assert!(s.pos[c].unwrap().dist(o + v(20.0, 0.05)) < 1e-6, "{:?}", s.pos[c]);
// Circles about centres 1 mm apart, 1e6 mm from the origin, are not concentric.
let o = v(1e6, 1e6);
let mut sk = Sketch::new();
let a = sk.add_point(o, None).unwrap();
let b = sk.add_point(o + v(1.0, 0.0), None).unwrap();
let c = sk.add_point(o + v(0.4, -9.0), None).unwrap();
for p in [a, b] {
sk.add_constraint(ConstraintKind::Fix { p }, None).unwrap();
}
sk.add_constraint(ConstraintKind::Distance { p: a, q: c, value: 10.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: b, q: c, value: 10.0 }, None).unwrap();
let s = seed_of(&sk);
assert_eq!(s.placed_by[c], Some(Placement::TwoLoci { a, b, transversal: true }));
assert!(s.pos[c].unwrap().dist(o + v(0.5, -(100.0f64 - 0.25).sqrt())) < 1e-6, "{:?}", s.pos[c]);
}
/// Loci that only touch leave the point where it was: the solve is exactly the unseeded one.
#[test]
fn touching_loci_are_left_to_lm() {
let mut sk = Sketch::new();
let a = sk.add_point(v(0.0, 0.0), None).unwrap();
let b = sk.add_point(v(40.0, 0.0), None).unwrap();
let c = sk.add_point(v(18.0, 3.0), None).unwrap();
for p in [a, b] {
sk.add_constraint(ConstraintKind::Fix { p }, None).unwrap();
}
sk.add_constraint(ConstraintKind::Distance { p: a, q: c, value: 15.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: b, q: c, value: 25.0 }, None).unwrap();
let s = seed_of(&sk);
assert_eq!(s.placed_by[c], Some(Placement::TwoLoci { a, b, transversal: false }));
let (mut on, mut off) = (sk.clone(), sk.clone());
let with = seeded(true, || solve(&mut on));
let without = seeded(false, || solve(&mut off));
assert_eq!(on.points, off.points);
assert_eq!((with.status, with.iterations), (without.status, without.iterations));
}
/// The canonical bracket (Owen's articulation-pair case) behind a row–column point, with a
/// point on top: O2 is placed by propagation (level with O1, under F), P Q R only by the
/// decomposition (none has two placed neighbours), and S by propagation again (level with P,
/// under Q: relations the decomposition does not combine). Returns the sketch and
/// [O1, F, O2, P, Q, R, S].
fn bracket_chain() -> (Sketch, [usize; 7]) {
let truth = [v(0.0, 0.0), v(60.0, 40.0), v(60.0, 0.0), v(10.0, 30.0), v(45.0, 35.0), v(25.0, 55.0), v(45.0, 30.0)];
let mut sk = Sketch::new();
let mut ids = [0; 7];
for (i, t) in truth.iter().enumerate() {
// The free points start a few mm off, as after an edit.
let off = if i < 2 { v(0.0, 0.0) } else { v(1.5 * (i as f64 - 4.0), 1.0 - 0.5 * i as f64) };
ids[i] = sk.add_point(*t + off, None).unwrap();
}
let [o1, f, o2, p, q, r, s] = ids;
for x in [o1, f] {
sk.add_constraint(ConstraintKind::Fix { p: x }, None).unwrap();
}
sk.add_constraint(ConstraintKind::HorizontalPoints { p: o1, q: o2 }, None).unwrap();
sk.add_constraint(ConstraintKind::VerticalPoints { p: f, q: o2 }, None).unwrap();
let at = |x: usize| truth[ids.iter().position(|i| *i == x).unwrap()];
sk.add_constraint(ConstraintKind::HorizontalPoints { p, q: s }, None).unwrap();
sk.add_constraint(ConstraintKind::VerticalPoints { p: q, q: s }, None).unwrap();
for (a, b) in [(p, q), (q, r), (p, r), (o1, p), (o1, r), (o2, q)] {
sk.add_constraint(ConstraintKind::Distance { p: a, q: b, value: at(a).dist(at(b)) }, None).unwrap();
}
(sk, ids)
}
#[test]
fn propagation_and_decomposition_interleave() {
let (mut sk, [o1, f, o2, p, q, r, s]) = bracket_chain();
let out = seed_of(&sk);
for x in [o1, f] {
assert_eq!(out.placed_by[x], Some(Placement::Given));
}
assert!(matches!(out.placed_by[o2], Some(Placement::TwoLoci { transversal: true, .. })), "{out:?}");
for x in [p, q, r] {
assert_eq!(out.placed_by[x], Some(Placement::Cluster), "point {x}: {out:?}");
}
assert_eq!(out.placed_by[s], Some(Placement::TwoLoci { a: p, b: q, transversal: true }), "{out:?}");
let rep = solve(&mut sk);
assert!(rep.ok() && rep.dof == 0, "{rep:?}");
assert_eq!(rep.iterations, 0, "every point constructed exactly");
}
/// A cluster that only fits at a touching intersection is not merged: its points are left to
/// LM, as a touching pair of loci is.
#[test]
fn touching_cluster_merges_are_left_to_lm() {
// P fixed; rigid triangle P Q R; Q–R at a DistanceX. Equal to |QR|, it holds only with
// Q–R level: turning the triangle onto it is a tangency.
let build = |dx: f64| {
let mut sk = Sketch::new();
let p = sk.add_point(v(10.0, 10.0), None).unwrap();
let q = sk.add_point(v(0.0, -21.0), None).unwrap();
let r = sk.add_point(v(31.0, -17.0), None).unwrap();
sk.add_constraint(ConstraintKind::Fix { p }, None).unwrap();
let truth = [v(10.0, 10.0), v(-2.0, -20.0), v(30.0, -20.0)];
let ids = [p, q, r];
for (a, b) in [(0, 1), (1, 2), (0, 2)] {
sk.add_constraint(ConstraintKind::Distance { p: ids[a], q: ids[b], value: truth[a].dist(truth[b]) }, None).unwrap();
}
sk.add_constraint(ConstraintKind::DistanceX { p: q, q: r, value: dx }, None).unwrap();
(sk, q, r)
};
let (sk, q, r) = build(32.0);
let out = seed_of(&sk);
assert_eq!((out.placed_by[q], out.placed_by[r]), (None, None), "{out:?}");
let (mut on, mut off) = (sk.clone(), sk.clone());
let with = seeded(true, || solve(&mut on));
let without = seeded(false, || solve(&mut off));
assert_eq!(on.points, off.points);
assert_eq!((with.status, with.iterations), (without.status, without.iterations));
// Shorter: the triangle turns onto it at a crossing and is placed.
let (sk, q, r) = build(31.0);
let out = seed_of(&sk);
assert_eq!((out.placed_by[q], out.placed_by[r]), (Some(Placement::Cluster), Some(Placement::Cluster)), "{out:?}");
}
/// The seed does not depend on the order of the constraints.
#[test]
fn seed_is_independent_of_constraint_order() {
for mut sk in [grid(6), linkage().0, bracket_chain().0] {
let forward = seed_of(&sk);
sk.constraints.reverse();
assert_eq!(seed_of(&sk), forward);
let n = sk.constraints.len();
sk.constraints.rotate_left(n / 3);
assert_eq!(seed_of(&sk), forward);
}
}
/// A reference taken before points were appended covers the points it has; one longer than
/// the point list is ignored.
#[test]
fn short_reference_covers_its_points_and_long_one_is_ignored() {
let arm = || {
let mut sk = Sketch::new();
let p1 = sk.add_point(v(0.0, 0.0), None).unwrap();
let p2 = sk.add_point(v(0.0, 30.0), None).unwrap();
let p3 = sk.add_point(v(20.0, 30.0), None).unwrap();
sk.add_constraint(ConstraintKind::Fix { p: p1 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: p1, q: p2, value: 30.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: p2, q: p3, value: 20.0 }, None).unwrap();
(sk, p1, p2, p3)
};
let side = |sk: &Sketch, p1: usize, p2: usize, p3: usize| orientation(sk.points[p1].pos, sk.points[p3].pos, sk.points[p2].pos);
let hand_moved = |extra: usize| {
let (mut sk, p1, p2, p3) = arm();
let before: Vec<Vec2> = sk.points.iter().map(|p| p.pos).collect();
let start = side(&sk, p1, p2, p3);
sk.add_point(v(5.0, 5.0), None).unwrap();
sk.points[p3].pos = v(-20.0, 30.0);
let reference: Vec<Vec2> = before.iter().copied().chain(std::iter::repeat_n(Vec2::ZERO, extra)).collect();
assert!(solve_with(&mut sk, &Hold { points: vec![p3], radii: vec![] }, Some(&reference), Analysis::Full, None).ok());
(start, side(&sk, p1, p2, p3))
};
// Shorter than the sketch (a point appended since): the elbow keeps its side.
let (start, after) = hand_moved(0);
assert_eq!(after, start);
// Longer than the sketch: ignored, the orientation comes from the moved hand.
let (start, after) = hand_moved(5);
assert_ne!(after, start);
}
/// [`bracket_chain`] with a second bracket on S (placed by propagation after the first
/// decomposition) and Q: P' Q' R' rigid, |S P'|, |S R'|, |Q Q'|. Returns the sketch and
/// [P', Q', R'].
fn two_stage_bracket() -> (Sketch, [usize; 3]) {
let (mut sk, [.., q, _, s]) = bracket_chain();
let truth = [v(70.0, 20.0), v(85.0, 40.0), v(65.0, 50.0)];
let ids = truth.map(|t| sk.add_point(t + v(1.0, -1.5), None).unwrap());
let (sq, qq) = (v(45.0, 30.0), v(45.0, 35.0));
for (a, b, value) in [
(ids[0], ids[1], truth[0].dist(truth[1])),
(ids[1], ids[2], truth[1].dist(truth[2])),
(ids[0], ids[2], truth[0].dist(truth[2])),
(s, ids[0], sq.dist(truth[0])),
(s, ids[2], sq.dist(truth[2])),
(q, ids[1], qq.dist(truth[1])),
] {
sk.add_constraint(ConstraintKind::Distance { p: a, q: b, value }, None).unwrap();
}
(sk, ids)
}
/// Propagation placing a point the second bracket hangs on extends the graph: one build.
#[test]
fn the_decomposition_graph_is_reused_across_rounds() {
let (mut sk, ids) = two_stage_bracket();
let builds = crate::decompose::builds();
let out = seed_of(&sk);
assert_eq!(crate::decompose::builds() - builds, 1, "one graph for both rounds");
for x in ids {
assert_eq!(out.placed_by[x], Some(Placement::Cluster), "point {x}: {out:?}");
}
let rep = solve(&mut sk);
assert!(rep.ok() && rep.dof == 0 && rep.iterations == 0, "{rep:?}");
}
/// A long chain of dimensioned links hanging off a fixed point: every free point keeps a degree
/// of freedom and no cluster of three points is rigid, so no graph is built.
#[test]
fn no_graph_is_built_where_the_decomposition_can_place_nothing() {
let mut sk = Sketch::new();
let mut prev = sk.add_point(v(0.0, 0.0), None).unwrap();
sk.add_constraint(ConstraintKind::Fix { p: prev }, None).unwrap();
for i in 1..300 {
let p = sk.add_point(v(i as f64 * 10.0, (i % 3) as f64), None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: prev, q: p, value: 10.0 }, None).unwrap();
prev = p;
}
let builds = crate::decompose::builds();
let out = seed_of(&sk);
assert_eq!(crate::decompose::builds() - builds, 0);
// The sketch's origin and the fixed end are given.
assert!(out.placed_by.iter().skip(2).all(Option::is_none), "{:?}", out.placed_by);
}
/// Dimensioned rectangles that float (no fixed point) are oriented clusters. Solved, they hold
/// at their reference and no graph is built; after a width edit the edited one is floated by
/// its reference pose (it keeps its centre) and the others are left alone.
#[test]
fn floating_rectangles_are_placed_by_their_reference_pose() {
let mut sk = Sketch::new();
let mut widths = Vec::new();
for k in 0..50 {
let o = v(k as f64 * 30.0, 100.0);
let ps = [v(0.0, 0.0), v(20.0, 0.0), v(20.0, 10.0), v(0.0, 10.0)].map(|d| sk.add_point(o + d, None).unwrap());
for i in 0..4 {
let l = sk.add_line_pts(ps[i], ps[(i + 1) % 4], None).unwrap();
let kind = if i % 2 == 0 { ConstraintKind::Horizontal { l } } else { ConstraintKind::Vertical { l } };
sk.add_constraint(kind, None).unwrap();
sk.add_constraint(ConstraintKind::Length { l, value: if i % 2 == 0 { 20.0 } else { 10.0 } }, None).unwrap();
if i % 2 == 0 {
widths.push(sk.constraints.len() - 1);
}
}
}
let builds = crate::decompose::builds();
let out = seed_of(&sk);
assert_eq!(crate::decompose::builds() - builds, 0);
assert!(out.placed_by.iter().skip(1).all(Option::is_none), "{:?}", out.placed_by);
// The first rectangle made 26 wide (bottom and top).
for c in &widths[..2] {
if let ConstraintKind::Length { value, .. } = &mut sk.constraints[*c].kind {
*value = 26.0;
}
}
let out = seed_of(&sk);
assert_eq!(crate::decompose::builds() - builds, 1);
// Past the sketch's origin: the first rectangle 3 wider on each side; the others, already
// at their reference pose, are left alone.
for (i, p) in sk.points.iter().enumerate().skip(1) {
if i <= 4 {
assert_eq!(out.placed_by[i], Some(Placement::Float), "point {i}");
let want = p.pos + v(if p.pos.x > 10.0 { 3.0 } else { -3.0 }, 0.0);
assert!(out.pos[i].unwrap().dist(want) < 1e-9, "point {i}: {:?} vs {want:?}", out.pos[i]);
} else {
assert_eq!(out.placed_by[i], None, "point {i}");
}
}
let rep = solve(&mut sk);
assert!(rep.ok() && rep.dof == 100 && rep.iterations == 0, "{rep:?}");
}
/// Readings of one pair that disagree are left to LM, whatever the order of the constraints.
#[test]
fn conflicting_readings_of_one_pair_do_not_depend_on_order() {
let (mut sk, [.., p, q, _, _]) = bracket_chain();
sk.add_constraint(ConstraintKind::Distance { p, q, value: 25.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p, q, value: 30.0 }, None).unwrap();
let forward = seed_of(&sk);
sk.constraints.reverse();
assert_eq!(seed_of(&sk), forward);
// Neither end is seeded by a cluster, nor floated with one (P with the triangle O1 P R).
for x in [p, q] {
assert!(!matches!(forward.placed_by[x], Some(Placement::Cluster | Placement::Float)), "point {x}: {forward:?}");
}
}
/// A cluster placement must hold every relation of the point, as a propagated one does.
#[test]
fn inconsistent_offsets_are_not_placed() {
// B: 30 right of A, 40 above it, and 60 from it (50 would hold). C hangs off A and B.
let mut sk = Sketch::new();
let a = sk.add_point(v(0.0, 0.0), None).unwrap();
let b = sk.add_point(v(31.0, 39.0), None).unwrap();
let c = sk.add_point(v(60.0, 0.0), None).unwrap();
sk.add_constraint(ConstraintKind::Fix { p: a }, None).unwrap();
sk.add_constraint(ConstraintKind::DistanceX { p: a, q: b, value: 30.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::DistanceY { p: a, q: b, value: 40.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: a, q: b, value: 60.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: a, q: c, value: 60.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: b, q: c, value: 50.0 }, None).unwrap();
let out = seed_of(&sk);
assert_eq!((out.placed_by[b], out.placed_by[c]), (None, None), "{out:?}");
}
/// A given point is a constant for the solve: never placed, even when out of range.
#[test]
fn given_points_are_never_placed() {
let mut sk = Sketch::new();
let a = sk.add_point(v(0.0, 0.0), None).unwrap();
let b = sk.add_point(v(40.0, 50.0), None).unwrap();
for p in [a, b] {
sk.add_constraint(ConstraintKind::Fix { p }, None).unwrap();
}
let g = sk.points.len();
sk.points.push(SPoint { id: "far".into(), pos: v(2e9, 0.0), fixed: true, link: None });
let d = sk.add_point(v(20.0, 30.0), None).unwrap();
let push = |sk: &mut Sketch, kind: ConstraintKind| {
sk.constraints.push(Constraint { id: format!("h{}", sk.constraints.len()), kind, param: None, driven: false, text: None })
};
// Level with A, under B: the row and the column cross at (40, 0), no branch to pick.
push(&mut sk, ConstraintKind::HorizontalPoints { p: a, q: g });
push(&mut sk, ConstraintKind::VerticalPoints { p: b, q: g });
push(&mut sk, ConstraintKind::Distance { p: g, q: d, value: 30.0 });
push(&mut sk, ConstraintKind::Distance { p: a, q: d, value: 36.0 });
let mask = given(&sk);
assert!(mask[g]);
let out = seed(&sk, &mask, None, true, &points_on_curves(&sk), &mut Budget::full());
assert_eq!((out.pos[g], out.placed_by[g]), (None, None), "{out:?}");
assert_eq!(out.placed_by[d], None, "nothing is built on it: {out:?}");
}
/// A component the seed did not move is solved once, also when it fails: the plain-start
/// retry only runs where the seed moved the start.
#[test]
fn an_unseeded_failing_component_is_not_solved_twice() {
// A triangle the seed places, and two free points held 10 and 20 apart.
let mut sk = Sketch::new();
let a = sk.add_point(v(0.0, 0.0), None).unwrap();
let b = sk.add_point(v(40.0, 0.0), None).unwrap();
let c = sk.add_point(v(21.0, 14.0), None).unwrap();
for p in [a, b] {
sk.add_constraint(ConstraintKind::Fix { p }, None).unwrap();
}
sk.add_constraint(ConstraintKind::Distance { p: a, q: c, value: 25.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: b, q: c, value: 25.0 }, None).unwrap();
let pair = |sk: &mut Sketch| {
let p = sk.add_point(v(100.0, 0.0), None).unwrap();
let q = sk.add_point(v(130.0, 7.0), None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p, q, value: 10.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p, q, value: 20.0 }, None).unwrap();
};
pair(&mut sk);
let mut alone = Sketch::new();
pair(&mut alone);
let pair_alone = seeded(false, || solve(&mut alone));
let with = seeded(true, || solve(&mut sk));
assert!(!with.ok() && !pair_alone.ok());
assert!(pair_alone.iterations > 0);
assert_eq!(with.iterations, pair_alone.iterations, "the triangle takes none, the pair is solved once");
}
// ---------------------------------------------------------------------------------------------
// Floating clusters: rigid clusters that are free or pinned at a single placed point.
/// Distances between pairs of points, each its current length times `scale`.
fn dimension(sk: &mut Sketch, pairs: &[(usize, usize, f64)]) {
for &(p, q, scale) in pairs {
let value = sk.points[p].pos.dist(sk.points[q].pos) * scale;
sk.add_constraint(ConstraintKind::Distance { p, q, value }, None).unwrap();
}
}
fn points(sk: &mut Sketch, at: &[Vec2]) -> Vec<usize> {
at.iter().map(|p| sk.add_point(*p, None).unwrap()).collect()
}
/// A floated pose is a guess at free motion: it seeds the solver but nothing is built on it.
/// Two triangles pinned at fixed P and Q, both edited, joined by two links (no freedom left):
/// B is not built on A's guess (and then rejected against it), it is floated too.
#[test]
fn a_floated_pose_anchors_nothing() {
let mut sk = Sketch::new();
let a = points(&mut sk, &[v(0.0, 0.0), v(10.0, 5.0), v(5.0, 12.0)]);
let b = points(&mut sk, &[v(40.0, 0.0), v(30.0, 5.0), v(35.0, 12.0)]);
for p in [a[0], b[0]] {
sk.add_constraint(ConstraintKind::Fix { p }, None).unwrap();
}
for t in [&a, &b] {
dimension(&mut sk, &[(t[0], t[1], 1.0), (t[1], t[2], 1.1), (t[2], t[0], 1.0)]);
}
dimension(&mut sk, &[(a[1], b[1], 1.0), (a[2], b[2], 1.0)]);
let out = seed_of(&sk);
for x in [a[1], a[2], b[1], b[2]] {
assert_eq!(out.placed_by[x], Some(Placement::Float), "point {x}: {out:?}");
}
let rep = solve(&mut sk);
assert!(rep.ok() && rep.dof == 0, "{rep:?}");
}
/// A float is pinned only at a point the seed accepted: the bracket's P is constructed by the
/// decomposition but breaks a midpoint the decomposition does not combine with it, so it is not
/// accepted, and the edited triangle hanging off P is not floated about the rejected position.
#[test]
fn floats_are_pinned_only_at_accepted_points() {
let truth = [v(0.0, 0.0), v(60.0, 0.0), v(10.0, 30.0), v(45.0, 35.0), v(25.0, 55.0)];
let mut sk = Sketch::new();
let ids = points(&mut sk, &truth);
let [o1, o2, p, q, r] = [ids[0], ids[1], ids[2], ids[3], ids[4]];
for x in [o1, o2] {
sk.add_constraint(ConstraintKind::Fix { p: x }, None).unwrap();
}
dimension(&mut sk, &[(p, q, 1.0), (q, r, 1.0), (p, r, 1.0), (o1, p, 1.0), (o1, r, 1.0), (o2, q, 1.0)]);
let qr = sk.add_line_pts(q, r, None).unwrap();
sk.add_constraint(ConstraintKind::Midpoint { p, l: qr }, None).unwrap();
let t = points(&mut sk, &[v(5.0, 40.0), v(0.0, 33.0)]);
dimension(&mut sk, &[(p, t[0], 1.0), (t[0], t[1], 1.2), (t[1], p, 1.0)]);
let out = seed_of(&sk);
assert_eq!(out.placed_by[p], None, "{out:?}");
for x in t {
assert_eq!(out.placed_by[x], None, "point {x}: {out:?}");
}
}
/// An edit to a floating triangle read only through a tie (a point's distance from a line)
/// still floats it.
#[test]
fn a_tie_that_misses_floats_its_cluster() {
let mut sk = Sketch::new();
let [a, b, c] = [v(0.0, 0.0), v(20.0, 0.0), v(10.0, 8.0)].map(|p| sk.add_point(p, None).unwrap());
let l = sk.add_line_pts(a, b, None).unwrap();
dimension(&mut sk, &[(a, b, 1.0), (b, c, 1.0)]);
sk.add_constraint(ConstraintKind::PointLineDistance { p: c, l, value: 10.0 }, None).unwrap();
let out = seed_of(&sk);
for x in [a, b, c] {
assert_eq!(out.placed_by[x], Some(Placement::Float), "point {x}: {out:?}");
}
let rep = solve(&mut sk);
assert!(rep.ok() && rep.dof == 3 && rep.iterations == 0, "{rep:?}");
}
/// A drag step moves only held points: a floating part it does not reach (here one that can't
/// be solved) builds no graph on any frame.
#[test]
fn a_drag_builds_no_graph_for_a_floating_part_it_does_not_reach() {
let mut sk = Sketch::new();
let t = points(&mut sk, &[v(100.0, 0.0), v(101.0, 0.0), v(100.5, 0.5)]);
for (p, q, value) in [(t[0], t[1], 1.0), (t[1], t[2], 1.0), (t[2], t[0], 5.0)] {
sk.add_constraint(ConstraintKind::Distance { p, q, value }, None).unwrap();
}
let o = sk.add_point(v(0.0, 0.0), None).unwrap();
let d = sk.add_point(v(10.0, 0.0), None).unwrap();
sk.add_constraint(ConstraintKind::Fix { p: o }, None).unwrap();
sk.add_constraint(ConstraintKind::Distance { p: o, q: d, value: 10.0 }, None).unwrap();
let builds = crate::decompose::builds();
for k in 1..=8 {
drag(&mut sk, d, Vec2::from_angle(k as f64 * 0.1) * 10.0, true);
}
assert_eq!(crate::decompose::builds() - builds, 0);
}
/// Solved floating parts are where their reference pose puts them: an edit elsewhere floats
/// none of them, and they cost the decomposition little more than its graph.
#[test]
fn solved_floating_parts_are_not_floated() {
let mut sk = Sketch::new();
let rect = |sk: &mut Sketch, o: Vec2, width: f64| {
let ps = [v(0.0, 0.0), v(20.0, 0.0), v(20.0, 10.0), v(0.0, 10.0)].map(|d| sk.add_point(o + d, None).unwrap());
for i in 0..4 {
let l = sk.add_line_pts(ps[i], ps[(i + 1) % 4], None).unwrap();
let kind = if i % 2 == 0 { ConstraintKind::Horizontal { l } } else { ConstraintKind::Vertical { l } };
sk.add_constraint(kind, None).unwrap();
sk.add_constraint(ConstraintKind::Length { l, value: if i % 2 == 0 { width } else { 10.0 } }, None).unwrap();
}
ps
};
for k in 0..1000 {
rect(&mut sk, v((k % 40) as f64 * 30.0, 100.0 + (k / 40) as f64 * 20.0), 20.0);
}
let floating = sk.points.len();
// The canonical bracket (O1 O2 fixed, rigid P Q R; no propagation order), edited.
let o = v(0.0, -100.0);
let ids = points(&mut sk, &[v(0.0, 0.0), v(60.0, 0.0), v(10.0, 30.0), v(45.0, 35.0), v(25.0, 55.0)].map(|p| o + p));
for x in &ids[..2] {
sk.add_constraint(ConstraintKind::Fix { p: *x }, None).unwrap();
}
dimension(
&mut sk,
&[(ids[2], ids[3], 1.1), (ids[3], ids[4], 1.0), (ids[2], ids[4], 1.0), (ids[0], ids[2], 1.0), (ids[0], ids[4], 1.0), (ids[1], ids[3], 1.0)],
);
let out = seed_of(&sk);
let work = crate::decompose::last_work();
for x in &ids[2..] {
assert_eq!(out.placed_by[*x], Some(Placement::Cluster), "point {x}");
}
assert!(out.placed_by[1..floating].iter().all(Option::is_none));
assert!(work < 1_000_000, "{work}");
}
#[test]
fn an_arc_follows_its_constructed_centre() {
// An arc whose centre is put on the origin follows it: the seed places the centre, and the
// ends, which nothing else constrains, start carried along instead of left behind (from
// there LM would turn them; reference test 20-slot-constrained).
let mut sk = Sketch::new();
let arc = sk.add_arc(v(1.0, 1.0), v(1.0, 7.0), v(1.0, -5.0), [None, None, None], None).unwrap();
let CurveKind::Arc { c, a, b } = sk.curves[arc].kind else { panic!() };
sk.add_constraint(ConstraintKind::Coincident { p: c, q: 0 }, None).unwrap();
assert!(solve_holding(&mut sk, &Hold { points: vec![0], radii: vec![] }).ok());
for (p, want) in [(c, v(0.0, 0.0)), (a, v(0.0, 6.0)), (b, v(0.0, -6.0))] {
assert!(sk.points[p].pos.dist(want) < 1e-9, "{:?} vs {want:?}", sk.points[p].pos);
}
}
View Git Blame Copy Permalink