Merge pull request #1510 from hannobraun/builder

Expand builder API

crates/fj-interop/src/ext.rs

@@ -51,6 +51,32 @@ impl<T> ArrayExt<T, 2> for [T; 2] {
     }
 }
 
+impl<T> ArrayExt<T, 3> for [T; 3] {
+    fn each_ref_ext(&self) -> [&T; 3] {
+        let [a, b, c] = self;
+        [a, b, c]
+    }
+
+    fn each_mut_ext(&mut self) -> [&mut T; 3] {
+        let [a, b, c] = self;
+        [a, b, c]
+    }
+
+    fn try_map_ext<F, U, E>(self, f: F) -> Result<[U; 3], E>
+    where
+        F: FnMut(T) -> Result<U, E>,
+    {
+        let [a, b, c] = self.map(f);
+        Ok([a?, b?, c?])
+    }
+
+    fn zip_ext<U>(self, rhs: [U; 3]) -> [(T, U); 3] {
+        let [a, b, c] = self;
+        let [q, r, s] = rhs;
+        [(a, q), (b, r), (c, s)]
+    }
+}
+
 impl<T> ArrayExt<T, 4> for [T; 4] {
     fn each_ref_ext(&self) -> [&T; 4] {
         let [a, b, c, d] = self;

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

@@ -60,7 +60,7 @@ impl CurveBuilder for PartialCurve {
         radius: impl Into<Scalar>,
     ) -> SurfacePath {
         let path = SurfacePath::circle_from_radius(radius);
-        self.path = Some(path);
+        self.path = Some(path.into());
         path
     }
 
@@ -70,7 +70,7 @@ impl CurveBuilder for PartialCurve {
         radius: impl Into<Scalar>,
     ) -> SurfacePath {
         let path = SurfacePath::circle_from_center_and_radius(center, radius);
-        self.path = Some(path);
+        self.path = Some(path.into());
         path
     }
 
@@ -79,7 +79,7 @@ impl CurveBuilder for PartialCurve {
         points: [impl Into<Point<2>>; 2],
     ) -> SurfacePath {
         let (path, _) = SurfacePath::line_from_points(points);
-        self.path = Some(path);
+        self.path = Some(path.into());
         path
     }
 }

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

@@ -1,3 +1,4 @@
+use fj_interop::ext::ArrayExt;
 use fj_math::Point;
 
 use crate::{
@@ -34,6 +35,19 @@ pub trait CycleBuilder {
         point: impl Into<Point<2>>,
     ) -> 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_global_point_to_start(
+        &mut self,
+        point: impl Into<Point<3>>,
+    ) -> Partial<HalfEdge>;
+
     /// Update cycle as a polygon from the provided points
     fn update_as_polygon_from_points<O, P>(
         &mut self,
@@ -127,6 +141,25 @@ impl CycleBuilder for PartialCycle {
         half_edge
     }
 
+    fn add_half_edge_from_global_point_to_start(
+        &mut self,
+        point: impl Into<Point<3>>,
+    ) -> Partial<HalfEdge> {
+        let mut half_edge = self.add_half_edge();
+
+        half_edge
+            .write()
+            .back_mut()
+            .write()
+            .surface_form
+            .write()
+            .global_form
+            .write()
+            .position = Some(point.into());
+
+        half_edge
+    }
+
     fn update_as_polygon_from_points<O, P>(
         &mut self,
         points: O,
@@ -151,10 +184,28 @@ impl CycleBuilder for PartialCycle {
         &mut self,
         points_global: [impl Into<Point<3>>; 3],
     ) -> [Partial<HalfEdge>; 3] {
+        let points_global = points_global.map(Into::into);
+
         let points_surface = self
             .surface
             .write()
             .update_as_plane_from_points(points_global);
-        self.update_as_polygon_from_points(points_surface)
+
+        let half_edges = self.update_as_polygon_from_points(points_surface);
+
+        for (mut half_edge, point) in half_edges.clone().zip_ext(points_global)
+        {
+            half_edge
+                .write()
+                .back_mut()
+                .write()
+                .surface_form
+                .write()
+                .global_form
+                .write()
+                .position = Some(point);
+        }
+
+        half_edges
     }
 }

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

@@ -2,8 +2,8 @@ use fj_interop::ext::ArrayExt;
 use fj_math::{Point, Scalar};
 
 use crate::{
-    objects::{GlobalEdge, Surface},
-    partial::{Partial, PartialGlobalEdge, PartialHalfEdge},
+    objects::{GlobalEdge, HalfEdge, Surface},
+    partial::{MaybeSurfacePath, Partial, PartialGlobalEdge, PartialHalfEdge},
 };
 
 use super::{CurveBuilder, VertexBuilder};
@@ -46,6 +46,12 @@ pub trait HalfEdgeBuilder {
     /// Updates the global form referenced by this half-edge, and also returns
     /// it.
     fn infer_global_form(&mut self) -> Partial<GlobalEdge>;
+
+    /// Update this edge from another
+    ///
+    /// Infers as much information about this edge from the other, under the
+    /// assumption that the other edge is on a different surface.
+    fn update_from_other_edge(&mut self, other: &Partial<HalfEdge>);
 }
 
 impl HalfEdgeBuilder for PartialHalfEdge {
@@ -177,6 +183,35 @@ impl HalfEdgeBuilder for PartialHalfEdge {
 
         self.global_form.clone()
     }
+
+    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();
+        self.global_form.write().curve = global_curve;
+
+        self.curve().write().path = other
+            .read()
+            .curve()
+            .read()
+            .path
+            .as_ref()
+            .map(MaybeSurfacePath::to_undefined);
+
+        for (this, other) in self
+            .vertices
+            .iter_mut()
+            .zip(other.read().vertices.iter().rev())
+        {
+            this.write().position = other.read().position;
+            this.write()
+                .surface_form
+                .write()
+                .global_form
+                .write()
+                .position =
+                other.read().surface_form.read().global_form.read().position;
+        }
+    }
 }
 
 /// Builder API for [`PartialGlobalEdge`]

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

@@ -1,15 +1,99 @@
+use std::collections::VecDeque;
+
+use fj_interop::ext::ArrayExt;
+
 use crate::{
-    objects::Cycle,
+    objects::{Cycle, HalfEdge, Surface},
     partial::{Partial, PartialCycle, PartialFace},
 };
 
+use super::{CycleBuilder, HalfEdgeBuilder, ObjectArgument, SurfaceBuilder};
+
 /// Builder API for [`PartialFace`]
 pub trait FaceBuilder {
+    /// Connect the face to another face at the provided half-edges
+    ///
+    /// Assumes that the provided half-edges, once translated into local
+    /// equivalents of this face, will not form a cycle.
+    ///
+    /// Returns the local equivalents of the provided half-edges and, as the
+    /// last entry, an additional half-edge that closes the cycle.
+    fn connect_to_open_edges<O>(
+        &mut self,
+        edges: O,
+    ) -> O::SizePlusOne<Partial<HalfEdge>>
+    where
+        O: ObjectArgument<Partial<HalfEdge>>;
+
+    /// Connect the face to another face at the provided half-edges
+    ///
+    /// Assumes that the provided half-edges, once translated into local
+    /// equivalents of this face, form a cycle.
+    ///
+    /// Returns the local equivalents of the provided half-edges.
+    fn connect_to_closed_edges<O>(
+        &mut self,
+        edges: O,
+    ) -> O::SameSize<Partial<HalfEdge>>
+    where
+        O: ObjectArgument<Partial<HalfEdge>>;
+
     /// Add an interior cycle
     fn add_interior(&mut self) -> Partial<Cycle>;
+
+    /// Update the face's surface as a plane
+    ///
+    /// The plane geometry is inferred from three of the face's vertices. Also
+    /// infers any undefined `SurfaceVertex` positions.
+    ///
+    /// # Panics
+    ///
+    /// Assumes that the face exterior has exactly three vertices to use. Panics
+    /// otherwise. This is a temporary limitation, not a fundamental one. It
+    /// could be overcome with some more work.
+    fn update_surface_as_plane(&mut self) -> Partial<Surface>;
 }
 
 impl FaceBuilder for PartialFace {
+    fn connect_to_open_edges<O>(
+        &mut self,
+        edges: O,
+    ) -> O::SizePlusOne<Partial<HalfEdge>>
+    where
+        O: ObjectArgument<Partial<HalfEdge>>,
+    {
+        // We need to create the additional half-edge last, but at the same time
+        // need to provide it to the `map_plus_one` method first. Really no
+        // choice but to create them all in one go, as we do here.
+        let mut half_edges = VecDeque::new();
+        for _ in 0..edges.num_objects() {
+            half_edges.push_back(self.exterior.write().add_half_edge());
+        }
+        let additional_half_edge = self.exterior.write().add_half_edge();
+
+        edges.map_plus_one(additional_half_edge, |other| {
+            let mut this = half_edges.pop_front().expect(
+                "Pushed correct number of half-edges; should be able to pop",
+            );
+            this.write().update_from_other_edge(&other);
+            this
+        })
+    }
+
+    fn connect_to_closed_edges<O>(
+        &mut self,
+        edges: O,
+    ) -> O::SameSize<Partial<HalfEdge>>
+    where
+        O: ObjectArgument<Partial<HalfEdge>>,
+    {
+        edges.map(|other| {
+            let mut this = self.exterior.write().add_half_edge();
+            this.write().update_from_other_edge(&other);
+            this
+        })
+    }
+
     fn add_interior(&mut self) -> Partial<Cycle> {
         let cycle = Partial::from_partial(PartialCycle {
             surface: self.exterior.read().surface.clone(),
@@ -18,4 +102,45 @@ impl FaceBuilder for PartialFace {
         self.interiors.push(cycle.clone());
         cycle
     }
+
+    fn update_surface_as_plane(&mut self) -> Partial<Surface> {
+        let mut exterior = self.exterior.write();
+        let mut vertices = {
+            exterior.half_edges.iter().map(|half_edge| {
+                half_edge.read().back().read().surface_form.clone()
+            })
+        };
+
+        let vertices = {
+            let array = [
+                vertices.next().expect("Expected exactly three vertices"),
+                vertices.next().expect("Expected exactly three vertices"),
+                vertices.next().expect("Expected exactly three vertices"),
+            ];
+
+            assert!(
+                vertices.next().is_none(),
+                "Expected exactly three vertices"
+            );
+
+            array
+        };
+        let points = vertices.each_ref_ext().map(|vertex| {
+            vertex
+                .read()
+                .global_form
+                .read()
+                .position
+                .expect("Need global position to infer plane")
+        });
+
+        let points_surface =
+            exterior.surface.write().update_as_plane_from_points(points);
+
+        for (mut surface_vertex, point) in vertices.zip_ext(points_surface) {
+            surface_vertex.write().position = Some(point);
+        }
+
+        exterior.surface.clone()
+    }
 }

crates/fj-kernel/src/partial/mod.rs

@@ -16,7 +16,7 @@ mod wrapper;
 
 pub use self::{
     objects::{
-        curve::{PartialCurve, PartialGlobalCurve},
+        curve::{MaybeSurfacePath, PartialCurve, PartialGlobalCurve},
         cycle::PartialCycle,
         edge::{PartialGlobalEdge, PartialHalfEdge},
         face::PartialFace,