Procedures

Add 3D line plot data by projecting to 2D

Add 3D line plot to figure (projected to 2D)

Add arrow annotation to figure

Add a box plot to the plot array

Object-oriented contour helper.

Object-oriented filled contour helper.

Add filled contour plot with colors

Add basic contour plot

Matplotlib-canonical alias for add_contour_filled.

Add line plot data with comprehensive validation Enhanced Issue #854: Added comprehensive parameter validation

Object-oriented pcolormesh helper.

Add pseudocolor mesh plot

Add 2D line plot to figure

Add 2D scatter plot to figure

Add 3D scatter plot to figure

Add a single efficient scatter plot object Properly handles thousands of points with single plot object

Add scatter plot data with optional properties

Add streamline trajectory to figure as line plot

Add a plot to a specific subplot

Add surface plot to figure

Object-oriented surface helper.

Add text annotation to figure

Create and store a text element on the ASCII canvas

Advance pattern state for continuous rendering Following SRP - handles only state advancement

Add arrow annotation to the current figure

Apply colormap to array of values efficiently

Translate config_t into figure_state_t fields.

Apply custom tick positions/labels, converting data coords to plot area coords

Apply inverse scale transformation to recover original value

Apply marching squares lookup table to get line segments

Convert Vega-Lite padding to figure_state_t margins.

Apply forward scale transformation to a single value

Fill spec%config from built-in style. When force=.true., overrides any JSON-provided config. When force=.false. (default), only fills when absent.

Map a 1-based band index onto the ordered density ramp.

Draw top x-axis tick labels for ASCII backend in the reserved top band

Draw right y-axis tick labels for ASCII backend in the reserved band to the right of the primary data area.

ASCII text drawing with legend processing (moved from main module)

Fill quadrilateral using character mapping based on current color

Get the complete ASCII canvas as a string

Replace a leading ASCII hyphen-minus (U+002D) marking a negative number with the typographic minus sign U+2212, matching matplotlib's default tick/colorbar labels. Only the sign position is converted; interior hyphens (none occur in numeric labels) and non-negative labels pass through unchanged.

Width in character cells needed to hold the widest secondary y tick label, plus one column of padding from the data area. Used to reserve the right-hand band before data is drawn.

Draw a horizontal reference line.

Set aspect ratio: axis('equal'), axis('auto'), or axis(2.0)

Draw a vertical reference line.

Check if backend is allocated

Set backend color

Detect whether backend is operating in ASCII mode based on canvas size

Draw line using backend

Add vertical bar plot

Plot a vertical bar chart with per-bar RGB color arrays.

Add horizontal bar plot

Plot a horizontal bar chart with per-bar RGB color arrays.

Basic legend usage with labeled plots

Reverses the bits of a given value up to num_bits.

Convert 3D RGB bitmap to PNG buffer format with filter bytes

Alpha blend a pixel with existing pixel data

matplotlib default: whisker cap total width is half the box width, so the cap half-width is a quarter of the box width.

Add boxplot

UTF-8 encoding of the braille codepoint for a mask. Invalid masks are clamped before encoding (braille_mask_valid reports the raw value).

Codepoint for a braille mask, clamped into the valid block so an invalid mask can never encode outside U+2800..U+28FF.

Bit value for one dot within a cell. local_x in {0,1} (left/right), local_y in {0,1,2,3} (top to bottom). Out-of-range positions have no dot and return 0 so an invalid position never sets a spurious bit.

Rasterize a line between two subpixel coordinates with Bresenham's algorithm, setting every visited dot.

Braille counterpart of ascii_finalize: writes the composited braille canvas to a file, falling back to terminal output on error.

A mask is a valid braille bitmask only within [0, 255]; any other value carries dot bits that do not exist in the U+2800 block.

Compose the ASCII text canvas and the braille subpixel mask into UTF-8 rows: cells with a set braille mask emit the braille glyph, all other cells keep their ASCII character (frame, axes, ticks, labels).

Build a uniform or per-point size array for scatter markers.

Calculate Adler-32 checksum for zlib

Calculate aligned text position based on alignment settings

Calculate overall data ranges for the figure with robust edge case handling

Calculate histogram bin edges and counts from data.

Calculate optimal legend box dimensions and position DRY: Centralized legend box calculation logic

Calculate legend position based on backend and position setting

Calculate minor tick positions for log scale at 2,3,4,5,6,7,8,9 within decades

Calculate marching squares configuration for a cell

Calculate total height of mathematical text elements

Calculate total width of mathematical text elements

Calculate minor tick positions between major ticks Places minor_count minor ticks between each pair of major ticks

Calculate nice axis limits that encompass the data like matplotlib The axis limits are set to nice round numbers based on tick locations

Calculate optimal legend dimensions using actual text system measurements KISS: Based on measured text content, not estimates

Calculate plot area for PDF backend (mathematical coordinates: Y=0 at bottom)

Calculate plot area based on canvas size and margins (matplotlib-compatible) Note: left/bottom are margins, right/top are edge positions

Calculate bounding box for rotated text

Calculate bounding box for rotated text

Calculate anchor position based on alignment settings

Calculate the descent (below baseline) portion of text in pixels

Calculate the pixel height of text using STB TrueType Supports mathematical notation with superscripts and subscripts

Calculate text height for a given font pixel size

Internal text height calculation based on font metrics

Calculate text dimensions for given annotation

Safe text metrics calculation with error handling

Calculate the pixel width of text using STB TrueType with UTF-8 support Supports mathematical notation with superscripts and subscripts

Calculate text width using a specific font size Supports mathematical notation with superscripts and subscripts

Internal text width calculation to avoid circular dependencies Note: Uses len(text) not len_trim to preserve trailing spaces in mathtext

Calculate appropriate tick labels at nice locations like matplotlib Ensures all labels have consistent formatting and nice round numbers

Calculate logarithmic tick labels at powers of 10 with sub-ticks

Calculate symlog tick labels with improved linear and log regions

Calculate X-axis label position (40px below plot)

Calculate X-axis label position with matplotlib-style centering and spacing

Calculate X-axis tick label position using proper font metrics and matplotlib spacing

Calculate X-axis tick label position for PDF (Y=0 at bottom, increases upward)

Calculate Y-axis label position with proper spacing from tick labels

Calculate Y-axis label position with right alignment and proper spacing

Calculate Y-axis tick label position using proper font metrics

Calculate Y-axis tick label position for PDF (Y=0 at bottom, increases upward)

True when a data glyph may occupy the cell (in bounds and not reserved for a label).

Convert Cartesian to polar coordinates Returns theta in [0, 2*pi) range

Catmull-Rom spline interpolation between P1 and P2 t in [0,1], P0/P3 are control points

Check if UTF-8 sequence is valid and return its length

Resolve matplotlib 'best' placement to a concrete corner. Computes the legend box for each candidate corner and scores it by the number of plotted artist sample points its bbox covers; the lowest overlap wins, ties broken in matplotlib's order (upper right first).

Clamp extreme logarithmic ranges to ensure usable plots

Clamp value to [0,1] range

Remove temporary file (best effort, no error on failure)

Clean up text system resources

Clear the color cache

Clear streamline data

Convert unknown codepoint to default placeholder format

Convert lowercase Greek codepoint to ASCII name

Convert uppercase Greek codepoint to ASCII name

Map an RGB triple to a standard (30-37) or bright (90-97) SGR foreground code by nearest 3-bit color plus a luminance-based bright bit.

Map an RGB triple to a 6x6x6 color-cube index (16..231).

Convert floating-point color value [0,1] to byte [0,255]

Add a colorbar for the active figure.

Convert data value to RGB color using colormap

Composite 3D RGB bitmap directly onto raster image buffer

Composite 3D RGB bitmap onto raster buffer using 0-based destination coords

Compute angular tick positions and labels for polar plot Returns angles in radians and labels in degrees

Compute radial tick positions for polar plot

Compute tick positions for different scale types

Compute arrow metadata for streamlines based on trajectory geometry

Compute per-cell subplot margins in fractional figure coordinates. Margins, inter-column gaps, and inter-row gaps are driven by each panel's decoration sizes (tick labels, axis labels, titles) so every panel's y-axis label sits to the left of its plot box and the top row's x-axis label clears the title of the row below. Short figures additionally reclaim excess margin so the panels fill at least MIN_AXES_FILL_FRAC of the figure height, matching matplotlib's default vertical fill.

Compute the position for centered title above plot area

Compute x-position for ylabel to avoid overlapping with y-tick labels. The gap between the ylabel's right edge and the outer edge of the y-tick labels is matplotlib's axes.labelpad (AXIS_LABEL_PAD_PT), scaled to device pixels by DPI, so the label sits snug against the tick labels rather than floating far to the left.

Configure figure dimensions

Configure grid settings

Check if a style string contains matplotlib format characters Returns false for named linestyles (solid, dashed, etc)

Detect whether a collection of plots contains at least one pie chart

Check if text contains Unicode characters

Draw contour lines.

Draw filled contour regions.

Matplotlib-canonical alias for contour_filled.

Infer vertex edges from center coordinates for uniform grids

Add a filled contour plot to the figure

Add a pcolormesh plot to the figure

Add a 3D surface plot to the figure

Draw a horizontal line spanning the axes at y position

Draw a vertical line spanning the axes at x position

Create a box plot

Clear the figure for reuse, preserving backend settings

Enable a stateful colorbar for the current figure.

Create a histogram plot (matplotlib-compatible).

Draw horizontal lines at each y position from xmin to xmax

Add quiver plot (discrete vector arrows) to figure

Add an efficient scatter plot using a single plot object Properly handles thousands of points without O(n) overhead

Store the text-backend charset: 'ascii' (default), 'unicode', 'auto' (resolved from the environment at save time), or 'braille'. Unknown names warn and fall back to 'ascii' (#2060, #2061).

Store the text-backend ANSI color mode: 'never' (default), 'ansi16', 'ansi256', 'truecolor', or 'auto' (resolved at output time). Unknown names warn and fall back to 'never' so escapes never leak (#2062).

Draw vertical lines at each x position from ymin to ymax

Count frames in a .txt animation without playing them.

Calculate CRC32 checksum using standard polynomial

Build a blank braille canvas sized to a text grid of n_cols by n_rows character cells. Subpixel resolution is 2n_cols by 4n_rows dots.

Create line data for histogram visualization as connected rectangles.

Factory function following Dependency Inversion

Factory function following Dependency Inversion

Create 2D meshgrid from 1D coordinate arrays Used internally for regular grid setup

Create a grid of subplots

Create a text annotation with specified properties

Full deflate compression implementation with LZ77 and Huffman coding

Demonstrate 3D line plots with helices and parametric curves

Demonstrate various 3D scatter plot patterns and combinations

Demonstrate 3D surface plots with different mathematical functions

Demonstrates all available marker types

Basic contour line plot with Gaussian function

Basic pcolormesh with simple gradient - enhanced 51x51 grid

Demonstrates categorical axis labels for bar charts Uses set_xticks() with string labels to create categorical x-axis

Compare different colormaps with ripple function

Demo different colormaps - enhanced 51x51 grid

Filled contour plots with colorbar

Demonstrates matplotlib-style format strings

Demonstrates all available line styles

Contour plot combined with a line plot overlay

Demonstrate mixing 2D and 3D plots, and combining different 3D types

Pcolormesh with negative coordinates and values to exercise edge cases

Creates a scatter plot demonstrating markers in practical use

Demonstrates show_viewer() - opens in system PDF viewer

Pcolormesh with sinusoidal pattern - enhanced 51x51 grid

Demonstrates show() - intelligent display selection

Demonstrates stacked bar charts (Issue #1460) Uses bottom parameter to stack bars on top of each other

Clean up text annotation resources

Decimal places needed to render the step exactly, matching matplotlib's ScalarFormatter. A step of 2.5 needs 1 decimal ("2.5"), 0.25 needs 2 ("0.25"); rounding to fewer would mislabel a tick (e.g. 2.5 -> "3"). The count is the fractional-digit depth of the step, not a function of its magnitude.

Determine decimal places from an array of tick positions. Uses the smallest non-zero spacing as representative step.

Flag axis sides where the generic 5% data-range margin must not be applied, matching matplotlib's sticky edges. Bars carry their own margin (with a sticky baseline) in process_bar_plot_ranges; a pcolormesh and contour grids fill their data extent exactly. In each case the data range is authoritative and adding margin would float the artist off the axis (bars) or leave a gap around it (mesh/contour).

Calculate minimum distance from point to line segment

Integrate streamline using DOPRI5 method with adaptive step size

Redraw the current figure to terminal (ASCII output)

Draw complete 3D axes frame with ticks and labels

Draw the box spines that lie in front of the data. Called after the data is rendered so near spines occlude curves and surfaces, while the far spines drawn by draw_3d_axes stay behind the data.

Draw arrow using Unicode directional characters for ASCII backend

Draw axes and labels for ASCII backend

Rasterize a streamplot trajectory segment thinned to terminal-cell resolution (issue #2070). Flow cells are placed through the layer policy so they never overwrite axes, ticks, or labels, and a minimum horizontal gap keeps any single row from being flooded with flow glyphs. The result is a sparse dotted flow field instead of a dense run of hyphen fragments.

Project a quiver vector to a text cell, clip it to the interior plot area, and stamp an eight-direction ASCII glyph at data-layer priority so it never overwrites axis spines, ticks, or label text (issue #2071). u/v are the already scaled vector components in data units, so the caller's scale factor still governs which arrows survive the minimum-shaft cut. The interior clip drops vectors that would land on the frame or in the tick/axis label margin.

Fill the three back-facing panes with light gray, behind the data.

Draw the box edges that lie behind the data (mean edge depth below the cube center). These render before the data so the data paints over them.

Draw arrow using backend

Draw line using backend

Draw basic rectangular axes frame Uses a procedure pointer to be backend-agnostic

Draw filled circle with antialiasing

Draw circle outline with antialiasing

Draw circle with separate edge and face colors

Draw diamond marker with separate edge and face colors

Draw a filled quadrilateral

Draw filled quadrilateral using scanline algorithm.

Draw filled quadrilateral with anti-aliased, supersampled coverage and alpha blending. Supersampling in both axes gives the correct filled area for rotated quads such as diamond markers: a per-scanline nint span (the previous approach) collapsed the narrow rows near a diamond's tips, leaving the concave four-petal artifact. Each pixel's coverage is the fraction of sub-samples inside the polygon, then blended once at coverage*opacity so overlapping fills do not double-darken.

Draw the box edges in front of the data (mean edge depth above the cube center). These render after the data so they occlude it, matching the global painter ordering of matplotlib mplot3d.

Draw antialiased line using distance-based approach

Draw gridlines across each back pane at the per-axis tick fractions, one line per tick, in light gray (matplotlib mplot3d).

Draw arrow marker in PDF

Streamplot arrowhead only: head triangle at (x, y) tip, no shaft.

Streamplot arrowhead: head glyph at (x, y), no shaft. (dx, dy) is a unit direction in data coords; only its angle matters.

Draw complete axes system with labels using actual plot area coordinates

Draw filled circle with outline in PDF

Draw filled diamond with outline in PDF

Draw the plot frame using actual plot area coordinates (FIXED version)

Draw text with mathematical notation

Draw minor tick marks (shorter than major ticks)

Draw secondary X axis at the top of the plot

Draw secondary Y axis on the right side of the plot

Draw filled square with outline in PDF

Draw tick labels using actual plot area coordinates (FIXED version)

Draw tick marks using actual plot area coordinates (FIXED version)

Draw plot title and axis labels

Draw X-shaped marker in PDF

Draw quadrilateral edges

Draw a visible marker for a single point This ensures single points are visible even without explicit markers

Draw square marker with separate edge and face colors

Draw line with pattern support (dashed, dotted, etc.)

Draw the solid left and bottom axis spines plus the corner tick. Spines are filled cell-by-cell in screen space so they stay continuous regardless of the data range (issue #2069).

Draw a single tick mark on a spine at a labeled tick position.

Fill interior grid glyphs aligned to major-tick columns and rows. Grid cells are drawn at LAYER_GRID, the lowest drawable layer, so put_cell leaves data, axis spines, tick marks, and labels intact and only paints otherwise-blank interior cells (issue #2074).

Draw X-shaped marker

Adjust axis limits to enforce the specified aspect ratio. For equal aspect, x and y have the same scale per pixel. For numeric ratio, y-scale = ratio * x-scale.

Adjust the figure axis limits so pie charts render with equal scaling

Ensure output directory exists for a given filepath Extracts the parent directory and creates it securely using the runtime file operations with path validation.

Ensure the global figure exists and is initialized

Lazily allocate plot storage and the active backend so that operations invoked on a default-initialized figure_t do not dereference unallocated arrays (#1638).

Public wrapper to guarantee the singleton is ready for use

Ensure numbers like .5 become 0.5 for readability

Ensure a test output directory exists and return its normalized path

Add error bar plot to figure

Escape a string for safe JSON embedding. Handles: " -> \", \ -> \, and control characters.

Escape special characters in PDF strings

Convert Unicode text to ASCII-compatible text for ASCII backend Processes UTF-8 input and converts Unicode characters to readable ASCII equivalents

Pass through Unicode for raster rendering (STB TrueType supports Unicode)

Estimate rendered width (in PDF points) of a text string

Expand a data range by DATA_RANGE_MARGIN (5%) of the span on each side, matching matplotlib's default axes margin (rcParams axes.{x,y}margin = 0.05). Also keeps markers at exact boundaries clear of the plot frame stroke.

Expect and consume a specific character

Extract RGB data from ASCII backend (not supported - dummy data)

Extract polygonal regions between contour levels using marching squares

Extract PNG data for animation

Extract RGB data for animation

Extract PNG data for animation

Extract PNG data for animation

Extract RGB data for animation

Extract RGB data for animation

Create or reset the shared figure.

Add a contour plot to the figure

Add a filled contour plot with color mapping

Add a filled contour plot with color mapping

Add a contour plot to the figure

Add an area fill between two curves

Add an area fill between two curves

Add a pcolormesh plot

Add a pcolormesh plot

Store pie chart slices using polar wedges with optional explode & colors

Add a pie chart to the figure

Add a line plot to the figure

Add a line plot to the figure

Add a 3D surface plot to the figure

Add a 3D surface plot to the figure

Draw arrow using backend property

Get backend association property

Set backend color property

Draw line using backend property

Create a box plot

Clear the figure to prepare for reuse (preserving backend settings)

Clear streamline data

Finalize and clean up figure

Extract PNG data for animation

Extract RGB data for animation

Get figure height property

Get figure plot count property

Get figure plots property

Get figure rendered property

Get figure width property

Get x maximum property

Get x minimum property

Get y maximum property

Get y minimum property

Enable/disable and configure grid lines

Create a histogram plot (matplotlib-compatible).

Initialize the figure with specified dimensions and backend Added DPI support for OO interface consistency with matplotlib interface

Add legend to figure

Save figure to file (backward compatibility version)

Save figure to file with error status reporting

Add an efficient scatter plot using a single plot object

Set line width for subsequent plots

Set figure rendered property

Set figure title

Set x-axis label

Set x-axis limits

Set x-axis scale type

Update y data for an existing plot

Set y-axis label

Set y-axis limits

Set y-axis scale type

Setup PNG backend for animation

Display the figure

Add streamline plot to figure using basic algorithm

Add a plot to a specific subplot

Get the number of plots in a specific subplot

Set the title for a specific subplot

Set the x-axis label for a specific subplot

Set the y-axis label for a specific subplot

Get the title for a specific subplot

Create a grid of subplots

Update data ranges based on current plot

Update data ranges after adding boxplot - delegate to ranges module

Update data ranges after adding pcolormesh plot - delegate to ranges module

Fill scanline coverage from active edges. Port of stbtt__fill_active_edges_new. scanline is 0-based [0..w-1], scanline2 is 0-based [0..w]. In STB, fill function receives scanline_fill = scanline2+1. Here scanline2(k+1) = STB's scanline_fill[k].

Paint filled-contour bands into the ASCII canvas with an ordered glyph ramp (issue #2077). Each interior character cell is mapped back to a data coordinate (same screen mapping as ascii_fill_quad_primitive), its scalar value is looked up on the grid, and the band index selects a ramp glyph. Cells are written through put_cell at LAYER_DATA so axis spines, ticks, and labels stay reserved.

Fill ASCII canvas with heatmap representation of 2D data

Fill horizontal line segment

Fill tick positions and labels arrays

Fill triangle using barycentric coordinates

Find any available font using same priority order as system initialization

Find column index by field name

Find font by name in typical system locations

Find nice tick locations following matplotlib's MaxNLocator algorithm exactly

Format angle in degrees with a trailing degree sign, matching matplotlib's polar theta tick labels (e.g. "45" + U+00B0). The degree sign is emitted as its two-byte UTF-8 encoding (0xC2 0xB0) so the text backend renders the glyph directly.

Build a mathtext label for a sub-decade log tick: m x 10^{p}. Mirrors matplotlib's minor log labels, e.g. 2 x 10^0 or 4.2 x 10^1. Exact powers of ten are delegated to format_power_of_ten_label.

Format logarithmic tick values using scientific notation like matplotlib

Simple number formatting for annotations

Build a mathtext-friendly power-of-ten label: 10^{n} or -10^{n}

Format a tick value as a string label

Format tick value based on data range like matplotlib

Format tick value with consistent decimal places for uniform appearance

Smart tick value formatting with automatic exponential notation for long labels Limits output to max_chars and uses exponential notation when needed

Fractional part of floating-point number

Facade constructor: builds the animation_t and registers the save implementation so anim%save(...) works directly (per README).

Internal helper to generate axis tick positions and labels

Generate tick labels based on scale type - common function for all backends

Generate seed points in spiral pattern starting from boundary Implements matplotlib's _gen_starting_points algorithm

Generate streamlines using matplotlib-compatible algorithm

Generate tick positions and labels for axes

Generate X axis tick positions and labels

Generate Y axis tick positions and labels

Return the name of the currently active axes.

Get actual text dimensions using text system measurements
Returns [width, height] in data coordinates

Get PNG data from ASCII backend (not supported)

Generate tick mark positions for basic axes

Determine backend type from file extension

Get cache hit rate for performance monitoring

Get RGB color from colormap for a normalized value [0,1]

Extract contour lines from a cell using marching squares

Get default marker style

Get default viewing angles matching matplotlib

Get descriptive error message for status code

Get figure height from state

Get number of plots from state

Get pointer to plots array

Get rendered state

Get figure width from state

Get x maximum value from state

Get x minimum value from state

Get y maximum value from state

Get y minimum value from state

Get font ascent ratio for baseline positioning

Get font metrics in pixels for current font and scale

Get font scale for a specific pixel height

Return the global figure pointer, initializing on demand

Get figure height

Inset between the legend box and the axes frame. Matches matplotlib's borderaxespad default (0.5 * 10pt font = 5pt), which at the standard ~100 dpi is ~7 px, independent of the data range. A fixed pixel inset keeps the legend flush in the corner the way matplotlib draws it, instead of a large data-proportional gap.

Get line pattern array for a given style, in points. Single source of truth: the matplotlib default dash sequences. On/off lengths are in points; callers scale by line width (points) and convert to device units (see scale_pattern_to_pixels).

Get the current global logging level Returns one of: LOG_LEVEL_SILENT, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, LOG_LEVEL_INFO, LOG_LEVEL_DEBUG

Get standardized marker size for given style Eliminates magic number duplication across backends

Extract parent directory from a path

Calculate total length of pattern cycle Following KISS principle - simple sum calculation

Get number of plots

Get rendered state

Get the number of plots in a specific subplot

Get the title for a specific subplot

Generate unique temporary filename with proper platform handling

Get appropriate temporary directory for tests

Get ascent/descent/height for a given pixel_height.

Get figure width

Get Windows-safe numerical tolerance

Get x maximum value

Get x minimum value

Get y maximum value

Get y minimum value

Classify a character already present on the canvas into a layer so put_cell can resolve collisions without a parallel layer buffer.

Toggle or style grid lines.

Enable/disable and configure grid lines

Handle ticks for zero or near-zero range data

Check if a graphical session is available Returns .true. if X11, Wayland, macOS GUI, or Windows GUI available

Check if coordinates span too small a range to be reliably rendered. A collapsed axis (whole extent at machine-precision scale relative to the coordinate magnitude) cannot be distinguished after normalization. Individual coincident adjacent points, common near extrema of smooth curves, are normal and must not be flagged.

Check if text needs math layout. A matched '$...$' segment always enables math. Braced script markup ('^{...}' or '{...}') also enables math even without dollars so grouped exponents and subscripts render as scripts instead of leaking literal grouping braces. Bare unbraced '^'/'' outside dollars still render literally and are not math.

Return Helvetica advance width in 1000-unit em for given codepoint

Add histogram to figure plots array (matplotlib-compatible).

Add histogram (matplotlib-compatible).

Draw one or more horizontal lines.

Parameters z - image data. cmap - colormap name. alpha - opacity. vmin - lower color limit. vmax - upper color limit. origin - array origin keyword. extent - image extent. interpolation - interpolation mode. aspect - aspect keyword.

Initialize fixed Huffman tables as per RFC 1951

Initialize basic line plot data

Initialize STB TrueType font system with robust font discovery

Initialize the appropriate backend based on type

Initialize figure state with specified parameters Added Issue #854: Parameter validation for user input safety Added DPI support for OO interface consistency with matplotlib interface

Initialize tick count and allocate arrays

Initialize warning suppression based on environment variables Supports manual control and automatic CI detection

Initialize debug logging based on FORTPLOT_ZLIB_DEBUG environment variable

True when the cell lies within the circular frame (elliptical in cell space because of the character aspect ratio).

Interpolate the positions where contour crosses cell edges

Bilinear interpolation of Z value at world coordinates Refactored to be under 100 lines (QADS compliance)

Disable interactive mode

Enable interactive mode for live terminal visualization

Integer part of floating-point number

Check if annotation is visible within plot area

Check if backend is allocated

Check if arrays are empty

Check if status code indicates an error

Check if codepoint is a Greek letter

Determine if we're running in an interactive environment Returns false for CI, batch, or piped environments

Check if a character is Unicode (multi-byte)

Check if color string is valid without full parsing

Check if arrays represent a valid single point

True when mode names one of the five canonical color modes.

Check if warnings are currently suppressed

Parse a Vega-Lite JSON string into spec_t

Launch system viewer for file Uses xdg-open on Linux, open on macOS, start on Windows

Display the figure legend.

Demonstrate legend box styling and multiple entries

Render legend - delegates to drawing module

Load font system from specified path

Log a debug message

Log error message to error unit

Log an error message

Log an informational message

Log a warning message with suppression support Respects FORTPLOT_SUPPRESS_WARNINGS and CI environment detection

Convert matplotlib-style grid index to data coordinate

Apply an aspect-preserving projection map to one projected point.

Map axis tick data values to integer screen cells along one axis. in_range flags the ticks that fall inside [cell_lo, cell_hi] and are therefore drawable; callers decide which are labeled.

Map Unix-style /tmp paths to Windows-compatible paths

Linear radius scale factor for a matplotlib scatter area s. s is an area (points^2); radius scales with sqrt(s). Normalized so that area == DEFAULT_SCATTER_AREA returns 1 (today's default size).

Enable minor ticks on both axes.

Return config_t matching matplotlib visual defaults.

Complex legend with multiple mathematical functions

Next colour from the patch cycle (scatter/fill/bar/histogram). matplotlib cycles patches independently of lines, so the first scatter or filled area is tab:blue even when a line was drawn before it, and a following line plot still starts at tab:blue. Counts existing patch artists rather than the global plot index.

Next colour from the line cycle (plot/axhline/axvline). matplotlib advances the line property cycle only for line artists; scatter and contour draw from the patch/colormap path and never touch it. When the plots array is supplied, count existing line artists so an intervening scatter or contour does not skip a colour. Without it, fall back to the global plot index for callers that have no array in scope.

Normalize angle to [0, 2*pi) range

Normalize a user-facing backend name to its canonical identifier.

Normalize path separators for the target platform

Normalize path for cross-platform compatibility

Canonicalize a user charset selection to 'ascii' or 'unicode'. 'auto' resolves through the environment; anything unrecognized falls back to the ASCII compatibility charset.

Canonicalize a user color-mode selection; unknown names fall back to 'never' so unexpected input can never leak escapes into output.

Check if every plot in the collection is a pie chart

Pack an RGB triple (0..1) into a single 24-bit integer for the per-cell color buffer.

Parse autosize as a string or object (extracting type).

Parse axis object

Case-insensitive parse for common boolean-ish strings.

Parse a single encoding channel object

Parse matplotlib-compatible color string to RGB values [0,1]

Parse color string to RGBA values [0,1] including alpha channel

Parse multiple colors efficiently

Parse config.range object, extracting category colors.

Parse data object: {"values": [{...}, ...]}

Parse domain array [min, max]

Parse encoding object with named channels

Recognize lines of the form "=== Frame ===" and return N.

Parse layer array

Parse mark: either a string or an object

Parse mathematical text into renderable elements

Parse a single layer object

Parse padding as integer object or single integer.

Parse a path into directory segments

Parse one row object and store values into data columns

Parse scale object

Parse only numeric domains and skip categorical domains.

Parse row-oriented data: [{"x":1,"y":2}, ...] Two-pass: first count rows and discover columns, then parse values.

Draw the current figure and pause for specified duration

Draw a pseudocolor mesh (matplotlib-compatible)

Get height scale in drawing units per data unit.

Get width scale in drawing units per data unit.

Parameters values - wedge sizes. labels - wedge labels. colors - wedge colors. explode - wedge offsets. autopct - percentage label format. startangle - rotation angle in degrees.

Open a .txt animation and play frames at options%fps.

Plot x and y data with the active figure or subplot.

Internal validation is always available.

Convert single polar coordinate to Cartesian theta: angle in radians r: radius theta_offset: angular offset (default: 0, 0 at east) clockwise: if true, angles increase clockwise

Convert arrays of polar coordinates to Cartesian

Map a polar sample to a canvas cell. r_max is the shared radial axis maximum so r == r_max lands on the circular boundary.

Demonstrate different legend positions

Prepare 3D data for ASCII backend (no-op - ASCII doesn't use 3D data)

Return trimmed text and leave math parsing decisions to explicit $...$ delimiters.

Run the full latex -> mathtext -> unicode pipeline for raster output.

Escape '^'/'' outside math so they render literally, and pass the '$' delimiters through so the parser can toggle math mode (and tag math runs italic). Only content between '$...$' is treated as math, matching matplotlib: bare '^'/'' outside dollars stay literal. UTF-8 aware: multi-byte characters are copied as intact sequences

Print centered title to terminal.

Process bar plot data to calculate axis ranges

Process box plot data to calculate ranges

Process contour plot data to calculate ranges

Process errorbar plot data to calculate ranges including error extents

Process fill_between data to calculate ranges

Convert LaTeX-style commands to Unicode while preserving math scopes UTF-8 aware: multi-byte characters are copied as intact sequences

Process line plot data to calculate ranges

Process pcolormesh plot data to calculate ranges

Process pie chart slices to compute axis ranges

Process text segments for rotated mixed font rendering

Process text segments for mixed font rendering Groups consecutive glyphs for the same font into a single Tj to avoid odd intra-word spacing in some PDF viewers.

Project 3D samples into the data window using a single shared scale that preserves the projected box aspect ratio (no independent x/y stretch). width_scale/height_scale are the backend pixel scales (pixels per data unit) used to keep the box aspect correct on screen.

Project 3D coordinates to 2D using orthographic projection.

Build the aspect-preserving projection map for one 3D axes box.

Convert points (1/72 inch) to pixels at given DPI.

Write glyph into the canvas only when its layer is at least the layer of the glyph already occupying the cell (higher or equal layer wins).

Validate quiver input arrays have matching dimensions

Add quiver plot to figure Creates discrete vector arrows at (x,y) positions with (u,v) directions

Calculate legend dimensions for PNG using real text metrics (pixels)

Calculate standard legend position for PNG using plot coordinates

Draw all axis labels (title, xlabel, ylabel)

Render an xlabel centered above the plot area

Extract RGB data from PNG backend

Fill contour plot using scanline method for pixel-by-pixel rendering

Fill quadrilateral with current color

Raster context doesn't generate PNG data - only PNG context does

Render legend using standard algorithm for PNG

Render rotated ylabel to the left of y-axis

Render rotated ylabel along the right side of the axis

Set thin border width for PNG legend

Read a JSON boolean (true/false)

Read entire file into a single string

Read a JSON integer

Read an arbitrary JSON value as a literal string. For strings returns the quoted content; for numbers, booleans, null returns the raw text.

Read a JSON number as real(wp). Recognises JSON null and maps it to IEEE NaN.

Read entire stdin into a single string

Read a JSON quoted string, advancing pos past closing quote. Unescapes standard JSON escape sequences.

Remove trailing zeros from decimal representation

Draw the front box spines after the data for the 3D case so they occlude curves and surfaces (global painter ordering, refs #1956). Raster, PDF, and ASCII backends all carry the projected 3D box so the near spines occlude the data on every backend (refs #2054).

Render all plots in the figure

Render axes for ASCII context (stub implementation)

Paint text-backend grid glyphs aligned to major ticks after the data series so the layer policy keeps data on top of the grid (issue

Render compact ASCII legend with style-specific handles

Render Y-axis label for ASCII backend (no-op - handled elsewhere)

Render bar plots (vertical or horizontal) for the active backend

Render a single box plot (vertical or horizontal)

Render a contour plot

Render error bars for a plot

Render all annotations for the current figure

Render figure axes and labels For raster backends, split rendering to prevent label overlap issues

Render ONLY axis labels (for raster and PDF backends after plots are drawn)

Render figure background

Main rendering pipeline implementation Fixed Issue #432: Always render axes/labels even with no plot data Fixed Issue #844: ASCII annotation functionality

Render fill_between polygons as trapezoids

Render grid lines on the figure

Render histogram bins as solid quads without outline seams between bins

Render a line plot with proper scaling and clipping

Render markers for a plot

Render a single mathematical text element in PDF

Render text with mixed fonts at specific position and size

Process LaTeX and render mixed-font text with mathtext support.

Render a pcolormesh plot

Render pie slices using triangle fans per wedge

Render angular gridlines (concentric circles)

Render angular tick labels around the polar plot boundary

Render polar axes: circular boundary, radial spokes, angular circles, tick labels

Render polar axes: circular boundary, radial spokes, angular circles, tick labels

Render circular boundary for polar plot

Render polar data as connected line segments

Composite one polar series onto the text canvas.

Render polar plot data within the coordinate system The plot stores pre-converted Cartesian coordinates in x/y arrays but we use polar_theta/polar_r for proper polar rendering

Render polar plot data within the coordinate system The plot stores pre-converted Cartesian coordinates in x/y arrays but we use polar_theta/polar_r for proper polar rendering

Render radial gridlines (spokes) from center to boundary

Render radial tick labels along a spoke, matching matplotlib's polar r-axis labels (e.g. 0.2, 0.4, ... at 22.5 degrees by default).

Render quiver plot (discrete vector arrows) Draws arrows at each (x,y) position with direction (u,v) Respects angles, pivot, alpha, and per-arrow c(:) color mapping.

Render a reference line (horizontal or vertical) Reference lines store normalized coordinates for axis-spanning lines or actual data coordinates for hlines/vlines

Render a reference line (horizontal or vertical) Reference lines store normalized coordinates for axis-spanning lines or actual data coordinates for hlines/vlines

Process LaTeX and render rotated mixed-font ylabel with mathtext support.

Render rotated text to PNG image using STB TrueType with UTF-8 support

Render a solid line connecting all points

Render standard legend for PNG/PDF backends with improved sizing

Render queued streamplot arrows after plot lines are drawn. See fortplot_figure_plot_renderers for the canonical version; kept in sync so this helpers module stays a drop-in.

Render queued streamplot arrows after plot lines are drawn. Uses draw_arrowhead (head-only glyph) so a normalized direction vector does not get scaled into a data-coord shaft like draw_arrow does for quiver.

Render a 3D surface plot using wireframe or filled representation

Render stored text elements onto the ASCII canvas with Unicode-to-ASCII conversion

Render text to RGB bitmap by using existing PNG rendering then converting

Render text to an RGB bitmap using a given font size (pixel_height).

Render text to image using STB TrueType with UTF-8 support Supports mathematical notation with superscripts and subscripts

Render text with specific font size Supports mathematical notation with superscripts and subscripts

Render title centered above the plot area

Render title centered at specified position with custom font scale Used for suptitle rendering above subplots

Render only the figure title without drawing axes

Render labels for all backend types (raster, PDF, ASCII)

Replace figure state stream arrows and manage rendered flag

Reserve a label footprint of span cells starting at (row, col) plus a halo border, so plotted data is kept clear of the label.

Reset figure state to initial values

Reset pattern distance to start of pattern

If the legend is in 'best' mode, pick the lowest-overlap corner and pin the legend to it. Coordinates passed to the scorer are relative to the data window origin (x_min, y_min), matching the layout module.

Resolve matplotlib-canonical cmap against legacy colormap alias

Merge string/RGB color inputs into a single RGB triple.

Parse an array of color strings into a 3xN RGB matrix.

Resolve 'auto' deterministically from FORTPLOT_TEXT_CHARSET. Absent or unset, the file default stays ASCII so saved .txt bytes are stable and never depend on the host locale (issue #2060 non-goal).

Resolve the color mode for file output. Saved files must stay reproducible, so 'auto' always resolves to 'never'; explicit modes are honored because the caller asked for them.

Resolve the color mode for interactive terminal output. Explicit modes are honored; 'auto' is resolved from the environment and a stdout TTY probe.

Reverse fractional part (1 - fractional part)

Convert RGB to HSV color space

Convert RGB to LAB color space (simplified implementation)

Rotate bitmap 90 degrees counter-clockwise For arrays: (i,j) maps to (height-j+1, i) with swapped dimensions

Rotate bitmap 90 degrees clockwise For arrays: (i,j) maps to (j, width-i+1) with swapped dimensions

Rotate an RGB bitmap around an anchor point, returning the rotated bitmap and the anchor location in the destination bitmap.

Parse arguments and play a .txt text-backend animation.

Safe coordinate transformation using independent x/y scales

Produce an ASCII-safe version of input suitable for placement onto the canvas: LaTeX commands become Unicode (or ASCII words), math delimiters and mathtext braces are stripped, and any remaining Unicode symbols are transliterated.

Save ASCII file with status reporting

Save the figure with appropriate backend based on file extension

Save PDF file with status reporting

Save PNG file with status reporting

Save SVG file with status reporting

Save the current figure.

Save figure to file (backward compatibility version)

Save the figure and return a status code.

Save figure to file with error status reporting Added Issue #854: File path validation for user input safety

Scale a point-based pattern in place to device pixels, matching matplotlib: multiply each on/off length (points) by the line width (points), then convert points to pixels via px = pt * dpi / 72. The solid sentinel is left untouched.

Scale a pixel value from reference DPI (100) to target DPI. At REFERENCE_DPI the value is unchanged.

Scan one row object to discover field names and types. Advances pos past the entire row object.

Select font family with fallback mechanism

Set backend color

Turn on the subpixel dot at absolute subpixel coordinates (x_sub in [0, sub_w), y_sub in [0, sub_h)). Coordinates outside the canvas are ignored, so callers never corrupt an out-of-range cell.

Set figure labels

Set axis limits

Set rendered state

Set axis scale types

Pin the axis box so autoscale does not refit between frames.

Single source of truth for orient string -> position int.

Set line plot properties (style, color, etc.) Extracted from add_line_plot_data for QADS compliance

Set the default line width for subsequent plots.

Set line width for subsequent plots

Set the global logging level with input validation

Set preferred font and reinitialize if needed. Call before rendering to switch fonts for a style mode.

Set line style pattern for raster

Set rendered state

Set the title for a specific subplot

Set the x-axis label for a specific subplot

Set the y-axis label for a specific subplot

Set figure title

Set the 3D view angles (degrees) and optional camera distance. Mirrors matplotlib's Axes3D.view_init(elev, azim).

Set x-axis label

Set x-axis limits

Set the x-axis scale.

Set x-axis scale type

Set custom x-axis tick positions and optional labels.

Replace the y-data of the first plot line.

Set y-axis label

Set y-axis limits

Set the y-axis scale.

Set y-axis scale type

Set custom y-axis tick positions and optional labels.

Set up data ranges for axes with optional log scaling

Setup the coordinate system for rendering The transformed bounds passed here already include any autoscale margin from calculate_figure_data_ranges, so this routine just hands them to the backend.

Setup or change the figure backend

Setup PNG backend for animation (temporary method)

Setup PNG backend for animation (temporary method)