* claim: #8151 * Opening: a design saved by 0.24 keeps the body a Join To Object runs to (#8151) Since 0.24.1 a Join extrude To Object also joins the body it runs to (#6424). Designs saved by 0.24.0 and earlier were built without that, so on 0.25 the reported box swallowed its lid: the lid's sketch, the holes, the cut and the moves after it failed. An extent may now save `to_body_apart: true`, which leaves that body apart. One pending format change sets it on every Join extrude To Object of a design of format 39 or older as it opens; designs of format 40 and later keep the join. Editing the extrude keeps the field. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Markus Kaltenbrunner <kaltenbrunnermarkus@users.noreply.github.com> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
3359 lines
175 KiB
Rust
3359 lines
175 KiB
Rust
//! Solid feature commands: extrude, revolve, fillet, chamfer, primitives, combine, move.
|
|
|
|
use serde_json::{Value, json};
|
|
use solidcraft_doc::{
|
|
AxisRef, Direction, Expr, Extent, FeatureKind, Operation, PointExpr, ProfileSel, RailFit, SweepOrientation, SweepRail, ThinSide, ThinWall,
|
|
expr::Kind, point_expr,
|
|
};
|
|
use solidcraft_doc::{BodyName, FeatureName, SketchId};
|
|
use solidcraft_doc::{Dir, FacePick, Position};
|
|
use solidcraft_geom::Vec3;
|
|
|
|
use super::{CommandSpec, not_in_sketch};
|
|
use crate::params::{UNKNOWN_COMMAND, bad, bool_, expr, expr_problem, req_expr, str_, string_list, string_list_or_default, vec2, vec3};
|
|
use crate::schema::features::{
|
|
BoundingSolidParams, BoxParams, ConeParams, CylinderParams, ExtrudeParams, FeatureResult, OffsetPlaneParams, PipeParams, PlaneAtAngleParams,
|
|
ScaleParams, SphereParams, TorusParams,
|
|
};
|
|
use crate::schema::{TypedContract, output_schema_for};
|
|
use crate::{EngineError, Result, Session};
|
|
|
|
const BOX_CONTRACT: TypedContract<BoxParams> = TypedContract::new();
|
|
const EXTRUDE_CONTRACT: TypedContract<ExtrudeParams> = TypedContract::new();
|
|
const CYLINDER_CONTRACT: TypedContract<CylinderParams> = TypedContract::new();
|
|
const SPHERE_CONTRACT: TypedContract<SphereParams> = TypedContract::new();
|
|
const TORUS_CONTRACT: TypedContract<TorusParams> = TypedContract::new();
|
|
const CONE_CONTRACT: TypedContract<ConeParams> = TypedContract::new();
|
|
const PIPE_CONTRACT: TypedContract<PipeParams> = TypedContract::new();
|
|
const BOUNDING_SOLID_CONTRACT: TypedContract<BoundingSolidParams> = TypedContract::new();
|
|
const SCALE_CONTRACT: TypedContract<ScaleParams> = TypedContract::new();
|
|
const OFFSET_PLANE_CONTRACT: TypedContract<OffsetPlaneParams> = TypedContract::new();
|
|
const PLANE_AT_ANGLE_CONTRACT: TypedContract<PlaneAtAngleParams> = TypedContract::new();
|
|
|
|
pub static COMMANDS: &[CommandSpec] = &[
|
|
CommandSpec::new("solid.extrude", "Extrude", crate::checked!("solid.extrude", extrude))
|
|
.at("SOLID", "CREATE")
|
|
.icon("extrude")
|
|
.key("E")
|
|
.contract(&EXTRUDE_CONTRACT)
|
|
.output(output_schema_for::<FeatureResult>)
|
|
.params("distance: expr (or through_all: true); taper?: angle expr (positive: outward, so the far end is larger along the extrusion direction; negative: inward, so the far end is smaller); sketch?: id|name (default: active or last sketch); profiles?: all | [index] | [{curves: [ids]}] (the profile whose outer loop is made of exactly these curves, or pieces of them; found again on every recompute, so it follows parameter changes; islands inside are its holes; an error when no profile or several match) | [{point:[x,y]}] (index and point picks are stored by their curves when that finds the same profile; a pick on a drawn profile that reference geometry, such as the projected outline of the face the sketch is on, cuts into regions takes the whole drawn profile); exact_regions?: bool (each index or point pick is exactly the region it names, as the dialogs send); default: every drawn profile, except that a loop inside another is its hole and a loop inside that hole is material again; face?: [x,y,z] (extrude a planar body face instead of a sketch profile); faces?: [[x,y,z],…] (coplanar faces of one body); face_body?: name (whose face, where faces of several bodies meet at the point); direction?: positive|negative|symmetric (distance is total thickness, split evenly around the start plane); convention?: total_distance|legacy_per_side (default total_distance; legacy preserves older symmetric extents); distance2?: expr (Two Sides: a second distance the other way from the first side, which may be through_all or to; with direction: negative the first side goes against the normal and distance2 along it); start_offset?: expr (along the sketch normal, also with direction: negative); to?: [x,y,z] (To Object: a face, vertex or point; to_offset?: expr past it); from?: [x,y,z] (From Object: start at that face or point); operation?: new|join|cut|intersect|auto (cut into a body, otherwise join existing solids; new in an empty component); targets?: [body] (Join from a face, or from a sketch on a body's face, defaults to that face's body; explicit targets or participants override); name?; body_name?; thin?: true (Thin: a wall along sketch curves instead of the profiles) with curves?: [curve ids] (open chains and closed loops, joined where they meet end to end; default: every drawn curve of the sketch), thickness: expr, side?: center|inside|outside|two_sides (a closed loop's inside is the area it encloses, an open chain's the side it bends toward, a straight line's the left of its first curve as drawn; default center), thickness2?: expr (two_sides: the thickness outside); corners are mitred, crossing walls are one"),
|
|
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?, targets?, name?, body_name?"),
|
|
CommandSpec::new("solid.sweep", "Sweep", sweep)
|
|
.at("SOLID", "CREATE")
|
|
.icon("sweep")
|
|
.params("sketch: profile sketch; profiles?; path_sketch: sketch; path: [curve ids in order]; orientation?: perpendicular (default: square to the path, turning with it) | parallel (as drawn: the profile moves without turning; the path must keep crossing its plane) | [x,y,z] (square to the path, its turn about the path fixed by this direction); twist?: angle expr (the profile turns this much about the path over its length; within 4 turns); scale?: expr (the profile's scale at the end, linear along the path; 0.01…100); rails?: [{sketch?: sketch (default path_sketch), curves: [curve ids in order]}] (guide rails, one or two, each meeting every plane square to the path once along it, from the end nearest the path's start: one rail turns the profile so its point where the rail starts stays on the rail and scales it with the rail's distance from the path; two rails carry it between them, its points where they start staying on both; rails take the default orientation, no twist and no scale, and a path without sharp corners); rail_fit?: scale (default: the profile grows and shrinks evenly) | stretch (only across to the rail, between the rails); operation?, targets?, name?, body_name?"),
|
|
CommandSpec::new("solid.loft", "Loft", loft).at("SOLID", "CREATE").icon("loft").params("sections: [{sketch, profiles?} | {sketch, point: id} (an apex)] (2…50, in order; matching hole counts, no holes at an apex); rails?: [{sketch, curves: [ids in order]}] (one or two guide rails from the first section to the last, through every section's outline: the loft follows them between the sections; not with sections that have holes); rail_fit?: scale|stretch (default scale: with one rail the sections grow evenly with the rail's distance from their middle, with two with the distance between the rails; stretch: only that way); operation?, targets? (Join excludes hidden bodies from automatic targets; explicit targets or participants may include them), name?, body_name?"),
|
|
CommandSpec::new("solid.box", "Box", crate::checked!("solid.box", prim_box))
|
|
.at("SOLID", "CREATE")
|
|
.icon("box")
|
|
.contract(&BOX_CONTRACT)
|
|
.output(output_schema_for::<FeatureResult>)
|
|
.params("length, width, height: expr; corner?: [x,y,z] | center?: [x,y,z] (numbers in mm or length expressions; default: the origin); operation?, targets?: [body], name?, body_name?"),
|
|
CommandSpec::new("solid.cylinder", "Cylinder", crate::checked!("solid.cylinder", prim_cylinder))
|
|
.at("SOLID", "CREATE")
|
|
.icon("cylinder")
|
|
.contract(&CYLINDER_CONTRACT)
|
|
.output(output_schema_for::<FeatureResult>)
|
|
.params("radius | diameter, height: expr; base?: [x,y,z] (centre of the bottom: numbers in mm or length expressions; default: the origin); axis?: X|Y|Z|[x,y,z] (default Z); references?: [{edge: [x,y,z] on a straight edge of the face it stands on, distance: expr}] (at most two, as solid.hole's: the base centre goes that far from each edge's line, in the face's plane, and follows the edges; with a numeric base only); operation?, targets?: [body], name?, body_name?"),
|
|
CommandSpec::new("solid.sphere", "Sphere", crate::checked!("solid.sphere", prim_sphere))
|
|
.at("SOLID", "CREATE")
|
|
.icon("sphere")
|
|
.contract(&SPHERE_CONTRACT)
|
|
.output(output_schema_for::<FeatureResult>)
|
|
.params("radius | diameter: expr; center?: [x,y,z] (numbers in mm or length expressions; default: the origin); operation?, targets?: [body], name?, body_name?"),
|
|
CommandSpec::new("solid.torus", "Torus", crate::checked!("solid.torus", prim_torus))
|
|
.at("SOLID", "CREATE")
|
|
.icon("torus")
|
|
.contract(&TORUS_CONTRACT)
|
|
.output(output_schema_for::<FeatureResult>)
|
|
.params("major, minor: expr (radii); center?: [x,y,z] (numbers in mm or length expressions; default: the origin); operation?, targets?: [body], name?, body_name?"),
|
|
CommandSpec::new("solid.cone", "Cone", crate::checked!("solid.cone", prim_cone))
|
|
.at("SOLID", "CREATE")
|
|
.icon("cone")
|
|
.contract(&CONE_CONTRACT)
|
|
.output(output_schema_for::<FeatureResult>)
|
|
.params("radius | diameter, height: expr (the base circle, and the top's distance along the axis; a negative height goes the other way); top_radius? | top_diameter?: expr (the top circle; default 0: a full cone ending in an apex); base?: [x,y,z] (centre of the base circle: numbers in mm or length expressions; default: the origin); axis?: X|Y|Z|[x,y,z] (default Z); operation?, targets?: [body], name?, body_name?"),
|
|
CommandSpec::new("solid.fillet", "Fillet", fillet)
|
|
.at("SOLID", "MODIFY")
|
|
.icon("fillet")
|
|
.key("F")
|
|
.params("edges: [[x,y,z] point on edge | {body, index}]; radius: expr; body?; type?: constant|curvature (alias g2: curvature-continuous quintic between planar faces along straight edges, one planar end face at each end (including sloped ends); radius sets the equivalent circular setback, not constant curvature; exact fit only)|chord (radius is the width across)|variable (radius at the end nearest start, radius2 at the other; one end may be 0, where the round closes to the corner)|spline (the radius along the edge is a clamped B-spline from the end nearest start: radius is its first control radius, radii the rest, knots its knot vector from 0 to 1; one end may be 0); radius2?; start?: [x,y,z]; radii?: [expr, …]; knots?: [number, …]; mid?: [[position 0…1 from start, radius expr], …] (variable radii between the ends); smooth?: bool (smooth instead of straight between the radii); corner?: rolling|g2 (rolling, the default: the corners where three blended edges meet are pieces of the rolling ball's sphere, tangent to each blend; g2: a patch repeating each blend's surface up to the second order, constant-radius exact fillets only, refused where it cannot be built); fit?: exact|reduce|taper (exact, the default: a radius too large for the geometry around the edges is refused; reduce: where it doesn't fit it is reduced to the largest that does, one radius for edges sharing a face; the smallest used is returned as `radius_applied`, each edge's as `radii_applied: [{edge: [x,y,z], radius}]`, and noted in the feature's warning; taper: along each straight edge between planar faces where it doesn't fit, the radius follows the room there as a smooth spline, down to 0 where a face closes to a point, noted in the feature's warning)"),
|
|
CommandSpec::new("solid.chamfer", "Chamfer", chamfer).at("SOLID", "MODIFY").icon("chamfer").params("edges: [[x,y,z] | {body, index}]; distance: expr; distance2?: expr (along the second face) | angle?: expr (from the first face); flip?: bool (which face is first: by default the one facing up most); body?"),
|
|
CommandSpec::new("solid.combine", "Combine", combine).at("SOLID", "MODIFY").icon("combine").params("target: body; tools: [body]; operation?: join|cut|intersect; keep_tools?: bool; new_component?: bool (the result goes into a new component; component_name?)"),
|
|
CommandSpec::new("solid.pattern.rectangular", "Rectangular Pattern", pattern_rect)
|
|
.at("SOLID", "CREATE")
|
|
.icon("pattern_rect")
|
|
.params("features: [names] | bodies: [names] | components: [names]; dir1: [x,y,z]; count1; spacing1; dir2?, count2?, spacing2?; alignment?, alignment2?: left|center|right (default right; counts include the original); reversed?, reversed2?: bool (Flip)"),
|
|
CommandSpec::new("solid.pattern.circular", "Circular Pattern", pattern_circ)
|
|
.at("SOLID", "CREATE")
|
|
.icon("pattern_circ")
|
|
.params("features: [names] | bodies: [names] | components: [names]; axis: X|Y|Z | construction axis name (followed when edited) | {origin, dir} (origin coordinates may be length expressions; the pattern follows them) | {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); count; angle? (default 360 deg; partial arcs include both ends); alignment?: left|center|right (default right; original stays fixed); reversed?: bool (Flip; selects the extra side for even centered counts)"),
|
|
CommandSpec::new("solid.pattern.path", "Pattern on Path", pattern_path)
|
|
.at("SOLID", "CREATE")
|
|
.icon("pattern_path")
|
|
.params("features: [names] | bodies: [names]; path_sketch: sketch; path: [curve ids in order]; count; spacing (between instances) | distance (first to last); orientation?: identical|path; flip?: bool"),
|
|
CommandSpec::new("solid.mirror", "Mirror", mirror).at("SOLID", "CREATE").icon("mirror").params("features: [names] | bodies: [names] (combine?: join with the original); plane: XY|XZ|YZ|construction plane name or id|{origin, normal}|{origin, x_dir, y_dir} (origin coordinates may be length expressions; the mirror follows them, or a construction plane)"),
|
|
CommandSpec::new("solid.hole", "Hole", hole)
|
|
.at("SOLID", "CREATE")
|
|
.icon("hole")
|
|
.key("H")
|
|
.params("position: [x,y,z] on a face (numbers, or length expressions the hole follows) | sketch + points: [sketch point ids] (one hole each, perpendicular to the sketch, into the material on whichever side of the sketch plane it is) | sketch alone (every sketch point: standalone points and circle centres); flip?: bool (sketch points: drill to the other side); single?: bool (with one sketch point: a Single hole that follows the point, drilled into the face there); direction?: [x,y,z] (default: into the face, against its outward normal; one that leaves the face is mirrored into it; ignored with sketch points unless single); diameter | thread (a tapped hole: metric major minus pitch or tabulated UNC/UNF, G or Rp cut-tap drill) | clearance: \"M6\" with fit?: close|normal|loose (ISO 273); depth? (default through all) | to?: [x,y,z] (To Object: drill to that face or point); references?: [{edge: [x,y,z] on a straight edge of the face, distance: expr}] (at most two; the centre goes that far from each edge's line, in the face's plane, and follows the edges; with a numeric position only); type?: simple|drilled|counterbore|countersink; tip_angle?; cb_diameter?, cb_depth?; cs_diameter?, cs_angle?; thread?: \"M6\" or \"1/4-20 UNC\" (cosmetic); handedness?: right|left (default right, needs thread for left); thread_depth?: positive length independent of drill depth (default: full useful cylindrical wall; must fit that wall); targets?: [body] (the bodies to drill; holes at the points of a sketch on a body's face default to that body, found along the holes' direction on it alone; explicit targets or participants override, [\"*\"] every body)"),
|
|
CommandSpec::new("solid.pipe", "Pipe", crate::checked!("solid.pipe", pipe))
|
|
.at("SOLID", "CREATE")
|
|
.icon("pipe")
|
|
.contract(&PIPE_CONTRACT)
|
|
.output(output_schema_for::<FeatureResult>)
|
|
.params("path_sketch: sketch; path: [curve ids in order]; diameter: expr; wall?: expr (hollow); operation?, targets?, name?, body_name?"),
|
|
CommandSpec::new("solid.bounding_solid", "Bounding Solid", crate::checked!("solid.bounding_solid", bounding_solid))
|
|
.at("SOLID", "CREATE")
|
|
.icon("bounding_solid")
|
|
.contract(&BOUNDING_SOLID_CONTRACT)
|
|
.output(output_schema_for::<FeatureResult>)
|
|
.params("bodies?: [names] (default: all); margin?: expr; name?, body_name?"),
|
|
CommandSpec::new("solid.scale", "Scale", crate::checked!("solid.scale", scale))
|
|
.at("SOLID", "MODIFY")
|
|
.icon("scale")
|
|
.contract(&SCALE_CONTRACT)
|
|
.output(output_schema_for::<FeatureResult>)
|
|
.params("bodies: [names]; factor: expr | factors: [x, y, z] exprs; origin?: [x,y,z]"),
|
|
CommandSpec::new("face.delete", "Delete Face", delete_face)
|
|
.at("SOLID", "MODIFY")
|
|
.icon("delete_face")
|
|
.params("faces: [[x,y,z] points on the faces, or face names from model.faces]; body?; heal?: bool (default true: the neighbouring planes close the gap, as when a rounded edge, hole or boss is taken off; false: the gap stays open and the faces left are a surface body)"),
|
|
CommandSpec::new("solid.offset_face", "Offset Face", offset_face)
|
|
.at("SOLID", "MODIFY")
|
|
.icon("offset_face")
|
|
.params("faces: [[x,y,z] points on faces (planar or curved), or face names from model.faces]; distance: expr (positive: outward); body?"),
|
|
CommandSpec::new("solid.thread", "Thread", thread)
|
|
.at("SOLID", "CREATE")
|
|
.icon("thread")
|
|
.params("face: [x,y,z] on a cylindrical face; designation?: ISO metric (\"M8\", \"M8x1\"; default: the size that fits); length?: expr (default: the whole face); handedness?: right|left (default right); modeled?: bool (default false). Cosmetic: the model is unchanged, model.threads lists it. Modeled: cuts the thread profile into the body; a shaft thicker than the thread is first turned down to its major diameter over the threaded length"),
|
|
CommandSpec::new("solid.shell", "Shell", shell)
|
|
.at("SOLID", "MODIFY")
|
|
.icon("shell")
|
|
.params("faces: [[x,y,z] points on the faces to remove, or face names from model.faces]; thickness: expr; direction?: inside|outside|both; tangent_chain?: bool (also open faces joined smoothly to the picked ones); body?"),
|
|
CommandSpec::new("solid.draft", "Draft", draft)
|
|
.at("SOLID", "MODIFY")
|
|
.icon("draft")
|
|
.params("faces: [[x,y,z] points, or face names from model.faces]; angle: expr; neutral: XY|XZ|YZ|plane name|{origin, normal}; pull?: [x,y,z] (default: neutral plane normal); body?"),
|
|
CommandSpec::new("construct.plane.offset", "Offset Plane", crate::checked!("construct.plane.offset", plane_offset))
|
|
.at("SOLID", "CONSTRUCT")
|
|
.icon("plane")
|
|
.contract(&OFFSET_PLANE_CONTRACT)
|
|
.output(output_schema_for::<FeatureResult>)
|
|
.params("base: XY|XZ|YZ|plane name, or a planar face {face: [x,y,z], body?, index?, path?}; offset: expr, or through: a point ref (vertex, sketch point, construction point) the plane goes through, parallel to base; name?"),
|
|
CommandSpec::new("construct.plane.at_angle", "Plane at Angle", crate::checked!("construct.plane.at_angle", plane_angle))
|
|
.at("SOLID", "CONSTRUCT")
|
|
.icon("plane_angle")
|
|
.contract(&PLANE_AT_ANGLE_CONTRACT)
|
|
.output(output_schema_for::<FeatureResult>)
|
|
.params("base: XY|XZ|YZ|plane name, or a planar face {face: [x,y,z], body?, index?, path?}; axis: X|Y|Z|construction axis name (where it is now)|{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; name?"),
|
|
CommandSpec::new("solid.split_face", "Split Face", split_face)
|
|
.at("SOLID", "MODIFY")
|
|
.icon("split_face")
|
|
.params(
|
|
"faces: [[x,y,z] points on the faces to split, or face names from model.faces]; body?; and the splitting tool: plane: XY|XZ|YZ|plane name|{origin, normal} — or tool: {body, point} (a face of a body, its surface extended) — or sketch: id or name (its curves, along the sketch's normal)",
|
|
),
|
|
CommandSpec::new("solid.split_body", "Split Body", split_body)
|
|
.at("SOLID", "MODIFY")
|
|
.icon("split_body")
|
|
.params("body: name; plane: XY|XZ|YZ|plane name|{origin, normal} — or tool: {body, point} (a face of a body, its surface extended) — or sketch: id, line: curve id (a straight sketch line, along the sketch's normal)"),
|
|
CommandSpec::new("solid.press_pull", "Press Pull", press_pull)
|
|
.at("SOLID", "MODIFY")
|
|
.icon("presspull")
|
|
.key("Q")
|
|
.params("face: [x,y,z] and distance: expr (positive adds material, negative cuts), or edges: [[x,y,z]…] and distance (a fillet)"),
|
|
CommandSpec::new("solid.move", "Move/Copy", move_bodies).at("SOLID", "MODIFY").icon("move").key("M").enabled(not_in_sketch).params("bodies: [names]; translate?: [x,y,z] (exprs or numbers); axis?: [x,y,z]; angle?: expr; copy?: bool (default false: keeps the original bodies and transforms a new copy instead of moving them in place); occurrences?: [occurrence paths, root first] (only with copy: each component is copied as an independent component, as Paste New copies it, and the copy moves by the same translate, axis and angle in the world; the reply lists the copies in occurrences)"),
|
|
];
|
|
|
|
/// Where an extrude starts and which way is positive: a point inside the (first) profile or
|
|
/// face, and the unit normal.
|
|
fn extrude_base(s: &Session, p: &Value) -> Option<(Vec3, Vec3)> {
|
|
if let Some(fp) = p.get("face").or_else(|| p.get("faces").and_then(Value::as_array).and_then(|faces| faces.first())).and_then(vec3) {
|
|
return Some((fp, super::face::face_normal_in(s, fp, str_(p, "face_body"))?));
|
|
}
|
|
let sid = feature_sketch(s, p, "Extrude").ok()?;
|
|
let st = s.model.state();
|
|
let ss = st.sketch(sid)?;
|
|
if bool_(p, "thin").unwrap_or(false) {
|
|
let thin = thin_param(s, p, sid, "solid.extrude").ok()?;
|
|
let q = thin_regions(s, ss, &thin).ok()?.first()?.interior_point();
|
|
return Some((ss.plane.to_world(q), ss.plane.normal()));
|
|
}
|
|
let ps = &ss.profiles;
|
|
let q = match profiles(p, "Extrude").ok()? {
|
|
ProfileSel::All => ps.first()?.region.interior_point(),
|
|
ProfileSel::Indices { indices } => ps.get(*indices.first()?)?.region.interior_point(),
|
|
ProfileSel::Points { points } => *points.first()?,
|
|
selection @ (ProfileSel::Curves { .. } | ProfileSel::OffsetBoundaries { .. } | ProfileSel::WholeBoundaries { .. }) => {
|
|
let indices = solidcraft_doc::profile_selection_indices(ss, &selection).ok()?;
|
|
ps.get(*indices.first()?)?.region.interior_point()
|
|
}
|
|
};
|
|
Some((ss.plane.to_world(q), ss.plane.normal()))
|
|
}
|
|
|
|
/// How far an extrude with these parameters goes from its profile along the profile's normal
|
|
/// (negative: the other way). To an object, the target's height, on whichever side it is: the
|
|
/// extrude goes there and its `direction` does not count (#1633). Otherwise its distance, turned
|
|
/// round for the negative direction.
|
|
pub fn extrude_reach(s: &Session, p: &Value) -> Option<f64> {
|
|
if let Some(t) = p.get("to").and_then(vec3) {
|
|
let (base, n) = extrude_base(s, p)?;
|
|
return Some((t - base).dot(n)).filter(|h| h.is_finite());
|
|
}
|
|
let d = s.doc.eval(&expr(p, "distance")?, Kind::Length).ok()?;
|
|
let dir = str_(p, "direction").map(str::to_ascii_lowercase);
|
|
Some(if matches!(dir.as_deref(), Some("negative" | "reverse" | "flip")) { -d } else { d })
|
|
}
|
|
|
|
/// How far past the profile [`auto_operation`] looks for material it starts in.
|
|
const START_PROBE_MM: f64 = 0.1;
|
|
|
|
/// What `operation: "auto"` means for an extrude with these parameters: `cut` when it goes
|
|
/// into a body, otherwise `join` when the active component has a solid. Keeping an
|
|
/// addition separate requires an explicit `new` operation.
|
|
///
|
|
/// "Goes into a body" is decided where the extrude starts: just past the profile in the
|
|
/// direction it grows, or halfway along it. With the halfway point alone, a cut dragged far
|
|
/// past a body's far side read as a Join (#1257).
|
|
pub fn auto_operation(s: &Session, p: &Value) -> Option<&'static str> {
|
|
auto_operation_in(s, p, true)
|
|
}
|
|
|
|
impl Session {
|
|
/// Whether a cut or intersect that names no bodies takes part in every body of `st`: the
|
|
/// active component has no body of its own while the model has some (a sketch in the
|
|
/// assembly's root cutting through its parts, #1234). The command and its preview both ask
|
|
/// this, so the preview never refuses a cut the command makes (#3085).
|
|
pub fn cut_takes_every_body(&self, st: &solidcraft_doc::ModelState) -> bool {
|
|
!st.bodies.is_empty() && !st.bodies.iter().any(|b| self.doc.model_body_component(b) == self.active_component)
|
|
}
|
|
}
|
|
|
|
fn auto_operation_in(s: &Session, p: &Value, world_faces: bool) -> Option<&'static str> {
|
|
let symmetric = p.get("to").is_none() && str_(p, "direction").is_some_and(|d| d.eq_ignore_ascii_case("symmetric"));
|
|
// Imported face groups can belong to a child of an empty active component.
|
|
// Probe in the same coordinate frame as the face picks.
|
|
let grouped = p.get("faces").and_then(Value::as_array).and_then(|faces| faces.first()).and_then(vec3);
|
|
let st = if grouped.is_some() && world_faces { s.world_state() } else { s.model.state() };
|
|
// The body the extrude starts on, when it is in a component inside the active one: it takes
|
|
// part as the active component's own bodies do (#5679).
|
|
let mut started_on = None;
|
|
let (base, n) = if let Some(point) = grouped {
|
|
let (mesh, index, distance, name) = super::face::face_at_state(&st, point, str_(p, "face_body")).ok().flatten()?;
|
|
if distance > (mesh.bounds().diagonal() * 1e-3).max(1e-3) * 10.0 {
|
|
return None;
|
|
}
|
|
let normal = st.body(&name)?.body.planar_face(index as usize)?.normal();
|
|
started_on = Some(name);
|
|
(point, normal)
|
|
} else {
|
|
if p.get("face").is_none() {
|
|
started_on = feature_sketch(s, p, "Extrude").ok().and_then(|sketch| face_body_reached(s, sketch).ok().flatten());
|
|
}
|
|
extrude_base(s, p)?
|
|
};
|
|
// The extrude starts at its From Object or start offset, not at the profile: probe from
|
|
// there (#467). To an object it then reaches only from that start.
|
|
let start = match p.get("from").and_then(vec3) {
|
|
Some(from) if grouped.is_none() => (from - base).dot(n),
|
|
_ => expr(p, "start_offset").and_then(|e| s.doc.eval(&e, Kind::Length).ok()).unwrap_or(0.0),
|
|
};
|
|
let start = if start.is_finite() { start } else { 0.0 };
|
|
let base = base + n * start;
|
|
let d = if grouped.is_some() && p.get("to").is_some() {
|
|
(p.get("to").and_then(vec3)? - base).dot(n)
|
|
} else if let Some(d) = extrude_reach(s, p) {
|
|
if p.get("to").is_some() { d - start } else { d }
|
|
} else {
|
|
through_all_reach(&st, p, base)?
|
|
};
|
|
if st.bodies.is_empty() || !d.is_finite() {
|
|
return Some("new");
|
|
}
|
|
// Match the evaluator's implicit participants: a grouped cut from an empty
|
|
// assembly component considers every body; otherwise keep the active scope.
|
|
// Explicit participants override either default.
|
|
// A component with no body of its own works on those of the components inside it (#3223).
|
|
// The participants only pick the scope here; the feature itself refuses a list of the
|
|
// wrong type (`add_feature`), so a wrong type cannot make this cut anything. This preview
|
|
// cannot fail, so it reads the list leniently.
|
|
let parts = string_list_or_default(p, "participants");
|
|
let implicit_all = grouped.is_some() && !st.bodies.iter().any(|body| s.doc.model_body_component(body) == s.active_component);
|
|
let mut bodies: Vec<_> = if !parts.is_empty() {
|
|
st.bodies.iter().filter(|b| parts.contains(&b.name)).collect()
|
|
} else if implicit_all {
|
|
st.bodies.iter().collect()
|
|
} else {
|
|
active_scope(s, &st)
|
|
};
|
|
if parts.is_empty()
|
|
&& let Some(body) = started_on.as_deref().and_then(|name| st.body(name))
|
|
&& !bodies.iter().any(|b| b.name == body.name)
|
|
&& s.doc.component_within(s.doc.model_body_component(body), s.active_component)
|
|
{
|
|
bodies.push(body);
|
|
}
|
|
if bodies.is_empty() {
|
|
return Some("new");
|
|
}
|
|
// A profile's points are in the active component's frame; a body placed differently (in a
|
|
// moved or turned component) is probed where it is shown. Face picks are in `st`'s frame.
|
|
let frames: Vec<Option<solidcraft_doc::Mat>> = bodies.iter().map(|b| if grouped.is_some() { None } else { into_body_frame(s, b) }).collect();
|
|
let inside = |q: Vec3| bodies.iter().zip(&frames).any(|(b, m)| b.mesh().contains(m.as_ref().map_or(q, |m| solidcraft_doc::apply_point(m, q))));
|
|
// A step into whatever is right in front of the profile, short of the far end.
|
|
let near = |d: f64| d.signum() * (d.abs() * 0.5).min(START_PROBE_MM);
|
|
let into = |d: f64| inside(base + n * near(d)) || inside(base + n * (d * 0.5));
|
|
if symmetric {
|
|
return Some(if into(d.abs()) || into(-d.abs()) { "cut" } else { "join" });
|
|
}
|
|
if into(d) {
|
|
Some("cut")
|
|
} else {
|
|
// A profile can meet material along its side, or only around part of a
|
|
// screw boss. A single point behind its centre cannot establish contact.
|
|
// Default additions to Join and let the boolean merge the actual geometry.
|
|
Some("join")
|
|
}
|
|
}
|
|
|
|
/// How far a Through All extrude with no distance reaches from `base`, signed by its
|
|
/// direction: past every body of the model. Without it `auto` could not tell a cut through
|
|
/// a part from an addition and made a separate body.
|
|
fn through_all_reach(st: &solidcraft_doc::ModelState, p: &Value, base: Vec3) -> Option<f64> {
|
|
let through_all = bool_(p, "through_all").unwrap_or(false) || str_(p, "extent").is_some_and(|e| e.eq_ignore_ascii_case("through_all"));
|
|
if !through_all {
|
|
return None;
|
|
}
|
|
let reach =
|
|
st.bodies.iter().map(|b| b.mesh().bounds()).map(|bb| bb.center().dist(base) + bb.diagonal()).filter(|r| r.is_finite()).fold(1.0, f64::max);
|
|
let dir = str_(p, "direction").map(str::to_ascii_lowercase);
|
|
Some(if matches!(dir.as_deref(), Some("negative" | "reverse" | "flip")) { -reach } else { reach })
|
|
}
|
|
|
|
pub(super) fn operation(p: &Value, cmd: &str) -> Result<Operation> {
|
|
match str_(p, "operation") {
|
|
None => Ok(Operation::NewBody),
|
|
Some(o) => Operation::parse(o).ok_or_else(|| bad(cmd, format!("unknown operation `{o}` (new, join, cut, intersect)"))),
|
|
}
|
|
}
|
|
|
|
/// The sketch a feature uses: `sketch` param, the active sketch, or the last sketch.
|
|
pub(super) fn feature_sketch(s: &Session, p: &Value, cmd: &str) -> Result<u64> {
|
|
if let Some(v) = p.get("sketch") {
|
|
let key = sketch_key(Some(v)).ok_or_else(|| bad(cmd, "`sketch` must be an id or name"))?;
|
|
let f = s.doc.find_feature(&key).ok_or_else(|| bad(cmd, format!("no sketch `{key}`")))?;
|
|
return match f.kind {
|
|
FeatureKind::Sketch { .. } => Ok(f.id),
|
|
_ => Err(bad(cmd, format!("`{key}` is not a sketch"))),
|
|
};
|
|
}
|
|
if let Some(a) = super::sketch_store::active(s) {
|
|
return Ok(a);
|
|
}
|
|
let limit = s.doc.marker.unwrap_or(usize::MAX);
|
|
s.doc
|
|
.features
|
|
.iter()
|
|
.take(limit)
|
|
.rev()
|
|
.find(|f| matches!(f.kind, FeatureKind::Sketch { .. }))
|
|
.map(|f| f.id)
|
|
.ok_or_else(|| bad(cmd, "there is no sketch to use (create one first)"))
|
|
}
|
|
|
|
/// Profiles picked by index or point are stored by the curve ids of each profile's outer loop
|
|
/// as the sketch is now solved, so they follow the geometry when parameters move it. A pick
|
|
/// whose curves would not find that same profile again (two profiles bounded by the same
|
|
/// curves) stays as given. Curve picks are checked: one that names no profile, or several, is
|
|
/// refused now rather than failing later.
|
|
///
|
|
/// `exact` keeps each index or point pick to the region it names. Otherwise a pick on a drawn
|
|
/// profile that reference geometry cuts into regions takes the whole drawn profile
|
|
/// ([`drawn_profile_regions`], #5302).
|
|
pub(super) fn stable_profiles(s: &Session, kind: &mut FeatureKind, exact: bool) -> Result<()> {
|
|
use solidcraft_doc::sketch::profile_at_point;
|
|
let st = s.model.state();
|
|
for (sketch, sel) in kind.profile_sels_mut() {
|
|
let Some(ss) = st.sketch(sketch) else { continue };
|
|
let indices = match sel {
|
|
ProfileSel::Indices { indices } => {
|
|
let have = ss.profiles.len();
|
|
if indices.len() > have {
|
|
return Err(EngineError::Other(format!("{} profiles are listed, but {} has {have}", indices.len(), ss.name)));
|
|
}
|
|
if let Some(i) = indices.iter().find(|i| **i >= have) {
|
|
return Err(EngineError::Other(format!("there is no profile {i} in {} (it has {have})", ss.name)));
|
|
}
|
|
solidcraft_doc::profile_selection_indices(ss, sel)?
|
|
}
|
|
ProfileSel::Points { points } => {
|
|
if points.len() > ss.profiles.len() {
|
|
return Err(EngineError::Other(format!(
|
|
"{} profile points are given, but {} has {} profiles",
|
|
points.len(),
|
|
ss.name,
|
|
ss.profiles.len()
|
|
)));
|
|
}
|
|
let Some(indices) = points.iter().map(|point| profile_at_point(&ss.profiles, *point)).collect::<Option<Vec<_>>>() else { continue };
|
|
let mut seen = std::collections::BTreeSet::new();
|
|
if let Some(i) = indices.iter().find(|i| !seen.insert(**i)) {
|
|
return Err(EngineError::Other(format!("two profile points pick the same profile ({i}) in {}", ss.name)));
|
|
}
|
|
indices
|
|
}
|
|
ProfileSel::Curves { loops } => {
|
|
// The command's ordinary curve lists are sets, including repeated
|
|
// caller IDs. Saved graph-span multisets retain their legacy meaning.
|
|
// Reserved offset roles never use this ordinary normalization.
|
|
let mut normalized = loops.clone();
|
|
let reserved = ss
|
|
.sketch
|
|
.offsets
|
|
.iter()
|
|
.filter_map(|offset| offset.topology.as_ref())
|
|
.flat_map(|topology| topology.roles.iter().map(|role| role.output.as_str()))
|
|
.collect::<std::collections::BTreeSet<_>>();
|
|
for curves in &mut normalized {
|
|
let dynamic = curves.iter().any(|curve| reserved.contains(curve.as_str()));
|
|
if !dynamic {
|
|
let mut seen = std::collections::BTreeSet::new();
|
|
curves.retain(|curve| seen.insert(curve.clone()));
|
|
}
|
|
}
|
|
let selection = ProfileSel::Curves { loops: normalized };
|
|
solidcraft_doc::profile_selection_indices(ss, &selection)?;
|
|
*sel = selection;
|
|
continue;
|
|
}
|
|
ProfileSel::OffsetBoundaries { .. } | ProfileSel::WholeBoundaries { .. } => {
|
|
// Explicit identities retain the caller's semantics. Validate through the
|
|
// same resolver as recomputation, including reserved-role precedence.
|
|
solidcraft_doc::profile_selection_indices(ss, sel)?;
|
|
continue;
|
|
}
|
|
ProfileSel::All => continue,
|
|
};
|
|
let picked = if exact { indices } else { drawn_profile_regions(ss, &indices) };
|
|
let captured = solidcraft_doc::capture_profile_selection(ss, &picked)?;
|
|
*sel = match captured {
|
|
ProfileSel::OffsetBoundaries { associations }
|
|
if associations.iter().any(|id| {
|
|
s.doc
|
|
.sketch(sketch)
|
|
.is_ok_and(|raw| !raw.offsets.iter().filter_map(|offset| offset.topology.as_ref()).any(|topology| topology.id == *id))
|
|
}) =>
|
|
{
|
|
// Legacy upgrade descriptors belong to the solved copy. Persist the
|
|
// complete original role IDs instead of an unsaved association ID.
|
|
let loops = associations
|
|
.iter()
|
|
.map(|id| {
|
|
ss.sketch
|
|
.offsets
|
|
.iter()
|
|
.filter_map(|offset| offset.topology.as_ref())
|
|
.find(|topology| topology.id == *id)
|
|
.map(|topology| topology.roles.iter().map(|role| role.output.clone()).collect())
|
|
.ok_or_else(|| EngineError::Other(format!("offset association `{id}` changed during profile capture")))
|
|
})
|
|
.collect::<Result<Vec<_>>>()?;
|
|
ProfileSel::Curves { loops }
|
|
}
|
|
captured => captured,
|
|
};
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// The regions a picked profile stands for.
|
|
///
|
|
/// A drawn profile cut by reference geometry that crosses it (the projected outline of the face
|
|
/// a sketch is on) is several regions of the sketch's graph, and picking one of them takes the
|
|
/// whole drawn profile (#5302): the regions that share a drawn curve with the picked one are
|
|
/// the parts of that outline, split by the reference geometry crossing it. Reference geometry
|
|
/// that stays inside the drawn profile (the rim of a counterbored hole) bounds an inner region
|
|
/// of it, a real boundary of the material, so the pick keeps its own region. The drawn profiles
|
|
/// are the disjoint faces of the drawn graph, so a drawn hole keeps filling only itself
|
|
/// (#5176).
|
|
fn drawn_profile_regions(ss: &solidcraft_doc::SolvedSketch, indices: &[usize]) -> Vec<usize> {
|
|
const MAX_PROFILES: usize = 10_000;
|
|
if indices.is_empty() || indices.len() > MAX_PROFILES || ss.profiles.len() > MAX_PROFILES {
|
|
return indices.to_vec();
|
|
}
|
|
let drawn = solidcraft_sketch::find_drawn_profiles(&ss.sketch);
|
|
if drawn.is_empty() || drawn.len() >= ss.profiles.len() {
|
|
return indices.to_vec();
|
|
}
|
|
// The curves the user drew: the drawn profiles are made of them, the reference geometry is
|
|
// not part of them.
|
|
let drawn_curves: std::collections::BTreeSet<&str> = ss
|
|
.sketch
|
|
.curves
|
|
.iter()
|
|
.enumerate()
|
|
.filter(|(index, curve)| {
|
|
!curve.construction && !curve.centerline && !curve.infinite && (!ss.sketch.is_linked_curve(*index) || ss.sketch.is_text_curve(*index))
|
|
})
|
|
.map(|(_, curve)| curve.id.as_str())
|
|
.collect();
|
|
let mut out: Vec<usize> = Vec::with_capacity(indices.len());
|
|
for index in indices {
|
|
let Some(picked) = ss.profiles.get(*index) else { continue };
|
|
// The drawn profile the picked region belongs to: the region around it that the drawn
|
|
// geometry alone bounds.
|
|
let probe = picked.region.interior_point();
|
|
let Some(owner) = drawn.iter().find(|profile| profile.region.contains(probe)) else {
|
|
out.push(*index);
|
|
continue;
|
|
};
|
|
// The drawn curves the picked region is bounded by.
|
|
let picked_curves: std::collections::BTreeSet<&str> = picked
|
|
.outer_curves
|
|
.iter()
|
|
.chain(picked.hole_curves.iter().flatten())
|
|
.map(String::as_str)
|
|
.filter(|id| drawn_curves.contains(id))
|
|
.collect();
|
|
if picked_curves.is_empty() {
|
|
out.push(*index);
|
|
continue;
|
|
}
|
|
// The regions of the drawn profile that share a drawn curve with the picked one: the
|
|
// parts of the same outline, cut apart by reference geometry crossing it.
|
|
let pieces: Vec<usize> = ss
|
|
.profiles
|
|
.iter()
|
|
.enumerate()
|
|
.filter(|(_, profile)| owner.region.contains(profile.region.interior_point()))
|
|
.filter(|(_, profile)| {
|
|
profile.outer_curves.iter().chain(profile.hole_curves.iter().flatten()).any(|id| picked_curves.contains(id.as_str()))
|
|
})
|
|
.map(|(index, _)| index)
|
|
.collect();
|
|
if pieces.is_empty() {
|
|
out.push(*index);
|
|
} else {
|
|
out.extend(pieces);
|
|
}
|
|
}
|
|
out.sort_unstable();
|
|
out.dedup();
|
|
out
|
|
}
|
|
|
|
/// `exact_regions: true`: each index or point pick is the region it names, never grown to the
|
|
/// whole drawn profile. The dialogs send it: they highlight exactly the regions picked, and OK
|
|
/// must build those (#6724).
|
|
pub(super) fn exact_regions(p: &Value) -> bool {
|
|
bool_(p, "exact_regions").unwrap_or(false)
|
|
}
|
|
|
|
pub(crate) fn profiles(p: &Value, cmd: &str) -> Result<ProfileSel> {
|
|
let Some(v) = p.get("profiles") else { return Ok(ProfileSel::All) };
|
|
match v {
|
|
Value::Object(fields) => {
|
|
if fields.get("type").and_then(Value::as_str) == Some("whole_boundaries") {
|
|
return solidcraft_doc::whole_profile_selection_from_value(v).map_err(|error| bad(cmd, error.to_string()));
|
|
}
|
|
if !fields.contains_key("offset_boundaries") && fields.get("type").and_then(Value::as_str) != Some("offset_boundaries") {
|
|
return Err(bad(
|
|
cmd,
|
|
r#"`profiles` must be `"all"`, an index such as `0`, indices such as `[0]`, point picks such as `[{"point": [0, 0]}]` or curve-id picks such as `[{"curves": ["c1"]}]`"#,
|
|
));
|
|
}
|
|
let associations = fields
|
|
.get("offset_boundaries")
|
|
.or_else(|| (fields.get("type").and_then(Value::as_str) == Some("offset_boundaries")).then(|| fields.get("associations")).flatten())
|
|
.and_then(Value::as_array)
|
|
.ok_or_else(|| bad(cmd, "profile object must provide `offset_boundaries: [association ids]`"))?;
|
|
if associations.is_empty() || associations.len() > 128 {
|
|
return Err(bad(cmd, "offset profile selection needs 1 to 128 association ids"));
|
|
}
|
|
let associations = associations
|
|
.iter()
|
|
.map(|id| {
|
|
id.as_str()
|
|
.filter(|id| !id.is_empty() && id.len() <= 512)
|
|
.map(str::to_string)
|
|
.ok_or_else(|| bad(cmd, "offset association ids must be nonempty strings of at most 512 bytes"))
|
|
})
|
|
.collect::<Result<Vec<_>>>()?;
|
|
if associations.iter().collect::<std::collections::BTreeSet<_>>().len() != associations.len() {
|
|
return Err(bad(cmd, "offset association ids must be unique"));
|
|
}
|
|
Ok(ProfileSel::OffsetBoundaries { associations })
|
|
}
|
|
Value::String(s) if s.eq_ignore_ascii_case("all") => Ok(ProfileSel::All),
|
|
Value::Number(n) => Ok(ProfileSel::Indices { indices: vec![n.as_u64().ok_or_else(|| bad(cmd, "profile index"))? as usize] }),
|
|
Value::Array(a) if a.is_empty() => Err(bad(cmd, "`profiles` is empty")),
|
|
Value::Array(a) if a.len() > 10_000 => Err(bad(cmd, "too many profiles")),
|
|
Value::Array(a) => {
|
|
if a.iter().all(Value::is_u64) {
|
|
// Each profile once: a repeat would build the same body again.
|
|
let mut seen = std::collections::BTreeSet::new();
|
|
let mut indices = Vec::with_capacity(a.len());
|
|
for i in a.iter().filter_map(Value::as_u64) {
|
|
let i = usize::try_from(i).map_err(|_| bad(cmd, format!("there is no profile {i}")))?;
|
|
if !seen.insert(i) {
|
|
return Err(bad(cmd, format!("profile {i} is listed twice")));
|
|
}
|
|
indices.push(i);
|
|
}
|
|
return Ok(ProfileSel::Indices { indices });
|
|
}
|
|
if a.iter().all(|x| x.get("point").is_some()) {
|
|
let pts =
|
|
a.iter().map(|x| x.get("point").and_then(vec2).ok_or_else(|| bad(cmd, "profile point must be [x, y]"))).collect::<Result<_>>()?;
|
|
return Ok(ProfileSel::Points { points: pts });
|
|
}
|
|
// [[ids]], [{curves: [...]}] or recipe-style [{loops: [{outer: true, curves: [...]}]}].
|
|
let mut loops = Vec::new();
|
|
for x in a {
|
|
let ids: Vec<String> = match x {
|
|
Value::Array(ids) => ids.iter().filter_map(|i| i.as_str().map(str::to_string)).collect(),
|
|
Value::Object(_) => {
|
|
if x.get("curves").is_some() {
|
|
string_list(cmd, x, "curves")?
|
|
} else if let Some(ls) = x.get("loops").and_then(Value::as_array) {
|
|
let outer = ls.iter().find(|l| l.get("outer").and_then(Value::as_bool).unwrap_or(true)).or(ls.first());
|
|
match outer {
|
|
Some(l) => string_list(cmd, l, "curves")?,
|
|
None => Vec::new(),
|
|
}
|
|
} else {
|
|
Vec::new()
|
|
}
|
|
}
|
|
_ => Vec::new(),
|
|
};
|
|
if ids.is_empty() {
|
|
return Err(bad(cmd, "each profile must be an index, a list of curve ids, {curves}, {loops} or {point}"));
|
|
}
|
|
loops.push(ids);
|
|
}
|
|
Ok(ProfileSel::Curves { loops })
|
|
}
|
|
_ => Err(bad(cmd, "`profiles` must be \"all\" or a list")),
|
|
}
|
|
}
|
|
|
|
pub(super) fn check_expr(s: &Session, e: &str, kind: Kind, cmd: &str, what: &str) -> Result<()> {
|
|
s.doc.eval(e, kind).map(|_| ()).map_err(|err| bad(cmd, format!("{what}: {err}")))
|
|
}
|
|
|
|
/// A pattern count: a whole, unit-less number (see `expr::eval_count`).
|
|
pub(super) fn check_count(s: &Session, e: &str, cmd: &str, what: &str) -> Result<()> {
|
|
let (vals, _) = s.doc.param_values();
|
|
solidcraft_doc::expr::eval_count(e, &vals).map(|_| ()).map_err(|err| bad(cmd, format!("{what}: {err}")))
|
|
}
|
|
|
|
/// Add a feature, evaluate, and report its result (an evaluation error fails the command).
|
|
pub(super) fn add_feature(s: &mut Session, p: &Value, kind: FeatureKind) -> Result<Value> {
|
|
add_feature_in(s, p, kind, true)
|
|
}
|
|
|
|
/// `add_feature`; `world` is false when `kind` is already in the active component's frame.
|
|
fn add_feature_in(s: &mut Session, p: &Value, kind: FeatureKind, world: bool) -> Result<Value> {
|
|
let name = str_(p, "name");
|
|
// The bodies before the feature, to say which ones it changed or removed.
|
|
let before = s.model.state();
|
|
// Commands speak world coordinates; the feature is authored in the active component.
|
|
let mut kind = kind;
|
|
if world {
|
|
super::component::to_active_frame(s, &mut kind);
|
|
}
|
|
// Bare lengths typed in an inch (or cm…) design mean that unit.
|
|
if s.doc.units.trim() != "mm" {
|
|
let doc = s.doc.clone();
|
|
for (_, e, k) in kind.inputs_mut() {
|
|
*e = doc.with_design_unit(e, k).into();
|
|
}
|
|
}
|
|
// Profiles picked by index are kept by the curves around them: a recompute can renumber a
|
|
// sketch's profiles (a face sketch's projected outline rebuilt), never the curves.
|
|
stable_profiles(s, &mut kind, exact_regions(p))?;
|
|
// Blends remember where their edges sat, to find them again after upstream edits.
|
|
let (refs, names) = match &kind {
|
|
FeatureKind::Fillet { edges, body, .. } | FeatureKind::Chamfer { edges, body, .. } => {
|
|
let st = s.model.state();
|
|
(
|
|
solidcraft_doc::edge_refs(&st, body, &solidcraft_doc::plain(edges)),
|
|
solidcraft_doc::edge_names_for(&st, body, &solidcraft_doc::plain(edges)),
|
|
)
|
|
}
|
|
// Sheet metal edges are named by the sheet model.
|
|
FeatureKind::SheetFlange { edges, .. } => {
|
|
let points: Vec<_> = edges.iter().map(|e| e.point).collect();
|
|
(Vec::new(), solidcraft_doc::sheet::sheet_edge_names(&s.model.state(), &solidcraft_doc::plain(&points)))
|
|
}
|
|
FeatureKind::SheetHem { edges, .. } => (Vec::new(), solidcraft_doc::sheet::sheet_edge_names(&s.model.state(), &solidcraft_doc::plain(edges))),
|
|
// A hole's reference edges (#37) are edges of the body it is drilled into.
|
|
FeatureKind::Hole { position, references, .. } if !references.is_empty() => {
|
|
let edges: Vec<Vec3> = references.iter().map(|r| r.edge.0).collect();
|
|
(Vec::new(), solidcraft_doc::hole_reference::reference_edge_names(&s.model.state(), position.0, &edges))
|
|
}
|
|
// A cylinder's reference edges (#6380) are edges of the body it stands on.
|
|
FeatureKind::Cylinder { base, references, .. } if !references.is_empty() => {
|
|
(Vec::new(), solidcraft_doc::hole_reference::cylinder_edge_names(&s.model.state(), base, references))
|
|
}
|
|
// A conversion's bend edges are edges of the body it converts.
|
|
FeatureKind::SheetConvert { body, bends, .. } if !bends.is_empty() => {
|
|
(Vec::new(), solidcraft_doc::sheet::bend_edge_names(&s.model.state(), body, &solidcraft_doc::plain(bends)))
|
|
}
|
|
_ => (Vec::new(), Vec::new()),
|
|
};
|
|
let face_names = {
|
|
let pts = kind.face_points();
|
|
if let FeatureKind::Emboss { face: Some(face), .. } = &kind {
|
|
let state = s.model.state();
|
|
let body = state.body(&face.body).ok_or_else(|| EngineError::Other("selected cylinder body no longer exists".into()))?;
|
|
let frame = face.body_frame(&s.doc, body).map_err(|e| EngineError::Other(e.to_string()))?;
|
|
let inverse = solidcraft_doc::mat_inverse(&frame).ok_or_else(|| EngineError::Other("invalid cylinder placement".into()))?;
|
|
let at = solidcraft_doc::apply_point(&solidcraft_doc::mat_mul(&inverse, &s.active_component_frame()), face.at.0);
|
|
let mut scoped = solidcraft_doc::ModelState::default();
|
|
scoped.bodies.push(body.clone());
|
|
let names = solidcraft_doc::naming::face_names_at(&scoped, &[at]);
|
|
if names.len() != 1 || names.first().is_none_or(|name| name.is_empty()) {
|
|
return Err(EngineError::Other("selected cylinder face has no persistent identity".into()));
|
|
}
|
|
names
|
|
} else if pts.is_empty() {
|
|
Vec::new()
|
|
} else {
|
|
solidcraft_doc::face_point_names(&s.doc, &s.model.state(), &kind, s.active_component)
|
|
}
|
|
};
|
|
// Primitives have no `targets` of their own: their `targets` are the bodies taking part (#259).
|
|
let primitive = matches!(
|
|
kind,
|
|
FeatureKind::Box { .. } | FeatureKind::Cylinder { .. } | FeatureKind::Sphere { .. } | FeatureKind::Torus { .. } | FeatureKind::Cone { .. }
|
|
);
|
|
let (participants, key) = match string_list(UNKNOWN_COMMAND, p, "participants")? {
|
|
v if v.is_empty() && primitive => (string_list(UNKNOWN_COMMAND, p, "targets")?, "targets"),
|
|
v => (v, "participants"),
|
|
};
|
|
if participants.len() > 10_000 || participants.iter().any(|b| b != "*" && s.model.state().body(b).is_none()) {
|
|
return Err(EngineError::Other(format!("`{key}` must list existing bodies")));
|
|
}
|
|
// A cut or intersect made where the active component has no body of its own (a sketch in
|
|
// the assembly's root, cutting through the parts, #1234) would have nothing to work on: it
|
|
// takes part in every body instead, which it changes only where it meets them. An extrude's
|
|
// own operation counts too: an automatic one that came out as a cut (#3223); and so does a
|
|
// hole, which is always a cut (one at the points of a sketch on a nested part's face).
|
|
let participants = if participants.is_empty()
|
|
&& !primitive
|
|
&& (matches!(str_(p, "operation").and_then(Operation::parse), Some(Operation::Cut | Operation::Intersect))
|
|
|| matches!(&kind, FeatureKind::Extrude { operation: Operation::Cut | Operation::Intersect, .. } | FeatureKind::Hole { .. }))
|
|
&& s.cut_takes_every_body(&s.model.state())
|
|
{
|
|
vec!["*".to_string()]
|
|
} else {
|
|
participants
|
|
};
|
|
if matches!(kind, FeatureKind::ConstructionPlane { .. })
|
|
&& let Some(n) = name
|
|
{
|
|
check_plane_name(n, "construct.plane")?;
|
|
}
|
|
let id = s.doc_mut().add_feature(kind, name)?;
|
|
if let Some(f) = s.doc_mut().feature_mut(id) {
|
|
f.participants = participants;
|
|
f.edge_refs = refs;
|
|
f.edge_names = names;
|
|
f.face_names = face_names;
|
|
}
|
|
s.doc_mut().name_feature_inputs(id);
|
|
let comp = s.active_component;
|
|
if comp != 0
|
|
&& let Some(f) = s.doc_mut().feature_mut(id)
|
|
{
|
|
f.component = comp;
|
|
}
|
|
let mut names = string_list(UNKNOWN_COMMAND, p, "body_names")?;
|
|
if let Some(b) = str_(p, "body_name") {
|
|
names.insert(0, b.to_string());
|
|
}
|
|
if !names.is_empty()
|
|
&& let Some(f) = s.doc_mut().feature_mut(id)
|
|
{
|
|
f.body_names = names.clone();
|
|
}
|
|
s.active_sketch = None;
|
|
s.refresh();
|
|
// A feature that makes more bodies than it was given names (a multi-profile extrude with one
|
|
// `body_name`) has the rest numbered after the first by the evaluator: `Ribs`, `Ribs (2)`,
|
|
// `Ribs (3)`… (#266, #373). They are stored on the feature, so recomputes and saved designs
|
|
// keep them even when the profiles are later picked in another order.
|
|
if names.first().is_some_and(|n| !n.trim().is_empty()) {
|
|
let made: Vec<String> = s.model.state().bodies.iter().filter(|b| b.feature == id).map(|b| b.name.clone()).collect();
|
|
if made.len() > names.len()
|
|
&& let Some(f) = s.doc_mut().feature_mut(id)
|
|
{
|
|
f.body_names = made;
|
|
}
|
|
}
|
|
let r = s.model.result(id).cloned();
|
|
if let Some(e) = r.as_ref().and_then(|r| r.error.clone()) {
|
|
return Err(EngineError::Other(e));
|
|
}
|
|
let st = s.model.state();
|
|
let bodies: Vec<&str> = st.bodies.iter().map(|b| b.name.as_str()).collect();
|
|
// Bodies that were there before and now have other geometry, and bodies that are gone.
|
|
let old: std::collections::HashMap<&str, &solidcraft_doc::kernel::Body> = before.bodies.iter().map(|b| (b.name.as_str(), &b.body)).collect();
|
|
// The bodies this feature made, apart from the ones it changed or that were there (#374),
|
|
// and the pieces a cut left of a body made earlier, which keep that body's feature.
|
|
let created: Vec<&str> = st.bodies.iter().filter(|b| b.feature == id || !old.contains_key(b.name.as_str())).map(|b| b.name.as_str()).collect();
|
|
let now: std::collections::HashSet<&str> = st.bodies.iter().map(|b| b.name.as_str()).collect();
|
|
let changed: Vec<&str> =
|
|
st.bodies.iter().filter(|b| b.feature != id && old.get(b.name.as_str()).is_some_and(|o| !o.same(&b.body))).map(|b| b.name.as_str()).collect();
|
|
let removed: Vec<&str> = before.bodies.iter().map(|b| b.name.as_str()).filter(|n| !now.contains(n)).collect();
|
|
let fname = s.doc.feature(id).map(|f| f.name.clone()).unwrap_or_default();
|
|
// A warning (a Boolean that needed a retry, a reference found again elsewhere) is part of
|
|
// the reply: a script or an agent sees it without asking the timeline (#616).
|
|
let warning = r.as_ref().and_then(|r| r.warning.clone());
|
|
let owned = |names: Vec<&str>| names.into_iter().map(str::to_string).collect();
|
|
let reply = FeatureResult {
|
|
feature: id,
|
|
name: fname,
|
|
bodies: owned(bodies),
|
|
created_bodies: owned(created),
|
|
changed_bodies: owned(changed),
|
|
removed_bodies: owned(removed),
|
|
warning,
|
|
ms: r.map(|r| r.ms),
|
|
param_warnings: Vec::new(),
|
|
};
|
|
serde_json::to_value(reply).map_err(|e| EngineError::Other(e.to_string()))
|
|
}
|
|
|
|
fn extrude(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.extrude";
|
|
let grouped = if let Some(value) = p.get("faces") {
|
|
if p.get("face").is_some() || p.get("sketch").is_some() || p.get("profiles").is_some() {
|
|
return Err(bad(cmd, "faces cannot be combined with face, sketch or profiles"));
|
|
}
|
|
let faces = value
|
|
.as_array()
|
|
.filter(|faces| !faces.is_empty() && faces.len() <= 1024)
|
|
.ok_or_else(|| bad(cmd, "faces must contain between 1 and 1024 points"))?;
|
|
let points = faces.iter().map(|point| vec3(point).ok_or_else(|| bad(cmd, "faces must be points [x,y,z]"))).collect::<Result<Vec<_>>>()?;
|
|
let (id, points, body) = super::face::sketch_of_faces(s, &points, cmd, str_(p, "face_body"))?;
|
|
Some((id, Some(ProfileSel::Points { points }), Some(body)))
|
|
} else {
|
|
None
|
|
};
|
|
// A planar body face extrudes like a profile: its boundary is copied into a sketch on it.
|
|
let (sketch, face_profile, face_body) = if let Some(grouped) = grouped {
|
|
grouped
|
|
} else {
|
|
match p.get("face").and_then(vec3) {
|
|
Some(fp) => {
|
|
let (id, inside, body) = super::face::sketch_of_face(s, fp, cmd, str_(p, "face_body"))?;
|
|
(id, Some(ProfileSel::Points { points: vec![inside] }), Some(body))
|
|
}
|
|
None => (feature_sketch(s, p, cmd)?, None, None),
|
|
}
|
|
};
|
|
let extent = extent_param(s, p, cmd)?;
|
|
let thin = match bool_(p, "thin") {
|
|
Some(true) => {
|
|
if face_profile.is_some() || p.get("profiles").is_some() {
|
|
return Err(bad(cmd, "a thin extrude follows `curves`; it takes no `profiles` or `face`"));
|
|
}
|
|
Some(thin_param(s, p, sketch, cmd)?)
|
|
}
|
|
_ if p.get("thin").is_some_and(|v| !v.is_boolean()) => return Err(bad(cmd, "`thin` must be true or false")),
|
|
_ => None,
|
|
};
|
|
let operation = match str_(p, "operation") {
|
|
Some(o) if o.eq_ignore_ascii_case("auto") => Operation::parse(auto_operation_in(s, p, false).unwrap_or("new")).unwrap_or(Operation::NewBody),
|
|
_ => operation(p, cmd)?,
|
|
};
|
|
let mut targets = string_list(cmd, p, "targets")?;
|
|
let mut p = std::borrow::Cow::Borrowed(p);
|
|
if operation == Operation::Join && targets.is_empty() && string_list(cmd, &p, "participants")?.is_empty() {
|
|
// A face's outward extension joins that body, and so does a profile sketched on a body's
|
|
// face. Assembly neighbours can touch only an edge of the tool: trying to join them
|
|
// first fails, or absorbs unrelated parts (#226). A profile drawn past the face can lie
|
|
// on a neighbour's face too: a rib on a bracket's side welded in the motor the bracket
|
|
// holds, a join that ran for minutes and failed (#1349).
|
|
// Store the resolved target so recomputes and reopening keep the same scope.
|
|
targets.extend(match face_body {
|
|
Some(body) => Some(body),
|
|
None => face_body_reached(s, sketch)?,
|
|
});
|
|
} else if let Some(parts) = cut_scope(s, &p, operation, sketch, face_body, cmd)? {
|
|
p.to_mut()["participants"] = json!(parts);
|
|
}
|
|
if matches!(operation, Operation::Cut | Operation::Intersect) && targets.is_empty() && string_list(cmd, &p, "participants")?.is_empty() {
|
|
// With every body hidden, every body, as before.
|
|
targets = shown_scope(s).unwrap_or_default();
|
|
}
|
|
let kind = FeatureKind::Extrude {
|
|
sketch: SketchId(sketch),
|
|
profiles: match face_profile {
|
|
Some(f) => f,
|
|
None if thin.is_some() => ProfileSel::All,
|
|
None if p.get("profiles").is_none() => default_extrude_profiles(s, sketch),
|
|
None => profiles(&p, cmd)?,
|
|
},
|
|
extent,
|
|
operation,
|
|
targets: targets.into_iter().map(BodyName).collect(),
|
|
thin,
|
|
};
|
|
add_feature(s, &p, kind)
|
|
}
|
|
|
|
/// The bodies a cut or intersect from a profile on a body's face takes part in when it names
|
|
/// none and that body is in a component inside the active one (#5679): the active component's
|
|
/// own bodies, as by default, and that body. `None` when the default already reaches it: it is
|
|
/// one of the active component's, or a component with no body of its own cuts every body.
|
|
fn cut_scope(s: &Session, p: &Value, operation: Operation, sketch: u64, face_body: Option<String>, cmd: &str) -> Result<Option<Vec<String>>> {
|
|
if !matches!(operation, Operation::Cut | Operation::Intersect)
|
|
|| !string_list(cmd, p, "targets")?.is_empty()
|
|
|| !string_list(cmd, p, "participants")?.is_empty()
|
|
{
|
|
return Ok(None);
|
|
}
|
|
let Some(body) = face_body_reached(s, sketch)?.or(face_body) else { return Ok(None) };
|
|
let st = s.model.state();
|
|
if s.cut_takes_every_body(&st) {
|
|
return Ok(None);
|
|
}
|
|
let mut parts: Vec<String> = active_scope(s, &st).into_iter().map(|b| b.name.clone()).collect();
|
|
let within = st.body(&body).is_some_and(|b| s.doc.component_within(s.doc.model_body_component(b), s.active_component));
|
|
if parts.contains(&body) || !within {
|
|
return Ok(None);
|
|
}
|
|
parts.push(body);
|
|
Ok(Some(parts))
|
|
}
|
|
|
|
/// The profiles an extrude takes when `profiles` is omitted: even-odd nesting over what was drawn,
|
|
/// so a loop inside an outline is its hole and a loop inside that hole is material again (#5172).
|
|
/// Without nesting this is `All`, as before. When the pick cannot be stored so that it finds the
|
|
/// same profiles again (the sketch is not solved, or two profiles share their curves), it stays
|
|
/// `All` too.
|
|
fn default_extrude_profiles(s: &Session, sketch: u64) -> ProfileSel {
|
|
let st = s.model.state();
|
|
let Some(ss) = st.sketch(sketch) else { return ProfileSel::All };
|
|
let drawn = solidcraft_sketch::find_drawn_profiles(&ss.sketch);
|
|
let ps = if drawn.is_empty() { ss.profiles.clone() } else { drawn };
|
|
if ps.len() > 10_000 || ps.iter().all(|p| p.region.holes.is_empty()) {
|
|
return ProfileSel::All;
|
|
}
|
|
// Each profile has the profiles directly inside it as holes, so the number of holes around a
|
|
// point of a profile's material is its nesting depth.
|
|
let material: Vec<_> = ps
|
|
.iter()
|
|
.filter(|p| {
|
|
let probe = p.region.interior_point();
|
|
ps.iter().filter(|other| other.region.holes.iter().any(|hole| hole.contains(probe))).count() % 2 == 0
|
|
})
|
|
.collect();
|
|
let all = solidcraft_sketch::without_text_counters(&ss.sketch, ps.clone());
|
|
if material.iter().map(|p| &p.outer_curves).eq(all.iter().map(|p| &p.outer_curves)) {
|
|
return ProfileSel::All;
|
|
}
|
|
// Profiles of the solved sketch itself are stored by index, which `stable_profiles` turns
|
|
// into curves; drawn profiles of a sketch with projected references are named by curves.
|
|
let same = ps.len() == ss.profiles.len() && ps.iter().zip(&ss.profiles).all(|(a, b)| a.outer_curves == b.outer_curves);
|
|
let sel = if same {
|
|
let indices = ps.iter().enumerate().filter(|(_, p)| material.iter().any(|m| std::ptr::eq(*m, *p))).map(|(i, _)| i).collect();
|
|
ProfileSel::Indices { indices }
|
|
} else {
|
|
ProfileSel::Curves { loops: material.iter().map(|p| p.outer_curves.clone()).collect() }
|
|
};
|
|
match solidcraft_doc::profile_selection_indices(ss, &sel) {
|
|
Ok(found) if found.len() == material.len() && material.iter().all(|p| !p.outer_curves.is_empty()) => sel,
|
|
_ => ProfileSel::All,
|
|
}
|
|
}
|
|
|
|
/// The matrix taking a point of the active component's frame into the frame `b`'s geometry is
|
|
/// kept in, as the evaluator moves a tool into it; `None` when the two are the same.
|
|
fn into_body_frame(s: &Session, b: &solidcraft_doc::ModelBody) -> Option<solidcraft_doc::Mat> {
|
|
let frame = s.doc.component_transform(s.doc.model_body_component(b));
|
|
let world = s.doc.model_body_offset(b).map_or(frame, |offset| solidcraft_doc::mat_mul(&frame, offset));
|
|
let active = s.doc.component_transform(s.active_component);
|
|
if world == active {
|
|
return None;
|
|
}
|
|
solidcraft_doc::mat_inverse(&world).map(|into| solidcraft_doc::mat_mul(&into, &active))
|
|
}
|
|
|
|
/// The body whose face `sketch` is attached to, when a join or cut made in the active component
|
|
/// can change it: one of the active component's own ([`active_scope`]), or one in a component
|
|
/// inside it, moved or turned, which is changed in its own component, so every placement of that
|
|
/// component shows the change (#5679). `Ok(None)` when the sketch is not on a face, or the body is
|
|
/// outside the active component. Refused where the change can't be made in the body's component:
|
|
/// its bodies come from a linked design file, or the face was picked on a further placement of a
|
|
/// component placed more than once (the change is drawn at the first).
|
|
fn face_body_reached(s: &Session, sketch: u64) -> Result<Option<String>> {
|
|
let Some(FeatureKind::Sketch { plane: solidcraft_doc::PlaneRef::Face { anchor: Some(anchor), .. }, .. }) = s.doc.feature(sketch).map(|f| &f.kind)
|
|
else {
|
|
return Ok(None);
|
|
};
|
|
let st = s.model.state();
|
|
if let Some(own) = active_scope(s, &st).into_iter().find(|b| b.name == anchor.target.body) {
|
|
return Ok(Some(own.name.clone()));
|
|
}
|
|
let Some(body) = st.body(&anchor.target.body) else { return Ok(None) };
|
|
let component = s.doc.model_body_component(body);
|
|
if !s.doc.component_within(component, s.active_component) {
|
|
return Ok(None);
|
|
}
|
|
let name = |c: u64| s.doc.components.iter().find(|x| x.id == c).map_or_else(|| format!("component {c}"), |x| x.name.clone());
|
|
let mut c = component;
|
|
for _ in 0..1000 {
|
|
if c == s.active_component || c == 0 {
|
|
break;
|
|
}
|
|
if s.doc.links.contains_key(&c) {
|
|
return Err(EngineError::Other(format!(
|
|
"`{}` is in {}, which is linked to a design file: open that design to change it, or break the link first",
|
|
body.name,
|
|
name(c)
|
|
)));
|
|
}
|
|
match s.doc.components.iter().find(|x| x.id == c) {
|
|
Some(x) => c = x.parent,
|
|
None => break,
|
|
}
|
|
}
|
|
if !anchor.path.is_empty() && anchor.path != s.doc.first_path(component) {
|
|
return Err(EngineError::Other(format!(
|
|
"`{}` is in {}, which is placed more than once, and the sketch is on another placement than the first: activate that placement of {} to cut or join it there",
|
|
body.name,
|
|
name(component),
|
|
name(component)
|
|
)));
|
|
}
|
|
Ok(Some(body.name.clone()))
|
|
}
|
|
|
|
/// The body whose face `sketch` is attached to (on the face itself, not offset from it), when
|
|
/// it is one the active component works on ([`active_scope`]).
|
|
fn sketch_face_body(s: &Session, sketch: u64) -> Option<String> {
|
|
let FeatureKind::Sketch { plane: solidcraft_doc::PlaneRef::Face { anchor: Some(anchor), .. }, .. } = &s.doc.feature(sketch)?.kind else {
|
|
return None;
|
|
};
|
|
let st = s.model.state();
|
|
active_scope(s, &st).into_iter().find(|b| b.name == anchor.target.body).map(|b| b.name.clone())
|
|
}
|
|
|
|
/// The bodies a Join named none for: the body whose face a profile sketch is on (the first
|
|
/// sketch that is on one), as for an extrude, also in a component inside the active one, moved
|
|
/// or turned (#5679; refused as [`face_body_reached`] says). Explicit `targets` or
|
|
/// `participants` keep theirs.
|
|
fn face_join_targets(s: &Session, p: &Value, operation: Operation, sketches: &[u64], cmd: &str) -> Result<Vec<BodyName>> {
|
|
let mut targets = string_list(cmd, p, "targets")?;
|
|
if operation == Operation::Join && targets.is_empty() && string_list(cmd, p, "participants")?.is_empty() {
|
|
for sketch in sketches {
|
|
if let Some(body) = face_body_reached(s, *sketch)? {
|
|
targets.push(body);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
Ok(targets.into_iter().map(BodyName).collect())
|
|
}
|
|
|
|
/// The bodies a Join, Cut or Intersect that names none may change, less the hidden ones, when
|
|
/// some of them are hidden: stored as the feature's `targets`, so a hidden body is left alone
|
|
/// (#3961, #6901) and showing it again later doesn't change the model. None when every one is
|
|
/// shown; empty when none is.
|
|
pub fn shown_scope(s: &Session) -> Option<Vec<String>> {
|
|
let st = s.model.state();
|
|
let scope = active_scope(s, &st);
|
|
if scope.iter().all(|b| s.body_visible(&b.name)) {
|
|
return None;
|
|
}
|
|
Some(scope.into_iter().filter(|b| s.body_visible(&b.name)).map(|b| b.name.clone()).collect())
|
|
}
|
|
|
|
/// The bodies a feature of the active component works on when it names none: the component's
|
|
/// own. A component with no body of its own (the root of an opened STEP assembly, whose parts
|
|
/// are components inside it) works on the bodies of the components inside it whose geometry is
|
|
/// in its own frame, as an import places it: a profile sketched on such a part's face meets the
|
|
/// part where it is shown (#3223).
|
|
fn active_scope<'a>(s: &Session, st: &'a solidcraft_doc::ModelState) -> Vec<&'a solidcraft_doc::ModelBody> {
|
|
let active = s.active_component;
|
|
let own: Vec<_> = st.bodies.iter().filter(|b| s.doc.model_body_component(b) == active).collect();
|
|
if !own.is_empty() {
|
|
return own;
|
|
}
|
|
let Some(into_active) = solidcraft_doc::mat_inverse(&s.doc.component_transform(active)) else { return own };
|
|
st.bodies
|
|
.iter()
|
|
.filter(|b| {
|
|
let comp = s.doc.model_body_component(b);
|
|
if !s.doc.component_within(comp, active) {
|
|
return false;
|
|
}
|
|
let frame = s.doc.component_transform(comp);
|
|
let world = s.doc.model_body_offset(b).map_or(frame, |offset| solidcraft_doc::mat_mul(&frame, offset));
|
|
let rel = solidcraft_doc::mat_mul(&into_active, &world);
|
|
rel.iter().flatten().zip(solidcraft_doc::IDENTITY.iter().flatten()).all(|(a, b)| (a - b).abs() < 1e-9)
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// A thin extrude's wall from its parameters: the sketch's curves it follows (every drawn
|
|
/// curve when none are given), its thickness and which side of them it lies on.
|
|
fn thin_param(s: &Session, p: &Value, sketch: u64, cmd: &str) -> Result<ThinWall> {
|
|
let st = s.model.state();
|
|
let ss = st.sketch(sketch).ok_or_else(|| bad(cmd, "the sketch is not evaluated"))?;
|
|
let mut curves = string_list(cmd, p, "curves")?;
|
|
if curves.is_empty() {
|
|
curves =
|
|
ss.sketch.curves.iter().filter(|c| !c.construction && !c.centerline && !c.infinite && c.link.is_none()).map(|c| c.id.clone()).collect();
|
|
}
|
|
if curves.is_empty() || curves.len() > 1000 {
|
|
return Err(bad(cmd, "a thin extrude needs 1…1000 sketch curves (`curves`)"));
|
|
}
|
|
if let Some(c) = curves.iter().find(|c| ss.sketch.curve_index(c).is_none()) {
|
|
return Err(bad(cmd, format!("no curve `{c}` in the sketch")));
|
|
}
|
|
let thickness = req_expr(cmd, p, "thickness")?;
|
|
check_expr(s, &thickness, Kind::Length, cmd, "thickness")?;
|
|
let side = match str_(p, "side") {
|
|
None => ThinSide::Center,
|
|
Some(o) => ThinSide::parse(o).ok_or_else(|| bad(cmd, format!("unknown side `{o}` (center, inside, outside or two_sides)")))?,
|
|
};
|
|
let thickness2 = expr(p, "thickness2");
|
|
match (&thickness2, side) {
|
|
(Some(t), ThinSide::TwoSides) => check_expr(s, t, Kind::Length, cmd, "thickness2")?,
|
|
(None, ThinSide::TwoSides) => return Err(bad(cmd, "`side: two_sides` needs `thickness2` (the thickness outside)")),
|
|
(Some(_), _) => return Err(bad(cmd, "`thickness2` goes with `side: two_sides`")),
|
|
(None, _) => {}
|
|
}
|
|
let thin = ThinWall { curves, thickness, side, thickness2 };
|
|
// Refuse a wall that can't be built now, with the reason, rather than a failed feature.
|
|
thin_regions(s, ss, &thin).map_err(|e| bad(cmd, e))?;
|
|
Ok(thin)
|
|
}
|
|
|
|
/// The regions of a thin wall in its (solved) sketch, with the current parameter values.
|
|
fn thin_regions(s: &Session, ss: &solidcraft_doc::SolvedSketch, thin: &ThinWall) -> std::result::Result<Vec<solidcraft_geom::Region2>, String> {
|
|
let length = |e: &str| s.doc.eval(&s.doc.with_design_unit(e, Kind::Length), Kind::Length).map_err(|e| e.to_string());
|
|
let t = length(&thin.thickness)?;
|
|
let (inside, outside) = match thin.side {
|
|
ThinSide::Center => (t / 2.0, t / 2.0),
|
|
ThinSide::Inside => (t, 0.0),
|
|
ThinSide::Outside => (0.0, t),
|
|
ThinSide::TwoSides => (t, length(thin.thickness2.as_deref().unwrap_or("0"))?),
|
|
};
|
|
let curves: Vec<Vec<solidcraft_geom::Seg2>> = thin
|
|
.curves
|
|
.iter()
|
|
.filter_map(|id| ss.sketch.curve_index(id))
|
|
.map(|ci| ss.sketch.exact_segs(ci).unwrap_or_else(|| ss.sketch.segs(ci)))
|
|
.collect();
|
|
solidcraft_sketch::thin_wall_regions(&curves, inside, outside).map_err(|e| format!("thin wall: {e}"))
|
|
}
|
|
|
|
/// An extrude's extent from its parameters: distance (or through all, or to an object), the
|
|
/// side(s), a second distance, a start offset, a taper, and from an object.
|
|
pub(super) fn extent_param(s: &Session, p: &Value, cmd: &str) -> Result<Extent> {
|
|
let through_all = bool_(p, "through_all").unwrap_or(false) || str_(p, "extent").is_some_and(|e| e.eq_ignore_ascii_case("through_all"));
|
|
let to_object = p.get("to").is_some();
|
|
if to_object && p.get("to").and_then(vec3).is_none() {
|
|
return Err(bad(cmd, "`to` must be a point [x, y, z] on the face, vertex or point to extrude to"));
|
|
}
|
|
if p.get("from").is_some() && p.get("from").and_then(vec3).is_none() {
|
|
return Err(bad(cmd, "`from` must be a point [x, y, z] on the face or point to start from"));
|
|
}
|
|
let distance = if through_all || to_object { expr(p, "distance").unwrap_or_else(|| "0".into()) } else { req_expr(cmd, p, "distance")? };
|
|
check_expr(s, &distance, Kind::Length, cmd, "distance")?;
|
|
let taper = expr(p, "taper");
|
|
if let Some(t) = &taper {
|
|
check_expr(s, t, Kind::Angle, cmd, "taper")?;
|
|
}
|
|
let direction = match str_(p, "direction").map(str::to_ascii_lowercase).as_deref() {
|
|
None | Some("positive") | Some("one_side") => Direction::Positive,
|
|
Some("negative") | Some("reverse") | Some("flip") => Direction::Negative,
|
|
Some("symmetric") => Direction::Symmetric,
|
|
Some(o) => return Err(bad(cmd, format!("unknown direction `{o}`"))),
|
|
};
|
|
let distance2 = expr(p, "distance2");
|
|
if let Some(d) = &distance2 {
|
|
check_expr(s, d, Kind::Length, cmd, "distance2")?;
|
|
}
|
|
let start_offset = expr(p, "start_offset");
|
|
if let Some(d) = &start_offset {
|
|
check_expr(s, d, Kind::Length, cmd, "start_offset")?;
|
|
}
|
|
let convention = match p.get("convention") {
|
|
// Surface Extrude shares Extent but retains its existing per-side distance semantics.
|
|
None if cmd == "surface.extrude" => solidcraft_doc::ExtrudeConvention::LegacyPerSide,
|
|
None => solidcraft_doc::ExtrudeConvention::TotalDistance,
|
|
Some(value) => serde_json::from_value(value.clone()).map_err(|_| bad(cmd, "`convention` must be total_distance or legacy_per_side"))?,
|
|
};
|
|
Ok(Extent {
|
|
distance,
|
|
convention,
|
|
direction,
|
|
distance2,
|
|
start_offset,
|
|
through_all,
|
|
taper,
|
|
to: p.get("to").and_then(vec3).map(FacePick),
|
|
to_offset: expr(p, "to_offset"),
|
|
from: p.get("from").and_then(vec3).map(FacePick),
|
|
to_body_apart: false,
|
|
})
|
|
}
|
|
|
|
fn revolve(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.revolve";
|
|
// A planar body face revolves like a profile (its edges projected into a sketch on it).
|
|
let (sketch, face_profile) = match p.get("face").and_then(vec3) {
|
|
Some(fp) => {
|
|
let (id, inside, _) = super::face::sketch_of_face(s, fp, cmd, str_(p, "face_body"))?;
|
|
s.active_sketch = None;
|
|
(id, Some(ProfileSel::Points { points: vec![inside] }))
|
|
}
|
|
None => (feature_sketch(s, p, cmd)?, None),
|
|
};
|
|
let axis = axis_param(s, sketch, p, cmd)?;
|
|
let angle = expr(p, "angle").unwrap_or_else(|| "360 deg".into());
|
|
check_expr(s, &angle, Kind::Angle, cmd, "angle")?;
|
|
let profiles = match face_profile {
|
|
Some(f) => f,
|
|
None => profiles(p, cmd)?,
|
|
};
|
|
let angle2 = expr(p, "angle2");
|
|
if let Some(a) = &angle2 {
|
|
check_expr(s, a, Kind::Angle, cmd, "angle2")?;
|
|
}
|
|
let to = match p.get("to") {
|
|
Some(v) => Some(vec3(v).ok_or_else(|| bad(cmd, "`to` must be a point [x, y, z] to turn to"))?),
|
|
None => None,
|
|
};
|
|
let symmetric =
|
|
matches!(str_(p, "direction").map(str::to_ascii_lowercase).as_deref(), Some("symmetric")) || bool_(p, "symmetric").unwrap_or(false);
|
|
let convention = match p.get("convention") {
|
|
None => solidcraft_doc::RevolveConvention::SketchNormal,
|
|
Some(value) => serde_json::from_value(value.clone()).map_err(|_| bad(cmd, "`convention` must be sketch_normal or legacy_axis_start"))?,
|
|
};
|
|
let operation = operation(p, cmd)?;
|
|
let targets = face_join_targets(s, p, operation, &[sketch], cmd)?;
|
|
// From a profile on a body's face in a component inside the active one, a cut changes that
|
|
// body too, as an extrude's does (#5679).
|
|
let mut p = std::borrow::Cow::Borrowed(p);
|
|
if let Some(parts) = cut_scope(s, &p, operation, sketch, None, cmd)? {
|
|
p.to_mut()["participants"] = json!(parts);
|
|
}
|
|
let kind = FeatureKind::Revolve {
|
|
sketch: SketchId(sketch),
|
|
profiles,
|
|
axis,
|
|
angle,
|
|
operation,
|
|
targets,
|
|
angle2,
|
|
symmetric,
|
|
convention,
|
|
to: to.map(FacePick),
|
|
};
|
|
add_feature(s, &p, kind)
|
|
}
|
|
|
|
/// 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
|
|
/// 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> {
|
|
if let Some((geo, ..)) = super::construct::model_axis_param(s, p.get("axis"), cmd)? {
|
|
return Ok(AxisRef::Model { geo });
|
|
}
|
|
if let Some(o) = p.get("axis").filter(|v| v.is_object()) {
|
|
if str_(o, "type") == Some("world") {
|
|
let axis =
|
|
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) });
|
|
}
|
|
match str_(p, "axis") {
|
|
Some(a @ ("X" | "Y" | "Z")) => Ok(AxisRef::World { axis: a.into() }),
|
|
Some(a @ ("x" | "y")) => Ok(AxisRef::SketchAxis { axis: a.into() }),
|
|
Some(name) if !is_sketch_line(s, sketch, name) && is_construction_axis(s, name) => Ok(AxisRef::Construction { name: name.into() }),
|
|
Some(id) => Ok(AxisRef::SketchLine { curve: id.into() }),
|
|
None => {
|
|
Err(bad(cmd, "`axis` must be a sketch line id, x, y (sketch axes), X, Y, Z, a construction axis, {origin, dir} or {edge|face: [x,y,z]}"))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Whether `curve` is a curve of the sketch feature `sketch`.
|
|
fn is_sketch_line(s: &Session, sketch: u64, curve: &str) -> bool {
|
|
matches!(s.doc.feature(sketch).map(|f| &f.kind), Some(FeatureKind::Sketch { sketch, .. }) if sketch.curve_index(curve).is_some())
|
|
}
|
|
|
|
/// Whether `name` is a construction axis feature of the design.
|
|
fn is_construction_axis(s: &Session, name: &str) -> bool {
|
|
s.doc.find_feature(name).is_some_and(|f| matches!(f.kind, FeatureKind::ConstructionAxis { .. }))
|
|
}
|
|
|
|
fn radius_expr(s: &Session, p: &Value, cmd: &str) -> Result<Expr> {
|
|
match (expr(p, "radius"), expr(p, "diameter")) {
|
|
(Some(r), _) => Ok(r),
|
|
(None, Some(d)) => {
|
|
let [d] = length_operands(s, [(&d, &typed_length_unit(s))]);
|
|
Ok(format!("({d}) / 2").into())
|
|
}
|
|
_ => Err(bad(cmd, "needs `radius` or `diameter`")),
|
|
}
|
|
}
|
|
|
|
/// The unit a bare length typed into a command means: the design's units. (A point's bare
|
|
/// coordinates, and a bare number already stored in a feature, are millimetres.)
|
|
pub(super) fn typed_length_unit(s: &Session) -> String {
|
|
solidcraft_doc::expr::length_unit_or_mm(&s.doc.units).to_string()
|
|
}
|
|
|
|
/// The lengths a command works one expression out from (a radius from a diameter, a pitch from
|
|
/// a height), each with the unit a bare number means where it came from. Bare numbers get that
|
|
/// unit written in, so the expression keeps the meaning they had: inside a larger expression a
|
|
/// bare number is read in the design's units of the moment, and changing them would resize the
|
|
/// part (#716). Next to a unit-less expression that is not a bare number (`2 * 5`, a unit-less
|
|
/// parameter), which is read in the design's units itself, they stay bare and are read with it,
|
|
/// as before.
|
|
pub(super) fn length_operands<const N: usize>(s: &Session, operands: [(&str, &str); N]) -> [String; N] {
|
|
use solidcraft_doc::expr::is_bare_number;
|
|
let follows = operands.iter().any(|(e, _)| !is_bare_number(e) && s.doc.eval(e, Kind::Unitless).is_ok());
|
|
operands.map(|(e, unit)| if !follows && is_bare_number(e) { format!("{} {unit}", e.trim()) } else { e.to_string() })
|
|
}
|
|
|
|
/// A placement point: `[x, y, z]` (or `{x, y, z}`) of numbers (mm) or length expressions;
|
|
/// the origin when it is not given. Anything else is refused (never read as the origin).
|
|
pub(super) fn point_param(s: &Session, p: &Value, key: &str, cmd: &str) -> Result<Option<PointExpr>> {
|
|
let Some(v) = p.get(key) else { return Ok(None) };
|
|
let want = || bad(cmd, format!("`{key}` must be a point [x, y, z] of numbers or length expressions"));
|
|
let coords: Vec<&Value> = match v {
|
|
Value::Array(a) if a.len() == 3 => a.iter().collect(),
|
|
Value::Object(o) => ["x", "y", "z"].iter().map(|k| o.get(*k)).collect::<Option<Vec<_>>>().ok_or_else(want)?,
|
|
_ => return Err(want()),
|
|
};
|
|
let mut out = PointExpr::default();
|
|
for (slot, (c, axis)) in out.iter_mut().zip(coords.into_iter().zip(["x", "y", "z"])) {
|
|
let e = expr(&json!({ "v": c }), "v").ok_or_else(want)?;
|
|
let x = s.doc.eval(&e, Kind::Length).map_err(|err| bad(cmd, format!("{key} {axis}: {err}")))?;
|
|
if !(x.is_finite() && x.abs() < 1e9) {
|
|
return Err(bad(cmd, format!("{key} {axis} is out of range")));
|
|
}
|
|
*slot = e;
|
|
}
|
|
Ok(Some(out))
|
|
}
|
|
|
|
/// An axis direction: X|Y|Z or a non-zero `[x, y, z]`; `Z` when it is not given.
|
|
pub(super) fn axis_dir_param(p: &Value, cmd: &str) -> Result<Vec3> {
|
|
match p.get("axis") {
|
|
None => Ok(Vec3::Z),
|
|
Some(v) => axis_dir_form(v).map_err(|why| bad(cmd, why)),
|
|
}
|
|
}
|
|
|
|
/// What [`axis_dir_param`] reads a given `axis` as, without the design: X, Y or Z (trimmed, any
|
|
/// case), else a non-zero `[x, y, z]`, normalized.
|
|
pub(crate) fn axis_dir_form(v: &Value) -> std::result::Result<Vec3, &'static str> {
|
|
match v {
|
|
Value::String(a) => match a.trim().to_ascii_uppercase().as_str() {
|
|
"X" => Ok(Vec3::X),
|
|
"Y" => Ok(Vec3::Y),
|
|
"Z" => Ok(Vec3::Z),
|
|
_ => Err("`axis` must be X, Y, Z or [x, y, z]"),
|
|
},
|
|
v => vec3(v).and_then(|a| a.normalized()).ok_or("`axis` must be X, Y, Z or a non-zero [x, y, z]"),
|
|
}
|
|
}
|
|
|
|
fn prim_box(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.box";
|
|
let (l, w, h) = (req_expr(cmd, p, "length")?, req_expr(cmd, p, "width")?, req_expr(cmd, p, "height")?);
|
|
for (e, n) in [(&l, "length"), (&w, "width"), (&h, "height")] {
|
|
check_expr(s, e, Kind::Length, cmd, n)?;
|
|
}
|
|
let corner = match (point_param(s, p, "corner", cmd)?, point_param(s, p, "center", cmd)?) {
|
|
(Some(c), _) => c,
|
|
// The corner half a size back from the centre (numbers stay numbers, in mm). The centre's
|
|
// bare numbers are millimetres, the sizes' the design's units.
|
|
(None, Some([cx, cy, cz])) => {
|
|
let unit = typed_length_unit(s);
|
|
let mm_per_unit = solidcraft_doc::expr::unit_info(&unit).map_or(1.0, |(_, k)| k);
|
|
let back = |c: Expr, size: &Expr| -> Expr {
|
|
match (c.parse::<f64>(), size.parse::<f64>()) {
|
|
(Ok(a), Ok(b)) => format!("{}", a - b * mm_per_unit / 2.0).into(),
|
|
_ => {
|
|
let [c, size] = length_operands(s, [(&c, "mm"), (size, &unit)]);
|
|
format!("({c}) - ({size}) / 2").into()
|
|
}
|
|
}
|
|
};
|
|
[back(cx, &l), back(cy, &w), back(cz, &h)]
|
|
}
|
|
_ => point_expr(Vec3::ZERO),
|
|
};
|
|
add_feature(s, p, FeatureKind::Box { corner, length: l, width: w, height: h, operation: operation(p, cmd)? })
|
|
}
|
|
|
|
fn prim_cylinder(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.cylinder";
|
|
let radius = radius_expr(s, p, cmd)?;
|
|
let height = req_expr(cmd, p, "height")?;
|
|
check_expr(s, &radius, Kind::Length, cmd, "radius")?;
|
|
check_expr(s, &height, Kind::Length, cmd, "height")?;
|
|
let base = point_param(s, p, "base", cmd)?.unwrap_or_else(|| point_expr(Vec3::ZERO));
|
|
let axis = axis_dir_param(p, cmd)?;
|
|
// Reference edges (#6380), as a Single hole's: the base centre sits at these distances from
|
|
// straight edges of the face it stands on, and `base` keeps where those put it.
|
|
let references = hole_reference_params(s, p, cmd)?;
|
|
let base = if references.is_empty() {
|
|
base
|
|
} else {
|
|
let at = p
|
|
.get("base")
|
|
.and_then(vec3)
|
|
.ok_or_else(|| bad(cmd, "`references` place a cylinder by its `base` given as numbers, not length expressions"))?;
|
|
point_expr(referenced_centre(s, cmd, &references, at, -axis)?)
|
|
};
|
|
add_feature(s, p, FeatureKind::Cylinder { base, axis: Dir(axis), radius, height, operation: operation(p, cmd)?, references })
|
|
}
|
|
|
|
fn prim_sphere(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.sphere";
|
|
let radius = radius_expr(s, p, cmd)?;
|
|
check_expr(s, &radius, Kind::Length, cmd, "radius")?;
|
|
let center = point_param(s, p, "center", cmd)?.unwrap_or_else(|| point_expr(Vec3::ZERO));
|
|
add_feature(s, p, FeatureKind::Sphere { center, radius, operation: operation(p, cmd)? })
|
|
}
|
|
|
|
fn prim_torus(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.torus";
|
|
let (major, minor) = (req_expr(cmd, p, "major")?, req_expr(cmd, p, "minor")?);
|
|
check_expr(s, &major, Kind::Length, cmd, "major")?;
|
|
check_expr(s, &minor, Kind::Length, cmd, "minor")?;
|
|
let center = point_param(s, p, "center", cmd)?.unwrap_or_else(|| point_expr(Vec3::ZERO));
|
|
add_feature(s, p, FeatureKind::Torus { center, major, minor, operation: operation(p, cmd)? })
|
|
}
|
|
|
|
/// A cone or truncated cone (#5641), placed and sized like a cylinder, with the top circle's
|
|
/// radius (or diameter) besides; none is a full cone.
|
|
fn prim_cone(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.cone";
|
|
let radius = radius_expr(s, p, cmd)?;
|
|
let top_radius = match (expr(p, "top_radius"), expr(p, "top_diameter")) {
|
|
(Some(r), _) => r,
|
|
(None, Some(d)) => {
|
|
let [d] = length_operands(s, [(&d, &typed_length_unit(s))]);
|
|
format!("({d}) / 2").into()
|
|
}
|
|
// Given but unreadable (a huge number, a list): refused, never a full cone instead.
|
|
(None, None) if p.get("top_radius").is_some() || p.get("top_diameter").is_some() => {
|
|
return Err(bad(cmd, "`top_radius` (or `top_diameter`) must be a length expression"));
|
|
}
|
|
(None, None) => "0".into(),
|
|
};
|
|
let height = req_expr(cmd, p, "height")?;
|
|
for (e, n) in [(&radius, "radius"), (&top_radius, "top_radius"), (&height, "height")] {
|
|
check_expr(s, e, Kind::Length, cmd, n)?;
|
|
}
|
|
let base = point_param(s, p, "base", cmd)?.unwrap_or_else(|| point_expr(Vec3::ZERO));
|
|
let axis = axis_dir_param(p, cmd)?;
|
|
add_feature(s, p, FeatureKind::Cone { base, axis: Dir(axis), radius, top_radius, height, operation: operation(p, cmd)? })
|
|
}
|
|
|
|
/// Edge references → points on the edges.
|
|
fn edge_points(s: &Session, p: &Value, cmd: &str) -> Result<Vec<Vec3>> {
|
|
let a = p.get("edges").and_then(Value::as_array).ok_or_else(|| bad(cmd, "`edges` must be a list"))?;
|
|
if a.is_empty() || a.len() > 1000 {
|
|
return Err(bad(cmd, "select 1…1000 edges"));
|
|
}
|
|
let st = s.model.state();
|
|
// A picked point must lie on an edge (within the distance the kernel re-finds an edge from)
|
|
// of the body the feature names, or of any body: a pick far from every edge would round
|
|
// whichever edge is nearest (#783). Each body's edges are worked out once.
|
|
let named = str_(p, "body").filter(|n| st.body(n).is_some());
|
|
// Per body: its size, its edges' polylines and which of them are seams.
|
|
let mut candidates: Option<Vec<(f64, Vec<Vec<Vec3>>, Vec<bool>)>> = None;
|
|
let mut out = Vec::new();
|
|
for e in a {
|
|
let pt = match edge_ref_form(e).map_err(|why| bad(cmd, why))? {
|
|
EdgeRefForm::Point(pt) => pt,
|
|
EdgeRefForm::Index { body, index } => {
|
|
let idx = index as usize;
|
|
let b = st.body(body).ok_or_else(|| bad(cmd, format!("no body `{body}`")))?;
|
|
let tol = (b.body.size() * 2e-3).max(1e-3);
|
|
let edges = b.body.edges(tol)?;
|
|
out.push(edges.get(idx).ok_or_else(|| bad(cmd, format!("{body} has no edge {idx}")))?.mid);
|
|
continue;
|
|
}
|
|
};
|
|
let bodies = candidates.get_or_insert_with(|| {
|
|
// Mesh bodies have no edges to pick: rounding one is refused later, saying why.
|
|
st.bodies
|
|
.iter()
|
|
.filter(|b| named.is_none_or(|n| b.name == n) && !b.body.is_mesh())
|
|
.filter_map(|b| {
|
|
let size = b.body.size();
|
|
let tol = (size * 2e-3).max(1e-3);
|
|
// The display mesh flags seams (a smooth surface meeting itself, as down the side
|
|
// of a cylinder), which nobody means by a pick where they end.
|
|
match b.body.display_mesh(tol) {
|
|
Ok(m) => Some((size, m.edges, m.seams)),
|
|
Err(_) => b.body.edges(tol).ok().map(|edges| (size, edges.into_iter().map(|e| e.points).collect(), Vec::new())),
|
|
}
|
|
})
|
|
.collect()
|
|
});
|
|
// A point where several edges meet (a corner) is ambiguous: the kernel would round one of
|
|
// them, picked silently (#5173). Edges that carry straight on through the point (the two
|
|
// halves of a circle) are one edge to whoever picked it, and seams don't count. Directions
|
|
// come from the polylines' end chords, which lean off a curve's tangent: within about 45°
|
|
// of opposite counts as carrying on (edges at a real corner are far from opposite).
|
|
let mut nearest = f64::INFINITY;
|
|
let mut near = Vec::new();
|
|
for (size, edges, seams) in bodies.iter() {
|
|
for (i, points) in edges.iter().enumerate() {
|
|
let d = points.windows(2).filter_map(|w| Some(pt.dist_to_segment(*w.first()?, *w.get(1)?))).fold(f64::INFINITY, f64::min);
|
|
nearest = nearest.min(d);
|
|
if d <= size * 0.05 + 1e-3 {
|
|
near.push((d, seams.get(i).copied().unwrap_or(false), leaving(points, pt)));
|
|
}
|
|
}
|
|
}
|
|
let matches = near.len();
|
|
let mut meeting: Vec<Option<Vec3>> = near.iter().filter(|(d, seam, _)| !seam && *d <= nearest + 1e-3).map(|(_, _, dir)| *dir).collect();
|
|
let mut chains = 0usize;
|
|
while let Some(dir) = meeting.pop() {
|
|
chains += 1;
|
|
if let Some(dir) = dir
|
|
&& let Some(j) = meeting.iter().position(|o| o.is_some_and(|other| other.dot(dir) < -0.7))
|
|
{
|
|
meeting.swap_remove(j);
|
|
}
|
|
}
|
|
if chains > 1 {
|
|
return Err(bad(
|
|
cmd,
|
|
format!("[{}, {}, {}] is where {chains} edges meet: give a point along one edge, such as its midpoint", pt.x, pt.y, pt.z),
|
|
));
|
|
}
|
|
if matches == 0 && !bodies.is_empty() {
|
|
let far = if nearest.is_finite() { format!("the nearest edge is {nearest:.3} mm away") } else { "there is no edge".to_string() };
|
|
return Err(bad(cmd, format!("no edge at [{}, {}, {}]: {far}", pt.x, pt.y, pt.z)));
|
|
}
|
|
out.push(pt);
|
|
}
|
|
Ok(out)
|
|
}
|
|
|
|
/// The direction an edge's polyline leaves `pt` in, when `pt` is one of its ends; `None` when
|
|
/// the edge runs on through `pt`.
|
|
fn leaving(points: &[Vec3], pt: Vec3) -> Option<Vec3> {
|
|
let (first, last) = (points.first()?, points.last()?);
|
|
if first.dist(pt) <= 1e-3 {
|
|
(*points.get(1)? - *first).normalized()
|
|
} else if last.dist(pt) <= 1e-3 {
|
|
(*points.get(points.len().checked_sub(2)?)? - *last).normalized()
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
/// An edge reference as given, before it is looked up: see [`edge_points`].
|
|
pub(crate) enum EdgeRefForm<'a> {
|
|
Point(Vec3),
|
|
Index { body: &'a str, index: u64 },
|
|
}
|
|
|
|
/// What [`edge_points`] reads one edge as, without the design: a point on it (`[x, y, z]` or
|
|
/// `{point}`), else `{body, index}`.
|
|
pub(crate) fn edge_ref_form(e: &Value) -> std::result::Result<EdgeRefForm<'_>, &'static str> {
|
|
if let Some(pt) = vec3(e).or_else(|| e.get("point").and_then(vec3)) {
|
|
return Ok(EdgeRefForm::Point(pt));
|
|
}
|
|
let body = e.get("body").and_then(Value::as_str).ok_or("an edge is a point [x,y,z], {point} or {body, index}")?;
|
|
let index = e.get("index").and_then(Value::as_u64).ok_or("edge `index` must be a number")?;
|
|
Ok(EdgeRefForm::Index { body, index })
|
|
}
|
|
|
|
/// Press Pull: a face moves along its normal (an extrude that joins outward or cuts inward); a
|
|
/// fillet's or chamfer's face changes that feature's size; an edge is rounded (a fillet).
|
|
fn press_pull(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.press_pull";
|
|
let distance = req_expr(cmd, p, "distance")?;
|
|
if p.get("edges").is_some() {
|
|
return fillet(s, &json!({"edges": p.get("edges"), "radius": distance}));
|
|
}
|
|
let face = p.get("face").ok_or_else(|| bad(cmd, "needs `face` or `edges`"))?;
|
|
let d = s.doc.eval(&distance, Kind::Length).map_err(|e| bad(cmd, format!("distance: {e}")))?;
|
|
if d.abs() < 1e-9 {
|
|
return Err(bad(cmd, "the distance must not be zero"));
|
|
}
|
|
// A fillet's or chamfer's face: its size changes by the distance (the feature is edited). A
|
|
// chamfer's face is flat, so this is asked before whether the face is planar (#4986).
|
|
if let Some(fp) = vec3(face) {
|
|
let name = solidcraft_doc::naming::face_names_at(&s.model.state(), &[fp]).into_iter().next().unwrap_or_default();
|
|
let fid = solidcraft_doc::persistent_name::made_by(&name);
|
|
if solidcraft_doc::persistent_name::is_blend(&name) {
|
|
let f = fid.and_then(|id| s.doc.feature(id)).cloned().ok_or_else(|| bad(cmd, "the blend's feature is gone"))?;
|
|
let (key, old) = match &f.kind {
|
|
FeatureKind::Fillet { radius, .. } => ("radius", radius.clone()),
|
|
FeatureKind::Chamfer { distance, .. } => ("distance", distance.clone()),
|
|
_ => return Err(bad(cmd, "that face is not a fillet's or a chamfer's")),
|
|
};
|
|
// A bare number stored in the feature is millimetres; the distance's, the design's units.
|
|
let [old, more] = length_operands(s, [(&old, "mm"), (&distance, &typed_length_unit(s))]);
|
|
let new = format!("({old}) + ({more})");
|
|
let r = super::find_command("timeline.edit").ok_or_else(|| bad(cmd, "timeline.edit"))?;
|
|
let out = (r.run)(s, &json!({"feature": f.id, "set": {key: new}}))?;
|
|
return Ok(json!({"feature": f.id, "edited": f.name, key: new, "recomputed": out.get("recomputed"), "restored": out.get("restored")}));
|
|
}
|
|
// Another curved face moves along its normal.
|
|
if super::face::face_is_planar(s, fp) == Some(false) {
|
|
let r = super::find_command("solid.offset_face").ok_or_else(|| bad(cmd, "solid.offset_face"))?;
|
|
return (r.run)(s, &json!({"faces": [face], "distance": distance}));
|
|
}
|
|
}
|
|
// Pushed in: the extrude cuts the other way by as much (a bare number stays one, so it keeps
|
|
// being read as a bare number typed into the extrude).
|
|
let flipped = match distance.trim().parse::<f64>() {
|
|
Ok(v) if solidcraft_doc::expr::is_bare_number(&distance) => Expr::new(format!("{}", -v)),
|
|
_ => Expr::new(format!("-({distance})")),
|
|
};
|
|
let (dist, dir, op) = if d > 0.0 { (distance, "positive", "join") } else { (flipped, "negative", "cut") };
|
|
extrude(s, &json!({"face": face, "distance": dist, "direction": dir, "operation": op}))
|
|
}
|
|
|
|
fn fillet(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.fillet";
|
|
let edges = edge_points(s, p, cmd)?;
|
|
let radius = req_expr(cmd, p, "radius")?;
|
|
check_expr(s, &radius, Kind::Length, cmd, "radius")?;
|
|
let style = match str_(p, "type").map(str::to_ascii_lowercase).as_deref() {
|
|
None | Some("constant") | Some("rolling_ball") => solidcraft_doc::FilletStyle::Constant,
|
|
Some("chord") | Some("chord_length") => solidcraft_doc::FilletStyle::Chord,
|
|
Some("curvature") | Some("g2") => solidcraft_doc::FilletStyle::Curvature,
|
|
Some("variable") => {
|
|
let radius2 = req_expr(cmd, p, "radius2")?;
|
|
check_expr(s, &radius2, Kind::Length, cmd, "radius2")?;
|
|
let start =
|
|
p.get("start").and_then(vec3).ok_or_else(|| bad(cmd, "a variable fillet needs `start`: [x,y,z] near the end that takes `radius`"))?;
|
|
let mut mid = Vec::new();
|
|
for m in p.get("mid").and_then(Value::as_array).into_iter().flatten().take(100) {
|
|
let (Some(t), Some(r)) = (m.get(0).and_then(Value::as_f64), m.get(1)) else {
|
|
return Err(bad(cmd, "`mid` entries are [position, radius]"));
|
|
};
|
|
if !(t.is_finite() && t > 0.0 && t < 1.0) {
|
|
return Err(bad(cmd, "`mid` positions lie between 0 and 1 (from the start end)"));
|
|
}
|
|
let r = match r {
|
|
Value::String(x) => x.clone(),
|
|
Value::Number(n) => n.to_string(),
|
|
_ => return Err(bad(cmd, "a `mid` radius is a number or an expression")),
|
|
};
|
|
check_expr(s, &r, Kind::Length, cmd, "mid radius")?;
|
|
mid.push((t, r.into()));
|
|
}
|
|
let smooth = p.get("smooth").and_then(Value::as_bool).unwrap_or(false);
|
|
solidcraft_doc::FilletStyle::Variable { radius2, start: Position(start), mid, smooth }
|
|
}
|
|
Some("spline") => {
|
|
let start = p
|
|
.get("start")
|
|
.and_then(vec3)
|
|
.ok_or_else(|| bad(cmd, "a spline fillet needs `start`: [x,y,z] near the end its positions start from"))?;
|
|
let knots: Vec<f64> = p.get("knots").and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_f64).collect();
|
|
let mut radii = Vec::new();
|
|
for r in p.get("radii").and_then(Value::as_array).into_iter().flatten().take(100) {
|
|
let r = match r {
|
|
Value::String(x) => x.clone(),
|
|
Value::Number(n) => n.to_string(),
|
|
_ => return Err(bad(cmd, "a control radius is a number or an expression")),
|
|
};
|
|
check_expr(s, &r, Kind::Length, cmd, "control radius")?;
|
|
radii.push(Expr::from(r));
|
|
}
|
|
// All control radii (`radius` and `radii`) plus the degree (1…3) plus one.
|
|
if radii.is_empty() || !(radii.len() + 3..=radii.len() + 5).contains(&knots.len()) {
|
|
return Err(bad(
|
|
cmd,
|
|
"a spline fillet needs `radii` (the control radii after `radius`) and `knots` (as many as all control radii, the degree 1…3 and one more)",
|
|
));
|
|
}
|
|
solidcraft_doc::FilletStyle::Spline { start: Position(start), knots, radii }
|
|
}
|
|
Some(o) => return Err(bad(cmd, format!("unknown fillet type `{o}` (constant, chord, variable, spline or curvature)"))),
|
|
};
|
|
let fit = match str_(p, "fit").map(str::to_ascii_lowercase).as_deref() {
|
|
None | Some("exact") => solidcraft_doc::FilletFit::Exact,
|
|
Some("reduce") => solidcraft_doc::FilletFit::Reduce,
|
|
Some("taper") => solidcraft_doc::FilletFit::Taper,
|
|
Some(o) => return Err(bad(cmd, format!("unknown fit `{o}` (exact, reduce or taper)"))),
|
|
};
|
|
if !fit.is_exact() && !style.is_constant() {
|
|
return Err(bad(cmd, "`fit: reduce` and `fit: taper` take a constant radius"));
|
|
}
|
|
// What fills the corners where three blended edges meet.
|
|
let corner = match str_(p, "corner").map(str::to_ascii_lowercase).as_deref() {
|
|
None | Some("rolling") => solidcraft_doc::FilletCorner::Rolling,
|
|
Some("g2") => solidcraft_doc::FilletCorner::G2,
|
|
Some(o) => return Err(bad(cmd, format!("unknown corner `{o}` (rolling or g2)"))),
|
|
};
|
|
if !corner.is_rolling() && (!style.is_constant() || !fit.is_exact()) {
|
|
return Err(bad(cmd, "`corner: g2` is built for a constant-radius fillet (`type: constant`, `fit: exact`) only"));
|
|
}
|
|
let mut out = add_feature(
|
|
s,
|
|
p,
|
|
FeatureKind::Fillet {
|
|
edges: edges.into_iter().map(Position).collect(),
|
|
radius,
|
|
body: str_(p, "body").map(BodyName::from),
|
|
style,
|
|
fit,
|
|
corner,
|
|
},
|
|
)?;
|
|
// The radii the fillet used, when `fit: reduce` reduced it.
|
|
if let Some(id) = out.get("feature").and_then(Value::as_u64)
|
|
&& let Some(state) = s.model.result(id).map(|res| &res.state)
|
|
&& let Some(r) = state.fitted_radius(id)
|
|
{
|
|
out["radius_applied"] = serde_json::json!(r);
|
|
let each: Vec<Value> =
|
|
state.fitted_edges(id).unwrap_or_default().into_iter().map(|(p, r)| serde_json::json!({"edge": [p.x, p.y, p.z], "radius": r})).collect();
|
|
out["radii_applied"] = Value::Array(each);
|
|
}
|
|
Ok(out)
|
|
}
|
|
|
|
fn chamfer(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.chamfer";
|
|
let edges = edge_points(s, p, cmd)?;
|
|
let distance = req_expr(cmd, p, "distance")?;
|
|
check_expr(s, &distance, Kind::Length, cmd, "distance")?;
|
|
let (distance2, angle) = (expr(p, "distance2"), expr(p, "angle"));
|
|
if let Some(d) = &distance2 {
|
|
check_expr(s, d, Kind::Length, cmd, "distance2")?;
|
|
}
|
|
if let Some(a) = &angle {
|
|
check_expr(s, a, Kind::Angle, cmd, "angle")?;
|
|
}
|
|
if distance2.is_some() && angle.is_some() {
|
|
return Err(bad(cmd, "give `distance2` or `angle`, not both"));
|
|
}
|
|
let flip = bool_(p, "flip").unwrap_or(false);
|
|
add_feature(
|
|
s,
|
|
p,
|
|
FeatureKind::Chamfer {
|
|
edges: edges.into_iter().map(Position).collect(),
|
|
distance,
|
|
distance2,
|
|
angle,
|
|
flip,
|
|
body: str_(p, "body").map(BodyName::from),
|
|
},
|
|
)
|
|
}
|
|
|
|
fn combine(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.combine";
|
|
let target = str_(p, "target").ok_or_else(|| bad(cmd, "`target` must be a body name"))?.to_string();
|
|
let tools = string_list(cmd, p, "tools")?;
|
|
if tools.is_empty() {
|
|
return Err(bad(cmd, "`tools` must list bodies"));
|
|
}
|
|
let op = match str_(p, "operation") {
|
|
None => Operation::Join,
|
|
Some(o) => Operation::parse(o).filter(|o| *o != Operation::NewBody).ok_or_else(|| bad(cmd, "operation must be join, cut or intersect"))?,
|
|
};
|
|
let mut out = add_feature(
|
|
s,
|
|
p,
|
|
FeatureKind::Combine {
|
|
target: target.clone().into(),
|
|
tools: tools.into_iter().map(BodyName).collect(),
|
|
operation: op,
|
|
keep_tools: bool_(p, "keep_tools").unwrap_or(false),
|
|
},
|
|
)?;
|
|
// New Component: the result goes into a component of its own.
|
|
if bool_(p, "new_component").unwrap_or(false) {
|
|
let name = str_(p, "component_name").map(str::to_string).unwrap_or_else(|| format!("{target} Combined"));
|
|
let c = s.execute("component.create", &json!({"name": name, "activate": false}))?;
|
|
super::component::transfer_constructor_result(s, &json!({"bodies": [target], "component": c["component"]}))?;
|
|
out["component"] = c["component"].clone();
|
|
}
|
|
Ok(out)
|
|
}
|
|
|
|
fn move_bodies(s: &mut Session, p: &Value) -> Result<Value> {
|
|
if let Some(paths) = copied_components(p)? {
|
|
return copy_components(s, p, paths);
|
|
}
|
|
if let Some(plan) = crate::frames::placements_moved(s, p) {
|
|
return move_placements(s, p, plan);
|
|
}
|
|
// Bodies in differently placed frames: one Move feature per frame, each moving its bodies
|
|
// by the world vector and turn mapped into that frame (#9660).
|
|
if let Some(moves) = crate::frames::split_move(s, p) {
|
|
return move_split(s, &moves);
|
|
}
|
|
move_body_feature(s, p)
|
|
}
|
|
|
|
/// The moves of `frames::split_move`, in one step, with one reply: the features made, and the
|
|
/// bodies made, changed and removed by any of them.
|
|
fn move_split(s: &mut Session, moves: &[Value]) -> Result<Value> {
|
|
let mut features = Vec::new();
|
|
let mut lists: [(&str, Vec<Value>); 3] = [("created_bodies", Vec::new()), ("changed_bodies", Vec::new()), ("removed_bodies", Vec::new())];
|
|
let mut last = Value::Null;
|
|
for p in moves {
|
|
let reply = move_body_feature(s, p)?;
|
|
features.push(reply.get("feature").cloned().unwrap_or(Value::Null));
|
|
for (key, list) in &mut lists {
|
|
for name in reply.get(*key).and_then(Value::as_array).into_iter().flatten() {
|
|
if !list.contains(name) {
|
|
list.push(name.clone());
|
|
}
|
|
}
|
|
}
|
|
last = reply;
|
|
}
|
|
if let Some(out) = last.as_object_mut() {
|
|
if let Some(first) = features.first() {
|
|
out.insert("feature".into(), first.clone());
|
|
}
|
|
out.insert("features".into(), Value::Array(features));
|
|
for (key, list) in lists {
|
|
out.insert(key.into(), Value::Array(list));
|
|
}
|
|
}
|
|
Ok(last)
|
|
}
|
|
|
|
/// The occurrence paths a copying move copies (`occurrences`, root first), `None` when it names
|
|
/// none. A component is only ever copied, so the move must set `copy`.
|
|
fn copied_components(p: &Value) -> Result<Option<Vec<Vec<u64>>>> {
|
|
let cmd = "solid.move";
|
|
let Some(list) = p.get("occurrences") else { return Ok(None) };
|
|
let paths: Vec<Vec<u64>> = list
|
|
.as_array()
|
|
.into_iter()
|
|
.flatten()
|
|
.map(|path| path.as_array().and_then(|ids| ids.iter().map(Value::as_u64).collect::<Option<Vec<u64>>>()).filter(|ids| !ids.is_empty()))
|
|
.collect::<Option<_>>()
|
|
.ok_or_else(|| bad(cmd, "`occurrences` must list occurrence paths, each a list of occurrence ids"))?;
|
|
if paths.is_empty() || paths.len() > 1000 {
|
|
return Err(bad(cmd, "`occurrences` must list 1…1000 occurrence paths"));
|
|
}
|
|
if p.get("copy").and_then(Value::as_bool) != Some(true) {
|
|
return Err(bad(cmd, "`occurrences` are copied: set `copy` to true"));
|
|
}
|
|
Ok(Some(paths))
|
|
}
|
|
|
|
/// The translation (mm) and turn (radians, if any) of a move in the world.
|
|
fn world_move(s: &Session, p: &Value) -> Result<(Vec<f64>, Option<f64>)> {
|
|
let cmd = "solid.move";
|
|
let length = |v: &Value| -> Result<f64> {
|
|
match v {
|
|
Value::Number(n) => n.as_f64().ok_or_else(|| bad(cmd, "translate entries must be numbers or expressions")),
|
|
Value::String(e) => s.doc.eval(e, Kind::Length).map_err(|e| bad(cmd, format!("translate: {e}"))),
|
|
_ => Err(bad(cmd, "translate entries must be numbers or expressions")),
|
|
}
|
|
};
|
|
let translate = match p.get("translate") {
|
|
Some(Value::Array(a)) if a.len() == 3 => a.iter().map(length).collect::<Result<Vec<f64>>>()?,
|
|
None => vec![0.0; 3],
|
|
_ => return Err(bad(cmd, "`translate` must be [x, y, z]")),
|
|
};
|
|
let angle = match expr(p, "angle") {
|
|
Some(a) => Some(s.doc.eval(&a, Kind::Angle).map_err(|e| bad(cmd, format!("angle: {e}")))?),
|
|
None => None,
|
|
};
|
|
Ok((translate, angle))
|
|
}
|
|
|
|
/// A copying move of components (`occurrences`, with `copy`): each picked placement's component is
|
|
/// copied as an independent component, as Paste New copies it (`component.paste_new`), placed where
|
|
/// the placement is; the copy then moves by the move's translation and turn in the world, as
|
|
/// `occurrence.move` moves a placement. The bodies listed are copied as bodies (see
|
|
/// `move_body_feature`) in the same command, so the whole move is one undo step.
|
|
fn copy_components(s: &mut Session, p: &Value, paths: Vec<Vec<u64>>) -> Result<Value> {
|
|
let cmd = "solid.move";
|
|
let (translate, angle) = world_move(s, p)?;
|
|
let paste = super::find_command("component.paste_new").ok_or_else(|| EngineError::UnknownCommand("component.paste_new".into()))?;
|
|
let mover = super::find_command("occurrence.move").ok_or_else(|| EngineError::UnknownCommand("occurrence.move".into()))?;
|
|
// A component inside another one copied here comes with its parent's copy.
|
|
let mut paths: Vec<Vec<u64>> = paths.into_iter().fold(Vec::new(), |mut out, path| {
|
|
if !out.contains(&path) {
|
|
out.push(path);
|
|
}
|
|
out
|
|
});
|
|
let all = paths.clone();
|
|
paths.retain(|p| !all.iter().any(|q| q.len() < p.len() && p.starts_with(q)));
|
|
// The bodies are given in the world; their own component's frame turns them, as a move of bodies
|
|
// alone is turned, so they are mapped the same way, before any copy is made.
|
|
let has_bodies = match p.get("bodies") {
|
|
None => false,
|
|
Some(Value::Array(bodies)) => !bodies.is_empty(),
|
|
Some(_) => return Err(bad(cmd, "`bodies` must list bodies")),
|
|
};
|
|
let mut rest = p.clone();
|
|
if let Some(object) = rest.as_object_mut() {
|
|
object.remove("occurrences");
|
|
}
|
|
// Bodies in differently placed frames split by frame (`frames::split_move`, #9660), as a move of them alone does.
|
|
let split = crate::frames::split_move(s, &rest);
|
|
let bodies = (has_bodies && split.is_none()).then(|| crate::frames::to_local(s, cmd, &rest).unwrap_or_else(|| rest.clone()));
|
|
let mut copies = Vec::new();
|
|
for path in &paths {
|
|
let Some(&source) = path.last() else { continue };
|
|
let component =
|
|
s.doc.occurrences.iter().find(|o| o.id == source).map(|o| o.component).ok_or_else(|| bad(cmd, "`occurrences` names no occurrence"))?;
|
|
let made = paste.run_nested(s, &json!({"component": component, "occurrence": source, "path": path}))?;
|
|
let copy = made.get("occurrence").and_then(Value::as_u64).ok_or_else(|| bad(cmd, "the copy has no occurrence"))?;
|
|
// The copy is placed by the same parent placement as its source.
|
|
let mut at = path[..path.len() - 1].to_vec();
|
|
at.push(copy);
|
|
let mut q = json!({"occurrence": copy, "path": at, "space": "world", "translate": translate});
|
|
if let Some(axis) = p.get("axis") {
|
|
q["axis"] = axis.clone();
|
|
}
|
|
if let Some(angle) = angle {
|
|
q["angle"] = json!(angle);
|
|
}
|
|
mover.run_nested(s, &q)?;
|
|
copies.push(copy);
|
|
}
|
|
// The reply is a solid.move reply: the bodies' feature reply, with the copies made alongside.
|
|
let mut out = match (split, bodies) {
|
|
(Some(moves), _) => move_split(s, &moves)?,
|
|
(None, Some(local)) => move_body_feature(s, &local)?,
|
|
(None, None) => json!({}),
|
|
};
|
|
if let Some(object) = out.as_object_mut() {
|
|
object.insert("occurrences".into(), json!(copies));
|
|
}
|
|
Ok(out)
|
|
}
|
|
|
|
/// A move of several placements of one part (`frames::placements_moved`, #4768): each placement
|
|
/// moved in the world by the move's translation and turn (about the world origin, as the Move
|
|
/// feature turns bodies), and the root component's bodies listed moved as bodies, in one step.
|
|
fn move_placements(s: &mut Session, p: &Value, plan: crate::frames::PlacementMove) -> Result<Value> {
|
|
let (translate, angle) = world_move(s, p)?;
|
|
let spec = super::find_command("occurrence.move").ok_or_else(|| EngineError::UnknownCommand("occurrence.move".into()))?;
|
|
let mut moved = Vec::new();
|
|
for path in &plan.paths {
|
|
let Some(&occurrence) = path.last() else { continue };
|
|
let mut q = json!({"occurrence": occurrence, "path": path, "space": "world", "translate": translate});
|
|
if let Some(axis) = p.get("axis") {
|
|
q["axis"] = axis.clone();
|
|
}
|
|
if let Some(angle) = angle {
|
|
q["angle"] = json!(angle);
|
|
}
|
|
spec.run_nested(s, &q)?;
|
|
moved.push(occurrence);
|
|
}
|
|
let mut out = json!({"placements": moved});
|
|
if !plan.bodies.is_empty() {
|
|
let mut rest = p.clone();
|
|
rest["bodies"] = json!(plan.bodies);
|
|
out["bodies"] = move_body_feature(s, &rest)?;
|
|
}
|
|
Ok(out)
|
|
}
|
|
|
|
fn move_body_feature(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.move";
|
|
let bodies = string_list(cmd, p, "bodies")?;
|
|
if bodies.is_empty() {
|
|
return Err(bad(cmd, "`bodies` must list bodies"));
|
|
}
|
|
let t = match p.get("translate") {
|
|
Some(Value::Array(a)) if a.len() == 3 => {
|
|
let mut out: [Expr; 3] = Default::default();
|
|
for (i, v) in a.iter().enumerate() {
|
|
let e = expr(&json!({"v": v}), "v").ok_or_else(|| bad(cmd, "translate entries must be numbers or expressions"))?;
|
|
check_expr(s, &e, Kind::Length, cmd, "translate")?;
|
|
if let Some(slot) = out.get_mut(i) {
|
|
*slot = e;
|
|
}
|
|
}
|
|
out
|
|
}
|
|
None => ["0".into(), "0".into(), "0".into()],
|
|
_ => return Err(bad(cmd, "`translate` must be [x, y, z]")),
|
|
};
|
|
let angle = expr(p, "angle");
|
|
if let Some(a) = &angle {
|
|
check_expr(s, a, Kind::Angle, cmd, "angle")?;
|
|
}
|
|
let copy = bool_(p, "copy").unwrap_or(false);
|
|
let reply = add_feature(
|
|
s,
|
|
p,
|
|
FeatureKind::Move {
|
|
bodies: bodies.iter().cloned().map(BodyName).collect(),
|
|
translate: t,
|
|
rotate_axis: p.get("axis").and_then(vec3).map(Dir),
|
|
angle,
|
|
copy,
|
|
},
|
|
)?;
|
|
if copy {
|
|
copy_keeps_appearance(s, &reply, &bodies, cmd)?;
|
|
super::print_face::copies_keep_print_faces(s, &reply, &bodies);
|
|
}
|
|
Ok(reply)
|
|
}
|
|
|
|
/// A copy keeps the look and the material of the body it came from (#6423): the copy is the same
|
|
/// part in another place, so it looks the same.
|
|
fn copy_keeps_appearance(s: &mut Session, reply: &Value, sources: &[String], cmd: &str) -> Result<()> {
|
|
let id = reply.get("feature").and_then(Value::as_u64).ok_or_else(|| bad(cmd, "the copy has no feature id"))?;
|
|
let copies: Vec<String> = s.model.state().bodies.iter().filter(|b| b.feature == id).map(|b| b.name.clone()).collect();
|
|
if copies.len() != sources.len() {
|
|
return Err(bad(cmd, "the copy did not make one body per body it copied"));
|
|
}
|
|
for (source, copy) in sources.iter().zip(copies.iter()) {
|
|
if let Some(look) = s.doc.appearances.bodies.get(source).cloned() {
|
|
s.doc_mut().appearances.bodies.insert(copy.clone(), look);
|
|
}
|
|
if let Some(material) = s.doc.materials.get(source).cloned() {
|
|
s.doc_mut().materials.insert(copy.clone(), material);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn source_features(s: &Session, p: &Value, cmd: &str) -> Result<Vec<solidcraft_doc::FeatureId>> {
|
|
let names = string_list(cmd, p, "features")?;
|
|
if names.is_empty() {
|
|
return Err(bad(cmd, "`features` must list features to copy"));
|
|
}
|
|
// Names stay input only: the feature stores its seeds by id (#1134), resolved the way
|
|
// evaluation used to resolve them (a shared sketch name does not win over the geometry).
|
|
names.iter().map(|n| s.doc.seed_feature(n).map(|f| f.id.into()).ok_or_else(|| bad(cmd, format!("no feature `{n}`")))).collect()
|
|
}
|
|
|
|
/// An axis line from its parameter, with what it follows: an edge or round face of the model
|
|
/// ({edge|face: [x,y,z]}) or a construction axis by name ([`named_axis_line`]).
|
|
fn axis_line(s: &Session, p: &Value, cmd: &str) -> Result<(Vec3, Vec3, Option<solidcraft_doc::construct::GeoRef>, Option<FeatureName>)> {
|
|
if let Some((geo, o, d)) = super::construct::model_axis_param(s, p.get("axis"), cmd)? {
|
|
return Ok((o, d, Some(geo), None));
|
|
}
|
|
let (o, d, name) = named_axis_line(s, p, cmd)?;
|
|
Ok((o, d, None, name))
|
|
}
|
|
|
|
/// An axis line from `axis`: X, Y, Z, a construction axis by name or {origin, dir}. A construction
|
|
/// axis comes back where it is now, with its name.
|
|
fn named_axis_line(s: &Session, p: &Value, cmd: &str) -> Result<(Vec3, Vec3, Option<FeatureName>)> {
|
|
match p.get("axis") {
|
|
Some(Value::String(a)) => match a.to_ascii_uppercase().as_str() {
|
|
"X" => Ok((Vec3::ZERO, Vec3::X, None)),
|
|
"Y" => Ok((Vec3::ZERO, Vec3::Y, None)),
|
|
"Z" => Ok((Vec3::ZERO, Vec3::Z, None)),
|
|
_ if is_construction_axis(s, a) => {
|
|
let (_, _, origin, dir) = crate::view::construction_axes(s)
|
|
.into_iter()
|
|
.find(|(_, name, _, _)| name == a)
|
|
.ok_or_else(|| bad(cmd, format!("construction axis `{a}` has no geometry: fix its definition first")))?;
|
|
Ok((origin, dir, Some(a.as_str().into())))
|
|
}
|
|
_ => Err(bad(cmd, "axis must be X, Y, Z, a construction axis, {origin, dir} or {edge|face: [x,y,z]}")),
|
|
},
|
|
Some(o @ Value::Object(_)) => {
|
|
let (origin, dir) = axis_line_object(o).map_err(|why| bad(cmd, why))?;
|
|
Ok((origin, dir, None))
|
|
}
|
|
_ => Err(bad(cmd, "`axis` is required")),
|
|
}
|
|
}
|
|
|
|
/// An axis line `{origin?, dir}` as [`named_axis_line`] reads it: the origin (default: the
|
|
/// origin) and the unit direction.
|
|
pub(crate) fn axis_line_object(o: &Value) -> std::result::Result<(Vec3, Vec3), &'static str> {
|
|
let origin = match o.get("origin") {
|
|
None => Vec3::ZERO,
|
|
Some(v) => vec3(v).ok_or("axis.origin must contain three finite numeric coordinates in millimetres; expressions are not supported")?,
|
|
};
|
|
let dir = o.get("dir").and_then(vec3).and_then(|d| d.normalized()).ok_or("axis needs a non-zero `dir`")?;
|
|
Ok((origin, dir))
|
|
}
|
|
|
|
/// A pattern feature, or for `components`, new occurrences of them at each placement.
|
|
fn finish_pattern(
|
|
s: &mut Session,
|
|
p: &Value,
|
|
features: Vec<solidcraft_doc::FeatureId>,
|
|
pattern: solidcraft_doc::PatternKind,
|
|
bodies: Vec<String>,
|
|
) -> Result<Value> {
|
|
let comps = string_list(UNKNOWN_COMMAND, p, "components")?;
|
|
if comps.is_empty() {
|
|
return add_feature(s, p, FeatureKind::Pattern { features, pattern, bodies: bodies.into_iter().map(BodyName).collect() });
|
|
}
|
|
let cmd = "pattern (components)";
|
|
let mats = solidcraft_doc::pattern_matrices(&s.doc, &s.model.state(), &pattern)?;
|
|
let mut made = Vec::new();
|
|
for c in &comps {
|
|
let id = s.doc.find_component(c).filter(|id| *id != 0).ok_or_else(|| bad(cmd, format!("no component `{c}`")))?;
|
|
let src = s.doc.occurrence_of(id).cloned().ok_or_else(|| bad(cmd, format!("component `{c}` has no occurrence")))?;
|
|
for m in &mats {
|
|
made.push(s.doc_mut().add_occurrence(id, src.parent, solidcraft_doc::mat_mul(m, &src.transform))?);
|
|
}
|
|
}
|
|
Ok(json!({"occurrences": made}))
|
|
}
|
|
|
|
/// What a pattern copies: features (replayed), bodies (`bodies: [names]`), or components
|
|
/// (`components: [names]`, placed again as occurrences).
|
|
fn pattern_sources(s: &Session, p: &Value, cmd: &str) -> Result<(Vec<solidcraft_doc::FeatureId>, Vec<String>)> {
|
|
if !string_list(cmd, p, "components")?.is_empty() {
|
|
return Ok((Vec::new(), Vec::new()));
|
|
}
|
|
let bodies = string_list(cmd, p, "bodies")?;
|
|
if bodies.is_empty() {
|
|
return Ok((source_features(s, p, cmd)?, Vec::new()));
|
|
}
|
|
let st = s.model.state();
|
|
if let Some(b) = bodies.iter().find(|b| st.body(b).is_none()) {
|
|
return Err(bad(cmd, format!("no body `{b}`")));
|
|
}
|
|
Ok((Vec::new(), bodies))
|
|
}
|
|
|
|
fn pattern_rect(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.pattern.rectangular";
|
|
let (features, bodies) = pattern_sources(s, p, cmd)?;
|
|
let dir1 = p.get("dir1").and_then(vec3).ok_or_else(|| bad(cmd, "`dir1` must be [x, y, z]"))?;
|
|
let count1 = req_expr(cmd, p, "count1")?;
|
|
let spacing1 = req_expr(cmd, p, "spacing1")?;
|
|
check_count(s, &count1, cmd, "count1")?;
|
|
check_expr(s, &spacing1, Kind::Length, cmd, "spacing1")?;
|
|
let dir2 = p.get("dir2").and_then(vec3);
|
|
let (count2, spacing2) = (expr(p, "count2"), expr(p, "spacing2"));
|
|
if let Some(c) = &count2 {
|
|
check_count(s, c, cmd, "count2")?;
|
|
}
|
|
if let Some(c) = &spacing2 {
|
|
check_expr(s, c, Kind::Length, cmd, "spacing2")?;
|
|
}
|
|
let pattern = solidcraft_doc::PatternKind::Rectangular {
|
|
dir1: Dir(dir1),
|
|
count1,
|
|
spacing1,
|
|
dir2: dir2.map(Dir),
|
|
count2,
|
|
spacing2,
|
|
alignment: super::alignment_param(p, "alignment", cmd)?,
|
|
alignment2: super::alignment_param(p, "alignment2", cmd)?,
|
|
reversed: super::reversed_param(p, "reversed", cmd)?,
|
|
reversed2: super::reversed_param(p, "reversed2", cmd)?,
|
|
};
|
|
finish_pattern(s, p, features, pattern, bodies)
|
|
}
|
|
|
|
/// The line a circular pattern turns about, as [`axis_line`] reads it, except that the origin of
|
|
/// `{origin, dir}` may be length expressions, kept so the pattern follows them (#10852).
|
|
fn pattern_axis(s: &Session, p: &Value, cmd: &str) -> Result<(PointExpr, Vec3, Option<solidcraft_doc::construct::GeoRef>, Option<FeatureName>)> {
|
|
if let Some(a @ Value::Object(o)) = p.get("axis")
|
|
&& o.contains_key("origin")
|
|
&& !super::is_model_axis(a)
|
|
{
|
|
// Read under its full name, so a refusal says which origin it means.
|
|
let origin = point_param(s, &json!({ "axis.origin": o.get("origin") }), "axis.origin", cmd)?;
|
|
let dir = a.get("dir").and_then(vec3).and_then(|d| d.normalized()).ok_or_else(|| bad(cmd, "axis needs a non-zero `dir`"))?;
|
|
return Ok((origin.unwrap_or_else(|| solidcraft_doc::point_expr(Vec3::ZERO)), dir, None, None));
|
|
}
|
|
let (origin, dir, axis_ref, axis_feature) = axis_line(s, p, cmd)?;
|
|
Ok((solidcraft_doc::point_expr(origin), dir, axis_ref, axis_feature))
|
|
}
|
|
|
|
fn pattern_circ(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.pattern.circular";
|
|
let (features, bodies) = pattern_sources(s, p, cmd)?;
|
|
let (origin, axis, axis_ref, axis_feature) = pattern_axis(s, p, cmd)?;
|
|
let count = req_expr(cmd, p, "count")?;
|
|
check_count(s, &count, cmd, "count")?;
|
|
let angle = expr(p, "angle").unwrap_or_else(|| "360 deg".into());
|
|
check_expr(s, &angle, Kind::Angle, cmd, "angle")?;
|
|
let pattern = solidcraft_doc::PatternKind::Circular {
|
|
origin,
|
|
axis: Dir(axis),
|
|
count,
|
|
angle,
|
|
alignment: super::alignment_param(p, "alignment", cmd)?,
|
|
reversed: super::reversed_param(p, "reversed", cmd)?,
|
|
axis_ref,
|
|
axis_feature,
|
|
};
|
|
finish_pattern(s, p, features, pattern, bodies)
|
|
}
|
|
|
|
fn pattern_path(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.pattern.path";
|
|
let (features, bodies) = pattern_sources(s, p, cmd)?;
|
|
let path_sketch = sketch_id(s, p.get("path_sketch").or_else(|| p.get("sketch")), cmd, "path_sketch")?;
|
|
let path = string_list(cmd, p, "path")?;
|
|
if path.is_empty() || path.len() > 1000 {
|
|
return Err(bad(cmd, "`path` must list 1…1000 curve ids"));
|
|
}
|
|
let count = req_expr(cmd, p, "count")?;
|
|
check_count(s, &count, cmd, "count")?;
|
|
let (spacing, extent) = match (expr(p, "spacing"), expr(p, "distance")) {
|
|
(Some(x), _) => (x, false),
|
|
(None, Some(x)) => (x, true),
|
|
(None, None) => return Err(bad(cmd, "give `spacing` (between instances) or `distance` (first to last)")),
|
|
};
|
|
check_expr(s, &spacing, Kind::Length, cmd, "spacing")?;
|
|
let orient = match str_(p, "orientation") {
|
|
None | Some("identical") => false,
|
|
Some("path" | "path_direction" | "along_path") => true,
|
|
Some(o) => return Err(bad(cmd, format!("unknown orientation `{o}` (identical or path)"))),
|
|
};
|
|
let flip = bool_(p, "flip").unwrap_or(false);
|
|
let pattern = solidcraft_doc::PatternKind::Path { path_sketch: SketchId(path_sketch), path, count, spacing, extent, flip, orient };
|
|
finish_pattern(s, p, features, pattern, bodies)
|
|
}
|
|
|
|
fn mirror(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.mirror";
|
|
let bodies = string_list(cmd, p, "bodies")?;
|
|
let features = if bodies.is_empty() { source_features(s, p, cmd)? } else { Vec::new() };
|
|
let plane = plane_param(s, p.get("plane"), cmd)?;
|
|
let combine = bool_(p, "combine").unwrap_or(false);
|
|
let (bodies, placements) = placed_bodies(s, bodies, cmd)?;
|
|
let reply =
|
|
add_feature(s, p, FeatureKind::Mirror { features, plane, bodies: bodies.iter().cloned().map(BodyName).collect(), combine, placements })?;
|
|
if !combine {
|
|
super::print_face::copies_keep_print_faces(s, &reply, &bodies);
|
|
}
|
|
Ok(reply)
|
|
}
|
|
|
|
/// Bodies picked where the viewport shows them: each world name ("Body1", or "Body1 (Occ:2)"
|
|
/// for a further instance) becomes its component's body name, with the occurrence path of the
|
|
/// placement it was picked at (where the copy goes). Names stay as they are, and no placement is
|
|
/// kept, while every body is in the active component and every component in place, or when one
|
|
/// of them is not a body.
|
|
fn placed_bodies(s: &Session, names: Vec<String>, cmd: &str) -> Result<(Vec<String>, Vec<Vec<u64>>)> {
|
|
if names.is_empty() || s.doc.occurrences.is_empty() {
|
|
return Ok((names, Vec::new()));
|
|
}
|
|
let frames = s.doc.body_frames_with_source(&s.model.state());
|
|
let mut picked = Vec::with_capacity(names.len());
|
|
for name in &names {
|
|
let Some((_, own, component, path, _)) = frames.iter().find(|(world, ..)| world == name) else { return Ok((names, Vec::new())) };
|
|
picked.push((own.clone(), *component, path.clone()));
|
|
}
|
|
if !crate::frames::placed(s) && picked.iter().all(|(_, component, _)| *component == s.active_component) {
|
|
return Ok((names, Vec::new()));
|
|
}
|
|
if let Some((name, ..)) = picked.iter().find(|(_, _, path)| path.iter().any(|id| s.pending_moves.contains_key(id))) {
|
|
return Err(bad(cmd, format!("`{name}` has a position that is not captured yet: Capture Position (component.capture_position) first")));
|
|
}
|
|
Ok(picked.into_iter().map(|(own, _, path)| (own, path)).unzip())
|
|
}
|
|
|
|
/// The other name of an origin plane (`Top` for `XY`, `XY` for `Top`...), if `name` is one.
|
|
pub(super) fn origin_plane_alias(name: &str) -> Option<&'static str> {
|
|
match name.trim().to_ascii_uppercase().as_str() {
|
|
"XY" => Some("Top"),
|
|
"TOP" => Some("XY"),
|
|
"XZ" => Some("Front"),
|
|
"FRONT" => Some("XZ"),
|
|
"YZ" => Some("Right"),
|
|
"RIGHT" => Some("YZ"),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// A construction plane may not take an origin plane's name (`XY`, `Top`...): a plane
|
|
/// parameter could then mean either.
|
|
pub(super) fn check_plane_name(name: &str, cmd: &str) -> Result<()> {
|
|
match plane_name_problem(name) {
|
|
Some(why) => Err(bad(cmd, why)),
|
|
None => Ok(()),
|
|
}
|
|
}
|
|
|
|
/// What [`check_plane_name`] says about `name`, or `None` when a construction plane may take it.
|
|
pub(crate) fn plane_name_problem(name: &str) -> Option<String> {
|
|
solidcraft_geom::Plane::named(name.trim()).map(|_| {
|
|
format!("`{}` is reserved for an origin plane (XY, XZ, YZ, Top, Front, Right); give the construction plane another name", name.trim())
|
|
})
|
|
}
|
|
|
|
/// The forms [`plane_param`] takes, for its messages.
|
|
pub(crate) const PLANE_FORMS: &str =
|
|
"XY, XZ, YZ, a construction plane name or id, or {origin, normal} (origin coordinates may be length expressions)";
|
|
|
|
/// The plane an explicit plane object gives through `origin`, as [`plane_param`] reads it: from
|
|
/// `x_dir` and `y_dir` when both are points, else from `normal`; `None` when they don't make one.
|
|
pub(crate) fn explicit_plane(o: &Value, origin: Vec3) -> Option<solidcraft_geom::Plane> {
|
|
match (o.get("x_dir").and_then(vec3), o.get("y_dir").and_then(vec3), o.get("normal").and_then(vec3)) {
|
|
(Some(x), Some(y), _) => solidcraft_geom::Plane::new(origin, x, y),
|
|
(_, _, Some(n)) => solidcraft_geom::Plane::from_normal(origin, n),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// A plane reference from a parameter: an origin plane, a construction plane (by name or
|
|
/// feature id; kept by name, so the feature follows the plane when it changes), or an
|
|
/// explicit plane `{origin, x_dir, y_dir}` / `{origin, normal}`. Every command that takes a
|
|
/// plane reads it here.
|
|
pub(super) fn plane_param(s: &Session, v: Option<&Value>, cmd: &str) -> Result<solidcraft_doc::PlaneRef> {
|
|
use solidcraft_doc::PlaneRef;
|
|
const WANT: &str = PLANE_FORMS;
|
|
let construction = |r: &str| match s.doc.find_feature(r) {
|
|
Some(f) if matches!(f.kind, FeatureKind::ConstructionPlane { .. }) => Ok(PlaneRef::Construction { feature: f.id.into() }),
|
|
Some(f) => Err(bad(cmd, format!("`{}` is not a construction plane (a plane is {WANT})", f.name))),
|
|
None => Err(bad(cmd, format!("no plane `{r}` (a plane is {WANT})"))),
|
|
};
|
|
match v {
|
|
Some(Value::String(n)) if solidcraft_geom::Plane::named(n.trim()).is_some() => {
|
|
if let Some(f) = s.doc.find_feature(n.trim())
|
|
&& matches!(f.kind, FeatureKind::ConstructionPlane { .. })
|
|
{
|
|
return Err(bad(
|
|
cmd,
|
|
format!(
|
|
"plane `{}` is ambiguous: an origin-plane alias and a construction plane; use `{}` for the origin plane, construction plane feature id {}, or an explicit {{origin, normal}} plane",
|
|
n.trim(),
|
|
origin_plane_alias(n).unwrap_or("XY"),
|
|
f.id
|
|
),
|
|
));
|
|
}
|
|
Ok(PlaneRef::Origin { name: n.trim().to_ascii_uppercase() })
|
|
}
|
|
Some(Value::String(n)) => construction(n.trim()),
|
|
Some(Value::Number(id)) => match id.as_u64() {
|
|
Some(id) => construction(&id.to_string()),
|
|
None => Err(bad(cmd, format!("`plane` must be {WANT}"))),
|
|
},
|
|
Some(o @ Value::Object(_)) => {
|
|
// The origin's coordinates are numbers or length expressions; expressions are kept,
|
|
// so the plane follows its parameters.
|
|
let origin = match o.get("origin") {
|
|
None => point_expr(Vec3::ZERO),
|
|
Some(_) => point_param(s, o, "origin", cmd)?.unwrap_or_else(|| point_expr(Vec3::ZERO)),
|
|
};
|
|
let at = |e: &str| s.doc.eval(e, Kind::Length).unwrap_or(0.0);
|
|
let here = Vec3::new(at(&origin[0]), at(&origin[1]), at(&origin[2]));
|
|
let plane = explicit_plane(o, here).ok_or_else(|| bad(cmd, "plane needs x_dir and y_dir, or normal"))?;
|
|
if origin.iter().all(|e| solidcraft_doc::expr::is_literal(e)) {
|
|
return Ok(PlaneRef::Custom { plane });
|
|
}
|
|
Ok(PlaneRef::Placed { origin, x_dir: plane.x, y_dir: plane.y })
|
|
}
|
|
_ => Err(bad(cmd, format!("`plane` must be {WANT}"))),
|
|
}
|
|
}
|
|
|
|
fn plane_offset(s: &mut Session, p: &Value) -> Result<Value> {
|
|
use solidcraft_doc::PlaneRef;
|
|
let cmd = "construct.plane.offset";
|
|
// Through a point, or at a distance along the base's normal.
|
|
let through = match p.get("through").filter(|t| !t.is_null()) {
|
|
Some(_) if p.get("offset").is_some_and(|o| !o.is_null()) => return Err(bad(cmd, "give `offset` or `through`, not both")),
|
|
Some(t) => Some(super::construct::geo(s, Some(t), cmd, "through")?),
|
|
None => None,
|
|
};
|
|
let distance = match &through {
|
|
Some(_) => Default::default(),
|
|
None => {
|
|
let d = req_expr(cmd, p, "offset")?;
|
|
check_expr(s, &d, Kind::Length, cmd, "offset")?;
|
|
d
|
|
}
|
|
};
|
|
let offset = move |base: PlaneRef| match through {
|
|
Some(point) => PlaneRef::ThroughPoint { base: Box::new(base), point: Box::new(point) },
|
|
None => PlaneRef::Offset { base: Box::new(base), distance },
|
|
};
|
|
// A planar body face: attached exactly, as a sketch on that face is, so the plane follows it.
|
|
if let Some(face) = p.get("base").filter(|b| b.get("face").is_some()) {
|
|
let base = super::sketch::face::capture(s, face, cmd)?;
|
|
super::sketch::face::capture_positions(s, &base)?;
|
|
// The capture is already in the authoring frame.
|
|
return add_feature_in(s, p, FeatureKind::ConstructionPlane { plane: offset(base) }, false);
|
|
}
|
|
let base = plane_param(s, p.get("base"), cmd)?;
|
|
add_feature(s, p, FeatureKind::ConstructionPlane { plane: offset(base) })
|
|
}
|
|
|
|
fn plane_angle(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "construct.plane.at_angle";
|
|
// The plane follows an edge or face it is on; a construction axis is kept as it is now.
|
|
let (axis_origin, axis_dir, line, _) = axis_line(s, p, cmd)?;
|
|
let angle = req_expr(cmd, p, "angle")?;
|
|
check_expr(s, &angle, Kind::Angle, cmd, "angle")?;
|
|
let line = line.map(Box::new);
|
|
// A planar body face: attached exactly, as a sketch on that face is, so the plane follows it.
|
|
if let Some(face) = p.get("base").filter(|b| b.get("face").is_some()) {
|
|
let base = super::sketch::face::capture(s, face, cmd)?;
|
|
super::sketch::face::capture_positions(s, &base)?;
|
|
let plane = solidcraft_doc::PlaneRef::AtAngle { base: Box::new(base), axis_origin, axis_dir, angle, line };
|
|
// The capture is already in the authoring frame.
|
|
return add_feature_in(s, p, FeatureKind::ConstructionPlane { plane }, false);
|
|
}
|
|
let base = plane_param(s, p.get("base"), cmd)?;
|
|
let plane = solidcraft_doc::PlaneRef::AtAngle { base: Box::new(base), axis_origin, axis_dir, angle, line };
|
|
add_feature(s, p, FeatureKind::ConstructionPlane { plane })
|
|
}
|
|
|
|
fn split_face(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.split_face";
|
|
let faces = face_points(s, p, cmd)?;
|
|
let body = str_(p, "body").map(str::to_string);
|
|
let xy = || solidcraft_doc::PlaneRef::Origin { name: "XY".into() };
|
|
let kind = if let Some(t) = p.get("tool").filter(|t| !t.is_null()) {
|
|
let tb = t.get("body").and_then(Value::as_str).ok_or_else(|| bad(cmd, "`tool.body` must name a body"))?.to_string();
|
|
let point = t.get("point").and_then(crate::params::vec3).ok_or_else(|| bad(cmd, "`tool.point` must be [x, y, z] on the tool face"))?;
|
|
FeatureKind::SplitFace {
|
|
faces: faces.into_iter().map(FacePick).collect(),
|
|
body: body.map(BodyName),
|
|
plane: xy(),
|
|
tool: Some(solidcraft_doc::FaceAt { body: BodyName(tb), point: Position(point) }),
|
|
sketch: None,
|
|
}
|
|
} else if p.get("sketch").is_some_and(|v| !v.is_null()) {
|
|
let sketch = sketch_id(s, p.get("sketch"), cmd, "sketch")?;
|
|
FeatureKind::SplitFace {
|
|
faces: faces.into_iter().map(FacePick).collect(),
|
|
body: body.map(BodyName),
|
|
plane: xy(),
|
|
tool: None,
|
|
sketch: Some(SketchId(sketch)),
|
|
}
|
|
} else {
|
|
let plane = plane_param(s, p.get("plane"), cmd)?;
|
|
FeatureKind::SplitFace { faces: faces.into_iter().map(FacePick).collect(), body: body.map(BodyName), plane, tool: None, sketch: None }
|
|
};
|
|
add_feature(s, p, kind)
|
|
}
|
|
|
|
fn split_body(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.split_body";
|
|
let body = str_(p, "body").ok_or_else(|| bad(cmd, "`body` is required"))?.to_string();
|
|
if s.model.state().body(&body).is_none() {
|
|
return Err(bad(cmd, format!("no body `{body}`")));
|
|
}
|
|
// A straight sketch line as the tool: `sketch` and `line` (#1552).
|
|
if p.get("sketch").is_some_and(|v| !v.is_null()) || p.get("line").is_some_and(|v| !v.is_null()) {
|
|
let sketch = p.get("sketch").and_then(Value::as_u64).ok_or_else(|| bad(cmd, "`sketch` must be a sketch feature id"))?;
|
|
let line = str_(p, "line").ok_or_else(|| bad(cmd, "`line` must name a line of the sketch"))?.to_string();
|
|
let st = s.model.state();
|
|
if st.sketch(sketch).is_none() {
|
|
return Err(bad(cmd, format!("no sketch {sketch}")));
|
|
}
|
|
solidcraft_doc::sketch_line_plane(&st, sketch, &line).map_err(|e| bad(cmd, e.to_string()))?;
|
|
return add_feature(
|
|
s,
|
|
p,
|
|
FeatureKind::Split {
|
|
body: BodyName(body),
|
|
plane: solidcraft_doc::PlaneRef::Origin { name: "XY".into() },
|
|
tool: None,
|
|
sketch: Some(solidcraft_doc::SketchId(sketch)),
|
|
line: Some(line),
|
|
},
|
|
);
|
|
}
|
|
// A face as the tool: `tool: {body, point}` (its surface extended); else a plane.
|
|
if let Some(t) = p.get("tool").filter(|t| !t.is_null()) {
|
|
let tb = t.get("body").and_then(Value::as_str).ok_or_else(|| bad(cmd, "`tool.body` must name a body"))?.to_string();
|
|
let point = t.get("point").and_then(crate::params::vec3).ok_or_else(|| bad(cmd, "`tool.point` must be [x, y, z] on the tool face"))?;
|
|
let st = s.model.state();
|
|
let tbody = st.body(&tb).ok_or_else(|| bad(cmd, format!("no body `{tb}`")))?;
|
|
if solidcraft_doc::appearance::face_index_at(tbody, point).is_none() {
|
|
return Err(bad(cmd, "`tool.point` is not on a face of the tool body"));
|
|
}
|
|
return add_feature(
|
|
s,
|
|
p,
|
|
FeatureKind::Split {
|
|
body: BodyName(body),
|
|
plane: solidcraft_doc::PlaneRef::Origin { name: "XY".into() },
|
|
tool: Some(solidcraft_doc::FaceAt { body: BodyName(tb), point: Position(point) }),
|
|
sketch: None,
|
|
line: None,
|
|
},
|
|
);
|
|
}
|
|
let plane = plane_param(s, p.get("plane"), cmd)?;
|
|
add_feature(s, p, FeatureKind::Split { body: BodyName(body), plane, tool: None, sketch: None, line: None })
|
|
}
|
|
|
|
/// ISO 273 clearance hole diameters (close, normal, loose fit) for metric bolts.
|
|
fn clearance_diameter(size: &str, fit: &str) -> Option<f64> {
|
|
const TABLE: [(f64, f64, f64, f64); 21] = [
|
|
(1.6, 1.7, 1.8, 2.0),
|
|
(2.0, 2.2, 2.4, 2.6),
|
|
(2.5, 2.7, 2.9, 3.1),
|
|
(3.0, 3.2, 3.4, 3.6),
|
|
(4.0, 4.3, 4.5, 4.8),
|
|
(5.0, 5.3, 5.5, 5.8),
|
|
(6.0, 6.4, 6.6, 7.0),
|
|
(8.0, 8.4, 9.0, 10.0),
|
|
(10.0, 10.5, 11.0, 12.0),
|
|
(12.0, 13.0, 13.5, 14.5),
|
|
(14.0, 15.0, 15.5, 16.5),
|
|
(16.0, 17.0, 17.5, 18.5),
|
|
(20.0, 21.0, 22.0, 24.0),
|
|
(24.0, 25.0, 26.0, 28.0),
|
|
(30.0, 31.0, 33.0, 35.0),
|
|
(36.0, 37.0, 39.0, 42.0),
|
|
(42.0, 43.0, 45.0, 48.0),
|
|
(48.0, 50.0, 52.0, 56.0),
|
|
(56.0, 58.0, 62.0, 66.0),
|
|
(60.0, 62.0, 66.0, 70.0),
|
|
(64.0, 66.0, 70.0, 74.0),
|
|
];
|
|
let t = size.trim().trim_start_matches(['M', 'm']);
|
|
let d: f64 = t.split(['x', 'X']).next()?.trim().parse().ok()?;
|
|
let row = TABLE.iter().find(|r| (r.0 - d).abs() < 1e-9)?;
|
|
match fit {
|
|
"close" | "fine" => Some(row.1),
|
|
"normal" | "medium" => Some(row.2),
|
|
"loose" | "coarse" => Some(row.3),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// The refusal for a thread designation `parse_metric_thread` does not know. A plain `M<d>` with
|
|
/// a sane diameter but no ISO coarse pitch (M28, M7) gets two pitches to try: the largest common
|
|
/// pitch up to about an eighth of the diameter, and the next finer one.
|
|
fn unknown_metric_thread(t: &str, examples: &str) -> String {
|
|
fine_only_hint(t).unwrap_or_else(|| format!("unknown thread `{t}` (ISO metric, like {examples})"))
|
|
}
|
|
|
|
/// The pitches to try for a plain `M<d>` that has no ISO coarse pitch, `None` for anything else.
|
|
fn fine_only_hint(t: &str) -> Option<String> {
|
|
const PITCHES: [f64; 9] = [2.0, 1.5, 1.25, 1.0, 0.75, 0.5, 0.35, 0.25, 0.2];
|
|
let diameter = t.trim().strip_prefix(['M', 'm']).and_then(|d| d.trim().parse::<f64>().ok());
|
|
if let Some(d) = diameter.filter(|d| d.is_finite() && *d > 0.2 && *d <= 1e4) {
|
|
let first = PITCHES.iter().position(|p| *p <= 0.12 * d).unwrap_or(PITCHES.len() - 1);
|
|
let pitches: Vec<String> = PITCHES.iter().skip(first).take(2).filter(|p| **p < d).map(|p| format!("M{d}x{p}")).collect();
|
|
if !pitches.is_empty() {
|
|
return Some(format!("M{d} has no coarse ISO pitch: give one, e.g. {}", pitches.join(" or ")));
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
/// Largest nominal diameter automatic thread sizing knows (the last ISO coarse size).
|
|
const LARGEST_COARSE: f64 = 56.0;
|
|
|
|
/// The refusal for automatic sizing on a cylinder too big for the coarse table (a Ø75 shaft):
|
|
/// `None` when sizing finds a thread, or the cylinder is not past the table's end (the feature's
|
|
/// own error then explains). It suggests sizes with a pitch to type, scaled to the diameter.
|
|
fn beyond_coarse_range(st: &solidcraft_doc::ModelState, face: Vec3) -> Option<String> {
|
|
if solidcraft_doc::suggested_thread(st, face).is_ok() {
|
|
return None;
|
|
}
|
|
let cyl = st.bodies.iter().filter_map(|b| solidcraft_doc::kernel::cylinder_face_at(&b.body, face)).min_by(|a, b| {
|
|
let dist =
|
|
|c: &solidcraft_doc::kernel::CylinderFace| ((face - c.axis_point - c.axis * (face - c.axis_point).dot(c.axis)).len() - c.radius).abs();
|
|
dist(a).total_cmp(&dist(b))
|
|
})?;
|
|
let dia = cyl.radius * 2.0;
|
|
if !dia.is_finite() || dia <= LARGEST_COARSE * 0.9 || dia > 1e4 {
|
|
return None;
|
|
}
|
|
// ISO fine pitches for large sizes: the largest up to about a 25th of the diameter, then the
|
|
// next finer one. A hole's major diameter is about its bore plus one pitch.
|
|
const PITCHES: [f64; 4] = [4.0, 3.0, 2.0, 1.5];
|
|
let first = PITCHES.iter().position(|p| *p <= dia / 25.0 + 1e-6).unwrap_or(PITCHES.len() - 1);
|
|
let sizes: Vec<String> =
|
|
PITCHES.iter().skip(first).take(2).map(|p| format!("M{}x{p}", if cyl.internal { dia + p } else { dia }.round())).collect();
|
|
let kind = if cyl.internal { "hole" } else { "cylinder" };
|
|
Some(format!(
|
|
"a {dia:.2} mm {kind} is beyond the coarse thread range (up to M{LARGEST_COARSE}): type a size with its pitch, e.g. {}",
|
|
sizes.join(" or ")
|
|
))
|
|
}
|
|
|
|
fn hole(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.hole";
|
|
// At sketch points: the holes go perpendicular to the sketch and follow its points.
|
|
let points = match (p.get("sketch"), p.get("points"), p.get("position")) {
|
|
(Some(_), Some(_), _) | (Some(_), None, None) => {
|
|
let sketch = feature_sketch(s, p, cmd)?;
|
|
// No points named: every sketch point (standalone points and circle centres, not
|
|
// line or arc ends, not the origin).
|
|
let ids = if p.get("points").is_some() { string_list(cmd, p, "points")? } else { sketch_hole_points(s, sketch) };
|
|
if ids.is_empty() || ids.len() > 10_000 {
|
|
return Err(bad(cmd, "`points` must list 1…10000 sketch point ids"));
|
|
}
|
|
let st = s.model.state();
|
|
let ss = st.sketch(sketch).ok_or_else(|| bad(cmd, "the sketch is not evaluated"))?;
|
|
for id in &ids {
|
|
if !ss.sketch.points.iter().any(|q| &q.id == id) {
|
|
return Err(bad(cmd, format!("no point `{id}` in the sketch")));
|
|
}
|
|
}
|
|
let n = ss.plane.normal();
|
|
let first =
|
|
ids.first().and_then(|id| ss.sketch.points.iter().find(|q| &q.id == id)).map(|q| ss.plane.to_world(q.pos)).unwrap_or_default();
|
|
let flip = p.get("flip").and_then(Value::as_bool).unwrap_or(false);
|
|
// A Single hole at one sketch point (#2110): it follows the point, drilled into the
|
|
// face there rather than across the sketch.
|
|
let single = p.get("single").and_then(Value::as_bool).unwrap_or(false);
|
|
if single && (ids.len() != 1 || flip) {
|
|
return Err(bad(cmd, "a `single` hole takes one sketch point and no `flip`"));
|
|
}
|
|
Some((solidcraft_doc::SketchPoints { sketch: SketchId(sketch), ids, flip, single }, first, -n))
|
|
}
|
|
_ => None,
|
|
};
|
|
let thread = str_(p, "thread").map(|t| t.trim().to_string()).filter(|t| !t.is_empty());
|
|
let handedness = thread_handedness(p, cmd)?;
|
|
if thread.is_none() && !handedness.is_right() {
|
|
return Err(bad(cmd, "`handedness` needs `thread` (a tapped hole)"));
|
|
}
|
|
if let Some(t) = &thread
|
|
&& solidcraft_doc::parse_tapped_thread(t).is_none()
|
|
{
|
|
return Err(bad(
|
|
cmd,
|
|
fine_only_hint(t).unwrap_or_else(|| format!("unknown tapped thread `{t}` (ISO metric or a catalogued UNC/UNF, G or Rp size)")),
|
|
));
|
|
}
|
|
let thread_depth = match p.get("thread_depth") {
|
|
None | Some(Value::Null) => None,
|
|
Some(_) => Some(req_expr(cmd, p, "thread_depth")?),
|
|
};
|
|
if let Some(d) = &thread_depth {
|
|
if thread.is_none() {
|
|
return Err(bad(cmd, "`thread_depth` requires `thread` (a tapped hole)"));
|
|
}
|
|
let depth = s.doc.eval(d, Kind::Length).map_err(|e| bad(cmd, format!("`thread_depth`: {e}")))?;
|
|
if !depth.is_finite() || depth <= 0.0 {
|
|
return Err(bad(cmd, "`thread_depth` must be finite and positive"));
|
|
}
|
|
}
|
|
// A position given as length expressions (#1678), say `["leg_h*0.4", "width/2", "t"]`: kept,
|
|
// so the hole follows the parameters; drilled where they evaluate now.
|
|
let at: Option<solidcraft_doc::PointExpr> = match p.get("position").and_then(Value::as_array) {
|
|
Some(a) if points.is_none() && a.len() == 3 && a.iter().any(Value::is_string) => {
|
|
let mut coords = Vec::with_capacity(3);
|
|
for v in a {
|
|
let e = match v {
|
|
Value::String(x) => x.trim().to_string(),
|
|
Value::Number(n) => n.to_string(),
|
|
_ => return Err(bad(cmd, "`position` must be [x, y, z]: numbers or length expressions")),
|
|
};
|
|
check_expr(s, &e, Kind::Length, cmd, "position")?;
|
|
coords.push(solidcraft_doc::Expr::new(e));
|
|
}
|
|
let [x, y, z]: [solidcraft_doc::Expr; 3] = coords.try_into().map_err(|_| bad(cmd, "`position` must be [x, y, z]"))?;
|
|
Some([x, y, z])
|
|
}
|
|
_ => None,
|
|
};
|
|
let at_value = match &at {
|
|
Some([x, y, z]) => {
|
|
let c = |e: &solidcraft_doc::Expr| s.doc.eval(e, Kind::Length).map_err(|e| bad(cmd, format!("`position`: {e}")));
|
|
Some(Vec3::new(c(x)?, c(y)?, c(z)?)).filter(|v| v.is_finite())
|
|
}
|
|
None => None,
|
|
};
|
|
// Reference edges (#37): the centre sits at these distances from straight edges of its face.
|
|
let references = hole_reference_params(s, p, cmd)?;
|
|
if !references.is_empty() && (points.is_some() || at.is_some()) {
|
|
return Err(bad(cmd, "`references` place a hole by its `position` given as numbers, not at sketch points or length expressions"));
|
|
}
|
|
let position = match (&points, at_value.or_else(|| p.get("position").and_then(vec3))) {
|
|
(Some((_, first, _)), None) => *first,
|
|
(_, Some(x)) => x,
|
|
(None, None) => return Err(bad(cmd, "`position` must be [x, y, z], numbers or length expressions (or give `sketch` and `points`)")),
|
|
};
|
|
// A hole starts on a face: a point off every face (past a body's edge) would drill a hole
|
|
// nobody picked, and cutting across an edge that way is slow.
|
|
if points.is_none() && !super::face::on_a_face(s, position) {
|
|
return Err(bad(
|
|
cmd,
|
|
format!("`position` [{}, {}, {}] is not on a face of a body; pick a point on the face to drill", position.x, position.y, position.z),
|
|
));
|
|
}
|
|
let direction = match (p.get("direction").and_then(vec3), &points) {
|
|
(None, Some((sp, _, d))) if !sp.single => *d,
|
|
(d, _) => match d {
|
|
Some(d) => d.normalized().ok_or_else(|| bad(cmd, "`direction` must be non-zero"))?,
|
|
None => {
|
|
// Into the face the position lies on: against the outward normal of the face
|
|
// nearest it (planar or curved), as it faces out of its own body.
|
|
let st = s.model.state();
|
|
solidcraft_doc::hole_direction_at(&st, position).ok_or_else(|| bad(cmd, "no face at `position`; give `direction`"))?
|
|
}
|
|
},
|
|
};
|
|
// Placed by its reference edges: drilled where their distances put it, which `position`
|
|
// then keeps. The edges must be straight edges at the given points, and cross.
|
|
let position = if references.is_empty() { position } else { referenced_centre(s, cmd, &references, position, direction)? };
|
|
// The diameter: given, or a metric-estimate/Unified-table tap drill, or an ISO 273
|
|
// clearance hole for a bolt size (close, normal or loose fit).
|
|
let diameter = match (expr(p, "diameter"), &thread, str_(p, "clearance")) {
|
|
(Some(d), _, _) => d,
|
|
(None, _, Some(c)) => {
|
|
let fit = str_(p, "fit").unwrap_or("normal").to_ascii_lowercase();
|
|
let d = clearance_diameter(c, &fit).ok_or_else(|| bad(cmd, format!("no clearance hole for `{c}` ({fit} fit): M1.6 to M64")))?;
|
|
Expr::new(format!("{d} mm"))
|
|
}
|
|
(None, Some(t), None) => {
|
|
let size = solidcraft_doc::parse_tapped_thread(t).ok_or_else(|| bad(cmd, "thread"))?;
|
|
Expr::new(format!("{} mm", size.tap_drill))
|
|
}
|
|
(None, None, None) => return Err(bad(cmd, "needs `diameter`, `thread` (a tapped hole) or `clearance` (a bolt size)")),
|
|
};
|
|
check_expr(s, &diameter, Kind::Length, cmd, "diameter")?;
|
|
let depth = expr(p, "depth");
|
|
if let Some(d) = &depth {
|
|
check_expr(s, d, Kind::Length, cmd, "depth")?;
|
|
}
|
|
let get = |k: &str| -> Result<Expr> {
|
|
let e = req_expr(cmd, p, k)?;
|
|
Ok(e)
|
|
};
|
|
let kind = match str_(p, "type").unwrap_or("simple") {
|
|
"simple" => match expr(p, "tip_angle") {
|
|
Some(t) if depth.is_some() => solidcraft_doc::HoleKind::Drilled { tip_angle: t },
|
|
_ => solidcraft_doc::HoleKind::Simple,
|
|
},
|
|
"drilled" => solidcraft_doc::HoleKind::Drilled { tip_angle: expr(p, "tip_angle").unwrap_or_else(|| "118 deg".into()) },
|
|
"counterbore" => {
|
|
solidcraft_doc::HoleKind::Counterbore { cb_diameter: get("cb_diameter")?, cb_depth: get("cb_depth")?, tip_angle: expr(p, "tip_angle") }
|
|
}
|
|
"countersink" => solidcraft_doc::HoleKind::Countersink {
|
|
cs_diameter: get("cs_diameter")?,
|
|
cs_angle: expr(p, "cs_angle").unwrap_or_else(|| "90 deg".into()),
|
|
tip_angle: expr(p, "tip_angle"),
|
|
},
|
|
other => return Err(bad(cmd, format!("unknown hole type `{other}`"))),
|
|
};
|
|
let to = match p.get("to") {
|
|
Some(v) => Some(vec3(v).ok_or_else(|| bad(cmd, "`to` must be a point [x, y, z] on the face to drill to"))?),
|
|
None => None,
|
|
};
|
|
let mut p = p.clone();
|
|
let targets = string_list(cmd, &p, "targets")?;
|
|
if p.get("participants").is_none() {
|
|
// The bodies to drill, as `targets` (like an extrude's): its participants.
|
|
if !targets.is_empty() {
|
|
p["participants"] = json!(targets);
|
|
} else if let Some(body) = points.as_ref().filter(|(sp, _, _)| !sp.single).and_then(|(sp, _, _)| sketch_face_body(s, sp.sketch.0)) {
|
|
// Holes at the points of a sketch on a body's face drill that body (#2882): a body
|
|
// further along, past the face, doesn't take them. Stored, so recomputes and
|
|
// reopening keep the same scope.
|
|
p["participants"] = json!([body]);
|
|
} else if points.is_none()
|
|
&& let Some(body) = body_of_other_component_at(s, position)
|
|
{
|
|
// A hole picked on a body of another component (a moved one, shown where it is
|
|
// placed) cuts that body: the pick is already in that body's frame, and the
|
|
// component's own bodies alone would leave nothing to cut.
|
|
p["participants"] = json!([body]);
|
|
}
|
|
}
|
|
add_feature(
|
|
s,
|
|
&p,
|
|
FeatureKind::Hole {
|
|
position: FacePick(position),
|
|
at,
|
|
direction: Dir(direction),
|
|
diameter,
|
|
depth,
|
|
hole: kind,
|
|
points: points.map(|x| x.0),
|
|
thread,
|
|
thread_depth,
|
|
handedness,
|
|
to: to.map(FacePick),
|
|
references,
|
|
},
|
|
)
|
|
}
|
|
|
|
/// Where reference edges (#37) put a hole's (or a cylinder's) centre picked at `at` on a flat
|
|
/// face, `dir` into it: at their distances from the edges, which must be straight edges at the
|
|
/// given points, and cross.
|
|
fn referenced_centre(s: &Session, cmd: &str, references: &[solidcraft_doc::HoleReference], at: Vec3, dir: Vec3) -> Result<Vec3> {
|
|
let st = s.model.state();
|
|
let mut distances = Vec::with_capacity(references.len());
|
|
for r in references {
|
|
distances.push(s.doc.eval(&r.distance, Kind::Length).map_err(|e| bad(cmd, format!("`references`: {e}")))?);
|
|
}
|
|
let edges: Vec<(Vec3, Option<&str>)> = references.iter().map(|r| (r.edge.0, None)).collect();
|
|
let frame = solidcraft_doc::hole_reference::reference_frame(&st, at, dir, &edges, true).map_err(|e| bad(cmd, e.to_string()))?;
|
|
let centre = frame.place(at, &distances).map_err(|e| bad(cmd, e.to_string()))?;
|
|
if !solidcraft_doc::hole_reference::on_reference_face(&st, &frame, centre) {
|
|
let what = if cmd == "solid.cylinder" { "cylinder's base" } else { "hole's centre" };
|
|
return Err(bad(cmd, format!("the reference distances put the {what} off its face")));
|
|
}
|
|
Ok(centre)
|
|
}
|
|
|
|
/// A hole's reference edges (#37): `references: [{edge: [x, y, z], distance: expr}]`, at most
|
|
/// two, each distance a length.
|
|
fn hole_reference_params(s: &Session, p: &Value, cmd: &str) -> Result<Vec<solidcraft_doc::HoleReference>> {
|
|
let Some(v) = p.get("references") else { return Ok(Vec::new()) };
|
|
let list = v.as_array().ok_or_else(|| bad(cmd, "`references` must be a list of {edge: [x, y, z], distance}"))?;
|
|
let most = solidcraft_doc::hole_reference::MAX_HOLE_REFERENCES;
|
|
if list.len() > most {
|
|
return Err(bad(cmd, format!("a hole takes at most {most} `references`")));
|
|
}
|
|
let mut out = Vec::with_capacity(list.len());
|
|
for (i, r) in list.iter().enumerate() {
|
|
let edge = r
|
|
.get("edge")
|
|
.and_then(vec3)
|
|
.ok_or_else(|| bad(cmd, format!("`references[{i}].edge` must be a point [x, y, z] on a straight edge of the face")))?;
|
|
let distance = expr(r, "distance").ok_or_else(|| bad(cmd, format!("`references[{i}].distance` {}", expr_problem(r.get("distance")))))?;
|
|
check_expr(s, &distance, Kind::Length, cmd, "references")?;
|
|
out.push(solidcraft_doc::HoleReference { edge: Position(edge), distance });
|
|
}
|
|
Ok(out)
|
|
}
|
|
|
|
/// The body whose face is nearest `p` (within its pick tolerance), when it belongs to another
|
|
/// component than the active one.
|
|
fn body_of_other_component_at(s: &Session, p: Vec3) -> Option<String> {
|
|
let st = s.model.state();
|
|
let (_, body) = st
|
|
.bodies
|
|
.iter()
|
|
.filter(|b| !b.body.is_mesh())
|
|
.filter_map(|b| {
|
|
let (d, _) = solidcraft_doc::appearance::nearest_face(b, p)?;
|
|
(d <= solidcraft_doc::appearance::pick_tolerance(b)).then_some((d, b))
|
|
})
|
|
.min_by(|a, b| a.0.total_cmp(&b.0))?;
|
|
(s.doc.model_body_component(body) != s.active_component).then(|| body.name.clone())
|
|
}
|
|
|
|
/// The points of a sketch a hole drills at when only the sketch is given.
|
|
fn sketch_hole_points(s: &Session, sketch: u64) -> Vec<String> {
|
|
let st = s.model.state();
|
|
let Some(ss) = st.sketch(sketch) else { return Vec::new() };
|
|
let mut ends: Vec<usize> = Vec::new();
|
|
for c in &ss.sketch.curves {
|
|
match &c.kind {
|
|
solidcraft_sketch::CurveKind::Circle { .. } => {}
|
|
solidcraft_sketch::CurveKind::Arc { a, b, .. } | solidcraft_sketch::CurveKind::Line { a, b } => ends.extend([*a, *b]),
|
|
solidcraft_sketch::CurveKind::Ellipse { m, .. } => ends.push(*m),
|
|
solidcraft_sketch::CurveKind::Spline { pts, .. } => ends.extend(pts.iter().copied()),
|
|
solidcraft_sketch::CurveKind::Conic { a, b, apex, .. } => ends.extend([*a, *b, *apex]),
|
|
}
|
|
}
|
|
ss.sketch.points.iter().enumerate().filter(|(i, p)| p.id != "origin" && !ends.contains(i)).map(|(_, p)| p.id.clone()).collect()
|
|
}
|
|
|
|
fn face_points(s: &Session, p: &Value, cmd: &str) -> Result<Vec<Vec3>> {
|
|
let a = p.get("faces").and_then(Value::as_array).ok_or_else(|| bad(cmd, "`faces` must be a list of points or face names"))?;
|
|
if a.is_empty() || a.len() > 1000 {
|
|
return Err(bad(cmd, "select 1…1000 faces"));
|
|
}
|
|
a.iter().map(|v| super::face::face_ref(s, v, str_(p, "body"), cmd)).collect()
|
|
}
|
|
|
|
fn shell(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.shell";
|
|
let faces = face_points(s, p, cmd)?;
|
|
let thickness = req_expr(cmd, p, "thickness")?;
|
|
check_expr(s, &thickness, Kind::Length, cmd, "thickness")?;
|
|
let direction = str_(p, "direction").map(str::to_ascii_lowercase).unwrap_or_default();
|
|
if !matches!(direction.as_str(), "" | "inside" | "outside" | "both") {
|
|
return Err(bad(cmd, "`direction` must be inside, outside or both"));
|
|
}
|
|
add_feature(
|
|
s,
|
|
p,
|
|
FeatureKind::Shell {
|
|
faces: faces.into_iter().map(FacePick).collect(),
|
|
thickness,
|
|
body: str_(p, "body").map(BodyName::from),
|
|
direction: if direction == "inside" { String::new() } else { direction },
|
|
tangent_chain: bool_(p, "tangent_chain").unwrap_or(false),
|
|
},
|
|
)
|
|
}
|
|
|
|
fn draft(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.draft";
|
|
let faces = face_points(s, p, cmd)?;
|
|
let angle = req_expr(cmd, p, "angle")?;
|
|
check_expr(s, &angle, Kind::Angle, cmd, "angle")?;
|
|
let neutral = plane_param(s, p.get("neutral"), cmd)?;
|
|
let (vals, _) = s.doc.param_values();
|
|
let pl = s.doc.resolve_plane_in(&vals, &neutral, 0, Some(&s.model.state()))?;
|
|
let pull = p.get("pull").and_then(vec3).unwrap_or_else(|| pl.normal());
|
|
add_feature(
|
|
s,
|
|
p,
|
|
FeatureKind::Draft {
|
|
faces: faces.into_iter().map(FacePick).collect(),
|
|
angle,
|
|
neutral,
|
|
pull: Dir(pull),
|
|
body: str_(p, "body").map(BodyName::from),
|
|
},
|
|
)
|
|
}
|
|
|
|
pub(super) fn sketch_id(s: &Session, v: Option<&Value>, cmd: &str, what: &str) -> Result<u64> {
|
|
let key = sketch_key(v).ok_or_else(|| bad(cmd, format!("`{what}` must be a sketch id or name")))?;
|
|
match s.doc.find_feature(&key) {
|
|
Some(f) if matches!(f.kind, FeatureKind::Sketch { .. }) => Ok(f.id),
|
|
_ => Err(bad(cmd, format!("no sketch `{key}`"))),
|
|
}
|
|
}
|
|
|
|
/// The key [`sketch_id`] and [`feature_sketch`] look a sketch up by: an id (a number) or a name.
|
|
pub(crate) fn sketch_key(v: Option<&Value>) -> Option<String> {
|
|
match v {
|
|
Some(Value::Number(n)) => Some(n.to_string()),
|
|
Some(Value::String(x)) => Some(x.clone()),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn sweep(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.sweep";
|
|
let sketch = feature_sketch(s, p, cmd)?;
|
|
let path_sketch = sketch_id(s, p.get("path_sketch"), cmd, "path_sketch")?;
|
|
let path = string_list(cmd, p, "path")?;
|
|
if path.is_empty() {
|
|
return Err(bad(cmd, "`path` must list curve ids"));
|
|
}
|
|
let (orientation, twist, scale) = sweep_options(s, p, cmd)?;
|
|
let (rails, rail_fit) = sweep_rails(s, p, cmd, path_sketch)?;
|
|
let operation = operation(p, cmd)?;
|
|
let targets = face_join_targets(s, p, operation, &[sketch], cmd)?;
|
|
add_feature(
|
|
s,
|
|
p,
|
|
FeatureKind::Sweep {
|
|
sketch: SketchId(sketch),
|
|
profiles: profiles(p, cmd)?,
|
|
path_sketch: SketchId(path_sketch),
|
|
path,
|
|
orientation,
|
|
twist,
|
|
scale,
|
|
rails,
|
|
rail_fit,
|
|
operation,
|
|
targets,
|
|
},
|
|
)
|
|
}
|
|
|
|
/// A sweep's `orientation`, `twist` and `scale` (solid.sweep and surface.sweep), checked: an
|
|
/// orientation the sweep knows, a twist within four turns, an end scale within 0.01…100.
|
|
pub(super) fn sweep_options(s: &Session, p: &Value, cmd: &str) -> Result<(SweepOrientation, Option<Expr>, Option<Expr>)> {
|
|
let orientation = match p.get("orientation") {
|
|
None | Some(Value::Null) => SweepOrientation::Perpendicular,
|
|
Some(Value::String(o)) if o.eq_ignore_ascii_case("perpendicular") => SweepOrientation::Perpendicular,
|
|
Some(Value::String(o)) if o.eq_ignore_ascii_case("parallel") => SweepOrientation::Parallel,
|
|
Some(v) => {
|
|
let d = vec3(v)
|
|
.or_else(|| v.get("direction").and_then(vec3))
|
|
.ok_or_else(|| bad(cmd, "`orientation` must be perpendicular, parallel or a direction [x, y, z]"))?;
|
|
if !(d.len() > 1e-9) {
|
|
return Err(bad(cmd, "the `orientation` direction must not be zero"));
|
|
}
|
|
SweepOrientation::Direction(Dir(d))
|
|
}
|
|
};
|
|
let twist = match p.get("twist") {
|
|
None | Some(Value::Null) => None,
|
|
Some(_) => {
|
|
let t = expr(p, "twist").ok_or_else(|| bad(cmd, "`twist` must be an angle or an expression"))?;
|
|
let v = s.doc.eval(&t, Kind::Angle).map_err(|e| bad(cmd, format!("twist: {e}")))?;
|
|
if !(v.is_finite() && v.abs() <= solidcraft_kernel::SweepControl::MAX_TWIST) {
|
|
return Err(bad(cmd, "`twist` must be within four turns (1440 deg)"));
|
|
}
|
|
Some(t)
|
|
}
|
|
};
|
|
let scale = match p.get("scale") {
|
|
None | Some(Value::Null) => None,
|
|
Some(_) => {
|
|
let k = req_expr(cmd, p, "scale")?;
|
|
let v = s.doc.eval(&k, Kind::Unitless).map_err(|e| bad(cmd, format!("scale: {e}")))?;
|
|
let range = solidcraft_kernel::SweepControl::MIN_SCALE..=solidcraft_kernel::SweepControl::MAX_SCALE;
|
|
if !(v.is_finite() && range.contains(&v)) {
|
|
return Err(bad(cmd, "`scale` (the end scale) must be between 0.01 and 100"));
|
|
}
|
|
Some(k)
|
|
}
|
|
};
|
|
Ok((orientation, twist, scale))
|
|
}
|
|
|
|
/// A sweep's guide `rails` and `rail_fit` (solid.sweep and surface.sweep), checked: one or two
|
|
/// rails, each a sketch (default: the path's) and 1…1000 of its curves; a fit of scale or
|
|
/// stretch; and no orientation, twist or scale besides, since the rails set those.
|
|
pub(super) fn sweep_rails(s: &Session, p: &Value, cmd: &str, path_sketch: u64) -> Result<(Vec<SweepRail>, RailFit)> {
|
|
let (rails, rail_fit) = guide_rails(s, p, cmd, "sweep", Some(path_sketch))?;
|
|
if !rails.is_empty() {
|
|
for key in ["orientation", "twist", "scale"] {
|
|
if p.get(key).is_some_and(|v| !v.is_null()) {
|
|
return Err(bad(cmd, format!("guide rails set the profile's turn and size along the path: leave out `{key}`")));
|
|
}
|
|
}
|
|
}
|
|
Ok((rails, rail_fit))
|
|
}
|
|
|
|
/// A sweep's or a loft's (`what`) `rails` (one or two `{sketch?, curves}`, each rail's sketch
|
|
/// `default_sketch` when it names none) and `rail_fit` (scale | stretch).
|
|
pub(super) fn guide_rails(s: &Session, p: &Value, cmd: &str, what: &str, default_sketch: Option<u64>) -> Result<(Vec<SweepRail>, RailFit)> {
|
|
let rail_fit = match p.get("rail_fit") {
|
|
None | Some(Value::Null) => RailFit::Scale,
|
|
Some(Value::String(f)) if f.eq_ignore_ascii_case("scale") => RailFit::Scale,
|
|
Some(Value::String(f)) if f.eq_ignore_ascii_case("stretch") => RailFit::Stretch,
|
|
Some(_) => return Err(bad(cmd, "`rail_fit` must be scale or stretch")),
|
|
};
|
|
let given = match p.get("rails") {
|
|
None | Some(Value::Null) => return Ok((Vec::new(), rail_fit)),
|
|
Some(Value::Array(a)) => a,
|
|
Some(_) => return Err(bad(cmd, "`rails` must list one or two rails: [{sketch, curves: [ids]}]")),
|
|
};
|
|
if !(1..=2).contains(&given.len()) {
|
|
return Err(bad(cmd, format!("a {what} takes one or two guide rails")));
|
|
}
|
|
let mut rails = Vec::with_capacity(given.len());
|
|
for rail in given {
|
|
let sketch = match (rail.get("sketch").filter(|v| !v.is_null()), default_sketch) {
|
|
(None, Some(sketch)) => sketch,
|
|
(None, None) => return Err(bad(cmd, "each rail needs the `sketch` its curves are in")),
|
|
(Some(_), _) => sketch_id(s, rail.get("sketch"), cmd, "rails[].sketch")?,
|
|
};
|
|
let curves = string_list(cmd, rail, "curves")?;
|
|
if curves.is_empty() || curves.len() > 1000 {
|
|
return Err(bad(cmd, "each rail's `curves` must list 1…1000 curve ids in order"));
|
|
}
|
|
rails.push(SweepRail { sketch: SketchId(sketch), curves });
|
|
}
|
|
Ok((rails, rail_fit))
|
|
}
|
|
|
|
fn loft(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.loft";
|
|
let list = p.get("sections").and_then(Value::as_array).ok_or_else(|| bad(cmd, "`sections` must be a list"))?;
|
|
if list.len() < 2 || list.len() > 50 {
|
|
return Err(bad(cmd, "a loft needs 2…50 sections"));
|
|
}
|
|
let mut sections = Vec::new();
|
|
for sec in list {
|
|
let sketch = sketch_id(s, sec.get("sketch"), cmd, "sections[].sketch")?;
|
|
// A sketch point closes the loft to an apex.
|
|
if let Some(pt) = str_(sec, "point") {
|
|
let st = s.model.state();
|
|
if !st.sketch(sketch).is_some_and(|ss| ss.sketch.points.iter().any(|q| q.id == pt)) {
|
|
return Err(bad(cmd, format!("no point `{pt}` in the section's sketch")));
|
|
}
|
|
sections.push(solidcraft_doc::LoftSection {
|
|
sketch: SketchId(sketch),
|
|
profiles: solidcraft_doc::ProfileSel::All,
|
|
point: Some(pt.to_string()),
|
|
});
|
|
continue;
|
|
}
|
|
sections.push(solidcraft_doc::LoftSection { sketch: SketchId(sketch), profiles: profiles(sec, cmd)?, point: None });
|
|
}
|
|
let (rails, rail_fit) = guide_rails(s, p, cmd, "loft", None)?;
|
|
let operation = operation(p, cmd)?;
|
|
let sketches: Vec<u64> = sections.iter().map(|sec| sec.sketch.0).collect();
|
|
let mut targets = face_join_targets(s, p, operation, &sketches, cmd)?;
|
|
if operation == Operation::Join && string_list(cmd, p, "targets")?.is_empty() && string_list(cmd, p, "participants")?.is_empty() {
|
|
let st = s.model.state();
|
|
let candidates: Vec<_> = st
|
|
.bodies
|
|
.iter()
|
|
.filter(|b| if targets.is_empty() { s.doc.model_body_component(b) == s.active_component } else { targets.iter().any(|t| t.0 == b.name) })
|
|
.collect();
|
|
// Capture the visible subset now: showing a body later or reopening the design must
|
|
// not let an existing loft consume it (#1988). Keep the usual scope when none is hidden.
|
|
if candidates.iter().any(|b| !s.body_visible(&b.name)) {
|
|
targets = candidates.iter().filter(|b| s.body_visible(&b.name)).map(|b| BodyName(b.name.clone())).collect();
|
|
// Empty targets mean automatic scope, not "no bodies". Never fall back to that
|
|
// scope when every candidate is hidden; an explicit target can still choose one.
|
|
if targets.is_empty() {
|
|
return Err(bad(cmd, "no visible body to join; show a body, choose explicit targets, or use New Body"));
|
|
}
|
|
}
|
|
}
|
|
add_feature(s, p, FeatureKind::Loft { sections, operation, targets, rails, rail_fit })
|
|
}
|
|
|
|
fn thread_handedness(p: &Value, cmd: &str) -> Result<solidcraft_doc::ThreadHandedness> {
|
|
match p.get("handedness") {
|
|
None => Ok(solidcraft_doc::ThreadHandedness::Right),
|
|
Some(value) => serde_json::from_value(value.clone()).map_err(|_| bad(cmd, "`handedness` must be `right` or `left`")),
|
|
}
|
|
}
|
|
|
|
fn thread(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.thread";
|
|
let face = p
|
|
.get("face")
|
|
.and_then(|v| vec3(v).or_else(|| v.get("point").and_then(vec3)))
|
|
.ok_or_else(|| bad(cmd, "`face` must be a point [x, y, z] on a cylindrical face"))?;
|
|
let designation = str_(p, "designation").map(|t| t.trim().to_string()).filter(|t| !t.is_empty());
|
|
if let Some(t) = &designation
|
|
&& solidcraft_doc::parse_metric_thread(t).is_none()
|
|
{
|
|
return Err(bad(cmd, unknown_metric_thread(t, "M8 or M8x1")));
|
|
}
|
|
let length = expr(p, "length");
|
|
if let Some(l) = &length {
|
|
check_expr(s, l, Kind::Length, cmd, "length")?;
|
|
}
|
|
let modeled = p.get("modeled").and_then(Value::as_bool).unwrap_or(false);
|
|
if designation.is_none()
|
|
&& let Some(msg) = beyond_coarse_range(&s.model.state(), face)
|
|
{
|
|
return Err(bad(cmd, msg));
|
|
}
|
|
let handedness = thread_handedness(p, cmd)?;
|
|
let v = add_feature(s, p, FeatureKind::Thread { face: FacePick(face), designation, length, modeled, handedness })?;
|
|
let st = s.model.state();
|
|
let t = v.get("feature").and_then(Value::as_u64).and_then(|id| st.threads.iter().find(|t| t.feature == id).cloned());
|
|
Ok(json!({"feature": v.get("feature"), "name": v.get("name"), "thread": t}))
|
|
}
|
|
|
|
fn pipe(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.pipe";
|
|
let path_sketch = sketch_id(s, p.get("path_sketch"), cmd, "path_sketch")?;
|
|
let path = string_list(cmd, p, "path")?;
|
|
if path.is_empty() {
|
|
return Err(bad(cmd, "`path` must list curve ids"));
|
|
}
|
|
let diameter = req_expr(cmd, p, "diameter")?;
|
|
check_expr(s, &diameter, Kind::Length, cmd, "diameter")?;
|
|
let wall = expr(p, "wall");
|
|
if let Some(w) = &wall {
|
|
check_expr(s, w, Kind::Length, cmd, "wall")?;
|
|
}
|
|
add_feature(
|
|
s,
|
|
p,
|
|
FeatureKind::Pipe {
|
|
path_sketch: SketchId(path_sketch),
|
|
path,
|
|
diameter,
|
|
wall,
|
|
operation: operation(p, cmd)?,
|
|
targets: string_list(cmd, p, "targets")?.into_iter().map(BodyName).collect(),
|
|
},
|
|
)
|
|
}
|
|
|
|
fn bounding_solid(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.bounding_solid";
|
|
let margin = expr(p, "margin").unwrap_or_else(|| "0".into());
|
|
check_expr(s, &margin, Kind::Length, cmd, "margin")?;
|
|
add_feature(s, p, FeatureKind::BoundingSolid { bodies: string_list(cmd, p, "bodies")?.into_iter().map(BodyName).collect(), margin })
|
|
}
|
|
|
|
fn scale(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.scale";
|
|
let bodies = string_list(cmd, p, "bodies")?;
|
|
if bodies.is_empty() {
|
|
return Err(bad(cmd, "`bodies` must list bodies"));
|
|
}
|
|
let factors = match p.get("factors").and_then(Value::as_array) {
|
|
Some(a) if a.len() == 3 => {
|
|
let e: Vec<String> = a.iter().map(|v| v.as_str().map(str::to_string).unwrap_or_else(|| v.to_string())).collect();
|
|
for x in &e {
|
|
check_expr(s, x, Kind::Unitless, cmd, "factors")?;
|
|
}
|
|
Some([e[0].clone().into(), e[1].clone().into(), e[2].clone().into()])
|
|
}
|
|
Some(_) => return Err(bad(cmd, "`factors` must have three values")),
|
|
None => None,
|
|
};
|
|
let factor = match (&factors, expr(p, "factor")) {
|
|
(_, Some(f)) => f,
|
|
(Some(_), None) => "1".into(),
|
|
(None, None) => return Err(bad(cmd, "give `factor` or `factors`")),
|
|
};
|
|
check_expr(s, &factor, Kind::Unitless, cmd, "factor")?;
|
|
let origin = p.get("origin").and_then(vec3).unwrap_or(Vec3::ZERO);
|
|
add_feature(s, p, FeatureKind::Scale { bodies: bodies.into_iter().map(BodyName).collect(), origin: Position(origin), factor, factors })
|
|
}
|
|
|
|
fn delete_face(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let faces = face_points(s, p, "face.delete")?;
|
|
let heal = bool_(p, "heal").unwrap_or(true);
|
|
add_feature(s, p, FeatureKind::DeleteFace { faces: faces.into_iter().map(FacePick).collect(), body: str_(p, "body").map(BodyName::from), heal })
|
|
}
|
|
|
|
fn offset_face(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "solid.offset_face";
|
|
let faces = face_points(s, p, cmd)?;
|
|
let distance = req_expr(cmd, p, "distance")?;
|
|
check_expr(s, &distance, Kind::Length, cmd, "distance")?;
|
|
add_feature(
|
|
s,
|
|
p,
|
|
FeatureKind::OffsetFace { faces: faces.into_iter().map(FacePick).collect(), distance, body: str_(p, "body").map(BodyName::from) },
|
|
)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[path = "patterns_tests.rs"]
|
|
mod patterns_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "model_axis_tests.rs"]
|
|
mod model_axis_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "prism_local_tests.rs"]
|
|
mod prism_local_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "loft_rails_tests.rs"]
|
|
mod loft_rails_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "revolve_convention_tests.rs"]
|
|
mod revolve_convention_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "single_hole_tests.rs"]
|
|
mod single_hole_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "sweep_options_tests.rs"]
|
|
mod sweep_options_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "sweep_rails_tests.rs"]
|
|
mod sweep_rails_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "offset_topology_tests.rs"]
|
|
mod offset_topology_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "offset_identity_tests.rs"]
|
|
mod offset_identity_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "offset_edit_guard_tests.rs"]
|
|
mod offset_edit_guard_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "offset_ends_tests.rs"]
|
|
mod offset_ends_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "offset_plane_face_tests.rs"]
|
|
mod offset_plane_face_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "lineage_face_tests.rs"]
|
|
mod lineage_face_tests;
|
|
#[cfg(test)]
|
|
#[path = "stacked_face_tests.rs"]
|
|
mod stacked_face_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "solid_move_copy_tests.rs"]
|
|
mod solid_move_copy_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "move_in_sketch_tests.rs"]
|
|
mod move_in_sketch_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "thin_extrude_tests.rs"]
|
|
mod thin_extrude_tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "extrude_convention_tests.rs"]
|
|
mod extrude_convention_tests;
|
|
/// `solid.fillet corner?: rolling|g2`: the default keeps the rolling ball's sphere corner, `g2`
|
|
/// is accepted and refuses (item 10's patch is built but not sewn in yet, see `corner_g2`), and an
|
|
/// unknown word is refused.
|
|
#[cfg(test)]
|
|
#[allow(clippy::unwrap_used)]
|
|
mod corner_tests {
|
|
use serde_json::{Value, json};
|
|
|
|
use crate::Session;
|
|
|
|
fn run(s: &mut Session, id: &str, p: &Value) -> Value {
|
|
s.execute(id, p).unwrap_or_else(|e| panic!("{id}: {e}"))
|
|
}
|
|
|
|
/// A 20 mm box with its three edges at one corner, filleted by 4 with `corner`.
|
|
fn cornered(corner: Option<&str>) -> (Session, Value) {
|
|
let mut s = Session::default();
|
|
run(&mut s, "solid.box", &json!({"length": 20, "width": 20, "height": 20, "body_name": "B"}));
|
|
let mut p = json!({"edges": [[10, 0, 0], [0, 10, 0], [0, 0, 10]], "radius": 4});
|
|
if let Some(c) = corner {
|
|
p["corner"] = json!(c);
|
|
}
|
|
let reply = run(&mut s, "solid.fillet", &p);
|
|
(s, reply)
|
|
}
|
|
|
|
#[test]
|
|
fn the_default_corner_is_the_rolling_ball_and_g2_refuses_clearly() {
|
|
let (default, reply) = cornered(None);
|
|
assert_eq!(reply["warning"], json!(null), "{reply}");
|
|
let (rolling, _) = cornered(Some("rolling"));
|
|
let ball = default.world_state().body("B").unwrap().body.clone();
|
|
let same = rolling.world_state().body("B").unwrap().body.clone();
|
|
// `corner: rolling` is the default: the same body, to the last bit of its area.
|
|
assert_eq!(solidcraft_kernel::measure(&ball).unwrap().area, solidcraft_kernel::measure(&same).unwrap().area);
|
|
assert!(solidcraft_kernel::measure(&ball).unwrap().volume > 7000.0);
|
|
// `corner: g2`: accepted, and refused with a clear message until the patch sews in.
|
|
let mut s = Session::default();
|
|
run(&mut s, "solid.box", &json!({"length": 20, "width": 20, "height": 20, "body_name": "B"}));
|
|
let err =
|
|
s.execute("solid.fillet", &json!({"edges": [[10, 0, 0], [0, 10, 0], [0, 0, 10]], "radius": 4, "corner": "g2"})).unwrap_err().to_string();
|
|
eprintln!("corner g2: {err}");
|
|
assert!(err.contains("not supported yet:") && err.contains("G2 corner"), "{err}");
|
|
// An unknown word, and a style the G2 corner has no patch for, are refused as parameters.
|
|
assert!(s.execute("solid.fillet", &json!({"edges": [[10, 0, 0]], "radius": 4, "corner": "round"})).is_err());
|
|
assert!(s.execute("solid.fillet", &json!({"edges": [[10, 0, 0]], "radius": 4, "corner": "g2", "type": "chord"})).is_err());
|
|
assert!(s.execute("solid.fillet", &json!({"edges": [[10, 0, 0]], "radius": 4, "corner": "g2", "fit": "reduce"})).is_err());
|
|
}
|
|
}
|
|
#[cfg(test)]
|
|
#[path = "fillet_connected_rounds_tests.rs"]
|
|
mod fillet_connected_rounds_tests;
|