Merge branch 'aggressive-refactoring' into bar-element-gallery-fixes

Author: johannes-wolf

gallery/barchart.typ

@@ -20,5 +20,5 @@
                       bar-width: .8,
                       data2,
                       labels: ([Low], [Medium], [High], [Very high]),
-                      legend: "inner-north-east",)
-})
+                      legend: "inner-north-east")
+})

manual.pdf

@@ -75,6 +75,10 @@
           ((
             x: x,
             y: y,
+            y-error: if y-error-keys != none {
+              let err-key = y-error-keys.at(series-index, default: none)
+              if err-key != none {observation.at(err-key, default: 0)}
+            }
           ),)
         }
       )
@@ -86,7 +90,7 @@
     series-data,
     x-key: "x", 
     y-key: "y",
-    y-error-key: none,
+    y-error-key: if y-error-keys != none {"y-error"},
     label-key: label-key,
     bar-width: bar-width,
     bar-style: bar-style,

src/charts/bar/clustered.typ

@@ -8,7 +8,7 @@
   series-data,
   x-key: "x", 
   y-key: "y",
-  y-error-keys: none,
+  y-error-key: none,
   y-offset-key: none,
   label-key: none,
   bar-width: 0.7,
@@ -56,7 +56,7 @@
               axes: axes,
             )
 
-            if y-error-keys != none {
+            if y-error-key != none {
               add.errorbar(
                 data,
                 x-key: x-key,y-key: y-key, y-error-key: y-error-key,

src/charts/bar/plotter.typ

@@ -53,9 +53,9 @@
   axes: ("x", "y"),
   ..plot-args
 ) = {
-  let series-count = y-keys.len()
-  let cluster-width = series-count * bar-width
-  let offsets = (0,)*series-count
+  let cluster-count = data.len()
+  let cluster-width = cluster-count * bar-width
+  let offsets = (0,)*cluster-count
 
   let series-data = ()
 

src/charts/bar/stacked.typ

@@ -1,168 +1,104 @@
+#import "/src/cetz.typ"
+
 /// Clip line-strip in rect
 ///
 /// - points (array): Array of vectors representing a line-strip
 /// - low (vector): Lower clip-window coordinate
 /// - high (vector): Upper clip-window coordinate
+/// - fill (bool): Return fillable shapes
+/// - generate-edge-points (bool): Generate interpolated points on clipped edges
 /// -> array List of line-strips representing the paths insides the clip-window
-#let clipped-paths-rect(points, ctx, fill: false) = {
+#let clipped-paths-rect(points, ctx, fill: false, generate-edge-points: false) = {
   let (low, high) = ctx.clip
   let (min-x, max-x) = (calc.min(low.at(0), high.at(0)),
                         calc.max(low.at(0), high.at(0)))
   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 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
+    }
+  }
 
-    let (x1, y1) = prev
-    let (x2, y2) = pt
+  // 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()))
+  }
 
-    // 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)
+  // 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 = ()
+
+      // If we must generate edge points, take the previous crossing
+      // as source point and interpolate between that and the current one.
+      if generate-edge-points and i > 2 {
+        let (c-index, c-dir, c-pt) = crossings.at(i - 2)
+
+        let n = a-index - c-index
+        if n > 1 {
+          path += range(0, n).map(t => {
+            cetz.vector.lerp(c-pt, a-pt, t / (n - 1))
+          })
         }
       }
-      was-inside = false
-      continue
-    }
 
-    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)
-          }
-        }
-      }
+      // Append the path insides the bounds
+      path.push(a-pt)
+      path += points.slice(a-index, b-index)
+      path.push(b-pt)
 
-      if path.len() > 0 and not fill {
-        paths = append-path(paths, path)
-        path = ()
+      // Insert the last end point to connect
+      // to a filled area.
+      if fill and paths.len() > 0 {
+        path.insert(0, paths.last().last())
       }
-    }
-    
-    was-inside = is-inside
-  }
 
-  // Append clamped last point if filling
-  if fill and not in-rect(points.last()) {
-    path.push(clamped-pt(points.last()))
-  }
-
-  if path.len() > 1 {
-    paths = append-path(paths, path)
+      paths.push(path)
+    }
   }
 
   return paths
@@ -181,4 +117,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)