//! `snapshot --body`, `--tool` and `--section`: a picture of a tool body inside the material it //! meets, which is the one picture that says whether a cut reaches through. //! //! Each option is a shortcut for the command the app itself runs (`appearance.assign`, //! `inspect.section`), so every test here asserts that the option's picture is the picture of a //! script that runs those commands — not that the pixels match a stored image. Pictures are //! compared with a tolerance, and the tests run on whatever renderer the machine has (a GPU, a //! software adapter, or the CPU rasterizer), because they only ever compare two pictures this //! same CLI drew. use std::path::{Path, PathBuf}; use std::process::{Command, Output}; use std::sync::atomic::{AtomicUsize, Ordering}; use serde_json::{Value, json}; static NEXT: AtomicUsize = AtomicUsize::new(0); const SIZE: (u32, u32) = (200, 140); /// A PNG's size and RGBA pixels. fn decode(png: &[u8]) -> (u32, u32, Vec) { let img = image::load_from_memory_with_format(png, image::ImageFormat::Png).unwrap().to_rgba8(); (img.width(), img.height(), img.into_raw()) } /// Pixels of two same-sized pictures that differ by more than a little in some channel. fn differing(a: &[u8], b: &[u8]) -> usize { let ((wa, ha, a), (wb, hb, b)) = (decode(a), decode(b)); assert_eq!((wa, ha), (wb, hb), "pictures of different sizes"); a.as_chunks::<4>().0.iter().zip(b.as_chunks::<4>().0).filter(|(p, q)| p.iter().zip(q.iter()).any(|(x, y)| x.abs_diff(*y) > 16)).count() } /// The same picture: a renderer's output may differ by a few levels or a stray edge pixel. #[track_caller] fn assert_same(a: &[u8], b: &[u8], what: &str) { let (n, total) = (differing(a, b), (SIZE.0 * SIZE.1) as usize); assert!(n * 500 <= total, "{what}: {n} of {total} pixels differ"); } /// Different pictures: more than stray pixels differ. #[track_caller] fn assert_differs(a: &[u8], b: &[u8], what: &str) { let n = differing(a, b); assert!(n >= 100, "{what}: only {n} pixels differ"); } /// How much of a picture is the tool colour (`preview::TOOL_COLOR`, #e8542c): a red neither /// the default body grey nor the background has, still recognisable once a see-through body in /// front of it has tinted it (measured on this machine: (200, 108, 85) through a target at /// opacity 0.3, against (164, 173, 184) for the plain grey). fn tool_pixels(png: &[u8]) -> usize { let (_, _, px) = decode(png); px.as_chunks::<4>().0.iter().filter(|p| p[0] > 140 && p[0] > p[1].saturating_add(50) && p[0] > p[2].saturating_add(50)).count() } struct Scratch(PathBuf); impl Scratch { fn new() -> Self { let dir = std::env::temp_dir().join(format!("solidcraft-snapshot-appearance-{}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed))); std::fs::create_dir(&dir).unwrap(); Self(dir) } /// A plate with a pin standing in it: the tool body a cut would remove, reaching 6 mm short /// of the far face, which is exactly what a picture is supposed to show and a volume is not. /// `more` runs on top. fn script(&self, name: &str, more: &[Value]) -> PathBuf { let mut steps = vec![ json!({"command": "solid.box", "params": {"length": 50, "width": 34, "height": 20, "center": [0, 0, 10], "body_name": "Target"}}), json!({"command": "solid.cylinder", "params": {"diameter": 12, "height": 14, "base": [0, 0, 0], "operation": "new_body", "body_name": "Tool"}}), ]; steps.extend(more.iter().cloned()); let path = self.0.join(name); std::fs::write(&path, json!({"commands": steps}).to_string()).unwrap(); path } fn run(&self, script: &Path, out: &str, extra: &[&str]) -> Output { let (w, h) = (SIZE.0.to_string(), SIZE.1.to_string()); Command::new(env!("CARGO_BIN_EXE_solidcraft-cli")) .arg("snapshot") .arg(script) .arg("--out") .arg(self.0.join(out)) .args(["--width", &w, "--height", &h, "--no-grid", "--no-axes"]) .args(extra) .output() .unwrap() } /// The PNG `snapshot` writes. fn snapshot(&self, script: &Path, out: &str, extra: &[&str]) -> Vec { let output = self.run(script, out, extra); assert!(output.status.success(), "{extra:?}: {}", String::from_utf8_lossy(&output.stderr)); let png = std::fs::read(self.0.join(out)).unwrap(); assert!(png.starts_with(b"\x89PNG"), "{extra:?}"); png } } impl Drop for Scratch { fn drop(&mut self) { let _ = std::fs::remove_dir_all(&self.0); } } /// `--body NAME:opacity=…` draws that body see-through, and the picture is the one a script /// gets by assigning the same appearance itself: the option is the command, not a second way /// of drawing. #[test] fn a_body_drawn_see_through_is_the_picture_of_the_same_appearance_assigned() { let dir = Scratch::new(); let plain = dir.script("plain.json", &[]); let assigned = dir.script("assigned.json", &[json!({"command": "appearance.assign", "params": {"bodies": ["Target"], "color": "#b0bac6", "opacity": 0.3}})]); let solid = dir.snapshot(&plain, "solid.png", &[]); let see_through = dir.snapshot(&plain, "see-through.png", &["--body", "Target:opacity=0.3"]); assert_differs(&see_through, &solid, "--body opacity was ignored"); assert_same(&see_through, &dir.snapshot(&assigned, "by-script.png", &[]), "the same appearance assigned by a script"); // The option's colour is the design's too. It names the target, not the tool: the tool is // inside the target, so a solid target hides whatever colour the tool is given. let painted = dir.script("painted.json", &[json!({"command": "appearance.assign", "params": {"bodies": ["Target"], "color": "#00aa33", "opacity": 1.0}})]); let by_option = dir.snapshot(&plain, "painted.png", &["--body", "Target:color=#00aa33"]); assert_differs(&by_option, &solid, "--body color was ignored"); assert_same(&by_option, &dir.snapshot(&painted, "painted-script.png", &[]), "the same colour assigned by a script"); } /// `--tool NAME` is the whole point: the tool solid in the tool colour, every other body /// see-through, so the tool shows inside the material it meets. The tool's colour covers more /// of the picture than it does without the option, because the target no longer hides it. #[test] fn a_tool_shows_through_the_bodies_around_it() { let dir = Scratch::new(); let script = dir.script("part.json", &[]); let plain = dir.snapshot(&script, "plain.png", &["--view", "front"]); let preview = dir.snapshot(&script, "preview.png", &["--view", "front", "--tool", "Tool"]); assert_differs(&preview, &plain, "--tool was ignored"); // Seen from the front the plate hides the pin completely; the preview shows all of it. assert_eq!(tool_pixels(&plain), 0, "nothing is the tool colour before the option"); assert!(tool_pixels(&preview) > 200, "the tool shows through the target: {} pixels", tool_pixels(&preview)); // It is the two commands it stands for, run in that order. let by_script = dir.script( "by-script.json", &[ json!({"command": "appearance.assign", "params": {"bodies": ["Target"], "color": "#b0bac6", "opacity": 0.3}}), json!({"command": "appearance.assign", "params": {"bodies": ["Tool"], "color": "#e8542c", "opacity": 1.0}}), ], ); assert_same(&preview, &dir.snapshot(&by_script, "script.png", &["--view", "front"]), "the appearances --tool assigns"); // A later --body overrides what --tool said. let overridden = dir.snapshot(&script, "override.png", &["--view", "front", "--tool", "Tool", "--body", "Tool:color=#2255cc"]); assert!(tool_pixels(&overridden) < 50, "--body after --tool decides the tool's colour"); } /// `--section` cuts the model where `inspect.section` would, and the same spec written as the /// command's own JSON, or as the command in a script, gives the same picture. #[test] fn a_section_cuts_the_model_as_inspect_section_does() { let dir = Scratch::new(); let script = dir.script("part.json", &[]); let whole = dir.snapshot(&script, "whole.png", &[]); let cut = dir.snapshot(&script, "cut.png", &["--section", "z=12"]); assert_differs(&cut, &whole, "--section was ignored"); assert_same(&cut, &dir.snapshot(&script, "cut-json.png", &["--section", r#"{"plane": "XY", "at": 12}"#]), "the command's own JSON"); let by_script = dir.script("sectioned.json", &[json!({"command": "inspect.section", "params": {"plane": "XY", "at": 12}})]); assert_same(&cut, &dir.snapshot(&by_script, "by-script.png", &[]), "inspect.section in a script"); // The other side of the same plane is a different picture. let flipped = dir.snapshot(&script, "flipped.png", &["--section", "z=12,flip"]); assert_differs(&flipped, &cut, "flip keeps the other side"); // A section through a see-through target still shows the tool inside it. let both = dir.snapshot(&script, "both.png", &["--section", "z=12", "--tool", "Tool"]); assert_differs(&both, &cut, "--tool and --section together"); assert!(tool_pixels(&both) > 100, "the tool is in the cut picture"); } /// Every way of getting the options wrong is an error that says what it takes, and writes no /// picture: a snapshot that quietly ignored an option would be a lie about the design. #[test] fn a_body_tool_or_section_that_cannot_be_used_is_an_error_and_writes_nothing() { let dir = Scratch::new(); let script = dir.script("part.json", &[]); let cases: [(&[&str], &str); 8] = [ (&["--body", "Nowhere:opacity=0.3"], "no body `Nowhere`"), (&["--body", "Target"], "NAME:key=value"), (&["--body", "Target:opacity=3"], "0 to 1"), (&["--body", "Target:alpha=0.3"], "unknown key `alpha`"), (&["--body", "Target:color=red"], "#rrggbb"), (&["--tool", "Nowhere"], "no body `Nowhere`"), (&["--section", "q=1"], "unknown axis `q`"), (&["--section", "nonsense"], "z=27"), ]; for (extra, expect) in cases { let output = dir.run(&script, "never.png", extra); let stderr = String::from_utf8_lossy(&output.stderr); assert_eq!(output.status.code(), Some(1), "{extra:?}: {stderr}"); assert!(stderr.contains(expect), "{extra:?}: {stderr}"); assert!(output.stdout.is_empty() && !dir.0.join("never.png").exists(), "{extra:?}"); } // An error naming a body says which bodies the design has. let stderr = String::from_utf8_lossy(&dir.run(&script, "never.png", &["--tool", "Nowhere"]).stderr).to_string(); assert!(stderr.contains("Target") && stderr.contains("Tool"), "{stderr}"); } /// The usage text says what the options do. #[test] fn the_usage_names_the_body_tool_and_section_options() { let output = Command::new(env!("CARGO_BIN_EXE_solidcraft-cli")).arg("snapshot").output().unwrap(); let stderr = String::from_utf8_lossy(&output.stderr); for word in ["--body", "--tool", "--section", "appearance.assign", "inspect.section", "see-through"] { assert!(stderr.contains(word), "usage lacks {word}: {stderr}"); } }