Drawing basics: TikZ and CeTZ

coords/coords.tex

% coords.tex: three points on a 1 cm grid, written as an absolute, a relative and a polar coordinate. \report writes
% where TikZ put a named coordinate to the terminal, in centimetres from the origin.
\documentclass[border=4pt]{standalone}
\usepackage{tikz}
\newcommand\report[1]{\path (#1); \pgfgetlastxy{\px}{\py}%
  \typeout{#1 is at (\fpeval{round(\px / 1cm, 2)}, \fpeval{round(\py / 1cm, 2)}) cm}}
\begin{document}
\begin{tikzpicture}
  \draw[help lines] (0,0) grid (4,3);
  \draw[->] (0,0) -- (4.4,0) node[right] {$x$};
  \draw[->] (0,0) -- (0,3.4) node[above] {$y$};
  \coordinate (A) at (2,1);                       % absolute: 2 cm right of the origin, 1 cm up
  \draw[thick] (A) -- ++(1,1.5) coordinate (B);   % relative: from A, 1 cm right and 1.5 cm up
  \coordinate (C) at (60:2);                      % polar: 2 cm from the origin, at 60 degrees
  \draw[dashed] (0,0) -- (C);
  \foreach \p/\where in {A/below right, B/above right, C/above left}
    \fill (\p) circle (1.5pt) node[\where] {\p};
  \report{A}\report{B}\report{C}
\end{tikzpicture}
\end{document}

coords/coords.typ

// coords.typ: the same three points in CeTZ: absolute, relative to the previous point, and polar.
#import "@preview/cetz:0.5.2"
#set page(width: auto, height: auto, margin: 4pt)
#cetz.canvas({
  import cetz.draw: *
  grid((0, 0), (4, 3), stroke: gray + 0.4pt)
  line((0, 0), (4.4, 0), mark: (end: "stealth"))
  content((4.4, 0), $x$, anchor: "west", padding: 3pt)
  line((0, 0), (0, 3.4), mark: (end: "stealth"))
  content((0, 3.4), $y$, anchor: "south", padding: 3pt)
  // Absolute: 2 cm right of the origin, 1 cm up. Relative: from that point, 1 cm right and 1.5 cm up.
  line((2, 1), (rel: (1, 1.5)), stroke: 1.2pt, name: "ab")
  // Polar: 2 cm from the origin, at 60 degrees.
  line((0, 0), (60deg, 2), stroke: (dash: "dashed"), name: "oc")
  for (label, at, side) in (("A", "ab.start", "north-west"), ("B", "ab.end", "south-west"), ("C", "oc.end", "south-east")) {
    circle(at, radius: 0.053, fill: black)
    content(at, label, anchor: side, padding: 3pt)
  }
})

flow/flow-tikz.tex

% flow-tikz.tex: the build loop as a flowchart, each node placed relative to another with the positioning library.
\documentclass[border=4pt]{standalone}
\usepackage{tikz}
\usetikzlibrary{positioning, arrows.meta, shapes.geometric}
% \hgap and \vgap write the distance between two anchors to the terminal, in millimetres, across and down.
\newcommand\hgap[2]{\path (#1); \pgfgetlastxy{\ax}{\ay}\path (#2); \pgfgetlastxy{\bx}{\by}%
  \typeout{#1 to #2: \fpeval{round((\bx - \ax) / 1mm, 1)} mm across}}
\newcommand\vgap[2]{\path (#1); \pgfgetlastxy{\ax}{\ay}\path (#2); \pgfgetlastxy{\bx}{\by}%
  \typeout{#1 to #2: \fpeval{round((\ay - \by) / 1mm, 1)} mm down}}
\begin{document}
\begin{tikzpicture}[
    node distance=6mm and 12mm,
    >={Stealth},
    box/.style={draw, rounded corners, minimum width=28mm, minimum height=7mm},
    test/.style={draw, diamond, aspect=2.2, inner sep=1pt}]
  \node[box] (write) {Write the source};
  \node[box, below=of write] (compile) {Compile};
  \node[test, below=of compile] (errors) {Errors?};
  \node[box, right=of errors] (fix) {Fix the first error};
  \node[box, below=of errors] (pdf) {Read the PDF};
  \draw[->] (write) -- (compile);
  \draw[->] (compile) -- (errors);
  \draw[->] (errors) -- node[above] {yes} (fix);
  \draw[->] (fix) |- (compile);
  \draw[->] (errors) -- node[right] {no} (pdf);
  \vgap{write.south}{compile.north}
  \hgap{errors.east}{fix.west}
\end{tikzpicture}
\end{document}

flow/flow-long.tex

% flow-long.tex: flow-tikz.tex with a longer label in the node on the right.
\documentclass[border=4pt]{standalone}
\usepackage{tikz}
\usetikzlibrary{positioning, arrows.meta, shapes.geometric}
% \hgap and \vgap write the distance between two anchors to the terminal, in millimetres, across and down.
\newcommand\hgap[2]{\path (#1); \pgfgetlastxy{\ax}{\ay}\path (#2); \pgfgetlastxy{\bx}{\by}%
  \typeout{#1 to #2: \fpeval{round((\bx - \ax) / 1mm, 1)} mm across}}
\newcommand\vgap[2]{\path (#1); \pgfgetlastxy{\ax}{\ay}\path (#2); \pgfgetlastxy{\bx}{\by}%
  \typeout{#1 to #2: \fpeval{round((\ay - \by) / 1mm, 1)} mm down}}
\begin{document}
\begin{tikzpicture}[
    node distance=6mm and 12mm,
    >={Stealth},
    box/.style={draw, rounded corners, minimum width=28mm, minimum height=7mm},
    test/.style={draw, diamond, aspect=2.2, inner sep=1pt}]
  \node[box] (write) {Write the source};
  \node[box, below=of write] (compile) {Compile};
  \node[test, below=of compile] (errors) {Errors?};
  \node[box, right=of errors] (fix) {Fix the first error in the log};
  \node[box, below=of errors] (pdf) {Read the PDF};
  \draw[->] (write) -- (compile);
  \draw[->] (compile) -- (errors);
  \draw[->] (errors) -- node[above] {yes} (fix);
  \draw[->] (fix) |- (compile);
  \draw[->] (errors) -- node[right] {no} (pdf);
  \vgap{write.south}{compile.north}
  \hgap{errors.east}{fix.west}
\end{tikzpicture}
\end{document}

flow/flow-abs.tex

% flow-abs.tex: the same flowchart with every node placed at a coordinate of its own, and the longer label on the right.
\documentclass[border=4pt]{standalone}
\usepackage{tikz}
\usetikzlibrary{arrows.meta, shapes.geometric}
% \hgap and \vgap write the distance between two anchors to the terminal, in millimetres, across and down.
\newcommand\hgap[2]{\path (#1); \pgfgetlastxy{\ax}{\ay}\path (#2); \pgfgetlastxy{\bx}{\by}%
  \typeout{#1 to #2: \fpeval{round((\bx - \ax) / 1mm, 1)} mm across}}
\newcommand\vgap[2]{\path (#1); \pgfgetlastxy{\ax}{\ay}\path (#2); \pgfgetlastxy{\bx}{\by}%
  \typeout{#1 to #2: \fpeval{round((\ay - \by) / 1mm, 1)} mm down}}
\begin{document}
\begin{tikzpicture}[
    >={Stealth},
    box/.style={draw, rounded corners, minimum width=28mm, minimum height=7mm},
    test/.style={draw, diamond, aspect=2.2, inner sep=1pt}]
  \node[box] (write) at (0, 0) {Write the source};
  \node[box] (compile) at (0, -1.3) {Compile};
  \node[test] (errors) at (0, -2.7) {Errors?};
  \node[box] (fix) at (4.2, -2.7) {Fix the first error in the log};
  \node[box] (pdf) at (0, -4.1) {Read the PDF};
  \draw[->] (write) -- (compile);
  \draw[->] (compile) -- (errors);
  \draw[->] (errors) -- node[above] {yes} (fix);
  \draw[->] (fix) |- (compile);
  \draw[->] (errors) -- node[right] {no} (pdf);
  \vgap{write.south}{compile.north}
  \hgap{errors.east}{fix.west}
\end{tikzpicture}
\end{document}

flow/flow-cetz.typ

// flow-cetz.typ: the build loop in CeTZ. Each node after the first is placed from an anchor of another node, as TikZ's
// positioning library does: (rel: (0, -0.6), to: "write.south") is 6 mm below the bottom of "write", and
// anchor: "north" puts the top of the new node there.
#import "@preview/cetz:0.5.2"
#set page(width: auto, height: auto, margin: 4pt)
#set text(size: 10pt)
#cetz.canvas({
  import cetz.draw: *
  set-style(content: (frame: "rect", padding: (x: 8pt, y: 5pt)), mark: (end: "stealth", fill: black, scale: 0.6))
  // The question in a diamond: the text, then a closed line through four points around it, grouped under one name
  // so that the group's anchors (north, east, south, west) are the diamond's corners.
  let diamond(below, name, body) = group(name: name, {
    content((rel: (0, -0.95), to: below), body, frame: none, name: "text")
    line(
      (rel: (-0.45, 0), to: "text.west"), (rel: (0, 0.35), to: "text.north"),
      (rel: (0.45, 0), to: "text.east"), (rel: (0, -0.35), to: "text.south"),
      close: true, mark: none,
    )
  })
  content((0, 0), [Write the source], name: "write")
  content((rel: (0, -0.6), to: "write.south"), [Compile], anchor: "north", name: "compile")
  diamond("compile.south", "errors", [Errors?])
  content((rel: (1.2, 0), to: "errors.east"), [Fix the first error], anchor: "west", name: "fix")
  content((rel: (0, -0.6), to: "errors.south"), [Read the PDF], anchor: "north", name: "pdf")
  line("write", "compile")
  line("compile", "errors")
  line("errors", "fix", name: "yes")
  content("yes.mid", [yes], anchor: "south", frame: none, padding: 3pt)
  line("fix.north", ("fix.north", "|-", "compile.east"), "compile.east")
  line("errors", "pdf", name: "no")
  content("no.mid", [no], anchor: "west", frame: none, padding: 3pt)
})

export/report.tex

% report.tex: a tagged report that includes the cropped flowchart PDF made from flow-tikz.tex, with alternative text.
% Build it with LuaLaTeX.
\DocumentMetadata{lang=en, tagging=on}
\documentclass{article}
\usepackage{graphicx}
\begin{document}
\section{How to build}
Figure~\ref{fig:loop} shows the loop of writing, compiling and fixing.
\begin{figure}[ht]
  \centering
  \includegraphics[alt={Flowchart: write the source, compile, and if there are errors fix the first one and compile
    again; with no errors, read the PDF.}]{flow-tikz.pdf}
  \caption{The build loop.}\label{fig:loop}
\end{figure}
\end{document}

tags.py

"""Prints the structure tree that `pdfinfo -struct-text` reads from a tagged PDF, given on standard input, in short:
one line per tag, indented as in the tree, with the alternative text of a Figure in square brackets and the text of
the tag in quotes. The numbers poppler gives each tag, its attributes, its references to link annotations and its empty
text runs are left out.

  pdfinfo -struct-text report.pdf | python3 tags.py
"""
import re
import sys

tags = []  # [depth, tag, alt, text]
# pdfinfo prints some titles as raw UTF-16 bytes; they are not text a reader hears, so they are dropped.
for raw in sys.stdin.buffer.read().decode("utf-8", errors="replace").splitlines():
    body = raw.lstrip(" ")
    depth = (len(raw) - len(body)) // 2
    if not body or body.startswith("/") or body.startswith("Syntax") or body.startswith("Object "):
        continue
    if body.startswith('"'):
        text = body.strip().strip('"').strip()
        # A run of text belongs to the nearest tag above it that is less indented.
        owner = next((t for t in reversed(tags) if t[0] < depth), None)
        if text and owner:
            owner[3] = (owner[3] + " " + text).strip()
        continue
    match = re.match(r"(\w+)(?: <[^>]*>)?(?: \[\"(.*)\"\])?", body)
    if match:
        tags.append([depth, match.group(1), (match.group(2) or "").strip(), ""])

if not tags:
    print("no structure tree: the PDF is not tagged")
for depth, tag, alt, text in tags:
    line = "  " * depth + tag
    if tag == "Figure":
        line += f" [{alt}]" if alt else " (no alternative text)"
    if text:
        line += f' "{text}"'
    print(line)

alt/alt.tex

% alt.tex: the same small drawing twice in a tagged PDF, first without alternative text, then with the alt key that
% the tagging code defines for tikzpicture. Build it with LuaLaTeX.
\DocumentMetadata{lang=en, tagging=on}
\documentclass{article}
\usepackage{tikz}
\usetikzlibrary{positioning, arrows.meta}
\begin{document}
\section{Build loop}
Text before.
\begin{tikzpicture}[>={Stealth}, node distance=8mm]
  \node[draw] (w) {Write};
  \node[draw, right=of w] (c) {Compile};
  \draw[->] (w) -- (c);
\end{tikzpicture}
Text between.
\begin{tikzpicture}[>={Stealth}, node distance=8mm, alt={Flowchart: Write leads to Compile.}]
  \node[draw] (w) {Write};
  \node[draw, right=of w] (c) {Compile};
  \draw[->] (w) -- (c);
\end{tikzpicture}
Text after.
\end{document}

alt/alt.typ

// alt.typ: the same small drawing twice, first as a bare canvas, then in a figure with alternative text.
#import "@preview/cetz:0.5.2"
#set document(title: [Build loop])
#set text(lang: "en")
#let loop = cetz.canvas({
  import cetz.draw: *
  content((0, 0), [Write], name: "w", frame: "rect", padding: 4pt)
  content((rel: (0.8, 0), to: "w.east"), [Compile], anchor: "west", name: "c", frame: "rect", padding: 4pt)
  line("w", "c", mark: (end: "stealth", fill: black))
})
= Build loop
Text before.
#loop
Text between.
#figure(loop, alt: "Flowchart: Write leads to Compile.", caption: [The build loop.])
Text after.