Papers for

data visualization engineers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Iterative visual feedback improves plot to code generation quality

Simple Test-Time Refinement for Plot-to-Code Generation via Visual-Code Diagnostics

Abstract: Plot-to-code generation has been greatly advanced by recent multimodal large language models (MLLMs). However, existing studies mainly focus on one-pass generation or iterative sampling guided by verifier-based filtering, which does not align with the typical human programming workflow of generate first, then iteratively error-location and fix. This naturally motivates a test-time refinement paradigm for plot-to-code generation. In this work, we present the first study on plot-to-code generation via iterative test-time refinement. We propose a Visual-Code Diagnostics framework that enables refinement through visual feedback from source code. Specifically, we first categorize generation errors into four coarse-grained types, and then train lightweight discriminators to recognize and localize these errors based on the rendered visual outputs and corresponding code. Unlike traditional compiler- or debugger-based verification, our approach performs iterative refinement guided by one diagnostics system, enabling more effective semantic and visual correction during test time. Extensive experiments demonstrate that our method consistently improves generation quality across diverse generators and significantly outperforms strong test-time scaling baselines.

Sat 7 NovComputation and LanguageComputer Vision and Pattern Recognition
The gist
Turning pictures of plots into computer code that recreates them is tricky and often has mistakes. The authors introduce a way to catch and fix errors by looking at both the code and the pictures it produces repeatedly, similar to how people debug programs. They train small models to spot four main types of errors based on how the pictures look compared to the code. By using these visual clues to guide fixes step-by-step, their method improves the accuracy of generating code from plot images.
Open → 2611.10840v1

Eunoia library creates accurate set diagrams across popular languages

Eunoia: Area-Proportional Euler and Venn Diagrams in Rust, Julia, Python, R, and JavaScript

Abstract: Area-proportional Euler diagrams visualize sets and their intersections through regions whose areas represent their sizes. Because many set specifications have no exact geometric representation, constructing these diagrams requires numerical optimization and diagnostics that quantify the remaining discrepancies. Eunoia is a Rust library for fitting area-proportional Euler diagrams and constructing canonical Venn diagrams. It supports circles, ellipses, squares, and rectangles, computes region areas analytically, and provides exact analytical gradients for several shape families. Its fitting pipeline combines multidimensional scaling initialization with local refinement, global optimization when needed, and seeded restarts. Fitted layouts include residuals and goodness-of-fit statistics that help users assess how faithfully a diagram represents the data. Shared plotting routines extract region polygons, place labels, and pack unit glyphs and member names within regions. The same core implementation powers packages for R, Python, Julia, and JavaScript, a C interface, and a web application that fits diagrams entirely in the browser through WebAssembly. By centralizing fitting, geometry, diagnostics, and annotation in an independent library, Eunoia provides consistent set visualization across programming languages and interactive applications.

Sun 1 NovMathematical Software
The gist
Visualizing overlapping groups can be tricky because their relationships don't always fit nice shapes perfectly. The authors developed Eunoia, a software library that draws diagrams where the size of each overlapping area matches the group's size as closely as possible. It uses smart math tricks and checks how well the drawing fits the real data. Eunoia works in many programming languages and even inside web browsers, making it easier for people to create clear visuals about how groups relate.
Open → 2611.02198v1

Mapping squares to cubes with optimal smoothness exponent

On surfaces, that fill the space

Abstract: The article is devoted to the construction of dimension-raising maps of cubes with the highest possible Holder exponent. In particular, a square-to-cube mapping with a Holder exponent of $2/3$ is constructed, which is a solution to the V.I.Arnold problem.

Tue 27 OctComputational Geometry
The gist
The paper deals with mapping a square shape into a cube in a way that stretches it smoothly but as much as possible, measured by something called the Holder exponent. The authors find a mapping from a 2D square to a 3D cube with a Holder exponent of two-thirds, which is the best possible smoothness level. This solves a known mathematical problem posed by V.I. Arnold. Their work helps understand how to fill higher-dimensional spaces with lower-dimensional shapes smoothly.
Open → 2610.36766v1

Two-walk spectral ordering improves mosaic heatmap clarity and layout

MHeatmap: Two-Walk Laplacian Reordering and Mosaic Layout for Rectangular Matrix Visualization

Abstract: Weighted rectangular matrices record relations between two types of objects, such as occupations and industries, documents and terms, origins and destinations, or annotated classes and computed clusters. Their heatmaps become difficult to read when arbitrary row and column orders scatter related objects, while equal size cells hide large differences in row and column totals. We present MHeatmap (Mosaic Heatmap), which addresses these problems in two stages. Two-Walk spectral seriation first represents the matrix as a weighted bipartite graph. Ordinary bipartite ordering uses only observed row to column links. Two-Walk also uses length-two walks, so rows that share columns and columns that share rows receive explicit similarity links. Sorting a Fiedler vector of the resulting graph Laplacian gives coordinated row and column orders. The Mosaic layout then partitions a unit square so that row height is proportional to the row total and column width is proportional to the column total, while color represents the observed entry. We prove how the Two-Walk energy combines direct alignment with shared-neighbor smoothness, derive an exact matrix vector product that permits sparse computation, and formalize the tiling and area semantics of Mosaic. Across 300 synthetic matrices and seven real data sets, Two-Walk obtains the lowest normalized 2-SUM in all 15 synthetic regimes and the highest Band@10% in 14. The largest gains occur when shared neighborhoods express the latent relational structure.

Wed 21 OctMachine LearningHuman-Computer Interaction
The gist
Big tables showing relationships between two groups, like jobs and industries, can be hard to understand if the rows and columns are all mixed up. This paper presents a way to reorder these tables by looking not just at direct connections but also at shared connections to better group related items. After sorting, the table cells are resized so that bigger totals stand out, making the heatmap easier to read. The authors tested their method on lots of made-up and real data and found it worked better than other techniques at revealing hidden patterns.
Open → 2610.29114v1

Invertible mapping improves 2D visualization of complex data

NFMap: Topographic 2D Manifold Learning with Invertible Normalizing Flows

Abstract: We present NFMap, a dimensionality reduction method for 2D visualisation that extends Generative Topographic Mapping (GTM) with a bijective normalizing flow. Like GTM, NFMap places a fixed mixture grid prior over a 2D latent map, giving a parametric embedding, an explicit likelihood, and the ability to project new points onto an existing map; the likelihood is an effective out-of-distribution signal on chemical datasets. Unlike GTM, whose latent-to-data mapping is an RBF network of bounded flexibility, NFMap's mapping is a normalizing flow, and is therefore fully invertible: any location on the map can be carried back to data space. To alleviate map crowding on large datasets, NFMap additionally supports heavy-tailed Student-t mixture components. NFMap maps data to a latent space of the same dimension, split into a 2-dimensional navigable map and an off-manifold residual. Because the flow is bijective and its objective penalises volume contraction, variance squeezed out of the residual must reappear in the navigable map. The residual scale is the main control between local neighbourhood fidelity and global distance fidelity; its effect depends on the dimensionality of the data and is coupled to the extent of the latent grid.

Mon 12 OctMachine Learning
The gist
Reducing complex data to two dimensions for visualization is tricky because some methods lose important details or are hard to interpret. The authors introduce NFMap, a technique that creates a reversible and clear 2D map of data while retaining important information. This method allows users to go back and forth between the 2D map and original data points, improving how new data can be visualized and understood. It also balances showing detailed neighborhood relationships and global distances better than previous methods.
Open → 2610.16750v1

Unified multimodal models improve themselves by swapping training tasks

Recursive Self-Improvement in Unified Multimodal Models

Abstract: Unified multimodal models (UMMs) understand and generate both text and images, which lets a model produce its own training data. Existing self-improvement in UMMs keeps supervision on the visual side, where image understanding judges image generation. We propose recursive cross-capability self-improvement (RSI), a training loop in which the text and visual abilities of a UMM supply training data for one another. In each round, the model generates images and reads them to find where it falls short. It then writes programs aimed at these shortcomings, and execution verifies every result against its specification. Verified renders train image generation, while labeled renders and the model's own correct programs train visual understanding and program writing. Program execution thus acts as a source of truth outside the model, so errors do not accumulate across rounds. We study RSI on charts and build BasicChartBench to evaluate open models early in training. On requests worded differently from training, four rounds of RSI raise the score from 45.7% to 60.2%, while continued training stays at 46.3%. Verified construction carries most of the gain, and targeting the model's failures adds 3.5%. Along the way, the share of verified programs rises from 48.9% to 95.2%, and the reader's accuracy on edited renders rises from 55.6% to 87.4%.

Fri 2 OctComputation and LanguageComputer Vision and Pattern Recognition
The gist
Unified multimodal models can understand and create both text and images. The authors propose a method where the model improves itself by generating images and then checking how well it understands those images using its own text skills. By writing simple programs to fix mistakes and verifying their correctness externally, the model avoids accumulating errors over time. This process helps the model get better at both creating images and understanding them, especially for chart-related tasks.
Open → 2610.03002v1

Multimodal agents struggle to fix and check flawed data visualizations

VisAudit: Evaluating Multimodal Agents for Visual Diagnosis and Repair

Abstract: Multimodal agents are increasingly used for data visualization tasks but remain limited in autonomous review. Unlike humans, they may fail to recognize when a visualization is incorrect, determine what to change, repair it without disrupting correct content, and verify whether the intervention succeeded. Existing benchmarks largely evaluate predefined individual capabilities such as chart generation, instruction-guided editing, or defect detection, and therefore do not capture this gap in autonomous review. We introduce VisAudit, a benchmark for evaluating visualization diagnosis, repair, and verification. Given a rendered chart and configurable auxiliary evidence, including its source data table, intended text summary, and visualization code, an agent iteratively diagnoses potential defects, modifies and executes visualization code, inspects execution and visual feedback, and determines when no further intervention is needed. VisAudit defines three tracks spanning diagnosed repair, autonomous repair, and open-world verification, and contains 1,900 flawed instances across 21 chart types and 10 flaw categories, together with 300 initially correct charts. We construct the benchmark through controlled perturbations of validated source visualizations, with systematic verification and human-aligned quality control to ensure that injected defects are well-defined and recoverable from the available evidence. Experiments with leading multimodal models reveal a substantial gap from reliable autonomous review: the strongest evaluated model fully recovers only $47.4\%$ of flawed charts in the autonomous-repair setting.

Thu 1 OctMachine Learning
The gist
Charts and graphs often contain mistakes, but current AI tools find it hard to detect and fix these errors on their own. The authors created VisAudit, a test system that gives AI agents flawed charts along with related data, then checks if they can spot and repair the problems correctly without breaking other parts of the visualization. They found that even the best AI model fixed less than half of the flawed charts entirely on its own. This shows there is still a big gap before AI can reliably review and repair visualizations like humans can.
Open → 2610.02399v1

Visual density reduces accuracy of AI chart data extraction

ChartDensity-Bench: Benchmarking MLLMs for Numerical Data Reconstruction under Visual Density

Abstract: Multimodal large language models (MLLMs) offer a promising approach for recovering numerical data from scientific charts, but their ability to reconstruct chart data from visually dense figures remains poorly understood. Existing chart understanding benchmarks primarily evaluate question answering or chart-level reasoning and provide limited support for evaluating structured numerical reconstruction from scientific figures. We introduce \textbf{ChartDensity-Bench}, a benchmark for evaluating MLLMs on structured numerical data reconstruction from compound chart figures under controlled visual density. Built from charts paired with source-level ground-truth data, ChartDensity-Bench systematically varies the number of simultaneously presented charts ($k\in{1,3,6,9}$), enabling controlled evaluation of density-induced degradation. We further propose a multi-dimensional evaluation framework covering structural reliability, reconstruction completeness, parseability, and numerical fidelity. Experiments on five recent MLLMs show that numerical reconstruction generally degrades as visual density increases, while the magnitude of degradation varies substantially across models. Chart-level paired comparisons further show that the same source chart can incur higher reconstruction error when embedded in denser visual contexts. These findings highlight visual density as an important and previously underexplored factor in MLLM chart data reconstruction and provide a systematic benchmark for evaluating model robustness in this setting.

Wed 30 SeptMachine LearningArtificial Intelligence
The gist
Extracting exact numbers from scientific charts is challenging when many charts appear close together. The authors created a new benchmark called ChartDensity-Bench to test how well AI models can recover numerical data from multiple charts shown at once. They found that as more charts are shown together, AI performance drops, but some models handle the clutter better than others. This work helps understand AI limits when reading complex scientific visuals and provides a tool for testing improvements.
Open → 2609.38781v1

Chartrevise dataset improves exact chart code editing evaluation

ChartRevise: A Dataset and Evaluation Protocol for Exact Chart Editing via Code

Abstract: Chart editing requires cross-modal edit grounding, realizing a requested visual change in the code that draws it, with necessary related updates and without altering unrelated content. Existing benchmarks emphasize either code executability or chart quality, but their metrics do not clearly distinguish request completion from missed coupled updates and gratuitous changes. We introduce ChartRevise, a structured dataset and evaluation protocol for exact program-grounded chart editing. For dataset construction, we build on the grammar of graphics to systematically cover chart-editing operations, using source-program checks to verify their applicability across chart types and libraries. To improve edit exactness, our pipeline checks individual requirements and guides repair or exclusion when they are unmet. The resulting dataset contains 92,438 records covering 344 edit types across 20 chart types and three plotting libraries. For evaluation, our reference-free protocol separately measures atomic requirement completion, identifies gratuitous changes, and detects missed coupled updates. These checks are combined with successful execution and rendering to determine exact-edit success. Across five models and four external benchmarks, fine-tuning yields relative gains of 16\% in mean requirement recall and 22\% in mean exact-edit rate.

Tue 29 SeptArtificial IntelligenceComputer Vision and Pattern Recognition
The gist
Editing charts by changing the code behind them is tricky because the edits need to exactly match the request without breaking anything else. The authors created ChartRevise, a large collection of chart edits with clear rules about which changes are needed and which are not. They also designed a way to check how well editing systems perform by measuring if all requested changes were made exactly and no extra changes happened. Their tests show training models on ChartRevise improves accuracy in making precise chart edits.
Open → 2609.38642v1

LegendBench diagnoses chart legend reading errors in AI models

LegendBench: A Diagnostic Benchmark for Legend Understanding with Counterfactual Interventions

Abstract: Legends are fundamental to chart understanding, as reliable interpretation requires correctly binding legend entries to corresponding visual marks. While vision-language models (VLMs) are increasingly applied to chart understanding, their legend understanding is poorly diagnosed by aggregate accuracy, which can be satisfied by superficial shortcuts and confound legend-specific errors with other reasoning failures. To enable fine-grained diagnosis and controlled testing, we introduce LegendBench, a parametric benchmark and generation pipeline that produces targeted legend-centric test cases. LegendBench contributes (1) a capability-task taxonomy spanning legend parsing, legend grounding, legend-conditioned reasoning, and legend-aware abstention to localize failures, and (2) counterfactual group generation, where each base chart yields multiple variants under controlled legend interventions to probe model invariance and sensitivity. Using LegendBench, we evaluate both general-purpose VLMs and specialized chart models and generate their capability profiles, revealing persistent bottlenecks in reliable legend-to-mark binding and counterfactual consistency. We then use these capability profiles to guide targeted fine-tuning, demonstrating that bottleneck-specific interventions can effectively close the localized capability gaps and generalize to unseen data. We further leverage our counterfactual design to conduct fine-grained diagnostic experiments, analyzing encoding-channel effects, legend-order shortcuts, and abstention under varying visibility.

Mon 21 SeptComputer Vision and Pattern Recognition
The gist
Charts have legends that explain what the colors or symbols mean, but it's hard for AI models to correctly connect those legends to the right parts of the chart. The authors created LegendBench, a tool that makes test charts with tricky legends to see where AI models make mistakes. This helps find specific problems with how the AI reads legends, and by fixing those, models get better at understanding charts overall. They also tested different tweaks to improve AI performance and analyzed how models handle tricky legend details.
Open → 2609.24172v1

Universal small point sets improve planar graph drawings

Almost Linear Universal Point Sets for Planar Graphs

Abstract: A point set is universal for planar graphs on $n$ vertices if every such graph has a straight-line drawing without crossings whose vertices belong to the set. We construct universal point sets of size $n^{1+o(1)}$, improving the previous quadratic upper bound. Our construction uses the reduction of Bannister, Cheng, Devanny, and Eppstein from universal point sets to superpatterns for $213$-avoiding permutations. We represent these permutations by ordered rooted forests and construct a small family of intervals containing every such forest. The result follows from a straightforward bound on the size of the family of intervals. GPT-6 Astra assisted in developing the construction and proof.

Thu 10 SeptComputational Geometry
The gist
Drawing any network without lines crossing can be tricky. The authors found a way to pick almost the smallest number of points needed so that any network with a certain number of points can be drawn without overlaps using those points. They built on earlier work linking these drawings to special sequences called permutations. This helps to better understand how to arrange points for neat network drawings.
Open → 2609.10916v1

Chart layer understanding and editing reveal visibility challenges

Charts Are Beyond Pixels: Probing for Layer-Wise Chart Understanding and Editing

Abstract: Charts are structured visual compositions whose elements have distinct functional roles, semantic correspondences, and visibility relations. This structural view motivates evaluating whether models can understand and manipulate charts at the layer level. Existing chart benchmarks, however, primarily assess the correctness or fidelity of final outputs and do not directly evaluate these layer-wise behaviors. We present LayerWiseBench, a benchmark organized around three core concepts, layer attribution, layer binding, and visibility ordering, that structure its chart-understanding and chart-editing evaluations. Generated from executable chart programs, LayerWiseBench pairs each rendered chart with spatially aligned per-layer RGBA assets and construction-derived labels for functional roles, semantic bindings, and visibility relations. From this layer-wise representation, we derive controlled understanding questions, editing targets, reference images, and evaluation regions. It contains 2,800 source charts across 14 chart paradigms, from which we derive 7,329 layer-wise understanding questions and 53,791 instruction-guided editing variants. Among the evaluated VLMs, Qwen3.5-27B, which achieves the highest QA macro-average, obtains 93.04% accuracy on layer attribution and 97.46% on layer binding, but only 61.46% on visibility ordering. Across the four evaluated image editors, overall mIoU ranges from 1.49% to 4.93%, and visibility-constrained edits have the lowest mIoU for every editor, ranging from 0.37% to 2.00%. Taken together, these results identify tasks involving front-to-back relations between overlapping components as a recurring challenge across understanding and editing, motivating more explicit modeling of component identity and visibility relations.

Tue 8 SeptComputer Vision and Pattern RecognitionMachine Learning
The gist
Charts are made of different layers that have specific roles and meanings, like pieces of a puzzle stacked in order. The authors created a new benchmark called LayerWiseBench to see if computer models can understand and edit charts by looking at these layers one by one, instead of just the final image. They found that models do well recognizing the parts and their roles but often struggle with figuring out which parts are in front or behind others. This work highlights how tricky it is for computers to grasp the overlapping and visibility between chart components.
Open → 2609.08657v1