Merge Curve into HalfEdge

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

@@ -9,7 +9,7 @@ use std::collections::BTreeMap;
 
 use crate::{
     geometry::path::{GlobalPath, SurfacePath},
-    objects::{Curve, GlobalEdge, HalfEdge, Surface},
+    objects::{GlobalEdge, HalfEdge, Surface},
     storage::{Handle, ObjectId},
 };
 
@@ -41,7 +41,7 @@ impl Approx for (&Handle<HalfEdge>, &Surface) {
                 Some(approx) => approx,
                 None => {
                     let approx = approx_edge(
-                        half_edge.curve(),
+                        &half_edge.curve(),
                         surface,
                         range,
                         tolerance,
@@ -56,14 +56,10 @@ impl Approx for (&Handle<HalfEdge>, &Surface) {
                 .map(|point| {
                     let point_surface = half_edge
                         .curve()
-                        .path()
                         .point_from_path_coords(point.local_form);
 
                     ApproxPoint::new(point_surface, point.global_form)
-                        .with_source((
-                            half_edge.curve().clone(),
-                            point.local_form,
-                        ))
+                        .with_source((half_edge.clone(), point.local_form))
                 })
                 .collect()
         };
@@ -95,7 +91,7 @@ impl HalfEdgeApprox {
 }
 
 fn approx_edge(
-    curve: &Curve,
+    curve: &SurfacePath,
     surface: &Surface,
     range: RangeOnPath,
     tolerance: impl Into<Tolerance>,
@@ -106,14 +102,14 @@ fn approx_edge(
     // This will probably all be unified eventually, as `SurfacePath` and
     // `GlobalPath` grow APIs that are better suited to implementing this code
     // in a more abstract way.
-    let points = match (curve.path(), surface.geometry().u) {
+    let points = match (curve, surface.geometry().u) {
         (SurfacePath::Circle(_), GlobalPath::Circle(_)) => {
             todo!(
                 "Approximating a circle on a curved surface not supported yet."
             )
         }
         (SurfacePath::Circle(_), GlobalPath::Line(_)) => {
-            (curve.path(), range)
+            (curve, range)
                 .approx_with_cache(tolerance, &mut ())
                 .into_iter()
                 .map(|(point_curve, point_surface)| {
@@ -142,7 +138,7 @@ fn approx_edge(
         (SurfacePath::Line(line), _) => {
             let range_u =
                 RangeOnPath::from(range.boundary.map(|point_curve| {
-                    [curve.path().point_from_path_coords(point_curve).u]
+                    [curve.point_from_path_coords(point_curve).u]
                 }));
 
             let approx_u = (surface.geometry().u, range_u)
@@ -151,7 +147,7 @@ fn approx_edge(
             let mut points = Vec::new();
             for (u, _) in approx_u {
                 let t = (u.t - line.origin().u) / line.direction().u;
-                let point_surface = curve.path().point_from_path_coords([t]);
+                let point_surface = curve.point_from_path_coords([t]);
                 let point_global =
                     surface.geometry().point_from_surface_coords(point_surface);
                 points.push((u, point_global));
@@ -323,10 +319,8 @@ mod tests {
             .approx(tolerance)
             .into_iter()
             .map(|(point_local, _)| {
-                let point_surface = half_edge
-                    .curve()
-                    .path()
-                    .point_from_path_coords(point_local);
+                let point_surface =
+                    half_edge.curve().point_from_path_coords(point_local);
                 let point_global =
                     surface.geometry().point_from_surface_coords(point_surface);
                 ApproxPoint::new(point_surface, point_global)
@@ -355,7 +349,7 @@ mod tests {
         let approx = (&half_edge, surface.deref()).approx(tolerance);
 
         let expected_approx =
-            (half_edge.curve().path(), RangeOnPath::from([[0.], [TAU]]))
+            (&half_edge.curve(), RangeOnPath::from([[0.], [TAU]]))
                 .approx(tolerance)
                 .into_iter()
                 .map(|(_, point_surface)| {

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

@@ -19,10 +19,7 @@ use std::{
 
 use fj_math::Point;
 
-use crate::{
-    objects::{Curve, HalfEdge},
-    storage::Handle,
-};
+use crate::{objects::HalfEdge, storage::Handle};
 
 pub use self::tolerance::{InvalidTolerance, Tolerance};
 
@@ -121,5 +118,4 @@ impl<const D: usize> PartialOrd for ApproxPoint<D> {
 /// The source of an [`ApproxPoint`]
 pub trait Source: Any + Debug {}
 
-impl Source for (Handle<Curve>, Point<1>) {}
 impl Source for (Handle<HalfEdge>, Point<1>) {}

crates/fj-kernel/src/algorithms/approx/path.rs

@@ -36,7 +36,7 @@ use crate::geometry::path::{GlobalPath, SurfacePath};
 
 use super::{Approx, Tolerance};
 
-impl Approx for (SurfacePath, RangeOnPath) {
+impl Approx for (&SurfacePath, RangeOnPath) {
     type Approximation = Vec<(Point<1>, Point<2>)>;
     type Cache = ();
 
@@ -49,7 +49,7 @@ impl Approx for (SurfacePath, RangeOnPath) {
 
         match path {
             SurfacePath::Circle(circle) => {
-                approx_circle(&circle, range, tolerance.into())
+                approx_circle(circle, range, tolerance.into())
             }
             SurfacePath::Line(_) => vec![],
         }

crates/fj-kernel/src/algorithms/intersect/curve_edge.rs

@@ -35,7 +35,7 @@ impl CurveEdgeIntersection {
         };
 
         let edge_as_segment = {
-            let edge_curve_as_line = match half_edge.curve().path() {
+            let edge_curve_as_line = match half_edge.curve() {
                 SurfacePath::Line(line) => line,
                 _ => {
                     todo!("Curve-edge intersection only supports line segments")

crates/fj-kernel/src/algorithms/intersect/ray_edge.rs

@@ -17,7 +17,7 @@ impl Intersect for (&HorizontalRayToTheRight<2>, &Handle<HalfEdge>) {
     fn intersect(self) -> Option<Self::Intersection> {
         let (ray, edge) = self;
 
-        let line = match edge.curve().path() {
+        let line = match edge.curve() {
             SurfacePath::Line(line) => line,
             SurfacePath::Circle(_) => {
                 todo!("Casting rays against circles is not supported yet")

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

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

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

@@ -4,15 +4,15 @@ use crate::{
     builder::SurfaceBuilder,
     geometry::path::{GlobalPath, SurfacePath},
     insert::Insert,
-    objects::{Curve, Objects, Surface},
+    objects::{Objects, Surface},
     partial::{PartialObject, PartialSurface},
     services::Service,
     storage::Handle,
 };
 
 use super::{Sweep, SweepCache};
 
-impl Sweep for (Handle<Curve>, &Surface) {
+impl Sweep for (SurfacePath, &Surface) {
     type Swept = Handle<Surface>;
 
     fn sweep_with_cache(
@@ -47,7 +47,7 @@ impl Sweep for (Handle<Curve>, &Surface) {
             }
         }
 
-        let u = match curve.path() {
+        let u = match curve {
             SurfacePath::Circle(circle) => {
                 let center = surface
                     .geometry()

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

@@ -35,8 +35,7 @@ impl Sweep for (Handle<HalfEdge>, &Surface, Color) {
         // we're sweeping.
         {
             let surface = Partial::from(
-                (edge.curve().clone(), surface)
-                    .sweep_with_cache(path, cache, objects),
+                (edge.curve(), surface).sweep_with_cache(path, cache, objects),
             );
             face.surface = surface;
         }

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

@@ -109,8 +109,7 @@ impl Sweep for Handle<Face> {
                 .into_iter()
                 .zip(top_cycle.write().half_edges.iter_mut())
             {
-                top.write().curve.write().path =
-                    Some(bottom.curve().path().into());
+                top.write().curve = Some(bottom.curve().into());
 
                 let boundary = bottom.boundary();
 

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

@@ -15,10 +15,9 @@ impl TransformObject for HalfEdge {
         objects: &mut Service<Objects>,
         cache: &mut TransformCache,
     ) -> Self {
-        let curve = self
-            .curve()
-            .clone()
-            .transform_with_cache(transform, objects, cache);
+        // Don't need to transform curve, as that's defined in surface
+        // coordinates.
+        let curve = self.curve();
         let boundary = self.boundary().zip_ext(self.surface_vertices()).map(
             |(point, surface_vertex)| {
                 let surface_vertex = surface_vertex

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

@@ -1,6 +1,5 @@
 //! API for transforming objects
 
-mod curve;
 mod cycle;
 mod edge;
 mod face;