Merge pull request #2353 from hannobraun/geometry

Set curve geometry when reverting curve coordinate systems

crates/fj-core/src/operations/build/shell.rs

@@ -176,9 +176,10 @@ pub trait BuildShell {
                                 .update_half_edge(
                                     cycle.half_edges().nth_circular(0),
                                     |edge, core| {
-                                        [edge.reverse_curve_coordinate_systems(
-                                            core,
-                                        )]
+                                        [(edge, bad.face.surface())
+                                            .reverse_curve_coordinate_systems(
+                                                core,
+                                            )]
                                     },
                                     core,
                                 )
@@ -207,7 +208,7 @@ pub trait BuildShell {
                                     .update_half_edge(
                                         cycle.half_edges().nth_circular(1),
                                         |edge, core| {
-                                            [edge
+                                            [(edge, dac.face.surface())
                                         .reverse_curve_coordinate_systems(core)]
                                         },
                                         core,
@@ -222,7 +223,7 @@ pub trait BuildShell {
                                     .update_half_edge(
                                         cycle.half_edges().nth_circular(0),
                                         |edge, core| {
-                                            [edge
+                                            [(edge, dac.face.surface())
                                         .reverse_curve_coordinate_systems(core)]
                                         },
                                         core,
@@ -252,23 +253,23 @@ pub trait BuildShell {
                                     .update_half_edge(
                                         cycle.half_edges().nth_circular(0),
                                         |edge, core| {
-                                            [edge
+                                            [(edge, cbd.face.surface())
                                         .reverse_curve_coordinate_systems(core)]
                                         },
                                         core,
                                     )
                                     .update_half_edge(
                                         cycle.half_edges().nth_circular(1),
                                         |edge, core| {
-                                            [edge
+                                            [(edge, cbd.face.surface())
                                         .reverse_curve_coordinate_systems(core)]
                                         },
                                         core,
                                     )
                                     .update_half_edge(
                                         cycle.half_edges().nth_circular(2),
                                         |edge, core| {
-                                            [edge
+                                            [(edge, cbd.face.surface())
                                         .reverse_curve_coordinate_systems(core)]
                                         },
                                         core,

crates/fj-core/src/operations/reverse/curve.rs

@@ -0,0 +1,54 @@
+use crate::{
+    operations::{derive::DeriveFrom, insert::Insert},
+    storage::Handle,
+    topology::{Curve, Surface},
+    Core,
+};
+
+use super::ReverseCurveCoordinateSystems;
+
+impl ReverseCurveCoordinateSystems for (&Handle<Curve>, &Handle<Surface>) {
+    type Reversed = Handle<Curve>;
+
+    fn reverse_curve_coordinate_systems(
+        self,
+        core: &mut Core,
+    ) -> Self::Reversed {
+        // We don't *actually* need a surface here, because *all* local
+        // definitions need to be reversed in sync anyway. However, then this
+        // method couldn't be called in `HalfEdge`'s implementation, meaning the
+        // way this trait works had to change completely.
+        //
+        // At this point it's probably not worth it to re-architect the trait,
+        // since eventually, redundant geometry definitions shouldn't exist any
+        // more, and then the existence of this trait, at least in its current
+        // form, is in question anyway.
+        //
+        // Once the dust has settled, we can figure out what needs to happen
+        // here. In the meantime, we can have this weird implementation, and
+        // rely on the callers to make sure everything stays consistent.
+        //
+        // [1]: https://github.com/hannobraun/fornjot/issues/2290
+        let (curve, surface) = self;
+
+        let mut curve_geom = core
+            .layers
+            .geometry
+            .of_curve(curve)
+            .unwrap()
+            .local_on(surface)
+            .unwrap()
+            .clone();
+        curve_geom.path = curve_geom.path.reverse();
+
+        let curve = Curve::new().insert(core).derive_from(curve, core);
+
+        core.layers.geometry.define_curve(
+            curve.clone(),
+            surface.clone(),
+            curve_geom,
+        );
+
+        curve
+    }
+}

crates/fj-core/src/operations/reverse/cycle.rs

@@ -2,7 +2,8 @@ use crate::{
     operations::{
         derive::DeriveFrom, geometry::UpdateHalfEdgeGeometry, insert::Insert,
     },
-    topology::{Cycle, HalfEdge},
+    storage::Handle,
+    topology::{Cycle, HalfEdge, Surface},
     Core,
 };
 
@@ -33,17 +34,19 @@ impl Reverse for Cycle {
     }
 }
 
-impl ReverseCurveCoordinateSystems for &Cycle {
+impl ReverseCurveCoordinateSystems for (&Cycle, &Handle<Surface>) {
     type Reversed = Cycle;
 
     fn reverse_curve_coordinate_systems(
         self,
         core: &mut Core,
     ) -> Self::Reversed {
-        let edges = self
+        let (cycle, surface) = self;
+
+        let edges = cycle
             .half_edges()
             .iter()
-            .map(|edge| edge.reverse_curve_coordinate_systems(core));
+            .map(|edge| (edge, surface).reverse_curve_coordinate_systems(core));
 
         Cycle::new(edges)
     }

crates/fj-core/src/operations/reverse/face.rs

@@ -1,4 +1,4 @@
-use std::borrow::Borrow;
+use std::{borrow::Borrow, ops::Deref};
 
 use crate::{
     operations::{
@@ -49,8 +49,7 @@ impl ReverseCurveCoordinateSystems for &Face {
         self,
         core: &mut Core,
     ) -> Self::Reversed {
-        let region = self
-            .region()
+        let region = (self.region().deref(), self.surface())
             .reverse_curve_coordinate_systems(core)
             .insert(core)
             .derive_from(self.region(), core);

crates/fj-core/src/operations/reverse/half_edge.rs

@@ -1,27 +1,31 @@
 use crate::{
     operations::{derive::DeriveFrom, insert::Insert},
     storage::Handle,
-    topology::HalfEdge,
+    topology::{HalfEdge, Surface},
     Core,
 };
 
 use super::ReverseCurveCoordinateSystems;
 
-impl ReverseCurveCoordinateSystems for &Handle<HalfEdge> {
+impl ReverseCurveCoordinateSystems for (&Handle<HalfEdge>, &Handle<Surface>) {
     type Reversed = Handle<HalfEdge>;
 
     fn reverse_curve_coordinate_systems(
         self,
         core: &mut Core,
     ) -> Self::Reversed {
-        let mut half_edge_geom = *core.layers.geometry.of_half_edge(self);
+        let (half_edge, surface) = self;
+
+        let mut half_edge_geom = *core.layers.geometry.of_half_edge(half_edge);
         half_edge_geom.path = half_edge_geom.path.reverse();
         half_edge_geom.boundary = half_edge_geom.boundary.reverse();
 
-        let half_edge =
-            HalfEdge::new(self.curve().clone(), self.start_vertex().clone())
-                .insert(core)
-                .derive_from(self, core);
+        let curve =
+            (half_edge.curve(), surface).reverse_curve_coordinate_systems(core);
+
+        let half_edge = HalfEdge::new(curve, half_edge.start_vertex().clone())
+            .insert(core)
+            .derive_from(half_edge, core);
 
         core.layers
             .geometry

crates/fj-core/src/operations/reverse/mod.rs

@@ -2,6 +2,7 @@
 
 use crate::Core;
 
+mod curve;
 mod cycle;
 mod face;
 mod half_edge;

crates/fj-core/src/operations/reverse/region.rs

@@ -1,6 +1,9 @@
+use std::ops::Deref;
+
 use crate::{
     operations::{derive::DeriveFrom, insert::Insert},
-    topology::Region,
+    storage::Handle,
+    topology::{Region, Surface},
     Core,
 };
 
@@ -21,20 +24,21 @@ impl Reverse for Region {
     }
 }
 
-impl ReverseCurveCoordinateSystems for &Region {
+impl ReverseCurveCoordinateSystems for (&Region, &Handle<Surface>) {
     type Reversed = Region;
 
     fn reverse_curve_coordinate_systems(
         self,
         core: &mut Core,
     ) -> Self::Reversed {
-        let exterior = self
-            .exterior()
+        let (region, surface) = self;
+
+        let exterior = (region.exterior().deref(), surface)
             .reverse_curve_coordinate_systems(core)
             .insert(core)
-            .derive_from(self.exterior(), core);
-        let interiors = self.interiors().iter().map(|cycle| {
-            cycle
+            .derive_from(region.exterior(), core);
+        let interiors = region.interiors().iter().map(|cycle| {
+            (cycle.deref(), surface)
                 .reverse_curve_coordinate_systems(core)
                 .insert(core)
                 .derive_from(cycle, core)