Parametric Human Body Models

A parametric human body model is a function that maps a short vector of parameters to the surface of a human body: a polygon mesh with a fixed number of vertices and a fixed connectivity, in a chosen shape and a chosen pose. A few numbers describe who the person is (tall or short, heavy or slight) and a few dozen describe how their joints are bent; the model returns all the vertices. Because every output mesh has the same topology, vertex 1,000 is always the same place on the body, which makes such models a common language for capture, animation and estimation from images. The models in use today are learned from thousands of registered 3D scans. The best known is SMPL, the Skinned Multi-Person Linear model of Loper et al. (2015): a template mesh that is first sculpted by linear shape and pose corrections and then posed by standard linear blend skinning on a tree of joints. Its relatives model the hands (MANO), the face and head (FLAME) and the whole body with both (SMPL-X). In 3D human pose estimation these models turn the estimation of a skeleton into the estimation of a full surface, either by fitting the model to image evidence or by training a network to regress its parameters.

Definition

A parametric body model is a differentiable function $M(\boldsymbol\beta, \boldsymbol\theta) \to \mathbb{R}^{3N}$ from shape parameters $\boldsymbol\beta$ and pose parameters $\boldsymbol\theta$ to the coordinates of $N$ mesh vertices, with learned parameters that are fixed after training. Shape parameters are coefficients of a low-dimensional space of body shapes, usually learned by principal component analysis. Pose parameters are the rotations of the joints of a skeleton, each relative to its parent in a kinematic tree. The SMPL family adds further inputs where the body part needs them: facial expression coefficients in FLAME and SMPL-X, and dynamic soft-tissue coefficients in DMPL.

Intuition

Animation software has long posed characters by skinning: a mesh is attached to a skeleton, each vertex is given weights saying how strongly each bone pulls it, and when the bones rotate each vertex moves to a weighted average of where its bones would carry it. This is cheap and every graphics engine supports it. Its weakness is at the joints. Averaging positions instead of rotations makes a bent elbow lose volume on its inside, and a twisted limb pinches towards a line; in SMPL’s own example, linear blend skinning shrinks a neck that twists in either direction (Loper et al., 2015, §7). The SMPL paper counts the “taffy” and “bowtie” effects among the unrealistic deformations that linear blend skinning produces at joints (§1 and Fig. 2); the twist collapse is also known as the candy-wrapper artefact, a name the SMPL paper does not use. Animators fix such artefacts by hand with corrective shapes, sculpted offsets that are switched on in particular poses.

A learned body model automates both halves. From many people scanned in a standard pose it learns how bodies differ, as a mean shape plus a few principal directions of variation; from people scanned in many poses it learns the skinning weights, the joint positions and a set of corrective offsets that depend on pose. A new body is then made by adding shape offsets to the template, adding pose-dependent corrections, and skinning the result. SMPL’s central design choice is that the corrections are linear functions of the entries of the joints’ rotation matrices, so the whole model is a short sequence of matrix products that can be trained from data and run in an engine.

Formal Definition

The notation follows the SMPL paper (Loper et al., 2015, §3), whose definitions FLAME and SMPL-X reuse.

Linear blend skinning on a kinematic tree

The skeleton has $K$ joints with rest-pose locations $\mathbf{j}_1, \dots, \mathbf{j}_K$ and a parent for each joint; $A(k)$ is the ordered set of ancestors of joint $k$, from the root to $k$. A pose $\boldsymbol\theta = [\boldsymbol\omega_0^\top, \dots, \boldsymbol\omega_K^\top]^\top$ gives each part a rotation vector $\boldsymbol\omega_k \in \mathbb{R}^3$ relative to its parent, plus the root orientation. Each is converted to a matrix by the Rodrigues formula, described in rotation representations:

$$\exp(\boldsymbol\omega) = I + [\bar{\boldsymbol\omega}]_\times \sin\lVert\boldsymbol\omega\rVert + [\bar{\boldsymbol\omega}]_\times^2 \left(1 - \cos\lVert\boldsymbol\omega\rVert\right), \qquad \bar{\boldsymbol\omega} = \boldsymbol\omega / \lVert\boldsymbol\omega\rVert .$$

The authors’ copy of the SMPL paper prints the last factor of its Eq. (1) as $\cos\lVert\boldsymbol\omega\rVert$ rather than $1 - \cos\lVert\boldsymbol\omega\rVert$, which differs from the standard Rodrigues formula given above (the rotation representations article states it in the equivalent form that uses $\bar{\boldsymbol\omega}\bar{\boldsymbol\omega}^\top = I + [\bar{\boldsymbol\omega}]_\times^2$); with $\cos$ the matrix does not approach the identity as the angle goes to zero, so the printed form is a misprint. The world transformation of joint $k$ is the product of the local rigid transformations along its chain (Eq. 4),

$$G_k(\boldsymbol\theta, \mathbf{J}) = \prod_{j \in A(k)} \begin{bmatrix} \exp(\boldsymbol\omega_j) & \mathbf{j}_j \\ \mathbf{0}^\top & 1 \end{bmatrix},$$

where $\mathbf{j}_j$ is the location of joint $j$, as printed in the paper. Removing the rest-pose transformation, $G'_k = G_k(\boldsymbol\theta, \mathbf{J})\, G_k(\boldsymbol\theta^*, \mathbf{J})^{-1}$ (Eq. 3), gives the motion of part $k$ away from the rest pose $\boldsymbol\theta^*$. Linear blend skinning moves each rest vertex $\bar{\mathbf{t}}_i$, in homogeneous coordinates, by the weighted sum of these motions (Eq. 2):

$$\bar{\mathbf{t}}'_i = \sum_{k=1}^{K} w_{k,i}\, G'_k(\boldsymbol\theta, \mathbf{J})\, \bar{\mathbf{t}}_i .$$

The weights $w_{k,i}$ form the blend-weight matrix $\mathcal{W} \in \mathbb{R}^{N \times K}$; SMPL keeps it sparse, with at most four parts influencing a vertex, for compatibility with rendering engines. The sum of weighted rigid transformations is in general not rigid, which is the source of the artefacts above.

Shape blend shapes and the joint regressor

Body shape is a linear offset from the mean template $\bar{\mathbf{T}} \in \mathbb{R}^{3N}$ (Eq. 8):

$$B_S(\boldsymbol\beta; \mathcal{S}) = \sum_{n=1}^{|\boldsymbol\beta|} \beta_n \mathbf{S}_n ,$$

where the $\mathbf{S}_n$ are orthonormal principal components of vertex displacements. Since joint positions differ between people, SMPL predicts them from the shaped mesh with a learned linear regressor $\mathcal{J}$ (Eq. 10), $\mathbf{J}(\boldsymbol\beta) = \mathcal{J}(\bar{\mathbf{T}} + B_S(\boldsymbol\beta))$. SMPL learns $\mathcal{J}$ by non-negative least squares with a term that encourages each joint’s weights to sum to one, which encourages sparse weights and keeps each predicted joint in the convex hull of surface vertices, discouraging joints outside the surface (§4.1).

Pose blend shapes

Let $R(\boldsymbol\theta)$ be the vector of the $9K$ entries of the part-relative rotation matrices; with $K = 23$ the paper gives its length as $23 \times 9 = 207$, so, in our reading, the root orientation is not among them. The pose blend shapes are linear in the change of these entries from the rest pose (Eq. 9):

$$B_P(\boldsymbol\theta; \mathcal{P}) = \sum_{n=1}^{9K} \left( R_n(\boldsymbol\theta) - R_n(\boldsymbol\theta^*) \right) \mathbf{P}_n .$$

In a zero rest pose every rotation vector is zero, so by the Rodrigues formula $R(\boldsymbol\theta^*)$ is a vector of identity matrices and each feature is an entry of $\exp(\boldsymbol\omega_k) - I$. Subtracting the rest value makes the corrections vanish in the rest pose, which matters for animation (§3).

The full model

Shape and pose offsets are added in the rest pose, and the corrected template is skinned around the shape-dependent joints (Eqs. 5–6):

$$M(\boldsymbol\beta, \boldsymbol\theta) = W\!\left(T_P(\boldsymbol\beta, \boldsymbol\theta), \mathbf{J}(\boldsymbol\beta), \boldsymbol\theta, \mathcal{W}\right), \qquad T_P(\boldsymbol\beta, \boldsymbol\theta) = \bar{\mathbf{T}} + B_S(\boldsymbol\beta) + B_P(\boldsymbol\theta).$$

The learned parameters are $\Phi = \{\bar{\mathbf{T}}, \mathcal{W}, \mathcal{S}, \mathcal{J}, \mathcal{P}\}$. The skinning function $W$ can be linear or dual-quaternion blend skinning; the pose blend shapes are trained to correct whichever is used, and also absorb static soft-tissue deformation caused by pose (§3).

Properties

SMPL in numbers

SMPL starts from an artist-made mesh with $N = 6{,}890$ vertices and $K = 23$ joints, segmented by hand into 24 parts, with the same topology for men and women. A pose has $3 \times 23 + 3 = 72$ parameters, and there are $23 \times 9 = 207$ pose blend shapes (Loper et al., 2015, §3). The paper sums the skinning over $k = 1, \dots, K$ with $K = 23$ while the pose vector and part segmentation include the root as a 24th part.

Training from registrations

SMPL is trained on registrations, meshes of the template topology aligned to high-resolution scans. The pose parameters $\{\mathcal{J}, \mathcal{W}, \mathcal{P}\}$ are learned from a multi-pose dataset of 1,786 registrations of 40 people (891 of 20 women, 895 of 20 men); the shape space $\{\bar{\mathbf{T}}, \mathcal{S}\}$ from registrations to the CAESAR scans, 1,700 of men and 2,100 of women, with separate models for each sex (§4). The pose objective penalizes squared vertex distances between model and registrations, with regularizers that keep templates and joints left-right symmetric, keep each subject’s joints near an initial estimate taken from the part boundaries, pull the pose blend shapes towards zero and keep the weights near an initialization obtained by diffusing the part segmentation (Eq. 14). Before principal component analysis, every shape registration is pose-normalized: its pose is estimated and the mesh is unposed into the rest pose, without which pose variation would leak into the shape space (§4.2). The paper notes that its training subjects gave prior informed written consent for their data to be used in creating statistical models for distribution, and that the registered meshes and subjects shown in it are of professional models working under contract (§5).

Vertices against triangle deformations

SCAPE (Anguelov et al., 2005) and the models that followed it, as the SMPL paper describes them, represent shape and pose-dependent deformation as deformations of individual triangles, and reconstruct the vertices by solving a least-squares problem; SCAPE combines the shape and pose deformations multiplicatively (Loper et al., 2015, §2 and §7). SMPL instead adds offsets in vertex space. Its authors give three consequences: the model can be trained to minimize vertex error directly, which for triangle models would put a least-squares solve inside every optimization step; PCA is applied to vertices, which live in a Euclidean space, rather than to triangle deformations, which do not; and generating a mesh takes roughly six times fewer multiplications, since a SCAPE-style model has nine numbers per triangle and about twice as many triangles as vertices (§4.2, §5.4, §7). Trained on the same data with the same kinematic tree and number of shape parameters, SMPL fitted 120 held-out registrations of six people from the Dyna dataset more accurately than BlendSCAPE, a SCAPE variant, by differences on the order of 0.5 mm in mean absolute vertex distance (§5.1, Figs. 11–12).

Why rotation-matrix entries

The SMPL authors report that making pose blend shapes linear in the raw rotation vector $\boldsymbol\theta$, the obvious choice, does not work, and that polynomials and sines and cosines of $\boldsymbol\theta$ did not perform as well as the rotation-matrix entries (§7). Their example is a neck twist: linear blend skinning shrinks the neck whichever way it turns, so the correction must add volume for both positive and negative angles, which a function linear in the signed angle cannot do. The entries of a rotation matrix contain $\cos$ terms that are even in the angle, and they are bounded, so the corrections cannot grow without limit outside the training poses. The example below reproduces this argument on a synthetic limb.

Linear and dual-quaternion skinning

The paper trains both an LBS and a dual-quaternion version and calls SMPL-DQBS its default (§3). In its evaluation the two are essentially identical at fitting new people in new poses and SMPL-LBS is slightly better at fitting new poses of a known person, which the authors find surprising because the corrections have more to repair with LBS (§5.1). The SMPL website’s FAQ states that only the LBS version is distributed, as the more accurate and simpler one (as of November 2026).

Limitations stated by the authors

SMPL’s pose blend shapes do not depend on body shape, so the same corrections are applied to every body; the authors expect the approach to fail for spaces of characters whose part scales vary widely, or for a space spanning infants and adults. The model is a function of joint angles and shape only: it has no breathing, facial motion or muscle tension. The part segmentation, mesh topology and rest pose are set by hand (§7). DMPL, the dynamic extension in the same paper, adds soft-tissue blend shapes driven by joint velocities and accelerations and by body shape, learned from about 40,000 registrations of the Dyna data (§6).

The Model Family

SCAPE (Anguelov et al., 2005) is the triangle-deformation model that SMPL’s authors compare against and describe as the basis of the most successful earlier class of body models (Loper et al., 2015, §2); its paper could not be read for this article.

MANO and SMPL+H. MANO is a hand model by Romero, Tzionas and Black (2017). According to the SMPL-X paper, it follows the SMPL formulation and learns shape and pose spaces from 3D scans of 31 subjects in up to 51 poses; SMPL+H combines the SMPL body with this hand model, taking hand shape variation from full-body scans and pose-dependent deformation from hand scans, and has no deformable face (Pavlakos et al., 2019, §2). The MANO paper itself could not be read for this article.

FLAME (Li et al., 2017) applies the SMPL formulation to the head. It has $N = 5{,}023$ vertices and $K = 4$ joints (neck, jaw and the two eyeballs), and adds expression blend shapes $B_E(\boldsymbol\psi; \mathcal{E}) = \sum_n \psi_n \mathbf{E}_n$, offsets that are not driven by pose and have no counterpart in SMPL (§3). Its shape space is trained from 3,800 head scans, and its pose and expression from 4D face sequences, over 33,000 scans in total (abstract); the paper evaluates versions with 90 and 300 identity components and 100 expression components (§7.2).

SMPL-X (Pavlakos et al., 2019) unifies body, hands and face. It has $N = 10{,}475$ vertices and $K = 54$ joints, including the neck, jaw, eyeballs and fingers, and adds FLAME’s expression blend shapes to SMPL’s formulation, $T_P = \bar{\mathbf{T}} + B_S(\boldsymbol\beta) + B_E(\boldsymbol\psi) + B_P(\boldsymbol\theta)$. Its template matches the FLAME face and the MANO hands; the shape space is trained on 3,800 alignments in an A-pose and the body pose space on 1,786 alignments, while the hand pose space and correctives come from MANO and the expression space from FLAME. The 30 finger joints (90 pose parameters) are driven through a lower-dimensional PCA space, and the model has 119 parameters in all: 75 for the global rotation and the body, eye and jaw joints, 24 for the hands, 10 for shape and 10 for expression (§3.1).

The SMPL website also lists later models from the same group (STAR, SUPR and SKEL, as of November 2026), which are outside this article’s sources.

Estimating Body Models from Images

Estimation of body models from images is a part of 3D human pose estimation, which holds the benchmarks and protocols; this section gives the two strategies in outline.

Fitting. SMPLify (Bogo et al., 2016) detects 2D joints in an image with a CNN and then fits SMPL to them by minimizing

$$E(\boldsymbol\beta, \boldsymbol\theta) = E_J(\boldsymbol\beta, \boldsymbol\theta; K, J_{\text{est}}) + \lambda_\theta E_\theta(\boldsymbol\theta) + \lambda_a E_a(\boldsymbol\theta) + \lambda_{sp} E_{sp}(\boldsymbol\theta; \boldsymbol\beta) + \lambda_\beta E_\beta(\boldsymbol\beta),$$

where $E_J$ is a confidence-weighted, robust (Geman–McClure) distance between the projected model joints and the detections, $E_\theta$ a pose prior from a mixture of eight Gaussians fitted to about a million motion-capture poses, $E_a$ a penalty on elbows and knees bending the wrong way, $E_{sp}$ an interpenetration penalty computed on capsules (approximated by spheres) whose sizes are regressed from shape, and $E_\beta$ a shape prior (Eqs. 1–7). The camera’s focal length is assumed known; translation and orientation are initialized from the torso and the energy is minimized in stages, which takes less than a minute per image (§3.3). On Human3.6M (subjects S9 and S11, all 15 actions of trial 1 from the frontal camera, with the Procrustes similarity alignment of its HumanEva evaluation) it reported a mean 3D joint error of 82.3 mm (Table 3). SMPLify-X (Pavlakos et al., 2019) fits SMPL-X the same way to body, hand, foot and face keypoints, with a learned pose prior (VPoser, a variational autoencoder), a new interpenetration penalty and gender detection. On 100 curated pseudo-ground-truth images (the EHF set) it reported a mean vertex-to-vertex error of 52.9 mm after Procrustes alignment, rising to 56.4 mm with SMPLify’s mixture prior in place of VPoser (Tables 1–2). Fitting is a nonlinear least-squares problem of the kind that also underlies fitting with a differentiable renderer, whose article discusses a SMPL body fit through a renderer.

Regression. HMR (Kanazawa et al., 2018) trains a network to predict the parameters directly: a ResNet-50 encoder and an iterative regressor output an 85-dimensional vector: the relative rotations of SMPL’s 23 joints, the first 10 shape coefficients, a global rotation and a weak-perspective camera (translation and scale). It is trained with a 2D keypoint reprojection loss and with discriminators that judge whether the predicted parameters look like real bodies, and can add 3D supervision where paired data exist (§3). It runs in real time given a person’s bounding box; HMR’s own table lists 0.04 s per image against about a minute for SMPLify (Table 4). Its Human3.6M results, and those of later methods that combine the two strategies, are reported in the 3D human pose estimation article.

Fitting adapts to each image and to any keypoints available but needs an initialization and minutes of computation; regression is fast but limited by the paired data it learns from. Later systems combine the two; SPIN, described in the 3D human pose estimation article, initializes a SMPLify fit with a regressor’s estimate and trains the regressor on the improved fit.

Licences and Data Terms

The model files of the SMPL family are not open data. As of November 2026, the official websites state the following.

• SMPL. The website asks users to register and agree to the licence before downloading. The SMPL-Model License grants a personal, single-user, non-exclusive, non-transferable, free right to use the model for non-commercial scientific research, non-commercial education or non-commercial artistic projects; it prohibits any other use, in particular commercial use, prohibits pornographic use, and also prohibits using the model to train methods or neural networks “for commercial use of any kind”. The model may not be redistributed, except for one archive copy. Commercial licences are offered through Meshcapade.
• SMPL-Body. A separate licence covers SMPL-Body, a subset that excludes the shape blend shapes and the tools to create bodies with them and consists of a mesh, a skeleton rig, pose blend shapes and dynamic blend shapes. It is licensed under Creative Commons Attribution 4.0. The same page states that the SMPL-Model specification is defined in a granted US patent (US10395411B2) and in pending European and international applications.
• SMPL-X and MANO. Their licences follow the same non-commercial pattern and also prohibit military and surveillance uses, the creation of fake, libellous, misleading or defamatory content (except analyses in peer-reviewed research), and training networks for any of these uses. SMPL-X Body, the subset without shape blend shapes, is under Creative Commons Attribution 4.0.
• FLAME. All FLAME models except FLAME 2023 Open are under an academic, non-commercial licence of the same kind. The website announces the FLAME 2023 Open model under Creative Commons Attribution 4.0, which allows commercial use, with prohibitions on pornographic material and on fake, libellous, misleading or defamatory content; the licence page states that it applies only to that model.
• Code. The SMPLify licence, which covers the SMPLify software, is non-commercial. The SMPL licence covers the “Software/Data” distributed from the SMPL website and the SMPL-X licence the “Model & Software”, so, in our reading of these pages, the code distributed from the model websites falls under the same non-commercial terms.

These terms, not the mathematics, decide what a project may do with the learned models; the formulation itself can be implemented on any mesh, as the example below does.

Examples

The example builds the parts of the model that do not need SMPL’s data: linear blend skinning on a kinematic tree, its collapse under twist, and pose blend shapes fitted by least squares to scans. No body model files are used; the mesh, the rig and the scans are synthetic. The limb is a tube of radius 50 mm and length 600 mm along $+x$ (61 rings of 24 vertices, 1,464 vertices, all units in millimetres), with a root joint at the origin and an elbow at $x = 300$ mm whose parent is the root. The forearm’s blend weight rises smoothly from 0 at $x = 250$ to 1 at $x = 350$ mm and is 0.5 on the elbow ring. The root stays fixed; the elbow rotates by $R = R_z(\beta) R_x(\varphi)$ relative to its parent, a twist $\varphi$ about the bone axis followed by a bend $\beta$ about $z$, with right-handed angles. Skinning follows SMPL’s Eqs. 2–4 with the rest transformation removed; the code takes each joint’s local translation as its offset from its parent joint, which with the root at the origin equals the $\mathbf{j}_j$ printed in Eq. 4 for this two-joint chain.

The scans are generated by a rule chosen for this example, not taken from a paper: each vertex turns about the elbow by the fraction $w_1$ of the elbow rotation along the geodesic, $\mathbf{v}_i = \mathbf{j}_1 + \exp(w_{1,i} \log R)(\mathbf{t}_i - \mathbf{j}_1)$, which keeps every cross-section circular under twist. Training scans get Gaussian noise of 1 mm per coordinate; test scans are noise-free. Three models are compared: plain LBS, LBS with pose blend shapes linear in the rotation vector $\boldsymbol\theta = \log R$ (three features, the choice SMPL’s authors say does not work), and LBS with pose blend shapes linear in the entries of $R - I$ (nine features, SMPL’s Eq. 9). The blend shapes are fitted per vertex by least squares on the error after skinning, $\sum_j \lVert \mathbf{v}_{ij} - (A_{ij}(\mathbf{t}_i + P_i \mathbf{f}_j) + \mathbf{c}_{ij}) \rVert^2 + \lambda \lVert P_i \rVert^2$ with $\lambda = 10^{-3}$, where $A_{ij}\mathbf{t} + \mathbf{c}_{ij}$ is the skinning of vertex $i$ in pose $j$ and $\mathbf{f}_j$ the pose features; SMPL’s own training minimizes the same kind of posed-space vertex error, jointly with the weights and joints. Each model is trained on 400 poses with $|\varphi| < 120°$ and $0 \le \beta < 110°$, and tested on 200 new poses from the same range and 200 with $120° < |\varphi| < 160°$; seeds 0, 1 and 2 draw the poses and the noise. The error is the per-vertex Euclidean distance to the noise-free scan, the measure SMPL’s evaluation uses, as a mean over all vertices and poses and as a maximum. The second table measures the radius of the elbow ring for pure twists. The script uses NumPy 2.3.5 (Python 3.13) and takes from about 40 seconds to a few minutes, depending on the machine.

import numpy as np

# Synthetic two-bone "arm": a tube of radius 50 mm along +x, 600 mm long, 61 rings x 24 vertices.
R_TUBE, N_RING = 50.0, 24
xs = np.arange(0.0, 601.0, 10.0)
ang = 2 * np.pi * np.arange(N_RING) / N_RING
T = np.array([[x, R_TUBE * np.cos(a), R_TUBE * np.sin(a)] for x in xs for a in ang])  # rest template
ring_of = np.repeat(np.arange(len(xs)), N_RING)
JOINT_RING = 30                                    # the ring at x = 300 mm, where the elbow sits
J = np.array([[0.0, 0, 0], [300.0, 0, 0]])         # joints: root (upper arm) and elbow
parents = [-1, 0]                                  # kinematic tree: the elbow's parent is the root
s = np.clip((T[:, 0] - 250.0) / 100.0, 0, 1)
w1 = s * s * (3 - 2 * s)                           # smoothstep weight of the forearm, 0.5 at the elbow
W = np.stack([1 - w1, w1], 1)                      # blend weights, N x K

def hat(v):
    return np.array([[0, -v[2], v[1]], [v[2], 0, -v[0]], [-v[1], v[0], 0]])

def rodrigues(r):                                  # rotation vector -> matrix
    th = np.linalg.norm(r)
    if th < 1e-12:
        return np.eye(3)
    K = hat(r / th)
    return np.eye(3) + np.sin(th) * K + (1 - np.cos(th)) * K @ K

def log_rot(R):                                    # matrix -> rotation vector (angles below 180 deg)
    th = np.arccos(np.clip((np.trace(R) - 1) / 2, -1, 1))
    if th < 1e-12:
        return np.zeros(3)
    v = np.array([R[2, 1] - R[1, 2], R[0, 2] - R[2, 0], R[1, 0] - R[0, 1]])
    return th * v / (2 * np.sin(th))

def Rx(deg):
    c, s_ = np.cos(np.radians(deg)), np.sin(np.radians(deg))
    return np.array([[1, 0, 0], [0, c, -s_], [0, s_, c]])

def Rz(deg):
    c, s_ = np.cos(np.radians(deg)), np.sin(np.radians(deg))
    return np.array([[c, -s_, 0], [s_, c, 0], [0, 0, 1]])

def rel_transforms(rots):
    """G'_k = G_k(theta) G_k(theta*)^-1 (SMPL Eqs. 3-4), chained along the kinematic tree."""
    G = []
    for k, Rk in enumerate(rots):
        L = np.eye(4)
        L[:3, :3] = Rk
        L[:3, 3] = J[k] - (J[parents[k]] if parents[k] >= 0 else 0)
        G.append(L if parents[k] < 0 else G[parents[k]] @ L)
    out = np.array(G)
    out[:, :3, 3] -= np.einsum("kab,kb->ka", out[:, :3, :3], J)   # rest transform is a pure translation
    return out

def lbs_parts(R):
    """Linear blend skinning as v_i = A_i t_i + c_i for an elbow rotation R (root fixed)."""
    M = np.einsum("ik,kab->iab", W, rel_transforms([np.eye(3), R]))
    return M[:, :3, :3], M[:, :3, 3]

def features(R, kind):
    if kind == "rotvec":                           # linear in the rotation vector theta
        return log_rot(R)
    if kind == "rotmat":                           # linear in the elements of R - I (SMPL Eq. 9)
        return (R - np.eye(3)).ravel()
    return np.zeros(0)

def model(R, P, kind):
    A, c = lbs_parts(R)
    Tp = T if kind == "none" else T + np.einsum("iaf,f->ia", P, features(R, kind))  # blend shapes in rest pose
    return np.einsum("iab,ib->ia", A, Tp) + c

def ground_truth(R):
    """Synthetic scan: each vertex turns about the elbow by the fraction w1 of the rotation (geodesic blend)."""
    lr = log_rot(R)
    return np.array([J[1] + rodrigues(w * lr) @ (t - J[1]) for w, t in zip(w1, T)])

def fit(Rs, scans, kind, lam=1e-3):
    """Per-vertex least squares for the pose blend shapes P_i (3 x F), error measured in the posed space."""
    F, nv = len(features(np.eye(3), kind)), len(T)
    AtA, Atb = np.zeros((nv, 3 * F, 3 * F)), np.zeros((nv, 3 * F))
    for R, V in zip(Rs, scans):
        A, c = lbs_parts(R)
        resid = V - (np.einsum("iab,ib->ia", A, T) + c)
        B = np.einsum("iab,f->iabf", A, features(R, kind)).reshape(nv, 3, 3 * F)   # A_i P_i f = B_i vec(P_i)
        AtA += np.einsum("iak,ial->ikl", B, B)
        Atb += np.einsum("iak,ia->ik", B, resid)
    return np.linalg.solve(AtA + lam * np.eye(3 * F), Atb[..., None])[..., 0].reshape(nv, 3, F)

def poses(rng, n, beyond):
    mag = rng.uniform(120, 160, n) if beyond else rng.uniform(0, 120, n)
    phi = mag * rng.choice([-1, 1], n)             # twist about the bone axis, either direction
    beta = rng.uniform(0, 110, n)                  # bend about z
    return [Rz(b) @ Rx(p) for p, b in zip(phi, beta)]

def errors(Rs, P, kind):
    d = np.array([np.linalg.norm(model(R, P, kind) - ground_truth(R), axis=1) for R in Rs])
    return d.mean(), d.max()

def ring_radius(V):
    ring = V[ring_of == JOINT_RING]
    return np.linalg.norm(ring - ring.mean(0), axis=1).mean()

KINDS = {"none": "LBS only", "rotvec": "LBS + blend shapes linear in theta", "rotmat": "LBS + blend shapes linear in R - I"}
results = {}
for seed in [0, 1, 2]:
    rng = np.random.default_rng(seed)
    train = poses(rng, 400, beyond=False)
    scans = [ground_truth(R) + rng.normal(scale=1.0, size=T.shape) for R in train]   # 1 mm scan noise
    test_in, test_out = poses(rng, 200, beyond=False), poses(rng, 200, beyond=True)
    for kind in KINDS:
        P = fit(train, scans, kind) if kind != "none" else None
        results[seed, kind] = (errors(test_in, P, kind), errors(test_out, P, kind), P)

print("vertex error in mm against noise-free ground truth (mean / max over vertices and poses)")
print(f"{'model':36s} {'seed':>4s} {'|twist|<120 mean':>17s} {'max':>6s} {'120-160 mean':>13s} {'max':>6s}")
for kind, name in KINDS.items():
    for seed in [0, 1, 2]:
        (mi, xi), (mo, xo), _ = results[seed, kind]
        print(f"{name:36s} {seed:4d} {mi:17.3f} {xi:6.2f} {mo:13.3f} {xo:6.2f}")

print("\nradius of the elbow ring (mm), bend 0, models fitted with seed 0")
print(f"{'twist':>6s} {'scan':>6s} {'LBS':>6s} {'theta':>6s} {'R - I':>6s}")
for d in [-135, -90, -45, 0, 45, 90, 135]:
    R = Rx(d)
    row = [ring_radius(ground_truth(R))] + [ring_radius(model(R, results[0, k][2], k)) for k in KINDS]
    print(f"{d:6d} " + " ".join(f"{v:6.2f}" for v in row))

vertex error in mm against noise-free ground truth (mean / max over vertices and poses)
model                                seed  |twist|<120 mean    max  120-160 mean    max
LBS only                                0             1.043  34.79         2.743  44.04
LBS only                                1             1.030  33.08         2.766  43.93
LBS only                                2             1.065  34.76         2.759  44.32
LBS + blend shapes linear in theta      0             0.813  29.46         2.456  48.58
LBS + blend shapes linear in theta      1             0.783  28.50         2.524  47.32
LBS + blend shapes linear in theta      2             0.835  29.59         2.482  48.36
LBS + blend shapes linear in R - I      0             0.434  13.13         1.955  35.18
LBS + blend shapes linear in R - I      1             0.422  11.76         2.053  34.00
LBS + blend shapes linear in R - I      2             0.452  13.65         1.996  34.84

radius of the elbow ring (mm), bend 0, models fitted with seed 0
 twist   scan    LBS  theta  R - I
  -135  50.00  19.13  22.16  34.23
   -90  50.00  35.36  39.03  51.82
   -45  50.00  46.19  48.58  52.62
     0  50.00  50.00  50.00  50.00
    45  50.00  46.19  43.85  52.19
    90  50.00  35.36  31.79  51.36
   135  50.00  19.13  16.31  34.05

The ring table shows the collapse directly. Under LBS the elbow ring, where both bones have weight 0.5, shrinks to $r\,|\cos(\varphi/2)|$: 35.4 mm at 90° and 19.1 mm at 135°, the same for both directions of twist, because the vertex is moved to the average of two points on a circle that the twist has carried apart. The blend shapes linear in $\boldsymbol\theta$ make it worse in one direction and slightly better in the other: a correction proportional to the signed angle can only push the ring outwards for one sign of $\varphi$, which is the neck-twist argument of the SMPL paper reproduced on a tube. The blend shapes linear in $R - I$ hold the ring near 50 mm within the training range (51.4 to 52.6 mm at ±45° and ±90°) and in both directions, since the rotation-matrix entries include $\cos\varphi$, which is even in the angle. At ±135°, just outside the training range, they restore the ring only to about 34 mm. In our reading this follows from the construction: on the elbow ring the rest-pose offset that would undo the shrinkage grows like $r\,(1/\cos(\varphi/2) - 1)$, without bound as the twist approaches 180°, while any function linear in the entries of $R$ stays bounded, so the correction can match the need only over the range it was fitted on.

The error table shows the same pattern over random poses. The means are small because most of the 1,464 vertices lie outside the blending zone and move rigidly; the maxima show the joint. Within the training range the rotation-matrix blend shapes lower the mean error by a factor of about 2.4 and the maximum from about 33–35 mm to 12–14 mm over the three seeds, while the rotation-vector blend shapes recover only part of that. In our reading much of the remaining error is the limit of the model class: by the argument above, a linear function of nine matrix entries cannot represent the exact correction of this synthetic limb. Beyond the training range all models get worse; the rotation-matrix blend shapes still have the lowest mean and maximum, and the rotation-vector blend shapes have a larger maximum error than plain skinning. In our reading this matches SMPL’s authors’ argument: corrections linear in the angle keep growing with it outside the training poses, while those linear in the constrained matrix entries cannot “blow up” (§7). The ranking is the same for all three seeds.

Common Misconceptions

• “The pose parameters are the joint positions.” SMPL’s pose is a set of relative joint rotations; joint positions come from the shaped mesh through the joint regressor, so the same pose gives different joint positions on different bodies.
• “Pose blend shapes are a function of the joint angles.” They are linear in the entries of the rotation matrices, not in the angles; the SMPL authors report that the linear-in-angle version does not work, and the example shows why for a twist.
• “Shape and pose are separated automatically by PCA.” The separation depends on pose-normalizing every shape registration before PCA (Loper et al., 2015, §4.2).
• “SMPL’s corrections adapt to each body.” In SMPL the pose blend shapes are shared by all bodies; only DMPL’s dynamic blend shapes depend on shape (§6–§7).
• “The SMPL model is open source.” The formulation is published, but the learned model files are licensed for non-commercial research only, with registration; among the models named here, only the SMPL-Body and SMPL-X Body subsets and the FLAME 2023 Open model carry a Creative Commons licence (as of November 2026).
• “A body model gives a measured person.” A fitted model is the body in a learned space that best explains the evidence under the fitting priors. Because few images come with ground-truth 3D shape, SMPLify’s authors evaluated shape quantitatively only on synthetic bodies, where shape from noisy 2D joints was more accurate than guessing the mean shape, and more accurate with more joints (Bogo et al., 2016, §4.1).

Where It Is Used

• Human mesh recovery from images and video, by fitting (SMPLify, SMPLify-X) and by regression (HMR and its successors), as part of 3D human pose estimation built on 2D human pose estimation and keypoint detection of hands and faces.
• Dataset annotation. 3D Poses in the Wild obtains its ground truth by fitting SMPL to inertial sensors and video, as described in the 3D human pose estimation article.
• Animation and graphics. Because SMPL is a standard skinned mesh with blend shapes, it can be exported as an FBX file and animated in Maya, Unity, Blender and Unreal, with the pose blend shape weights computed by scripts (Loper et al., 2015, §5.5; SMPL website).
• Fitting by optimization through rendering, with a differentiable renderer comparing the model’s silhouettes or images with photographs, and more generally 3D reconstruction of people with a shape prior.
• Faces and hands. FLAME is the target of face reconstruction methods listed on its website (for example DECA, EMOCA and MICA), and the MANO website links hand datasets and methods built on MANO.