This commit is contained in:
@@ -179,7 +179,7 @@ pub static COMMANDS: &[CommandSpec] = &[
|
||||
.params("entities: [curve, point or constraint ids]"),
|
||||
CommandSpec::new("sketch.move_point", "Drag Sketch Point", move_point).icon("sketch_move").enabled(in_sketch).params("point: ref, to: [x,y]"),
|
||||
CommandSpec::new("sketch.drag", "Drag Sketch Geometry", drag).icon("sketch_move").enabled(in_sketch).live(drag_live).params(
|
||||
"entity: point or curve, from: [x,y] where it was grabbed, to: [x,y], live?: bool: a point goes to `to`, a line (spline, conic) slides by to - from, a circle or arc grabbed on its edge takes the radius to `to`; the rest moves as little as it can and keeps its solution branch (a long move is followed in short steps, each solved with the entity held; a step that cannot be solved that way is approached as far as it can be and the next ones tried; when none past it solves, the last one is left to the sketch's ordinary solve, which may pull it back or leave the sketch unsolved; a step that would sweep an arc through its start is undone and the drag ends there). Returns `reached`: how much of the way from `from` to `to` the geometry followed (0..1), and `at`: where the grabbed spot went (`from` moved as the dragged points did), the `from` of the next move. `live: true` (each frame of an interactive drag) solves the sketch once and leaves the features after it as they were (stale) until `sketch.drag_end` or any command that reads the model; `dof` is then the one from before the drag",
|
||||
"entity: point or curve, from: [x,y] where it was grabbed, to: [x,y], live?: bool: a point moves toward `to` within the design constraints; when exact cursor placement is impossible, bounded feasible steps minimize cursor distance while keeping design constraints mandatory. A line (spline, conic) slides by to - from; a circle or arc grabbed on its edge takes the radius to `to`. Long moves use continuation to retain the solution branch, and a step that would sweep an arc through its start is rejected. Returns `reached`: progress along the requested move (0..1; feasible point motion projects its actual displacement onto that move), and `at`: where the grabbed spot went (`from` moved as the dragged points did), the `from` of the next move. `live: true` solves the sketch and leaves later features stale until `sketch.drag_end` or a command that reads the model; `dof` is then the one from before the drag",
|
||||
),
|
||||
CommandSpec::new("sketch.drag_end", "End Sketch Drag", drag_end).icon("sketch_move").enabled(in_sketch).doc_only().params(
|
||||
"constraint?: {command: a sketch.constraint.* id, params}: ends a drag made of `sketch.drag` `live: true` frames: adds the constraint it let go on (not kept if it over-constrains the sketch), then evaluates the whole model once; returns the constraint's result and the sketch's solved state and degrees of freedom",
|
||||
|
||||
@@ -104,29 +104,31 @@ impl Path {
|
||||
}
|
||||
}
|
||||
|
||||
/// Drag: the grabbed entity follows the cursor exactly (a point goes to it; a line or spline
|
||||
/// Drag: the grabbed entity follows the cursor where possible (a point moves toward it; a line or spline
|
||||
/// slides by the cursor's move; a circle or arc grabbed on its edge changes radius about its
|
||||
/// centre; a conic grabbed on its curve reads its fullness, `rho`, off the cursor) and the rest
|
||||
/// of the sketch moves as little as it can, staying on the
|
||||
/// solution it started on. Fixed geometry stays. A step that cannot be solved with the entity
|
||||
/// held (the path crosses where the geometry cannot reach) is approached by halving the way to
|
||||
/// it, and the next steps are tried from the last solved state, the last of them being the whole
|
||||
/// remaining move. When none past it solves, the first failed step stays placed but unsolved:
|
||||
/// remaining move. A point whose exact pin fails instead minimizes cursor distance in the
|
||||
/// design's remaining freedom, retaining only corrected, feasible poses. For other entities,
|
||||
/// when none past it solves, the first failed step stays placed but unsolved:
|
||||
/// the edit's ordinary, non-strict solve that follows (seeded on the last solved state, see
|
||||
/// [`Left::MovedFrom`]) then pulls it back (fully constrained geometry) or leaves the sketch
|
||||
/// unsolved for the user to see. A step that would sweep an arc through its own start is undone
|
||||
/// and the drag ends there. Returns how far it got and what it leaves for the edit's solve
|
||||
/// ([`Left::Solved`]: the held solve of the last step it kept left the sketch solved).
|
||||
///
|
||||
/// `live`: one frame of an interactive drag, whose held solves share one frame's decomposition
|
||||
/// budget ([`Budget::frame`]); otherwise each has a solve's own.
|
||||
/// `live`: one frame of an interactive drag, whose held solves and cursor correction share
|
||||
/// one frame's work budget ([`Budget::frame`]); otherwise each has a solve's own.
|
||||
pub(super) fn drag_entity(sk: &mut Sketch, e: Ent, from: Vec2, to: Vec2, live: bool) -> (Dragged, Left) {
|
||||
let Some((path, hold, n, short)) = prepare(sk, e, from, to) else {
|
||||
return (Dragged { reached: 0.0, moving: Vec::new() }, Left::Unsolved);
|
||||
};
|
||||
#[cfg(test)]
|
||||
let (n, short) = (n.min(step_cap::get()), short.min(step_cap::get()));
|
||||
let moving = path.points().filter_map(|q| Some((q, sk.point(q)?))).collect();
|
||||
let moving: Vec<_> = path.points().filter_map(|q| Some((q, sk.point(q)?))).collect();
|
||||
let mut frame = live.then(frame_budget);
|
||||
// Only success matters to these solves: the degrees of freedom of a sketch with the entity
|
||||
// held are not the sketch's. Each is seeded on the last solved state (`last`), so what the
|
||||
@@ -211,6 +213,41 @@ pub(super) fn drag_entity(sk: &mut Sketch, e: Ent, from: Vec2, to: Vec2, live: b
|
||||
failed = Some(t);
|
||||
}
|
||||
}
|
||||
// First retain held continuation across unreachable stretches of an otherwise reachable
|
||||
// path (for example an arm dragged through the hole around its shoulder). If it cannot
|
||||
// arrive, optimize the full cursor target without relaxing the design constraints.
|
||||
if failed.is_some()
|
||||
&& let Ent::Point(q) = e
|
||||
{
|
||||
let (points, radii) = sk.coupled(&hold.points, &hold.radii);
|
||||
let size = smallest_size(sk, &hold, Some(Group { points: &points, radii: &radii }));
|
||||
let max_step = (size * SHORT_STEP_FRACTION).min(path.length()).max(MIN_STEP);
|
||||
#[cfg(test)]
|
||||
let spent = frame.as_ref().map_or(0, Budget::spent);
|
||||
let followed = solidcraft_sketch::move_point_towards(sk, q, to, max_step, frame.as_mut(), |before, after| {
|
||||
let mut geometry = Geometry::default();
|
||||
geometry.take(before);
|
||||
!geometry.sweep_wrapped(after)
|
||||
});
|
||||
#[cfg(test)]
|
||||
if let Some(budget) = &frame {
|
||||
solves.work += budget.spent() - spent;
|
||||
solves.cut |= budget.exhausted();
|
||||
}
|
||||
if followed {
|
||||
#[cfg(test)]
|
||||
last_drag::set(solves);
|
||||
let reached = moving
|
||||
.iter()
|
||||
.find(|(p, _)| *p == q)
|
||||
.and_then(|(_, start)| {
|
||||
let d = to - *start;
|
||||
sk.point(q).map(|at| if at.dist(to) < 1e-6 || d.dot(d) == 0.0 { 1.0 } else { ((at - *start).dot(d) / d.dot(d)).clamp(0.0, 1.0) })
|
||||
})
|
||||
.unwrap_or(0.0);
|
||||
return (Dragged { reached, moving }, Left::Solved);
|
||||
}
|
||||
}
|
||||
#[cfg(test)]
|
||||
last_drag::set(solves);
|
||||
let left = match failed {
|
||||
@@ -225,8 +262,8 @@ pub(super) fn drag_entity(sk: &mut Sketch, e: Ent, from: Vec2, to: Vec2, live: b
|
||||
(Dragged { reached: good, moving }, left)
|
||||
}
|
||||
|
||||
/// The held solves of one drag: how many, the decomposition work they did, and whether one ran
|
||||
/// out of budget.
|
||||
/// The held solves of one drag: how many, their shared work (including cursor correction),
|
||||
/// and whether it ran out of budget.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq)]
|
||||
pub(super) struct Solves {
|
||||
pub count: usize,
|
||||
|
||||
@@ -1524,3 +1524,22 @@ fn the_first_dimension_does_not_scale_a_sketch_that_has_a_size() {
|
||||
let out = run(&mut s, "sketch.dimension", json!({"entities": ["l1", "l2"], "value": "60 deg", "scale_sketch": true}));
|
||||
assert!(out.get("scaled").is_none(), "{out}");
|
||||
}
|
||||
|
||||
/// The cursor fallback shares the held solves' frame budget; a scripted drag can finish later.
|
||||
#[test]
|
||||
fn cursor_fallback_respects_an_exhausted_live_frame_budget() {
|
||||
let mut s = new_sketch();
|
||||
run(&mut s, "sketch.line", json!({"points": [[0, 0], [-10, 0]], "ids": ["crank"], "infer": false}));
|
||||
run(&mut s, "sketch.dimension", json!({"entities": ["crank"], "value": 10}));
|
||||
let target = v(-10.0, 16.0);
|
||||
let nearest = target * (10.0 / target.len());
|
||||
super::drag::last_drag::with_frame_work(0, || {
|
||||
run(&mut s, "sketch.drag", json!({"entity": "crank.end", "from": [-10, 0], "to": [target.x, target.y], "live": true}));
|
||||
});
|
||||
let at = pt(&s, "crank.end");
|
||||
assert!(at.dist(nearest) > 1.0, "an exhausted frame must not start unbudgeted cursor work: {at:?}");
|
||||
assert!((at.len() - 10.0).abs() < 1e-6);
|
||||
assert!(s.model.state().sketch(s.active_sketch.unwrap()).unwrap().report.ok());
|
||||
run(&mut s, "sketch.drag", json!({"entity": "crank.end", "from": [at.x, at.y], "to": [target.x, target.y], "live": false}));
|
||||
assert!(pt(&s, "crank.end").dist(nearest) < 1e-4, "scripted motion retains the full cursor objective");
|
||||
}
|
||||
|
||||
@@ -0,0 +1,107 @@
|
||||
//! Cursor distance is minimized within the design's freedom; lengths stay mandatory.
|
||||
#[path = "support/four_bar.rs"]
|
||||
mod four_bar;
|
||||
|
||||
use serde_json::json;
|
||||
use solidcraft_geom::Vec2;
|
||||
|
||||
fn drag(s: &mut solidcraft_engine::Session, target: Vec2) {
|
||||
let from = four_bar::point(s, "crank.end").unwrap();
|
||||
s.execute("sketch.drag", &json!({"entity":"crank.end","from":[from.x,from.y],"to":[target.x,target.y],"live":true})).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn four_bar_large_off_locus_drag_reaches_the_closest_feasible_point() {
|
||||
for target in [Vec2::new(-10.0, 8.0), Vec2::new(-10.0, -8.0), Vec2::new(20.0, 20.0), Vec2::new(20.0, 0.0), Vec2::new(1000.0, -1000.0)] {
|
||||
let mut s = four_bar::session().unwrap();
|
||||
let side = four_bar::branch(&s).unwrap();
|
||||
drag(&mut s, target);
|
||||
let actual = four_bar::point(&s, "crank.end").unwrap();
|
||||
let nearest = target * (10.0 / target.len());
|
||||
assert!(actual.dist(nearest) < 1e-4, "target {target:?}, actual {actual:?}, expected {nearest:?}");
|
||||
assert!(four_bar::length_error(&s).unwrap() < 1e-6);
|
||||
assert_eq!(four_bar::branch(&s).unwrap(), side);
|
||||
let state = s.model.state();
|
||||
let report = &state.sketch(s.active_sketch.unwrap()).unwrap().report;
|
||||
assert!(report.ok());
|
||||
assert_eq!(report.dof, 1);
|
||||
s.execute("sketch.drag_end", &json!({})).unwrap();
|
||||
assert!(four_bar::point(&s, "crank.end").unwrap().dist(nearest) < 1e-4);
|
||||
s.execute("edit.undo", &json!({})).unwrap();
|
||||
assert!(four_bar::point(&s, "crank.end").unwrap().dist(Vec2::new(-10.0, 0.0)) < 1e-7);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn four_bar_reverse_motion_and_stationary_cursor_do_not_drift() {
|
||||
let mut s = four_bar::session().unwrap();
|
||||
let side = four_bar::branch(&s).unwrap();
|
||||
for target in [Vec2::new(-10.0, 16.0), Vec2::new(-10.0, -16.0), Vec2::new(0.0, 25.0), Vec2::new(0.0, -25.0)] {
|
||||
drag(&mut s, target);
|
||||
let at = four_bar::point(&s, "crank.end").unwrap();
|
||||
assert!(
|
||||
at.dist(target * (10.0 / target.len())) < 1e-4,
|
||||
"target {target:?}, actual {at:?}, length error {}",
|
||||
four_bar::length_error(&s).unwrap()
|
||||
);
|
||||
for _ in 0..8 {
|
||||
drag(&mut s, target);
|
||||
assert!(four_bar::point(&s, "crank.end").unwrap().dist(at) < 1e-4);
|
||||
assert!(four_bar::length_error(&s).unwrap() < 1e-6);
|
||||
assert_eq!(four_bar::branch(&s).unwrap(), side);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn four_bar_one_event_and_split_moves_agree_and_keep_the_branch() {
|
||||
let target = Vec2::new(-10.0, 16.0);
|
||||
let mut single = four_bar::session().unwrap();
|
||||
let mut split = four_bar::session().unwrap();
|
||||
let start = four_bar::point(&single, "crank.end").unwrap();
|
||||
let side = four_bar::branch(&single).unwrap();
|
||||
drag(&mut single, target);
|
||||
for i in 1..=16 {
|
||||
drag(&mut split, start + (target - start) * (i as f64 / 16.0));
|
||||
assert!(four_bar::length_error(&split).unwrap() < 1e-6);
|
||||
assert_eq!(four_bar::branch(&split).unwrap(), side);
|
||||
}
|
||||
assert!(four_bar::point(&single, "crank.end").unwrap().dist(four_bar::point(&split, "crank.end").unwrap()) < 1e-4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn four_bar_live_cursor_motion_updates_driven_dimensions_before_release() {
|
||||
let mut s = four_bar::session().unwrap();
|
||||
s.execute("sketch.dimension", &json!({"entities": ["crank"], "type": "horizontal", "driven": true})).unwrap();
|
||||
let id = s.active_sketch.unwrap();
|
||||
let dimension = s.doc.sketch(id).unwrap().constraints.last().unwrap().id.clone();
|
||||
drag(&mut s, Vec2::new(-10.0, 8.0));
|
||||
let at = four_bar::point(&s, "crank.end").unwrap();
|
||||
assert!(at.dist(Vec2::new(-10.0, 8.0) * (10.0 / 164.0_f64.sqrt())) < 1e-4);
|
||||
let state = s.model.state();
|
||||
for sketch in [s.doc.sketch(id).unwrap(), &state.sketch(id).unwrap().sketch] {
|
||||
let c = sketch.constraints.iter().find(|c| c.id == dimension).unwrap();
|
||||
assert!(c.driven);
|
||||
assert!((c.kind.value().unwrap() - at.x.abs()).abs() < 1e-6, "reference dimension must measure the final live pose: {:?}", c.kind);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn four_bar_other_joint_follows_the_rocker_arc_and_its_limits() {
|
||||
let base = Vec2::new(42.0, 0.0);
|
||||
let lo = -(-1264.0_f64 / 1680.0).acos();
|
||||
let hi = -(0.2_f64).acos();
|
||||
for angle in [-2.6_f64, -2.1, -1.5, -1.1] {
|
||||
let mut s = four_bar::session().unwrap();
|
||||
let side = four_bar::branch(&s).unwrap();
|
||||
let from = four_bar::point(&s, "coupler.end").unwrap();
|
||||
let target = base + Vec2::new(angle.cos(), angle.sin()) * 60.0;
|
||||
let nearest = base + Vec2::new(angle.clamp(lo, hi).cos(), angle.clamp(lo, hi).sin()) * 20.0;
|
||||
s.execute("sketch.drag", &json!({"entity":"coupler.end","from":[from.x,from.y],"to":[target.x,target.y],"live":true})).unwrap();
|
||||
assert!(four_bar::point(&s, "coupler.end").unwrap().dist(nearest) < 1e-4, "angle {angle}");
|
||||
assert!(four_bar::length_error(&s).unwrap() < 1e-6);
|
||||
assert_eq!(four_bar::branch(&s).unwrap(), side);
|
||||
s.execute("sketch.drag_end", &json!({})).unwrap();
|
||||
assert!(four_bar::point(&s, "coupler.end").unwrap().dist(nearest) < 1e-4);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
//! Public-safe 10/40/20/42 mm linkage, matching the reported one-degree-of-freedom sketch.
|
||||
use serde_json::json;
|
||||
use solidcraft_engine::Session;
|
||||
use solidcraft_geom::Vec2;
|
||||
|
||||
pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
|
||||
|
||||
pub fn session() -> Result<Session> {
|
||||
let mut s = Session::default();
|
||||
s.execute("sketch.create", &json!({"plane":"XZ"}))?;
|
||||
let x = -10.0 + (1600.0 - 400.0 + 52.0 * 52.0) / 104.0;
|
||||
let y = -(1600.0_f64 - (x + 10.0) * (x + 10.0)).sqrt();
|
||||
s.execute("sketch.line", &json!({"points":[[0,0],[-10,0],[x,y],[42,0]],"ids":["crank","coupler","rocker"],"infer":false}))?;
|
||||
s.execute("sketch.line", &json!({"points":["crank.start","rocker.end"],"ids":["ground"],"infer":false}))?;
|
||||
for (line, length) in [("crank", 10.0), ("coupler", 40.0), ("rocker", 20.0), ("ground", 42.0)] {
|
||||
s.execute("sketch.dimension", &json!({"entities":[line],"value":length}))?;
|
||||
}
|
||||
s.execute("sketch.constraint.horizontal_vertical", &json!({"line":"ground"}))?;
|
||||
Ok(s)
|
||||
}
|
||||
|
||||
pub fn point(s: &Session, name: &str) -> Result<Vec2> {
|
||||
let sk = s.doc.sketch(s.active_sketch.ok_or("missing active sketch")?)?;
|
||||
sk.resolve_point(name).and_then(|p| sk.point(p)).ok_or_else(|| format!("missing point {name}").into())
|
||||
}
|
||||
|
||||
pub fn length_error(s: &Session) -> Result<f64> {
|
||||
let mut error = 0.0_f64;
|
||||
for (a, b, length) in [
|
||||
("crank.start", "crank.end", 10.0),
|
||||
("coupler.start", "coupler.end", 40.0),
|
||||
("rocker.start", "rocker.end", 20.0),
|
||||
("ground.start", "ground.end", 42.0),
|
||||
] {
|
||||
error = error.max((point(s, a)?.dist(point(s, b)?) - length).abs());
|
||||
}
|
||||
error = error.max(point(s, "crank.start")?.len());
|
||||
error = error.max(point(s, "ground.end")?.dist(Vec2::new(42.0, 0.0)));
|
||||
Ok(error)
|
||||
}
|
||||
|
||||
pub fn branch(s: &Session) -> Result<f64> {
|
||||
let a = point(s, "crank.end")?;
|
||||
Ok((point(s, "rocker.end")? - a).cross(point(s, "coupler.end")? - a).signum())
|
||||
}
|
||||
@@ -0,0 +1,296 @@
|
||||
//! Feasible cursor motion: optimize only within the design Jacobian's null space, then
|
||||
//! retract to the constraint manifold. Mouse error never competes with design residuals.
|
||||
use super::{
|
||||
ACCEPT, Hold, Layout, State, TOL, build_blocks, columns, initial_x, layout, lm_capped_with_budget, local_system, max_abs, points_on_curves,
|
||||
residual_work, system, within_budget,
|
||||
};
|
||||
use crate::{
|
||||
Budget, CurveKind, Sketch,
|
||||
linalg::{Mat, rref},
|
||||
union_find::{find, union},
|
||||
};
|
||||
use solidcraft_geom::Vec2;
|
||||
|
||||
const MAX_VARIABLES: usize = 400;
|
||||
const MAX_STEPS: usize = 96;
|
||||
const CORRECTION_ITERS: usize = 16;
|
||||
const TOTAL_CORRECTION_ITERS: usize = 256;
|
||||
|
||||
/// Move a point toward `target` using freedom left by the design constraints. `max_step`
|
||||
/// bounds the full variable displacement before constraint correction; `valid` can reject
|
||||
/// a corrected candidate (for example, an arc crossing its own start). Only feasible,
|
||||
/// cursor-improving candidates are committed. False leaves the sketch unchanged when the
|
||||
/// input is unsolved, invalid or outside the dense-work limit. Work is bounded; true may
|
||||
/// retain the best feasible pose when the iteration or optional shared frame-work budget is
|
||||
/// exhausted. The work budget includes Jacobian, null-space and LM arithmetic, not wall time.
|
||||
pub fn move_point_towards(
|
||||
sk: &mut Sketch,
|
||||
point: usize,
|
||||
target: Vec2,
|
||||
max_step: f64,
|
||||
mut budget: Option<&mut Budget>,
|
||||
valid: impl Fn(&Sketch, &Sketch) -> bool,
|
||||
) -> bool {
|
||||
let setup_work = sk.points.len().saturating_add(sk.curves.len()).saturating_add(sk.constraints.len()).max(1);
|
||||
if !within_budget(&mut budget, setup_work) {
|
||||
return false;
|
||||
}
|
||||
if !crate::model::in_range(target) || !max_step.is_finite() || max_step <= 0.0 || !in_range(sk) {
|
||||
return false;
|
||||
}
|
||||
let problem = sk.clone();
|
||||
let lay = layout(&problem, &Hold::default());
|
||||
let Some(px) = lay.pvar.get(point).copied().flatten() else { return false };
|
||||
let (blocks, _) = build_blocks(&problem, &lay, &points_on_curves(&problem));
|
||||
let mut parent: Vec<usize> = (0..lay.n).collect();
|
||||
union(&mut parent, px, px + 1);
|
||||
for (_, vars) in &blocks {
|
||||
if let Some(&first) = vars.first() {
|
||||
for &v in vars.iter().skip(1) {
|
||||
union(&mut parent, first, v);
|
||||
}
|
||||
}
|
||||
}
|
||||
let root = find(&mut parent, px);
|
||||
let vars: Vec<usize> = (0..lay.n).filter(|v| find(&mut parent, *v) == root).collect();
|
||||
if vars.len() > MAX_VARIABLES {
|
||||
return false;
|
||||
}
|
||||
let sub: Vec<_> =
|
||||
blocks.iter().filter(|(_, v)| v.iter().any(|i| vars.binary_search(i).is_ok())).map(|(b, v)| (super::copy_block(b), v.clone())).collect();
|
||||
// Reserve both initial and final all-block validation before starting cursor work.
|
||||
// An exhausted search can then keep its best feasible pose, including unrelated blocks.
|
||||
if !within_budget(&mut budget, residual_work(&lay, &blocks).saturating_mul(2)) {
|
||||
return false;
|
||||
}
|
||||
let mut x = initial_x(&problem, &lay);
|
||||
let initial_residual = max_abs(&system(&problem, &lay, &blocks, &mut x, false).0);
|
||||
if initial_residual >= ACCEPT {
|
||||
return false;
|
||||
}
|
||||
let mut col = vec![usize::MAX; lay.n];
|
||||
columns(&mut col, &vars, &vars);
|
||||
let (Some(ix), Some(iy)) = (vars.iter().position(|v| *v == px), vars.iter().position(|v| *v == px + 1)) else { return false };
|
||||
let mut best = problem.clone();
|
||||
let mut spent = 0;
|
||||
// Held feasibility solves accept up to ACCEPT. A tiny, nearly feasible hard pin can
|
||||
// precede a failed step; refine it before constructing a tangent, rather than losing
|
||||
// the cursor objective just because the previous pose is between TOL and ACCEPT.
|
||||
if initial_residual >= TOL {
|
||||
let Some((its, residual)) = lm_capped_with_budget(&problem, &lay, &sub, &vars, &mut x, &col, CORRECTION_ITERS, budget.as_deref_mut()) else {
|
||||
return false;
|
||||
};
|
||||
spent += its.max(1);
|
||||
if !(residual < TOL) {
|
||||
return false;
|
||||
}
|
||||
apply(&mut best, &lay, &x);
|
||||
if !in_range(&best) || !valid(&problem, &best) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
let mut gain = 1.0_f64;
|
||||
for _ in 0..MAX_STEPS {
|
||||
let at = State { sk: &problem, lay: &lay, x: &x }.p(point);
|
||||
let error = target - at;
|
||||
if error.len() < 1e-7 || spent >= TOTAL_CORRECTION_ITERS {
|
||||
break;
|
||||
}
|
||||
let n = vars.len();
|
||||
let jacobian_work = residual_work(&lay, &sub).saturating_mul(n.saturating_mul(2).saturating_add(1));
|
||||
if !within_budget(&mut budget, jacobian_work) {
|
||||
break;
|
||||
}
|
||||
let (_, j, _) = local_system(&problem, &lay, &sub, &mut x, &col, n);
|
||||
let null_work = n.saturating_mul(n).saturating_mul(j.rows.saturating_add(n));
|
||||
if !within_budget(&mut budget, null_work) {
|
||||
break;
|
||||
}
|
||||
let z = null_space(j);
|
||||
if z.is_empty() {
|
||||
break;
|
||||
}
|
||||
let mut direction = target_step(&z, ix, iy, error);
|
||||
let norm = length(&direction);
|
||||
// Adapt to curvature of the reachable locus. Inside a circle the Gauss-Newton
|
||||
// cursor step can be arbitrarily small although useful freedom remains.
|
||||
let scale = if norm > 0.0 { gain.min(max_step / norm) } else { gain };
|
||||
for v in &mut direction {
|
||||
*v *= scale;
|
||||
}
|
||||
let mut directions = vec![(direction, false)];
|
||||
// A cursor across a circular locus has (nearly) zero first derivative at the
|
||||
// farthest point. If line search stalls, probe both tangent directions. Testing
|
||||
// only an exactly zero gradient would strand reversed drags after rounding.
|
||||
let influence = |v: &&Vec<f64>| v.get(ix).copied().unwrap_or(0.0).hypot(v.get(iy).copied().unwrap_or(0.0));
|
||||
let mut probes: Vec<_> = z.iter().collect();
|
||||
probes.sort_by(|a, b| influence(b).total_cmp(&influence(a)));
|
||||
for v in probes.into_iter().take(2) {
|
||||
directions.push((v.iter().map(|x| x * max_step).collect(), true));
|
||||
directions.push((v.iter().map(|x| -x * max_step).collect(), true));
|
||||
}
|
||||
let old_cost = error.dot(error);
|
||||
let mut accepted = None;
|
||||
'search: for (direction, probe) in directions {
|
||||
if length(&direction) < 1e-12 {
|
||||
continue;
|
||||
}
|
||||
for backtrack in 0..if probe { 1 } else { 8 } {
|
||||
if spent >= TOTAL_CORRECTION_ITERS {
|
||||
break 'search;
|
||||
}
|
||||
let alpha = 0.5_f64.powi(backtrack);
|
||||
let mut trial = x.clone();
|
||||
for (&v, d) in vars.iter().zip(&direction) {
|
||||
if let Some(t) = trial.get_mut(v) {
|
||||
*t += alpha * d;
|
||||
}
|
||||
}
|
||||
let Some((its, residual)) = lm_capped_with_budget(
|
||||
&problem,
|
||||
&lay,
|
||||
&sub,
|
||||
&vars,
|
||||
&mut trial,
|
||||
&col,
|
||||
CORRECTION_ITERS.min(TOTAL_CORRECTION_ITERS - spent),
|
||||
budget.as_deref_mut(),
|
||||
) else {
|
||||
break 'search;
|
||||
};
|
||||
spent += its.max(1);
|
||||
if !(residual < TOL) {
|
||||
if budget.as_ref().is_some_and(|b| b.exhausted()) {
|
||||
break 'search;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let next = State { sk: &problem, lay: &lay, x: &trial }.p(point);
|
||||
let cost = (target - next).dot(target - next);
|
||||
if !cost.is_finite() || cost >= old_cost - 1e-14 * old_cost.max(1.0) {
|
||||
continue;
|
||||
}
|
||||
if !within_budget(&mut budget, setup_work.saturating_mul(4)) {
|
||||
break 'search;
|
||||
}
|
||||
let mut candidate = best.clone();
|
||||
apply(&mut candidate, &lay, &trial);
|
||||
if !in_range(&candidate) || !valid(&best, &candidate) {
|
||||
continue;
|
||||
}
|
||||
accepted = Some((trial, candidate, ((if probe { 1.0 } else { scale }) * alpha * 1.5).clamp(1e-8, 1e8)));
|
||||
break 'search;
|
||||
}
|
||||
}
|
||||
let Some((next, candidate, next_gain)) = accepted else { break };
|
||||
x = next;
|
||||
best = candidate;
|
||||
gain = next_gain;
|
||||
}
|
||||
// Full constraint validation includes constant blocks and disconnected components.
|
||||
if max_abs(&system(&best, &lay, &blocks, &mut x, false).0) >= ACCEPT {
|
||||
return false;
|
||||
}
|
||||
super::refresh_driven_dimensions(&mut best);
|
||||
*sk = best;
|
||||
true
|
||||
}
|
||||
|
||||
fn length(v: &[f64]) -> f64 {
|
||||
v.iter().map(|x| x * x).sum::<f64>().sqrt()
|
||||
}
|
||||
|
||||
fn in_range(sk: &Sketch) -> bool {
|
||||
sk.points.iter().all(|p| crate::model::in_range(p.pos))
|
||||
&& sk
|
||||
.curves
|
||||
.iter()
|
||||
.all(|c| !matches!(c.kind, CurveKind::Circle { r, .. } | CurveKind::Ellipse { r, .. } if !crate::model::radius_in_range(r)))
|
||||
}
|
||||
|
||||
fn null_space(mut j: Mat) -> Vec<Vec<f64>> {
|
||||
for row in 0..j.rows {
|
||||
let scale = (0..j.cols).map(|c| j.get(row, c).abs()).fold(0.0_f64, f64::max);
|
||||
if scale > 0.0 {
|
||||
for c in 0..j.cols {
|
||||
j.set(row, c, j.get(row, c) / scale);
|
||||
}
|
||||
}
|
||||
}
|
||||
let pivots = rref(&mut j, 1e-9);
|
||||
let mut z: Vec<Vec<f64>> = Vec::new();
|
||||
for free in (0..j.cols).filter(|c| !pivots.contains(c)) {
|
||||
let mut v = vec![0.0; j.cols];
|
||||
if let Some(x) = v.get_mut(free) {
|
||||
*x = 1.0;
|
||||
}
|
||||
for (row, &pivot) in pivots.iter().enumerate() {
|
||||
if let Some(x) = v.get_mut(pivot) {
|
||||
*x = -j.get(row, free);
|
||||
}
|
||||
}
|
||||
for _ in 0..2 {
|
||||
for q in &z {
|
||||
let d: f64 = v.iter().zip(q).map(|(a, b)| a * b).sum();
|
||||
for (a, b) in v.iter_mut().zip(q) {
|
||||
*a -= d * b;
|
||||
}
|
||||
}
|
||||
}
|
||||
let norm = length(&v);
|
||||
if norm.is_finite() && norm > 1e-10 {
|
||||
for x in &mut v {
|
||||
*x /= norm;
|
||||
}
|
||||
z.push(v);
|
||||
}
|
||||
}
|
||||
z
|
||||
}
|
||||
|
||||
fn target_step(z: &[Vec<f64>], ix: usize, iy: usize, error: Vec2) -> Vec<f64> {
|
||||
let mut a = 0.0;
|
||||
let mut b = 0.0;
|
||||
let mut c = 0.0;
|
||||
for q in z {
|
||||
let x = q.get(ix).copied().unwrap_or(0.0);
|
||||
let y = q.get(iy).copied().unwrap_or(0.0);
|
||||
a += x * x;
|
||||
b += x * y;
|
||||
c += y * y;
|
||||
}
|
||||
let high = 0.5 * (a + c + (a - c).hypot(2.0 * b));
|
||||
let low = if high > 0.0 { (a * c - b * b).max(0.0) / high } else { 0.0 };
|
||||
let axis = if a >= c { Vec2::new(high - c, b) } else { Vec2::new(b, high - a) }.normalized().unwrap_or(if a >= c { Vec2::X } else { Vec2::Y });
|
||||
let other = Vec2::new(-axis.y, axis.x);
|
||||
let mut u = if high > 1e-12 { axis * (axis.dot(error) / high) } else { Vec2::ZERO };
|
||||
if low > high * 1e-8 {
|
||||
u += other * (other.dot(error) / low);
|
||||
}
|
||||
let mut step = vec![0.0; z.first().map_or(0, Vec::len)];
|
||||
for q in z {
|
||||
let d = q.get(ix).copied().unwrap_or(0.0) * u.x + q.get(iy).copied().unwrap_or(0.0) * u.y;
|
||||
for (x, v) in step.iter_mut().zip(q) {
|
||||
*x += d * v;
|
||||
}
|
||||
}
|
||||
step
|
||||
}
|
||||
|
||||
fn apply(sk: &mut Sketch, lay: &Layout, x: &[f64]) {
|
||||
for (i, p) in sk.points.iter_mut().enumerate() {
|
||||
if let Some(v) = lay.pvar.get(i).copied().flatten()
|
||||
&& let (Some(a), Some(b)) = (x.get(v), x.get(v + 1))
|
||||
{
|
||||
p.pos = Vec2::new(*a, *b);
|
||||
}
|
||||
}
|
||||
for (i, c) in sk.curves.iter_mut().enumerate() {
|
||||
if let Some(v) = lay.rvar.get(i).copied().flatten()
|
||||
&& let Some(value) = x.get(v)
|
||||
&& let CurveKind::Circle { r, .. } | CurveKind::Ellipse { r, .. } = &mut c.kind
|
||||
{
|
||||
*r = *value;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -75,9 +75,9 @@ pub(crate) const MAX_WORK: usize = 20_000_000;
|
||||
/// frame (see [`Budget::exhausted`]).
|
||||
pub(crate) const FRAME_WORK: usize = 1_000_000;
|
||||
|
||||
/// Work the seed's cluster decomposition may do, shared by the solves it is passed to (the held
|
||||
/// solves of one drag frame): each decomposition is bounded by what is left, and charges what it
|
||||
/// did.
|
||||
/// Work shared by the held solves and feasible cursor correction of one drag frame. Cluster
|
||||
/// decomposition charges membership scans; cursor correction reserves estimates of dense
|
||||
/// arithmetic before starting it. These deterministic units approximate time, not a deadline.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct Budget {
|
||||
left: usize,
|
||||
@@ -86,7 +86,7 @@ pub struct Budget {
|
||||
}
|
||||
|
||||
impl Budget {
|
||||
/// A budget of `work` units (a unit is one membership scan of the merge search).
|
||||
/// A budget of `work` units: membership scans or estimated dense arithmetic operations.
|
||||
pub fn new(work: usize) -> Budget {
|
||||
Budget { left: work, spent: 0, cut: false }
|
||||
}
|
||||
@@ -98,8 +98,7 @@ impl Budget {
|
||||
pub fn frame() -> Budget {
|
||||
Budget::new(FRAME_WORK)
|
||||
}
|
||||
/// Some decomposition stopped because the budget ran out: what it would have placed was
|
||||
/// left to LM, from where it was.
|
||||
/// Some decomposition or cursor work stopped because the budget ran out.
|
||||
pub fn exhausted(&self) -> bool {
|
||||
self.cut
|
||||
}
|
||||
@@ -110,6 +109,17 @@ impl Budget {
|
||||
pub(crate) fn left(&self) -> usize {
|
||||
self.left
|
||||
}
|
||||
/// Reserve estimated dense arithmetic before starting it. Unlike a decomposition scan,
|
||||
/// a dense operation can be large, so it must not overshoot the remaining work.
|
||||
pub(crate) fn try_charge(&mut self, work: usize) -> bool {
|
||||
if work > self.left {
|
||||
self.cut = true;
|
||||
return false;
|
||||
}
|
||||
self.charge(work, false);
|
||||
true
|
||||
}
|
||||
|
||||
/// Charge a decomposition's `work`; `cut` when it stopped at the budget.
|
||||
pub(crate) fn charge(&mut self, work: usize, cut: bool) {
|
||||
self.left = self.left.saturating_sub(work);
|
||||
|
||||
@@ -62,8 +62,8 @@ pub use profiles::{
|
||||
};
|
||||
pub use shape::{Shape, intersections};
|
||||
pub use solver::{
|
||||
Analysis, CONSISTENT, DrivingValues, Hold, SolveReport, SolveStatus, constraint_residual, determined_by, measure_dimension, solve,
|
||||
solve_after_edit, solve_after_value_edit, solve_holding, solve_with,
|
||||
Analysis, CONSISTENT, DrivingValues, Hold, SolveReport, SolveStatus, constraint_residual, determined_by, measure_dimension, move_point_towards,
|
||||
solve, solve_after_edit, solve_after_value_edit, solve_holding, solve_with,
|
||||
};
|
||||
pub use text::{MAX_TEXT_CHARS, TextAlign, TextStyle, text_geometry, text_geometry_in, text_geometry_styled};
|
||||
pub use thin::{MAX_THIN_SEGMENTS, thin_wall_regions};
|
||||
|
||||
+61
-15
@@ -21,6 +21,10 @@ use crate::linalg::{Mat, determined_vars, solve as lin_solve};
|
||||
use crate::model::{ConstraintKind, CurveKind, Sketch};
|
||||
use crate::union_find::{find, union};
|
||||
|
||||
#[path = "cursor.rs"]
|
||||
mod cursor;
|
||||
pub use cursor::move_point_towards;
|
||||
|
||||
#[path = "redundancy.rs"]
|
||||
mod redundancy;
|
||||
pub use redundancy::{CONSISTENT, constraint_residual, determined_by};
|
||||
@@ -945,6 +949,26 @@ fn lm_capped(
|
||||
col: &[usize],
|
||||
max_iters: usize,
|
||||
) -> (usize, f64) {
|
||||
// Without a work budget the initial residual is always evaluated.
|
||||
lm_capped_with_budget(sk, lay, blocks, vars, x, col, max_iters, None).unwrap_or((0, f64::INFINITY))
|
||||
}
|
||||
|
||||
/// Deterministic work units, shared with the frame's decomposition budget. Estimates bound
|
||||
/// dense arithmetic; they are not a wall-clock deadline. None means no residual was evaluated.
|
||||
fn lm_capped_with_budget(
|
||||
sk: &Sketch,
|
||||
lay: &Layout,
|
||||
blocks: &[(Block, Vec<usize>)],
|
||||
vars: &[usize],
|
||||
x: &mut Vec<f64>,
|
||||
col: &[usize],
|
||||
max_iters: usize,
|
||||
mut budget: Option<&mut Budget>,
|
||||
) -> Option<(usize, f64)> {
|
||||
let evaluation_work = if budget.is_some() { residual_work(lay, blocks) } else { 0 };
|
||||
if !within_budget(&mut budget, evaluation_work) {
|
||||
return None;
|
||||
}
|
||||
let n = vars.len();
|
||||
#[cfg(test)]
|
||||
lm_vars::add(n);
|
||||
@@ -953,7 +977,12 @@ fn lm_capped(
|
||||
let mut f = norm2(&r);
|
||||
for it in 0..max_iters {
|
||||
if max_abs(&r) < TOL {
|
||||
return (it, max_abs(&r));
|
||||
return Some((it, max_abs(&r)));
|
||||
}
|
||||
let normal_work =
|
||||
n.saturating_mul(n).saturating_mul(r.len()).saturating_add(evaluation_work.saturating_mul(n.saturating_mul(2).saturating_add(1)));
|
||||
if !within_budget(&mut budget, normal_work) {
|
||||
return Some((it, max_abs(&r)));
|
||||
}
|
||||
let (_, j, _) = local_system(sk, lay, blocks, x, col, n);
|
||||
// Normal equations of this component.
|
||||
@@ -979,7 +1008,11 @@ fn lm_capped(
|
||||
// the point sliding along it.) A point held on a curve is cheaper still, so it slides
|
||||
// rather than the curve's ends moving.
|
||||
let weight: Vec<f64> = vars.iter().map(|&v| if lay.slide.get(v).copied().unwrap_or(false) { SLIDE_WEIGHT } else { 1.0 }).collect();
|
||||
for _ in 0..30 {
|
||||
for _attempt in 0..30 {
|
||||
let linear_work = n.saturating_mul(n).saturating_mul(n).saturating_add(evaluation_work);
|
||||
if !within_budget(&mut budget, linear_work) {
|
||||
return Some((it, max_abs(&r)));
|
||||
}
|
||||
let mut m = a.clone();
|
||||
for (i, w) in weight.iter().enumerate() {
|
||||
m.add(i, i, lambda * w + 1e-12);
|
||||
@@ -1011,10 +1044,18 @@ fn lm_capped(
|
||||
}
|
||||
}
|
||||
if !improved {
|
||||
return (it, max_abs(&r));
|
||||
return Some((it, max_abs(&r)));
|
||||
}
|
||||
}
|
||||
(max_iters, max_abs(&r))
|
||||
Some((max_iters, max_abs(&r)))
|
||||
}
|
||||
|
||||
fn within_budget(budget: &mut Option<&mut Budget>, work: usize) -> bool {
|
||||
budget.as_deref_mut().is_none_or(|b| b.try_charge(work))
|
||||
}
|
||||
|
||||
fn residual_work(lay: &Layout, blocks: &[(Block, Vec<usize>)]) -> usize {
|
||||
blocks.iter().fold(lay.n.max(1), |work, (_, vars)| work.saturating_add(vars.len().max(1)))
|
||||
}
|
||||
|
||||
/// The variables LM was given and its runs on this thread, for tests that count what the
|
||||
@@ -2222,17 +2263,7 @@ fn solve_inner(
|
||||
Some(v) => vdet(Some(v)) && vdet(Some(v + 1)),
|
||||
None => true,
|
||||
};
|
||||
// Driven dimensions measure the solved geometry.
|
||||
let fixed_lay = Layout { pvar: vec![None; sk.points.len()], rvar: vec![None; sk.curves.len()], n: 0, points: 0, slide: Vec::new() };
|
||||
let measured: Vec<Option<f64>> =
|
||||
sk.constraints.iter().map(|c| if c.driven { measure(&State { sk, lay: &fixed_lay, x: &[] }, &c.kind) } else { None }).collect();
|
||||
for (c, m) in sk.constraints.iter_mut().zip(measured) {
|
||||
if let Some(v) = m
|
||||
&& v.is_finite()
|
||||
{
|
||||
c.kind.set_value(v);
|
||||
}
|
||||
}
|
||||
refresh_driven_dimensions(sk);
|
||||
let (dof, point_determined, curve_determined) = match analysis {
|
||||
Analysis::Full => (
|
||||
lay.n.saturating_sub(rank),
|
||||
@@ -2255,6 +2286,21 @@ fn solve_inner(
|
||||
}
|
||||
}
|
||||
|
||||
/// Geometry can also be finalized by feasible cursor motion, without another solve.
|
||||
/// Both paths must measure reference dimensions from the pose they publish.
|
||||
fn refresh_driven_dimensions(sk: &mut Sketch) {
|
||||
let fixed_lay = Layout { pvar: vec![None; sk.points.len()], rvar: vec![None; sk.curves.len()], n: 0, points: 0, slide: Vec::new() };
|
||||
let measured: Vec<Option<f64>> =
|
||||
sk.constraints.iter().map(|c| if c.driven { measure(&State { sk, lay: &fixed_lay, x: &[] }, &c.kind) } else { None }).collect();
|
||||
for (c, m) in sk.constraints.iter_mut().zip(measured) {
|
||||
if let Some(v) = m
|
||||
&& v.is_finite()
|
||||
{
|
||||
c.kind.set_value(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod continuation_unit_tests {
|
||||
use super::*;
|
||||
|
||||
@@ -0,0 +1,160 @@
|
||||
//! Analytic cursor oracle plus feasibility checks on every accepted continuation step.
|
||||
use solidcraft_geom::Vec2;
|
||||
use solidcraft_sketch::{ConstraintKind, Sketch, move_point_towards, solve};
|
||||
|
||||
fn linkage() -> (Sketch, usize, usize) {
|
||||
let mut sk = Sketch::new();
|
||||
let a = sk.add_point(Vec2::new(-10.0, 0.0), None).unwrap();
|
||||
let x = -10.0 + (1600.0 - 400.0 + 52.0 * 52.0) / 104.0;
|
||||
let c = sk.add_point(Vec2::new(x, -(1600.0_f64 - (x + 10.0).powi(2)).sqrt()), None).unwrap();
|
||||
let b = sk.add_point(Vec2::new(42.0, 0.0), None).unwrap();
|
||||
sk.points[b].fixed = true;
|
||||
for (p, q, value) in [(0, a, 10.0), (a, c, 40.0), (c, b, 20.0)] {
|
||||
sk.add_constraint(ConstraintKind::Distance { p, q, value }, None).unwrap();
|
||||
}
|
||||
assert!(solve(&mut sk).ok());
|
||||
(sk, a, c)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn circle_oracle_all_directions_and_large_targets() {
|
||||
for radius in [1.0, 12.8, 28.3, 100.0, 1000.0] {
|
||||
for i in 0..24 {
|
||||
let (mut sk, a, c) = linkage();
|
||||
let angle = std::f64::consts::TAU * i as f64 / 24.0;
|
||||
let target = Vec2::new(angle.cos(), angle.sin()) * radius;
|
||||
let nearest = target * (10.0 / radius);
|
||||
assert!(move_point_towards(&mut sk, a, target, 1.25, None, |before, after| {
|
||||
assert!(after.points[a].pos.dist(target) < before.points[a].pos.dist(target));
|
||||
assert!((after.points[a].pos.len() - 10.0).abs() < 1e-9);
|
||||
assert!((after.points[a].pos.dist(after.points[c].pos) - 40.0).abs() < 1e-9);
|
||||
assert!((after.points[c].pos.dist(Vec2::new(42.0, 0.0)) - 20.0).abs() < 1e-9);
|
||||
(Vec2::new(42.0, 0.0) - after.points[a].pos).cross(after.points[c].pos - after.points[a].pos) < 0.0
|
||||
}));
|
||||
assert!(sk.points[a].pos.dist(nearest) < 1e-4, "radius {radius}, angle {angle}, actual {:?}, nearest {nearest:?}", sk.points[a].pos);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fixed_axis_and_rejected_candidates_keep_design_constraints() {
|
||||
let mut sk = Sketch::new();
|
||||
let a = sk.add_point(Vec2::new(10.0, 0.0), None).unwrap();
|
||||
let l = sk.add_line_pts(0, a, None).unwrap();
|
||||
sk.add_constraint(ConstraintKind::Horizontal { l }, None).unwrap();
|
||||
assert!(move_point_towards(&mut sk, a, Vec2::new(20.0, 10.0), 2.0, None, |_, _| true));
|
||||
assert!(sk.points[a].pos.dist(Vec2::new(20.0, 0.0)) < 1e-5, "{:?}", sk.points[a].pos);
|
||||
let before = sk.clone();
|
||||
assert!(move_point_towards(&mut sk, a, Vec2::new(-20.0, 10.0), 2.0, None, |_, _| false));
|
||||
assert_eq!(sk, before);
|
||||
assert!(!move_point_towards(&mut sk, usize::MAX, Vec2::ZERO, 1.0, None, |_, _| true));
|
||||
assert!(!move_point_towards(&mut sk, a, Vec2::new(f64::NAN, 0.0), 1.0, None, |_, _| true));
|
||||
assert_eq!(sk, before);
|
||||
sk.points[a].pos.x = f64::NAN;
|
||||
assert!(!move_point_towards(&mut sk, a, Vec2::ZERO, 1.0, None, |_, _| true));
|
||||
assert!(sk.points[a].pos.x.is_nan());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reversing_across_a_nearly_stationary_extremum_keeps_following() {
|
||||
let (mut sk, a, _) = linkage();
|
||||
for target in [Vec2::new(-10.0, 16.0), Vec2::new(-10.0, -16.0), Vec2::new(0.0, 25.0), Vec2::new(0.0, -25.0)] {
|
||||
assert!(move_point_towards(&mut sk, a, target, 1.25, None, |_, _| true));
|
||||
assert!(sk.points[a].pos.dist(target * (10.0 / target.len())) < 1e-4, "target {target:?}, actual {:?}", sk.points[a].pos);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accepted_constraint_roundoff_is_refined_before_following_the_cursor() {
|
||||
let (mut sk, a, _) = linkage();
|
||||
sk.points[a].pos.x -= 1e-8;
|
||||
let target = Vec2::new(-10.0, 8.0);
|
||||
assert!(move_point_towards(&mut sk, a, target, 1.25, None, |_, _| true));
|
||||
assert!(sk.points[a].pos.dist(target * (10.0 / target.len())) < 1e-4);
|
||||
assert!((sk.points[a].pos.len() - 10.0).abs() < 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_cursor_at_the_pivot_does_not_choose_a_pose_from_roundoff() {
|
||||
let (mut sk, a, _) = linkage();
|
||||
let before = sk.clone();
|
||||
assert!(move_point_towards(&mut sk, a, Vec2::ZERO, 1.25, None, |_, _| true));
|
||||
assert!(sk.points[a].pos.dist(before.points[a].pos) < 1e-5, "{:?}", sk.points[a].pos);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cursor_motion_refreshes_driven_dimensions_without_a_followup_solve() {
|
||||
let (mut sk, a, _) = linkage();
|
||||
sk.add_constraint(ConstraintKind::DistanceX { p: 0, q: a, value: 10.0 }, None).unwrap();
|
||||
sk.constraints.last_mut().unwrap().driven = true;
|
||||
assert!(move_point_towards(&mut sk, a, Vec2::new(-10.0, 8.0), 1.25, None, |_, _| true));
|
||||
let value = sk.constraints.last().unwrap().kind.value().unwrap();
|
||||
assert!((value - sk.points[a].pos.x.abs()).abs() < 1e-6, "reference {value} does not measure {:?}", sk.points[a].pos);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_other_moving_joint_reaches_its_rocker_arc_and_motion_limits() {
|
||||
let base = Vec2::new(42.0, 0.0);
|
||||
let lo = -(-1264.0_f64 / 1680.0).acos(); // |OC| >= 40 - 10
|
||||
let hi = -(0.2_f64).acos(); // |OC| <= 40 + 10
|
||||
for angle in [-2.6_f64, -2.1, -1.5, -1.1] {
|
||||
let (mut sk, a, c) = linkage();
|
||||
let target = base + Vec2::new(angle.cos(), angle.sin()) * 60.0;
|
||||
let nearest = base + Vec2::new(angle.clamp(lo, hi).cos(), angle.clamp(lo, hi).sin()) * 20.0;
|
||||
assert!(move_point_towards(&mut sk, c, target, 1.25, None, |_, after| {
|
||||
(base - after.points[a].pos).cross(after.points[c].pos - after.points[a].pos) < 0.0
|
||||
}));
|
||||
assert!(sk.points[c].pos.dist(nearest) < 1e-4, "angle {angle}, actual {:?}, nearest {nearest:?}", sk.points[c].pos);
|
||||
assert!((sk.points[a].pos.len() - 10.0).abs() < 1e-9);
|
||||
assert!((sk.points[a].pos.dist(sk.points[c].pos) - 40.0).abs() < 1e-9);
|
||||
assert!((sk.points[c].pos.dist(base) - 20.0).abs() < 1e-9);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_cursor_budget_does_not_start_optimization() {
|
||||
let (mut sk, a, _) = linkage();
|
||||
let before = sk.clone();
|
||||
let mut budget = solidcraft_sketch::Budget::new(0);
|
||||
assert!(!move_point_towards(&mut sk, a, Vec2::new(-10.0, 16.0), 1.25, Some(&mut budget), |_, _| {
|
||||
panic!("an exhausted budget must not evaluate candidates")
|
||||
}));
|
||||
assert_eq!(sk, before);
|
||||
assert_eq!(budget.spent(), 0);
|
||||
assert!(budget.exhausted());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_cursor_budget_stop_keeps_the_best_corrected_pose_and_reference_dimensions() {
|
||||
let target = Vec2::new(-10.0, 16.0);
|
||||
let nearest = target * (10.0 / target.len());
|
||||
let mut stopped_after_progress = false;
|
||||
for work in [128, 256, 512, 1024, 2048, 4096, 8192, 16384] {
|
||||
let (mut sk, a, c) = linkage();
|
||||
sk.add_constraint(ConstraintKind::DistanceX { p: 0, q: a, value: 10.0 }, None).unwrap();
|
||||
sk.constraints.last_mut().unwrap().driven = true;
|
||||
let before = sk.clone();
|
||||
let mut budget = solidcraft_sketch::Budget::new(work);
|
||||
// The validation callback is Fn: Cell records whether a corrected step was accepted.
|
||||
let calls = std::cell::Cell::new(0);
|
||||
let moved = move_point_towards(&mut sk, a, target, 1.25, Some(&mut budget), |_, after| {
|
||||
calls.set(calls.get() + 1);
|
||||
assert!((after.points[a].pos.len() - 10.0).abs() < 1e-9);
|
||||
assert!((after.points[a].pos.dist(after.points[c].pos) - 40.0).abs() < 1e-9);
|
||||
assert!((after.points[c].pos.dist(Vec2::new(42.0, 0.0)) - 20.0).abs() < 1e-9);
|
||||
true
|
||||
});
|
||||
assert!(budget.spent() <= work, "{budget:?}");
|
||||
if !moved {
|
||||
assert_eq!(sk, before);
|
||||
continue;
|
||||
}
|
||||
assert!((sk.points[a].pos.len() - 10.0).abs() < 1e-9);
|
||||
assert!((sk.constraints.last().unwrap().kind.value().unwrap() - sk.points[a].pos.x.abs()).abs() < 1e-6);
|
||||
if calls.get() > 0 && budget.exhausted() && sk.points[a].pos.dist(nearest) > 1e-4 {
|
||||
assert!(sk.points[a].pos.dist(target) < before.points[a].pos.dist(target));
|
||||
stopped_after_progress = true;
|
||||
}
|
||||
}
|
||||
assert!(stopped_after_progress, "exercise exhaustion after a feasible cursor improvement");
|
||||
}
|
||||
Reference in New Issue
Block a user