Need help with flowchart (compare 2 coordinates, code optimization)

[Andrew15-5]

I'm trying to make a flowchart from scratch, since there is no such library in Typst yet. The first time was a complete failure, as I couldn't use relative and absolute coordinates efficiently. But the second time is actually pretty good, but I still think that there could be a lot of improvements. Right now, I didn't add any functions or logic as to how flowchart elements connect or position. But they all do depend on each other, and I used relative coordinates almost everywhere.

My main concern right now is to how find the lowest of the 2 coordinates in Cartesian coordinate system. I want to put a finish block to the bottom center, but I have 2 branches of different lengths. I need to draw 1 line per branch so that both lines will be parallel and stop at the same height (Y coordinate). Here are my mock-up + how it roughly should look.

2 branches problem source

#import "@preview/cetz:0.1.0"

#figure(cetz.canvas({
  import cetz.draw: *

  let i = counter("i")
  let next = { i.step(); i.display() }

  let h = 2
  let w = h * 1.5
  let l = h / 2

  merge-path({
    arc((h / 4, 0), radius: h / 4, start: 90deg, delta: 180deg)
    arc((w - h / 4, -h / 2), radius: h / 4, start: -90deg, delta: 180deg)
  }, close: true, name: "m")
  content("m.center", next)

  line(
    (rel: (0, 0), to: "m.bottom"),
    (rel: (0, -1), to: "m.bottom"),
    name: "l",
  )

  // rect((0, 0), (w, h), anchor: "top", name: "r")
  // content("r.center", next)
  rect(
    (rel: (-w / 2, -h), to: "l.end"),
    (rel: (w / 2, 0), to: "l.end"),
    name: "r",
  )
  content("r.center", next)

  line(
    (rel: (0, 0), to: "r.bottom"),
    (rel: (0, -1), to: "r.bottom"),
    name: "l",
  )

  rect(
    (rel: (-w / 2, -h), to: "l.end"),
    (rel: (w / 2, 0), to: "l.end"),
    name: "r",
  )
  content("r.center", next)

  line(
    (rel: (0, 0), to: "r.bottom"),
    (rel: (0, -1), to: "r.bottom"),
    name: "l",
  )

  rect(
    (rel: (-w / 2, -h), to: "l.end"),
    (rel: (w / 2, 0), to: "l.end"),
    name: "r",
  )
  content("r.center", next)

  line(
    (rel: (0, 0), to: "r.bottom"),
    (rel: (0, -1), to: "r.bottom"),
    name: "l",
  )

  line(
    (rel: (0, 0), to: "l.end"),
    (rel: (w / 2, -h / 2), to: "l.end"),
    (rel: (0, -h), to: "l.end"),
    (rel: (-w / 2, -h / 2), to: "l.end"),
    close: true,
    name: "d",
  )
  content("d.center", next)

  group(name: "lg", {
    rect((rel: (-w, -h), to: "d.bottom-left"), (rel: (w, h)), name: "r")
    content("r.center", next)

    line(
      (rel: (0, 0), to: "r.bottom"),
      (rel: (0, -1), to: "r.bottom"),
      name: "l",
    )

    rect(
      (rel: (-w / 2, -h), to: "l.end"),
      (rel: (w / 2, 0), to: "l.end"),
      name: "r",
    )
    content("r.center", next + [<l>])
  })
  line("d.left", ("d.left", "-|", "lg.top"), ("lg.top"), name: "l")

  group(name: "rg", {
    rect((rel: (0, -h), to: "d.bottom-right"), (rel: (w, h)), name: "r")
    content("r.center", next + [<r>])
  })
  line("d.right", ("d.right", "-|", "rg.top"), ("rg.top"), name: "l")
}))

The second problem is optimization. I feel that my code can be optimized so that relative positioning and/or line connection would be more natural/universal/smart. In other words, how can I generalize the elements and their connection for easier use in any part of any flowchart. Maybe there is nothing to improve, but I want to hear some thoughts and pointers from someone who is fluent in the library. :)

[johannes-wolf]

For getting the lowest of the two coordinates, you can use a coordinate callback:

#import "@preview/cetz:0.1.0"

#cetz.canvas({
  import cetz.draw: *

  let a = (0,-1)
  let b = (2,-2.1)

  circle(a, name: "a")
  circle(b, name: "b")

  // Return base with y set to min(a.y, b.y)
  let lowest = (base, a, b) => {
    let (x, y, z) = base
    y = calc.min(a.at(1), b.at(1))
    return (x, y, z)
  }

  line("a.bottom", (rel: (0,-1), to: (lowest, (), "a.bottom", "b.bottom")))
  line("b.bottom", (rel: (0,-1), to: (lowest, (), "a.bottom", "b.bottom")))
})

If you pass an array of a function + coordinates as coordinate, the function gets called with all
the coordinates resolved to absolute values.

Your code looks totally fine to me.

[Andrew15-5]

Wow, this looks so simple and yet so confusing! The fact that string actually resolves to an array with normal numbers and I can actually use calc.min() this way kinda mind blowing. Thanks so much for the quick reply. I'll try this out later and maybe ask some questions if I'll have any.

[Andrew15-5]

Yeah, heh, I've missed the Section 4.10. This is super cool stuff. Since the function isn't really called, there is no invalid argument type issues. It took me a while to understand what is base and what exactly the () refers to, but in the end I get it. Apparently the code example you provided is redundant in a way, so I've optimized/simplified it and it also takes fewer arguments:

#import "@preview/cetz:0.1.0"

#cetz.canvas({
  import cetz.draw: *

  let a = (0, -1)
  let b = (2, -2.1)

  circle(a, name: "a")
  circle(b, name: "b")

  // content("a", "a")
  // content("b", "b")

  let lowest(previous, other) = {
    let y = calc.min(previous.at(1), other.at(1))
    (previous.at(0), y, previous.at(2))
  }

  line("a.bottom", (rel: (0, -1), to: (lowest, (), "b.bottom")))
  line("b.bottom", (rel: (0, -1), to: (lowest, (), "a.bottom")))
})

But the namings are the real pain, as in any code. But here previous and other are good enough.

P.S. It's also nice to hear that I already grasped enough knowledge to make a pretty "clean" (optimized) flowchart (on the 2nd try). This also probably means that the library and the Typst themselves are pretty easy to grasp (as all things should be).