acceptodds
Under review as a conference paper at ICLR 2027

IteraFigure: Editable Structured Scientific Diagram Generation with Atomic Local Editing

16 views

Abstract

A generated scientific figure is rarely final. Authors rename a module, enlarge a label, or shift a group, and each of these requests is small and local. Most systems nevertheless deliver an image or an editable file with no persistent state behind it, so one small revision triggers full regeneration and disturbs already-verified content. We present IteraFigure, whose product of generation is not a rendered image but a persistent object graph, so generation and revision operate on one structured state. A revision is an atomic local edit on this state, not a regeneration. In the editor, the user's selection states which region should change, an interaction design that lets authors express a revision more precisely and conveniently than language alone. The selected scope is then enforced mechanically. A deterministic guard validates the whole operation batch against the scope before mutation, and an accepted batch commits atomically, leaving every object outside the scope with identical content, style, geometry, hierarchy, and endpoints. Locality is thereby turned from a request in natural language into a property decidable at commit time. On FigureBench, IteraFigure attains the highest overall quality among ranked systems while every element stays addressable, and under a matched-input protocol that gives every system the same editing interface it strictly passes 99.3% of single-turn local edits while preserving every unrelated visible element. The advantage compounds over ten-step mixed editing chains, where it still completes 96.7% at the final step, and a blinded study rates its outputs highest for visual quality, topology accuracy, and publication willingness.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
scientific figure generation, editable diagrams, persistent object graphs, atomic local editing, scope-guarded revision, LLM agents, vision-language models, deterministic verification, human-in-the-loop editing, FigureBench

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_umt5OpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This manuscript presents ITERAFIGURE, a system that treats a persistent object graph as the product of scientific-figure generation and as the authoritative state for later revision. Generation is organized as a Plan–Compose–Ground–Verify pipeline; editing is restricted to scope-guarded atomic operations over stable object IDs. The manuscript reports first-pass generation, single-turn editing, ten-step revision, human evaluation, and ablations.

Critical strengths
  1. The problem is well motivated. Local edits to generated figures often disturb already-verified content, and the paper correctly identifies the gap between “editable” files and enforceable local editing.

  2. The architecture is described in considerable implementation detail, including commit semantics, validation channels, and deterministic inspectors.

  3. The blinded human study and the reporting of strict pass rates, preservation, and residual defects are appreciated.

Critical weaknesses
  1. The core reason for rejection:The main contribution appears to lie in the generation workflow and interaction mechanism rather than in a new learning method or generalizable algorithmic insight, which raises questions about ICLR fit. Besides, the proposed “unified representation” appears very close to existing mxGraph XML. It is unclear whether the formulation in Eq. (1) is a novel abstraction or a reverse-engineering of mxGraph XML. If the latter, the representation itself should not be claimed as a core contribution.

  2. Alternative representation is not justified. The paper adopts draw.io mxGraph XML but does not justify this choice against SVG, which is more widely used, highly expressive, and plausibly well suited to LLM generation. The authors should explain why mxGraph XML is preferable to SVG, considering dimensions such as expressiveness, editability, ecosystem support, and model-generation reliability. As written, mxGraph XML appears convenient rather than demonstrably superior. A technical argument and, ideally, a controlled comparison would be expected.

  3. The manuscript’s coverage of related work on natural-language chart editing and generative editing interfaces appears incomplete; relevant efforts such as DynaVis [1], DataWink [2], ChartEdit [3], and ChartM3 [4] are not discussed. The authors should discuss the novelty of ITERAFIGURE relative to related figure-editing work.

Reference

[1] Vaithilingam P, Glassman E L, Inala J P, et al. Dynavis: Dynamically synthesized ui widgets for visualization editing[C]//Proceedings of the 2024 CHI Conference on Human Factors in Computing Systems. 2024: 1-17.

[2] Xie L, Lin Y, Liu C, et al. DataWink: Reusing and adapting SVG-based visualization examples with large multimodal models[J]. IEEE Transactions on Visualization and Computer Graphics, 2025.

[3] Zhao X, Liu X, Haoyue Y, et al. Chartedit: How far are mllms from automating chart analysis? evaluating mllms’ capability via chart editing[C]//Findings of the Association for Computational Linguistics: ACL 2025. 2025: 3616-3630.

[4] Yang D, Zhang L, Yue Z, et al. Chartm3: Benchmarking chart editing with multimodal instructions[C]//Proceedings of the 33rd ACM International Conference on Multimedia. 2025: 5001-5009.

Questions for authors

No Questions

4 comments

Thank you for your review and constructive feedback. We respond to your weaknesses below.

W1: What is the technical contribution, and how does Eq. (1) relate to mxGraph?

"The main contribution appears to lie in the generation workflow and interaction mechanism rather than in a new learning method or generalizable algorithmic insight, which raises questions about ICLR fit."
"It is unclear whether the formulation in Eq. (1) is a novel abstraction or a reverse-engineering of mxGraph XML. If the latter, the representation itself should not be claimed as a core contribution."

Our contribution is to let a language model continuously generate, modify, and verify scientific figures around one persistent object state. Planning, figure composition, content validation, and visual revision act on the same object graph; natural language and an optional selection are turned into checkable object-level operations, and failure reasons are returned to the model for revision. Eq. (1) is not a new representation or abstraction: it states the fields that an mxGraph cell already carries—label ℓ\ell, style attributes σ\sigma, geometry γ\gamma, hierarchical parent π\pi, and connector endpoints ϵ\epsilon—as a state tuple κ(c,G)=(ℓ(c),σ(c),γ(c),π(c),ϵ(c))\kappa(c,G)=(\ell(c),\sigma(c),\gamma(c),\pi(c),\epsilon(c)), on which the operations and audits are defined. mxGraph is the existing editor format that carries this workflow. We therefore do not claim the representation itself as a core contribution; the contribution is the workflow that generates, modifies, and verifies one persistent object state.

On ICLR fit, this work studies how model-driven systems perform constrained, verifiable iterative modifications on persistent structured artifacts. In this problem area, one of our important baselines, AutoFigure, was published at ICLR 2026, in the same subject area we selected, namely applications to computer vision, audio, language, and other modalities. In addition, ScImage (ICLR 2025) and AutomaTikZ (ICLR 2024) are papers accepted at the conference in earlier years, showing that the problem studied here has been one of the topics ICLR has consistently covered over the years.

We agree that the contribution is methodological rather than a new learning method, and we do not present it as one; it belongs to verifier-gated generation, where a deterministic check admits a model proposal before it changes the state. The generalizable part is the mechanism condition, not the backbone: when an artifact is addressable and the commit path can validate a whole operation batch before applying it, the user's intended scope, the read-only context supplied to the model, and the writable scope can be kept separate, so non-target changes become detectable and rejectable before publication. This condition is not specific to mxGraph XML (Section 3.3 and Appendix J.5). The paper measures it rather than asserting it: matched-input single-turn editing, the strict ten-step audit, and the Selected-scope Guard ablation comparing the pathway with and without the pre-submission check under a fixed selected-scope interface (Sections 4.4–4.5, Appendices D.2 and E). The research value therefore lies in characterizing and measuring the controllability of model edits on structured artifacts—which non-target changes still occur, what a checkable commit boundary prevents, and what it costs—within a problem area ICLR has consistently covered. We have revised the contribution statements in the main text accordingly.

We thank the reviewer for the remaining weaknesses and answer them below.

W2: Why mxGraph rather than SVG?

"The authors should explain why mxGraph XML is preferable to SVG, considering dimensions such as expressiveness, editability, ecosystem support, and model-generation reliability."
"As written, mxGraph XML appears convenient rather than demonstrably superior. A technical argument and, ideally, a controlled comparison would be expected."

This paper targets method and architecture diagrams made of modules, connectors, and hierarchies. We do not claim that mxGraph is superior to SVG: as Section 3.3 states, adopting mxGraph is an editor-integration choice, not a new format or a controlled format comparison. mxGraph directly exposes hierarchy and connector endpoints for our deterministic checker, stable IDs map onto canvas selections, and draw.io supports mature manual continuation and export, which provides substantial convenience for human–AI collaborative editing. SVG has a broader rendering ecosystem and can likewise be configured with stable IDs and graph semantics; we did not run a controlled comparison and make no claim about model-generation reliability. The Guard requires only an addressable representation whose commit path validates a batch before applying it (Section 6, Conclusion), so the contribution does not lie in the format itself. A controlled study that holds the editor, prompts, and checker fixed while varying only the serialization is left to future work. We have added the corresponding discussion to the paper and give the full four-dimension argument in Appendix J.5.

W3: How does IteraFigure differ from DynaVis, DataWink, ChartEdit, and ChartM$^3$?

"The manuscript’s coverage of related work on natural-language chart editing and generative editing interfaces appears incomplete; relevant efforts such as DynaVis [1], DataWink [2], ChartEdit [3], and ChartM3 [4] are not discussed."
"The authors should discuss the novelty of ITERAFIGURE relative to related figure-editing work."

The four studies have been added to the related work. DynaVis combines natural language with persistent interactive widgets; DataWink reuses and adapts SVG-based visualization examples; ChartEdit and ChartM$^3$ provide chart-editing evaluations, and the latter also uses multimodal instructions to express the target. These works mainly address data visualization and data encoding, whereas IteraFigure targets method and architecture diagrams, with an emphasis on persistent object state, multi-round object-level modification, explicit selections, and pre-submission checks. The revised related-work discussion is organized around this difference in task and mechanism.

Reviewer_umt5OpenReview ↗

Response to the rebuttal

Thank you for your response. I appreciate the authors’ clarifications on my concerns, particularly regarding the contribution and novelty. Accordingly, I will raise my score.

Thank you for taking the time to carefully review our response and the additional clarifications, and for raising your score. We are glad that our discussion of the contribution and novelty addressed your concerns, and we sincerely appreciate your reconsideration and support.

Reviewer_3CoqOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents IteraFigure, a system for generating and iteratively editing scientific diagrams represented as persistent mxGraph object graphs. Its generation pipeline combines structured planning, content validation, and visual and geometric verification. For interactive editing, the system uses persistent object identifiers, a selection-based scope guard, and atomic commits to preserve objects outside the permitted scope. Evaluation includes generation on 300 FigureBench prompts, 300 single-turn editing tasks, 30 ten-step editing chains, component ablations, and a blinded human study. The reported results demonstrate competitive generation quality and strong editing performance under the evaluated protocols.

Critical strengths
  1. The system addresses an important practical problem through a coherent structured-generation workflow. Maintaining addressable objects throughout generation and revision is valuable for scientific figures that require repeated changes. On the 300-prompt evaluation, IteraFigure achieves an automated Overall score of 8.44, compared with 7.56 for the strongest ranked baseline under the evaluated configurations. The blinded human ratings provide complementary evidence of competitive output quality.

  2. The paper provides concrete preservation evidence beyond qualitative examples. The single-turn evaluation checks requested changes and structural conditions, while Appendix C reports an object-level audit of 468 non-move edit pairs using canonical state fingerprints. The reported exact preservation of protected cells under the declared protection policy is meaningful empirical evidence for reliable editing on these operations. The combination of artifact-level checks and human evaluation strengthens the assessment of the system’s practical value.

Critical weaknesses
  1. The central selected-scope editing mechanism lacks direct empirical validation in the reported evaluation. Section 4.4 and Appendix H.3 explicitly state that the matched-input experiments return complete native artifacts without executing the active-selection guard. I appreciate the rationale for using a common interface across systems. Nevertheless, this leaves an important gap between the mechanism emphasized in the paper and the pathway evaluated: the strong editing results establish preservation in returned artifacts, but do not isolate the contribution of scope enforcement and atomic commits. The by-ID repair ablation concerns generation-time refinement and does not resolve this gap. Direct tests of the protected commit pathway and a comparison against otherwise matched ID-addressed editing would clarify the mechanism’s contribution.

  2. The long-horizon evidence also requires careful interpretation. The reported completion rate uses visual-or-native target satisfaction at four checkpoints, with preservation measured separately. This is a clearly disclosed metric, but it does not establish joint correctness and preservation at every editing step. A concise summary of all-step results from the stricter native acceptance ledger referenced in Appendix D would help assess the strength of the sustained-revision claim.

Questions for authors
  1. Can you provide or point to direct tests of the actual selected-scope commit pathway? What evidence distinguishes the effects of scope enforcement and atomic commits from those of the structured representation and ordinary ID-addressed editing?

  2. Equation (3) defines the target set to include all identifiers read or written. How does the implementation account for the implicit writes caused by cascading deletion in Appendix H.3? If only node A is selected while an incident edge is unselected, is deletion rejected before any mutation? A concrete operation trace or test would clarify how the implementation satisfies the stated invariant.

  3. Appendix D refers to a stricter native acceptance ledger. Can you identify the relevant supplementary results and summarize, for each method, the fraction of chains passing target correctness, structural validity, preservation, and expected-delta checks at every one of the ten steps? Please clarify the handling of unavailable or unmeasurable fields.

7 comments

Thank you for your review and constructive feedback. We answer your questions and respond to the weaknesses below.

W1/Q1: What is the contribution of the explicit selected-scope commit pathway?

"The central selected-scope editing mechanism lacks direct empirical validation in the reported evaluation. Section 4.4 and Appendix H.3 explicitly state that the matched-input experiments return complete native artifacts without executing the active-selection guard."
"... this leaves an important gap between the mechanism emphasized in the paper and the pathway evaluated: the strong editing results establish preservation in returned artifacts, but do not isolate the contribution of scope enforcement and atomic commits."
"Can you provide or point to direct tests of the actual selected-scope commit pathway? What evidence distinguishes the effects of scope enforcement and atomic commits from those of the structured representation and ordinary ID-addressed editing?"

We added a Selected-scope Guard ablation that directly targets the selected-scope commit pathway. With an explicit selection, the checker validates the batch and returns a rejection reason for one regeneration; without a selection, no local scope is imposed. Both conditions share the selection, context, interface, executor, and initial proposal. Quality is on a 0--5 scale over all 90 planned tasks, zero for incomplete tasks.

MetricGuard disabledGuard enabled
Completed tasks7779
Mean adjusted quality3.86033.9556
Semantic restyling quality4.83334.8571
Local extension quality3.23333.1905
Branch removal quality3.51433.8190
Observed scope changes18/9016/90
Complete and audit-clear63/9065/90
7 triggered tasks: completed / adjusted quality4 / 2.73476 / 3.9592

The direct scope evidence is as follows. An independent deterministic object/attribute audit found 19 of 89 committed initial proposals violating the declared scope rule or a protected-object condition. The Guard strategy intercepted 7 and allowed 12 through; neither strategy falsely rejected any of the 70 mechanically valid candidates, and 54 targeted scope and shared-structure cases passed. All seven were regenerated once; the other 83 reused the shared proposal. The completion count rose by a net two tasks, with the quality gain concentrated in the cases that actually triggered a revision. The per-family rows show the largest gain on branch removal and a small decrease on local extension, so we do not claim a uniform improvement. This contrast estimates the combined Guard-and-feedback strategy conditional on the selected-scope interface; it does not isolate selection context, structured output, or object-level operation constraints. See Section 4.5 and Appendix D.2.

For the atomic commit mechanism, we completed 900 offline fault-injection tests: all 300 valid batches committed, while the 600 batches with a late execution or late Guard error retained the original state and published no partial result. These tests measure batch publication behavior in the tested submission path. They are separate from the editing-quality outcomes in the Guard ablation. Details are in Appendix J.

W2/Q3: Does every step of a ten-step chain satisfy all requirements?

"The reported completion rate uses visual-or-native target satisfaction at four checkpoints, with preservation measured separately. ... it does not establish joint correctness and preservation at every editing step."
"Can you identify the relevant supplementary results and summarize, for each method, the fraction of chains passing target correctness, structural validity, preservation, and expected-delta checks at every one of the ten steps? Please clarify the handling of unavailable or unmeasurable fields."

We added a strict step-wise acceptance rule: a chain is confirmed as passing only if all ten steps have evidence for, and pass, all four conditions---target completion, structural validity, non-target preservation, and expected structure delta. The results are:

MethodConfirmed passConfirmed failUnknown
IteraFigure2910
LiveFigure11154
Paper2Any0300
AutoFigure0300

Each method has 30 planned chains. IteraFigure has 298 measurable steps: target completion, preservation, and expected delta pass on all of them, and structural validity passes on 297. The single failure produces a duplicate ID at step 8, after which the last two steps are blocked. LiveFigure has 26 complete artifact sequences; the other four did not form complete ten-step records because the first-step generation failed or acceptance was not passed.

We report the strict ten-step results, coverage counts, and main failure reasons in Appendix E.

We thank the reviewer for the question on the deletion invariant and answer it below.

Q2: If only node A is selected, are unselected incident edges deleted?

"Equation (3) defines the target set to include all identifiers read or written. How does the implementation account for the implicit writes caused by cascading deletion in Appendix H.3? If only node A is selected while an incident edge is unselected, is deletion rejected before any mutation? A concrete operation trace or test would clarify how the implementation satisfies the stated invariant."

We agree that the original implementation did not guarantee this invariant: when the direct target A was admissible, the proposal could be allowed through, after which the executor also removed A's descendants, its incident edges, and those edges' labels, including objects outside the selection. This was an authorization gap in the old deletion path, not merely an imprecision in the wording. We therefore revised both the definition and the interaction: the permitted scope SS now contains the direct selection UU plus deletion dependencies that are previewed and explicitly authorized by the user, tgt(Π)\mathrm{tgt}(\Pi) includes the executor's deletion dependencies but excludes read-only context, and read-only context never widens SS. The mathematical form of Eq. (3) is unchanged; the guarantee now rests on these definitions and on a pre-submission authorization step, not on the formula alone.

A concrete trace for the reviewer's example (Appendix J.3):

  1. The user selects node A (U={A}U=\{A\}) and submits a deletion. Before any mutation, the executor computes the deletion closure and finds the unselected incident edge e and its label in it.
  2. Because the closure reaches outside UU, the entire batch is held. A preview lists the direct target A separately from the out-of-selection dependent objects, with each object's name, type, dependency reason, and associated object.
  3. If the user cancels, no part of the batch is published and the graph state is unchanged: e remains present.
  4. If the user authorizes, the batch executes only while the canvas, selection, and session are identical to their preview-time state; A, e, and e's label are removed together, and objects outside the authorized closure are unchanged.
  5. Any change to the canvas, selection, or session invalidates that authorization and requires a fresh preview and confirmation. Deletions whose closure stays inside UU require no extra confirmation.

Necessary cascading deletion thus becomes an informed user decision rather than a silent widening of the selection. The matched-input and long-horizon results are post-hoc artifact checks of a different pathway and did not execute this interactive Guard. This interaction change does not rewrite the frozen tasks, model-facing prompts, input identities, or experimental artifacts, and does not change the experimental results reported in the paper.

Reviewer_3CoqOpenReview ↗

Response

Thank you for the detailed rebuttal and additions to the revised paper. The strict step-wise acceptance results in Appendix E address my concern about the long-horizon evaluation, with 29/30 confirmed passing chains for IteraFigure versus 11/30 for LiveFigure. The deletion-dependency authorization in Appendix J.3 directly addresses my cascading-deletion example, and the 900 fault-injection tests provide evidence for atomic commits in the tested submission path.

My remaining question concerns the Guard evaluation in Appendix D.2. The independent audit found that 19 of the 89 committed initial proposals violated the declared scope rule or a protected-object condition, but the Guard intercepted only 7, allowing the remaining 12 through. Consistent with this, observed scope changes decreased only from 18/90 to 16/90 when the Guard was enabled, and 4 of the 7 retry outputs still exhibited scope changes.

Could the authors clarify the nature of these 12 violations? Specifically, did any involve out-of-scope state modifications under the locality definition in Eq. (5), or were they violations of additional conditions outside the Guard's enforcement scope? I would also like to clarify whether the Guard accounts for implicit changes to the stored state of unselected objects, beyond declared operation targets, and whether retry outputs were checked by the Guard again before being committed.

This distinction matters because the paper presents locality as enforced at commit time. If any of these cases violate Eq. (5), the scope of the guarantee should be stated more precisely.

Overall, the rebuttal has improved my assessment of the paper, and I am open to raising my score if this concern is clarified.

Reviewer_7UtvOpenReview ↗
Rating
3(+1)
Confidence
3(−1)
Informativeness
2
Presentation
2
Soundness
3(+1)
Read review
Paper summary

IteraFigure generates scientific diagrams as object graphs (mxGraph) that contain nodes/labels/connectors/assets. Its generation pipeline combines planning, composition, grounding, verification, and multiple repair rounds. For editing, a scope gets predefined and a guard validates operation batches before committment. Evaluation includes generation on 300 FigureBench prompts, 300 single-turn editing tasks, ten-step editing chains on 30 diagrams, component ablations, and a human evaluation study with 32 researchers.

Critical strengths
  • Solves a common problem where models regenerate the whole figure even if only small edits are requested which leads to the modification of elements that should be preserved. Using an object graph to locally operate on it is good
  • Shows strong results against generation baselines such as GPT Image 2. Evaluation includes single-turn, chains, ablations, and human eval
Critical weaknesses
  • Editing scope is limited where to architecture/method diagrams with small predefined edit sequences (label replacement, font enlargement, horizontal movement). Does not consider larger semantic edits where multiple related elements and larger structures may change.
  • The paper describes that if elements are deleted, its descendants (and edges) are also deleted which could remove elements that shouldnt be deleted in some cases
Questions for authors
  • Reporting the proportion of existing objects that are modified per edit (and in the chain) could be useful
  • Could you show one or two examples of a figure that gets iteratively refined in the main paper
4 comments

Thank you for your review and constructive feedback. We respond to your points below.

W1: Can the system handle complex edits beyond simple attribute adjustments?

"Editing scope is limited where to architecture/method diagrams with small predefined edit sequences (label replacement, font enlargement, horizontal movement). Does not consider larger semantic edits where multiple related elements and larger structures may change."

We set up semantic restyling, local extension, and branch removal on 30 sources, giving 90 tasks per method. Each method starts from its own native artifact and the common task families, and receives only the same natural-language request, with no object IDs, coordinates, operation script, or user selection. Completion is judged visually, with reviewed resolutions for ambiguous cases; adjusted quality measures the effect of the requested change, is averaged over all planned tasks, and scores zero for incomplete tasks.

MethodSemantic restyling: completed / qualityLocal extension: completed / qualityBranch removal: completed / qualityTotal completed / adjusted quality
IteraFigure28 / 4.44330 / 4.09030 / 4.78688 / 4.440
LiveFigure30 / 4.80529 / 4.44828 / 4.48687 / 4.579
Paper2Any30 / 4.70528 / 4.16727 / 4.48185 / 4.451
AutoFigure28 / 4.28629 / 4.16222 / 3.48679 / 3.978

Each family has 30 tasks and quality is on a 0--5 scale. IteraFigure has the highest number of completed tasks, and branch removal is especially consistent, indicating that it can handle complex edits beyond simple attribute adjustments; its overall mean adjusted quality, however, is lower than that of LiveFigure and Paper2Any. Semantic restyling and local extension still leave room for improvement, mainly in the placement of newly added modules, information-flow integration, and connector organization. The main text summarizes this finding near the local-editing experiment, and Appendix D.1 gives the full results and also lists nine verbatim task instructions (three per family) from the complex-editing study for reference.

W2: How does cascading deletion handle incident edges and labels?

"The paper describes that if elements are deleted, its descendants (and edges) are also deleted which could remove elements that shouldnt be deleted in some cases"

In the complex-editing study, IteraFigure completed all 30 branch-removal tasks, and all 30 passed the VLM non-target content/structure preservation judgment.

On the selected-scope pathway, after node A is deleted the executor removes its descendants, incident edges, and their labels. The reviewed cases show that this cleanup is necessary to avoid dangling connections, but the earlier implementation could carry it out without the user's explicit authorization when dependent objects lay outside the selection. We have accordingly changed the interaction itself, not just its description: when a deletion reaches beyond the selection, the executor computes the deletion closure before any mutation, lists the direct targets separately from the out-of-selection dependent objects, and commits the whole batch only after user authorization (Appendix J.3); cancellation leaves the state unchanged, and a new confirmation is required if the canvas, selection, or session changes. The paper now distinguishes the direct selection from authorized deletion dependencies, and the existing experimental inputs and artifacts are unchanged.

We thank the reviewer for the two questions and answer them below.

Q1: How many existing objects are modified per edit?

"Reporting the proportion of existing objects that are modified per edit (and in the chain) could be useful"

We added two modification footprints (Appendix F). The native object-property modification proportion compares content, style, geometry, hierarchy, endpoints, and deletion by stable ID, using the number of objects present before an edit as the denominator. IteraFigure's single-turn mean is 2.4503% (300 edits); the per-step ten-step value is 1.1724% (298 steps); and the per-chain cumulative union over ten steps is 2.3007% (30 chains). In the complex-editing study the values are 26.83% for semantic restyling, 1.91% for local extension, and 30.19% for branch removal (30 tasks each). In the Selected-scope Guard ablation, the means over the 89 committed outputs in each condition are 15.80% with the Guard disabled and 15.70% with the Guard enabled. The other methods currently have no stable-ID property audit on the same definition.

The lexical reduction of pre-existing text instances applies to all methods: we parse text units from the before/after files, match normalized strings with their multiplicities, compute the proportion of old text instances whose multiplicity decreases, and average over edits. It only describes whether the original text remains present as the same string with the same multiplicity; it cannot identify text recreated with identical wording, nor measure semantic loss, style, geometry, or non-text objects. The results are as follows:

MethodSingle-turn local editingTen-step long-horizon editingComplex: semantic restylingComplex: local extensionComplex: branch removal
IteraFigure1.10%0.36%3.15%0.37%28.65%
LiveFigure0.87%0.23%1.33%0.81%25.38%
Paper2Any0.94%0.64%1.76%0.80%17.53%
AutoFigure0.31%0.38%19.56%17.84%58.95%

The numbers of computable pairs are 300, 283, 300, and 220 for the single-turn study; 298, 260, 296, and 300 for the long-horizon study; and 30 pairs per complex-editing family, except that 29 pairs are available for LiveFigure's branch removal. Lexical reduction includes the replacements and removals requested by the instruction and is a descriptive footprint. It measures something different from object-property modification, so the values can differ substantially: for IteraFigure's semantic restyling, lexical reduction is 3.15% while object-property modification is 26.83%.

Q2: Can you show a real iterative authoring process?

"Could you show one or two examples of a figure that gets iteratively refined in the main paper"

Figure 2 in the revised main text shows four representative saved states of Figure 1: the three-panel structure, object-graph refinement, the scope view and color semantics, and a global type-scale pass. Appendix L presents each of the four states as a full-width figure and provides the corresponding requests and region descriptions. The authoring process of Figure 1 includes manual adjustments, the illustrations in the version finally used were inserted by the authors, and the paper notes the nature of these states as a qualitative authoring record.

Thanks a lot for the additional experiments. Especially the complex-editing results do address my coverage concern and makes the paper much more well rounded, even though the advantage over the strongest baselines is now less clear as it was before. I will increase my rating accordingly.

Thank you for going through the additional experiments and for raising your score. We are glad the complex-editing results addressed your coverage concern. We take your point that the broader evaluation narrows the margin over the strongest baselines. We locate the contribution not in that margin but in the editing mechanism: a deterministic checker admits or rejects the declared batch against an explicit scope before it changes one persistent object state; this needs only addressable identifiers and a checkable commit path, not mxGraph specifically.

Comments on the paper

1 comment

We thank all reviewers for the specific suggestions on the problem motivation, the technical contribution, and the scope of the evaluation. Following these comments, we added a complex-editing study (Appendix D.1) and a Selected-scope Guard ablation (Section 4.5, Appendix D.2). The former tests the ability to handle complex semantic changes; the latter tests the role of pre-submission checks and rejection-feedback revision once a user supplies a selection. We also completed the strict step-wise acceptance results (Appendix E), the modification footprints (Appendix F), a four-state authoring example (Figure 2, Appendix L), and the related work (Section 2.2), and revised the contribution and representation discussion (Sections 1, 3.1, 3.3 and 6; Appendix J.5), the atomic-commit tests (Appendix J.3), the generation wall-time accounting (Appendix P.4). We have uploaded a revised PDF and an updated anonymous supplement. We summarize all changes here so that the modifications are clearly communicated to the reviewers and the Area Chair. The corresponding parts of the paper have been updated, with the revised text marked in blue.

In the complex-editing study, four methods receive the same natural-language request and return complete native artifacts, with no selection provided. The Selected-scope Guard ablation instead provides a selection and an object-operation interface; both conditions share the initial proposal, and the Guard-enabled condition allows one rejection-feedback revision. The two experiments address, respectively, complete-artifact editing capability and the mechanism contribution within the selected-scope workflow.

We have also added the strict per-step acceptance results and record coverage for the ten-step editing chains, the proportion of pre-existing objects modified, and the real authoring history of Figure 1; we clarified the deletion-dependency authorization in selected-scope editing, which holds a batch for preview and user consent when a deletion reaches beyond the selection. The related work now also covers DynaVis, DataWink, ChartEdit, and ChartM$^3$.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.