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 (matplotlib-compatible kwargs)

Object-oriented filled contour helper (matplotlib-compatible kwargs)

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 (matplotlib-compatible kwargs)

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

Object-oriented surface helper (matplotlib-compatible kwargs)

Add surface plot to figure

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.

Draw top x-axis tick labels for ASCII backend

Draw right y-axis tick labels for ASCII backend

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

Draw a horizontal reference line at data value y (matplotlib-compatible)

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

Draw a vertical reference line at data value x (matplotlib-compatible)

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

Bar with per-bar RGB color arrays

Add horizontal bar plot

Barh 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

Add boxplot

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)

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

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

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

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 the position for centered title above plot area

Compute x-position for ylabel to avoid overlapping with y-tick labels

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 (matplotlib-compatible)

Draw filled contour regions (matplotlib-compatible)

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

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

Create line data for histogram visualization as connected rectangles.

Factory function following Dependency Inversion

Factory function following Dependency Inversion

Create 4x4 projection matrix for 3D to 2D transformation

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

Determine decimal places based on step size for nice formatting

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

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 arrow using Unicode directional characters for ASCII backend

Draw axes and labels for ASCII backend

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 using scanline algorithm and alpha blending

Draw antialiased line using distance-based approach

Draw arrow marker in PDF

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 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

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 a matplotlib-style figure using the shared singleton

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].

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 as a label string

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

Get appropriate margins for legend placement DRY: Centralized margin calculation

Get line pattern array for given style Following DRY principle - centralized pattern definitions

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

Toggle or style grid lines (matplotlib-compatible)

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 are too close together for reliable rendering

Check if text contains math segments delimited by '$...$'

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

Add histogram (matplotlib-compatible).

Draw one or more horizontal lines at y values between xmin and xmax

Display 2D array as an image (heatmap)

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

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

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 figure legend (matplotlib-compatible)

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

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

Enable minor ticks on both axes (matplotlib-compatible)

Return config_t matching matplotlib visual defaults.

Complex legend with multiple mathematical functions

Normalize angle to [0, 2*pi) range

Normalize path separators for the target platform

Normalize path for cross-platform compatibility

Check if every plot in the collection is a pie chart

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.

Create a pie chart

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

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

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.

Remove '$' delimiters and escape '^'/'_' outside math so they render literally UTF-8 aware: multi-byte characters are copied as intact sequences

Print centered title to terminal with Unicode-to-ASCII conversion

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 coordinates to 2D using orthographic projection

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

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

Render all plots in the figure

Render axes for ASCII context (stub implementation)

Render compact ASCII legend with proper formatting

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 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

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 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

Render queued streamplot arrows after plot lines are drawn

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

Reset figure state to initial values

Reset pattern distance to start of pattern

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.

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.

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 current figure using matplotlib-compatible API.

Save figure to file (backward compatibility version)

Save figure and return status code for testing scenarios. Applies dpi and silently accepts transparent/bbox_inches.

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

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

Set figure labels

Set axis limits

Set rendered state

Set axis scale types

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 x-axis label

Set x-axis limits

Set x-axis scale (matplotlib-compatible)

Set x-axis scale type

Set custom x-axis tick positions and optionally labels

Replace the y-data of the first plot line.

Set y-axis label

Set y-axis limits

Set y-axis scale (matplotlib-compatible); see set_xscale for kwargs

Set y-axis scale type

Set custom y-axis tick positions and optionally labels

Set up data ranges for axes with optional log scaling

Setup the coordinate system for rendering Adds a small margin to data ranges to prevent boundary data from being clipped by the plot frame stroke.

Setup or change the figure backend

Setup PNG backend for animation (temporary method)

Setup PNG backend for animation (temporary method)

Setup PNG backend for animation

Setup and validate streamplot parameters (validation logic only)

Setup local state for twin axes configuration

Determine if line should be drawn at given distance in pattern Following SRP - handles only pattern position logic

Convenience routine mirroring matplotlib.pyplot.show signature with data

Show the global figure via backend implementation

Display the figure

Launch external viewer with saved figure artifact when available

Check if test should be skipped on Windows CI

Skip an arbitrary JSON value (string, number, bool, null, object, or array) without storing it.

Skip whitespace characters

Smooth a polyline using Catmull-Rom spline interpolation

Simple bubble sort for small arrays (sufficient for boxplot quartiles)

Sort edges by y0 ascending. Quicksort + insertion sort.

Serialize spec_t to a Vega-Lite JSON string

Write spec_t as Vega-Lite JSON to a file

Create a stem plot

Store a pre-processed text element for later ASCII rendering

Get current 0-based byte offset in a stream file.

Stateful streamplot wrapper - delegates to OO interface

Basic validation for streamplot inputs

Add streamline plot to figure - direct streamline generation Streamplot draws arrowheads along streamlines (not full trajectory lines). Arrow rendering happens in render_axes_and_plots after all plots.

Add streamlines for vector field

Matplotlib-compatible streamplot implementation Based on matplotlib streamplot.py (not a line-for-line port)

Select a subplot in an nrows-by-ncols grid (matplotlib-compatible)

Initialize an nrows-by-ncols subplot grid (matplotlib-compatible)

Create subplot grid and return axis indices in row-major order

Subsample ticks in transformed coordinate space for proportional visual spacing.

Suggest appropriate marker type for single point based on backend

Set a centered figure-level title above all subplots

Clean up all registered files and the test directory.

Clean up a specific test file

Get a temporary file path for a test artifact.

Generate reliable unique suffix combining multiple entropy sources

Initialize test environment with specific name

Initialize figure for testing (ensures temp directory exists)

Register a file for automatic cleanup

Save figure to temporary directory with automatic registration

Add text annotation to the current figure

Automatically adjust subplot parameters to give specified padding

Set the title for the current axes. Routes to subplot or figure level.

Convert string to lowercase (ASCII A-Z)

Convert string to lowercase in-place

Convert single character to lowercase

Trace a single contour level with smoothing

Transform annotation coordinates with logarithmic scaling support

Transform data x-coordinate to screen coordinate

Transform data y-coordinate to screen coordinate

Read one unsigned byte (0..255) at a 0-based offset.

Look up the glyph index for a Unicode codepoint in a cmap subtable. Returns 0 when the codepoint is not covered by the subtable.

Find a table by its 4-byte tag in the table directory. Returns the table byte offset, or 0 if not found.