Body-shape Transfer for Super Deformation of 3D Character Models
Peng Wang
Yoshihiro Kanamori
Yuki Endo
Jun Mitani
Department of Computer Science, Graduate School of Systems and Information Engineering,
University of Tsukuba,
Email: wangpeng@npal.cs.tsukuba.ac.jp, {kanamori,endo,mitani}@cs.tsukuba.ac.jp

Abstract—We present a technique for semi-automaticallysuper-deforming 3D character models. Super deformation is aunique style of exaggeration, often seen in Japanese animationand manga, to enhance characters’ cute appearances. Specifically, super-deformed (SD) characters are chubby with stubby
limbs and oversized heads. Given a reference SD model witha rig and a target character model, our method automaticallycalculates a rig of the target model, measures the body
shapes, and shortens the target limbs and enlarges the target
head by transferring the reference body shape. Our method
further makes the target face younger by applying a simple
deformation based on a biological insight. We demonstrate that
our method can create visually-pleasing SD character models
quickly.
Keywords-3D modeling; super deformation; rigging;

Figure 1: “Unity-chan” (left) and its super-deformed (SD)version designed by an artist (right).

I. I NTRODUCTION
Japanese animation (or “anime”) and manga have attracted not only children but also adults around the world. Insuch Japanese culture, super deformation is a unique style ofexaggeration to enhance characters’ cute appearances; superdeformed (SD) characters are typically chubby with stubby
limbs and oversized heads, and resemble small children [1].
SD characters often appear not only in anime or manga
but also in commercials and character figures. Figure 1
shows a pair of normal and corresponding SD examples of acharacter “Unity-chan”1 . SD character models are currently
created by skilled artists via a burdensome manual process,which hinders widespread use of SD characters. We thus
focus on semi-automatic creation of SD models from normal
character models.
However, designing a “good” SD model from scratch
is not easy even for professional artists, as we confirmed
through an interview with a character figure company. Thisis because the definition of super deformation is ambiguous;
each SD model has its own appropriate style of exaggerationand simplification, depending on various factors such as
the character’s personality, the character design in the story
series, and the style in specific product series. On the other
hand, if the designer can start from a base SD model thatis close to the output model, the designer can skip basicmodeling and focus on detail modification. We thus let theuser input an appropriate reference SD model as a hint foravoiding excessive trial-and-errors in the early design stage.
1 The models were obtained from http://www.unity-chan.com

In this paper, we propose a semi-automatic method that
can accelerate the modeling process of SD characters. The
inputs of our method are a reference SD model with a rig
and a target character model without any rig (Figure 2). Herea rig is a standard data structure commonly used in characteranimation, consisting of a skeleton (a tree structure of joints
and bones) and weight maps (weights of bones for the meshvertices). Our method automatically calculates the target rig,measures body-shape parameters, and shortens the target
limbs as well as enlarges the target head by transferring
the reference body shape. Our method further makes thetarget face younger by applying simple deformation basedon the biological insight by D’Arcy Thompson [2]. Our
method is automatic except for the face infantilization step
where the user tweaks the face shape by simply tuning asingle parameter. We demonstrate that our method can create
visually-pleasing SD character models quickly.
II. R ELATED W ORK
Shape deformation has been long studied in computer
graphics, and there are deformation techniques used forhuman characters. For example, linear blend skinning [3]and its successors [4] have been standard techniques foranimating characters. Body-shape control has been actively
studied. Blantz and Vetter published a seminal work for parametric control of human face model [5]. They scanned 199
human faces and constructed a statistical morphable modelof human face based on principal component analysis. This

Target model

Skeleton

Weight maps

y
0.5

0

-0.5

Face transformation

Output model

Bone length
Surrounding-mesh radius
Body-shape parameters
Reference model (with skeleton)

Figure 2: Overview of our system. Given target and reference SD models, our method calculates their body-shape parameters
and a target skeleton as well as weight maps. After applying a simple transformation to the target face, we obtain an output
SD model.

idea is later extended to morphable human body models [6],[7]. Apart from statistical models, there are also techniques
for exaggerating body parts according to a user-specified
importance map [8] and deforming a body shape based on
an anatomical muscle model [9]. These methods are notintended for SD character models.
The most related method to ours is that proposed by Shenet al. [10]. Their method aims at super-deforming various
mesh models such as human characters and monsters. The
important differences with ours are as follows. (i) Theirmethod does not use a reference model and enforces theuser to manually tweak parameters for controlling shape
optimization. Our method, on the other hand, does not relyon optimization, provides quick feedback to the user, andcan avoid excessive trial-and-errors by obtaining body-shapeparameters from a given reference SD model. (ii) Theirmethod implicitly assumes that an input character model
consists of only a single mesh. However, character models
often have cloth meshes as well as body meshes, whichmight cause inconsistent deformation between the meshes(see Section IV-B). Our method can handle models withmultiple meshes. (iii) To deform a character’s face, their
method deforms the head shape so that it approximates asphere. However, this sphere approximation is not sufficient
to making the face look younger. For this, our method
applies a biology-inspired transformation to the head model.
III. O UR A LGORITHM
A. Overview
Figure 2 shows the overview of our system. Our inputs
are two character models; one is the target model, which

has normal body proportion without any skeleton or weightmaps. The other is the reference model, which is an SD
model with a skeleton and weight maps, selected by theuser as a reference. We assume both models are in a rest
pose and have cloth and hole-free body meshes separately.
A rest pose is common and simplifies the measurementand deformation of body shapes. Hole-free body mesh isrequired for calculating weight maps [11]. The key idea
is to transfer the body shape from the reference model tothe target model for automatically determining the basic
shape of the output SD model. This goal is accomplishedas follows. First, we calculate a skeleton and corresponding
weight maps for the target model (Section IV). We thenmeasure body-shape parameters, i.e., each bone’s lengthand distance to the surrounding mesh, for both the target
and reference models, and super-deform the target model
automatically (Section V). The user can further make thetarget face look younger by lowering the eye positions androunding the chin based on a biology-inspired transformation(Section VI). The user can optionally add manual modifications, e.g., deformation of hair polygons, to obtain the output
model. We describe the details in the following sections.
IV. S KELETON AND W EIGHT M AP C ALCULATION
A. Skeleton definition
We use a skeleton often used in linear blend skinning forcharacter animation. A skeleton is a tree structure where
joints and bones serve as nodes and edges (Figure 3,left). Let N and M be the numbers of joints and bones
respectively. The position of joint j(j = 1, 2, ..., N ) isdenoted by pj . Bone i(i = 1, 2, ..., M ) contains a parent

(a) body weight map(b) naive weight map(c) penetrated skirt(d) transferred weight map(e) consistently-deformed skirt

Figure 3: Tree structure consisting of joints and bones (left),and bone groups (right).

node parent(i) and child node(s) child(i), and its length isli = ||pparent(i) − pchild(i) ||. If a parent node has multiple
children nodes, we calculate the bone length for each pairof parent and child nodes. We assume both skeletons of thereference and target models have the same structure, i.e.,the same numbers of joints and bones with the same connections. We further separate bones into user-defined bonegroups (Figure 3, right), and apply similar deformations tobones in each bone group G.
B. Calculation of skeleton and weight maps
Our method automatically calculates a skeleton andweight maps of the target model. For a skeleton, we employ the ray-casting based method by Lopez et al. [12]using a publicly-available implementation that can handle
even fingers automatically. For weight maps, we use theoptimization-based method by Baran et al. [11] as follows.
The method by Baran et al. [11] automatically calculates
weight maps by solving the thermal diffusion equation.
Using this method we obtain weight maps consisting of
weight wki of each bone i for vertex k (where wki ≥ 0M∑andwki = 1). This method works well with singlei=1

mesh models, as demonstrated in the previous study [10].
However, most character models wear multiple clothes thatare represented as non-manifold meshes separated from thebody meshes; if we apply the method by Baran et al. [11] toboth cloth and body meshes naı̈vely, they will have different
weights at their contact part and therefore deform differently,
resulting in penetrations or gaps between cloth and bodymeshes (Figure 4(c)).
To ensure that the weights of cloth and body vertices
match at contact parts, our method first calculates theweights for the body mesh, and then transfers the weights
to the cloth meshes by linearly blending weights of thenearest body vertices. This modification yields consistent
deformation of the clothes and body (Figure 4(e)).

Figure 4: Comparison of cloth weight map calculation. (b)The naı̈vely calculated weight map of the skirt does notmatch (a) that of the body, which causes (c) penetration. (d)By transferring the weights from the body to the skirt, (e)the skirt deforms consistently with the body.

V. S UPER - DEFORMATION U SING B ODY- SHAPEPARAMETERS
A. Body-shape parameter measurement
Our method automatically measures body-shape parameters based on the method by Lopez et al. [12]. The bodyshape parameters used in our method are (i) the length li ofeach bone i and (ii) the radius ri of a cylinder approximating
the mesh surrounding bone i, which we call the surroundingmesh radius. We label each of them with labels tar (for thetarget model) and ref (for the reference model). Let Lref =refref{l1ref , l2ref , ..., lM} and Rref = {r1ref , r2ref , ..., rM} bethe sets of bone lengths and surrounding-mesh radii of thereference model, respectively. Ltar and Rtar are definedsimilarly for the target model.
Body-shape parameters are calculated as follows. Bonelength li is calculated simply as the distance between parent
and child nodes of bone i. Surrounding-mesh radius ri is
calculated based on ray casting. Figure 5 illustrates thisprocess. For each bone i, our method samples three points z
at a uniform interval along each bone. It then emits rays fromeach sampled point z in directions orthogonal to the boneequiangularly (we use 12 rays) in order to find the nearest
intersections with the body mesh. Given intersections, itcalculates the centroid and the average distance between
each intersection and the centroid. It finally calculates themesh-surrounding radius of bone i as an average of theaverage distance at each sampled point z.

(a)Figure 5: Calculation of surrounding-mesh radius. Left: We
sample points (blue) along each bone (red) and emit rays tofind mesh intersections (green). Right: We then calculate thesurrounding-mesh radius as an average of averaged distancesfrom centroids (magenta) to intersections.

Our basic process of automatic super deformation is toshrink the target limbs and enlarge the target head so thatthe output model will have body proportion similar to thatof the reference model, while referring to the body-shapeparameters. For this, our method first modifies skeletonsbased on the body-shape parameters and then deforms themeshes of the target model using linear blend skinning.
1) Skeleton deformation: The target skeleton is deformedby shortening each bone recursively from the root joint.
Bones belonging to the same bone group undergo similar
shortening. Specifically, for each bone i in bone group Gb ,the same shortening coefficient αb (αb < 1) is applied:(1)

How to determine {αb } is explained in Section V-B3. Also,
the position of each joint j belonging to the child set of joint
child(i) is recursively updated:p′j = pj + ∆pchild(i) ,(2)∆pchild(i) = p′child(i) − pchild(i) .

(3)

As a special case, only the head bone is enlarged; byenlarging a head, limbs become relatively shorter thanthe head, and thus we do not have to shorten the limbs
excessively. Specifically, the head bone length is updated
using an enlarging coefficient αhead (αhead > 1) as follows:′lhead= αhead lhead ,(4)′where lhead and lhead
are the head bone lengths before andafter enlargement. In our experiments, we use αhead = 1.5.
2) Mesh deformation: We explain mesh deformation
driven by bone shortening. The vertex position after deformation is calculated according to the change in joint
positions:v′k = vk +

M
∑

(c)

Figure 6: (a) Original mesh as well as results of (b) boneshrinkage and (c) mesh thickness adjustment.

B. Automatic Super Deformationp′child(i) = pparent(i) + αb (pchild(i) − pparent(i) ).

(b)wki (λki ∆pparent(i) + µki ∆pchild(i) ) (5)i=1where vk and v′k are the positions of vertex k before andafter the transformation, and wki is the weight of bone i forvertex k. ∆pparent(i) and ∆pchild(i) are differences of joint

positions. λki and µki are the weights of joints parent(i)and child(i), and calculated as follows.
λki = 1 −∥proji (vk ) − pparent(i) ∥µki = 1 −∥pparent(i) − pchild(i) ∥∥proji (vk ) − pchild(i) ∥∥pparent(i) − pchild(i) ∥

,

(6)
(7)

where proji (vk ) is the foot of a perpendicular draw fromvertex position vk on the line segment of bone i. These two
equations indicate that the closer vertex k is to a joint, thegreater the influence of the joint is.
We adjust not only the length of each bone but also thethickness of the mesh around the bone. For each bone group
Gb , the vertex position of the mesh around bone i ∈ Gb ischanged as follows:∑v′k = vk +wki (proji (vk ) − vk )(1 − βb )
(8)
i∈Gb

where βb is the thickness coefficient assigned for bone group
Gb . How to determine {βb } is described in Section V-B3.
Figures 6b and 6c show the results of applying bone shortening and mesh thickness adjustment, respectively.
3) Automatic coefficient calculation: The coefficients{αb } and {βb } are calculated based on the body-parameters(Lref , Rref ) and (Ltar , Rtar ) as follows:
tar
l′tar
αhead lheadg = head
=
,
ref
ref
lhead
lhead

(9)

lref
αb = 1 + ηb (g itar − 1), i ∈ Gb ,
li

(10)

riref
− 1), i ∈ Gb .
ritar

(11)

βb = 1 + ϕb (gwhere g is the ratio of the enlarged target head length(Section V-B1) to the reference head length. ηb and ϕb arecoefficients for suppressing deformation; shortening bodyparts such as shoulder and hip yields an unnatural body
shape because such parts cannot be well approximated asa cylinder. Therefore, to suppress deformation of such parts,
we set ηshoulder = ηhip = 0.2 and ϕshoulder = ϕhip = 0.
For the rest parts, we set them to 1. For fingers and toes,
just shortening them makes the target parts similar to thereference ones, and thus we just set αf inger = αf oot = 0.5
and βf inger = βf oot = 1. The user can also adjust thecoefficients, although we use the default values withoutmanual adjustments in our experiments.

(a) f2, γ = 1(b) f2, γ = 0.5(c) original face(d) f4, γ = 2(e) f4, γ = 1(f) spherified face

VI. FACE I NFANTILIZATION
Here we try to make the target face younger like achild. Comparing faces of normal and SD models (see theexamples in Figure 1), we notice that the eye positions of
the SD model are lower than those of the normal model
while the chin of the SD model is more rounded. Our
method accomplishes both by applying a simple geometrictransformation to the head mesh. Our approach is inspiredby the biological theory by D’Arcy Thompson [2], whichclaims that a wide variety of body shapes of related species(e.g., crustacean, fishes or primate heads) can be well approximated by deforming one shape to another. Indeed, there
is an example movie [13] demonstrating infantilization ofcharacter’s face based on his theory, but the specific function
for the transformation is not disclosed. Note that D’Arcy
Thompson’s theory does not mention a specific choice oftransformation for each shape, and thus we have to design
deformation functions by ourselves.
We design our own deformation functions as follows. In
the bounding box of the head mesh, we set a normalized coordinate system where the upper vertical direction indicates+y direction and y ∈ [−0.5, 0.5]. We consider the following
two deformation functions:f2 (y) = γ (y 2 − 0.52 ) + y,

(12)

f4 (y) = γ (y − 0.5 ) + y,

(13)

4

4

where γ is a coefficient. Both two functions are designed
so that they squash the face only in the vertical direction,
and always satisfy f2 (−0.5) = f4 (−0.5) = −0.5 andf2 (0.5) = f4 (0.5) = 0.5 for any γ. Figure 7 shows acomparison. While both functions f2 (y) and f4 (y) can lower
the eye positions and make chins round, f2 (y) has too strong
effects (Figure 7(d) and (e)). The sphere approximation(Figure 7(f)), as done in [10], has only limited effects. We
thus use function f4 (y) with manually selected γ for eachmodel in our experiments.

Figure 7: Comparison of face transformations. (a)(b) Function f2 lowers eyes and rounds chins too much, while (f)sphere approximation has limited effects. We use function
f4 in our results.

VIII. R ESULTS
We implemented our prototype system on Blender andUnity3D using Python and C# as programming languages.
We use the SD model shown in Figure 1 as a reference
model in our experiments. The computation time both forcalculating body-shape parameters and automatic deformation is less than ten seconds. A single execution of theface transformation takes less than a second. When the user
repeats the face transformation until satisfied, it typicallycompletes within ten seconds. Figure 8 summarizes our
results. We can see the generated SD models look visuallypleasing with younger faces and stubby limbs.
Compared to the method by Shen et al. [10], their method
provides larger degrees of freedom to the user with much
more parameters than ours (i.e., only a single parameterin our face infantilization), which causes more trial-anderrors. Every time the user specifies any parameter(s), theiroptimization step takes time ranging from a few seconds
to more than ten seconds. Longer computation time in thetrial-and-error loop is not desirable because the user usuallyadds further manual editing as automatic process is often
insufficient; for example, Figure 7(f) demonstrates sphereapproximation similar to [10] does not work well.
IX. C ONCLUSION AND F UTURE W ORK

VII. D ETAILED ADJUSTMENT
After the process described so far, we have a SD versionof the target model. The user can further modify the target
model manually. For example, we shorten long hair meshes(Figure 8(b) and (f)) manually using the modeling software
3ds Max. In our experiments, we do not apply any othermanual editing unless otherwise noted.

In this paper, we have proposed a technique for semiautomatically generating a super-deformed (SD) model froma normal character model. We designed our method so thatit takes a reference SD model as input to learn body-shapeparameters for avoiding repetitive parameter tuning. Our
method automatically calculates the skeleton and weightmaps for a target model, while accounting for consistent

(a)

(e)

(b)

(c)

(f)

(d)

(g)

(h)

Figure 8: Our results. Using the SD model shown in Figure 1 as a reference model, our method generates SD models (b),(d), (f) and (h) from normal models (a), (c), (e) and (g).

deformation between body and cloth meshes. The target
model is then automatically super-deformed by transferring
the body-shape parameters from the reference model. The
target face becomes younger through a simple quartic transformation.
As future work, we would like to improve the appearanceof generated SD characters. For example, SD legs shouldhave less muscles with children’s skeleton structure, andgeometric as well as texture details should be suppressed,
while discriminative features of the character should be
exaggerated.
As a limitation, our method currently assumes that each ofreference and target models has a hole-free skin mesh and aseparated garment mesh so that we can measure body-shapeparameters and calculate weight maps, which is often not thecase with character models publicly available on the Internet.
Considering different methods for calculating weight maps isalso an interesting future direction. For example, the voxelbased method [14] is an option, but weight transfer (Section IV-B) would be required for separated skin and garment
meshes. Cage-based methods [15] would be beneficial tohandle separate meshes, if an automatic method [16] forgenerating cages is available.
R EFERENCES[1] “Super deformed,” https://en.wikipedia.org/wiki/Super
deformed, [Online; accessed 23-December-2016].
[2] D. W. Thompson, On growth and form. Cambridge University Press, 1945.
[3] N. Magnenat-Thalmann, R. Laperrière, and D. Thalmann,“Joint-dependent local deformations for hand animation andobject grasping,” in Proceedings on Graphics Interface ’88,
1988, pp. 26–33.
[4] L. Kavan, S. Collins, J. Žára, and C. O’Sullivan, “Geometricskinning with approximate dual quaternion blending,” ACM
Trans. Graph., vol. 27, no. 4, pp. 105:1–105:23, Nov. 2008.
[5] V. Blanz and T. Vetter, “A morphable model for the synthesisof 3D faces,” in Proceedings of the 26th Annual Conference
on Computer Graphics and Interactive Techniques, ser. SIGGRAPH ’99, 1999, pp. 187–194.

[6] B. Allen, B. Curless, and Z. Popović, “The space of humanbody shapes: reconstruction and parameterization from range
scans,” in ACM transactions on graphics (TOG), vol. 22,
no. 3. ACM, 2003, pp. 587–594.
[7] D. Anguelov, P. Srinivasan, D. Koller, S. Thrun, J. Rodgers,
and J. Davis, “SCAPE: Shape completion and animation ofpeople,” ACM Trans. Graph., vol. 24, no. 3, pp. 408–416, Jul.
2005.
[8] B. Reinert, T. Ritschel, and H.-P. Seidel, “Homunculus warping: Conveying importance using self-intersection-free nonhomogeneous mesh deformation,” Comput. Graph. Forum,
vol. 31, no. 7pt2, pp. 2165–2171, Sep. 2012.
[9] S. Saito, Z.-Y. Zhou, and L. Kavan, “Computational bodybuilding: Anatomically-based modeling of human bodies,”
ACM Trans. Graph., vol. 34, no. 4, pp. 41:1–41:12, Jul. 2015.
[10] L.-T. Shen, S.-J. Luo, C.-K. Huang, and B.-Y. Chen, “SD
models: Super-deformed character models,” Comput. Graph.
Forum, vol. 31, no. 7pt1, pp. 2067–2075, Sep. 2012.
[11] I. Baran and J. Popović, “Automatic rigging and animationof 3D characters,” in ACM Transactions on Graphics (TOG),
vol. 26, no. 3. ACM, 2007, p. 72.
[12] R. Lopez and C. Poirel, “Raycast based auto-rigging method
for humanoid meshes,” in ACM SIGGRAPH 2013 Posters.
ACM, 2013, p. 11.
[13] “D’Arcy Thompson’s transformation,” https://www.youtube.
com/watch?v=017Fa8Gs4bI, [Online; accessed 23-December2016].
[14] O. Dionne and M. de Lasa, “Geodesic voxel binding for
production character meshes,” in Proceedings of the 12th
ACM SIGGRAPH/Eurographics Symposium on Computer Animation, 2013, pp. 173–180.
[15] A. Jacobson, I. Baran, J. Popović, and O. Sorkine, “Boundedbiharmonic weights for real-time deformation,” ACM Trans.
Graph., vol. 30, no. 4, pp. 78:1–78:8, Jul. 2011.
[16] B. H. Le and Z. Deng, “Interactive cage generation for meshdeformation,” in Proceedings of the 21st ACM SIGGRAPH
Symposium on Interactive 3D Graphics and Games, 2017,
pp. 3:1–3:9.