Remove Vertex

crates/fj-kernel/src/algorithms/intersect/face_point.rs

@@ -1,9 +1,10 @@
 //! Intersection between faces and points in 2D
 
+use fj_interop::ext::ArrayExt;
 use fj_math::Point;
 
 use crate::{
-    objects::{Face, HalfEdge, Vertex},
+    objects::{Face, HalfEdge, SurfaceVertex},
     storage::Handle,
 };
 
@@ -48,13 +49,17 @@ impl Intersect for (&Handle<Face>, &Point<2>) {
                         ));
                     }
                     (Some(RaySegmentIntersection::RayStartsOnOnFirstVertex), _) => {
-                        let vertex = half_edge.vertices()[0].clone();
+                        let [vertex, _] = half_edge.boundary().zip_ext(
+                            half_edge.surface_vertices().map(Clone::clone)
+                        );
                         return Some(
                             FacePointIntersection::PointIsOnVertex(vertex)
                         );
                     }
                     (Some(RaySegmentIntersection::RayStartsOnSecondVertex), _) => {
-                        let vertex = half_edge.vertices()[1].clone();
+                        let [_, vertex] = half_edge.boundary().zip_ext(
+                            half_edge.surface_vertices().map(Clone::clone)
+                        );
                         return Some(
                             FacePointIntersection::PointIsOnVertex(vertex)
                         );
@@ -125,11 +130,12 @@ pub enum FacePointIntersection {
     PointIsOnEdge(Handle<HalfEdge>),
 
     /// The point is coincident with a vertex
-    PointIsOnVertex(Vertex),
+    PointIsOnVertex((Point<1>, Handle<SurfaceVertex>)),
 }
 
 #[cfg(test)]
 mod tests {
+    use fj_interop::ext::ArrayExt;
     use fj_math::Point;
     use pretty_assertions::assert_eq;
 
@@ -342,12 +348,15 @@ mod tests {
         let vertex = face
             .exterior()
             .half_edges()
-            .flat_map(|half_edge| half_edge.vertices())
-            .find(|vertex| {
-                vertex.surface_form().position() == Point::from([1., 0.])
+            .flat_map(|half_edge| {
+                half_edge
+                    .boundary()
+                    .zip_ext(half_edge.surface_vertices().map(Clone::clone))
             })
-            .unwrap()
-            .clone();
+            .find(|(_, surface_vertex)| {
+                surface_vertex.position() == Point::from([1., 0.])
+            })
+            .unwrap();
         assert_eq!(
             intersection,
             Some(FacePointIntersection::PointIsOnVertex(vertex))

crates/fj-kernel/src/algorithms/intersect/ray_face.rs

@@ -5,7 +5,7 @@ use fj_math::{Plane, Point, Scalar};
 use crate::{
     algorithms::intersect::face_point::FacePointIntersection,
     geometry::path::GlobalPath,
-    objects::{Face, HalfEdge, Vertex},
+    objects::{Face, HalfEdge, SurfaceVertex},
     storage::Handle,
 };
 
@@ -136,11 +136,12 @@ pub enum RayFaceIntersection {
     RayHitsEdge(Handle<HalfEdge>),
 
     /// The ray hits a vertex
-    RayHitsVertex(Vertex),
+    RayHitsVertex((Point<1>, Handle<SurfaceVertex>)),
 }
 
 #[cfg(test)]
 mod tests {
+    use fj_interop::ext::ArrayExt;
     use fj_math::Point;
 
     use crate::{
@@ -287,12 +288,15 @@ mod tests {
         let vertex = face
             .exterior()
             .half_edges()
-            .flat_map(|half_edge| half_edge.vertices())
-            .find(|vertex| {
-                vertex.surface_form().position() == Point::from([-1., -1.])
+            .flat_map(|half_edge| {
+                half_edge
+                    .boundary()
+                    .zip_ext(half_edge.surface_vertices().map(Clone::clone))
             })
-            .unwrap()
-            .clone();
+            .find(|(_, surface_vertex)| {
+                surface_vertex.position() == Point::from([-1., -1.])
+            })
+            .unwrap();
         assert_eq!(
             (&ray, &face).intersect(),
             Some(RayFaceIntersection::RayHitsVertex(vertex))

crates/fj-kernel/src/algorithms/reverse/edge.rs

@@ -1,3 +1,5 @@
+use fj_interop::ext::ArrayExt;
+
 use crate::{
     insert::Insert,
     objects::{HalfEdge, Objects},
@@ -10,7 +12,9 @@ use super::Reverse;
 impl Reverse for Handle<HalfEdge> {
     fn reverse(self, objects: &mut Service<Objects>) -> Self {
         let vertices = {
-            let [a, b] = self.vertices().clone();
+            let [a, b] = self
+                .boundary()
+                .zip_ext(self.surface_vertices().map(Clone::clone));
             [b, a]
         };
 

crates/fj-kernel/src/algorithms/sweep/edge.rs

@@ -8,7 +8,6 @@ use crate::{
     insert::Insert,
     objects::{
         Curve, Cycle, Face, GlobalEdge, HalfEdge, Objects, SurfaceVertex,
-        Vertex,
     },
     partial::{Partial, PartialFace, PartialObject},
     services::Service,
@@ -57,39 +56,43 @@ impl Sweep for (Handle<HalfEdge>, Color) {
                 .insert(objects)
             };
 
-            let vertices = {
+            let boundary = {
                 let points_surface = points_curve_and_surface
                     .map(|(_, point_surface)| point_surface);
 
-                edge.vertices()
-                    .each_ref_ext()
+                edge.boundary()
+                    .zip_ext(edge.surface_vertices())
                     .into_iter_fixed()
                     .zip(points_surface)
                     .collect::<[_; 2]>()
-                    .map(|(vertex, point_surface)| {
+                    .map(|((point, surface_vertex), point_surface)| {
                         let surface_vertex = SurfaceVertex::new(
                             point_surface,
                             surface.clone(),
-                            vertex.surface_form().global_form().clone(),
+                            surface_vertex.global_form().clone(),
                         )
                         .insert(objects);
 
-                        Vertex::new(vertex.position(), surface_vertex)
+                        (point, surface_vertex)
                     })
             };
 
-            HalfEdge::new(curve, vertices, edge.global_form().clone())
+            HalfEdge::new(curve, boundary, edge.global_form().clone())
                 .insert(objects)
         };
 
-        let side_edges = bottom_edge.vertices().clone().map(|vertex| {
-            (vertex, surface.clone()).sweep_with_cache(path, cache, objects)
-        });
+        let side_edges = bottom_edge
+            .boundary()
+            .zip_ext(bottom_edge.surface_vertices())
+            .map(|(point, surface_vertex)| {
+                (point, surface_vertex.clone(), surface.clone())
+                    .sweep_with_cache(path, cache, objects)
+            });
 
         let top_edge = {
             let surface_vertices = side_edges.clone().map(|edge| {
-                let [_, vertex] = edge.vertices();
-                vertex.surface_form().clone()
+                let [_, surface_vertex] = edge.surface_vertices();
+                surface_vertex.clone()
             });
 
             let points_curve_and_surface = bottom_edge
@@ -122,14 +125,13 @@ impl Sweep for (Handle<HalfEdge>, Color) {
             )
             .insert(objects);
 
-            let vertices = bottom_edge
+            let boundary = bottom_edge
                 .boundary()
                 .into_iter_fixed()
                 .zip(surface_vertices)
-                .collect::<[_; 2]>()
-                .map(|(point, surface_form)| Vertex::new(point, surface_form));
+                .collect::<[_; 2]>();
 
-            HalfEdge::new(curve, vertices, global).insert(objects)
+            HalfEdge::new(curve, boundary, global).insert(objects)
         };
 
         let cycle = {
@@ -144,15 +146,13 @@ impl Sweep for (Handle<HalfEdge>, Color) {
             while i < edges.len() {
                 let j = (i + 1) % edges.len();
 
-                let [_, prev_last] = edges[i].vertices();
-                let [next_first, _] = edges[j].vertices();
+                let [_, prev_last] = edges[i].surface_vertices();
+                let [next_first, _] = edges[j].surface_vertices();
 
                 // Need to compare surface forms here, as the global forms might
                 // be coincident when sweeping circles, despite the vertices
                 // being different!
-                if prev_last.surface_form().id()
-                    != next_first.surface_form().id()
-                {
+                if prev_last.id() != next_first.id() {
                     edges[j] = edges[j].clone().reverse(objects);
                 }
 

crates/fj-kernel/src/algorithms/sweep/vertex.rs

@@ -5,15 +5,15 @@ use crate::{
     insert::Insert,
     objects::{
         Curve, GlobalCurve, GlobalEdge, GlobalVertex, HalfEdge, Objects,
-        Surface, SurfaceVertex, Vertex,
+        Surface, SurfaceVertex,
     },
     services::Service,
     storage::Handle,
 };
 
 use super::{Sweep, SweepCache};
 
-impl Sweep for (Vertex, Handle<Surface>) {
+impl Sweep for (Point<1>, Handle<SurfaceVertex>, Handle<Surface>) {
     type Swept = Handle<HalfEdge>;
 
     fn sweep_with_cache(
@@ -22,7 +22,7 @@ impl Sweep for (Vertex, Handle<Surface>) {
         cache: &mut SweepCache,
         objects: &mut Service<Objects>,
     ) -> Self::Swept {
-        let (vertex, surface) = self;
+        let (point, surface_vertex, surface) = self;
         let path = path.into();
 
         // The result of sweeping a `Vertex` is an `Edge`. Seems
@@ -60,8 +60,7 @@ impl Sweep for (Vertex, Handle<Surface>) {
         // With that out of the way, let's start by creating the `GlobalEdge`,
         // as that is the most straight-forward part of this operations, and
         // we're going to need it soon anyway.
-        let (edge_global, vertices_global) = vertex
-            .surface_form()
+        let (edge_global, vertices_global) = surface_vertex
             .global_form()
             .clone()
             .sweep_with_cache(path, cache, objects);
@@ -81,8 +80,8 @@ impl Sweep for (Vertex, Handle<Surface>) {
         // straight-forward: The start of the edge is at zero, the end is at
         // one.
         let points_surface = [
-            Point::from([vertex.position().t, Scalar::ZERO]),
-            Point::from([vertex.position().t, Scalar::ONE]),
+            Point::from([point.t, Scalar::ZERO]),
+            Point::from([point.t, Scalar::ONE]),
         ];
 
         // Armed with those coordinates, creating the `Curve` of the output
@@ -99,20 +98,20 @@ impl Sweep for (Vertex, Handle<Surface>) {
             let [_, global_form] = vertices_global;
 
             [
-                vertex.surface_form().clone(),
+                surface_vertex,
                 SurfaceVertex::new(position, surface, global_form)
                     .insert(objects),
             ]
         };
 
         // And now the vertices. Again, nothing wild here.
-        let vertices = vertices_surface.map(|surface_form| {
-            Vertex::new([surface_form.position().v], surface_form)
+        let boundary = vertices_surface.map(|surface_vertex| {
+            (Point::from([surface_vertex.position().v]), surface_vertex)
         });
 
         // And finally, creating the output `Edge` is just a matter of
         // assembling the pieces we've already created.
-        HalfEdge::new(curve, vertices, edge_global).insert(objects)
+        HalfEdge::new(curve, boundary, edge_global).insert(objects)
     }
 }
 
@@ -158,7 +157,7 @@ mod tests {
         insert::Insert,
         partial::{
             Partial, PartialCurve, PartialGlobalVertex, PartialHalfEdge,
-            PartialObject, PartialSurfaceVertex, PartialVertex,
+            PartialObject, PartialSurfaceVertex,
         },
         services::Services,
     };
@@ -168,24 +167,26 @@ mod tests {
         let mut services = Services::new();
 
         let surface = services.objects.surfaces.xz_plane();
-        let mut curve = PartialCurve {
-            surface: Partial::from(surface.clone()),
-            ..Default::default()
-        };
-        curve.update_as_u_axis();
-        let vertex = PartialVertex {
-            position: Some([0.].into()),
-            surface_form: Partial::from_partial(PartialSurfaceVertex {
+        let (position, surface_vertex) = {
+            let mut curve = PartialCurve {
+                surface: Partial::from(surface.clone()),
+                ..Default::default()
+            };
+            curve.update_as_u_axis();
+
+            let surface_form = Partial::from_partial(PartialSurfaceVertex {
                 position: Some(Point::from([0., 0.])),
                 surface: Partial::from(surface.clone()),
                 global_form: Partial::from_partial(PartialGlobalVertex {
                     position: Some(Point::from([0., 0., 0.])),
                 }),
-            }),
-        }
-        .build(&mut services.objects);
+            })
+            .build(&mut services.objects);
+
+            (Point::from([0.]), surface_form)
+        };
 
-        let half_edge = (vertex, surface.clone())
+        let half_edge = (position, surface_vertex, surface.clone())
             .sweep([0., 0., 1.], &mut services.objects);
 
         let expected_half_edge = {

crates/fj-kernel/src/algorithms/transform/edge.rs

@@ -1,3 +1,4 @@
+use fj_interop::ext::ArrayExt;
 use fj_math::Transform;
 
 use crate::{
@@ -18,15 +19,20 @@ impl TransformObject for HalfEdge {
             .curve()
             .clone()
             .transform_with_cache(transform, objects, cache);
-        let vertices = self.vertices().clone().map(|vertex| {
-            vertex.transform_with_cache(transform, objects, cache)
-        });
+        let boundary = self.boundary().zip_ext(self.surface_vertices()).map(
+            |(point, surface_vertex)| {
+                let surface_vertex = surface_vertex
+                    .clone()
+                    .transform_with_cache(transform, objects, cache);
+                (point, surface_vertex)
+            },
+        );
         let global_form = self
             .global_form()
             .clone()
             .transform_with_cache(transform, objects, cache);
 
-        Self::new(curve, vertices, global_form)
+        Self::new(curve, boundary, global_form)
     }
 }