fix(clipper): Improved orthorect clipping

Which should be faster!

Author: johannes-wolf

src/plot/axis-styles/orthorect-2d/clipper.typ

@@ -1,3 +1,5 @@
+#import "/src/cetz.typ"
+
 /// Clip line-strip in rect
 ///
 /// - points (array): Array of vectors representing a line-strip
@@ -11,158 +13,74 @@
   let (min-y, max-y) = (calc.min(low.at(1), high.at(1)),
                         calc.max(low.at(1), high.at(1)))
 
-  let in-rect(pt) = {
-    return (pt.at(0) >= min-x and pt.at(0) <= max-x and
-            pt.at(1) >= min-y and pt.at(1) <= max-y)
-  }
-
-  let interpolated-end(a, b) = {
-    if in-rect(a) and in-rect(b) {
-      return b
-    }
-
-    let (x1, y1, ..) = a
-    let (x2, y2, ..) = b
-
-    if x2 - x1 == 0 {
-      return (x2, calc.min(max-y, calc.max(y2, min-y)))
-    }
-
-    if y2 - y1 == 0 {
-      return (calc.min(max-x, calc.max(x2, min-x)), y2)
-    }
-
-    let m = (y2 - y1) / (x2 - x1)
-    let n = y2 - m * x2
-
-    let x = x2
-    let y = y2
-
-    y = calc.min(max-y, calc.max(y, min-y))
-    x = (y - n) / m
-
-    x = calc.min(max-x, calc.max(x, min-x))
-    y = m * x + n
-
-    return (x, y)
+  let in-rect((x, y)) = {
+    return (x >= min-x and x <= max-x and
+            y >= min-y and y <= max-y)
   }
 
-  // Append path to paths and return paths
-  //
-  // If path starts or ends with a vector of another part, merge those
-  // paths instead appending path as a new path.
-  let append-path(paths, path) = {
-    if path.len() <= 1 {
-      return paths
-    }
-
-    let cmp(a, b) = {
-      return a.map(calc.round.with(digits: 8)) == b.map(calc.round.with(digits: 8))
-    }
+  let edges = (
+    ((min-x, min-y), (min-x, max-y)),
+    ((max-x, min-y), (max-x, max-y)),
+    ((min-x, min-y), (max-x, min-y)),
+    ((min-x, max-y), (max-x, max-y)),
+  )
 
-    let added = false
-    for i in range(0, paths.len()) {
-      let p = paths.at(i)
-      if cmp(p.first(), path.last()) {
-        paths.at(i) = path + p
-        added = true
-      } else if cmp(p.first(), path.first()) {
-        paths.at(i) = path.rev() + p
-        added = true
-      } else if cmp(p.last(), path.first()) {
-        paths.at(i) = p + path
-        added = true
-      } else if cmp(p.last(), path.last()) {
-        paths.at(i) = p + path.rev()
-        added = true
+  let interpolated-end(a, b) = {
+    for (edge-a, edge-b) in edges {
+      let pt = cetz.intersection.line-line(a, b, edge-a, edge-b)
+      if pt != none {
+        return pt
       }
-      if added { break }
     }
-
-    if not added {
-      paths.push(path)
-    }
-    return paths
   }
 
-  let clamped-pt(pt) = {
-    return (calc.max(min-x, calc.min(pt.at(0), max-x)),
-            calc.max(min-y, calc.min(pt.at(1), max-y)))
-  }
 
-  let paths = ()
+  // Find lines crossing the rect bounds
+  // by storing all crossings as tuples (<index>, <goes-inside>, <point-on-border>)
+  let crossings = ()
 
-  let path = ()
-  let prev = points.at(0)
-  let was-inside = in-rect(prev)
+  // Push a pseudo entry for the last point, if it is insides the bounds.
+  let was-inside = in-rect(points.at(0))
   if was-inside {
-    path.push(prev)
-  } else if fill {
-    path.push(clamped-pt(prev))
+    crossings.push((0, true, points.first()))
   }
 
+  // Find crossings and compute interseciton points.
   for i in range(1, points.len()) {
-    let prev = points.at(i - 1)
-    let pt = points.at(i)
-
-    let is-inside = in-rect(pt)
-
-    let (x1, y1) = prev
-    let (x2, y2) = pt
-
-    // Ignore lines if both ends are outsides the x-window and on the
-    // same side.
-    if (x1 < min-x and x2 < min-x) or (x1 > max-x and x2 > max-x) {
-      if fill {
-        let clamped = clamped-pt(pt)
-        if path.last() != clamped {
-          path.push(clamped)
-        }
-      }
-      was-inside = false
-      continue
+    let current-inside = in-rect(points.at(i))
+    if current-inside != was-inside {
+      crossings.push((
+        i,
+        current-inside,
+        interpolated-end(points.at(i - 1), points.at(i))))
+      was-inside = current-inside
     }
-
-    if is-inside {
-      if was-inside {
-        path.push(pt)
-      } else {
-        path.push(interpolated-end(pt, prev))
-        path.push(pt)
-      }
-    } else {
-      if was-inside {
-        path.push(interpolated-end(prev, pt))
-      } else {
-        let (a, b) = (interpolated-end(pt, prev),
-                      interpolated-end(prev, pt))
-        if in-rect(a) and in-rect(b) {
-          path.push(a)
-          path.push(b)
-        } else if fill {
-          let clamped = clamped-pt(pt)
-          if path.last() != clamped {
-            path.push(clamped)
-          }
-        }
-      }
-
-      if path.len() > 0 and not fill {
-        paths = append-path(paths, path)
-        path = ()
-      }
-    }
-    
-    was-inside = is-inside
   }
 
-  // Append clamped last point if filling
-  if fill and not in-rect(points.last()) {
-    path.push(clamped-pt(points.last()))
+  // Push a pseudo entry for the last point, if it is insides the bounds.
+  if in-rect(points.last()) and crossings.last().at(1) {
+    crossings.push((points.len() - 1, false, points.last()))
   }
 
-  if path.len() > 1 {
-    paths = append-path(paths, path)
+  // Generate paths
+  let paths = ()
+  for i in range(1, crossings.len()) {
+    let (a-index, a-dir, a-pt) = crossings.at(i - 1)
+    let (b-index, b-dir, b-pt) = crossings.at(i)
+
+    if a-dir {
+      let path = points.slice(a-index, b-index)
+      path.insert(0, a-pt)
+      path.push(b-pt)
+
+      // Insert the last end point to connect
+      // to a filled area.
+      if fill and paths.len() > 0 {
+        path.insert(0, paths.last().last())
+      }
+
+      paths.push(path)
+    }
   }
 
   return paths
@@ -181,4 +99,4 @@
 /// - low (vector): Lower clip-window coordinate
 /// - high (vector): Upper clip-window coordinate
 /// -> array List of fill paths
-#let compute-fill-paths = clipped-paths-rect.with(fill: true)
+#let compute-fill-paths = clipped-paths-rect.with(fill: true)