canvas: Support custom coordinate systems

CHANGES.md

@@ -6,8 +6,9 @@
 - Braces are now drawn tapered by default (#828)
 - Brace styling changed, see the documention of `decorations.brace`
 - **BREAKING** Removed support for using ratios as canvas lengths. To get back the removed behavior, wrap your canvas in a `layout(ly => canvas(length: ly.width * <ratio>, ...))`
-- Added support for specifying a baseline offset via `canvas(baseline: <coordinate>, ...)`. The canvas switches to an inline `box` as the top-level element if set.
+- Added support for specifying a baseline offset via `canvas(baseline: <coordinate>, ...)`. The canvas switches to an inline `box` as the top-level element if set
 - Added support for passing a stroke style to the canvas top-level element, see `canvas(stroke: <stroke>, ...)`
+- Added support for user-defined coordinate systems. See `register-coordinate-resolver(<callback>)`
 
 # 0.3.4
 - Fixed a bug with rendering curves with Typst 0.13.1

src/canvas.typ

@@ -62,6 +62,8 @@
       mnemonics: (:),
       marks: (:),
     ),
+    // coordinate resolver
+    resolve-coordinate: none,
     // Shared state that is not scoped by group/scope elements.
     // CeTZ itself does not use this dictionary for data.
     shared-state: (:),

src/coordinate.typ

@@ -251,7 +251,7 @@
 /// Figures out what system a coordinate belongs to and returns the corresponding string.
 /// - c (coordinate): The coordinate to find the system of.
 /// -> str
-#let resolve-system(c) = {
+#let resolve-system(ctx, c) = {
   let t = if type(c) == dictionary {
     let keys = c.keys()
     let len = c.len()
@@ -294,6 +294,9 @@
     } else {
       "element"
     }
+  } else if ctx.at("resolve-system", default: none) != none {
+    ctx.resolve-system = none
+    resolve-system(ctx, c)
   }
 
   if t == none {
@@ -319,10 +322,20 @@
 /// - update (bool): Update the context's last position
 /// -> array
 #let resolve(ctx, ..coordinates, update: true) = {
+  let resolver = if type(ctx.resolve-coordinate) == array {
+    ctx.resolve-coordinate
+  } else {
+    ()
+  }
+
   let result = ()
   for c in coordinates.pos() {
-    let t = resolve-system(c)
-    let out = if t == "xyz" {
+    for i in range(1, resolver.len() + 1) {
+      c = (resolver.at(resolver.len() - i))(ctx, c)
+    }
+
+    let t = resolve-system(ctx, c)
+    c = if t == "xyz" {
       resolve-xyz(c)
     } else if t == "previous" {
       ctx.prev.pt
@@ -348,9 +361,10 @@
     }.map(util.resolve-number.with(ctx))
 
     if update {
-      ctx.prev.pt = out
+      ctx.prev.pt = c
     }
-    result.push(out)
+
+    result.push(c)
   }
 
   return (ctx, ..result)

src/draw.typ

@@ -3,4 +3,4 @@
 #import "draw/styling.typ": set-style, fill, stroke, register-mark
 #import "draw/shapes.typ": circle, circle-through, arc, arc-through, mark, line, grid, content, rect, bezier, bezier-through, catmull, hobby, merge-path, polygon, multi-path
 #import "draw/projection.typ": ortho, on-xy, on-xz, on-yz
-#import "draw/util.typ": assert-version
+#import "draw/util.typ": assert-version, register-coordinate-resolver

src/draw/grouping.typ

@@ -380,7 +380,6 @@
   assert(name != none and name != "" and not name.starts-with("."),
     message: "Anchors must not be none, \"\" or start with \".\"!")
 
-  coordinate.resolve-system(position)
   return (ctx => {
     let (ctx, position) = coordinate.resolve(ctx, position)
     position = util.apply-transform(ctx.transform, position)

src/draw/shapes.typ

@@ -133,8 +133,6 @@
   assert.eq(style.pos(), (), message: "Unexpected positional arguments: " + repr(style.pos()))
   style = style.named()
 
-  (a, b, c).map(coordinate.resolve-system)
-
   return (ctx => {
     let (ctx, a, b, c) = coordinate.resolve(ctx, a, b, c)
 
@@ -237,9 +235,6 @@
   )
   let style = style.named()
 
-  // Coordinate check
-  let t = coordinate.resolve-system(position)
-
   let start-angle = if start == auto { stop - delta } else { start }
   let stop-angle = if stop == auto { start + delta } else { stop }
   // Border angles can break if the angle is 0.
@@ -462,8 +457,6 @@
     to = ((rel: (to, 1), to: from))
   }
 
-  (from, to).map(coordinate.resolve-system)
-
   return (ctx => {
     let (ctx, ..pts) = coordinate.resolve(ctx, from, to)
     let style = styles.resolve(ctx.style, merge: style, root: "mark")
@@ -523,9 +516,6 @@
 
   assert(pts.len() >= 2, message: "Line must have a minimum of two points")
 
-  // Coordinate check
-  let pts-system = pts.map(coordinate.resolve-system)
-
   // Find the intersection between line a-b next to b
   // if no intersection could be found, return a.
   let element-line-intersection(ctx, elem, a, b) = {
@@ -551,6 +541,7 @@
   return (ctx => {
     let first-elem = pts.first()
     let last-elem = pts.last()
+    let pts-system = pts.map(coordinate.resolve-system.with(ctx))
     let (ctx, ..pts) = coordinate.resolve(ctx, ..pts)
 
     // If the first/last element, test for intersection
@@ -622,8 +613,6 @@
 /// *Root*: `polygon`
 /// - radius (number) = 1: Radius of the polygon
 #let polygon(origin, sides, angle: 0deg, name: none, anchor: none, ..style) = {
-  coordinate.resolve-system(origin)
-
   assert(type(sides) == int and sides >= 3,
     message: "Invalid number of sides: " + repr(sides))
 
@@ -708,8 +697,6 @@
 /// ## Anchors
 ///   Supports border anchors.
 #let grid(from, to, name: none, ..style) = {
-  (from, to).map(coordinate.resolve-system)
-
   assert.eq(style.pos(), (), message: "Unexpected positional arguments: " + repr(style.pos()))
   style = style.named()
 
@@ -859,16 +846,6 @@
     panic("Expected 2 or 3 positional arguments, got " + str(args.len()))
   }
 
-  coordinate.resolve-system(a)
-
-  if b != auto {
-    coordinate.resolve-system(b)
-  }
-
-  if type(angle) != typst-angle {
-    coordinate.resolve-system(angle)
-  }
-
   return (ctx => {
     let body = body
     let style = styles.resolve(ctx.style, merge: style, root: "content")
@@ -1114,9 +1091,6 @@
 ///   Supports border and path anchors. It's default is the `"center"` anchor.
 ///
 #let rect(a, b, name: none, anchor: none, ..style) = {
-  // Coordinate check
-  let t = (a, b).map(coordinate.resolve-system)
-
   // No extra positional arguments from the style sink
   assert.eq(
     style.pos(),
@@ -1320,9 +1294,6 @@
   )
   let coordinates = (start, ..ctrl, end)
 
-  // Coordinates check
-  let t = coordinates.map(coordinate.resolve-system)
-
   return (
     ctx => {
       let (ctx, start, ..ctrl, end) = coordinate.resolve(ctx, ..coordinates)
@@ -1423,8 +1394,6 @@
 
   assert(pts.len() >= 2, message: "Catmull-rom curve requires at least two points. Got " + repr(pts.len()) + "instead.")
 
-  pts.map(coordinate.resolve-system)
-
   return (ctx => {
     let (ctx, ..pts) = coordinate.resolve(ctx, ..pts)
     let style = styles.resolve(ctx.style, merge: style, root: "catmull")
@@ -1497,8 +1466,6 @@
 
   assert(pts.len() >= 2, message: "Hobby curve requires at least two points. Got " + repr(pts.len()) + "instead.")
 
-  pts.map(coordinate.resolve-system)
-
   return (ctx => {
     let (ctx, ..pts) = coordinate.resolve(ctx, ..pts)
     let style = styles.resolve(ctx.style, merge: style, root: "hobby")

src/draw/transformations.typ

@@ -225,8 +225,6 @@
 ///
 /// - pt (coordinate): The coordinate to move to.
 #let move-to(pt) = {
-  let t = coordinate.resolve-system(pt)
-
   return (ctx => {
     let (ctx, pt) = coordinate.resolve(ctx, pt)
     return (ctx: ctx)
@@ -246,8 +244,6 @@
 /// - bounds (vector): Viewport bounds vector that describes the inner width,
 ///   height and depth of the viewport
 #let set-viewport(from, to, bounds: (1, 1, 1)) = {
-  (from, to).map(coordinate.resolve-system)
-
   return (ctx => {
     let bounds = vector.as-vec(bounds, init: (1, 1, 1))
 

src/draw/util.typ

@@ -18,3 +18,41 @@
     return (ctx: ctx)
   },)
 }
+
+/// Push a custom coordinate resolve function to the list of coordinate
+/// resolvers. This resolver is scoped to the current context scope!
+///
+/// A coordinate resolver must be a function of the format `(context, coordinate) => coordinate`. And must _always_ return a valid coordinate or panic, in case of an error.
+///
+/// If multiple resolvers are registered, coordinates get passed through all
+/// resolvers in reverse registering order. All coordinates get paased to cetz'
+/// default coordinate resolvers.
+///
+/// ```typc example
+/// register-coordinate-resolver((ctx, c) => {
+///   if type(c) == dictionary and "log" in c {
+///     c = c.log.map(n => calc.log(n, base: 10))
+///   }
+///   return c
+/// })
+///
+/// circle((log: (10, 0)), radius: .25)
+/// circle((log: (100, 0)), radius: .25)
+/// circle((log: (1000, 0)), radius: .25)
+/// ```
+///
+/// - resolver (function): The resolver function, taking a context and a single coordinate and returning a single coordinate
+#let register-coordinate-resolver(resolver) = {
+  assert.eq(type(resolver), function,
+    message: "Coordinate resolver must be of type function (ctx, coordinate) => coordinate.")
+
+  return (ctx => {
+    if type(ctx.resolve-coordinate) == array {
+      ctx.resolve-coordinate.push(resolver)
+    } else {
+      ctx.resolve-coordinate = (resolver,)
+    }
+
+    return (ctx: ctx)
+  },)
+}

src/lib/decorations/brace.typ

@@ -248,12 +248,7 @@
   name: none,
   ..style,
 ) = {
-  import draw: *
-
-  // Validate coordinates
-  let _ = (start, end).map(coordinate.resolve-system)
-
-  group(name: name, ctx => {
+  draw.group(name: name, ctx => {
     // Get styles and validate their types and values
     let style = styles.resolve(ctx.style, merge: style.named(),
       root: "flat-brace", base: flat-brace-default-style)
@@ -314,8 +309,8 @@
     // all the following code assumes the brace to start at (0, 0), growing to the right,
     // pointing upwards, so we set the origin and rotate the entire group accordingly
     let (_, start, end) = coordinate.resolve(ctx, start, end)
-    set-origin(start)
-    rotate(vector.angle2(start, end))
+    draw.set-origin(start)
+    draw.rotate(vector.angle2(start, end))
 
     // we achieve flipping by inverting the amplitude
     if flip {
@@ -365,23 +360,23 @@
     let crc = (middle +      inner-curves.at(3)  * ri, (1 - inner-curves.at(2) / 2) * amplitude)
     let brc = (length -      outer-curves.at(3)  * ro,      outer-curves.at(2) / 2  * amplitude)
 
-    merge-path({
-      bezier(a, d, alc, dlc)
-      bezier(e, c, elc, clc)
-      bezier(c, f, crc, frc)
-      bezier(g, b, grc, brc)
+    draw.merge-path({
+      draw.bezier(a, d, alc, dlc)
+      draw.bezier(e, c, elc, clc)
+      draw.bezier(c, f, crc, frc)
+      draw.bezier(g, b, grc, brc)
     }, stroke: style.stroke, fill: style.fill)
 
     // Define some named anchors
-    anchor("spike", c)
-    anchor("content", h)
-    anchor("start", a)
-    anchor("end", b)
-    anchor("default", (d, 50%, g))
+    draw.anchor("spike", c)
+    draw.anchor("content", h)
+    draw.anchor("start", a)
+    draw.anchor("end", b)
+    draw.anchor("default", (d, 50%, g))
 
     // Define anchors for all points
     for (name, point) in points {
-      anchor(name, point)
+      draw.anchor(name, point)
     }
   })
 

tests/coordinate/custom/test.typ

@@ -0,0 +1,26 @@
+#set page(width: auto, height: auto)
+#import "/src/lib.typ": *
+#import "/tests/helper.typ": *
+
+#test-case({
+  import draw: *
+  grid((-2,-1), (7,1), stroke: gray)
+
+  let log-resolver(ctx, coordinate) = {
+    if type(coordinate) == dictionary and "log" in coordinate {
+      coordinate = coordinate.log
+      coordinate = coordinate.map(n => calc.log(calc.max(n, util.float-epsilon), base: 10))
+    }
+
+    return coordinate
+  }
+
+  register-coordinate-resolver(log-resolver)
+
+  set-style(circle: (radius: .1))
+  for i in (.1, 1, 10, 100, 1000, 10000) {
+    let pt = (log: (i * 1, 1))
+    circle(pt)
+    content(pt, repr(i), anchor: "north", padding: (top: .5))
+  }
+})