Merge pull request #1522 from hannobraun/simplify

Move `Curve` reference from `Vertex` to `HalfEdge`

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

@@ -14,6 +14,11 @@ impl Reverse for Handle<HalfEdge> {
             [b, a]
         };
 
-        HalfEdge::new(vertices, self.global_form().clone()).insert(objects)
+        HalfEdge::new(
+            self.curve().clone(),
+            vertices,
+            self.global_form().clone(),
+        )
+        .insert(objects)
     }
 }

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

@@ -76,15 +76,12 @@ impl Sweep for (Handle<HalfEdge>, Color) {
                         )
                         .insert(objects);
 
-                        Vertex::new(
-                            vertex.position(),
-                            curve.clone(),
-                            surface_vertex,
-                        )
+                        Vertex::new(vertex.position(), surface_vertex)
                     })
             };
 
-            HalfEdge::new(vertices, edge.global_form().clone()).insert(objects)
+            HalfEdge::new(curve, vertices, edge.global_form().clone())
+                .insert(objects)
         };
 
         let side_edges = bottom_edge.vertices().clone().map(|vertex| {
@@ -136,10 +133,10 @@ impl Sweep for (Handle<HalfEdge>, Color) {
                 .zip(surface_vertices)
                 .collect::<[_; 2]>()
                 .map(|(vertex, surface_form)| {
-                    Vertex::new(vertex.position(), curve.clone(), surface_form)
+                    Vertex::new(vertex.position(), surface_form)
                 });
 
-            HalfEdge::new(vertices, global).insert(objects)
+            HalfEdge::new(curve, vertices, global).insert(objects)
         };
 
         let cycle = {
@@ -229,7 +226,7 @@ mod tests {
             };
             let side_up = {
                 let mut side_up = PartialHalfEdge::default();
-                side_up.curve().write().surface = surface.clone();
+                side_up.curve.write().surface = surface.clone();
 
                 {
                     let [back, front] = &mut side_up.vertices;
@@ -248,7 +245,7 @@ mod tests {
             };
             let top = {
                 let mut top = PartialHalfEdge::default();
-                top.curve().write().surface = surface.clone();
+                top.curve.write().surface = surface.clone();
 
                 {
                     let [back, front] = &mut top.vertices;
@@ -274,7 +271,7 @@ mod tests {
             };
             let side_down = {
                 let mut side_down = PartialHalfEdge::default();
-                side_down.curve().write().surface = surface;
+                side_down.curve.write().surface = surface;
 
                 let [back, front] = &mut side_down.vertices;
 

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

@@ -107,16 +107,12 @@ impl Sweep for (Vertex, Handle<Surface>) {
 
         // And now the vertices. Again, nothing wild here.
         let vertices = vertices_surface.map(|surface_form| {
-            Vertex::new(
-                [surface_form.position().v],
-                curve.clone(),
-                surface_form,
-            )
+            Vertex::new([surface_form.position().v], surface_form)
         });
 
         // And finally, creating the output `Edge` is just a matter of
         // assembling the pieces we've already created.
-        HalfEdge::new(vertices, edge_global).insert(objects)
+        HalfEdge::new(curve, vertices, edge_global).insert(objects)
     }
 }
 
@@ -153,15 +149,16 @@ impl Sweep for Handle<GlobalVertex> {
 
 #[cfg(test)]
 mod tests {
+    use fj_math::Point;
     use pretty_assertions::assert_eq;
 
     use crate::{
         algorithms::sweep::Sweep,
         builder::{CurveBuilder, HalfEdgeBuilder},
         insert::Insert,
         partial::{
-            Partial, PartialCurve, PartialHalfEdge, PartialObject,
-            PartialSurfaceVertex, PartialVertex,
+            Partial, PartialCurve, PartialGlobalVertex, PartialHalfEdge,
+            PartialObject, PartialSurfaceVertex, PartialVertex,
         },
         services::Services,
     };
@@ -176,15 +173,14 @@ mod tests {
             ..Default::default()
         };
         curve.update_as_u_axis();
-        let curve = curve
-            .build(&mut services.objects)
-            .insert(&mut services.objects);
         let vertex = PartialVertex {
             position: Some([0.].into()),
-            curve: Partial::from(curve),
             surface_form: Partial::from_partial(PartialSurfaceVertex {
+                position: Some(Point::from([0., 0.])),
                 surface: Partial::from(surface.clone()),
-                ..Default::default()
+                global_form: Partial::from_partial(PartialGlobalVertex {
+                    position: Some(Point::from([0., 0., 0.])),
+                }),
             }),
         }
         .build(&mut services.objects);

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

@@ -14,6 +14,10 @@ impl TransformObject for HalfEdge {
         objects: &mut Service<Objects>,
         cache: &mut TransformCache,
     ) -> Self {
+        let curve = self
+            .curve()
+            .clone()
+            .transform_with_cache(transform, objects, cache);
         let vertices = self.vertices().clone().map(|vertex| {
             vertex.transform_with_cache(transform, objects, cache)
         });
@@ -22,7 +26,7 @@ impl TransformObject for HalfEdge {
             .clone()
             .transform_with_cache(transform, objects, cache);
 
-        Self::new(vertices, global_form)
+        Self::new(curve, vertices, global_form)
     }
 }
 

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

@@ -18,16 +18,12 @@ impl TransformObject for Vertex {
         // coordinates and thus transforming the curve takes care of it.
         let position = self.position();
 
-        let curve = self
-            .curve()
-            .clone()
-            .transform_with_cache(transform, objects, cache);
         let surface_form = self
             .surface_form()
             .clone()
             .transform_with_cache(transform, objects, cache);
 
-        Self::new(position, curve, surface_form)
+        Self::new(position, surface_form)
     }
 }
 

crates/fj-kernel/src/builder/edge.rs

@@ -58,14 +58,15 @@ impl HalfEdgeBuilder for PartialHalfEdge {
     fn replace_surface(&mut self, surface: impl Into<Partial<Surface>>) {
         let surface = surface.into();
 
+        self.curve.write().surface = surface.clone();
+
         for vertex in &mut self.vertices {
             vertex.replace_surface(surface.clone());
         }
     }
 
     fn update_as_circle_from_radius(&mut self, radius: impl Into<Scalar>) {
-        let mut curve = self.curve();
-        let path = curve.write().update_as_circle_from_radius(radius);
+        let path = self.curve.write().update_as_circle_from_radius(radius);
 
         let [a_curve, b_curve] =
             [Scalar::ZERO, Scalar::TAU].map(|coord| Point::from([coord]));
@@ -107,8 +108,8 @@ impl HalfEdgeBuilder for PartialHalfEdge {
             angle_rad,
         );
 
-        let mut curve = self.curve();
-        let path = curve
+        let path = self
+            .curve
             .write()
             .update_as_circle_from_center_and_radius(arc.center, arc.radius);
 
@@ -137,9 +138,9 @@ impl HalfEdgeBuilder for PartialHalfEdge {
     ) {
         let surface = surface.into();
 
-        for (vertex, point) in self.vertices.each_mut_ext().zip_ext(points) {
-            vertex.curve.write().surface = surface.clone();
+        self.curve.write().surface = surface.clone();
 
+        for (vertex, point) in self.vertices.each_mut_ext().zip_ext(points) {
             let mut surface_form = vertex.surface_form.write();
             surface_form.position = Some(point.into());
             surface_form.surface = surface.clone();
@@ -157,7 +158,7 @@ impl HalfEdgeBuilder for PartialHalfEdge {
                 .expect("Can't infer line segment without surface position")
         });
 
-        self.curve()
+        self.curve
             .write()
             .update_as_line_from_points(points_surface);
 
@@ -170,8 +171,7 @@ impl HalfEdgeBuilder for PartialHalfEdge {
     }
 
     fn infer_global_form(&mut self) -> Partial<GlobalEdge> {
-        self.global_form.write().curve =
-            self.curve().read().global_form.clone();
+        self.global_form.write().curve = self.curve.read().global_form.clone();
         self.global_form.write().vertices = self
             .vertices
             .each_ref_ext()
@@ -181,13 +181,13 @@ impl HalfEdgeBuilder for PartialHalfEdge {
     }
 
     fn update_from_other_edge(&mut self, other: &Partial<HalfEdge>) {
-        let global_curve = other.read().curve().read().global_form.clone();
-        self.curve().write().global_form = global_curve.clone();
+        let global_curve = other.read().curve.read().global_form.clone();
+        self.curve.write().global_form = global_curve.clone();
         self.global_form.write().curve = global_curve;
 
-        self.curve().write().path = other
+        self.curve.write().path = other
             .read()
-            .curve()
+            .curve
             .read()
             .path
             .as_ref()

crates/fj-kernel/src/builder/face.rs

@@ -151,7 +151,7 @@ impl FaceBuilder for PartialFace {
         for half_edge in &mut self.exterior.write().half_edges {
             let mut half_edge = half_edge.write();
 
-            let mut curve = half_edge.curve();
+            let mut curve = half_edge.curve.clone();
             let mut curve = curve.write();
 
             if let Some(path) = &mut curve.path {

crates/fj-kernel/src/builder/vertex.rs

@@ -23,8 +23,6 @@ pub trait VertexBuilder {
 impl VertexBuilder for PartialVertex {
     fn replace_surface(&mut self, surface: impl Into<Partial<Surface>>) {
         let surface = surface.into();
-
-        self.curve.write().surface = surface.clone();
         self.surface_form.write().surface = surface;
     }
 }

crates/fj-kernel/src/objects/full/edge.rs

@@ -8,23 +8,28 @@ use crate::{
 /// A half-edge
 #[derive(Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
 pub struct HalfEdge {
+    curve: Handle<Curve>,
     vertices: [Vertex; 2],
     global_form: Handle<GlobalEdge>,
 }
 
 impl HalfEdge {
     /// Create an instance of `HalfEdge`
-    pub fn new(vertices: [Vertex; 2], global_form: Handle<GlobalEdge>) -> Self {
+    pub fn new(
+        curve: Handle<Curve>,
+        vertices: [Vertex; 2],
+        global_form: Handle<GlobalEdge>,
+    ) -> Self {
         Self {
+            curve,
             vertices,
             global_form,
         }
     }
 
     /// Access the curve that defines the half-edge's geometry
     pub fn curve(&self) -> &Handle<Curve> {
-        let [vertex, _] = self.vertices();
-        vertex.curve()
+        &self.curve
     }
 
     /// Access the vertices that bound the half-edge on the curve

crates/fj-kernel/src/objects/full/vertex.rs

@@ -1,9 +1,6 @@
 use fj_math::Point;
 
-use crate::{
-    objects::{Curve, Surface},
-    storage::Handle,
-};
+use crate::{objects::Surface, storage::Handle};
 
 /// A vertex
 ///
@@ -15,22 +12,19 @@ use crate::{
 #[derive(Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
 pub struct Vertex {
     position: Point<1>,
-    curve: Handle<Curve>,
     surface_form: Handle<SurfaceVertex>,
 }
 
 impl Vertex {
     /// Construct an instance of `Vertex`
     pub fn new(
         position: impl Into<Point<1>>,
-        curve: Handle<Curve>,
         surface_form: Handle<SurfaceVertex>,
     ) -> Self {
         let position = position.into();
 
         Self {
             position,
-            curve,
             surface_form,
         }
     }
@@ -40,11 +34,6 @@ impl Vertex {
         self.position
     }
 
-    /// Access the curve that the vertex is defined in
-    pub fn curve(&self) -> &Handle<Curve> {
-        &self.curve
-    }
-
     /// Access the surface form of this vertex
     pub fn surface_form(&self) -> &Handle<SurfaceVertex> {
         &self.surface_form