Computational Design of Mechanical Characters
Stelian Coros*
1
Bernhard Thomaszewski*
1
Gioacchino Noris
1
Shinjiro Sueda
2
Moira Forberg
2
Robert W. Sumner
1
Wojciech Matusik
3
Bernd Bickel
1
1
Disney Research Zurich
2
Disney Research Boston
3
MIT CSAIL
Figure 1: The interactive design system we introduce allows non-expert users to create complex, animated mechanical characters.
Abstract
We present an interactive design system that allows non-expert
users to create animated mechanical characters. Given an articu-
lated character as input, the user iteratively creates an animation
by sketching motion curves indicating how different parts of the
character should move. For each motion curve, our framework cre-
ates an optimized mechanism that reproduces it as closely as pos-
sible. The resulting mechanisms are attached to the character and
then connected to each other using gear trains, which are created
in a semi-automated fashion. The mechanical assemblies generated
with our system can be driven with a single input driver, such as a
hand-operated crank or an electric motor, and they can be fabricated
using rapid prototyping devices. We demonstrate the versatility of
our approach by designing a wide range of mechanical characters,
several of which we manufactured using 3D printing. While our
pipeline is designed for characters driven by planar mechanisms,
significant parts of it extend directly to non-planar mechanisms, al-
lowing us to create characters with compelling 3D motions.
CR Categories: I.3.6 [Computer Graphics]: Methodology and
Techniques—Interaction Techniques; I.3.5 [Computer Graphics]:
Computational Geometry and Object Modeling—Physically based
modeling
Keywords: mechanical characters, animation, fabrication, inter-
active design
Links: DL PDF
*The first two authors contributed equally to this work.
1 Introduction
Character animation allows artists to bring fictional characters to
life as virtual actors in animated movies, video games, and live-
action films. Well-established software packages assist artists in
realizing their creative vision, making almost any digital charac-
ter and movement possible. In the physical world, animatronic
figures play an equivalent role in theme parks and as special ef-
fects in movies and television. While these sophisticated robots are
far from becoming household items, toys that exhibit mechanical
movement are extremely popular as consumer products. However,
unlike virtual characters, creating complex and detailed movement
for mechanical characters, whose motion is determined by physi-
cal assemblies of gears and linkages, remains an elusive and chal-
lenging task. Although mechanical characters have been part of
the toy industry since the nineteenth century [Peppe 2002], design
technology for these characters has changed little and is limited to
expert designers and engineers. Even for them, the design process
is largely trial and error, with many iterations needed to produce
an acceptable result. Since iteration times increase greatly as the
complexity of the design space increases, mechanical characters are
limited in scope and complexity, which in turn limits the range of
possible movement and the creative freedom of the designers.
We present a computational design system that allows non-expert
users to design and fabricate complex animated mechanical char-
acters (Fig. 1). Our system automates tedious and difficult steps in
the design process, and the resulting mechanical characters can be
fabricated using rapid manufacturing methods such as 3D printing.
Interactivity is a core design principle of our system, allowing users
to quickly explore many different mechanical design options, as the
motion of the characters is iteratively created.
In order to make the computational design problem tractable, we
limit the scope of this work to characters that perform cyclic mo-
tions and that do not need to sense or respond to the external envi-
ronment. However, within these restrictions, we wish to support a
wide range of complex, user-defined motions. In order to accom-
plish this goal, we begin with a library of parameterized mechanical
assembly types. Our system first pre-computes a sparse sampling of
their parameter spaces, resulting in a representative set of motions
for each type of mechanical assembly. After this precomputation
step has been completed, our interactive design pipeline proceeds
as follows (see Fig. 2 for a visual summary):
Figure 2: Overview of our interactive design system: a) an input character and a gear box are provided; b) the desired motion of the
character is specified by sketching motion curves; c) optimized driving mechanisms are generated by our framework; d) gear trains are
created to connect all the driving mechanisms to one actuator; e) support structure is generated; f) the mechanical character is 3D-printed.
1. Given an articulated character as an input, the user selects a set
of actuation points on the character and sketches associated
motion curves.
2. For each input curve, the precomputed database is queried
to find an assembly that matches the motion specified by the
user. This gives us both the type of mechanical assembly that
is best suited for each motion curve, and a good initial set of
parameter values (Sec. 4).
3. Appropriate driving mechanisms are instantiated, connected
to the character, and their parameter values are further opti-
mized using a gradient-based formulation (Sec. 4.2).
4. Once all driving mechanisms are set up, the gears that actuate
them are connected to each other through a gear train in a
semi-automatic fashion (Sec. 6.1).
5. For planar characters, our system then repositions the me-
chanical components to ensure that no collisions occur during
operation (Sec. 6.2).
6. Finally, support structures are generated to hold the compo-
nents of the assembly in place (Sec. 6.3). The complete char-
acter model and the mechanical assembly driving it are then
ready for fabrication (Sec. 6.4).
2 Related Work
Mechanical Assemblies have tremendously changed our way
of life since the industrial revolution — for a comprehensive in-
troduction into mechanisms and mechanical devices we refer the
interested reader to the textbook of Sclater and Chironis [2001].
The potential to use specialized software for analysis and design
of mechanisms has been recognized since the early days of com-
puters [Freudenstein 1954]. Consequently, a variety of approaches
for representing mechanical structures have been presented. Some
modeling systems, for instance, implement function-oriented and
shape-oriented approaches, where objects, assemblies and posi-
tional relationships are represented as nodes in a graph structure,
and an explicit or procedural representation is used for shape prim-
itives [Wesley et al. 1980; Gui and M
¨
antyl
¨
a 1994]. Similar tech-
niques are used to implement basic functionality for commercially
available CAD/CAM tools. Despite the significant benefits pre-
sented by such tools, creating complex mechanisms, such as those
needed to animate mechanical characters, currently requires expert
designers.
Kinematic Synthesis. Several existing methods aim at automat-
ing the design of devices that transform a specified input motion
into a specified output motion. Chiou and Sridhar [1999], for
instance, use symbolic matrices representing a library of mecha-
nism as basic building blocks. Starting with an intended function,
the system recursively decomposes it into simpler sub-functions
until a match is found in the database. Similarly, Subramanian
and Wang [1995] define valid configuration spaces for building
blocks and use an iterative deepening search to generate mechanism
topologies and geometries that satisfy given motion constraints. Al-
ternatively, genetic algorithms or other stochastic search methods
can be applied [Cabrera et al. 2002]. Recently, Zhu et al. [2012]
suggested selecting a mechanism from a parameterized set accord-
ing to a priori knowledge of its motion. The selected mechanism is
then refined by optimizing over both discrete and continuous vari-
ables using simulated annealing. While this approach can effec-
tively handle, e.g., linear, ellipsoidal or circular motions, creating
mechanical characters exhibiting complex motions requires a more
general formulation. In our work, we use a sampling-based ap-
proach to generate a sparse but representative set of motions that
different types of mechanisms can generate. This allows us to de-
termine which of the available mechanism types are well-suited to
create a desired motion, and we use a gradient-based method in
order to further optimize the mechanisms generated by our frame-
work.
Motion and Interaction Analysis. There exists a variety of
methods for analyzing the geometry of mechanisms in order to ex-
tract the kinematic constraints that define their motions. For in-
stance, Mitra et al. [2010] present a semi-automatic technique for
depicting the operation of mechanical assemblies. Their method
determines the causal relationship between different parts of an
assembly based solely on geometry. Such processes are also in-
vestigated for reverse engineering of scanned devices [Demarsin
et al. 2007]. Recent work also explores the creation of a print-
able articulated model from input geometry by analyzing a skinned
mesh [B
¨
acher et al. 2012] or offering an intuitive user interface
to control the placement and range of motion of joints [Cal
`
ı et al.
2012]. While the resulting characters can be posed, these methods
do not address the challenge of animating them. In principle, how-
ever, the characters designed using these methods could be used as
input for our framework.
Design Systems and Personalized Fabrication are quickly
gaining interest in the computer graphics community. Interac-
tive systems enable non-expert users to design, for example, their
own plush toys [Mori and Igarashi 2007] or furniture [Lau et al.
2011; Umetani et al. 2012]. Rapid prototyping devices allow for
the fabrication of physical objects with desired properties based
on custom microgemetry [Weyrich et al. 2009], reflectance func-
tions [Malzbender et al. 2012], subsurface scattering [Hasan et al.
2010; Dong et al. 2010] and deformation behavior [Bickel et al.
2010]. Ensuring that printed objects are structurally stable, Stava
et al. [2012] proposed to relieve stress by automatically detecting
and correcting problematic parts of the models. In our work, we
focus on the problem of designing mechanical assemblies. Inspired
Figure 3: The driving mechanisms we use as building blocks can generate a continuous space of widely different motions. To generate
optimized assemblies that best match an input motion, we first perform a coarse exploration of the space of possible motions for each
mechanism, followed by a continuous parameter optimization.
by recent work in sketch-based interfaces [Eitz et al. 2012] and de-
sign galleries [Marks et al. 1997], we present an interactive design
system that allows non-expert users to intuitively create complex,
animated mechanical characters.
3 Assembly simulation
The recent method proposed by Zhu et al. [2012] simulates me-
chanical assemblies in a two-stage process. First, the configuration
of the driving assembly is computed using forward kinematics: by
assuming a tree-based representation of the mechanism [Mitra et al.
2010], the configuration of a component fully determines the con-
figuration of all other components that are connected to it. Second,
the motion of the toys is computed using inverse kinematics. In
contrast, we employ a constraint-based simulation of mechanical
assemblies. This allows us to reconstruct the motion of the charac-
ter and the driving assemblies in a unified manner, and it enables us
to simulate a much broader range of mechanisms, such as assem-
blies with kinematic loops, which cannot be simulated using the
forward kinematics approach employed by [Zhu et al. 2012]. As
discussed shortly, this approach also allows us to efficiently com-
pute gradients needed to optimize individual sub-assemblies.
3.1 Components and Connections
The mechanical assemblies we simulate consist of rigid compo-
nents that are connected to each other. The world-coordinates x of a
point x expressed in the local coordinates of component i are given
by x(x)
i
= T
i
+ R
γ
i
R
β
i
R
α
i
x. Similarly, the world-coordinates
v of a vector v expressed in the local coordinates of component i
are v(v)
i
= R
γ
i
R
β
i
R
α
i
v. The 6-dimensional state of the compo-
nent is defined as s
i
= {T
T
i
, γ
i
, β
i
, α
i
}
T
, where T
i
∈ R
3
denotes
the global position of the component, γ
i
, β
i
, α
i
are the Euler an-
gles parameterizing the component’s orientation and R
γ
i
, R
β
i
and
R
α
i
are the corresponding rotation matrices. The rotation axes n
γ
and n
β
are initially set to the x and y-axes respectively. To avoid
numerical problems due to the gimbal lock, they (together with the
corresponding rotational degrees of freedom γ and β) can be re-
computed by decomposing the component’s net orientation when-
ever it approaches a singularity. The axis of rotation for R
α
i
is set
to the component’s local z-axis, and we refer to the rotation angle
α as the phase of the component.
The components of an assembly are linked to each other through
different types of connections. Each connection c outputs a set of
scalar constraints C
c
. We have implemented four types of connec-
tions that, when combined, allow us to simulate a wide variety of
mechanical assemblies:
Pin Connections are used to model hinge joints between pairs
of components i and j. The constraints output by this type of con-
nection take the form C
c
= {(x(x
i
)
i
− x(x
j
)
j
)
T
(v(v
i
)
i
−
v(v
j
)
j
)
T
}
T
. The parameters x
i
, x
j
, v
i
and v
j
define the position
and rotation axis of the pin joint. Note that while the Pin Con-
nections output six constraints, they only remove five degrees of
freedom from the system: the two connected components can still
rotate freely with respect to each other about the axis v(v
i
)
i
(or
equivalently v(v
j
)
j
). Attaching two pin connections between the
same pair of components results in them being welded to each other.
Point On Line Connections ensure that a pin on component i
always lies on a line defined on component j. This type of con-
nection outputs constraints C
c
= v(v
j
)
j
× (x(x
i
)
i
− x(x
j
)
j
),
where x
i
represents the local coordinates of the pin on component
i, and the vector v
j
and point x
j
define the line that the pin should
lie on. Using two point on line connections between the same pair
of components allows us to model prismatic joints. As for the Pin
Connections, we can create three additional scalar constraints to en-
sure that the two components can only rotate with respect to each
other about one axis.
Phase Connections are typically used to connect gears to each
other, and they directly constrain the phase of the affected compo-
nents. In its most general form, the scalar constraint output by these
connections has the form: C
c
= α
i
− f(α
j
). The function f de-
pends on the types of gears that are connected. For spur and bevel
gears, f(α) = −r ∗α, where r is the ratio of the number of teeth of
the two gears. For non-circular gears, f is slightly more involved,
as described in Sec. 4.3. As a special case of the phase connection,
we allow gears to be directly connected to a virtual actuator, which
we call the Input Driver.
Fixed State Connections affect individual components and out-
puts six constraints: C
c
= s −s
d
, where s is the state of the affected
component, and s
d
is the desired state. The phase variable can be
optionally omitted from the list of constraints, allowing components
to rotate freely about one axis. These connections are used to sim-
ulate support structures such as walls or shafts, and to allow users
to temporarily freeze parts of the characters.
3.2 Simulation
To run a simulation step, we first advance the phase of the Input
Driver forward in time. We then solve the following optimization
problem in order to compute component state values that satisfy all
the constraints:
min
s
1
2
C
T
C, (1)
where C is a vector collecting the scalar constraints output by
all the connections in the assembly. We use a standard Newton-
Raphson method to solve Eq. (1), assuming that the phase of the
Input Driver fully determines the configuration of the entire assem-
bly. The mechanical assemblies that we simulate, however, can be
under or over constrained, if the user employs too few or too many
driving mechanisms. Our framework detects these problems (if the
system is over-constrained, Eq. (1) has a non-zero minimum; if it
is under-constrained, the hessian of
1
2
C
T
C is singular) and allows
the user to edit the assembly as required.
4 Mechanism Design
Our interactive design system allows users to sketch a set of curves
that specify the motion of different parts of the input character.
For each of the input curves, our system outputs optimized driv-
ing mechanisms that are attached to the character and control its
motion. Two problems need to be addressed in order to achieve
this. First, out of a library of input driving mechanism types, our
system must choose an appropriate one. Second, the parameters of
the selected mechanism must be optimized in order to best match
the motion specified through the input animation curves.
For simple motion trajectories specified by circular, elliptical or
straight-line curves, the map to an appropriate driving mechanism
can be manually specified [Zhu et al. 2012]. However, as the com-
plexity of the driving mechanisms increases, the space of possible
output motions grows significantly (see, e.g., Fig. 3), and this ap-
proach very quickly becomes impractical. Furthermore, in order to
accommodate arbitrary, black-box mechanisms, we do not assume
that there exist analytic expressions describing the relationship be-
tween a given set of parameters and the motion they lead do. The
methods we describe in this section allow us to address the chal-
lenges of working with complex driving mechanisms.
Overview Our system takes as input a library of parameterized
mechanism types as illustrated in Fig. 4. Each of these mechanisms
contains at least one driving gear that is either connected directly
to the Input Driver or to other gears. Once instantiated, the assem-
blies are attached to the character, typically through pin connec-
tions. While the locations of the pin joints on the input character are
generally user-specified, the attachment points on the driving mech-
anisms are parameterized. For each type of driving mechanism, the
locations of the pin and point-on-line connections between the indi-
vidual components as well as the positions of the support shafts are
also parameterized. As an example, the mechanism types shown in
Fig. 4 have between 6 and 12 parameters.
To address the challenge of determining which assembly type is
best suited for a desired animation, we begin by performing a coarse
exploration of their parameter spaces through sampling (Sec. 4.1).
This pre-processing step results in a database that stores a repre-
sentative set of possible motions for each class of mechanism, as
illustrated in Fig. 3. Rather than recording the motion trajectories
of the individual gears and linkages comprising the mechanisms,
however, the database represents a map between specific points in
an assembly’s parameter space and the motion curves traced out
by the mechanism’s attachment point, since these trajectories fully
define the motion of the input character.
Figure 4: We assume as input a library of parameterized driving
mechanisms such as the ones illustrated here. These building blocks
are instantiated by our framework, optimized and attached to the
input character, driving its motion. The locations of the attachment
points are highlighted.
The input motion curves provided to our system directly specify the
trajectories that the attachment point of a driving mechanism should
trace out. To determine which type of mechanism is capable of
best matching an input curve, it is therefore sufficient to search the
precomputed database using the curve similarity metric described
in Sec. 5. Once a mechanism is selected from the database, it is
first scaled, rotated and translated using the transformation that best
aligns the curve traced out by its attachment point to the input curve
(see Sec. 5). If a designated gear box is provided as input, then
we must ensure that the bounding box of the chosen mechanism
fits inside. If this is not the case, we discard the mechanism and
proceed to the next best match.
As the database we pre-compute represents only a sparse sampling
of the parameter space for each assembly type, the selected mech-
anisms need to be further optimized, as described in Sec. 4.2. We
note that the driving mechanisms obtained by querying the database
typically provide a good starting point for the continuous opti-
mization method we use. This significantly improves convergence
rates and reduces the likelihood of encountering bad local-minima,
which is a very real possibility given the highly non-linear relation-
ship between assembly parameters and the resulting motions.
4.1 Parameter Space Exploration
We approximate the space of motions that a given type of mecha-
nism can generate by sampling its parameter domain. Our goal in
this context is to obtain a good coverage of the space of possible
motion curves with a sparse set of samples. The latter point is im-
portant since it determines the response time for curve retrieval dur-
ing interactive design. In order to generate a sparse set of samples
that cover a large variety of motion curves, we use a Poisson-disk
sampling scheme in metric space. This amounts to requiring that
for any pair of parameter-space samples, the distance between the
two corresponding curves must not be lower than a given thresh-
Figure 5: The trajectory (gray polyline) traced out by a marker
point (red dot) to approximate a target curve (red polyline). A
marker point can either be located on the driving mechanism (left)
or on a part of the character that is driven by a mechanism (right).
old. Unfortunately, fast Poisson-disk sampling methods [Bridson
2007] cannot be applied in our setting: while it easy to satisfy the
minimum distance criterion in parameter space, this is not the case
in metric space since the mapping between the parameters of the
mechanism and its generated motion curve is non-trivial.
We therefore generate the samples using a simple recursive process.
For each accepted sample, we generate a number of new samples by
uniformly probing the parameter space around the current sample’s
location. For each generated sample, we compute the correspond-
ing curve, and using the distance metric described in Sec. 5, we
check whether it is too close to any of the existing samples in the
database. If this is the case, we reject the sample, otherwise it is
added to the database. We note that it is possible that some regions
in the parameter space lead to infeasible configurations. As a re-
sult, although our sampling strategy is very effective for exploring
connected regions of a mechanism’s parameter space, we have no
guarantees that it exhaustively explores the entire space of feasible
parameters.
4.2 Continuous parameter optimization
After selecting an appropriate driving mechanism from the
database, its parameters need to be further fine-tuned, and we use
a continuous optimization method for this purpose. We assume
that a marker point specified on the character should follow a user-
provided curve as closely as possible. The marker can either coin-
cide with the attachment point of the driving mechanism, or it can
be located at an arbitrary point on the character, as illustrated in
Fig. 5. To optimize the resulting motion, we minimize the follow-
ing objective as a function of the mechanisms’s parameters p:
F =
1
2
Z
1
t=0
(x(p, s
t
) −
ˆ
x
t
)
T
(x(p, s
t
) −
ˆ
x
t
)dt, (2)
where t is the phase of the Input Driver, such that when t = 1 a full
cycle of the animation has been completed. x(p, s
t
) and
ˆ
x
t
denote
the position of the marker point and its target position at phase t.
The state of the assembly at phase t, s
t
, is computed by minimizing
Eq. 1 after instantiating the mechanism with the current set of pa-
rameters p. As the parameters of the mechanisms directly affect the
connections between the different components, for the remainder of
this section we write the system constraints as an explicit function
of the parameters and the state variables i.e. C(p, s
t
).
Note that in Eq. (2), we use a point-based metric to measure the
similarity between the input and output motion curves, rather than
the more involved metric described in Sec. 5. Because the curve
traced out by the marker point is already aligned with the input
curve, and their shapes are relatively similar, we have found this to
be sufficient. For any phase t, the gradient of the matching objective
∂F
t
∂p
is given by:
∂F
t
∂p
= (
∂x
∂p
+
∂x
∂s
t
∂s
t
∂p
)
T
(x(p, s
t
) −
ˆ
x
t
), (3)
where all the partial derivatives are evaluated at (p, s
t
). In the
equation above,
∂x
∂p
represents the change in the marker’s position
when the state of the sub-assembly remains unaltered. For instance,
changing the location of the attachment point in the linkage struc-
ture shown in Fig 5 (left) does not affect the evolution of the state of
the sub-assembly, but results in a different curve being traced out.
The term
∂x
∂s
t
is evaluated analytically, and the remaining term,
∂s
t
∂p
,
represents the change in the state of the assembly as its parameters
change. This term cannot be evaluated analytically because the sub-
assemblies we optimize can be arbitrarily complex, and in general
there is no closed-form solution describing their motion. Finite dif-
ferences can be used to estimate the derivatives, but this requires Eq.
(1) to be solved O(|p|) times to a high degree of accuracy, which
is too computationally demanding for interactive applications. In-
stead, we exploit the implicit relationship between the parameters
of the sub-assembly and the state configuration that results in all
constraints being satisfied, i.e., C(p, s
t
(p)) = 0. According to the
Implicit Function Theorem,
∂s
t
∂p
= −
∂C
∂s
t
−1
∂C
∂p
. (4)
We estimate
∂C
∂p
using finite differences. This requires us to in-
stantiate sub-assemblies with different parameters
e
p and compute
the value of the constraints C(
e
p, s
t
(p)). We note that this does
not require Eq. (1) to be minimized, and its computational cost
is therefore negligible. The matrix
∂C
∂s
t
is computed analytically.
As noted in Sec. 3, our mechanical assemblies can have more
constraints than degrees-of-freedom. Since the additional con-
straints are redundant however, the matrix
∂C
∂s
t
still has full col-
umn rank, and in such cases, we instead use the pseudo-inverse
∂C
∂s
t
+
= (
∂C
∂s
t
T
∂C
∂s
t
)
−1
∂C
∂s
t
T
.
We minimize Eq. (2) by evaluating the matching objective and its
gradient at a discrete number of points (i.e., t values). To improve
convergence rates we use the BFGS quasi-Newton method to esti-
mate the approximate Hessian
∂
∂p
∂F
∂p
[Nocedal and Wright 2006].
4.3 Timing control via non-circular gears
Controlling the timing of motions is an integral part of character
animation. We therefore also allow users to explicitly control the
timing of the characters’ motions. This is accomplished through
the use of non-circular gears, which are always used in pairs: a
constant angular velocity input signal applied to the first gear gets
transformed to variable angular velocity for the second gear. The
phase-dependent ratio of angular velocities of the two gears de-
pends on the shape of their profiles, and in particular, on the ra-
tio of the gears’ radii at the point where they mesh. Asking users
to directly provide the phase-dependent ratio of angular velocities,
however, is not intuitive, as the integral of this ratio needs to re-
main constant (otherwise one gear rotates more than the other over
a full cycle). Instead, we allow users to define the relative phase
profile between the two gears, as illustrated in Fig 6 (left). This is
accomplished by allowing the user to set samples (α
1i
, α
2i
) that
