Lift limitation when inferring surface as plane

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

@@ -182,7 +182,7 @@ impl CycleBuilder for PartialCycle {
  ) -> [Partial<HalfEdge>; 3] {
  let points_global = points_global.map(Into::into);
 
- let points_surface = self
+ let (points_surface, _) = self
  .surface
  .write()
  .update_as_plane_from_points(points_global);

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

@@ -1,4 +1,4 @@
-use std::collections::VecDeque;
+use std::{array, collections::VecDeque};
 
 use fj_interop::ext::ArrayExt;
 
@@ -12,7 +12,7 @@ use super::{CycleBuilder, HalfEdgeBuilder, ObjectArgument, SurfaceBuilder};
 
 /// Builder API for [`PartialFace`]
 pub trait FaceBuilder {
- /// Connect the face to another face at the provided half-edges
+ /// Connect the face to other faces at the provided half-edges
  ///
  /// Assumes that the provided half-edges, once translated into local
  /// equivalents of this face, will not form a cycle.
@@ -26,7 +26,7 @@ pub trait FaceBuilder {
  where
  O: ObjectArgument<Partial<HalfEdge>>;
 
- /// Connect the face to another face at the provided half-edges
+ /// Connect the face to other faces at the provided half-edges
  ///
  /// Assumes that the provided half-edges, once translated into local
  /// equivalents of this face, form a cycle.
@@ -109,38 +109,52 @@ impl FaceBuilder for PartialFace {
 
  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| {
- let [vertex, _] = &half_edge.read().vertices;
- vertex.1.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 mut vertices = exterior
+ .half_edges
+ .iter()
+ .map(|half_edge| {
+ let [(_, surface_vertex), _] = &half_edge.read().vertices;
+ let global_position = surface_vertex
+ .read()
+ .global_form
+ .read()
+ .position
+ .expect("Need global position to infer plane");
+
+ (surface_vertex.clone(), global_position)
+ })
+ .collect::<VecDeque<_>>();
+
+ let (first_three_vertices, surface) = {
+ let first_three_vertices = array::from_fn(|_| {
+ vertices
+ .pop_front()
+ .expect("Expected at least three vertices")
+ });
+
+ let first_three_points_global =
+ first_three_vertices.each_ref_ext().map(|(_, point)| *point);
+
+ let (first_three_points_surface, surface) = exterior
+ .surface
+ .write()
+ .update_as_plane_from_points(first_three_points_global);
+
+ let first_three_vertices = first_three_vertices
+ .zip_ext(first_three_points_surface)
+ .map(|((vertex, _), point_global)| (vertex, point_global));
+
+ (first_three_vertices, surface)
  };
- 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) {
+ let rest_of_vertices =
+ vertices.into_iter().map(|(vertex, point_global)| {
+ let point_surface = surface.project_global_point(point_global);
+ (vertex, point_surface)
+ });
+
+ for (mut surface_vertex, point) in
+ first_three_vertices.into_iter().chain(rest_of_vertices)
+ {
  surface_vertex.write().position = Some(point);
  }
 

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

@@ -14,7 +14,7 @@ pub trait SurfaceBuilder: Sized {
  fn update_as_plane_from_points(
  &mut self,
  points: [impl Into<Point<3>>; 3],
- ) -> [Point<2>; 3];
+ ) -> ([Point<2>; 3], SurfaceGeometry);
 }
 
 impl SurfaceBuilder for PartialSurface {
@@ -29,16 +29,19 @@ impl SurfaceBuilder for PartialSurface {
  fn update_as_plane_from_points(
  &mut self,
  points: [impl Into<Point<3>>; 3],
- ) -> [Point<2>; 3] {
+ ) -> ([Point<2>; 3], SurfaceGeometry) {
  let [a, b, c] = points.map(Into::into);
 
  let (u, u_coords) = GlobalPath::line_from_points([a, b]);
  let v = c - a;
 
- self.geometry = Some(SurfaceGeometry { u, v });
+ let geometry = SurfaceGeometry { u, v };
+ self.geometry = Some(geometry);
 
  let [a, b] = u_coords.map(|point| point.t);
- [[a, Scalar::ZERO], [b, Scalar::ZERO], [a, Scalar::ONE]]
- .map(Point::from)
+ let points = [[a, Scalar::ZERO], [b, Scalar::ZERO], [a, Scalar::ONE]]
+ .map(Point::from);
+
+ (points, geometry)
  }
 }

crates/fj-kernel/src/geometry/surface.rs

@@ -1,6 +1,6 @@
 //! The geometry that defines a surface
 
-use fj_math::{Line, Point, Transform, Vector};
+use fj_math::{Line, Plane, Point, Transform, Vector};
 
 use super::path::GlobalPath;
 
@@ -39,6 +39,17 @@ impl SurfaceGeometry {
  Line::from_origin_and_direction(self.u.origin(), self.v)
  }
 
+ /// Project the global point into the surface
+ pub fn project_global_point(&self, point: impl Into<Point<3>>) -> Point<2> {
+ let GlobalPath::Line(line) = self.u else {
+ todo!("Projecting point into non-plane surface is not supported")
+ };
+
+ let plane =
+ Plane::from_parametric(line.origin(), line.direction(), self.v);
+ plane.project_point(point)
+ }
+
  /// Transform the surface geometry
  #[must_use]
  pub fn transform(self, transform: &Transform) -> Self {