Revolve: an axis origin written as an expression is no longer read as zero (#10252)
* fix: Revolve axis origin takes expressions instead of silently zero - AxisRef::Line origin is a PointExpr evaluated with parameter values in the design unit (format note in pending) - An unreadable origin or dir is a BadParams error instead of (0, 0, 0) - Edit Feature keeps the saved expressions of an untouched origin or dir, for solid and surface revolves, in moved components too - Face role names stay stable with a parameter-driven axis * chore: Re-run PR checks after the description fix * fix: Edit Feature of a revolve maps nothing where nothing is placed - unplaced designs skip world_state and the pick table, as before the merge - the untouched-edit test checks that OK applied the edit (CodeRabbit) --------- Co-authored-by: P'tite Tête <asso@ptitetete.com>
This commit is contained in:
1 parent
46edd8d749
commit
09bb8aaaf5
14 files changed
+295
-42
No files matched your search
@@ -452,8 +452,14 @@ pub enum AxisRef {
|
||||
SketchAxis { axis: String },
|
||||
/// World X / Y / Z axis through the origin.
|
||||
World { axis: String },
|
||||
/// Any line in the sketch plane, in world coordinates.
|
||||
Line { origin: Position, dir: Dir },
|
||||
/// Any line in the sketch plane, in world coordinates. The origin's coordinates are length
|
||||
/// expressions, so the axis follows parameter changes.
|
||||
Line {
|
||||
#[serde(with = "point_expr")]
|
||||
#[walk(placement)]
|
||||
origin: PointExpr,
|
||||
dir: Dir,
|
||||
},
|
||||
/// An edge or round face of the model (a straight or circular edge, a cylinder, cone or
|
||||
/// torus face), found again on each evaluation: [`crate::construct::model_axis`].
|
||||
Model { geo: GeoRef },
|
||||
|
||||
+31
-5
@@ -713,6 +713,7 @@ impl ModelState {
|
||||
/// After a feature evaluated to this state from `before` with cache key `key`: bodies it
|
||||
/// made or changed take that key, sketches it made a digest of their solved geometry (see
|
||||
/// [`quantize`]); the rest keep theirs.
|
||||
/// `f` must have gone through [`naming_feature`]: face naming reads no parameter values.
|
||||
fn stamp(&mut self, doc: &Document, before: &Arc<ModelState>, f: &Feature, key: u64, mats: Vec<Mat>) {
|
||||
let feature = f.id;
|
||||
let depth = before.bodies.iter().filter_map(|b| b.names.depth()).max().unwrap_or(0) + 1;
|
||||
@@ -1381,6 +1382,12 @@ impl Document {
|
||||
pub fn evaluation_values(&self) -> BTreeMap<String, Value> {
|
||||
evaluation_values(self).0
|
||||
}
|
||||
|
||||
/// A placement point read as the features read it: the parameters, and a bare number
|
||||
/// beside them in the design's length unit (#9015).
|
||||
pub fn eval_point(&self, p: &crate::PointExpr) -> Result<Vec3> {
|
||||
point(&self.evaluation_values(), p)
|
||||
}
|
||||
}
|
||||
|
||||
/// The values features are evaluated with: the parameters, and the design's length unit.
|
||||
@@ -2342,7 +2349,9 @@ impl Model {
|
||||
}
|
||||
_ => mats,
|
||||
};
|
||||
next.stamp(doc, &state, f, key, mats);
|
||||
// A revolve axis origin that follows parameters names its faces from its values.
|
||||
let named = naming_feature(&vals, f);
|
||||
next.stamp(doc, &state, &named, key, mats);
|
||||
// Evaluated again only for what came before it (a mirror moved by a drag).
|
||||
if let Some(old) = self.results.get(i).filter(|old| old.id == f.id) {
|
||||
let made = old.state.bodies.iter().filter(|b| b.feature == f.id).map(|b| (b.name.as_str(), b));
|
||||
@@ -4226,10 +4235,26 @@ fn blend_body(
|
||||
Ok((Traced::step(nb.with_preserved_planar_sources(&mb.body)?, &[&from]), used, tapered))
|
||||
}
|
||||
|
||||
/// `f` as the naming of its faces reads it: a revolve's explicit axis origin written as the values
|
||||
/// it has now (the naming has no parameter values to read an expression with).
|
||||
fn naming_feature<'a>(vals: &BTreeMap<String, Value>, f: &'a Feature) -> std::borrow::Cow<'a, Feature> {
|
||||
if let FeatureKind::Revolve { axis: AxisRef::Line { origin, .. }, .. } = &f.kind
|
||||
&& let Ok(o) = point(vals, origin)
|
||||
{
|
||||
let mut g = f.clone();
|
||||
if let FeatureKind::Revolve { axis: AxisRef::Line { origin, .. }, .. } = &mut g.kind {
|
||||
*origin = [format!("{} mm", o.x).into(), format!("{} mm", o.y).into(), format!("{} mm", o.z).into()];
|
||||
}
|
||||
return std::borrow::Cow::Owned(g);
|
||||
}
|
||||
std::borrow::Cow::Borrowed(f)
|
||||
}
|
||||
|
||||
/// The revolve axis in the sketch's plane coordinates (a point and a direction). `st` is the model
|
||||
/// an axis on an edge or face of it is found in; `construct` gives a construction axis, by name, in
|
||||
/// the sketch's 3D frame.
|
||||
/// the sketch's 3D frame; `vals` are the parameter values an explicit axis's origin is read with.
|
||||
pub(crate) fn revolve_axis(
|
||||
vals: &BTreeMap<String, Value>,
|
||||
ss: &SolvedSketch,
|
||||
axis: &AxisRef,
|
||||
st: &ModelState,
|
||||
@@ -4264,7 +4289,7 @@ pub(crate) fn revolve_axis(
|
||||
}
|
||||
Ok((pl.to_local(Vec3::ZERO), Vec2::new(d.dot(pl.x), d.dot(pl.y))))
|
||||
}
|
||||
AxisRef::Line { origin, dir } => line_in_sketch_plane(ss, origin.0, dir.0),
|
||||
AxisRef::Line { origin, dir } => line_in_sketch_plane(ss, point(vals, origin)?, dir.0),
|
||||
AxisRef::Model { geo } => {
|
||||
let (o, d) = crate::construct::model_axis(st, geo)?;
|
||||
line_in_sketch_plane(ss, o, d)
|
||||
@@ -5377,8 +5402,9 @@ fn feature_tools_with_constructor(
|
||||
f,
|
||||
)?;
|
||||
let regions = solidcraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
|
||||
let (o, d) =
|
||||
revolve_axis(&ss, axis, &*axis_state(doc, st, f.component, axis)?, &|name| construction_axis_in(Some(doc), st, name, f.component))?;
|
||||
let (o, d) = revolve_axis(vals, &ss, axis, &*axis_state(doc, st, f.component, axis)?, &|name| {
|
||||
construction_axis_in(Some(doc), st, name, f.component)
|
||||
})?;
|
||||
// To Object is in this feature's component frame: the model as seen from there.
|
||||
let tst = if to.is_some() { state_in_frame(doc, st, f.component)? } else { std::borrow::Cow::Borrowed(st) };
|
||||
let angles = if to.is_some() {
|
||||
|
||||
@@ -308,7 +308,7 @@ pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature,
|
||||
st.sketch(sketch.0).ok_or_else(|| DocError::Unknown(format!("sketch {sketch} (it must come earlier in the timeline)")))?,
|
||||
f.component,
|
||||
)?;
|
||||
let (o, d) = revolve_axis(&ss, axis, &*super::axis_state(doc, st, f.component, axis)?, &|name| {
|
||||
let (o, d) = revolve_axis(vals, &ss, axis, &*super::axis_state(doc, st, f.component, axis)?, &|name| {
|
||||
construction_axis_in(Some(doc), st, name, f.component)
|
||||
})?;
|
||||
let a = val(vals, angle, Kind::Angle)?;
|
||||
|
||||
@@ -12,6 +12,7 @@ revolve
|
||||
moves: axis.dir[0], axis.dir[1], axis.dir[2], axis.origin[0], axis.origin[1], axis.origin[2], to[0], to[1], to[2]
|
||||
face points: [3, 3.5, 3.25]
|
||||
profiles: 1 all
|
||||
placement: 9, 9.5, 9.25
|
||||
fillet_constant
|
||||
moves: edges[0][0], edges[0][1], edges[0][2]
|
||||
fillet_chord
|
||||
@@ -167,6 +168,7 @@ surface_extrude
|
||||
face points: [1, 1.5, 1.25], [2, 2.5, 2.25]
|
||||
surface_revolve
|
||||
moves: axis.dir[0], axis.dir[1], axis.dir[2], axis.origin[0], axis.origin[1], axis.origin[2]
|
||||
placement: 9, 9.5, 9.25
|
||||
surface_sweep
|
||||
surface_sweep_options
|
||||
surface_loft
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
//! A revolve's explicit axis `{origin, dir}` can save its origin's coordinates as length
|
||||
//! expressions (`["W / 2", 0, "groove_floor"]`) so the axis follows the parameters; a plain number
|
||||
//! stays a number. An older design has numbers only and reads as before. The last release refuses
|
||||
//! a design with this change and asks for an update, instead of opening it and reading an
|
||||
//! expression as the origin.
|
||||
@@ -835,7 +835,7 @@ pub(crate) fn face_centres(b: &ModelBody) -> Vec<Vec3> {
|
||||
samples(&b.mesh(), face_count(b)).into_iter().map(|ps| ps.iter().fold(Vec3::ZERO, |a, p| a + *p) * (1.0 / ps.len().max(1) as f64)).collect()
|
||||
}
|
||||
|
||||
/// The name of a face new to `f`.
|
||||
/// The name of a face new to `f` (a feature that went through `eval::naming_feature`).
|
||||
fn role_name(f: &Feature, before: &ModelState, ps: &[Vec3], ns: &[Vec3], fi: usize, fid: u64, curves: &std::cell::OnceCell<Curves>) -> String {
|
||||
let c = ps.iter().fold(Vec3::ZERO, |a, p| a + *p) * (1.0 / ps.len().max(1) as f64);
|
||||
match &f.kind {
|
||||
@@ -858,7 +858,10 @@ fn role_name(f: &Feature, before: &ModelState, ps: &[Vec3], ns: &[Vec3], fi: usi
|
||||
}
|
||||
FeatureKind::Revolve { sketch, axis, .. } => {
|
||||
let Some(ss) = before.sketch(sketch.0) else { return format!("F{fid}:face:{fi}") };
|
||||
let Ok((o2, d2)) = crate::eval::revolve_axis(ss, axis, before, &|name| crate::eval::construction_axis_in(None, before, name, 0)) else {
|
||||
// The origin was written as its values when the feature was evaluated (`naming_feature`).
|
||||
let Ok((o2, d2)) =
|
||||
crate::eval::revolve_axis(&Default::default(), ss, axis, before, &|name| crate::eval::construction_axis_in(None, before, name, 0))
|
||||
else {
|
||||
return format!("F{fid}:face:{fi}");
|
||||
};
|
||||
let (o, d) = (ss.plane.to_world(o2), (ss.plane.to_world(o2 + d2) - ss.plane.to_world(o2)).normalized().unwrap_or(Vec3::Z));
|
||||
|
||||
@@ -43,7 +43,7 @@ pub static COMMANDS: &[CommandSpec] = &[
|
||||
CommandSpec::new("solid.revolve", "Revolve", revolve)
|
||||
.at("SOLID", "CREATE")
|
||||
.icon("revolve")
|
||||
.params("axis: sketch line id | x | y (sketch axes) | X|Y|Z (world) | {type: world, axis: X|Y|Z} (as returned by timeline.inspect) | construction axis name (followed when edited) | {origin, dir} | {edge|face: [x,y,z]} (a straight or circular edge, or a cylinder, cone or torus face: about its axis, followed as the model changes); angle?: expr (default 360 deg); angle2?: expr (Two Sides: the other side's angle); direction?: symmetric (angle split either side, independent of axis direction); convention?: sketch_normal|legacy_axis_start (default sketch_normal; legacy retains older angular starts); to?: [x,y,z] (To Object: turn until that face, vertex or point); sketch?, profiles? | face: [x,y,z] (a planar body face as the profile) and face_body?: name (whose face, where faces of several bodies meet), operation?, touching?, targets?, name?, body_name?"),
|
||||
.params("axis: sketch line id | x | y (sketch axes) | X|Y|Z (world) | {type: world, axis: X|Y|Z} (as returned by timeline.inspect) | construction axis name (followed when edited) | {origin, dir} (origin: numbers or length expressions, followed when parameters change) | {edge|face: [x,y,z]} (a straight or circular edge, or a cylinder, cone or torus face: about its axis, followed as the model changes); angle?: expr (default 360 deg); angle2?: expr (Two Sides: the other side's angle); direction?: symmetric (angle split either side, independent of axis direction); convention?: sketch_normal|legacy_axis_start (default sketch_normal; legacy retains older angular starts); to?: [x,y,z] (To Object: turn until that face, vertex or point); sketch?, profiles? | face: [x,y,z] (a planar body face as the profile) and face_body?: name (whose face, where faces of several bodies meet), operation?, touching?, targets?, name?, body_name?"),
|
||||
CommandSpec::new("solid.sweep", "Sweep", sweep)
|
||||
.at("SOLID", "CREATE")
|
||||
.icon("sweep")
|
||||
@@ -1335,7 +1335,8 @@ fn revolve(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
|
||||
/// A revolve axis of `sketch` from its parameter: a sketch line id, the sketch's x or y axis, a
|
||||
/// world axis (also as saved: {type: world, axis: X|Y|Z}), a construction axis by name
|
||||
/// (followed when it is edited), {origin, dir}, or an edge
|
||||
/// (followed when it is edited), {origin, dir} (each origin coordinate a number or an expression over
|
||||
/// the parameters, which the axis follows), or an edge
|
||||
/// or round face of the model ({edge|face: [x,y,z]}), which the revolve follows as the model
|
||||
/// changes. A line of the sketch wins over a construction axis of the same name.
|
||||
pub(super) fn axis_param(s: &Session, sketch: u64, p: &Value, cmd: &str) -> Result<AxisRef> {
|
||||
@@ -1348,9 +1349,12 @@ pub(super) fn axis_param(s: &Session, sketch: u64, p: &Value, cmd: &str) -> Resu
|
||||
str_(o, "axis").filter(|a| matches!(*a, "X" | "Y" | "Z")).ok_or_else(|| bad(cmd, "world axis requires `axis` to be X, Y or Z"))?;
|
||||
return Ok(AxisRef::World { axis: axis.into() });
|
||||
}
|
||||
let origin = o.get("origin").and_then(vec3).unwrap_or(Vec3::ZERO);
|
||||
let dir = o.get("dir").and_then(vec3).ok_or_else(|| bad(cmd, "axis needs `dir`"))?;
|
||||
return Ok(AxisRef::Line { origin: Position(origin), dir: Dir(dir) });
|
||||
let origin = point_param(s, o, "origin", cmd)?.unwrap_or_else(|| solidcraft_doc::point_expr(Vec3::ZERO));
|
||||
let dir = match o.get("dir") {
|
||||
None => return Err(bad(cmd, "axis needs `dir`")),
|
||||
Some(v) => vec3(v).ok_or_else(|| bad(cmd, "axis `dir` must be a direction [x, y, z] of numbers"))?,
|
||||
};
|
||||
return Ok(AxisRef::Line { origin, dir: Dir(dir) });
|
||||
}
|
||||
match str_(p, "axis") {
|
||||
Some(a @ ("X" | "Y" | "Z")) => Ok(AxisRef::World { axis: a.into() }),
|
||||
|
||||
@@ -473,3 +473,74 @@ fn invalid_world_axis_objects_are_rejected_atomically() {
|
||||
assert!(s.model.state().bodies.is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_axis_origin_takes_expressions_and_follows_parameters() {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "parameters.add", json!({"name": "W", "expression": "40 mm"}));
|
||||
profile(&mut s, false);
|
||||
let volume = |s: &Session| solidcraft_kernel::measure(&s.model.state().bodies[0].body).unwrap().volume;
|
||||
let axis = json!({"origin": ["W / 2 - 20", 0, 0], "dir": [0, 1, 0]});
|
||||
run(&mut s, "solid.revolve", json!({"sketch": "Profile", "axis": axis, "name": "Turn", "operation": "new"}));
|
||||
// W / 2 - 20 is 0 mm: radii 2 to 4 about x = 0.
|
||||
assert!((volume(&s) - 120.0 * PI).abs() < 0.2, "{}", volume(&s));
|
||||
let FeatureKind::Revolve { axis: solidcraft_doc::AxisRef::Line { origin, .. }, .. } = &s.doc.find_feature("Turn").unwrap().kind else {
|
||||
panic!("not a line axis");
|
||||
};
|
||||
assert_eq!(origin[0].as_str(), "W / 2 - 20");
|
||||
let reopened = Document::from_json(&s.doc.to_json()).unwrap();
|
||||
assert_eq!(reopened.find_feature("Turn").unwrap().kind, s.doc.find_feature("Turn").unwrap().kind);
|
||||
// Moving the axis follows W: the origin is at x = 1, so the radii are 1 to 3.
|
||||
run(&mut s, "parameters.change", json!({"name": "W", "expression": "42 mm"}));
|
||||
assert!((volume(&s) - 80.0 * PI).abs() < 0.2, "{}", volume(&s));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_axis_refuses_an_origin_or_dir_it_cannot_read() {
|
||||
let mut s = Session::default();
|
||||
profile(&mut s, false);
|
||||
let before = s.doc.to_json();
|
||||
for axis in [
|
||||
json!({"origin": ["no_such_parameter", 0, 0], "dir": [0, 1, 0]}),
|
||||
json!({"origin": ["1 +", 0, 0], "dir": [0, 1, 0]}),
|
||||
json!({"origin": [0, 0], "dir": [0, 1, 0]}),
|
||||
json!({"origin": [null, 0, 0], "dir": [0, 1, 0]}),
|
||||
json!({"origin": [0, 0, 0], "dir": ["W", 1, 0]}),
|
||||
] {
|
||||
let error = s.execute("solid.revolve", &json!({"sketch": "Profile", "axis": axis, "operation": "new"})).unwrap_err();
|
||||
assert!(matches!(error, crate::EngineError::BadParams { .. }), "{axis}: {error}");
|
||||
assert!(!error.to_string().contains("sketch plane"), "{axis}: {error}");
|
||||
assert_eq!(s.doc.to_json(), before);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn surface_revolve_axis_origin_follows_a_parameter() {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "parameters.add", json!({"name": "W", "expression": "40 mm"}));
|
||||
profile(&mut s, false);
|
||||
let axis = json!({"origin": ["W / 2 - 20", 0, 0], "dir": [0, 1, 0]});
|
||||
run(&mut s, "surface.revolve", json!({"sketch": "Profile", "axis": axis, "name": "Wall"}));
|
||||
let min_x = |s: &Session| s.model.state().bodies[0].body.mesh(&solidcraft_kernel::MeshTolerance::chord(1e-3)).unwrap().bounds().min.x;
|
||||
// W / 2 - 20 is 0 mm: the profile (x from 2 to 4) sweeps out to x = -4.
|
||||
assert!((min_x(&s) + 4.0).abs() < 0.05, "{}", min_x(&s));
|
||||
run(&mut s, "parameters.change", json!({"name": "W", "expression": "42 mm"}));
|
||||
// The axis is at x = 1: the farthest point is 3 from it.
|
||||
assert!((min_x(&s) + 2.0).abs() < 0.05, "{}", min_x(&s));
|
||||
let reopened = Document::from_json(&s.doc.to_json()).unwrap();
|
||||
assert_eq!(reopened.find_feature("Wall").unwrap().kind, s.doc.find_feature("Wall").unwrap().kind);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_parameter_driven_axis_origin_names_revolve_faces_as_the_numeric_origin_does() {
|
||||
let names = |origin: Value| {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "parameters.add", json!({"name": "W", "expression": "40 mm"}));
|
||||
profile(&mut s, false);
|
||||
run(&mut s, "solid.revolve", json!({"sketch": "Profile", "axis": {"origin": origin, "dir": [0, 1, 0]}, "operation": "new"}));
|
||||
solidcraft_doc::naming::face_names(&s.model.state().bodies[0]).to_vec()
|
||||
};
|
||||
let numeric = names(json!([20, 0, 0]));
|
||||
assert!(numeric.iter().all(|n| !n.contains(":face:")), "index names: {numeric:?}");
|
||||
assert_eq!(names(json!(["W / 2", 0, 0])), numeric);
|
||||
}
|
||||
@@ -44,7 +44,7 @@ pub static COMMANDS: &[CommandSpec] = &[
|
||||
CommandSpec::new("surface.revolve", "Surface Revolve", surface_revolve)
|
||||
.at("SURFACE", "CREATE")
|
||||
.icon("surface_revolve")
|
||||
.params("sketch?: id|name; curves?: [curve ids] and/or profiles? (as surface.extrude); axis: sketch line id|x|y|X|Y|Z|{type: world, axis: X|Y|Z}|construction axis name|{origin, dir} | {edge|face: [x,y,z]} (a straight or circular edge, or a cylinder, cone or torus face: about its axis, followed as the model changes); angle?: expr (default 360 deg); angle2?: expr (the other side); symmetric?: bool; name?, body_name? (a surface body, no caps; a solid where a full turn closes it)"),
|
||||
.params("sketch?: id|name; curves?: [curve ids] and/or profiles? (as surface.extrude); axis: sketch line id|x|y|X|Y|Z|{type: world, axis: X|Y|Z}|construction axis name|{origin, dir} (origin: numbers or length expressions, followed when parameters change) | {edge|face: [x,y,z]} (a straight or circular edge, or a cylinder, cone or torus face: about its axis, followed as the model changes); angle?: expr (default 360 deg); angle2?: expr (the other side); symmetric?: bool; name?, body_name? (a surface body, no caps; a solid where a full turn closes it)"),
|
||||
CommandSpec::new("surface.sweep", "Surface Sweep", surface_sweep)
|
||||
.at("SURFACE", "CREATE")
|
||||
.icon("surface_sweep")
|
||||
|
||||
+48
-15
@@ -434,7 +434,11 @@ impl Drop for Nested {
|
||||
pub fn to_local(s: &Session, id: &str, params: &Value) -> crate::Result<Option<Value>> {
|
||||
// A command with no world picks has nothing to map, and may not need the bodies placed.
|
||||
let picks = !table(id).is_empty() || matches!(id, "library.apply" | "timeline.redefine" | "sketch.redefine");
|
||||
if !picks || !placed(s) {
|
||||
// Edit Feature of a revolve restores its saved axis (and the origin's expressions) even
|
||||
// where nothing is placed (`map_local`).
|
||||
let revolve_edit =
|
||||
id == "timeline.redefine" && matches!(params.get("command").and_then(Value::as_str), Some("solid.revolve" | "surface.revolve"));
|
||||
if !picks || (!placed(s) && !revolve_edit) {
|
||||
return Ok(None);
|
||||
}
|
||||
// A move of bodies in differently turned frames keeps its world vectors: `solid.move` splits
|
||||
@@ -442,7 +446,8 @@ pub fn to_local(s: &Session, id: &str, params: &Value) -> crate::Result<Option<V
|
||||
if id == "solid.move" && split_move(s, params)?.is_some() {
|
||||
return Ok(None);
|
||||
}
|
||||
let world = s.world_state()?;
|
||||
// Nothing placed: the model is its own world, and only the saved axis is restored.
|
||||
let world = if placed(s) { s.world_state()? } else { s.model.state() };
|
||||
Ok(map_local(s, &world, id, params))
|
||||
}
|
||||
|
||||
@@ -527,16 +532,41 @@ fn map_local(s: &Session, world: &solidcraft_doc::ModelState, id: &str, params:
|
||||
if let solidcraft_doc::FeatureKind::Emboss { face: Some(face), .. } = &feature.kind {
|
||||
context.active_occurrence_path = (!face.author_path.is_empty()).then(|| face.author_path.clone());
|
||||
}
|
||||
let mut inner = map_local(&context, world, cmd, params.get("params")?)?;
|
||||
// Nothing to map (a surface revolve has no picks; a design with no placed component needs
|
||||
// none): an untouched explicit axis is still restored below.
|
||||
let mapped = if placed(s) { map_local(&context, world, cmd, params.get("params")?) } else { None };
|
||||
let mut inner = match mapped {
|
||||
Some(inner) => inner,
|
||||
None if matches!(cmd, "solid.revolve" | "surface.revolve") => params.get("params")?.clone(),
|
||||
None => return None,
|
||||
};
|
||||
// An untouched explicit axis is displayed in world coordinates by Edit
|
||||
// Feature. Keep its exact saved values instead of an affine round trip.
|
||||
if cmd == "solid.revolve"
|
||||
&& let solidcraft_doc::FeatureKind::Revolve { axis: solidcraft_doc::AxisRef::Line { origin, dir }, .. } = &feature.kind
|
||||
if let (
|
||||
"solid.revolve" | "surface.revolve",
|
||||
solidcraft_doc::FeatureKind::Revolve { axis: solidcraft_doc::AxisRef::Line { origin, dir }, .. }
|
||||
| solidcraft_doc::FeatureKind::SurfaceRevolve { axis: solidcraft_doc::AxisRef::Line { origin, dir }, .. },
|
||||
) = (cmd, &feature.kind)
|
||||
&& let Ok(at) = s.doc.eval_point(origin)
|
||||
{
|
||||
let frame = context.active_component_frame();
|
||||
let displayed = serde_json::json!({"origin":pt(apply_point(&frame,origin.0)),"dir":pt(apply_vector(&frame,dir.0))});
|
||||
if params.get("params").and_then(|p| p.get("axis")) == Some(&displayed) {
|
||||
inner["axis"] = serde_json::json!({"origin":pt(origin.0),"dir":pt(dir.0)});
|
||||
// Each half is kept when the dialog gives back what it showed (to float dust), so
|
||||
// editing only the direction leaves the origin's expressions alone.
|
||||
let given = params.get("params").and_then(|p| p.get("axis"));
|
||||
let shown = |key: &str, shown: Vec3| {
|
||||
let given = given.and_then(|a| a.get(key)).and_then(Value::as_array)?;
|
||||
let [x, y, z] = given.as_slice() else { return None };
|
||||
let near = |g: &Value, w: f64| g.as_f64().is_some_and(|g| (g - w).abs() <= 1e-9 * (1.0 + w.abs()));
|
||||
(near(x, shown.x) && near(y, shown.y) && near(z, shown.z)).then_some(())
|
||||
};
|
||||
if let Some(axis) = inner.get_mut("axis").and_then(Value::as_object_mut) {
|
||||
if shown("origin", apply_point(&frame, at)).is_some() {
|
||||
// The origin as saved: its expressions stay expressions.
|
||||
axis.insert("origin".into(), placement_point(origin));
|
||||
}
|
||||
if shown("dir", apply_vector(&frame, dir.0)).is_some() {
|
||||
axis.insert("dir".into(), pt(dir.0));
|
||||
}
|
||||
}
|
||||
}
|
||||
let points = match (&feature.kind, cmd) {
|
||||
@@ -677,16 +707,19 @@ fn map_local(s: &Session, world: &solidcraft_doc::ModelState, id: &str, params:
|
||||
m.changed.then_some(Value::Object(out))
|
||||
}
|
||||
|
||||
/// A placement point as saved: a plain number stays a number, an expression is its text.
|
||||
fn placement_point(p: &solidcraft_doc::PointExpr) -> Value {
|
||||
Value::Array(
|
||||
p.iter()
|
||||
.map(|e| e.as_str().trim().parse::<f64>().ok().filter(|x| x.is_finite()).map_or_else(|| Value::from(e.as_str()), Value::from))
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
|
||||
/// A primitive's saved placement inputs, in its component's frame, for redefining it with `cmd`.
|
||||
fn primitive_placement(kind: &solidcraft_doc::FeatureKind, cmd: &str) -> Vec<(&'static str, Value)> {
|
||||
use solidcraft_doc::FeatureKind as Feature;
|
||||
let point = |p: &solidcraft_doc::PointExpr| {
|
||||
Value::Array(
|
||||
p.iter()
|
||||
.map(|e| e.as_str().trim().parse::<f64>().ok().filter(|x| x.is_finite()).map_or_else(|| Value::from(e.as_str()), Value::from))
|
||||
.collect(),
|
||||
)
|
||||
};
|
||||
let point = placement_point;
|
||||
match (kind, cmd) {
|
||||
(Feature::Box { corner, .. }, "solid.box") => vec![("corner", point(corner))],
|
||||
(Feature::Sphere { center, .. }, "solid.sphere") | (Feature::Torus { center, .. }, "solid.torus") => vec![("center", point(center))],
|
||||
|
||||
@@ -358,6 +358,48 @@ fn editing_a_primitive_in_a_turned_component_keeps_its_placement() {
|
||||
assert!((size.x - before.x).abs() < 1e-6 && (size.y - 12.0).abs() < 0.05 && (size.z - 12.0).abs() < 0.05, "{size:?}");
|
||||
}
|
||||
|
||||
/// Edit Feature shows an explicit revolve axis with its origin evaluated; sending that back
|
||||
/// untouched keeps the saved expressions, for a solid and a surface revolve alike.
|
||||
#[test]
|
||||
fn an_untouched_revolve_axis_keeps_its_origin_expressions_through_redefine() {
|
||||
for (command, name) in [("solid.revolve", "Turn"), ("surface.revolve", "Shell")] {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "parameters.add", json!({"name": "W", "expression": "40 mm"}));
|
||||
run(&mut s, "sketch.create", json!({"name": "Profile", "plane": "XY"}));
|
||||
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [5, 0], "p1": [10, 5]}));
|
||||
run(&mut s, "sketch.finish", json!({}));
|
||||
let axis = json!({"origin": ["W / 2", 0, 0], "dir": [0, 1, 0]});
|
||||
let mut made = json!({"sketch": "Profile", "axis": axis, "angle": "90 deg", "name": name});
|
||||
if command == "solid.revolve" {
|
||||
made["operation"] = json!("new");
|
||||
}
|
||||
run(&mut s, command, made);
|
||||
// The origin's coordinates as text (a saved 0 may read back as 0 or 0.0).
|
||||
let saved = |s: &mut Session| -> Vec<String> {
|
||||
let axis = run(s, "timeline.inspect", json!({"feature": name}))["definition"]["axis"].clone();
|
||||
axis["origin"].as_array().unwrap().iter().map(|c| c.as_f64().map_or_else(|| c.as_str().unwrap().to_string(), |x| x.to_string())).collect()
|
||||
};
|
||||
let original = saved(&mut s);
|
||||
assert_eq!(original, ["W / 2", "0", "0"]);
|
||||
// What the dialog sends back untouched: the origin as numbers.
|
||||
let mut params = json!({"sketch": "Profile", "axis": {"origin": [20.0, 0.0, 0.0], "dir": [0.0, 1.0, 0.0]}, "angle": "45 deg"});
|
||||
if command == "solid.revolve" {
|
||||
params["operation"] = json!("new");
|
||||
}
|
||||
run(&mut s, "timeline.redefine", json!({"feature": name, "command": command, "params": params}));
|
||||
assert_eq!(saved(&mut s), original, "{command}");
|
||||
// Only the direction changed: the origin keeps its expressions.
|
||||
let mut turned = params.clone();
|
||||
turned["axis"]["dir"] = json!([0.0, -1.0, 0.0]);
|
||||
run(&mut s, "timeline.redefine", json!({"feature": name, "command": command, "params": turned}));
|
||||
assert_eq!(saved(&mut s), original, "{command}");
|
||||
// A changed origin is taken as given.
|
||||
params["axis"]["origin"] = json!([21.0, 0.0, 0.0]);
|
||||
run(&mut s, "timeline.redefine", json!({"feature": name, "command": command, "params": params}));
|
||||
assert_eq!(saved(&mut s), ["21", "0", "0"], "{command}");
|
||||
}
|
||||
}
|
||||
|
||||
/// A new placement given to `timeline.redefine` is still a world point.
|
||||
#[test]
|
||||
fn a_new_primitive_placement_is_still_mapped_from_the_world() {
|
||||
|
||||
@@ -2949,6 +2949,17 @@ fn stored_input_reference_key(d: &Dialog, index: usize) -> Option<&'static str>
|
||||
}
|
||||
}
|
||||
|
||||
/// An explicit revolve axis as its dialog holds it, in the world: the origin evaluated with the
|
||||
/// parameters (an untouched axis is restored as saved, expressions included:
|
||||
/// `solidcraft_engine::frames::to_local`). An origin that cannot be evaluated is kept as saved.
|
||||
pub(crate) fn line_axis_value(s: &Session, frame: &solidcraft_engine::doc::Mat, origin: &solidcraft_engine::doc::PointExpr, dir: Vec3) -> Value {
|
||||
let dir_world = pt(solidcraft_engine::doc::apply_vector(frame, dir));
|
||||
match s.doc.eval_point(origin) {
|
||||
Ok(at) => json!({"origin": pt(solidcraft_engine::doc::apply_point(frame, at)), "dir": dir_world}),
|
||||
Err(_) => json!({"origin": origin, "dir": dir_world}),
|
||||
}
|
||||
}
|
||||
|
||||
fn stored_revolve_axis(kind: &Kind) -> Option<&Value> {
|
||||
match kind {
|
||||
Kind::Revolve { axis, .. } | Kind::Surface(crate::dialogs_surface::Surf::Revolve { axis, .. }) => axis.as_ref(),
|
||||
@@ -6370,10 +6381,7 @@ pub fn for_feature(app: &SolveApp, id: u64, marker: Option<usize>) -> Option<Dia
|
||||
let mut d = start("solid.revolve")?;
|
||||
let frame = feature_frame(s, f.component);
|
||||
let stored_axis = match axis {
|
||||
AxisRef::Line { origin, dir } => Some(json!({
|
||||
"origin": pt(solidcraft_engine::doc::apply_point(&frame, origin.0)),
|
||||
"dir": pt(solidcraft_engine::doc::apply_vector(&frame, dir.0))
|
||||
})),
|
||||
AxisRef::Line { origin, dir } => Some(line_axis_value(s, &frame, origin, dir.0)),
|
||||
// An edge or face that is gone stays the reference until another is picked.
|
||||
AxisRef::Model { geo } if model_axis_sel(s, geo).is_none() => serde_json::to_value(geo).ok(),
|
||||
_ => None,
|
||||
|
||||
@@ -829,13 +829,7 @@ pub fn for_feature(app: &SolveApp, kind: &FeatureKind, frame: &Mat) -> Option<(K
|
||||
AxisRef::SketchAxis { axis } => (Some(Sel::Axis { name: axis.to_ascii_lowercase() }), None),
|
||||
AxisRef::SketchLine { curve } => (Some(crate::selection::curve_pick(curve, sketch.0, s.active_sketch)), None),
|
||||
AxisRef::Construction { name } => (Some(Sel::Axis { name: name.to_string() }), None),
|
||||
AxisRef::Line { origin, dir } => (
|
||||
None,
|
||||
Some(json!({
|
||||
"origin": pt(solidcraft_engine::doc::apply_point(frame, origin.0)),
|
||||
"dir": pt(solidcraft_engine::doc::apply_vector(frame, dir.0))
|
||||
})),
|
||||
),
|
||||
AxisRef::Line { origin, dir } => (None, Some(crate::dialogs::line_axis_value(s, frame, origin, dir.0))),
|
||||
// An edge or face that is gone stays the reference until another is picked.
|
||||
AxisRef::Model { geo } => match crate::dialogs::model_axis_sel(s, geo) {
|
||||
Some(pick) => (Some(pick), None),
|
||||
|
||||
@@ -288,3 +288,62 @@ fn only_the_active_selection_field_looks_active() {
|
||||
assert_eq!(border(&h, "Profile"), filled, "filled inactive");
|
||||
assert_ne!(filled, t.control_border, "filled inactive differs from empty inactive");
|
||||
}
|
||||
|
||||
/// A solid (or surface) revolve named `Turn` about `axis`, made in a new component `Owner` that is
|
||||
/// turned and moved afterwards when `moved`, with parameter `W` = 40 mm.
|
||||
fn expression_axis_design(surface: bool, moved: bool) -> Harness {
|
||||
let mut h = Harness::new();
|
||||
h.app.run("parameters.add", json!({"name":"W","expression":"40 mm"})).unwrap();
|
||||
let owner = h.app.run("component.create", json!({"name":"Owner","grounded":false})).unwrap();
|
||||
let axis = json!({"origin":["W / 2", "5 mm", 0],"dir":[0,1,0]});
|
||||
let mut h = if surface {
|
||||
h.app.run("sketch.create", json!({"plane":"XY","name":"Profile"})).unwrap();
|
||||
h.app.run("sketch.rectangle.two_point", json!({"p0":[10,0],"p1":[15,5]})).unwrap();
|
||||
h.app.run("sketch.finish", json!({})).unwrap();
|
||||
h.app.run("surface.revolve", json!({"sketch":"Profile","axis":axis,"angle":"90 deg","name":"Turn"})).unwrap();
|
||||
h
|
||||
} else {
|
||||
make(h, axis)
|
||||
};
|
||||
if moved {
|
||||
h.app.run("occurrence.move", json!({"occurrence":owner["occurrence"],"translate":[100,0,20],"axis":[0,0,1],"angle":"17 deg"})).unwrap();
|
||||
h.app.run("component.create", json!({"name":"Other","parent":0})).unwrap();
|
||||
}
|
||||
h
|
||||
}
|
||||
|
||||
fn saved_axis(h: &Harness) -> Value {
|
||||
match &h.app.session.doc.find_feature("Turn").unwrap().kind {
|
||||
FeatureKind::Revolve { axis, .. } | FeatureKind::SurfaceRevolve { axis, .. } => serde_json::to_value(axis).unwrap(),
|
||||
other => panic!("not a revolve: {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn untouched_edit_keeps_an_explicit_axis_origin_expression_for_solid_and_surface_revolves() {
|
||||
for (surface, moved) in [(false, false), (true, false), (false, true), (true, true)] {
|
||||
let mut h = expression_axis_design(surface, moved);
|
||||
let original = saved_axis(&h);
|
||||
assert_eq!(original["origin"][0], json!("W / 2"));
|
||||
open(&mut h);
|
||||
h.step(&json!({"widget":"OK"})).unwrap();
|
||||
assert!(h.app.dialog.is_none(), "OK did not apply the edit (surface: {surface}, moved: {moved})");
|
||||
assert_eq!(saved_axis(&h), original, "surface: {surface}, moved: {moved}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_axis_origin_that_cannot_be_evaluated_is_kept_by_an_untouched_edit() {
|
||||
for (surface, moved) in [(false, false), (true, false), (false, true), (true, true)] {
|
||||
let mut h = expression_axis_design(surface, moved);
|
||||
let original = saved_axis(&h);
|
||||
// W is no longer a length: the revolve fails and its origin cannot be shown as numbers.
|
||||
// (`parameters.change` refuses that, so the parameter is set directly.)
|
||||
let mut doc = (*h.app.session.doc).clone();
|
||||
doc.params.iter_mut().filter(|p| p.name == "W").for_each(|p| p.expr = "5 deg".into());
|
||||
h.app.session.doc = std::sync::Arc::new(doc);
|
||||
open(&mut h);
|
||||
h.step(&json!({"widget":"OK"})).unwrap();
|
||||
assert_eq!(saved_axis(&h), original, "surface: {surface}, moved: {moved}");
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user