API: Render
Figures and tables through PGFPlotsX.
Public names
VisualGeometryToolkitEval.Render — Module
RenderFigure and table rendering through PGFPlotsX: the panel record (PanelSpec), a paper's styling as one value (PaperStyle), the faceted-arm grammar (arm_style), the house axis style (HOUSE_AXIS_COMMON), the shared faceted group-plot emitter (open_faceted_groupplot) and the panel and table emitters (emit_miscal_faceted, emit_basin_faceted, emit_tuning_table), the table-file helpers (fmt3, write_tsv, read_tsv), and a floor plan's station fan (station_cells, write_station_fan, write_station_fan_colorbar).
VisualGeometryToolkitEval.Render.FAMILY_ORDER — Constant
The loss-family facet order, left to right, of every faceted figure and legend.
VisualGeometryToolkitEval.Render.HOUSE_AXIS_COMMON — Constant
HOUSE_AXIS_COMMONThe common axis-option string every NEW (post-ACCV) panel starts from: no grids, plain-number tick labels on log axes, house fonts and legend style. Panel-specific options (labels, limits, modes) are appended after.
VisualGeometryToolkitEval.Render.HOUSE_LINE_WIDTH — Constant
House default line width for curve plots.
VisualGeometryToolkitEval.Render.HOUSE_MARK_SIZE — Constant
House default marker size for curve plots.
VisualGeometryToolkitEval.Render.PANELS — Constant
PANELSThe summary panels, keyed by id: (id, yfn, ylabel, log_y, y_spacing, y_minor_subdiv). y_spacing is the major-tick (labeled) gradation on a linear y-axis (NaN = off); y_minor_subdiv the number of minor ticks BETWEEN majors (0 = none). eR_mean is a legacy id: for E and F the metric is the imc POSE error max(Δrot,Δtrans); a homography's imc is the decomposition's rotation alone (VgtkCore pool_imc on an H pool), so an H panel overrides the label (build_axis(...; ylabel)).
VisualGeometryToolkitEval.Render.PATH_RANK — Constant
The within-family sort rank of each optimization path (arm_style_records' path).
VisualGeometryToolkitEval.Render.PanelSpec — Method
PanelSpec(base::PanelSpec; overrides...) -> PanelSpecCopy base with the given fields replaced (non-mutating derivation, e.g. PanelSpec(spec; xlabel = x_label)).
VisualGeometryToolkitEval.Render.PaperStyle — Type
PaperStyle(; colors = Pair{String,String}[], rows = [], arms = Dict(),
grid, zeta_x, zeta_med_y, zeta_maa_y, med_ylabel, maa_ylabel)A paper's figure style, built once by the paper (accv2026 builds it from its palette, arm table and figure-style blocks) and given as the first argument of every renderer that draws arms or paper colours.
Fields:
colors::Dict{String,String}: colour NAME => hex"RRGGBB"— the paper palette (default_paletteis the house base) plus every arm colour whose record carries a hex; emitted bypaper_color_defs.rows::Vector{Tuple{String,String,String,String,Bool}}: the summary-panel rows ofbuild_axis, in legend order:(method key, display label, colour name, mark, dashed).arms::Dict{String,NamedTuple}: the faceted-arm style records,arm_style_records— family, path, scale, label, colour, hex, marker, dashed, shade.axes::NamedTuple: the paper's axis blocks of the faceted emitters —grid(the grid options spliced into the budget/basin/time panels;""is the house rule, no grid),zeta_x(x block of the ζ panels),zeta_med_y(a function(ymin; ymax, ytick_spacing) -> String, the median row's y block),zeta_maa_y(the mAA row's y block),med_ylabelandmaa_ylabel(the two rows' y labels).
A paper whose figures were frozen at an earlier style (the ACCV panels are byte-compared) supplies those exact blocks here; nothing in this package defaults to them.
VisualGeometryToolkitEval.Render.arm_addplot — Method
arm_addplot(io, color, marker, dashed, coords; line_width = "0.8pt")One per-arm curve: \addplot[<arm_plot_opts>, forget plot] coordinates {<coords>}; (legends are image-only — see arm_legendimage).
VisualGeometryToolkitEval.Render.arm_legendimage — Method
arm_legendimage(io, color, marker, dashed, label;
line_width = "0.8pt", mark_size = nothing)One legend entry: \addlegendimage{color=…, mark=…, mark options={solid,fill=…}, line width=…[, mark size=…][, dashed]}\addlegendentry{…}. The faceted 3×2 panels omit mark size in legend images (historical bytes); the paired layout forwards its plot options (mark_size = "1.6pt").
VisualGeometryToolkitEval.Render.arm_order — Method
arm_order(style, key) -> TupleThe within-facet sort key of arm key of style: its ramp step (shade) when the paper declares one, else its optimization path's rank; then its label.
VisualGeometryToolkitEval.Render.arm_plot_opts — Method
arm_plot_opts(color, marker; dashed = false, line_width = "0.8pt",
mark_size = "1.6pt") -> StringThe shared per-arm plot options: color=…, mark=…, mark options={solid,fill=…}, line width=…, mark size=…[, dashed].
VisualGeometryToolkitEval.Render.arm_record — Method
Full style record (NamedTuple) of arm key of style.
VisualGeometryToolkitEval.Render.arm_style — Method
Style tuple (family, label, color, marker, dashed) of arm key of style.
VisualGeometryToolkitEval.Render.arm_style_records — Method
arm_style_records(probes, table) -> Dict{String,NamedTuple}The faceted-arm style records of a paper, keyed by arm: one record (family, path, scale, label, color, hex, marker, dashed, shade) per arm_key => probe_instance pair of probes (one LO instance per deployed arm; ctor kwargs immaterial, the identity traits are type/variant-level), with table[arm_key] the paper-owned part, (color = …, [hex = …], [shade = …], [scale = …]): the colour NAME, optionally its hex (a PaperStyle defines it under that name), the arm's step on its family's light→dark colour ramp (shade, 1 = lightest; it fixes the within-facet legend/plot order) and an optional scale tag, which must agree with the strategy's scale_interface. family, path, label, marker and dashed (FixedScale ⇒ dashed) DERIVE from the probe's identity traits. Errors on a probe with unspecified identity traits (registry hygiene).
VisualGeometryToolkitEval.Render.budget_curves — Method
budget_curves(files; arms) -> (; budgets, med, maa, oracle_med, oracle_maa, outcomes)The statistics of a budget cell from its per-scene budget files (the scene schema above), for each of arms and the oracle, at every LO checkpoint (budgets = the files' lo_counts; the oracle read off its dense batch grid at those budgets):
med— the mean over scenes of the per-scene finite median (Shekhovtsov's mean-median; a scene without a finite error is skipped);maa— the eligibility-ruled mAA (eligible_maa) POOLED over every pair of every scene — every stored pool pair is eligible, a pair whose run left no model (non-finite error) scores 0.
Every file must carry the same count axes and every one of arms. outcomes[arm] is pair_outcomes at the last checkpoint (why runs fail).
VisualGeometryToolkitEval.Render.build_axis — Method
build_axis(style::PaperStyle, panel, data, tune::String, spec::PanelSpec; ylabel = "")The PGFPlots axis of one (PANELS entry, tuning-criterion label tune): one curve per row of style.rows present in data (load_results). Every display option comes from spec; spec.xlabel === nothing is "Validation set size". ylabel overrides the panel's.
VisualGeometryToolkitEval.Render.color_defs — Function
color_defs(pairs; command = "definecolor") -> StringThe colour-definition emitter: one \<command>{<name>}{HTML}{<hex>} line per name => "RRGGBB" pair, newline-separated (no trailing newline). command is "definecolor" or "providecolor" (idempotent; a host's own definition wins).
VisualGeometryToolkitEval.Render.default_palette — Method
default_palette() -> Vector{Pair{String,String}}The house base palette (name => hex, ordered): the standing selector/ reference colors every paper starts from — RGB-primary "ours" hues (Jeffreys red e6194b, IG-Robust green 3cb44b, IG-MLE blue 4363d8), baselines chosen so none competes with Jeffreys red (RANSAC pastel pink ffb6c1, MSAC yellow ffe119, GaU cyan 42d4f4, MAGSAC++ orange f58231), and the medium-gray Oracle 808080. Per-arm FAMILY shades (Welsch greens / TLS oranges / GM purples — the faceted grammar's hue-= family rule) are paper-assigned on top of this base in the paper's PaperStyle; papers override or extend freely — this table is the documented default, not a constraint.
VisualGeometryToolkitEval.Render.emit_basin_faceted — Method
emit_basin_faceted(style::PaperStyle, bundle, out; row_label = "", succ, deploy,
exclude = Set{String}(), legend_name = "basinlegend",
panels = [(f, panel_title(f)) for f in FAMILY_ORDER],
minsucc = [render] min_success_for_cond_mean, seed_key = "seed",
rows = [:succ, :cond])Emit the δ-perturbation basin faceted groupplot body to out from the ladder bundle (errs [pairs × nδ × nmethod], methods, deltas, refinable). rows selects the statistic per row, in order: :succ — success rate P(e≤succ°); :maa — mAA@succ° under the eligibility rule (eligible_maa: the refinable pairs are the eligible ones, a failed refit — stored as NaN — scores 0); :cond — conditional mean final error given success, masked below success rate minsucc. Success is recomputed at succ degrees; the seed_key method draws as the dashed reference (its success rate, mAA, or unconditional median per row). deploy/exclude/legend_name as in emit_miscal_faceted.
VisualGeometryToolkitEval.Render.emit_budget_faceted_curves — Method
emit_budget_faceted_curves(style::PaperStyle, out; row_label = "", budgets, med, maa,
med_ylabel, legend_name, deploy, xticks = nothing,
maa_ylabel = style.axes.maa_ylabel,
panels = [(f, panel_title(f)) for f in FAMILY_ORDER],
xlabel = raw"sample budget", xlog = true, rows = [:med, :maa],
oracle_med = nothing, oracle_maa = nothing,
oracle_label = "oracle")The objective-faceted accuracy-vs-budget groupplot, from PRECOMPUTED per-arm curves (budget_curves for a budget cell's scene files; the PnP budget's own aggregation): med[arm] (median error, row label med_ylabel) and maa[arm] (mAA@10°) are vectors aligned with budgets; arms are keys of style.arms, and the grid options are style.axes.grid. xlog draws a log₂ budget axis with plain-number ticks at the given budgets (small budget grids such as 5…2000); the y ranges are derived from the curves. oracle_med/oracle_maa (aligned with budgets) draw the oracle reference line when given.
VisualGeometryToolkitEval.Render.emit_budget_time_panel — Method
emit_budget_time_panel(style::PaperStyle, out; row_label = "", budgets, maa, percall_us, legend_name,
xmax, xticks, maamax, panels = [(f, panel_title(f)) for f in FAMILY_ORDER])The COMPUTE-EFFICIENCY companion of a budget panel: mAA (maa[arm], aligned with budgets, from budget_curves) against the cumulative LO time per pair [ms] — at checkpoint j, j × the arm's deterministic single-thread per-call time percall_us[arm] [µs] (one LO per pair per checkpoint). LO cost only: scoring, sampling and termination are shared and excluded (the caption must keep that scoping); the oracle runs no LO and has no curve. xmax / xticks / maamax are the panel's fixed axis constants. Every arm of maa must have a per-call time.
VisualGeometryToolkitEval.Render.emit_lo_timing_table — Method
emit_lo_timing_table(figdir; timedir, arm_rows, dataset_names,
rider_labels, filename = "table_lo_timing.tex")Emit the LO per-call wall-clock table (<figdir>/<filename>) from the lo_timing_*.jld2 files under timedir. arm_rows is the ordered [(display_label, run_tag), …] row table; dataset_names maps dataset tag → display name; rider_labels maps a rider method Symbol (a non-:ig column of a run) → its arm label, nothing to skip. Each run's :ig column is keyed by the run tag itself (the timing driver's tags ARE the base names, so a roster extension cannot silently KeyError this emitter).
VisualGeometryToolkitEval.Render.emit_miscal_faceted — Method
emit_miscal_faceted(style::PaperStyle, sidecar, out; row_label = "", oracle, oracle_maa,
oracle_class = "E", ymin, deploy, ymax = 6, ytick_spacing = 1,
exclude = Set{String}(), legend_name = "miscallegend",
panels = [(f, panel_title(f)) for f in FAMILY_ORDER],
arm_filter = a -> true, rows = [:med, :maa])Emit the ζ-miscalibration faceted groupplot body to out from the tuning artifact sidecar (zetas + evaluation): the per-arm evaluation_curves through emit_miscal_faceted_curves. Rows: median pose error (oracle FLOOR oracle) and mAA@10° (oracle CEILING oracle_maa); the median row's y block is style.axes.zeta_med_y(ymin; ymax, ytick_spacing), ymin its y floor (string, TeX-interpolated), ymax/ytick_spacing its ceiling and tick spacing (default 6°/1°). deploy wraps in a tikzpicture and leaves the legend to the host (\pgfplotslegendfromname{<legend_name>}); exclude drops arm keys from THIS render only; arm_filter restricts the roster (e.g. one scoring selector).
VisualGeometryToolkitEval.Render.emit_miscal_faceted_curves — Method
emit_miscal_faceted_curves(style::PaperStyle, out; zetas, med, maa, deploy, legend_name, rows,
oracle = nothing, oracle_maa = nothing,
oracle_class = "",
x_axis = style.axes.zeta_x,
med_axis = style.axes.zeta_med_y("0.4"),
maa_axis = style.axes.zeta_maa_y,
med_ylabel = style.axes.med_ylabel,
maa_ylabel = style.axes.maa_ylabel,
panels = [(f, panel_title(f)) for f in FAMILY_ORDER],
flat = Set{String}())The objective-faceted ζ groupplot from PRECOMPUTED per-arm curves: med[arm] and maa[arm] are vectors aligned with zetas (NaN = masked point); arms are keys of style.arms, so family, mechanism order, label, color and marker all derive from the style. Arms in flat carry a single value that is drawn as a constant line across zetas (width-free controls). The oracle line spans zetas and is drawn only when oracle is given. Axis blocks default to the style's; supply other blocks for other error scales.
VisualGeometryToolkitEval.Render.emit_miscal_summary_table — Method
emit_miscal_summary_table(style::PaperStyle, path; tracks, stat = :med, exclude = Set{String}(),
arm_filter = a -> true, label = a -> arm_record(style, a).label)The miscalibration summary table of a set of cells, from their sidecars (the same evaluations the faceted panels draw, so table and figure agree by construction). tracks = [(title, [(column_name, sidecar), …]), …]: one booktabs block per track, rows = the union of the track's arms of style in the faceted order, per dataset three columns — calibration, the deflation extreme and the inflation extreme of the ladder — with the best value per column bold (min for :med, max for :maa) and -- where a cell lacks the arm. Returns path.
VisualGeometryToolkitEval.Render.emit_tuning_table — Method
emit_tuning_table(path, out; axes, labels, stage = :coarse, fmt = "%.3f") -> outtuning_slice as a LaTeX tabular written to out: one axis, a two-column curve (value, criterion); two axes, a surface (rows the first axis, columns the second). labels names the axes in the header; fmt formats the axis values. The argmin cell is starred.
VisualGeometryToolkitEval.Render.evaluation_curve — Method
evaluation_curve(evaluation, arm, stat) -> Vector{Float64}One arm's curve over the columns of a deployed evaluation (evaluation[arm], pairs × ζ): stat of each column — finite_median for the median row, eligible_maa for the mAA row (the eligibility rule: every stored pair is eligible, a pair without a model scores 0).
VisualGeometryToolkitEval.Render.faceted_legend_opts — Method
faceted_legend_opts(name; columns = 4) -> StringThe shared legend to name axis-option suffix (prepend to the first cell's \nextgroupplot[...] options): one shared legend drawn by the host via \pgfplotslegendfromname{<name>}.
VisualGeometryToolkitEval.Render.family_of — Method
Loss family (:welsch/:tls/:gm) of arm key of style.
VisualGeometryToolkitEval.Render.family_rank — Method
family_rank(family) -> IntThe facet position of a loss family in FAMILY_ORDER (1 = leftmost); a family outside it ranks after every facet. The facet-walk key of tables and vocabularies that list arms in figure order.
VisualGeometryToolkitEval.Render.fmt3 — Method
fmt3(x; nonfinite = nothing) -> StringA number cell: x with three decimals ("%.3f"). A non-finite x reads as Julia's own spelling ("NaN", "Inf", "-Inf") by default, or as nonfinite (a String) when one is given: a report that collapses every non-finite value to one text gives it as nonfinite.
VisualGeometryToolkitEval.Render.has_arm — Method
Is key a faceted arm of style?
VisualGeometryToolkitEval.Render.house_colors — Function
house_colors(pairs::Vector{<:Pair}) -> String\definecolor block (color_defs) from name => "RRGGBB" pairs, newline-terminated — the one way a house figure loads its color registry (names come from the paper's arm/legend vocabulary; one color per arm).
VisualGeometryToolkitEval.Render.lo_us_per_call — Method
lo_us_per_call(res, m) -> Float64The mean warm LO wall clock per call [µs] of method column m of a budget result (anything carrying lo_ns_total / lo_calls_total per method — a budget engine's result or a run record read back from its sidecar); NaN when the column made no LO call. A pure accessor on persisted data.
VisualGeometryToolkitEval.Render.load_results — Method
load_results(path) -> Dict{Tuple{String,String}, SubDataFrame}Load a results JLD2 carrying a summary DataFrame (the rows Evaluation.compute_method_rows emits — LocalOptimizationDoneRight's plotlosensitivity writes it as summary.jld2) and bucket that summary into one SubDataFrame per (method_key, tuning_criterion) for the PGFPlotsX renderer. Method key strips a trailing (median|mAA) suffix so the style rows' bare keys ("RANSAC") match.
Each sub-DataFrame is sorted by n so downstream rendering can index column vectors directly (s.nn, s.mean_med, s.lo95_mean_med, ...). The bucketing is results_by_method, for a summary already in hand.
VisualGeometryToolkitEval.Render.miscal_summary_rows — Method
miscal_summary_rows(style::PaperStyle, sidecar; stat = :med, exclude = Set{String}(),
arm_filter = a -> true)
-> (arms, rows, zetas)The deployed evaluation of a miscalibration sidecar summarized at three points of its ζ ladder — the deflation extreme, calibration (ζ nearest 1) and the inflation extreme — per arm of style, in the faceted order (facet, then ramp step). stat is :med (finite median of the imc error, deg) or :maa (the eligibility rule, eligible_maa). rows[arm] = (deflation, calibration, inflation); zetas the three ζ values.
VisualGeometryToolkitEval.Render.open_faceted_groupplot — Method
open_faceted_groupplot(io; cols, rows, width, height, opts,
hsep = "6pt", vsep = "12pt", edge_labels = true)Emit the shared groupplot preamble:
\begin{groupplot}[
group style={group size=<cols> by <rows>, horizontal sep=<hsep>[, vertical sep=<vsep>,
xticklabels at=edge bottom, xlabels at=edge bottom]},
scale only axis, width=<width>, height=<height>,
<opts[1]>,
...
<opts[end]>]opts are the remaining option LINES (each printed at 2-space indent; the last gets the closing ]). edge_labels=false drops the edge-tick lines AND the vertical sep (the 1-row paired layout).
VisualGeometryToolkitEval.Render.panel_title — Method
Two-line panel title (TeX) for a loss family.
VisualGeometryToolkitEval.Render.paper_color_defs — Method
paper_color_defs(style::PaperStyle) -> StringThe \providecolor{<name>}{HTML}{<HEX>} block of every colour of style (sorted by colour name, hex upper-cased), through the one colour emitter color_defs — what a standalone preview prepends so it is self-contained for any roster (\providecolor is idempotent and the paper's own definitions win).
VisualGeometryToolkitEval.Render.paper_color_name — Method
paper_color_name(key) -> StringThe LaTeX colour name of a method key: "Color" + the key's alphanumerics (ALL others stripped, so keys with spaces/+ such as "IG sel", "MSAC +LO" yield valid names).
VisualGeometryToolkitEval.Render.path_rank — Method
Within-family optimization-path sort rank of arm key of style.
VisualGeometryToolkitEval.Render.pgf_colormap — Method
pgf_colormap(colormap; reverse = false, samples = 15) -> StringThe colormap colormap (t ∈ [0, 1] -> colour with fields r, g, b) as pgfplots' colormap body, rgb=(r,g,b) rgb=(…) …: sampled at samples evenly spaced points, each channel rounded to 4 digits, reversed (1 - t) when reverse. The text write_station_fan_colorbar defines its \pgfplotsset{colormap={<name>}{…}} with; a figure that defines the same colormap for its own axis writes it here.
VisualGeometryToolkitEval.Render.pgf_coords — Method
pgf_coords(xs, ys; fmt = "(%.6f,%.4f)") -> StringThe pgfplots coordinates {…} body of a curve: one fmt-formatted (x,y) per point with a FINITE y (a non-finite point is dropped — pgfplots cannot draw it), space-separated. fmt is a Printf format of the two coordinates ("(%d,%.4f)" for an integer budget axis).
VisualGeometryToolkitEval.Render.read_tsv — Method
read_tsv(path) -> Vector{Dict{String,String}}The rows of a tab-separated table as dictionaries keyed by the header cells. Blank lines and # comment lines are skipped; the first remaining line is the header, and cells are strings (a row shorter than the header lacks the trailing keys).
VisualGeometryToolkitEval.Render.results_by_method — Method
results_by_method(summary::DataFrame) -> Dict{Tuple{String,String}, SubDataFrame}A summary DataFrame (the rows Evaluation.compute_method_rows emits) bucketed into one SubDataFrame per (method_key, tuning_criterion), each sorted by n, as load_results reads it from a file. The method key strips a trailing (median|mAA) suffix (either case). Each bucket carries the added columns method_key, tune_key and nn (Float64(n)). The summary itself is not modified.
VisualGeometryToolkitEval.Render.station_cells — Method
station_cells(df; stations = -80:10:80) -> Vector{NamedTuple}The cells of a floorplan fan from df, one row per (frame, marker) attempt with rig_distances_bin (mm), rig_angles (rad, the frame's), error_distances (mm, missing where nothing was placed) and abs_error_angles_deg. Each attempt belongs to the member of stations nearest its rig angle (an angle beyond either end at that end; never numbered by rank: a station with no capture shifts no other, and per-frame jitter stays in its station); per (station, distance) a cell (; angle, dist, n, rate, med, medr): the station's angle (degrees), the distance, the placed count, the placed fraction, the median distance error and the median |angle error| (NaN with nothing placed). The ±90° stations are edge-on (a plane presenting no area) and are dropped; every station angle of stations (degrees) at a distance without an attempt gets a cell n = 0, so a hole in the fan always means no detection, never missing data.
VisualGeometryToolkitEval.Render.tuning_slice — Method
tuning_slice(path; axes, stage = :coarse) -> (; axes, xs, values, argmin)The objective of a coarse-fine tuning artifact (Evaluation.save_coarse_fine_artifact) over the stage (:coarse or :fine) product grid, restricted to axes (one or two axis names) through that grid's argmin on every other axis: xs[i] the grid of axes[i], values the criterion's reported value (the mAA for a mean_average_accuracy criterion, else the objective) over them, argmin the index of the stage's argmin within the slice.
VisualGeometryToolkitEval.Render.write_article_preview — Method
write_article_preview(out_dir, panel_base, colordefs; legend_ref = "")Write an article-class preview.tex in out_dir that \inputs the panel fragment panel_base (its filename WITHOUT .tex), then compile it to PDF with latexmk when it is installed. colordefs is the \providecolor block for the panel's colours; legend_ref names a legend to \ref below the panel.
VisualGeometryToolkitEval.Render.write_station_fan — Method
write_station_fan(colormap, io::IO, cells; value, span, logarithmic = false, reverse = false,
comment = "station fan", ring_labels = true) -> io
write_station_fan(colormap, path, cells; <the same keywords>) -> pathA floor plan's station fan as a bare TikZ picture (no title): per cell of cells (station_cells: angle in degrees, dist in mm, n the placed count) an annular wedge 10° wide (0° up, clockwise) from dist - 300 to dist + 300 mm, drawn in metres, its geometry scaled by the \fpscale macro (\providecommanded to 1; fonts are unaffected), the picture anchored at its top (baseline=(current bounding box.north), level with a colorbar beside it), the rig a black square at the origin, and with ring_labels the rings labelled 1, 2 and 3 m (\scriptsize, not scaled: drop them below about \fpscale 0.3).
A cell with n == 0 is grey (gray!30): a hole in the fan means no detection. Any other cell is filled with colormap(t) — a colour with fields r, g, b in [0, 1], written at 4 decimals (Makie's or PlotUtils' t -> get(cgrad(:RdYlGn), t)) — where t is the cell's statistic value (a field name: :rate, :med, :medr) placed in span = (lo, hi) (in the statistic's units) and clamped to [0, 1], on a log10 axis when logarithmic, and 1 - t when reverse (a statistic that is better low, an error). comment is the file's first line, after %. Requires, in the document, \usepackage{tikz}.
VisualGeometryToolkitEval.Render.write_station_fan_colorbar — Method
write_station_fan_colorbar(colormap, io::IO; span, ticks, tick_labels = <the ticks>, label = nothing,
logarithmic = false, reverse = false, colormap_name = "stationfan",
orientation = :vertical, length = "1.6cm",
comment = "station fan colorbar") -> io
write_station_fan_colorbar(colormap, path; <the same keywords>) -> pathThe colorbar of a row of station fans (write_station_fan with the same colormap, span, logarithmic and reverse) as a pgfplots colorbar-only axis in a TikZ picture, anchored at its top. :vertical stands beside the row, length its height; :horizontal lies beneath it, length its width. ticks are in the statistic's units (log10 inside when logarithmic), labelled tick_labels (default: each tick, an integer value without its decimals); label is the bar's axis label (nothing: none, where the document names the quantity already).
The picture defines the colormap colormap sampled at 15 points as pgfplots' <colormap_name> and its reverse as <colormap_name>rev (both, so a figure's bars share one pair of definitions) and draws the bar in <colormap_name>rev when reverse. comment is the file's first line, after %. Requires, in the document, \usepackage{pgfplots} and \pgfplotsset{compat=1.18}.
VisualGeometryToolkitEval.Render.write_tsv — Method
write_tsv(path, rows::AbstractVector{<:NamedTuple}; comments = String[]) -> pathThe same table with its header the rows' field names, in their order, and one line per row. Every row has the same field names (an ArgumentError names the first row that differs). The element type may be abstract (NamedTuple[], a table built by push!): the header is read from the rows. A table without rows writes the header when its element type names the fields (Vector{@NamedTuple{a::Int}}), else an empty header line; either reads back (read_tsv) as no rows.
VisualGeometryToolkitEval.Render.write_tsv — Method
write_tsv(path, header, rows; comments = String[]) -> pathWrite a tab-separated table: each of comments as a #-prefixed line, then the header cells, then one line per row of rows (each cell through string), lines ended by \n. The parent directory is created. read_tsv reads it back.
Internals
These names are not public; they are listed for contributors.