matplotlib

This study addresses the accessibility bottleneck in Jupyter notebooks caused by the absence of high-quality alternative text (alt text) for Matplotlib visualizations. We propose a hybrid generation method that synergistically combines heuristic rules with a large language model (GPT-4-turbo). By parsing Matplotlib’s backend rendering objects, we extract structured tabular data and visual features—such as chart type, axes, labels, and subplot layout—and inject them into LLM prompts, significantly improving factual accuracy and coverage across diverse chart types. The approach supports single-variable plots as well as complex multi-subplot and multi-axis visualizations. We deliver a lightweight Python toolkit enabling one-click alt text generation, validation, and embedding into notebooks. Experimental evaluation on real-world notebooks shows a 37.2% absolute improvement in alt text accuracy for complex charts, balancing automation efficiency with user configurability. To our knowledge, this is the first data-augmented, dual-driven (LLM + rule-based) framework for accessible computational notebooks.

This work addresses the challenge of reproducibility in data visualization scripts, which often lack essential components such as source code, input data, execution environment, or output artifacts. To bridge this gap, we propose yProv4DV—a lightweight Python library that, for the first time, targets script-based visualization workflows by automatically capturing comprehensive provenance information—including source code, input data, runtime environment, and output results—through a single function call. Designed to be minimally invasive and ready-to-use, yProv4DV enables full reproducibility of visualization outputs without requiring any modification to existing scripts. This approach significantly reduces the development burden on researchers striving to ensure reproducibility and fills a critical void in automated provenance support within visualization pipelines.

This work addresses the lack of standardized evaluation for large language models (LLMs) in generating visualization code from tabular data. We introduce PandasPlotBench, the first benchmark dataset specifically targeting Pandas DataFrame visualization—comprising 175 human-annotated tasks spanning Matplotlib, Seaborn, and Plotly. Our methodology employs natural-language instruction-driven code generation, coupled with standardized prompting and execution-based code evaluation. Key contributions include: (1) the first fine-grained, task-level evaluation framework for exploratory data visualization from tables; (2) empirical identification of a significant generalization gap for LLMs on Plotly—despite strong performance on Matplotlib and Seaborn; (3) demonstration of robustness to concise instructions across the latter two libraries; and (4) open-sourcing of both the benchmark dataset and evaluation framework, which has been widely adopted by the research community.

This work addresses the “last-mile” gap between executable code and publication-ready academic figures by proposing chart-plot, an intelligent agent framework for end-to-end generation and precise editing of conference-quality visualizations. The approach innovatively distills target conference figure style guidelines into textual skill instructions to guide large language models in style-conditioned code generation. It further establishes a rendering feedback loop within a LaTeX environment to iteratively refine layout and introduces a structured figure representation enabling direct, element-level manipulation. Experimental evaluations across three representative academic chart types and user studies demonstrate that the framework substantially reduces manual revision cycles while significantly improving both the quality and efficiency of figure production.

This work addresses the computationally challenging problem of efficiently enumerating small-scale pseudoline arrangements and abstract order types. We propose a customized algorithmic framework integrating symbolic computation, backtracking search, and combinatorial constraint pruning, augmented by canonical-form normalization and isomorphism testing to eliminate structural redundancies. Our approach achieves, for the first time, the complete and provably correct enumeration of all abstract order types on 12 points and all pseudoline arrangements of 11 pseudolines—thereby filling a critical gap in existing combinatorial geometry databases. The resulting experimental toolkit substantially enhances both the feasibility and efficiency of systematic exploration of discrete geometric configurations. It provides essential infrastructure for empirical research in computational geometry, discrete geometry, and formal verification, enabling rigorous experimentation with complex combinatorial structures previously beyond reach.

This work proposes a Pythonic adaptation of the PIMPL (Pointer-to-Implementation) design pattern to address the challenge of maintaining stable APIs in large, evolving Python libraries, where users often inadvertently depend on internal implementation details. By introducing lightweight public objects that delegate calls opaquely to hidden implementations, the approach effectively isolates internal complexity. The design systematically integrates module-level indirection, facade objects, backend dispatching, and lazy imports to construct a decoupled encapsulation architecture. Empirical evaluation demonstrates that this paradigm enables runtime backend switching and lazy loading, significantly enhancing API stability and long-term maintainability in both the Python standard library and scientific computing ecosystems. The resulting pattern offers a general, reusable solution for robust library design in Python.

Existing Plot2API approaches struggle with hand-drawn charts from non-expert users, primarily due to domain gaps and the absence of tailored training data. To address this limitation, this work introduces HDpy-13, the first dedicated dataset of hand-drawn charts, and proposes a lightweight Plot-Adapter architecture. The design leverages independent adapter modules that integrate CNN-based local feature enhancement with shared projection matrices, enabling efficient graphical API recommendation across multilingual and multidomain scenarios. By decoupling task-specific adaptation from the base model, the approach substantially reduces both parameter count and computational overhead while maintaining high recommendation accuracy. Experimental results demonstrate the method’s effectiveness and scalability under the paradigm of parameter-efficient fine-tuning (PEFT), offering a practical solution for real-world deployment in diverse user environments.

This work addresses the lack of effective support for Kendall’s 3D shape space in existing Python libraries—such as Geomstats—which has hindered the practical application of Riemannian geometry in three-dimensional shape analysis. We present the first systematic implementation of an efficient and user-friendly Python toolkit tailored specifically to Kendall’s 3D shape space, enabling scale-, position-, and orientation-invariant shape modeling and statistical analysis. By providing a ready-to-use, open-source solution for shape statistics on manifolds, this contribution fills a critical software gap in advanced 3D shape analysis, substantially lowering the barrier to entry for researchers, improving computational efficiency, and enhancing the reproducibility of results.

Robotics research has long suffered from a lack of accessible, high-quality visualization tools; while Blender is powerful, its steep learning curve and lack of native robotics support hinder adoption. This paper introduces the first lightweight Blender-based robotics visualization library, implemented via Blender’s Python API to enable standardized URDF model import, state-driven keyframe animation generation, and parametric 3D primitive modeling. The library requires no prior Blender expertise and reduces the creation time for publication-grade figures, schematic diagrams, and demonstration animations to minutes. Its core contribution is an end-to-end visualization pipeline tailored for robotics research—integrating URDF parsing, dynamic simulation visualization, and schematic generation into a unified framework. This significantly lowers the barrier to scientific visualization, enhances the expressiveness and reproducibility of research results, and streamlines communication of robotic system behavior and design principles.

Existing visualization tools suffer from fragmentation between static and interactive paradigms as well as between desktop and web environments, hindering write-once, run-anywhere reusability. This work proposes Pluot, a novel architecture that establishes a unified rendering core implemented in Rust and automatically generates language bindings for Python, JavaScript, and other ecosystems. Pluot enables cross-platform, cross-interactivity reproducible execution while unifying publication-quality static graphics with dynamic interactive experiences—an integration previously unachieved. The system delivers both high performance and high-fidelity visual output, addressing a critical gap in the visualization landscape. The implementation is open-sourced at https://pluot.dev.