- 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
-
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.
-
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
-
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.
-
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
-
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?
-
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)?
-
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?
-
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?
-
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)?
-
What is the number of decoder queries N, and how are their initial coordinates set? How often does the true anchor count approach N?
-
How are compound paths and shapes with holes handled?
-
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
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.
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.