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
+ })
  }
 }