Merge pull request #107 from deffi/segment-relative-positions

Add support for label-pos: (segment, position)

Author: Jollywatt

README.src.md

@@ -42,6 +42,7 @@ Pull requests are most welcome!
 - Added `brace`, `bracket`, `paren` and `stretched-glyph` node shapes (#99).
 - Fix bug with anchors of absolutely-positioned enclose nodes (#95).
 - Fix some instabilities with edges related to division by zero (#100, #105).
+- Allow specifying label positions as `(segment, position)` 
 
 ### 0.5.7
 

docs/manual.pdf

@@ -102,8 +102,8 @@
 ///   the edge in $x y$ coordinates.
 #let place-edge-label-on-curve(edge, curve, debug: 0) = {
 
-	let curve-point = curve(edge.label-pos)
-	let curve-point-ε = curve(edge.label-pos + 1e-3%)
+	let curve-point = curve(edge.label-pos.position)
+	let curve-point-ε = curve(edge.label-pos.position + 1e-3%)
 
 	let θ = wrap-angle-180(angle-between(curve-point, curve-point-ε))
 	let θ-normal = θ + if edge.label-side == right { +90deg } else { -90deg }
@@ -244,7 +244,11 @@
 	}
 
 	// Draw label
-	if edge.label != none {
+	// This edge only has a single segment, so don't draw the label unless it's 
+	// placed on segment 0. This means that when calling this function for the
+	// individual segments of an edge (`draw-edge-polyline`), the `segment` field
+	// of `label-pos` must be set to 0.
+	if edge.label != none and edge.label-pos.segment == 0 {
 
 		// Choose label anchor based on edge direction,
 		// preferring to place labels above the edge
@@ -308,7 +312,7 @@
 	}
 
 	// Draw label
-	if edge.label != none {
+	if edge.label != none and edge.label-pos.segment == 0 {
 
 		if edge.label-side == auto {
 			// Choose label side to be on outside of arc
@@ -499,9 +503,15 @@
 			mark
 		}).filter(mark => mark.pos != none)
 
-		let label-pos = lerp-scale(edge.label-pos, i)
-		let label-options = if label-pos == none { (label: none) }
-		else { (label-pos: label-pos, label: edge.label) }
+		// If the current segment is the one where the label is placed, keep the
+		// label (but change its segment to 0 because `draw-edge-line` will consider
+		// this segment a single-segment edge and only draw labels on segment 0).
+		// Otherwise, draw no label.
+		let label-options = if i == edge.label-pos.segment {
+			(label-pos: edge.label-pos + (segment: 0), label: edge.label)
+		} else {
+			(label: none)
+		}
 
 
 		draw-edge-line(

src/draw.typ

@@ -322,8 +322,6 @@
 
 
 
-
-
 /// Draw a connecting edge in a diagram.
 ///
 ///
@@ -429,13 +427,13 @@
 ///    - roughly above the connector, in the case of straight lines; or
 ///    - on the outside of the curve, in the case of arcs.
 ///
-/// - label-pos (float, ratio, relative length): Position of the label along the
+/// - label-pos (float, ratio, relative length, array): Position of the label along the
 ///   edge, from the start to end.
 ///
 ///   A number or ratio between zero and one is interpreted as a fraction of the
 ///   edge length. Physical and relative relative lengths work too. For example,
 ///   `100% - 1em` means `1em` from the end.
-///
+/// 
 ///   #stack(
 ///   	dir: ltr,
 ///   	spacing: 1fr,
@@ -448,6 +446,12 @@
 ///   For `"poly"` edges (see @edge-types), a number does not specify a fraction
 ///   of the path length; instead, the $k$th vertex is at position $k/n$ where
 ///   $n$ is the number of vertices. Each midpoint is then at $k/n + 0.5$.
+/// 
+///   As an alternative, the position can be specified by an array
+///   `(segment, position)`, where `segment` is an integer that indicates which
+///   segment the label is placed on (segment $s$ is the one between vertices
+///   $s$ and $s+1$). `position` is then relative to the specified segment; the
+///   segment midpoint is at `(s, 50%)`.
 ///
 /// - label-sep (length): Separation between the connector and the label anchor.
 ///
@@ -787,7 +791,7 @@
 	let options = (
 		vertices: vertices,
 		label: label,
-		label-pos: as-relative(label-pos),
+		label-pos: label-pos,
 		label-sep: label-sep,
 		label-angle: label-angle,
 		label-anchor: label-anchor,
@@ -835,8 +839,6 @@
 	}
 	options.vertices = options.vertices.map(interpret-coord-str)
 
-
-
 	if options.label-side not in (left, center, right, auto) {
 		error("`label-side` must be one of `left`, `center`, `right`, or `auto`; got #0.", options.label-side)
 	}
@@ -867,11 +869,60 @@
 
 
 
+// Convert to `(segment, pos)`, where `segment` is an `int` and `pos` is a
+// `relative`. `pos` is relative to segment `segment`.
+// 
+// Possible inputs:
+//   * `(segment, pos)`, where `segment` is an int and `pos` is accepted by
+//     `as-relative`. `pos` will be interpreted as relative to segment
+//     `segment`.
+//   * `pos`, where `pos` is accepted by `as-relative`. `pos` will be
+//     interpreted as relative to the whole edge.
+#let normalize-position(position, n-segments) = {
+	if type(position) == array and type(position.at(0)) == int {
+		// Segment specified
+		(
+			segment: position.at(0),
+			position: as-relative(position.at(1)),
+		)
+
+	} else {
+		// No segment specified
+		position = as-relative(position)
+		position = position.ratio * n-segments + position.length
+
+		// Which segment does the position refer to?
+		// Use ceil-1 instead of floor to put positions that fall on the boundary
+		// between two segment on the end of the first, not the beginning of the
+		// second. There's no particular reason to do it like this, other than
+		// compatibility.
+		let segment = calc.ceil(float(position.ratio)) - 1
+		if segment < 0 { segment = 0 }
+		if segment > n-segments - 1 { segment = n-segments - 1 }
+
+		// Make the position relative to the selected segment. This applies only to
+		// the `ratio` part of the `relative` position, not to the `length` part.
+		let position = (position.ratio - 100% * segment) + position.length
+
+		(segment: segment, position: position)
+	}
+}
+
+
+
 #let resolve-edge-options(edge, options) = {
 	// let to-pt(len) = to-abs-length(len, options.em-size)
 
 	edge += interpret-marks-arg(edge.marks)
 
+	// Determine the number of segments
+	let n-segments = edge.vertices.len() - 1
+	if edge.corner != none { n-segments += 1 }
+
+	// Now that we know the number of segments, we can normalize the label
+	// positions
+	edge.label-pos = normalize-position(edge.label-pos, n-segments)
+
 	if edge.stroke == none {
 		// hack: for no stroke, it's easier to do the following.
 		// then we have the guarantee that edge.stroke is actually

src/edge.typ

@@ -0,0 +1,74 @@
+#set page(width: auto, height: auto, margin: 1em)
+#import "/src/edge.typ": normalize-position
+
+// this test contains no visual output
+#show: none
+
+#let assert-position-almost-equal(a, b) = {
+  a.position = a.position + 0pt + 0%
+  b.position = b.position + 0pt + 0%
+
+  let dl = calc.abs(a.position.length - b.position.length)
+  let dr = calc.abs(a.position.ratio - b.position.ratio)
+
+  assert(a.segment == b.segment
+    and dl < 1e-3pt
+    and dr < 1e-3%
+  , message: repr(a) + " != " + repr(b))
+}
+
+= `normalize-position`
+
+== Odd number of segments
+
+#assert-position-almost-equal(normalize-position(-10%, 5), (segment: 0, position: -50%))
+#assert-position-almost-equal(normalize-position(0%, 5), (segment: 0, position: 0%))
+#assert-position-almost-equal(normalize-position(10%, 5), (segment: 0, position: 50%))
+#assert-position-almost-equal(normalize-position(20%, 5), (segment: 0, position: 100%))
+#assert-position-almost-equal(normalize-position(30%, 5), (segment: 1, position: 50%))
+#assert-position-almost-equal(normalize-position(40%, 5), (segment: 1, position: 100%))
+#assert-position-almost-equal(normalize-position(50%, 5), (segment: 2, position: 50%))
+#assert-position-almost-equal(normalize-position(60%, 5), (segment: 2, position: 100%))
+#assert-position-almost-equal(normalize-position(70%, 5), (segment: 3, position: 50%))
+#assert-position-almost-equal(normalize-position(80%, 5), (segment: 3, position: 100%))
+#assert-position-almost-equal(normalize-position(90%, 5), (segment: 4, position: 50%))
+#assert-position-almost-equal(normalize-position(100%, 5), (segment: 4, position: 100%))
+#assert-position-almost-equal(normalize-position(110%, 5), (segment: 4, position: 150%))
+
+== Even number of segments
+
+#assert-position-almost-equal(normalize-position(-10%, 4), (segment: 0, position: -40%))
+#assert-position-almost-equal(normalize-position(0%, 4), (segment: 0, position: 0%))
+#assert-position-almost-equal(normalize-position(10%, 4), (segment: 0, position: 40%))
+#assert-position-almost-equal(normalize-position(20%, 4), (segment: 0, position: 80%))
+#assert-position-almost-equal(normalize-position(30%, 4), (segment: 1, position: 20%))
+#assert-position-almost-equal(normalize-position(40%, 4), (segment: 1, position: 60%))
+#assert-position-almost-equal(normalize-position(50%, 4), (segment: 1, position: 100%))
+#assert-position-almost-equal(normalize-position(60%, 4), (segment: 2, position: 40%))
+#assert-position-almost-equal(normalize-position(70%, 4), (segment: 2, position: 80%))
+#assert-position-almost-equal(normalize-position(80%, 4), (segment: 3, position: 20%))
+#assert-position-almost-equal(normalize-position(90%, 4), (segment: 3, position: 60%))
+#assert-position-almost-equal(normalize-position(100%, 4), (segment: 3, position: 100%))
+#assert-position-almost-equal(normalize-position(110%, 4), (segment: 3, position: 140%))
+
+== Different inputs
+
+#assert-position-almost-equal(normalize-position(100%, 5), (segment: 4, position: 100%))
+#assert-position-almost-equal(normalize-position(1, 5), (segment: 4, position: 100%))
+#assert-position-almost-equal(normalize-position(1.0, 5), (segment: 4, position: 100%))
+
+
+== With length
+
+#assert-position-almost-equal(normalize-position(100% + 10pt, 5), (segment: 4, position: 100% + 10pt))
+#assert-position-almost-equal(normalize-position(-10pt, 5), (segment: 0, position: 0% - 10pt))
+
+#assert-position-almost-equal(normalize-position(1em, 5), (segment: 0, position: 0% + 1em))
+#assert-position-almost-equal(normalize-position(10pt - 1em, 5), (segment: 0, position: 0% + 10pt - 1em))
+#assert-position-almost-equal(normalize-position(10% + 10pt - 1em, 5), (segment: 0, position: 50% + 10pt - 1em))
+
+== With segment
+
+#assert-position-almost-equal(normalize-position((3, 27%), 5), (segment: 3, position: 27%))
+// Segment out of range
+#assert-position-almost-equal(normalize-position((5, 27%), 3), (segment: 5, position: 27%))

tests/edge/calculations/test.typ

@@ -0,0 +1,37 @@
+#set page(width: auto, height: auto, margin: 1em)
+#import "/src/exports.typ" as fletcher: diagram, node, edge
+
+#diagram(
+  debug: 0,
+
+  edge-corner-radius: 10pt,
+
+  {
+    for i in (
+      (0, -50%),
+      (0, 0%),
+      (0, 50%),
+      (0, 100%),
+      (0, 150%),
+
+      (1, 50%),
+
+      (2, -0.5),
+      (2, 0),
+      (2, 12pt),
+      (2, 0.25),
+      (2, 0.5),
+      (2, 0.75),
+      (2, 100%-6pt),
+      (2, 100%+6pt),
+
+      (3, 50%),
+    ) {
+      edge((0, 0), "d,drr,ddd", "-}>",
+        [#i],
+        label-side: center,
+        label-pos: i,
+      )
+    }
+  }
+)