Remove position fields of SurfaceVertex/PartialSurfaceVertex

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

@@ -94,41 +94,39 @@ impl Sweep for (Handle<HalfEdge>, &Handle<SurfaceVertex>, &Surface, Color) {
             edge_down.write(),
         ]
         .zip_ext(boundaries)
-        .zip_ext(surface_points)
         .zip_ext(global_vertices)
-        .map(
-            |(((mut half_edge, boundary), surface_point), global_vertex)| {
-                for (a, b) in
-                    half_edge.boundary.each_mut_ext().zip_ext(boundary)
-                {
-                    *a = Some(b);
-                }
-
-                // Writing to the start vertices is enough. Neighboring half-
-                // edges share surface vertices, so writing the start vertex of
-                // each half-edge writes to all vertices.
-                let mut vertex = half_edge.start_vertex.write();
-                vertex.position = Some(surface_point);
-                vertex.global_form = Partial::from(global_vertex);
-            },
-        );
+        .map(|((mut half_edge, boundary), global_vertex)| {
+            for (a, b) in half_edge.boundary.each_mut_ext().zip_ext(boundary) {
+                *a = Some(b);
+            }
+
+            // Writing to the start vertices is enough. Neighboring half-
+            // edges share surface vertices, so writing the start vertex of
+            // each half-edge writes to all vertices.
+            let mut vertex = half_edge.start_vertex.write();
+            vertex.global_form = Partial::from(global_vertex);
+        });
 
         // With the vertices set, we can now update the curves.
         //
         // Those are all line segments. For the bottom and top curve, because
         // even if the original edge was a circle, it's still going to be a line
         // when projected into the new surface. For the side edges, because
         // we're sweeping along a straight path.
-        for (mut edge, next) in [
+        for ((mut half_edge, start), (next_half_edge, end)) in [
             edge_bottom.clone(),
             edge_up.clone(),
             edge_top.clone(),
             edge_down.clone(),
         ]
+        .zip_ext(surface_points)
         .into_iter()
         .circular_tuple_windows()
         {
-            edge.write().update_as_line_segment(next.clone());
+            half_edge.write().update_as_line_segment(start, end);
+            half_edge
+                .write()
+                .infer_global_form(next_half_edge.read().start_vertex.clone());
         }
 
         // Finally, we can make sure that all edges refer to the correct global

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

@@ -94,23 +94,6 @@ impl Sweep for Handle<Face> {
                 .write()
                 .connect_to_closed_edges(top_edges, &top_surface.geometry());
 
-            for half_edge in &mut top_cycle.write().half_edges {
-                let mut half_edge = half_edge.write();
-
-                let mut start_vertex = half_edge.start_vertex.write();
-                let global_point = start_vertex.global_form.read().position;
-
-                if start_vertex.position.is_none() {
-                    if let Some(global_point) = global_point {
-                        start_vertex.position = Some(
-                            top_surface
-                                .geometry()
-                                .project_global_point(global_point),
-                        );
-                    }
-                }
-            }
-
             for (bottom, top) in original_edges
                 .into_iter()
                 .zip(top_cycle.write().half_edges.iter_mut())

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

@@ -14,16 +14,12 @@ impl TransformObject for SurfaceVertex {
         objects: &mut Service<Objects>,
         cache: &mut TransformCache,
     ) -> Self {
-        // Don't need to transform position, as that is defined in surface
-        // coordinates and thus transforming the surface takes care of it.
-        let position = self.position();
-
         let global_form = self
             .global_form()
             .clone()
             .transform_with_cache(transform, objects, cache);
 
-        Self::new(position, global_form)
+        Self::new(global_form)
     }
 }
 

crates/fj-kernel/src/algorithms/triangulate/mod.rs

@@ -196,11 +196,11 @@ mod tests {
         // is not part of the polygon. The higher-level triangulation will
         // filter that out, but it will result in missing triangles.
 
-        let a = [0.1, 0.0];
-        let b = [0.2, 0.9];
-        let c = [0.2, 1.0];
-        let d = [0.1, 0.1];
-        let e = [0.0, 1.0];
+        let a = [1., 0.];
+        let b = [2., 8.];
+        let c = [2., 9.];
+        let d = [1., 1.];
+        let e = [0., 9.];
 
         let surface = services.objects.surfaces.xy_plane();
         let mut face = PartialFace {

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

@@ -22,19 +22,6 @@ pub trait CycleBuilder {
     /// meaning its front and back vertices are the same.
     fn add_half_edge(&mut self) -> Partial<HalfEdge>;
 
-    /// Add a new half-edge that starts at the provided point
-    ///
-    /// Opens the cycle between the last and first edge, updates the last edge
-    /// to go the provided point, and adds a new half-edge from the provided
-    /// point the the first edge.
-    ///
-    /// If the cycle doesn't have any edges yet, the new edge connects to
-    /// itself, starting and ending at the provided point.
-    fn add_half_edge_from_point_to_start(
-        &mut self,
-        point: impl Into<Point<2>>,
-    ) -> Partial<HalfEdge>;
-
     /// Update cycle as a polygon from the provided points
     fn update_as_polygon_from_points<O, P>(
         &mut self,
@@ -44,11 +31,6 @@ pub trait CycleBuilder {
         O: ObjectArgument<P>,
         P: Into<Point<2>>;
 
-    /// Update cycle as a polygon
-    ///
-    /// Will update each half-edge in the cycle to be a line segment.
-    fn update_as_polygon(&mut self);
-
     /// Connect the cycles to the provided half-edges
     ///
     /// Assumes that the provided half-edges, once translated into local
@@ -109,15 +91,6 @@ impl CycleBuilder for PartialCycle {
         new_half_edge
     }
 
-    fn add_half_edge_from_point_to_start(
-        &mut self,
-        point: impl Into<Point<2>>,
-    ) -> Partial<HalfEdge> {
-        let mut half_edge = self.add_half_edge();
-        half_edge.write().start_vertex.write().position = Some(point.into());
-        half_edge
-    }
-
     fn update_as_polygon_from_points<O, P>(
         &mut self,
         points: O,
@@ -126,18 +99,21 @@ impl CycleBuilder for PartialCycle {
         O: ObjectArgument<P>,
         P: Into<Point<2>>,
     {
-        let half_edges =
-            points.map(|point| self.add_half_edge_from_point_to_start(point));
-        self.update_as_polygon();
-        half_edges
-    }
-
-    fn update_as_polygon(&mut self) {
-        for (mut half_edge, next) in
-            self.half_edges.iter().cloned().circular_tuple_windows()
+        let mut start_positions = Vec::new();
+        let half_edges = points.map(|point| {
+            start_positions.push(point.into());
+            self.add_half_edge()
+        });
+
+        for ((start, end), half_edge) in start_positions
+            .into_iter()
+            .circular_tuple_windows()
+            .zip(&mut self.half_edges)
         {
-            half_edge.write().update_as_line_segment(next.clone());
+            half_edge.write().update_as_line_segment(start, end);
         }
+
+        half_edges
     }
 
     fn connect_to_closed_edges<O>(

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

@@ -26,14 +26,16 @@ pub trait HalfEdgeBuilder {
     /// Panics if the given angle is not within the range (-2pi, 2pi) radians.
     fn update_as_arc(
         &mut self,
+        start: Point<2>,
+        end: Point<2>,
         angle_rad: impl Into<Scalar>,
-        next_half_edge: Partial<HalfEdge>,
     );
 
     /// Update partial half-edge to be a line segment
     fn update_as_line_segment(
         &mut self,
-        next_half_edge: Partial<HalfEdge>,
+        start: Point<2>,
+        end: Point<2>,
     ) -> Curve;
 
     /// Infer the global form of the half-edge
@@ -80,9 +82,6 @@ impl HalfEdgeBuilder for PartialHalfEdge {
         let [a_curve, b_curve] =
             [Scalar::ZERO, Scalar::TAU].map(|coord| Point::from([coord]));
 
-        self.start_vertex.write().position =
-            Some(path.point_from_path_coords(a_curve));
-
         for (point_boundary, point_curve) in
             self.boundary.each_mut_ext().zip_ext([a_curve, b_curve])
         {
@@ -96,20 +95,14 @@ impl HalfEdgeBuilder for PartialHalfEdge {
 
     fn update_as_arc(
         &mut self,
+        start: Point<2>,
+        end: Point<2>,
         angle_rad: impl Into<Scalar>,
-        mut next_half_edge: Partial<HalfEdge>,
     ) {
         let angle_rad = angle_rad.into();
         if angle_rad <= -Scalar::TAU || angle_rad >= Scalar::TAU {
             panic!("arc angle must be in the range (-2pi, 2pi) radians");
         }
-        let [start, end] = [
-            &self.start_position(),
-            &next_half_edge.read().start_position(),
-        ]
-        .map(|position| {
-            position.expect("Can't infer arc without surface position")
-        });
 
         let arc = fj_math::Arc::from_endpoints_and_angle(start, end, angle_rad);
 
@@ -119,35 +112,20 @@ impl HalfEdgeBuilder for PartialHalfEdge {
         let [a_curve, b_curve] =
             [arc.start_angle, arc.end_angle].map(|coord| Point::from([coord]));
 
-        for ((point_boundary, surface_vertex), point_curve) in self
-            .boundary
-            .each_mut_ext()
-            .zip_ext([
-                &mut self.start_vertex,
-                &mut next_half_edge.write().start_vertex,
-            ])
-            .zip_ext([a_curve, b_curve])
+        for (point_boundary, point_curve) in
+            self.boundary.each_mut_ext().zip_ext([a_curve, b_curve])
         {
             *point_boundary = Some(point_curve);
-            surface_vertex.write().position =
-                Some(path.point_from_path_coords(point_curve));
         }
-
-        self.infer_global_form(next_half_edge.read().start_vertex.clone());
     }
 
     fn update_as_line_segment(
         &mut self,
-        next_half_edge: Partial<HalfEdge>,
+        start: Point<2>,
+        end: Point<2>,
     ) -> Curve {
         let boundary = self.boundary;
-        let points_surface = [
-            &self.start_position(),
-            &next_half_edge.read().start_position(),
-        ]
-        .map(|position| {
-            position.expect("Can't infer line segment without surface position")
-        });
+        let points_surface = [start, end];
 
         let path = if let [Some(start), Some(end)] = boundary {
             let points = [start, end].zip_ext(points_surface);
@@ -169,8 +147,6 @@ impl HalfEdgeBuilder for PartialHalfEdge {
             path
         };
 
-        self.infer_global_form(next_half_edge.read().start_vertex.clone());
-
         path
     }
 
@@ -202,21 +178,7 @@ impl HalfEdgeBuilder for PartialHalfEdge {
         {
             let position_curve = boundary_point
                 .expect("Can't infer surface position without curve position");
-
-            let position_surface = surface_vertex.read().position;
-
-            // Infer surface position, if not available.
-            let position_surface = match position_surface {
-                Some(position_surface) => position_surface,
-                None => {
-                    let position_surface =
-                        path.point_from_path_coords(position_curve);
-
-                    surface_vertex.write().position = Some(position_surface);
-
-                    position_surface
-                }
-            };
+            let position_surface = path.point_from_path_coords(position_curve);
 
             // Infer global position, if not available.
             let position_global =

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

@@ -5,26 +5,13 @@ use crate::storage::Handle;
 /// A vertex, defined in surface (2D) coordinates
 #[derive(Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
 pub struct SurfaceVertex {
-    position: Point<2>,
     global_form: Handle<GlobalVertex>,
 }
 
 impl SurfaceVertex {
     /// Construct a new instance of `SurfaceVertex`
-    pub fn new(
-        position: impl Into<Point<2>>,
-        global_form: Handle<GlobalVertex>,
-    ) -> Self {
-        let position = position.into();
-        Self {
-            position,
-            global_form,
-        }
-    }
-
-    /// Access the position of the vertex on the surface
-    pub fn position(&self) -> Point<2> {
-        self.position
+    pub fn new(global_form: Handle<GlobalVertex>) -> Self {
+        Self { global_form }
     }
 
     /// Access the global form of the vertex

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

@@ -25,7 +25,20 @@ pub struct PartialHalfEdge {
 impl PartialHalfEdge {
     /// Compute the surface position where the half-edge starts
     pub fn start_position(&self) -> Option<Point<2>> {
-        self.start_vertex.read().position
+        // Computing the surface position from the curve position is fine.
+        // `HalfEdge` "owns" its start position. There is no competing code that
+        // could compute the surface position from slightly different data.
+
+        let [start, _] = self.boundary;
+        start.and_then(|start| {
+            let curve = self.curve?;
+
+            if let MaybeCurve::Defined(curve) = curve {
+                return Some(curve.point_from_path_coords(start));
+            }
+
+            None
+        })
     }
 }