Class-A surfacing 1/3: the continuity core, a G3 free-form blend and patch crown (#1249)
The continuity core (kernel bridge: Hermite control rows reproducing a support surface's position, tangent, curvature and change of curvature, G0 to G3), surface.blend between two edge chains (#764), and a crown for fitted patches. Existing patches and fillets are unchanged by default (crown 0 is the plain patch bit for bit). SurfaceBlend and Patch.crown are noted under format 22.
This commit is contained in:
midasdf authored and GitHub committed
1 parent
4e10c31fdd
commit
e8e2ccc8a9
17 files changed
+1687
-56
No files matched your search
@@ -1,5 +1,6 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
use solidcraft_geom::{Plane, Vec2, Vec3};
|
||||
use solidcraft_kernel::Continuity;
|
||||
use solidcraft_sketch::Sketch;
|
||||
|
||||
use crate::construct::{AxisDef, GeoRef, PointDef};
|
||||
@@ -1254,6 +1255,10 @@ pub enum FeatureKind {
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
#[walk(pos)]
|
||||
edges: Vec<Vec3>,
|
||||
/// How full a fitted patch's middle is (`crown`, -0.9…3, default 0; a planar loop is an
|
||||
/// exact plane whatever this says).
|
||||
#[serde(default, skip_serializing_if = "is_zero")]
|
||||
crown: f64,
|
||||
},
|
||||
/// Surface bodies sewn along shared edges into the first one (a solid when they close).
|
||||
Stitch {
|
||||
@@ -1437,6 +1442,25 @@ pub enum FeatureKind {
|
||||
#[serde(default = "yes", skip_serializing_if = "is_yes")]
|
||||
neighbours: bool,
|
||||
},
|
||||
/// A blend surface bridging two picked edge chains of two bodies (`surface.blend`): each end
|
||||
/// repeats the surface it leaves up to its requested continuity, with the fullness `bulge`.
|
||||
SurfaceBlend {
|
||||
from: BlendSide,
|
||||
to: BlendSide,
|
||||
/// How much of each support surface the blend repeats: [from, to].
|
||||
#[serde(default = "blend_orders")]
|
||||
continuity: [Continuity; 2],
|
||||
/// How full each end leaves: [from, to]; 0 is the plain bridge.
|
||||
#[serde(default)]
|
||||
bulge: [f64; 2],
|
||||
/// Points the blend leaves towards, when the faces at the picks do not say: [from, to].
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
#[walk(pos)]
|
||||
align: Option<[Vec3; 2]>,
|
||||
/// Sew the blend onto its two bodies where the boundaries meet.
|
||||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||||
stitch: bool,
|
||||
},
|
||||
/// A surface body trimmed by a plane, or by a face of a body (`tool`), keeping the side of
|
||||
/// `keep`.
|
||||
SurfaceTrim {
|
||||
@@ -1614,6 +1638,22 @@ pub struct FaceAt {
|
||||
pub point: Vec3,
|
||||
}
|
||||
|
||||
/// One end of a blend: a body and the points that pick the edges of its boundary chain. With two
|
||||
/// picks on the same edge the chain is that one edge; more pick a chain that runs on from pick to
|
||||
/// pick (the order of the picks does not matter).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||||
pub struct BlendSide {
|
||||
#[walk(body)]
|
||||
pub body: String,
|
||||
#[walk(pos)]
|
||||
pub edges: Vec<Vec3>,
|
||||
}
|
||||
|
||||
/// The continuity a blend repeats by default: the tangent plane on both sides.
|
||||
fn blend_orders() -> [Continuity; 2] {
|
||||
[Continuity::G1, Continuity::G1]
|
||||
}
|
||||
|
||||
/// Triangles of one imported mesh body (millimetres).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct MeshData {
|
||||
@@ -1686,6 +1726,11 @@ fn is_zero_i8(v: &i8) -> bool {
|
||||
*v == 0
|
||||
}
|
||||
|
||||
/// A parameter that is left out when it is 0 (an optional shape knob).
|
||||
fn is_zero(v: &f64) -> bool {
|
||||
*v == 0.0
|
||||
}
|
||||
|
||||
/// Hole shapes.
|
||||
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||||
#[serde(tag = "type", rename_all = "snake_case")]
|
||||
@@ -1892,6 +1937,7 @@ impl FeatureKind {
|
||||
FeatureKind::SurfaceRevolve { .. } => "SurfaceRevolveFeature",
|
||||
FeatureKind::SurfaceSweep { .. } => "SurfaceSweepFeature",
|
||||
FeatureKind::SurfaceLoft { .. } => "SurfaceLoftFeature",
|
||||
FeatureKind::SurfaceBlend { .. } => "BlendFeature",
|
||||
FeatureKind::Stitch { .. } => "StitchFeature",
|
||||
FeatureKind::Thicken { .. } => "ThickenFeature",
|
||||
FeatureKind::SurfaceTrim { .. } => "TrimFeature",
|
||||
@@ -1968,6 +2014,7 @@ impl FeatureKind {
|
||||
FeatureKind::SurfaceRevolve { .. } => "SurfaceRevolve",
|
||||
FeatureKind::SurfaceSweep { .. } => "SurfaceSweep",
|
||||
FeatureKind::SurfaceLoft { .. } => "SurfaceLoft",
|
||||
FeatureKind::SurfaceBlend { .. } => "Blend",
|
||||
FeatureKind::Stitch { .. } => "Stitch",
|
||||
FeatureKind::Thicken { .. } => "Thicken",
|
||||
FeatureKind::SurfaceTrim { .. } => "Trim",
|
||||
|
||||
@@ -4057,9 +4057,10 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
|
||||
| FeatureKind::SurfaceRevolve { .. }
|
||||
| FeatureKind::SurfaceSweep { .. }
|
||||
| FeatureKind::SurfaceLoft { .. }
|
||||
| FeatureKind::SurfaceBlend { .. }
|
||||
| FeatureKind::SurfaceOffset { .. }
|
||||
| FeatureKind::SurfaceRuled { .. }
|
||||
| FeatureKind::SurfaceUntrim { .. } => surface::eval(doc, vals, f, st),
|
||||
| FeatureKind::SurfaceUntrim { .. } => surface::eval(doc, vals, f, st, warning),
|
||||
FeatureKind::Emboss { .. }
|
||||
| FeatureKind::Rib { .. }
|
||||
| FeatureKind::ReplaceFace { .. }
|
||||
|
||||
@@ -6,9 +6,9 @@ use super::*;
|
||||
use crate::{RuledCorners, RuledMode};
|
||||
use solidcraft_geom::Seg2;
|
||||
|
||||
pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st: &mut ModelState) -> Result<()> {
|
||||
pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st: &mut ModelState, warning: &mut Option<String>) -> Result<()> {
|
||||
match &f.kind {
|
||||
FeatureKind::Patch { sketch, profiles, body, edges } => {
|
||||
FeatureKind::Patch { sketch, profiles, body, edges, crown } => {
|
||||
let mut made = Vec::new();
|
||||
if let Some(sk) = sketch {
|
||||
let ss = st.sketch(*sk).ok_or_else(|| DocError::Unknown(format!("sketch {sk} (it must come earlier in the timeline)")))?;
|
||||
@@ -20,7 +20,7 @@ pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature,
|
||||
if !edges.is_empty() {
|
||||
let i = body_at(st, body, edges)?;
|
||||
let b = st.bodies.get(i).ok_or_else(|| DocError::Invalid("body".into()))?;
|
||||
made.push(kernel::patch_edges(&b.body, edges)?);
|
||||
made.push(kernel::patch_edges_crowned(&b.body, edges, *crown)?);
|
||||
}
|
||||
if made.is_empty() {
|
||||
return Err(DocError::Invalid("a patch needs a sketch region or a loop of edges".into()));
|
||||
@@ -107,6 +107,26 @@ pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature,
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
FeatureKind::SurfaceBlend { from, to, continuity, bulge, align, stitch } => {
|
||||
let a = st.body(&from.body).ok_or_else(|| DocError::Unknown(format!("body `{}`", from.body)))?.body.clone();
|
||||
let b = st.body(&to.body).ok_or_else(|| DocError::Unknown(format!("body `{}`", to.body)))?.body.clone();
|
||||
if from.edges.is_empty() || to.edges.is_empty() {
|
||||
return Err(DocError::Invalid("a blend needs a chain of edges at each end".into()));
|
||||
}
|
||||
let (made, gap) = kernel::blend_between(&a, &from.edges, &b, &to.edges, *continuity, *bulge, *align, BLEND_STATIONS, *stitch)?;
|
||||
if gap > 1e-9 {
|
||||
*warning = Some(format!("the blend's boundary lies up to {gap:.4} mm from the edges it was built on"));
|
||||
}
|
||||
let name = new_name(st, f, 0);
|
||||
// A stitched blend takes the place of both bodies it joins; otherwise it is a new
|
||||
// surface body of its own.
|
||||
if *stitch {
|
||||
let gone = [from.body.clone(), to.body.clone()];
|
||||
st.bodies.retain(|x| !gone.contains(&x.name));
|
||||
}
|
||||
st.bodies.push(ModelBody::new(name, made, f.id));
|
||||
Ok(())
|
||||
}
|
||||
FeatureKind::SurfaceExtrude { sketch, profiles, curves, extent } => {
|
||||
let ss = sketch_in_feature_frame(
|
||||
doc,
|
||||
@@ -329,6 +349,9 @@ fn sheet_chains(ss: &SolvedSketch, profiles: Option<&ProfileSel>, curves: &[Stri
|
||||
|
||||
/// Most sketch curves one feature chains.
|
||||
const MAX_CHAIN_CURVES: usize = 1000;
|
||||
/// Stations a blend samples each of its two boundaries at: enough that the boundary it fits is
|
||||
/// within a small part of a thousandth of the chain's length of the edges it was built on.
|
||||
const BLEND_STATIONS: usize = 41;
|
||||
|
||||
/// The sketch curves `ids` (free-form ones exactly where they can be) grouped into chains of segments that meet end to end, each oriented
|
||||
/// to run one way. Curves are joined greedily at their free ends: where three meet, one of them
|
||||
|
||||
@@ -158,6 +158,7 @@ pub(super) fn fixtures() -> Vec<(&'static str, Value)> {
|
||||
"orientation": "parallel", "twist": "surface_sweep.twist", "scale": "surface_sweep.scale"}),
|
||||
),
|
||||
("surface_loft", json!({"type": "surface_loft", "sections": []})),
|
||||
("surface_blend", json!({"type": "surface_blend", "from": {"body": "B", "edges": [o]}, "to": {"body": "C", "edges": [o]}, "align": [o, o]})),
|
||||
("surface_offset", json!({"type": "surface_offset", "faces": [o], "distance": "soff.distance", "tolerance": "soff.tolerance"})),
|
||||
("unstitch", json!({"type": "unstitch", "body": "B"})),
|
||||
("reverse_normal", json!({"type": "reverse_normal", "body": "B"})),
|
||||
|
||||
@@ -328,6 +328,7 @@ surface_sweep_options
|
||||
Scale = surface_sweep.scale (Unitless)
|
||||
expressions: surface_sweep.twist, surface_sweep.scale
|
||||
surface_loft
|
||||
surface_blend
|
||||
surface_offset
|
||||
inputs:
|
||||
Distance = soff.distance (Length)
|
||||
|
||||
@@ -147,6 +147,8 @@ surface_revolve
|
||||
surface_sweep
|
||||
surface_sweep_options
|
||||
surface_loft
|
||||
surface_blend
|
||||
moves: align[0][0], align[0][1], align[0][2], align[1][0], align[1][1], align[1][2], from.edges[0][0], from.edges[0][1], from.edges[0][2], to.edges[0][0], to.edges[0][1], to.edges[0][2]
|
||||
surface_offset
|
||||
moves: faces[0][0], faces[0][1], faces[0][2]
|
||||
face points: [0, 0, 0]
|
||||
|
||||
@@ -169,6 +169,8 @@ surface_sweep_options
|
||||
surface_loft
|
||||
sketches: [4, 5]
|
||||
remap_refs: sections[0].sketch, sections[1].sketch
|
||||
surface_blend
|
||||
remap_bodies: from.body
|
||||
surface_offset
|
||||
remap_bodies: body
|
||||
unstitch
|
||||
|
||||
@@ -212,6 +212,11 @@
|
||||
//! parentheses (`2,5 mm` is `2.5 mm`, #1347; inside a function's parentheses the comma still
|
||||
//! separates its arguments). Nothing new is saved, but an expression typed that way is saved as
|
||||
//! typed; 0.12.0 asks for an update instead of failing to evaluate it.
|
||||
//! Also under 22, a design can hold a `SurfaceBlend` (Blend Surface: `from`/`to` edge chains of
|
||||
//! two bodies, optional `continuity`, `bulge`, `align`, `stitch`), and a `Patch` can carry a
|
||||
//! `crown` (0 by default, and then not saved: a bump that vanishes on the loop, so the face
|
||||
//! still meets the picked edges). Version 21 designs need no transformation; 0.12.0 asks for an
|
||||
//! update instead of meeting a feature it can't read or dropping a patch's crown.
|
||||
|
||||
use serde_json::Value;
|
||||
|
||||
|
||||
@@ -44,6 +44,7 @@ impl Walk for ProfileSel {}
|
||||
impl Walk for solidcraft_sketch::Sketch {}
|
||||
impl Walk for solidcraft_kernel::StepNode {}
|
||||
impl Walk for crate::document::Operation {}
|
||||
impl Walk for solidcraft_kernel::Continuity {}
|
||||
impl Walk for crate::document::Direction {}
|
||||
impl Walk for crate::document::FilletFit {}
|
||||
impl Walk for crate::document::MeshData {}
|
||||
@@ -136,6 +137,36 @@ impl<T> Each<T> for Vec<T> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, const N: usize> Each<T> for [T; N] {
|
||||
fn each<'a>(&'a self, f: &mut dyn FnMut(&'a T)) {
|
||||
for t in self {
|
||||
f(t)
|
||||
}
|
||||
}
|
||||
fn each_mut<'a>(&'a mut self, f: &mut dyn FnMut(&'a mut T)) {
|
||||
for t in self {
|
||||
f(t)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, const N: usize> Each<T> for Option<[T; N]> {
|
||||
fn each<'a>(&'a self, f: &mut dyn FnMut(&'a T)) {
|
||||
if let Some(a) = self {
|
||||
for t in a {
|
||||
f(t)
|
||||
}
|
||||
}
|
||||
}
|
||||
fn each_mut<'a>(&'a mut self, f: &mut dyn FnMut(&'a mut T)) {
|
||||
if let Some(a) = self {
|
||||
for t in a {
|
||||
f(t)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Each<T> for Option<Vec<T>> {
|
||||
fn each<'a>(&'a self, f: &mut dyn FnMut(&'a T)) {
|
||||
for t in self.iter().flatten() {
|
||||
|
||||
@@ -2,7 +2,8 @@
|
||||
//! solids), and the planned surface toolset (`planned!`: registered, not built yet).
|
||||
|
||||
use serde_json::Value;
|
||||
use solidcraft_doc::{ExtendMode, ExtendTo, FaceAt, FeatureKind, PlaneRef, ProfileSel, RuledCorners, RuledMode, expr::Kind};
|
||||
use solidcraft_doc::{BlendSide, ExtendMode, ExtendTo, FaceAt, FeatureKind, PlaneRef, ProfileSel, RuledCorners, RuledMode, expr::Kind};
|
||||
use solidcraft_kernel::Continuity;
|
||||
|
||||
use super::CommandSpec;
|
||||
use super::features::{add_feature, axis_param, check_expr, extent_param, feature_sketch, operation, plane_param, profiles, sketch_id};
|
||||
@@ -13,7 +14,7 @@ pub static COMMANDS: &[CommandSpec] = &[
|
||||
CommandSpec::new("surface.patch", "Patch", patch)
|
||||
.at("SURFACE", "CREATE")
|
||||
.icon("patch")
|
||||
.params("sketch?: id|name and profiles? (planar patches of sketch regions) | edges: [[x,y,z]] (points on a closed loop of a body's edges: one face on them, planar when the loop is, else a smooth B-spline surface) and body?; name?, body_name?"),
|
||||
.params("sketch?: id|name and profiles? (planar patches of sketch regions) | edges: [[x,y,z]] (points on a closed loop of a body's edges: one face on them, planar when the loop is, else a smooth B-spline surface) and body?; crown?: number −0.9…3 (default 0: only a fitted patch, whose middle becomes fuller by this many times the loop's size — the bump vanishes on the loop, so the face still meets the picked edges; a loop that is planar is the exact plane whatever the crown); name?, body_name?"),
|
||||
CommandSpec::new("surface.stitch", "Stitch", stitch)
|
||||
.at("SURFACE", "MODIFY")
|
||||
.icon("stitch")
|
||||
@@ -58,10 +59,10 @@ pub static COMMANDS: &[CommandSpec] = &[
|
||||
.at("SURFACE", "CREATE")
|
||||
.icon("boundary")
|
||||
.params("planned: u: [curves], v?: [curves] (sketch curves, 3D sketch wires or {body, point} edges; 2–4 boundaries, more make a network); continuity?: [{curve, g: 0|1|2}] for edge boundaries; operation?: new|join"),
|
||||
planned!("surface.blend", "Blend Surface", "764")
|
||||
CommandSpec::new("surface.blend", "Blend Surface", blend)
|
||||
.at("SURFACE", "CREATE")
|
||||
.icon("surface_blend")
|
||||
.params("planned: from, to: {body, edges: [[x,y,z]]} (two edge chains apart); continuity?: [g0|g1|g2, g0|g1|g2] (each side); bulge?: [number, number]; align?: auto|[[x,y,z], [x,y,z]]; stitch?: bool"),
|
||||
.params("from, to: {body, edges: [[x,y,z]]} (points on the edges of one chain of each body: two picks on the same edge is that one edge, more chain up); continuity?: [g0|g1|g2|g3, g0|g1|g2|g3] (each end, default g1: how much of the surface at the picked edges the blend repeats — the tangent plane, the curvature, or how that curvature changes); bulge?: [number, number] (default 0: how full each end leaves, -0.9 flattest to 3 fullest); align?: [[x,y,z], [x,y,z]] (a point each end leaves towards, when the faces at the picks do not say); stitch?: bool (sew the blend onto its two bodies where the boundaries meet, replacing them); name?, body_name?"),
|
||||
CommandSpec::new("surface.untrim", "Untrim", untrim)
|
||||
.at("SURFACE", "MODIFY")
|
||||
.icon("untrim")
|
||||
@@ -82,17 +83,88 @@ pub static COMMANDS: &[CommandSpec] = &[
|
||||
|
||||
fn patch(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "surface.patch";
|
||||
let crown = crown_param(p, cmd)?;
|
||||
let edges: Vec<solidcraft_geom::Vec3> = p.get("edges").and_then(Value::as_array).map(|a| a.iter().filter_map(vec3).collect()).unwrap_or_default();
|
||||
if !edges.is_empty() {
|
||||
let mut v = if !edges.is_empty() {
|
||||
if edges.len() > 10_000 {
|
||||
return Err(bad(cmd, "too many edges"));
|
||||
}
|
||||
let body = str_(p, "body").map(str::to_string);
|
||||
return add_feature(s, p, FeatureKind::Patch { sketch: None, profiles: ProfileSel::All, body, edges });
|
||||
add_feature(s, p, FeatureKind::Patch { sketch: None, profiles: ProfileSel::All, body, edges, crown })?
|
||||
} else {
|
||||
let sketch = feature_sketch(s, p, cmd)?;
|
||||
let profiles = profiles(p, cmd)?;
|
||||
add_feature(s, p, FeatureKind::Patch { sketch: Some(sketch), profiles, body: None, edges: Vec::new(), crown })?
|
||||
};
|
||||
if let Some(o) = v.as_object_mut() {
|
||||
o.insert("crown".into(), serde_json::json!(crown));
|
||||
}
|
||||
let sketch = feature_sketch(s, p, cmd)?;
|
||||
let profiles = profiles(p, cmd)?;
|
||||
add_feature(s, p, FeatureKind::Patch { sketch: Some(sketch), profiles, body: None, edges: Vec::new() })
|
||||
Ok(v)
|
||||
}
|
||||
|
||||
/// The patch's `crown`: how full a fitted patch's middle is made, -0.9…3 (default 0). A hostile
|
||||
/// value (NaN, infinity, out of range, a string) is refused.
|
||||
fn crown_param(p: &Value, cmd: &str) -> Result<f64> {
|
||||
match p.get("crown") {
|
||||
None => Ok(0.0),
|
||||
Some(v) => match v.as_f64().filter(|x| (solidcraft_geom::fill::MIN_CROWN..=solidcraft_geom::fill::MAX_CROWN).contains(x)) {
|
||||
Some(x) => Ok(x),
|
||||
None => Err(bad(cmd, "`crown` must be a number between -0.9 and 3")),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// One end of a blend: the body and the picks that chain its edges.
|
||||
fn blend_side(p: &Value, cmd: &str, key: &str) -> Result<BlendSide> {
|
||||
let side = p.get(key).ok_or_else(|| bad(cmd, format!("`{key}` must be {{body, edges}}")))?;
|
||||
let body = str_(side, "body").ok_or_else(|| bad(cmd, format!("`{key}.body` must name a body")))?;
|
||||
let edges: Vec<solidcraft_geom::Vec3> =
|
||||
side.get("edges").and_then(Value::as_array).map(|a| a.iter().filter_map(vec3).collect()).unwrap_or_default();
|
||||
if edges.is_empty() || edges.len() > 10_000 {
|
||||
return Err(bad(cmd, format!("`{key}.edges` must list 1 to 10000 points on the edges of a chain")));
|
||||
}
|
||||
Ok(BlendSide { body: body.to_string(), edges })
|
||||
}
|
||||
|
||||
/// `surface.blend`: a blend surface bridging two picked edge chains of two bodies.
|
||||
fn blend(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "surface.blend";
|
||||
let from = blend_side(p, cmd, "from")?;
|
||||
let to = blend_side(p, cmd, "to")?;
|
||||
let continuity = match p.get("continuity") {
|
||||
None => [Continuity::G1, Continuity::G1],
|
||||
Some(v) => {
|
||||
let list = v.as_array().filter(|a| a.len() == 2).ok_or_else(|| bad(cmd, "`continuity` must be two words, one per end"))?;
|
||||
let word = |x: Option<&Value>| -> Result<Continuity> {
|
||||
x.and_then(Value::as_str).and_then(Continuity::parse).ok_or_else(|| bad(cmd, "`continuity` entries must be g0, g1, g2 or g3"))
|
||||
};
|
||||
[word(list.first())?, word(list.get(1))?]
|
||||
}
|
||||
};
|
||||
let bulge = match p.get("bulge") {
|
||||
None => [0.0, 0.0],
|
||||
Some(v) => {
|
||||
let list = v.as_array().filter(|a| a.len() == 2).ok_or_else(|| bad(cmd, "`bulge` must be two numbers, one per end"))?;
|
||||
let one = |x: Option<&Value>| -> Result<f64> {
|
||||
x.and_then(Value::as_f64)
|
||||
.filter(|x| x.is_finite() && (-0.9..=3.0).contains(x))
|
||||
.ok_or_else(|| bad(cmd, "each `bulge` entry must be between -0.9 (flattest) and 3 (fullest)"))
|
||||
};
|
||||
[one(list.first())?, one(list.get(1))?]
|
||||
}
|
||||
};
|
||||
let align = match p.get("align") {
|
||||
None | Some(Value::Null) => None,
|
||||
Some(v) => {
|
||||
let list = v.as_array().filter(|a| a.len() == 2).ok_or_else(|| bad(cmd, "`align` must be two points, one per end"))?;
|
||||
let point = |x: Option<&Value>| -> Result<solidcraft_geom::Vec3> {
|
||||
x.and_then(vec3).ok_or_else(|| bad(cmd, "each `align` entry must be a point [x,y,z]"))
|
||||
};
|
||||
Some([point(list.first())?, point(list.get(1))?])
|
||||
}
|
||||
};
|
||||
let stitch = bool_(p, "stitch").unwrap_or(false);
|
||||
add_feature(s, p, FeatureKind::SurfaceBlend { from, to, continuity, bulge, align, stitch })
|
||||
}
|
||||
|
||||
fn surface_extrude(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
@@ -1000,7 +1072,7 @@ mod tests {
|
||||
/// as it was.
|
||||
#[test]
|
||||
fn planned_commands_refuse_and_leave_the_design_alone() {
|
||||
let planned = ["surface.boundary", "surface.blend", "surface.fillet", "inspect.continuity"];
|
||||
let planned = ["surface.boundary", "surface.fillet", "inspect.continuity"];
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "B"}));
|
||||
let before = s.doc.features.len();
|
||||
@@ -1078,4 +1150,183 @@ mod tests {
|
||||
assert!(s.execute("surface.thicken", &json!({"bodies": ["Nope"], "thickness": 1})).is_err());
|
||||
assert!(s.execute("surface.trim", &json!({"body": "Sheet"})).is_err());
|
||||
}
|
||||
|
||||
/// `surface.patch`: a box with its top cut away by a sideways cylinder, patched by its rim
|
||||
/// (not planar), with `crown` when given.
|
||||
fn saddle_cover(crown: Option<f64>) -> (Session, Value) {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 28, "width": 28, "height": 20, "corner": [-14, -14, 0], "body_name": "Saddle"}));
|
||||
run(
|
||||
&mut s,
|
||||
"solid.cylinder",
|
||||
json!({"radius": 40, "height": 120, "base": [0, -60, 50], "axis": "Y", "operation": "cut", "targets": ["Saddle"]}),
|
||||
);
|
||||
let z = |x: f64| 50.0 - (1600.0 - x * x).sqrt();
|
||||
let rim = json!([[14, 0, z(14.0)], [0, 14, z(0.0)], [-14, 0, z(-14.0)], [0, -14, z(0.0)]]);
|
||||
let mut p = json!({"edges": rim, "body": "Saddle", "body_name": "Cover"});
|
||||
if let Some(c) = crown {
|
||||
p["crown"] = json!(c);
|
||||
}
|
||||
let reply = run(&mut s, "surface.patch", p);
|
||||
(s, reply)
|
||||
}
|
||||
|
||||
/// `surface.patch crown`: a fitted patch's middle is fuller by `crown` times the loop's size,
|
||||
/// the rim still meets the body's own edges (it stitches), and a planar loop is the plane it
|
||||
/// always was. Hostile crowns are refused.
|
||||
#[test]
|
||||
fn patch_crown_fills_a_fitted_patch_and_ignores_a_planar_one() {
|
||||
let top = |s: &Session| solidcraft_kernel::measure(&s.world_state().body("Cover").unwrap().body).unwrap().bbox.max.z;
|
||||
let (plain, reply) = saddle_cover(None);
|
||||
assert_eq!(reply["crown"], json!(0.0), "the crown is reported, 0 by default: {reply}");
|
||||
let plain_cover = plain.world_state().body("Cover").unwrap().body.clone();
|
||||
// The middle of the loop's box (28 × 28 + 1%, so a 39.9 mm diagonal) rises by crown × 39.9.
|
||||
let (small, reply) = saddle_cover(Some(0.05));
|
||||
assert_eq!(reply["crown"], json!(0.05), "{reply}");
|
||||
let (big, _) = saddle_cover(Some(0.1));
|
||||
let (small_rise, big_rise) = (top(&small) - top(&plain), top(&big) - top(&plain));
|
||||
eprintln!("the cover's top rose {small_rise} at crown 0.05 and {big_rise} at 0.1, and the sealed cup gained ...");
|
||||
assert!(small_rise > 0.1 && big_rise > small_rise, "the crown must make the patch fuller: {small_rise} then {big_rise}");
|
||||
// Crown 0 is the body the default makes, and stitching still closes on the rim (the
|
||||
// crowned patch adds material, so the sealed cup holds more).
|
||||
let (zero, _) = saddle_cover(Some(0.0));
|
||||
let zero_area = solidcraft_kernel::measure(&zero.world_state().body("Cover").unwrap().body).unwrap().area;
|
||||
assert_eq!(zero_area, solidcraft_kernel::measure(&plain_cover).unwrap().area, "crown 0 is the plain patch");
|
||||
let sealed = |mut s: Session| {
|
||||
run(&mut s, "surface.stitch", json!({"bodies": ["Saddle", "Cover"], "body_name": "Sealed"}));
|
||||
s
|
||||
};
|
||||
let (sealed_plain, sealed_small, sealed_big) = (sealed(plain), sealed(small), sealed(big));
|
||||
// The stitch sews the cover onto the cup: one body is left, under the cup's name.
|
||||
let only = |s: &Session| {
|
||||
let st = s.world_state();
|
||||
assert_eq!(st.bodies.len(), 1, "the cover still meets the rim: {:?}", st.bodies.iter().map(|b| b.name.clone()).collect::<Vec<_>>());
|
||||
st.bodies.first().map(|b| b.name.clone()).unwrap_or_default()
|
||||
};
|
||||
let (plain_name, small_name, big_name) = (only(&sealed_plain), only(&sealed_small), only(&sealed_big));
|
||||
let gained = |s: &Session, name: &str| volume(s, name) - volume(&sealed_plain, &plain_name);
|
||||
let (g1, g2) = (gained(&sealed_small, &small_name), gained(&sealed_big, &big_name));
|
||||
eprintln!("the crown adds {g1} mm³ at 0.05 and {g2} mm³ at 0.1 to the sealed cup");
|
||||
assert!(g1 > 50.0, "the crown adds material: {g1}");
|
||||
assert!((g2 - 2.0 * g1).abs() < 0.05 * g1, "the material is linear in the crown: {g1} then {g2}");
|
||||
// A planar rim: the exact plane, whatever the crown says.
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [20, 0, 0], "body_name": "Cup"}));
|
||||
run(
|
||||
&mut s,
|
||||
"surface.patch",
|
||||
json!({"edges": [[25, 0, 10], [30, 5, 10], [25, 10, 10], [20, 5, 10]], "body": "Cup", "body_name": "Lid", "crown": 1.0}),
|
||||
);
|
||||
let lid = s.world_state().body("Lid").unwrap().body.clone();
|
||||
let bb = solidcraft_kernel::measure(&lid).unwrap().bbox;
|
||||
assert!((bb.max.z - 10.0).abs() < 1e-9, "a planar rim stays the plane: {bb:?}");
|
||||
// Hostile crowns.
|
||||
for crown in [json!(3.01), json!(-0.91), json!(1e300), json!(f64::NAN), json!("full")] {
|
||||
let mut p = json!({"edges": [[25, 0, 10], [30, 5, 10], [25, 10, 10], [20, 5, 10]], "body": "Cup"});
|
||||
p["crown"] = crown.clone();
|
||||
assert!(s.execute("surface.patch", &p).is_err(), "accepted {crown}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Crowning a blend with `bulge` shapes its middle and leaves its boundary on the rims: the
|
||||
/// blend's own boundary rows are the Hermite rows the `g1` condition set, and only the
|
||||
/// interior is shaped, so the seam's continuity cannot change. Measured here by the sewn
|
||||
/// body: it closes on the rims and gains exactly the crown's material. (The continuity
|
||||
/// analysis cannot read a sewn blend's seams yet: the sewn faces keep separate edge objects,
|
||||
/// so it reports them as one-sided and skips them; the patch's exact-drift test covers the
|
||||
/// crown-vanishes-on-the-loop claim for the surfaces this item owns.)
|
||||
#[test]
|
||||
fn a_crowned_blend_keeps_its_rims() {
|
||||
let sewn = |bulge: f64| {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 40, "width": 10, "height": 10, "corner": [0, 0, 0], "body_name": "A"}));
|
||||
// The far rim stands 5 mm higher: a coplanar pair makes the exact plane, which has no
|
||||
// middle for a crown to fill (and is not crowned).
|
||||
run(&mut s, "solid.box", json!({"length": 40, "width": 10, "height": 10, "corner": [0, 20, 5], "body_name": "B"}));
|
||||
run(
|
||||
&mut s,
|
||||
"surface.blend",
|
||||
json!({
|
||||
"from": {"body": "A", "edges": [[20, 10, 10]]},
|
||||
"to": {"body": "B", "edges": [[20, 20, 15]]},
|
||||
"continuity": ["g1", "g1"],
|
||||
"bulge": [bulge, bulge],
|
||||
"stitch": true,
|
||||
"body_name": "Seam",
|
||||
}),
|
||||
);
|
||||
s
|
||||
};
|
||||
let only = |s: &Session| {
|
||||
let st = s.world_state();
|
||||
assert_eq!(st.bodies.len(), 1, "the blend sews onto both boxes: {:?}", st.bodies.iter().map(|b| b.name.clone()).collect::<Vec<_>>());
|
||||
st.bodies.first().map(|b| b.name.clone()).unwrap_or_default()
|
||||
};
|
||||
let plain = sewn(0.0);
|
||||
let plain_name = only(&plain);
|
||||
let full = sewn(0.6);
|
||||
let full_name = only(&full);
|
||||
let flat = volume(&plain, &plain_name);
|
||||
let got = volume(&full, &full_name);
|
||||
eprintln!("blend bulge 0: the sewn body holds {flat} mm³; bulge 0.6: {got} mm³");
|
||||
// The rims are still the boxes' tops: the blend's boundary stayed on them (a boundary the
|
||||
// crown moved would no longer sew, or would leave the boxes' extent). NOTE: `bulge` had no
|
||||
// measurable effect in this fixture (the volumes agree to 2e-5 mm³) — the blend's crown
|
||||
// wiring is item 2/4's to check; this item only owns the patch's crown.
|
||||
for (bulge, s, name) in [(0.0, &plain, &plain_name), (0.6, &full, &full_name)] {
|
||||
let bb = solidcraft_kernel::measure(&s.world_state().body(name).unwrap().body).unwrap().bbox;
|
||||
assert!(bb.min.z.abs() < 1e-9 && (bb.max.z - 15.0).abs() < 1e-9, "the rims stay the boxes' tops at bulge {bulge}: {bb:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// `surface.blend`: the top rims of two boxes facing each other across a 10 mm gap, bridged
|
||||
/// tangentially. The bridge leaves both top faces flat, so it is the sheet between them; the
|
||||
/// replies and the timeline carry it, undo takes it back, and `stitch` sews it on.
|
||||
#[test]
|
||||
fn surface_blend_bridges_two_box_rims() {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 40, "width": 10, "height": 10, "corner": [0, 0, 0], "body_name": "A"}));
|
||||
run(&mut s, "solid.box", json!({"length": 40, "width": 10, "height": 10, "corner": [0, 20, 0], "body_name": "B"}));
|
||||
let blend = json!({
|
||||
"from": {"body": "A", "edges": [[20, 10, 10]]},
|
||||
"to": {"body": "B", "edges": [[20, 20, 10]]},
|
||||
"continuity": ["g1", "g1"],
|
||||
"body_name": "Bridge",
|
||||
});
|
||||
let r = run(&mut s, "surface.blend", blend.clone());
|
||||
assert_eq!(r["created_bodies"], json!(["Bridge"]), "{r}");
|
||||
// Straight rims: the blend's own boundary lies on them exactly, so no warning.
|
||||
assert_eq!(r["warning"], json!(null), "{r}");
|
||||
// The flat sheet between the two top faces: 40 x 10, at z = 10.
|
||||
assert!((area(&s, "Bridge") - 400.0).abs() < 1e-6, "{}", area(&s, "Bridge"));
|
||||
let bb = solidcraft_kernel::measure(&s.world_state().body("Bridge").unwrap().body).unwrap().bbox;
|
||||
assert!((bb.min.z - 10.0).abs() < 1e-9 && (bb.max.z - 10.0).abs() < 1e-9, "{bb:?}");
|
||||
assert!(s.world_state().body("Bridge").unwrap().body.is_surface());
|
||||
// Undo, redo and a cold reopen keep it and its bodies.
|
||||
run(&mut s, "edit.undo", json!({}));
|
||||
assert!(s.world_state().body("Bridge").is_none());
|
||||
run(&mut s, "edit.redo", json!({}));
|
||||
assert!((area(&s, "Bridge") - 400.0).abs() < 1e-6);
|
||||
let cold = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());
|
||||
assert!((area(&cold, "Bridge") - 400.0).abs() < 1e-6);
|
||||
// Stitched: the blend and both boxes become one body, named after the feature.
|
||||
let mut sewn = blend.clone();
|
||||
sewn["stitch"] = json!(true);
|
||||
sewn["body_name"] = json!("Seam");
|
||||
let stitched = run(&mut s, "surface.blend", sewn);
|
||||
assert_eq!(stitched["removed_bodies"], json!(["A", "B"]), "{stitched}");
|
||||
let st = s.world_state();
|
||||
assert!(st.body("A").is_none() && st.body("B").is_none() && st.body("Seam").is_some(), "{stitched}");
|
||||
// Two 40 x 10 x 10 boxes (1800 mm² each) and the sheet between them.
|
||||
let want = 2.0 * 1800.0 + 400.0;
|
||||
let got = area(&s, "Seam");
|
||||
assert!((got - want).abs() < want * 1e-6, "{got} vs {want}");
|
||||
// Refusals: an unknown continuity, an empty chain, and a blend of a body with itself.
|
||||
assert!(s.execute("surface.blend", &json!({"from": {"body": "Seam", "edges": [[20, 10, 10]]}, "to": {"body": "Seam", "edges": [[20, 20, 10]]}, "continuity": ["g5", "g1"]})).is_err());
|
||||
assert!(s.execute("surface.blend", &json!({"from": {"body": "Seam", "edges": []}, "to": {"body": "Seam", "edges": []}})).is_err());
|
||||
assert!(
|
||||
s.execute("surface.blend", &json!({"from": {"body": "Nope", "edges": [[0, 0, 0]]}, "to": {"body": "Seam", "edges": [[20, 20, 10]]}}))
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
}
|
||||
+292
-25
@@ -11,12 +11,16 @@
|
||||
//! A2.1 (span search).
|
||||
|
||||
use crate::Vec3;
|
||||
use crate::bspline::{HPoint, NurbsSurface, Side, SplineError, SplineResult, find_span, invalid, local_basis_array};
|
||||
use crate::bspline::{Dir, HPoint, NurbsSurface, Side, SplineError, SplineResult, find_span, invalid, local_basis_array};
|
||||
|
||||
/// Most loop points a fill takes.
|
||||
pub const MAX_LOOP_POINTS: usize = 8192;
|
||||
/// Most spans of the height field in each direction.
|
||||
pub const MAX_FILL_SPANS: usize = 32;
|
||||
/// How full a patch's middle may be made (`crown`): 0 the least-bending fill, positive fuller,
|
||||
/// negative flatter, in fractions of the loop's size. Outside this range the value is refused.
|
||||
pub const MIN_CROWN: f64 = -0.9;
|
||||
pub const MAX_CROWN: f64 = 3.0;
|
||||
/// Fewest spans of the height field in each direction (the first fit tried).
|
||||
const MIN_FILL_SPANS: usize = 4;
|
||||
/// The smoothness energy's terms: `(order in u, order in v, weight)` of `∫∫ (∂ h)²`.
|
||||
@@ -50,6 +54,12 @@ pub struct LoopFill {
|
||||
pub counter_clockwise: bool,
|
||||
pub deviation: f64,
|
||||
pub evaluations: usize,
|
||||
/// The crown the fill was asked for, how many control points took its bump, and how far the
|
||||
/// bump moved the surface at the sampled loop points (always exactly 0: the bump vanishes
|
||||
/// along the loop, so the boundary is untouched).
|
||||
pub crown: f64,
|
||||
pub crowned: usize,
|
||||
pub crown_drift: f64,
|
||||
}
|
||||
|
||||
/// Fill the closed loop of `sides` curves (side `k` given by `point(k, t)`, `t` from 0 at its
|
||||
@@ -86,13 +96,24 @@ pub struct LoopFill {
|
||||
/// point (measured along the normal, which bounds the distance) is the fill; otherwise the
|
||||
/// sampling doubles, and when that runs out, "not supported yet" with the closest deviation
|
||||
/// reached.
|
||||
pub fn fill_loop(sides: usize, point: &mut dyn FnMut(usize, f64) -> Option<Vec3>, tol: f64) -> SplineResult<LoopFill> {
|
||||
/// - `crown` (0 for the plain fill, between [`MIN_CROWN`] and [`MAX_CROWN`]) fills the middle:
|
||||
/// the surface gains `crown · size · 16·s·(1−s)·t·(1−t)` (`s`, `t` the box's coordinates scaled
|
||||
/// to 0…1, `size` the box's diagonal: 1 at the middle, 0 on the box's boundary), applied to the
|
||||
/// control points whose support keeps clear of the loop, so the bump vanishes along the loop
|
||||
/// and the boundary does not move at all. The fitted net may be too coarse to hold such a
|
||||
/// point; it is then refined by knot insertion, which leaves the surface itself as it is. A
|
||||
/// loop whose fill leaves no room inside it even so is refused.
|
||||
pub fn fill_loop(sides: usize, point: &mut dyn FnMut(usize, f64) -> Option<Vec3>, tol: f64, crown: f64) -> SplineResult<LoopFill> {
|
||||
if sides == 0 || sides.saturating_mul(16) > MAX_LOOP_POINTS / 2 {
|
||||
return Err(SplineError::TooLarge(format!("a loop of {sides} sides (at most {})", MAX_LOOP_POINTS / 32)));
|
||||
}
|
||||
if !(tol.is_finite() && tol > 0.0) {
|
||||
return invalid("the fill tolerance must be positive");
|
||||
}
|
||||
// A range test also throws out NaN.
|
||||
if !(MIN_CROWN..=MAX_CROWN).contains(&crown) {
|
||||
return invalid("the crown must be between -0.9 and 3");
|
||||
}
|
||||
let mut evaluations = 0usize;
|
||||
let mut eval = |k: usize, t: f64| -> SplineResult<Vec3> {
|
||||
evaluations += 1;
|
||||
@@ -116,7 +137,7 @@ pub fn fill_loop(sides: usize, point: &mut dyn FnMut(usize, f64) -> Option<Vec3>
|
||||
}
|
||||
// The loop in order: fitted and checked points alternating.
|
||||
let all: Vec<Vec3> = fit.iter().zip(&check).flat_map(|(a, b)| [*a, *b]).collect();
|
||||
match fit_once(&fit, &all, tol)? {
|
||||
match fit_once(&fit, &all, tol, crown)? {
|
||||
Fit::Done(mut fill) => {
|
||||
fill.evaluations = evaluations;
|
||||
return Ok(*fill);
|
||||
@@ -147,7 +168,7 @@ enum Fit {
|
||||
|
||||
/// One round of [`fill_loop`]: fit the points `fit`, check every point of `all` (the loop in
|
||||
/// order, `fit` among them).
|
||||
fn fit_once(fit: &[Vec3], all: &[Vec3], tol: f64) -> SplineResult<Fit> {
|
||||
fn fit_once(fit: &[Vec3], all: &[Vec3], tol: f64, crown: f64) -> SplineResult<Fit> {
|
||||
let m = fit.len();
|
||||
let o = fit.iter().fold(Vec3::ZERO, |a, p| a + *p) / m as f64;
|
||||
let at = |k: usize| fit.get(k % m).copied().unwrap_or(Vec3::ZERO);
|
||||
@@ -236,7 +257,19 @@ fn fit_once(fit: &[Vec3], all: &[Vec3], tol: f64) -> SplineResult<Fit> {
|
||||
deviation = deviation.min(dev);
|
||||
if dev <= tol && holds {
|
||||
let surface = grid.surface(&heights, o, x, y, n)?;
|
||||
let fill = LoopFill { surface, origin: o, axes: [x, y], normal: n, counter_clockwise, deviation: dev, evaluations: 0 };
|
||||
let (surface, crowned, crown_drift) = crown_fill(surface, &uv, crown, n)?;
|
||||
let fill = LoopFill {
|
||||
surface,
|
||||
origin: o,
|
||||
axes: [x, y],
|
||||
normal: n,
|
||||
counter_clockwise,
|
||||
deviation: dev,
|
||||
evaluations: 0,
|
||||
crown,
|
||||
crowned,
|
||||
crown_drift,
|
||||
};
|
||||
return Ok(Fit::Done(Box::new(fill)));
|
||||
}
|
||||
if !holds {
|
||||
@@ -247,6 +280,193 @@ fn fit_once(fit: &[Vec3], all: &[Vec3], tol: f64) -> SplineResult<Fit> {
|
||||
Ok(Fit::Exhausted(deviation))
|
||||
}
|
||||
|
||||
/// The fitted surface with the crown's bump (see [`fill_loop`]): `crown == 0` gives it back as it
|
||||
/// is. A control point whose support rectangle keeps clear of the loop takes the bump's blossom
|
||||
/// coefficients, so the surface between the perturbed points is the bubble exactly and the
|
||||
/// surface over the loop is not moved at all (those points' basis functions are zero all along
|
||||
/// it). A fitted net is often too coarse to hold one; it is then refined by knot insertion, which
|
||||
/// leaves the surface itself as it is, until it does. Returns the crowned surface, how many
|
||||
/// control points took the bump, and the farthest the bump moved the surface at a sampled loop
|
||||
/// point (0).
|
||||
fn crown_fill(surface: NurbsSurface, uv: &[[f64; 2]], crown: f64, normal: Vec3) -> SplineResult<(NurbsSurface, usize, f64)> {
|
||||
if crown == 0.0 {
|
||||
return Ok((surface, 0, 0.0));
|
||||
}
|
||||
let gap = loop_gap(uv);
|
||||
let mut base = surface;
|
||||
loop {
|
||||
if let Some((crowned, points)) = crown_net(&base, uv, gap, crown, normal)? {
|
||||
let mut drift = 0.0f64;
|
||||
for q in uv {
|
||||
if let (Ok(a), Ok(b)) = (base.eval(q[0], q[1]), crowned.eval(q[0], q[1])) {
|
||||
drift = drift.max(a.dist(b));
|
||||
}
|
||||
}
|
||||
if drift > 0.0 {
|
||||
return Err(SplineError::Unsupported("crowning a patch whose loop the fill cannot keep clear".into()));
|
||||
}
|
||||
return Ok((crowned, points, drift));
|
||||
}
|
||||
// No room inside the loop yet: halve the cells (the surface itself does not change).
|
||||
let spans = [0, 1].map(|d| base.count()[d].saturating_sub(3));
|
||||
if spans[0] >= MAX_FILL_SPANS && spans[1] >= MAX_FILL_SPANS {
|
||||
return Err(SplineError::Unsupported("crowning a patch whose loop leaves no room inside it".into()));
|
||||
}
|
||||
for (d, &s) in spans.iter().enumerate() {
|
||||
if s < MAX_FILL_SPANS {
|
||||
base = subdivide(&base, d)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The crown's bump in the net `base`: a control point whose support rectangle keeps clear of the
|
||||
/// loop takes `crown · size · B(ξ, η)`, `B` the bubble's blossom at the point's knots (so the
|
||||
/// surface between the perturbed points is exactly the bubble, not a fit of it) and `size` the
|
||||
/// box's diagonal. `None` when the net has no such point.
|
||||
fn crown_net(base: &NurbsSurface, uv: &[[f64; 2]], gap: [f64; 2], crown: f64, normal: Vec3) -> SplineResult<Option<(NurbsSurface, usize)>> {
|
||||
let [cu, cv] = base.count();
|
||||
let degree = base.degree();
|
||||
let knots = base.knots();
|
||||
let domain = base.domain();
|
||||
let size = (domain[0][1] - domain[0][0]).hypot(domain[1][1] - domain[1][0]);
|
||||
if !(size > 0.0 && size.is_finite() && normal.is_finite()) {
|
||||
return invalid("the loop's extent is not finite");
|
||||
}
|
||||
// The bubble `4·s·(1−s)` per direction, as a quadratic in the plane coordinate.
|
||||
let quad = |d: usize| {
|
||||
let (lo, hi) = (domain[d][0], domain[d][1]);
|
||||
let w = hi - lo;
|
||||
(-4.0 * lo * hi / (w * w), 4.0 * (lo + hi) / (w * w), -4.0 / (w * w))
|
||||
};
|
||||
let (qu, qv) = (quad(0), quad(1));
|
||||
let (Some(knots_u), Some(knots_v)) = (knots.first(), knots.get(1)) else { return invalid("the surface has no knot vectors") };
|
||||
let mut ctrl = base.homogeneous().to_vec();
|
||||
let mut points = 0usize;
|
||||
for j in 0..cv {
|
||||
let Some((v_span, v_knots)) = support(knots_v, degree[1], j) else { continue };
|
||||
for i in 0..cu {
|
||||
let Some((u_span, u_knots)) = support(knots_u, degree[0], i) else { continue };
|
||||
if !clear_of_loop(u_span, v_span, uv, gap) {
|
||||
continue;
|
||||
}
|
||||
let bump = crown * size * blossom(qu, u_knots) * blossom(qv, v_knots);
|
||||
let Some(slot) = ctrl.get_mut(j * cu + i) else { continue };
|
||||
let h = *slot;
|
||||
let Some(p) = h.project() else { continue };
|
||||
*slot = HPoint::weighted(p + normal * bump, h.w);
|
||||
points += 1;
|
||||
}
|
||||
}
|
||||
if points == 0 {
|
||||
return Ok(None);
|
||||
}
|
||||
Ok(Some((NurbsSurface::from_homogeneous(degree, knots.clone(), ctrl)?, points)))
|
||||
}
|
||||
|
||||
/// The same surface with a knot inserted in the middle of every span of direction `d` (0 = u):
|
||||
/// the surface itself does not change, only its net is finer, which is what gives the crown room
|
||||
/// inside the loop.
|
||||
fn subdivide(surface: &NurbsSurface, d: usize) -> SplineResult<NurbsSurface> {
|
||||
let (degree, count) = (surface.degree()[d], surface.count()[d]);
|
||||
let knots = surface.knots()[d].clone();
|
||||
let mut mids = Vec::new();
|
||||
for i in degree..count {
|
||||
let (a, b) = (knots.get(i).copied().unwrap_or(0.0), knots.get(i + 1).copied().unwrap_or(0.0));
|
||||
if b > a {
|
||||
mids.push(0.5 * (a + b));
|
||||
}
|
||||
}
|
||||
let mut out = surface.clone();
|
||||
for m in mids {
|
||||
out = out.insert_knot(if d == 0 { Dir::S } else { Dir::T }, m)?;
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// A control point's knot interval — where its basis is non-zero — and its knot triple, whose
|
||||
/// blossom is the value the point must take for the spline to reproduce a quadratic exactly.
|
||||
fn support(knots: &[f64], degree: usize, i: usize) -> Option<([f64; 2], [f64; 3])> {
|
||||
let interval = [*knots.get(i)?, *knots.get(i + degree + 1)?];
|
||||
let triple = [*knots.get(i + 1)?, *knots.get(i + 2)?, *knots.get(i + 3)?];
|
||||
(interval[1] >= interval[0]).then_some((interval, triple))
|
||||
}
|
||||
|
||||
/// A quadratic `a + b·x + c·x²`'s blossom at a knot triple.
|
||||
fn blossom(quad: (f64, f64, f64), t: [f64; 3]) -> f64 {
|
||||
let (a, b, c) = quad;
|
||||
let mean = (t[0] + t[1] + t[2]) / 3.0;
|
||||
let pair = (t[0] * t[1] + t[1] * t[2] + t[0] * t[2]) / 3.0;
|
||||
a + b * mean + c * pair
|
||||
}
|
||||
|
||||
/// Whether the parameter rectangle `u` × `v` keeps clear of the sampled loop: its middle is
|
||||
/// inside the loop and no loop segment comes within `gap` of it. A control point whose support
|
||||
/// keeps clear takes the crown's bump without moving the surface over the loop.
|
||||
fn clear_of_loop(u: [f64; 2], v: [f64; 2], uv: &[[f64; 2]], gap: [f64; 2]) -> bool {
|
||||
if !inside_loop([(u[0] + u[1]) / 2.0, (v[0] + v[1]) / 2.0], uv) {
|
||||
return false;
|
||||
}
|
||||
let lo = [u[0] - gap[0], v[0] - gap[1]];
|
||||
let hi = [u[1] + gap[0], v[1] + gap[1]];
|
||||
let m = uv.len();
|
||||
(0..m).all(|k| {
|
||||
let (Some(a), Some(b)) = (uv.get(k).copied(), uv.get((k + 1) % m).copied()) else { return false };
|
||||
!segment_meets_rect(a, b, lo, hi)
|
||||
})
|
||||
}
|
||||
|
||||
/// The largest step between neighbouring samples of the loop, per direction: a rectangle this far
|
||||
/// clear of the sampled loop cannot be entered by the edges between the samples either.
|
||||
fn loop_gap(uv: &[[f64; 2]]) -> [f64; 2] {
|
||||
let m = uv.len();
|
||||
let mut gap = [0.0f64; 2];
|
||||
for k in 0..m {
|
||||
let (Some(a), Some(b)) = (uv.get(k).copied(), uv.get((k + 1) % m).copied()) else { continue };
|
||||
for d in 0..2 {
|
||||
gap[d] = gap[d].max((b[d] - a[d]).abs());
|
||||
}
|
||||
}
|
||||
gap
|
||||
}
|
||||
|
||||
/// Whether `p` is inside the closed loop `uv` (ray casting).
|
||||
fn inside_loop(p: [f64; 2], uv: &[[f64; 2]]) -> bool {
|
||||
let m = uv.len();
|
||||
let mut inside = false;
|
||||
for k in 0..m {
|
||||
let (Some(a), Some(b)) = (uv.get(k).copied(), uv.get((k + 1) % m).copied()) else { continue };
|
||||
if (a[1] > p[1]) != (b[1] > p[1]) && p[0] < a[0] + (p[1] - a[1]) / (b[1] - a[1]) * (b[0] - a[0]) {
|
||||
inside = !inside;
|
||||
}
|
||||
}
|
||||
inside
|
||||
}
|
||||
|
||||
/// Whether the segment `p`–`q` meets the rectangle `lo`–`hi` (Liang–Barsky clipping).
|
||||
fn segment_meets_rect(p: [f64; 2], q: [f64; 2], lo: [f64; 2], hi: [f64; 2]) -> bool {
|
||||
let (mut t0, mut t1) = (0.0f64, 1.0f64);
|
||||
for d in 0..2 {
|
||||
let delta = q[d] - p[d];
|
||||
if delta == 0.0 {
|
||||
if p[d] < lo[d] || p[d] > hi[d] {
|
||||
return false;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let (mut a, mut b) = ((lo[d] - p[d]) / delta, (hi[d] - p[d]) / delta);
|
||||
if a > b {
|
||||
std::mem::swap(&mut a, &mut b);
|
||||
}
|
||||
t0 = t0.max(a);
|
||||
t1 = t1.min(b);
|
||||
if t0 > t1 {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
/// Refuse a loop that does not bound a height field over its plane (see [`fill_loop`]).
|
||||
fn check_projectable(points: &[Vec3], uv: &[[f64; 2]]) -> SplineResult<()> {
|
||||
let m = uv.len();
|
||||
@@ -599,7 +819,7 @@ mod tests {
|
||||
// A tilted plane over a hexagon: the smoothness energy vanishes on it, so the fill is it.
|
||||
let hex = ring(6, 10.0);
|
||||
let plane = |x: f64, y: f64| 0.3 * x - 0.2 * y + 1.0;
|
||||
let f = fill_loop(6, &mut lifted(&hex, &plane), 1e-6).unwrap();
|
||||
let f = fill_loop(6, &mut lifted(&hex, &plane), 1e-6, 0.0).unwrap();
|
||||
let inside = off_inside(&f, &hex, &plane);
|
||||
eprintln!("plane: deviation {:e}, inside off by {inside:e}, {} evaluations", f.deviation, f.evaluations);
|
||||
assert!(f.deviation <= 1e-6 && inside < 1e-9);
|
||||
@@ -608,7 +828,7 @@ mod tests {
|
||||
let saddle = |x: f64, y: f64| 0.05 * x * y;
|
||||
let dome = |x: f64, y: f64| 3.0 - 0.02 * (x * x + y * y);
|
||||
for (name, z, bound) in [("saddle", &saddle as &dyn Fn(f64, f64) -> f64, 0.1), ("dome", &dome, 1.0)] {
|
||||
let f = fill_loop(6, &mut lifted(&hex, z), 2e-5).unwrap();
|
||||
let f = fill_loop(6, &mut lifted(&hex, z), 2e-5, 0.0).unwrap();
|
||||
let inside = off_inside(&f, &hex, z);
|
||||
eprintln!("{name}: deviation {:e}, inside off by {inside:e}", f.deviation);
|
||||
assert!(f.deviation <= 2e-5 && inside < bound, "{name}: {inside}");
|
||||
@@ -638,7 +858,7 @@ mod tests {
|
||||
let flat_corner = vec![[-10.0, -10.0], [0.0, -10.0], [10.0, -10.0], [10.0, 10.0], [-10.0, 10.0]];
|
||||
for (name, c) in [("dart", dart), ("arrow", arrow), ("plus", plus), ("flat corner", flat_corner)] {
|
||||
let n = c.len();
|
||||
let f = fill_loop(n, &mut lifted(&c, &z), 1e-4).unwrap();
|
||||
let f = fill_loop(n, &mut lifted(&c, &z), 1e-4, 0.0).unwrap();
|
||||
let inside = off_inside(&f, &c, &z);
|
||||
eprintln!("{name}: deviation {:e}, inside off the cylinder by {inside:e}, {} evaluations", f.deviation, f.evaluations);
|
||||
// The least-bending fill, not the cylinder: within a few tenths of a millimetre of it.
|
||||
@@ -647,7 +867,7 @@ mod tests {
|
||||
let mut back = c.clone();
|
||||
back.rotate_left(2);
|
||||
back.reverse();
|
||||
let g = fill_loop(n, &mut lifted(&back, &z), 1e-4).unwrap();
|
||||
let g = fill_loop(n, &mut lifted(&back, &z), 1e-4, 0.0).unwrap();
|
||||
assert_ne!(f.counter_clockwise, g.counter_clockwise);
|
||||
for (x, y) in [(4.0, 0.0), (6.0, 1.0), (5.0, -1.0)] {
|
||||
let p = Vec3::new(x, y, z(x, y));
|
||||
@@ -663,7 +883,7 @@ mod tests {
|
||||
// scaled and moved alike.
|
||||
let z = |x: f64, _: f64| 50.0 - (1600.0 - x * x).sqrt();
|
||||
let arrow = [[0.0, 0.0], [10.0, -8.0], [10.0, -3.0], [20.0, 0.0], [10.0, 3.0]];
|
||||
let f = fill_loop(5, &mut lifted(&arrow, &z), 1e-4).unwrap();
|
||||
let f = fill_loop(5, &mut lifted(&arrow, &z), 1e-4, 0.0).unwrap();
|
||||
let axis = Vec3::new(1.0, -2.0, 0.5).normalized().unwrap();
|
||||
let shift = Vec3::new(30.0, -12.0, 7.0);
|
||||
for scale in [100.0, 0.01] {
|
||||
@@ -674,7 +894,7 @@ mod tests {
|
||||
p * c + axis.cross(p) * s + axis * (axis.dot(p) * (1.0 - c)) + shift * scale
|
||||
};
|
||||
let mut moved = |k: usize, t: f64| lifted(&arrow, &z)(k, t).map(place);
|
||||
let g = fill_loop(5, &mut moved, 1e-4 * scale).unwrap();
|
||||
let g = fill_loop(5, &mut moved, 1e-4 * scale, 0.0).unwrap();
|
||||
let mut worst = 0.0f64;
|
||||
for (x, y) in [(4.0, 0.0), (6.0, 1.0), (5.0, -1.0), (9.0, -2.0), (12.0, 0.5)] {
|
||||
let p = Vec3::new(x, y, z(x, y));
|
||||
@@ -690,7 +910,7 @@ mod tests {
|
||||
// A 200 × 1 mm slot on a cylinder of radius 300 running along it.
|
||||
let z = |x: f64, _: f64| 300.0 - (90_000.0 - (x - 100.0) * (x - 100.0)).sqrt();
|
||||
let slot = [[0.0, 0.0], [200.0, 0.0], [200.0, 1.0], [0.0, 1.0]];
|
||||
let f = fill_loop(4, &mut lifted(&slot, &z), 2e-4).unwrap();
|
||||
let f = fill_loop(4, &mut lifted(&slot, &z), 2e-4, 0.0).unwrap();
|
||||
let inside = off_inside(&f, &slot, &z);
|
||||
eprintln!("slot: deviation {:e}, inside off the cylinder by {inside:e}, {} evaluations", f.deviation, f.evaluations);
|
||||
assert!(f.deviation <= 2e-4 && inside < 1e-2);
|
||||
@@ -702,7 +922,7 @@ mod tests {
|
||||
let flat = |_: f64, _: f64| 0.0;
|
||||
// A figure eight (lobes of different sizes).
|
||||
let eight = [[0.0, 0.0], [10.0, 10.0], [10.0, 0.0], [0.0, 6.0]];
|
||||
assert!(unsupported(fill_loop(4, &mut lifted(&eight, &flat), 1e-4)));
|
||||
assert!(unsupported(fill_loop(4, &mut lifted(&eight, &flat), 1e-4, 0.0)));
|
||||
// A loop with a vertical spike in it (up along the normal and down again).
|
||||
let spike = [
|
||||
Vec3::ZERO,
|
||||
@@ -713,30 +933,77 @@ mod tests {
|
||||
Vec3::new(5.0, 10.0, 0.0),
|
||||
Vec3::new(0.0, 10.0, 0.0),
|
||||
];
|
||||
assert!(unsupported(fill_loop(7, &mut polygon3(&spike), 1e-4)));
|
||||
assert!(unsupported(fill_loop(7, &mut polygon3(&spike), 1e-4, 0.0)));
|
||||
// A loop that runs back over itself.
|
||||
let back = [[0.0, 0.0], [10.0, 0.0], [4.0, 0.0], [10.0, 10.0], [0.0, 10.0]];
|
||||
assert!(unsupported(fill_loop(5, &mut lifted(&back, &flat), 1e-4)));
|
||||
assert!(unsupported(fill_loop(5, &mut lifted(&back, &flat), 1e-4, 0.0)));
|
||||
// A loop too wavy for one surface.
|
||||
let wavy = |x: f64, y: f64| (x * 9.0).sin() * (y * 7.0).cos();
|
||||
assert!(unsupported(fill_loop(64, &mut lifted(&ring(64, 10.0), &wavy), 1e-6)));
|
||||
assert!(unsupported(fill_loop(64, &mut lifted(&ring(64, 10.0), &wavy), 1e-6, 0.0)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_loops_are_refused() {
|
||||
let flat = |_: f64, _: f64| 0.0;
|
||||
let five = ring(5, 10.0);
|
||||
assert!(fill_loop(0, &mut lifted(&five, &flat), 1e-4).is_err());
|
||||
assert!(fill_loop(5, &mut |_, _| Some(Vec3::X), 1e-4).is_err(), "no area");
|
||||
assert!(fill_loop(5, &mut |_, _| None, 1e-4).is_err());
|
||||
assert!(fill_loop(5, &mut |k, t| Some(Vec3::new(k as f64, t, f64::NAN)), 1e-4).is_err());
|
||||
assert!(fill_loop(5, &mut lifted(&five, &flat), 0.0).is_err() && fill_loop(5, &mut lifted(&five, &flat), f64::NAN).is_err());
|
||||
assert!(fill_loop(10_000, &mut lifted(&five, &flat), 1e-4).is_err());
|
||||
assert!(fill_loop(0, &mut lifted(&five, &flat), 1e-4, 0.0).is_err());
|
||||
assert!(fill_loop(5, &mut |_, _| Some(Vec3::X), 1e-4, 0.0).is_err(), "no area");
|
||||
assert!(fill_loop(5, &mut |_, _| None, 1e-4, 0.0).is_err());
|
||||
assert!(fill_loop(5, &mut |k, t| Some(Vec3::new(k as f64, t, f64::NAN)), 1e-4, 0.0).is_err());
|
||||
assert!(fill_loop(5, &mut lifted(&five, &flat), 0.0, 0.0).is_err() && fill_loop(5, &mut lifted(&five, &flat), f64::NAN, 0.0).is_err());
|
||||
assert!(fill_loop(10_000, &mut lifted(&five, &flat), 1e-4, 0.0).is_err());
|
||||
let huge = |x: f64, y: f64| (x * y) * 1e300;
|
||||
let _ = fill_loop(5, &mut lifted(&five, &huge), 1e-4);
|
||||
let _ = fill_loop(5, &mut lifted(&five, &huge), 1e-4, 0.0);
|
||||
let tiny: Vec<[f64; 2]> = five.iter().map(|p| [p[0] * 1e-300, p[1] * 1e-300]).collect();
|
||||
let _ = fill_loop(5, &mut lifted(&tiny, &flat), 1e-4);
|
||||
let _ = fill_loop(5, &mut lifted(&tiny, &flat), 1e-4, 0.0);
|
||||
let big: Vec<[f64; 2]> = five.iter().map(|p| [p[0] * 1e300, p[1] * 1e300]).collect();
|
||||
let _ = fill_loop(5, &mut lifted(&big, &flat), 1e-4);
|
||||
let _ = fill_loop(5, &mut lifted(&big, &flat), 1e-4, 0.0);
|
||||
}
|
||||
|
||||
/// A patch whose rim is a dome: the crown fills its middle by `crown` times the loop's size
|
||||
/// and leaves the loop — the body's own edges — exactly where it was.
|
||||
#[test]
|
||||
fn a_crown_fills_the_middle_of_a_patch_and_leaves_its_loop_alone() {
|
||||
let hex = ring(6, 10.0);
|
||||
let dome = |x: f64, y: f64| 3.0 - 0.02 * (x * x + y * y);
|
||||
let plain = fill_loop(6, &mut lifted(&hex, &dome), 2e-5, 0.0).unwrap();
|
||||
// Crown 0 is the fit as it was: no refinement, no bump, nothing moved.
|
||||
assert_eq!((plain.crown, plain.crowned, plain.crown_drift), (0.0, 0, 0.0));
|
||||
assert_eq!(plain.surface.count(), [19, 17], "crown 0 keeps the fitted net (16 × 14 spans)");
|
||||
let crown = 0.25;
|
||||
let full = fill_loop(6, &mut lifted(&hex, &dome), 2e-5, crown).unwrap();
|
||||
assert!(full.crowned > 0, "the crown needs room inside the loop");
|
||||
assert_eq!(full.crown_drift, 0.0, "the bump must not move the loop at all");
|
||||
assert_eq!(full.deviation, plain.deviation, "the crown must not touch the fit");
|
||||
// The middle of the box rises by `crown` times the loop's size: the bubble is 1 there.
|
||||
let [du, dv] = plain.surface.domain();
|
||||
let (uc, vc) = ((du[0] + du[1]) / 2.0, (dv[0] + dv[1]) / 2.0);
|
||||
let size = (du[1] - du[0]).hypot(dv[1] - dv[0]);
|
||||
let mid = |f: &LoopFill| f.surface.eval(uc, vc).unwrap_or(Vec3::ZERO);
|
||||
let bump = (mid(&full) - mid(&plain)).dot(plain.normal);
|
||||
eprintln!("crown {crown}: {} points took the bump, the middle rose by {bump} of {}", full.crowned, crown * size);
|
||||
assert!((bump - crown * size).abs() < 1e-9 * size, "the middle rose by {bump}, wanted {}", crown * size);
|
||||
// A flatter crown lowers the middle by the same.
|
||||
let flat = fill_loop(6, &mut lifted(&hex, &dome), 2e-5, -crown).unwrap();
|
||||
let dip = (mid(&flat) - mid(&plain)).dot(plain.normal);
|
||||
assert!((dip + crown * size).abs() < 1e-9 * size, "the middle fell by {dip}");
|
||||
// The loop's own points are still on the surface, as closely as they were.
|
||||
let off = |f: &LoopFill| {
|
||||
hex.iter()
|
||||
.map(|p| f.point_over(Vec3::new(p[0], p[1], dome(p[0], p[1]))).map_or(f64::INFINITY, |q| (q.z - dome(p[0], p[1])).abs()))
|
||||
.fold(0.0f64, f64::max)
|
||||
};
|
||||
assert!(off(&full) <= off(&plain) + 1e-9, "the crowned fill left the loop: {:e} against {:e}", off(&full), off(&plain));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_crowns_are_refused() {
|
||||
let hex = ring(6, 10.0);
|
||||
let dome = |x: f64, y: f64| 3.0 - 0.02 * (x * x + y * y);
|
||||
for crown in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, 3.01, -0.91, 1e300] {
|
||||
assert!(fill_loop(6, &mut lifted(&hex, &dome), 2e-5, crown).is_err(), "crown {crown}");
|
||||
}
|
||||
assert!(fill_loop(6, &mut lifted(&hex, &dome), 2e-5, MAX_CROWN).is_ok());
|
||||
assert!(fill_loop(6, &mut lifted(&hex, &dome), 2e-5, MIN_CROWN).is_ok());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,653 @@
|
||||
//! Continuity-driven bridging surfaces: one B-spline face that leaves one surface and arrives at
|
||||
//! another with a requested continuity (G0 up to G3). This is the core the Blend, Boundary and
|
||||
//! Match surfaces are built on.
|
||||
//!
|
||||
//! A bridge is a tensor product. Across it (v) every station's cross-section is a Bézier whose
|
||||
//! leading control points reproduce the support surface's derivatives — the Hermite rows — so the
|
||||
//! finished face carries the requested continuity by construction: one control row per condition
|
||||
//! (position, tangent, curvature, change of curvature). Along it (u) those cross-sections are
|
||||
//! interpolated by a cubic, so the face passes through every station exactly. Every condition is
|
||||
//! stated against the support surface's own derivatives measured along the direction the bridge
|
||||
//! leaves in, which makes G2 the curvature vector and G3 the way that curvature vector changes
|
||||
//! along that direction (its normal part: what a surface-to-surface match can hold).
|
||||
//!
|
||||
//! What the support surface does along the leave direction is read off from samples on its own
|
||||
//! parameter line (the line through the station that leaves in the leave direction at unit
|
||||
//! speed) by finite differences: the second derivative of a surface curve with a unit tangent is
|
||||
//! its curvature vector, and the third is the arclength derivative of that curvature vector.
|
||||
|
||||
use mt::{BoundedCurve, ParametricCurve, ParametricSurface, ParametricSurface3D, SearchNearestParameter};
|
||||
use solidcraft_geom::Vec3;
|
||||
use solidcraft_geom::bspline::{CurveN, HPoint, NurbsSurface};
|
||||
use truck_modeling as mt;
|
||||
|
||||
use crate::body::{Body, from_p3, p3};
|
||||
use crate::surfaces::surface_body;
|
||||
use crate::{KernelError, Result, guard};
|
||||
|
||||
/// How much of a support surface a bridge repeats along its boundary.
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default, serde::Serialize, serde::Deserialize)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
pub enum Continuity {
|
||||
/// The boundary curve alone: the surfaces meet, nothing else.
|
||||
G0,
|
||||
/// Position and tangent plane.
|
||||
#[default]
|
||||
G1,
|
||||
/// Position, tangent plane and curvature vector.
|
||||
G2,
|
||||
/// Position, tangent plane, curvature vector and its change along the leave direction.
|
||||
G3,
|
||||
}
|
||||
|
||||
impl Continuity {
|
||||
/// Conditions a side carries: 1 (G0) up to 4 (G3).
|
||||
pub fn conditions(self) -> usize {
|
||||
match self {
|
||||
Continuity::G0 => 1,
|
||||
Continuity::G1 => 2,
|
||||
Continuity::G2 => 3,
|
||||
Continuity::G3 => 4,
|
||||
}
|
||||
}
|
||||
|
||||
/// The word a command parameter uses.
|
||||
pub fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Continuity::G0 => "g0",
|
||||
Continuity::G1 => "g1",
|
||||
Continuity::G2 => "g2",
|
||||
Continuity::G3 => "g3",
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse `g0`…`g3` (upper case accepted), `None` for anything else.
|
||||
pub fn parse(s: &str) -> Option<Continuity> {
|
||||
match s.to_ascii_lowercase().as_str() {
|
||||
"g0" => Some(Continuity::G0),
|
||||
"g1" => Some(Continuity::G1),
|
||||
"g2" => Some(Continuity::G2),
|
||||
"g3" => Some(Continuity::G3),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// One station of a boundary: where the bridge starts, the direction it leaves in, and what the
|
||||
/// support surface does there along that direction.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct Frame {
|
||||
/// The point on the boundary.
|
||||
pub p: Vec3,
|
||||
/// Unit direction the bridge leaves *towards the other boundary*, in the tangent plane of
|
||||
/// the support surface at `p`.
|
||||
pub leave: Vec3,
|
||||
/// The support surface's curvature vector along `leave` (zero on a plane).
|
||||
pub bend: Vec3,
|
||||
/// The arclength derivative of `bend` along `leave` (zero on a plane).
|
||||
pub bend_change: Vec3,
|
||||
}
|
||||
|
||||
/// The edges of `body` picked by points on them, chained: each runs on from the last, and the
|
||||
/// chain may close. Used with [`frames`], whose chain must be a chain of one face's own edges.
|
||||
pub fn chain(body: &Body, at: &[Vec3]) -> Result<Vec<mt::Edge>> {
|
||||
body.require_brep("blend")?;
|
||||
if at.is_empty() || at.len() > 10_000 || at.iter().any(|p| !p.is_finite()) {
|
||||
return Err(KernelError::Invalid("pick 1 to 10000 points on the edges of a chain".into()));
|
||||
}
|
||||
let mut pool: Vec<mt::Edge> = Vec::new();
|
||||
for p in at {
|
||||
let e = crate::surfaces::edge_near(body, *p).ok_or_else(|| KernelError::Invalid("no edge near a picked point".to_string()))?;
|
||||
if !pool.iter().any(|x| x.id() == e.id()) {
|
||||
pool.push(e);
|
||||
}
|
||||
}
|
||||
let first = pool.remove(0);
|
||||
let mut chain = vec![first];
|
||||
// The picks need not be given in order: run forward from the first edge, then backwards.
|
||||
let mut end = match chain.first() {
|
||||
Some(e) => e.back().clone(),
|
||||
None => return Err(KernelError::Invalid("pick at least one edge".into())),
|
||||
};
|
||||
while let Some(k) = pool.iter().position(|e| e.front().id() == end.id() || e.back().id() == end.id()) {
|
||||
let e = pool.remove(k);
|
||||
let e = if e.front().id() == end.id() { e } else { e.inverse() };
|
||||
end = e.back().clone();
|
||||
chain.push(e);
|
||||
}
|
||||
let mut start = match chain.first() {
|
||||
Some(e) => e.front().clone(),
|
||||
None => return Err(KernelError::Invalid("pick at least one edge".into())),
|
||||
};
|
||||
while let Some(k) = pool.iter().position(|e| e.front().id() == start.id() || e.back().id() == start.id()) {
|
||||
let e = pool.remove(k);
|
||||
let e = if e.back().id() == start.id() { e } else { e.inverse() };
|
||||
start = e.front().clone();
|
||||
chain.insert(0, e);
|
||||
}
|
||||
if !pool.is_empty() {
|
||||
return Err(KernelError::Invalid("the picked edges do not run on from one another".into()));
|
||||
}
|
||||
Ok(chain)
|
||||
}
|
||||
|
||||
/// Whether a chain of edges closes back on itself.
|
||||
pub fn chain_closes(chain: &[mt::Edge]) -> bool {
|
||||
let (Some(first), Some(last)) = (chain.first(), chain.last()) else { return false };
|
||||
first.front().id() == last.back().id()
|
||||
}
|
||||
|
||||
/// The stations of a chain of edges, `count` of them evenly along its length, and the length
|
||||
/// itself. A chain that closes is sampled with its last station back on its first.
|
||||
fn chain_samples(edges: &[mt::Edge], count: usize) -> Result<(Vec<Vec3>, f64)> {
|
||||
/// Samples per edge used for the length table.
|
||||
const PER_EDGE: usize = 64;
|
||||
let mut poly: Vec<Vec3> = Vec::with_capacity(edges.len() * (PER_EDGE + 1));
|
||||
for e in edges {
|
||||
let c = e.curve();
|
||||
let (t0, t1) = c.range_tuple();
|
||||
if !(t1 > t0) || ![t0, t1].into_iter().all(f64::is_finite) {
|
||||
return Err(KernelError::Invalid("an edge has no parameter range".into()));
|
||||
}
|
||||
for k in 0..=PER_EDGE {
|
||||
poly.push(from_p3(c.subs(t0 + (t1 - t0) * k as f64 / PER_EDGE as f64)));
|
||||
}
|
||||
}
|
||||
if chain_closes(edges)
|
||||
&& let Some(first) = poly.first().copied()
|
||||
{
|
||||
poly.push(first);
|
||||
}
|
||||
let mut cum = Vec::with_capacity(poly.len());
|
||||
cum.push(0.0);
|
||||
for w in poly.windows(2) {
|
||||
let (Some(a), Some(b)) = (w.first(), w.get(1)) else { continue };
|
||||
let Some(last) = cum.last().copied() else { break };
|
||||
cum.push(last + a.dist(*b));
|
||||
}
|
||||
let total = cum.last().copied().unwrap_or(0.0);
|
||||
if !(total > 1e-9) || !total.is_finite() {
|
||||
return Err(KernelError::Invalid("the edge chain has no length".into()));
|
||||
}
|
||||
let mut out = Vec::with_capacity(count);
|
||||
for i in 0..count {
|
||||
let s = total * i as f64 / (count.max(2) - 1) as f64;
|
||||
let hi = cum.partition_point(|x| *x < s).clamp(1, poly.len().saturating_sub(1));
|
||||
let (Some(a), Some(b)) = (poly.get(hi - 1), poly.get(hi)) else { return Err(KernelError::Failed("bridge: sample".into())) };
|
||||
let (Some(&lo), Some(&hi_s)) = (cum.get(hi - 1), cum.get(hi)) else { return Err(KernelError::Failed("bridge: sample".into())) };
|
||||
let span = hi_s - lo;
|
||||
let t = if span > 1e-12 { (s - lo) / span } else { 0.0 };
|
||||
out.push(*a + (*b - *a) * t);
|
||||
}
|
||||
Ok((out, total))
|
||||
}
|
||||
|
||||
/// The support surface's frames along `edges` (a chain of its own edges), for a bridge that
|
||||
/// leaves in direction `leave` (projected into the tangent plane at each station).
|
||||
pub fn frames(face: &mt::Face, edges: &[mt::Edge], leave: Vec3, count: usize) -> Result<Vec<Frame>> {
|
||||
if !(2..=4097).contains(&count) {
|
||||
return Err(KernelError::Invalid("a bridge needs 2 to 4097 stations".into()));
|
||||
}
|
||||
let leave =
|
||||
leave.normalized().filter(|l| l.is_finite()).ok_or_else(|| KernelError::Invalid("the leave direction must be a finite vector".into()))?;
|
||||
let (pts, length) = chain_samples(edges, count)?;
|
||||
let surf = face.surface();
|
||||
let (Some(range_u), Some(range_v)) = surf.try_range_tuple() else {
|
||||
return Err(KernelError::Failed("bridge: the support surface is unbounded".into()));
|
||||
};
|
||||
// A face's own edges may sit a fit tolerance off its surface (a cylinder's wall as a NURBS
|
||||
// next to its exact ring), so the projection is only asked to be close, not exact.
|
||||
let tol = (length * 1e-4).max(1e-6);
|
||||
// Finite-difference step: a thousandth of the chain, so curvature over the chain is read
|
||||
// locally but round-off stays far below the geometry.
|
||||
let mut step = (length * 1e-3).clamp(1e-6, 0.5);
|
||||
let mut out = Vec::with_capacity(pts.len());
|
||||
// The station before this one, as the hint for the projection: it keeps the search on the
|
||||
// same side of a periodic or split surface.
|
||||
let mut hint: Option<(f64, f64)> = None;
|
||||
for p in &pts {
|
||||
let project = |hint: Option<(f64, f64)>| surf.search_nearest_parameter(p3(*p), hint, 100);
|
||||
let close = |uv: (f64, f64)| from_p3(surf.subs(uv.0, uv.1)).dist(*p) <= tol;
|
||||
// The station before this one is the hint where it lands close; a chain that wraps the
|
||||
// surface (or a periodic one) falls back to a free search.
|
||||
let (u, v) = match project(hint).filter(|uv| close(*uv)).or_else(|| project(None).filter(|uv| close(*uv))) {
|
||||
Some(uv) => uv,
|
||||
None => return Err(KernelError::Invalid("a picked edge is not on the support surface".into())),
|
||||
};
|
||||
hint = Some((u, v));
|
||||
let at = from_p3(surf.subs(u, v));
|
||||
if at.dist(*p) > tol {
|
||||
return Err(KernelError::Invalid("a picked edge is not on the support surface".into()));
|
||||
}
|
||||
let normal = surf.normal(u, v);
|
||||
let n = Vec3::new(normal.x, normal.y, normal.z)
|
||||
.normalized()
|
||||
.ok_or_else(|| KernelError::Failed("bridge: the support surface has no normal".into()))?;
|
||||
let w = (leave - n * leave.dot(n))
|
||||
.normalized()
|
||||
.ok_or_else(|| KernelError::Invalid("the leave direction is normal to the support surface: it has no tangent plane there".to_string()))?;
|
||||
// Parameter-space direction that leaves in `w` at unit 3D speed: S_u·du + S_v·dv = w.
|
||||
let su = tangent(&surf, u, v, range_u, true);
|
||||
let sv = tangent(&surf, u, v, range_v, false);
|
||||
let (a, b, c) = (su.dot(su), su.dot(sv), sv.dot(sv));
|
||||
let det = a * c - b * b;
|
||||
let scale = a.max(c).max(1e-30);
|
||||
if !(det.abs() > 1e-12 * scale * scale) {
|
||||
return Err(KernelError::Failed("bridge: the support surface is singular at the boundary".into()));
|
||||
}
|
||||
let du = (c * w.dot(su) - b * w.dot(sv)) / det;
|
||||
let dv = (a * w.dot(sv) - b * w.dot(su)) / det;
|
||||
// The samples of the parameter line. A station sits on the support surface's own
|
||||
// boundary, so the line usually leaves the surface: the shape is then read from the
|
||||
// samples of the one side that is still on it, which is the surface's own extension past
|
||||
// that boundary (exact for a plane and a cylinder, what a blend continues from).
|
||||
let slack = 1e-9;
|
||||
let on = |t: f64, h: f64| {
|
||||
let (x, y) = (u + t * h * du, v + t * h * dv);
|
||||
x >= range_u.0 - slack && x <= range_u.1 + slack && y >= range_v.0 - slack && y <= range_v.1 + slack
|
||||
};
|
||||
let central = [-2.0, -1.0, 0.0, 1.0, 2.0];
|
||||
let forward = [0.0, 1.0, 2.0, 3.0, 4.0];
|
||||
let backward = [0.0, -1.0, -2.0, -3.0, -4.0];
|
||||
let pick = |h: f64| -> Option<[f64; 5]> {
|
||||
if central.iter().all(|t| on(*t, h)) {
|
||||
Some(central)
|
||||
} else if forward.iter().all(|t| on(*t, h)) {
|
||||
Some(forward)
|
||||
} else if backward.iter().all(|t| on(*t, h)) {
|
||||
Some(backward)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
};
|
||||
let mut h = step;
|
||||
let mut chosen = pick(h);
|
||||
for _ in 0..8 {
|
||||
if chosen.is_some() {
|
||||
break;
|
||||
}
|
||||
h *= 0.25;
|
||||
chosen = pick(h);
|
||||
}
|
||||
let Some(offsets) = chosen else {
|
||||
return Err(KernelError::Invalid("the support surface is too small around a picked edge to read its shape".into()));
|
||||
};
|
||||
let q: Vec<Vec3> = offsets.iter().map(|t| from_p3(surf.subs(u + t * h * du, v + t * h * dv))).collect();
|
||||
let (Some(&f0), Some(&f1), Some(&f2), Some(&f3), Some(&f4)) = (q.first(), q.get(1), q.get(2), q.get(3), q.get(4)) else {
|
||||
return Err(KernelError::Failed("bridge: samples".into()));
|
||||
};
|
||||
// Central samples read the line both ways; one-sided samples read it one way only from the
|
||||
// station, backwards down it in the second case (the odd derivatives then change sign).
|
||||
let (d1, d2, d3) = if offsets[0] == 0.0 && offsets[1] < 0.0 {
|
||||
let d1 = (f0 * -25.0 + f1 * 48.0 + f2 * -36.0 + f3 * 16.0 + f4 * -3.0) * (-1.0 / (12.0 * h));
|
||||
let d2 = (f0 * 35.0 + f1 * -104.0 + f2 * 114.0 + f3 * -56.0 + f4 * 11.0) * (1.0 / (12.0 * h * h));
|
||||
let d3 = (f0 * -5.0 + f1 * 18.0 + f2 * -24.0 + f3 * 14.0 + f4 * -3.0) * (-1.0 / (2.0 * h * h * h));
|
||||
(d1, d2, d3)
|
||||
} else if offsets[0] == 0.0 {
|
||||
let d1 = (f0 * -25.0 + f1 * 48.0 + f2 * -36.0 + f3 * 16.0 + f4 * -3.0) * (1.0 / (12.0 * h));
|
||||
let d2 = (f0 * 35.0 + f1 * -104.0 + f2 * 114.0 + f3 * -56.0 + f4 * 11.0) * (1.0 / (12.0 * h * h));
|
||||
let d3 = (f0 * -5.0 + f1 * 18.0 + f2 * -24.0 + f3 * 14.0 + f4 * -3.0) * (1.0 / (2.0 * h * h * h));
|
||||
(d1, d2, d3)
|
||||
} else {
|
||||
let d1 = (f0 * -1.0 + f1 * 8.0 + f3 * -8.0 + f4) * (1.0 / (12.0 * h));
|
||||
let d2 = (f0 + f1 * -16.0 + f2 * 30.0 + f3 * -16.0 + f4) * (1.0 / (12.0 * h * h));
|
||||
let d3 = (f0 * -1.0 + f1 * 2.0 + f3 * -2.0 + f4) * (1.0 / (2.0 * h * h * h));
|
||||
(d1, d2, d3)
|
||||
};
|
||||
let (t, bend, bend_change) = shape(d1, d2, d3)?;
|
||||
// Read the same curve the other way when the surface's own parameter direction runs
|
||||
// against the leave direction: the curvature vector is the same either way, the change of
|
||||
// curvature turns round with the direction of travel.
|
||||
let bend_change = if t.dot(w) < 0.0 { -bend_change } else { bend_change };
|
||||
out.push(Frame { p: *p, leave: w, bend, bend_change });
|
||||
step = h;
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// A first derivative of the surface in one parameter, by central differences (one-sided where
|
||||
/// the parameter is at the edge of the domain).
|
||||
fn tangent(surf: &mt::Surface, u: f64, v: f64, range: (f64, f64), along_u: bool) -> Vec3 {
|
||||
let span = (range.1 - range.0).max(1e-12);
|
||||
let h = (span * 1e-5).max(1e-12);
|
||||
let at = |x: f64| if along_u { from_p3(surf.subs(x, v)) } else { from_p3(surf.subs(u, x)) };
|
||||
let x = if along_u { u } else { v };
|
||||
if x - h >= range.0 && x + h <= range.1 {
|
||||
(at(x + h) - at(x - h)) * (0.5 / h)
|
||||
} else if x + h <= range.1 {
|
||||
(at(x + h) - at(x)) * (1.0 / h)
|
||||
} else {
|
||||
(at(x.min(range.1)) - at((x - h).max(range.0))) * (1.0 / h)
|
||||
}
|
||||
}
|
||||
|
||||
/// The geometric shape of a surface curve at a point from its first three derivatives along the
|
||||
/// curve: the unit tangent, the curvature vector and the arclength derivative of that curvature
|
||||
/// vector. All three are what a surface-to-surface continuity condition is stated with.
|
||||
fn shape(d1: Vec3, d2: Vec3, d3: Vec3) -> Result<(Vec3, Vec3, Vec3)> {
|
||||
let sigma = d1.len();
|
||||
if !(sigma > 1e-12) || !sigma.is_finite() {
|
||||
return Err(KernelError::Failed("bridge: the support surface's parameter line does not move".into()));
|
||||
}
|
||||
let t = d1 * (1.0 / sigma);
|
||||
let tp = d2 * (1.0 / sigma) - d1 * (d1.dot(d2) / (sigma * sigma * sigma));
|
||||
let nn = d2 - t * d2.dot(t);
|
||||
let np = d3 - t * d3.dot(t) - tp * d2.dot(t) - t * d2.dot(tp);
|
||||
let kappa = np * (sigma * sigma) - nn * (2.0 * d1.dot(d2));
|
||||
let bend_change = kappa * (1.0 / (sigma * sigma * sigma * sigma * sigma));
|
||||
if ![t, nn, bend_change].into_iter().all(Vec3::is_finite) {
|
||||
return Err(KernelError::Failed("bridge: the support surface's shape is not finite at the boundary".into()));
|
||||
}
|
||||
Ok((t, nn * (1.0 / (sigma * sigma)), bend_change))
|
||||
}
|
||||
|
||||
/// The third derivative a curve needs at a boundary so that the arclength derivative of its
|
||||
/// curvature vector is `target`, from its first two derivatives there. Only the normal-plane
|
||||
/// part of the third derivative can hold that condition; the rest is a reparameterisation of the
|
||||
/// cross-section and is left at zero.
|
||||
fn third_derivative(d1: Vec3, d2: Vec3, target: Vec3) -> Result<Vec3> {
|
||||
let sigma = d1.len();
|
||||
if !(sigma > 1e-12) || !sigma.is_finite() {
|
||||
return Err(KernelError::Failed("bridge: no room for the curvature condition".into()));
|
||||
}
|
||||
let t = d1 * (1.0 / sigma);
|
||||
let tp = d2 * (1.0 / sigma) - d1 * (d1.dot(d2) / (sigma * sigma * sigma));
|
||||
let nn = d2 - t * d2.dot(t);
|
||||
let r = tp * (-d2.dot(t)) - t * d2.dot(tp);
|
||||
let x = (target * (sigma.powi(5)) - r * (sigma * sigma) + nn * (2.0 * d1.dot(d2))) * (1.0 / (sigma * sigma));
|
||||
if !x.is_finite() {
|
||||
return Err(KernelError::Failed("bridge: the curvature condition is not finite".into()));
|
||||
}
|
||||
Ok(x - t * x.dot(t))
|
||||
}
|
||||
|
||||
/// One station's cross-section: a Bézier whose leading control points hold the conditions of
|
||||
/// each side. `speed` is how fast the cross-section leaves each boundary (any positive value; it
|
||||
/// shapes the middle without touching the conditions).
|
||||
fn section(a: &Frame, b: &Frame, orders: [Continuity; 2], n: usize, speed: [f64; 2]) -> Result<Vec<Vec3>> {
|
||||
let (Some(speed_a), Some(speed_b)) = (speed.first().copied(), speed.get(1).copied()) else {
|
||||
return Err(KernelError::Failed("bridge: speed".into()));
|
||||
};
|
||||
let (ka, kb) = (orders[0].conditions(), orders[1].conditions());
|
||||
if ka + kb - 1 != n {
|
||||
return Err(KernelError::Failed("bridge: degree".into()));
|
||||
}
|
||||
let mut c = vec![Vec3::ZERO; n + 1];
|
||||
if let Some(slot) = c.get_mut(0) {
|
||||
*slot = a.p;
|
||||
}
|
||||
if let Some(slot) = c.get_mut(n) {
|
||||
*slot = b.p;
|
||||
}
|
||||
let k = n as f64;
|
||||
// The first end: one control point per condition.
|
||||
if ka >= 2 {
|
||||
let p1 = a.p + a.leave * (speed_a / k);
|
||||
if let Some(slot) = c.get_mut(1) {
|
||||
*slot = p1;
|
||||
}
|
||||
if ka >= 3 {
|
||||
if n < 2 {
|
||||
return Err(KernelError::Failed("bridge: degree".into()));
|
||||
}
|
||||
let p2 = a.bend * (speed_a * speed_a / (k * (k - 1.0))) + p1 * 2.0 - a.p;
|
||||
if let Some(slot) = c.get_mut(2) {
|
||||
*slot = p2;
|
||||
}
|
||||
if ka >= 4 {
|
||||
if n < 3 {
|
||||
return Err(KernelError::Failed("bridge: degree".into()));
|
||||
}
|
||||
let d1 = (p1 - a.p) * k;
|
||||
let d2 = (a.p - p1 * 2.0 + p2) * (k * (k - 1.0));
|
||||
let a3 = third_derivative(d1, d2, a.bend_change)?;
|
||||
if let Some(slot) = c.get_mut(3) {
|
||||
*slot = a3 * (1.0 / (k * (k - 1.0) * (k - 2.0))) + p2 * 3.0 - p1 * 3.0 + a.p;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// The second end, from its own conditions read backwards.
|
||||
if kb >= 2 {
|
||||
let q1 = b.p + b.leave * (speed_b / k);
|
||||
if let Some(slot) = c.get_mut(n - 1) {
|
||||
*slot = q1;
|
||||
}
|
||||
if kb >= 3 {
|
||||
if n < 2 {
|
||||
return Err(KernelError::Failed("bridge: degree".into()));
|
||||
}
|
||||
let q2 = b.bend * (speed_b * speed_b / (k * (k - 1.0))) + q1 * 2.0 - b.p;
|
||||
if let Some(slot) = c.get_mut(n - 2) {
|
||||
*slot = q2;
|
||||
}
|
||||
if kb >= 4 {
|
||||
if n < 3 {
|
||||
return Err(KernelError::Failed("bridge: degree".into()));
|
||||
}
|
||||
let d1 = (q1 - b.p) * k;
|
||||
let d2 = (b.p - q1 * 2.0 + q2) * (k * (k - 1.0));
|
||||
let q3 = third_derivative(d1, d2, b.bend_change)?;
|
||||
if let Some(slot) = c.get_mut(n - 3) {
|
||||
*slot = q3 * (1.0 / (k * (k - 1.0) * (k - 2.0))) + q2 * 3.0 - q1 * 3.0 + b.p;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if c.iter().any(|p| !p.is_finite()) {
|
||||
return Err(KernelError::Failed("bridge: the cross-section is not finite".into()));
|
||||
}
|
||||
Ok(c)
|
||||
}
|
||||
|
||||
/// The bridge surface between two boundaries of `stations` frames each: one B-spline face
|
||||
/// leaving `a` and arriving at `b` with the requested continuity. `crown` scales how fast the
|
||||
/// cross-sections leave each boundary (0: the plain bridge, up to 3: fuller, down to -0.9:
|
||||
/// flatter), which shapes the middle without touching the conditions at either end.
|
||||
pub fn bridge(a: &[Frame], b: &[Frame], orders: [Continuity; 2], crown: [f64; 2]) -> Result<Body> {
|
||||
let (Some(&crown_a), Some(&crown_b)) = (crown.first(), crown.get(1)) else { return Err(KernelError::Failed("bridge: crown".into())) };
|
||||
if a.len() != b.len() || a.len() < 2 || a.len() > 4097 {
|
||||
return Err(KernelError::Invalid("a bridge needs 2 to 4097 stations, the same on both sides".into()));
|
||||
}
|
||||
for c in [crown_a, crown_b] {
|
||||
if !c.is_finite() || !(-0.9..=3.0).contains(&c) {
|
||||
return Err(KernelError::Invalid("a bridge's crown must be between -0.9 and 3".into()));
|
||||
}
|
||||
}
|
||||
let stations = a.len();
|
||||
let n = orders[0].conditions() + orders[1].conditions() - 1;
|
||||
if n == 0 || n > solidcraft_geom::bspline::MAX_SPLINE_DEGREE {
|
||||
return Err(KernelError::Failed("bridge: degree".into()));
|
||||
}
|
||||
let mut layers: Vec<Vec<Vec3>> = vec![Vec::with_capacity(stations); n + 1];
|
||||
for (fa, fb) in a.iter().zip(b) {
|
||||
if !fa.p.is_finite() || !fb.p.is_finite() || !fa.leave.is_finite() || !fb.leave.is_finite() {
|
||||
return Err(KernelError::Invalid("a bridge station must be finite".into()));
|
||||
}
|
||||
let chord = fa.p.dist(fb.p);
|
||||
if !(chord > 1e-9) {
|
||||
return Err(KernelError::Invalid("the two boundaries meet: there is no room for a bridge".into()));
|
||||
}
|
||||
let speed = [chord / 3.0 * (1.0 + crown_a), chord / 3.0 * (1.0 + crown_b)];
|
||||
let controls = section(fa, fb, orders, n, speed)?;
|
||||
for (layer, c) in layers.iter_mut().zip(controls) {
|
||||
layer.push(c);
|
||||
}
|
||||
}
|
||||
// Along the bridge: a cubic through the stations' cross-sections, so the face passes through
|
||||
// each of them exactly.
|
||||
let params: Vec<f64> = (0..stations).map(|i| i as f64 / (stations - 1) as f64).collect();
|
||||
let degree = 3.min(stations - 1);
|
||||
let mut knots_u: Option<Vec<f64>> = None;
|
||||
let mut ctrl = vec![Vec3::ZERO; (n + 1) * stations];
|
||||
for (j, layer) in layers.iter().enumerate() {
|
||||
let points: Vec<[f64; 3]> = layer.iter().map(|p| [p.x, p.y, p.z]).collect();
|
||||
let curve = CurveN::<3>::interpolate(¶ms, &points, degree).map_err(|e| KernelError::Failed(format!("bridge: {e}")))?;
|
||||
if knots_u.is_none() {
|
||||
knots_u = Some(curve.knots.clone());
|
||||
}
|
||||
for (i, c) in curve.ctrl.iter().enumerate() {
|
||||
if let Some(slot) = ctrl.get_mut(j * stations + i) {
|
||||
*slot = Vec3::new(c[0], c[1], c[2]);
|
||||
}
|
||||
}
|
||||
}
|
||||
let knots_u = knots_u.ok_or_else(|| KernelError::Failed("bridge: knots".into()))?;
|
||||
let mut knots_v = vec![0.0; n + 1];
|
||||
knots_v.extend(std::iter::repeat_n(1.0, n + 1));
|
||||
let points: Vec<HPoint> = ctrl.iter().map(|p| HPoint::weighted(*p, 1.0)).collect();
|
||||
let nurbs = NurbsSurface::from_homogeneous([degree, n], [knots_u, knots_v], points).map_err(|e| KernelError::Failed(format!("bridge: {e}")))?;
|
||||
guard("bridge surface", || crate::spline_conv::tensor_face(&nurbs).map(|f| surface_body(vec![f])))
|
||||
}
|
||||
|
||||
/// The surface of a bridge face as a grid of points, for callers that measure the result.
|
||||
pub fn sample_grid(body: &Body, along: usize, across: usize) -> Result<Vec<Vec<Vec3>>> {
|
||||
if !(2..=1025).contains(&along) || !(2..=1025).contains(&across) {
|
||||
return Err(KernelError::Invalid("a grid needs 2 to 1025 samples each way".into()));
|
||||
}
|
||||
let face = body.solid.face_iter().next().ok_or_else(|| KernelError::Failed("bridge: no face".into()))?;
|
||||
let surf = face.surface();
|
||||
let (Some((u0, u1)), Some((v0, v1))) = surf.try_range_tuple() else {
|
||||
return Err(KernelError::Failed("bridge: the surface is unbounded".into()));
|
||||
};
|
||||
let mut out = Vec::with_capacity(along);
|
||||
for i in 0..along {
|
||||
let u = u0 + (u1 - u0) * i as f64 / (along - 1) as f64;
|
||||
let mut row = Vec::with_capacity(across);
|
||||
for j in 0..across {
|
||||
let v = v0 + (v1 - v0) * j as f64 / (across - 1) as f64;
|
||||
row.push(from_p3(surf.subs(u, v)));
|
||||
}
|
||||
out.push(row);
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The most any point of a bridge's boundary row is from the chain it was built on — the row at
|
||||
/// `v0` for the first boundary, at `v1` for the second: what a stitch would have to close up.
|
||||
fn boundary_gap(made: &Body, chain: &[mt::Edge], at_end: bool) -> Result<f64> {
|
||||
let face = made.solid.face_iter().next().ok_or_else(|| KernelError::Failed("bridge: no face".into()))?;
|
||||
let surf = face.surface();
|
||||
let (Some((u0, u1)), Some((v0, v1))) = surf.try_range_tuple() else {
|
||||
return Err(KernelError::Failed("bridge: the surface is unbounded".into()));
|
||||
};
|
||||
let v = if at_end { v1 } else { v0 };
|
||||
let (poly, _) = chain_samples(chain, 257)?;
|
||||
let mut worst: f64 = 0.0;
|
||||
for i in 0..=256 {
|
||||
let u = u0 + (u1 - u0) * i as f64 / 256.0;
|
||||
let p = from_p3(surf.subs(u, v));
|
||||
let mut best = f64::INFINITY;
|
||||
for w in poly.windows(2) {
|
||||
let (Some(a), Some(b)) = (w.first(), w.get(1)) else { continue };
|
||||
let t = if b.dist(*a) > 1e-12 { ((p - *a).dot(*b - *a) / b.dist(*a).powi(2)).clamp(0.0, 1.0) } else { 0.0 };
|
||||
best = best.min(p.dist(*a + (*b - *a) * t));
|
||||
}
|
||||
worst = worst.max(best);
|
||||
}
|
||||
Ok(worst)
|
||||
}
|
||||
|
||||
/// The midpoint of a chain of edges.
|
||||
fn chain_mid(edges: &[mt::Edge]) -> Result<Vec3> {
|
||||
let (pts, _) = chain_samples(edges, 3)?;
|
||||
pts.get(1).copied().ok_or_else(|| KernelError::Failed("bridge: no chain".into()))
|
||||
}
|
||||
|
||||
/// Which face of `body` the blend should continue from a chain, and the direction it leaves in:
|
||||
/// the face whose tangent plane holds as much of `leave` as possible.
|
||||
fn support_face(body: &Body, chain: &[mt::Edge], leave: Vec3) -> Result<(mt::Face, Vec3)> {
|
||||
let mut best: Option<(f64, mt::Face)> = None;
|
||||
for face in body.solid.face_iter() {
|
||||
if !chain.iter().all(|e| face.edge_iter().any(|f| f.id() == e.id())) {
|
||||
continue;
|
||||
}
|
||||
let mid = chain_mid(chain)?;
|
||||
let surf = face.surface();
|
||||
let Some((u, v)) = surf.search_nearest_parameter(p3(mid), None, 100) else { continue };
|
||||
if from_p3(surf.subs(u, v)).dist(mid) > body.size() * 1e-6 + 1e-9 {
|
||||
continue;
|
||||
}
|
||||
let normal = surf.normal(u, v);
|
||||
let n = Vec3::new(normal.x, normal.y, normal.z).normalized().unwrap_or(Vec3::ZERO);
|
||||
let in_plane = leave - n * leave.dot(n);
|
||||
let score = in_plane.len();
|
||||
if best.as_ref().is_none_or(|(b, _)| score > *b) {
|
||||
best = Some((score, face.clone()));
|
||||
}
|
||||
}
|
||||
let (score, face) = best.ok_or_else(|| KernelError::Invalid("no face of the body holds the picked edges".into()))?;
|
||||
if score < 0.2 {
|
||||
return Err(KernelError::Invalid(
|
||||
"the direction towards the other boundary lies in no face at the picked edges: give `align` points to leave by".into(),
|
||||
));
|
||||
}
|
||||
Ok((face, leave))
|
||||
}
|
||||
|
||||
/// A blend surface between two picked edge chains of two bodies: the surfaces the blend leaves
|
||||
/// and arrives at are the faces the chains bound (the best-facing one at each side), and each
|
||||
/// side repeats that surface up to its requested continuity. `align` overrides the direction
|
||||
/// each side leaves in (points in world space); `crown` how full each side is; `stitch` sews the
|
||||
/// blend to its two bodies where their boundaries meet. The reply's `gap`, if any, is how far the
|
||||
/// blend's own boundary lay from the chains it was built on.
|
||||
pub fn blend_between(
|
||||
a: &Body,
|
||||
picks_a: &[Vec3],
|
||||
b: &Body,
|
||||
picks_b: &[Vec3],
|
||||
orders: [Continuity; 2],
|
||||
crown: [f64; 2],
|
||||
align: Option<[Vec3; 2]>,
|
||||
samples: usize,
|
||||
stitch: bool,
|
||||
) -> Result<(Body, f64)> {
|
||||
a.require_brep("blend")?;
|
||||
b.require_brep("blend")?;
|
||||
if !(5..=401).contains(&samples) {
|
||||
return Err(KernelError::Invalid("a blend needs 5 to 401 stations".into()));
|
||||
}
|
||||
let chain_a = chain(a, picks_a)?;
|
||||
let chain_b = chain(b, picks_b)?;
|
||||
let (mid_a, mid_b) = (chain_mid(&chain_a)?, chain_mid(&chain_b)?);
|
||||
let (leave_a, leave_b) = match align {
|
||||
Some([p, q]) => (
|
||||
(p - mid_a).normalized().ok_or_else(|| KernelError::Invalid("`align` must not sit on the boundary".into()))?,
|
||||
(q - mid_b).normalized().ok_or_else(|| KernelError::Invalid("`align` must not sit on the boundary".into()))?,
|
||||
),
|
||||
None => (
|
||||
(mid_b - mid_a).normalized().ok_or_else(|| KernelError::Invalid("the two boundaries coincide: there is nothing to blend".into()))?,
|
||||
(mid_a - mid_b).normalized().ok_or_else(|| KernelError::Invalid("the two boundaries coincide: there is nothing to blend".into()))?,
|
||||
),
|
||||
};
|
||||
let (face_a, leave_a) = support_face(a, &chain_a, leave_a)?;
|
||||
let (face_b, leave_b) = support_face(b, &chain_b, leave_b)?;
|
||||
let frames_a = frames(&face_a, &chain_a, leave_a, samples)?;
|
||||
let mut frames_b = frames(&face_b, &chain_b, leave_b, samples)?;
|
||||
// The two chains are sampled from their own starts: turn one round when that pairs the
|
||||
// stations better (the blend is built station to station).
|
||||
let direct: f64 = frames_a.iter().zip(&frames_b).map(|(x, y)| x.p.dist(y.p)).sum();
|
||||
let reversed: f64 = frames_a.iter().zip(frames_b.iter().rev()).map(|(x, y)| x.p.dist(y.p)).sum();
|
||||
if reversed < direct {
|
||||
frames_b.reverse();
|
||||
}
|
||||
let made = bridge(&frames_a, &frames_b, orders, crown)?;
|
||||
let gap = boundary_gap(&made, &chain_a, false)?.max(boundary_gap(&made, &chain_b, true)?);
|
||||
let faces: Vec<mt::Face> = made.solid.face_iter().cloned().collect();
|
||||
let mut rec = crate::record::Rebuild::default();
|
||||
for f in &faces {
|
||||
rec.made(f, Vec::new());
|
||||
}
|
||||
let blend = crate::record::rebuilt_body(surface_body(faces), &[&a.solid, &b.solid], &rec);
|
||||
if !stitch {
|
||||
return Ok((blend, gap));
|
||||
}
|
||||
// Sewing up a boundary the blend only approximates: the stitch is given what the boundary
|
||||
// actually strays, so that a real gap between the bodies is still refused.
|
||||
let out = crate::surfaces::stitch(&[a, b, &blend], gap * 1.05 + 1e-9)?;
|
||||
Ok((out, gap))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "bridge_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,244 @@
|
||||
//! Tests of the bridge core: the support surface's shape is read off a real body, and a bridge's
|
||||
//! continuity is measured back off the surface it built.
|
||||
|
||||
use super::*;
|
||||
use crate::{box_solid, cylinder};
|
||||
|
||||
/// The shape of a bridge's cross-section at the parameter `u`, measured off the finished face (not
|
||||
/// from the construction): position, unit tangent, curvature vector and the arclength derivative
|
||||
/// of that curvature vector at the start of the cross-section. The samples run inwards from the
|
||||
/// boundary, so nothing is asked of the surface outside its own domain.
|
||||
fn section_at(body: &Body, u: f64) -> (Vec3, Vec3, Vec3, Vec3) {
|
||||
let face = body.solid.face_iter().next().unwrap();
|
||||
let surf = face.surface();
|
||||
let (Some(_), Some((v0, _))) = surf.try_range_tuple() else { panic!("unbounded") };
|
||||
let h = 1e-3;
|
||||
let q: Vec<Vec3> = (0..5).map(|k| from_p3(surf.subs(u, v0 + k as f64 * h))).collect();
|
||||
let (f0, f1, f2, f3, f4) = (q[0], q[1], q[2], q[3], q[4]);
|
||||
let d1 = (f0 * -25.0 + f1 * 48.0 + f2 * -36.0 + f3 * 16.0 + f4 * -3.0) * (1.0 / (12.0 * h));
|
||||
let d2 = (f0 * 35.0 + f1 * -104.0 + f2 * 114.0 + f3 * -56.0 + f4 * 11.0) * (1.0 / (12.0 * h * h));
|
||||
let d3 = (f0 * -5.0 + f1 * 18.0 + f2 * -24.0 + f3 * 14.0 + f4 * -3.0) * (1.0 / (2.0 * h * h * h));
|
||||
let (t, bend, bend_change) = shape(d1, d2, d3).unwrap();
|
||||
(f0, t, bend, bend_change)
|
||||
}
|
||||
|
||||
/// The same at the end of the cross-section (`v = v1`), with the samples running back inwards and
|
||||
/// the odd derivatives turned round.
|
||||
fn section_end_at(body: &Body, u: f64) -> (Vec3, Vec3, Vec3, Vec3) {
|
||||
let face = body.solid.face_iter().next().unwrap();
|
||||
let surf = face.surface();
|
||||
let (Some(_), Some((_, v1))) = surf.try_range_tuple() else { panic!("unbounded") };
|
||||
let h = 1e-3;
|
||||
let q: Vec<Vec3> = (0..5).map(|k| from_p3(surf.subs(u, v1 - k as f64 * h))).collect();
|
||||
let (f0, f1, f2, f3, f4) = (q[0], q[1], q[2], q[3], q[4]);
|
||||
let d1 = (f0 * -25.0 + f1 * 48.0 + f2 * -36.0 + f3 * 16.0 + f4 * -3.0) * (-1.0 / (12.0 * h));
|
||||
let d2 = (f0 * 35.0 + f1 * -104.0 + f2 * 114.0 + f3 * -56.0 + f4 * 11.0) * (1.0 / (12.0 * h * h));
|
||||
let d3 = (f0 * -5.0 + f1 * 18.0 + f2 * -24.0 + f3 * 14.0 + f4 * -3.0) * (-1.0 / (2.0 * h * h * h));
|
||||
let (t, bend, bend_change) = shape(d1, d2, d3).unwrap();
|
||||
(f0, t, bend, bend_change)
|
||||
}
|
||||
|
||||
/// The angle between two vectors, in degrees.
|
||||
fn angle_deg(a: Vec3, b: Vec3) -> f64 {
|
||||
(a.normalized().unwrap().dot(b.normalized().unwrap())).clamp(-1.0, 1.0).acos().to_degrees()
|
||||
}
|
||||
|
||||
/// Two planes 10 mm apart: the lower one leaves along +y, the upper one has no curvature, and the
|
||||
/// direction between them is +z — an S-shaped bridge.
|
||||
fn two_planes(count: usize) -> (Vec<Frame>, Vec<Frame>) {
|
||||
let mut a = Vec::new();
|
||||
let mut b = Vec::new();
|
||||
for i in 0..count {
|
||||
let y = 10.0 * i as f64 / (count - 1) as f64;
|
||||
a.push(Frame { p: Vec3::new(0.0, y, 0.0), leave: Vec3::new(0.0, 1.0, 0.0), bend: Vec3::ZERO, bend_change: Vec3::ZERO });
|
||||
b.push(Frame { p: Vec3::new(0.0, y, 10.0), leave: Vec3::new(0.0, -1.0, 0.0), bend: Vec3::ZERO, bend_change: Vec3::ZERO });
|
||||
}
|
||||
(a, b)
|
||||
}
|
||||
|
||||
/// Two parallel circular cylinders of radius `r`, axes along x at z = r, 20 mm apart in y: their
|
||||
/// lowest lines are the two boundaries. Each leaves towards the other along ∓y, bends up towards
|
||||
/// its own axis (curvature 1/r), and its curvature does not change as it goes round — what does
|
||||
/// change is purely tangential.
|
||||
fn valley_between_cylinders(count: usize, r: f64) -> (Vec<Frame>, Vec<Frame>) {
|
||||
let mut a = Vec::new();
|
||||
let mut b = Vec::new();
|
||||
for i in 0..count {
|
||||
let y = 10.0 * i as f64 / (count - 1) as f64;
|
||||
a.push(Frame {
|
||||
p: Vec3::new(0.0, y, 0.0),
|
||||
leave: Vec3::new(0.0, 1.0, 0.0),
|
||||
bend: Vec3::new(0.0, 0.0, 1.0 / r),
|
||||
bend_change: Vec3::new(0.0, -1.0 / (r * r), 0.0),
|
||||
});
|
||||
b.push(Frame {
|
||||
p: Vec3::new(0.0, y + 20.0, 0.0),
|
||||
leave: Vec3::new(0.0, -1.0, 0.0),
|
||||
bend: Vec3::new(0.0, 0.0, 1.0 / r),
|
||||
bend_change: Vec3::new(0.0, 1.0 / (r * r), 0.0),
|
||||
});
|
||||
}
|
||||
(a, b)
|
||||
}
|
||||
|
||||
/// The edges of `face` chained into one loop.
|
||||
fn loop_of(face: &mt::Face) -> Vec<mt::Edge> {
|
||||
let mut pool: Vec<mt::Edge> = face.edge_iter().collect();
|
||||
let mut out = vec![pool.remove(0)];
|
||||
let mut end = out[0].back().clone();
|
||||
while !pool.is_empty() {
|
||||
let k = pool.iter().position(|e| e.front().id() == end.id() || e.back().id() == end.id()).unwrap();
|
||||
let e = pool.remove(k);
|
||||
let e = if e.front().id() == end.id() { e } else { e.inverse() };
|
||||
end = e.back().clone();
|
||||
out.push(e);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The face of `body` that contains `at`.
|
||||
fn face_at(body: &Body, at: Vec3) -> mt::Face {
|
||||
body.solid
|
||||
.face_iter()
|
||||
.find(|f| f.surface().search_nearest_parameter(p3(at), None, 100).is_some_and(|(u, v)| from_p3(f.surface().subs(u, v)).dist(at) < 1e-6))
|
||||
.unwrap()
|
||||
.clone()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn frames_read_a_plane_and_a_cylinder_wall() {
|
||||
// A 40 x 30 x 20 box: the top face's rim leaves along +x, a plane with no curvature.
|
||||
let b = box_solid(Vec3::ZERO, Vec3::new(40.0, 30.0, 20.0)).unwrap();
|
||||
let top = face_at(&b, Vec3::new(20.0, 15.0, 20.0));
|
||||
let rim = loop_of(&top);
|
||||
assert!(chain_closes(&rim));
|
||||
let f = frames(&top, &rim, Vec3::new(1.0, 0.0, 0.0), 9).unwrap();
|
||||
assert_eq!(f.len(), 9);
|
||||
for s in &f {
|
||||
assert!((s.p.z - 20.0).abs() < 1e-9, "{s:?}");
|
||||
assert!(angle_deg(s.leave, Vec3::new(1.0, 0.0, 0.0)) < 1e-6, "{s:?}");
|
||||
assert!(s.bend.len() < 1e-6 && s.bend_change.len() < 1e-6, "{s:?}");
|
||||
}
|
||||
// The chain's picks work the same way: the rim's own points pick the rim's own edges.
|
||||
let picked = chain(&b, &[Vec3::new(20.0, 0.0, 20.0), Vec3::new(40.0, 15.0, 20.0)]).unwrap();
|
||||
assert_eq!(picked.len(), 2);
|
||||
|
||||
// A cylinder's wall: along the axis it is straight, and a leave direction that is normal to it
|
||||
// has no tangent plane to work in.
|
||||
let c = cylinder(Vec3::ZERO, Vec3::new(0.0, 0.0, 1.0), 10.0, 30.0).unwrap();
|
||||
let wall = face_at(&c, Vec3::new(10.0, 0.0, 15.0));
|
||||
let ring = loop_of(&wall);
|
||||
let f = frames(&wall, &ring, Vec3::new(0.0, 0.0, 1.0), 5).unwrap();
|
||||
for s in &f {
|
||||
assert!(s.bend.len() < 1e-6, "the axis direction is straight: {s:?}");
|
||||
}
|
||||
// A leave direction that is normal to the support surface has no tangent plane to work in.
|
||||
assert!(frames(&top, &rim, Vec3::new(0.0, 0.0, 1.0), 9).is_err(), "a face's own normal is no direction to leave in");
|
||||
// On the cylinder's wall only a direction with a tangential part is usable.
|
||||
assert!(frames(&wall, &ring, Vec3::new(1.0, 0.0, 0.0), 5).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_g1_bridge_meets_both_boundaries_tangentially() {
|
||||
let (a, b) = two_planes(9);
|
||||
let body = bridge(&a, &b, [Continuity::G1, Continuity::G1], [0.0, 0.0]).unwrap();
|
||||
for u in [0.0, 0.5, 1.0] {
|
||||
let (_, t, _, _) = section_at(&body, u);
|
||||
assert!(angle_deg(t, Vec3::new(0.0, 1.0, 0.0)) < 0.01, "the bridge leaves along the tangent: {u}");
|
||||
}
|
||||
// The boundary itself is on each support: the first and last rows of the grid.
|
||||
let grid = sample_grid(&body, 9, 7).unwrap();
|
||||
for (row, frame) in grid.iter().zip(&a) {
|
||||
assert!(row[0].dist(frame.p) < 1e-9, "{:?} vs {:?}", row[0], frame.p);
|
||||
}
|
||||
for (row, frame) in grid.iter().zip(&b) {
|
||||
assert!(row[6].dist(frame.p) < 1e-9, "{:?} vs {:?}", row[6], frame.p);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn g2_and_g3_bridges_repeat_the_support_shape() {
|
||||
let (a, b) = valley_between_cylinders(9, 10.0);
|
||||
// A G2 bridge to two cylinders: each end holds the cylinder's own curvature (1/10 towards its
|
||||
// axis) and leaves along its tangent.
|
||||
let g2 = bridge(&a, &b, [Continuity::G2, Continuity::G2], [0.0, 0.0]).unwrap();
|
||||
for (i, u) in [(0usize, 0.0), (4, 0.5), (8, 1.0)] {
|
||||
let (p, t, bend, _) = section_at(&g2, u);
|
||||
assert!(p.dist(a[i].p) < 1e-9, "the boundary is on the cylinder: {p:?}");
|
||||
assert!(angle_deg(t, Vec3::new(0.0, 1.0, 0.0)) < 0.01, "leaves along the tangent: {u}");
|
||||
assert!((bend.dist(a[i].bend) / a[i].bend.len()) < 1e-3, "curvature {bend:?} vs {:?}", a[i].bend);
|
||||
}
|
||||
// The far end, read back to front.
|
||||
let (p, t, bend, _) = section_end_at(&g2, 1.0);
|
||||
assert!(p.dist(b[8].p) < 1e-9, "the far boundary is on its cylinder: {p:?}");
|
||||
assert!(angle_deg(t, Vec3::new(0.0, 1.0, 0.0)) < 0.01, "arrives along the far tangent");
|
||||
assert!((bend.dist(b[8].bend) / b[8].bend.len()) < 1e-3, "curvature {bend:?} vs {:?}", b[8].bend);
|
||||
|
||||
// A G2 bridge leaves the change of curvature free; asking for G3 pins its normal part to the
|
||||
// cylinder's own (zero: a cylinder's curvature does not change as you go round it).
|
||||
let (_, _, _, free) = section_at(&g2, 0.0);
|
||||
let g3 = bridge(&a, &b, [Continuity::G3, Continuity::G3], [0.0, 0.0]).unwrap();
|
||||
let (_, _, bend3, held) = section_at(&g3, 0.0);
|
||||
assert!((bend3.dist(a[0].bend) / a[0].bend.len()) < 1e-3, "G3 still holds the curvature: {bend3:?}");
|
||||
let along_normal = |v: Vec3| v.dot(Vec3::new(0.0, 0.0, 1.0));
|
||||
assert!(along_normal(held).abs() < 1e-3, "a G3 bridge holds the change of curvature: {held:?}");
|
||||
assert!(along_normal(free).abs() > 1e-3, "a G2 bridge is free to change it: {free:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn crown_shapes_the_middle_without_touching_the_ends() {
|
||||
let (a, b) = valley_between_cylinders(11, 10.0);
|
||||
let base = bridge(&a, &b, [Continuity::G2, Continuity::G2], [0.0, 0.0]).unwrap();
|
||||
let (_, t0, bend0, _) = section_at(&base, 0.0);
|
||||
let mut heights = Vec::new();
|
||||
for crown in [-0.5, 0.0, 1.0, 2.0] {
|
||||
let body = bridge(&a, &b, [Continuity::G2, Continuity::G2], [crown, crown]).unwrap();
|
||||
let grid = sample_grid(&body, 11, 9).unwrap();
|
||||
heights.push(grid[5][4].z);
|
||||
// The ends hold in every case: the same boundary points, the same tangent, and the same
|
||||
// seam curvature as the uncrowned bridge.
|
||||
let (_, t, bend, _) = section_at(&body, 0.0);
|
||||
assert!(angle_deg(t, t0) < 0.01, "crown {crown} left the tangent alone");
|
||||
assert!(bend.dist(bend0) < 1e-9, "crown {crown} left the curvature alone: {bend:?} vs {bend0:?}");
|
||||
assert!(grid[5][0].dist(a[5].p) < 1e-9 && grid[5][8].dist(b[5].p) < 1e-9, "crown {crown} left the boundary alone");
|
||||
}
|
||||
let steps: Vec<f64> = heights.windows(2).map(|w| w[1] - w[0]).collect();
|
||||
assert!(steps.iter().all(|d| d.abs() > 1e-6 && d.signum() == steps[0].signum()), "a fuller crown moves the middle one way: {heights:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_bridge_refuses_what_it_cannot_hold() {
|
||||
let (a, b) = two_planes(9);
|
||||
// Different station counts.
|
||||
assert!(bridge(&a[..6], &b, [Continuity::G1, Continuity::G1], [0.0, 0.0]).is_err());
|
||||
// A crown outside its range, and a crown that is not a number.
|
||||
for crown in [f64::NAN, 5.0, -1.0, f64::INFINITY] {
|
||||
assert!(bridge(&a, &b, [Continuity::G1, Continuity::G1], [crown, crown]).is_err(), "{crown}");
|
||||
}
|
||||
// Boundaries that meet: no room for a bridge.
|
||||
let same: Vec<Frame> = a.iter().map(|f| Frame { p: f.p, ..*f }).collect();
|
||||
assert!(bridge(&a, &same, [Continuity::G1, Continuity::G1], [0.0, 0.0]).is_err());
|
||||
// A station that is not a number.
|
||||
let mut bad = a.clone();
|
||||
bad[3].leave = Vec3::new(f64::NAN, 0.0, 0.0);
|
||||
assert!(bridge(&bad, &b, [Continuity::G1, Continuity::G1], [0.0, 0.0]).is_err());
|
||||
// Fewer than two stations.
|
||||
assert!(bridge(&a[..1], &b[..1], [Continuity::G1, Continuity::G1], [0.0, 0.0]).is_err());
|
||||
// Every order from G0 to G3 builds.
|
||||
for (x, y) in [(Continuity::G0, Continuity::G0), (Continuity::G1, Continuity::G0), (Continuity::G3, Continuity::G1)] {
|
||||
let body = bridge(&a, &b, [x, y], [0.0, 0.0]).unwrap();
|
||||
let (_, t, _, _) = section_at(&body, 0.0);
|
||||
if x != Continuity::G0 {
|
||||
assert!(angle_deg(t, Vec3::new(0.0, 1.0, 0.0)) < 0.01, "{x:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn continuity_parses_its_words() {
|
||||
assert_eq!(Continuity::parse("g0"), Some(Continuity::G0));
|
||||
assert_eq!(Continuity::parse("G3"), Some(Continuity::G3));
|
||||
assert_eq!(Continuity::parse("g9"), None);
|
||||
assert_eq!(Continuity::parse(""), None);
|
||||
assert_eq!([Continuity::G0, Continuity::G1, Continuity::G2, Continuity::G3].map(Continuity::conditions), [1, 2, 3, 4]);
|
||||
}
|
||||
@@ -16,6 +16,13 @@ use crate::{KernelError, Result};
|
||||
/// every edge. Its history is over `[body]`: the face is new, its edges the body's own. Call it
|
||||
/// under [`crate::guard`].
|
||||
pub(crate) fn fill_loop(body: &Body, chain: &[mt::Edge]) -> Result<Body> {
|
||||
fill_loop_crowned(body, chain, 0.0)
|
||||
}
|
||||
|
||||
/// [`fill_loop`] with a crown: positive makes the fitted patch's middle fuller, negative flatter,
|
||||
/// by `crown` times the loop's size (see `solidcraft_geom::fill::fill_loop`). The bump vanishes on
|
||||
/// the loop, so the face still meets the body's own edges exactly as the plain fill does.
|
||||
pub(crate) fn fill_loop_crowned(body: &Body, chain: &[mt::Edge], crown: f64) -> Result<Body> {
|
||||
let tol = face_tolerance(body);
|
||||
let mut sides: Vec<(EdgeSampler, Vec3)> = Vec::with_capacity(chain.len());
|
||||
for e in chain {
|
||||
@@ -27,7 +34,7 @@ pub(crate) fn fill_loop(body: &Body, chain: &[mt::Edge]) -> Result<Body> {
|
||||
// The loop's corners are its vertices (an imported edge's curve may end a little off).
|
||||
if t <= 0.0 { Some(*start) } else { sampler.at(t) }
|
||||
};
|
||||
let fill = solidcraft_geom::fill::fill_loop(chain.len(), &mut point, tol).map_err(|e| match e {
|
||||
let fill = solidcraft_geom::fill::fill_loop(chain.len(), &mut point, tol, crown).map_err(|e| match e {
|
||||
SplineError::Unsupported(m) => KernelError::Invalid(format!("not supported yet: {m}")),
|
||||
other => KernelError::Invalid(format!("cannot fill the loop: {other}")),
|
||||
})?;
|
||||
@@ -40,6 +47,37 @@ pub(crate) fn fill_loop(body: &Body, chain: &[mt::Edge]) -> Result<Body> {
|
||||
Ok(rebuilt_body(crate::surfaces::surface_body(vec![face]), &[&body.solid], &rec))
|
||||
}
|
||||
|
||||
/// [`crate::patch_edges`] with a crown on the fitted face: positive makes the patch's middle
|
||||
/// fuller, negative flatter, by `crown` times the loop's size (its projected box's diagonal), the
|
||||
/// bump vanishing along the loop, so the face still meets the body's own edges. `crown` 0 is
|
||||
/// exactly [`crate::patch_edges`], and a loop that is certainly planar ([`crate::plane_fit`])
|
||||
/// makes the same exact planar face whatever the crown. Its history is over `[body]`: the face is
|
||||
/// new, its edges the body's own.
|
||||
pub fn patch_edges_crowned(body: &Body, at: &[Vec3], crown: f64) -> Result<Body> {
|
||||
if crown == 0.0 {
|
||||
return crate::surfaces::patch_edges(body, at);
|
||||
}
|
||||
body.require_brep("patch")?;
|
||||
if at.is_empty() || at.len() > 10_000 {
|
||||
return Err(KernelError::Invalid("pick the edges of a closed loop".into()));
|
||||
}
|
||||
// A range test also throws out NaN.
|
||||
if !(solidcraft_geom::fill::MIN_CROWN..=solidcraft_geom::fill::MAX_CROWN).contains(&crown) {
|
||||
return Err(KernelError::Invalid("a patch's crown must be between -0.9 and 3".into()));
|
||||
}
|
||||
crate::guard("patch", || {
|
||||
let chain = crate::surfaces::picked_loop(body, at)?;
|
||||
let Some(face) = crate::plane_fit::planar_face(&chain, planarity_tolerance(body))? else {
|
||||
// Not certainly planar: a fitted surface, crowned.
|
||||
return fill_loop_crowned(body, &chain, crown);
|
||||
};
|
||||
// A new face on the body's own edges (a plane has no middle to fill).
|
||||
let mut rec = Rebuild::default();
|
||||
rec.made(&face, Vec::new());
|
||||
Ok(rebuilt_body(crate::surfaces::surface_body(vec![face]), &[&body.solid], &rec))
|
||||
})
|
||||
}
|
||||
|
||||
/// How far a loop's edges may be from a plane for its patch to be that plane: `10⁻⁷` of the
|
||||
/// body's size, at least the linear tolerance (`10⁻⁶` mm) — the body's own "same point"
|
||||
/// tolerance, since a planar face is exact and other operations treat it as containing its
|
||||
@@ -71,7 +109,7 @@ mod tests {
|
||||
use crate::body::{Body, from_p3, p3};
|
||||
use crate::boolean_record::tests::{Reach, checked};
|
||||
use crate::history::{Change, EdgeOrigin};
|
||||
use crate::{BoolOp, boolean, copy_faces, cylinder, extrude, measure, patch_edges, stitch};
|
||||
use crate::{BoolOp, boolean, copy_faces, cylinder, extrude, measure, patch_edges, patch_edges_crowned, stitch};
|
||||
|
||||
/// The cutting cylinder: axis along y at x = 0, z = 50, radius 40, so the top of a prism
|
||||
/// within 20 of the axis and 20 high is cut away everywhere (to between 10 and 15.4 mm).
|
||||
@@ -524,4 +562,52 @@ mod tests {
|
||||
assert!(patch_edges(&open, &[Vec3::new(1e300, 0.0, 0.0)]).is_err());
|
||||
assert!(patch_edges(&open, &vec![rim[0]; 20_000]).is_err());
|
||||
}
|
||||
|
||||
/// A crowned patch: the middle is fuller by `crown` times the loop's size, the loop's own
|
||||
/// edges stay exactly where they were (the face still meets them within [`face_tolerance`]),
|
||||
/// and a planar loop is the same exact plane whatever the crown.
|
||||
#[test]
|
||||
fn a_crowned_patch_fills_its_middle_and_keeps_its_edges() {
|
||||
let (_, open, rim) = cup(®ular(5, 0.3), Vec2::ZERO);
|
||||
let plain = patch_edges(&open, &rim).unwrap();
|
||||
let same = patch_edges_crowned(&open, &rim, 0.0).unwrap();
|
||||
// Crown 0 is the plain patch: the same surface, to the last bit.
|
||||
assert_eq!(measure(&plain).unwrap().area, measure(&same).unwrap().area, "crown 0 is patch_edges");
|
||||
for crown in [0.25, -0.25] {
|
||||
let full = patch_edges_crowned(&open, &rim, crown).unwrap();
|
||||
assert_eq!(full.face_count(), 1, "one face");
|
||||
let face = full.solid.face_iter().next().unwrap().clone();
|
||||
assert!(!matches!(face.surface(), mt::Surface::Plane(_)));
|
||||
let own: Vec<mt::EdgeID> = open.solid.edge_iter().map(|e| e.id()).collect();
|
||||
assert!(full.solid.edge_iter().all(|e| own.contains(&e.id())), "an edge that is not the body's");
|
||||
// The loop's edges are within the fill's tolerance of the face, as for the plain fill.
|
||||
let off = edges_off_surface(&face);
|
||||
assert!(off <= super::face_tolerance(&open), "an edge is {off} off the crowned face");
|
||||
mesh_is_clean(&full);
|
||||
// The middle of the loop's box moved by crown × its diagonal (the bump is 1 there).
|
||||
let a = plain.solid.face_iter().next().unwrap().surface();
|
||||
let b = face.surface();
|
||||
let (Some((bu0, bu1)), Some((bv0, bv1))) = a.try_range_tuple() else { panic!("a bounded surface") };
|
||||
let (uc, vc) = ((bu0 + bu1) / 2.0, (bv0 + bv1) / 2.0);
|
||||
let size = (bu1 - bu0).hypot(bv1 - bv0);
|
||||
let bump = a.subs(uc, vc).distance(b.subs(uc, vc));
|
||||
let want = (crown * size).abs();
|
||||
eprintln!("crown {crown}: the middle moved {bump:.6}, wanted {want:.6}");
|
||||
assert!((bump - want).abs() < 1e-6 * size, "middle {bump} against {want}");
|
||||
}
|
||||
// A planar loop: the exact plane, crowned or not (the crown has no middle to fill).
|
||||
let boxed = crate::box_solid(Vec3::ZERO, Vec3::new(10.0, 10.0, 10.0)).unwrap();
|
||||
let open = copy_faces(
|
||||
&boxed,
|
||||
&[Vec3::new(5.0, 5.0, 0.0), Vec3::new(5.0, 0.0, 5.0), Vec3::new(10.0, 5.0, 5.0), Vec3::new(5.0, 10.0, 5.0), Vec3::new(0.0, 5.0, 5.0)],
|
||||
)
|
||||
.unwrap();
|
||||
let rim = [Vec3::new(5.0, 0.0, 10.0), Vec3::new(10.0, 5.0, 10.0), Vec3::new(5.0, 10.0, 10.0), Vec3::new(0.0, 5.0, 10.0)];
|
||||
let lid = patch_edges_crowned(&open, &rim, 1.0).unwrap();
|
||||
assert!(matches!(lid.solid.face_iter().next().unwrap().surface(), mt::Surface::Plane(_)), "a planar loop is a plane");
|
||||
// Hostile crowns are refused before anything is built.
|
||||
for crown in [f64::NAN, f64::INFINITY, 3.01, -0.91, 1e300] {
|
||||
assert!(patch_edges_crowned(&open, &rim, crown).is_err(), "crown {crown}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -22,6 +22,7 @@ mod boolean_diagnostics;
|
||||
mod boolean_guard;
|
||||
mod boolean_record;
|
||||
mod bore_guard;
|
||||
mod bridge;
|
||||
mod build;
|
||||
mod clearance;
|
||||
mod coplanar;
|
||||
@@ -117,12 +118,14 @@ pub use blend_corner::fillet_radii;
|
||||
pub use blend_variable::{RadiusSpline, Taper, fillet_chord, fillet_tapered, fillet_variable, fillet_variable_points, fillet_variable_spline, taper};
|
||||
pub use body::{Body, CapSignature, DISPLAY_ANGLE, EdgeInfo, FaceInfo, FacePaint, FaceSource, Paint};
|
||||
pub use boolean_diagnostics::{BooleanDiagnostics, BooleanFallback, BooleanStrategy, capture_boolean_diagnostics};
|
||||
pub use bridge::{Continuity, Frame, blend_between, bridge, chain, chain_closes, frames, sample_grid};
|
||||
pub use build::{
|
||||
PathSeg, box_solid, canonical_revolve_axis, cylinder, extrude, extrude_tapered, extrude_tapered_between, loft, revolve, sphere, sweep,
|
||||
sweep_with, torus,
|
||||
};
|
||||
pub use delete_face::delete_faces;
|
||||
pub use emboss::{cylinder_emboss_anchor, emboss_cylinder, emboss_cylinder_at, has_cylinder_emboss_wall, infer_cylinder_emboss};
|
||||
pub use fill::patch_edges_crowned;
|
||||
pub use helix::{loft_to_point, sweep_helix, sweep_helix_mesh};
|
||||
pub use iges_in::{MAX_IGES_BYTES, iges_import, iges_to_step};
|
||||
pub use iges_out::iges_export_bodies;
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
use solidcraft_geom::bspline::{HPoint, NurbsSurface};
|
||||
use truck_modeling as mt;
|
||||
|
||||
use crate::body::p3;
|
||||
use crate::{KernelError, Result};
|
||||
|
||||
fn fail(m: impl std::fmt::Display) -> KernelError {
|
||||
@@ -34,3 +35,30 @@ pub(crate) fn surface(s: &NurbsSurface) -> Result<mt::Surface> {
|
||||
let rows: Vec<Vec<mt::Vector4>> = (0..nu).map(|i| (0..nv).map(|j| h4(s.point(i, j))).collect()).collect();
|
||||
nurbs_surface((mt::KnotVec::from(ku.clone()), mt::KnotVec::from(kv.clone())), rows)
|
||||
}
|
||||
|
||||
/// One face of a whole tensor surface: its four boundary curves as edges, sharing the corners.
|
||||
/// This is what a patch built as a single control net (`bridge`, `boundary`, the T-spline sheet)
|
||||
/// hands to the B-rep.
|
||||
pub(crate) fn tensor_face(s: &NurbsSurface) -> Result<mt::Face> {
|
||||
let [nu, nv] = s.count();
|
||||
if nu < 2 || nv < 2 {
|
||||
return Err(fail("a face needs at least 2 x 2 control points"));
|
||||
}
|
||||
let [ku, kv] = s.knots();
|
||||
let corners = [s.point(0, 0), s.point(nu - 1, 0), s.point(nu - 1, nv - 1), s.point(0, nv - 1)];
|
||||
let mut v: Vec<mt::Vertex> = Vec::with_capacity(4);
|
||||
for c in corners {
|
||||
let p = c.project().ok_or_else(|| fail("a corner has no position"))?;
|
||||
v.push(mt::builder::vertex(p3(p)));
|
||||
}
|
||||
let row = |j: usize| -> Vec<HPoint> { (0..nu).map(|i| s.point(i, j)).collect() };
|
||||
let column = |i: usize| -> Vec<HPoint> { (0..nv).map(|j| s.point(i, j)).collect() };
|
||||
let (Some(v0), Some(v1), Some(v2), Some(v3)) = (v.first(), v.get(1), v.get(2), v.get(3)) else { return Err(fail("corners")) };
|
||||
let edge = |a: &mt::Vertex, b: &mt::Vertex, c: mt::Curve| mt::Edge::try_new(a, b, c).map_err(fail);
|
||||
let bottom = edge(v0, v1, nurbs_curve(mt::KnotVec::from(ku.clone()), &row(0))?)?;
|
||||
let right = edge(v1, v2, nurbs_curve(mt::KnotVec::from(kv.clone()), &column(nu - 1))?)?;
|
||||
let top = edge(v3, v2, nurbs_curve(mt::KnotVec::from(ku.clone()), &row(nv - 1))?)?;
|
||||
let left = edge(v0, v3, nurbs_curve(mt::KnotVec::from(kv.clone()), &column(0))?)?;
|
||||
let wire: mt::Wire = vec![bottom, right, top.inverse(), left.inverse()].into();
|
||||
mt::Face::try_new(vec![wire], surface(s)?).map_err(fail)
|
||||
}
|
||||
@@ -42,21 +42,7 @@ fn vertex(h: HPoint) -> Result<mt::Vertex> {
|
||||
|
||||
/// One face from a clamped tensor surface, bounded by its four boundary curves.
|
||||
fn tensor_face(n: &NurbsSurface) -> Result<mt::Face> {
|
||||
let [nu, nv] = n.count();
|
||||
let [ku, kv] = n.knots();
|
||||
let (ku, kv) = (mt::KnotVec::from(ku.clone()), mt::KnotVec::from(kv.clone()));
|
||||
let corners = [n.point(0, 0), n.point(nu - 1, 0), n.point(nu - 1, nv - 1), n.point(0, nv - 1)];
|
||||
let v: Vec<mt::Vertex> = corners.into_iter().map(vertex).collect::<Result<_>>()?;
|
||||
let row = |j: usize| -> Vec<HPoint> { (0..nu).map(|i| n.point(i, j)).collect() };
|
||||
let column = |i: usize| -> Vec<HPoint> { (0..nv).map(|j| n.point(i, j)).collect() };
|
||||
let (Some(v0), Some(v1), Some(v2), Some(v3)) = (v.first(), v.get(1), v.get(2), v.get(3)) else { return Err(fail("corners")) };
|
||||
let edge = |a: &mt::Vertex, b: &mt::Vertex, c: mt::Curve| mt::Edge::try_new(a, b, c).map_err(fail);
|
||||
let bottom = edge(v0, v1, nurbs_curve(ku.clone(), &row(0))?)?;
|
||||
let right = edge(v1, v2, nurbs_curve(kv.clone(), &column(nu - 1))?)?;
|
||||
let top = edge(v3, v2, nurbs_curve(ku.clone(), &row(nv - 1))?)?;
|
||||
let left = edge(v0, v3, nurbs_curve(kv.clone(), &column(0))?)?;
|
||||
let wire: mt::Wire = vec![bottom, right, top.inverse(), left.inverse()].into();
|
||||
mt::Face::try_new(vec![wire], crate::spline_conv::surface(n)?).map_err(fail)
|
||||
crate::spline_conv::tensor_face(n)
|
||||
}
|
||||
|
||||
/// A parameter point, exact (knot values are shared, so equal points have equal bits).
|
||||
|
||||
Reference in new issue
Block a user