use crate::Result;
use crate::common::points::dist;
use crate::geom3::curve3::CurveStation3;
use crate::geom3::{Aabb3, Curve3, Iso3, Point3};
use crate::io::{read_tc_curves3_file, write_tc_curves3_file};
use parry3d_f64::bounding_volume::BoundingVolume;
use std::path::Path;
#[derive(Clone)]
pub struct CurveGroup3 {
curves: Vec<Curve3>,
}
impl CurveGroup3 {
pub fn new(curves: Vec<Curve3>) -> Result<Self> {
if curves.is_empty() {
return Err("a curve group must have at least one member curve".into());
}
Ok(Self { curves })
}
pub fn curves(&self) -> &[Curve3] {
&self.curves
}
pub fn into_curves(self) -> Vec<Curve3> {
self.curves
}
pub fn len(&self) -> usize {
self.curves.len()
}
pub fn is_empty(&self) -> bool {
self.curves.is_empty()
}
pub fn load_tccurve3(path: &Path) -> Result<Self> {
Self::new(read_tc_curves3_file(path)?)
}
pub fn save_tccurve3(&self, path: &Path, tol: f64) -> Result<()> {
write_tc_curves3_file(path, &self.curves, tol)
}
pub fn aabb(&self) -> Aabb3 {
let mut aabb = self.curves[0].aabb();
for c in self.curves.iter().skip(1) {
aabb.merge(&c.aabb());
}
aabb
}
pub fn length(&self) -> f64 {
self.curves.iter().map(|c| c.length()).sum()
}
pub fn at_closest_to_point(&self, test_point: &Point3) -> (usize, CurveStation3<'_>) {
self.curves
.iter()
.enumerate()
.map(|(i, c)| {
let station = c.at_closest_to_point(test_point);
let d = dist(test_point, &station.point());
(i, d, station)
})
.min_by(|a, b| a.1.total_cmp(&b.1))
.map(|(i, _, station)| (i, station))
.expect("a curve group is never empty")
}
pub fn new_transformed_by(&self, iso: &Iso3) -> Self {
Self {
curves: self
.curves
.iter()
.map(|c| c.new_transformed_by(iso))
.collect(),
}
}
}
impl From<Curve3> for CurveGroup3 {
fn from(curve: Curve3) -> Self {
Self {
curves: vec![curve],
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::geom3::{PlanarMap, Plane3, Vector3};
use approx::assert_relative_eq;
fn square_at(x0: f64, y0: f64, z0: f64) -> Curve3 {
let points = [
Point3::new(x0, y0, z0),
Point3::new(x0 + 1.0, y0, z0),
Point3::new(x0 + 1.0, y0 + 1.0, z0),
Point3::new(x0, y0 + 1.0, z0),
Point3::new(x0, y0, z0),
];
Curve3::from_points(&points, 1e-8).unwrap()
}
fn segment() -> Curve3 {
Curve3::from_points(
&[Point3::new(0.0, 5.0, 0.0), Point3::new(1.0, 5.0, 0.0)],
1e-8,
)
.unwrap()
}
fn temp_path(tag: &str) -> std::path::PathBuf {
std::env::temp_dir().join(format!("engeom_curve_group3_{tag}.tccurve3"))
}
#[test]
fn a_group_round_trips_through_a_tccurve3_file() -> Result<()> {
let group = CurveGroup3::new(vec![
square_at(0.0, 0.0, 0.0),
segment(),
square_at(10.0, 0.0, 3.0),
])?;
let path = temp_path("round_trip");
let tol = 1e-6;
group.save_tccurve3(&path, tol)?;
let back = CurveGroup3::load_tccurve3(&path)?;
assert_eq!(back.len(), group.len());
for (i, (a, b)) in group.curves().iter().zip(back.curves().iter()).enumerate() {
assert_eq!(a.count(), b.count(), "member {i} vertex count");
assert_relative_eq!(a.tol(), b.tol(), epsilon = 1e-15);
for (p, q) in a.vertices().iter().zip(b.vertices().iter()) {
assert_relative_eq!(p, q, epsilon = tol);
}
}
let _ = std::fs::remove_file(&path);
Ok(())
}
#[test]
fn a_restored_loop_still_projects_to_a_closed_curve() -> Result<()> {
let group = CurveGroup3::from(square_at(0.0, 0.0, 0.0));
let path = temp_path("loop");
group.save_tccurve3(&path, 1e-9)?;
let back = CurveGroup3::load_tccurve3(&path)?;
let flat = PlanarMap::from_plane(&Plane3::xy()).curve_group_to_2d(&back)?;
assert!(flat.curves()[0].is_closed());
let _ = std::fs::remove_file(&path);
Ok(())
}
#[test]
fn a_single_curve_file_loads_as_a_group_of_one() -> Result<()> {
let path = temp_path("single");
square_at(0.0, 0.0, 0.0).save_tccurve3(&path, 1e-6)?;
assert_eq!(CurveGroup3::load_tccurve3(&path)?.len(), 1);
let _ = std::fs::remove_file(&path);
Ok(())
}
#[test]
fn a_group_file_is_refused_by_the_single_curve_reader() -> Result<()> {
let group = CurveGroup3::new(vec![square_at(0.0, 0.0, 0.0), segment()])?;
let path = temp_path("refuse_single");
group.save_tccurve3(&path, 1e-6)?;
assert!(Curve3::load_tccurve3(&path).is_err());
let _ = std::fs::remove_file(&path);
Ok(())
}
#[test]
fn an_empty_group_is_rejected() {
assert!(CurveGroup3::new(Vec::new()).is_err());
}
#[test]
fn a_single_curve_becomes_a_group_of_one() {
let group = CurveGroup3::from(square_at(0.0, 0.0, 0.0));
assert_eq!(group.len(), 1);
assert!(!group.is_empty());
}
#[test]
fn the_aabb_spans_every_member() {
let group =
CurveGroup3::new(vec![square_at(0.0, 0.0, 0.0), square_at(10.0, 0.0, 3.0)]).unwrap();
let aabb = group.aabb();
assert_relative_eq!(aabb.mins.x, 0.0, epsilon = 1e-12);
assert_relative_eq!(aabb.mins.y, 0.0, epsilon = 1e-12);
assert_relative_eq!(aabb.mins.z, 0.0, epsilon = 1e-12);
assert_relative_eq!(aabb.maxs.x, 11.0, epsilon = 1e-12);
assert_relative_eq!(aabb.maxs.y, 1.0, epsilon = 1e-12);
assert_relative_eq!(aabb.maxs.z, 3.0, epsilon = 1e-12);
}
#[test]
fn the_length_is_the_sum_of_the_members() {
let group = CurveGroup3::new(vec![square_at(0.0, 0.0, 0.0), segment()]).unwrap();
assert_relative_eq!(group.length(), 5.0, epsilon = 1e-12);
}
#[test]
fn the_closest_point_reports_its_owning_member() {
let group =
CurveGroup3::new(vec![square_at(0.0, 0.0, 0.0), square_at(10.0, 0.0, 0.0)]).unwrap();
let (m, station) = group.at_closest_to_point(&Point3::new(-1.0, 0.5, 0.0));
assert_eq!(m, 0);
assert_relative_eq!(station.point(), Point3::new(0.0, 0.5, 0.0), epsilon = 1e-12);
let (m, station) = group.at_closest_to_point(&Point3::new(12.0, 0.5, 0.0));
assert_eq!(m, 1);
assert_relative_eq!(
station.point(),
Point3::new(11.0, 0.5, 0.0),
epsilon = 1e-12
);
let (m, _) = group.at_closest_to_point(&Point3::new(4.0, 0.5, 0.0));
assert_eq!(m, 0);
}
#[test]
fn a_transformed_group_moves_every_member_together() {
let group = CurveGroup3::new(vec![square_at(0.0, 0.0, 0.0), segment()]).unwrap();
let iso = Iso3::new(
Vector3::new(100.0, -50.0, 7.0),
Vector3::z() * std::f64::consts::FRAC_PI_2,
);
let moved = group.new_transformed_by(&iso);
assert_eq!(moved.len(), 2);
assert_relative_eq!(moved.length(), group.length(), epsilon = 1e-10);
for (a, b) in group.curves().iter().zip(moved.curves().iter()) {
for (p, q) in a.vertices().iter().zip(b.vertices().iter()) {
assert_relative_eq!(iso * p, *q, epsilon = 1e-12);
}
}
}
#[test]
fn a_group_keeps_its_members_in_order() {
let group = CurveGroup3::new(vec![
square_at(0.0, 0.0, 0.0),
segment(),
square_at(10.0, 0.0, 0.0),
])
.unwrap();
let lengths: Vec<f64> = group.curves().iter().map(|c| c.length()).collect();
assert_relative_eq!(lengths[0], 4.0, epsilon = 1e-12);
assert_relative_eq!(lengths[1], 1.0, epsilon = 1e-12);
assert_relative_eq!(lengths[2], 4.0, epsilon = 1e-12);
let back = group.clone().into_curves();
assert_eq!(back.len(), 3);
assert_relative_eq!(back[1].length(), 1.0, epsilon = 1e-12);
}
}