Disney Research and ETH Zürich researchers have developed a method that converts raster line art into editable Bézier curves using 2D Gaussian splatting. Presented at SIGGRAPH 2026, the work tackles a stubborn graphics problem: recovering not just the visible pixels of a drawing, but a compact set of strokes that behaves as though an artist had drawn it.
That distinction matters whenever artwork must be resized, restyled, animated or revised. A faithful bitmap copy can look right while remaining awkward to edit. The new method instead reconstructs control points, changing line widths and brush texture, producing splines intended to work with conventional vector-graphics software. The Disney Research project page describes state-of-the-art reconstruction results and an early extension to tracked strokes in video.
The hard part is deciding what counts as a stroke
Turning a black-and-white image into paths sounds like a tracing task. In practice, a raster image says which pixels are dark, not how those marks are organized. At a junction, several lines may cross, touch or branch. A purely local tracer can connect the wrong segments. A method that floods the image with candidate curves may reproduce the pixels but leave an artist with a tangled collection of short, redundant paths.
Those failures expose the difference between visual similarity and useful structure. An editable vector result should preserve topology, follow plausible drawing gestures and use few enough control points to remain manageable. It also needs to cope with expressive marks whose width and opacity vary along a stroke. Older optimization techniques can be sensitive to noisy skeletons, while learned methods may miss fine detail or return representations that do not generalize cleanly beyond their training data.
The researchers’ answer combines computer-vision cues with classical graph processing before optimization begins. According to the 11-page conference paper, the system first binarizes the input, reduces the line work to a pixel skeleton and builds an eight-connected graph over that skeleton. It then uses predicted depth and semantic image features to estimate whether neighboring graph nodes should belong to the same stroke.
This added context is especially useful at ambiguous intersections. Depth can suggest that one contour sits in front of another, while semantic features can indicate that two locally adjacent marks belong to different parts of the subject. The system removes low-affinity connections, favors straight-through continuations at three-way junctions and partitions the cleaned graph into subgraphs. Those subgraphs become paths, which are fitted with splines and converted into cubic Bézier segments. Initial widths come from the distance between the skeleton and the line’s edges.
The approach does not claim to recover an artist’s literal hand motion. It constructs a more plausible and useful stroke decomposition from visual evidence. That is a narrower claim, but an important one for production tools.
Gaussian splats make the curves trainable
Gaussian splatting is best known as a way to render scenes from clouds of soft, overlapping primitives. Here it is used in two dimensions and for a different purpose. The renderer samples small Gaussian primitives inside the region around each Bézier centerline, then composites them to form the visible mark. Because the rendering operation is differentiable, the system can measure the difference between its output and the target image, then send gradients back to the curve parameters.
In plain terms, the renderer supplies a fast feedback loop. Move a control point, change a width or adjust an opacity texture, and the optimizer can calculate how that change affects the reconstructed image. The researchers use Adam to update the parameters. Each stroke has a Bézier centerline, a width function along its length and, for textured drawings, a repeating opacity map that describes the brush appearance.
Fitting happens in two stages. The first adjusts geometry and width. During that process, the system prunes faint or redundant strokes, removes unnecessary control points and adds new curves where foreground pixels remain uncovered. Only after the structure is in place does the second stage optimize brush texture. Keeping those phases separate limits the optimizer’s ability to disguise a bad curve with a convenient texture.
This is also where the representation differs from an opaque image-to-image result. The final parameters remain exposed. A user can move a spline, freeze its geometry while changing the brush, lock the texture while altering line width, or correct an intermediate result and continue fitting. The paper says the output is compatible with existing vector and image-editing software, though the project page does not advertise a public code release or a finished application.
The benchmark gains are substantial, with qualifications
The team evaluated the method on a benchmark containing 369 line drawings with vector ground truth. It compared the system with VirtualSketch, PolyFlow, PolyFields and DeepSketch using geometric and visual-similarity measures. On clean line art, the new method recorded a Chamfer distance of 0.94, compared with 1.45 for DeepSketch, the next-best result in that table. The authors calculate that as a 35.17% reduction. They also report a 55.41% reduction in stroke-length difference against DeepSketch.
The method led the clean-image table on every reported measure except stroke count. That exception needs context: fewer strokes are not automatically better if a method achieves the lower count by omitting parts of the drawing. The researchers explicitly make that point rather than presenting compactness as an unconditional win. Their qualitative examples focus on retaining fine details and handling complicated line topology.
Tests on textured line art show why jointly fitting shape and appearance is useful. The system’s learned width variation and opacity texture produced much better visual-similarity scores than the comparison methods in the paper’s table, while still improving the geometric Chamfer measure. The supplementary document adds per-resolution results and defines how the geometric metrics were calculated.
Speed is less clear-cut than a single ranking suggests. On an Nvidia RTX 3090 and with 200 optimization steps, the full system took an average of 6.37 seconds for a 512-pixel image. DeepSketch took 4.93 seconds and PolyFields 3.73 seconds in the same table. At 1,024 pixels, however, the new method completed in 10.73 seconds, ahead of DeepSketch at 16.76 seconds, VirtualSketch at 26.92 seconds and PolyFlow at 68.07 seconds, though PolyFields remained faster at 8.56 seconds. The graph-and-affinity initialization without the full refinement stage was faster still, but it is not equivalent to the finished result.
The useful conclusion is not that tracing is now instant. It is that the Gaussian renderer makes iterative fitting competitive while supporting a richer, editable stroke model. The benchmark is also relatively small and controlled. Results on 369 drawings do not by themselves establish how the system would handle the range of scanned paper, compressed web images or production animation assets encountered outside a research dataset.
Video turns vectorization into a tracking problem
For animation, processing every frame independently creates another failure. Each frame may look accurate, yet contain a different collection of paths, so a change to one curve cannot travel cleanly through the sequence. The researchers extend their representation by tracking points over time, learning per-frame movement for control points and estimating the visibility of Bézier segments.
The process begins with a vectorized reference frame. It uses an existing dense point tracker to initialize motion, then jointly optimizes strokes across the sequence. If one frame develops a particularly high reconstruction error, the method can introduce it as another reference frame, vectorize missing content there and track the added strokes through the rest of the clip. This adaptive keyframe step is meant to cover objects or marks that were not visible in the first frame without duplicating curves already represented.
The payoff is temporal identity: a stroke can remain the same editable object as it moves. In the examples, that lets an edit made to the initial frame propagate over time. The authors describe the video results as promising, not solved. Joint fitting alone reduces the number of lines but harms reconstruction quality; tracking and added keyframes are needed to recover it. The reported video optimization also runs for 15,000 iterations, far beyond the 200 used for clean still images.
Where the method still breaks
The paper identifies two central weaknesses. Rough drawings with complicated textures or noisy backgrounds can leave artifacts in the skeleton. Those artifacts may survive cleanup and become spurious strokes in the output. For video, occlusion is harder still because part of a single curve can disappear at almost any point along its length. Predicted motion and visibility can compensate for some cases, but severe occlusion can cause flicker and visible errors.
There are practical unknowns too. The published material demonstrates a research pipeline, not an announced feature for Disney’s animation software. Developers cannot yet judge installation complexity, memory use, model dependencies or behavior on their own assets from a public repository. The timing results rely on an RTX 3090, so performance on laptops and less capable GPUs remains unreported.
Still, the work points toward a useful role for machine perception in graphics: not generating a final pile of pixels, but recovering a structured document that a person can inspect and change. What matters next is whether code becomes available, whether independent tests reproduce the benchmark gains, and whether the video method can handle longer sequences and hard occlusions without losing stroke identity. Those checks will determine whether this remains an effective SIGGRAPH demonstration or becomes a practical part of drawing and animation workflows.