plot::renderer

Bucket prims into the tile grid covering a width×height framebuffer.

Append a stroked segment.

Append a filled disc (scatter/stem markers).

Append an axis-aligned rectangle — filled, or an outline when outline_half_width > 0 (bars, heatmap cells, legend swatches, square markers, gridline boxes).

Append a filled triangle (area fills are fan-triangulated into these).

Append one 8×16 glyph at a pixel position — the glyph's bitmap rides IN the prim's aux lanes (4 bits-rows per lane), so the kernel needs no font atlas.

Append a text run, left-aligned at (x, y) top-left, one glyph prim per character.

The 8×16 bitmap for character c — 16 rows top to bottom, one byte per row, bit 7 = leftmost pixel of the cell (matching the glyph prim's row packing in kernels.hpp).

The pixel width of s drawn in this font — the font is strictly monospace, so this is pure arithmetic on the length: kGlyphWidth * len.

Whether the default GPU lane can come up on this machine — a cached one-shot probe that NEVER throws.

Pack an RGBA colour (channels 0..1) into the kernel's byte order (r | g<<8 | b<<16 | a<<24), clamping each channel — the ONE quantization point between the float model layers and the integer raster.

Encode img as a complete PNG byte stream: the 8-byte signature; IHDR declaring 8-bit RGBA (colour type 6, no interlace); one IDAT whose zlib stream (header 0x78 0x01) carries the filtered pixel data as STORED deflate blocks of at most 65535 bytes each, followed by the Adler-32 of that raw data; then IEND.

Encode img and write the PNG to path in binary mode — the renderer's standard save.

Write img to path as a binary P6 PPM (24-bit RGB; the alpha channel is dropped) — the fallback format for tooling that predates PNG support, and a handy raw-bytes debug tap.

Rasterize a binned draw list into an RGBA8 framebuffer (one uint32 per pixel, row-major) — the reference implementation of plot_clear + plot_raster.

Reduce a Figure to the primitive list a rasterizer draws — layout, axes, ticks + labels, grid, every mark kind, and per-subplot legends, in paint order.

Render a figure to RGBA8 pixels at the figure's own size — the readback form (the stream frame, the test surface, the encoder input).

Render a figure and write it to path as a PNG — the one-call "give me my plot" form.

Rasterize a binned draw list through the plot kernels on context ctx — the device mirror of raster_cpu: upload prims/offsets/indices/params, dispatch plot_clear then plot_raster (one thread per pixel), download the framebuffer.

Render a figure to RGBA8 pixels on the default GPU lane — the device mirror of render: same reduce, same bins, same packed-pixel unpack; only the rasterizer differs.

Attempt the default GPU lane for one raster: honours CHEATAH_PLOT_FORCE_CPU=1, the cached gpu_available probe, and a process-wide failure latch — the FIRST device failure prints a one-time stderr notice and every later render goes straight to the CPU reference (retrying a broken lane per frame would re-fail and re-allocate forever).

Threads per workgroup axis of BOTH kernels — matches [numthreads(16, 16, 1)] in shaders/plot.slang.

The clear kernel's entry name — plot_clear in shaders/plot.slang (buffers: fb, params).

The raster kernel's entry name — plot_raster in shaders/plot.slang (buffers: prims, tile_offsets, tile_prims, fb, params).

The raster tile edge in pixels: binning buckets primitives into kTile×kTile screen tiles.

The glyph cell the kernel rasterizes: 8 pixels wide (a glyph prim's aux lanes carry the bitmap, one byte per row, bit 7 = leftmost pixel).

The glyph cell height in pixels (16 rows = the prim's four aux lanes, 4 rows per lane).

The primitive kinds the raster kernel draws. Values are the on-device codes — append-only.

The primitive list, in paint order. Push through the helpers below.