SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Divide intersection edges from their neighbours' parameters (#1038) (#1412)
JIJINBEI3333f8a62b0f
diff --git a/ATTRIBUTION.md b/ATTRIBUTION.mdindex 3a89945639..b5b8c4d2dd 100644--- a/ATTRIBUTION.md+++ b/ATTRIBUTION.md@@ -176,6 +176,7 @@ copied into SolidCraft.| vendor/truck-meshalgo | truck-meshalgo 0.4.0, https://github.com/ricosjp/truck (RICOS Co. Ltd.) | Apache-2.0 | meshing: bounded parameter searches, collapsed-boundary projection, subdivision and provisional fixed-grid previews (vendor/README.md) || vendor/truck-stepio | truck-stepio 0.3.0, https://github.com/ricosjp/truck (RICOS Co. Ltd.) | Apache-2.0 | STEP writer: intersection-curve surfaces written at unique ids (vendor/README.md) || vendor/truck-shapeops | truck-shapeops 0.4.0, https://github.com/ricosjp/truck (RICOS Co. Ltd.) | Apache-2.0 | robust meshing and nearest-parameter fallback in booleans; degenerate intersection-curve rejection; face and edge history of booleans; trace macro; corner choice at vertices several intersection curves end on (vendor/README.md) |+| vendor/truck-geometry | truck-geometry 0.5.0, https://github.com/ricosjp/truck (RICOS Co. Ltd.) | Apache-2.0 | intersection curves divided from their neighbours' surface parameters (vendor/README.md) || vendor/matext4cgmath | matext4cgmath 0.1.0, https://github.com/ricosjp/matext4cgmath (RICOS Co. Ltd.) | Apache-2.0 | root refinement stops after 100 Newton steps (vendor/README.md) |## Vendored renderer compatibility fixdiff --git a/Cargo.lock b/Cargo.lockindex 4124950ca5..88f732ed54 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4552,8 +4552,6 @@ dependencies = [[[package]]name = "truck-geometry"version = "0.5.0"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "4d9d85f203fdbc2d206a38b8e7c4417a05a2eb589be8b81ecfe9f98faafc425d"dependencies = ["serde","thiserror 1.0.69",diff --git a/Cargo.toml b/Cargo.tomlindex 1066b71b72..8955c336ac 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -126,6 +126,7 @@ debug = "line-tables-only"# truck-shapeops with SolidCraft fixes (Apache-2.0, see vendor/truck-shapeops and ATTRIBUTION.md).[patch.crates-io]+truck-geometry = { path = "vendor/truck-geometry" }truck-shapeops = { path = "vendor/truck-shapeops" }truck-stepio = { path = "vendor/truck-stepio" }truck-meshalgo = { path = "vendor/truck-meshalgo" }diff --git a/THIRD-PARTY-LICENSES.txt b/THIRD-PARTY-LICENSES.txtindex 6254c85ec0..a702b820b8 100644--- a/THIRD-PARTY-LICENSES.txt+++ b/THIRD-PARTY-LICENSES.txt@@ -1536,10 +1536,11 @@ android-activity 0.6.1, arboard 3.6.1, color 0.3.3, fdeflate 0.3.7, fearless_simimage 0.25.10, linebender_resource_handle 0.1.1, miniz_oxide 0.8.9, miniz_oxide 0.9.1, naga 30.0.1,naga-types 30.0.1, pin-project 1.1.13, pin-project-internal 1.1.13, pin-project-lite 0.2.17,portable-atomic 1.15.0, portable-atomic-util 0.2.8, range-alloc 0.1.5, raw-window-handle 0.6.2,-simdutf8 0.1.5, truck-meshalgo 0.4.0, truck-shapeops 0.4.0, truck-stepio 0.3.0, vello_common 0.1.0,-vello_cpu 0.1.0, wgpu 30.0.1, wgpu-core 30.0.1, wgpu-core-deps-apple 30.0.1,-wgpu-core-deps-emscripten 30.0.1, wgpu-core-deps-wasm 30.0.1, wgpu-core-deps-windows-linux-android-30.0.1, wgpu-hal 30.0.1, wgpu-naga-bridge 30.0.1, wgpu-types 30.0.1+simdutf8 0.1.5, truck-geometry 0.5.0, truck-meshalgo 0.4.0, truck-shapeops 0.4.0, truck-stepio+0.3.0, vello_common 0.1.0, vello_cpu 0.1.0, wgpu 30.0.1, wgpu-core 30.0.1, wgpu-core-deps-apple+30.0.1, wgpu-core-deps-emscripten 30.0.1, wgpu-core-deps-wasm 30.0.1,+wgpu-core-deps-windows-linux-android 30.0.1, wgpu-hal 30.0.1, wgpu-naga-bridge 30.0.1, wgpu-types+30.0.1================================================================================Apache License@@ -15964,7 +15965,6 @@ rustls-platform-verifier-android 0.2.0: MIT OR Apache-2.0 (https://github.com/ruspirv 0.4.0+sdk-1.4.341.0: Apache-2.0 (https://github.com/gfx-rs/rspirv)truck-base 0.5.0: Apache-2.0 (https://github.com/ricosjp/truck)truck-derivers 0.1.0: Apache-2.0 (https://github.com/ricosjp/truck)-truck-geometry 0.5.0: Apache-2.0 (https://github.com/ricosjp/truck)truck-geotrait 0.4.0: Apache-2.0 (https://github.com/ricosjp/truck)truck-modeling 0.6.0: Apache-2.0 (https://github.com/ricosjp/truck)truck-polymesh 0.6.0: Apache-2.0 (https://github.com/ricosjp/truck)diff --git a/crates/kernel/src/issue_1038_tests.rs b/crates/kernel/src/issue_1038_tests.rsnew file mode 100644index 0000000000..ca3f16f1cf--- /dev/null+++ b/crates/kernel/src/issue_1038_tests.rs@@ -0,0 +1,81 @@+//! #1038: a small hole on a large curved face divides its intersection edges from each point's+//! neighbour (the vendored `IntersectionCurve::parameter_division`) instead of searching both+//! surfaces from nothing for every point. These pin the hinted division to the search from+//! nothing, so a refresh of the vendored crate can't quietly lose the speedup or change a body.++use std::time::{Duration, Instant};++use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2, Vec3};+use truck_modeling as mt;+use truck_modeling::{BoundedCurve, ParameterDivision1D};++use crate::{Body, BoolOp, build::extrude, cylinder, ops::boolean};++/// A 200 × 200 block whose top is one cubic wave across x (a single B-spline face), with a+/// Ø1 mm hole through it at the middle.+fn holed() -> (Body, Body) {+ let plane = Plane::new(Vec3::new(0.0, 200.0, 0.0), Vec3::X, Vec3::Z).unwrap();+ let (a, b, c, d) = (Vec2::new(0.0, 0.0), Vec2::new(200.0, 0.0), Vec2::new(200.0, 40.0), Vec2::new(0.0, 40.0));+ let top = Seg2::Cubic { p0: c, p1: Vec2::new(133.0, 70.0), p2: Vec2::new(67.0, 10.0), p3: d };+ let outer = Loop2 { segs: vec![Seg2::Line { a, b }, Seg2::Line { a: b, b: c }, top, Seg2::Line { a: d, b: a }] };+ let block = extrude(&plane, &[Region2 { outer, holes: vec![] }], 0.0, 200.0).unwrap().pop().unwrap();+ let tool = cylinder(Vec3::new(100.0, 100.0, -10.0), Vec3::Z, 0.5, 100.0).unwrap();+ let cut = boolean(&block, &tool, BoolOp::Cut).unwrap().unwrap();+ (block, cut)+}++fn intersection_curves(body: &Body) -> Vec<mt::Curve> {+ body.solid.edge_iter().map(|e| e.curve()).filter(|c| matches!(c, mt::Curve::IntersectionCurve(_))).collect()+}++fn timed<T>(f: impl Fn() -> T) -> (T, Duration) {+ let start = Instant::now();+ let out = f();+ (out, start.elapsed())+}++#[test]+fn a_small_hole_in_a_large_spline_face_cuts_cleanly() {+ let (block, cut) = holed();+ assert!(cut.validity().is_empty(), "{:?}", cut.validity());+ // The hole adds its wall (two half cylinders) and splits nothing: the bottom and the wave+ // each gain a loop.+ assert_eq!(cut.face_count(), block.face_count() + 2);+ let curves = intersection_curves(&cut);+ assert!(!curves.is_empty(), "the hole's rim on the wave is an intersection edge");+ // The wave is within a few tenths of a millimetre of flat across a Ø1 hole, so the hole+ // removes a cylinder as tall as the wave at its axis (the cubic's middle: z = 40).+ let (v0, v1) = (block.volume_at(0.001).unwrap(), cut.volume_at(0.001).unwrap());+ let removed = std::f64::consts::PI * 0.25 * 40.0;+ assert!((v0 - v1 - removed).abs() < 0.05 * removed, "removed {} of {removed}", v0 - v1);+}++#[test]+fn hinted_division_matches_the_search_from_nothing_and_is_faster() {+ let (_, cut) = holed();+ let (mut hinted_time, mut scratch_time) = (Duration::ZERO, Duration::ZERO);+ for curve in intersection_curves(&cut) {+ let mt::Curve::IntersectionCurve(ic) = &curve else { continue };+ let range = ic.range_tuple();+ for tol in [0.01, 0.001] {+ let ((hp, hq), ht) = timed(|| ic.parameter_division(range, tol));+ let ((sp, _), st) = timed(|| mt::algo::curve::parameter_division(ic, range, tol));+ hinted_time += ht;+ scratch_time += st;+ // The same division up to rounding: the hinted projections converge to within the+ // Newton tolerance of the searched ones, so a split the chord test only just asks for+ // can come out one way or the other, but no more than that.+ assert_eq!((hp.first(), hp.last()), (sp.first(), sp.last()), "tol {tol}");+ assert!(hp.len().abs_diff(sp.len()) <= 2, "tol {tol}: {} points hinted, {} from nothing", hp.len(), sp.len());+ // Every hinted point is the curve's own point at its parameter.+ for (t, h) in hp.iter().zip(&hq) {+ let s = ic.search_triple(*t).unwrap().0;+ assert!(mt::MetricSpace::distance(*h, s) < 1e-6, "tol {tol}, t {t}: {h:?} vs {s:?}");+ }+ }+ }+ eprintln!("hinted {hinted_time:?}, from nothing {scratch_time:?}");+ // The hinted path skips each point's grid search of the B-spline face; a loose bound, so a+ // loaded runner doesn't trip it, but one a fallback to the search for every point would.+ assert!(hinted_time * 2 < scratch_time, "hinted {hinted_time:?}, from nothing {scratch_time:?}");+}diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rsindex 2124837296..a152328c5a 100644--- a/crates/kernel/src/lib.rs+++ b/crates/kernel/src/lib.rs@@ -47,6 +47,8 @@ mod iges_out;#[cfg(test)]mod intersection_curve_tests;#[cfg(test)]+mod issue_1038_tests;+#[cfg(test)]mod issue_1080_tests;#[cfg(test)]mod issue_616_tests;diff --git a/vendor/README.md b/vendor/README.mdindex e748f75ee5..3b1e4ea5cc 100644--- a/vendor/README.md+++ b/vendor/README.md@@ -42,6 +42,18 @@ Changes:wrappers that drop the history; the `*_with_history` forms return the same solid with thehistory as an `Option` (`None` where a face or edge went unrecorded).+## truck-geometry 0.5.0 (Apache-2.0, © RICOS Co. Ltd., https://github.com/ricosjp/truck)++Changes:+- `decorators/intersection_curve.rs`: `IntersectionCurve::parameter_division` divides as+ `algo::curve::parameter_division` does (the same split points, in the same order), but each+ point's projection onto the two surfaces starts from the parameters of the point that begins+ its piece, instead of a search of the whole surfaces (a grid pre-search of a B-spline surface+ for every point: a small hole on a large curved face took seconds, #1038). A hinted result+ farther from the leader's point than the curve's tolerance (the projection settled on another+ part of a surface, such as the far side of a small hole) is dropped for the search from+ nothing, as before. `crates/kernel/src/issue_1038_tests.rs` holds it to that search.+## truck-stepio 0.3.0 (Apache-2.0, © RICOS Co. Ltd., https://github.com/ricosjp/truck)Only the writer (`out`) is used; SolidCraft reads STEP with its own reader.diff --git a/vendor/truck-geometry/.cargo-ok b/vendor/truck-geometry/.cargo-oknew file mode 100644index 0000000000..5f8b795830--- /dev/null+++ b/vendor/truck-geometry/.cargo-ok@@ -0,0 +1 @@+{"v":1}\ No newline at end of filediff --git a/vendor/truck-geometry/Cargo.toml b/vendor/truck-geometry/Cargo.tomlnew file mode 100644index 0000000000..c74275816e--- /dev/null+++ b/vendor/truck-geometry/Cargo.toml@@ -0,0 +1,55 @@+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO+#+# When uploading crates to the registry Cargo will automatically+# "normalize" Cargo.toml files for maximal compatibility+# with all versions of Cargo and also rewrite `path` dependencies+# to registry (e.g., crates.io) dependencies.+#+# If you are reading this file be aware that the original Cargo.toml+# will likely look very different (and much more reasonable).+# See Cargo.toml.orig for the original contents.++[package]+edition = "2021"+name = "truck-geometry"+version = "0.5.0"+authors = ["Yoshinori Tanimura <[email protected]>"]+build = false+autobins = false+autoexamples = false+autotests = false+autobenches = false+description = "geometrical structs: knot vector, B-spline and NURBS"+homepage = "https://github.com/ricosjp/truck"+readme = "README.md"+keywords = [+ "truck",+ "graphics",+]+categories = ["graphics"]+license = "Apache-2.0"+repository = "https://github.com/ricosjp/truck"++[lib]+name = "truck_geometry"+path = "src/lib.rs"++[dependencies.serde]+version = "1.0.210"+features = ["derive"]++[dependencies.thiserror]+version = "1.0.63"++[dependencies.truck-base]+version = "0.5.0"++[dependencies.truck-geotrait]+version = "0.4.0"++[dev-dependencies.rand]+version = "0.8.5"++[target.'cfg(target_arch = "wasm32")'.dev-dependencies.getrandom]+version = "0.2.15"+features = ["js"]diff --git a/vendor/truck-geometry/LICENSE b/vendor/truck-geometry/LICENSEnew file mode 100644index 0000000000..f433b1a53f--- /dev/null+++ b/vendor/truck-geometry/LICENSE@@ -0,0 +1,177 @@++ Apache License+ Version 2.0, January 2004+ http://www.apache.org/licenses/++ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION++ 1. Definitions.++ "License" shall mean the terms and conditions for use, reproduction,+ and distribution as defined by Sections 1 through 9 of this document.++ "Licensor" shall mean the copyright owner or entity authorized by+ the copyright owner that is granting the License.++ "Legal Entity" shall mean the union of the acting entity and all+ other entities that control, are controlled by, or are under common+ control with that entity. For the purposes of this definition,+ "control" means (i) the power, direct or indirect, to cause the+ direction or management of such entity, whether by contract or+ otherwise, or (ii) ownership of fifty percent (50%) or more of the+ outstanding shares, or (iii) beneficial ownership of such entity.++ "You" (or "Your") shall mean an individual or Legal Entity+ exercising permissions granted by this License.++ "Source" form shall mean the preferred form for making modifications,+ including but not limited to software source code, documentation+ source, and configuration files.++ "Object" form shall mean any form resulting from mechanical+ transformation or translation of a Source form, including but+ not limited to compiled object code, generated documentation,+ and conversions to other media types.++ "Work" shall mean the work of authorship, whether in Source or+ Object form, made available under the License, as indicated by a+ copyright notice that is included in or attached to the work+ (an example is provided in the Appendix below).++ "Derivative Works" shall mean any work, whether in Source or Object+ form, that is based on (or derived from) the Work and for which the+ editorial revisions, annotations, elaborations, or other modifications+ represent, as a whole, an original work of authorship. For the purposes+ of this License, Derivative Works shall not include works that remain+ separable from, or merely link (or bind by name) to the interfaces of,+ the Work and Derivative Works thereof.++ "Contribution" shall mean any work of authorship, including+ the original version of the Work and any modifications or additions+ to that Work or Derivative Works thereof, that is intentionally+ submitted to Licensor for inclusion in the Work by the copyright owner+ or by an individual or Legal Entity authorized to submit on behalf of+ the copyright owner. For the purposes of this definition, "submitted"+ means any form of electronic, verbal, or written communication sent+ to the Licensor or its representatives, including but not limited to+ communication on electronic mailing lists, source code control systems,+ and issue tracking systems that are managed by, or on behalf of, the+ Licensor for the purpose of discussing and improving the Work, but+ excluding communication that is conspicuously marked or otherwise+ designated in writing by the copyright owner as "Not a Contribution."++ "Contributor" shall mean Licensor and any individual or Legal Entity+ on behalf of whom a Contribution has been received by Licensor and+ subsequently incorporated within the Work.++ 2. Grant of Copyright License. Subject to the terms and conditions of+ this License, each Contributor hereby grants to You a perpetual,+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable+ copyright license to reproduce, prepare Derivative Works of,+ publicly display, publicly perform, sublicense, and distribute the+ Work and such Derivative Works in Source or Object form.++ 3. Grant of Patent License. Subject to the terms and conditions of+ this License, each Contributor hereby grants to You a perpetual,+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable+ (except as stated in this section) patent license to make, have made,+ use, offer to sell, sell, import, and otherwise transfer the Work,+ where such license applies only to those patent claims licensable+ by such Contributor that are necessarily infringed by their+ Contribution(s) alone or by combination of their Contribution(s)+ with the Work to which such Contribution(s) was submitted. If You+ institute patent litigation against any entity (including a+ cross-claim or counterclaim in a lawsuit) alleging that the Work+ or a Contribution incorporated within the Work constitutes direct+ or contributory patent infringement, then any patent licenses+ granted to You under this License for that Work shall terminate+ as of the date such litigation is filed.++ 4. Redistribution. You may reproduce and distribute copies of the+ Work or Derivative Works thereof in any medium, with or without+ modifications, and in Source or Object form, provided that You+ meet the following conditions:++ (a) You must give any other recipients of the Work or+ Derivative Works a copy of this License; and++ (b) You must cause any modified files to carry prominent notices+ stating that You changed the files; and++ (c) You must retain, in the Source form of any Derivative Works+ that You distribute, all copyright, patent, trademark, and+ attribution notices from the Source form of the Work,+ excluding those notices that do not pertain to any part of+ the Derivative Works; and++ (d) If the Work includes a "NOTICE" text file as part of its+ distribution, then any Derivative Works that You distribute must+ include a readable copy of the attribution notices contained+ within such NOTICE file, excluding those notices that do not+ pertain to any part of the Derivative Works, in at least one+ of the following places: within a NOTICE text file distributed+ as part of the Derivative Works; within the Source form or+ documentation, if provided along with the Derivative Works; or,+ within a display generated by the Derivative Works, if and+ wherever such third-party notices normally appear. The contents+ of the NOTICE file are for informational purposes only and+ do not modify the License. You may add Your own attribution+ notices within Derivative Works that You distribute, alongside+ or as an addendum to the NOTICE text from the Work, provided+ that such additional attribution notices cannot be construed+ as modifying the License.++ You may add Your own copyright statement to Your modifications and+ may provide additional or different license terms and conditions+ for use, reproduction, or distribution of Your modifications, or+ for any such Derivative Works as a whole, provided Your use,+ reproduction, and distribution of the Work otherwise complies with+ the conditions stated in this License.++ 5. Submission of Contributions. Unless You explicitly state otherwise,+ any Contribution intentionally submitted for inclusion in the Work+ by You to the Licensor shall be under the terms and conditions of+ this License, without any additional terms or conditions.+ Notwithstanding the above, nothing herein shall supersede or modify+ the terms of any separate license agreement you may have executed+ with Licensor regarding such Contributions.++ 6. Trademarks. This License does not grant permission to use the trade+ names, trademarks, service marks, or product names of the Licensor,+ except as required for reasonable and customary use in describing the+ origin of the Work and reproducing the content of the NOTICE file.++ 7. Disclaimer of Warranty. Unless required by applicable law or+ agreed to in writing, Licensor provides the Work (and each+ Contributor provides its Contributions) on an "AS IS" BASIS,+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or+ implied, including, without limitation, any warranties or conditions+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A+ PARTICULAR PURPOSE. You are solely responsible for determining the+ appropriateness of using or redistributing the Work and assume any+ risks associated with Your exercise of permissions under this License.++ 8. Limitation of Liability. In no event and under no legal theory,+ whether in tort (including negligence), contract, or otherwise,+ unless required by applicable law (such as deliberate and grossly+ negligent acts) or agreed to in writing, shall any Contributor be+ liable to You for damages, including any direct, indirect, special,+ incidental, or consequential damages of any character arising as a+ result of this License or out of the use or inability to use the+ Work (including but not limited to damages for loss of goodwill,+ work stoppage, computer failure or malfunction, or any and all+ other commercial damages or losses), even if such Contributor+ has been advised of the possibility of such damages.++ 9. Accepting Warranty or Additional Liability. While redistributing+ the Work or Derivative Works thereof, You may choose to offer,+ and charge a fee for, acceptance of support, warranty, indemnity,+ or other liability obligations and/or rights consistent with this+ License. However, in accepting such obligations, You may act only+ on Your own behalf and on Your sole responsibility, not on behalf+ of any other Contributor, and only if You agree to indemnify,+ defend, and hold each Contributor harmless for any liability+ incurred by, or claims asserted against, such Contributor by reason+ of your accepting any such warranty or additional liability.++ END OF TERMS AND CONDITIONSdiff --git a/vendor/truck-geometry/README.md b/vendor/truck-geometry/README.mdnew file mode 100644index 0000000000..5d2212dbbc--- /dev/null+++ b/vendor/truck-geometry/README.md@@ -0,0 +1,5 @@+# truck-geometry++[](https://crates.io/crates/truck-geometry) [](https://docs.rs/truck-geometry)++Geometrical structs: knot vector, B-spline and NURBSdiff --git a/vendor/truck-geometry/src/decorators/curve_on_surface.rs b/vendor/truck-geometry/src/decorators/curve_on_surface.rsnew file mode 100644index 0000000000..690ed2ce56--- /dev/null+++ b/vendor/truck-geometry/src/decorators/curve_on_surface.rs@@ -0,0 +1,228 @@+use super::*;++impl<C, S> PCurve<C, S> {+ /// Creates composited+ #[inline(always)]+ pub const fn new(curve: C, surface: S) -> PCurve<C, S> { PCurve { curve, surface } }++ /// Returns the reference to the parameter curve+ #[inline(always)]+ pub const fn curve(&self) -> &C { &self.curve }++ /// Returns the reference to the surface+ #[inline(always)]+ pub const fn surface(&self) -> &S { &self.surface }++ /// Decompose the pcurve into its parameter curve and surface.+ #[inline(always)]+ pub fn decompose(self) -> (C, S) { (self.curve, self.surface) }+}++impl<C, S> ParametricCurve for PCurve<C, S>+where+ C: ParametricCurve2D,+ S: ParametricSurface,+ S::Vector: VectorSpace<Scalar = f64>,+{+ type Point = S::Point;+ type Vector = S::Vector;+ #[inline(always)]+ fn subs(&self, t: f64) -> Self::Point {+ let pt = self.curve.subs(t);+ self.surface.subs(pt[0], pt[1])+ }+ #[inline(always)]+ fn der(&self, t: f64) -> Self::Vector {+ let pt = self.curve.subs(t);+ let der = self.curve.der(t);+ self.surface.uder(pt[0], pt[1]) * der[0] + self.surface.vder(pt[0], pt[1]) * der[1]+ }+ #[inline(always)]+ fn parameter_range(&self) -> ParameterRange { self.curve.parameter_range() }+ #[inline(always)]+ fn der2(&self, t: f64) -> Self::Vector {+ let pt = self.curve.subs(t);+ let der = self.curve.der(t);+ let der2 = self.curve.der2(t);+ self.surface.uuder(pt[0], pt[1]) * der[0] * der[0]+ + self.surface.uvder(pt[0], pt[1]) * der[0] * der[1] * 2.0+ + self.surface.vvder(pt[0], pt[1]) * der[1] * der[1]+ + self.surface.uder(pt[0], pt[1]) * der2[0]+ + self.surface.vder(pt[0], pt[1]) * der2[1]+ }+}++impl<C, S> BoundedCurve for PCurve<C, S>+where+ C: BoundedCurve,+ PCurve<C, S>: ParametricCurve,+{+}++impl<C, S> Cut for PCurve<C, S>+where+ C: Cut,+ S: Clone,+ PCurve<C, S>: ParametricCurve,+{+ fn cut(&mut self, t: f64) -> Self {+ let curve = self.curve.cut(t);+ Self {+ curve,+ surface: self.surface.clone(),+ }+ }+}++impl<C, S> SearchParameter<D1> for PCurve<C, S>+where+ C: ParametricCurve2D + SearchParameter<D1, Point = Point2>,+ S: SearchParameter<D2>,+{+ type Point = <S as SearchParameter<D2>>::Point;+ fn search_parameter<H: Into<SPHint1D>>(+ &self,+ point: Self::Point,+ hint: H,+ trials: usize,+ ) -> Option<f64> {+ let hint = hint.into();+ let shint = match hint {+ SPHint1D::Parameter(hint) => {+ let p = self.curve.subs(hint);+ SPHint2D::Parameter(p.x, p.y)+ }+ SPHint1D::Range(x, y) => {+ let p = self.curve.subs(y);+ let ranges = (0..PRESEARCH_DIVISION).fold(+ ((p.x, p.x), (p.y, p.y)),+ |((x0, x1), (y0, y1)), i| {+ let t = x + (y - x) * i as f64 / PRESEARCH_DIVISION as f64;+ let p = self.curve.subs(t);+ (+ (f64::min(x0, p.x), f64::max(x1, p.x)),+ (f64::min(y0, p.y), f64::max(y1, p.y)),+ )+ },+ );+ SPHint2D::Range(ranges.0, ranges.1)+ }+ SPHint1D::None => SPHint2D::None,+ };+ let (x, y) = self.surface.search_parameter(point, shint, trials)?;+ self.curve.search_parameter(Point2::new(x, y), hint, trials)+ }+}++impl<C, S> SearchNearestParameter<D1> for PCurve<C, S>+where+ Self: BoundedCurve,+ <Self as ParametricCurve>::Point: EuclideanSpace<Scalar = f64, Diff = <Self as ParametricCurve>::Vector>+ + MetricSpace<Metric = f64>,+ <Self as ParametricCurve>::Vector: InnerSpace<Scalar = f64> + Tolerance,+{+ type Point = <Self as ParametricCurve>::Point;+ fn search_nearest_parameter<H: Into<SPHint1D>>(+ &self,+ point: Self::Point,+ hint: H,+ trials: usize,+ ) -> Option<f64> {+ let hint = match hint.into() {+ SPHint1D::Parameter(hint) => hint,+ SPHint1D::Range(x, y) => {+ algo::curve::presearch(self, point, (x, y), PRESEARCH_DIVISION)+ }+ SPHint1D::None => {+ algo::curve::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::curve::search_nearest_parameter(self, point, hint, trials)+ }+}++impl<C, S> ParameterDivision1D for PCurve<C, S>+where+ C: ParametricCurve2D,+ S: ParametricSurface,+ S::Point: EuclideanSpace<Scalar = f64> + MetricSpace<Metric = f64> + HashGen<f64>,+ S::Vector: VectorSpace<Scalar = f64>,+{+ type Point = S::Point;+ fn parameter_division(&self, range: (f64, f64), tol: f64) -> (Vec<f64>, Vec<S::Point>) {+ algo::curve::parameter_division(self, range, tol)+ }+}++impl<C, S> Invertible for PCurve<C, S>+where+ C: Invertible,+ S: Clone,+{+ fn invert(&mut self) { self.curve.invert() }+}++impl<C: Clone, S: Clone, T> Transformed<T> for PCurve<C, S>+where S: Transformed<T>+{+ #[inline(always)]+ fn transform_by(&mut self, trans: T) { self.surface.transform_by(trans); }+ fn transformed(&self, trans: T) -> Self {+ Self {+ curve: self.curve.clone(),+ surface: self.surface.transformed(trans),+ }+ }+}++#[test]+fn pcurve_test() {+ let curve = BSplineCurve::new(+ KnotVec::bezier_knot(2),+ vec![+ Point2::new(1.0, 1.0),+ Point2::new(1.0, 0.0),+ Point2::new(0.0, 0.0),+ ],+ );+ let surface = BSplineSurface::new(+ (KnotVec::bezier_knot(2), KnotVec::bezier_knot(1)),+ vec![+ vec![Point3::new(0.0, 0.0, 0.0), Point3::new(0.0, 1.0, 0.0)],+ vec![Point3::new(0.0, 0.0, 1.0), Point3::new(0.0, 1.0, 1.0)],+ vec![Point3::new(1.0, 0.0, 1.0), Point3::new(1.0, 1.0, 1.0)],+ ],+ );+ let pcurve = PCurve::new(curve, surface);+ assert_eq!(pcurve.range_tuple(), (0.0, 1.0));++ const N: usize = 100;+ for i in 0..=N {+ let t = i as f64 / N as f64;+ assert_near!(+ pcurve.subs(t),+ Point3::new(+ (1.0 - t * t) * (1.0 - t * t),+ (1.0 - t) * (1.0 - t),+ 1.0 - t * t * t * t,+ ),+ );+ assert_near!(+ pcurve.der(t),+ Vector3::new(4.0 * t * (t * t - 1.0), 2.0 * (t - 1.0), -4.0 * t * t * t,),+ );+ assert_near!(+ pcurve.der2(t),+ Vector3::new(4.0 * (3.0 * t * t - 1.0), 2.0, -12.0 * t * t,),+ );+ }++ let t = 0.675;+ let pt = pcurve.subs(t);+ assert_near!(pcurve.search_parameter(pt, None, 100).unwrap(), t);++ let pt = pt + Vector3::new(0.01, 0.06, -0.03);+ assert!(pcurve.search_parameter(pt, None, 100).is_none());+ let t = pcurve.search_nearest_parameter(pt, None, 100).unwrap();+ assert!(pcurve.der(t).dot(pcurve.subs(t) - pt).so_small());+}diff --git a/vendor/truck-geometry/src/decorators/extruded_curve.rs b/vendor/truck-geometry/src/decorators/extruded_curve.rsnew file mode 100644index 0000000000..7128e69717--- /dev/null+++ b/vendor/truck-geometry/src/decorators/extruded_curve.rs@@ -0,0 +1,203 @@+use super::*;++impl<C, V: Copy> ExtrudedCurve<C, V> {+ /// Creates a linear extruded curve by extrusion.+ #[inline(always)]+ pub const fn by_extrusion(curve: C, vector: V) -> Self { Self { curve, vector } }++ /// Returns the curve before extruded.+ #[inline(always)]+ pub const fn entity_curve(&self) -> &C { &self.curve }+ /// Into the curve before revoluted.+ #[inline(always)]+ pub fn into_entity_curve(self) -> C { self.curve }++ /// Returns the vector of extruded curve.+ #[inline(always)]+ pub const fn extruding_vector(&self) -> V { self.vector }+}++impl<C> ParametricSurface for ExtrudedCurve<C, C::Vector>+where+ C: ParametricCurve,+ C::Point: EuclideanSpace<Scalar = f64, Diff = C::Vector>,+ C::Vector: VectorSpace<Scalar = f64>,+{+ type Point = C::Point;+ type Vector = C::Vector;+ #[inline(always)]+ fn subs(&self, u: f64, v: f64) -> C::Point { self.curve.subs(u) + self.vector * v }+ #[inline(always)]+ fn uder(&self, u: f64, _: f64) -> C::Vector { self.curve.der(u) }+ #[inline(always)]+ fn vder(&self, _: f64, _: f64) -> C::Vector { self.vector }+ #[inline(always)]+ fn uuder(&self, u: f64, _: f64) -> C::Vector { self.curve.der2(u) }+ #[inline(always)]+ fn uvder(&self, _: f64, _: f64) -> C::Vector { C::Vector::zero() }+ #[inline(always)]+ fn vvder(&self, _: f64, _: f64) -> C::Vector { C::Vector::zero() }+ #[inline(always)]+ fn parameter_range(&self) -> (ParameterRange, ParameterRange) {+ (+ self.curve.parameter_range(),+ (Bound::Included(0.0), Bound::Included(1.0)),+ )+ }+ #[inline(always)]+ fn u_period(&self) -> Option<f64> { self.curve.period() }+}++impl<C: ParametricCurve3D> ParametricSurface3D for ExtrudedCurve<C, Vector3> {+ #[inline(always)]+ fn normal(&self, u: f64, _: f64) -> C::Vector {+ self.curve.der(u).cross(self.vector).normalize()+ }+}++impl<C, V> BoundedSurface for ExtrudedCurve<C, V>+where+ C: BoundedCurve,+ Self: ParametricSurface,+{+}++impl<C: ParameterDivision1D, V> ParameterDivision2D for ExtrudedCurve<C, V> {+ #[inline(always)]+ fn parameter_division(+ &self,+ (urange, vrange): ((f64, f64), (f64, f64)),+ tol: f64,+ ) -> (Vec<f64>, Vec<f64>) {+ (+ self.curve.parameter_division(urange, tol).0,+ vec![vrange.0, vrange.1],+ )+ }+}++impl<C: ParametricCurve2D + BoundedCurve> SearchParameter<D2> for ExtrudedCurve<C, Vector2> {+ type Point = Point2;+ #[inline(always)]+ fn search_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point2,+ hint: H,+ trials: usize,+ ) -> Option<(f64, f64)> {+ let hint = match hint.into() {+ SPHint2D::Parameter(x, y) => (x, y),+ SPHint2D::Range(range0, range1) => {+ algo::surface::presearch(self, point, (range0, range1), PRESEARCH_DIVISION)+ }+ SPHint2D::None => {+ algo::surface::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::surface::search_parameter2d(self, point, hint, trials)+ }+}++impl<C: ParametricCurve3D + BoundedCurve> SearchParameter<D2> for ExtrudedCurve<C, Vector3> {+ type Point = Point3;+ #[inline(always)]+ fn search_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point3,+ hint: H,+ trials: usize,+ ) -> Option<(f64, f64)> {+ let hint = match hint.into() {+ SPHint2D::Parameter(x, y) => (x, y),+ SPHint2D::Range(range0, range1) => {+ algo::surface::presearch(self, point, (range0, range1), PRESEARCH_DIVISION)+ }+ SPHint2D::None => {+ algo::surface::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::surface::search_parameter3d(self, point, hint, trials)+ }+}++impl<C: ParametricCurve3D + BoundedCurve> SearchNearestParameter<D2> for ExtrudedCurve<C, Vector3> {+ type Point = Point3;+ #[inline(always)]+ fn search_nearest_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point3,+ hint: H,+ trials: usize,+ ) -> Option<(f64, f64)> {+ let hint = match hint.into() {+ SPHint2D::Parameter(x, y) => (x, y),+ SPHint2D::Range(range0, range1) => {+ algo::surface::presearch(self, point, (range0, range1), PRESEARCH_DIVISION)+ }+ SPHint2D::None => {+ algo::surface::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::surface::search_nearest_parameter(self, point, hint, trials)+ }+}++impl<C: Invertible> Invertible for ExtrudedCurve<C, Vector3> {+ #[inline(always)]+ fn invert(&mut self) { self.curve.invert() }+ #[inline(always)]+ fn inverse(&self) -> Self {+ Self {+ curve: self.curve.inverse(),+ vector: self.vector,+ }+ }+}++impl<C: Transformed<Matrix4>> Transformed<Matrix4> for ExtrudedCurve<C, Vector3> {+ fn transform_by(&mut self, trans: Matrix4) {+ self.curve.transform_by(trans);+ self.vector = trans.transform_vector(self.vector);+ }+ fn transformed(&self, trans: Matrix4) -> Self {+ Self {+ curve: self.curve.transformed(trans),+ vector: trans.transform_vector(self.vector),+ }+ }+}++#[test]+fn extruded_curve_test() {+ let cpts = vec![+ Point3::new(0.0, 0.0, 0.0),+ Point3::new(0.0, 1.0, 0.0),+ Point3::new(1.0, 0.0, 0.0),+ ];+ let spts = vec![+ vec![Point3::new(0.0, 0.0, 0.0), Point3::new(0.0, 0.0, 1.0)],+ vec![Point3::new(0.0, 1.0, 0.0), Point3::new(0.0, 1.0, 1.0)],+ vec![Point3::new(1.0, 0.0, 0.0), Point3::new(1.0, 0.0, 1.0)],+ ];+ let curve = BSplineCurve::new(KnotVec::bezier_knot(2), cpts);+ let surface0 = ExtrudedCurve::by_extrusion(curve, Vector3::unit_z());+ let surface1 = BSplineSurface::new((KnotVec::bezier_knot(2), KnotVec::bezier_knot(1)), spts);+ assert_eq!(surface0.range_tuple(), surface1.range_tuple());+ const N: usize = 10;+ for i in 0..=N {+ for j in 0..=N {+ let u = i as f64 / N as f64;+ let v = j as f64 / N as f64;+ assert_near!(+ surface0.subs(u, v),+ ParametricSurface::subs(&surface1, u, v)+ );+ assert_near!(surface0.uder(u, v), surface1.uder(u, v));+ assert_near!(surface0.vder(u, v), surface1.vder(u, v));+ assert_near!(surface0.uuder(u, v), surface1.uuder(u, v));+ assert_near!(surface0.uvder(u, v), surface1.uvder(u, v));+ assert_near!(surface0.vvder(u, v), surface1.vvder(u, v));+ assert_near!(surface0.normal(u, v), surface1.normal(u, v));+ }+ }+}diff --git a/vendor/truck-geometry/src/decorators/intersection_curve.rs b/vendor/truck-geometry/src/decorators/intersection_curve.rsnew file mode 100644index 0000000000..d6390e61e2--- /dev/null+++ b/vendor/truck-geometry/src/decorators/intersection_curve.rs@@ -0,0 +1,330 @@+use super::*;++#[doc(hidden)]+pub fn double_projection<S>(+ surface0: &S,+ hint0: Option<(f64, f64)>,+ surface1: &S,+ hint1: Option<(f64, f64)>,+ mut point: Point3,+ normal: Vector3,+ trials: usize,+) -> Option<(Point3, Point2, Point2)>+where+ S: ParametricSurface3D + SearchNearestParameter<D2, Point = Point3>,+{+ #[cfg(all(test, debug_assertions))]+ let mut log = Vec::new();+ let mut uv0 = surface0.search_nearest_parameter(point, hint0, 10)?;+ let mut uv1 = surface1.search_nearest_parameter(point, hint1, 10)?;+ for _ in 0..trials {+ #[cfg(all(test, debug_assertions))]+ log.push((point, uv0, uv1));+ uv0 = surface0.search_nearest_parameter(point, Some(uv0), 10)?;+ let pt0 = surface0.subs(uv0.0, uv0.1);+ uv1 = surface1.search_nearest_parameter(point, Some(uv1), 10)?;+ let pt1 = surface1.subs(uv1.0, uv1.1);+ if point.near(&pt0) && point.near(&pt1) && pt0.near(&pt1) {+ return Some((point, Point2::from(uv0), Point2::from(uv1)));+ } else {+ let n0 = surface0.normal(uv0.0, uv0.1);+ let n1 = surface1.normal(uv1.0, uv1.1);+ let mat = Matrix3::from_cols(n0, n1, normal).transpose();+ let inv = mat.invert()?;+ let pt = inv * Vector3::new(pt0.dot(n0), pt1.dot(n1), point.dot(normal));+ point = Point3::from_vec(pt);+ }+ }+ #[cfg(all(test, debug_assertions))]+ {+ eprintln!("Newton method is not converges");+ log.into_iter().for_each(|t| eprintln!("{t:?}"));+ }+ None+}++/// Mutable editor for `IntersectionCurve`.+#[doc(hidden)]+#[derive(Debug)]+pub struct IntersectionCurveEditor<'a, C, S> {+ pub surface0: &'a mut S,+ pub surface1: &'a mut S,+ pub leader: &'a mut C,+ pub tol: &'a mut f64,+}++impl<C, S> IntersectionCurve<C, S> {+ /// This curve is a part of intersection of `self.surface0()` and `self.surface1()`.+ #[inline(always)]+ pub fn surface0(&self) -> &S { &self.surface0 }+ /// This curve is a part of intersection of `self.surface0()` and `self.surface1()`.+ #[inline(always)]+ pub fn surface1(&self) -> &S { &self.surface1 }+ /// Returns the polyline leading this curve.+ #[inline(always)]+ pub fn leader(&self) -> &C { &self.leader }+ /// Returns editor for `IntersectionCurve`. This method is only for developers, do not use.+ #[doc(hidden)]+ #[inline(always)]+ pub fn editor(&mut self) -> IntersectionCurveEditor<'_, C, S> {+ IntersectionCurveEditor {+ surface0: &mut self.surface0,+ surface1: &mut self.surface1,+ leader: &mut self.leader,+ tol: &mut self.tol,+ }+ }+ /// Change leader.+ #[doc(hidden)]+ #[inline(always)]+ pub fn change_leader<D>(self, f: impl FnOnce(C) -> D) -> IntersectionCurve<D, S> {+ IntersectionCurve {+ surface0: self.surface0,+ surface1: self.surface1,+ leader: f(self.leader),+ tol: self.tol,+ }+ }+ /// The tolerance for generating this intersection curve.+ #[inline(always)]+ pub fn tolerance(&self) -> f64 { self.tol }+ /// Creates intersection curve with unchecked bound. This method is only for developer of `truck`, deplicated for users.+ #[inline(always)]+ pub fn new_unchecked(surface0: Box<S>, surface1: Box<S>, leader: C, tol: f64) -> Self {+ Self {+ surface0,+ surface1,+ leader,+ tol,+ }+ }+}++impl<C, S> IntersectionCurve<C, S>+where+ C: ParametricCurve3D,+ S: ParametricSurface3D + SearchNearestParameter<D2, Point = Point3>,+{+ /// Search triple value of the point corresponding to the parameter `t`.+ /// - the coordinate on 3D space+ /// - the uv coordinate on `self.surface0()`+ /// - the uv coordinate on `self.surface1()`+ #[inline(always)]+ pub fn search_triple(&self, t: f64) -> Option<(Point3, Point2, Point2)> {+ double_projection(+ self.surface0(),+ None,+ self.surface1(),+ None,+ self.leader.subs(t),+ self.leader.der(t),+ 100,+ )+ }+}++impl<C, S> ParametricCurve for IntersectionCurve<C, S>+where+ C: ParametricCurve3D,+ S: ParametricSurface3D + SearchNearestParameter<D2, Point = Point3>,+{+ type Point = Point3;+ type Vector = Vector3;+ fn subs(&self, t: f64) -> Point3 { self.search_triple(t).unwrap().0 }+ fn der(&self, t: f64) -> Vector3 {+ let n = self.leader.der(t);+ let (_, p0, p1) = self.search_triple(t).unwrap();+ let d = self+ .surface0+ .normal(p0.x, p0.y)+ .cross(self.surface1.normal(p1.x, p1.y))+ .normalize();+ d * (n.dot(n) / d.dot(n))+ }+ /// This method is unimplemented! Should panic!!+ #[inline(always)]+ fn der2(&self, _: f64) -> Vector3 {+ unimplemented!();+ }+ #[inline(always)]+ fn parameter_range(&self) -> ParameterRange { self.leader.parameter_range() }+}++impl<C, S> BoundedCurve for IntersectionCurve<C, S>+where+ C: ParametricCurve3D + BoundedCurve,+ S: ParametricSurface3D + SearchNearestParameter<D2, Point = Point3>,+{+}++impl<C, S> ParameterDivision1D for IntersectionCurve<C, S>+where+ C: ParametricCurve3D,+ S: ParametricSurface3D + SearchNearestParameter<D2, Point = Point3>,+{+ type Point = Point3;+ // SolidCraft: the division of `algo::curve::parameter_division` (the same split points and+ // the same order), but each point's projection onto the two surfaces starts from the+ // parameters of the point that begins its piece instead of a search of the whole surfaces:+ // that search ran for every point and made dividing an intersection edge on a large B-spline+ // surface take seconds. A point the hinted projection misses is searched for as before.+ fn parameter_division(&self, range: (f64, f64), tol: f64) -> (Vec<f64>, Vec<Point3>) {+ nonpositive_tolerance!(tol);+ let start = self.hinted_triple(range.0, None);+ let end = self.hinted_triple(range.1, None);+ hinted_sub_division(self, range, (start, end), tol, 100)+ }+}++// SolidCraft: a point of the curve with its parameters on both surfaces.+type Triple = (Point3, Point2, Point2);++impl<C, S> IntersectionCurve<C, S>+where+ C: ParametricCurve3D,+ S: ParametricSurface3D + SearchNearestParameter<D2, Point = Point3>,+{+ // SolidCraft: `search_triple` started from `hint`'s parameters, falling back to the search+ // from nothing (and, where that fails too, to `subs` as before). A hinted result is taken+ // only within the curve's tolerance of the leader's point, where the leader lies: started+ // from a neighbour (or from a periodic surface's seam), the projection can settle on another+ // part of a surface, such as the far side of a small hole, which the search from nothing+ // would not.+ fn hinted_triple(&self, t: f64, hint: Option<Triple>) -> Triple {+ let lead = self.leader.subs(t);+ let near = self.tol.max(TOLERANCE);+ let hinted = hint.and_then(|(_, uv0, uv1)| {+ double_projection(+ self.surface0(),+ Some((uv0.x, uv0.y)),+ self.surface1(),+ Some((uv1.x, uv1.y)),+ lead,+ self.leader.der(t),+ 100,+ )+ .filter(|(p, _, _)| p.distance(lead) <= near)+ });+ match hinted.or_else(|| self.search_triple(t)) {+ Some(triple) => triple,+ None => (self.subs(t), Point2::origin(), Point2::origin()),+ }+ }+}++// SolidCraft: `algo::curve::sub_parameter_division`, carrying each end's parameters.+fn hinted_sub_division<C, S>(+ curve: &IntersectionCurve<C, S>,+ range: (f64, f64),+ ends: (Triple, Triple),+ tol: f64,+ trials: usize,+) -> (Vec<f64>, Vec<Point3>)+where+ C: ParametricCurve3D,+ S: ParametricSurface3D + SearchNearestParameter<D2, Point = Point3>,+{+ let (p0, p1) = (ends.0 .0, ends.1 .0);+ let gen = p0.midpoint(p1);+ let p = 0.5 + (0.2 * HashGen::hash1(gen) - 0.1);+ let t = range.0 * (1.0 - p) + range.1 * p;+ let mid = p0 + (p1 - p0) * p;+ let dist2 = curve.hinted_triple(t, Some(ends.0)).0.distance2(mid);+ if dist2 < tol * tol || trials == 0 {+ (vec![range.0, range.1], vec![p0, p1])+ } else {+ let mid_param = (range.0 + range.1) / 2.0;+ let mid_value = curve.hinted_triple(mid_param, Some(ends.0));+ let (mut params, mut pts) =+ hinted_sub_division(curve, (range.0, mid_param), (ends.0, mid_value), tol, trials - 1);+ let _ = (params.pop(), pts.pop());+ let (new_params, new_pts) =+ hinted_sub_division(curve, (mid_param, range.1), (mid_value, ends.1), tol, trials - 1);+ params.extend(new_params);+ pts.extend(new_pts);+ (params, pts)+ }+}++impl<C, S> Cut for IntersectionCurve<C, S>+where+ C: Cut<Point = Point3, Vector = Vector3>,+ S: ParametricSurface3D + SearchNearestParameter<D2, Point = Point3>,+{+ #[inline(always)]+ fn cut(&mut self, t: f64) -> Self {+ Self {+ surface0: self.surface0.clone(),+ surface1: self.surface1.clone(),+ leader: self.leader.cut(t),+ tol: self.tol,+ }+ }+}++impl<C: Invertible, S: Clone> Invertible for IntersectionCurve<C, S> {+ fn invert(&mut self) { self.leader.invert(); }+}++impl<C, S> SearchParameter<D1> for IntersectionCurve<C, S>+where+ C: ParametricCurve3D + SearchNearestParameter<D1, Point = Point3>,+ S: ParametricSurface3D + SearchNearestParameter<D2, Point = Point3>,+{+ type Point = Point3;+ fn search_parameter<H: Into<SPHint1D>>(+ &self,+ point: Point3,+ hint: H,+ trials: usize,+ ) -> Option<f64> {+ let t = self+ .leader()+ .search_nearest_parameter(point, hint, trials)+ .unwrap();+ let pt = self.subs(t);+ match pt.near(&point) {+ true => Some(t),+ false => None,+ }+ }+}++/// Only derive from leading curve. Not precise.+impl<C, S> SearchNearestParameter<D1> for IntersectionCurve<C, S>+where+ C: ParametricCurve3D + SearchNearestParameter<D1, Point = Point3>,+ S: ParametricSurface3D + SearchNearestParameter<D2, Point = Point3>,+{+ type Point = Point3;+ fn search_nearest_parameter<H: Into<SPHint1D>>(+ &self,+ point: Point3,+ hint: H,+ trials: usize,+ ) -> Option<f64> {+ self.leader().search_nearest_parameter(point, hint, trials)+ }+}++impl<C, S> Transformed<Matrix4> for IntersectionCurve<C, S>+where+ C: Transformed<Matrix4>,+ S: Transformed<Matrix4>,+{+ fn transform_by(&mut self, trans: Matrix4) {+ self.surface0.transform_by(trans);+ self.surface1.transform_by(trans);+ self.leader.transform_by(trans);+ self.tol *= trans.norm_l2();+ }+}++impl<C: BoundedCurve> IntersectionCurve<C, Plane> {+ /// Optimizes intersection curve of [`Plane`] into [`Line`].+ #[inline]+ pub fn optimize(&self) -> Line<C::Point> {+ let (s, t) = self.leader.range_tuple();+ Line(self.leader.subs(s), self.leader.subs(t))+ }+}diff --git a/vendor/truck-geometry/src/decorators/mod.rs b/vendor/truck-geometry/src/decorators/mod.rsnew file mode 100644index 0000000000..5961c1e56e--- /dev/null+++ b/vendor/truck-geometry/src/decorators/mod.rs@@ -0,0 +1,149 @@+use crate::{prelude::*, *};+use std::ops::{Deref, DerefMut, Mul};++/// revolution+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+struct Revolution {+ origin: Point3,+ axis: Vector3,+}++/// surface constructed by revoluting a curve+/// # Examples+/// Revoluted sphere+/// ```+/// use truck_geometry::prelude::*;+/// use std::f64::consts::PI;+/// let knot_vec = KnotVec::bezier_knot(2);+/// let control_points = vec![+/// Vector4::new(1.0, 0.0, 0.0, 1.0),+/// Vector4::new(0.0, 1.0, 0.0, 0.0),+/// Vector4::new(-1.0, 0.0, 0.0, 1.0),+/// ];+/// // upper half circle on xy-plane+/// let uhcircle = NurbsCurve::new(BSplineCurve::new(knot_vec, control_points));+/// // sphere constructed by revolute circle+/// let sphere = RevolutedCurve::by_revolution(+/// uhcircle, Point3::origin(), Vector3::unit_x(),+/// );+/// const N: usize = 30;+/// for i in 0..=N {+/// for j in 0..=N {+/// let u = i as f64 / N as f64;+/// let v = 2.0 * PI * j as f64 / N as f64;+/// let pt: Vector3 = sphere.subs(u, v).to_vec();+/// assert_near2!(pt.magnitude2(), 1.0);+/// assert_near!(pt, sphere.normal(u, v));+/// }+/// }+/// ```+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+pub struct RevolutedCurve<C> {+ curve: C,+ revolution: Revolution,+}++/// Linearly extruded curve+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+pub struct ExtrudedCurve<C, V> {+ curve: C,+ vector: V,+}++/// invertible and transformable geometric element+/// # Examples+/// Curve processing example+/// ```+/// use truck_geometry::prelude::*;+/// let curve: BSplineCurve<Point3> = BSplineCurve::new(+/// KnotVec::bezier_knot(2),+/// vec![+/// Point3::new(0.0, 0.0, 0.0),+/// Point3::new(0.0, 0.0, 1.0),+/// Point3::new(1.0, 0.0, 0.0),+/// ],+/// );+/// let mut processed = Processor::<_, Matrix4>::new(curve.clone());+///+/// // both curves are the same curve+/// const N: usize = 100;+/// for i in 0..=N {+/// let t = i as f64 / N as f64;+/// assert_eq!(curve.subs(t), processed.subs(t));+/// }+///+/// // Processed curve can inverted!+/// processed.invert();+/// for i in 0..=N {+/// let t = i as f64 / N as f64;+/// assert_eq!(curve.subs(1.0 - t), processed.subs(t));+/// }+/// ```+/// Surface processing example+/// ```+/// use truck_geometry::prelude::*;+/// use std::f64::consts::PI;+///+/// let sphere = Sphere::new(Point3::new(1.0, 2.0, 3.0), 2.45);+/// let mut processed = Processor::<_, Matrix4>::new(sphere);+///+/// // both surfaces are the same surface+/// const N: usize = 100;+/// for i in 0..=N {+/// for j in 0..=N {+/// let u = PI * i as f64 / N as f64;+/// let v = 2.0 * PI * j as f64 / N as f64;+/// assert_eq!(sphere.subs(u, v), processed.subs(u, v));+/// }+/// }+///+/// // Processed surface can be inverted!+/// // Here, "invert surface" means swap (u, v)-axes.+/// processed.invert();+/// for i in 0..=N {+/// for j in 0..=N {+/// let u = PI * i as f64 / N as f64;+/// let v = 2.0 * PI * j as f64 / N as f64;+/// assert_eq!(sphere.subs(u, v), processed.subs(v, u));+/// }+/// }+/// ```+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+pub struct Processor<E, T> {+ entity: E,+ transform: T,+ orientation: bool,+}++/// The composited maps+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+pub struct PCurve<C, S> {+ curve: C,+ surface: S,+}++/// Intersection curve between two surfaces.+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]+pub struct IntersectionCurve<C, S> {+ // Considering rotational surfaces, we can consider the case+ // where the class `S` holds the curve `C` as a variable.+ surface0: Box<S>,+ surface1: Box<S>,+ leader: C,+ tol: f64,+}++/// trimmed curve for parametric curve+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]+pub struct TrimmedCurve<C> {+ curve: C,+ range: (f64, f64),+}++mod curve_on_surface;+mod extruded_curve;+mod intersection_curve;+mod processor;+mod revolved_curve;+mod trimmied_curve;+pub use intersection_curve::double_projection;diff --git a/vendor/truck-geometry/src/decorators/processor.rs b/vendor/truck-geometry/src/decorators/processor.rsnew file mode 100644index 0000000000..3f44d3d8db--- /dev/null+++ b/vendor/truck-geometry/src/decorators/processor.rs@@ -0,0 +1,658 @@+use super::*;++impl<E, T: One> Processor<E, T> {+ /// Creates new processor+ #[inline(always)]+ pub fn new(entity: E) -> Processor<E, T> {+ Processor {+ entity,+ transform: T::one(),+ orientation: true,+ }+ }++ /// Returns the reference of entity+ #[inline(always)]+ pub const fn entity(&self) -> &E { &self.entity }++ /// Returns the reference of transform+ #[inline(always)]+ pub const fn transform(&self) -> &T { &self.transform }++ /// Returns the orientation of surface+ #[inline(always)]+ pub const fn orientation(&self) -> bool { self.orientation }++ #[inline(always)]+ fn sign(&self) -> f64 {+ match self.orientation {+ true => 1.0,+ false => -1.0,+ }+ }++ /// apply the function to the entity geometry+ #[inline(always)]+ pub fn map<G, F: FnOnce(E) -> G>(self, f: F) -> Processor<G, T> {+ Processor {+ entity: f(self.entity),+ transform: self.transform,+ orientation: self.orientation,+ }+ }++ /// apply the function to the entity geometry+ #[inline(always)]+ pub fn map_ref<G, F: FnOnce(&E) -> G>(&self, f: F) -> Processor<G, T>+ where T: Copy {+ Processor {+ entity: f(&self.entity),+ transform: self.transform,+ orientation: self.orientation,+ }+ }++ /// apply the transform and inverse+ pub fn constract(self) -> E+ where E: Transformed<T> + Invertible {+ let mut res = self.entity;+ res.transform_by(self.transform);+ if !self.orientation {+ res.invert();+ }+ res+ }+}++impl<E: Clone, T: Clone> Invertible for Processor<E, T> {+ #[inline(always)]+ fn invert(&mut self) { self.orientation = !self.orientation; }+ #[inline(always)]+ fn inverse(&self) -> Self {+ Processor {+ entity: self.entity.clone(),+ transform: self.transform.clone(),+ orientation: !self.orientation,+ }+ }+}++impl<C: BoundedCurve, T> Processor<C, T> {+ #[inline(always)]+ fn get_curve_parameter(&self, t: f64) -> f64 {+ let (t0, t1) = self.range_tuple();+ match self.orientation {+ true => t,+ false => t0 + t1 - t,+ }+ }+}++impl<C, T> ParametricCurve for Processor<C, T>+where+ C: BoundedCurve,+ C::Point: EuclideanSpace<Diff = C::Vector>,+ C::Vector: VectorSpace<Scalar = f64>,+ T: Transform<C::Point> + Clone,+{+ type Point = C::Point;+ type Vector = C::Vector;+ #[inline(always)]+ fn subs(&self, t: f64) -> C::Point {+ let t = self.get_curve_parameter(t);+ self.transform.transform_point(self.entity.subs(t))+ }+ #[inline(always)]+ fn der(&self, t: f64) -> Self::Vector {+ let t = self.get_curve_parameter(t);+ self.transform.transform_vector(self.entity.der(t)) * self.sign()+ }+ #[inline(always)]+ fn der2(&self, t: f64) -> Self::Vector {+ let t = self.get_curve_parameter(t);+ self.transform.transform_vector(self.entity.der2(t))+ }+ #[inline(always)]+ fn parameter_range(&self) -> ParameterRange { self.entity.parameter_range() }+ #[inline(always)]+ fn period(&self) -> Option<f64> { self.entity.period() }+}++impl<C, T> BoundedCurve for Processor<C, T>+where+ C: BoundedCurve,+ C::Point: EuclideanSpace<Diff = C::Vector>,+ C::Vector: VectorSpace<Scalar = f64>,+ T: Transform<C::Point> + Clone,+{+}++impl<C, T> Cut for Processor<C, T>+where+ C: BoundedCurve + Cut,+ C::Point: EuclideanSpace<Diff = C::Vector>,+ C::Vector: VectorSpace<Scalar = f64>,+ T: Transform<C::Point> + Clone,+{+ fn cut(&mut self, t: f64) -> Self {+ let t = self.get_curve_parameter(t);+ let mut entity = self.entity.cut(t);+ if !self.orientation {+ std::mem::swap(&mut entity, &mut self.entity);+ }+ Self {+ entity,+ transform: self.transform.clone(),+ orientation: self.orientation,+ }+ }+}++impl<S, T> ParametricSurface for Processor<S, T>+where+ S: ParametricSurface,+ S::Point: EuclideanSpace<Scalar = f64, Diff = S::Vector>,+ T: Transform<S::Point> + SquareMatrix<Scalar = f64> + Clone,+{+ type Point = S::Point;+ type Vector = S::Vector;+ #[inline(always)]+ fn subs(&self, u: f64, v: f64) -> Self::Point {+ match self.orientation {+ true => self.transform.transform_point(self.entity.subs(u, v)),+ false => self.transform.transform_point(self.entity.subs(v, u)),+ }+ }+ #[inline(always)]+ fn uder(&self, u: f64, v: f64) -> Self::Vector {+ match self.orientation {+ true => self.transform.transform_vector(self.entity.uder(u, v)),+ false => self.transform.transform_vector(self.entity.vder(v, u)),+ }+ }+ #[inline(always)]+ fn vder(&self, u: f64, v: f64) -> Self::Vector {+ match self.orientation {+ true => self.transform.transform_vector(self.entity.vder(u, v)),+ false => self.transform.transform_vector(self.entity.uder(v, u)),+ }+ }+ #[inline(always)]+ fn uuder(&self, u: f64, v: f64) -> Self::Vector {+ match self.orientation {+ true => self.transform.transform_vector(self.entity.uuder(u, v)),+ false => self.transform.transform_vector(self.entity.vvder(v, u)),+ }+ }+ #[inline(always)]+ fn uvder(&self, u: f64, v: f64) -> Self::Vector {+ match self.orientation {+ true => self.transform.transform_vector(self.entity.uvder(u, v)),+ false => self.transform.transform_vector(self.entity.uvder(v, u)),+ }+ }+ #[inline(always)]+ fn vvder(&self, u: f64, v: f64) -> Self::Vector {+ match self.orientation {+ true => self.transform.transform_vector(self.entity.vvder(u, v)),+ false => self.transform.transform_vector(self.entity.uuder(v, u)),+ }+ }+ #[inline(always)]+ fn parameter_range(&self) -> (ParameterRange, ParameterRange) {+ let (urange, vrange) = self.entity.parameter_range();+ match self.orientation {+ true => (urange, vrange),+ false => (vrange, urange),+ }+ }+ #[inline(always)]+ fn u_period(&self) -> Option<f64> {+ match self.orientation {+ true => self.entity.u_period(),+ false => self.entity.v_period(),+ }+ }+ #[inline(always)]+ fn v_period(&self) -> Option<f64> {+ match self.orientation {+ true => self.entity.v_period(),+ false => self.entity.u_period(),+ }+ }+}++impl<S, T> ParametricSurface3D for Processor<S, T>+where+ S: ParametricSurface3D,+ T: Transform<Point3> + SquareMatrix<Scalar = f64> + Clone,+{+ #[inline(always)]+ fn normal(&self, u: f64, v: f64) -> Self::Vector {+ let transtrans = self.transform.transpose();+ let n = match self.orientation {+ true => self.entity.normal(u, v),+ false => -self.entity.normal(v, u),+ };+ let n = transtrans+ .inverse_transform_vector(n)+ .expect("invalid transform");+ (n / self.transform.determinant()).normalize()+ }+}++impl<S, T> BoundedSurface for Processor<S, T>+where+ S: BoundedSurface<Point = Point3, Vector = Vector3>,+ T: Transform<S::Point> + SquareMatrix<Scalar = f64> + Clone,+{+}++impl<E, T> Deref for Processor<E, T> {+ type Target = E;+ #[inline(always)]+ fn deref(&self) -> &E { &self.entity }+}++impl<E, T> DerefMut for Processor<E, T> {+ #[inline(always)]+ fn deref_mut(&mut self) -> &mut E { &mut self.entity }+}++impl<E, T> Transformed<T> for Processor<E, T>+where+ T: Mul<T, Output = T> + Copy,+ E: Clone,+{+ #[inline(always)]+ fn transform_by(&mut self, trans: T) { self.transform = trans * self.transform; }+ #[inline(always)]+ fn transformed(&self, trans: T) -> Self {+ Self {+ entity: self.entity.clone(),+ transform: trans * self.transform,+ orientation: self.orientation,+ }+ }+}++impl<E, T, C> IncludeCurve<C> for Processor<E, T>+where+ C: ParametricCurve + Transformed<T> + Clone,+ C::Point: EuclideanSpace,+ E: IncludeCurve<C>,+ T: Transform<C::Point>,+{+ fn include(&self, curve: &C) -> bool {+ let inv = self+ .transform+ .inverse_transform()+ .expect("irregular transform");+ let curve = curve.clone().transformed(inv);+ self.entity.include(&curve)+ }+}++impl<C> ParameterDivision1D for Processor<C, Matrix3>+where C: ParameterDivision1D<Point = Point2> + BoundedCurve<Point = Point2>+{+ type Point = Point2;+ fn parameter_division(&self, range: (f64, f64), tol: f64) -> (Vec<f64>, Vec<Self::Point>) {+ let a = self.transform;+ let range = match self.orientation {+ true => range,+ false => (+ self.get_curve_parameter(range.1),+ self.get_curve_parameter(range.0),+ ),+ };+ let (_, k, _) = a+ .iwasawa_decomposition()+ .expect("transform matrix must be invertible!");+ let n = f64::abs(k[0][0])+ .max(f64::abs(k[1][1]))+ .max(f64::abs(k[2][2]));+ let (mut params, mut points) = self.entity.parameter_division(range, tol / n);+ points+ .iter_mut()+ .for_each(|pt| *pt = a.transform_point(*pt));+ if !self.orientation {+ params+ .iter_mut()+ .for_each(|t| *t = self.get_curve_parameter(*t));+ points.reverse();+ }+ (params, points)+ }+}++impl<C> ParameterDivision1D for Processor<C, Matrix4>+where C: ParameterDivision1D<Point = Point3> + BoundedCurve<Point = Point3>+{+ type Point = Point3;+ fn parameter_division(&self, range: (f64, f64), tol: f64) -> (Vec<f64>, Vec<Self::Point>) {+ let a = self.transform;+ let range = match self.orientation {+ true => range,+ false => (+ self.get_curve_parameter(range.1),+ self.get_curve_parameter(range.0),+ ),+ };+ let (_, k, _) = a+ .iwasawa_decomposition()+ .expect("transform matrix must be invertible!");+ let n = f64::abs(k[0][0])+ .max(f64::abs(k[1][1]))+ .max(f64::abs(k[2][2]))+ / f64::abs(k[3][3]);+ let (mut params, mut points) = self.entity.parameter_division(range, tol / n);+ points+ .iter_mut()+ .for_each(|pt| *pt = a.transform_point(*pt));+ if !self.orientation {+ params+ .iter_mut()+ .for_each(|t| *t = self.get_curve_parameter(*t));+ points.reverse();+ }+ (params, points)+ }+}++impl<S: ParameterDivision2D> ParameterDivision2D for Processor<S, Matrix3> {+ fn parameter_division(+ &self,+ range: ((f64, f64), (f64, f64)),+ tol: f64,+ ) -> (Vec<f64>, Vec<f64>) {+ let a = self.transform;+ let range = match self.orientation {+ true => range,+ false => (range.1, range.0),+ };+ let (_, k, _) = a+ .iwasawa_decomposition()+ .expect("transform matrix must be invertible!");+ let n = f64::abs(k[0][0])+ .max(f64::abs(k[1][1]))+ .max(f64::abs(k[2][2]));+ let (udiv, vdiv) = self.entity.parameter_division(range, tol / n);+ match self.orientation {+ true => (udiv, vdiv),+ false => (vdiv, udiv),+ }+ }+}++impl<S: ParameterDivision2D> ParameterDivision2D for Processor<S, Matrix4> {+ fn parameter_division(+ &self,+ range: ((f64, f64), (f64, f64)),+ tol: f64,+ ) -> (Vec<f64>, Vec<f64>) {+ let a = self.transform;+ let range = match self.orientation {+ true => range,+ false => (range.1, range.0),+ };+ let (_, k, _) = a+ .iwasawa_decomposition()+ .expect("transform matrix must be invertible!");+ let n = f64::abs(k[0][0])+ .max(f64::abs(k[1][1]))+ .max(f64::abs(k[2][2]))+ / f64::abs(k[3][3]);+ let (udiv, vdiv) = self.entity.parameter_division(range, tol / n);+ match self.orientation {+ true => (udiv, vdiv),+ false => (vdiv, udiv),+ }+ }+}++impl<E, T> SearchParameter<D1> for Processor<E, T>+where+ E: SearchParameter<D1> + BoundedCurve,+ <E as SearchParameter<D1>>::Point: EuclideanSpace,+ T: Transform<<E as SearchParameter<D1>>::Point>,+{+ type Point = <E as SearchParameter<D1>>::Point;+ fn search_parameter<H: Into<SPHint1D>>(+ &self,+ point: <E as SearchParameter<D1>>::Point,+ hint: H,+ trials: usize,+ ) -> Option<f64> {+ let inv = self.transform.inverse_transform().unwrap();+ let t = self+ .entity+ .search_parameter(inv.transform_point(point), hint, trials)?;+ Some(self.get_curve_parameter(t))+ }+}++impl<E, T> SearchParameter<D2> for Processor<E, T>+where+ E: SearchParameter<D2>,+ E::Point: EuclideanSpace,+ T: Transform<E::Point>,+{+ type Point = E::Point;+ fn search_parameter<H: Into<SPHint2D>>(+ &self,+ point: E::Point,+ hint: H,+ trials: usize,+ ) -> Option<(f64, f64)> {+ let inv = self.transform.inverse_transform().unwrap();+ let (u, v) = self+ .entity+ .search_parameter(inv.transform_point(point), hint, trials)?;+ match self.orientation {+ true => Some((u, v)),+ false => Some((v, u)),+ }+ }+}++impl<P, E, T> SearchNearestParameter<D1> for Processor<E, T>+where+ E: BoundedCurve<Point = P> + SearchNearestParameter<D1, Point = P>,+ P: EuclideanSpace<Scalar = f64, Diff = E::Vector>,+ E::Vector: InnerSpace<Scalar = f64> + Tolerance,+ T: Transform<P> + Clone,+{+ type Point = P;+ fn search_nearest_parameter<H: Into<SPHint1D>>(+ &self,+ point: Self::Point,+ hint: H,+ trials: usize,+ ) -> Option<f64> {+ let inv = self.transform.inverse_transform().unwrap();+ let hint =+ self.entity+ .search_nearest_parameter(inv.transform_point(point), hint, trials)?;+ let hint = self.get_curve_parameter(hint);+ algo::curve::search_nearest_parameter(self, point, hint, trials)+ }+}++impl<P, E, T> SearchNearestParameter<D2> for Processor<E, T>+where+ E: ParametricSurface<Point = P> + SearchNearestParameter<D2, Point = P>,+ P: EuclideanSpace<Scalar = f64, Diff = E::Vector>,+ E::Vector: InnerSpace<Scalar = f64> + Tolerance,+ T: Transform<P> + SquareMatrix<Scalar = f64> + Clone,+{+ type Point = P;+ fn search_nearest_parameter<H: Into<SPHint2D>>(+ &self,+ point: Self::Point,+ hint: H,+ trials: usize,+ ) -> Option<(f64, f64)> {+ let inv = self.transform.inverse_transform().unwrap();+ let hint =+ self.entity+ .search_nearest_parameter(inv.transform_point(point), hint, trials)?;+ let hint = match self.orientation {+ true => hint,+ false => (hint.1, hint.0),+ };+ algo::surface::search_nearest_parameter(self, point, hint, trials)+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ fn exec_compatible_with_bspcurve() {+ const DEGREE: usize = 3;+ const DIVISION: usize = 4;+ let knot_vec = KnotVec::uniform_knot(DEGREE, DIVISION);+ let control_points: Vec<Point3> = (0..DEGREE + DIVISION)+ .map(|i| Point3::new(i as f64, 20.0 * rand::random::<f64>() - 10.0, 0.0))+ .collect();+ let mut curve = BSplineCurve::new(knot_vec, control_points);+ let mut processor = Processor::new(curve.clone());+ let mat = Matrix3::new(+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ );+ if mat.determinant().so_small() {+ println!("omitted: {mat:?}");+ return;+ }+ curve.transform_by(mat);+ processor.transform_by(mat);+ assert_eq!(curve.parameter_range(), processor.parameter_range());++ const N: usize = 100;+ for i in 0..=N {+ let t = i as f64 / N as f64;+ assert_near!(ParametricCurve::subs(&curve, t), processor.subs(t));+ assert_near!(ParametricCurve::der(&curve, t), processor.der(t));+ assert_near!(ParametricCurve::der2(&curve, t), processor.der2(t));+ }++ curve.invert();+ processor.invert();+ assert_eq!(curve.parameter_range(), processor.parameter_range());+ for i in 0..=N {+ let t = i as f64 / N as f64;+ assert_near!(ParametricCurve::subs(&curve, t), processor.subs(t));+ assert_near!(ParametricCurve::der(&curve, t), processor.der(t));+ assert_near!(ParametricCurve::der2(&curve, t), processor.der2(t));+ }+ }++ #[test]+ fn compatible_with_bspcurve() { (0..10).for_each(|_| exec_compatible_with_bspcurve()) }++ fn exec_compatible_with_bspsurface() {+ const DEGREE: usize = 3;+ const DIVISION: usize = 4;+ let knot_vec = KnotVec::uniform_knot(DEGREE, DIVISION);+ let knot_vecs = (knot_vec.clone(), knot_vec);+ let control_points: Vec<Vec<Point3>> = (0..DEGREE + DIVISION)+ .map(|i| {+ (0..DEGREE + DIVISION)+ .map(|j| Point3::new(i as f64, j as f64, 20.0 * rand::random::<f64>() - 10.0))+ .collect()+ })+ .collect();+ let mut surface = BSplineSurface::new(knot_vecs, control_points);+ let mut processor = Processor::new(surface.clone());+ let mat = Matrix3::new(+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ 4.0 * rand::random::<f64>() - 2.0,+ );+ if mat.determinant().so_small() {+ println!("omitted: {mat:?}");+ return;+ }+ surface.transform_by(mat);+ processor.transform_by(mat);+ assert_eq!(surface.range_tuple(), processor.range_tuple());++ const N: usize = 30;+ for i in 0..=N {+ for j in 0..=N {+ let u = i as f64 / N as f64;+ let v = j as f64 / N as f64;+ let pt0 = ParametricSurface::subs(&surface, u, v);+ let pt1 = processor.subs(u, v);+ assert_near!(pt0, pt1);+ let uder0 = surface.uder(u, v);+ let uder1 = processor.uder(u, v);+ assert_near!(uder0, uder1);+ let vder0 = surface.vder(u, v);+ let vder1 = processor.vder(u, v);+ assert_near!(vder0, vder1);+ let uuder0 = surface.uuder(u, v);+ let uuder1 = processor.uuder(u, v);+ assert_near!(uuder0, uuder1);+ let uvder0 = surface.uvder(u, v);+ let uvder1 = processor.uvder(u, v);+ assert_near!(uvder0, uvder1);+ let vvder0 = surface.vvder(u, v);+ let vvder1 = processor.vvder(u, v);+ assert_near!(vvder0, vvder1);+ let n0 = surface.normal(u, v);+ let n1 = processor.normal(u, v);+ assert_near!(n0, n1);+ }+ }++ surface.swap_axes();+ processor.invert();+ assert_eq!(surface.range_tuple(), processor.range_tuple());+ for i in 0..=N {+ for j in 0..=N {+ let u = i as f64 / N as f64;+ let v = j as f64 / N as f64;+ let pt0 = ParametricSurface::subs(&surface, u, v);+ let pt1 = processor.subs(u, v);+ assert_near!(pt0, pt1);+ let uder0 = surface.uder(u, v);+ let uder1 = processor.uder(u, v);+ assert_near!(uder0, uder1);+ let vder0 = surface.vder(u, v);+ let vder1 = processor.vder(u, v);+ assert_near!(vder0, vder1);+ let uuder0 = surface.uuder(u, v);+ let uuder1 = processor.uuder(u, v);+ assert_near!(uuder0, uuder1);+ let uvder0 = surface.uvder(u, v);+ let uvder1 = processor.uvder(u, v);+ assert_near!(uvder0, uvder1);+ let vvder0 = surface.vvder(u, v);+ let vvder1 = processor.vvder(u, v);+ assert_near!(vvder0, vvder1);+ let n0 = surface.normal(u, v);+ let n1 = processor.normal(u, v);+ assert_near!(n0, n1);+ }+ }+ }++ #[test]+ fn compatible_with_bspsurface() { (0..3).for_each(|_| exec_compatible_with_bspsurface()) }+}diff --git a/vendor/truck-geometry/src/decorators/revolved_curve.rs b/vendor/truck-geometry/src/decorators/revolved_curve.rsnew file mode 100644index 0000000000..ee4bd7c641--- /dev/null+++ b/vendor/truck-geometry/src/decorators/revolved_curve.rs@@ -0,0 +1,689 @@+use super::*;+use std::f64::consts::PI;++impl Revolution {+ fn new(origin: Point3, axis: Vector3) -> Self {+ Self {+ origin,+ axis: axis.normalize(),+ }+ }+ #[inline(always)]+ fn point_rotation_matrix(self, v: f64) -> Matrix4 {+ Matrix4::from_translation(self.origin.to_vec())+ * Matrix4::from_axis_angle(self.axis, Rad(v))+ * Matrix4::from_translation(-self.origin.to_vec())+ }+ #[inline(always)]+ fn vector_rotation_matrix(self, v: f64) -> Matrix4 {+ Matrix4::from_axis_angle(self.axis, Rad(v))+ }+ #[inline(always)]+ fn derivation_rotation_matrix(self, v: f64) -> Matrix4 {+ let n = self.axis;+ Matrix3::new(+ n[0] * n[0] * f64::sin(v) - f64::sin(v),+ n[0] * n[1] * f64::sin(v) + n[2] * f64::cos(v),+ n[0] * n[2] * f64::sin(v) - n[1] * f64::cos(v),+ n[0] * n[1] * f64::sin(v) - n[2] * f64::cos(v),+ n[1] * n[1] * f64::sin(v) - f64::sin(v),+ n[1] * n[2] * f64::sin(v) + n[0] * f64::cos(v),+ n[0] * n[2] * f64::sin(v) + n[1] * f64::cos(v),+ n[1] * n[2] * f64::sin(v) - n[0] * f64::cos(v),+ n[2] * n[2] * f64::sin(v) - f64::sin(v),+ )+ .into()+ }+ #[inline(always)]+ fn invert(&mut self) { self.axis *= -1.0; }+ #[inline(always)]+ fn inverse(mut self) -> Self {+ self.axis *= -1.0;+ self+ }+ #[inline(always)]+ fn contains(self, p: Point3) -> bool { (p - self.origin).cross(self.axis).so_small() }+ #[inline(always)]+ fn proj_point(&self, p: Point3) -> Point2 {+ let r = p - self.origin;+ let z = r.dot(self.axis);+ let h = r - z * self.axis;+ Point2::new(z, h.magnitude())+ }+ #[inline(always)]+ fn proj_vector(&self, p: Point3, v: Vector3) -> Vector2 {+ let r = self.proj_point(p).y;+ let vz = v.dot(self.axis);+ let vxy = v - vz * self.axis;+ let vq = (p - self.origin).dot(vxy) / r;+ Vector2::new(vz, vq)+ }+ #[inline(always)]+ fn proj_vector2(&self, p: Point3, v: Vector3, v2: Vector3) -> Vector2 {+ let r = self.proj_point(p).y;+ let v2z = v2.dot(self.axis);+ let v2xy = v2 - v2z * self.axis;+ let vz = v.dot(self.axis);+ let vxy = v - vz * self.axis;+ let a = (vxy.dot(vxy) + (p - self.origin).dot(v2xy)) / r;+ let b = f64::powi((p - self.origin).dot(vxy), 2) / (r * r * r);+ Vector2::new(v2z, a - b)+ }+ #[inline(always)]+ fn proj_angle(&self, p: Point3, q: Point3) -> f64 {+ let (p, q) = (p - self.origin, q - self.origin);+ let hp = (p - p.dot(self.axis) * self.axis).normalize();+ let hq = (q - q.dot(self.axis) * self.axis).normalize();+ let t = f64::acos(f64::clamp(hp.dot(hq), -1.0, 1.0));+ match hp.cross(hq).dot(self.axis) < 0.0 {+ false => t,+ true => 2.0 * PI - t,+ }+ }+}++impl<C: ParametricCurve3D> ParametricSurface for RevolutedCurve<C> {+ type Point = Point3;+ type Vector = Vector3;+ #[inline(always)]+ fn subs(&self, u: f64, v: f64) -> Point3 {+ let mat = self.revolution.point_rotation_matrix(v);+ mat.transform_point(self.curve.subs(u))+ }+ #[inline(always)]+ fn uder(&self, u: f64, v: f64) -> Vector3 {+ let mat = self.revolution.vector_rotation_matrix(v);+ mat.transform_vector(self.curve.der(u))+ }+ #[inline(always)]+ fn vder(&self, u: f64, v: f64) -> Vector3 {+ let pt = self.curve.subs(u);+ let radius = self.axis().cross(pt - self.origin());+ let mat = self.revolution.vector_rotation_matrix(v);+ mat.transform_vector(radius)+ }+ #[inline(always)]+ fn uuder(&self, u: f64, v: f64) -> Vector3 {+ let mat = self.revolution.vector_rotation_matrix(v);+ mat.transform_vector(self.curve.der2(u))+ }+ #[inline(always)]+ fn vvder(&self, u: f64, v: f64) -> Vector3 {+ let pt = self.curve.subs(u);+ let z = self.revolution.proj_point(pt).x;+ let radius = pt - self.origin() - z * self.axis();+ let mat = self.revolution.vector_rotation_matrix(v);+ -mat.transform_vector(radius)+ }+ #[inline(always)]+ fn uvder(&self, u: f64, v: f64) -> Vector3 {+ let mat = self.revolution.derivation_rotation_matrix(v);+ mat.transform_vector(self.curve.der(u))+ }+ #[inline(always)]+ fn parameter_range(&self) -> (ParameterRange, ParameterRange) {+ (+ self.curve.parameter_range(),+ (Bound::Included(0.0), Bound::Excluded(2.0 * PI)),+ )+ }+ #[inline(always)]+ fn u_period(&self) -> Option<f64> { self.curve.period() }+ #[inline(always)]+ fn v_period(&self) -> Option<f64> { Some(2.0 * PI) }+}++impl<C: ParametricCurve3D + BoundedCurve> ParametricSurface3D for RevolutedCurve<C> {+ #[inline(always)]+ fn normal(&self, u: f64, v: f64) -> Vector3 {+ let (u0, u1) = self.curve.range_tuple();+ let (uder, vder) = if u.near(&u0) {+ let pt = self.curve.subs(u);+ let radius = self.axis().cross(pt - self.origin());+ if radius.so_small() {+ let uder = self.curve.der(u);+ (uder, self.axis().cross(uder))+ } else {+ (self.uder(u, v), self.vder(u, v))+ }+ } else if u.near(&u1) {+ let pt = self.curve.subs(u);+ let radius = self.axis().cross(pt - self.origin());+ if radius.so_small() {+ let uder = self.curve.der(u);+ (uder, uder.cross(self.axis()))+ } else {+ (self.uder(u, v), self.vder(u, v))+ }+ } else {+ (self.uder(u, v), self.vder(u, v))+ };+ uder.cross(vder).normalize()+ }+}++impl<C: ParametricCurve3D + BoundedCurve> BoundedSurface for RevolutedCurve<C> {}++impl<C: Clone> Invertible for RevolutedCurve<C> {+ #[inline(always)]+ fn invert(&mut self) { self.revolution.invert() }+ #[inline(always)]+ fn inverse(&self) -> Self {+ RevolutedCurve {+ curve: self.curve.clone(),+ revolution: self.revolution.inverse(),+ }+ }+}++#[derive(Clone, Debug)]+struct ProjectedCurve<C> {+ curve: C,+ revolution: Revolution,+}++impl<C: ParametricCurve3D> ParametricCurve for ProjectedCurve<C> {+ type Point = Point2;+ type Vector = Vector2;+ #[inline(always)]+ fn subs(&self, t: f64) -> Self::Point { self.revolution.proj_point(self.curve.subs(t)) }+ #[inline(always)]+ fn der(&self, t: f64) -> Self::Vector {+ self.revolution+ .proj_vector(self.curve.subs(t), self.curve.der(t))+ }+ #[inline(always)]+ fn der2(&self, t: f64) -> Self::Vector {+ self.revolution+ .proj_vector2(self.curve.subs(t), self.curve.der(t), self.curve.der2(t))+ }+ #[inline(always)]+ fn parameter_range(&self) -> ParameterRange { self.curve.parameter_range() }+ #[inline(always)]+ fn period(&self) -> Option<f64> { self.curve.period() }+}++impl<C: ParametricCurve3D + BoundedCurve> BoundedCurve for ProjectedCurve<C> {}++impl<C: ParametricCurve3D + BoundedCurve> SearchParameter<D1> for ProjectedCurve<C> {+ type Point = Point2;+ fn search_parameter<H: Into<SPHint1D>>(+ &self,+ point: Self::Point,+ hint: H,+ trials: usize,+ ) -> Option<f64> {+ let hint = match hint.into() {+ SPHint1D::Parameter(t) => t,+ SPHint1D::Range(x, y) => {+ algo::curve::presearch(self, point, (x, y), PRESEARCH_DIVISION)+ }+ SPHint1D::None => {+ algo::curve::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::curve::search_parameter(self, point, hint, trials)+ }+}++impl<C: ParametricCurve3D + BoundedCurve> SearchNearestParameter<D1> for ProjectedCurve<C> {+ type Point = Point2;+ fn search_nearest_parameter<H: Into<SPHint1D>>(+ &self,+ point: Self::Point,+ hint: H,+ trials: usize,+ ) -> Option<f64> {+ let hint = match hint.into() {+ SPHint1D::Parameter(t) => t,+ SPHint1D::Range(x, y) => {+ algo::curve::presearch(self, point, (x, y), PRESEARCH_DIVISION)+ }+ SPHint1D::None => {+ algo::curve::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::curve::search_nearest_parameter(self, point, hint, trials)+ }+}++impl<C> RevolutedCurve<C> {+ /// Creates a surface by revoluting a curve.+ #[inline(always)]+ pub fn by_revolution(curve: C, origin: Point3, axis: Vector3) -> Self {+ RevolutedCurve {+ curve,+ revolution: Revolution::new(origin, axis),+ }+ }+ /// Returns the curve before revoluted.+ #[inline(always)]+ pub const fn entity_curve(&self) -> &C { &self.curve }+ /// Into the curve before revoluted.+ #[inline(always)]+ pub fn into_entity_curve(self) -> C { self.curve }+ /// Returns origin of revolution+ #[inline(always)]+ pub const fn origin(&self) -> Point3 { self.revolution.origin }+ /// Returns axis of revolution+ #[inline(always)]+ pub const fn axis(&self) -> Vector3 { self.revolution.axis }+}++impl<C: ParametricCurve3D + BoundedCurve> RevolutedCurve<C> {+ /// Returns true if the front point of the curve is on the axis of rotation.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let line = BSplineCurve::new(+ /// KnotVec::bezier_knot(1),+ /// vec![Point3::new(0.0, 0.0, 0.0), Point3::new(0.0, 0.0, 1.0)],+ /// );+ /// let surface0 = RevolutedCurve::by_revolution(line.clone(), Point3::origin(), Vector3::unit_y());+ /// assert!(surface0.is_front_fixed());+ /// let surface1 = RevolutedCurve::by_revolution(line, Point3::new(1.0, 0.0, 0.0), Vector3::unit_y());+ /// assert!(!surface1.is_front_fixed());+ /// ```+ #[inline(always)]+ pub fn is_front_fixed(&self) -> bool { self.revolution.contains(self.curve.front()) }+ /// Returns true if the back point of the curve is on the axis of rotation.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let line = BSplineCurve::new(+ /// KnotVec::bezier_knot(1),+ /// vec![Point3::new(0.0, 0.0, 1.0), Point3::new(0.0, 0.0, 0.0)],+ /// );+ /// let surface0 = RevolutedCurve::by_revolution(line.clone(), Point3::origin(), Vector3::unit_y());+ /// assert!(surface0.is_back_fixed());+ /// let surface1 = RevolutedCurve::by_revolution(line, Point3::new(1.0, 0.0, 0.0), Vector3::unit_y());+ /// assert!(!surface1.is_back_fixed());+ /// ```+ #[inline(always)]+ pub fn is_back_fixed(&self) -> bool { self.revolution.contains(self.curve.back()) }+}++impl<C: ParametricCurve3D + BoundedCurve> SearchParameter<D2> for RevolutedCurve<C> {+ type Point = Point3;+ fn search_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point3,+ hint: H,+ trials: usize,+ ) -> Option<(f64, f64)> {+ let (t0, t1) = self.curve.range_tuple();+ if self.is_front_fixed() && self.curve.front().near(&point) {+ match hint.into() {+ SPHint2D::Parameter(_, y) => Some((t0, y)),+ SPHint2D::Range((_, y), _) => Some((t0, y)),+ SPHint2D::None => Some((t0, 0.0)),+ }+ } else if self.is_back_fixed() && self.curve.back().near(&point) {+ match hint.into() {+ SPHint2D::Parameter(_, y) => Some((t1, y)),+ SPHint2D::Range(_, (_, y)) => Some((t1, y)),+ SPHint2D::None => Some((t1, 2.0 * PI)),+ }+ } else {+ let proj_curve = ProjectedCurve {+ curve: &self.curve,+ revolution: self.revolution,+ };+ let p = self.revolution.proj_point(point);+ let hint0 = match hint.into() {+ SPHint2D::Parameter(x, _) => SPHint1D::Parameter(x),+ SPHint2D::Range((x0, _), (x1, _)) => SPHint1D::Range(x0, x1),+ SPHint2D::None => SPHint1D::None,+ };+ let t = proj_curve.search_parameter(p, hint0, trials)?;+ let p = self.curve.subs(t);+ let ang = self.revolution.proj_angle(p, point);+ match self.subs(t, ang).near(&point) {+ true => Some((t, ang)),+ false => None,+ }+ }+ }+}++impl<C: ParametricCurve3D + BoundedCurve> SearchNearestParameter<D2> for RevolutedCurve<C> {+ type Point = Point3;+ fn search_nearest_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point3,+ hint: H,+ trials: usize,+ ) -> Option<(f64, f64)> {+ let (t0, t1) = self.curve.range_tuple();+ let on_axis = move |o: Point3, normal: Vector3| {+ let op = point - o;+ op.cross(self.revolution.axis).so_small() && op.dot(normal) >= 0.0+ };+ if self.is_front_fixed() && on_axis(self.curve.front(), self.normal(t0, 0.0)) {+ match hint.into() {+ SPHint2D::Parameter(_, y) => Some((t0, y)),+ SPHint2D::Range((_, y), _) => Some((t0, y)),+ SPHint2D::None => Some((t0, 0.0)),+ }+ } else if self.is_back_fixed() && on_axis(self.curve.back(), self.normal(t1, 0.0)) {+ match hint.into() {+ SPHint2D::Parameter(_, y) => Some((t1, y)),+ SPHint2D::Range(_, (_, y)) => Some((t1, y)),+ SPHint2D::None => Some((t1, 2.0 * PI)),+ }+ } else {+ let proj_curve = ProjectedCurve {+ curve: &self.curve,+ revolution: self.revolution,+ };+ let p = self.revolution.proj_point(point);+ let hint0 = match hint.into() {+ SPHint2D::Parameter(x, _) => SPHint1D::Parameter(x),+ SPHint2D::Range((x0, _), (x1, _)) => SPHint1D::Range(x0, x1),+ SPHint2D::None => SPHint1D::None,+ };+ let t = proj_curve.search_nearest_parameter(p, hint0, trials)?;+ let p = self.curve.subs(t);+ Some((t, self.revolution.proj_angle(p, point)))+ }+ }+}++fn sub_include<C0, C1>(+ surface: &RevolutedCurve<C0>,+ curve: &C1,+ knots: &[f64],+ degree: usize,+) -> bool+where+ C0: ParametricCurve3D + BoundedCurve,+ C1: ParametricCurve3D + BoundedCurve,+{+ let first = curve.subs(knots[0]);+ let mut hint = match surface.search_parameter(first, None, INCLUDE_CURVE_TRIALS) {+ Some(hint) => hint,+ None => return false,+ };+ knots+ .windows(2)+ .flat_map(move |knot| {+ (1..=degree).map(move |i| {+ let s = i as f64 / degree as f64;+ knot[0] * (1.0 - s) + knot[1] * s+ })+ })+ .all(move |t| {+ let pt = ParametricCurve::subs(curve, t);+ surface+ .search_parameter(pt, Some(hint), INCLUDE_CURVE_TRIALS)+ .or_else(|| surface.search_parameter(pt, None, INCLUDE_CURVE_TRIALS))+ .map(|res| hint = res)+ .is_some()+ })+}++impl<'a> IncludeCurve<BSplineCurve<Point3>> for RevolutedCurve<&'a BSplineCurve<Point3>> {+ fn include(&self, curve: &BSplineCurve<Point3>) -> bool {+ let knots = curve.knot_vec().to_single_multi().0;+ let degree = usize::max(2, usize::max(curve.degree(), self.curve.degree()));+ sub_include(self, curve, &knots, degree)+ }+}++impl IncludeCurve<BSplineCurve<Point3>> for RevolutedCurve<BSplineCurve<Point3>> {+ fn include(&self, curve: &BSplineCurve<Point3>) -> bool {+ let knots = curve.knot_vec().to_single_multi().0;+ let degree = usize::max(2, usize::max(curve.degree(), self.curve.degree()));+ sub_include(self, curve, &knots, degree)+ }+}++impl<'a> IncludeCurve<BSplineCurve<Point3>> for RevolutedCurve<&'a NurbsCurve<Vector4>> {+ fn include(&self, curve: &BSplineCurve<Point3>) -> bool {+ let knots = curve.knot_vec().to_single_multi().0;+ let degree = curve.degree() + usize::max(2, self.curve.degree());+ sub_include(self, curve, &knots, degree)+ }+}++impl IncludeCurve<BSplineCurve<Point3>> for RevolutedCurve<NurbsCurve<Vector4>> {+ fn include(&self, curve: &BSplineCurve<Point3>) -> bool {+ let knots = curve.knot_vec().to_single_multi().0;+ let degree = curve.degree() + usize::max(2, self.curve.degree());+ sub_include(self, curve, &knots, degree)+ }+}++impl<'a> IncludeCurve<NurbsCurve<Vector4>> for RevolutedCurve<&'a BSplineCurve<Point3>> {+ fn include(&self, curve: &NurbsCurve<Vector4>) -> bool {+ let knots = curve.knot_vec().to_single_multi().0;+ let degree = curve.degree() + usize::max(2, self.curve.degree());+ sub_include(self, curve, &knots, degree)+ }+}++impl IncludeCurve<NurbsCurve<Vector4>> for RevolutedCurve<BSplineCurve<Point3>> {+ fn include(&self, curve: &NurbsCurve<Vector4>) -> bool {+ let knots = curve.knot_vec().to_single_multi().0;+ let degree = curve.degree() + usize::max(2, self.curve.degree());+ sub_include(self, curve, &knots, degree)+ }+}++impl<'a> IncludeCurve<NurbsCurve<Vector4>> for RevolutedCurve<&'a NurbsCurve<Vector4>> {+ fn include(&self, curve: &NurbsCurve<Vector4>) -> bool {+ let knots = curve.knot_vec().to_single_multi().0;+ let degree = curve.degree() + usize::max(2, self.curve.degree());+ sub_include(self, curve, &knots, degree)+ }+}++impl IncludeCurve<NurbsCurve<Vector4>> for RevolutedCurve<NurbsCurve<Vector4>> {+ fn include(&self, curve: &NurbsCurve<Vector4>) -> bool {+ let knots = curve.knot_vec().to_single_multi().0;+ let degree = curve.degree() + usize::max(2, self.curve.degree());+ sub_include(self, curve, &knots, degree)+ }+}++impl<C> ParameterDivision2D for RevolutedCurve<C>+where C: ParametricCurve3D + ParameterDivision1D<Point = Point3>+{+ fn parameter_division(+ &self,+ (urange, vrange): ((f64, f64), (f64, f64)),+ tol: f64,+ ) -> (Vec<f64>, Vec<f64>) {+ let curve_division = self.curve.parameter_division(urange, tol);+ let max = curve_division+ .1+ .into_iter()+ .fold(0.0, |max2, pt| {+ let h = self.revolution.proj_point(pt).y;+ f64::max(max2, h)+ })+ .sqrt();+ let acos = f64::acos(1.0 - tol / max);+ let div: usize = 1 + ((vrange.1 - vrange.0) / acos).floor() as usize;+ let circle_division = (0..=div)+ .map(|j| vrange.0 + (vrange.1 - vrange.0) * j as f64 / div as f64)+ .collect();+ (curve_division.0, circle_division)+ }+}++#[test]+fn revolve_test() {+ let pt0 = Point3::new(0.0, 2.0, 1.0);+ let pt1 = Point3::new(1.0, 0.0, 0.0);+ let curve = BSplineCurve::new(KnotVec::bezier_knot(1), vec![pt0, pt1]);+ let surface = RevolutedCurve::by_revolution(curve, Point3::origin(), Vector3::unit_y());+ const N: usize = 100;+ for i in 0..=N {+ for j in 0..=N {+ let u = i as f64 / N as f64;+ let v = 2.0 * PI * j as f64 / N as f64;+ let res = surface.subs(u, v);+ let ans = Point3::new(+ u * f64::cos(v) + (1.0 - u) * f64::sin(v),+ 2.0 * (1.0 - u),+ -u * f64::sin(v) + (1.0 - u) * f64::cos(v),+ );+ assert_near!(res, ans);+ let res_uder = surface.uder(u, v);+ let ans_uder =+ Vector3::new(f64::cos(v) - f64::sin(v), -2.0, -f64::sin(v) - f64::cos(v));+ assert_near!(res_uder, ans_uder);+ let res_vder = surface.vder(u, v);+ let ans_vder = Vector3::new(+ -u * f64::sin(v) + (1.0 - u) * f64::cos(v),+ 0.0,+ -u * f64::cos(v) - (1.0 - u) * f64::sin(v),+ );+ assert_near!(res_vder, ans_vder);+ let res_uuder = surface.uuder(u, v);+ let ans_uuder = Vector3::zero();+ assert_near!(res_uuder, ans_uuder);+ let res_uvder = surface.uvder(u, v);+ let ans_uvder =+ Vector3::new(-f64::sin(v) - f64::cos(v), 0.0, -f64::cos(v) + f64::sin(v));+ assert_near!(res_uvder, ans_uvder);+ let res_vvder = surface.vvder(u, v);+ let ans_vvder = Vector3::new(+ -u * f64::cos(v) - (1.0 - u) * f64::sin(v),+ 0.0,+ u * f64::sin(v) - (1.0 - u) * f64::cos(v),+ );+ assert_near!(res_vvder, ans_vvder);+ let normal = surface.normal(u, v);+ assert!(normal.dot(res_uder).so_small());+ assert!(normal.dot(res_vder).so_small());+ }+ }+}++#[test]+fn search_parameter() {+ let line = BSplineCurve::new(+ KnotVec::bezier_knot(1),+ vec![Point3::new(0.0, 2.0, 1.0), Point3::new(1.0, 0.0, 0.0)],+ );+ let surface = RevolutedCurve::by_revolution(line, Point3::origin(), Vector3::unit_y());+ let pt = Point3::new(-0.5, 1.0, 0.5);+ let (u, v) = surface.search_parameter(pt, Some((0.4, 1.2)), 100).unwrap();+ assert_near!(surface.subs(u, v), pt);+}++#[test]+fn search_parameter_with_fixed_points() {+ let line = BSplineCurve::new(+ KnotVec::bezier_knot(2),+ vec![+ Point3::new(0.0, 1.0, 0.0),+ Point3::new(0.0, 0.0, 1.0),+ Point3::new(0.0, -1.0, 0.0),+ ],+ );+ let surface = RevolutedCurve::by_revolution(line, Point3::origin(), Vector3::unit_y());++ let (u, v) = surface+ .search_parameter(Point3::new(0.0, 1.0, 0.0), Some((0.5, 0.3)), 10)+ .unwrap();+ assert_near!(Vector2::new(u, v), Vector2::new(0.0, 0.3));++ let (u, v) = surface+ .search_parameter(Point3::new(0.0, -1.0, 0.0), Some((0.5, 0.3)), 10)+ .unwrap();+ assert_near!(Vector2::new(u, v), Vector2::new(1.0, 0.3));+}++#[test]+fn search_nearest_parameter() {+ let line = BSplineCurve::new(+ KnotVec::bezier_knot(1),+ vec![Point3::new(0.0, 2.0, 1.0), Point3::new(1.0, 0.0, 0.0)],+ );+ let surface = RevolutedCurve::by_revolution(line, Point3::origin(), Vector3::unit_y());+ let pt = surface.subs(0.4, 1.2) + 0.1 * surface.normal(0.4, 1.2);+ let (u, v) = surface+ .search_nearest_parameter(pt, Some((0.4, 1.2)), 100)+ .unwrap();+ assert_near!(Vector2::new(u, v), Vector2::new(0.4, 1.2));+}++#[test]+fn search_nearest_parameter_with_fixed_points() {+ let line = BSplineCurve::new(+ KnotVec::bezier_knot(2),+ vec![+ Point3::new(0.0, 1.0, 0.0),+ Point3::new(0.0, 0.0, 1.0),+ Point3::new(0.0, -1.0, 0.0),+ ],+ );+ let surface = RevolutedCurve::by_revolution(line, Point3::origin(), Vector3::unit_y());++ let (u, v) = surface+ .search_nearest_parameter(Point3::new(0.0, 2.0, 0.0), Some((0.5, 0.3)), 10)+ .unwrap();+ assert_near!(Vector2::new(u, v), Vector2::new(0.0, 0.3));++ let (u, v) = surface+ .search_nearest_parameter(Point3::new(0.0, -2.0, 0.0), Some((0.5, 0.3)), 10)+ .unwrap();+ assert_near!(Vector2::new(u, v), Vector2::new(1.0, 0.3));+}++#[test]+fn include_curve_normal() {+ let line = BSplineCurve::new(+ KnotVec::bezier_knot(1),+ vec![Point3::new(0.0, 0.0, 0.0), Point3::new(0.0, 2.0, 2.0)],+ );+ let surface = RevolutedCurve::by_revolution(line, Point3::origin(), Vector3::unit_y());+ let parabola = BSplineCurve::new(+ KnotVec::bezier_knot(2),+ vec![+ Point3::new(1.0, 1.0, 0.0),+ Point3::new(0.0, 0.0, 1.0),+ Point3::new(-1.0, 1.0, 0.0),+ ],+ );+ assert!(surface.include(¶bola));+}++#[test]+fn include_curve_abnormal0() {+ let line = BSplineCurve::new(+ KnotVec::bezier_knot(1),+ vec![Point3::new(0.0, 0.0, 0.0), Point3::new(0.0, 2.0, 2.0)],+ );+ let surface = RevolutedCurve::by_revolution(line, Point3::origin(), Vector3::unit_y());+ let parabola = BSplineCurve::new(+ KnotVec::bezier_knot(2),+ vec![+ Point3::new(1.0, 1.0, 0.0),+ Point3::new(0.0, 0.0, 2.0),+ Point3::new(-1.0, 1.0, 0.0),+ ],+ );+ assert!(!surface.include(¶bola));+}++#[test]+fn include_curve_abnormal1() {+ let curve = NurbsCurve::new(BSplineCurve::new(+ KnotVec::bezier_knot(3),+ vec![+ Vector4::new(0.0, 3.0, 0.0, 1.0),+ Vector4::new(0.0, 3.0, 3.0, 0.5),+ Vector4::new(0.0, 0.0, 0.0, 1.0),+ Vector4::new(0.0, 0.0, 3.0, 1.0),+ ],+ ));+ let pt0 = curve.subs(0.2);+ let pt1 = curve.subs(0.6);+ let surface = RevolutedCurve::by_revolution(curve, Point3::origin(), Vector3::unit_y());+ let line = BSplineCurve::new(KnotVec::bezier_knot(1), vec![pt0, pt1]);+ assert!(!surface.include(&line));+}diff --git a/vendor/truck-geometry/src/decorators/trimmied_curve.rs b/vendor/truck-geometry/src/decorators/trimmied_curve.rsnew file mode 100644index 0000000000..708d67a6ab--- /dev/null+++ b/vendor/truck-geometry/src/decorators/trimmied_curve.rs@@ -0,0 +1,73 @@+use super::*;++impl<C> TrimmedCurve<C> {+ /// constructor+ #[inline(always)]+ pub const fn new(curve: C, range: (f64, f64)) -> Self { Self { curve, range } }+ /// Returns the reference of non-trimmed curve+ #[inline(always)]+ pub const fn curve(&self) -> &C { &self.curve }+ /// Returns the mutable reference of non-trimmed curve+ #[inline(always)]+ pub fn curve_mut(&mut self) -> &mut C { &mut self.curve }+}++impl<C: ParametricCurve> ParametricCurve for TrimmedCurve<C> {+ type Point = C::Point;+ type Vector = C::Vector;+ #[inline(always)]+ fn subs(&self, t: f64) -> Self::Point { self.curve.subs(t) }+ #[inline(always)]+ fn der(&self, t: f64) -> Self::Vector { self.curve.der(t) }+ #[inline(always)]+ fn der2(&self, t: f64) -> Self::Vector { self.curve.der2(t) }+ #[inline(always)]+ fn period(&self) -> Option<f64> { self.curve.period() }+ #[inline(always)]+ fn parameter_range(&self) -> ParameterRange {+ (Bound::Included(self.range.0), Bound::Included(self.range.1))+ }+}++impl<C: ParametricCurve> BoundedCurve for TrimmedCurve<C> {}++impl<C: ParametricCurve> Cut for TrimmedCurve<C> {+ fn cut(&mut self, t: f64) -> Self {+ let (t0, t1) = self.range;+ self.range = (t0, t);+ Self::new(self.curve.clone(), (t, t1))+ }+}++impl<C: SearchNearestParameter<D1>> SearchNearestParameter<D1> for TrimmedCurve<C> {+ type Point = C::Point;+ #[inline(always)]+ fn search_nearest_parameter<H: Into<SPHint1D>>(+ &self,+ pt: C::Point,+ hint: H,+ trials: usize,+ ) -> Option<f64> {+ self.curve.search_nearest_parameter(pt, hint, trials)+ }+}++impl<C: SearchParameter<D1>> SearchParameter<D1> for TrimmedCurve<C> {+ type Point = C::Point;+ #[inline(always)]+ fn search_parameter<H: Into<SPHint1D>>(+ &self,+ pt: C::Point,+ hint: H,+ trials: usize,+ ) -> Option<f64> {+ self.curve.search_parameter(pt, hint, trials)+ }+}++impl<C: ParameterDivision1D> ParameterDivision1D for TrimmedCurve<C> {+ type Point = C::Point;+ fn parameter_division(&self, range: (f64, f64), tol: f64) -> (Vec<f64>, Vec<Self::Point>) {+ self.curve.parameter_division(range, tol)+ }+}diff --git a/vendor/truck-geometry/src/errors.rs b/vendor/truck-geometry/src/errors.rsnew file mode 100644index 0000000000..5d1978e80c--- /dev/null+++ b/vendor/truck-geometry/src/errors.rs@@ -0,0 +1,190 @@+use thiserror::Error;++/// Error handler for [`Error`](./errors/enum.Error.html)+pub type Result<T> = std::result::Result<T, Error>;++/// Geometrical Errors+#[derive(Debug, PartialEq, Error)]+pub enum Error {+ /// The following operations are failed if the knot vector has zero range.+ /// * Creating `BSplineCurve` or `BSplineSurface`,+ /// * Calculating bspline basis functions, or+ /// * Normalizing the knot vector.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ /// let mut knot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 0.0]);+ /// assert_eq!(knot_vec.try_normalize(), Err(Error::ZeroRange));+ /// assert_eq!(knot_vec.try_bspline_basis_functions(1, 0.0), Err(Error::ZeroRange));+ ///+ /// let ctrl_pts = vec![Vector2::new(0.0, 0.0), Vector2::new(1.0, 1.0)];+ /// assert!(matches!(BSplineCurve::try_new(knot_vec, ctrl_pts), Err(Error::ZeroRange)));+ /// ```+ #[error("This knot vector consists single value.")]+ ZeroRange,+ /// Fails concatting two knot vectors if there is a difference between the back knot of+ /// the former knot vector and the front knot of the latter knot vector.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ /// let mut knot_vec0 = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);+ /// let knot_vec1 = KnotVec::from(vec![2.0, 2.0, 3.0, 3.0]);+ /// assert!(matches!(knot_vec0.try_concat(&knot_vec1, 1), Err(Error::DifferentBackFront(1.0, 2.0))));+ /// ```+ #[error("Cannot concat two knot vectors whose the back of the first and the front of the second are different.+the back of the first knot vector: {0}+the front of the second knot vector: {1}")]+ DifferentBackFront(f64, f64),+ /// If the knot vector is not clamped, then one cannot concat the vector with another knot vector.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ /// let mut knot_vec0 = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);+ /// let knot_vec1 = KnotVec::from(vec![2.0, 2.0, 3.0, 3.0]);+ /// assert!(matches!(knot_vec0.try_concat(&knot_vec1, 2), Err(Error::NotClampedKnotVector)));+ /// ```+ #[error("This knot vector is not clamped.")]+ NotClampedKnotVector,+ /// Creating a knot vector by `KnotVec::try_from()` is failed if the given vector is not sorted.+ /// `<KnotVec as From<Vec<f64>>>::from()` does not panic by this error because sorts the given+ /// vector before creating the knot vector. So, `KnotVec::try_from()` is more efficient than+ /// `<KnotVec as From<Vec<f64>>>::from()`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ /// use std::convert::*;+ ///+ /// assert!(matches!(KnotVec::try_from(vec![1.0, 3.0, 0.0, 2.0]), Err(Error::NotSortedVector)));+ /// assert_eq!(+ /// <KnotVec as From<Vec<f64>>>::from(vec![1.0, 3.0, 0.0, 2.0]),+ /// KnotVec::try_from(vec![0.0, 1.0, 2.0, 3.0]).unwrap(),+ /// );+ /// ```+ #[error("This knot vector is not sorted.")]+ NotSortedVector,+ /// The given degree is too large to calculate bspline basis functions.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ ///+ /// // a knot vector with length = 4.+ /// let knot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);+ /// assert!(matches!(+ /// knot_vec.try_bspline_basis_functions(5, 0.5),+ /// Err(Error::TooLargeDegree(4, 5)),+ /// ));+ /// ```+ #[error(+ "This knot vector is too short compared to the degree.+the length of knot_vec: {0}+the degree: {1}"+ )]+ TooLargeDegree(usize, usize),+ /// The specified knot cannot be removed.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let ctrl_pts = vec![Vector2::new(-1.0, 1.0), Vector2::new(0.0, -1.0), Vector2::new(1.0, 1.0)];+ /// let mut bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let org_curve = bspcurve.clone();+ /// bspcurve.add_knot(0.5).add_knot(0.5).add_knot(0.25).add_knot(0.75);+ /// assert!(bspcurve.try_remove_knot(3).is_ok());+ /// assert!(matches!(bspcurve.try_remove_knot(2), Err(Error::CannotRemoveKnot(2))));+ /// ```+ #[error("The {0}th knot in this knot vector cannot be removed.")]+ CannotRemoveKnot(usize),+ /// Empty vector of points cannot construct B-spline.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ ///+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let ctrl_pts: Vec<Vector4> = Vec::new();+ /// assert!(matches!(+ /// BSplineCurve::try_new(knot_vec, ctrl_pts),+ /// Err(Error::EmptyControlPoints),+ /// ));+ /// ```+ #[error("The control point must not be empty.")]+ EmptyControlPoints,+ /// The knot vector of B-spline curves or B-spline surfaces must be longer than the corresponded+ /// array of control points.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ /// let knot_vec = KnotVec::from(vec![0.0, 1.0, 2.0]);+ /// let ctrl_pts = vec![Vector2::new(0.0, 0.0), Vector2::new(0.0, 0.0), Vector2::new(0.0, 0.0), Vector2::new(0.0, 0.0)];+ /// assert!(matches!(+ /// BSplineCurve::try_new(knot_vec, ctrl_pts),+ /// Err(Error::TooShortKnotVector(3, 4)),+ /// ));+ /// ```+ #[error(+ "The knot vector must be more than the control points.+the length of knot_vec: {0}+the number of control points: {1}"+ )]+ TooShortKnotVector(usize, usize),+ /// The length of the given arrays of control points to create a B-spline surface is irregular.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ /// let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(1.0, 2.0), Vector2::new(1.0, 2.0)], // length = 2+ /// vec![Vector2::new(1.0, 2.0)] // length = 1+ /// ];+ /// assert!(matches!(+ /// BSplineSurface::try_new(knot_vecs, ctrl_pts),+ /// Err(Error::IrregularControlPoints),+ /// ));+ /// ```+ #[error("The number of control points is irregular")]+ IrregularControlPoints,+ /// The vector of control points and the one of weights have different length.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ /// let bspcurve = BSplineCurve::new(+ /// KnotVec::bezier_knot(2),+ /// vec![Point2::new(0.0, 1.0), Point2::new(2.0, 3.0), Point2::new(4.0, 5.0)],+ /// );+ /// let weights = vec![1.0, 2.0]; // less than control points+ ///+ /// assert!(matches!(+ /// NurbsCurve::<Vector3>::try_from_bspline_and_weights(bspcurve, weights),+ /// Err(Error::DifferentLength),+ /// ));+ /// ```+ #[error("The vector of control points and the one of weights have different length.")]+ DifferentLength,+}++#[test]+#[rustfmt::skip]+fn print_messages() {+ use std::io::Write;+ let stderr = &mut std::io::stderr();+ writeln!(stderr, "****** test of the expressions of error messages ******\n").unwrap();+ writeln!(stderr, "{}\n", Error::ZeroRange).unwrap();+ writeln!(stderr, "{}\n", Error::DifferentBackFront(0.0, 1.0)).unwrap();+ writeln!(stderr, "{}\n", Error::NotClampedKnotVector).unwrap();+ writeln!(stderr, "{}\n", Error::NotSortedVector).unwrap();+ writeln!(stderr, "{}\n", Error::TooLargeDegree(1, 2)).unwrap();+ writeln!(stderr, "{}\n", Error::CannotRemoveKnot(7)).unwrap();+ writeln!(stderr, "{}\n", Error::EmptyControlPoints).unwrap();+ writeln!(stderr, "{}\n", Error::TooShortKnotVector(1, 2)).unwrap();+ writeln!(stderr, "{}\n", Error::IrregularControlPoints).unwrap();+ writeln!(stderr, "*******************************************************").unwrap();+}diff --git a/vendor/truck-geometry/src/lib.rs b/vendor/truck-geometry/src/lib.rsnew file mode 100644index 0000000000..50ac5ff29e--- /dev/null+++ b/vendor/truck-geometry/src/lib.rs@@ -0,0 +1,52 @@+//! Geometrical structs: knot vector, B-spline and NURBS++#![cfg_attr(not(debug_assertions), deny(warnings))]+#![deny(clippy::all, rust_2018_idioms)]+#![warn(+ missing_docs,+ missing_debug_implementations,+ trivial_casts,+ trivial_numeric_casts,+ unsafe_code,+ unstable_features,+ unused_import_braces,+ unused_qualifications+)]++use serde::{Deserialize, Serialize};+use std::{fmt::Debug, ops::Bound};+use truck_base::bounding_box::Bounded;++const INCLUDE_CURVE_TRIALS: usize = 100;+const PRESEARCH_DIVISION: usize = 50;++/// re-export `truck_base`+pub mod base {+ pub use truck_base::bounding_box::BoundingBox;+ pub use truck_base::cgmath64::*;+ pub use truck_base::tolerance::*;+ pub use truck_base::{assert_near, assert_near2};+ pub use truck_base::{hash, hash::HashGen};+ pub use truck_geotrait::*;+}+/// Declares the nurbs+pub mod nurbs;++/// Enumerats `Error`.+pub mod errors;++/// Declares the specified gememetric items: Plane, Sphere, and so on.+pub mod specifieds;++/// Declares some decorators+pub mod decorators;++/// re-export all modules.+pub mod prelude {+ use crate::*;+ pub use base::*;+ pub use decorators::*;+ pub use errors::*;+ pub use nurbs::*;+ pub use specifieds::*;+}diff --git a/vendor/truck-geometry/src/nurbs/bspcurve.rs b/vendor/truck-geometry/src/nurbs/bspcurve.rsnew file mode 100644index 0000000000..50eb46bdab--- /dev/null+++ b/vendor/truck-geometry/src/nurbs/bspcurve.rs@@ -0,0 +1,1488 @@+use super::*;+use crate::errors::Error;+use std::ops::*;++impl<P> BSplineCurve<P> {+ /// constructor.+ /// # Arguments+ /// * `knot_vec` - the knot vector+ /// * `control_points` - the vector of the control points+ /// # Panics+ /// Panics occurs if:+ /// * There are no control points.+ /// * The number of knots is more than the one of control points.+ /// * The range of the knot vector is zero.+ pub fn new(knot_vec: KnotVec, control_points: Vec<P>) -> BSplineCurve<P> {+ BSplineCurve::try_new(knot_vec, control_points).unwrap_or_else(|e| panic!("{}", e))+ }++ /// constructor.+ /// # Arguments+ /// * `knot_vec` - the knot vector+ /// * `control_points` - the vector of the control points+ /// # Failures+ /// * If there are no control points, returns [`Error::EmptyControlPoint<f64>s`].+ /// * If the number of knots is more than the one of control points, returns [`Error::TooShortKnotVector`].+ /// * If the range of the knot vector is zero, returns [`Error::ZeroRange`].+ ///+ /// [`Error::EmptyControlPoint<f64>s`]: errors/enum.Error.html#variant.EmptyControlPoint<f64>s+ /// [`Error::TooShortKnotVector`]: errors/enum.Error.html#variant.TooShortKnotVector+ /// [`Error::ZeroRange`]: errors/enum.Error.html#variant.ZeroRange+ pub fn try_new(knot_vec: KnotVec, control_points: Vec<P>) -> Result<BSplineCurve<P>> {+ if control_points.is_empty() {+ Err(Error::EmptyControlPoints)+ } else if knot_vec.len() <= control_points.len() {+ Err(Error::TooShortKnotVector(+ knot_vec.len(),+ control_points.len(),+ ))+ } else if knot_vec.range_length().so_small() {+ Err(Error::ZeroRange)+ } else {+ Ok(BSplineCurve::new_unchecked(knot_vec, control_points))+ }+ }++ /// constructor.+ /// # Arguments+ /// * `knot_vec` - the knot vector+ /// * `control_points` - the vector of the control points+ /// # Remarks+ /// This method is prepared only for performance-critical development and is not recommended.+ /// This method does NOT check the rules for constructing B-spline curve.+ /// The programmer must guarantee these conditions before using this method.+ #[inline(always)]+ pub const fn new_unchecked(knot_vec: KnotVec, control_points: Vec<P>) -> BSplineCurve<P> {+ Self {+ knot_vec,+ control_points,+ }+ }++ /// constructor.+ /// # Arguments+ /// * `knot_vec` - the knot vector+ /// * `control_points` - the vector of the control points+ /// # Remarks+ /// This method checks the rules for constructing B-spline curve in the debug mode.+ /// The programmer must guarantee these conditions before using this method.+ #[inline(always)]+ pub fn debug_new(knot_vec: KnotVec, control_points: Vec<P>) -> BSplineCurve<P> {+ match cfg!(debug_assertions) {+ true => Self::new(knot_vec, control_points),+ false => Self::new_unchecked(knot_vec, control_points),+ }+ }++ /// Returns the reference of the knot vector+ #[inline(always)]+ pub const fn knot_vec(&self) -> &KnotVec { &self.knot_vec }++ /// Returns the `idx`th knot+ #[inline(always)]+ pub fn knot(&self, idx: usize) -> f64 { self.knot_vec[idx] }++ /// Returns the reference of the control points.+ #[inline(always)]+ pub const fn control_points(&self) -> &Vec<P> { &self.control_points }++ /// Returns the reference of the control point corresponding to the index `idx`.+ #[inline(always)]+ pub fn control_point(&self, idx: usize) -> &P { &self.control_points[idx] }++ /// Returns the mutable reference of the control point corresponding to index `idx`.+ #[inline(always)]+ pub fn control_point_mut(&mut self, idx: usize) -> &mut P { &mut self.control_points[idx] }+ /// Returns the iterator on all control points+ #[inline(always)]+ pub fn control_points_mut(&mut self) -> impl Iterator<Item = &mut P> {+ self.control_points.iter_mut()+ }++ /// Apply the given transformation to all control points.+ #[inline(always)]+ pub fn transform_control_points<F: FnMut(&mut P)>(&mut self, f: F) {+ self.control_points.iter_mut().for_each(f)+ }++ /// Returns the degree of B-spline curve+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let ctrl_pts = vec![Vector2::new(1.0, 2.0), Vector2::new(2.0, 3.0), Vector2::new(3.0, 4.0)];+ /// let bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// assert_eq!(bspcurve.degree(), 2);+ /// ```+ #[inline(always)]+ pub fn degree(&self) -> usize { self.knot_vec.len() - self.control_points.len() - 1 }+ /// Inverts a curve+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::uniform_knot(2, 2);+ /// let ctrl_pts = vec![Vector2::new(1.0, 2.0), Vector2::new(2.0, 3.0), Vector2::new(3.0, 4.0), Vector2::new(4.0, 5.0)];+ /// let bspcurve0 = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let mut bspcurve1 = bspcurve0.clone();+ /// bspcurve1.invert();+ ///+ /// const N: usize = 100; // sample size+ /// for i in 0..=N {+ /// let t = (i as f64) / (N as f64);+ /// assert_near2!(bspcurve0.subs(t), bspcurve1.subs(1.0 - t));+ /// }+ /// ```+ #[inline(always)]+ pub fn invert(&mut self) -> &mut Self {+ self.knot_vec.invert();+ self.control_points.reverse();+ self+ }++ /// Returns whether the knot vector is clamped or not.+ #[inline(always)]+ pub fn is_clamped(&self) -> bool { self.knot_vec.is_clamped(self.degree()) }++ /// Normalizes the knot vector+ #[inline(always)]+ pub fn knot_normalize(&mut self) -> &mut Self {+ self.knot_vec.try_normalize().unwrap();+ self+ }++ /// Translates the knot vector+ #[inline(always)]+ pub fn knot_translate(&mut self, x: f64) -> &mut Self {+ self.knot_vec.translate(x);+ self+ }+}++impl<P: ControlPoint<f64>> BSplineCurve<P> {+ /// Returns the closure of substitution.+ /// # Examples+ /// The following test code is the same test with the one of `BSplineCurve::subs()`.+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::from(vec![-1.0, -1.0, -1.0, 1.0, 1.0, 1.0]);+ /// let ctrl_pts = vec![Vector2::new(-1.0, 1.0), Vector2::new(0.0, -1.0), Vector2::new(1.0, 1.0)];+ /// let bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ ///+ /// const N: usize = 100; // sample size+ /// let get_t = |i: usize| -1.0 + 2.0 * (i as f64) / (N as f64);+ /// let res: Vec<_> = (0..=N).map(get_t).map(bspcurve.get_closure()).collect();+ /// let ans: Vec<_> = (0..=N).map(get_t).map(|t| Vector2::new(t, t * t)).collect();+ /// res.iter().zip(&ans).for_each(|(v0, v1)| assert_near2!(v0, v1));+ /// ```+ #[inline(always)]+ pub fn get_closure(&self) -> impl Fn(f64) -> P + '_ { move |t| self.subs(t) }+ #[inline(always)]+ fn delta_control_points(&self, i: usize) -> P::Diff {+ if i == 0 {+ self.control_point(i).to_vec()+ } else if i == self.control_points.len() {+ self.control_points[i - 1].to_vec() * (-1.0)+ } else {+ self.control_points[i] - self.control_points[i - 1]+ }+ }+ #[inline(always)]+ fn delta2_control_points(&self, i: usize) -> P::Diff {+ let k = self.degree();+ let knot_vec = self.knot_vec();+ if i == 0 {+ let coef = inv_or_zero(knot_vec[i + k] - knot_vec[i]);+ self.delta_control_points(i) * coef+ } else if i == self.control_points.len() + 1 {+ let coef = inv_or_zero(knot_vec[i - 1 + k] - knot_vec[i - 1]);+ self.delta_control_points(i - 1) * (-coef)+ } else {+ let coef0 = inv_or_zero(knot_vec[i + k] - knot_vec[i]);+ let coef1 = inv_or_zero(knot_vec[i - 1 + k] - knot_vec[i - 1]);+ self.delta_control_points(i) * coef0 - self.delta_control_points(i - 1) * coef1+ }+ }+ /// Returns the derived B-spline curve.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let ctrl_pts = vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, 0.0), Vector2::new(1.0, 1.0)];+ /// let bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let derived = bspcurve.derivation();+ ///+ /// // `bpscurve = (t, t^2), derived = (1, 2t)`+ /// const N : usize = 100; // sample size+ /// for i in 0..=N {+ /// let t = 1.0 / (N as f64) * (i as f64);+ /// assert_near2!(derived.subs(t), Vector2::new(1.0, 2.0 * t));+ /// }+ /// ```+ pub fn derivation(&self) -> BSplineCurve<P::Diff> {+ let n = self.control_points.len();+ let k = self.degree();+ let knot_vec = self.knot_vec.clone();+ let mut new_points = Vec::with_capacity(n + 1);+ if k > 0 {+ let (knot_vec, new_points) = (&knot_vec, &mut new_points);+ (0..=n).for_each(move |i| {+ let delta = knot_vec[i + k] - knot_vec[i];+ let coef = (k as f64) * inv_or_zero(delta);+ new_points.push(self.delta_control_points(i) * coef);+ });+ } else {+ new_points = vec![P::Diff::zero(); n];+ }+ BSplineCurve::new_unchecked(knot_vec, new_points)+ }+ pub(super) fn sub_near_as_curve<F: Fn(&P, &P) -> bool>(+ &self,+ other: &BSplineCurve<P>,+ div_coef: usize,+ ord: F,+ ) -> bool {+ if !self.knot_vec.same_range(&other.knot_vec) {+ return false;+ }++ let division = std::cmp::max(self.degree(), other.degree()) * div_coef;+ for i in 0..(self.knot_vec.len() - 1) {+ let delta = self.knot_vec[i + 1] - self.knot_vec[i];+ if delta.so_small() {+ continue;+ }++ for j in 0..division {+ let t = self.knot_vec[i] + delta * (j as f64) / (division as f64);+ if !ord(&self.subs(t), &other.subs(t)) {+ return false;+ }+ }+ }+ true+ }+}++impl<V: Homogeneous<f64>> BSplineCurve<V> {+ /// lift up control points to homogeneous coordinate.+ pub fn lift_up(curve: BSplineCurve<V::Point>) -> Self {+ let control_points = curve+ .control_points+ .into_iter()+ .map(V::from_point)+ .collect();+ BSplineCurve::new_unchecked(curve.knot_vec, control_points)+ }+}++impl<P: ControlPoint<f64>> ParametricCurve for BSplineCurve<P> {+ type Point = P;+ type Vector = P::Diff;+ /// Substitutes to B-spline curve.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::from(vec![-1.0, -1.0, -1.0, 1.0, 1.0, 1.0]);+ /// let ctrl_pts = vec![Vector2::new(-1.0, 1.0), Vector2::new(0.0, -1.0), Vector2::new(1.0, 1.0)];+ /// let bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ ///+ /// // bspcurve coincides with (t, t * t) in the range [-1.0..1.0].+ /// const N: usize = 100; // sample size+ /// for i in 0..=N {+ /// let t = -1.0 + 2.0 * (i as f64) / (N as f64);+ /// assert_near2!(bspcurve.subs(t), Vector2::new(t, t * t));+ /// }+ /// ```+ #[inline(always)]+ fn subs(&self, t: f64) -> P {+ let basis = self+ .knot_vec+ .try_bspline_basis_functions(self.degree(), t)+ .unwrap();+ self.control_points+ .iter()+ .zip(basis)+ .fold(P::origin(), |sum, (pt, basis)| sum + pt.to_vec() * basis)+ }+ /// Substitutes to the derived B-spline curve.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let ctrl_pts = vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, 0.0), Vector2::new(1.0, 1.0)];+ /// let bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ ///+ /// // `bpscurve = (t, t^2), derived = (1, 2t)`+ /// const N : usize = 100; // sample size+ /// for i in 0..=N {+ /// let t = 1.0 / (N as f64) * (i as f64);+ /// assert_near2!(bspcurve.der(t), Vector2::new(1.0, 2.0 * t));+ /// }+ /// ```+ #[inline(always)]+ fn der(&self, t: f64) -> P::Diff {+ let k = self.degree();+ let knot_vec = self.knot_vec();+ let closure = move |sum: P::Diff, (i, b): (usize, f64)| {+ let coef = inv_or_zero(knot_vec[i + k] - knot_vec[i]);+ sum + self.delta_control_points(i) * b * coef+ };+ knot_vec+ .bspline_basis_functions(k - 1, t)+ .into_iter()+ .enumerate()+ .fold(P::Diff::zero(), closure)+ * k as f64+ }+ /// Substitutes to the 2nd-ord derived B-spline curve.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::bezier_knot(3);+ /// let ctrl_pts = vec![+ /// Vector2::new(0.0, 0.0),+ /// Vector2::new(1.0, 1.0),+ /// Vector2::new(0.0, 1.0),+ /// Vector2::new(1.0, 0.0),+ /// ];+ /// let bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ ///+ /// // bpscurve = (4t^3 - 6t^2 + 3t, -3t^2 + 3t), derived2 = (24t - 12, -6)+ /// const N : usize = 100; // sample size+ /// for i in 0..=N {+ /// let t = 1.0 / (N as f64) * (i as f64);+ /// assert_near2!(bspcurve.der2(t), Vector2::new(24.0 * t - 12.0, -6.0));+ /// }+ /// ```+ #[inline(always)]+ fn der2(&self, t: f64) -> P::Diff {+ let k = self.degree();+ if k < 2 {+ return P::Diff::zero();+ }+ let knot_vec = self.knot_vec();+ let closure = move |sum: P::Diff, (i, b): (usize, f64)| {+ let coef = inv_or_zero(knot_vec[i + k - 1] - knot_vec[i]);+ sum + self.delta2_control_points(i) * b * coef+ };+ knot_vec+ .bspline_basis_functions(k - 2, t)+ .into_iter()+ .enumerate()+ .fold(P::Diff::zero(), closure)+ * k as f64+ * (k - 1) as f64+ }+ #[inline(always)]+ fn parameter_range(&self) -> ParameterRange {+ (+ Bound::Included(self.knot_vec[0]),+ Bound::Included(self.knot_vec[self.knot_vec.len() - 1]),+ )+ }+}++impl<P: ControlPoint<f64>> BoundedCurve for BSplineCurve<P> {}++impl<P: ControlPoint<f64> + Tolerance> BSplineCurve<P> {+ /// Returns whether all control points are the same or not.+ /// If the knot vector is clamped, it means whether the curve is constant or not.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ ///+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let pt = Vector2::new(1.0, 2.0);+ /// let mut ctrl_pts = vec![pt.clone(), pt.clone(), pt.clone()];+ /// let const_bspcurve = BSplineCurve::new(knot_vec.clone(), ctrl_pts.clone());+ /// assert!(const_bspcurve.is_const());+ ///+ /// ctrl_pts.push(Vector2::new(2.0, 3.0));+ /// let bspcurve = BSplineCurve::new(knot_vec.clone(), ctrl_pts.clone());+ /// assert!(!bspcurve.is_const());+ /// ```+ /// # Remarks+ /// If the knot vector is not clamped and the BSpline basis function is not partition of unity,+ /// then perhaps returns true even if the curve is not constant.+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::uniform_knot(1, 5);+ /// let ctrl_pts = vec![Vector2::new(1.0, 2.0), Vector2::new(1.0, 2.0)];+ /// let bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ ///+ /// // bspcurve is not constant.+ /// assert_eq!(bspcurve.subs(0.0), Vector2::new(0.0, 0.0));+ /// assert_ne!(bspcurve.subs(0.5), Vector2::new(0.0, 0.0));+ ///+ /// // bspcurve.is_const() is true+ /// assert!(bspcurve.is_const());+ /// ```+ pub fn is_const(&self) -> bool {+ self.control_points+ .iter()+ .all(move |vec| vec.near(&self.control_points[0]))+ }++ /// Adds a knot `x`, and do not change `self` as a curve.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let ctrl_pts = vec![Vector2::new(-1.0, 1.0), Vector2::new(0.0, -1.0), Vector2::new(1.0, 1.0)];+ /// let mut bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let org_curve = bspcurve.clone();+ ///+ /// // add 4 knots+ /// bspcurve.add_knot(0.5).add_knot(0.5).add_knot(0.25).add_knot(0.75);+ /// assert_eq!(bspcurve.knot_vec().len(), org_curve.knot_vec().len() + 4);+ /// // bspcurve does not change as a curve+ /// assert!(bspcurve.near2_as_curve(&org_curve));+ /// ```+ /// # Remarks+ /// If the added knot `x` is out of the range of the knot vector, then the knot vector will extended.+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let ctrl_pts = vec![Vector2::new(-1.0, 1.0), Vector2::new(0.0, -1.0), Vector2::new(1.0, 1.0)];+ /// let mut bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// assert_eq!(bspcurve.knot_vec().range_length(), 1.0);+ /// assert_eq!(bspcurve.front(), Vector2::new(-1.0, 1.0));+ /// assert_eq!(bspcurve.back(), Vector2::new(1.0, 1.0));+ ///+ /// // add knots out of the range of the knot vectors.+ /// bspcurve.add_knot(-1.0).add_knot(2.0);+ /// assert_eq!(bspcurve.knot_vec().range_length(), 3.0);+ /// assert_eq!(bspcurve.front(), Vector2::new(0.0, 0.0));+ /// assert_eq!(bspcurve.back(), Vector2::new(0.0, 0.0));+ /// ```+ pub fn add_knot(&mut self, x: f64) -> &mut Self {+ if x < self.knot_vec[0] {+ self.knot_vec.add_knot(x);+ self.control_points.insert(0, P::origin());+ return self;+ }++ let k = self.degree();+ let n = self.control_points.len();++ let idx = self.knot_vec.add_knot(x);+ let start = if idx > k { idx - k } else { 0 };+ let end = if idx > n {+ self.control_points.push(P::origin());+ n + 1+ } else {+ self.control_points+ .insert(idx - 1, *self.control_point(idx - 1));+ idx+ };+ for i in start..end {+ let i0 = end + start - i - 1;+ let delta = self.knot_vec[i0 + k + 1] - self.knot_vec[i0];+ let a = (self.knot_vec[idx] - self.knot_vec[i0]) * inv_or_zero(delta);+ let p = self.delta_control_points(i0) * (1.0 - a);+ self.control_points[i0] -= p;+ }+ self+ }++ /// Removes a knot corresponding to the indices `idx`, and do not change `self` as a curve.+ /// If cannot remove the knot, do not change `self` and return `self`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let ctrl_pts = vec![Vector2::new(-1.0, 1.0), Vector2::new(0.0, -1.0), Vector2::new(1.0, 1.0)];+ /// let mut bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let org_curve = bspcurve.clone();+ ///+ /// // add knots and remove them.+ /// bspcurve.add_knot(0.5).add_knot(0.5).add_knot(0.25).add_knot(0.75);+ /// bspcurve.remove_knot(3).remove_knot(3).remove_knot(3).remove_knot(3);+ /// assert!(bspcurve.near2_as_curve(&org_curve));+ /// assert_eq!(bspcurve.knot_vec().len(), org_curve.knot_vec().len())+ /// ```+ pub fn remove_knot(&mut self, idx: usize) -> &mut Self {+ let _ = self.try_remove_knot(idx);+ self+ }++ /// Removes a knot corresponding to the indice `idx`, and do not change `self` as a curve.+ /// If the knot cannot be removed, returns+ /// [`Error::CannotRemoveKnot`](./errors/enum.Error.html#variant.CannotRemoveKnot).+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let ctrl_pts = vec![Vector2::new(-1.0, 1.0), Vector2::new(0.0, -1.0), Vector2::new(1.0, 1.0)];+ /// let mut bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let org_curve = bspcurve.clone();+ /// bspcurve.add_knot(0.5).add_knot(0.5).add_knot(0.25).add_knot(0.75);+ /// assert!(bspcurve.try_remove_knot(3).is_ok());+ /// assert_eq!(bspcurve.try_remove_knot(2), Err(Error::CannotRemoveKnot(2)));+ /// ```+ pub fn try_remove_knot(&mut self, idx: usize) -> Result<&mut BSplineCurve<P>> {+ let k = self.degree();+ let n = self.control_points.len();+ let knot_vec = &self.knot_vec;++ if idx < k + 1 || idx >= n {+ return Err(Error::CannotRemoveKnot(idx));+ }++ let mut new_points = Vec::with_capacity(k + 1);+ new_points.push(*self.control_point(idx - k - 1));+ for i in (idx - k)..idx {+ let delta = knot_vec[i + k + 1] - knot_vec[i];+ let a = inv_or_zero(delta) * (knot_vec[idx] - knot_vec[i]);+ if a.so_small() {+ break;+ } else {+ let p = *new_points.last().unwrap();+ let p = p + (self.control_points[i] - p) / a;+ new_points.push(p);+ }+ }++ if !new_points.last().unwrap().near(self.control_point(idx)) {+ return Err(Error::CannotRemoveKnot(idx));+ }++ for (i, vec) in new_points.into_iter().skip(1).enumerate() {+ self.control_points[idx - k + i] = vec;+ }++ self.control_points.remove(idx);+ self.knot_vec.remove(idx);+ Ok(self)+ }++ /// elevate 1 degree for bezier curve.+ fn elevate_degree_bezier(&mut self) -> &mut Self {+ let k = self.degree();+ self.knot_vec.add_knot(self.knot_vec[0]);+ self.knot_vec+ .add_knot(self.knot_vec[self.knot_vec.len() - 1]);+ self.control_points.push(P::origin());+ for i in 0..=(k + 1) {+ let i0 = k + 1 - i;+ let a = (i0 as f64) / ((k + 1) as f64);+ let p = self.delta_control_points(i0) * a;+ self.control_points[i0] -= p;+ }+ self+ }++ /// elevate 1 degree.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::bezier_knot(1);+ /// let ctrl_pts = vec![Vector2::new(0.0, 0.0), Vector2::new(1.0, 1.0)];+ /// let mut bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// bspcurve.elevate_degree();+ /// assert_eq!(bspcurve.degree(), 2);+ /// assert_eq!(bspcurve.knot_vec(), &KnotVec::bezier_knot(2));+ /// assert_eq!(bspcurve.control_point(1), &Vector2::new(0.5, 0.5));+ /// ```+ pub fn elevate_degree(&mut self) -> &mut Self {+ let mut result = CurveCollector::Singleton;+ for mut bezier in self.bezier_decomposition() {+ result.concat(bezier.elevate_degree_bezier());+ }+ *self = result.unwrap();+ self+ }++ /// Makes the B-spline curve clamped+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::from(vec![0.0, 1.0, 2.0, 3.0, 4.0, 5.0]);+ /// let ctrl_pts = vec![Vector2::new(0.0, 1.0), Vector2::new(1.0, 2.0), Vector2::new(2.0, 3.0)];+ /// let mut bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// assert!(!bspcurve.is_clamped());+ /// bspcurve.clamp();+ /// assert!(bspcurve.is_clamped());+ /// assert_eq!(bspcurve.knot_vec().len(), 10);+ /// ```+ #[inline(always)]+ pub fn clamp(&mut self) -> &mut Self {+ let degree = self.degree();++ let s = self.knot_vec.multiplicity(0);+ for _ in s..=degree {+ self.add_knot(self.knot_vec[0]);+ }++ let n = self.knot_vec.len();+ let s = self.knot_vec.multiplicity(n - 1);+ for _ in s..=degree {+ self.add_knot(self.knot_vec[n - 1]);+ }+ self+ }++ /// Repeats `Self::try_remove_knot()` from the back knot in turn until the knot cannot be removed.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ ///+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let ctrl_pts = vec![Vector2::new(1.0, 2.0), Vector2::new(2.0, 3.0), Vector2::new(3.0, 4.0)];+ /// let mut bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let org_curve = bspcurve.clone();+ ///+ /// // add 4 new knots+ /// bspcurve.add_knot(0.5).add_knot(0.5).add_knot(0.25).add_knot(0.75);+ /// assert_eq!(bspcurve.knot_vec().len(), KnotVec::bezier_knot(2).len() + 4);+ ///+ /// // By the optimization, added knots are removed.+ /// bspcurve.optimize();+ /// assert_eq!(bspcurve.knot_vec(), &KnotVec::bezier_knot(2));+ /// assert!(bspcurve.near2_as_curve(&org_curve));+ /// ```+ pub fn optimize(&mut self) -> &mut Self {+ loop {+ let n = self.knot_vec.len();+ let closure = |flag, i| flag && self.try_remove_knot(n - i).is_err();+ if (1..=n).fold(true, closure) {+ break;+ }+ }+ self+ }++ /// Makes two splines having the same degrees.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ ///+ /// let knot_vec0 = KnotVec::bezier_knot(1);+ /// let ctrl_pts0 = vec![Vector2::new(1.0, 2.0), Vector2::new(2.0, 3.0)];+ /// let mut bspcurve0 = BSplineCurve::new(knot_vec0, ctrl_pts0);+ /// let knot_vec1 = KnotVec::bezier_knot(2);+ /// let ctrl_pts1 = vec![Vector2::new(1.0, 2.0), Vector2::new(2.0, 3.0), Vector2::new(3.0, 4.0)];+ /// let mut bspcurve1 = BSplineCurve::new(knot_vec1, ctrl_pts1);+ /// assert_ne!(bspcurve0.degree(), bspcurve1.degree());+ ///+ /// let org_curve0 = bspcurve0.clone();+ /// let org_curve1 = bspcurve1.clone();+ /// bspcurve0.syncro_degree(&mut bspcurve1);+ /// assert_eq!(bspcurve0.degree(), bspcurve1.degree());+ /// assert!(bspcurve0.near2_as_curve(&org_curve0));+ /// assert!(bspcurve1.near2_as_curve(&org_curve1));+ /// ```+ pub fn syncro_degree(&mut self, other: &mut Self) {+ let (degree0, degree1) = (self.degree(), other.degree());+ for _ in degree0..degree1 {+ self.elevate_degree();+ }+ for _ in degree1..degree0 {+ other.elevate_degree();+ }+ }++ /// Makes two splines having the same normalized knot vectors.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ ///+ /// let knot_vec0 = KnotVec::from(vec![0.0, 0.0, 0.0, 0.5, 1.0, 1.0, 1.0]);+ /// let ctrl_pts0 = vec![Vector2::new(0.0, 0.0), Vector2::new(1.0, 1.0), Vector2::new(2.0, 2.0), Vector2::new(3.0, 3.0)];+ /// let mut bspcurve0 = BSplineCurve::new(knot_vec0, ctrl_pts0);+ /// let mut org_curve0 = bspcurve0.clone();+ /// let knot_vec1 = KnotVec::from(vec![0.0, 0.0, 1.0, 3.0, 4.0, 4.0]);+ /// let ctrl_pts1 = vec![Vector2::new(0.0, 0.0), Vector2::new(1.0, 1.0), Vector2::new(2.0, 2.0), Vector2::new(3.0, 3.0)];+ /// let mut bspcurve1 = BSplineCurve::new(knot_vec1, ctrl_pts1);+ /// let mut org_curve1 = bspcurve1.clone();+ ///+ /// bspcurve0.syncro_knots(&mut bspcurve1);+ ///+ /// // The knot vectors are made the same.+ /// assert_eq!(bspcurve0.knot_vec(), bspcurve1.knot_vec());+ /// assert_eq!(+ /// bspcurve0.knot_vec().as_slice(),+ /// &[0.0, 0.0, 0.0, 0.25, 0.5, 0.75, 1.0, 1.0, 1.0]+ /// );+ /// // The degrees are not changed.+ /// assert_eq!(bspcurve0.degree(), org_curve0.degree());+ /// assert_eq!(bspcurve1.degree(), org_curve1.degree());+ /// // The knot vector is normalized, however, the shape of curve is not changed.+ /// assert!(bspcurve0.near2_as_curve(org_curve0.knot_normalize()));+ /// assert!(bspcurve1.near2_as_curve(org_curve1.knot_normalize()));+ /// ```+ pub fn syncro_knots(&mut self, other: &mut BSplineCurve<P>) {+ self.knot_normalize();+ other.knot_normalize();++ let mut i = 0;+ let mut j = 0;+ while !self.knot(i).near2(&1.0) || !other.knot(j).near2(&1.0) {+ if self.knot(i) - other.knot(j) > TOLERANCE {+ self.add_knot(other.knot(j));+ } else if other.knot(j) - self.knot(i) > TOLERANCE {+ other.add_knot(self.knot(i));+ }+ i += 1;+ j += 1;+ }++ use std::cmp::Ordering;+ match usize::cmp(&self.knot_vec.len(), &other.knot_vec.len()) {+ Ordering::Less => {+ (0..(other.knot_vec.len() - self.knot_vec.len())).for_each(|_| {+ self.add_knot(1.0);+ });+ }+ Ordering::Greater => (0..(self.knot_vec.len() - other.knot_vec.len())).for_each(|_| {+ other.add_knot(1.0);+ }),+ _ => {}+ }+ }++ /// Separates `self` into Bezier curves by each knots.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ ///+ /// let knot_vec = KnotVec::uniform_knot(2, 2);+ /// let ctrl_pts = vec![Vector2::new(0.0, 1.0), Vector2::new(1.0, 2.0), Vector2::new(2.0, 3.0), Vector2::new(3.0, 4.0)];+ /// let bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let beziers = bspcurve.bezier_decomposition();+ ///+ /// const N: usize = 100;+ /// for i in 0..=N {+ /// let t = 0.5 * (i as f64) / (N as f64);+ /// assert_near2!(bspcurve.subs(t), beziers[0].subs(t));+ /// }+ /// for i in 0..=N {+ /// let t = 0.5 + 0.5 * (i as f64) / (N as f64);+ /// assert_near2!(bspcurve.subs(t), beziers[1].subs(t));+ /// }+ /// ```+ pub fn bezier_decomposition(&self) -> Vec<BSplineCurve<P>> {+ let mut bspline = self.clone();+ bspline.clamp();+ let (knots, _) = self.knot_vec.to_single_multi();+ let n = knots.len();++ let mut result = Vec::new();+ for i in 2..n {+ result.push(bspline.cut(knots[n - i]));+ }+ result.push(bspline);+ result.reverse();+ result+ }++ /// Makes the curve locally injective.+ /// # Example+ /// ```+ /// use truck_geometry::prelude::*;+ /// const N : usize = 100; // sample size for test+ ///+ /// let knot_vec = KnotVec::from(+ /// vec![0.0, 0.0, 0.0, 1.0, 3.0, 4.0, 4.0, 4.0]+ /// );+ /// let ctrl_pts = vec![+ /// Vector3::new(1.0, 0.0, 0.0),+ /// Vector3::new(0.0, 1.0, 0.0),+ /// Vector3::new(0.0, 1.0, 0.0),+ /// Vector3::new(0.0, 1.0, 0.0),+ /// Vector3::new(0.0, 0.0, 1.0),+ /// ];+ ///+ /// let mut bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let mut flag = false;+ /// for i in 0..=N {+ /// let t = 4.0 * (i as f64) / (N as f64);+ /// flag = flag || bspcurve.subs(t).near(&bspcurve.subs(t + 1.0 / (N as f64)));+ /// }+ /// // There exists t such that bspcurve(t) == bspcurve(t + 0.01).+ /// assert!(flag);+ ///+ /// bspcurve.make_locally_injective().knot_normalize();+ /// let mut flag = false;+ /// for i in 0..=N {+ /// let t = 1.0 * (i as f64) / (N as f64);+ /// flag = flag || bspcurve.subs(t).near(&bspcurve.subs(t + 1.0 / (N as f64)));+ /// }+ /// // There does not exist t such that bspcurve(t) == bspcurve(t + 0.01).+ /// assert!(!flag);+ /// ```+ /// # Remarks+ /// If `self` is a constant curve, then does nothing.+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 2.0, 2.0, 2.0]);+ /// let ctrl_pts = vec![Vector2::new(1.0, 1.0); 4];+ /// let mut bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let org_curve = bspcurve.clone();+ /// bspcurve.make_locally_injective();+ /// assert_eq!(bspcurve, org_curve);+ /// ```+ pub fn make_locally_injective(&mut self) -> &mut Self {+ let mut iter = self.bezier_decomposition().into_iter();+ for bezier in iter.by_ref() {+ if !bezier.is_const() {+ *self = bezier;+ break;+ }+ }+ let mut x = 0.0;+ for mut bezier in iter {+ if bezier.is_const() {+ x += bezier.knot_vec.range_length();+ } else {+ self.concat(bezier.knot_translate(-x));+ }+ }+ self+ }+ /// Determine whether `self` and `other` is near as the B-spline curves or not.+ ///+ /// Divides each knot interval into the number of degree equal parts,+ /// and check `|self(t) - other(t)| < TOLERANCE` for each end points `t`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::from(+ /// vec![0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 4.0, 4.0]+ /// );+ /// let ctrl_pts = vec![+ /// Vector2::new(1.0, 1.0),+ /// Vector2::new(3.0, 2.0),+ /// Vector2::new(2.0, 3.0),+ /// Vector2::new(4.0, 5.0),+ /// Vector2::new(5.0, 4.0),+ /// Vector2::new(1.0, 1.0),+ /// ];+ /// let bspcurve0 = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let mut bspcurve1 = bspcurve0.clone();+ /// assert!(bspcurve0.near_as_curve(&bspcurve1));+ /// *bspcurve1.control_point_mut(1) += Vector2::new(0.01, 0.0002);+ /// assert!(!bspcurve0.near_as_curve(&bspcurve1));+ /// ```+ #[inline(always)]+ pub fn near_as_curve(&self, other: &BSplineCurve<P>) -> bool {+ self.sub_near_as_curve(other, 1, |x, y| x.near(y))+ }++ /// Determines `self` and `other` is near in square order as the B-spline curves or not.+ ///+ /// Divide each knot interval into the number of degree equal parts,+ /// and check `|self(t) - other(t)| < TOLERANCE`for each end points `t`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let eps = TOLERANCE;+ /// let knot_vec = KnotVec::from(+ /// vec![0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 4.0, 4.0]+ /// );+ /// let ctrl_pts = vec![+ /// Vector2::new(1.0, 1.0),+ /// Vector2::new(3.0, 2.0),+ /// Vector2::new(2.0, 3.0),+ /// Vector2::new(4.0, 5.0),+ /// Vector2::new(5.0, 4.0),+ /// Vector2::new(1.0, 1.0),+ /// ];+ /// let bspcurve0 = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let mut bspcurve1 = bspcurve0.clone();+ /// assert!(bspcurve0.near_as_curve(&bspcurve1));+ /// *bspcurve1.control_point_mut(1) += Vector2::new(eps, 0.0);+ /// assert!(!bspcurve0.near2_as_curve(&bspcurve1));+ /// ```+ #[inline(always)]+ pub fn near2_as_curve(&self, other: &BSplineCurve<P>) -> bool {+ self.sub_near_as_curve(other, 1, |x, y| x.near2(y))+ }+}++impl<P: ControlPoint<f64>> ParameterTransform for BSplineCurve<P> {+ #[inline(always)]+ fn parameter_transform(&mut self, scalar: f64, r#move: f64) -> &mut Self {+ self.knot_vec.transform(scalar, r#move);+ self+ }+}++#[test]+fn parameter_transform_random_test() {+ let curve = BSplineCurve::new(+ KnotVec::uniform_knot(4, 4),+ (0..8)+ .map(|_| {+ Point3::new(+ rand::random::<f64>(),+ rand::random::<f64>(),+ rand::random::<f64>(),+ )+ })+ .collect(),+ );+ truck_geotrait::parameter_transform_random_test(&curve, 10);+}++impl<P: ControlPoint<f64> + Tolerance> Cut for BSplineCurve<P> {+ fn cut(&mut self, mut t: f64) -> BSplineCurve<P> {+ let degree = self.degree();++ let idx = match self.knot_vec.floor(t) {+ Some(idx) => idx,+ None => {+ let bspline = self.clone();+ let knot_vec = KnotVec::from(vec![t, self.knot_vec[0]]);+ let ctrl_pts = vec![P::origin()];+ *self = BSplineCurve::new(knot_vec, ctrl_pts);+ return bspline;+ }+ };+ let s = if t.near(&self.knot_vec[idx]) {+ t = self.knot_vec[idx];+ self.knot_vec.multiplicity(idx)+ } else {+ 0+ };++ for _ in s..=degree {+ self.add_knot(t);+ }++ let k = self.knot_vec.floor(t).unwrap();+ let m = self.knot_vec.len();+ let n = self.control_points.len();+ let knot_vec0 = self.knot_vec.sub_vec(0..=k);+ let knot_vec1 = self.knot_vec.sub_vec((k - degree)..m);+ let control_points0 = Vec::from(&self.control_points[0..(k - degree)]);+ let control_points1 = Vec::from(&self.control_points[(k - degree)..n]);+ *self = BSplineCurve::new_unchecked(knot_vec0, control_points0);+ BSplineCurve::new_unchecked(knot_vec1, control_points1)+ }+}++#[test]+fn cut_random_test() {+ let curve = BSplineCurve::new(+ KnotVec::uniform_knot(4, 4),+ (0..8)+ .map(|_| {+ Point3::new(+ rand::random::<f64>(),+ rand::random::<f64>(),+ rand::random::<f64>(),+ )+ })+ .collect(),+ );+ truck_geotrait::cut_random_test(&curve, 10);+}++impl<P: ControlPoint<f64> + Tolerance> Concat<BSplineCurve<P>> for BSplineCurve<P> {+ type Output = BSplineCurve<P>;+ /// Concats two B-spline curves.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// ```+ /// # Failure+ /// If the back of the knot vector of `self` does not coincides with the front of the one of `other`,+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geotrait::traits::ConcatError;+ ///+ /// let knot_vec0 = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);+ /// let ctrl_pts0 = vec![Vector2::new(0.0, 0.0), Vector2::new(1.0, 1.0)];+ /// let mut bspcurve0 = BSplineCurve::new(knot_vec0, ctrl_pts0);+ /// let knot_vec1 = KnotVec::from(vec![2.0, 2.0, 3.0, 3.0]);+ /// let ctrl_pts1 = vec![Vector2::new(1.0, 1.0), Vector2::new(2.0, 2.0)];+ /// let mut bspcurve1 = BSplineCurve::new(knot_vec1, ctrl_pts1);+ ///+ /// assert_eq!(bspcurve0.try_concat(&mut bspcurve1), Err(ConcatError::DisconnectedParameters(1.0, 2.0)));+ /// ```+ fn try_concat(&self, other: &BSplineCurve<P>) -> std::result::Result<Self, ConcatError<P>> {+ let mut curve0 = self.clone();+ let mut curve1 = other.clone();+ curve0.syncro_degree(&mut curve1);+ curve0.clamp();+ curve1.clamp();+ curve0+ .knot_vec+ .try_concat(&curve1.knot_vec, curve0.degree())+ .map_err(|err| match err {+ Error::DifferentBackFront(a, b) => ConcatError::DisconnectedParameters(a, b),+ _ => unreachable!(),+ })?;+ let front = curve0.control_points.last().unwrap();+ let back = curve1.control_points.first().unwrap();+ if !front.near(back) {+ return Err(ConcatError::DisconnectedPoints(*front, *back));+ }+ curve0.control_points.extend(curve1.control_points);+ Ok(curve0)+ }+}++#[test]+fn concat_positive_test() {+ let mut part0 = BSplineCurve::new(+ KnotVec::uniform_knot(4, 4),+ (0..8)+ .map(|_| {+ Point3::new(+ rand::random::<f64>(),+ rand::random::<f64>(),+ rand::random::<f64>(),+ )+ })+ .collect(),+ );+ let part1 = part0.cut(0.56);+ concat_random_test(&part0, &part1, 10);+}++#[test]+fn concat_negative_test() {+ let curve0 = BSplineCurve::new(+ KnotVec::bezier_knot(1),+ vec![Point2::new(0.0, 0.0), Point2::new(0.0, 1.0)],+ );+ let mut curve1 = BSplineCurve::new(+ KnotVec::bezier_knot(1),+ vec![Point2::new(1.0, 1.0), Point2::new(1.0, 1.0)],+ );+ assert_eq!(+ curve0.try_concat(&curve1),+ Err(ConcatError::DisconnectedParameters(1.0, 0.0))+ );+ curve1.knot_translate(1.0);+ assert_eq!(+ curve0.try_concat(&curve1),+ Err(ConcatError::DisconnectedPoints(+ Point2::new(0.0, 1.0),+ Point2::new(1.0, 1.0)+ ))+ );+}++impl<P> ParameterDivision1D for BSplineCurve<P>+where P: ControlPoint<f64>+ + EuclideanSpace<Scalar = f64, Diff = <P as ControlPoint<f64>>::Diff>+ + MetricSpace<Metric = f64>+ + HashGen<f64>+{+ type Point = P;+ fn parameter_division(&self, range: (f64, f64), tol: f64) -> (Vec<f64>, Vec<P>) {+ algo::curve::parameter_division(self, range, tol)+ }+}++impl<P> BSplineCurve<P>+where+ P: ControlPoint<f64>+ + EuclideanSpace<Scalar = f64, Diff = <P as ControlPoint<f64>>::Diff>+ + MetricSpace<Metric = f64>+ + Tolerance,+ <P as ControlPoint<f64>>::Diff: InnerSpace<Scalar = f64> + Tolerance,+{+ /// Determines whether `self` is an arc of `curve` by repeating applying Newton method.+ ///+ /// The parameter `hint` is the init value, required that `curve.subs(hint)` is the front point of `self`.+ ///+ /// If `self` is an arc of `curve`, then returns `Some(t)` such that `curve.subs(t)` coincides with+ /// the back point of `self`. Otherwise, returns `None`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::from(+ /// vec![0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0]+ /// );+ /// let ctrl_pts = vec![+ /// Point3::new(0.0, 0.0, 0.0),+ /// Point3::new(1.0, 0.0, 0.0),+ /// Point3::new(1.0, 1.0, 0.0),+ /// Point3::new(0.0, 1.0, 0.0),+ /// Point3::new(0.0, 1.0, 1.0),+ /// ];+ /// let bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ ///+ /// let mut part = bspcurve.clone().cut(0.6);+ /// part.cut(2.8);+ /// let t = part.is_arc_of(&bspcurve, 0.6).unwrap();+ /// assert_near!(t, 2.8);+ ///+ /// // hint is required the init value.+ /// assert!(part.is_arc_of(&bspcurve, 0.7).is_none());+ ///+ /// // normal failure+ /// *part.control_point_mut(2) += Vector3::new(1.0, 2.0, 3.0);+ /// assert!(part.is_arc_of(&bspcurve, 0.6).is_none());+ /// ```+ pub fn is_arc_of(&self, curve: &BSplineCurve<P>, mut hint: f64) -> Option<f64> {+ let degree = std::cmp::max(self.degree(), curve.degree()) * 3 + 1;+ let (knots, _) = self.knot_vec.to_single_multi();+ if !self.subs(knots[0]).near(&curve.subs(hint)) {+ return None;+ }++ for i in 1..knots.len() {+ let range = knots[i] - knots[i - 1];+ for j in 1..=degree {+ let t = knots[i - 1] + range * (j as f64) / (degree as f64);+ let pt = ParametricCurve::subs(self, t);+ let res = curve.search_nearest_parameter(pt, Some(hint), 100);+ let flag = res.map(|res| hint <= res && curve.subs(res).near(&pt));+ hint = match flag {+ Some(true) => res.unwrap(),+ _ => return None,+ };+ }+ }+ Some(hint)+ }+}+impl<P> SearchNearestParameter<D1> for BSplineCurve<P>+where+ P: ControlPoint<f64>+ + EuclideanSpace<Scalar = f64, Diff = <P as ControlPoint<f64>>::Diff>+ + MetricSpace<Metric = f64>+ + Tolerance,+ <P as ControlPoint<f64>>::Diff: InnerSpace<Scalar = f64> + Tolerance,+{+ type Point = P;+ /// Searches the parameter `t` which minimize |self(t) - point| by Newton's method with initial guess `hint`.+ /// Returns `None` if the number of attempts exceeds `trial` i.e. if `trial == 0`, then the trial is only one time.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::from(+ /// vec![0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0]+ /// );+ /// let ctrl_pts = vec![+ /// Point3::new(0.0, 0.0, 0.0),+ /// Point3::new(1.0, 0.0, 0.0),+ /// Point3::new(1.0, 1.0, 0.0),+ /// Point3::new(0.0, 1.0, 0.0),+ /// Point3::new(0.0, 1.0, 1.0),+ /// ];+ /// let bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let pt = ParametricCurve::subs(&bspcurve, 1.2);+ /// let t = bspcurve.search_nearest_parameter(pt, Some(0.8), 100).unwrap();+ /// assert_near!(t, 1.2);+ /// ```+ /// # Remarks+ /// It may converge to a local solution depending on the hint.+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::from(+ /// vec![0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0]+ /// );+ /// let ctrl_pts = vec![+ /// Point3::new(0.0, 0.0, 0.0),+ /// Point3::new(1.0, 0.0, 0.0),+ /// Point3::new(1.0, 1.0, 0.0),+ /// Point3::new(0.0, 1.0, 0.0),+ /// Point3::new(0.0, 1.0, 1.0),+ /// ];+ /// let bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ /// let pt = Point3::new(0.0, 0.5, 1.0);+ /// let t = bspcurve.search_nearest_parameter(pt, Some(0.8), 100).unwrap();+ /// let pt0 = ParametricCurve::subs(&bspcurve, t);+ /// let pt1 = ParametricCurve::subs(&bspcurve, 3.0);+ /// // the point corresponding the obtained parameter is not+ /// // the globally nearest point in the curve.+ /// assert!((pt0 - pt).magnitude() > (pt1 - pt).magnitude());+ /// ```+ #[inline(always)]+ fn search_nearest_parameter<H: Into<SPHint1D>>(+ &self,+ point: P,+ hint: H,+ trial: usize,+ ) -> Option<f64> {+ let hint = match hint.into() {+ SPHint1D::Parameter(hint) => hint,+ SPHint1D::Range(x, y) => {+ algo::curve::presearch(self, point, (x, y), PRESEARCH_DIVISION)+ }+ SPHint1D::None => {+ algo::curve::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::curve::search_nearest_parameter(self, point, hint, trial)+ }+}+impl<P> SearchParameter<D1> for BSplineCurve<P>+where+ P: ControlPoint<f64>+ + EuclideanSpace<Scalar = f64, Diff = <P as ControlPoint<f64>>::Diff>+ + MetricSpace<Metric = f64>,+ <P as ControlPoint<f64>>::Diff: InnerSpace<Scalar = f64> + Tolerance,+{+ type Point = P;+ #[inline(always)]+ fn search_parameter<H: Into<SPHint1D>>(&self, point: P, hint: H, trial: usize) -> Option<f64> {+ let hint = match hint.into() {+ SPHint1D::Parameter(hint) => hint,+ SPHint1D::Range(x, y) => {+ algo::curve::presearch(self, point, (x, y), PRESEARCH_DIVISION)+ }+ SPHint1D::None => {+ algo::curve::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::curve::search_parameter(self, point, hint, trial)+ }+}++impl<P: Bounded> BSplineCurve<P> {+ /// Returns the bounding box including all control points.+ #[inline(always)]+ pub fn roughly_bounding_box(&self) -> BoundingBox<P> { self.control_points.iter().collect() }+}++impl<P: Clone> Invertible for BSplineCurve<P> {+ #[inline(always)]+ fn invert(&mut self) { self.invert(); }+}++impl<M, P> Transformed<M> for BSplineCurve<P>+where+ P: EuclideanSpace,+ M: Transform<P>,+{+ #[inline(always)]+ fn transform_by(&mut self, trans: M) {+ self.control_points+ .iter_mut()+ .for_each(|pt| *pt = trans.transform_point(*pt))+ }+}++impl<'de, P> Deserialize<'de> for BSplineCurve<P>+where P: Deserialize<'de>+{+ fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>+ where D: serde::Deserializer<'de> {+ #[derive(Deserialize)]+ struct BSplineCurve_<P> {+ knot_vec: KnotVec,+ control_points: Vec<P>,+ }+ let BSplineCurve_ {+ knot_vec,+ control_points,+ } = BSplineCurve_::<P>::deserialize(deserializer)?;+ Self::try_new(knot_vec, control_points).map_err(serde::de::Error::custom)+ }+}++#[test]+fn test_near_as_curve() {+ let knot_vec = KnotVec::from(vec![+ 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 5.0, 5.0,+ ]);+ let control_points = vec![+ Vector4::new(1.0, 0.0, 0.0, 0.0),+ Vector4::new(0.0, 1.0, 0.0, 0.0),+ Vector4::new(0.0, 0.0, 1.0, 0.0),+ Vector4::new(0.0, 0.0, 0.0, 1.0),+ Vector4::new(1.0, 1.0, 0.0, 0.0),+ Vector4::new(1.0, 0.0, 1.0, 0.0),+ Vector4::new(1.0, 0.0, 0.0, 1.0),+ Vector4::new(1.0, 1.0, 1.0, 0.0),+ ];+ let bspline0 = BSplineCurve::new(knot_vec, control_points.clone());+ let knot_vec = KnotVec::from(vec![+ 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 2.5, 3.0, 4.0, 5.0, 5.0, 5.0, 5.0,+ ]);+ let control_points = vec![+ control_points[0],+ control_points[1],+ control_points[2],+ control_points[3] * (5.0 / 6.0) + control_points[2] * (1.0 / 6.0),+ control_points[4] * 0.5 + control_points[3] * 0.5,+ control_points[5] * (1.0 / 6.0) + control_points[4] * (5.0 / 6.0),+ control_points[5],+ control_points[6],+ control_points[7],+ ];+ let bspline1 = BSplineCurve::new(knot_vec, control_points);+ let knot_vec = KnotVec::from(vec![+ 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 5.0, 5.0,+ ]);+ let control_points = vec![+ Vector4::new(1.0, 0.0, 0.0, 0.0),+ Vector4::new(0.0, 1.0, 0.0, 0.0),+ Vector4::new(0.0, 0.0, 1.0, 0.0),+ Vector4::new(0.0, 0.0, 0.0, 1.0),+ Vector4::new(1.0, 1.01, 0.0, 0.0),+ Vector4::new(1.0, 0.0, 1.0, 0.0),+ Vector4::new(1.0, 0.0, 0.0, 1.0),+ Vector4::new(1.0, 1.0, 1.0, 0.0),+ ];+ let bspline2 = BSplineCurve::new(knot_vec, control_points);+ assert!(bspline0.near_as_curve(&bspline1));+ assert!(!bspline0.near_as_curve(&bspline2));+}++#[test]+fn test_parameter_division() {+ let knot_vec = KnotVec::uniform_knot(2, 3);+ let ctrl_pts = vec![+ Point3::new(0.0, 0.0, 0.0),+ Point3::new(1.0, 0.0, 0.0),+ Point3::new(0.0, 1.0, 0.0),+ Point3::new(0.0, 0.0, 1.0),+ Point3::new(1.0, 1.0, 1.0),+ ];+ let bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ let tol = 0.01;+ let (div, pts) = bspcurve.parameter_division(bspcurve.range_tuple(), tol);+ let knot_vec = bspcurve.knot_vec();+ assert_eq!(knot_vec[0], div[0]);+ assert_eq!(knot_vec.range_length(), div.last().unwrap() - div[0]);+ for i in 1..div.len() {+ let pt0 = bspcurve.subs(div[i - 1]);+ assert_eq!(pt0, pts[i - 1]);+ let pt1 = bspcurve.subs(div[i]);+ assert_eq!(pt1, pts[i]);+ let value_middle = pt0 + (pt1 - pt0) / 2.0;+ let param_middle = bspcurve.subs((div[i - 1] + div[i]) / 2.0);+ assert!(value_middle.distance(param_middle) < tol);+ }+}++impl<P> BSplineCurve<P>+where+ P: ControlPoint<f64>+ + EuclideanSpace<Scalar = f64, Diff = <P as ControlPoint<f64>>::Diff>+ + MetricSpace<Metric = f64>+ + Tolerance+ + HashGen<f64>,+ <P as ControlPoint<f64>>::Diff: InnerSpace<Scalar = f64> + Tolerance,+{+ fn cubic_bezier_interpolation(+ pt0: P,+ pt1: P,+ der0: <P as EuclideanSpace>::Diff,+ der1: <P as EuclideanSpace>::Diff,+ range: (f64, f64),+ ) -> Self {+ let width = range.1 - range.0;+ let mut knot_vec = KnotVec::bezier_knot(3);+ knot_vec.transform(width, range.0);+ Self::debug_new(+ knot_vec,+ vec![pt0, pt0 + der0 * width / 3.0, pt1 - der1 * width / 3.0, pt1],+ )+ }++ fn sub_cubic_approximation<C>(+ curve: &C,+ range: (f64, f64),+ ends: (P, P),+ enders: (<P as EuclideanSpace>::Diff, <P as EuclideanSpace>::Diff),+ p_tol: f64,+ d_tol: f64,+ trialis: usize,+ ) -> Option<Self>+ where+ C: ParametricCurve<Point = P, Vector = <P as EuclideanSpace>::Diff>,+ {+ let bezier = Self::cubic_bezier_interpolation(ends.0, ends.1, enders.0, enders.1, range);+ let gen = ends.0.midpoint(ends.1);+ let p = 0.5 + (0.2 * HashGen::hash1(gen) - 0.1);+ let t = range.0 * (1.0 - p) + range.1 * p;+ let pt0 = bezier.subs(t);+ let pt1 = curve.subs(t);+ let der0 = bezier.der(t);+ let der1 = curve.der(t);+ let pt_dist2 = pt0.distance2(pt1);+ let der_dist2 = (der0 - der1).magnitude2();+ if pt_dist2 > p_tol * p_tol || der_dist2 > d_tol * d_tol {+ if trialis == 0 {+ return None;+ }+ let t = (range.0 + range.1) / 2.0;+ let pt = curve.subs(t);+ let der = curve.der(t);+ let bspcurve0 = Self::sub_cubic_approximation(+ curve,+ (range.0, t),+ (ends.0, pt),+ (enders.0, der),+ p_tol,+ d_tol,+ trialis - 1,+ );+ let bspcurve1 = Self::sub_cubic_approximation(+ curve,+ (t, range.1),+ (pt, ends.1),+ (der, enders.1),+ p_tol,+ d_tol,+ trialis - 1,+ );+ match (bspcurve0, bspcurve1) {+ (Some(x), Some(y)) => x.try_concat(&y).ok(),+ _ => None,+ }+ } else {+ Some(bezier)+ }+ }++ /// C^1-approximation for `curve` by cubic Bspline curve.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use std::f64::consts::PI;+ /// let circle = UnitCircle::<Point2>::new();+ /// let bspcurve = BSplineCurve::cubic_approximation(&circle, (-PI, PI), 0.01, 0.01, 10).unwrap();+ /// println!("{bspcurve:?}");+ ///+ /// const N: usize = 100;+ /// for i in 0..N {+ /// let t = i as f64 / N as f64;+ /// assert!(circle.subs(t).distance(bspcurve.subs(t)) < 0.02);+ /// assert!((circle.der(t) - bspcurve.der(t)).magnitude() < 0.02);+ /// }+ /// ```+ pub fn cubic_approximation<C>(+ curve: &C,+ range: (f64, f64),+ p_tol: f64,+ d_tol: f64,+ trials: usize,+ ) -> Option<Self>+ where+ C: ParametricCurve<Point = P, Vector = <P as EuclideanSpace>::Diff>,+ {+ let ends = (curve.subs(range.0), curve.subs(range.1));+ let enders = (curve.der(range.0), curve.der(range.1));+ Self::sub_cubic_approximation(curve, range, ends, enders, p_tol, d_tol, trials).map(+ |mut x| {+ x.optimize();+ x+ },+ )+ }+}++#[test]+fn cubic_bezier_interpolation_test() {+ let pt0 = Point2::new(0.0, 0.0);+ let pt1 = Point2::new(1.0, 0.0);+ let der0 = Vector2::new(0.5, 1.0);+ let der1 = Vector2::new(0.5, -1.0);+ let bspcurve = BSplineCurve::cubic_bezier_interpolation(pt0, pt1, der0, der1, (1.23, 3.45));+ let der = bspcurve.derivation();+ assert_near!(bspcurve.front(), pt0);+ assert_near!(bspcurve.back(), pt1);+ assert_near!(der.front(), der0);+ assert_near!(der.back(), der1);+}diff --git a/vendor/truck-geometry/src/nurbs/bspsurface.rs b/vendor/truck-geometry/src/nurbs/bspsurface.rsnew file mode 100644index 0000000000..fcedac201e--- /dev/null+++ b/vendor/truck-geometry/src/nurbs/bspsurface.rs@@ -0,0 +1,2230 @@+use super::*;+use crate::errors::Error;+use std::iter::FusedIterator;+use std::ops::*;++impl<P> BSplineSurface<P> {+ /// constructor.+ /// # Arguments+ /// * `knot_vecs` - the knot vectors+ /// * `control_points` - the vector of the control points+ /// # Panics+ /// There are 3 rules for construct B-spline curve.+ /// * The number of knots is more than the one of control points.+ /// * There exist at least two different knots.+ /// * There are at least one control point.+ #[inline(always)]+ pub fn new(knot_vecs: (KnotVec, KnotVec), control_points: Vec<Vec<P>>) -> BSplineSurface<P> {+ BSplineSurface::try_new(knot_vecs, control_points).unwrap_or_else(|e| panic!("{}", e))+ }++ /// constructor.+ /// # Arguments+ /// * `knot_vecs` - the knot vectors+ /// * `control_points` - the vector of the control points+ /// # Failures+ /// There are 3 rules for construct B-spline curve.+ /// * The number of knots is more than the one of control points.+ /// * There exist at least two different knots.+ /// * There are at least one control point.+ #[inline(always)]+ pub fn try_new(+ knot_vecs: (KnotVec, KnotVec),+ control_points: Vec<Vec<P>>,+ ) -> Result<BSplineSurface<P>> {+ if control_points.is_empty() || control_points[0].is_empty() {+ Err(Error::EmptyControlPoints)+ } else if knot_vecs.0.len() <= control_points.len() {+ Err(Error::TooShortKnotVector(+ knot_vecs.0.len(),+ control_points.len(),+ ))+ } else if knot_vecs.1.len() <= control_points[0].len() {+ Err(Error::TooShortKnotVector(+ knot_vecs.1.len(),+ control_points[0].len(),+ ))+ } else if knot_vecs.0.range_length().so_small() || knot_vecs.1.range_length().so_small() {+ Err(Error::ZeroRange)+ } else {+ let len = control_points[0].len();+ if control_points.iter().any(|vec| vec.len() != len) {+ Err(Error::IrregularControlPoints)+ } else {+ Ok(BSplineSurface::new_unchecked(knot_vecs, control_points))+ }+ }+ }++ /// constructor.+ /// # Arguments+ /// * `knot_vecs` - the knot vectors+ /// * `control_points` - the vector of the control points+ /// # Failures+ /// This method is prepared only for performance-critical development and is not recommended.+ /// This method does NOT check the 3 rules for constructing B-spline surface.+ /// The programmer must guarantee these conditions before using this method.+ #[inline(always)]+ pub const fn new_unchecked(+ knot_vecs: (KnotVec, KnotVec),+ control_points: Vec<Vec<P>>,+ ) -> BSplineSurface<P> {+ BSplineSurface {+ knot_vecs,+ control_points,+ }+ }++ /// constructor.+ /// # Arguments+ /// * `knot_vecs` - the knot vectors+ /// * `control_points` - the vector of the control points+ /// # Failures+ /// This method checks the 3 rules for constructing B-spline surface in the debug mode.+ /// The programmer must guarantee these conditions before using this method.+ #[inline(always)]+ pub fn debug_new(+ knot_vecs: (KnotVec, KnotVec),+ control_points: Vec<Vec<P>>,+ ) -> BSplineSurface<P> {+ match cfg!(debug_assertions) {+ true => Self::new(knot_vecs, control_points),+ false => Self::new_unchecked(knot_vecs, control_points),+ }+ }+ /// Returns the reference of the knot vectors+ #[inline(always)]+ pub const fn knot_vecs(&self) -> &(KnotVec, KnotVec) { &self.knot_vecs }++ /// Returns the u knot vector.+ #[inline(always)]+ pub const fn uknot_vec(&self) -> &KnotVec { &self.knot_vecs.0 }+ /// Returns the v knot vector.+ #[inline(always)]+ pub const fn vknot_vec(&self) -> &KnotVec { &self.knot_vecs.1 }++ /// Returns the `idx`th u knot.+ #[inline(always)]+ pub fn uknot(&self, idx: usize) -> f64 { self.knot_vecs.0[idx] }+ /// returns the `idx`th v knot.+ #[inline(always)]+ pub fn vknot(&self, idx: usize) -> f64 { self.knot_vecs.1[idx] }++ /// Returns the reference of the vector of the control points+ #[inline(always)]+ pub const fn control_points(&self) -> &Vec<Vec<P>> { &self.control_points }++ /// Returns the reference of the control point corresponding to the index `(idx0, idx1)`.+ #[inline(always)]+ pub fn control_point(&self, idx0: usize, idx1: usize) -> &P { &self.control_points[idx0][idx1] }+ /// Apply the given transformation to all control points.+ #[inline(always)]+ pub fn transform_control_points<F: FnMut(&mut P)>(&mut self, f: F) {+ self.control_points.iter_mut().flatten().for_each(f)+ }++ /// Returns the iterator over the control points in the `column_idx`th row.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::bezier_knot(1);+ /// let vknot_vec = KnotVec::bezier_knot(2);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let mut iter = bspsurface.ctrl_pts_row_iter(1);+ /// assert_eq!(iter.next(), Some(&Vector3::new(1.0, 0.0, 1.0)));+ /// assert_eq!(iter.next(), Some(&Vector3::new(1.0, 1.0, 1.0)));+ /// assert_eq!(iter.next(), None);+ /// ```+ #[inline(always)]+ pub fn ctrl_pts_row_iter(+ &self,+ column_idx: usize,+ ) -> impl ExactSizeIterator<Item = &P> + FusedIterator<Item = &P> {+ self.control_points.iter().map(move |vec| &vec[column_idx])+ }++ /// Returns the iterator over the control points in the `row_idx`th row.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::bezier_knot(1);+ /// let vknot_vec = KnotVec::bezier_knot(2);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let mut iter = bspsurface.ctrl_pts_column_iter(1);+ /// assert_eq!(iter.next(), Some(&Vector3::new(0.0, 1.0, 0.0)));+ /// assert_eq!(iter.next(), Some(&Vector3::new(1.0, 1.0, 1.0)));+ /// assert_eq!(iter.next(), Some(&Vector3::new(2.0, 1.0, 2.0)));+ /// assert_eq!(iter.next(), None);+ /// ```+ #[inline(always)]+ pub fn ctrl_pts_column_iter(&self, row_idx: usize) -> std::slice::Iter<'_, P> {+ self.control_points[row_idx].iter()+ }++ /// Returns the mutable reference of the control point corresponding to index `(idx0, idx1)`.+ #[inline(always)]+ pub fn control_point_mut(&mut self, idx0: usize, idx1: usize) -> &mut P {+ &mut self.control_points[idx0][idx1]+ }++ /// Returns the iterator on all control points+ #[inline(always)]+ pub fn control_points_mut(&mut self) -> impl Iterator<Item = &mut P> {+ self.control_points.iter_mut().flatten()+ }+ /// Returns the degrees of B-spline surface+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);+ /// let vknot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// assert_eq!(bspsurface.udegree(), 1);+ /// ```+ #[inline(always)]+ pub fn udegree(&self) -> usize { self.knot_vecs.0.len() - self.control_points.len() - 1 }++ /// Returns the degrees of B-spline surface+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);+ /// let vknot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// assert_eq!(bspsurface.vdegree(), 2);+ /// ```+ #[inline(always)]+ pub fn vdegree(&self) -> usize { self.knot_vecs.1.len() - self.control_points[0].len() - 1 }++ /// Returns the degrees of B-spline surface+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);+ /// let vknot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// assert_eq!(bspsurface.degrees(), (1, 2));+ /// ```+ #[inline(always)]+ pub fn degrees(&self) -> (usize, usize) { (self.udegree(), self.vdegree()) }+ /// Returns whether the knot vectors are clamped or not.+ #[inline(always)]+ pub fn is_clamped(&self) -> bool {+ self.knot_vecs.0.is_clamped(self.udegree()) && self.knot_vecs.1.is_clamped(self.vdegree())+ }++ /// Swaps two parameters.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs0 = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));+ /// let ctrl_pts0 = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// ];+ /// let mut bspsurface0 = BSplineSurface::new(knot_vecs0, ctrl_pts0);+ ///+ /// let knot_vecs1 = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(1));+ /// let ctrl_pts1 = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.0, 1.0)],+ /// vec![Vector2::new(0.5, -1.0), Vector2::new(0.5, 2.0)],+ /// vec![Vector2::new(1.0, 0.0), Vector2::new(1.0, 1.0)],+ /// ];+ /// let mut bspsurface1 = BSplineSurface::new(knot_vecs1, ctrl_pts1);+ /// assert_eq!(bspsurface0.swap_axes(), &bspsurface1);+ /// ```+ pub fn swap_axes(&mut self) -> &mut Self+ where P: Clone {+ let knot_vec = self.knot_vecs.0.clone();+ self.knot_vecs.0 = self.knot_vecs.1.clone();+ self.knot_vecs.1 = knot_vec;++ let n0 = self.control_points.len();+ let n1 = self.control_points[0].len();+ let mut new_points = vec![Vec::with_capacity(n0); n1];+ for pts in &self.control_points {+ for (vec0, pt) in new_points.iter_mut().zip(pts) {+ vec0.push(pt.clone());+ }+ }+ self.control_points = new_points;+ self+ }++ /// The range of the parameter of the surface.+ #[inline(always)]+ pub fn parameter_range(&self) -> (ParameterRange, ParameterRange) {+ (+ (+ Bound::Included(self.knot_vecs.0[0]),+ Bound::Included(self.knot_vecs.0[self.knot_vecs.0.len() - 1]),+ ),+ (+ Bound::Included(self.knot_vecs.1[0]),+ Bound::Included(self.knot_vecs.1[self.knot_vecs.1.len() - 1]),+ ),+ )+ }+ /// Creates the curve whose control points are the `idx`th column control points of `self`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::bezier_knot(1);+ /// let vknot_vec = KnotVec::bezier_knot(2);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let bspcurve = bspsurface.column_curve(1);+ ///+ /// assert_eq!(bspcurve.knot_vec(), &KnotVec::bezier_knot(2));+ /// assert_eq!(+ /// bspcurve.control_points(),+ /// &vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// );+ /// ```+ pub fn column_curve(&self, row_idx: usize) -> BSplineCurve<P>+ where P: Clone {+ let knot_vec = self.vknot_vec().clone();+ let ctrl_pts = self.control_points[row_idx].clone();+ BSplineCurve::new_unchecked(knot_vec, ctrl_pts)+ }+ /// Creates the column sectional curve.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::bezier_knot(1);+ /// let vknot_vec = KnotVec::bezier_knot(2);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let bspcurve = bspsurface.row_curve(1);+ ///+ /// assert_eq!(bspcurve.knot_vec(), &KnotVec::bezier_knot(1));+ /// assert_eq!(+ /// bspcurve.control_points(),+ /// &vec![Vector3::new(1.0, 0.0, 1.0), Vector3::new(1.0, 1.0, 1.0)],+ /// );+ /// ```+ pub fn row_curve(&self, column_idx: usize) -> BSplineCurve<P>+ where P: Clone {+ let knot_vec = self.uknot_vec().clone();+ let ctrl_pts: Vec<_> = self.ctrl_pts_row_iter(column_idx).cloned().collect();+ BSplineCurve::new_unchecked(knot_vec, ctrl_pts)+ }+}++impl<P: ControlPoint<f64>> BSplineSurface<P> {+ /// Returns the closure of substitution.+ #[inline(always)]+ pub fn get_closure(&self) -> impl Fn(f64, f64) -> P + '_ { move |u, v| self.subs(u, v) }++ #[inline(always)]+ fn udelta_control_points(&self, i: usize, j: usize) -> P::Diff {+ if i == 0 {+ self.control_point(i, j).to_vec()+ } else if i == self.control_points.len() {+ self.control_point(i - 1, j).to_vec() * (-1.0)+ } else {+ *self.control_point(i, j) - *self.control_point(i - 1, j)+ }+ }++ #[inline(always)]+ fn udelta2_control_points(&self, i: usize, j: usize) -> P::Diff {+ let k = self.udegree();+ let knot_vec = self.uknot_vec();+ if i == 0 {+ let coef = inv_or_zero(knot_vec[i + k] - knot_vec[i]);+ self.udelta_control_points(i, j) * coef+ } else if i == self.control_points.len() + 1 {+ let coef = inv_or_zero(knot_vec[i - 1 + k] - knot_vec[i - 1]);+ self.udelta_control_points(i - 1, j) * (-coef)+ } else {+ let coef0 = inv_or_zero(knot_vec[i + k] - knot_vec[i]);+ let coef1 = inv_or_zero(knot_vec[i - 1 + k] - knot_vec[i - 1]);+ self.udelta_control_points(i, j) * coef0 - self.udelta_control_points(i - 1, j) * coef1+ }+ }++ #[inline(always)]+ fn vdelta_control_points(&self, i: usize, j: usize) -> P::Diff {+ if j == 0 {+ self.control_point(i, j).to_vec()+ } else if j == self.control_points[0].len() {+ self.control_point(i, j - 1).to_vec() * (-1.0)+ } else {+ *self.control_point(i, j) - *self.control_point(i, j - 1)+ }+ }++ #[inline(always)]+ fn vdelta2_control_points(&self, i: usize, j: usize) -> P::Diff {+ let k = self.vdegree();+ let knot_vec = self.vknot_vec();+ if j == 0 {+ let coef = inv_or_zero(knot_vec[j + k] - knot_vec[j]);+ self.vdelta_control_points(i, j) * coef+ } else if j == self.control_points[0].len() + 1 {+ let coef = inv_or_zero(knot_vec[j - 1 + k] - knot_vec[j - 1]);+ self.vdelta_control_points(i, j - 1) * (-coef)+ } else {+ let coef0 = inv_or_zero(knot_vec[j + k] - knot_vec[j]);+ let coef1 = inv_or_zero(knot_vec[j - 1 + k] - knot_vec[j - 1]);+ self.vdelta_control_points(i, j) * coef0 - self.vdelta_control_points(i, j - 1) * coef1+ }+ }++ /// Calculate derived B-spline surface by the first parameter `u`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let uderivation = bspsurface.uderivation();+ ///+ /// // bspsurface: (v, 2v(1 - v)(2u - 1) + u), uderivation: (0.0, 4v(1 - v) + 1)+ /// const N: usize = 100; // sample size+ /// for i in 1..N {+ /// let u = (i as f64) / (N as f64);+ /// for j in 0..=N {+ /// let v = (j as f64) / (N as f64);+ /// assert_near2!(+ /// uderivation.subs(u, v),+ /// Vector2::new(0.0, 4.0 * v * (1.0 - v) + 1.0),+ /// );+ /// }+ /// }+ /// ```+ pub fn uderivation(&self) -> BSplineSurface<P::Diff> {+ let n0 = self.control_points.len();+ let n1 = self.control_points[0].len();+ let (k, _) = self.degrees();+ let (uknot_vec, vknot_vec) = self.knot_vecs.clone();++ let new_points = if k > 0 {+ (0..=n0)+ .map(|i| {+ let delta = uknot_vec[i + k] - uknot_vec[i];+ let coef = (k as f64) * inv_or_zero(delta);+ (0..n1)+ .map(|j| self.udelta_control_points(i, j) * coef)+ .collect()+ })+ .collect()+ } else {+ vec![vec![P::Diff::zero(); n1]; n0]+ };++ BSplineSurface::new_unchecked((uknot_vec, vknot_vec), new_points)+ }++ /// Calculate derived B-spline surface by the second parameter `v`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let vderivation = bspsurface.vderivation();+ ///+ /// // bspsurface: (v, 2v(1 - v)(2u - 1) + u), vderivation: (1, -2(2u - 1)(2v - 1))+ /// const N: usize = 100; // sample size+ /// for i in 0..=N {+ /// let u = (i as f64) / (N as f64);+ /// for j in 0..=N {+ /// let v = (j as f64) / (N as f64);+ /// assert_near2!(+ /// vderivation.subs(u, v),+ /// Vector2::new(1.0, -2.0 * (2.0 * u - 1.0) * (2.0 * v - 1.0)),+ /// );+ /// }+ /// }+ /// ```+ pub fn vderivation(&self) -> BSplineSurface<P::Diff> {+ let n0 = self.control_points.len();+ let n1 = self.control_points[0].len();+ let (_, k) = self.degrees();++ let (uknot_vec, vknot_vec) = self.knot_vecs.clone();++ let new_points = if k > 0 {+ let mut new_points = vec![Vec::with_capacity(n1 + 1); n0];+ for j in 0..=n1 {+ let delta = vknot_vec[j + k] - vknot_vec[j];+ let coef = (k as f64) * inv_or_zero(delta);+ for (i, vec) in new_points.iter_mut().enumerate() {+ vec.push(self.vdelta_control_points(i, j) * coef)+ }+ }+ new_points+ } else {+ vec![vec![P::Diff::zero(); n1]; n0]+ };++ BSplineSurface::new_unchecked((uknot_vec, vknot_vec), new_points)+ }++ pub(super) fn sub_near_as_surface<F: Fn(&P, &P) -> bool>(+ &self,+ other: &BSplineSurface<P>,+ div_coef: usize,+ ord: F,+ ) -> bool {+ if !self.knot_vecs.0.same_range(&other.knot_vecs.0) {+ return false;+ }+ if !self.knot_vecs.1.same_range(&other.knot_vecs.1) {+ return false;+ }++ let (self_degree0, self_degree1) = self.degrees();+ let (other_degree0, other_degree1) = other.degrees();+ let division0 = std::cmp::max(self_degree0, other_degree0) * div_coef;+ let division1 = std::cmp::max(self_degree1, other_degree1) * div_coef;++ for i0 in 1..self.knot_vecs.0.len() {+ let delta0 = self.knot_vecs.0[i0] - self.knot_vecs.0[i0 - 1];+ if delta0.so_small() {+ continue;+ }+ for j0 in 0..division0 {+ let u = self.knot_vecs.0[i0 - 1] + delta0 * (j0 as f64) / (division0 as f64);+ for i1 in 1..self.knot_vecs.1.len() {+ let delta1 = self.knot_vecs.1[i1] - self.knot_vecs.1[i1 - 1];+ if delta1.so_small() {+ continue;+ }+ for j1 in 0..division1 {+ let v =+ self.knot_vecs.1[i1 - 1] + delta1 * (j1 as f64) / (division1 as f64);+ if !ord(&self.subs(u, v), &other.subs(u, v)) {+ return false;+ }+ }+ }+ }+ }+ true+ }+}++impl<V: Homogeneous<f64>> BSplineSurface<V> {+ /// lift up control points to homogeneous coordinate.+ pub fn lift_up(surface: BSplineSurface<V::Point>) -> Self {+ let control_points = surface+ .control_points+ .into_iter()+ .map(|vec| vec.into_iter().map(V::from_point).collect())+ .collect();+ BSplineSurface::new_unchecked(surface.knot_vecs, control_points)+ }+}++impl<P: ControlPoint<f64>> ParametricSurface for BSplineSurface<P> {+ type Point = P;+ type Vector = P::Diff;+ /// Substitutes to a B-spline surface.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ ///+ /// // bspsurface: (v, 2v(1 - v)(2u - 1) + u)+ /// const N: usize = 100; // sample size+ /// for i in 0..=N {+ /// let u = (i as f64) / (N as f64);+ /// for j in 0..=N {+ /// let v = (j as f64) / (N as f64);+ /// assert_near2!(+ /// bspsurface.subs(u, v),+ /// Vector2::new(v, 2.0 * v * (1.0 - v) * (2.0 * u - 1.0) + u),+ /// );+ /// }+ /// }+ /// ```+ #[inline(always)]+ fn subs(&self, u: f64, v: f64) -> P {+ let (degree0, degree1) = self.degrees();+ let BSplineSurface {+ knot_vecs: (ref uknot_vec, ref vknot_vec),+ ref control_points,+ } = self;+ let basis0 = uknot_vec.bspline_basis_functions(degree0, u);+ let basis1 = vknot_vec.bspline_basis_functions(degree1, v);+ let closure = move |sum: P, (vec, b0): (&Vec<P>, f64)| {+ let closure = move |sum: P, (pt, b1): (&P, &f64)| sum + pt.to_vec() * (b0 * b1);+ vec.iter().zip(&basis1).fold(sum, closure)+ };+ control_points.iter().zip(basis0).fold(P::origin(), closure)+ }+ /// Substitutes derived B-spline surface by the first parameter `u`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ ///+ /// // bspsurface: (v, 2v(1 - v)(2u - 1) + u), uderivation: (0.0, 4v(1 - v) + 1)+ /// const N: usize = 100; // sample size+ /// for i in 0..=N {+ /// let u = (i as f64) / (N as f64);+ /// for j in 0..=N {+ /// let v = (j as f64) / (N as f64);+ /// assert_near2!(+ /// bspsurface.uder(u, v),+ /// Vector2::new(0.0, 4.0 * v * (1.0 - v) + 1.0),+ /// );+ /// }+ /// }+ /// ```+ #[inline(always)]+ fn uder(&self, u: f64, v: f64) -> P::Diff {+ let (degree0, degree1) = self.degrees();+ let (uknot_vec, vknot_vec) = self.knot_vecs();+ let basis0 = uknot_vec.bspline_basis_functions(degree0 - 1, u);+ let basis1 = vknot_vec.bspline_basis_functions(degree1, v);+ let closure = move |sum: P::Diff, (i, b0): (usize, f64)| {+ let coef = inv_or_zero(uknot_vec[i + degree0] - uknot_vec[i]);+ let closure = |sum: P::Diff, (j, b1): (usize, &f64)| {+ sum + self.udelta_control_points(i, j) * coef * b0 * *b1+ };+ basis1.iter().enumerate().fold(sum, closure)+ };+ basis0+ .into_iter()+ .enumerate()+ .fold(P::Diff::zero(), closure)+ * degree0 as f64+ }+ /// Substitutes derived B-spline surface by the first parameter `v`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ ///+ /// // bspsurface: (v, 2v(1 - v)(2u - 1) + u), vderivation: (1, -2(2u - 1)(2v - 1))+ /// const N: usize = 100; // sample size+ /// for i in 0..=N {+ /// let u = (i as f64) / (N as f64);+ /// for j in 0..=N {+ /// let v = (j as f64) / (N as f64);+ /// assert_near2!(+ /// bspsurface.vder(u, v),+ /// Vector2::new(1.0, -2.0 * (2.0 * u - 1.0) * (2.0 * v - 1.0)),+ /// );+ /// }+ /// }+ /// ```+ #[inline(always)]+ fn vder(&self, u: f64, v: f64) -> P::Diff {+ let (degree0, degree1) = self.degrees();+ let (uknot_vec, vknot_vec) = self.knot_vecs();+ let basis0 = uknot_vec.bspline_basis_functions(degree0, u);+ let basis1 = vknot_vec.bspline_basis_functions(degree1 - 1, v);+ let closure = move |sum: P::Diff, (i, b0): (usize, f64)| {+ let coef = inv_or_zero(vknot_vec[i + degree1] - vknot_vec[i]);+ let closure = |sum: P::Diff, (j, b1): (usize, &f64)| {+ sum + self.vdelta_control_points(j, i) * coef * b0 * *b1+ };+ basis0.iter().enumerate().fold(sum, closure)+ };+ basis1+ .into_iter()+ .enumerate()+ .fold(P::Diff::zero(), closure)+ * degree1 as f64+ }++ /// Substitutes 2nd-ord derived B-spline surface by the first parameter `u`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 0.5), Vector2::new(0.5, 1.0), Vector2::new(1.0, 0.5)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ ///+ /// // bspsurface: (v, 2 u^2 v^2 - 2 u^2 v - 6 u v^2 + 6uv + 2v^2 + u - 2v)+ /// // uuder: (0, 4v(v - 1))+ /// const N: usize = 100; // sample size+ /// for i in 0..=N {+ /// let u = (i as f64) / (N as f64);+ /// for j in 0..=N {+ /// let v = (j as f64) / (N as f64);+ /// assert_near2!(+ /// bspsurface.uuder(u, v),+ /// Vector2::new(0.0, 4.0 * v * (v - 1.0)),+ /// );+ /// }+ /// }+ /// ```+ #[inline(always)]+ fn uuder(&self, u: f64, v: f64) -> P::Diff {+ let (degree0, degree1) = self.degrees();+ if degree0 < 2 {+ return P::Diff::zero();+ }+ let (uknot_vec, vknot_vec) = self.knot_vecs();+ let basis0 = uknot_vec.bspline_basis_functions(degree0 - 2, u);+ let basis1 = vknot_vec.bspline_basis_functions(degree1, v);+ let closure = move |sum: P::Diff, (i, b0): (usize, f64)| {+ let coef = inv_or_zero(uknot_vec[i + degree0 - 1] - uknot_vec[i]);+ let closure = |sum: P::Diff, (j, b1): (usize, &f64)| {+ sum + self.udelta2_control_points(i, j) * coef * b0 * *b1+ };+ basis1.iter().enumerate().fold(sum, closure)+ };+ basis0+ .into_iter()+ .enumerate()+ .fold(P::Diff::zero(), closure)+ * degree0 as f64+ }++ /// Substitutes 2nd-ord derived B-spline surface by the second parameter `v`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 0.5), Vector2::new(0.5, 1.0), Vector2::new(1.0, 0.5)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ ///+ /// // bspsurface: (v, 2 u^2 v^2 - 2 u^2 v - 6 u v^2 + 6uv + 2v^2 + u - 2v)+ /// // vvder: (0, 4(u^2 - 3u + 1))+ /// const N: usize = 100; // sample size+ /// for i in 0..=N {+ /// let u = (i as f64) / (N as f64);+ /// for j in 0..=N {+ /// let v = (j as f64) / (N as f64);+ /// assert_near2!(+ /// bspsurface.vvder(u, v),+ /// Vector2::new(0.0, 4.0 * (u * u - 3.0 * u + 1.0)),+ /// );+ /// }+ /// }+ /// ```+ #[inline(always)]+ fn vvder(&self, u: f64, v: f64) -> P::Diff {+ let (degree0, degree1) = self.degrees();+ if degree1 < 2 {+ return P::Diff::zero();+ }+ let (uknot_vec, vknot_vec) = self.knot_vecs();+ let basis0 = uknot_vec.bspline_basis_functions(degree0, u);+ let basis1 = vknot_vec.bspline_basis_functions(degree1 - 2, v);+ let closure = move |sum: P::Diff, (j, b0): (usize, f64)| {+ let coef = inv_or_zero(vknot_vec[j + degree1 - 1] - vknot_vec[j]);+ let closure = |sum: P::Diff, (i, b1): (usize, &f64)| {+ sum + self.vdelta2_control_points(i, j) * coef * b0 * *b1+ };+ basis0.iter().enumerate().fold(sum, closure)+ };+ basis1+ .into_iter()+ .enumerate()+ .fold(P::Diff::zero(), closure)+ * degree1 as f64+ }++ /// Substitutes 2nd-ord derived B-spline surface by the both parameters `u, v`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 0.5), Vector2::new(0.5, 1.0), Vector2::new(1.0, 0.5)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ ///+ /// // bspsurface: (v, 2 u^2 v^2 - 2 u^2 v - 6 u v^2 + 6uv + 2v^2 + u - 2v)+ /// // uvder: (0, 8uv - 4u - 12v + 6)+ /// const N: usize = 100; // sample size+ /// for i in 0..=N {+ /// let u = (i as f64) / (N as f64);+ /// for j in 0..=N {+ /// let v = (j as f64) / (N as f64);+ /// assert_near2!(+ /// bspsurface.uvder(u, v),+ /// Vector2::new(0.0, 8.0 * u * v - 4.0 * u - 12.0 * v + 6.0),+ /// );+ /// }+ /// }+ /// ```+ #[inline(always)]+ fn uvder(&self, u: f64, v: f64) -> P::Diff {+ let (degree0, degree1) = self.degrees();+ let BSplineSurface {+ knot_vecs: (ref uknot_vec, ref vknot_vec),+ ref control_points,+ } = self;+ let basis0 = uknot_vec.bspline_basis_functions(degree0 - 1, u);+ let basis1 = vknot_vec.bspline_basis_functions(degree1 - 1, v);+ let closure = |sum: P::Diff, (i, vec): (usize, &Vec<P>)| {+ let coef0 = inv_or_zero(uknot_vec[i + degree0] - uknot_vec[i]);+ let coef1 = inv_or_zero(uknot_vec[i + degree0 + 1] - uknot_vec[i + 1]);+ let b0 = basis0[i] * coef0 - basis0[i + 1] * coef1;+ let closure = |sum: P::Diff, (j, pt): (usize, &P)| {+ let coef0 = inv_or_zero(vknot_vec[j + degree1] - vknot_vec[j]);+ let coef1 = inv_or_zero(vknot_vec[j + degree1 + 1] - vknot_vec[j + 1]);+ sum + pt.to_vec() * (basis1[j] * coef0 - basis1[j + 1] * coef1) * b0+ };+ vec.iter().enumerate().fold(sum, closure)+ };+ control_points+ .iter()+ .enumerate()+ .fold(P::Diff::zero(), closure)+ * degree0 as f64+ * degree1 as f64+ }+ #[inline(always)]+ fn parameter_range(&self) -> (ParameterRange, ParameterRange) { self.parameter_range() }+}++impl<V: Tolerance> BSplineSurface<V> {+ /// Returns whether all control points are same or not.+ /// If the knot vector is clamped, it means whether the curve is constant or not.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::bezier_knot(1);+ /// let vknot_vec = KnotVec::bezier_knot(2);+ /// let pt = Vector2::new(1.0, 2.0);+ /// let ctrl_pts = vec![+ /// vec![pt.clone(), pt.clone(), pt.clone()],+ /// vec![pt.clone(), pt.clone(), pt.clone()],+ /// ];+ /// let mut bspsurface = BSplineSurface::new((uknot_vec, vknot_vec), ctrl_pts);+ /// assert!(bspsurface.is_const());+ ///+ /// *bspsurface.control_point_mut(1, 2) = Vector2::new(2.0, 3.0);+ /// assert!(!bspsurface.is_const());+ /// ```+ /// # Remarks+ /// If the knot vector is not clamped and the BSpline basis function is not partition of unity,+ /// then perhaps returns true even if the surface is not constant.+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::uniform_knot(1, 5);+ /// let vknot_vec = KnotVec::uniform_knot(1, 5);+ /// let pt = Vector2::new(1.0, 2.0);+ /// let ctrl_pts = vec![+ /// vec![pt.clone(), pt.clone(), pt.clone()],+ /// vec![pt.clone(), pt.clone(), pt.clone()],+ /// ];+ /// let mut bspsurface = BSplineSurface::new((uknot_vec, vknot_vec), ctrl_pts);+ ///+ /// // bspsurface is not constant.+ /// assert_eq!(bspsurface.subs(0.0, 0.0), Vector2::new(0.0, 0.0));+ /// assert_ne!(bspsurface.subs(0.5, 0.5), Vector2::new(0.0, 0.0));+ ///+ /// // bspsurface.is_const() is true.+ /// assert!(bspsurface.is_const());+ /// ```+ #[inline(always)]+ pub fn is_const(&self) -> bool {+ for vec in self.control_points.iter().flat_map(|pts| pts.iter()) {+ if !vec.near(&self.control_points[0][0]) {+ return false;+ }+ }+ true+ }+}++impl<P: ControlPoint<f64> + Tolerance> BSplineSurface<P> {+ /// Adds a knot `x` of the first parameter `u`, and do not change `self` as a surface.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// ];+ /// let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let org_surface = bspsurface.clone();+ /// bspsurface.add_uknot(0.0).add_uknot(0.3).add_uknot(0.5).add_uknot(1.0);+ /// assert!(bspsurface.near2_as_surface(&org_surface));+ /// assert_eq!(bspsurface.uknot_vec().len(), org_surface.uknot_vec().len() + 4);+ /// ```+ pub fn add_uknot(&mut self, x: f64) -> &mut Self {+ let k = self.udegree();+ let n0 = self.control_points.len();+ let n1 = self.control_points[0].len();+ let uknot_vec = &mut self.knot_vecs.0;+ let control_points = &mut self.control_points;+ if x < uknot_vec[0] {+ uknot_vec.add_knot(x);+ control_points.insert(0, vec![P::origin(); n1]);+ return self;+ }++ let idx = uknot_vec.add_knot(x);+ let start = if idx > k { idx - k } else { 0 };+ let end = if idx > n0 {+ control_points.push(vec![P::origin(); n1]);+ n0 + 1+ } else {+ control_points.insert(idx - 1, control_points[idx - 1].clone());+ idx+ };+ for i in start..end {+ let i0 = end + start - i - 1;+ let delta = self.uknot(i0 + k + 1) - self.uknot(i0);+ let a = inv_or_zero(delta) * (self.uknot(idx) - self.uknot(i0));+ for j in 0..n1 {+ let p = self.udelta_control_points(i0, j) * (1.0 - a);+ self.control_points[i0][j] -= p;+ }+ }+ self+ }++ /// Adds a knot `x` for the second parameter, and do not change `self` as a surface.+ /// Return `false` if cannot add the knot, i.e.+ /// * the index of `x` will be lower than the degree, or+ /// * the index of `x` will be higher than the number of control points.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// ];+ /// let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let org_surface = bspsurface.clone();+ /// bspsurface.add_vknot(0.0).add_vknot(0.3).add_vknot(0.5).add_vknot(1.0);+ /// assert!(bspsurface.near2_as_surface(&org_surface));+ /// assert_eq!(bspsurface.vknot_vec().len(), org_surface.vknot_vec().len() + 4);+ /// ```+ pub fn add_vknot(&mut self, x: f64) -> &mut Self {+ if x < self.knot_vecs.1[0] {+ self.knot_vecs.1.add_knot(x);+ self.control_points+ .iter_mut()+ .for_each(|vec| vec.insert(0, P::origin()));+ return self;+ }++ let k = self.vdegree();+ let n0 = self.control_points.len();+ let n1 = self.control_points[0].len();++ let idx = self.knot_vecs.1.add_knot(x);+ let start = if idx > k { idx - k } else { 0 };+ let end = if idx > n1 {+ self.control_points+ .iter_mut()+ .for_each(|vec| vec.push(P::origin()));+ n1 + 1+ } else {+ self.control_points+ .iter_mut()+ .for_each(|vec| vec.insert(idx - 1, vec[idx - 1]));+ idx+ };+ for j in start..end {+ let j0 = end + start - j - 1;+ let delta = self.knot_vecs.1[j0 + k + 1] - self.knot_vecs.1[j0];+ let a = inv_or_zero(delta) * (self.knot_vecs.1[idx] - self.knot_vecs.1[j0]);+ for i in 0..n0 {+ let p = self.vdelta_control_points(i, j0) * (1.0 - a);+ self.control_points[i][j0] -= p;+ }+ }+ self+ }++ /// Removes the uknot corresponding to the indice `idx`, and do not change `self` as a curve.+ /// If the knot cannot be removed, returns+ /// [`Error::CannotRemoveKnot`](./errors/enum.Error.html#variant.CannotRemoveKnot).+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ /// let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 2.0)],+ /// ];+ /// let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let org_surface = bspsurface.clone();+ ///+ /// bspsurface.add_uknot(0.3).add_uknot(0.5);+ ///+ /// assert!(bspsurface.try_remove_uknot(3).is_ok());+ /// assert_eq!(bspsurface.try_remove_uknot(2), Err(Error::CannotRemoveKnot(2)));+ ///+ /// assert_eq!(bspsurface.uknot_vec().len(), org_surface.uknot_vec().len() + 1);+ /// assert!(bspsurface.near2_as_surface(&org_surface));+ /// ```+ pub fn try_remove_uknot(&mut self, idx: usize) -> Result<&mut Self> {+ let k = self.udegree();+ let knot_vec = self.uknot_vec();+ let n = self.control_points.len();++ if idx < k + 1 || idx >= n {+ return Err(Error::CannotRemoveKnot(idx));+ }++ let mut new_points = Vec::with_capacity(k + 1);+ let first_vec = self+ .ctrl_pts_column_iter(idx - k - 1)+ .cloned()+ .collect::<Vec<_>>();+ new_points.push(first_vec);+ for i in (idx - k)..idx {+ let delta = knot_vec[i + k + 1] - knot_vec[i];+ let a = inv_or_zero(delta) * (knot_vec[idx] - knot_vec[i]);+ if a.so_small() {+ break;+ } else {+ let vec = self+ .ctrl_pts_column_iter(i)+ .zip(new_points.last().unwrap())+ .map(|(pt0, pt1)| *pt1 + (*pt0 - *pt1) / a)+ .collect();+ new_points.push(vec);+ }+ }++ for (pt0, pt1) in self+ .ctrl_pts_column_iter(idx)+ .zip(new_points.last().unwrap())+ {+ if !pt0.near(pt1) {+ return Err(Error::CannotRemoveKnot(idx));+ }+ }++ for (i, vec) in new_points.into_iter().skip(1).enumerate() {+ self.control_points[idx - k + i] = vec;+ }++ self.control_points.remove(idx);+ self.knot_vecs.0.remove(idx);+ Ok(self)+ }++ /// Removes the uknot corresponding to the indices `idx`, and do not change `self` as a curve.+ /// If cannot remove the knot, do not change `self` and return `self`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ /// let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 2.0)],+ /// ];+ /// let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let org_surface = bspsurface.clone();+ ///+ /// bspsurface.add_uknot(0.3).add_uknot(0.5);+ /// bspsurface.remove_uknot(3).remove_uknot(3);+ ///+ /// assert!(bspsurface.near2_as_surface(&org_surface));+ /// assert_eq!(bspsurface.uknot_vec().len(), org_surface.uknot_vec().len())+ /// ```+ #[inline(always)]+ pub fn remove_uknot(&mut self, idx: usize) -> &mut Self {+ let _ = self.try_remove_uknot(idx);+ self+ }++ /// Removes a vknot corresponding to the indice `idx`, and do not change `self` as a curve.+ /// If the knot cannot be removed, returns+ /// [`Error::CannotRemoveKnot`](./errors/enum.Error.html#variant.CannotRemoveKnot).+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ /// let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 2.0)],+ /// ];+ /// let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let org_surface = bspsurface.clone();+ ///+ /// bspsurface.add_vknot(0.3).add_vknot(0.5);+ /// assert!(bspsurface.try_remove_vknot(3).is_ok());+ /// assert_eq!(bspsurface.try_remove_vknot(2), Err(Error::CannotRemoveKnot(2)));+ ///+ /// assert!(bspsurface.near2_as_surface(&org_surface));+ /// assert_eq!(bspsurface.vknot_vec().len(), org_surface.vknot_vec().len() + 1);+ /// ```+ pub fn try_remove_vknot(&mut self, idx: usize) -> Result<&mut Self> {+ let (_, k) = self.degrees();+ let knot_vec = self.vknot_vec();+ let n = self.control_points[0].len();++ if idx < k + 1 || idx >= n {+ return Err(Error::CannotRemoveKnot(idx));+ }++ let mut new_points = Vec::with_capacity(k + 1);+ let first_vec = self+ .ctrl_pts_row_iter(idx - k - 1)+ .cloned()+ .collect::<Vec<_>>();+ new_points.push(first_vec);+ for i in (idx - k)..idx {+ let delta = knot_vec[i + k + 1] - knot_vec[i];+ let a = inv_or_zero(delta) * (knot_vec[idx] - knot_vec[i]);+ if a.so_small() {+ break;+ } else {+ let vec = self+ .ctrl_pts_row_iter(i)+ .zip(new_points.last().unwrap())+ .map(|(pt0, pt1)| *pt1 + (*pt0 - *pt1) / a)+ .collect();+ new_points.push(vec);+ }+ }++ for (pt0, pt1) in self.ctrl_pts_row_iter(idx).zip(new_points.last().unwrap()) {+ if !pt0.near(pt1) {+ return Err(Error::CannotRemoveKnot(idx));+ }+ }++ for (i, vec) in new_points.into_iter().skip(1).enumerate() {+ for (j, pt) in vec.into_iter().enumerate() {+ self.control_points[j][idx - k + i] = pt;+ }+ }++ for vec in &mut self.control_points {+ vec.remove(idx);+ }+ self.knot_vecs.1.remove(idx);+ Ok(self)+ }++ /// Removes a uknot corresponding to the indices `idx`, and do not change `self` as a curve.+ /// If cannot remove the knot, do not change `self` and return `self`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// use truck_geometry::errors::Error;+ /// let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 2.0)],+ /// ];+ /// let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let org_surface = bspsurface.clone();+ ///+ /// bspsurface.add_vknot(0.3).add_vknot(0.5);+ /// bspsurface.remove_vknot(3).remove_vknot(3);+ ///+ /// assert!(bspsurface.near2_as_surface(&org_surface));+ /// assert_eq!(bspsurface.vknot_vec().len(), org_surface.vknot_vec().len())+ /// ```+ #[inline(always)]+ pub fn remove_vknot(&mut self, idx: usize) -> &mut Self {+ let _ = self.try_remove_vknot(idx);+ self+ }++ /// Elevates the vdegree.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 2.0)],+ /// ];+ /// let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let org_surface = bspsurface.clone();+ ///+ /// bspsurface.elevate_vdegree();+ ///+ /// assert_eq!(bspsurface.udegree(), org_surface.udegree());+ /// assert_eq!(bspsurface.vdegree(), org_surface.vdegree() + 1);+ /// assert!(bspsurface.near2_as_surface(&org_surface));+ /// ```+ pub fn elevate_vdegree(&mut self) -> &mut Self {+ let mut new_knot_vec = KnotVec::new();+ for (i, vec) in self.control_points.iter_mut().enumerate() {+ let knot_vec = self.knot_vecs.1.clone();+ let ctrl_pts = vec.clone();+ let mut curve = BSplineCurve::new(knot_vec, ctrl_pts);+ curve.elevate_degree();+ if i == 0 {+ new_knot_vec = curve.knot_vec().clone();+ }+ *vec = curve.control_points;+ }+ self.knot_vecs.1 = new_knot_vec;+ self+ }++ /// Elevates the udegree.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],+ /// vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 2.0)],+ /// ];+ /// let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let org_surface = bspsurface.clone();+ ///+ /// bspsurface.elevate_udegree();+ ///+ /// assert_eq!(bspsurface.udegree(), org_surface.udegree() + 1);+ /// assert_eq!(bspsurface.vdegree(), org_surface.vdegree());+ /// assert!(bspsurface.near2_as_surface(&org_surface));+ /// ```+ pub fn elevate_udegree(&mut self) -> &mut Self {+ self.swap_axes();+ self.elevate_vdegree();+ self.swap_axes();+ self+ }++ /// Aligns the udegree with the same degrees.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::bezier_knot(1);+ /// let vknot_vec = KnotVec::bezier_knot(2);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// ];+ /// let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let org_surface = bspsurface.clone();+ ///+ /// assert_ne!(bspsurface.udegree(), bspsurface.vdegree());+ /// bspsurface.syncro_uvdegrees();+ /// assert_eq!(bspsurface.udegree(), bspsurface.vdegree());+ /// assert!(bspsurface.near2_as_surface(&org_surface));+ /// ```+ pub fn syncro_uvdegrees(&mut self) -> &mut Self {+ if self.udegree() > self.vdegree() {+ for _ in 0..(self.udegree() - self.vdegree()) {+ self.elevate_vdegree();+ }+ }+ if self.vdegree() > self.udegree() {+ for _ in 0..(self.vdegree() - self.udegree()) {+ self.elevate_udegree();+ }+ }+ self+ }++ /// Makes the uknot vector and the vknot vector the same knot vector.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::uniform_knot(1, 2);+ /// let vknot_vec = KnotVec::bezier_knot(2);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// vec![Vector3::new(0.0, 2.0, 0.0), Vector3::new(1.0, 2.0, 1.0), Vector3::new(2.0, 2.0, 2.0)],+ /// ];+ /// let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let org_surface = bspsurface.clone();+ ///+ /// assert_ne!(bspsurface.uknot_vec(), bspsurface.vknot_vec());+ /// bspsurface.syncro_uvknots();+ /// assert_eq!(bspsurface.uknot_vec(), bspsurface.vknot_vec());+ /// assert!(bspsurface.near2_as_surface(&org_surface));+ /// ```+ pub fn syncro_uvknots(&mut self) -> &mut Self {+ self.knot_vecs.0.normalize();+ self.knot_vecs.1.normalize();+ let mut i = 0;+ let mut j = 0;+ while !self.uknot(i).near2(&1.0) || !self.vknot(j).near2(&1.0) {+ if self.uknot(i) - self.vknot(j) > TOLERANCE {+ self.add_uknot(self.vknot(j));+ } else if self.vknot(j) - self.uknot(i) > TOLERANCE {+ self.add_vknot(self.uknot(i));+ }+ i += 1;+ j += 1;+ }++ let ulen = self.uknot_vec().len();+ let vlen = self.vknot_vec().len();+ use std::cmp::Ordering;+ match usize::cmp(&ulen, &vlen) {+ Ordering::Less => {+ for _ in 0..vlen - ulen {+ self.add_uknot(1.0);+ }+ }+ Ordering::Greater => {+ for _ in 0..ulen - vlen {+ self.add_vknot(1.0);+ }+ }+ _ => {}+ }+ self+ }++ /// Cuts the surface into two surfaces at the parameter `u`+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ ///+ /// let knot_vec0 = KnotVec::uniform_knot(2, 2);+ /// let knot_vec1 = KnotVec::uniform_knot(2, 2);+ /// let ctrl_pts0 = vec![+ /// Vector2::new(0.0, 0.0), Vector2::new(0.5, 0.0), Vector2::new(2.0, 0.0), Vector2::new(2.5, 0.0),+ /// ];+ /// let ctrl_pts1 = vec![+ /// Vector2::new(0.0, 1.0), Vector2::new(0.5, 1.0), Vector2::new(2.0, 1.0), Vector2::new(2.5, 1.0),+ /// ];+ /// let ctrl_pts2 = vec![+ /// Vector2::new(0.0, 1.5), Vector2::new(0.5, 1.5), Vector2::new(2.0, 1.5), Vector2::new(2.5, 1.5),+ /// ];+ /// let ctrl_pts3 = vec![+ /// Vector2::new(0.0, 2.5), Vector2::new(0.5, 2.5), Vector2::new(2.0, 2.5), Vector2::new(2.5, 2.5),+ /// ];+ /// let ctrl_pts = vec![ctrl_pts0, ctrl_pts1, ctrl_pts2, ctrl_pts3];+ /// let bspsurface = BSplineSurface::new((knot_vec0, knot_vec1), ctrl_pts);+ ///+ /// let mut part0 = bspsurface.clone();+ /// let part1 = part0.ucut(0.68);+ /// const N: usize = 100;+ /// for i in 0..=N {+ /// for j in 0..=N {+ /// let u = 0.68 * (i as f64) / (N as f64);+ /// let v = 1.0 * (j as f64) / (N as f64);+ /// assert_near2!(bspsurface.subs(u, v), part0.subs(u, v));+ /// }+ /// }+ /// for i in 0..=N {+ /// for j in 0..=N {+ /// let u = 0.68 + 0.32 * (i as f64) / (N as f64);+ /// let v = 1.0 * (j as f64) / (N as f64);+ /// assert_near2!(bspsurface.subs(u, v), part1.subs(u, v));+ /// }+ /// }+ /// ```+ pub fn ucut(&mut self, mut u: f64) -> BSplineSurface<P> {+ let degree = self.udegree();++ let idx = match self.uknot_vec().floor(u) {+ Some(idx) => idx,+ None => {+ let bspline = self.clone();+ let uknot_vec = KnotVec::from(vec![u, self.vknot_vec()[0]]);+ let vknot_vec = self.vknot_vec().clone();+ let ctrl_pts = vec![vec![P::origin(); vknot_vec.len()]];+ *self = BSplineSurface::new((uknot_vec, vknot_vec), ctrl_pts);+ return bspline;+ }+ };+ let s = if u.near(&self.uknot_vec()[idx]) {+ u = self.uknot_vec()[idx];+ self.uknot_vec().multiplicity(idx)+ } else {+ 0+ };++ for _ in s..=degree {+ self.add_uknot(u);+ }++ let vknot_vec = self.vknot_vec().clone();+ let k = self.uknot_vec().floor(u).unwrap();+ let m = self.uknot_vec().len();+ let n = self.control_points.len();+ let knot_vec0 = self.uknot_vec().sub_vec(0..=k);+ let knot_vec1 = self.uknot_vec().sub_vec((k - degree)..m);+ let control_points0 = Vec::from(&self.control_points[0..(k - degree)]);+ let control_points1 = Vec::from(&self.control_points[(k - degree)..n]);+ *self = BSplineSurface::new((knot_vec0, vknot_vec.clone()), control_points0);+ BSplineSurface::new((knot_vec1, vknot_vec), control_points1)+ }+ /// Cuts the curve to two curves at the parameter `t`+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ ///+ /// let knot_vec0 = KnotVec::uniform_knot(2, 2);+ /// let knot_vec1 = KnotVec::uniform_knot(2, 2);+ /// let ctrl_pts0 = vec![+ /// Vector2::new(0.0, 0.0), Vector2::new(0.5, 0.0), Vector2::new(2.0, 0.0), Vector2::new(2.5, 0.0),+ /// ];+ /// let ctrl_pts1 = vec![+ /// Vector2::new(0.0, 1.0), Vector2::new(0.5, 1.0), Vector2::new(2.0, 1.0), Vector2::new(2.5, 1.0),+ /// ];+ /// let ctrl_pts2 = vec![+ /// Vector2::new(0.0, 1.5), Vector2::new(0.5, 1.5), Vector2::new(2.0, 1.5), Vector2::new(2.5, 1.5),+ /// ];+ /// let ctrl_pts3 = vec![+ /// Vector2::new(0.0, 2.5), Vector2::new(0.5, 2.5), Vector2::new(2.0, 2.5), Vector2::new(2.5, 2.5),+ /// ];+ /// let ctrl_pts = vec![ctrl_pts0, ctrl_pts1, ctrl_pts2, ctrl_pts3];+ /// let bspsurface = BSplineSurface::new((knot_vec0, knot_vec1), ctrl_pts);+ ///+ /// let mut part0 = bspsurface.clone();+ /// let part1 = part0.vcut(0.68);+ /// const N: usize = 100;+ /// for i in 0..=N {+ /// for j in 0..=N {+ /// let u = 1.0 * (i as f64) / (N as f64);+ /// let v = 0.68 * (j as f64) / (N as f64);+ /// assert_near2!(bspsurface.subs(u, v), part0.subs(u, v));+ /// }+ /// }+ /// for i in 0..=N {+ /// for j in 0..=N {+ /// let u = 1.0 * (i as f64) / (N as f64);+ /// let v = 0.68 + 0.32 * (j as f64) / (N as f64);+ /// assert_near2!(bspsurface.subs(u, v), part1.subs(u, v));+ /// }+ /// }+ /// ```+ pub fn vcut(&mut self, v: f64) -> BSplineSurface<P> {+ self.swap_axes();+ let mut res = self.ucut(v);+ self.swap_axes();+ res.swap_axes();+ res+ }++ /// Creates a sectional curve with normalized knot vector from the parameter `p` to the parameter `q`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ ///+ /// // a parabola surface: x = 2u - 1, y = 2v - 1, z = x^2 + y^z+ /// let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(-1.0, -1.0, 2.0), Vector3::new(-1.0, 0.0, 0.0), Vector3::new(-1.0, 1.0, 2.0)],+ /// vec![Vector3::new(0.0, -1.0, 0.0), Vector3::new(0.0, 0.0, -2.0), Vector3::new(0.0, 1.0, 0.0)],+ /// vec![Vector3::new(1.0, -1.0, 2.0), Vector3::new(1.0, 0.0, 0.0), Vector3::new(1.0, 1.0, 2.0)],+ /// ];+ /// let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ ///+ /// // add some knots for the test!+ /// bspsurface.add_uknot(0.26);+ /// # bspsurface.add_uknot(0.64);+ /// bspsurface.add_vknot(0.23);+ /// # bspsurface.add_vknot(0.82);+ ///+ /// let bnd_box = BoundingBox::from_iter(&[Vector2::new(0.2, 0.3), Vector2::new(0.8, 0.6)]);+ /// let curve = bspsurface.sectional_curve(bnd_box);+ /// const N: usize = 100;+ /// assert_near2!(curve.subs(0.0), bspsurface.subs(0.2, 0.3));+ /// assert_near2!(curve.subs(1.0), bspsurface.subs(0.8, 0.6));+ /// for i in 0..=N {+ /// let t = i as f64 / N as f64;+ /// let pt = curve.subs(t);+ /// assert_near2!(pt[1], pt[0] * 0.5 - 0.1);+ /// assert_near2!(pt[2], pt[0] * pt[0] + pt[1] * pt[1]);+ /// }+ /// ```+ pub fn sectional_curve(&self, bnd_box: BoundingBox<Vector2>) -> BSplineCurve<P> {+ let p = bnd_box.min();+ let q = bnd_box.max();+ let mut bspsurface = self.clone();+ if !p[0].near(&bspsurface.uknot(0)) {+ bspsurface = bspsurface.ucut(p[0]);+ }+ if !q[0].near(&bspsurface.uknot(bspsurface.uknot_vec().len() - 1)) {+ bspsurface.ucut(q[0]);+ }+ if !p[0].near(&bspsurface.vknot(0)) {+ bspsurface = bspsurface.vcut(p[1]);+ }+ if !q[0].near(&bspsurface.vknot(bspsurface.vknot_vec().len() - 1)) {+ bspsurface.vcut(q[1]);+ }+ bspsurface.syncro_uvdegrees();+ bspsurface.syncro_uvknots();+ let degree = bspsurface.udegree();+ let comb = combinatorial(degree);+ let comb2 = combinatorial(degree * 2);+ let (knots, _) = bspsurface.uknot_vec().to_single_multi();+ let mut cc = CurveCollector::Singleton;+ for p in 1..knots.len() {+ let mut backup = None;+ if p + 1 != knots.len() {+ backup = Some(bspsurface.ucut(knots[p]));+ bspsurface.vcut(knots[p]);+ }+ let mut knot_vec = KnotVec::bezier_knot(degree * 2);+ knot_vec.translate(p as f64 - 1.0);+ let ctrl_pts: Vec<_> = (0..=degree * 2)+ .map(|k| {+ (0..=k).fold(P::origin(), |sum, i| {+ if i <= degree && k - i <= degree {+ let coef = (comb[i] * comb[k - i]) as f64 / comb2[k] as f64;+ sum + bspsurface.control_points[i][k - i].to_vec() * coef+ } else {+ sum+ }+ })+ })+ .collect();+ cc.concat(&BSplineCurve::new(knot_vec, ctrl_pts));+ if p + 1 != knots.len() {+ bspsurface = backup.unwrap().vcut(knots[p]);+ }+ }+ let mut curve: BSplineCurve<P> = cc.unwrap();+ curve.knot_normalize();+ curve+ }++ /// Creates a surface with normailized knot vectors connecting two curves.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec0 = KnotVec::bezier_knot(2);+ /// let ctrl_pts0 = vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)];+ /// let bspcurve0 = BSplineCurve::new(knot_vec0, ctrl_pts0);+ ///+ /// let knot_vec1 = KnotVec::bezier_knot(2);+ /// let ctrl_pts1 = vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, 1.0), Vector2::new(1.0, 2.0)];+ /// let bspcurve1 = BSplineCurve::new(knot_vec1, ctrl_pts1);+ ///+ /// let homotopy_surface = BSplineSurface::homotopy(bspcurve0, bspcurve1);+ /// assert_eq!(+ /// homotopy_surface.control_points(),+ /// &vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.0, 2.0)],+ /// vec![Vector2::new(0.5, -1.0), Vector2::new(0.5, 1.0)],+ /// vec![Vector2::new(1.0, 0.0), Vector2::new(1.0, 2.0)],+ /// ],+ /// );+ /// ```+ pub fn homotopy(+ mut bspcurve0: BSplineCurve<P>,+ mut bspcurve1: BSplineCurve<P>,+ ) -> BSplineSurface<P> {+ bspcurve0.syncro_degree(&mut bspcurve1);++ //bspcurve0.optimize();+ //bspcurve1.optimize();++ bspcurve0.syncro_knots(&mut bspcurve1);++ let uknot_vec = bspcurve0.knot_vec().clone();+ let vknot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);+ let mut control_points = Vec::new();+ for i in 0..bspcurve0.control_points().len() {+ control_points.push(Vec::new());+ control_points[i].push(*bspcurve0.control_point(i));+ control_points[i].push(*bspcurve1.control_point(i));+ }+ BSplineSurface::new_unchecked((uknot_vec, vknot_vec), control_points)+ }++ /// Creates a surface by its boundary.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let curve0 = BSplineCurve::new(+ /// KnotVec::bezier_knot(1),+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(1.0, 0.0)],+ /// );+ /// let curve1 = BSplineCurve::new(+ /// KnotVec::bezier_knot(2),+ /// vec![Vector2::new(1.0, 0.0), Vector2::new(2.0, 0.5), Vector2::new(1.0, 1.0)],+ /// );+ /// let curve2 = BSplineCurve::new(+ /// KnotVec::bezier_knot(1),+ /// vec![Vector2::new(1.0, 1.0), Vector2::new(0.0, 1.0)],+ /// );+ /// let curve3 = BSplineCurve::new(+ /// KnotVec::bezier_knot(2),+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(-1.0, 0.5), Vector2::new(0.0, 0.0)],+ /// );+ /// let surface = BSplineSurface::by_boundary(curve0, curve1, curve2, curve3);+ /// assert_eq!(+ /// surface.control_points(),+ /// &vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(-1.0, 0.5), Vector2::new(0.0, 1.0)],+ /// vec![Vector2::new(1.0, 0.0), Vector2::new(2.0, 0.5), Vector2::new(1.0, 1.0)],+ /// ],+ /// );+ /// ```+ /// # Remarks+ /// If the end points of curves are not connected, `curve1` and `curve3` take precedence. i.e.+ /// `curve1` and `curve3` are contained in the boundary of the surface and `curve0` and+ /// `curve2` are not contained.+ /// ```+ /// use truck_geometry::prelude::*;+ /// let curve0 = BSplineCurve::new(+ /// KnotVec::bezier_knot(1),+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(1.0, 0.0)],+ /// );+ /// let curve1 = BSplineCurve::new(+ /// KnotVec::bezier_knot(2),+ /// vec![Vector2::new(2.0, 0.0), Vector2::new(3.0, 0.5), Vector2::new(2.0, 1.0)],+ /// );+ /// let curve2 = BSplineCurve::new(+ /// KnotVec::bezier_knot(1),+ /// vec![Vector2::new(1.0, 1.0), Vector2::new(0.0, 1.0)],+ /// );+ /// let curve3 = BSplineCurve::new(+ /// KnotVec::bezier_knot(2),+ /// vec![Vector2::new(-1.0, 1.0), Vector2::new(-2.0, 0.5), Vector2::new(-1.0, 0.0)],+ /// );+ /// let surface = BSplineSurface::by_boundary(+ /// curve0.clone(),+ /// curve1.clone(),+ /// curve2.clone(),+ /// curve3.clone()+ /// );+ /// assert_ne!(surface.subs(0.0, 0.0), curve0.subs(0.0));+ /// assert_eq!(surface.subs(0.0, 0.0), curve3.subs(1.0));+ /// ```+ pub fn by_boundary(+ mut curve0: BSplineCurve<P>,+ mut curve1: BSplineCurve<P>,+ mut curve2: BSplineCurve<P>,+ mut curve3: BSplineCurve<P>,+ ) -> BSplineSurface<P> {+ curve2.invert();+ curve3.invert();+ curve0.syncro_degree(&mut curve2);+ curve0.optimize();+ curve2.optimize();+ curve0.syncro_knots(&mut curve2);+ curve1.syncro_degree(&mut curve3);+ curve1.optimize();+ curve3.optimize();+ curve1.syncro_knots(&mut curve3);++ let knot_vecs = (curve0.knot_vec().clone(), curve3.knot_vec().clone());+ let mut control_points = vec![curve3.control_points().clone()];+ let n = curve0.control_points().len();+ let m = curve3.control_points().len();+ for i in 1..(n - 1) {+ let u = (i as f64) / (n as f64);+ let pt0 = curve2.control_points[i]+ + (curve0.control_points[i] - curve2.control_points[i]) * u;+ let mut new_row = vec![*curve0.control_point(i)];+ for j in 1..(m - 1) {+ let v = (j as f64) / (m as f64);+ let pt1 = curve1.control_points[j]+ + (curve3.control_points[j] - curve1.control_points[j]) * v;+ new_row.push(pt0 + (pt1 - pt0) / 2.0);+ }+ new_row.push(*curve2.control_point(i));+ control_points.push(new_row);+ }+ control_points.push(curve1.control_points().clone());+ BSplineSurface::new(knot_vecs, control_points)+ }++ /// Normalizes the knot vectors+ #[inline(always)]+ pub fn knot_normalize(&mut self) -> &mut Self {+ self.knot_vecs.0.normalize();+ self.knot_vecs.1.normalize();+ self+ }++ /// Translates the knot vectors.+ #[inline(always)]+ pub fn knot_translate(&mut self, x: f64, y: f64) -> &mut Self {+ self.knot_vecs.0.translate(x);+ self.knot_vecs.1.translate(y);+ self+ }++ /// Removes knots in order from the back+ pub fn optimize(&mut self) -> &mut Self {+ loop {+ let (n0, n1) = (self.knot_vecs.0.len(), self.knot_vecs.1.len());+ let mut flag = true;+ for i in 1..=n0 {+ flag = flag && self.try_remove_uknot(n0 - i).is_err();+ }+ for j in 1..=n1 {+ flag = flag && self.try_remove_vknot(n1 - j).is_err();+ }+ if flag {+ break;+ }+ }+ self+ }++ /// Gets the boundary by four splitted curves.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(3), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 1.0), Vector2::new(1.0, 1.0)],+ /// vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 2.0)],+ /// vec![Vector2::new(0.0, 3.0), Vector2::new(0.5, 3.5), Vector2::new(1.0, 3.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let curves = bspsurface.splitted_boundary();+ /// assert_eq!(+ /// curves[0].control_points(),+ /// &vec![Vector2::new(0.0, 0.0), Vector2::new(0.0, 1.0), Vector2::new(0.0, 2.0), Vector2::new(0.0, 3.0)],+ /// );+ /// assert_eq!(+ /// curves[1].control_points(),+ /// &vec![Vector2::new(0.0, 3.0), Vector2::new(0.5, 3.5), Vector2::new(1.0, 3.0)],+ /// );+ /// assert_eq!(+ /// curves[2].control_points(),+ /// &vec![Vector2::new(1.0, 3.0), Vector2::new(1.0, 2.0), Vector2::new(1.0, 1.0), Vector2::new(1.0, 0.0)],+ /// );+ /// assert_eq!(+ /// curves[3].control_points(),+ /// &vec![Vector2::new(1.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(0.0, 0.0)],+ /// );+ /// ```+ pub fn splitted_boundary(&self) -> [BSplineCurve<P>; 4] {+ let (uknot_vec, vknot_vec) = self.knot_vecs.clone();+ let control_points0 = self.control_points.iter().map(|x| x[0]).collect();+ let control_points1 = self.control_points.last().unwrap().clone();+ let control_points2 = self+ .control_points+ .iter()+ .map(|x| *x.last().unwrap())+ .collect();+ let control_points3 = self.control_points[0].clone();+ let curve0 = BSplineCurve::new_unchecked(uknot_vec.clone(), control_points0);+ let curve1 = BSplineCurve::new_unchecked(vknot_vec.clone(), control_points1);+ let mut curve2 = BSplineCurve::new_unchecked(uknot_vec, control_points2);+ curve2.invert();+ let mut curve3 = BSplineCurve::new_unchecked(vknot_vec, control_points3);+ curve3.invert();+ [curve0, curve1, curve2, curve3]+ }++ /// Extracts the boundary of surface+ pub fn boundary(&self) -> BSplineCurve<P> {+ let (uknot_vec, vknot_vec) = self.knot_vecs.clone();+ let (range0, range1) = (uknot_vec.range_length(), vknot_vec.range_length());+ let [bspline0, mut bspline1, mut bspline2, mut bspline3] = self.splitted_boundary();+ bspline0+ .concat(bspline1.knot_translate(range0))+ .concat(bspline2.invert().knot_translate(range0 + range1))+ .concat(bspline3.invert().knot_translate(range0 * 2.0 + range1))+ }+ /// Determines whether `self` and `other` is near as the B-spline surfaces or not.+ ///+ /// Divides each knot domain into the number of degree equal parts,+ /// and check `|self(u, v) - other(u, v)| < TOLERANCE` for each end points `(u, v)`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(3), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 1.0), Vector2::new(1.0, 1.0)],+ /// vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 2.0)],+ /// vec![Vector2::new(0.0, 3.0), Vector2::new(0.5, 3.5), Vector2::new(1.0, 3.0)],+ /// ];+ /// let bspsurface0 = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let mut bspsurface1 = bspsurface0.clone();+ /// assert!(bspsurface0.near_as_surface(&bspsurface1));+ ///+ /// *bspsurface1.control_point_mut(1, 1) = Vector2::new(0.4, 1.0);+ /// assert!(!bspsurface0.near_as_surface(&bspsurface1));+ /// ```+ #[inline(always)]+ pub fn near_as_surface(&self, other: &BSplineSurface<P>) -> bool {+ self.sub_near_as_surface(other, 1, |x, y| x.near(y))+ }+ /// Determines whether `self` and `other` is near in square order as the B-spline surfaces or not.+ ///+ /// Divides each knot domain into the number of degree equal parts,+ /// and check `|self(u, v) - other(u, v)| < TOLERANCE` for each end points `(u, v)`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let eps = TOLERANCE;+ /// let knot_vecs = (KnotVec::bezier_knot(3), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],+ /// vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 1.0), Vector2::new(1.0, 1.0)],+ /// vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 2.0)],+ /// vec![Vector2::new(0.0, 3.0), Vector2::new(0.5, 3.5), Vector2::new(1.0, 3.0)],+ /// ];+ /// let bspsurface0 = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let mut bspsurface1 = bspsurface0.clone();+ /// assert!(bspsurface0.near_as_surface(&bspsurface1));+ ///+ /// *bspsurface1.control_point_mut(1, 1) += Vector2::new(eps, eps / 2.0);+ /// assert!(bspsurface0.near_as_surface(&bspsurface1));+ /// assert!(!bspsurface0.near2_as_surface(&bspsurface1));+ /// ```+ #[inline(always)]+ pub fn near2_as_surface(&self, other: &BSplineSurface<P>) -> bool {+ self.sub_near_as_surface(other, 1, |x, y| x.near2(y))+ }+}++impl<V: Bounded> BSplineSurface<V> {+ /// Returns the bounding box including all control points.+ #[inline(always)]+ pub fn roughly_bounding_box(&self) -> BoundingBox<V> {+ self.control_points.iter().flatten().collect()+ }+}++impl<P: ControlPoint<f64>> ParameterDivision2D for BSplineSurface<P>+where P: EuclideanSpace<Scalar = f64, Diff = <P as ControlPoint<f64>>::Diff>+ + MetricSpace<Metric = f64>+ + HashGen<f64>+{+ #[inline(always)]+ fn parameter_division(+ &self,+ range: ((f64, f64), (f64, f64)),+ tol: f64,+ ) -> (Vec<f64>, Vec<f64>) {+ algo::surface::parameter_division(self, range, tol)+ }+}++impl ParametricSurface3D for BSplineSurface<Point3> {}++impl<V> BoundedSurface for BSplineSurface<V> where BSplineSurface<V>: ParametricSurface {}++impl<V: Clone> Invertible for BSplineSurface<V> {+ #[inline(always)]+ fn invert(&mut self) { self.swap_axes(); }+}++impl SearchParameter<D2> for BSplineSurface<Point2> {+ type Point = Point2;+ fn search_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point2,+ hint: H,+ trials: usize,+ ) -> Option<(f64, f64)> {+ let hint = match hint.into() {+ SPHint2D::Parameter(x, y) => (x, y),+ SPHint2D::Range(range0, range1) => {+ algo::surface::presearch(self, point, (range0, range1), PRESEARCH_DIVISION)+ }+ SPHint2D::None => {+ algo::surface::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::surface::search_parameter2d(self, point, hint, trials)+ }+}++impl SearchParameter<D2> for BSplineSurface<Point3> {+ type Point = Point3;+ fn search_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point3,+ hint: H,+ trials: usize,+ ) -> Option<(f64, f64)> {+ let hint = match hint.into() {+ SPHint2D::Parameter(x, y) => (x, y),+ SPHint2D::Range(range0, range1) => {+ algo::surface::presearch(self, point, (range0, range1), PRESEARCH_DIVISION)+ }+ SPHint2D::None => {+ algo::surface::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::surface::search_parameter3d(self, point, hint, trials)+ }+}++impl<P> SearchNearestParameter<D2> for BSplineSurface<P>+where+ P: ControlPoint<f64>+ + EuclideanSpace<Scalar = f64, Diff = <P as ControlPoint<f64>>::Diff>+ + MetricSpace<Metric = f64>,+ <P as ControlPoint<f64>>::Diff: InnerSpace<Scalar = f64> + Tolerance,+{+ type Point = P;+ fn search_nearest_parameter<H: Into<SPHint2D>>(+ &self,+ point: P,+ hint: H,+ trials: usize,+ ) -> Option<(f64, f64)> {+ let hint = match hint.into() {+ SPHint2D::Parameter(x, y) => (x, y),+ SPHint2D::Range(range0, range1) => {+ algo::surface::presearch(self, point, (range0, range1), PRESEARCH_DIVISION)+ }+ SPHint2D::None => {+ algo::surface::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::surface::search_nearest_parameter(self, point, hint, trials)+ }+}++impl IncludeCurve<BSplineCurve<Point2>> for BSplineSurface<Point2> {+ fn include(&self, curve: &BSplineCurve<Point2>) -> bool {+ let pt = curve.front();+ let mut hint = algo::surface::presearch(self, pt, self.range_tuple(), PRESEARCH_DIVISION);+ hint = match algo::surface::search_parameter2d(self, pt, hint, INCLUDE_CURVE_TRIALS) {+ Some(got) => got,+ None => return false,+ };+ let uknot_vec = self.uknot_vec();+ let vknot_vec = self.vknot_vec();+ let degree = curve.degree() * 6;+ let (knots, _) = curve.knot_vec().to_single_multi();+ for i in 1..knots.len() {+ for j in 1..=degree {+ let p = j as f64 / degree as f64;+ let t = knots[i - 1] * (1.0 - p) + knots[i] * p;+ let pt = ParametricCurve::subs(curve, t);+ hint = match algo::surface::search_parameter2d(self, pt, hint, INCLUDE_CURVE_TRIALS)+ {+ Some(got) => got,+ None => return false,+ };+ if !ParametricSurface::subs(self, hint.0, hint.1).near(&pt)+ || hint.0 < uknot_vec[0] - TOLERANCE+ || hint.0 - uknot_vec[0] > uknot_vec.range_length() + TOLERANCE+ || hint.1 < vknot_vec[0] - TOLERANCE+ || hint.1 - vknot_vec[0] > vknot_vec.range_length() + TOLERANCE+ {+ return false;+ }+ }+ }+ true+ }+}++impl IncludeCurve<BSplineCurve<Point3>> for BSplineSurface<Point3> {+ fn include(&self, curve: &BSplineCurve<Point3>) -> bool {+ let pt = curve.front();+ let mut hint = algo::surface::presearch(self, pt, self.range_tuple(), PRESEARCH_DIVISION);+ hint = match algo::surface::search_parameter3d(self, pt, hint, INCLUDE_CURVE_TRIALS) {+ Some(got) => got,+ None => return false,+ };+ let uknot_vec = self.uknot_vec();+ let vknot_vec = self.vknot_vec();+ let degree = curve.degree() * 6;+ let (knots, _) = curve.knot_vec().to_single_multi();+ for i in 1..knots.len() {+ for j in 1..=degree {+ let p = j as f64 / degree as f64;+ let t = knots[i - 1] * (1.0 - p) + knots[i] * p;+ let pt = ParametricCurve::subs(curve, t);+ hint = match algo::surface::search_parameter3d(self, pt, hint, INCLUDE_CURVE_TRIALS)+ {+ Some(got) => got,+ None => return false,+ };+ if !ParametricSurface::subs(self, hint.0, hint.1).near(&pt)+ || hint.0 < uknot_vec[0] - TOLERANCE+ || hint.0 - uknot_vec[0] > uknot_vec.range_length() + TOLERANCE+ || hint.1 < vknot_vec[0] - TOLERANCE+ || hint.1 - vknot_vec[0] > vknot_vec.range_length() + TOLERANCE+ {+ return false;+ }+ }+ }+ true+ }+}++impl IncludeCurve<NurbsCurve<Vector4>> for BSplineSurface<Point3> {+ fn include(&self, curve: &NurbsCurve<Vector4>) -> bool {+ let pt = curve.subs(curve.knot_vec()[0]);+ let mut hint = algo::surface::presearch(self, pt, self.range_tuple(), PRESEARCH_DIVISION);+ hint = match algo::surface::search_parameter3d(self, pt, hint, INCLUDE_CURVE_TRIALS) {+ Some(got) => got,+ None => return false,+ };+ let uknot_vec = self.uknot_vec();+ let vknot_vec = self.vknot_vec();+ let degree = curve.degree() * 6;+ let (knots, _) = curve.knot_vec().to_single_multi();+ for i in 1..knots.len() {+ for j in 1..=degree {+ let p = j as f64 / degree as f64;+ let t = knots[i - 1] * (1.0 - p) + knots[i] * p;+ let pt = curve.subs(t);+ hint = match algo::surface::search_parameter3d(self, pt, hint, INCLUDE_CURVE_TRIALS)+ {+ Some(got) => got,+ None => return false,+ };+ if !ParametricSurface::subs(self, hint.0, hint.1).near(&pt)+ || hint.0 < uknot_vec[0] - TOLERANCE+ || hint.0 - uknot_vec[0] > uknot_vec.range_length() + TOLERANCE+ || hint.1 < vknot_vec[0] - TOLERANCE+ || hint.1 - vknot_vec[0] > vknot_vec.range_length() + TOLERANCE+ {+ return false;+ }+ }+ }+ true+ }+}++macro_rules! impl_mat_multi {+ ($vector: ty, $matrix: ty) => {+ impl Mul<BSplineSurface<$vector>> for $matrix {+ type Output = BSplineSurface<$vector>;+ fn mul(self, mut spline: BSplineSurface<$vector>) -> Self::Output {+ spline+ .control_points+ .iter_mut()+ .flat_map(|vec| vec.iter_mut())+ .for_each(|vec| *vec = self * *vec);+ spline+ }+ }+ impl Mul<&BSplineSurface<$vector>> for $matrix {+ type Output = BSplineSurface<$vector>;+ fn mul(self, spline: &BSplineSurface<$vector>) -> Self::Output { self * spline.clone() }+ }+ };+}++macro_rules! impl_scalar_multi {+ ($vector: ty, $scalar: ty) => {+ impl_mat_multi!($vector, $scalar);+ impl Mul<$scalar> for &BSplineSurface<$vector> {+ type Output = BSplineSurface<$vector>;+ fn mul(self, scalar: $scalar) -> Self::Output { scalar * self }+ }+ impl Mul<$scalar> for BSplineSurface<$vector> {+ type Output = BSplineSurface<$vector>;+ fn mul(self, scalar: $scalar) -> Self::Output { scalar * self }+ }+ };+}++impl_mat_multi!(Vector2, Matrix2);+impl_scalar_multi!(Vector2, f64);+impl_mat_multi!(Vector3, Matrix3);+impl_scalar_multi!(Vector3, f64);+impl_mat_multi!(Vector4, Matrix4);+impl_scalar_multi!(Vector4, f64);++impl<M, P: EuclideanSpace<Scalar = f64>> Transformed<M> for BSplineSurface<P>+where M: Transform<P>+{+ #[inline(always)]+ fn transform_by(&mut self, trans: M) {+ self.control_points+ .iter_mut()+ .flatten()+ .for_each(|p| *p = trans.transform_point(*p))+ }+}++impl<'de, P> Deserialize<'de> for BSplineSurface<P>+where P: Deserialize<'de>+{+ fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>+ where D: serde::Deserializer<'de> {+ #[derive(Deserialize)]+ struct BSplineSurface_<P> {+ knot_vecs: (KnotVec, KnotVec),+ control_points: Vec<Vec<P>>,+ }+ let BSplineSurface_ {+ knot_vecs,+ control_points,+ } = BSplineSurface_::<P>::deserialize(deserializer)?;+ Self::try_new(knot_vecs, control_points).map_err(serde::de::Error::custom)+ }+}++fn combinatorial(n: usize) -> Vec<usize> {+ let mut res = vec![1];+ for i in 1..=n {+ res.push(res[i - 1] * (n - i + 1) / i);+ }+ res+}++#[test]+fn test_include_bspcurve2() {+ let knot_vec = KnotVec::uniform_knot(2, 3);+ let ctrl_pts = vec![+ vec![+ Point2::new(0.0, 0.0),+ Point2::new(0.1, 0.0),+ Point2::new(0.5, 0.0),+ Point2::new(0.7, 0.0),+ Point2::new(1.0, 0.0),+ ],+ vec![+ Point2::new(0.0, 0.1),+ Point2::new(0.2, 0.2),+ Point2::new(0.4, 0.3),+ Point2::new(0.6, 0.2),+ Point2::new(1.0, 0.3),+ ],+ vec![+ Point2::new(0.0, 0.5),+ Point2::new(0.3, 0.6),+ Point2::new(0.6, 0.4),+ Point2::new(0.9, 0.6),+ Point2::new(1.0, 0.5),+ ],+ vec![+ Point2::new(0.0, 0.7),+ Point2::new(0.2, 0.8),+ Point2::new(0.3, 0.6),+ Point2::new(0.5, 0.9),+ Point2::new(1.0, 0.7),+ ],+ vec![+ Point2::new(0.0, 1.0),+ Point2::new(0.1, 1.0),+ Point2::new(0.5, 1.0),+ Point2::new(0.7, 1.0),+ Point2::new(1.0, 1.0),+ ],+ ];+ let surface = BSplineSurface::new((knot_vec.clone(), knot_vec), ctrl_pts);++ let knot_vec0 = KnotVec::bezier_knot(2);+ let ctrl_pts0 = vec![+ Point2::new(0.0, 0.0),+ Point2::new(1.0, 1.0),+ Point2::new(0.0, 1.0),+ ];+ let curve0 = BSplineCurve::new(knot_vec0, ctrl_pts0);+ assert!(surface.include(&curve0));++ let knot_vec1 = KnotVec::bezier_knot(2);+ let ctrl_pts1 = vec![+ Point2::new(0.0, 0.0),+ Point2::new(2.5, 1.0),+ Point2::new(0.0, 1.0),+ ];+ let curve1 = BSplineCurve::new(knot_vec1, ctrl_pts1);+ assert!(!surface.include(&curve1));+}++#[test]+fn test_include_bspcurve3() {+ let knot_vec = KnotVec::uniform_knot(2, 3);+ let ctrl_pts = vec![+ vec![+ Point3::new(0.0, 0.0, 0.0),+ Point3::new(0.1, 0.0, 0.5),+ Point3::new(0.5, 0.0, 0.3),+ Point3::new(1.0, 0.0, 1.0),+ ],+ vec![+ Point3::new(0.0, 0.1, 0.1),+ Point3::new(0.2, 0.2, 0.1),+ Point3::new(0.4, 0.3, 0.4),+ Point3::new(1.0, 0.3, 0.7),+ ],+ vec![+ Point3::new(0.0, 0.5, 0.4),+ Point3::new(0.3, 0.6, 0.5),+ Point3::new(0.6, 0.4, 1.0),+ Point3::new(1.0, 0.5, 0.0),+ ],+ vec![+ Point3::new(0.0, 1.0, 1.0),+ Point3::new(0.1, 1.0, 1.0),+ Point3::new(0.5, 1.0, 0.5),+ Point3::new(1.0, 1.0, 0.3),+ ],+ ];+ let surface = BSplineSurface::new((knot_vec.clone(), knot_vec), ctrl_pts);+ let bnd_box = BoundingBox::from_iter(&[Vector2::new(0.2, 0.3), Vector2::new(0.8, 0.6)]);+ let mut curve = surface.sectional_curve(bnd_box);+ assert!(surface.include(&curve));+ *curve.control_point_mut(2) += Vector3::new(0.0, 0.0, 0.001);+ assert!(!surface.include(&curve));+}diff --git a/vendor/truck-geometry/src/nurbs/knot_vec.rs b/vendor/truck-geometry/src/nurbs/knot_vec.rsnew file mode 100644index 0000000000..c4a448b978--- /dev/null+++ b/vendor/truck-geometry/src/nurbs/knot_vec.rs@@ -0,0 +1,596 @@+use super::*;+use crate::errors::Error;+use std::slice::SliceIndex;+use std::vec::Vec;++impl KnotVec {+ /// empty constructor+ pub const fn new() -> KnotVec { KnotVec(Vec::new()) }++ /// Returns the length of range.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::from(vec![0.0, 6.0]);+ /// assert_eq!(knot_vec.range_length(), 6.0);+ /// ```+ #[inline(always)]+ pub fn range_length(&self) -> f64 {+ match self.is_empty() {+ true => 0.0,+ false => self[self.len() - 1] - self[0],+ }+ }++ /// Returns whether two knot vectors have the same range.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec0 = KnotVec::new(); // empty knot vector+ /// let knot_vec1 = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);+ /// let knot_vec2 = KnotVec::from(vec![0.0, 0.5, 1.0]);+ /// let knot_vec3 = KnotVec::from(vec![0.0, 0.0, 2.0, 2.0]);+ /// assert!(knot_vec0.same_range(&KnotVec::new())); // both empty knot vector+ /// assert!(!knot_vec0.same_range(&knot_vec1));+ /// assert!(knot_vec1.same_range(&knot_vec2)); // the range of both knot vector is [0, 1].+ /// assert!(!knot_vec1.same_range(&knot_vec3));+ /// ```+ #[inline(always)]+ pub fn same_range(&self, other: &KnotVec) -> bool {+ match (self.is_empty(), other.is_empty()) {+ (false, false) => {+ self[0].near(&other[0]) && self.range_length().near(&other.range_length())+ }+ (true, true) => true,+ _ => false,+ }+ }++ /// Removes one item.+ #[inline(always)]+ pub fn remove(&mut self, idx: usize) -> f64 { self.0.remove(idx) }++ /// Returns the maximum index `i` of `self[i] <= x`+ /// Return `None` if `x < self[0] or self.len() == 0`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::KnotVec;+ /// let mut knot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 2.0, 3.0, 3.0]);+ /// let idx = knot_vec.floor(1.5).unwrap();+ /// assert_eq!(idx, 2);+ /// ```+ #[inline(always)]+ pub fn floor(&self, x: f64) -> Option<usize> { self.iter().rposition(|t| *t <= x) }++ /// Returns the multiplicity of the `i`th knot+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::KnotVec;+ /// let knot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 2.0, 2.0, 2.0, 3.0, 3.0]);+ /// assert_eq!(knot_vec.multiplicity(5), 3);+ /// ```+ #[inline(always)]+ pub fn multiplicity(&self, i: usize) -> usize {+ self.iter().filter(|u| self[i].near(u)).count()+ }++ /// Adds a knot and return the index of the added knot.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::KnotVec;+ /// let mut knot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 2.0, 3.0, 3.0]);+ /// let idx0 = knot_vec.add_knot(1.5);+ /// assert_eq!(idx0, 3);+ /// let idx1 = knot_vec.add_knot(-1.0);+ /// assert_eq!(idx1, 0);+ /// let ansvec = KnotVec::from(vec![-1.0, 0.0, 0.0, 1.0, 1.5, 2.0, 3.0, 3.0]);+ /// assert_eq!(knot_vec, ansvec);+ /// ```+ #[inline(always)]+ pub fn add_knot(&mut self, knot: f64) -> usize {+ match self.floor(knot) {+ Some(idx) => {+ self.0.insert(idx + 1, knot);+ idx + 1+ }+ None => {+ self.0.insert(0, knot);+ 0+ }+ }+ }++ /// Calculates B-spline basis functions at `t` with degree `degree`.+ /// # Panics+ /// If the length of `self` is not more than `degree`, panic occurs.+ /// # Remarks+ /// In this package, the B-spline basis function is based on the characteristic function of+ /// the right-open intervals [s, t). So, the value corresponding to the end point t = t_n is always 0.0.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// const N : usize = 100; // sample size in tests+ ///+ /// // B-spline basis functions is a partition of unity in (t_k, t_{n - k}).+ /// let vec = vec![0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];+ /// let knot_vec = KnotVec::from(vec);+ /// let degree = 2;+ /// for i in 0..N {+ /// let t = 2.0 + 4.0 / (N as f64) * (i as f64);+ /// let res = knot_vec.bspline_basis_functions(degree, t);+ /// let sum = res.iter().fold(0.0, |sum, a| sum + a);+ /// assert_near2!(sum, 1.0);+ /// }+ /// ```+ /// ```+ /// use truck_geometry::prelude::*;+ /// const N : usize = 100; // sample size in tests+ ///+ /// // In some case, B-spline basis functions coincide with Bernstein polynomials.+ /// let vec = vec![0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0];+ /// let knot_vec = KnotVec::from(vec);+ /// let degree = 3;+ /// for i in 0..=N {+ /// let t = 1.0 / (N as f64) * (i as f64);+ /// let res = knot_vec.bspline_basis_functions(degree, t);+ /// let ans = [+ /// 1.0 * (1.0 - t) * (1.0 - t) * (1.0 - t),+ /// 3.0 * t * (1.0 - t) * (1.0 - t),+ /// 3.0 * t * t * (1.0 - t),+ /// 1.0 * t * t * t,+ /// ];+ /// for i in 0..4 { assert_near2!(res[i], ans[i]); }+ /// }+ /// ```+ pub fn bspline_basis_functions(&self, degree: usize, t: f64) -> Vec<f64> {+ match self.try_bspline_basis_functions(degree, t) {+ Ok(got) => got,+ Err(error) => panic!("{}", error),+ }+ }++ /// Calculates B-spline basis functions at `t` with degree `degree`.+ /// # Failures+ /// - If the range of the knot vector is zero, returns [`Error::ZeroRange`].+ /// - If the length of `self` is not more than `degree`, returns [`Error::TooLargeDegree`].+ /// # Remarks+ /// In this package, the B-spline basis function is based on the characteristic function of+ /// the right-open intervals [s, t). So, the value corresponding to the end point t = t_n is always 0.0.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// const N : usize = 100; // sample size in tests+ ///+ /// // B-spline basis functions is a partition of unity in (t_k, t_{n - k}).+ /// let vec = vec![0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];+ /// let knot_vec = KnotVec::from(vec);+ /// let degree = 2;+ /// for i in 0..N {+ /// let t = 2.0 + 4.0 / (N as f64) * (i as f64);+ /// let res = knot_vec.try_bspline_basis_functions(degree, t).unwrap();+ /// let sum = res.iter().fold(0.0, |sum, a| sum + a);+ /// assert_near2!(sum, 1.0);+ /// }+ /// ```+ /// ```+ /// use truck_geometry::prelude::*;+ /// const N : usize = 100; // sample size in tests+ ///+ /// // In some case, B-spline basis functions coincide with Bernstein polynomials.+ /// let vec = vec![0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0];+ /// let knot_vec = KnotVec::from(vec);+ /// let degree = 3;+ /// for i in 0..=N {+ /// let t = i as f64 / N as f64;+ /// let res = knot_vec.try_bspline_basis_functions(degree, t).unwrap();+ /// let ans = [+ /// 1.0 * (1.0 - t) * (1.0 - t) * (1.0 - t),+ /// 3.0 * t * (1.0 - t) * (1.0 - t),+ /// 3.0 * t * t * (1.0 - t),+ /// 1.0 * t * t * t,+ /// ];+ /// for i in 0..4 { assert_near2!(res[i], ans[i]); }+ /// }+ /// ```+ pub fn try_bspline_basis_functions(&self, degree: usize, t: f64) -> Result<Vec<f64>> {+ let n = self.len() - 1;+ if self[0].near(&self[n]) {+ return Err(Error::ZeroRange);+ } else if n < degree {+ return Err(Error::TooLargeDegree(n + 1, degree));+ }++ let idx = {+ let idx = self+ .floor(t)+ .unwrap_or_else(|| self.floor(self[0]).unwrap());+ if idx == n {+ n - self.multiplicity(n)+ } else {+ idx+ }+ };+ let mut res = vec![0.0; n];+ res[idx] = 1.0;++ for k in 1..=degree {+ let base = if idx < k { 0 } else { idx - k };+ let delta = self[base + k] - self[base];+ let max = if idx + k < n { idx } else { n - k - 1 };+ let mut a = inv_or_zero(delta) * (t - self[base]);+ for i in base..=max {+ let delta = self[i + k + 1] - self[i + 1];+ let b = inv_or_zero(delta) * (self[i + k + 1] - t);+ res[i] = a * res[i] + b * res[i + 1];+ a = 1.0 - b;+ }+ }++ res.truncate(n - degree);+ Ok(res)+ }++ #[doc(hidden)]+ pub fn maximum_points(&self, degree: usize) -> Vec<f64> {+ let n = self.len();+ let m = n - degree - 1;+ let range = self.range_length();+ const N: i32 = 100;++ let mut res = vec![0.0; m];+ let mut max = vec![0.0; m];+ for i in 1..N {+ let t = self[0] + range * (i as f64) / (N as f64);+ let vals = self.try_bspline_basis_functions(degree, t).unwrap();+ for j in 0..m {+ if max[j] < vals[j] {+ max[j] = vals[j];+ res[j] = t;+ }+ }+ }++ res+ }++ /// Transforms the knot vector+ /// # Examples+ /// ```+ /// use std::vec::Vec;+ /// use truck_geometry::prelude::KnotVec;+ /// let mut knot_vec = KnotVec::from(vec![1.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0]);+ /// knot_vec.transform(2.0, 3.0);+ /// let res : Vec<f64> = knot_vec.into();+ /// assert_eq!(res, vec![5.0, 5.0, 7.0, 9.0, 11.0, 13.0, 13.0]);+ /// ```+ /// # Panics+ /// Panic occurs if `scalar` is not positive.+ pub fn transform(&mut self, scalar: f64, r#move: f64) -> &mut Self {+ assert!(scalar > 0.0, "The scalar {scalar} is not positive.");+ self.0+ .iter_mut()+ .for_each(move |vec| *vec = *vec * scalar + r#move);+ self+ }++ /// Normalizes the knot vector i.e. makes the first value 0 and the last value 1.+ /// # Failures+ /// Returns [`Error::ZeroRange`] if the range of the knot vector is so small.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::KnotVec;+ /// let mut knot_vec = KnotVec::from(vec![1.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0]);+ /// knot_vec.try_normalize().unwrap();+ /// let res : Vec<f64> = knot_vec.into();+ /// assert_eq!(res, vec![0.0, 0.0, 0.25, 0.5, 0.75, 1.0, 1.0]);+ /// ```+ pub fn try_normalize(&mut self) -> Result<&mut Self> {+ let range = self.range_length();+ if range.so_small() {+ return Err(Error::ZeroRange);+ }+ Ok(self.transform(1.0 / range, -self[0] / range))+ }++ /// Normalizes the knot vector i.e. makes the first value 0 and the last value 1.+ /// # Panics+ /// Panic occurs if the range of the knot vector is so small.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::KnotVec;+ /// let mut knot_vec = KnotVec::from(vec![1.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0]);+ /// knot_vec.normalize();+ /// let res : Vec<f64> = knot_vec.into();+ /// assert_eq!(res, vec![0.0, 0.0, 0.25, 0.5, 0.75, 1.0, 1.0]);+ /// ```+ #[inline(always)]+ pub fn normalize(&mut self) -> &mut Self {+ self.try_normalize()+ .unwrap_or_else(|error| panic!("{}", error))+ }++ /// Translates the knot vector+ /// # Example+ /// ```+ /// use std::vec::Vec;+ /// use truck_geometry::prelude::KnotVec;+ /// let mut knot_vec = KnotVec::from(vec![1.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0]);+ /// knot_vec.translate(3.0);+ /// let res : Vec<f64> = knot_vec.into();+ /// assert_eq!(res, vec![4.0, 4.0, 5.0, 6.0, 7.0, 8.0, 8.0]);+ /// ```+ pub fn translate(&mut self, x: f64) -> &mut Self { self.transform(1.0, x) }++ /// Inverts the knot vector+ /// # Example+ /// ```+ /// use std::vec::Vec;+ /// use truck_geometry::prelude::KnotVec;+ /// let mut knot_vec = KnotVec::from(vec![1.0, 1.0, 1.0, 3.0, 5.0, 6.0]);+ /// knot_vec.invert();+ /// let res : Vec<f64> = knot_vec.into();+ /// assert_eq!(res, vec![1.0, 2.0, 4.0, 6.0, 6.0, 6.0]);+ ///+ /// ```+ pub fn invert(&mut self) -> &mut Self {+ let n = self.len();+ if n == 0 {+ return self;+ }+ let range = self[0] + self[n - 1];+ let clone = self.0.clone();+ for (knot1, knot0) in clone.iter().rev().zip(&mut self.0) {+ *knot0 = range - knot1;+ }+ self+ }++ /// Determines the knot vector is clamped for the given degree.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::KnotVec;+ /// let knot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 0.25, 0.5, 0.75, 1.0, 1.0, 1.0]);+ /// assert!(knot_vec.is_clamped(2));+ /// assert!(!knot_vec.is_clamped(3));+ /// ```+ #[inline(always)]+ pub fn is_clamped(&self, degree: usize) -> bool {+ self.multiplicity(0) > degree && self.multiplicity(self.len() - 1) > degree+ }++ /// Concats two knot vectors.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::KnotVec;+ /// let mut knot_vec0 = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);+ /// let knot_vec1 = KnotVec::from(vec![1.0, 1.0, 1.0, 2.0, 2.0, 2.0]);+ /// knot_vec0.try_concat(&knot_vec1, 2).unwrap();+ /// assert_eq!(knot_vec0.as_slice(), &[0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0]);+ /// ```+ /// # Failures+ /// - If at least one of `self` or `other` is not clamped, returns [`Error::NotClampedKnotVector`]+ /// - If the last knot of `self` and the first knot of `other` are different, returns [`Error::DifferentBackFront`].+ pub fn try_concat(&mut self, other: &KnotVec, degree: usize) -> Result<&mut Self> {+ if !self.is_clamped(degree) || !other.is_clamped(degree) {+ return Err(Error::NotClampedKnotVector);+ }+ let back = self.0.last().unwrap();+ let front = other.0.first().unwrap();+ if front < back || !front.near(back) {+ return Err(Error::DifferentBackFront(*back, *front));+ }++ self.0.truncate(self.len() - degree - 1);+ for knot in &other.0 {+ self.0.push(*knot);+ }++ Ok(self)+ }++ /// Concats two knot vectors.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::KnotVec;+ /// let mut knot_vec0 = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);+ /// let knot_vec1 = KnotVec::from(vec![1.0, 1.0, 1.0, 2.0, 2.0, 2.0]);+ /// knot_vec0.concat(&knot_vec1, 2);+ /// assert_eq!(knot_vec0.as_slice(), &[0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0]);+ /// ```+ /// # Panics+ /// Panic occurs if:+ /// - at least one of `self` or `other` is not clamped.+ /// - the last knot of `self` and the first knot of `other` are different.+ #[inline(always)]+ pub fn concat(&mut self, other: &KnotVec, degree: usize) -> &mut Self {+ self.try_concat(other, degree)+ .unwrap_or_else(|error| panic!("{}", error))+ }++ /// Returns trimmed vector by the specified range.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::from(vec![0.0, 1.0, 2.0, 3.0, 4.0, 5.0]);+ /// let sub_vec = knot_vec.sub_vec(1..3);+ /// assert_eq!(sub_vec, KnotVec::from(vec![1.0, 2.0]));+ /// ```+ #[inline(always)]+ pub fn sub_vec<I: SliceIndex<[f64], Output = [f64]>>(&self, range: I) -> KnotVec {+ KnotVec(Vec::from(&self.0[range]))+ }++ /// To single-multi description. i.e. decompose the unique vector of knots and the vector of+ /// multiplicity of knots.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::KnotVec;+ /// let knot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 2.0, 2.0, 2.0, 2.0, 3.0, 3.0]);+ /// let (knots, mults) = knot_vec.to_single_multi();+ /// assert_eq!(knots, vec![0.0, 1.0, 2.0, 3.0]);+ /// assert_eq!(mults, vec![3, 1, 4, 2]);+ /// ```+ pub fn to_single_multi(&self) -> (Vec<f64>, Vec<usize>) {+ let mut knots = Vec::new();+ let mut mults = Vec::new();++ let mut iter = self.as_slice().iter().peekable();+ let mut mult = 1;+ while let Some(knot) = iter.next() {+ if let Some(next) = iter.peek() {+ if knot.near(next) {+ mult += 1;+ } else {+ knots.push(*knot);+ mults.push(mult);+ mult = 1;+ }+ } else {+ knots.push(*knot);+ mults.push(mult);+ }+ }+ (knots, mults)+ }++ /// Constructs from single-multi description.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::KnotVec;+ /// let knots = vec![0.0, 1.0, 2.0, 3.0];+ /// let mults = vec![3, 1, 4, 2];+ /// let knot_vec = KnotVec::from_single_multi(knots, mults).unwrap();+ /// assert_eq!(knot_vec, KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 2.0, 2.0, 2.0, 2.0, 3.0, 3.0]));+ /// ```+ pub fn from_single_multi(knots: Vec<f64>, mults: Vec<usize>) -> Result<KnotVec> {+ for i in 1..knots.len() {+ if knots[i - 1] > knots[i] {+ return Err(Error::NotSortedVector);+ }+ }++ let mut vec = Vec::new();+ for i in 0..knots.len() {+ for _ in 0..mults[i] {+ vec.push(knots[i]);+ }+ }+ Ok(KnotVec(vec))+ }+ /// Constructs from `Vec<f64>`. do not sort, only check sorted.+ pub fn try_from(vec: Vec<f64>) -> Result<KnotVec> {+ for i in 1..vec.len() {+ if vec[i - 1] > vec[i] {+ return Err(Error::NotSortedVector);+ }+ }+ Ok(KnotVec(vec))+ }++ /// Constructs the knot vector for the bezier spline.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// assert_eq!(+ /// *KnotVec::bezier_knot(3),+ /// vec![0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0],+ /// );+ /// ```+ pub fn bezier_knot(degree: usize) -> KnotVec {+ let mut vec = vec![0.0; degree + 1];+ vec.extend(std::iter::repeat(1.0).take(degree + 1));+ KnotVec(vec)+ }++ /// Constructs the uniform knot vector+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// assert_eq!(+ /// *KnotVec::uniform_knot(2, 5),+ /// vec![0.0, 0.0, 0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.0, 1.0],+ /// );+ /// ```+ pub fn uniform_knot(degree: usize, division: usize) -> KnotVec {+ let mut vec = vec![0.0; degree + 1];+ vec.extend((1..division).map(|i| (i as f64) / (division as f64)));+ vec.extend(std::iter::repeat(1.0).take(degree + 1));+ KnotVec(vec)+ }+}++impl From<Vec<f64>> for KnotVec {+ /// constructs from `Vec<f64>`. The vector will sorted by the order.+ /// ```+ /// use truck_geometry::prelude::KnotVec;+ /// let knot_vec = KnotVec::from(vec![1.0, 0.0, 3.0, 2.0]);+ /// let arr : Vec<f64> = knot_vec.into();+ /// assert_eq!(arr, vec![0.0, 1.0, 2.0, 3.0]);+ /// ```+ fn from(mut vec: Vec<f64>) -> KnotVec {+ vec.sort_by(|a, b| a.partial_cmp(b).unwrap());+ KnotVec(vec)+ }+}++impl From<&Vec<f64>> for KnotVec {+ /// Constructs by the reference of vector. The clone of vector is sorted by the order.+ /// ```+ /// use truck_geometry::prelude::KnotVec;+ /// let knot_vec = KnotVec::from(&vec![1.0, 0.0, 3.0, 2.0]);+ /// let arr : Vec<f64> = knot_vec.into();+ /// assert_eq!(arr, vec![0.0, 1.0, 2.0, 3.0]);+ /// ```+ #[inline(always)]+ fn from(vec: &Vec<f64>) -> KnotVec {+ let mut copy_vec = vec.clone();+ copy_vec.sort_by(|a, b| a.partial_cmp(b).unwrap());+ KnotVec(copy_vec)+ }+}++impl From<KnotVec> for Vec<f64> {+ /// `KnotVec` into `Vec<f64>`+ /// ```+ /// use truck_geometry::prelude::KnotVec;+ /// let vec = vec![0.0, 1.0, 2.0, 3.0];+ /// let knot_vec = KnotVec::from(&vec);+ /// let vec0 : Vec<f64> = knot_vec.into();+ /// assert_eq!(vec, vec0);+ /// ```+ #[inline(always)]+ fn from(knotvec: KnotVec) -> Vec<f64> { knotvec.0 }+}++impl FromIterator<f64> for KnotVec {+ #[inline(always)]+ fn from_iter<I: IntoIterator<Item = f64>>(iter: I) -> KnotVec {+ KnotVec::try_from(iter.into_iter().collect::<Vec<_>>()).unwrap()+ }+}++impl<'a> IntoIterator for &'a KnotVec {+ type Item = &'a f64;+ type IntoIter = std::slice::Iter<'a, f64>;+ #[inline(always)]+ fn into_iter(self) -> Self::IntoIter { self.0.iter() }+}++impl std::ops::Deref for KnotVec {+ type Target = Vec<f64>;+ #[inline(always)]+ fn deref(&self) -> &Vec<f64> { &self.0 }+}++impl AsRef<[f64]> for KnotVec {+ #[inline(always)]+ fn as_ref(&self) -> &[f64] { &self.0 }+}++impl<'de> Deserialize<'de> for KnotVec {+ fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>+ where D: serde::Deserializer<'de> {+ let vec = Vec::<f64>::deserialize(deserializer)?;+ Self::try_from(vec).map_err(serde::de::Error::custom)+ }+}diff --git a/vendor/truck-geometry/src/nurbs/mod.rs b/vendor/truck-geometry/src/nurbs/mod.rsnew file mode 100644index 0000000000..24a553133d--- /dev/null+++ b/vendor/truck-geometry/src/nurbs/mod.rs@@ -0,0 +1,135 @@+use crate::{prelude::*, *};+use truck_base::cgmath64::control_point::ControlPoint;++/// knot vector+#[derive(Clone, PartialEq, Debug, Default, Serialize)]+pub struct KnotVec(Vec<f64>);++/// B-spline curve+/// # Examples+/// ```+/// use truck_geometry::prelude::*;+///+/// // the knot vector+/// let knot_vec = KnotVec::from(+/// vec![0.0, 0.0, 0.0, 0.25, 0.25, 0.5, 0.5, 0.75, 0.75, 1.0, 1.0, 1.0]+/// );+///+/// // sign up the control points in the vector of all points+/// let ctrl_pts = vec![ // the vector of the indices of control points+/// Vector4::new(0.0, -2.0, 0.0, 2.0),+/// Vector4::new(1.0, -1.0, 0.0, 1.0),+/// Vector4::new(1.0, 0.0, 0.0, 1.0),+/// Vector4::new(1.0, 1.0, 0.0, 1.0),+/// Vector4::new(0.0, 2.0, 0.0, 2.0),+/// Vector4::new(-1.0, 1.0, 0.0, 1.0),+/// Vector4::new(-1.0, 0.0, 0.0, 1.0),+/// Vector4::new(-1.0, -1.0, 0.0, 1.0),+/// Vector4::new(0.0, -2.0, 0.0, 2.0),+/// ];+///+/// // construct the B-spline curve+/// let bspline = BSplineCurve::new(knot_vec, ctrl_pts);+///+/// // This B-spline curve is a nurbs representation of the unit circle.+/// const N : usize = 100; // sample size in test+/// for i in 0..N {+/// let t = 1.0 / (N as f64) * (i as f64);+/// let v = bspline.subs(t); // We can use the instances as a function.+/// let c = (v[0] / v[3]).powi(2) + (v[1] / v[3]).powi(2);+/// assert_near2!(c, 1.0);+/// }+/// ```+#[derive(Clone, PartialEq, Debug, Serialize)]+pub struct BSplineCurve<P> {+ knot_vec: KnotVec, // the knot vector+ control_points: Vec<P>, // the indices of control points+}++/// B-spline surface+/// # Examples+/// ```+/// use truck_geometry::prelude::*;+/// const N : usize = 100; // sample size in test+///+/// // the knot vectors+/// let knot_vec0 = KnotVec::bezier_knot(3);+/// let knot_vec1 = KnotVec::from(+/// vec![0.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 1.0, 1.0]+/// );+/// let knot_vecs = (knot_vec0, knot_vec1);+///+/// // the control points+/// let mut v = vec![vec![Vector4::zero(); 7]; 4];+/// v[0][0] = Vector4::new(0.0, 0.0, 1.0, 1.0);+/// v[0][1] = &v[0][0] / 3.0;+/// v[0][2] = v[0][1].clone();+/// v[0][3] = v[0][0].clone();+/// v[0][4] = v[0][1].clone();+/// v[0][5] = v[0][1].clone();+/// v[0][6] = v[0][0].clone();+/// v[1][0] = Vector4::new(2.0, 0.0, 1.0, 1.0) / 3.0;+/// v[1][1] = Vector4::new(2.0, 4.0, 1.0, 1.0) / 9.0;+/// v[1][2] = Vector4::new(-2.0, 4.0, 1.0, 1.0) / 9.0;+/// v[1][3] = Vector4::new(-2.0, 0.0, 1.0, 1.0) / 3.0;+/// v[1][4] = Vector4::new(-2.0, -4.0, 1.0, 1.0) / 9.0;+/// v[1][5] = Vector4::new(2.0, -4.0, 1.0, 1.0) / 9.0;+/// v[1][6] = Vector4::new(2.0, 0.0, 1.0, 1.0) / 3.0;+/// v[2][0] = Vector4::new(2.0, 0.0, -1.0, 1.0) / 3.0;+/// v[2][1] = Vector4::new(2.0, 4.0, -1.0, 1.0) / 9.0;+/// v[2][2] = Vector4::new(-2.0, 4.0, -1.0, 1.0) / 9.0;+/// v[2][3] = Vector4::new(-2.0, 0.0, -1.0, 1.0) / 3.0;+/// v[2][4] = Vector4::new(-2.0, -4.0, -1.0, 1.0) / 9.0;+/// v[2][5] = Vector4::new(2.0, -4.0, -1.0, 1.0) / 9.0;+/// v[2][6] = Vector4::new(2.0, 0.0, -1.0, 1.0) / 3.0;+/// v[3][0] = Vector4::new(0.0, 0.0, -1.0, 1.0);+/// v[3][1] = &v[3][0] / 3.0;+/// v[3][2] = v[3][1].clone();+/// v[3][3] = v[3][0].clone();+/// v[3][4] = v[3][1].clone();+/// v[3][5] = v[3][1].clone();+/// v[3][6] = v[3][0].clone();+///+/// // cunstruct the B-spline curve+/// let bspline = BSplineSurface::new(knot_vecs, v);+///+/// // This B-spline curve is a nurbs representation of the unit sphere.+/// for i in 0..N {+/// for j in 0..N {+/// let u = 1.0 / (N as f64) * (i as f64);+/// let v = 1.0 / (N as f64) * (j as f64);+/// let v = bspline.subs(u, v); // We can use the instances as a function.+/// let c = (v[0] / v[3]).powi(2) + (v[1] / v[3]).powi(2) + (v[2] / v[3]).powi(2);+/// assert_near2!(c, 1.0);+/// }+/// }+/// ```+#[derive(Clone, PartialEq, Debug, Serialize)]+pub struct BSplineSurface<P> {+ knot_vecs: (KnotVec, KnotVec),+ control_points: Vec<Vec<P>>,+}++/// NURBS curve+#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]+pub struct NurbsCurve<V>(BSplineCurve<V>);++/// NURBS surface+#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]+pub struct NurbsSurface<V>(BSplineSurface<V>);++mod bspcurve;+mod bspsurface;+mod knot_vec;+mod nurbscurve;+mod nurbssurface;++#[doc(hidden)]+#[inline(always)]+pub fn inv_or_zero(delta: f64) -> f64 {+ if delta.so_small() {+ 0.0+ } else {+ 1.0 / delta+ }+}diff --git a/vendor/truck-geometry/src/nurbs/nurbscurve.rs b/vendor/truck-geometry/src/nurbs/nurbscurve.rsnew file mode 100644index 0000000000..b6a769a217--- /dev/null+++ b/vendor/truck-geometry/src/nurbs/nurbscurve.rs@@ -0,0 +1,619 @@+use super::*;++impl<V> NurbsCurve<V> {+ /// Constructs the rationalized B-spline curve.+ #[inline(always)]+ pub const fn new(curve: BSplineCurve<V>) -> Self { NurbsCurve(curve) }++ /// Returns the BSpline curve before rationalized.+ #[inline(always)]+ pub const fn non_rationalized(&self) -> &BSplineCurve<V> { &self.0 }++ /// Returns the BSpline curve before rationalized.+ #[inline(always)]+ pub fn into_non_rationalized(self) -> BSplineCurve<V> { self.0 }++ /// Returns the reference of the knot vector. cf.[`BSplineCurve::knot_vec`]+ #[inline(always)]+ pub const fn knot_vec(&self) -> &KnotVec { &self.0.knot_vec }++ /// Returns the `idx`th knot. cf.[`BSplineCurve::knot`]+ #[inline(always)]+ pub fn knot(&self, idx: usize) -> f64 { self.0.knot_vec[idx] }++ /// Returns the reference of the control points. cf.[`BSplineCurve::control_points`]+ #[inline(always)]+ pub const fn control_points(&self) -> &Vec<V> { &self.0.control_points }++ /// Returns the reference of the control point corresponding to the index `idx`.+ /// cf.[`BSplineCurve::control_point`]+ #[inline(always)]+ pub fn control_point(&self, idx: usize) -> &V { &self.0.control_points[idx] }++ /// Returns the mutable reference of the control point corresponding to index `idx`.+ /// cf.[`BSplineCurve::control_point_mut`]+ #[inline(always)]+ pub fn control_point_mut(&mut self, idx: usize) -> &mut V { &mut self.0.control_points[idx] }++ /// Returns the iterator on all control points. cf.[`BSplineCurve::control_points_mut`]+ #[inline(always)]+ pub fn control_points_mut(&mut self) -> impl Iterator<Item = &mut V> {+ self.0.control_points.iter_mut()+ }++ /// Applies the given transformation to all control points. cf.[`BSplineCurve::transform_control_points`]+ #[inline(always)]+ pub fn transform_control_points<F: FnMut(&mut V)>(&mut self, f: F) {+ self.0.transform_control_points(f)+ }++ /// Returns the degree of NURBS curve. cf.[`BSplineCurve::degree`]+ #[inline(always)]+ pub fn degree(&self) -> usize { self.0.degree() }++ /// Inverts a curve. cf.[`BSplineCurve::invert`]+ #[inline(always)]+ pub fn invert(&mut self) -> &mut Self {+ self.0.invert();+ self+ }++ /// Returns whether the knot vector is clamped or not. cf.[`BSplineCurve::is_clamped`]+ #[inline(always)]+ pub fn is_clamped(&self) -> bool { self.0.knot_vec.is_clamped(self.0.degree()) }++ /// Normalizes the knot vector. cf.[`BSplineCurve::knot_normalize`]+ #[inline(always)]+ pub fn knot_normalize(&mut self) -> &mut Self {+ self.0.knot_vec.try_normalize().unwrap();+ self+ }++ /// Translates the knot vector. cf.[`BSplineCurve::knot_translate`]+ #[inline(always)]+ pub fn knot_translate(&mut self, x: f64) -> &mut Self {+ self.0.knot_vec.translate(x);+ self+ }+}++impl<V: Homogeneous<f64>> NurbsCurve<V> {+ /// Constructs a rationalization curve from the non-rationalized curve and weights.+ /// # Failures+ /// the length of `curve.control_points()` and `weights` must be the same.+ #[inline(always)]+ pub fn try_from_bspline_and_weights(+ curve: BSplineCurve<V::Point>,+ weights: Vec<f64>,+ ) -> Result<Self> {+ let BSplineCurve {+ knot_vec,+ control_points,+ } = curve;+ if control_points.len() != weights.len() {+ return Err(Error::DifferentLength);+ }+ let control_points = control_points+ .into_iter()+ .zip(weights)+ .map(|(pt, w)| V::from_point_weight(pt, w))+ .collect();+ Ok(Self(BSplineCurve::new_unchecked(knot_vec, control_points)))+ }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> NurbsCurve<V> {+ /// Returns the closure of substitution.+ #[inline(always)]+ pub fn get_closure(&self) -> impl Fn(f64) -> V::Point + '_ { move |t| self.subs(t) }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> NurbsCurve<V>+where V::Point: Tolerance+{+ /// Returns whether all control points are the same or not.+ /// If the knot vector is clamped, it means whether the curve is constant or not.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ ///+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let pt = Vector3::new(1.0, 2.0, 1.0);+ /// // allows differences upto scalars+ /// let mut ctrl_pts = vec![pt.clone(), pt.clone() * 2.0, pt.clone() * 3.0];+ /// let bspcurve = BSplineCurve::new(knot_vec.clone(), ctrl_pts.clone());+ /// assert!(!bspcurve.is_const());+ /// let const_curve = NurbsCurve::new(bspcurve);+ /// assert!(const_curve.is_const());+ ///+ /// ctrl_pts.push(Vector3::new(2.0, 3.0, 1.0));+ /// let curve = NurbsCurve::new(BSplineCurve::new(knot_vec.clone(), ctrl_pts.clone()));+ /// assert!(!curve.is_const());+ /// ```+ /// # Remarks+ /// If the knot vector is not clamped and the BSpline basis function is not partition of unity,+ /// then perhaps returns true even if the curve is not constant.+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::uniform_knot(1, 5);+ /// let ctrl_pts = vec![Vector2::new(1.0, 2.0), Vector2::new(1.0, 2.0)];+ /// let bspcurve = BSplineCurve::new(knot_vec, ctrl_pts);+ ///+ /// // bspcurve is not constant.+ /// assert_eq!(bspcurve.subs(0.0), Vector2::new(0.0, 0.0));+ /// assert_ne!(bspcurve.subs(0.5), Vector2::new(0.0, 0.0));+ ///+ /// // bspcurve.is_const() is true+ /// assert!(bspcurve.is_const());+ /// ```+ pub fn is_const(&self) -> bool {+ let pt = self.0.control_points[0].to_point();+ self.0+ .control_points+ .iter()+ .all(move |vec| vec.to_point().near(&pt))+ }+ /// Determines whether `self` and `other` is near as the B-spline curves or not.+ ///+ /// Divides each knot interval into the number of degree equal parts,+ /// and check `|self(t) - other(t)| < TOLERANCE` for each end points `t`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::from(+ /// vec![0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 4.0, 4.0]+ /// );+ /// let ctrl_pts = vec![+ /// Vector3::new(1.0, 1.0, 1.0),+ /// Vector3::new(3.0, 2.0, 2.0),+ /// Vector3::new(2.0, 3.0, 1.0),+ /// Vector3::new(4.0, 5.0, 2.0),+ /// Vector3::new(5.0, 4.0, 1.0),+ /// Vector3::new(1.0, 1.0, 2.0),+ /// ];+ /// let curve0 = NurbsCurve::new(BSplineCurve::new(knot_vec, ctrl_pts));+ /// let mut curve1 = curve0.clone();+ /// assert!(curve0.near_as_curve(&curve1));+ /// *curve1.control_point_mut(1) += Vector3::new(0.01, 0.0002, 0.0);+ /// assert!(!curve0.near_as_curve(&curve1));+ /// ```+ #[inline(always)]+ pub fn near_as_curve(&self, other: &Self) -> bool {+ self.0+ .sub_near_as_curve(&other.0, 2, move |x, y| x.to_point().near(&y.to_point()))+ }++ /// Determines `self` and `other` is near in square order as the B-spline curves or not.+ ///+ /// Divide each knot interval into the number of degree equal parts,+ /// and check `|self(t) - other(t)| < TOLERANCE`for each end points `t`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::from(+ /// vec![0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 4.0, 4.0]+ /// );+ /// let ctrl_pts = vec![+ /// Vector3::new(1.0, 1.0, 1.0),+ /// Vector3::new(3.0, 2.0, 2.0),+ /// Vector3::new(2.0, 3.0, 1.0),+ /// Vector3::new(4.0, 5.0, 2.0),+ /// Vector3::new(5.0, 4.0, 1.0),+ /// Vector3::new(1.0, 1.0, 2.0),+ /// ];+ /// let curve0 = NurbsCurve::new(BSplineCurve::new(knot_vec, ctrl_pts));+ /// let mut curve1 = curve0.clone();+ /// assert!(curve0.near_as_curve(&curve1));+ /// *curve1.control_point_mut(1) += Vector3::new(0.01, TOLERANCE, 0.0);+ /// assert!(!curve0.near2_as_curve(&curve1));+ /// ```+ #[inline(always)]+ pub fn near2_as_curve(&self, other: &Self) -> bool {+ self.0+ .sub_near_as_curve(&other.0, 2, move |x, y| x.to_point().near2(&y.to_point()))+ }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V> + Tolerance> NurbsCurve<V> {+ /// Adds a knot `x`, and do not change `self` as a curve. cf.[`BSplineCurve::add_knot`]+ pub fn add_knot(&mut self, x: f64) -> &mut Self {+ self.0.add_knot(x);+ self+ }++ /// Removes a knot corresponding to the indices `idx`, and do not change `self` as a curve.+ /// If cannot remove the knot, do not change `self` and return `self`.+ /// cf.[`BSplineCurve::remove_knot`]+ pub fn remove_knot(&mut self, idx: usize) -> &mut Self {+ let _ = self.try_remove_knot(idx);+ self+ }++ /// Removes a knot corresponding to the indice `idx`, and do not change `self` as a curve.+ /// If the knot cannot be removed, returns [`Error::CannotRemoveKnot`].+ /// cf.[`BSplineCurve::try_remove_knot`]+ pub fn try_remove_knot(&mut self, idx: usize) -> Result<&mut Self> {+ self.0.try_remove_knot(idx)?;+ Ok(self)+ }++ /// Elevates 1 degree. cf.[`BSplineCurve::elevate_degree`]+ pub fn elevate_degree(&mut self) -> &mut Self {+ self.0.elevate_degree();+ self+ }++ /// Makes the NURBS curve clamped. cf.[`BSplineCurve::clamp`]+ #[inline(always)]+ pub fn clamp(&mut self) -> &mut Self {+ self.0.clamp();+ self+ }++ /// Repeats `Self::try_remove_knot()` from the back knot in turn until the knot cannot be removed.+ /// cf.[`BSplineCurve::optimize`]+ pub fn optimize(&mut self) -> &mut Self {+ self.0.optimize();+ self+ }++ /// Makes two splines having the same degrees. cf.[`BSplineCurve::syncro_degree`]+ pub fn syncro_degree(&mut self, other: &mut Self) {+ let (degree0, degree1) = (self.degree(), other.degree());+ for _ in degree0..degree1 {+ self.elevate_degree();+ }+ for _ in degree1..degree0 {+ other.elevate_degree();+ }+ }++ /// Makes two splines having the same normalized knot vectors. cf.[`BSplineCurve::syncro_knots`]+ pub fn syncro_knots(&mut self, other: &mut Self) { self.0.syncro_knots(&mut other.0) }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V> + Tolerance> ParameterTransform+ for NurbsCurve<V>+{+ #[inline(always)]+ fn parameter_transform(&mut self, scalar: f64, r#move: f64) -> &mut Self {+ self.0.parameter_transform(scalar, r#move);+ self+ }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V> + Tolerance> Cut for NurbsCurve<V> {+ #[inline(always)]+ fn cut(&mut self, t: f64) -> Self { NurbsCurve(self.0.cut(t)) }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V> + Tolerance> Concat<NurbsCurve<V>>+ for NurbsCurve<V>+where <V as Homogeneous<f64>>::Point: Debug+{+ type Output = NurbsCurve<V>;+ fn try_concat(+ &self,+ other: &Self,+ ) -> std::result::Result<Self, ConcatError<<V as Homogeneous<f64>>::Point>> {+ let curve0 = self.clone();+ let mut curve1 = other.clone();+ let w0 = curve0.0.control_points.last().unwrap().weight();+ let w1 = curve1.0.control_points[0].weight();+ curve1.transform_control_points(|pt| *pt *= w0 / w1);+ match curve0.0.try_concat(&curve1.0) {+ Ok(curve) => Ok(NurbsCurve::new(curve)),+ Err(err) => Err(err.point_map(|v| v.to_point())),+ }+ }+}++#[test]+fn concat_positive_test() {+ let mut part0 = NurbsCurve::new(BSplineCurve::new(+ KnotVec::uniform_knot(4, 4),+ (0..8)+ .map(|_| {+ Vector4::new(+ rand::random::<f64>(),+ rand::random::<f64>(),+ rand::random::<f64>(),+ rand::random::<f64>() + 0.5,+ )+ })+ .collect(),+ ));+ let mut part1 = part0.cut(0.56);+ let w = 20.0 * rand::random::<f64>() - 10.0;+ part1.transform_control_points(|vec| *vec *= w);+ assert_near!(part0.back(), part1.front());+ concat_random_test(&part0, &part1, 10);+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V> + Tolerance> NurbsCurve<V>+where V::Point: Tolerance+{+ /// Makes the rational curve locally injective.+ /// # Example+ /// ```+ /// use truck_geometry::prelude::*;+ /// const N : usize = 100; // sample size for test+ ///+ /// let knot_vec = KnotVec::from(+ /// vec![0.0, 0.0, 0.0, 1.0, 3.0, 4.0, 4.0, 4.0]+ /// );+ /// let control_points = vec![+ /// Vector4::new(1.0, 0.0, 0.0, 1.0),+ /// Vector4::new(0.0, 1.0, 0.0, 1.0),+ /// Vector4::new(0.0, 2.0, 0.0, 2.0),+ /// Vector4::new(0.0, 3.0, 0.0, 3.0),+ /// Vector4::new(0.0, 0.0, 3.0, 3.0),+ /// ];+ ///+ /// let mut curve = NurbsCurve::new(BSplineCurve::new(knot_vec, control_points));+ /// let mut flag = false;+ /// for i in 0..N {+ /// let t = 4.0 * (i as f64) / (N as f64);+ /// let pt0 = curve.subs(t);+ /// let pt1 = curve.subs(t + 1.0 / (N as f64));+ /// flag = flag || pt0.near(&pt1);+ /// }+ /// // There exists t such that bspcurve(t) == bspcurve(t + 0.01).+ /// assert!(flag);+ ///+ /// curve.make_locally_injective().knot_normalize();+ /// let mut flag = false;+ /// for i in 0..N {+ /// let t = 1.0 * (i as f64) / (N as f64);+ /// let pt0 = curve.subs(t);+ /// let pt1 = curve.subs(t + 1.0 / (N as f64));+ /// flag = flag || pt0.near(&pt1);+ /// }+ /// // There does not exist t such that bspcurve(t) == bspcurve(t + 0.01).+ /// assert!(!flag);+ /// ```+ /// # Remarks+ /// If `self` is a constant curve, then does nothing.+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 2.0, 2.0, 2.0]);+ /// let ctrl_pts = vec![+ /// Vector3::new(1.0, 1.0, 1.0),+ /// Vector3::new(2.0, 2.0, 2.0),+ /// Vector3::new(3.0, 3.0, 3.0),+ /// Vector3::new(4.0, 4.0, 4.0),+ /// ];+ /// let mut curve = NurbsCurve::new(BSplineCurve::new(knot_vec, ctrl_pts));+ /// let org_curve = curve.clone();+ /// curve.make_locally_injective();+ /// assert_eq!(curve, org_curve);+ /// ```+ pub fn make_locally_injective(&mut self) -> &mut Self {+ let mut iter = self.0.bezier_decomposition().into_iter();+ while let Some(bezier) = iter.next().map(NurbsCurve::new) {+ if !bezier.is_const() {+ *self = bezier;+ break;+ }+ }+ let mut x = 0.0;+ for mut bezier in iter.map(NurbsCurve::new) {+ if bezier.is_const() {+ x += bezier.0.knot_vec.range_length();+ } else {+ let s0 = self.0.control_points.last().unwrap().weight();+ let s1 = bezier.0.control_points[0].weight();+ bezier+ .0+ .control_points+ .iter_mut()+ .for_each(move |vec| *vec *= s0 / s1);+ self.concat(bezier.knot_translate(-x));+ }+ }+ self+ }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> ParameterDivision1D for NurbsCurve<V>+where V::Point: MetricSpace<Metric = f64> + HashGen<f64>+{+ type Point = V::Point;+ #[inline(always)]+ fn parameter_division(&self, range: (f64, f64), tol: f64) -> (Vec<f64>, Vec<V::Point>) {+ algo::curve::parameter_division(self, range, tol)+ }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> SearchNearestParameter<D1> for NurbsCurve<V>+where+ V::Point: MetricSpace<Metric = f64>,+ <V::Point as EuclideanSpace>::Diff: InnerSpace + Tolerance,+{+ type Point = V::Point;+ /// Searches the parameter `t` which minimize |self(t) - point| by Newton's method with initial guess `hint`.+ /// Returns `None` if the number of attempts exceeds `trial` i.e. if `trial == 0`, then the trial is only one time.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ ///+ /// // Defines the half unit circle in x > 0.+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let ctrl_pts = vec![Vector3::new(0.0, -1.0, 1.0), Vector3::new(1.0, 0.0, 0.0), Vector3::new(0.0, 1.0, 1.0)];+ /// let curve = NurbsCurve::new(BSplineCurve::new(knot_vec, ctrl_pts));+ ///+ /// // search rational nearest parameter+ /// let pt = Point2::new(1.0, 2.0);+ /// let hint = 0.8;+ /// let t = curve.search_nearest_parameter(pt, Some(hint), 100).unwrap();+ ///+ /// // check the answer+ /// let res = curve.subs(t);+ /// let ans = Point2::from_vec(pt.to_vec().normalize());+ /// assert_near!(res, ans);+ /// ```+ /// # Remarks+ /// It may converge to a local solution depending on the hint.+ /// ```+ /// use truck_geometry::prelude::*;+ ///+ /// // Same curve and point as above example+ /// let knot_vec = KnotVec::bezier_knot(2);+ /// let ctrl_pts = vec![Vector3::new(0.0, -1.0, 1.0), Vector3::new(1.0, 0.0, 0.0), Vector3::new(0.0, 1.0, 1.0)];+ /// let curve = NurbsCurve::new(BSplineCurve::new(knot_vec, ctrl_pts));+ /// let pt = Point2::new(1.0, 2.0);+ ///+ /// // another hint+ /// let hint = 0.5;+ ///+ /// // Newton's method is vibration divergent.+ /// assert!(curve.search_nearest_parameter(pt, Some(hint), 100).is_none());+ /// ```+ #[inline(always)]+ fn search_nearest_parameter<H: Into<SPHint1D>>(+ &self,+ point: V::Point,+ hint: H,+ trial: usize,+ ) -> Option<f64> {+ let hint = match hint.into() {+ SPHint1D::Parameter(hint) => hint,+ SPHint1D::Range(x, y) => {+ algo::curve::presearch(self, point, (x, y), PRESEARCH_DIVISION)+ }+ SPHint1D::None => {+ algo::curve::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::curve::search_nearest_parameter(self, point, hint, trial)+ }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> SearchParameter<D1> for NurbsCurve<V>+where+ V::Point: MetricSpace<Metric = f64>,+ <V::Point as EuclideanSpace>::Diff: InnerSpace + Tolerance,+{+ type Point = V::Point;+ #[inline(always)]+ fn search_parameter<H: Into<SPHint1D>>(+ &self,+ point: V::Point,+ hint: H,+ trial: usize,+ ) -> Option<f64> {+ let hint = match hint.into() {+ SPHint1D::Parameter(hint) => hint,+ SPHint1D::Range(x, y) => {+ algo::curve::presearch(self, point, (x, y), PRESEARCH_DIVISION)+ }+ SPHint1D::None => {+ algo::curve::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::curve::search_parameter(self, point, hint, trial)+ }+}++impl<V: Homogeneous<f64>> NurbsCurve<V>+where V::Point: Bounded<Scalar = f64>+{+ /// Returns the bounding box including all control points.+ #[inline(always)]+ pub fn roughly_bounding_box(&self) -> BoundingBox<V::Point> {+ self.0.control_points.iter().map(|p| p.to_point()).collect()+ }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> ParametricCurve for NurbsCurve<V> {+ type Point = V::Point;+ type Vector = <V::Point as EuclideanSpace>::Diff;+ #[inline(always)]+ fn subs(&self, t: f64) -> Self::Point { self.0.subs(t).to_point() }+ #[inline(always)]+ fn der(&self, t: f64) -> Self::Vector {+ let pt = self.0.subs(t);+ let der = self.0.der(t);+ pt.rat_der(der)+ }+ #[inline(always)]+ fn der2(&self, t: f64) -> Self::Vector {+ let pt = self.0.subs(t);+ let der = self.0.der(t);+ let der2 = self.0.der2(t);+ pt.rat_der2(der, der2)+ }+ #[inline(always)]+ fn parameter_range(&self) -> ParameterRange {+ (+ Bound::Included(self.0.knot_vec[0]),+ Bound::Included(self.0.knot_vec[self.0.knot_vec.len() - 1]),+ )+ }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> BoundedCurve for NurbsCurve<V> {}++impl<V: Clone> Invertible for NurbsCurve<V> {+ #[inline(always)]+ fn invert(&mut self) { self.invert(); }+ #[inline(always)]+ fn inverse(&self) -> Self {+ let mut curve = self.0.clone();+ curve.invert();+ NurbsCurve(curve)+ }+}++impl<M, V: Copy> Transformed<M> for NurbsCurve<V>+where M: Copy + std::ops::Mul<V, Output = V>+{+ #[inline(always)]+ fn transform_by(&mut self, trans: M) {+ self.0+ .control_points+ .iter_mut()+ .for_each(move |v| *v = trans * *v)+ }+}++impl<V: Homogeneous<f64>> From<BSplineCurve<V::Point>> for NurbsCurve<V> {+ fn from(bspcurve: BSplineCurve<V::Point>) -> NurbsCurve<V> {+ NurbsCurve::new(BSplineCurve::new_unchecked(+ bspcurve.knot_vec,+ bspcurve+ .control_points+ .into_iter()+ .map(V::from_point)+ .collect(),+ ))+ }+}++#[test]+fn test_parameter_division() {+ let knot_vec = KnotVec::uniform_knot(2, 3);+ let ctrl_pts = vec![+ Vector4::new(0.0, 0.0, 0.0, 1.0),+ Vector4::new(2.0, 0.0, 0.0, 2.0),+ Vector4::new(0.0, 3.0, 0.0, 3.0),+ Vector4::new(0.0, 0.0, 2.0, 2.0),+ Vector4::new(1.0, 1.0, 1.0, 1.0),+ ];+ let curve = NurbsCurve::new(BSplineCurve::new(knot_vec, ctrl_pts));+ let tol = 0.01;+ let (div, pts) = curve.parameter_division(curve.range_tuple(), tol * 0.5);+ let knot_vec = curve.knot_vec();+ assert_eq!(knot_vec[0], div[0]);+ assert_eq!(knot_vec.range_length(), div.last().unwrap() - div[0]);+ for i in 1..div.len() {+ let pt0 = curve.subs(div[i - 1]);+ assert_eq!(pt0, pts[i - 1]);+ let pt1 = curve.subs(div[i]);+ assert_eq!(pt1, pts[i]);+ let value_middle = pt0.midpoint(pt1);+ let param_middle = curve.subs((div[i - 1] + div[i]) / 2.0);+ let dist = value_middle.distance(param_middle);+ assert!(dist < tol, "large distance: {dist}");+ }+}diff --git a/vendor/truck-geometry/src/nurbs/nurbssurface.rs b/vendor/truck-geometry/src/nurbs/nurbssurface.rsnew file mode 100644index 0000000000..16984dab33--- /dev/null+++ b/vendor/truck-geometry/src/nurbs/nurbssurface.rs@@ -0,0 +1,920 @@+use super::*;++impl<V> NurbsSurface<V> {+ /// constructor+ #[inline(always)]+ pub const fn new(bspsurface: BSplineSurface<V>) -> Self { NurbsSurface(bspsurface) }++ /// Returns the nurbs surface before rationalized+ #[inline(always)]+ pub const fn non_rationalized(&self) -> &BSplineSurface<V> { &self.0 }+ /// Returns the nurbs surface before rationalized+ #[inline(always)]+ pub fn non_rationalized_mut(&mut self) -> &mut BSplineSurface<V> { &mut self.0 }++ /// Returns the nurbs surface before rationalized+ #[inline(always)]+ pub fn into_non_rationalized(self) -> BSplineSurface<V> { self.0 }++ /// Returns the reference of the knot vectors+ #[inline(always)]+ pub const fn knot_vecs(&self) -> &(KnotVec, KnotVec) { &self.0.knot_vecs }++ /// Returns the u knot vector.+ #[inline(always)]+ pub const fn uknot_vec(&self) -> &KnotVec { &self.0.knot_vecs.0 }+ /// Returns the v knot vector.+ #[inline(always)]+ pub const fn vknot_vec(&self) -> &KnotVec { &self.0.knot_vecs.1 }++ /// Returns the `idx`th u knot.+ #[inline(always)]+ pub fn uknot(&self, idx: usize) -> f64 { self.0.knot_vecs.0[idx] }+ /// returns the `idx`th v knot.+ #[inline(always)]+ pub fn vknot(&self, idx: usize) -> f64 { self.0.knot_vecs.1[idx] }++ /// Returns the reference of the vector of the control points+ #[inline(always)]+ pub const fn control_points(&self) -> &Vec<Vec<V>> { &self.0.control_points }++ /// Returns the reference of the control point corresponding to the index `(idx0, idx1)`.+ #[inline(always)]+ pub fn control_point(&self, idx0: usize, idx1: usize) -> &V {+ &self.0.control_points[idx0][idx1]+ }++ /// Apply the given transformation to all control points.+ #[inline(always)]+ pub fn transform_control_points<F: FnMut(&mut V)>(&mut self, f: F) {+ self.0.transform_control_points(f)+ }++ /// Returns the iterator over the control points in the `column_idx`th row.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::bezier_knot(1);+ /// let vknot_vec = KnotVec::bezier_knot(2);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let mut iter = bspsurface.ctrl_pts_row_iter(1);+ /// assert_eq!(iter.next(), Some(&Vector3::new(1.0, 0.0, 1.0)));+ /// assert_eq!(iter.next(), Some(&Vector3::new(1.0, 1.0, 1.0)));+ /// assert_eq!(iter.next(), None);+ /// ```+ #[inline(always)]+ pub fn ctrl_pts_row_iter(+ &self,+ column_idx: usize,+ ) -> impl ExactSizeIterator<Item = &V> + std::iter::FusedIterator<Item = &V> {+ self.0.ctrl_pts_row_iter(column_idx)+ }++ /// Returns the iterator over the control points in the `row_idx`th row.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::bezier_knot(1);+ /// let vknot_vec = KnotVec::bezier_knot(2);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// let mut iter = bspsurface.ctrl_pts_column_iter(1);+ /// assert_eq!(iter.next(), Some(&Vector3::new(0.0, 1.0, 0.0)));+ /// assert_eq!(iter.next(), Some(&Vector3::new(1.0, 1.0, 1.0)));+ /// assert_eq!(iter.next(), Some(&Vector3::new(2.0, 1.0, 2.0)));+ /// assert_eq!(iter.next(), None);+ /// ```+ #[inline(always)]+ pub fn ctrl_pts_column_iter(&self, row_idx: usize) -> std::slice::Iter<'_, V> {+ self.0.control_points[row_idx].iter()+ }++ /// Returns the mutable reference of the control point corresponding to index `(idx0, idx1)`.+ #[inline(always)]+ pub fn control_point_mut(&mut self, idx0: usize, idx1: usize) -> &mut V {+ &mut self.0.control_points[idx0][idx1]+ }++ /// Returns the iterator on all control points+ #[inline(always)]+ pub fn control_points_mut(&mut self) -> impl Iterator<Item = &mut V> {+ self.0.control_points.iter_mut().flatten()+ }+ /// Returns the degrees of B-spline surface+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);+ /// let vknot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// assert_eq!(bspsurface.udegree(), 1);+ /// ```+ #[inline(always)]+ pub fn udegree(&self) -> usize { self.0.udegree() }++ /// Returns the degrees of B-spline surface+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);+ /// let vknot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// assert_eq!(bspsurface.vdegree(), 2);+ /// ```+ #[inline(always)]+ pub fn vdegree(&self) -> usize { self.0.vdegree() }++ /// Returns the degrees of B-spline surface+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);+ /// let vknot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);+ /// let knot_vecs = (uknot_vec, vknot_vec);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],+ /// vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);+ /// assert_eq!(bspsurface.degrees(), (1, 2));+ /// ```+ #[inline(always)]+ pub fn degrees(&self) -> (usize, usize) { (self.udegree(), self.vdegree()) }+ /// Returns whether the knot vectors are clamped or not.+ #[inline(always)]+ pub fn is_clamped(&self) -> bool { self.0.is_clamped() }+ /// Swaps two parameters.+ pub fn swap_axes(&mut self) -> &mut Self+ where V: Clone {+ self.0.swap_axes();+ self+ }+ /// The range of the parameter of the surface.+ #[inline(always)]+ pub fn parameter_range(&self) -> (ParameterRange, ParameterRange) { self.0.parameter_range() }+ /// Creates the curve whose control points are the `idx`th column control points of `self`.+ #[inline(always)]+ pub fn column_curve(&self, row_idx: usize) -> NurbsCurve<V>+ where V: Clone {+ NurbsCurve(self.0.column_curve(row_idx))+ }+ /// Creates the column sectional curve.+ #[inline(always)]+ pub fn row_curve(&self, column_idx: usize) -> NurbsCurve<V>+ where V: Clone {+ NurbsCurve(self.0.row_curve(column_idx))+ }+}++impl<V: Homogeneous<f64>> NurbsSurface<V> {+ /// Constructs a rationalization surface from the non-rationalized surface and weights.+ /// # Failures+ /// the length of `surface.control_points()` and `weights` must be the same.+ #[inline(always)]+ pub fn try_from_bspline_and_weights(+ surface: BSplineSurface<V::Point>,+ weights: Vec<Vec<f64>>,+ ) -> Result<Self> {+ let BSplineSurface {+ knot_vecs,+ control_points,+ } = surface;+ if control_points.len() != weights.len() {+ return Err(Error::DifferentLength);+ }+ let control_points = control_points+ .into_iter()+ .zip(weights)+ .map(|(control_points, weights)| {+ if control_points.len() != weights.len() {+ return Err(Error::DifferentLength);+ }+ Ok(control_points+ .into_iter()+ .zip(weights)+ .map(|(pt, w)| V::from_point_weight(pt, w))+ .collect::<Vec<_>>())+ })+ .collect::<Result<Vec<_>>>()?;+ Ok(Self(BSplineSurface::new_unchecked(+ knot_vecs,+ control_points,+ )))+ }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> NurbsSurface<V> {+ /// Substitutes to a NURBS surface.+ #[inline(always)]+ pub fn subs(&self, u: f64, v: f64) -> V::Point { self.0.subs(u, v).to_point() }+ /// Substitutes derived NURBS surface by the first parameter `u`.+ #[inline(always)]+ pub fn uder(&self, u: f64, v: f64) -> <V::Point as EuclideanSpace>::Diff {+ let pt = self.0.subs(u, v);+ let ud = self.0.uder(u, v);+ pt.rat_der(ud)+ }+ /// Substitutes derived NURBS surface by the first parameter `v`.+ #[inline(always)]+ pub fn vder(&self, u: f64, v: f64) -> <V::Point as EuclideanSpace>::Diff {+ let pt = self.0.subs(u, v);+ let vd = self.0.vder(u, v);+ pt.rat_der(vd)+ }+ /// Substitutes 2nd-ord derived NURBS surface by the first parameter `u`.+ #[inline(always)]+ pub fn uuder(&self, u: f64, v: f64) -> <V::Point as EuclideanSpace>::Diff {+ let pt = self.0.subs(u, v);+ let ud = self.0.uder(u, v);+ let uud = self.0.uuder(u, v);+ pt.rat_der2(ud, uud)+ }+ /// Substitutes 2nd-ord derived NURBS surface by the first parameter `v`.+ #[inline(always)]+ pub fn vvder(&self, u: f64, v: f64) -> <V::Point as EuclideanSpace>::Diff {+ let pt = self.0.subs(u, v);+ let vd = self.0.vder(u, v);+ let vvd = self.0.vvder(u, v);+ pt.rat_der2(vd, vvd)+ }+ /// Substitutes 2nd-ord derived NURBS surface by both parameter `u, v`.+ #[inline(always)]+ pub fn uvder(&self, u: f64, v: f64) -> <V::Point as EuclideanSpace>::Diff {+ let pt = self.0.subs(u, v);+ let ud = self.0.uder(u, v);+ let vd = self.0.vder(u, v);+ let uvd = self.0.uvder(u, v);+ pt.rat_cross_der(ud, vd, uvd)+ }+ /// Returns the closure of substitution.+ #[inline(always)]+ pub fn get_closure(&self) -> impl Fn(f64, f64) -> V::Point + '_ { move |u, v| self.subs(u, v) }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> NurbsSurface<V>+where V::Point: Tolerance+{+ /// Returns whether constant curve or not, i.e. all control points are same or not.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let uknot_vec = KnotVec::bezier_knot(1);+ /// let vknot_vec = KnotVec::bezier_knot(2);+ /// let pt = Vector3::new(1.0, 2.0, 1.0);+ /// // allows differences upto scalars+ /// let ctrl_pts = vec![+ /// vec![pt.clone(), pt.clone() * 2.0, pt.clone() * 3.0],+ /// vec![pt.clone() * 0.5, pt.clone() * 0.25, pt.clone() * 0.125],+ /// ];+ /// let mut surface = NurbsSurface::new(BSplineSurface::new((uknot_vec, vknot_vec), ctrl_pts));+ /// assert!(surface.is_const());+ ///+ /// *surface.control_point_mut(1, 2) = Vector3::new(2.0, 3.0, 1.0);+ /// assert!(!surface.is_const());+ /// ```+ #[inline(always)]+ pub fn is_const(&self) -> bool {+ let pt = self.0.control_points[0][0].to_point();+ for vec in self.0.control_points.iter().flat_map(|pts| pts.iter()) {+ if !vec.to_point().near(&pt) {+ return false;+ }+ }+ true+ }+ /// Determines whether `self` and `other` is near as the B-spline rational surfaces or not.+ ///+ /// Divides each knot domain into the number of degree equal parts,+ /// and check `|self(u, v) - other(u, v)| < TOLERANCE` for each end points `(u, v)`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(3), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 1.0), Vector3::new(0.5, -1.0, 2.0), Vector3::new(1.0, 0.0, 1.0)],+ /// vec![Vector3::new(0.0, 1.0, 1.0), Vector3::new(0.5, 1.0, 1.0), Vector3::new(1.0, 1.0, 1.0)],+ /// vec![Vector3::new(0.0, 2.0, 1.0), Vector3::new(0.5, 2.0, 3.0), Vector3::new(1.0, 2.0, 1.0)],+ /// vec![Vector3::new(0.0, 3.0, 1.0), Vector3::new(0.5, 3.5, 2.0), Vector3::new(1.0, 3.0, 1.0)],+ /// ];+ /// let surface0 = NurbsSurface::new(BSplineSurface::new(knot_vecs, ctrl_pts));+ /// let mut surface1 = surface0.clone();+ /// assert!(surface0.near_as_surface(&surface1));+ ///+ /// *surface1.control_point_mut(1, 1) = Vector3::new(0.5, 1.0, 0.9);+ /// assert!(!surface0.near_as_surface(&surface1));+ /// ```+ #[inline(always)]+ pub fn near_as_surface(&self, other: &Self) -> bool {+ self.0+ .sub_near_as_surface(&other.0, 2, move |x, y| x.to_point().near(&y.to_point()))+ }+ /// Determines whether `self` and `other` is near in square order as the B-spline rational+ /// surfaces or not.+ ///+ /// Divides each knot domain into the number of degree equal parts,+ /// and check `|self(u, v) - other(u, v)| < TOLERANCE` for each end points `(u, v)`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let eps = TOLERANCE;+ /// let knot_vecs = (KnotVec::bezier_knot(3), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 1.0), Vector3::new(0.5, -1.0, 2.0), Vector3::new(1.0, 0.0, 1.0)],+ /// vec![Vector3::new(0.0, 1.0, 1.0), Vector3::new(0.5, 1.0, 1.0), Vector3::new(1.0, 1.0, 1.0)],+ /// vec![Vector3::new(0.0, 2.0, 1.0), Vector3::new(0.5, 2.0, 3.0), Vector3::new(1.0, 2.0, 1.0)],+ /// vec![Vector3::new(0.0, 3.0, 1.0), Vector3::new(0.5, 3.5, 2.0), Vector3::new(1.0, 3.0, 1.0)],+ /// ];+ /// let surface0 = NurbsSurface::new(BSplineSurface::new(knot_vecs, ctrl_pts));+ /// let mut surface1 = surface0.clone();+ /// assert!(surface0.near_as_surface(&surface1));+ ///+ /// *surface1.control_point_mut(1, 1) = Vector3::new(0.5, 1.0, 1.0 - eps);+ /// assert!(surface0.near_as_surface(&surface1));+ /// assert!(!surface0.near2_as_surface(&surface1));+ /// ```+ #[inline(always)]+ pub fn near2_as_surface(&self, other: &Self) -> bool {+ self.0+ .sub_near_as_surface(&other.0, 2, move |x, y| x.to_point().near2(&y.to_point()))+ }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V> + Tolerance> NurbsSurface<V> {+ /// Adds a knot `x` of the first parameter `u`, and do not change `self` as a surface.+ #[inline(always)]+ pub fn add_uknot(&mut self, x: f64) -> &mut Self {+ self.0.add_uknot(x);+ self+ }+ /// Adds a knot `x` of the first parameter `u`, and do not change `self` as a surface.+ #[inline(always)]+ pub fn add_vknot(&mut self, x: f64) -> &mut Self {+ self.0.add_vknot(x);+ self+ }+ /// Removes the uknot corresponding to the indice `idx`, and do not change `self` as a curve.+ /// If the knot cannot be removed, returns [`Error::CannotRemoveKnot`].+ #[inline(always)]+ pub fn try_remove_uknot(&mut self, idx: usize) -> Result<&mut Self> {+ match self.0.try_remove_uknot(idx) {+ Ok(_) => Ok(self),+ Err(error) => Err(error),+ }+ }+ /// Removes the uknot corresponding to the indices `idx`, and do not change `self` as a curve.+ /// If cannot remove the knot, do not change `self` and return `self`.+ #[inline(always)]+ pub fn remove_uknot(&mut self, idx: usize) -> &mut Self {+ self.0.remove_uknot(idx);+ self+ }+ /// Removes the uknot corresponding to the indice `idx`, and do not change `self` as a curve.+ /// If the knot cannot be removed, returns [`Error::CannotRemoveKnot`].+ #[inline(always)]+ pub fn try_remove_vknot(&mut self, idx: usize) -> Result<&mut Self> {+ match self.0.try_remove_vknot(idx) {+ Ok(_) => Ok(self),+ Err(error) => Err(error),+ }+ }+ /// Removes the uknot corresponding to the indices `idx`, and do not change `self` as a curve.+ /// If cannot remove the knot, do not change `self` and return `self`.+ #[inline(always)]+ pub fn remove_vknot(&mut self, idx: usize) -> &mut Self {+ self.0.remove_vknot(idx);+ self+ }+ /// Elevates the udegree.+ #[inline(always)]+ pub fn elevate_udegree(&mut self) -> &mut Self {+ self.0.elevate_udegree();+ self+ }+ /// Elevates the vdegree.+ #[inline(always)]+ pub fn elevate_vdegree(&mut self) -> &mut Self {+ self.0.elevate_vdegree();+ self+ }+ /// Aligns the udegree with the same degrees.+ #[inline(always)]+ pub fn syncro_uvdegrees(&mut self) -> &mut Self {+ self.0.syncro_uvdegrees();+ self+ }+ /// Makes the uknot vector and the vknot vector the same knot vector.+ #[inline(always)]+ pub fn syncro_uvknots(&mut self) -> &mut Self {+ self.0.syncro_uvknots();+ self+ }++ /// Cuts the surface into two surfaces at the parameter `u`+ #[inline(always)]+ pub fn ucut(&mut self, u: f64) -> Self { Self::new(self.0.ucut(u)) }++ /// Cuts the surface into two surfaces at the parameter `v`+ #[inline(always)]+ pub fn vcut(&mut self, v: f64) -> Self { Self::new(self.0.vcut(v)) }++ /// Normalizes the knot vectors+ #[inline(always)]+ pub fn knot_normalize(&mut self) -> &mut Self {+ self.0.knot_normalize();+ self+ }+ /// Translates the knot vectors.+ #[inline(always)]+ pub fn knot_translate(&mut self, x: f64, y: f64) -> &mut Self {+ self.0.knot_translate(x, y);+ self+ }++ /// Removes knots in order from the back+ #[inline(always)]+ pub fn optimize(&mut self) -> &mut Self {+ self.0.optimize();+ self+ }++ /// Get the boundary by four splitted curves.+ /// # Example+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(3), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 1.0), Vector3::new(0.5, -1.0, 2.0), Vector3::new(1.0, 0.0, 1.0)],+ /// vec![Vector3::new(0.0, 1.0, 2.0), Vector3::new(0.5, 1.0, 3.0), Vector3::new(1.0, 1.0, 2.0)],+ /// vec![Vector3::new(0.0, 2.0, 2.0), Vector3::new(0.5, 2.0, 3.0), Vector3::new(1.0, 2.0, 2.0)],+ /// vec![Vector3::new(0.0, 3.0, 1.0), Vector3::new(0.5, 3.5, 2.0), Vector3::new(1.0, 3.0, 1.0)],+ /// ];+ /// let bspsurface = NurbsSurface::new(BSplineSurface::new(knot_vecs, ctrl_pts));+ /// let curves = bspsurface.splitted_boundary();+ /// assert_eq!(+ /// curves[0].control_points(),+ /// &vec![+ /// Vector3::new(0.0, 0.0, 1.0),+ /// Vector3::new(0.0, 1.0, 2.0),+ /// Vector3::new(0.0, 2.0, 2.0),+ /// Vector3::new(0.0, 3.0, 1.0),+ /// ],+ /// );+ /// assert_eq!(+ /// curves[1].control_points(),+ /// &vec![+ /// Vector3::new(0.0, 3.0, 1.0),+ /// Vector3::new(0.5, 3.5, 2.0),+ /// Vector3::new(1.0, 3.0, 1.0),+ /// ],+ /// );+ /// assert_eq!(+ /// curves[2].control_points(),+ /// &vec![+ /// Vector3::new(1.0, 3.0, 1.0),+ /// Vector3::new(1.0, 2.0, 2.0),+ /// Vector3::new(1.0, 1.0, 2.0),+ /// Vector3::new(1.0, 0.0, 1.0),+ /// ],+ /// );+ /// assert_eq!(+ /// curves[3].control_points(),+ /// &vec![+ /// Vector3::new(1.0, 0.0, 1.0),+ /// Vector3::new(0.5, -1.0, 2.0),+ /// Vector3::new(0.0, 0.0, 1.0),+ /// ],+ /// );+ /// ```+ #[inline(always)]+ pub fn splitted_boundary(&self) -> [NurbsCurve<V>; 4] {+ TryFrom::try_from(+ self.0+ .splitted_boundary()+ .iter()+ .cloned()+ .map(NurbsCurve::new)+ .collect::<Vec<_>>(),+ )+ .unwrap()+ }++ /// Extracts the boundary of surface+ #[inline(always)]+ pub fn boundary(&self) -> NurbsCurve<V> { NurbsCurve::new(self.0.boundary()) }+}++impl<V: Homogeneous<f64>> SearchNearestParameter<D2> for NurbsSurface<V>+where+ Self: ParametricSurface<Point = V::Point, Vector = <V::Point as EuclideanSpace>::Diff>,+ V::Point: EuclideanSpace<Scalar = f64> + MetricSpace<Metric = f64>,+ <V::Point as EuclideanSpace>::Diff: InnerSpace<Scalar = f64> + Tolerance,+{+ type Point = V::Point;+ /// Searches the parameter `(u, v)` which minimize `|self(u, v) - point|` by Newton's method+ /// with initial guess `(u0, v0)`. If the repeated trial does not converge, then returns `None`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vecs = (KnotVec::bezier_knot(3), KnotVec::bezier_knot(2));+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 1.0), Vector3::new(1.0, -2.0, 2.0), Vector3::new(1.0, 0.0, 1.0)],+ /// vec![Vector3::new(0.0, 2.0, 2.0), Vector3::new(2.0, 4.0, 4.0), Vector3::new(2.0, 2.0, 2.0)],+ /// vec![Vector3::new(0.0, 4.0, 2.0), Vector3::new(2.0, 8.0, 4.0), Vector3::new(2.0, 4.0, 2.0)],+ /// vec![Vector3::new(0.0, 3.0, 1.0), Vector3::new(1.0, 7.0, 2.0), Vector3::new(1.0, 3.0, 1.0)],+ /// ];+ /// let surface = NurbsSurface::new(BSplineSurface::new(knot_vecs, ctrl_pts));+ /// let pt = surface.subs(0.3, 0.7);+ /// let (u, v) = surface.search_nearest_parameter(pt, Some((0.5, 0.5)), 100).unwrap();+ /// assert!(u.near(&0.3) && v.near(&0.7));+ /// ```+ /// # Remarks+ /// It may converge to a local solution depending on the hint.+ /// cf. [`BSplineCurve::search_rational_nearest_parameter`](struct.BSplineCurve.html#method.search_rational_nearest_parameter)+ #[inline(always)]+ fn search_nearest_parameter<H: Into<SPHint2D>>(+ &self,+ point: V::Point,+ hint: H,+ trials: usize,+ ) -> Option<(f64, f64)> {+ let hint = match hint.into() {+ SPHint2D::Parameter(x, y) => (x, y),+ SPHint2D::Range(range0, range1) => {+ algo::surface::presearch(self, point, (range0, range1), PRESEARCH_DIVISION)+ }+ SPHint2D::None => {+ algo::surface::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::surface::search_nearest_parameter(self, point, hint, trials)+ }+}++impl<V: Homogeneous<f64>> NurbsSurface<V>+where V::Point: Bounded<Scalar = f64>+{+ /// Returns the bounding box including all control points.+ #[inline(always)]+ pub fn roughly_bounding_box(&self) -> BoundingBox<V::Point> {+ self.0+ .control_points+ .iter()+ .flatten()+ .map(|pt| pt.to_point())+ .collect()+ }+}++impl SearchParameter<D2> for NurbsSurface<Vector3> {+ type Point = Point2;+ /// Search the parameter `(u, v)` such that `self.subs(u, v).rational_projection()` is near `pt`.+ /// If cannot find, then return `None`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::uniform_knot(2, 2);+ /// let ctrl_pts = vec![+ /// vec![Vector3::new(0.0, 0.0, 1.0), Vector3::new(0.1, 0.0, 0.5), Vector3::new(0.5, 0.0, 0.3), Vector3::new(1.0, 0.0, 1.0)],+ /// vec![Vector3::new(0.0, 0.1, 0.1), Vector3::new(0.2, 0.2, 0.1), Vector3::new(0.4, 0.3, 0.4), Vector3::new(1.0, 0.3, 0.7)],+ /// vec![Vector3::new(0.0, 0.5, 0.4), Vector3::new(0.3, 0.6, 0.5), Vector3::new(0.6, 0.4, 1.0), Vector3::new(1.0, 0.5, 0.4)],+ /// vec![Vector3::new(0.0, 1.0, 1.0), Vector3::new(0.1, 1.0, 1.0), Vector3::new(0.5, 1.0, 0.5), Vector3::new(1.0, 1.0, 0.3)],+ /// ];+ /// let bspsurface = BSplineSurface::new((knot_vec.clone(), knot_vec), ctrl_pts);+ /// let surface = NurbsSurface::new(bspsurface);+ ///+ /// let pt = surface.subs(0.3, 0.7);+ /// let (u, v) = surface.search_parameter(pt, Some((0.5, 0.5)), 100).unwrap();+ /// assert_near!(surface.subs(u, v), pt);+ /// ```+ #[inline(always)]+ fn search_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point2,+ hint: H,+ trials: usize,+ ) -> Option<(f64, f64)> {+ let hint = match hint.into() {+ SPHint2D::Parameter(x, y) => (x, y),+ SPHint2D::Range(range0, range1) => {+ algo::surface::presearch(self, point, (range0, range1), PRESEARCH_DIVISION)+ }+ SPHint2D::None => {+ algo::surface::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::surface::search_parameter2d(self, point, hint, trials)+ }+}++impl<V: Clone> Invertible for NurbsSurface<V> {+ #[inline(always)]+ fn invert(&mut self) { self.swap_axes(); }+ #[inline(always)]+ fn inverse(&self) -> Self {+ let mut surface = self.clone();+ surface.swap_axes();+ surface+ }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> ParametricSurface for NurbsSurface<V> {+ type Point = V::Point;+ type Vector = <V::Point as EuclideanSpace>::Diff;+ #[inline(always)]+ fn subs(&self, u: f64, v: f64) -> Self::Point { self.subs(u, v) }+ #[inline(always)]+ fn uder(&self, u: f64, v: f64) -> Self::Vector { self.uder(u, v) }+ #[inline(always)]+ fn vder(&self, u: f64, v: f64) -> Self::Vector { self.vder(u, v) }+ #[inline(always)]+ fn uuder(&self, u: f64, v: f64) -> Self::Vector { self.uuder(u, v) }+ #[inline(always)]+ fn uvder(&self, u: f64, v: f64) -> Self::Vector { self.uvder(u, v) }+ #[inline(always)]+ fn vvder(&self, u: f64, v: f64) -> Self::Vector { self.vvder(u, v) }+ #[inline(always)]+ fn parameter_range(&self) -> (ParameterRange, ParameterRange) { self.parameter_range() }+}++impl ParametricSurface3D for NurbsSurface<Vector4> {+ #[inline(always)]+ fn normal(&self, u: f64, v: f64) -> Vector3 {+ let pt = self.0.subs(u, v);+ let ud = self.0.uder(u, v);+ let vd = self.0.vder(u, v);+ pt.rat_der(ud).cross(pt.rat_der(vd)).normalize()+ }+}++impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> ParameterDivision2D for NurbsSurface<V>+where V::Point: MetricSpace<Metric = f64> + HashGen<f64>+{+ #[inline(always)]+ fn parameter_division(+ &self,+ range: ((f64, f64), (f64, f64)),+ tol: f64,+ ) -> (Vec<f64>, Vec<f64>) {+ algo::surface::parameter_division(self, range, tol)+ }+}++impl<V> BoundedSurface for NurbsSurface<V> where Self: ParametricSurface {}++impl IncludeCurve<NurbsCurve<Vector3>> for NurbsSurface<Vector3> {+ #[inline(always)]+ fn include(&self, curve: &NurbsCurve<Vector3>) -> bool {+ let pt = curve.subs(curve.knot_vec()[0]);+ let mut hint = match self.search_parameter(pt, None, INCLUDE_CURVE_TRIALS) {+ Some(got) => got,+ None => return false,+ };+ let uknot_vec = self.uknot_vec();+ let vknot_vec = self.vknot_vec();+ let degree = curve.degree() * 6;+ let (knots, _) = curve.knot_vec().to_single_multi();+ for i in 1..knots.len() {+ for j in 1..=degree {+ let p = j as f64 / degree as f64;+ let t = knots[i - 1] * (1.0 - p) + knots[i] * p;+ let pt = curve.subs(t);+ hint = match self.search_parameter(pt, Some(hint), INCLUDE_CURVE_TRIALS) {+ Some(got) => got,+ None => return false,+ };+ if !self.subs(hint.0, hint.1).near(&pt)+ || hint.0 < uknot_vec[0] - TOLERANCE+ || hint.0 - uknot_vec[0] > uknot_vec.range_length() + TOLERANCE+ || hint.1 < vknot_vec[0] - TOLERANCE+ || hint.1 - vknot_vec[0] > vknot_vec.range_length() + TOLERANCE+ {+ return false;+ }+ }+ }+ true+ }+}++impl IncludeCurve<BSplineCurve<Point3>> for NurbsSurface<Vector4> {+ #[inline(always)]+ fn include(&self, curve: &BSplineCurve<Point3>) -> bool {+ let pt = curve.front();+ let mut hint = match self.search_parameter(pt, None, INCLUDE_CURVE_TRIALS) {+ Some(got) => got,+ None => return false,+ };+ let uknot_vec = self.uknot_vec();+ let vknot_vec = self.vknot_vec();+ let degree = curve.degree() * 6;+ let (knots, _) = curve.knot_vec().to_single_multi();+ for i in 1..knots.len() {+ for j in 1..=degree {+ let p = j as f64 / degree as f64;+ let t = knots[i - 1] * (1.0 - p) + knots[i] * p;+ let pt = curve.subs(t);+ hint = match self.search_parameter(pt, Some(hint), INCLUDE_CURVE_TRIALS) {+ Some(got) => got,+ None => return false,+ };+ if !self.subs(hint.0, hint.1).near(&pt)+ || hint.0 < uknot_vec[0] - TOLERANCE+ || hint.0 - uknot_vec[0] > uknot_vec.range_length() + TOLERANCE+ || hint.1 < vknot_vec[0] - TOLERANCE+ || hint.1 - vknot_vec[0] > vknot_vec.range_length() + TOLERANCE+ {+ return false;+ }+ }+ }+ true+ }+}++impl IncludeCurve<NurbsCurve<Vector4>> for NurbsSurface<Vector4> {+ #[inline(always)]+ fn include(&self, curve: &NurbsCurve<Vector4>) -> bool {+ let pt = curve.front();+ let mut hint = match self.search_parameter(pt, None, INCLUDE_CURVE_TRIALS) {+ Some(got) => got,+ None => return false,+ };+ let uknot_vec = self.uknot_vec();+ let vknot_vec = self.vknot_vec();+ let degree = curve.degree() * 6;+ let (knots, _) = curve.knot_vec().to_single_multi();+ for i in 1..knots.len() {+ for j in 1..=degree {+ let p = j as f64 / degree as f64;+ let t = knots[i - 1] * (1.0 - p) + knots[i] * p;+ let pt = curve.subs(t);+ hint = match self.search_parameter(pt, Some(hint), INCLUDE_CURVE_TRIALS) {+ Some(got) => got,+ None => return false,+ };+ if !self.subs(hint.0, hint.1).near(&pt)+ || hint.0 < uknot_vec[0] - TOLERANCE+ || hint.0 - uknot_vec[0] > uknot_vec.range_length() + TOLERANCE+ || hint.1 < vknot_vec[0] - TOLERANCE+ || hint.1 - vknot_vec[0] > vknot_vec.range_length() + TOLERANCE+ {+ return false;+ }+ }+ }+ true+ }+}++impl<M, V: Copy> Transformed<M> for NurbsSurface<V>+where M: Copy + std::ops::Mul<V, Output = V>+{+ #[inline(always)]+ fn transform_by(&mut self, trans: M) {+ self.0+ .control_points+ .iter_mut()+ .flatten()+ .for_each(move |v| *v = trans * *v)+ }+}++impl SearchParameter<D2> for NurbsSurface<Vector4> {+ type Point = Point3;+ /// Search the parameter `(u, v)` such that `self.subs(u, v).rational_projection()` is near `pt`.+ /// If cannot find, then return `None`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let knot_vec = KnotVec::uniform_knot(2, 2);+ /// let ctrl_pts = vec![+ /// vec![Vector4::new(0.0, 0.0, 0.0, 1.0), Vector4::new(0.1, 0.0, 0.5, 0.4), Vector4::new(1.0, 0.0, 0.6, 2.0), Vector4::new(0.4, 0.0, 0.4, 0.4)],+ /// vec![Vector4::new(0.0, 0.2, 0.2, 2.0), Vector4::new(0.24, 0.24, 0.1, 1.2), Vector4::new(2.4, 1.8, 2.4, 0.6), Vector4::new(1.4, 0.42, 0.98, 1.4)],+ /// vec![Vector4::new(0.0, 1.5, 1.2, 3.0), Vector4::new(1.02, 2.04, 1.7, 3.4), Vector4::new(0.42, 0.28, 0.7, 0.7), Vector4::new(0.6, 0.3, 0.0, 0.6)],+ /// vec![Vector4::new(0.0, 1.0, 1.0, 1.0), Vector4::new(0.2, 2.0, 2.0, 2.0), Vector4::new(0.85, 1.7, 0.85, 1.7), Vector4::new(1.0, 1.0, 0.3, 1.0)],+ /// ];+ /// let bspsurface = BSplineSurface::new((knot_vec.clone(), knot_vec), ctrl_pts);+ /// let surface = NurbsSurface::new(bspsurface);+ ///+ /// let pt = surface.subs(0.3, 0.7);+ /// let (u, v) = surface.search_parameter(pt, Some((0.5, 0.5)), 100).unwrap();+ /// assert_near!(surface.subs(u, v), pt);+ /// ```+ fn search_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point3,+ hint: H,+ trials: usize,+ ) -> Option<(f64, f64)> {+ let hint = match hint.into() {+ SPHint2D::Parameter(x, y) => (x, y),+ SPHint2D::Range(range0, range1) => {+ algo::surface::presearch(self, point, (range0, range1), PRESEARCH_DIVISION)+ }+ SPHint2D::None => {+ algo::surface::presearch(self, point, self.range_tuple(), PRESEARCH_DIVISION)+ }+ };+ algo::surface::search_parameter3d(self, point, hint, trials)+ }+}++#[test]+fn test_include2d() {+ let knot_vec = KnotVec::uniform_knot(2, 3);+ let ctrl_pts = vec![+ vec![+ Vector3::new(0.0, 0.0, 1.0),+ Vector3::new(0.05, 0.0, 0.5),+ Vector3::new(0.15, 0.0, 0.3),+ Vector3::new(1.0, 0.0, 1.0),+ ],+ vec![+ Vector3::new(0.0, 0.01, 0.1),+ Vector3::new(0.02, 0.02, 0.1),+ Vector3::new(0.16, 0.12, 0.4),+ Vector3::new(0.7, 0.21, 0.7),+ ],+ vec![+ Vector3::new(0.0, 0.02, 0.4),+ Vector3::new(0.15, 0.3, 0.5),+ Vector3::new(0.6, 0.4, 1.0),+ Vector3::new(0.4, 0.2, 0.4),+ ],+ vec![+ Vector3::new(0.0, 1.0, 1.0),+ Vector3::new(0.1, 1.0, 1.0),+ Vector3::new(0.25, 0.5, 0.5),+ Vector3::new(0.3, 0.3, 0.3),+ ],+ ];+ let surface = BSplineSurface::new((knot_vec.clone(), knot_vec), ctrl_pts);+ let bnd_box = BoundingBox::from_iter(&[Vector2::new(0.2, 0.3), Vector2::new(0.8, 0.6)]);+ let mut curve = surface.sectional_curve(bnd_box);+ curve.control_points_mut().for_each(|pt| *pt *= 3.0);+ let surface = NurbsSurface::new(surface);+ let curve = NurbsCurve::new(curve);+ assert!(surface.include(&curve));+}++#[test]+fn test_include3d() {+ let knot_vec = KnotVec::bezier_knot(2);+ let ctrl_pts = vec![+ vec![+ Vector4::new(-1.0, -1.0, 2.0, 1.0),+ Vector4::new(-1.0, 0.0, 0.0, 1.0),+ Vector4::new(-1.0, 1.0, 2.0, 1.0),+ ],+ vec![+ Vector4::new(0.0, -1.0, 0.0, 1.0),+ Vector4::new(0.0, 0.0, -2.0, 1.0),+ Vector4::new(0.0, 1.0, 0.0, 1.0),+ ],+ vec![+ Vector4::new(1.0, -1.0, 2.0, 1.0),+ Vector4::new(1.0, 0.0, 0.0, 1.0),+ Vector4::new(1.0, 1.0, 2.0, 1.0),+ ],+ ];+ let surface = NurbsSurface::new(BSplineSurface::new((knot_vec.clone(), knot_vec), ctrl_pts));++ let knot_vec = KnotVec::from(vec![+ 0.0, 0.0, 0.0, 0.25, 0.25, 0.5, 0.5, 0.75, 0.75, 1.0, 1.0, 1.0,+ ]);+ let ctrl_pts = vec![+ // the vector of the indices of control points+ Vector4::new(0.0, -2.0, 2.0, 2.0),+ Vector4::new(1.0, -1.0, 1.0, 1.0),+ Vector4::new(1.0, 0.0, 1.0, 1.0),+ Vector4::new(1.0, 1.0, 1.0, 1.0),+ Vector4::new(0.0, 2.0, 2.0, 2.0),+ Vector4::new(-1.0, 1.0, 1.0, 1.0),+ Vector4::new(-1.0, 0.0, 1.0, 1.0),+ Vector4::new(-1.0, -1.0, 1.0, 1.0),+ Vector4::new(0.0, -2.0, 2.0, 2.0),+ ];+ let mut curve = NurbsCurve::new(BSplineCurve::new(knot_vec, ctrl_pts));+ assert!(surface.include(&curve));+ *curve.control_point_mut(1) += Vector4::new(0.0, 0.0, 0.00001, 0.0);+ assert!(!surface.include(&curve));+}diff --git a/vendor/truck-geometry/src/specifieds/circle.rs b/vendor/truck-geometry/src/specifieds/circle.rsnew file mode 100644index 0000000000..876be2f5c4--- /dev/null+++ b/vendor/truck-geometry/src/specifieds/circle.rs@@ -0,0 +1,161 @@+use super::*;+use std::f64::consts::PI;++impl<P> UnitCircle<P> {+ /// constructor+ #[inline]+ pub const fn new() -> Self { Self(std::marker::PhantomData) }+}++impl ParametricCurve for UnitCircle<Point2> {+ type Point = Point2;+ type Vector = Vector2;+ #[inline]+ fn subs(&self, t: f64) -> Self::Point { Point2::new(f64::cos(t), f64::sin(t)) }+ #[inline]+ fn der(&self, t: f64) -> Self::Vector { Vector2::new(-f64::sin(t), f64::cos(t)) }+ #[inline]+ fn der2(&self, t: f64) -> Self::Vector { Vector2::new(-f64::cos(t), -f64::sin(t)) }+ #[inline]+ fn parameter_range(&self) -> ParameterRange {+ (Bound::Included(0.0), Bound::Excluded(2.0 * PI))+ }+}++impl BoundedCurve for UnitCircle<Point2> {}++impl ParametricCurve for UnitCircle<Point3> {+ type Point = Point3;+ type Vector = Vector3;+ #[inline]+ fn subs(&self, t: f64) -> Self::Point { Point3::new(f64::cos(t), f64::sin(t), 0.0) }+ #[inline]+ fn der(&self, t: f64) -> Self::Vector { Vector3::new(-f64::sin(t), f64::cos(t), 0.0) }+ #[inline]+ fn der2(&self, t: f64) -> Self::Vector { Vector3::new(-f64::cos(t), -f64::sin(t), 0.0) }+ #[inline]+ fn period(&self) -> Option<f64> { Some(2.0 * PI) }+ #[inline]+ fn parameter_range(&self) -> ParameterRange {+ (Bound::Included(0.0), Bound::Excluded(2.0 * PI))+ }+}++impl BoundedCurve for UnitCircle<Point3> {}++impl<P> ParameterDivision1D for UnitCircle<P>+where UnitCircle<P>: ParametricCurve<Point = P>+{+ type Point = P;+ fn parameter_division(&self, range: (f64, f64), tol: f64) -> (Vec<f64>, Vec<P>) {+ nonpositive_tolerance!(tol);+ let tol = f64::min(tol, 0.8);+ let delta = 2.0 * f64::acos(1.0 - tol);+ let n = 1 + ((range.1 - range.0) / delta) as usize;+ let params = (0..=n)+ .map(|i| {+ let t = i as f64 / n as f64;+ range.0 * (1.0 - t) + range.1 * t+ })+ .collect::<Vec<_>>();+ let pts = params.iter().map(|t| self.subs(*t)).collect();+ (params, pts)+ }+}++impl SearchNearestParameter<D1> for UnitCircle<Point2> {+ type Point = Point2;+ fn search_nearest_parameter<H: Into<SPHint1D>>(+ &self,+ pt: Point2,+ _: H,+ _: usize,+ ) -> Option<f64> {+ let v = pt.to_vec();+ if v.magnitude().so_small() {+ return None;+ }+ let v = v.normalize();+ let theta = f64::acos(f64::clamp(v.x, -1.0, 1.0));+ let theta = match v.y > 0.0 {+ true => theta,+ false => 2.0 * PI - theta,+ };+ Some(theta)+ }+}++#[test]+fn search_nearest_parameter() {+ const N: usize = 100;+ let circle = UnitCircle::<Point2>::new();+ for i in 0..N {+ let t = 2.0 * PI * i as f64 / N as f64;+ let a = 5.0 * rand::random::<f64>() + 0.1;+ let p = a * circle.subs(t);+ let s = circle.search_nearest_parameter(p, None, 1).unwrap();+ let q = a * circle.subs(s);+ assert_near!(p, q);+ }+}++impl SearchParameter<D1> for UnitCircle<Point2> {+ type Point = Point2;+ fn search_parameter<H: Into<SPHint1D>>(&self, pt: Point2, _: H, _: usize) -> Option<f64> {+ let v = pt.to_vec();+ if !v.magnitude().near(&1.0) {+ return None;+ }+ let v = v.normalize();+ let theta = f64::acos(f64::clamp(v.x, -1.0, 1.0));+ let theta = match v.y > 0.0 {+ true => theta,+ false => 2.0 * PI - theta,+ };+ Some(theta)+ }+}++#[test]+fn search_parameter() {+ const N: usize = 100;+ let circle = UnitCircle::<Point2>::new();+ for i in 1..N {+ let t = 2.0 * PI * i as f64 / N as f64;+ let p = circle.subs(t);+ let s = circle.search_parameter(p, None, 1).unwrap();+ assert_near!(s, t);+ }+}++impl SearchNearestParameter<D1> for UnitCircle<Point3> {+ type Point = Point3;+ fn search_nearest_parameter<H: Into<SPHint1D>>(+ &self,+ pt: Point3,+ _: H,+ _: usize,+ ) -> Option<f64> {+ UnitCircle::<Point2>::new().search_nearest_parameter(Point2::new(pt.x, pt.y), None, 0)+ }+}++impl SearchParameter<D1> for UnitCircle<Point3> {+ type Point = Point3;+ fn search_parameter<H: Into<SPHint1D>>(&self, pt: Point3, _: H, _: usize) -> Option<f64> {+ if !f64::abs(pt.z).so_small() {+ return None;+ }+ UnitCircle::<Point2>::new().search_parameter(Point2::new(pt.x, pt.y), None, 0)+ }+}++#[test]+fn parameter_division() {+ let c = UnitCircle::<Point2>::new();+ let (_div, pts) = c.parameter_division(c.range_tuple(), 0.05);+ for a in pts.windows(2) {+ let p = a[0].midpoint(a[1]);+ assert!(p.to_vec().magnitude() > 0.95);+ }+}diff --git a/vendor/truck-geometry/src/specifieds/hyperbola.rs b/vendor/truck-geometry/src/specifieds/hyperbola.rsnew file mode 100644index 0000000000..a0c30bf8df--- /dev/null+++ b/vendor/truck-geometry/src/specifieds/hyperbola.rs@@ -0,0 +1,125 @@+use super::*;++impl<P> UnitHyperbola<P> {+ /// constructor+ #[inline]+ pub const fn new() -> UnitHyperbola<P> { UnitHyperbola(std::marker::PhantomData) }+}++impl ParametricCurve for UnitHyperbola<Point2> {+ type Point = Point2;+ type Vector = Vector2;+ #[inline]+ fn subs(&self, t: f64) -> Self::Point { Point2::new(f64::cosh(t), f64::sinh(t)) }+ #[inline]+ fn der(&self, t: f64) -> Self::Vector { Vector2::new(f64::sinh(t), f64::cosh(t)) }+ #[inline]+ fn der2(&self, t: f64) -> Self::Vector { Vector2::new(f64::cosh(t), f64::sinh(t)) }+}++impl ParametricCurve for UnitHyperbola<Point3> {+ type Point = Point3;+ type Vector = Vector3;+ #[inline]+ fn subs(&self, t: f64) -> Self::Point { Point3::new(f64::cosh(t), f64::sinh(t), 0.0) }+ #[inline]+ fn der(&self, t: f64) -> Self::Vector { Vector3::new(f64::sinh(t), f64::cosh(t), 0.0) }+ #[inline]+ fn der2(&self, t: f64) -> Self::Vector { Vector3::new(f64::cosh(t), f64::sinh(t), 0.0) }+}++impl<P> ParameterDivision1D for UnitHyperbola<P>+where+ UnitHyperbola<P>: ParametricCurve<Point = P>,+ P: EuclideanSpace<Scalar = f64> + MetricSpace<Metric = f64> + HashGen<f64>,+{+ type Point = P;+ fn parameter_division(&self, range: (f64, f64), tol: f64) -> (Vec<f64>, Vec<P>) {+ algo::curve::parameter_division(self, range, tol)+ }+}++impl SearchNearestParameter<D1> for UnitHyperbola<Point2> {+ type Point = Point2;+ fn search_nearest_parameter<H: Into<SPHint1D>>(+ &self,+ p: Point2,+ _: H,+ _: usize,+ ) -> Option<f64> {+ let a = -p.y;+ let b = (p.y * p.y - p.x * p.x) / 4.0 + 1.0;+ let c = -p.y;+ let d = p.y * p.y / 4.0;+ let y = solver::solve_quartic(a, b, c, d)+ .into_iter()+ .filter_map(|z| match z.im.so_small() {+ true => Some(z.re),+ false => None,+ })+ .min_by(|s, t| {+ p.distance2(self.subs(*s))+ .partial_cmp(&p.distance2(self.subs(*t)))+ .unwrap()+ })?;+ Some(f64::asinh(y))+ }+}++impl SearchNearestParameter<D1> for UnitHyperbola<Point3> {+ type Point = Point3;+ fn search_nearest_parameter<H: Into<SPHint1D>>(+ &self,+ p: Point3,+ _: H,+ _trials: usize,+ ) -> Option<f64> {+ UnitHyperbola::<Point2>::new().search_nearest_parameter(+ Point2::new(p.x, p.y),+ None,+ _trials,+ )+ }+}++impl SearchParameter<D1> for UnitHyperbola<Point2> {+ type Point = Point2;+ fn search_parameter<H: Into<SPHint1D>>(&self, p: Point2, _: H, _: usize) -> Option<f64> {+ let t = f64::asinh(p.y);+ match p.near(&self.subs(t)) {+ true => Some(t),+ false => None,+ }+ }+}++impl SearchParameter<D1> for UnitHyperbola<Point3> {+ type Point = Point3;+ fn search_parameter<H: Into<SPHint1D>>(&self, p: Point3, _: H, _: usize) -> Option<f64> {+ let t = f64::asinh(p.y);+ match p.near(&self.subs(t)) {+ true => Some(t),+ false => None,+ }+ }+}++#[test]+fn snp_test() {+ let curve = UnitHyperbola::<Point2>::new();+ let p = curve.subs(2.0);+ let q = p + Vector2::new(-p.x, p.y);+ let t = curve.search_nearest_parameter(q, None, 0).unwrap();+ assert_near!(t, 2.0);+}++#[test]+fn sp_test() {+ let curve = UnitHyperbola::<Point2>::new();+ let t = 100.0 * rand::random::<f64>() - 50.0;+ let p = curve.subs(t);+ assert_near!(curve.search_parameter(p, None, 0).unwrap(), t);++ let q = Point2::new(-1.0, 0.0);+ assert!(curve.search_parameter(q, None, 0).is_none());+}diff --git a/vendor/truck-geometry/src/specifieds/line.rs b/vendor/truck-geometry/src/specifieds/line.rsnew file mode 100644index 0000000000..22b7afda0c--- /dev/null+++ b/vendor/truck-geometry/src/specifieds/line.rs@@ -0,0 +1,217 @@+use super::*;+use truck_base::cgmath64::control_point::ControlPoint;++impl<P: Copy> Line<P> {+ /// initialize line from vector+ #[inline]+ pub fn from_origin_direction<V>(origin: P, direction: V) -> Self+ where P: std::ops::Add<V, Output = P> {+ Self(origin, origin + direction)+ }+ /// to a bspline curve+ #[inline]+ pub fn to_bspline(self) -> BSplineCurve<P> {+ BSplineCurve::new(KnotVec::bezier_knot(1), vec![self.0, self.1])+ }+}++impl<P> Line<P>+where+ P: EuclideanSpace<Scalar = f64>,+ P::Diff: InnerSpace<Scalar = f64>,+{+ /// Returns the projected point to the line.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let line = Line(Point2::new(0.0, 0.0), Point2::new(1.0, 2.0));+ /// let pt = Point2::new(0.0, 1.0);+ /// assert_near!(line.projection(pt), Point2::new(0.4, 0.8));+ /// ```+ pub fn projection(self, point: P) -> P {+ let (u, v) = (point - self.0, self.1 - self.0);+ self.0 + v * u.dot(v) / v.dot(v)+ }+ /// Returns the distance between the line and the point `point`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let line = Line(Point2::new(0.0, 0.0), Point2::new(3.0, 4.0));+ ///+ /// // The foot of the perpendicular line is on a line segment+ /// let pt = Point2::new(3.0, 0.0);+ /// assert_near!(line.distance_to_point(pt), 2.4);+ ///+ /// // The foot of the perpendicular line is not on a line segment+ /// let pt = Point2::new(0.0, -4.0);+ /// assert_near!(line.distance_to_point(pt), 2.4);+ /// ```+ pub fn distance_to_point(self, point: P) -> f64 {+ let (u, v) = (point - self.0, self.1 - self.0);+ (u - v * u.dot(v) / v.dot(v)).magnitude()+ }+ /// Returns the distance between the sengment and the point `point`.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let line = Line(Point2::new(0.0, 0.0), Point2::new(3.0, 4.0));+ ///+ /// // The foot of the perpendicular line is on a line segment+ /// let pt = Point2::new(3.0, 0.0);+ /// assert_near!(line.distance_to_point_as_segment(pt), 2.4);+ ///+ /// // The foot of the perpendicular line is not on a line segment+ /// let pt = Point2::new(0.0, -4.0);+ /// assert_near!(line.distance_to_point_as_segment(pt), 4.0);+ /// ```+ pub fn distance_to_point_as_segment(self, point: P) -> f64 {+ let (u, v) = (point - self.0, self.1 - self.0);+ let t = f64::clamp(u.dot(v) / v.dot(v), 0.0, 1.0);+ (u - v * t).magnitude()+ }+}++impl Line<Point2> {+ /// Returns the intersection of two lines and its parameters.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let line0 = Line(Point2::new(0.0, 0.0), Point2::new(9.0, 3.0));+ /// let line1 = Line(Point2::new(0.0, 6.0), Point2::new(9.0, 0.0));+ /// let (s, t, p) = line0.intersection(line1).unwrap();+ /// assert_near!(line0.subs(s), Point2::new(6.0, 2.0));+ /// assert_near!(line1.subs(t), Point2::new(6.0, 2.0));+ /// assert_near!(p, Point2::new(6.0, 2.0));+ /// ```+ /// # Failures+ /// Returns `None` if two lines are parallel.+ /// ```+ /// use truck_geometry::prelude::*;+ /// let line0 = Line(Point2::new(0.0, 0.0), Point2::new(9.0, 3.0));+ /// let line1 = Line(Point2::new(-1.0, 0.0), Point2::new(8.0, 3.0));+ /// assert!(line0.intersection(line1).is_none());+ /// ```+ pub fn intersection(self, other: Line<Point2>) -> Option<(f64, f64, Point2)> {+ let mat = Matrix2::from_cols(self.1 - self.0, other.0 - other.1);+ let v = other.0 - self.0;+ let params = mat.invert().map(|inv| inv * v)?;+ Some((params.x, params.y, self.subs(params.x)))+ }+}++impl<P: ControlPoint<f64>> ParametricCurve for Line<P> {+ type Point = P;+ type Vector = P::Diff;+ #[inline]+ fn subs(&self, t: f64) -> Self::Point { self.0 + (self.1 - self.0) * t }+ #[inline]+ fn der(&self, _: f64) -> Self::Vector { self.1 - self.0 }+ #[inline]+ fn der2(&self, _: f64) -> Self::Vector { Self::Vector::zero() }+ /// Return `0.0..=1.0` i.e. we regard it as a segment+ #[inline]+ fn parameter_range(&self) -> ParameterRange { (Bound::Included(0.0), Bound::Included(1.0)) }+}++impl<P: ControlPoint<f64>> BoundedCurve for Line<P> {}++impl<P: ControlPoint<f64>> Cut for Line<P> {+ #[inline]+ fn cut(&mut self, t: f64) -> Self {+ let r = self.subs(t);+ let res = Self(r, self.1);+ self.1 = r;+ res+ }+}++impl<P: ControlPoint<f64>> ParameterDivision1D for Line<P> {+ type Point = P;+ #[inline]+ fn parameter_division(&self, range: (f64, f64), _: f64) -> (Vec<f64>, Vec<P>) {+ (+ vec![range.0, range.1],+ vec![self.subs(range.0), self.subs(range.1)],+ )+ }+}++impl<P: Copy> Invertible for Line<P> {+ #[inline]+ fn invert(&mut self) { *self = Self(self.1, self.0); }+ #[inline]+ fn inverse(&self) -> Self { Self(self.1, self.0) }+}++impl<P> SearchNearestParameter<D1> for Line<P>+where+ P: ControlPoint<f64>,+ P::Diff: InnerSpace<Scalar = f64>,+{+ type Point = P;+ #[inline]+ fn search_nearest_parameter<H: Into<SPHint1D>>(&self, pt: P, _: H, _: usize) -> Option<f64> {+ let b = self.1 - self.0;+ Some((pt - self.0).dot(b) / b.dot(b))+ }+}++impl<P> SearchParameter<D1> for Line<P>+where+ P: ControlPoint<f64> + Tolerance,+ P::Diff: InnerSpace<Scalar = f64>,+{+ type Point = P;+ #[inline]+ fn search_parameter<H: Into<SPHint1D>>(&self, pt: P, _: H, _: usize) -> Option<f64> {+ let b = self.1 - self.0;+ let t = (pt - self.0).dot(b) / b.dot(b);+ match self.subs(t).near(&pt) {+ true => Some(t),+ false => None,+ }+ }+}++impl<P: EuclideanSpace, M: Transform<P>> Transformed<M> for Line<P> {+ #[inline]+ fn transform_by(&mut self, trans: M) {+ self.0 = trans.transform_point(self.0);+ self.1 = trans.transform_point(self.1);+ }+ #[inline]+ fn transformed(&self, trans: M) -> Self {+ Line(trans.transform_point(self.0), trans.transform_point(self.1))+ }+}++#[test]+fn line() {+ let line = Line(Point2::new(1.0, 0.0), Point2::new(0.0, 1.0));++ // subs+ assert_near!(line.subs(0.4), Point2::new(0.6, 0.4));++ // inverse+ let line_inverse = line.inverse();+ assert_eq!(line.0, line_inverse.1);+ assert_eq!(line.1, line_inverse.0);++ // cut+ let mut line0 = line;+ let line1 = line0.cut(0.4);+ assert_eq!(line.0, line0.0);+ assert_near!(line0.1, line.subs(0.4));+ assert_eq!(line0.1, line1.0);+ assert_eq!(line1.1, line.1);++ // SNP+ assert_near!(+ line.search_nearest_parameter(Point2::new(1.0, 1.0), None, 0)+ .unwrap(),+ 0.5+ );+ assert!(line+ .search_parameter(Point2::new(1.0, 1.0), None, 0)+ .is_none());+}diff --git a/vendor/truck-geometry/src/specifieds/mod.rs b/vendor/truck-geometry/src/specifieds/mod.rsnew file mode 100644index 0000000000..fc7c24a14b--- /dev/null+++ b/vendor/truck-geometry/src/specifieds/mod.rs@@ -0,0 +1,115 @@+use crate::{prelude::*, *};++/// line+/// # Example+/// ```+/// use truck_geometry::prelude::*;+/// let line = Line(Point2::new(0.0, 0.0), Point2::new(1.0, 1.0));+/// assert_near!(line.subs(0.5), Point2::new(0.5, 0.5));+/// ```+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]+pub struct Line<P>(pub P, pub P);++/// unit circle+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]+pub struct UnitCircle<P>(std::marker::PhantomData<P>);++/// unit hyperbola+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]+pub struct UnitHyperbola<P>(std::marker::PhantomData<P>);++/// parabola whose apex is the origin.+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]+pub struct UnitParabola<P>(std::marker::PhantomData<P>);++/// plane+/// # Example+/// ```+/// use truck_geometry::prelude::*;+///+/// // arbitrary three points+/// let pt0 = Point3::new(0.0, 1.0, 2.0);+/// let pt1 = Point3::new(1.0, 1.0, 3.0);+/// let pt2 = Point3::new(0.0, 2.0, 3.0);+///+/// // Creates a plane+/// let plane: Plane = Plane::new(pt0, pt1, pt2);+/// // The origin of the plane is pt0.+/// assert_near!(plane.origin(), pt0);+/// // The u-axis of the plane is the vector from pt0 to pt1.+/// assert_near!(plane.u_axis(), pt1 - pt0);+/// // The v-axis of the plane is the vector from pt0 to pt2.+/// assert_near!(plane.v_axis(), pt2 - pt0);+/// // The normal is the normalized u-axis × v-axis+/// assert_near!(plane.normal(), (pt1 - pt0).cross(pt2 - pt0).normalize());+/// ```+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+pub struct Plane {+ o: Point3,+ p: Point3,+ q: Point3,+}++/// sphere+/// # Examples+/// ```+/// use truck_geometry::prelude::*;+/// use std::f64::consts::PI;+///+/// let center = Point3::new(1.0, 2.0, 3.0);+/// let radius = 4.56;+///+/// let sphere = Sphere::new(center, radius);+/// const N: usize = 100;+/// for i in 0..=N {+/// for j in 0..=N {+/// // the parameter u is latitude+/// let u = PI * i as f64 / N as f64;+/// // the parameter v is longitude+/// let v = 2.0 * PI * j as f64 / N as f64;+///+/// // simple relation between a point and its normal.+/// let pt = sphere.subs(u, v);+/// let n = sphere.normal(u, v);+/// assert_near!(pt - center, n * radius);+///+/// // the proof of u is latitude and v is longitude+/// assert!((PI / 2.0 - u) * (pt.z - center.z) >= 0.0);+/// assert!((PI - v) * (pt.y - center.y) >= 0.0);+/// }+/// }+/// ```+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+pub struct Sphere {+ center: Point3,+ radius: f64,+}++/// torus+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+pub struct Torus {+ center: Point3,+ large_radius: f64,+ small_radius: f64,+}++mod circle;+mod hyperbola;+mod line;+mod parabola;+mod plane;+mod sphere;+mod torus;++macro_rules! always_true {+ ($ty: tt) => {+ impl<P> PartialEq for $ty<P> {+ fn eq(&self, _: &Self) -> bool { true }+ }+ impl<P> Eq for $ty<P> {}+ };+}++always_true!(UnitCircle);+always_true!(UnitParabola);+always_true!(UnitHyperbola);diff --git a/vendor/truck-geometry/src/specifieds/parabola.rs b/vendor/truck-geometry/src/specifieds/parabola.rsnew file mode 100644index 0000000000..58b57f8de2--- /dev/null+++ b/vendor/truck-geometry/src/specifieds/parabola.rs@@ -0,0 +1,137 @@+use super::*;++impl<P> UnitParabola<P> {+ /// constructor+ #[inline]+ pub const fn new() -> Self { Self(std::marker::PhantomData) }+}++impl ParametricCurve for UnitParabola<Point2> {+ type Point = Point2;+ type Vector = Vector2;+ #[inline]+ fn subs(&self, t: f64) -> Self::Point { Point2::new(t * t, 2.0 * t) }+ #[inline]+ fn der(&self, t: f64) -> Self::Vector { Vector2::new(2.0 * t, 2.0) }+ #[inline]+ fn der2(&self, _: f64) -> Self::Vector { Vector2::new(2.0, 0.0) }+}++impl ParametricCurve for UnitParabola<Point3> {+ type Point = Point3;+ type Vector = Vector3;+ #[inline]+ fn subs(&self, t: f64) -> Self::Point { Point3::new(t * t, 2.0 * t, 0.0) }+ #[inline]+ fn der(&self, t: f64) -> Self::Vector { Vector3::new(2.0 * t, 2.0, 0.0) }+ #[inline]+ fn der2(&self, _: f64) -> Self::Vector { Vector3::new(2.0, 0.0, 0.0) }+}++impl<P> ParameterDivision1D for UnitParabola<P>+where+ UnitParabola<P>: ParametricCurve<Point = P>,+ P: EuclideanSpace<Scalar = f64> + MetricSpace<Metric = f64> + HashGen<f64>,+{+ type Point = P;+ fn parameter_division(&self, range: (f64, f64), tol: f64) -> (Vec<f64>, Vec<P>) {+ algo::curve::parameter_division(self, range, tol)+ }+}++impl SearchNearestParameter<D1> for UnitParabola<Point2> {+ type Point = Point2;+ #[inline]+ fn search_nearest_parameter<H: Into<SPHint1D>>(+ &self,+ pt: Point2,+ _: H,+ _: usize,+ ) -> Option<f64> {+ let p = 2.0 - pt.x;+ let q = -pt.y;+ solver::pre_solve_cubic(p, q)+ .into_iter()+ .filter_map(|x| match x.im.so_small() {+ true => Some(x.re),+ false => None,+ })+ .min_by(|s, t| {+ pt.distance2(self.subs(*s))+ .partial_cmp(&pt.distance2(self.subs(*t)))+ .unwrap()+ })+ }+}++impl SearchNearestParameter<D1> for UnitParabola<Point3> {+ type Point = Point3;+ #[inline]+ fn search_nearest_parameter<H: Into<SPHint1D>>(+ &self,+ pt: Point3,+ _hint: H,+ _trials: usize,+ ) -> Option<f64> {+ UnitParabola::<Point2>::new().search_nearest_parameter(+ Point2::new(pt.x, pt.y),+ _hint,+ _trials,+ )+ }+}++impl SearchParameter<D1> for UnitParabola<Point2> {+ type Point = Point2;+ #[inline]+ fn search_parameter<H: Into<SPHint1D>>(&self, pt: Point2, _: H, _: usize) -> Option<f64> {+ let t = pt.y / 2.0;+ let pt0 = self.subs(t);+ match pt.near(&pt0) {+ true => Some(t),+ false => None,+ }+ }+}++impl SearchParameter<D1> for UnitParabola<Point3> {+ type Point = Point3;+ #[inline]+ fn search_parameter<H: Into<SPHint1D>>(+ &self,+ pt: Point3,+ _hint: H,+ _trials: usize,+ ) -> Option<f64> {+ match pt.z.so_small() {+ true => UnitParabola::<Point2>::new().search_parameter(+ Point2::new(pt.x, pt.y),+ _hint,+ _trials,+ ),+ false => None,+ }+ }+}++#[test]+fn snp_test() {+ let curve = UnitParabola::<Point2>::new();++ let p = Point2::new(-3.0, 0.0);+ assert_near!(curve.search_nearest_parameter(p, None, 0).unwrap(), 0.0);+ let p = Point2::new(-3.0, 6.0);+ assert_near!(curve.search_nearest_parameter(p, None, 0).unwrap(), 1.0);+ let p = Point2::new(1.5, 1.5);+ assert_near!(curve.search_nearest_parameter(p, None, 0).unwrap(), 1.0);+}++#[test]+fn sp_test() {+ let curve = UnitParabola::<Point2>::new();++ let p = Point2::new(4.0, -4.0);+ assert_near!(curve.search_parameter(p, None, 0).unwrap(), -2.0);+ let p = Point2::new(-3.0, 6.0);+ assert!(curve.search_parameter(p, None, 0).is_none());+}diff --git a/vendor/truck-geometry/src/specifieds/plane.rs b/vendor/truck-geometry/src/specifieds/plane.rsnew file mode 100644index 0000000000..c5ffebdcd6--- /dev/null+++ b/vendor/truck-geometry/src/specifieds/plane.rs@@ -0,0 +1,256 @@+use super::*;++impl Plane {+ /// Creates a new plane from three points.+ #[inline(always)]+ pub const fn new(origin: Point3, one: Point3, another: Point3) -> Plane {+ Plane {+ o: origin,+ p: one,+ q: another,+ }+ }+ /// Returns the origin+ #[inline(always)]+ pub const fn origin(&self) -> Point3 { self.o }+ /// Returns the u-axis+ #[inline(always)]+ pub fn u_axis(&self) -> Vector3 { self.p - self.o }+ /// Returns the v-axis+ #[inline(always)]+ pub fn v_axis(&self) -> Vector3 { self.q - self.o }+ /// Returns the normal+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let plane = Plane::new(+ /// Point3::new(0.0, 0.0, 0.0),+ /// Point3::new(1.0, 0.0, 0.0),+ /// Point3::new(0.0, 1.0, 0.0),+ /// );+ /// assert_near!(plane.normal(), Vector3::unit_z());+ /// ```+ #[inline(always)]+ pub fn normal(&self) -> Vector3 { self.u_axis().cross(self.v_axis()).normalize() }+ /// Gets the parameter of `pt` in plane's matrix.+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let plane = Plane::new(+ /// Point3::new(1.0, 2.0, 3.0),+ /// Point3::new(2.0, 1.0, 3.0),+ /// Point3::new(3.0, 4.0, -1.0),+ /// );+ ///+ /// let pt = Point3::new(2.1, -6.5, 4.7);+ /// let prm = plane.get_parameter(pt);+ /// let rev = plane.origin()+ /// + prm[0] * plane.u_axis()+ /// + prm[1] * plane.v_axis()+ /// + prm[2] * plane.normal();+ /// assert_near!(pt, rev);+ /// ```+ #[inline(always)]+ pub fn get_parameter(&self, pt: Point3) -> Vector3 {+ let a = self.u_axis();+ let b = self.v_axis();+ let c = self.normal();+ let mat = Matrix3::from_cols(a, b, c).invert().unwrap();+ mat * (pt - self.o)+ }+ /// into B-spline surface+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let pt0 = Point3::new(0.0, 1.0, 2.0);+ /// let pt1 = Point3::new(1.0, 1.0, 3.0);+ /// let pt2 = Point3::new(0.0, 2.0, 3.0);+ /// let plane: Plane = Plane::new(pt0, pt1, pt2);+ /// let surface: BSplineSurface<Point3> = plane.into_bspline();+ /// assert_eq!(surface.range_tuple(), ((0.0, 1.0), (0.0, 1.0)));+ ///+ /// const N: usize = 100;+ /// for i in 0..=N {+ /// for j in 0..=N {+ /// let u = i as f64 / N as f64;+ /// let v = j as f64 / N as f64;+ /// let res = surface.subs(u, v);+ /// let ans = plane.subs(u, v);+ /// assert_near!(ans, res);+ /// }+ /// }+ /// ```+ #[inline(always)]+ pub fn into_bspline(&self) -> BSplineSurface<Point3> {+ let o = self.o;+ let p = self.p;+ let q = self.q;+ BSplineSurface::debug_new(+ (KnotVec::bezier_knot(1), KnotVec::bezier_knot(1)),+ vec![vec![o, q], vec![p, p + (q - o)]],+ )+ }+ /// into NURBS surface+ /// # Examples+ /// ```+ /// use truck_geometry::prelude::*;+ /// let pt0 = Point3::new(0.0, 1.0, 2.0);+ /// let pt1 = Point3::new(1.0, 1.0, 3.0);+ /// let pt2 = Point3::new(0.0, 2.0, 3.0);+ /// let plane: Plane = Plane::new(pt0, pt1, pt2);+ /// let surface: NurbsSurface<Vector4> = plane.into_nurbs();+ /// assert_eq!(surface.range_tuple(), ((0.0, 1.0), (0.0, 1.0)));+ ///+ /// const N: usize = 100;+ /// for i in 0..=N {+ /// for j in 0..=N {+ /// let u = i as f64 / N as f64;+ /// let v = j as f64 / N as f64;+ /// let res = surface.subs(u, v);+ /// let ans = plane.subs(u, v);+ /// assert_near!(ans, res);+ /// }+ /// }+ /// ```+ #[inline(always)]+ pub fn into_nurbs(&self) -> NurbsSurface<Vector4> {+ let o = self.o.to_homogeneous();+ let p = self.p.to_homogeneous();+ let q = self.q.to_homogeneous();+ NurbsSurface::new(BSplineSurface::debug_new(+ (KnotVec::bezier_knot(1), KnotVec::bezier_knot(1)),+ vec![vec![o, q], vec![p, p + q - o]],+ ))+ }+}++impl ParametricSurface for Plane {+ type Point = Point3;+ type Vector = Vector3;+ #[inline(always)]+ fn subs(&self, u: f64, v: f64) -> Point3 {+ self.o + u * (self.p - self.o) + v * (self.q - self.o)+ }+ #[inline(always)]+ fn uder(&self, _: f64, _: f64) -> Vector3 { self.p - self.o }+ #[inline(always)]+ fn vder(&self, _: f64, _: f64) -> Vector3 { self.q - self.o }+ #[inline(always)]+ fn uuder(&self, _: f64, _: f64) -> Vector3 { Vector3::zero() }+ #[inline(always)]+ fn uvder(&self, _: f64, _: f64) -> Vector3 { Vector3::zero() }+ #[inline(always)]+ fn vvder(&self, _: f64, _: f64) -> Vector3 { Vector3::zero() }+ /// as square+ #[inline(always)]+ fn parameter_range(&self) -> (ParameterRange, ParameterRange) {+ let range = (Bound::Included(0.0), Bound::Included(1.0));+ (range, range)+ }+}++impl ParametricSurface3D for Plane {+ #[inline(always)]+ fn normal(&self, _: f64, _: f64) -> Vector3 { self.normal() }+}++impl BoundedSurface for Plane {}++impl Invertible for Plane {+ #[inline(always)]+ fn inverse(&self) -> Self {+ Plane {+ o: self.o,+ p: self.q,+ q: self.p,+ }+ }+ #[inline(always)]+ fn invert(&mut self) { *self = self.inverse(); }+}++impl IncludeCurve<BSplineCurve<Point3>> for Plane {+ #[inline(always)]+ fn include(&self, curve: &BSplineCurve<Point3>) -> bool {+ let origin = self.origin();+ let normal = self.normal();+ curve+ .control_points()+ .iter()+ .all(|pt| (pt - origin).dot(normal).so_small())+ }+}++impl IncludeCurve<NurbsCurve<Vector4>> for Plane {+ fn include(&self, curve: &NurbsCurve<Vector4>) -> bool {+ let origin = self.origin();+ let normal = self.normal();+ let (s, e) = (curve.front(), curve.back());+ if !(s - origin).dot(normal).so_small() || !(e - origin).dot(normal).so_small() {+ return false;+ }+ curve.non_rationalized().control_points().iter().all(|pt| {+ if pt[3].so_small() {+ true+ } else {+ let pt = Point3::from_homogeneous(*pt);+ (pt - origin).dot(normal).so_small()+ }+ })+ }+}++impl ParameterDivision2D for Plane {+ #[inline(always)]+ fn parameter_division(&self, range: ((f64, f64), (f64, f64)), _: f64) -> (Vec<f64>, Vec<f64>) {+ (vec![range.0 .0, range.0 .1], vec![range.1 .0, range.1 .1])+ }+}++impl<T: Transform3<Scalar = f64>> Transformed<T> for Plane {+ #[inline(always)]+ fn transform_by(&mut self, trans: T) {+ self.o = trans.transform_point(self.o);+ self.p = trans.transform_point(self.p);+ self.q = trans.transform_point(self.q);+ }+ #[inline(always)]+ fn transformed(&self, trans: T) -> Self {+ Plane {+ o: trans.transform_point(self.o),+ p: trans.transform_point(self.p),+ q: trans.transform_point(self.q),+ }+ }+}++impl SearchParameter<D2> for Plane {+ type Point = Point3;+ #[inline(always)]+ fn search_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point3,+ _: H,+ _: usize,+ ) -> Option<(f64, f64)> {+ let v = self.get_parameter(point);+ match v[2].so_small() {+ true => Some((v[0], v[1])),+ false => None,+ }+ }+}++impl SearchNearestParameter<D2> for Plane {+ type Point = Point3;+ #[inline(always)]+ fn search_nearest_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point3,+ _: H,+ _: usize,+ ) -> Option<(f64, f64)> {+ let v = self.get_parameter(point);+ Some((v[0], v[1]))+ }+}diff --git a/vendor/truck-geometry/src/specifieds/sphere.rs b/vendor/truck-geometry/src/specifieds/sphere.rsnew file mode 100644index 0000000000..257997e553--- /dev/null+++ b/vendor/truck-geometry/src/specifieds/sphere.rs@@ -0,0 +1,219 @@+use super::*;+use std::f64::consts::PI;++impl Sphere {+ /// Creates a sphere+ #[inline(always)]+ pub const fn new(center: Point3, radius: f64) -> Sphere { Sphere { center, radius } }+ /// Returns the center+ #[inline(always)]+ pub const fn center(&self) -> Point3 { self.center }+ /// Returns the radius+ #[inline(always)]+ pub const fn radius(&self) -> f64 { self.radius }+ /// Returns whether the point `pt` is on sphere+ #[inline(always)]+ pub fn include(&self, pt: Point3) -> bool { self.center.distance(pt).near(&self.radius) }+}++impl ParametricSurface for Sphere {+ type Point = Point3;+ type Vector = Vector3;+ #[inline(always)]+ fn subs(&self, u: f64, v: f64) -> Point3 { self.center() + self.radius * self.normal(u, v) }+ #[inline(always)]+ fn uder(&self, u: f64, v: f64) -> Vector3 {+ self.radius+ * Vector3::new(+ f64::cos(u) * f64::cos(v),+ f64::cos(u) * f64::sin(v),+ -f64::sin(u),+ )+ }+ #[inline(always)]+ fn vder(&self, u: f64, v: f64) -> Vector3 {+ self.radius * f64::sin(u) * Vector3::new(-f64::sin(v), f64::cos(v), 0.0)+ }+ #[inline(always)]+ fn uuder(&self, u: f64, v: f64) -> Vector3 { -self.radius * self.normal(u, v) }+ #[inline(always)]+ fn uvder(&self, u: f64, v: f64) -> Vector3 {+ self.radius * f64::cos(u) * Vector3::new(-f64::sin(v), f64::cos(v), 0.0)+ }+ #[inline(always)]+ fn vvder(&self, u: f64, v: f64) -> Vector3 {+ -self.radius * f64::sin(u) * Vector3::new(f64::cos(v), f64::sin(v), 0.0)+ }+ #[inline(always)]+ fn parameter_range(&self) -> (ParameterRange, ParameterRange) {+ (+ (Bound::Included(0.0), Bound::Included(PI)),+ (Bound::Included(0.0), Bound::Excluded(2.0 * PI)),+ )+ }+ #[inline(always)]+ fn v_period(&self) -> Option<f64> { Some(2.0 * PI) }+}++impl ParametricSurface3D for Sphere {+ #[inline(always)]+ fn normal(&self, u: f64, v: f64) -> Vector3 {+ Vector3::new(+ f64::sin(u) * f64::cos(v),+ f64::sin(u) * f64::sin(v),+ f64::cos(u),+ )+ }+}++#[test]+fn sphere_derivation_test() {+ let center = Point3::new(1.0, 2.0, 3.0);+ let radius = 4.56;+ let sphere = Sphere::new(center, radius);+ const N: usize = 100;+ for i in 0..N {+ for j in 0..N {+ let u = PI * i as f64 / N as f64;+ let v = 2.0 * PI * j as f64 / N as f64;+ let normal = sphere.normal(u, v);+ assert!(normal.dot(sphere.uder(u, v)).so_small());+ assert!(normal.dot(sphere.vder(u, v)).so_small());+ }+ }+}++impl BoundedSurface for Sphere {}++impl IncludeCurve<BSplineCurve<Point3>> for Sphere {+ #[inline(always)]+ fn include(&self, curve: &BSplineCurve<Point3>) -> bool {+ curve.is_const() && self.include(curve.front())+ }+}++impl IncludeCurve<NurbsCurve<Vector4>> for Sphere {+ fn include(&self, curve: &NurbsCurve<Vector4>) -> bool {+ let (knots, _) = curve.knot_vec().to_single_multi();+ let degree = curve.degree() * 2;+ knots+ .windows(2)+ .flat_map(move |window| (1..degree).map(move |i| (window, i)))+ .all(move |(window, i)| {+ let t = i as f64 / degree as f64;+ let t = window[0] * (1.0 - t) + window[1] * t;+ self.include(curve.subs(t))+ })+ }+}++impl ParameterDivision2D for Sphere {+ #[inline(always)]+ fn parameter_division(+ &self,+ (urange, vrange): ((f64, f64), (f64, f64)),+ tol: f64,+ ) -> (Vec<f64>, Vec<f64>) {+ nonpositive_tolerance!(tol);+ assert!(+ tol < self.radius,+ "Tolerance is larger than the radius of sphere."+ );+ let delta = 2.0 * f64::acos(1.0 - tol / self.radius);+ let u_div = 1 + ((urange.1 - urange.0) / delta).floor() as usize;+ let v_div = 1 + ((vrange.1 - vrange.0) / delta).floor() as usize;+ (+ (0..=u_div)+ .map(|i| urange.0 + (urange.1 - urange.0) * i as f64 / u_div as f64)+ .collect(),+ (0..=v_div)+ .map(|j| vrange.0 + (vrange.1 - vrange.0) * j as f64 / v_div as f64)+ .collect(),+ )+ }+}++impl SearchParameter<D2> for Sphere {+ type Point = Point3;+ #[inline(always)]+ fn search_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point3,+ hint: H,+ _: usize,+ ) -> Option<(f64, f64)> {+ let radius = point - self.center;+ if (self.radius * self.radius).near(&radius.magnitude2()) {+ let radius = radius.normalize();+ let u = f64::acos(radius[2]);+ let sinu = f64::sqrt(1.0 - radius[2] * radius[2]);+ let cosv = f64::clamp(radius[0] / sinu, -1.0, 1.0);+ let v = if sinu.so_small() {+ match hint.into() {+ SPHint2D::Parameter(_, hint) => hint,+ _ => 0.0,+ }+ } else if radius[1] > 0.0 {+ f64::acos(cosv)+ } else {+ 2.0 * PI - f64::acos(cosv)+ };+ Some((u, v))+ } else {+ None+ }+ }+}++impl SearchNearestParameter<D2> for Sphere {+ type Point = Point3;+ #[inline(always)]+ fn search_nearest_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point3,+ _: H,+ _: usize,+ ) -> Option<(f64, f64)> {+ let radius = (point - self.center).normalize();+ let u = f64::acos(radius[2]);+ let sinu = f64::sqrt(1.0 - radius[2] * radius[2]);+ let cosv = radius[0] / sinu;+ let v = if radius[1] > 0.0 {+ f64::acos(cosv)+ } else {+ 2.0 * PI - f64::acos(cosv)+ };+ Some((u, v))+ }+}++#[cfg(test)]+fn exec_search_parameter_test() {+ let center = Point3::new(+ 100.0 * rand::random::<f64>() - 50.0,+ 100.0 * rand::random::<f64>() - 50.0,+ 100.0 * rand::random::<f64>() - 50.0,+ );+ let radius = 100.0 * rand::random::<f64>();+ let sphere = Sphere::new(center, radius);+ let u = PI * rand::random::<f64>();+ let v = 2.0 * PI * rand::random::<f64>();+ let pt = sphere.subs(u, v);+ let (u0, v0) = sphere.search_parameter(pt, None, 100).unwrap();+ assert_near!(Vector2::new(u, v), Vector2::new(u0, v0));+ let pt = pt+ + Vector3::new(+ (0.1 * rand::random::<f64>() + 0.01) * f64::signum(rand::random::<f64>() - 0.5),+ (0.1 * rand::random::<f64>() + 0.01) * f64::signum(rand::random::<f64>() - 0.5),+ (0.1 * rand::random::<f64>() + 0.01) * f64::signum(rand::random::<f64>() - 0.5),+ );+ assert!(sphere.search_parameter(pt, None, 100).is_none());+ let (u, v) = sphere.search_nearest_parameter(pt, None, 100).unwrap();+ assert_near!(+ sphere.subs(u, v),+ center + (pt - center).normalize() * radius+ );+}++#[test]+fn search_parameter_test() { (0..10).for_each(|_| exec_search_parameter_test()) }diff --git a/vendor/truck-geometry/src/specifieds/torus.rs b/vendor/truck-geometry/src/specifieds/torus.rsnew file mode 100644index 0000000000..d53a8bfd41--- /dev/null+++ b/vendor/truck-geometry/src/specifieds/torus.rs@@ -0,0 +1,238 @@+use super::*;+use std::f64::consts::PI;++impl Torus {+ /// constructor+ #[inline(always)]+ pub fn new(center: Point3, large_radius: f64, small_radius: f64) -> Self {+ if large_radius <= 0.0 || small_radius <= 0.0 {+ panic!("radius must be larger than 0");+ }+ Self {+ center,+ large_radius,+ small_radius,+ }+ }++ /// get center+ #[inline(always)]+ pub const fn center(&self) -> Point3 { self.center }++ /// get large radius+ #[inline(always)]+ pub const fn large_radius(&self) -> f64 { self.large_radius }++ /// get small radius+ #[inline(always)]+ pub const fn small_radius(&self) -> f64 { self.small_radius }+}++impl ParametricSurface for Torus {+ type Point = Point3;+ type Vector = Vector3;+ #[inline(always)]+ fn subs(&self, u: f64, v: f64) -> Point3 {+ let sr = self.small_radius() * Vector2::new(f64::cos(v), f64::sin(v));+ let lr = (self.large_radius() + sr.x) * Vector2::new(f64::cos(u), f64::sin(u));+ self.center() + Vector3::new(lr.x, lr.y, sr.y)+ }+ #[inline(always)]+ fn uder(&self, u: f64, v: f64) -> Vector3 {+ let sr = self.small_radius() * f64::cos(v);+ let lr = (self.large_radius() + sr) * Vector2::new(f64::cos(u), f64::sin(u));+ Vector3::new(-lr.y, lr.x, 0.0)+ }+ #[inline(always)]+ fn vder(&self, u: f64, v: f64) -> Vector3 {+ let sv = self.small_radius() * Vector2::new(-f64::sin(v), f64::cos(v));+ Vector3::new(sv.x * f64::cos(u), sv.x * f64::sin(u), sv.y)+ }+ #[inline(always)]+ fn uuder(&self, u: f64, v: f64) -> Vector3 {+ let sr = self.small_radius() * f64::cos(v);+ let lr = (self.large_radius() + sr) * Vector2::new(f64::cos(u), f64::sin(u));+ Vector3::new(-lr.x, -lr.y, 0.0)+ }+ #[inline(always)]+ fn uvder(&self, u: f64, v: f64) -> Vector3 {+ let sr = -self.small_radius() * f64::sin(v);+ let lr = sr * Vector2::new(f64::cos(u), f64::sin(u));+ Vector3::new(-lr.y, lr.x, 0.0)+ }+ #[inline(always)]+ fn vvder(&self, u: f64, v: f64) -> Vector3 {+ let sv = -self.small_radius() * Vector2::new(f64::cos(v), f64::sin(v));+ Vector3::new(sv.x * f64::cos(u), sv.x * f64::sin(u), sv.y)+ }+ #[inline(always)]+ fn parameter_range(&self) -> (ParameterRange, ParameterRange) {+ const RANGE: (Bound<f64>, Bound<f64>) = (Bound::Included(0.0), Bound::Excluded(2.0 * PI));+ (RANGE, RANGE)+ }+ #[inline(always)]+ fn u_period(&self) -> Option<f64> { Some(2.0 * PI) }+ #[inline(always)]+ fn v_period(&self) -> Option<f64> { Some(2.0 * PI) }+}++impl ParametricSurface3D for Torus {+ fn normal(&self, u: f64, v: f64) -> Vector3 {+ let sv = Vector2::new(f64::cos(v), f64::sin(v));+ Vector3::new(sv.x * f64::cos(u), sv.x * f64::sin(u), sv.y)+ }+}++impl BoundedSurface for Torus {}++impl SearchParameter<D2> for Torus {+ type Point = Point3;+ fn search_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point3,+ _: H,+ _: usize,+ ) -> Option<(f64, f64)> {+ let r = point - self.center();+ let rxy = Vector2::new(r.x, r.y);+ let v = f64::asin(f64::clamp(r.z / self.small_radius(), -1.0, 1.0));+ let minus = rxy.magnitude2() < self.large_radius() * self.large_radius();+ let v = match (minus, v < 0.0) {+ (true, _) => PI - v,+ (false, false) => v,+ (false, true) => 2.0 * PI + v,+ };+ let rxy_n = rxy.normalize();+ let u = f64::acos(f64::clamp(rxy_n.x, -1.0, 1.0));+ let u = match rxy_n.y < 0.0 {+ true => 2.0 * PI - u,+ false => u,+ };+ match self.subs(u, v).near(&point) {+ true => Some((u, v)),+ false => None,+ }+ }+}++impl SearchNearestParameter<D2> for Torus {+ type Point = Point3;+ fn search_nearest_parameter<H: Into<SPHint2D>>(+ &self,+ point: Point3,+ _: H,+ _: usize,+ ) -> Option<(f64, f64)> {+ let r = point - self.center();+ let rxy = Vector2::new(r.x, r.y);+ if rxy.so_small() {+ return None;+ }+ let rxy_n = rxy.normalize();+ let large_r = self.large_radius() * rxy_n.extend(0.0);+ let diff = r - large_r;+ if diff.so_small() {+ return None;+ }+ let small_r = diff.normalize();++ let u = f64::acos(f64::clamp(rxy_n.x, -1.0, 1.0));+ let u = match rxy_n.y < 0.0 {+ true => 2.0 * PI - u,+ false => u,+ };+ let v = f64::asin(f64::clamp(small_r.z, -1.0, 1.0));+ let v = match (small_r.dot(large_r) < 0.0, v < 0.0) {+ (true, _) => PI - v,+ (false, false) => v,+ (false, true) => 2.0 * PI + v,+ };+ Some((u, v))+ }+}++impl ParameterDivision2D for Torus {+ fn parameter_division(+ &self,+ (urange, vrange): ((f64, f64), (f64, f64)),+ tol: f64,+ ) -> (Vec<f64>, Vec<f64>) {+ let circle = UnitCircle::<Point2>::new();+ let utol = tol / (self.small_radius() + self.large_radius());+ let (udiv, _) = circle.parameter_division(urange, utol);+ let vtol = tol / self.small_radius();+ let (vdiv, _) = circle.parameter_division(vrange, vtol);+ (udiv, vdiv)+ }+}++#[test]+fn surface() {+ use std::ops::RangeBounds;+ let small_radius = 5.0 * rand::random::<f64>() + 1.0;+ let large_radius = 2.0 * small_radius + 5.0 * rand::random::<f64>();+ let torus = Torus::new(Point3::new(0.0, 0.0, 0.0), large_radius, small_radius);+ const N: usize = 10;+ const EPS: f64 = 1.0e-2;+ for i in 0..N {+ for j in 0..N {+ let u = 2.0 * PI * i as f64 / N as f64;+ let v = 2.0 * PI * j as f64 / N as f64;+ let p = torus.subs(u, v);+ let r = large_radius * Point3::new(f64::cos(u), f64::sin(u), 0.0);+ assert_near!(p.distance(r), small_radius);+ assert_near!(p.z, small_radius * f64::sin(v));++ let uder0 = torus.uder(u, v);+ let uder1 = (torus.subs(u + EPS, v) - torus.subs(u - EPS, v)) / (2.0 * EPS);+ assert!((uder0 - uder1).magnitude() < EPS, "{:?} {:?}", uder0, uder1);++ let vder0 = torus.vder(u, v);+ let vder1 = (torus.subs(u, v + EPS) - torus.subs(u, v - EPS)) / (2.0 * EPS);+ assert!((vder0 - vder1).magnitude() < EPS, "{:?} {:?}", vder0, vder1);++ let uuder0 = torus.uuder(u, v);+ let uuder1 = (torus.uder(u + EPS, v) - torus.uder(u - EPS, v)) / (2.0 * EPS);+ assert!(+ (uuder0 - uuder1).magnitude() < EPS,+ "{:?} {:?}",+ uuder0,+ uuder1+ );++ let uvder0 = torus.uvder(u, v);+ let uvder1 = (torus.vder(u + EPS, v) - torus.vder(u - EPS, v)) / (2.0 * EPS);+ assert!(+ (uvder0 - uvder1).magnitude() < EPS,+ "{:?} {:?}",+ uvder0,+ uvder1+ );++ let vvder0 = torus.vvder(u, v);+ let vvder1 = (torus.vder(u, v + EPS) - torus.vder(u, v - EPS)) / (2.0 * EPS);+ assert!(+ (vvder0 - vvder1).magnitude() < EPS,+ "{:?} {:?}",+ vvder0,+ vvder1+ );++ let n0 = torus.normal(u, v);+ let n1 = torus.uder(u, v).cross(torus.vder(u, v)).normalize();+ assert_near!(n0, n1);++ let (u0, v0) = torus.search_parameter(p, None, 1).unwrap();+ let (urange, vrange) = torus.parameter_range();+ assert!(urange.contains(&u0) && vrange.contains(&v0), "{u0}, {v0}");+ assert_near!(torus.subs(u0, v0), p);++ let deform = (0.8 * rand::random::<f64>() - 0.4) * small_radius;+ let q = p + deform * n0;+ let (u0, v0) = torus.search_nearest_parameter(q, None, 1).unwrap();+ let (urange, vrange) = torus.parameter_range();+ assert!(urange.contains(&u0) && vrange.contains(&v0), "{u0}, {v0}");+ assert_near!(torus.subs(u0, v0), p);+ }+ }+}