# Inbetweening with occlusions for non-linear rough 2D animation

Melvin Even, Pierre Bénard, Pascal Barla

<figure><img src="image_1.png" /></figure>

To cite this version:

Melvin Even, Pierre Bénard, Pascal Barla. Inbetweening with occlusions for non-linear rough 2D animation. Computers and Graphics, 2025, 129, pp.104223. 10.1016/j.cag.2025.104223. hal-05085135

HAL Id: hal-05085135

https://hal.science/hal-05085135v1

Submitted on 26 May 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_2.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
Special Section on Expressive Media

Inbetweening with occlusions for non-linear rough 2D animation

Melvin Even, Pierre Bénard *, Pascal Barla

Inria, Univ. Bordeaux, CNRS, Bordeaux INP, LaBRI, UMR 5800, 200 avenue de la vielle tour, Talence, 33400, France

<figure><img src="image_3.png" /></figure>

ARTICLE INFO

Keywords:

2D animation

Occlusions

Sketch

A B S T R A C T

Representing 3D motion and depth through 2D animated drawings is a notoriously difficult task, requiring time and expertise when done by hand. Artists must pay particular attention to occlusions and how they evolve through time, a tedious process. Computer-assisted inbetweening methods such as cut-out animation tools allow for such occlusions to be handled beforehand using a 2D rig, at the expense of flexibility and artistic expression.

In this work, we extend the more flexible 2D animation framework of Even et al., (2023) to handle
occlusions. We do so by retaining three key properties of their system that are crucial to speed-up the animation
process: input rough drawings, real-time preview, and non-linear animation editing. Our contribution is two-
fold: a fast method to compute 2D masks from rough drawings with a semi-automatic dynamic layout system
for occlusions between drawing parts; and a method to both automatically and manually control the dynamic
visibility of strokes for self-occlusions. Such controls are not available in any traditional 2D animation software
especially with rough drawings. Our system helps artists produce convincing 3D-like 2D animations, including
head turns, foreshortening effects, out-of-plane rotations, overlapping volumes and even transparency.

1. Introduction

Creating the illusion of 3D-like motion with animated drawings is
one of the most difficult challenges of 2D animation. The two main
contributing factors to give the illusion of 3D shape are occlusions and
perspective cues. In this paper we focus on occlusions, which have
been shown to play a central role in conveying motion in depth [1,2].
Visually, occlusions translate into parts of the drawing masking or
revealing each others, such as the ears of the character in Fig. 1, and
into silhouette lines gradually appearing or disappearing, such as the
face contour in the same head-turn animation (also see the close-up
view in Fig. 8).

In traditional animation, either on paper or on screen, artists achieve
such effects by precisely controlling the layout of their drawings and
controlling its evolution (trajectories and dynamics) through time.
This process not only requires intensive manual labor, which makes
experimenting with different motions time-consuming as the artist
needs to redraw every frame of the animation at each trial; but it also
implies extensive training and expertise on the part of the animator.

An alternative approach is to rely on cut-out animation software, in
which artists first build 2.5D rigs composed of 2D shapes organized in
depth, then animate them directly through time. To convey depth, spe-
cific animations (e.g., out-of-plane rotations) must be predefined in the
rig. This approach is often used in animated series as it greatly shortens
production times, as well as in video games and live performance since

rig controls may be easily mapped to various user inputs. However,
cut-out animation suffers from a number of limitations: artists must
work with a constrained workflow which is often restricted to char-
acter animation; and animation expressivity remains reduced unless a
significant time is invested early on in the design of the rig, which once
again requires a tremendous amount of manual work.

Our goal is to provide artists with a set of tools and algorithms
that facilitate the control of occlusions, namely the dynamic masking
and ordering of drawing parts and the smooth growing and receding
of silhouette lines, while retaining the flexibility of traditional 2D
animation workflows. To guide the design of our method, we have
conducted interviews with professional 2D animators, from which we
have identified the following practical guidelines:

* **G1:** the handling of occlusions should not deviate significantly from animators workflow, with most of their time spent drawing or erasing lines.

* **G2:** since the illusion of 3D motion is conveyed at the very first stages of animation, occlusions should be conveyed given rough drawings as input.

* **G3:** occlusions should be made to happen at or between keyframes, and may be of two types: between object parts (e.g., a hand passing in front of another and hiding it), and self-occlusions (e.g., as in the folds of a piece of cloth).

<footnote>* Corresponding author.
E-mail address: pierre.benard@u-bordeaux.fr (P. Bénard).</footnote>
<figure><img src="image_4.png" /><figcaption>**Fig. 1.** Starting from the head-turn animation in [3] (bottom), with input key drawings in dark blue and automatic inbetweens in light blue, we use different features of our system to produce an animation (top) with occlusions (e.g., ears). From left to right: masks are automatically computed for all drawing parts to create occlusions among them; a stroke is appearing through a temporal visibility threshold; a partial drawing of the nose is created at an intermediate frame (it is stored at a keyframe, but is made to appear later on via visibility); a stroke is made to disappear on the opposite ear, and it is suddenly interrupted by the “pop” of the right ear in front, via a layout change between keyframes. The final result conveys a strong 3D-like sense as best seen in our video.</figcaption></figure>

<figure><img src="image_5.png" /><figcaption>**Fig. 2.** Mask creation. (a,d): input drawing parts overlaid by their lattice (in magenta). The coarse mask in (b) is computed from the exterior boundary of the lattice, and automatically refined by projecting the lattice boundary vertices onto the strokes to yield the tight mask in (c). The tight mask in (e) only encloses the strokes in the drawing part. In (f), an invisible line has been sketched, yielding a new mask.</figcaption></figure>

To comply with G2, we have decided to build our method on the 2D animation system of Even et al. [3] (presented in Section 3), as it retains the flexibility of traditional 2D rough animation while easing both the matching of drawings at key frames (key drawings) and their interpolation at intermediate frames (inbetweens). In addition, it allows artists to perform non-linear edits and provides real-time previsualization.

However, this system does not handle any kind of occlusions. Our first contribution (Section 4) is to extend its structure to support the semi-automatic inbetweening of key drawings, using masks and dynamic layouts to handle occlusions among object parts and stroke visibility attributes for self-occlusions.

Our second set of contributions (Section 5) is to provide (semi-)automatic algorithms and tools to control this animation structure, while retaining non-linear editing functionalities and interactivity. In particular, we introduce (1) automatic layout propagation and layout change algorithms to produce dynamic occlusions among drawing parts; and (2) automatic computation of stroke visibility attributes to let lines appear or disappear between keyframes.

In Section 6, we demonstrate the effectiveness of our approach by reproducing complex 2D animations with occlusions using a minimal number of key drawings or user interaction (also see the supplemental video), which is confirmed through a usability study comparing our novel tools with the system of Even et al. [3]. We discuss the limitations of our method in Section 7.

## 2. Previous work

In traditional 2D animation, occluded lines are either erased manually or masked through *matting*, a process in which drawings are broken down into layers ordered in depth, and each drawing element is represented as a silhouette to create solid areas that occlude underlying elements [4]. This method can be found in all modern 2D animation software [5,6].

Previous work on computer-assisted 2D animation with occlusions can be classified into three main families of approaches: rig-based, stroke-based and learning-based methods.

**Rig-based methods.** In rig-based systems, artists first create a rig over the drawing by defining controllers and deformations. Rigged models are then used to accelerate the animation process at the cost of less flexibility compared to traditional animation workflows, which require drawing every single frame. The “skeletal strokes” of Hsu et al. [7,8] are probably the first rig of that sort demonstrating the ability to manually control and animate vector drawing deformations, including 3D-like effects with occlusions (using a surface removal trick). Following 2.5D animation systems allow artists to decompose 2D drawings into parts according to depth ordering, using 3D handles (e.g., bones, anchors) to guide their motion and deformation in 3D.

Yeh et al. [9] use a simple two-sided drawing representation to produce 2.5D effects, including rolling, twisting, and folding. The method of Rivers et al. [10] estimates 3D anchor points to drive the motion of animated billboards. In their system, the user draws various viewpoints of the same object and place them in a predefined parameterized space which is then used to both blend the key drawings as well as to interpolate the 3D anchors. Coutinho et al. [11] use a 2.5D skeleton on top of the previous method to ease the creation of new poses. The work of Fukusato and Maejima [12] is in the same vein but it combines view-dependent deformations [13] with As-Rigid-As-Possible (ARAP) interpolation techniques [14].

Other methods use different types of proxies such as 3D skeletons (e.g., [15]). Most notably, the method of Brodt and Bessmeltsev [16] interpolates raster key drawings with occlusions by optimizing the topology of a 2.5D partially layered template guided by a 3D skeleton. Some commercial software use 2.5D methods to animate characters for cartoons [17,18] or interactive performance [19].

Such 2.5D methods suffer from rigid workflows due to a strict de-coupling between the rigging and the animation phases, making them closer to 3D animation (with flat 2D shapes) than traditional hand-drawn 2D animation (G1). In addition, despite depth information and occlusions, the resulting animations may still look overly flat, revealing their cut-out nature. Our method addresses these two limitations.
**Stroke-based methods.** Stroke-based methods take as input clean-line drawings and either (1) use the strokes themselves to define occluding regions, or (2) use the stroke-graph representation of each drawing to handle the visibility of (sub)strokes.

In the first category, Jiang et al. [20] let the user define one-sided *boundary strokes* from which masks are automatically computed at keyframes and during the inbetweening process. Carvalho et al. [21] let the user manually select a sequence of strokes to define the contour of a region. These regions can then be colored to mask each other; region depth is manually specified at keyframes and interpolated for inbetween frames.

In the second category, Noris et al. [22] and Yang [23] handle occlusions by drawing occluded strokes or manually tagging their visibility at the substroke level, which is then propagated through time using the stroke graph. Dalstein et al. [24] extend such a representation with a space-time data-structure that stores time-continuous topological events (merge, split, appearance, or disappearance) throughout the animation. The drawing interpolation problem is thus solved by construction, but the structure itself must be built manually, which is little intuitive and time-consuming. Similarly to our system, the layout of the drawings may be specified at keyframes with a discrete depth-ordering. However, unlike ours, the layout cannot change inbetween keys during the interpolation, and no tools are provided for its automatic propagation to adjacent keyframes.

Starting from existing cell animations, dedicated region tracking algorithms [25,26] have been proposed for editing propagation or temporal super-sampling. They manage to automatically find spatio-temporal correspondences between regions across a full animation sequence with an existing but implicit layout in the presence of partial and even complete occlusions. We tackle an almost opposite problem: starting from already registered key drawings, we propagate the layout of one of these keys to the others.

Stroke-based methods are more in line with the traditional 2D animation pipeline than rig-based approaches, but they can only be applied after the cleaning step, on the final animation, which prevents their use at earlier, more creative stages of the animation process (G2). In contrast, we would like to handle rough drawings that are typical of the motion design stage, and we want to avoid creating a global structure (e.g., a stroke-graph) of the drawings or animation. These goals guided our choice for the non-linear animation system of Even et al. [3] based on transient embeddings that we recall in Section 3. It seems to us a more appropriate starting point than the system of Xing et al. [27] that purely works at the stroke level and thus makes drawing layout hard to define.

**Learning-based methods.** In recent years, video frame interpolation, which aims at synthesizing intermediate frames in between two adjacent frames of a video, has been extensively studied with data-driven approaches. Several methods dedicated to cartoon animations have been proposed [28–31] with impressive results but limited artistic controls of the generated motion.

Methods dedicated to line drawings [32–34] have also been introduced, but they target clean line drawing as input and/or as output. In addition, such learning-based methods require large annotated data sets for training purposes, and these are often biased towards a specific drawing style (e.g., 75% of Japanese anime in the data set of Xing et al. [31]), questioning their generalization capabilities.

# 3. System overview

**Previous system.** The core of our system (matching and interpolation of the key drawings) is based on the 2D animation system of Even et al. [3]. In this system, the user draws sparse and rough key drawings that are manually decomposed into a set of transient embeddings. Each transient embedding corresponds to a drawing part, i.e., a group of strokes (polylines) that usually share a common semantic and similar

motion, and are embedded in the same 2D square lattice. The lattice is built axis-aligned, and each quad cell stores the stroke vertex indices that it contains.

Drawing parts of consecutive keyframes are semi-automatically registered using ARAP matching [35] and inbetweened with ARAP interpolation [36]. The system is non-linear in the sense that the matching and the interpolation dynamics (i.e., the timing and spacing) can be modified in a non-destructive fashion in any order or workflow. The spacing (i.e., the distribution of the inbetween frames in time) of the animation can be controlled via a chart-like interface. Spatial and temporal continuity of the animation may be locally enforced using trajectory constraints connecting multiple transient embeddings, allowing for continuity preservation across topological changes between key drawings.

Nevertheless, the major limitation of the system of Even et al. is the fact that drawing parts cannot occlude each other. Furthermore, topological changes (e.g., stroke appearance or disappearance) can only occur at keyframes which is problematic for 3D-like motion since many elements of the drawing should potentially appear or disappear during interpolation (G3).

**Our additions and necessary structural changes.** To lift these restrictions, we extend their animation structure in several ways. First, at keyframes, we compute masks for rough drawings parts and let the user order them in depth, forming the *static layout* of key drawings (G2). Second, at any inbetween frame, we support adding *dynamic layout changes* that provide artists with controls over occlusions among drawing parts (G3) without sacrificing non-linear editing. Finally, we introduce *temporal visibility thresholds* to control the gradual appearance and disappearance of stroke vertices within embeddings during the course of the interpolation. These three structural extensions are described in Section 4. A graphical overview of our new structures and how they interplay with those of Even et al. [3] is available in the supplemental material.

The ways we instantiate and manipulate this new animation structure are described in Section 5. Our general approach is to suggest changes to the animation structure, which if required may be non-linearly edited through tools compatible with traditional animation workflows (G1). The main practical advantage of our approach is that animators do not have to learn how to manipulate a complex structure, as opposed to methods based on rigs or stroke graphs.

To speed up the animation process, we present two automatic algorithms to propagate the layout of a given key drawing to adjacent keyframes, but also to determine whether a layout must change between two key drawings to minimize visibility changes and, if so, at what interpolation time. We additionally propose stroke visibility tools to automatically estimate temporal visibility thresholds based on the key drawing content, and to manually specify or refine them with a painting metaphor. We show in the supplemental video and in Section 6 how these tools are used in practice, and how they convey occlusions in typical animation cases.

# 4. Animation structure

In this section we describe the extensions we made to the animation structure of Even et al. [3] to handle occlusions. In Section 4.1, we explain how occlusions are handled at keyframes using masks and layouts. Occlusion between keyframes are permitted through dynamic layout changes for occlusions among parts, and through stroke visibility attributes for self-occlusions, as described in Sections 4.2 and 4.3 respectively.

## 4.1. Static layout

**Mask creation.** To create occlusions among parts, we first need to identify their interiors. We thus pre-compute a *mask* per drawing part, which consists of a 2D polygon that approximately encloses all of its
<figure><img src="image_6.png" /><figcaption>**Fig. 3.** Drawing layout. We start in (a) with a layout where part $X_1$ is in front of $X_2$, and parts $X_3$ and $X_4$ are both in the background. This is represented by the list at the bottom. Part $X_4$ is then moved in front of $X_2$ (red arrow). The result is shown in (b) with the default occluded line style, and in (c) with a different style per part, varying thickness and opacity.</figcaption></figure>

strokes. We propose a simple algorithm that leverages the lattice to compute masks in real time. We assume that the lattice has a sufficient resolution to capture the general silhouette of the drawing part, otherwise its resolution may be increased independently for each part. The exterior boundary of the lattice already forms the outline of a coarse but conservative mask (Fig. 2(b)). It is efficiently extracted by walking along boundary edges starting from one of the quad corners with minimum abscissa. We then refine this initial mask by projecting its outline onto the enclosed strokes (Fig. 2(c)). The interior of the resulting polygon is eventually tessellated using the algorithm of the OpenGL Utility Library (GLU) [37]. The polygon might be self-intersecting, but this is not an issue for mask rendering.

Optionally, the artist may manually refine the mask by drawing its silhouette, which is especially useful to close open parts (Fig. 2(e,f)). In practice, silhouette strokes are simply added to the lattice, potentially expanding it, before recomputing the mask. These strokes are never drawn, except when editing the mask. Silhouette strokes could be automatically suggested to the user based on the convex hull of the drawing part.

For simplicity, we do not support masks with holes. If required, “Smart Scribbles” [38] could be used instead, but this method is more computationally expensive and produces raster masks, which would make their interpolation more difficult.

**Drawing layout.** The parts of a key drawing equipped with their mask are partially ordered with *discrete* depth levels, defining the drawing layout. Parts at a given depth occlude the strokes of parts with a strictly lower depth level (as well as parts from lower layers). The major advantage of such a representation over continuous depth values is that we do not need to consider the depth of a part relative to the whole drawing, but solely to the parts it intersects, requiring less user intervention.

As shown in Fig. 3, the depth ordering is stored at keyframes as an ordered list of sets of parts. When a key drawing is first drawn, the list is made of a single set holding all the drawing parts; hence no occlusion occurs. As shown in Fig. 3(a,b) and the supplemental video, the user may move the currently selected parts in front of, behind, or at the same depth level of a target part by clicking on it and using keyboard modifiers.

**Stroke masking.** When rendering a drawing, its parts are drawn from farthest to closest according to the drawing layout. To account for the cumulative effect of the masks, we progressively store them in an offscreen buffer that acts as a stencil. See the supplemental document for a detailed description of our OpenGL implementation. The style of (partially) occluded strokes can change per drawing part, as shown in Fig. 3(c). This is particularly useful during the first stages of animation, where hidden lines may be shown in a different style even when fully occluded to better read motion.

## 4.2. Dynamic layout

**Layout inbetweening.** Similarly to the strokes they enclose, masks are embedded in their corresponding lattice and thus automatically follow the lattice deformation at intermediate frames. The system of Even et al. [3] optionally uses a thickness-based cross-fading of strokes between keyframes, whereby strokes of the next key drawing are propagated backward in time. We provide a similar option by propagating the mask of the next keyframe backward and cross-fading the opacities of forward and backward masks.

**Layout change.** By default, the drawing layout remains constant throughout interpolation, and only changes at keyframes. However, defining a new keyframe every time the depth level of a given part changes is undesirable. We thus support layout changes occurring at any intermediate frame between two keyframes. These layout changes are recorded relative to the linear interpolation time $t \in [0, 1]$ between two contiguous keyframes. This has the advantage of precisely locating the layout change at a point in space (e.g., along a motion trajectory), while remaining unaffected by timing or spacing.

The layout change occurs at the frame $f$ that follows the relative time $t$. When an intermediate frame is rendered, we assign the current layout to that of the previous layout change if there is one, or else to the layout stored at the previous keyframe. Our dynamic layout approach provides an explicit control in time, in contrast to previous approaches (e.g., [10,21] for rig- and stroke-based methods respectively) where ordering emerges from depth interpolation of drawing parts.

## 4.3. Stroke visibility

In addition to global layout changes, contours may grow or shrink to convey self-occlusions due to camera motion or object deformation. To capture this effect with sketchy drawings, we need a way to make a group of strokes (representing one or multiple contours) gradually appear or disappear during interpolation.

Our solution is to assign a temporal visibility threshold $v_i \in [-1, 1]$ to each vertex of a stroke, with $\text{sign}(v_i)$ encoding whether the $i$th vertex should appear or disappear, and $|v_i|$ storing the time when this event should occur. The visibility of a vertex $i$ at interpolation time $t \in [0, 1]$ is then given by the condition $t \ge v_i$ for appearing vertices and $t < -v_i$ for disappearing vertices.

By default, $v_i = 0$ which means the vertex is always visible. When all the vertices of a stroke have the same threshold $v_i \ne 0$, it will “pop” in or out at frame $|v_i|$. For a progressive appearance/disappearance of strokes throughout interpolation, visibility thresholds should smoothly vary in screen space (and hence across multiple strokes). This is exemplified in Fig. 10, where some stroke vertices are made to disappear during a traveling motion to convey levels of detail.

# 5. Animation tools

We now introduce animation tools whose purpose is to control dynamic layouts (Section 5.1) and stroke visibility (Section 5.2). The full animation is updated in real-time thanks to an efficient implementation, whose performance is detailed in the supplemental document. Mathematical notations are summarized in Table 1.

## 5.1. Layout editing tools

In the following, we assume that at least one non-trivial drawing layout has been given at a key drawing, such as in Fig. 4(a) at frame 6.
<figure><img src="image_7.png" /><figcaption>**Fig. 4.** Layout editing tools overview. (a) We start from three key drawings with a static layout set for the second keyframe. (b) This layout is automatically propagated to the third keyframe upon user request. Since the layout of the first keyframe is fixed throughout the interpolation, the ear suddenly changes depth just before the second keyframe. (c) Our automatic algorithm suggests a layout change at the most appropriate time: in this case at frame 2 as it presents minimal overlap between the ear and the face, which reduces the number of stroke vertices suddenly appearing.</figcaption></figure>

<table><caption>**Table 1**
Table of notation.</caption><thead><tr><th>Notation</th><th>Description</th></tr></thead><tbody><tr><td>X/Y</td><td>Two successive key drawings, i.e., set of stroke vertices</td></tr><tr><td>X<sup>i</sup><sub>m</sub></td><td><i>m</i>th drawing part of <i>X</i> deformed at time <i>t</i> (omitted if <i>t</i> = 0)</td></tr><tr><td>L<sub>X</sub></td><td>Layout of <i>X</i>, i.e., ordered list of its drawing parts</td></tr><tr><td>x<sub>i</sub></td><td>2D position of the <i>i</i>th stroke vertex of a key drawing or a drawing part</td></tr><tr><td>τ<sub>i</sub></td><td>Radius of the <i>i</i>th stroke vertex</td></tr><tr><td>ν<sub>i</sub></td><td>Visibility threshold of the <i>i</i>th stroke vertex (in [-1, 1])</td></tr><tr><td>N<sub>Y</sub>(x)</td><td>Set of vertices in <i>Y</i> that are within a threshold distance of <i>x</i></td></tr><tr><td>vis<sub>i</sub>(L<sub>X</sub>)</td><td>Indicates whether the <i>i</i>th stroke vertex is visible with L<sub>X</sub> applied (in {0, 1})</td></tr><tr><td>ν'<sub>X,Y</sub>(L<sub>X</sub>, L<sub>Y</sub>)</td><td>Stroke visibility changes metric between layouts L<sub>X</sub> and L<sub>Y</sub></td></tr><tr><td>X'<sub>vis</sub></td><td>Set of visible vertices in <i>X</i> at time <i>t</i></td></tr><tr><td>X<sub>out</sub>(Y)</td><td>Set of vertices in <i>X</i> that are at least a minimal distance away from <i>Y</i></td></tr><tr><td>X<sub>seed</sub>(Y)</td><td>Set of vertices in X \ X<sub>out</sub>(Y) that should appear first.</td></tr></tbody></table>

**Automatic layout propagation.** The layout of a key drawing *X* is propagated to the next key drawing *Y* using a mapping between drawing parts from *X* to *Y* that was not necessary in the system of Even et al. [3]. In general, this is a many-to-one mapping since adjacent key drawings may be composed of different numbers of parts. For each pair of parts *X*<sub>m</sub> in *X* and *Y*<sub>n</sub> in *Y*, we measure how much *X*<sub>m</sub> is covered by *Y*<sub>n</sub> at the key drawing *Y*. To this end, we transform the strokes of *X*<sub>m</sub> to their target position at interpolation time *t* = 1 using their lattice deformation and we resample them uniformly, denoting the resulting set of vertices by *X*<sup>1</sup><sub>m</sub> (Fig. 5(b)). We then iterate over all the vertices *x*<sub>i</sub> ∈ *X*<sup>1</sup><sub>m</sub> and count the number *N*<sub>*Y*<sub>n</sub></sub>(*x*<sub>i</sub>) of vertices in *Y*<sub>n</sub> encountered within a spatial window based on the local stroke thickness τ(*x*<sub>i</sub>), using:

$$N_Y(x) = \{ y_j \in Y \mid \|x - y_j\| < \tau(x) + 2 \}, \quad (1)$$

where thickness is measured in pixels, and we have added a tolerance of 2 pixels to handle very thin lines. The part *X*<sub>*</sub> with the highest coverage is then selected for the mapping, and *Y*<sub>n</sub> receives its depth level. This process is illustrated in Fig. 4(b). We use the same approach to propagate a layout to a previous key drawing, using the inverse mapping. The process may also be repeated multiple times from key to key.

<figure><img src="image_8.png" /><figcaption>**Fig. 5.** Automatic layout propagation. (a-b) Every parts of the first key drawing *X* (second keyframe of Fig. 4) is deformed to its target position at *t* = 1 using its lattice deformation. (c) These parts are then mapped to the drawing parts in the second key drawing *Y* (third keyframe of Fig. 4), based on coverage.</figcaption></figure>

**Automatic layout change.** Since the layout of a key drawing *X* is held during the course of interpolation towards the next key drawing *Y*, it may lead to strokes popping in or out when *Y* is reached, as seen in the second row of Fig. 4 between frames 1 and 6. We propose an algorithm to detect automatically whether the layout of *X* must be modified to minimize such visibility changes. We write *L*<sub>*X*</sub> to denote the ordered list of drawing parts at *X*, as shown in Fig. 3-bottom. Starting from *L*<sub>*X*</sub> and *L*<sub>*Y*</sub>, our goal is twofold: find an optimal layout change *L*<sup>*</sup><sub>*X*</sub> that produces the smallest amount of visibility changes; and determine the best interpolation time *t*<sub>*</sub> for this change to occur. In case *L*<sub>*X*</sub> is already optimal, the default layout change occurs at *t* = 1.

We measure visibility changes between two layouts for two key drawings *X* and *Y* using:

$$\nu_{X,Y}(L_X, L_Y) = \sum_{x_i \in X} \sum_{y_j \in N_Y(x_i)} \frac{|\text{vis}_i(L_X) - \text{vis}_j(L_Y)|}{\#N_Y(x_i)}, \quad (2)$$

where *x*<sub>*i*</sub> ∈ *X* denotes the *i*th stroke vertex from any drawing part in *X*, vis<sub>*i*</sub>(*L*<sub>*X*</sub>) ∈ {0, 1} indicates whether this vertex is visible when the layout *L*<sub>*X*</sub> is used, N<sub>*Y*</sub>(*x*<sub>*i*</sub>) identifies the set of stroke vertices of *Y* in the neighborhood of *x*<sub>*i*</sub> (see Eq. (1)) and # indicates its cardinal.

In principle, we would like to find a layout *L*<sup>*</sup><sub>*X*</sub> that minimizes $\nu_{X^1,Y}(L_X^*, L_Y)$, with $X^1$ the set of stroke vertices in *X* transformed by their lattice deformation at *t* = 1. In practice, this is not feasible as the size of the search space is factorial in the number of drawing parts, and multiple optimal solutions exist since a layout is only a relative ordering of parts. We therefore use the following
<figure><img src="image_9.png" /><figcaption>Fig. 6. Automatic layout change. (a) Deformed version of the key drawing X at t = 1 using its original layout L_X (first keyframe of Fig. 4). (b) Drawing obtained using our heuristic layout L'_X propagated backward from the key drawing Y (second keyframe of Fig. 4). This leads to less visibility changes (i.e., gray strokes) compared to (a).</figcaption></figure>

heuristic: we compute a possible layout change L'_X using the many-to-one mapping described previously for layout propagation (see Fig. 6). This layout change is relevant if it produces less stroke visibility changes than the current layout, which happens when $\nu'_{X^1,Y}(L'_X, L_Y) < \nu'_{X^1,Y}(L_X, L_Y)$. If the matching between key drawings is precise enough, we observed that our heuristic and the optimal layouts are equivalent (i.e., $\nu'_{X^1,Y}(L'_X, L_Y) = \nu'_{X^1,Y}(L_X^*, L_Y)$), which happens in nearly all our tests. Otherwise, when key drawings are poorly matched or very sketchy, the layouts might differ but the difference in terms of visibility changes is minimal. Examples for these two cases are provided in the supplemental document.

When a layout change is detected, we also compute its optimal interpolation time $t_*$ by applying $L'_X$ to every interpolated time t corresponding to a frame f, keeping the one that produces the smallest amount of visibility changes (see Fig. 4(c) and the supplemental document):

$$t_* = \operatorname*{argmin}_{t} \nu'_{X',X}(L_X, L'_{X}). \qquad (3)$$

As demonstrated in the supplemental video, artists may still edit the time $t_*$ of the layout change directly on the spacing chart interface or on motion trajectories, which complies with traditional animation workflows.

## 5.2. Stroke visibility tools

By default, all stroke visibility thresholds are set to $v_i = 0$ (strokes fully visible). We now introduce tools that change $v_i$ values so that strokes progressively appear or disappear through interpolation.

**Automatic visibility thresholds.** When interpolating a key drawing from one key drawing to the next, portions of strokes may appear or disappear suddenly. Since this is often undesirable, we propose an automatic algorithm to gradually reveal or hide these portions.

First consider the simpler case of disappearing vertices. We identify by $X_{\text{out}}(Y)$ the set of vertices in key drawing X that must disappear when matched with key drawing Y:

$$X_{\text{out}}(Y) = \{ \mathbf{x}_i \in X_{\text{vis}}^1 \mid \|\mathbf{x}_i - \mathbf{y}_j\| \ge \epsilon, \forall \mathbf{y}_j \in Y_{\text{vis}} \}, \qquad (4)$$

with $X_{\text{vis}}^1$ the set of visible vertices in X at time t = 1 based on the current layout $L_X$, and $Y_{\text{vis}}$ the set of visible vertices in Y (at time t = 0) based on $L_Y$. We use $\epsilon = \sqrt{2\pi}(x)$ to account for small gaps between strokes. Geometrically, $X_{\text{out}}$ corresponds to the stroke vertices of Y that are outside a dilated version of the key drawing X transformed at t = 1 (shown in blue in Fig. 7(c)).

By default, we propose to make stroke vertices in $X_{\text{out}}$ disappear based on their proximity to strokes in Y, i.e., the farthest vertices from Y should disappear first. To obtain such a behavior, we compute spatially-smooth temporal visibility thresholds $v_i$ through an isotropic diffusion process that starts at a set of vertices $X_{\text{seed}}$ acting as sources with $v_i = 0$ and progresses until all vertices in $X_{\text{out}}$ are processed. $X_{\text{seed}}(Y)$ (shown in red in Fig. 7(c)) is given by:

$$X_{\text{seed}}(Y) = \{ \mathbf{x}_i \in X_{\text{vis}}^1 \mid \exists \mathbf{y}_j \in Y_{\text{vis}}, \|\mathbf{x}_i - \mathbf{y}_j\| < \epsilon \\ \wedge \exists \mathbf{x}_o \in X_{\text{out}}(Y), \|\mathbf{x}_i - \mathbf{x}_o\| < \epsilon \},$$

<figure><img src="image_10.png" /><figcaption>Fig. 7. Stroke visibility. (a,b) Input key drawings X and Y. (c) Computation of $X_{\text{out}}(Y)$ and $X_{\text{seed}}(Y)$, the tolerance $\epsilon$ around strokes is visualized with thin lines. (d) Stroke visibility thresholds $v_i$ are automatically computed through isotropic diffusion from $X_{\text{seed}}(Y)$ over all of $X_{\text{out}}(Y)$, with their values visualized in red.</figcaption></figure>

<figure><img src="image_11.png" /><figcaption>Fig. 8. Automatic visibility thresholds. The default interpolation of the two input keyframes (top row) results in the sudden disappearance of strokes vertices at the second keyframe. Our algorithm automatically assigns visibility thresholds to keyframe 1 (shown in red), resulting in the gradual disappearance of stroke vertices during the animation (bottom row).</figcaption></figure>

The first condition ensures that seed vertices are close to the key drawing Y, and the second condition makes sure that they are close to vertices of X that must disappear (i.e., $X_{\text{out}}$). Note that $X_{\text{out}}(Y) \cap X_{\text{seed}}(Y) = \emptyset$. We now assign visibility thresholds $v_i \in [0, 1]$ to all vertices i in $X_{\text{out}}$ through isotropic diffusion (see Fig. 7(d)), using:

$$v'_i = \min_{\mathbf{x}_s \in X_{\text{seed}}} \|\mathbf{x}_i - \mathbf{x}_s\|, \quad \text{and} \quad v_i = \frac{-v'_i}{\max_k v'_k}. \qquad (5)$$

Note the negative sign before $v'_i$ since vertices are disappearing and thus receive negative visibility thresholds.

For appearing stroke portions, we first need to identify the set of appearing stroke vertices in the key drawing Y based on its matching with the previous key drawing X. This amounts to identifying $Y_{\text{out}}(X)$ which is defined similarly to $X_{\text{out}}(Y)$ in Eq. (4), except that the process is applied backward in time, from Y to X. More details are provided in the supplemental document. Once all appearing vertices have been copied into key drawing X, we apply the previously described isotropic diffusion process, but using positive visibility thresholds in Eq. (5). Fig. 8 demonstrates the application of this algorithm on the final two keyframes of the head-turn animation from Fig. 1.

**Painting tools.** The isotropic diffusion process used to estimate visibility thresholds may fail in tricky configurations, such as the spiral animation shown out in the supplemental video. We then resort to a more direct editing approach through a visibility gradient tool. Using a brush metaphor, the user paints a guiding path along which strokes should appear or disappear. Vertices inside the brush footprint are projected
<figure><img src="image_12.png" /><figcaption>**Fig. 9.** Parallax scrolling. A character (at depth level 1) walks in front of a door (at depth level 0) and behind objects laid on a table (at depth level 2). The masks of the semi-transparent vase, bottle and fish bowl are used to modulate the thickness and opacity of the character strokes (inset zooms). The drawings at the three depth levels are translated at a slightly different speed to create a parallax scrolling effect, better seen in the supplemental video.</figcaption></figure>

onto the guiding path and assigned the threshold $v(u) = (1-u)v^{\text{start}} + uv^{\text{end}}$ where $u$ is the arc-length parameterization of the guiding path. As shown in the video, we provide additional controls to adjust $v^{\text{start}}$ and $v^{\text{end}}$, the thresholds at the extremities of the guiding stroke.

An even more direct artistic control is provided through temporal painting tools, which are applied at interpolated frames. We first provide a temporal eraser tool, which instead of erasing vertices, sets their threshold to $v = -\frac{f-f_X}{f_Y-f_X}$, where $f$ is the edited frame, and $f_X$ and $f_Y$

are the previous and next keyframes. As a result, these stroke vertices disappear at frame $f$. Conversely, the temporal pen tool allows artists to draw new strokes at an intermediate frame $f$, effectively creating a *partial drawing*. These strokes are embedded in the deformed lattice then carried out to the previous key drawing $X$ by applying the inverse lattice transform, and their visibility thresholds are set to $v = \frac{f-f_X}{f_Y-f_X}$. This is used on the nose in Fig. 1 for instance.

# 6. Results

We demonstrate our animation system in a three-parts supplemental video, starting with complex animation results presented in Section 6.1, followed by a detailed explanation of how the tools of Section 5 work (also see the supplemental document), and concluded by comparisons with the previous system of Even et al. [3], as described in Section 6.2.

## 6.1. Case studies

In the following examples, we did not use the cross-fade feature of Even et al. [3] system to smoothly blend sketchy keyframes, as we did not find it necessary for the design of rough 2D animations.

**Parallax scrolling.** In Fig. 9, we show a simple and direct use of masks and layout to give the classic illusion of drawings in different planes moving at different depths, i.e., parallax scrolling. We reuse a walk cycle animation from Even et al. [3] (their Figure 16), and place it between background and foreground elements. Some of the drawing parts in the foreground are semi-transparent. The artist only needs to set up the layout once at keyframes and make the different drawing parts move at different speeds to obtain the new animation.

**Traveling motion.** A motion that conveys 3D-like cues is when the camera zooms in or out, also known as traveling motion. Here depth is conveyed by the gain or loss of details. This is trivially achieved with our temporal eraser or temporal pen tools, as shown in Fig. 10 for the case of a zoom out motion, inspired by the animation “Love and Theft” by Studio Film Bilder.<fnref n="1" />

<figure><img src="image_13.png" /><figcaption>**Fig. 10.** Traveling motion. Temporal visibility thresholds (shown in red at keyframes) are used to control stroke disappearance while zooming out leading to a smooth level-of-detail effect.</figcaption></figure>

**Out-of-plane rotations.** Among the most difficult 2D animations to produce by hand are the ones that convey the rotation of a 3D object or character around an axis different than the view direction, also called out-of-plane rotations. We show a first example in Fig. 11, where we start from three key drawings traced from an animation made by artist Łukasz Rusinek.<fnref n="2" /> The key drawings are decomposed into 13 parts: lines that lie in disconnected lattice elements are automatically grouped in different parts, some of which (e.g., the ears) are further separated. Masks are then automatically created and a layout assigned to the first keyframe. The mask of the left ear must be closed as it is moved to the front at frame 2 via a layout change. The drawing layout then remains the same until the end of the animation, and is thus easily propagated automatically. Note that we have used a different workflow compared to Fig. 6, which demonstrates the versatility of our approach.

Another example of out-of-plane rotation is shown in Fig. 12, where this time we use the rotation of a 3D cartoon character<fnref n="3" /> as a reference. We first obtain keyframes by drawing over three frames of that animation (i.e., rotoscoping). These key drawings are decomposed into 7 parts to facilitate pose-to-pose matching. Their layouts differ in all three keyframes, as illustrated in the insets. After part matching, the animation is refined by controlling the trajectory of the top drawing part. Finally, we use stroke visibility to animate the appearance and disappearance of lines separating the three bottom parts of the object. Compared to a headlight rendering of the 3D animation (bottom row), even though inbetweens generated by our system follow rather faithfully the 3D motion of the object, our tools allow artistic expression in the way strokes appear and disappear, making them depart from their 3D counterpart.

**Partial drawings.** As explained in the book of Williams [39], 3D-like effects may be provided at specific frames through partial drawings. He gives several examples of walking characters where feet or hands suddenly appear to change orientation in 3D, revealing otherwise occluded parts. We reproduce such an example in Fig. 13, using a walking animation towards the camera. The initial animation is produced as before: the different character parts are animated with the system of Even et al., [3] masks are automatically created, and layout changes are set so that arms and legs pop in front or behind at the desired frame. We add a partial drawing in the style of Williams at frame 4 by using two different drawing parts for the feet with antagonist visibility thresholds: one where strokes are visible *before* that frame, and another where strokes appear *at* that frame. Hence both parts are never visible in a same frame.

**Deforming character.** Depicting a deformable character in motion with hand-drawn animation requires training. A common exercise consists in animating a flour sack folding onto itself as it jumps around. We reproduce this animation with our approach in Fig. 14 using three

<footnote n="1">¹ https://youtu.be/rEUxlwb2~uFI?si=z2vDrunhITNdIeOR.</footnote>

<footnote n="2">² https://youtu.be/uEXZ9wICeWc?si=VdgLinA9pJuQbxHHk.</footnote>

<footnote n="3">³ https://www.thingiverse.com/thing:3429760/files.</footnote>
<figure><img src="image_14.png" /><figcaption>**Fig. 11.** Out-of-plane rotation. The drawings parts along with their mask are depicted with colors on the first keyframe and the first inbetween. The depth level of the parts only changes at keyframes, except for the character's right ear that pops out in the foreground at frame 2 thanks to a dynamic layout change. The mask of the character's left ear does not need to be closed since it stays in the background.</figcaption></figure>

<figure><img src="image_15.png" /><figcaption>**Fig. 12.** Out-of-plane rotation. Up and down tilting of an organic shape, rotoscoped on 3 frames of a 3D reference. Key drawings are decomposed into 7 parts whose layout only changes at keyframes (colored insets with depth levels). The temporal gradient tool was used to make stroke vertices progressively disappear (shown in red at keyframe 1) and appear (shown in green at keyframe 31), and their temporal visibility thresholds were then manually adjusted with the painting tool. The full line of the torus hole is made to appear at frame 32 using the temporal pen tool. In the bottom row, we show selected inbetweens generated by our system over a headlight rendering of the reference 3D animation.</figcaption></figure>

<figure><img src="image_16.png" /><figcaption>**Fig. 13.** Partial drawings. Interval between the first and second keyframe of a walk cycle. A partial drawing is used to suddenly change the side of the right foot: the bottom (resp. top) side is made to disappear (resp. appear) at frame 4 using temporal visibility thresholds set to -3/8 (resp. 3/8). Note that partial drawings are drawn at intermediate frames but stored at keyframes.</figcaption></figure>

key drawings made of a single part. The fold of the first key drawing representing a self-occlusion disappears thanks to temporal visibility. We let the top part of the sack appear halfway between the second and third keyframes through a partial drawing. Thanks to its relative positioning in time, it remains correct after retiming of the animation.

## 6.2. *Comparison with the system of even et al.*

The only way to convey occlusions in the original system of Even et al. [3] is to convert (or “bake”) each interpolated frame to a keyframe, and manually erase all hidden lines. This has several

<figure><img src="image_17.png" /><figcaption>**Fig. 14.** Deforming character. Classical flour sack animation, where we rely on stroke visibility to create 3D cues: strokes disappear (shown in red at keyframes 1 and 8) to convey moving cusps, while a partial drawing (in green) is used to make the back of the flour sack appear at frame 11. We show on the right the animation with onion skin visualization after retiming (doubling the number of frames).</figcaption></figure>

drawbacks, as shown in the supplemental video on a couple use cases (one for each type of occlusion, based respectively on Figs. 11 and 1): it is not only time consuming, but it also makes non-linear edition functionalities useless, as shown on a retiming example. In contrast, our semi-automatic tools retain such functionalities while requiring little user interaction. Most notably, when retiming the animation, our approach produces a proper interpolation without the need of further adjustments. This would be the same for other non-linear editing operations such as modifications of the spacing.

This set of comparisons was performed by one of the authors, who completed the two animation use cases 5.1 and 8.5 times faster respectively with the proposed tools. Such completion speedups are of course dependent on the number of inbetween frames that must be produced, with better speedups obtained when more inbetweens are generated.

We have also tested the usability of our system on 5 participants (4 novices and a more experienced 2D artist) who were not familiar with the animation tools we introduced, on the same pair of use cases. This preliminary study is described in details in the supplemental material. Even though participants had to learn how to use our animation tools, they still performed on average 2.1 and 5.2 times faster respectively on each use case with our approach. Participants gave positive feedback of the system, with the main criticisms focused on the user interface, which was to be expected for a prototype implementation.

## 7. Discussion

We have presented a 2D animation system offering automatic and semi-automatic tools whose purpose is to convey occlusion cues. It is by design more adapted to traditional 2D animation workflows than 2.5D methods, which are more suited to interactive environments or live performance retargeting. A central feature of our approach is the ability to control occlusions among drawing parts and self-occlusions *between* keyframes. We do so while retaining ordering, drawing and erasing
<figure><img src="image_18.png" /><figcaption>**Fig. 15.** Sliding T-junctions. We traced over the glove animation from [22] in a sketchy style and segmented the drawing in 7 parts. The sliding T-junctions of the fingers cannot be accurately represented without separating them into different parts (second row). We use trajectory constraints to guide the junctions as shown in the video.</figcaption></figure>

interaction metaphors, which stay close to traditional 2D animation workflows, while providing fast and non-linear controls. In particular, timing & spacing or trajectories may be edited at anytime without breaking the animation, as shown in the supplemental video. We have demonstrated the benefits of our approach on a variety of example motions: parallax, out-of-plane rotations, zooms with LOD, deforming characters, etc.

**Limitations.** As shown in Fig. 12, our method is able to create occlusions where parts of an object move in front of others, creating typical sliding T-junctions. However, this requires separating the drawing into smaller parts, which may occlude each other via their masks. In Fig. 15 we show an example of this limitation. Imposing such a drawing decomposition may become tedious for artists, especially when animating very flexible elements such as cloth, requiring many parts. One solution would be to implement local layering [40] in our animation structure, which would also help deal with occlusion cycles.

Our animation tools have limitations of their own. Automatic layout propagation may not find the best many-to-one mapping between drawing parts in some tricky cases. However, we have found it to provide adequate suggestions in practice in all our experiments. The automatic detection of visibility thresholds relies on an isotropic diffusion, which does not capture complex stroke (dis)appearance as shown with the spiral example in the supplemental video. A more sophisticated diffusion might correct that issue, even though the visibility gradient tool already provides a practical alternative. Lastly, dynamic layouts and stroke visibility are controlled independently. This may raise some issues in practice when a T-junction turns into a cusp. Coupling tools that control the two types of occlusions might thus constitute a useful extension.

**Future work.** In our system, perspective effects must still be handled by the artist. Hence they are “baked” in key drawings or partial drawings. An interesting direction of future work would be to provide non-linear controls over perspective distortions, using 2D widgets such as editable vanishing lines.

Another aspect that remains in the hands of artists is the depiction of volumes. This could be incorporated in our system by taking inspiration from Disney's solid animation technique, using drawings of simple 3D volumes (e.g., ellipsoids) that are used as proxies to guide the animation while remaining hidden. Finding semi-automatic techniques that achieve such a high-level control is a challenging avenue of future work.

Finally, our system does not seem to be adapted to complex special effects animation, such as growing elements, water splashes, or sparks and explosions. Assisting artists in producing such effects might require an altogether different solution due to the amount of changes in drawings across frames.

## CRediT authorship contribution statement

**Melvin Even:** Writing – review & editing, Writing – original draft, Software, Methodology, Investigation, Conceptualization. **Pierre Bénard:** Writing – review & editing, Writing – original draft, Validation, Supervision, Methodology, Investigation, Funding acquisition, Formal analysis, Conceptualization. **Pascal Barla:** Writing – review & editing, Writing – original draft, Validation, Supervision, Methodology, Investigation, Funding acquisition, Formal analysis, Conceptualization.

## Declaration of competing interest

The authors declare the following financial interests/personal relationships which may be considered as potential competing interests: Pierre Benard reports financial support was provided by French National Research Agency. Melvin Even reports financial support was provided by French National Research Agency. Pascal Barla reports financial support was provided by French National Research Agency. Pierre Benard reports a relationship with Praxinos that, includes: non-financial support. Melvin Even reports a relationship with Praxinos that, includes: non-financial support. Pascal Barla reports a relationship with Praxinos that, includes: non-financial support. If there are other authors, they declare that they have, no known competing financial interests or personal relationships that could have, appeared to influence the work reported in this paper.

## Acknowledgments

We are grateful to Don Perro (Capilano University), and to Antoine Antin, Gary Gabriel and Fabrice Debarge from Praxinos for very helpful discussions. This work is supported by the ANR MoStyle project (ANR-20-CE33-0002).

## Appendix A. Supplementary data

Supplementary material related to this article can be found online at https://doi.org/10.1016/j.cag.2025.104223.

## Data availability

Data will be made available on request.

## References

[1] Gibson JJ. The ecological approach to the visual perception of pictures. Leonardo 1978;11(3):227–35. http://dx.doi.org/10.2307/1574154.

[2] Engel SA, Remus DA, Sainath R. Motion from occlusion. J Vis 2006;6(5). http://dx.doi.org/10.1167/6.5.9, 9–9.

[3] Even M, Bénard P, Barla P. Non-linear rough 2D animation using transient embeddings. Comput Graph Forum 2023;42(2):411–25. http://dx.doi.org/10.1111/cgf.14771.

[4] Burtnyk N, Wein M. Computer animation of free form images. In: Proc. of the 2nd annual conference on computer graphics and interactive techniques. ACM; 1975, p. 78–80. http://dx.doi.org/10.1145/563732.563743.

[5] TVPaint Developpement. TVPaint animation. 2024, URL: https://www.tvpaint.com.

[6] Celsys, Inc. Clip studio paint. 2024, URL: https://www clipstudio net/.

[7] Hsu SC, Lee IHH, Wiseman NE. Skeletal strokes. In: Proceedings of the 6th annual ACM symposium on user interface software and technology. UIST '93, ACM; 1993, p. 197–206. http://dx.doi.org/10.1145/168642.168662.
[8] Hsu SC, Lee IHH. Drawing and animation using skeletal strokes. In: Proceedings of the 21st annual conference on computer graphics and interactive techniques. SIGGRAPH '94, ACM; 1994, p. 109–18. http://dx.doi.org/10.1145/192161.192186.

[9] Yeh C-K, Song P, Lin P-Y, Fu C-W, Lin C-H, Lee T-Y. Double-sided 2.5D graphics. IEEE Trans Vis Comput Graphics 2013;19(2):225–35. http://dx.doi.org/10.1109/TVCG.2012.116.

[10] Rivers A, Igarashi T, Durand F. 2.5D cartoon models. ACM Trans Graph 2010;29(4). http://dx.doi.org/10.1145/1778765.1778796.

[11] Coutinho J, Marques BAD, Gois JP. Puppeteering 2.5D models. In: 2016 29th SIBGRAPI conference on graphics, patterns and images. SIBGRAPI, 2016, p. 1–8. http://dx.doi.org/10.1109/SIBGRAPI.2016.010.

[12] Fukusato T, Maejima A. View-dependent deformation for 2.5-D cartoon models. IEEE Comput Graph Appl 2022;42(5):66–75. http://dx.doi.org/10.1109/MCG.2022.3174202.

[13] Rademacher P. View-dependent geometry. In: Proc. of the 26th annual conference on computer graphics and interactive techniques. SIGGRAPH '99, ACM; 1999, p. 439–46. http://dx.doi.org/10.1145/311535.311612.

[14] Alexa M, Cohen-Or D, Levin D. As-rigid-as-possible shape interpolation. In: Proc. of the 27th annual conference on computer graphics and interactive techniques. ACM; 2000, p. 157–64. http://dx.doi.org/10.1145/344779.344859.

[15] Di Fiore F, Schaeken P, Elens K, Van Reeth F. Automatic in-betweening in computer assisted animation by exploiting 2.5D modelling techniques. In: Proc. computer animation 2001. 2001, p. 192–200. http://dx.doi.org/10.1109/CA.2001.982393.

[16] Brodt K, Bessmeltsev M. Skeleton-driven inbetweening of bitmap character drawings. ACM Trans Graph 2024;43(6). http://dx.doi.org/10.1145/3687955.

[17] Toon Boom Animation Inc. Harmony. 2024, URL: https://www.toonboom.com/products/harmony.

[18] Reallusion Inc. 360 head creator. 2024, URL: https://www.reallusion.com/cartoon-animator/360-head-creator.html.

[19] Live2D Inc. Cubism. 2024, URL: https://www.live2d.com/.

[20] Jiang J, Seah HS, Liew HZ. Stroke-based drawing and inbetweening with boundary strokes. Comput Graph Forum 2022;41(1):257–69. http://dx.doi.org/10.1111/cgf.14433.

[21] Carvalho L, Marroquim R, Vital Brazil E. Dilight: Digital light table – Inbetweening for 2D animations using guidelines. Comput Graph 2017;65:31–44. http://dx.doi.org/10.1016/j.cag.2017.04.001.

[22] Whited B, Noris G, Simmons M, Sumner RW, Gross M, Rossignac J. Betweenit: An interactive tool for tight inbetweening. Comput Graph Forum 2010;29(2):605–14. http://dx.doi.org/10.1111/j.1467-8659.2009.01630.x.

[23] Yang W. Context-aware computer aided inbetweening. IEEE Trans Vis Comput Graphics 2018;24(2):1049–62. http://dx.doi.org/10.1109/TVCG.2017.2657511.

[24] Dalstein B, Ronfard R, van de Panne M. Vector graphics animation with time-varying topology. ACM Trans Graph 2015;34(4). http://dx.doi.org/10.1145/2766913.

[25] Zhang L, Huang H, Fu H. Excol: An extract-and-complete layering approach to cartoon animation reusing. IEEE Trans Vis Comput Graphics 2012;18(7):1156–69. http://dx.doi.org/10.1109/TVCG.2011.111.

[26] Zhu H, Liu X, Wong T-T, Heng P-A. Globally optimal toon tracking. ACM Trans Graph 2016;35(4). http://dx.doi.org/10.1145/2897824.2925872.

[27] Xing J, Wei L-Y, Shiratori T, Yatani K. Autocomplete hand-drawn animations. ACM Trans Graph 2015;34(6). http://dx.doi.org/10.1145/2816795.2818079.

[28] Li X, Zhang B, Liao J, Sander P. Deep sketch-guided cartoon video inbetweening. IEEE Trans Vis Comput Graphics 2021. http://dx.doi.org/10.1109/TVCG.2021.3049419.

[29] Siyao L, Zhao S, Yu W, Sun W, Metaxas D, Loy CC, Liu Z. Deep animation video interpolation in the wild. In: 2021 IEEE/CVF conference on computer vision and pattern recognition. CVPR, IEEE Computer Society; 2021, p. 6583–91. http://dx.doi.org/10.1109/CVPR46437.2021.00652.

[30] Chen S, Zwicker M. Improving the perceptual quality of 2d animation interpolation. In: European conference on computer vision. Springer; 2022, p. 271–87. http://dx.doi.org/10.1007/978-3-031-97970-1_17.

[31] Xing J, Liu H, Xia M, Zhang Y, Wang X, Shan Y, Wong T-T. ToonCrafter: Generative cartoon interpolation. ACM Trans Graph 2024;43(6). http://dx.doi.org/10.1145/3687761.

[32] Siyao L, Gu T, Xiao W, Ding H, Liu Z, Loy CC. Deep geometrized cartoon line inbetweening. In: Proceedings of the IEEE/CVF international conference on computer vision. ICCV, 2023, p. 7291–300.

[33] Chen S, Zwicker M. Match-free inbetweening assistant (MIBA): A practical animation tool without user stroke correspondence. In: Proceedings of the Asian conference on computer vision. ACCV, 2024, p. 179–93.

[34] Mo H, Gao C, Wang R. Joint stroke tracing and correspondence for 2D animation. ACM Trans Graph 2024;43(3). http://dx.doi.org/10.1145/3649890.

[35] Sýkora D, Dingliana J, Collins S. As-rigid-as-possible image registration for hand-drawn cartoon animations. In: Proc. of the 7th international symposium on non-photorealistic animation and rendering. ACM; 2009, p. 25–33. http://dx.doi.org/10.1145/1572614.1572619.

[36] Baxter W, Barla P, Anjyo K-I. Rigid shape interpolation using normal equations. In: Proc. of the international symposium on non-photorealistic animation and rendering. ACM; 2008, p. 59–64. http://dx.doi.org/10.1145/1377980.1377993.

[37] Shreiner D. OpenGL programming guide: The official guide to learning OpenGL. 7th ed.. Pearson Education; 2009, chapter 11.

[38] Noris G, Sýkora D, Shamir A, Coros S, Whited B, Simmons M, Hornung A, Gross M, Sumner R. Smart scribbles for sketch segmentation. Comput Graph Forum 2012;31(8):2516–27. http://dx.doi.org/10.1111/j.1467-8659.2012.03224.x.

[39] Williams R. The animator's survival kit. Faber and Faber; 2001.

[40] McCann J, Pollard N. Local layering. In: ACM SIGGRAPH 2009 papers. SIGGRAPH '09, New York, NY, USA: Association for Computing Machinery; 2009, http://dx.doi.org/10.1145/1576246.1531390.