acceptodds
Under review as a conference paper at ICLR 2027

AnchorFlow: Learning Anchor Placement for Faithful and Editable SVG Reconstruction

Abstract

Raster-to-SVG reconstruction requires faithful geometry and a compact control structure for editing. A central challenge is deciding where to place anchors: raster appearance alone does not determine how a contour should be divided into Bézier segments. We present AnchorFlow, which learns anchor placement from designer-authored SVGs to reconstruct accurate curves with sparse controls. Our key idea is a sparse anchor field that jointly encodes contour geometry and reference segment junctions, including those along smooth contours. An anchor decoder predicts explicit anchor proposals from features learned under field supervision. These proposals guide boundary-constrained fitting and local refinement to recover cubic Bézier paths. On clean single-path inputs, AnchorFlow achieves 99.52% mean IoU while using 56.6% fewer anchors on average than AdaVec, with lower boundary error and closer agreement with source-SVG anchor layouts. Under boundary perturbations, it maintains high fidelity with limited anchor growth. Integrated into a component-based pipeline, the same path module also produces compact, faithful full-image reconstructions. A user study further shows that our reconstructions support faster local editing with fewer operations while maintaining target-shape accuracy.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
raster-to-vector conversion, SVG reconstruction, anchor placement, Bézier curve fitting, editable vector graphics

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_tMwrOpenReview ↗
Rating
3
Confidence
2
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

AnchorFlow learns Bézier anchor placement from designer-authored SVGs, using a U-Net trained on an anchor heatmap plus a DETR-style decoder to predict anchors, which then guide least-squares curve fitting and merging to the observed contour (applied per component via AdaVec for full images). Experiments on 2,400 single paths, three full-image datasets, ablations, and an 18-person editing study show comparable or better fidelity with substantially fewer anchors and lower editing effort than tracing, optimization, and generative baselines.

Critical strengths
  1. Well-isolated evidence that learned anchor placement matters. The matched-count ablation (Table 5) fixes anchor count and backend and shows learned placement beats uniform and error-greedy placement both before and after refinement (e.g., 36.5% lower GOSPA, 0.4 pp higher IoU vs. error-greedy). This is consequential because it is the one experiment that cleanly supports the paper’s core premise that designer-style anchor layout is a learnable, useful prior.

  2. Evaluation tied to the practical goal of editability. Beyond fidelity metrics, the paper measures anchor compactness, agreement with source layouts, robustness to perturbations, and runs a controlled user study where AnchorFlow approaches source-SVG editing effort (15.5 vs. 16.0 s median). This matters because it connects the method’s compactness to a real downstream benefit rather than leaving it as a proxy metric.

Critical weaknesses
  1. Limited methodological novelty and missing prior work. The pipeline combines standard components (a U-Net heatmap, a Deformable-DETR-style set decoder, least-squares Bézier fitting, greedy merging), and learned corner/vertex detection followed by curve fitting is well established. Examples include Hoshyari et al. (SIGGRAPH 2018) and PolyFit (SIGGRAPH 2020) for region-boundary vectorization, PolyWorld/PolyBuilding for polygon extraction, and Puhachov et al. (2021) for line drawings, none of which are cited. The paper’s stated key idea, the sparse anchor field, is not shown to be necessary: in Table 3, field-peak readout alone and joint training without field supervision perform on par with the full two-stage method. This is consequential because the contribution then reduces to applying known machinery to designer anchor supervision, and design choices such as regressing 2D coordinates and snapping them to the contour (instead of classifying anchors along the ordered 1D contour) are not justified against simpler alternatives.

  2. Gains are confounded with backend tuning and operating-point choice. Fidelity is largely enforced by a carefully tuned geometric backend (IoU-gated retries, error-driven insertion, tight merge tolerances), yet baselines are evaluated at single default settings with no fidelity–compactness trade-off curves. Table 4 shows that passing Potrace or AdaVec anchors through the same backend already cuts their counts from 17.9/21.9 to 12.4/11.5 at similar IoU, so much of the headline “56.6% fewer anchors” comes from the backend rather than learning, and the backend components themselves are never ablated. This is consequential because the central empirical claim cannot be attributed to the proposed learned model without matched-budget or Pareto comparisons and backend ablations.

Questions for authors
  1. Prior work. How does AnchorFlow differ from learned corner/discontinuity detection combined with spline fitting in Hoshyari et al. (2018) and PolyFit (2020), and from vertex-detection pipelines such as PolyWorld and PolyBuilding? Could you compare against at least one of them?

  2. Backend vs. learning. Can you ablate the backend components (IoU-gated retry, insertion, merge tolerances, refit steps, λᵢ) and apply the same refit-and-merge post-processing to the baselines’ native outputs? Can you also report fidelity–compactness curves by sweeping each baseline’s simplification parameters (e.g., Potrace alphamax/opttolerance, AdaVec thresholds)?

  3. Necessity of the anchor field. Given Table 3, what evidence supports the sparse anchor field and two-stage training as the key contribution beyond faster training?

  4. Simpler formulation. Why regress free 2D coordinates and snap them to the contour, rather than classify anchors directly on the ordered 1D contour samples, which guarantees on-curve, ordered anchors? How does such a baseline compare?

  5. Multimodality. Anchor layouts are non-unique, but both stages use deterministic regression losses. How consistent are designer layouts across similar shapes, and do you observe mode-averaging failures (e.g., on symmetric shapes or smooth arcs)?

  6. What is the number of decoder queries N, and how are their initial coordinates set? How often does the true anchor count approach N?

  7. How are compound paths and shapes with holes handled?

  8. Suggestion: A mode-seeking or generative formulation (autoregressive or diffusion over anchor sets) could offer designers alternative layouts. Extending the learned prior to handle placement and tangent continuity, not only anchors, would strengthen the editability story.

2 comments
AuthorsOpenReview ↗

Response to Reviewer tMwr (1/2): novelty and prior work (W1/Q1), backend versus learning (W2/Q2)

Thank you for the detailed review. This comment answers W1/Q1 and W2/Q2; 2/2 answers Q3–Q8. Changes in the revised PDF are in blue. Notation: K is the number of anchors; GOSPA measures how far the anchors are from the designer's anchors in the source SVG (lower is closer); our backend fits the handles and inserts and merges anchors after prediction.

W1/Q1 — What is learned, and how it differs from the works you list. AnchorFlow learns from designer-authored SVG paths where a designer ends one Bézier segment and starts the next. Sec. 2 now discusses all five works. Hoshyari et al. (2018) learn where people perceive corners, PolyFit (2020) which line/arc/curve configuration people prefer, PolyWorld and PolyBuilding the vertices of building polygons, and Puhachov et al. (2021) stroke keypoints. In each of them, the places where a smooth stretch of boundary is divided are left to a fitting or simplification criterion; AnchorFlow makes that division the learning target.

Most designer anchors are not corners: only 37.2% in our test set turn by at least 30°, while 59.3% lie where the outline is smooth (below 10°). As a control for "detect corners, then fit" (ours, not an implementation of the cited systems), we give a fitter the designer's own corners (a perfect corner detector) and fill the same per-shape budget by error-driven insertion. It recovers 22.2% of the smooth junctions within 2 px, against 62.5% for AnchorFlow (Table 17, App. D.5).

Comparison with PolyFit (Tables 1 and 14). Of the listed methods, PolyFit is the one we could run fairly: Hoshyari et al. release only a Windows binary, PolyWorld only a network trained on aerial building footprints, and PolyBuilding no code. With the official release and default parameters, on the 2,400 clean paths PolyFit reaches 99.66% IoU with 32.43 anchors and GOSPA 0.0647, against 99.52%, 9.53 and 0.0254 for AnchorFlow. On the 2,400 perturbed paths, AnchorFlow has +1.99 pp IoU, 90% fewer anchors and 75% lower GOSPA. With PolyFit's anchors passed through our backend, AnchorFlow still has 27% fewer anchors and 33% lower GOSPA.

Our contribution. The novelty is this learning target and the sparse anchor field through which a plain U-Net learns it, as the revised abstract and Sec. 2 state.

W2/Q2 — Backend versus learning. Our compactness comes mainly from the predicted anchors, not from deleting anchors in the backend. Without our merge step, AnchorFlow keeps 11.76 anchors at 99.53% IoU, already 46% fewer than native AdaVec (21.95 anchors, Table 1); the merge then brings our count to 9.53. When AdaVec's anchors go through the same backend, ours still end with 17.2% fewer anchors and 45.7% lower GOSPA (Table 4). Details (2,400 clean paths unless stated; failures stay in the denominators):

Same backend, other anchor sources (Table 4; VTracer in Table 12). AnchorFlow ends with 11–27% fewer anchors than Potrace, AdaVec, AutoTrace, VTracer, PolyFit and RDP (PolyFit and VTracer reach higher IoU with 36–38% more anchors), and with GOSPA 0.025 against 0.037–0.047: the backend lowers the count but does not move anchors to the designer's positions. At the RDP tolerance that matches our IoU (99.520% vs. 99.521%), ours has 10.8% fewer anchors and 32.2% lower GOSPA. At matched anchor count, learned placement has 36.5% lower GOSPA and +0.40 pp IoU than error-greedy placement (Table 5).

Backend components (Table 11). With our anchors fixed, insertion and the refit updates add 0.19 and 0.12 pp IoU; the IoU-gated retry saves 0.57 anchors against a fixed decoder threshold of 0.2, while a fixed 0.4 fails on 131 paths; a 4× change of the merge tolerance moves IoU by 0.02 pp. Scaling the handle regularization λ by 0.1 has almost no effect; at ×10, 887 paths fail. GOSPA stays at 0.025–0.028 for every variant except λ ×10.

Our post-processing on native outputs (Table 13, 300 paths). With only our merge applied to their own curves, Potrace, AutoTrace, VTracer and AdaVec keep 11.32–15.79 anchors at 98.07–99.31% IoU, against 9.37 and 99.50% for ours. Pruned greedily to our per-shape count, they reach 99.09–99.37% IoU and GOSPA 0.038–0.040, against 99.56% and 0.0234 (253 paths; Fig. R2).

Trade-off curves (Figs. R4 and R5). We swept 12 Potrace, 8 AutoTrace, 8 VTracer and 7 RDP settings on all paths, natively and with our backend, and AdaVec's thresholds at 0.5×/1×/2× on 90 paths. No native tracer or RDP setting reaches 99.52% IoU at any anchor count; AdaVec reaches at most 99.53% with 20.09 or more anchors, against 99.61% with 8.78 for ours on the same paths. No measured baseline setting has fewer anchors than our default at equal or higher IoU, and none has lower GOSPA.

AuthorsOpenReview ↗

Response to Reviewer tMwr (2/2): anchor field and decoder (Q3), 1D formulation (Q4), Q5–Q8

Q3 — Anchor field and two-stage training. The core of the method is the learning target, the designer's anchor layout; the anchor field turns it into a dense target that a plain U-Net can learn. Read out by simple peak picking, with no decoder, it already gives 9.87 anchors at 99.57% IoU and GOSPA 0.0256 (Table 3, row 1). As you observed, on clean inputs the readout and the training schedule change the final curves little (Table 3: within 0.06 pp IoU and 3.4% in anchor count), which supports the central claim: the result follows the learned target. On the same paths and backend, the variants that learn the designer layout (Table 3 and Q4) end at GOSPA 0.0241–0.0259, while the anchor sources that do not learn it end at 0.0374–0.0467 (Table 4). What the field adds is practical: no decoder is needed (row 1), and training is cheaper (14.6 vs. 26.5 h for the same 120 epochs).

The decoder outputs one existence probability per candidate, so selection is a single threshold (0.4, retried at 0.2) instead of a response floor, a relative threshold, two windows and a minimum-count rule. In the three examples of Fig. R1 it matches the designer's anchor count (6/14/9), while peak picking keeps extra peaks on smooth arcs (9/16/11). Over all paths the two readouts are comparable (Q4), so Sec. 3.2 no longer presents the decoder as essential.

Q4 — Classification on the ordered 1D contour. We tested this with our network in two ways (Table 15, App. D.3). Reading the field on the contour: its peaks at the ordered contour samples, with no further training and the same retry, give 9.52 anchors / 99.52% IoU / GOSPA 0.0248 on the 2,400 clean paths (decoder: 9.53 / 99.52% / 0.0254) and 12.91 / 97.69% / 0.0386 on the 2,400 perturbed paths (decoder: 12.55 / 97.69% / 0.0376). A trained 1D head: a small classifier that replaces the decoder and labels each ordered contour sample from the U-Net features gives 8.80 anchors / 98.81% IoU / GOSPA 0.0241 on the clean paths, with two failures: fewer anchors and closer to the designer layout, but lower fidelity. It was trained and tested on clean inputs, with a threshold chosen for detection F1 on validation paths and no retry. The 2D field thus already contains the formulation you suggest: read on the contour, it matches the decoder without further training. In every case our final anchors are on-curve and ordered, because the backend assigns each prediction to a distinct contour sample and orders them by arclength. We keep the 2D target because the reference anchors lie on the clean source path, while the observed contour may be displaced (Sec. 3.1). We keep the submitted decoder but do not claim that it places anchors better than selection on the contour.

Q5 — Multimodality. You are right that layouts are not unique; our model returns one layout per shape. We found no averaged layouts, but each situation you name shows a limit (App. D.8). Similar shapes: among 617 pairs of near-identical test shapes, the designer layouts differ in anchor count in 70% of pairs; our prediction is closer to its own shape's reference than to the other's in 96% (593/617), so similar shapes are not collapsed onto one layout. Smooth arcs: ambiguous junctions tend to be left out, not placed in between (widening the matching gate from 2 px to 16 px raises smooth-junction recall only from 52% to 67%). Symmetric shapes: on 927 mirror-symmetric shapes, 87.6% of our anchors have a mirrored counterpart within 2 px, against 96.1% for designers. The revision states these limits and reads GOSPA as agreement with the given reference, not with a unique ground truth.

Q6 — Queries. N = 256 learned queries with learnable coordinates, initialized at the centers of a 16×16 grid (Sec. 3.2, Table 8). Source anchor counts have mean 11.8, 99th percentile ≈ 50 and maximum 94, so no path approaches N.

Q7 — Compound paths and holes. The benchmark and the pipeline cover closed, hole-free paths; in full images, a hole comes from a component drawn on top in the layered decomposition. Processing each contour of a compound path separately is the natural extension, not evaluated (App. D.8).

Q8 — Continuity and generative layouts. App. D.8 discusses both as extensions. As a diagnostic, we constrained the two handles at output junctions that turn by less than 10° to share one tangent: these junctions become exactly tangent-continuous at a cost of 0.04 pp IoU, and no path fails. Without the constraint, matched smooth junctions already have a median tangent turn of 1.8°. A generative layout model is future work.

We hope these results address the soundness and novelty concerns, and we would be grateful if you would reconsider your assessment.

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

This paper presents a learning-based method (AnchorFlow) for reconstructing compact SVG from raster. The method predicts anchor locations using a field feature network and a decoder, followed by geometric fitting and refinement of cubic Bézier curves. The central objective is to preserve reconstruction fidelity with a compact and well placed set of anchors.

Critical strengths

1. Strong reconstruction and compactness results. The method achieves a favorable balance between reconstruction fidelity and anchor count compared with the evaluated baselines. These results demonstrate practical value in producing compact vector representations while preserving high reconstruction quality.

2. Solid and well controlled comparisons and component ablations. Table 4 compares different anchor initializations under a shared geometric backend, while Table 5 matches the initial anchor count for each input and separately evaluates fixed-anchor fitting and subsequent refinement. These experiments help distinguish the contribution of anchor placement from that of geometric reconstruction. In particular, Table 5 provides evidence that learned placement remains beneficial even when the initial anchor budget is controlled.

Critical weaknesses

1. Limited evidence for the benefit of field pretraining and decoder readout. In Table 3, the improvement on IoU and anchor counts from two-stage are quite marginal. These results leave the need for the particular field representation and decoder design insufficiently explained. Since these choices constitute a central part of the technical presentation, stronger evidence is needed to explain which prediction errors they resolve and why the added complexity is warranted. I recommend authors to present more qualitative comparisons on them.

2. Limited coverage of baselines in Table 4. Table 4 controls the geometric backend but considers only Potrace and AdaVec as external anchor initializers, both of which start with substantially more anchors than AnchorFlow. Given that learned anchor prediction is central to the paper, extending the comparison to other baselines would strengthen the evidence. AutoTrace is a reasonable candidate, as it already produces relatively compact outputs in Table 1. Such comparisons would help understand the benefit and effect of anchor initialization.

Questions for authors
  1. If the compactness of anchor points is the issue, could it be addressed using more aggressive pruning methods? If so, showing the results of comparisons with these methods could help make a stronger case for the necessity of the proposed method.

  2. Does ablation study in Table 3 show meaningful difference in qualitative comparison? Since the quantitative comparison can't sufficiently show the necessity of two-staged training pipeline, it would be helpful to provide their effect in qualitative examples.

  3. How do additional baselines perform under the Table 4 reconstruction backend? In particular, could AutoTrace be included? Furthermore, Table 4 shows a very shallow IoU gap and incremental differences in final anchor count. More comprehensive quantitative comparison and qualitative comparison would help explain the improvements of anchorflow and whether they correspond to useful differences during editing.

3 comments
AuthorsOpenReview ↗

Response to Reviewer mUCK (1/2): pruning baselines (Q1) and Table 3 (Q2/W1)

Thank you for recognizing the reconstruction results and the controlled comparisons in Tables 4–5. Each result below names where it appears in the revised PDF (changes in blue); Figures R1–R5 are in App. D.9. K is the number of anchors.

Q1 — Could more aggressive pruning reach the same compactness? Not at the same fidelity and layout. We tested three kinds of pruning: none reaches both our anchor count and our IoU, and none places the anchors where the designer did (GOSPA; lower means closer to the designer's layout).

1. Our own merge step on other anchors (Table 4). Our backend (the geometric stage after anchor prediction: handle fitting, anchor insertion and merging) ends with a merge step, which is itself pruning. Applied to AdaVec's anchors it reduces them from 21.9 to 11.5, still above our 9.5, and their GOSPA stays at 0.047 against our 0.025.

2. Pruning the baselines' own curves to our anchor count (300 paths; App. D.1). We keep the native curves of Potrace, AutoTrace and AdaVec and delete anchors greedily until each path has as many anchors as ours. Each step tries every deletion, refits the affected arc and keeps the one that loses the least IoU on the input; source anchors are never used. On the 253 paths where all three reach our count exactly (mean 8.73 anchors):

Same 253 paths, K = 8.73IoUGOSPA
Pruned Potrace99.333%0.0379
Pruned AutoTrace99.087%0.0401
Pruned AdaVec99.373%0.0387
Ours99.561%0.0234

On all 300 paths the pruned curves reach 99.29/98.97/99.22% IoU against 99.50% for ours. Fig. R2 shows three paths from this experiment: in each, the pruned anchors sit beside the designer's junctions while ours coincide with them.

3. A standard contour simplifier followed by our full backend (2,400 paths; RDP row of Table 4, App. D.1). Ramer–Douglas–Peucker (RDP) simplification removes contour points within a tolerance ε. Of the seven tolerances we tried, ε = 3 gives the same IoU as ours (99.520% vs. 99.521%). At that IoU ours uses 10.8% fewer anchors (95% interval 9.8–11.7%) and has 32.2% lower GOSPA (31.1–33.3%).

Q2 / W1 — What field pretraining and the decoder add, and whether Table 3 shows qualitative differences. The accuracy comes from learning the designer's layout, which every Table 3 variant does. Field pretraining and the decoder add practical benefits: field pretraining cuts training time by 45%, and the decoder simplifies anchor selection and, in some cases, avoids extra anchors on smooth arcs (Fig. R1).

Table 3. The variants are peak picking on the field without the decoder (row 1: 9.87 anchors / 99.57% IoU / GOSPA 0.0256), joint training with anchor-set supervision only, and our two-stage training with the decoder. All are above 99.5% IoU, within 0.06 percentage points (pp) of each other and within 3.4% in anchor count, and all end at GOSPA 0.025–0.026, against 0.037–0.047 for the anchor sources in Table 4 that do not learn the designer layout (same backend).

Field pretraining. For the same 120 epochs, two-stage training takes 14.6 h and joint training 26.5 h (new column in Table 3), with similar final quality.

Decoder. Its benefit is the readout: each candidate carries one existence probability, so selection needs one threshold (0.4, retried at 0.2 on failure or observed IoU < 0.99) instead of the five settings of peak extraction. In three paths (Fig. R1), peak picking keeps extra peaks on smooth arcs and ends with 9/16/11 anchors and GOSPA 0.021–0.032 (with 0.1–0.4 pp higher IoU), while the decoder matches the designer's 6/14/9 (GOSPA 0.004–0.006). Over all 2,400 paths a contour peak readout with the same retry is comparable (9.52 anchors / 99.52% IoU / GOSPA 0.0248 vs. 9.53 / 99.52% / 0.0254 for the decoder; App. D.3), also on perturbed paths, so we do not claim the decoder places anchors more accurately.

Where the accuracy comes from. With the same anchor count per shape and the same refinement, learned placement has 36.5% lower GOSPA and 0.40 pp higher IoU than error-greedy placement (Table 5). Given the designer's own corners (a perfect corner detector) and the same anchor budget, a fitting pipeline recovers 22.2% of the designer's smooth junctions within 2 px; our anchors recover 62.5% (2,400 paths; App. D.5).

AuthorsOpenReview ↗

Response to Reviewer mUCK (2/2): more initializers under the Table 4 backend (Q3/W2)

Q3 / W2 — More initializers under the Table 4 backend, including AutoTrace. We added AutoTrace, RDP and PolyFit to Table 4. With the backend held fixed, our anchors end with 11–27% fewer anchors and 32–46% lower GOSPA than every other initializer, at comparable IoU (2,400 clean paths, failures in the denominators):

Initial anchorsInitial KFinal K ↓IoU ↑GOSPA ↓
Potrace (Table 4)17.8812.3799.468%0.0466
AdaVec (Table 4)21.9511.5299.486%0.0467
AutoTrace (new)12.9711.1499.393%0.0466
RDP ε=3 (new)15.0410.6899.520%0.0374
PolyFit (new)32.4313.1299.774%0.0381
Ours11.599.5399.521%0.0254

Initial K is the number of anchors given to the backend; the other columns describe its output. AutoTrace, the most compact tracer, ends with 17% more anchors at lower IoU. At the same IoU as RDP (contour simplification; see 1/2, Q1), ours has 10.8% fewer anchors and 32.2% lower GOSPA. PolyFit, added at Reviewer tMwr's request, has the highest IoU; ours has 27% fewer anchors and 33% lower GOSPA; VTracer anchors behave the same way (App. D.1). Over all baseline parameter settings we swept, natively and with our backend, none has fewer anchors than ours at equal or higher IoU (Fig. R4/R5).

Qualitative comparison. Fig. R2, described in 1/2 (Q1), shows our anchors next to native and pruned baseline curves on three paths.

Do the differences matter for editing? We agree that the IoU differences in Table 4 are small; IoU is near its ceiling for all initializers. The difference is in the layout: lower GOSPA means the anchors sit closer to where a designer placed them, and a lower count means fewer anchors and handles to manage. Our editing study is consistent with this for the methods it covered: starting from our output, participants needed fewer median actions than from AdaVec's on all four tasks (Table 6), and our starting paths also had lower GOSPA than AdaVec's (App. D.7). The study did not include the new backend variants.

We thank the reviewer for the constructive suggestions. The extended Table 4, the backend-component table, the readout comparison and the pruning baselines are in the revised PDF; we would be glad to add anything else that would help the assessment.

I thank for authors for a solid response. I am leaning to acceptance, so I will keep my rating.

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

This paper learns anchor layouts from designer-authored SVGs and fits boundary-constrained cubic Béziers, producing sparser editable paths for closed contours and full icons. On 2,400 clean paths it reaches 99.521% IoU with 9.53 anchors, 56.6% fewer than AdaVec’s 21.95, with lower Chamfer distance and lower GOSPA to the source SVG.

Critical strengths
  • The problem is well chosen: similar outlines can have very different control layouts, while most vectorizers optimize pixel error only.
  • With a shared fitting backend, learned initialization cuts GOSPA from about 0.047 to 0.025 (Table 4). Under boundary perturbation, anchors grow only from 9.53 to 12.55 while IoU stays at 97.687%.
  • In a study with 18 participants and four local edits, the median is 15.5 seconds and 4 actions, close to the source SVG (16.0 seconds, 4 actions) and better than AdaVec and LIVE.
Critical weaknesses
  • Fidelity on clean paths is already saturated. AutoTrace reaches 98.073% IoU with 12.97 anchors in 0.07 seconds; this method reaches 99.521% IoU with 9.53 anchors in 0.84 seconds. Against tracers, the anchor reduction is modest and the method is much slower.
  • In Table 3, field-peak readout has higher IoU (0.995679) than the decoder (0.995211), with almost the same anchor count. The text treats the decoder as essential; the table does not.
  • Full-image gains are uneven. On Noto, anchors are 176 versus AdaVec’s 281 and PSNR is 37.32 versus 34.66. On HeisenVec, anchors are 892 versus 927, while runtime is 173 seconds versus 80. The method also depends on an external component decomposition and handles only closed cubic paths. GOSPA measures agreement with the source SVG style, not editing optimality.
Questions for authors
  • What is the perturbation magnitude distribution? Please show curves over noise level, not a single perturbed setting.
  • How many participants completed each editing task, and what is the spread across people? Do four local edits cover splitting, merging, and corner preservation?
  • Where does full-image runtime go: decomposition, decoding, or fitting? Why does the compactness gain nearly disappear on HeisenVec?
2 comments
AuthorsOpenReview ↗

Response to Reviewer XrEw (1/2): weaknesses W1–W3

Thank you for the careful assessment and for recognizing the problem choice, the shared-backend result and the editing study. Changes in the revised PDF are in blue, and Figures R1–R5 are in App. D.9. Notation: K is the number of anchors; GOSPA measures how far the anchors are from the designer's anchors in the source SVG (lower is closer).

W1 — Saturated fidelity and speed. We agree that clean-input IoU is saturated, and we do not claim speed as an advantage.

Fidelity and compactness. We treat high fidelity as the prerequisite (Sec. 4.2 no longer calls our clean IoU the highest); beyond it we compare how many anchors a method needs and whether they sit where a designer would place them. Against AutoTrace (Table 1): on clean inputs AnchorFlow uses 26.5% fewer anchors with about half the GOSPA (and +1.45 pp IoU). Under perturbation the anchor margin grows to 33% fewer anchors, with 38% lower GOSPA and +1.1 pp IoU. AutoTrace's own parameters do not close this gap: across 8 settings, every setting with at most 12 anchors stays below 96.5% IoU (App. D.1). Passing AutoTrace's anchors through our full backend (handle fitting, anchor insertion and merging) still leaves 17% more anchors than Ours, at lower IoU (Table 4). The editing study points the same way for the methods it covered: fewer starting anchors and fewer median actions than AdaVec on all four tasks (Fig. 9 and Table 6). AutoTrace was not part of that study.

Speed. We are slower than tracers, as Sec. 5 states. Table 1 records 0.84 s per path for Ours, against 9.65 s for AdaVec and 24.5–52.3 s for the optimization-based DiffVG and LIVE (timing scopes: App. B.3): per path, the cost is above tracers and below the other learned or optimization-based methods we compare with. In full images our pipeline is slower than AdaVec on all three datasets (Table 2), mainly because fitting runs sequentially over the component paths; the network is a small part of it (on HeisenVec, 2.5 s per image against 95 s of fitting and merging).

W2 — Table 3 and the decoder. Thank you for pointing this out: the text overstated the decoder, and the revision corrects it. The core observation is that a simple network can learn the anchor field: peak picking on the field, with no decoder, already reaches 9.87 anchors / 99.57% IoU / GOSPA 0.0256 (Table 3, row 1). The IoU gap you note (99.57% vs. 99.52%) is small, and all Table 3 variants end at GOSPA 0.025–0.026, against 0.037–0.047 for other anchor sources under the same backend (Table 4): the result comes from the learned target. The decoder's benefit is in the readout: one existence probability per candidate, so selection is a single threshold (0.4, retried at 0.2 if the fit fails or IoU < 0.99), instead of the five settings of peak extraction (response floor, relative threshold, NMS window, centroid window, minimum count). In the three examples of Fig. R1, it does not keep the extra peaks on smooth arcs that peak picking keeps, and its anchor count equals the designer's (6/14/9). On all 2,400 paths, with the same retry, the two readouts are comparable (contour peaks with retry: 9.52 anchors / 99.52% IoU / GOSPA 0.0248; decoder: 9.53 / 99.52% / 0.0254), as on perturbed inputs (App. D.3). Sec. 3.2 no longer presents the decoder as essential: the contribution is the learned target and the anchor field through which it is learned, and the decoder is a practical way to read it out.

W3 — Full-image gains, scope and GOSPA. In full images the path module works on components from an AdaVec-based decomposition frontend (Sec. 2), so the full-image gain also depends on that decomposition; Sec. 5 lists decomposition errors as a limitation. On HeisenVec the anchor saving is small, while fidelity is still better with fewer anchors (MSE 0.00178 vs. 0.00215, PSNR 28.25 vs. 27.82 dB); the runtime breakdown and the HeisenVec analysis are in Q3 below.

Scope. The method targets closed single-subpath cubic paths. Cubic Béziers are the standard path primitive of SVG and of vector editors, so we consider this a reasonable first scope; compound paths are not evaluated.

GOSPA. We agree: it measures agreement with one reference layout and is a proxy, not editing optimality. As a more interpretable complement we add junction recall against the source anchors (2 px gate, 2,400 paths): Ours recovers 88.0% of corner anchors and 52.3% of smooth-curve junctions at 80.9% precision; native AdaVec 70.4% / 14.9% / 19.1%; AutoTrace 77.2% / 9.1% / 31.7% (App. D.4). The editing study remains the direct measure of effort. In its four tasks, the starting path of Ours had lower GOSPA than AdaVec's (0.004–0.054 vs. 0.079–0.109; App. D.7) and needed fewer median actions.

AuthorsOpenReview ↗

Response to Reviewer XrEw (2/2): questions Q1–Q3

Q1 — Perturbation distribution and curves over noise level. The fixed perturbation draws the raster size from {192, 224, 256} px with probabilities 0.25/0.5/0.25 and displaces the boundary by δ = g·[a·clip(η, −2, 2) + b] low-resolution pixels, where η is a smoothed standardized Gaussian field, a ∼ U[0.5, 0.75], b ∼ U[−0.2, 0.2], and g = 1 in the paper (App. B.3 and D.6 now state this in full). Sweeping g on 300 fixed paths that share the same fields:

Gain gOurs: K / IoU / GOSPAPotrace: K / IoU / GOSPAAutoTrace: K / IoU / GOSPAOurs failures
clean9.37 / 99.50% / 0.02617.64 / 99.24% / 0.05512.66 / 98.23% / 0.0480/300
0.25, 0.510.41 / 97.90% / 0.03240.86 / 97.77% / 0.08112.94 / 97.12% / 0.0490/300
0.7510.72 / 97.85% / 0.03345.23 / 97.71% / 0.08614.33 / 97.02% / 0.0520/300
1.0 (paper)12.24 / 97.64% / 0.03759.48 / 97.50% / 0.10218.50 / 96.65% / 0.0600/300
1.2514.56 / 97.28% / 0.04371.87 / 97.14% / 0.11322.99 / 96.26% / 0.0660/300
1.520.68 / 96.49% / 0.05383.49 / 96.59% / 0.12227.35 / 95.80% / 0.0721/300

At g = 0.25 and 0.5 the perturbed rasters are identical, so one row covers both; it reflects the resampling alone. Up to g = 1.25, Ours has the fewest anchors, the highest IoU and the lowest GOSPA of the three. At g = 1.5 Potrace has slightly higher IoU, with four times our anchors. These are the 300 fixed paths; Table 1 reports g = 1 on all 2,400. Fig. R3 gives the curves up to g = 1.5, with VTracer.

Q2 — Participants, spread and task coverage. All 18 participants attempted every task under every condition (18 attempts per cell). App. D.7 adds the per-task spread and completion counts to the medians of Table 6. Per task, medians [IQR] over participants:

TaskOurs finishedOurs time (s)AdaVec finishedAdaVec time (s)
Top bar15/1817.5 [9.0, 36.5]11/1854.0 [35.0, 90.0]
X arm18/188.0 [7.0, 11.5]17/1816.0 [14.3, 26.3]
Shorten18/1822.0 [18.3, 26.5]11/1874.0 [57.3, 89.5]
Bottom curve17/1815.5 [10.0, 22.8]16/1818.5 [15.0, 26.5]

"Finished" means the participant clicked Finish; timeouts and abandonments stay in the time statistics. Per participant, summed over the four tasks, Ours was faster than AdaVec for 17 of 18 and needed fewer actions for 18 of 18. Coverage: the four tasks are local move/reshape edits. Splitting and merging segments were not tasks, and no task isolates corner preservation. App. D.7 states this coverage.

Q3 — Where the full-image time goes, and HeisenVec. Geometry dominates the time; the small gain on HeisenVec is partly explained by its many tiny components (App. D.7).

Runtime. Mean per HeisenVec image: decomposition 17.4 s, network inference 2.5 s, per-path fitting and merging 94.7 s, final global optimization 40.1 s; 172.6 s end to end including setup. Fitting runs sequentially over about 127 paths per image (126 foreground components plus the background) and is parallelizable, but we report measured time.

Why the compactness gain nearly disappears. HeisenVec images average 126 components; 76.8% of them are small (area < 1,024 px and span < 64 px) and hold 54.5% of all anchors. We matched our components to native AdaVec's by overlap (12,106 matched pairs). The saving is concentrated in the few large components: those of at least 4,096 px (5% of all components) have 28–38% fewer anchors than AdaVec's. Below that size there is no consistent saving: components of 256–1,024 px have 7.8% fewer anchors, while the smallest (< 256 px) and those of 1,024–4,096 px have more than AdaVec's (4.36 vs. 3.62 and 12.46 vs. 11.82). The smallest mostly sit at four anchors. With 95% of the components below 4,096 px, the saving on matched components is 5.3% (3.7% on whole images in Table 2, which also count unmatched components). Size is part of the explanation, not all of it: components that are not small save 8.8% of the anchors here against 47–61% on the emoji sets.

We thank the reviewer again. The perturbation curves, user-study statistics, runtime breakdown and HeisenVec analysis are in the revised PDF, and we would be glad to provide anything further.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.