Merge pull request #2017 from hannobraun/approx

Support partial curve approximation matches

crates/fj-core/src/algorithms/approx/curve/approx.rs

@@ -1,3 +1,7 @@
+use fj_math::Point;
+
+use crate::geometry::CurveBoundary;
+
 use super::CurveApproxSegment;
 
 /// Partial approximation of a curve
@@ -19,6 +23,15 @@ impl CurveApprox {
         self
     }
 
+    /// Reduce the approximation to the subset defined by the provided boundary
+    pub fn make_subset(&mut self, boundary: &CurveBoundary<Point<1>>) {
+        for segment in &mut self.segments {
+            segment.make_subset(boundary.normalize());
+        }
+
+        self.segments.retain(|segment| !segment.is_empty());
+    }
+
     /// Merge the provided segment into the approximation
     pub fn merge(
         &mut self,

crates/fj-core/src/algorithms/approx/curve/cache.rs

@@ -25,20 +25,13 @@ impl CurveApproxCache {
     ) -> Option<CurveApprox> {
         let curve = HandleWrapper::from(curve.clone());
 
-        // Approximations within the cache are all stored in normalized form. If
-        // the caller requests a non-normalized boundary, that means we need to
-        // adjust the result before we return it, so let's remember whether the
-        // normalization resulted in a reversal.
-        let was_already_normalized = boundary.is_normalized();
-        let normalized_boundary = boundary.normalize();
-
         let mut approx = self.inner.get(&curve).cloned()?;
+        approx.make_subset(boundary);
 
-        approx
-            .segments
-            .retain(|segment| segment.boundary == normalized_boundary);
-
-        if !was_already_normalized {
+        // Approximations within the cache are stored in normalized form. If the
+        // caller requests a non-normalized boundary, that means we need to
+        // adjust the result before we return it.
+        if !boundary.is_normalized() {
             approx.reverse();
         }
 
@@ -53,6 +46,10 @@ impl CurveApproxCache {
     ) -> CurveApproxSegment {
         let curve = HandleWrapper::from(curve);
 
+        // Overlapping approximations need to result in the same points,
+        // regardless of what direction those overlapping approximations happen
+        // to have. To make sure this is always the case, we normalize each new
+        // approximated segment before doing *anything* with it.
         new_segment.normalize();
 
         let (approx, segment) = match self.inner.remove(&curve) {
@@ -256,4 +253,112 @@ pub mod tests {
             })
         );
     }
+
+    #[test]
+    fn partial_match_that_overlaps_start() {
+        let mut services = Services::new();
+
+        let mut cache = CurveApproxCache::default();
+        let curve = Curve::new().insert(&mut services);
+
+        cache.insert(
+            curve.clone(),
+            CurveApproxSegment {
+                boundary: CurveBoundary::from([[0.], [1.]]),
+                points: vec![
+                    ApproxPoint::new([0.125], [0.125, 0.125, 0.125]),
+                    ApproxPoint::new([0.375], [0.375, 0.375, 0.375]),
+                    ApproxPoint::new([0.625], [0.625, 0.625, 0.625]),
+                    ApproxPoint::new([0.875], [0.875, 0.875, 0.875]),
+                ],
+            }
+            .clone(),
+        );
+
+        let cached = cache.get(&curve, &CurveBoundary::from([[-0.5], [0.5]]));
+        assert_eq!(
+            cached,
+            Some(CurveApprox {
+                segments: vec![CurveApproxSegment {
+                    boundary: CurveBoundary::from([[0.], [0.5]]),
+                    points: vec![
+                        ApproxPoint::new([0.125], [0.125, 0.125, 0.125]),
+                        ApproxPoint::new([0.375], [0.375, 0.375, 0.375]),
+                    ],
+                }]
+            })
+        );
+    }
+
+    #[test]
+    fn partial_match_that_overlaps_end() {
+        let mut services = Services::new();
+
+        let mut cache = CurveApproxCache::default();
+        let curve = Curve::new().insert(&mut services);
+
+        cache.insert(
+            curve.clone(),
+            CurveApproxSegment {
+                boundary: CurveBoundary::from([[0.], [1.]]),
+                points: vec![
+                    ApproxPoint::new([0.125], [0.125, 0.125, 0.125]),
+                    ApproxPoint::new([0.375], [0.375, 0.375, 0.375]),
+                    ApproxPoint::new([0.625], [0.625, 0.625, 0.625]),
+                    ApproxPoint::new([0.875], [0.875, 0.875, 0.875]),
+                ],
+            }
+            .clone(),
+        );
+
+        let cached = cache.get(&curve, &CurveBoundary::from([[0.5], [1.5]]));
+        assert_eq!(
+            cached,
+            Some(CurveApprox {
+                segments: vec![CurveApproxSegment {
+                    boundary: CurveBoundary::from([[0.5], [1.0]]),
+                    points: vec![
+                        ApproxPoint::new([0.625], [0.625, 0.625, 0.625]),
+                        ApproxPoint::new([0.875], [0.875, 0.875, 0.875]),
+                    ],
+                }]
+            })
+        );
+    }
+
+    #[test]
+    fn partial_match_in_the_middle() {
+        let mut services = Services::new();
+
+        let mut cache = CurveApproxCache::default();
+        let curve = Curve::new().insert(&mut services);
+
+        cache.insert(
+            curve.clone(),
+            CurveApproxSegment {
+                boundary: CurveBoundary::from([[0.], [1.]]),
+                points: vec![
+                    ApproxPoint::new([0.125], [0.125, 0.125, 0.125]),
+                    ApproxPoint::new([0.375], [0.375, 0.375, 0.375]),
+                    ApproxPoint::new([0.625], [0.625, 0.625, 0.625]),
+                    ApproxPoint::new([0.875], [0.875, 0.875, 0.875]),
+                ],
+            }
+            .clone(),
+        );
+
+        let cached = cache.get(&curve, &CurveBoundary::from([[0.25], [0.75]]));
+        assert_eq!(
+            cached,
+            Some(CurveApprox {
+                segments: vec![CurveApproxSegment {
+                    boundary: CurveBoundary::from([[0.25], [0.75]]),
+                    points: vec![
+                        ApproxPoint::new([0.375], [0.375, 0.375, 0.375]),
+                        ApproxPoint::new([0.625], [0.625, 0.625, 0.625]),
+                    ],
+                }]
+            })
+        );
+    }
 }

crates/fj-core/src/algorithms/approx/curve/segment.rs

@@ -20,6 +20,23 @@ pub struct CurveApproxSegment {
 }
 
 impl CurveApproxSegment {
+    /// Indicate whether the segment is empty
+    pub fn is_empty(&self) -> bool {
+        let is_empty = {
+            let [min, max] = self.boundary.inner;
+            min >= max
+        };
+
+        if is_empty {
+            assert!(
+                self.points.is_empty(),
+                "Empty approximation still has points"
+            );
+        }
+
+        is_empty
+    }
+
     /// Indicate whether the segment is normalized
     pub fn is_normalized(&self) -> bool {
         self.boundary.is_normalized()
@@ -44,6 +61,32 @@ impl CurveApproxSegment {
 
         self
     }
+
+    /// Reduce the approximation to the subset defined by the provided boundary
+    pub fn make_subset(&mut self, boundary: CurveBoundary<Point<1>>) {
+        assert!(
+            self.boundary.is_normalized(),
+            "Expected normalized segment for making subset."
+        );
+        assert!(
+            boundary.is_normalized(),
+            "Expected subset to be defined by normalized boundary."
+        );
+
+        let [min, max] = boundary.inner;
+
+        self.boundary.inner = {
+            let [self_min, self_max] = self.boundary.inner;
+
+            let min = cmp::max(self_min, min);
+            let max = cmp::min(self_max, max);
+
+            [min, max]
+        };
+
+        self.points
+            .retain(|point| point.local_form > min && point.local_form < max);
+    }
 }
 
 impl Ord for CurveApproxSegment {