# Motion ribbons: Parametrized surfaces for depicting motion effects

Amine Farhat, Alexandre Bléron, Romain Vergne, Joëlle Thollot

► To cite this version:

Amine Farhat, Alexandre Bléron, Romain Vergne, Joëlle Thollot. Motion ribbons: Parametrized surfaces for depicting motion effects. Computers and Graphics, 2025, 129, pp.104227. 10.1016/j.cag.2025.104227. hal-05084833

HAL Id: hal-05084833

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

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_1.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
Graphical Abstract

Motion Ribbons: Parametrized Surfaces for Depicting Motion Ef-
fects

Amine Farhat, Alexandre Bléron, Romain Vergne, Joëlle Thollot

Motion Ribbons: Parametrized Surfaces for Depicting Motion Effects

Submission ver.

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

Expressive2025
# Highlights

## Motion Ribbons: Parametrized Surfaces for Depicting Motion Effects

Amine Farhat, Alexandre Bléron, Romain Vergne, Joëlle Thollot

* Motion effects, such as smears and motion lines, have a significant impact on the perception of motion.

* Their digital creation for 3D animations is mostly done manually at each frame.

* Our motion ribbon is a parametrized space generated to support motion effect rendering.

* It is controllable, allowing a large variety of style via procedural rendering functions.
# Motion Ribbons: Parametrized Surfaces for Depicting Motion Effects

Amine Farhat<sup>a,b</sup>, Alexandre Bléron<sup>b</sup>, Romain Vergne<sup>a</sup>, Joëlle Thollot<sup>a</sup>

<sup>a</sup>LJK (CNRS, UGA, INP-G, inria), Grenoble, France

<sup>b</sup>Left Angle, Grenoble, France

## Abstract

Motion effects, such as motion lines or smearing, are an essential tool in illustration and animation for conveying and enhancing the perceived movement of an object. In this paper, we propose a user-guided method to generate such effects on top of a rendered 3D scene. Our method is flexible enough to accommodate a variety of styles, and allows the depiction of complex composite movements in an intuitive way, by granting the user the ability to portray individual motion components using separate sets of motion effects, as is often done in traditional animation. Our method takes as input the rendered 3D object and its movement, represented as a hierarchy of transforms varying over time. Users specify a subset of those transforms which represents the movement to be depicted, and an anchor point on the object to guide the placement of the motion effect. From this, our algorithm generates a 3D "motion ribbon", a parametrized swept surface evolving over time, which acts as a support for rendering motion effects which are coherent with the movement selected by the user. We show how this ribbon and its parametrization can then be used to draw a variety of motion effects, such as motion lines, smears, and stroboscopic sequences, depending on a user-defined procedural function.

Keywords:

Expressive rendering, stylization, motion lines

## 1. Introduction

Over the last two decades, various rendering styles have been made available in commercial software, and stylization is steadily becoming a staple of
<figure><img src="image_3.png" /><figcaption>Figure 1: *Motion simplification*. (Left) Only the rotation of the object is depicted, likely because the rotation is the focal point of the action. The lines form circular arcs centered around the object's center. (Right) An example of multiple motions depicted simultaneously on a single object. The rotation and the translation are emphasized with two different sets of lines, highlighted in yellow and blue. Source: *Teenage Mutant Ninja Turtles: Mutant Mayhem (2023)*.</figcaption></figure>

the animation industry. However, some iconic effects found in traditional animations are still painstakingly hand-drawn by artists over rendered frames. This applies to the depiction of motion effects, such as smears and motion lines. Despite their significant impact on the perception of motion, the process of creating these effects has yet to be codified and automated. In this paper, we propose a method for generating expressive motion effects on top of a rendered 3D scene. Our method is semi-automatic to provide artists with a convenient level of control, while speeding up the designing process.

Motion effects are created by abstracting parts of the object's trajectory. They can be seen as a way to stylize motion blur, but they are also used to stylize the motion itself as they capture the *artistic moment* of a scene [1]. What makes their creation and rendering challenging is that they live in 3D, along the object's trajectory, but have to be shaped and stylized in 2D, while not being directly supported by the object's geometry itself. Following previous work [2, 3], we propose to compute a specific motion drawing space, that we call motion ribbons, to support the creation and rendering of stylized motion effects.

Motion effects are commonly used in comic books, where they provide invaluable context clues on the movement of objects ([4, p.33]). They are also used in animated films to exaggerate or emphasize certain aspects of motion. By observing hand-drawn motion effects in both traditional cartoons and contemporary animated movies, we have identified key requirements that we believe a motion drawing space should fulfill in order to accommodate individual art styles:
<figure><img src="image_4.png" /><figcaption>Figure 2: *Planar shape*. (Left) Motion lines are often parallel and form *ribbon-like* 3D surfaces. The surface's orientation is a compromise between the view angle and the motion's direction. (Right) Smearing effects often take the shape of a swept surface in screen-space that can be assimilated to a ribbon. *Sources: Tiny Toons (Glen Kennedy — 1990), The Fox and the Hound (Chris Buck - Glen Keane - Michael Cedeno — 1981), Spider-Man: Into the Spider-Verse (2018), Dexter's Laboratory (Genndy Tartakovsky — 2001).*</figcaption></figure>

***Motion simplification.*** Artists tend to simplify complex movements for the purposes of both readability and expressiveness. This complexity often manifests as movements composed of simpler sub-movements, as shown in Figure 1. We should be able to generate a motion drawing space for those individual sub-movements.

***Planar shape.*** The effects are often arranged on simple, planar surfaces, such as circular arcs or cylindrical shapes. Artists typically draw motion lines as a set of parallel curves, as shown in Figure 2. Regardless of the motion's orientation, the drawn lines remain parallel, sharing the same shape and thereby conveying a uniform sense of movement. Thus, the motion drawing space should reflect this planar appearance found in illustration.

Meanwhile, as shown in Figure 2(right), smears are often a screenspace melding of the moving object's image through multiple frames. Keeping the smearing restricted to a neatly defined area helps with clarity.

***Style expressiveness.*** There is a great variety of styles among motion effects. They can go from simple line-based effects to intricate repetition of an object. For something as simple as motion lines, artists often vary their number, length, closeness to one another or color, depending on the motion's context and the artist's style. Artists also tend to begin their lines near the trailing edge [5]: the side of the object opposite to the movement's direction (Figure 3). The motion drawing space should be versatile enough to accommodate this diversity in style.
<figure><img src="image_5.png" /><figcaption>Figure 3: Two frames showcasing the motion lines changing sides depending on the motion direction, but still starting at the trailing edge of the object's silhouette. Source: Magician Mickey (Les Clark — 1937).</figcaption></figure>

<figure><img src="image_6.png" /><figcaption>Figure 4: A motion ribbon (a) is a parametrized surface computed in 3D to support various stylized motion effects such as smears (b) and motion lines (c,d).</figcaption></figure>
Following these three guidelines, motion ribbons (see Figure 4) are computed as a parametrized 2D surface embedded in the 3D space that will be used as a drawing space to depict the motion selected by the artist. By design, a motion ribbon ensures that motion lines remain parallel along its parametrization. Motion ribbons are computed at each frame and are temporally coherent. Thanks to their parametrization, various styles can be achieved depending on the artist's needs.

Compared to previous work, we give more control to the artist – at the price of more user interaction – offering a large variety of styles, shape and motion effect placement. That way, motion ribbons offer a generic approach that works for complex animations, letting the artist choose the motion they want to emphasize.

## 2. Related Works

Cutting [1] enumerates five methods to represent motion in illustration: *dynamic balance* (compositional techniques to break the appearance of stillness), *motion blur* inspired from photography, *deformations* such as smear and shearing in the direction of motion, *stroboscopic sequences* such as repeated trailing edges, and *action lines* (sometimes referred to as *speed lines*), which are lines overlaid on top of the image and oriented in the direction of motion. In this section, we will focus on those four last techniques, which we will collectively refer to as *motion effects*.

While essential in static illustration and sequential art like comics [6], those techniques are also widespread in traditional animation, which has limited frame rates, in order to make the viewer understand the movement better. Furthermore, user-guided or fully automatic generation of motion effects has applications in many fields, such as automatic storyboarding [7, 8], user interface design [9], or depiction of motion in time-lapse videos [10]. There is also a large body of research on rendering physically-inspired motion blur [11]. It is of interest to note that some motion blur techniques can be modulated to approximate other kinds of motion effects.

### 2.1. Image- and video-based techniques

Motion effects can be used to enhance the perception of motion on top of existing still images and videos. For video input, the cartoon-style rendering technique presented by Collomosse et al. [12] can render several kinds of motion effects over moving objects in videos, such as speed lines, stroboscopic
contours, and deformations. They propose a segmentation technique to automatically extract and track moving objects in videos. A similar technique is proposed by Kim et al. [13]. The motion effects (particle effects, stroboscopic images, and speed lines) are placed on automatically detected trailing and leading edges. One limitation of this technique is that the extracted features are not parametrized, which greatly limits the artist's control over the position and visual aspect of the rendered motion effects. Still working from video inputs, Zhang et al. [14] visualize the 3D motion of a human body over time as a swept 3D "sculpture" representing its complete motion over the duration of the animation. By rendering the resulting sculpture with colors derived from the input video, an effect similar to motion trails can be achieved. A common limitation of those methods is that they do not provide a way to simplify or decompose complex composite motion since they are only able to see the final composite motion on the video input. In contrast, our system takes as input a 3D scene with decomposed transformations, which is less general than video input, but allows much greater control over which components of the movement to depict.

Many methods have been devised to simulate motion blur as a post-processing effect [15, 16], but few provide significant stylistic control over the result. Specifically for 2D cartoon animation, Salvati and Ito [17] present a border-aware directional motion blur algorithm that can produce expressive motion-line like effects when modulated with noise. While they provide variants of their algorithm for scaling and rotational motion, it is unclear whether they handle translations that do not follow a straight line, since the directional blur they use would be unable to bend with the curved trajectory of an object. In contrast, our method is not subject to this limitation since it employs an explicit drawing space embedded in 3D, which can perfectly follow the trajectory of the object.

On still images, Luo et al. [18] propose a motion blur method that employs a user-guided image segmentation method to selectively blur different regions of an image, such as the foreground and background, with controllable blur direction. They show how their technique can be extended to reproduce locally-controllable motion trails. This provides compelling user direction over the result, but it is specific to still images and it is unclear how this approach could be extended to animations.

Joshi et al. [19] propose a way to generate various motion effects on generic time-varying data (3D surfaces and volumetric datasets) by tracking the trajectory of features of interest over time. They also introduce the
concept of "flow ribbons", which are 3D ribbons generated along the path of
a feature of interest, drawn in a manner inspired from illustration. However,
contrary to our technique, these ribbons are not parametrized and are not
used as a support for drawing other motion effects.

## 2.2. Vector and 3D geometry based techniques

Targeting 2D vector animations, Hsu et al. [20] present a 2D vector illus-
tration and animation tool which can render speed lines behind the trailing
edge of an object, varying their spacing and length to reproduce a variety
of artistic styles. Those lines can be automatically generated from user-
authored animations. On 3D scenes, Masuch et al. [21] present a system to
render two kinds of motion lines (speed lines and stroboscopic contour lines),
inspired by comic illustration, on a 3D model with keyframe animation data.
The lines are generated by sweeping the vertices of the model over the dura-
tion of the animation. Lake et al. [22] employ a similar technique, in which
the vertices on 3D objects are chosen randomly, but the user can vary the
number of lines generated and their width.

Chenney et al. [23] utilized affine scaling deformation to procedurally
apply a squash-and-stretch effect on colliding 3D objects. While this provides
a convincing enhancement of motion for collisions, this approach is only
suitable for motion effects that can be assimilated to simple deformations of
the moving object.

In a similar context, Ma et al. [24] proposed a streamlined way of integrat-
ing various motion effects in 3D scenes using both a layer-based and node-
based approach. They achieve motion stylization via presets that change the
speed of the animation along the motion path, deform the object according
to the motion path and speed, and render motion trails behind the mov-
ing object. However, this last effect has a small range of visual diversity
compared to what we can achieve with our system.

In [5], Kawagishi et al. propose a method to render three kinds of motion
effects for 2D vector animations: speed lines, stroboscopic sequences, and
contour deformation, the three of which they call "cartoon motion blur". An
important part of their method is the detection of the vertices of the trailing
edge, which serves as the anchor for the effects. Their method works very
well for 2D scenes but is hard to adapt to 3D scenes due to the complex
behavior of silhouettes in 3D. In the context of 3D animation, Haller et al.
[25] propose a different process for choosing the starting point of the speed
lines, and render them using a particle system. The appearance of the lines
can be controlled by adjusting the particle properties over time. Guan et al. [26] propose a method to render motion blur on top of point-based renderings of surfaces, by extruding points to ellipsoids along the trajectory of motion. Stylized motion trails can be achieved by modulating the appearance of those ellipsoids. Similarly, Wheeler et al. [27] describe a method to generate stylized motion blur effects on 3D scenes by placing and rendering particles on trail surfaces that were procedurally generated by sweeping an object over time. However, those methods do not provide a way to selectively depict one component of a complex composite movement.

Comparable to our method, Moriya et al. [2] propose a technique to generate motion effects for still snapshots extracted from 3D animations. First, they decompose the target object's transformation matrix into its translational and rotational components. They employ two distinct techniques to generate different motion effects for fast translations, slow translations and rotations. For fast translation, they generate a triangle strip using the trajectory representing the positions of the object's center of gravity. The triangle strip is oriented to always face the camera. The lines are then drawn as a texture on this triangle strip. For slow translations, camera-facing billboards with crescent shaped textures on them are placed along the trajectory. Finally, when it comes to rotations, faces with a high curvature are selected as line generators, each face generating a single line representing its rotation around the object's axis.

In comparison to their work, we posit that a ribbon based approach can be generalized to all types of motion regardless of their nature. Any combination of translation, rotation or scaling is applicable, as long as the generated trajectory is validated by the artist. By ensuring the temporal coherence of the ribbon, our approach is suitable for animation sequences. Finally, by treating our ribbon as a drawing space, we show that many visually distinct effects can be generated, and most of these effects work just as well with translations, rotations, and scaling alike.

Several techniques have made use of 3D scene graph information to render motion effects in an automated way: for instance, Nienhaus and Döllner [28] are able to automatically insert motion effects by matching patterns on a scene graph. However, their technique requires a structured representation of the animation (the *behavior graph*), which is a significant constraint for the artists. For 3D skeletal motion capture data, in which the scene graph is a hierarchy of joints and bones, Bouvier-Zappa et al. [29] propose a system of recursive groupings of bones in order to depict human body movements at
different levels of detail.

Closest to our method, the programmable motion effects of Schmid et al. [3], later optimized for GPU evaluation by Huang et al. [30], also target 3D scenes. Their motion abstraction is based on a "time aggregate object" (TAO), allowing them to trace the consecutive positions of any point on a mesh, which they use to generate various motion effects including speed lines, stroboscopic copies, deformations, and stylized motion blur. This method can deal with complex scenes; however, it offers no screen space control when it comes to placing and shaping the lines, and the location of the motion effects is constrained to the inside of the convex hull of the swept object across time.

More recently, Basset et al. [31] describe a method to render smear frames (deformations, stroboscopic repetition and motion lines) on animated 3D scenes by computing *motion offsets* on 3D meshes, which serve to identify leading and trailing parts of the input mesh to deform and/or replicate. They show how their method can also be used to render motion lines, by placing seed points on leading and trailing parts of the mesh and tracing their trajectory over time. While their method achieves artistic control over motion effects that is comparable to our method, it cannot isolate and depict only one sub-movement of a complex movement made of compounded translations and rotations, nor can it take into account screen space information, such as the camera viewpoint, the object's silhouette, or the projected size and spacing of the motion effects.

### 3. Method

Our pipeline, illustrated in Figure 5, takes as input an animated 3D scene, composed of objects with their associated time-dependent transformations organized in a hierarchy. This input is equivalent to the ubiquitous "scene graph" representation at the core of most 3D modeling software.

In the first stage (see Section 3.1), the artist selects the motion to depict by choosing some transformations from the available set. Then they select a 3D anchor point in one of the frames in order to generate a guide trajectory for each frame.

In the second stage, we compute the motion ribbon (see Section 3.2) by sweeping a generator segment centered on the anchor point and oriented by the artist. This segment is evaluated over time for each frame of the animation, which amounts to sweeping it along the trajectory of the motion. Leveraging the parametrization of the resulting motion ribbon, the artist
<figure><img src="image_7.png" /><figcaption>Figure 5: Pipeline overview. Starting from a 3D scene and the associated hierarchy of transformations, we first create the main trajectory to depict by letting the user select the transformations on which the motion effects should be applied. Next, we create a parametrized surface in 3D (the motion ribbon) along the trajectory. The final step consists in using the ribbon as canvas to draw motion effects. Thanks to its proper parametrization, drawn effects are ensured to follow the chosen motion, while remaining coherent in space and time.</figcaption></figure>

<figure><img src="image_8.png" /><figcaption>Figure 6: The steps of our method illustrated on the spinning top example. (a) Trajectory creation. (b) Motion ribbon generation. (c) Resulting motion lines.</figcaption></figure>

specifies a procedural function to evaluate on the ribbon to render the desired motion effect (see Section 3.3).

### 3.1. Trajectory creation

The first step of our approach consists in creating the main trajectory to depict. For that, the user first picks the object for which to render motion effects. We then extract the motion decomposition $\mathcal{D}$ of this object in the scene, which is the chain of transformations from the root of the scene leading to the object: $\mathcal{D} = (M^i)_{i=1..k}$. Depending on the input scene, this chain of transformations is either explicitly authored by the 3D artist during the animation process (in which case we rely on them to break down the object's movement into a sequence of "meaningful" simpler transformations), or automatically inferred from a parent-child hierarchy, particularly in the case of rigged models. Each transformation is time dependent, and might be
<figure><img src="image_9.png" /><figcaption>Figure 7: Illustration of motion selection. The object's original motion is composed of a translation, a rotation and a precession: $\mathcal{D} = (\mathbf{T}, \mathbf{R}, \mathbf{P})$. By properly selecting the transformations to apply in $\mathcal{T}$ and $\mathcal{M}$, one may decide which motion to depict.</figcaption></figure>

animated using common animation tools (e.g. keyframing). The matrix $M_t^i$ then denotes the $i^{th}$ transformation at time $t$.

Among all these transformations, the artist will choose two disjoint subsets, $\mathcal{T} \cup \mathcal{M} \subset \mathcal{D}$, such that $\mathcal{T} \cap \mathcal{M} = \emptyset$ and $\mathcal{T} \neq \emptyset$. The *trace set*, $\mathcal{T}$, contains the transformations that best express the movement to be depicted. These transformations are responsible for shaping the guide trajectory. The *move set*, $\mathcal{M}$, contains the transformations needed to anchor the motion lines to the object's global motion, determining the overall position of the guide trajectory. These two subsets are relevant to the entirety of the animation, guaranteeing the continuity and the coherence of the resulting trajectory. The user is provided with all the transformations in $\mathcal{D}$ in their proper hierarchical order, and is invited to select, for each transformation, whether it should be in the trace set, the move set, or ignored. Since these two subsets
are the same for every frame, this selection process is a one-time interaction. However, the user is allowed to modify them at any time if the generated guide trajectory proves to be unsatisfactory.

Figure 7 shows the impact of the choice of these two sets of transformations on the spinning top example. The input transform sequence is composed of three transformations: $D = (T, R, P)$, where T is a translation matrix and R, P are rotation matrices handling the spinning and precession motions. By properly choosing the transformations in T and M, artists can select which trajectory to depict:

(a) $T = \{T, R, P\}$ and $M = \emptyset$. The motion is entirely depicted by the trace: we are following a point as it moves in world space.

(b) $T = \{T\}$ and $M = \emptyset$. We only represent the translation: the motion of the point if the object was not rotating.

(c) $T = \{R\}$ and $M = \{T, P\}$. We represent the spinning, and ensure the trajectory follows the object translation.

(d) $T = \{R\}$, $M = \emptyset$. We represent the spinning, but the translation is not taken into account. We consider this to be a degenerate case, clarifying the importance of the move transformations in case (c).

Once the motion is selected, our next step consists in computing the resulting trajectory curve for a given point p, defined in object-space coordinates. For that, we must evaluate, for every frame $t \in \{0, ..., n\}$, the position of p through time. We note $u \in [0, n]$ this second time parameter, representing the position along the trajectory of p.

The resulting curve $C_t$, for frame $t$, is therefore computed using a specific transform function that depends on both frame $t$ and parameter $u$:

$$C_t(u) = \mu(t, u)p.$$

$\mu$ intuitively represents the motion chosen by the artist. It contains the $T$ transformations evaluated at $u$ (motion to depict) as well as the $M$ transformations evaluated at $t$ to keep the trajectory at a coherent position relative to the object at the current frame. All the transformations are applied in the order defined by the initial decomposition sequence $D$:

$$\mu(t, u) = \prod_{i=1}^{k} s(t, u, i), \text{ where } s(t, u, i) = \begin{cases} M_u^i & \text{if } M^i \in T \\ M_t^i & \text{if } M^i \in M \\ I & \text{otherwise.} \end{cases}$$
In our approach, **p** is computed from a world space coordinate **p**<sub>ref</sub> defined anywhere in the 3D scene by the user at a convenient frame *t*<sub>ref</sub>, using the same matrix *μ*:

$$ \mathbf{p} = \mu^{-1}(t_{\text{ref}}, t_{\text{ref}})\mathbf{p}_{\text{ref}}. $$

This allows the artist to precisely control the main trajectory to follow, albeit at the cost of not preventing degenerate trajectories: for instance, locating the reference point on the pivot axis of a chosen rotation will degenerate in a single point. Our guideline for this placement is to place the point on the surface or around the object to depict. An example of resulting trajectory is shown for the spinning top in Figure 6(a).

## 3.2. Motion ribbon generation

We now have a parametrized curve $C_t(u)$ for each frame *t* of the animation. From that, we want to compute a motion ribbon $R_t(u, v)$ as a surface in 3D, parametrized by the same *u* and an orthogonal *v* parameter. We also want this ribbon to enforce the drawing of parallel curves along the *v* coordinate.

In 2D, two curves are parallel if they maintain a constant perpendicular distance from each other. A parallel curve – also known as an offset curve – can be constructed by translating every point of the original curve along one of the two normal vectors at that point by a constant length.

Translating this property from 2D to 3D is not trivial, as a 3D curve has an infinite number of normals, distributed across a normal plane whose orthogonal vector is the tangent to the curve at that point. Since the normal plane has no inherent notion of orientation aside from its normal, there is no straightforward way to guarantee a continuous evolution of its local frame along the curve.

To solve this problem we compute a coherent *orientation basis* along the curve to ensure smooth parallel lines with minimal user adjustment. In our case, this basis requires two main constraints:

* It has to remain stable along the curve to prevent the motion ribbon from suddenly flipping or twisting around when motion changes occur;

* It has to be aligned as best as possible to the camera plane, since motion lines are meant to be drawn on a flat screen space canvas.

An orientation basis computation consists in finding a tangent **t**(*u*), a binormal **b**(*u*) and a normal **n**(*u*) along the given trajectory $C_t(u)$. Common
<figure><img src="image_10.png" /><figcaption>Figure 8: Local frame comparison. (a) Frenet-Serret frames are known to flip suddenly at curve's inflection points. This is thus not adapted to preserve the line's coherency. (b) Rotation-Minimization-Frames preserve a global coherency of the lines, but do not preserve the screen space alignment. (c) Our approach allows screen space stability and alignment.</figcaption></figure>

basis computation methods, such as Frenet-Serret [32, 33] or Rotation Minimizing Frames (RMF) [34] cannot be used directly as illustrated Figure 8. Instead, to ensure the camera plane alignment, the binormal is computed as the cross product between the camera view vector **v** and the curve tangent: $\mathbf{b}(u) = \mathbf{t}(u) \times \mathbf{v}$, where $\mathbf{t}(u)$ is simply obtained using curve's derivatives. The orthogonal basis is then obtained by taking the cross product between the tangent and the normal: $\mathbf{n}(u) = \mathbf{t}(u) \times \mathbf{b}(u)$.

The obtained local frame is still not stable and will cause the ribbon to flip if the trajectory suddenly changes in screen space. To ensure the basis stability, we take inspiration from the RMF method and algorithmically compare consecutive vectors of the basis and flip them back when necessary:

for $u = 1$ to $n$ do
    if $\mathbf{b}(u-1) \cdot \mathbf{b}(u) < 0$ then
        $\mathbf{b}(u) = -\mathbf{b}(u)$
        $\mathbf{n}(u) = -\mathbf{n}(u)$
    end if
end for

Figure 8 compares a simple result obtained using Frenet-Serret [32, 33], RMF [34] and our local frames. Our method allows the resulting motion
lines to remain stable in screen space.

*Motion ribbon.* To compute the final motion ribbon, we position a parametrized segment, centered on the $\mathbf{b}(u)\mathbf{n}(u)$ plane of the basis, and we sweep it along the trajectory $C_t(u)$. The choice of a segment ensures that the ribbon has a simple planar shape, as observed in section 1.

We let the user choose the length $l$ of the segment, as well as its orientation $\alpha$ relative to $\mathbf{n}(u)$ in the normal plane. As with trace and move selection, these parameters have to be set only once, and are applied to the whole sequence.

The segment is thus defined by a single parameter $v \in [-1, 1]$, and is denoted by $S_{l,\alpha}(v)$. The fully parametrized ribbon is obtained by sweeping the segment along the oriented trajectory for each frame:

$$R_t(u, v) = \mu(t, u) \begin{bmatrix} \mathbf{t}(u) \\ \mathbf{b}(u) \\ \mathbf{n}(u) \end{bmatrix}^T S_{l,\alpha}(v).$$

$u$ is the time parameter, defining the position of a point along the chosen trajectory and $v$ is the segment parameter, defining the space around the trajectory in which it is possible to draw. When $u = t$ and $v = 0$, we are located exactly on the point $\mathbf{p}$ by construction.

Finally, and to avoid sharp edges when the temporal resolution is too low, we perform a smoothing on the ribbon using a Catmull-Rom interpolation. Furthermore, we extend the ribbon on its extremities to avoid edge cases on the first and last frames, by cloning the last available sections. Figure 6(b) shows the motion ribbon on the spinning top example.
<figure><img src="image_11.png" /><figcaption>Figure 9: *Ribbon's coordinate systems*. (a) $(u, v)$, (b) $(u', v')$ reparametrization, (c) world space, (d) screen space. In this figure, the visual representation of the coordinate's values are normalized for better readability. (a) $(u, v)$ parametrization, represented in the red and green color channels (blue channel set to 1). (b) $(u', v')$ reparametrization, same representation. (c) world space position of each ribbon point directly represented as a color (renormalized for clarity). (d) screen space projected ribbon points (blue channel set to 1).</figcaption></figure>
### 3.3. Drawing the motion effect

Depending on the target rendering style, the motion ribbon is used either to generate a procedural texture or to generate polylines that can be later rendered as strokes (vector lines or splatting). This allows both textured and line drawing styles. Rendering functions can then be written as simple procedural instructions, applied to all pixels (for pixel wise effects) or points (for polyline-based effects). All these functions share the same inputs that we describe in this section. Practical examples will be given in the result section.

As shown in Figure 9, for a given point on the ribbon surface, the rendering function can rely both on the motion ribbon parametrization and standard projected coordinates systems (screen space or world space):

(a) $(u, v)$ coordinates inside the ribbon are at the heart of the motion effects because they are linked to the object trajectory. By construction the horizontal $u$ coordinate ranges from 0 to $n$ and the vertical $v$ coordinate goes from 0 to 1. Because of the ribbon being both a time and space object, moving alongside its $u$ coordinate is akin to tracing the trajectory of the object. For example, motion lines are computed as polylines using $u$ to design the line length and $v$ to create several parallel curves.

(b) By reparametrizing the motion ribbon using its camera projection, we offer $(u', v')$ coordinates expressed in pixel length along the ribbon. This reparametrization is used for rendering motion effects taking into account measurements in screen space. A typical example is a dashed motion line with regular dashes in screen space as shown in Figure 12.

(c) World space coordinate is useful to define interactions between the motion effect and the 3D scene. We typically use it to compute occlusion for motion lines.

(d) Screen space coordinates are simply obtained by projecting the world space coordinates onto the camera. They allow defining interactions between the motion effects and 2D primitives, such as the silhouette. For instance, when applicable, we use a mask buffer to prevent the lines from crossing over the object's silhouette.

The rendering can use any kind of scene attributes stored as G-Buffers. For the effects shown in this paper, we use three following G-buffers:
* The color buffer, used to colorize the effects.

* The position buffer, used to compute the occlusions between the objects and the ribbon.

* The signed distance to silhouette buffer, used to control the behavior of the effects with respect to the 2D silhouette of the object, for example, by making motion lines start at a certain distance from the silhouette (Figure 13), or by preventing them from crossing over it.

# 4. Results

<figure><img src="image_12.png" /><figcaption>Figure 10: *Decomposition example*. The spinning top's two types of movement are depicted separately: each have their own ribbon and set of lines.</figcaption></figure>

In this section and in the accompanying video, we show various motions effects, styles and movements.

## 4.1. *Rendering styles*

Figure 11 illustrates three styles applied to three simple transformations (translation, rotation, scaling).

**Line drawing styles.** To compute simple motion lines we rely on the ribbon (u, v) parametrization to generate a set of parallel polylines. *u* is used to set the line length and *v* to set the spacing between the lines. We define the starting point of the lines by using the trailing region. The ending point is an offset of the starting position by the length attribute. These attributes can be more or less randomized to create variations in length or line spacing depending on the artist choice. Finally, we render these lines by splatting a small pattern using common technique like position and size jitter for more
<figure><img src="image_13.png" /><figcaption>Figure 11: *Simple transformations.* (left) A swinging sword (rotation). (middle) A ball bouncing on a paddle (translation). (right) A balloon deflating (scaling). We apply 3 different styles to these scenes: Trailing horizontal lines; Painterly smears; Echoes/Onion skin. *Lowpoly Stylized Scimitar - Krystian Zem*</figcaption></figure>

expressive effects, and we use the occlusion mask for visibility computation at rendering.

By using $(u', v')$ reparametrization, we can provide motion lines with screen space properties. Figure 12 shows two examples: fractalization and dashes.

When zooming in, using $v$ to compute the motion lines spacing causes them to spread out as the object gets closer. Using $v'$ instead keeps the spacing between the lines constant in screen space along the animation, producing a fractalization mechanism by adding new lines when needed.

In the case of dashes, by construction, the ribbon parameter $u$ is intrinsically time-dependent, meaning the dashes spacing is related to the object speed. By using $u'$ instead of $u$ we are able to create regularly spaced dashes.

We propose a smearing effect by interpolating the colors of consecutive frames along the ribbon. To improve the hand drawn look we abstract the interpolation by dividing the ribbon into multiple strokes with a randomized
<figure><img src="image_14.png" /><figcaption>(a) Fractalization</figcaption></figure>

<figure><img src="image_15.png" /><figcaption>(b) Dashed line</figcaption></figure>

Figure 12: *Screen space effects*. In both examples, the (u, v) parametrization is used on the left and its screen space reparametrization (u', v') is used on the right. (a) when relying on (u', v'), we can easily ensure a constant spacing between motion lines whatever the distance or size of the object according to the camera. This leads to a natural fractalization mechanism. (b) This parametrization also allows constant spaced dashes to be obtained.

length. The color of each stroke is computed from the color buffer at each
frame – that is when *u* is round – and interpolated in between. The result is
a spatial and temporal blending of the moving object as it moves, but still
retaining a hand drawn painterly aspect thanks to the strokes shape, which
we compute through a randomized offset.

Finally, we propose an echoes style, like an onion skin visualization only
on the trailing edge. To compute this effect we only use the current frame
and offset it several times backward in the direction of the ribbon. We mask
parts of the repeated images, either by hiding half of the object, or by only
showing the silhouette's edge (using the distance to the silhouette buffer).
The shape of the ribbon ensures the coherence of the repeated images with
the object's motion.

4.2. *Complex scenes*

Since armatures can be boiled down to a hierarchy of transforms, our
method is perfectly adapted to rigged animation. In Figure 13 we show a
rigged model where the anchor point is located on the bone. The mask is
<figure><img src="image_16.png" /><figcaption>Figure 13: *Motion captured animation of a kick.* (Left) weights of the region of interest, computed using the bone's associated vertex group. (Right) Onion, smear and line styles applied to emphasize the foot motion. Source: Adobe Mixamo – Model by Maxim Lenchik</figcaption></figure>

<figure><img src="image_17.png" /><figcaption>Figure 14: *Technical drawing application.* Assembly guide for the wheel and head of a toy horse, with the lines instructing to perform a translation and a rotation to slide the wheel into its socket.</figcaption></figure>

computed using the bone's associated vertex group.

For complex movements, such as the spinning top example (Figure 10) or Figure 15, our method allows to precisely control which motion to emphasize.

Putting aside the obvious application to the animation industry, our method is also perfectly suited for technical drawings and assembly instructions. An example is shown in Figure 14 where we take advantage of the vector nature of our motion lines.

### 4.3. *Comparison with previous work*

Figure 15 shows that we can produce motion lines close to Schmid et al. [3]. The motion decomposition also allows us to depict the rotation and the translation with two separate sets of lines.
<figure><img src="image_18.png" /><figcaption>Figure 15: *Comparison with Schmid et al.* (Top) Result from [3]. (Middle) our result with a similar input scene: our lines follow the same trajectory than their example. (Bottom) Our result with motion decomposition: using the same input scene we are able to produce an animation that emphasize separately the translation and the rotation of the ball. The lines colors are taken from the color buffer at the starting point of each line.</figcaption></figure>

Figure 16 shows that our method can produce similar results to Moriya and Takahashi [2] in a unified method.
<figure><img src="image_19.png" /><figcaption>Figure 16: *Comparison between Moriya and Takahashi [2] (left) and our method (right).*
Our method allows for a similar motion decomposition and line style, applied to an ani-
mated sequence. The motion lines maintain temporal coherence. *Model source: Airplane*
— *Poly by Google [CC-BY]*</figcaption></figure>

4.4. *Implementation*

We have implemented our model on the CPU as a web application with-
out any optimization on a simple laptop (AMD Ryzen 9 4900H). The full
computation of one frame, including the ribbon generation and the rendering,
takes approximatively one second. We believe that an optimized GPU imple-
mentation, as planned as future work, would lead to interactive to real-time
frame rates, more adapted to production pipelines.

To test our model, we have implemented a proof-of-concept GUI (Fig-
ure 17) with a properties panel, a timeline and a viewport, allowing users
to set input parameters and visualize their changes. For example, trace and
move selection, generator parameters and rendering function parameters can
be controlled by simple sliders and check-boxes. The rendering functions
themselves are custom fragment shaders which share the same exposed in-
put parameters, and can be edited through the GUI. The G-buffers and the
matrix hierarchy are directly extracted from the 3D software Blender using a
simple Python script that can be run with a single command. Our prototype
is able to parse through the bitmaps and JSON files this script generates.
<figure><img src="image_20.png" /><figcaption>Figure 17: *Our web-based interface* The properties panel can be seen on the left, the timeline on the bottom, and the viewport at the center.</figcaption></figure>

5. Conclusions

The motion ribbon is a new drawing space devised to procedurally gen-
erate motion effects over rendered 3D scenes, using a pre-computed motion
decomposition provided as the main input. Our design process is based on
our observations of artistic examples in the industry. To accommodate the
wide range of motion effect styles, our method relies on the user's input at
each stage, even when most processes remain automatic.

Our method can, however, greatly benefit from further optimizations. For
instance, we have identified that the segment's placement heavily depends
on the object's geometry, and decided to leave it to the artist's discretion.
There may be a way to deduce a satisfying position for the segment based on a
position buffer, or a saliency map, thus completely automatizing the ribbon
creation process from a user-chosen trajectory. At the same time, despite
its simplicity and applicability in most use-cases, other generator shapes do
fit our requirements well enough to hint at a possible generalization of this
aspect of our method.

Finally, our method requires a decomposition of the desired movement as
an input, which has to be done by hand. Automatizing this process would
make our method more universal, typically by making it applicable to motion
capture or video tracking, and is a great avenue for future investigations.

Acknowledgement

We would like to thank Pascal Barla for the many fruitful discussions.
This work was partially financed by the software development company Left
Angle.

References

[1] J. E. Cutting, Representing motion in a static image: constraints and parallels in art, science, and popular culture, Perception 31 (10) (2002) 1165–1193.

[2] T. Moriya, T. Takahashi, An extended non-photorealistic rendering technique for depicting motions of multiple 3d objects, in: 2008 Second International Symposium on Universal Communication, 2008, pp. 199–205. doi:10.1109/ISUC.2008.64.

[3] J. Schmid, R. Sumner, H. Bowles, M. Gross, Programmable motion effects, ACM Trans. Graph. 29 (07 2010). doi:10.1145/1833349.1778794.

[4] M. Walker, The Lexicon of Comicana, iUniverse, 1980.

[5] Y. Kawagishi, K. Hatsuyama, K. Kondo, Cartoon blur: nonphotorealistic motion blur, in: Proceedings Computer Graphics International 2003, 2003, pp. 276–281. doi:10.1109/CGI.2003.1214482.

[6] S. McCloud, Understanding Comics, HarperPerennial, 1993.

[7] D. B. Goldman, B. Curless, D. Salesin, S. M. Seitz, Schematic storyboarding for video visualization and editing, ACM Trans. Graph. 25 (3) (2006) 862–871. doi:10.1145/1141911.1141967.
URL https://doi.org/10.1145/1141911.1141967

[8] T. Stein, N. Holzschuch, Création de storyboards dynamiques pour la visualisation d'animations, in: 21èmes journées de l'Association Française d'Informatique Graphique (AFIG), IRIT Press, Toulouse, France, 2008. URL https://inria.hal.science/inria-00345907
[9] P. Baudisch, D. Tan, M. Collomb, D. Robbins, K. Hinckley, M. Agrawala, S. Zhao, G. Ramos, Phosphor: Explaining transitions in the user interface using afterglow effects, in: Proceedings of the 19th Annual ACM Symposium on User Interface Software and Technology, UIST '06, Association for Computing Machinery, New York, NY, USA, 2006, p. 169–178. doi:10.1145/1166253.1166280.
URL https://doi.org/10.1145/1166253.1166280

[10] E. P. Bennett, L. McMillan, Computational time-lapse video, ACM Trans. Graph. 26 (3) (2007) 102–es. doi:10.1145/1276377.1276505.
URL https://doi.org/10.1145/1276377.1276505

[11] F. Navarro, F. J. Serón, D. Gutierrez, Motion Blur Rendering: State of the Art, Computer Graphics Forum (2011). doi:10.1111/j.1467-8659.2010.01840.x.

[12] J. Collomosse, P. Hall, Cartoon-Style Rendering of Motion from Video, in: P. Hall, P. Willis (Eds.), Vision, Video, and Graphics (VVG) 2003, The Eurographics Association, 2003, pp. 117 – 124. doi:10.2312/vvg.20031016.

[13] B. Kim, I. Essa, Video-based nonphotorealistic and expressive illustration of motion, in: International 2005 Computer Graphics, 2005, pp. 32–35. doi:10.1109/CGI.2005.1500363.

[14] X. Zhang, T. Dekel, T. Xue, A. Owens, Q. He, J. Wu, S. Mueller, W. T. Freeman, Mosculp: Interactive visualization of shape and time, in: Proceedings of the 31st Annual ACM Symposium on User Interface Software and Technology, UIST '18, Association for Computing Machinery, New York, NY, USA, 2018, p. 275–285. doi:10.1145/3242587.3242592.
URL https://doi.org/10.1145/3242587.3242592

[15] G. Rosado, Motion blur as a post-processing effect, in: H. Nguyen (Ed.), Gpu Gems 3, Addison-Wesley Professional, 2007, Ch. 27, pp. 575–582.

[16] M. McGuire, P. Hennessy, M. Bukowski, B. Osman, A reconstruction filter for plausible motion blur, in: Proceedings of the ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games, I3D '12, Association for Computing Machinery, New York, NY, USA, 2012, p. 135–142. doi:
10.1145/2159616.2159639.

URL https://doi.org/10.1145/2159616.2159639

[17] M. Salvati, K. Ito, Blur algorithms for cartoon animation, 2018, pp. 1–2.
doi:10.1145/3283289.3283295.

[18] X. Luo, N. Z. Salamon, E. Eisemann, Controllable motion-blur effects in still images, IEEE Transactions on Visualization and Computer Graphics 26 (7) (2020) 2362–2372. doi:10.1109/TVCG.2018.2889485.

[19] A. Joshi, P. Rheingans, Illustration-inspired techniques for visualizing time-varying data, VIS 05. IEEE Visualization, 2005. (2005) 679–686.
URL https://api.semanticscholar.org/CorpusID:15654524

[20] S. C. Hsu, I. H. H. Lee, Drawing and animation using skeletal strokes, in: Proceedings of the 21st Annual Conference on Computer Graphics and Interactive Techniques, SIGGRAPH '94, Association for Computing Machinery, New York, NY, USA, 1994, p. 109–118. doi: 10.1145/192161.192186.
URL https://doi.org/10.1145/192161.192186

[21] M. Masuch, S. Schlechtweg, R. Schulz, Speedlines: depicting motion in motionless pictures, in: ACM SIGGRAPH 99 Conference Abstracts and Applications, SIGGRAPH '99, Association for Computing Machinery, New York, NY, USA, 1999, p. 277. doi:10.1145/311625.312369.
URL https://doi.org/10.1145/311625.312369

[22] A. Lake, C. Marshall, M. Harris, M. Blackstein, Stylized rendering techniques for scalable real-time 3d animation, in: Proceedings of the 1st International Symposium on Non-Photorealistic Animation and Rendering, NPAR '00, Association for Computing Machinery, New York, NY, USA, 2000, p. 13–20. doi:10.1145/340916.340918.
URL https://doi.org/10.1145/340916.340918

[23] S. Chenney, M. Pingel, R. Iverson, M. Szymanski, Simulating cartoon style animation, in: Proceedings of the 2nd International Symposium on Non-Photorealistic Animation and Rendering, NPAR '02, Association for Computing Machinery, New York, NY, USA, 2002, p. 133–138. doi: 10.1145/508530.508553.
URL https://doi.org/10.1145/508530.508553
[24] J. Ma, L.-Y. Wei, R. H. Kazi, A layered authoring tool for stylized 3d animations, in: Proceedings of the 2022 CHI Conference on Human Factors in Computing Systems, CHI '22, Association for Computing Machinery, New York, NY, USA, 2022. doi:10.1145/3491102.3501894.
URL https://doi.org/10.1145/3491102.3501894

[25] M. Haller, C. Hanl, J. Diephuis, Non-photorealistic rendering techniques for motion in computer games, Comput. Entertain. 2 (4) (2004) 11. doi:10.1145/1037851.1037869.
URL https://doi.org/10.1145/1037851.1037869

[26] X. Guan, K. Mueller, Point-based Surface Rendering with Motion Blur, in: M. Gross, H. Pfister, M. Alexa, S. Rusinkiewicz (Eds.), SPBG'04 Symposium on Point - Based Graphics 2004, The Eurographics Association, 2004. doi:/10.2312/SPBG/SPBG04/033-040.

[27] A. Wheeler, J. Thiel, G. Hart, Cartoon motion blur for 3d animation, in: ACM SIGGRAPH 2006 Sketches, SIGGRAPH '06, Association for Computing Machinery, New York, NY, USA, 2006, p. 95-es. doi:10.1145/1179849.1179968.
URL https://doi.org/10.1145/1179849.1179968

[28] M. Nienhaus, J. Dollner, Depicting dynamics using principles of visual art and narrations, IEEE Computer Graphics and Applications 25 (3) (2005) 40-51. doi:10.1109/MCG.2005.53.

[29] S. Bouvier-Zappa, V. Ostromoukhov, P. Poulin, Motion cues for illustration of skeletal motion capture data, in: Proceedings of the 5th International Symposium on Non-Photorealistic Animation and Rendering, NPAR '07, Association for Computing Machinery, New York, NY, USA, 2007, p. 133-140. doi:10.1145/1274871.1274891.
URL https://doi.org/10.1145/1274871.1274891

[30] X. Huang, Q. Hou, Z. Ren, K. Zhou, Scalable Programmable Motion Effects on GPUs, Computer Graphics Forum (2012). doi:10.1111/j.1467-8659.2012.03219.x.

[31] J. Basset, P. Bénard, P. Barla, SMEAR: Stylized Motion Exaggeration with ARt-direction, in: SIGGRAPH 2024 - Conference & Exhibition on Computer Graphics & Interactive Techniques, Denver, CO / Virtual,
United States, 2024. doi:10.1145/3641519.3657457.

URL https://hal.science/hal-04576817

[32] F. Frenet, Sur les courbes à double courbure, Journal de Mathématiques Pures et Appliquées 1e série, 17 (1852) 437-447.

URL http://www.numdam.org/item/JMPA_1852_1_17__437_0/

[33] J.-A. Serret, Sur quelques formules relatives à la théorie des courbes à double courbure, Journal de Mathématiques Pures et Appliquées 1e série, 16 (1851) 193-207.

URL http://www.numdam.org/item/JMPA_1851_1_16__193_0/

[34] W. Wang, B. Jüttler, D. Zheng, Y. Liu, Computation of rotation minimizing frames, ACM Trans. Graph. 27 (1) (Mar. 2008). doi: 10.1145/1330511.1330513.

URL https://doi.org/10.1145/1330511.1330513