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

Add colored contour plot data

Add filled contour plot with colors

Add basic contour plot

Add contour plot data to internal storage

Store a fill_between polygon for rendering

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

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

Add pseudocolor mesh plot

Add pcolormesh plot data

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

Add 3D surface plot data using structured grid storage

Add text annotation to figure

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

Analyze data to estimate compression ratio Returns value between 0 (incompressible) and 1 (highly compressible)

Add arrow annotation to the current figure

Append a legend line to ASCII backend array

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

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

Assign pending autopct values to legend lines

Draw arrow using backend (compatibility wrapper)

Check if backend is allocated (compatibility wrapper)

Check if backend is allocated

Set backend color (compatibility wrapper)

Set backend color

Draw line using backend (compatibility wrapper)

Draw line using backend

Add vertical bar plot

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 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 total height of mathematical text elements This function signature is used by text_rendering but implementation moved there

Calculate total height of mathematical text elements

Calculate total width of mathematical text elements This function signature is used by text_rendering but implementation moved there

Calculate total width of mathematical text elements

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 seed points using matplotlib-compatible spiral algorithm with collision detection for proper streamline spacing

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

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

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)

Check if a command is available - with security restrictions

Check if a directory exists using inquire

Timeout-protected FFmpeg availability check for Windows CI

Check if a file or directory exists

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

Enhanced baseline comparison with comprehensive analysis

Composite 3D RGB bitmap directly onto raster image buffer

Compress data using fixed Huffman codes with LZ77

Compute which x-axis tick labels can be drawn without overlapping Always shows first and last labels, hides overlapping ones in between

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

Infer vertex edges from center coordinates for uniform grids

Create a box plot

Clear the figure for reuse, preserving backend settings

Create a histogram plot

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

Calculate CRC32 checksum using standard polynomial

Recursively create directory path including parent directories

Create directory with comprehensive security validation Issue #903: Allow legitimate user directories while preserving security

Create and initialize functionality verifier

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 single directory level - robust cross-platform method

Create a grid of subplots

Create a text annotation with specified properties

SECURITY: File deletion disabled for security compliance

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

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.

Disable fast I/O operations

Calculate minimum distance from point to line segment

Integrate streamline using DOPRI5 method with adaptive step size

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 antialiased line using distance-based approach

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 text with mathematical notation

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

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

Public wrapper to guarantee the singleton is ready for use

Ensure numbers like .5 become 0.5 for readability

Add error bar plot to figure

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

Export results in CI-compatible format

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 (compatibility wrapper)

Extract PNG data for animation

Extract PNG data for animation

Extract RGB data for animation (compatibility wrapper)

Extract RGB data for animation

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

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

Initialize the figure with specified dimensions and backend

Add legend to figure

Render a figure, handling both single-axis and subplot layouts.

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 the area under a curve

Fill ASCII canvas with heatmap representation of 2D data

Fill the area between two curves

Fill horizontal line segment

Fill triangle using barycentric coordinates

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

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

Generate default contour levels

Generate technical evidence report

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

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

Get global memory backend instance

Extract parent directory from a path

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

Get current performance configuration

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 safe test output path

Get appropriate temporary directory for tests

Get figure width

Get Windows-safe numerical tolerance

Get appropriate timeout for Windows CI operations with aggressive optimization

Get x maximum value

Get x minimum value

Get y maximum value

Get y minimum value

Enable/disable and configure grid lines

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

Add histogram

Display 2D array as an image (heatmap)

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

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

Initialize debug logging based on FORTPLOT_ZLIB_DEBUG environment variable

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 debug logging is enabled via environment variable Uses a C helper wrapping getenv() to ensure dynamic updates from the current process environment are observed reliably.

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 path is safe from injection attacks

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

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

Demonstrate legend box styling and multiple entries

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

List files and direct child directories without recursion

Load font system from specified path

Log a debug message

Log an error message

Log error message to error unit

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

Map a data value to pixel X coordinate using axis scale

Map a data value to pixel Y coordinate using axis scale Raster coordinates have Y increasing downward; account for that here.

Complex legend with multiple mathematical functions

Determine the next color from the figure palette using plot count

Normalize path separators for the target platform

Normalize path for cross-platform compatibility

Check if every plot in the collection is a pie chart

Open file with default application - SECURITY: Disabled for compliance

Case-insensitive parse for common boolean-ish strings.

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 mathematical text into renderable elements

Parse a path into directory segments

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

Create a pie chart

Legacy API: external tool check disabled for security compliance Always returns .false. to avoid shell-based validation paths

Create a polar plot

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.

Remove '$' delimiters and escape '^'/'_' outside math so they render literally

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

Convert LaTeX-style commands to Unicode while preserving math scopes

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

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

Calculate standard legend position for PNG using plot coordinates

Draw axes and labels for raster backends

Draw axes lines and tick marks WITHOUT labels (for proper drawing order)

Draw all axis labels (title, xlabel, ylabel)

Draw ONLY axis labels and tick labels (for proper drawing order)

Render an xlabel centered above the plot area

Draw only x-axis tick labels (no marks)

Draw x-axis tick labels on the top side (no marks)

Draw only x-axis tick marks (no labels)

Draw x-axis tick marks on the top side (no labels)

Draw x-axis tick marks and labels

Draw x-axis tick marks and labels along the top side

Draw only y-axis tick labels (no marks)

Draw y-axis tick labels on the right side (no marks)

Draw only y-axis tick marks (no labels)

Draw y-axis tick marks on the right side (no labels)

Draw y-axis tick marks and labels

Draw y-axis tick marks and labels along the right side

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

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

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

Register a legend entry for processing

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 legend using ASCII-specific compact layout

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 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 mathematical text elements to image This function signature is used by text_rendering but implementation moved there

Render text with mixed fonts at specific position and size

PDF needs Unicode superscripts converted to mathtext for proper rendering

Render a pcolormesh plot

Render pie slices using triangle fans per wedge

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

Render queued streamplot arrows after plot lines are drawn

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 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 only the figure title without drawing axes

Replace figure state stream arrows and manage rendered flag

Reset ASCII legend lines array

Reset figure state to initial values

Reset pattern distance to start of pattern

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

Main entry point for comprehensive verification

Safe coordinate transformation using independent x/y scales

Safely create directory without shell injection

Safely remove file

Sanitize filename by removing dangerous characters

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

Save figure to file (backward compatibility version)

Save figure and return status code for testing scenarios

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

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 line plot properties (style, color, etc.) Extracted from add_line_plot_data for QADS compliance

Set line width for subsequent plots

Set the global logging level with input validation

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 type

Set y-axis label

Set y-axis limits

Set y-axis scale type

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 (temporary method)

Setup PNG backend for animation (compatibility wrapper)

Setup PNG backend for animation (temporary method)

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

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

Sleep for specified milliseconds with Windows CI safety timeout and performance optimization

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

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

Create a stem plot

Create a step plot

Basic validation for streamplot inputs

Add streamline plot to figure - direct streamline generation

Add streamlines for vector field

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

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

Initialize a subplot grid using the global figure

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

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

Add text annotation to the current figure

Convert string to lowercase in-place

Convert string to lowercase (ASCII A-Z)

Convert single character to lowercase

Transform annotation coordinates with logarithmic scaling support

Transform data x-coordinate to screen coordinate

Transform data y-coordinate to screen coordinate

Try to use system mkdir command as last resort (with security checks)

Activate a secondary y-axis that shares the x-axis but renders on the right

Activate a secondary x-axis that shares the y-axis but renders on the top

Convert Unicode codepoint to ASCII equivalent

Convert Unicode codepoint to PDF escape sequence

Convert Unicode codepoint to Symbol font character

Update data ranges based on boxplot statistics

Update data ranges after adding boxplot

Update data ranges based on current plot

Update data ranges after adding pcolormesh plot

Update data ranges after adding boxplot - delegate to specialized module

Update data ranges after adding pcolormesh plot

Update y data for an existing plot

SECURITY FIX: Pure Fortran directory creation - no system calls

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 grid dimensions for pcolormesh with flexible dimension support

Validate plot data and provide informative warnings for edge cases Added for Issue #432: Better user feedback for problematic data Fixed Issue #833: Reduced warning verbosity for constant data

Validate PNG file using internal signature checks (secure)

Validate arrow size and style inputs (matplotlib compatible)

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 binary string to unit using exact length (no trimming)

Write centered title to file with Unicode-to-ASCII conversion

Write PDF context to file

Write string to unit, handling long strings properly

Compute the rightmost edge of y-tick labels relative to the y-axis

Backwards-compatible wrapper returning an allocatable result

Compress data into a newly allocated buffer

Decompress zlib (deflate) data using fixed Huffman tables