Que
fe07f79387
Hole centres from a sketch now drill into the material on whichever side of the sketch plane it lies: material the spot starts in wins, then the nearest body ahead, else against the sketch normal as before. A sketch on a part's underside or below it now drills up into the part. Covers counterbores, through-all, edge and corner centres, patterns and reopening.
325 lines
14 KiB
Rust
325 lines
14 KiB
Rust
//! A hole placed on a face follows that face along the hole's axis, never sideways: when the face
|
|
//! moves the hole moves with it, and when the face no longer reaches the place the hole stays
|
|
//! where it was put and says so instead of sliding to the face's nearest point.
|
|
|
|
use serde_json::{Value, json};
|
|
use solidcraft_geom::Vec3;
|
|
|
|
use crate::Session;
|
|
|
|
fn run(s: &mut Session, id: &str, p: Value) -> Value {
|
|
match s.execute(id, &p) {
|
|
Ok(v) => v,
|
|
Err(e) => panic!("{id} {p}: {e}"),
|
|
}
|
|
}
|
|
|
|
fn change(s: &mut Session, name: &str, expression: &str) {
|
|
run(s, "parameters.change", json!({"name": name, "expression": expression}));
|
|
}
|
|
|
|
fn volume(s: &mut Session) -> f64 {
|
|
run(s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap()
|
|
}
|
|
|
|
/// Whether the model holds material at (x, y, z).
|
|
fn solid_at(s: &Session, x: f64, y: f64, z: f64) -> bool {
|
|
s.model.state().bodies.iter().any(|b| b.body.contains(Vec3::new(x, y, z)))
|
|
}
|
|
|
|
/// What the hole feature says (its error and its warning); empty when it is silent.
|
|
fn said(s: &Session, feature: &str) -> String {
|
|
let id = s.doc.find_feature(feature).unwrap().id;
|
|
let r = s.model.result(id).unwrap();
|
|
format!("{}{}", r.error.clone().unwrap_or_default(), r.warning.clone().unwrap_or_default())
|
|
}
|
|
|
|
#[test]
|
|
fn a_hole_the_face_no_longer_reaches_stays_where_it_was_placed_and_says_so() {
|
|
let mut s = Session::default();
|
|
run(&mut s, "parameters.add", json!({"name": "length", "expression": "100 mm"}));
|
|
run(&mut s, "solid.box", json!({"length": "length", "width": 50, "height": 20, "name": "Plate"}));
|
|
run(&mut s, "solid.hole", json!({"position": [80, 25, 20], "diameter": "6 mm", "name": "Hole"}));
|
|
// The bore is at x = 80, 3 mm either way.
|
|
let drilled_at_80 = |s: &Session| !solid_at(s, 80.0, 25.0, 10.0) && solid_at(s, 76.0, 25.0, 10.0) && solid_at(s, 84.0, 25.0, 10.0);
|
|
assert!(drilled_at_80(&s));
|
|
// Longer: the place is still on the top face, and the hole stays at x = 80.
|
|
change(&mut s, "length", "150 mm");
|
|
assert_eq!(said(&s, "Hole"), "");
|
|
assert!(drilled_at_80(&s));
|
|
// Shorter than the place: nothing is drilled at the new end, and the hole says why. A hole
|
|
// moved to the face's nearest point would cut half a hole there (59 717 mm³ left).
|
|
change(&mut s, "length", "60 mm");
|
|
let left = volume(&mut s);
|
|
assert!((left - 60_000.0).abs() < 1.0, "half a hole was cut at the plate's end: {left} mm³ of 60000");
|
|
let msg = said(&s, "Hole");
|
|
assert!(msg.contains("no longer on face") && msg.contains("[80, 25, 20]"), "{msg}");
|
|
// Long again: the hole is back where it was put, with no message.
|
|
change(&mut s, "length", "100 mm");
|
|
assert_eq!(said(&s, "Hole"), "");
|
|
assert!(drilled_at_80(&s));
|
|
}
|
|
|
|
#[test]
|
|
fn a_slanted_hole_stays_on_its_axis_when_its_face_moves() {
|
|
let mut s = Session::default();
|
|
run(&mut s, "parameters.add", json!({"name": "height", "expression": "20 mm"}));
|
|
run(&mut s, "solid.box", json!({"length": 60, "width": 30, "height": "height", "name": "Block"}));
|
|
// Entering the top face at x = 20, running on in x as it goes down: 1 across for every 2 down.
|
|
run(&mut s, "solid.hole", json!({"position": [20, 15, 20], "direction": [1, 0, -2], "diameter": "2 mm", "name": "Hole"}));
|
|
// The axis is the line through the place along the direction, whatever the height of the block:
|
|
// x = 20 + (20 - z) / 2. At mid-height the bore is empty on it and solid 3 mm to either side
|
|
// (the bore is about 2.2 mm wide there).
|
|
let on_axis = |s: &Session, h: f64| {
|
|
let (x, z) = (20.0 + (20.0 - h / 2.0) / 2.0, h / 2.0);
|
|
assert!(!solid_at(s, x, 15.0, z), "block height {h}: the bore should pass through x = {x} at z = {z}");
|
|
assert!(solid_at(s, x - 3.0, 15.0, z) && solid_at(s, x + 3.0, 15.0, z), "block height {h}: material 3 mm beside the axis");
|
|
// (The kernel may note a boolean retry for a slanted bore; the hole's place is on its face.)
|
|
assert!(!said(s, "Hole").contains("no longer on face"), "block height {h}: {}", said(s, "Hole"));
|
|
};
|
|
on_axis(&s, 20.0);
|
|
// Taller: the top face moves up. Moved to the face's nearest point the hole would slide
|
|
// sideways onto another axis (5 mm further along x at mid-height); along its axis it enters
|
|
// higher up the same line.
|
|
change(&mut s, "height", "30 mm");
|
|
on_axis(&s, 30.0);
|
|
// Lower: the same line enters further along.
|
|
change(&mut s, "height", "12 mm");
|
|
on_axis(&s, 12.0);
|
|
}
|
|
|
|
// Hole centres on a sketch drill into the material whichever way the sketch plane faces. Base
|
|
// part: a 40 x 40 x 20 box at z 0..20 (32000 mm³).
|
|
|
|
fn box_part(s: &mut Session) {
|
|
run(s, "solid.box", json!({"length": 40, "width": 40, "height": 20, "name": "Part", "position": [20, 20, 0]}));
|
|
}
|
|
|
|
/// A sketch named `Pts` on the XY plane lifted to `z`, holding the given points (ids p0, p1, ...).
|
|
fn points_sketch(s: &mut Session, z: f64, at: &[[f64; 2]]) -> Vec<String> {
|
|
let plane = if z == 0.0 { json!("XY") } else { json!({"origin": [0, 0, z], "x_dir": [1, 0, 0], "y_dir": [0, 1, 0]}) };
|
|
run(s, "sketch.create", json!({"plane": plane, "name": "Pts"}));
|
|
let ids: Vec<String> = (0..at.len()).map(|i| format!("pt{z}_{i}").replace(['-', '.'], "m")).collect();
|
|
for (id, p) in ids.iter().zip(at) {
|
|
run(s, "sketch.point", json!({"point": p, "id": id}));
|
|
}
|
|
run(s, "sketch.finish", json!({}));
|
|
ids
|
|
}
|
|
|
|
fn drill(s: &mut Session, ids: &[String], extra: Value) {
|
|
let mut p = json!({"sketch": "Pts", "points": ids, "diameter": 10, "name": "H"});
|
|
if let (Some(m), Some(e)) = (p.as_object_mut(), extra.as_object()) {
|
|
m.extend(e.clone());
|
|
}
|
|
run(s, "solid.hole", p);
|
|
}
|
|
|
|
fn removed(s: &mut Session) -> f64 {
|
|
32_000.0 - volume(s)
|
|
}
|
|
|
|
fn near(a: f64, b: f64) {
|
|
assert!((a - b).abs() < 1.0, "{a} vs {b}");
|
|
}
|
|
|
|
const CB: fn() -> Value = || json!({"type": "counterbore", "diameter": 6, "cb_diameter": 12, "cb_depth": 3, "depth": 10});
|
|
|
|
#[test]
|
|
fn sketch_under_the_part_drills_up_into_it() {
|
|
let mut s = Session::default();
|
|
box_part(&mut s);
|
|
let ids = points_sketch(&mut s, 0.0, &[[20.0, 20.0]]);
|
|
drill(&mut s, &ids, json!({"depth": 8}));
|
|
near(removed(&mut s), 628.3);
|
|
assert!(!solid_at(&s, 20.0, 20.0, 4.0) && solid_at(&s, 20.0, 20.0, 10.0));
|
|
}
|
|
|
|
#[test]
|
|
fn sketch_under_the_part_counterbore_and_four_points() {
|
|
let one = std::f64::consts::PI * 36.0 * 3.0 + std::f64::consts::PI * 9.0 * 7.0;
|
|
let mut s = Session::default();
|
|
box_part(&mut s);
|
|
let ids = points_sketch(&mut s, 0.0, &[[20.0, 20.0]]);
|
|
drill(&mut s, &ids, CB());
|
|
near(removed(&mut s), one);
|
|
near(one, 537.2);
|
|
let mut s = Session::default();
|
|
box_part(&mut s);
|
|
let ids = points_sketch(&mut s, 0.0, &[[10.0, 10.0], [30.0, 10.0], [10.0, 30.0], [30.0, 30.0]]);
|
|
drill(&mut s, &ids, CB());
|
|
near(removed(&mut s), 4.0 * one);
|
|
}
|
|
|
|
#[test]
|
|
fn sketch_under_the_part_through_all() {
|
|
let mut s = Session::default();
|
|
box_part(&mut s);
|
|
let ids = points_sketch(&mut s, 0.0, &[[20.0, 20.0]]);
|
|
drill(&mut s, &ids, json!({}));
|
|
near(removed(&mut s), 1570.8);
|
|
assert!(!solid_at(&s, 20.0, 20.0, 19.0));
|
|
}
|
|
|
|
#[test]
|
|
fn sketch_in_the_air_below_the_part() {
|
|
let mut s = Session::default();
|
|
box_part(&mut s);
|
|
let ids = points_sketch(&mut s, -10.0, &[[20.0, 20.0]]);
|
|
drill(&mut s, &ids, json!({"depth": 8}));
|
|
near(removed(&mut s), 628.3);
|
|
}
|
|
|
|
#[test]
|
|
fn sketch_on_top_face_height_is_unchanged() {
|
|
let one = std::f64::consts::PI * 36.0 * 3.0 + std::f64::consts::PI * 9.0 * 7.0;
|
|
let mut s = Session::default();
|
|
box_part(&mut s);
|
|
let ids = points_sketch(&mut s, 20.0, &[[20.0, 20.0]]);
|
|
drill(&mut s, &ids, json!({"depth": 8}));
|
|
near(removed(&mut s), 628.3);
|
|
assert!(!solid_at(&s, 20.0, 20.0, 16.0) && solid_at(&s, 20.0, 20.0, 10.0));
|
|
let mut s = Session::default();
|
|
box_part(&mut s);
|
|
let ids = points_sketch(&mut s, 20.0, &[[10.0, 10.0], [30.0, 10.0], [10.0, 30.0], [30.0, 30.0]]);
|
|
drill(&mut s, &ids, CB());
|
|
near(removed(&mut s), 4.0 * one);
|
|
let mut s = Session::default();
|
|
box_part(&mut s);
|
|
let ids = points_sketch(&mut s, 20.0, &[[20.0, 20.0]]);
|
|
drill(&mut s, &ids, json!({}));
|
|
near(removed(&mut s), 1570.8);
|
|
}
|
|
|
|
#[test]
|
|
fn sketch_inside_the_body_still_drills_down() {
|
|
let mut s = Session::default();
|
|
box_part(&mut s);
|
|
let ids = points_sketch(&mut s, 10.0, &[[20.0, 20.0]]);
|
|
drill(&mut s, &ids, json!({"depth": 8}));
|
|
near(removed(&mut s), 628.3);
|
|
// As before: the spot moves back up to the top face and drills down from there (z 12..20).
|
|
assert!(!solid_at(&s, 20.0, 20.0, 16.0) && solid_at(&s, 20.0, 20.0, 6.0));
|
|
}
|
|
|
|
// A center exactly on an edge or a corner of the part: half or a quarter of the hole is in the
|
|
// material, and the side is chosen the same way as for a center well inside the face.
|
|
|
|
#[test]
|
|
fn center_on_an_edge_drills_half_a_hole_from_either_side() {
|
|
let half = std::f64::consts::PI * 25.0 * 8.0 / 2.0;
|
|
near(half, 314.2);
|
|
for (z, cut, kept) in [(20.0, 16.0, 6.0), (0.0, 4.0, 14.0)] {
|
|
let mut s = Session::default();
|
|
box_part(&mut s);
|
|
let ids = points_sketch(&mut s, z, &[[0.0, 20.0]]);
|
|
drill(&mut s, &ids, json!({"depth": 8}));
|
|
near(removed(&mut s), half);
|
|
assert!(!solid_at(&s, 2.0, 20.0, cut) && solid_at(&s, 2.0, 20.0, kept), "sketch at z {z}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn center_on_a_corner_drills_a_quarter_of_a_hole_from_either_side() {
|
|
let quarter = std::f64::consts::PI * 25.0 * 8.0 / 4.0;
|
|
near(quarter, 157.1);
|
|
for (z, cut, kept) in [(20.0, 16.0, 6.0), (0.0, 4.0, 14.0)] {
|
|
let mut s = Session::default();
|
|
box_part(&mut s);
|
|
let ids = points_sketch(&mut s, z, &[[0.0, 0.0]]);
|
|
drill(&mut s, &ids, json!({"depth": 8}));
|
|
near(removed(&mut s), quarter);
|
|
assert!(!solid_at(&s, 2.0, 2.0, cut) && solid_at(&s, 2.0, 2.0, kept), "sketch at z {z}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pattern_of_a_flipped_hole_and_round_trip() {
|
|
let mut s = Session::default();
|
|
box_part(&mut s);
|
|
let ids = points_sketch(&mut s, 0.0, &[[8.0, 8.0]]);
|
|
drill(&mut s, &ids, json!({"depth": 8}));
|
|
near(removed(&mut s), 628.3);
|
|
run(&mut s, "solid.pattern.rectangular", json!({"features": ["H"], "dir1": [1, 0, 0], "count1": 3, "spacing1": 12, "name": "Row"}));
|
|
near(removed(&mut s), 3.0 * 628.3);
|
|
let before = volume(&mut s);
|
|
let doc = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
|
|
let mut again = Session::new(doc);
|
|
near(volume(&mut again), before);
|
|
}
|
|
|
|
// Two plates of the box, joined by a wall, with an air gap between them: the sketch plane sits on
|
|
// the face of one plate and the holes go into that plate, not across the gap into the other one.
|
|
|
|
/// The 40 x 40 x 20 box with a slot cut through it from z = `lo` to `hi` (a wall stays at x < 5).
|
|
fn slotted_part(s: &mut Session, lo: f64, hi: f64) {
|
|
run(s, "solid.box", json!({"length": 40, "width": 40, "height": 20}));
|
|
run(s, "sketch.create", json!({"plane": "XY", "offset": format!("{lo} mm"), "name": "Slot"}));
|
|
run(s, "sketch.rectangle.two_point", json!({"p0": [5, -1], "p1": [45, 41]}));
|
|
run(s, "sketch.finish", json!({}));
|
|
run(s, "solid.extrude", json!({"sketch": "Slot", "distance": format!("{} mm", hi - lo), "operation": "cut", "direction": "positive"}));
|
|
}
|
|
|
|
/// A sketch `Pts` at z = `z` with its normal pointing down (-z), holding one point over (20, 20).
|
|
fn down_facing_point(s: &mut Session, z: f64) {
|
|
let plane = json!({"origin": [0, 0, z], "x_dir": [1, 0, 0], "y_dir": [0, -1, 0]});
|
|
run(s, "sketch.create", json!({"plane": plane, "name": "Pts"}));
|
|
run(s, "sketch.point", json!({"point": [20, -20], "id": "p1"}));
|
|
run(s, "sketch.finish", json!({}));
|
|
}
|
|
|
|
fn pi() -> f64 {
|
|
std::f64::consts::PI
|
|
}
|
|
|
|
#[test]
|
|
fn plates_sketch_normal_into_the_gap_drills_the_plate_it_touches() {
|
|
let mut s = Session::default();
|
|
slotted_part(&mut s, 6.0, 14.0);
|
|
let base = volume(&mut s);
|
|
down_facing_point(&mut s, 6.0);
|
|
let cb = json!({"type": "counterbore", "diameter": 4, "cb_diameter": 10, "cb_depth": 2, "depth": 9});
|
|
drill(&mut s, &["p1".to_string()], cb);
|
|
near(base - volume(&mut s), pi() * 25.0 * 2.0 + pi() * 4.0 * 4.0);
|
|
assert!(!solid_at(&s, 20.0, 20.0, 5.0) && !solid_at(&s, 20.0, 20.0, 1.0) && solid_at(&s, 20.0, 20.0, 16.0));
|
|
}
|
|
|
|
#[test]
|
|
fn plates_sketch_normal_away_from_the_gap_drills_the_plate_it_touches() {
|
|
let mut s = Session::default();
|
|
slotted_part(&mut s, 8.0, 14.0);
|
|
let base = volume(&mut s);
|
|
run(&mut s, "sketch.create", json!({"plane": {"origin": [0, 0, 14], "x_dir": [1, 0, 0], "y_dir": [0, 1, 0]}, "name": "Pts"}));
|
|
run(&mut s, "sketch.point", json!({"point": [20, 20], "id": "p1"}));
|
|
run(&mut s, "sketch.finish", json!({}));
|
|
drill(&mut s, &["p1".to_string()], json!({"depth": 7}));
|
|
near(base - volume(&mut s), pi() * 25.0 * 6.0);
|
|
assert!(!solid_at(&s, 20.0, 20.0, 17.0) && solid_at(&s, 20.0, 20.0, 4.0));
|
|
}
|
|
|
|
#[test]
|
|
fn two_separate_bodies_sketch_touching_one_drills_it_not_the_far_one() {
|
|
let mut s = Session::default();
|
|
run(&mut s, "solid.box", json!({"length": 40, "width": 40, "height": 6, "name": "Low"}));
|
|
run(&mut s, "solid.box", json!({"length": 40, "width": 40, "height": 6, "corner": [0, 0, 14], "name": "High"}));
|
|
let base = volume(&mut s);
|
|
near(base, 2.0 * 40.0 * 40.0 * 6.0);
|
|
down_facing_point(&mut s, 6.0);
|
|
drill(&mut s, &["p1".to_string()], json!({"depth": 9}));
|
|
near(base - volume(&mut s), pi() * 25.0 * 6.0);
|
|
assert!(!solid_at(&s, 20.0, 20.0, 3.0) && !solid_at(&s, 20.0, 20.0, 5.9));
|
|
assert!(solid_at(&s, 20.0, 20.0, 15.0) && solid_at(&s, 20.0, 20.0, 19.0));
|
|
}
|
|
|
|
#[test]
|
|
fn sketch_floating_in_the_gap_touching_neither_still_drills_down() {
|
|
let mut s = Session::default();
|
|
slotted_part(&mut s, 6.0, 14.0);
|
|
let base = volume(&mut s);
|
|
// Normal +z (the default direction), material ahead on both sides, touching neither.
|
|
points_sketch(&mut s, 10.0, &[[20.0, 20.0]]);
|
|
drill(&mut s, &["pt10_0".to_string()], json!({"depth": 4}));
|
|
near(base - volume(&mut s), pi() * 25.0 * 4.0);
|
|
assert!(!solid_at(&s, 20.0, 20.0, 4.0) && solid_at(&s, 20.0, 20.0, 16.0));
|
|
}
|