A relation given no values already started from where its parts sit (relation_values), so the part moves no further than it must. A typed joint (planar, revolute, cylindrical ...) added between parts another joint already relates started its values at 0 instead, so the loop solver began far from the current placement and could report a conflict for a joint that agrees with how the parts are placed. Seed every loop-closing joint, typed or relation, from the current placement when no values are given. Joints in an open chain and joints with explicit values keep their initial values as before.
This commit is contained in:
@@ -16,14 +16,11 @@ const TURNS: [f64; 4] = [0.0, std::f64::consts::FRAC_PI_2, std::f64::consts::PI,
|
||||
/// Starts tried at most (angle values beyond the first three start at 0).
|
||||
const MAX_STARTS: usize = 64;
|
||||
|
||||
/// The values of relation `j` that move B least from where it is now: B's joint frame as it sits
|
||||
/// in A's, met as nearly as the relation allows (its origin as near as it can be to where it is,
|
||||
/// and its axes, each weighed as a point a part's size along it). `None` for a joint that is not a relation, or whose
|
||||
/// origins can't be found.
|
||||
/// The values of joint `j` that move B least from where it is now: B's joint frame as it sits
|
||||
/// in A's, met as nearly as the joint allows (its origin as near as it can be to where it is,
|
||||
/// and its axes, each weighed as a point a part's size along it). Used for relations and for
|
||||
/// typed joints that close a loop. `None` when the origins or finite values can't be found.
|
||||
pub fn relation_values(doc: &Document, st: &ModelState, j: &Joint) -> Option<Vec<f64>> {
|
||||
if !j.kind.is_relation() {
|
||||
return None;
|
||||
}
|
||||
let world = |occ: u64| if occ == 0 { IDENTITY } else { occurrence_world(doc, occ) };
|
||||
let fa = mat_mul(&world(j.a.occurrence), &resolve_origin(doc, st, &j.a).ok()?);
|
||||
let fb = mat_mul(&world(j.b.occurrence), &resolve_origin(doc, st, &j.b).ok()?);
|
||||
|
||||
@@ -697,11 +697,47 @@ fn check_sides(a: &JointOrigin, b: &JointOrigin, cmd: &str) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// A path already joins the two sides, including paths through grounded occurrences.
|
||||
fn closes_loop(s: &Session, j: &Joint) -> bool {
|
||||
let mut at: BTreeMap<u64, Vec<u64>> = BTreeMap::new();
|
||||
for joint in s.doc.assembly.joints.iter().filter(|j| !j.suppressed).take(joints::MAX_JOINTS) {
|
||||
at.entry(joint.a.occurrence).or_default().push(joint.b.occurrence);
|
||||
at.entry(joint.b.occurrence).or_default().push(joint.a.occurrence);
|
||||
}
|
||||
// The solver fixes the root and every grounded occurrence in the same world frame.
|
||||
for o in s.doc.occurrences.iter().filter(|o| o.grounded) {
|
||||
at.entry(0).or_default().push(o.id);
|
||||
at.entry(o.id).or_default().push(0);
|
||||
}
|
||||
let mut seen = BTreeSet::from([j.a.occurrence]);
|
||||
let mut pending = vec![j.a.occurrence];
|
||||
while let Some(occ) = pending.pop() {
|
||||
if occ == j.b.occurrence {
|
||||
return true;
|
||||
}
|
||||
for other in at.get(&occ).into_iter().flatten() {
|
||||
if seen.insert(*other) {
|
||||
pending.push(*other);
|
||||
}
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
fn add_joint(s: &mut Session, mut j: Joint, p: &Value) -> Result<Value> {
|
||||
if s.doc.assembly.joints.len() >= 10_000 {
|
||||
return Err(EngineError::Other("too many joints".into()));
|
||||
}
|
||||
check_sides(&j.a, &j.b, "joint.create")?;
|
||||
// Relations and loop-closing typed joints start where their parts are. A typed joint in
|
||||
// an open chain keeps its usual initial values; explicitly supplied values also keep theirs.
|
||||
if p.get("values").is_none()
|
||||
&& p.get("value").is_none()
|
||||
&& (j.kind.is_relation() || closes_loop(s, &j))
|
||||
&& let Some(q) = joints::relation_values(&s.doc, &s.model.state(), &j)
|
||||
{
|
||||
j.values = q;
|
||||
}
|
||||
// It starts at its values inside its limits. A value moved to a limit moves the part as it
|
||||
// is joined, which the answer says.
|
||||
let mut q = j.values.clone();
|
||||
@@ -798,13 +834,6 @@ fn joint(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
suppressed: false,
|
||||
exprs: JointExprs { offset: typed(p.get("offset")), angle: typed(p.get("angle")), values: value_exprs(p) },
|
||||
};
|
||||
// A relation given no values starts from where its parts are: B moves no further than it must.
|
||||
if p.get("values").is_none()
|
||||
&& p.get("value").is_none()
|
||||
&& let Some(q) = joints::relation_values(&s.doc, &s.model.state(), &j)
|
||||
{
|
||||
j.values = q;
|
||||
}
|
||||
// No angle given: B keeps its turn about the joint's axis where a half turn would otherwise
|
||||
// come only from how its origin's x was chosen. (An angle relation's angle is its tilt.)
|
||||
if angle.is_none() && !j.kind.is_relation() {
|
||||
@@ -1515,7 +1544,7 @@ fn edit(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
// A relation whose type, offset, tilt or flip changes starts again from where its parts are.
|
||||
let reseat = kind.is_some() || offset.is_some() || angle.is_some() || p.get("flip").is_some() || sides;
|
||||
if reseat {
|
||||
let edited = s.doc.assembly.joints.iter().find(|j| j.id == id).cloned();
|
||||
let edited = s.doc.assembly.joints.iter().find(|j| j.id == id).filter(|j| j.kind.is_relation()).cloned();
|
||||
if let Some(q) = edited.and_then(|j| joints::relation_values(&s.doc, &s.model.state(), &j))
|
||||
&& let Some(j) = s.doc_mut().assembly.joints.iter_mut().find(|j| j.id == id)
|
||||
{
|
||||
|
||||
@@ -60,6 +60,43 @@ fn clean(r: &Value) -> bool {
|
||||
r["conflicts"] == json!([]) && r["errors"] == json!([])
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn closing_planar_joint_starts_from_the_current_placement() {
|
||||
let mut s = Session::default();
|
||||
for name in ["Base", "Part"] {
|
||||
run(&mut s, "component.create", json!({"name": name}));
|
||||
run(&mut s, "solid.box", json!({"length": 20, "width": 10, "height": 6}));
|
||||
run(&mut s, "component.activate", json!({"component": "root"}));
|
||||
}
|
||||
let base = occ(&s, "Base");
|
||||
run(&mut s, "occurrence.ground", json!({"occurrence": base, "grounded": true}));
|
||||
let r = run(
|
||||
&mut s,
|
||||
"joint.create",
|
||||
json!({"type": "planar", "name": "First", "flip": true, "angle": 0,
|
||||
"a": {"occurrence": "Base", "point": [0, 0, 0], "x": [1, 0, 0]},
|
||||
"b": {"occurrence": "Part", "point": [0, 0, 0], "x": [1, 0, 0]}, "values": [50, 30, 120]}),
|
||||
);
|
||||
assert!(clean(&r), "{r}");
|
||||
// Check a frame, so a turn as well as a translation is observable.
|
||||
let points = [Vec3::ZERO, Vec3::X, Vec3::Y, Vec3::Z];
|
||||
let before = points.map(|p| place(&s, "Part", p));
|
||||
let at = before[0];
|
||||
let x = before[1] - at;
|
||||
let r = run(
|
||||
&mut s,
|
||||
"joint.create",
|
||||
json!({"type": "planar", "name": "Closing", "flip": true, "angle": 0,
|
||||
"a": {"occurrence": "Base", "point": [0, 0, 0], "x": [1, 0, 0]},
|
||||
"b": {"occurrence": "Part", "point": [at.x, at.y, at.z], "x": [x.x, x.y, x.z]}}),
|
||||
);
|
||||
assert!(clean(&r), "{r}");
|
||||
for (p, want) in points.into_iter().zip(before) {
|
||||
let got = place(&s, "Part", p);
|
||||
assert!(near(got, want, 1e-6), "{p:?}: {got:?}, expected {want:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stacked_relations_place_a_part_and_follow_the_panel() {
|
||||
let mut s = panel();
|
||||
|
||||
Reference in New Issue
Block a user