use crate::Result;
use crate::geom2::Curve2;
use crate::geom3::Curve3;
use std::io::{Read, Write};
use std::path::Path;
use tol_compress::{Polyline2, Polyline3, polyline};
pub const CHORD_TOL: &str = "engeom.chord_tol";
fn chord_tol(metadata: &tol_compress::Metadata, what: &str) -> Result<f64> {
metadata
.get(CHORD_TOL)
.and_then(|v| v.as_f64())
.ok_or_else(|| {
format!("{what} has no `{CHORD_TOL}` metadata; was it written by engeom?").into()
})
}
pub fn write_tc_curve2_to<W: Write>(writer: &mut W, curve: &Curve2, tol: f64) -> Result<()> {
polyline::write_one_to(writer, &curve2_item(curve), tol)?;
Ok(())
}
pub fn read_tc_curve2_from<R: Read>(reader: &mut R) -> Result<Curve2> {
curve2_from(polyline::read_one_from::<R, 2>(reader)?)
}
pub fn write_tc_curve2_file(path: &Path, curve: &Curve2, tol: f64) -> Result<()> {
polyline::write_one_file(path, &curve2_item(curve), tol)?;
Ok(())
}
pub fn read_tc_curve2_file(path: &Path) -> Result<Curve2> {
curve2_from(polyline::read_one_file::<2>(path)?)
}
pub fn write_tc_curve3_to<W: Write>(writer: &mut W, curve: &Curve3, tol: f64) -> Result<()> {
polyline::write_one_to(writer, &curve3_item(curve), tol)?;
Ok(())
}
pub fn read_tc_curve3_from<R: Read>(reader: &mut R) -> Result<Curve3> {
curve3_from(polyline::read_one_from::<R, 3>(reader)?)
}
pub fn write_tc_curve3_file(path: &Path, curve: &Curve3, tol: f64) -> Result<()> {
polyline::write_one_file(path, &curve3_item(curve), tol)?;
Ok(())
}
pub fn read_tc_curve3_file(path: &Path) -> Result<Curve3> {
curve3_from(polyline::read_one_file::<3>(path)?)
}
pub fn write_tc_curves2_to<W: Write>(writer: &mut W, curves: &[Curve2], tol: f64) -> Result<()> {
let items: Vec<Polyline2> = curves.iter().map(curve2_item).collect();
polyline::write_to(writer, &items, tol)?;
Ok(())
}
pub fn read_tc_curves2_from<R: Read>(reader: &mut R) -> Result<Vec<Curve2>> {
polyline::read_from::<R, 2>(reader)?
.into_iter()
.map(curve2_from)
.collect()
}
pub fn write_tc_curves2_file(path: &Path, curves: &[Curve2], tol: f64) -> Result<()> {
let items: Vec<Polyline2> = curves.iter().map(curve2_item).collect();
polyline::write_file(path, &items, tol)?;
Ok(())
}
pub fn read_tc_curves2_file(path: &Path) -> Result<Vec<Curve2>> {
polyline::read_file::<2>(path)?
.into_iter()
.map(curve2_from)
.collect()
}
pub fn write_tc_curves3_to<W: Write>(writer: &mut W, curves: &[Curve3], tol: f64) -> Result<()> {
let items: Vec<Polyline3> = curves.iter().map(curve3_item).collect();
polyline::write_to(writer, &items, tol)?;
Ok(())
}
pub fn read_tc_curves3_from<R: Read>(reader: &mut R) -> Result<Vec<Curve3>> {
polyline::read_from::<R, 3>(reader)?
.into_iter()
.map(curve3_from)
.collect()
}
pub fn write_tc_curves3_file(path: &Path, curves: &[Curve3], tol: f64) -> Result<()> {
let items: Vec<Polyline3> = curves.iter().map(curve3_item).collect();
polyline::write_file(path, &items, tol)?;
Ok(())
}
pub fn read_tc_curves3_file(path: &Path) -> Result<Vec<Curve3>> {
polyline::read_file::<3>(path)?
.into_iter()
.map(curve3_from)
.collect()
}
fn curve2_item(curve: &Curve2) -> Polyline2 {
let points = curve.points().iter().map(|p| [p.x, p.y]).collect();
Polyline2::new(points, curve.is_closed()).with_meta(CHORD_TOL, curve.tol())
}
fn curve2_from(item: Polyline2) -> Result<Curve2> {
let tol = chord_tol(&item.metadata, "tccurve2 file")?;
let points: Vec<_> = item
.points
.iter()
.map(|p| crate::Point2::new(p[0], p[1]))
.collect();
Curve2::from_points(&points, tol, item.closed)
}
fn curve3_item(curve: &Curve3) -> Polyline3 {
let points = curve.vertices().iter().map(|p| [p.x, p.y, p.z]).collect();
Polyline3::new(points, false).with_meta(CHORD_TOL, curve.tol())
}
fn curve3_from(item: Polyline3) -> Result<Curve3> {
if item.closed {
return Err("tccurve3 file is marked closed, which a Curve3 cannot represent".into());
}
let tol = chord_tol(&item.metadata, "tccurve3 file")?;
let points: Vec<_> = item
.points
.iter()
.map(|p| crate::Point3::new(p[0], p[1], p[2]))
.collect();
Curve3::from_points(&points, tol)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::common::random_geometry::RandomGeometry3;
use crate::geom2::Point2;
use crate::geom3::Point3;
use approx::assert_relative_eq;
use std::io::Cursor;
fn make_curve2(rg: &mut RandomGeometry3, n: usize, tol: f64) -> Curve2 {
let points: Vec<Point2> = (0..n)
.map(|_| Point2::new(rg.f64_sym(100.0), rg.f64_sym(100.0)))
.collect();
Curve2::from_points(&points, tol, false).unwrap()
}
fn make_closed_curve2(rg: &mut RandomGeometry3, n: usize, tol: f64) -> Curve2 {
let mut points: Vec<Point2> = (0..n)
.map(|_| Point2::new(rg.f64_sym(100.0), rg.f64_sym(100.0)))
.collect();
points.push(points[0]);
Curve2::from_points(&points, tol, true).unwrap()
}
fn make_curve3(rg: &mut RandomGeometry3, n: usize, tol: f64) -> Curve3 {
let points: Vec<Point3> = (0..n)
.map(|_| Point3::new(rg.f64_sym(100.0), rg.f64_sym(100.0), rg.f64_sym(100.0)))
.collect();
Curve3::from_points(&points, tol).unwrap()
}
fn check_curve2_round_trip(original: &Curve2, recovered: &Curve2, tol: f64) {
assert_eq!(original.points().len(), recovered.points().len());
assert_eq!(original.is_closed(), recovered.is_closed());
assert_eq!(original.tol(), recovered.tol());
for (a, b) in original.points().iter().zip(recovered.points().iter()) {
assert_relative_eq!(a, b, epsilon = tol);
}
}
fn check_curve3_round_trip(original: &Curve3, recovered: &Curve3, tol: f64) {
assert_eq!(original.vertices().len(), recovered.vertices().len());
assert_eq!(original.tol(), recovered.tol());
for (a, b) in original.vertices().iter().zip(recovered.vertices().iter()) {
assert_relative_eq!(a, b, epsilon = tol);
}
}
#[test]
fn round_trip_curve2_bytes() {
let tol = 1e-4;
let mut rg = RandomGeometry3::from_seed(42);
let curve = make_curve2(&mut rg, 1000, 1e-6);
let mut buf = Vec::new();
write_tc_curve2_to(&mut buf, &curve, tol).unwrap();
let mut cursor = Cursor::new(&buf);
let recovered = read_tc_curve2_from(&mut cursor).unwrap();
check_curve2_round_trip(&curve, &recovered, tol);
}
#[test]
fn round_trip_curve2_closed_bytes() {
let tol = 1e-4;
let mut rg = RandomGeometry3::from_seed(7);
let curve = make_closed_curve2(&mut rg, 999, 1e-6);
assert!(curve.is_closed());
let mut buf = Vec::new();
write_tc_curve2_to(&mut buf, &curve, tol).unwrap();
let mut cursor = Cursor::new(&buf);
let recovered = read_tc_curve2_from(&mut cursor).unwrap();
check_curve2_round_trip(&curve, &recovered, tol);
}
#[test]
fn round_trip_curve2_file() {
let tol = 1e-4;
let mut rg = RandomGeometry3::from_seed(13);
let curve = make_curve2(&mut rg, 500, 1e-6);
let path = std::env::temp_dir().join("test_curve2_round_trip.tccurve2");
write_tc_curve2_file(&path, &curve, tol).unwrap();
let recovered = read_tc_curve2_file(&path).unwrap();
check_curve2_round_trip(&curve, &recovered, tol);
}
#[test]
fn round_trip_curve3_bytes() {
let tol = 1e-4;
let mut rg = RandomGeometry3::from_seed(42);
let curve = make_curve3(&mut rg, 1000, 1e-6);
let mut buf = Vec::new();
write_tc_curve3_to(&mut buf, &curve, tol).unwrap();
let mut cursor = Cursor::new(&buf);
let recovered = read_tc_curve3_from(&mut cursor).unwrap();
check_curve3_round_trip(&curve, &recovered, tol);
}
#[test]
fn round_trip_curve3_file() {
let tol = 1e-4;
let mut rg = RandomGeometry3::from_seed(99);
let curve = make_curve3(&mut rg, 500, 1e-6);
let path = std::env::temp_dir().join("test_curve3_round_trip.tccurve3");
write_tc_curve3_file(&path, &curve, tol).unwrap();
let recovered = read_tc_curve3_file(&path).unwrap();
check_curve3_round_trip(&curve, &recovered, tol);
}
#[test]
fn invalid_magic_curve2_rejected() {
let bad = b"NOPE0000\x00\x00";
let mut cursor = Cursor::new(bad);
assert!(read_tc_curve2_from(&mut cursor).is_err());
}
#[test]
fn invalid_magic_curve3_rejected() {
let bad = b"NOPE0000\x00\x00";
let mut cursor = Cursor::new(bad);
assert!(read_tc_curve3_from(&mut cursor).is_err());
}
#[test]
fn missing_chord_tol_is_rejected() {
let item = Polyline2::new(vec![[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]], false);
let mut buf = Vec::new();
polyline::write_one_to(&mut buf, &item, 1e-4).unwrap();
let mut cursor = Cursor::new(&buf);
let err = match read_tc_curve2_from(&mut cursor) {
Err(e) => e.to_string(),
Ok(_) => panic!("a file with no chord tolerance must not read back as a curve"),
};
assert!(err.contains(CHORD_TOL), "unhelpful error: {err}");
}
#[test]
fn wrong_dimension_is_rejected() {
let mut rg = RandomGeometry3::from_seed(5);
let curve = make_curve3(&mut rg, 50, 1e-6);
let mut buf = Vec::new();
write_tc_curve3_to(&mut buf, &curve, 1e-4).unwrap();
let mut cursor = Cursor::new(&buf);
assert!(read_tc_curve2_from(&mut cursor).is_err());
}
#[test]
fn a_collection_of_curve2_round_trips_with_mixed_members() {
let tol = 1e-5;
let mut rg = RandomGeometry3::from_seed(101);
let curves = vec![
make_closed_curve2(&mut rg, 200, 1e-4),
make_curve2(&mut rg, 50, 1e-6),
make_closed_curve2(&mut rg, 75, 1e-3),
];
let mut buf = Vec::new();
write_tc_curves2_to(&mut buf, &curves, tol).unwrap();
let back = read_tc_curves2_from(&mut Cursor::new(&buf)).unwrap();
assert_eq!(back.len(), curves.len());
for (a, b) in curves.iter().zip(back.iter()) {
check_curve2_round_trip(a, b, tol);
}
assert_relative_eq!(back[0].tol(), 1e-4);
assert_relative_eq!(back[1].tol(), 1e-6);
assert_relative_eq!(back[2].tol(), 1e-3);
}
#[test]
fn a_collection_of_curve3_round_trips() {
let tol = 1e-5;
let mut rg = RandomGeometry3::from_seed(202);
let curves = vec![
make_curve3(&mut rg, 300, 1e-6),
make_curve3(&mut rg, 40, 1e-4),
];
let mut buf = Vec::new();
write_tc_curves3_to(&mut buf, &curves, tol).unwrap();
let back = read_tc_curves3_from(&mut Cursor::new(&buf)).unwrap();
assert_eq!(back.len(), curves.len());
for (a, b) in curves.iter().zip(back.iter()) {
check_curve3_round_trip(a, b, tol);
}
}
#[test]
fn a_collection_round_trips_through_a_real_file() {
let tol = 1e-5;
let mut rg = RandomGeometry3::from_seed(303);
let curves = vec![
make_closed_curve2(&mut rg, 120, 1e-4),
make_curve2(&mut rg, 60, 1e-4),
];
let path = std::env::temp_dir().join("engeom_tc_curves2_collection.tccurve2");
write_tc_curves2_file(&path, &curves, tol).unwrap();
let back = read_tc_curves2_file(&path).unwrap();
assert_eq!(back.len(), 2);
for (a, b) in curves.iter().zip(back.iter()) {
check_curve2_round_trip(a, b, tol);
}
let _ = std::fs::remove_file(&path);
}
#[test]
fn the_collection_reader_accepts_a_single_curve_file() {
let mut rg = RandomGeometry3::from_seed(404);
let curve = make_curve2(&mut rg, 30, 1e-6);
let mut buf = Vec::new();
write_tc_curve2_to(&mut buf, &curve, 1e-5).unwrap();
let back = read_tc_curves2_from(&mut Cursor::new(&buf)).unwrap();
assert_eq!(back.len(), 1);
check_curve2_round_trip(&curve, &back[0], 1e-5);
}
#[test]
fn the_single_reader_refuses_a_collection() {
let mut rg = RandomGeometry3::from_seed(505);
let curves = vec![
make_curve2(&mut rg, 20, 1e-6),
make_curve2(&mut rg, 20, 1e-6),
];
let mut buf = Vec::new();
write_tc_curves2_to(&mut buf, &curves, 1e-5).unwrap();
let refused = read_tc_curve2_from(&mut Cursor::new(&buf)).is_err();
assert!(refused, "a two-curve file must not read back as one curve");
}
#[test]
fn an_empty_collection_is_a_valid_file() {
let mut buf = Vec::new();
write_tc_curves2_to(&mut buf, &[], 1e-5).unwrap();
let back = read_tc_curves2_from(&mut Cursor::new(&buf)).unwrap();
assert!(back.is_empty());
}
#[test]
fn airfoil_fixture_reads_back() {
let curve = crate::tests::airfoil_curve();
assert_eq!(curve.points().len(), 544);
assert!(curve.is_closed());
assert_relative_eq!(curve.tol(), 1e-4);
}
}