drawable.apply-transform alternative

[Robotechnic]

Hello,

To place an element correctly in my drawing, I use process.many to compute its bounds. It works as I want, but after that, I need to draw the element again, which almost doubles my rendering time. To optimize that, I tried to use drawable.apply-transform to use the drawable output.
The thing is that it doesn't translate the anchors. I searched the code, and it
seems complicated to translate all the anchors.
Is there a way to have the correct anchors and the translation without having to compute the drawing twice?

Here is a skeleton of the code:

#{
let (ctx: cetz-ctx, drawables, bounds) = cetz.process.many(cetz-ctx, molecule)
bounds = cetz.util.revert-transform(cetz-ctx.transform, bounds)

let (translate-x, translate-y) = ...

(
  _ => (
    ctx: cetz-ctx,
    drawables: cetz.drawable.apply-transform(
      cetz.matrix.transform-translate(
        translate-x,
        translate-y,
        0,
      ),
      drawables,
    ),
  ),
)
}

[johannes-wolf]

I can see a use of this and I think process.many should return the nodes in addition.

Here is a hack that works (I hope):

#import "@preview/cetz:0.4.0"
#import "@preview/cetz-plot:0.1.2"

#set page(width: auto, height: auto, margin: 0.6pt)

#let custom(body) = (
  ctx => {
    let old-ctx = ctx
    let (ctx, drawables, bounds) = cetz.process.many(ctx, body)

    let t = cetz.matrix.transform-translate(-4,-2,0)

    // Hack: Find all new & changed nodes and install a new anchor handler.
    //       This is private API and might break with a new release!
    for (name, value) in ctx.nodes {
      if name not in old-ctx.nodes or old-ctx.nodes.at(name) != value {
        let old-anchors = ctx.nodes.at(name).anchors
        ctx.nodes.at(name).anchors = (name) => {
          if name != () {
            cetz.matrix.mul4x4-vec3(t, old-anchors(name))
          } else {
            old-anchors(name)
          }
        }
      }
    }
    
    return (
      ctx: ctx,
      drawables: cetz.drawable.apply-transform(
        t, drawables,
      )
    )
  },
)

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

  custom(circle((3,1), name: "c"))

  for-each-anchor("c", name => {
    circle((), radius: .1)
  })
})

Although, I do not like the search for the changed/new nodes.

[Robotechnic]

I should work in a pinch, but I would prefer not to use a private API.

[johannes-wolf]

Do you have an idea for an API? Maybe add a cetz.process.elements that gives more output? Or a switch add: false that disables adding the elements to the context, so the user can handle them beforehand?

[Robotechnic]

A function like cetz.process.elements that returns the bounding box, the path, and the anchors without adding them to the context seems to be exactly what I need.
I didn't look into other packages that use cetz, but I'm convinced this can help others optimize their code.

[johannes-wolf]

Maybe returning all the names here:

cetz/src/process.typ

Line 44 in 7c03afc

if "anchors" in element {

plus here:

cetz/src/process.typ

Line 89 in 7c03afc

return (ctx: ctx, bounds: bounds, drawables: drawables)

should do the trick. Then you can access ctx.nodes.archors with a list of names. Not sure how else it should work.
Alternative is returning a list of elements instead of names and then adding them to the ctx.nodes dict by hand…

[Robotechnic]

Returning all the anchors' names should work. But what about the border and path anchors? I suppose that they are not just vec3.

[johannes-wolf]

See my workaround solution on how it works.