Procedures

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

Add a 3D line plot with optional markers Provides direct access to figure's 3D plotting capabilities

Add arrow annotation to figure

Add a box plot to the plot array

Add colored contour plot data

Direct interface to figure's add_contour method for testing

Direct interface to figure's add_contour_filled for testing

Add filled contour plot with colors

Add basic contour plot

Add contour plot data to internal storage

Add an errorbar plot with error bars Provides direct access to figure's add_errorbar method

Add line plot data with comprehensive validation Refactored to be under 100 lines (QADS compliance)

Add line plot data to internal storage with edge case validation Fixed Issue #432: Added data validation for better user feedback

Direct interface to figure's add_pcolormesh for testing

Add pseudocolor mesh plot

Add pcolormesh plot data

Direct interface to figure's add_plot method for testing

Direct interface to figure's add_scatter method for testing

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

Add scatter plot data with optional properties

Add a simple streamline to demonstrate functionality This creates a basic horizontal streamline that shows streamplot is working for the test suite.

Add streamline trajectory to figure as line plot

Add a plot to a specific subplot

Add surface plot to figure

Add a 3D surface plot with optional colormapping Provides direct access to figure's 3D surface capabilities

Add text annotation to figure

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

Stub for annotation with arrow

Apply colormap to array of values efficiently

Apply inverse scale transformation to recover original value

Apply marching squares lookup table to get line segments

Apply forward scale transformation to a single value

Assert that performance meets target

Check if backend is allocated (compatibility wrapper)

Set backend color (compatibility wrapper)

Draw line using backend (compatibility wrapper)

Add a bar plot to the global figure (pyplot-style)

Add vertical bar plot

Add a horizontal bar plot to the global figure (pyplot-style)

Add horizontal bar plot

Basic legend usage with labeled plots

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

Alpha blend a pixel with existing pixel data

Add a box-and-whisker plot to the global figure (pyplot-style)

Add boxplot

Calculate aligned text position based on alignment settings

Calculate ASCII-specific legend dimensions

Calculate ASCII-specific legend position using character coordinates

Calculate overall data ranges for the figure with robust edge case handling Fixed Issue #432: Handles zero-size arrays and single points properly

Calculate histogram bin edges and counts from data

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

Calculate marching squares configuration for a cell

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 based on canvas size and margins (matplotlib-compatible) Note: left/bottom are margins, right/top are edge positions

Calculate bounds of projected 2D data

Calculate bounding box for rotated text

Calculate bounding box for rotated text

Calculate seed points using matplotlib-compatible spiral algorithm with collision detection for proper streamline spacing

Calculate anchor position based on alignment settings

Calculate the pixel height of text using STB TrueType

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

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)

Securely check if a command is available

Check if a command is available - with security restrictions

Timeout-protected FFmpeg availability check for Windows CI

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

Clamp extreme logarithmic ranges to ensure usable plots

Clean up STB TrueType font system

Clear the color cache

Clear global memory backend

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

Compute tick positions for different scale types

Configure figure dimensions

Configure grid settings

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

Check if text contains Unicode characters

Add a contour plot to the global figure (pyplot-style)

Python-accessible contour function

Add a filled contour plot with color levels to the global figure

Python-accessible filled contour function

Calculate CRC32 checksum using standard polynomial

Generate 8 corners of 3D bounding box

Generate 3D axis lines (X, Y, Z axes)

Generate 3D tick mark positions on axes

Create directory with security restrictions SECURITY: Only allows creation of test output directories

Securely create a directory path using C system calls

Create line data for histogram visualization as connected rectangles

Factory function following Dependency Inversion

Create complete PDF document structure

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

SECURITY: File deletion disabled for security compliance

Securely delete a file using system calls

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 with realistic data

Basic pcolormesh with simple gradient - enhanced 51x51 grid

Demo different colormaps - enhanced 51x51 grid

Demonstrates different colored markers with realistic data

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

Creates a scatter plot to demonstrate markers in practical use

Pcolormesh with sinusoidal pattern - enhanced 51x51 grid

Clean up text annotation resources

Disable fast I/O operations

Calculate minimum distance from point to line segment

Integrate streamline using DOPRI5 method with adaptive step size

Draw 3D axes frame to raster backend - matplotlib style

Draw arrow using Unicode directional characters for ASCII backend

Draw axes and labels for ASCII 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 antialiased line using distance-based approach

Draw a line with the specified style

Draw 3D axes frame - see issue #494 for implementation roadmap

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

Enable fast I/O operations

End timing a performance test

Stub: Ensure directory exists for given filepath (see issue #492)

Ensure global figure is initialized before use (matplotlib compatibility) Auto-initializes with default dimensions if not already initialized

Add an errorbar plot to the global figure (pyplot-style)

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

SECURITY: Command execution with timeout disabled for security compliance

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

Extract polygonal regions between contour levels using marching squares

Extract PNG data for animation (compatibility wrapper)

Extract PNG data for animation

Extract RGB data for animation (compatibility wrapper)

Extract RGB data for animation

Fast file existence check (may use memory backend)

Fast file size check (may use memory backend)

Fast savefig that can use memory backend when appropriate

Python-accessible figure initialization

Create or activate a figure with optional size and DPI settings

Add a contour plot to the figure

Add a filled contour plot with color mapping

Add a pcolormesh plot

Add a line plot to the figure

Fill ASCII canvas with heatmap representation of 2D data

Find any available font using same priority order as system initialization

Find font by name in typical system locations

Find nice tick locations following matplotlib's MaxNLocator algorithm exactly

Format logarithmic tick values using scientific notation like matplotlib

Simple number formatting for annotations

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

Generate default contour levels

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 Refactored to be under 100 lines (QADS compliance)

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 global CI performance monitor

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 fast I/O statistics

Get Windows performance-optimized temporary directory Priority order for Windows performance: 1. RAMDISK if available (fastest) 2. Local temp directory 3. System temp directory

Get figure height from state

Get figure height (compatibility wrapper)

Get number of plots from state

Get number of plots (compatibility wrapper)

Get pointer to plots array

Get rendered state

Get rendered state (compatibility wrapper)

Get figure width from state

Get figure width (compatibility wrapper)

Get x maximum value from state

Get x maximum value (compatibility wrapper)

Get x minimum value from state

Get x minimum value (compatibility wrapper)

Get y maximum value from state

Get y maximum value (compatibility wrapper)

Get y minimum value from state

Get y minimum value (compatibility wrapper)

Get the ratio of font ascent to total height This is used to properly center text vertically

Get font metrics in pixels for current font

Get reference to the global figure for testing access to arrow data This allows tests to access fig%arrow_data without making fig public

Get appropriate margins for legend placement DRY: Centralized margin calculation

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

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

Get global memory backend instance

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

Get current performance configuration

Get platform-appropriate tolerance for numerical comparisons Addresses Issue #297: Windows CI precision differences

Get the number of plots in a specific subplot

Get the title for a specific subplot

Get cross-platform test output path with automatic directory creation

Get appropriate temporary directory for tests

Get Windows-safe numerical tolerance

Get appropriate timeout for Windows CI operations

Check if coordinates are too close together for reliable rendering

Add a histogram to the global figure (pyplot-style)

Add histogram

Alias for hist to match numpy.histogram naming

Python-accessible histogram function

Initialize STB TrueType font system with robust font discovery

Initialize the appropriate backend based on type

Initialize figure state with specified parameters

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

Convert integer to string

Bidirectional streamline integration like matplotlib Integrates both forward and backward from seed point for complete streamlines

High-accuracy streamline integration using DOPRI5 method Provides adaptive step size control and superior accuracy

Interpolate the positions where contour crosses cell edges

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

Integer part of floating-point number

Check if annotation is visible within plot area

Check if backend is allocated

Check if running in CI environment

Check if arrays are empty

Check if status code indicates an error

Check if codepoint is a Greek letter

Check if ImageMagick environment is enabled

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

Check if path is safe (no shell injection attempts)

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

Detect if running on Windows at runtime

Add a legend to the global figure (pyplot-style)

Python-accessible legend function

Demonstrate legend box styling and multiple entries

Render legend following Liskov Substitution Works with any backend that implements plot_context interface

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

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

Complex legend with multiple mathematical functions

Normalize a coordinate value to [0,1] range

Normalize path separators for the target platform

Normalize path for cross-platform compatibility

Securely open a file with system default application

Open file with default application - SECURITY: Disabled for compliance

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

Add a pseudocolor plot to the global figure (pyplot-style) Creates a colored mesh representation of 2D data

Python-accessible pcolormesh function

Get height scale - now returns 1.0 since page size matches figure size

Get width scale - now returns 1.0 since page size matches figure size

Add a line plot to the global figure (pyplot-fortran compatible)

Python-accessible plot function for line plots

Demonstrate different legend positions

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

Print centered title to terminal

Project 3D axis lines to 2D screen coordinates

Project 8 3D corners to 2D screen coordinates

Project 3D coordinates to 2D using orthographic projection

Project normalized 3D data to 2D using default viewing angles

Draw axes and labels for raster backends

Render rotated Y-axis label for PNG backend

Render all plots in the figure

Render axes for ASCII context (stub implementation)

Render compact ASCII legend with proper formatting

Render legend using ASCII-specific compact layout

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

Render a contour plot

Render figure axes and labels

Render figure background

Render grid lines on the figure

Render a line plot with proper scaling and clipping

Render markers for a plot

Render a line with dash patterns

Render a pcolormesh plot

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

Render a solid line

Render standard legend for PNG/PDF backends with improved sizing Refactored to be under 100 lines (QADS compliance)

Render stored text elements onto the ASCII canvas

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

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

Reset figure state to initial values

Reset pattern distance to start of pattern

Restore original coordinate system after 3D rendering

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

Safely check if external program is available

Safe coordinate transformation with aspect ratio preservation Updated to maintain correct aspect ratios like normalize_to_pdf_coords

Safely create directory without shell injection

Safely launch file viewer without shell injection

Safely remove file without shell injection

Safely validate MPEG files without shell injection

Sanitize filename for safe file operations

Save original coordinates and set new backend coordinate system

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

Python-accessible savefig function

Save the global figure to a file (pyplot-style)

Save figure with status return (error handling version)

Add a scatter plot to the global figure (pyplot-style)

Python-accessible scatter plot function

Select font family with fallback mechanism

ASCII doesn't use line widths - no-op

Set backend color

Set figure labels

Set axis limits

Set rendered state

Set rendered state (compatibility wrapper)

Set axis scale types

Set the line width for subsequent plot elements This affects all plot elements added after this call

Set the global logging level

Set line style pattern for raster

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 the x-axis scale type (linear, log, symlog)

Python-accessible x-axis scale function

Update y-data for the last plot added to the figure Useful for animation or updating existing plots

Set the y-axis scale type (linear, log, symlog)

Python-accessible y-axis scale function

Setup coordinate system for 3D projection rendering

Set up data ranges for axes with optional log scaling

Setup the coordinate system for rendering

Setup or change the figure backend

Setup figure legend

Setup PNG backend for animation (compatibility wrapper)

Setup PNG backend for animation

Setup and validate streamplot parameters (focused on validation logic)

Configure Windows-specific performance optimizations This should be called at the start of test suites on Windows CI

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

Determine if memory backend should be used for current context

Python-accessible show_figure function with optional blocking This replaces the temp file + webbrowser approach with direct Fortran call

Python-accessible show_viewer function with optional blocking Forces display in system viewer regardless of GUI availability

Display figure using system viewer (cross-platform)

Determine if test should be skipped on slow CI

Check if test should be skipped on Windows CI

Sleep for specified milliseconds using Fortran intrinsic

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

Start timing a performance test

Clean up font resources

Find glyph index for Unicode codepoint

Free bitmap allocated by stb_get_codepoint_bitmap

Allocate and render character bitmap

Get bounding box for character bitmap

Get horizontal character metrics in unscaled coordinates

Get vertical font metrics in unscaled coordinates

Initialize font from file path

Render character into provided buffer

Calculate scale factor for desired pixel height

Add a streamplot to the global figure (pyplot-style) Creates streamlines from a vector field

Python-accessible streamplot function with arrow support

Basic validation for streamplot inputs

Add streamlines for vector field

Matplotlib-compatible streamplot implementation Following the EXACT algorithm from matplotlib/streamplot.py

Create subplot arrangement (simplified for single axis) Currently implements single plot behavior

Suggest appropriate marker type for single point based on backend

SECURITY: System command wrapper disabled for security compliance

Clean up all registered files and test directory securely

Clean up a specific test file

Get secure temporary file path with validation

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

Stub for text annotation

Set the title for the global figure (pyplot-style)

Python-accessible title function

Convert string to lowercase

Transform annotation coordinates based on coordinate type (Issue #184)

Transform annotation coordinates with logarithmic scaling support

Transform projected corners from data space to screen space

Transform quad coordinates to screen coordinates

Transform quad coordinates to screen space

Transform data x-coordinate to screen coordinate

Transform data y-coordinate to screen coordinate

Convert Unicode codepoint to ASCII equivalent

Update data ranges based on boxplot statistics

Update y data for an existing plot

Check if fast test mode should be used

Determine the number of bytes in a UTF-8 character

Convert UTF-8 sequence to Unicode codepoint

Comprehensive annotation validation combining coordinate and parameter checks

Validate annotation coordinate values

Validate annotation parameter values

Validate color for specific backend constraints

Validate if colormap name is supported

Comprehensive validation of coordinate arrays for plotting Returns validation result with detailed information about the data

Validate that coordinate values are finite and reasonable

Validate if marker style is supported

Validate a file or directory path for security

Validate grid dimensions for pcolormesh

Validate plot data and provide informative warnings for edge cases Added for Issue #432: Better user feedback for problematic data

Alias for validate_annotation_parameters for API compatibility

Validate typography-specific parameters with normalization support

Wait for user input when blocking=true Reads a single character or line from stdin to pause execution This prevents the program from continuing until user interaction

Write RGB bitmap as simple 24-bit BMP file

Write centered title to file

Write PDF context to file

Write string to unit, handling long strings properly

Set the x-axis label for the global figure (pyplot-style)

Python-accessible xlabel function

Set the x-axis limits for the global figure (pyplot-style)

Python-accessible x-axis limits function

Set the y-axis label for the global figure (pyplot-style)

Python-accessible ylabel function

Set the y-axis limits for the global figure (pyplot-style)

Python-accessible y-axis limits function

Full deflate compression with LZ77 and Huffman coding