promote Vertex and eliminate redundant types

Author: timschmidt

src/bmesh/triangulated.rs

@@ -1,12 +1,13 @@
 use crate::bmesh::BMesh;
 use crate::float_types::Real;
 use nalgebra::{Point3, Vector3};
-use crate::triangulated::{TriVertex, Triangulated3D};
+use crate::triangulated::Triangulated3D;
+use crate::vertex::Vertex;
 
 impl<S: Clone + Send + Sync + std::fmt::Debug> Triangulated3D for BMesh<S> {
     fn visit_triangles<F>(&self, mut f: F)
     where
-        F: FnMut([TriVertex; 3]),
+        F: FnMut([Vertex; 3]),
     {
         let Some(m) = &self.manifold else { return; };
 
@@ -33,9 +34,9 @@ impl<S: Clone + Send + Sync + std::fmt::Debug> Triangulated3D for BMesh<S> {
             };
 
             f([
-                TriVertex { position: p[0], normal: n },
-                TriVertex { position: p[1], normal: n },
-                TriVertex { position: p[2], normal: n },
+                Vertex { position: p[0], normal: n },
+                Vertex { position: p[1], normal: n },
+                Vertex { position: p[2], normal: n },
             ]);
         }
     }

src/io/amf.rs

@@ -61,7 +61,7 @@ impl<S: Clone + Debug + Send + Sync> Mesh<S> {
                 let mut triangle_indices = Vec::new();
 
                 for vertex in triangle {
-                    let vertex_idx = add_unique_vertex_amf(&mut vertices, vertex.pos);
+                    let vertex_idx = add_unique_vertex_amf(&mut vertices, vertex.position);
                     triangle_indices.push(vertex_idx);
                 }
 
@@ -197,7 +197,7 @@ impl<S: Clone + Debug + Send + Sync> Mesh<S> {
                 let mut triangle_indices = Vec::new();
 
                 for vertex in triangle {
-                    let vertex_idx = add_unique_vertex_amf(&mut vertices, vertex.pos);
+                    let vertex_idx = add_unique_vertex_amf(&mut vertices, vertex.position);
                     triangle_indices.push(vertex_idx);
                 }
 

src/io/dxf.rs

@@ -1,7 +1,7 @@
 use crate::float_types::Real;
 use crate::mesh::Mesh;
 use crate::mesh::polygon::Polygon;
-use crate::mesh::vertex::Vertex;
+use crate::vertex::Vertex;
 use crate::sketch::Sketch;
 use geo::{Polygon as GeoPolygon, line_string};
 use nalgebra::{Point3, Vector3};
@@ -151,24 +151,24 @@ impl<S: Clone + Debug + Send + Sync> Mesh<S> {
                 let face = dxf::entities::Face3D::new(
                     // 3DFACE expects four vertices, but for triangles, the fourth is the same as the third
                     dxf::Point::new(
-                        tri[0].pos.x as f64,
-                        tri[0].pos.y as f64,
-                        tri[0].pos.z as f64,
+                        tri[0].position.x as f64,
+                        tri[0].position.y as f64,
+                        tri[0].position.z as f64,
                     ),
                     dxf::Point::new(
-                        tri[1].pos.x as f64,
-                        tri[1].pos.y as f64,
-                        tri[1].pos.z as f64,
+                        tri[1].position.x as f64,
+                        tri[1].position.y as f64,
+                        tri[1].position.z as f64,
                     ),
                     dxf::Point::new(
-                        tri[2].pos.x as f64,
-                        tri[2].pos.y as f64,
-                        tri[2].pos.z as f64,
+                        tri[2].position.x as f64,
+                        tri[2].position.y as f64,
+                        tri[2].position.z as f64,
                     ),
                     dxf::Point::new(
-                        tri[2].pos.x as f64,
-                        tri[2].pos.y as f64,
-                        tri[2].pos.z as f64,
+                        tri[2].position.x as f64,
+                        tri[2].position.y as f64,
+                        tri[2].position.z as f64,
                     ), // Duplicate for triangular face
                 );
 

src/io/gltf.rs

@@ -5,22 +5,17 @@
 
 use crate::float_types::{tolerance, Real};
 use crate::triangulated::Triangulated3D;
+use crate::vertex::Vertex;
 use nalgebra::{Point3, Vector3};
 use std::fmt::Debug;
 use std::io::Write;
 use base64::engine::general_purpose::STANDARD as BASE64_ENGINE;
 use base64::Engine;
 
-#[derive(Clone)]
-struct GltfVertex {
-    position: Point3<Real>,
-    normal: Vector3<Real>,
-}
-
 /// Add a vertex to the list, reusing an existing one if position and normal
 /// are within `tolerance()`.
 fn add_unique_vertex_gltf(
-    vertices: &mut Vec<GltfVertex>,
+    vertices: &mut Vec<Vertex>,
     position: Point3<Real>,
     normal: Vector3<Real>,
 ) -> u32 {
@@ -31,14 +26,14 @@ fn add_unique_vertex_gltf(
             return i as u32;
         }
     }
-    vertices.push(GltfVertex { position, normal });
+    vertices.push(Vertex { position, normal });
     (vertices.len() - 1) as u32
 }
 
 fn build_gltf_buffers<T: Triangulated3D>(
     shape: &T,
-) -> (Vec<GltfVertex>, Vec<u32>) {
-    let mut vertices = Vec::<GltfVertex>::new();
+) -> (Vec<Vertex>, Vec<u32>) {
+    let mut vertices = Vec::<Vertex>::new();
     let mut indices  = Vec::<u32>::new();
 
     shape.visit_triangles(|tri| {
@@ -60,7 +55,7 @@ fn build_gltf_buffers<T: Triangulated3D>(
 ///
 /// All binary data is stored in a single buffer as a base64-embedded data URI.
 fn gltf_from_vertices(
-    vertices: &[GltfVertex],
+    vertices: &[Vertex],
     indices: &[u32],
     object_name: &str,
 ) -> String {

src/io/obj.rs

@@ -5,7 +5,7 @@
 use crate::float_types::{Real, tolerance};
 use crate::mesh::Mesh;
 use crate::mesh::polygon::Polygon;
-use crate::mesh::vertex::Vertex;
+use crate::vertex::Vertex;
 use crate::sketch::Sketch;
 use geo::CoordsIter;
 use nalgebra::{Point3, Vector3};
@@ -55,7 +55,7 @@ impl<S: Clone + Debug + Send + Sync> Mesh<S> {
                 let normal_idx = add_unique_normal(&mut normals, normal);
 
                 for vertex in triangle {
-                    let vertex_idx = add_unique_vertex(&mut vertices, vertex.pos);
+                    let vertex_idx = add_unique_vertex(&mut vertices, vertex.position);
                     face_indices.push((vertex_idx, normal_idx));
                 }
 

src/io/ply.rs

@@ -4,19 +4,13 @@
 //! a popular format for 3D scanning, research, and mesh processing applications.
 use crate::float_types::{Real, tolerance};
 use crate::mesh::Mesh;
+use crate::vertex::Vertex;
 use crate::sketch::Sketch;
 use geo::CoordsIter;
 use nalgebra::{Point3, Vector3};
 use std::fmt::Debug;
 use std::io::Write;
 
-// Helper struct for PLY vertex with normal
-#[derive(Clone)]
-struct PlyVertex {
-    position: Point3<Real>,
-    normal: Vector3<Real>,
-}
-
 impl<S: Clone + Debug + Send + Sync> Mesh<S> {
     /// Export this Mesh to PLY format as a string
     ///
@@ -50,7 +44,7 @@ impl<S: Clone + Debug + Send + Sync> Mesh<S> {
 
                 for vertex in triangle {
                     let vertex_idx =
-                        add_unique_vertex_ply(&mut vertices, vertex.pos, vertex.normal);
+                        add_unique_vertex_ply(&mut vertices, vertex.position, vertex.normal);
                     face_indices.push(vertex_idx);
                 }
 
@@ -221,7 +215,7 @@ impl<S: Clone + Debug + Send + Sync> Sketch<S> {
     fn add_2d_polygon_to_ply(
         &self,
         poly2d: &geo::Polygon<Real>,
-        vertices: &mut Vec<PlyVertex>,
+        vertices: &mut Vec<Vertex>,
         faces: &mut Vec<Vec<usize>>,
     ) {
         // Get the exterior ring
@@ -261,7 +255,7 @@ impl<S: Clone + Debug + Send + Sync> Sketch<S> {
 
 // Helper function to add unique vertex with normal for PLY
 fn add_unique_vertex_ply(
-    vertices: &mut Vec<PlyVertex>,
+    vertices: &mut Vec<Vertex>,
     position: Point3<Real>,
     normal: Vector3<Real>,
 ) -> usize {
@@ -275,6 +269,6 @@ fn add_unique_vertex_ply(
     }
 
     // Add new vertex
-    vertices.push(PlyVertex { position, normal });
+    vertices.push(Vertex { position, normal });
     vertices.len() - 1
 }

src/io/svg.rs

@@ -46,7 +46,7 @@ impl<F: CoordNum> PathBuilder<F> {
     }
 
     /// Get the current position to be used for relative moves.
-    fn get_pos(&self) -> Coord<F> {
+    fn get_position(&self) -> Coord<F> {
         self.inner
             .0
             .last()
@@ -69,7 +69,7 @@ impl<F: CoordNum> PathBuilder<F> {
             .unwrap_or(false);
 
         if start_new_path {
-            self.inner.0.push(LineString::new(vec![self.get_pos()]));
+            self.inner.0.push(LineString::new(vec![self.get_position()]));
         }
 
         self.inner.0.last_mut().ok_or_else(|| {
@@ -87,8 +87,8 @@ impl<F: CoordNum> PathBuilder<F> {
     /// Start a new path at `delta` relative to the last point.
     /// If and only if this is the first command, the point is treated as absolute coordinates.
     pub fn move_by(&mut self, delta: Coord<F>) {
-        let pos = self.get_pos();
-        self.inner.0.push(LineString::new(vec![pos + delta]));
+        let position = self.get_position();
+        self.inner.0.push(LineString::new(vec![position + delta]));
     }
 
     /// Extend the current path to the `point`.
@@ -102,16 +102,16 @@ impl<F: CoordNum> PathBuilder<F> {
     /// Extend the current path by `delta` relative to the current point.
     /// Can not be the first command.
     pub fn line_by(&mut self, delta: Coord<F>) -> Result<(), IoError> {
-        let pos = self.get_pos();
+        let position = self.get_position();
         let line = self.get_path_mut_or_fail()?;
-        line.0.push(pos + delta);
+        line.0.push(position + delta);
         Ok(())
     }
 
     /// Extend the current path with a horizontal move to `x`.
     /// Can not be the first command.
     pub fn hline_to(&mut self, x: F) -> Result<(), IoError> {
-        let Coord { y, .. } = self.get_pos();
+        let Coord { y, .. } = self.get_position();
         let line = self.get_path_mut_or_fail()?;
         line.0.push(Coord { x, y });
         Ok(())
@@ -120,7 +120,7 @@ impl<F: CoordNum> PathBuilder<F> {
     /// Extend the current path with a horizontal move by `dx` relative to the current point.
     /// Can not be the first command.
     pub fn hline_by(&mut self, dx: F) -> Result<(), IoError> {
-        let Coord { x, y } = self.get_pos();
+        let Coord { x, y } = self.get_position();
         let line = self.get_path_mut_or_fail()?;
         line.0.push(Coord { x: x + dx, y });
         Ok(())
@@ -129,7 +129,7 @@ impl<F: CoordNum> PathBuilder<F> {
     /// Extend the current path with a vertical move to `y`.
     /// Can not be the first command.
     pub fn vline_to(&mut self, y: F) -> Result<(), IoError> {
-        let Coord { x, .. } = self.get_pos();
+        let Coord { x, .. } = self.get_position();
         let line = self.get_path_mut_or_fail()?;
         line.0.push(Coord { x, y });
         Ok(())
@@ -138,7 +138,7 @@ impl<F: CoordNum> PathBuilder<F> {
     /// Extend the current path with a vertical move by `dy` relative to the current point.
     /// Can not be the first command.
     pub fn vline_by(&mut self, dy: F) -> Result<(), IoError> {
-        let Coord { x, y } = self.get_pos();
+        let Coord { x, y } = self.get_position();
         let line = self.get_path_mut_or_fail()?;
         line.0.push(Coord { x, y: y + dy });
         Ok(())

src/lib.rs

@@ -31,6 +31,7 @@
 pub mod errors;
 pub mod float_types;
 pub mod io;
+pub mod vertex;
 pub mod mesh;
 pub mod nurbs;
 pub mod sketch;

src/mesh/bsp.rs

@@ -4,7 +4,7 @@
 use crate::float_types::tolerance;
 
 #[cfg(not(feature = "parallel"))]
-use crate::mesh::vertex::Vertex;
+use crate::vertex::Vertex;
 
 use crate::float_types::Real;
 use crate::mesh::plane::{BACK, COPLANAR, FRONT, Plane, SPANNING};
@@ -254,7 +254,7 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
             let types: Vec<_> = poly
                 .vertices
                 .iter()
-                .map(|vertex| slicing_plane.orient_point(&vertex.pos))
+                .map(|vertex| slicing_plane.orient_point(&vertex.position))
                 .collect();
 
             let polygon_type = types.iter().fold(0, |acc, &vertex_type| acc | vertex_type);
@@ -282,10 +282,10 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
                             let vj = &poly.vertices[j];
 
                             if (ti | tj) == SPANNING {
-                                let denom = slicing_plane.normal().dot(&(vj.pos - vi.pos));
+                                let denom = slicing_plane.normal().dot(&(vj.position - vi.position));
                                 if denom.abs() > tolerance() {
                                     let intersection = (slicing_plane.offset()
-                                        - slicing_plane.normal().dot(&vi.pos.coords))
+                                        - slicing_plane.normal().dot(&vi.position.coords))
                                         / denom;
                                     Some(vi.interpolate(vj, intersection))
                                 } else {

src/mesh/bsp_parallel.rs

@@ -184,7 +184,7 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
                 let mut types = Vec::with_capacity(vcount);
 
                 for vertex in &poly.vertices {
-                    let vertex_type = slicing_plane.orient_point(&vertex.pos);
+                    let vertex_type = slicing_plane.orient_point(&vertex.position);
                     polygon_type |= vertex_type;
                     types.push(vertex_type);
                 }
@@ -211,10 +211,10 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
                             if (ti | tj) == SPANNING {
                                 // The param intersection at which plane intersects the edge [vi -> vj].
                                 // Avoid dividing by zero:
-                                let denom = slicing_plane.normal().dot(&(vj.pos - vi.pos));
+                                let denom = slicing_plane.normal().dot(&(vj.position - vi.position));
                                 if denom.abs() > tolerance() {
                                     let intersection = (slicing_plane.offset()
-                                        - slicing_plane.normal().dot(&vi.pos.coords))
+                                        - slicing_plane.normal().dot(&vi.position.coords))
                                         / denom;
                                     // Interpolate:
                                     let intersect_vert = vi.interpolate(vj, intersection);