mannequin-x 0.0.1__tar.gz

mannequin_x-0.0.1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

mannequin_x-0.0.1/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: mannequin-x
+Version: 0.0.1
+Summary: Rigid, non-skinned mannequins driven directly by SMPL-X motion
+Author: Andrea Boscolo Camiletto
+Author-email: Andrea Boscolo Camiletto <abcamiletto@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Dist: jaxtyping>=0.2.28
+Requires-Dist: nanomanifold>=0.8.0
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: trimesh>=4.0.0
+Requires-Dist: viser>=0.2.0 ; extra == 'viser'
+Requires-Python: >=3.11
+Provides-Extra: viser
+Description-Content-Type: text/markdown
+
+# SMPL-X Mannequin
+
+A rigid mannequin driven directly by SMPL-X parameters — no skinning, no
+blend shapes. Every part, down to the fingers, is a rigid mesh owned by one
+SMPL-X joint; shape coefficients change bone lengths without changing part
+thickness. Numpy-only and fully standalone: the SMPL-X shape response is
+baked into a small bundled table, so neither `body-models` nor the SMPL-X
+model files are needed.
+
+```bash
+pip install mannequin-x
+```
+
+## Usage
+
+```python
+from mannequin import SmplxMannequin
+
+model = SmplxMannequin(lod=1)
+params = model.get_rest_pose()
+vertices = model.forward_vertices(**params)
+```
+
+`forward_vertices`, `forward_skeleton`, `forward_links`, and `forward_meshes`
+take SMPL-X parameters (axis-angle, optionally batched) and use the native
+SMPL-X origin: identical parameters place the pelvis and neutral foot surface
+in the same coordinates as SMPL-X. For repeated calls with the same betas,
+prepare the identity once with `prepare_identity` and pass it as `identity=`.
+
+## Viser
+
+Each link mesh is uploaded to the [viser](https://viser.studio) scene once,
+parented to its joint's frame; pose and shape updates only send the per-joint
+frame transforms (~10 KB per full pose).
+
+```python
+import viser
+from mannequin import SmplxMannequin, add_mannequin
+
+server = viser.ViserServer()
+model = SmplxMannequin(lod=1)
+handle = add_mannequin(server.scene, "/mannequin", model)
+handle.set_shape(betas)
+handle.set_pose(**model.get_apose())
+```
+
+`set_pose` accepts any subset of the SMPL-X pose parameters, and full
+per-frame parameter dicts work directly (`shape` is routed to `set_shape`,
+`expression` is ignored). Unchanged values are skipped.
+
+`add_mannequin` takes a `palette` — one of the built-in armor/joint pairs in
+`PALETTES` (`sand`, `ivory`, `charcoal`, `sage`, `clay`, `slate`; see
+[`renders/palettes.jpg`](renders/palettes.jpg)) or a custom
+`(armor, joint)` RGB pair.
+
+## Assets
+
+Three exactly mirrored levels of detail are bundled: `lod=0` (~40k vertices),
+`lod=1` (~15k), and `lod=2` (<5k). Lower-leg length is calibrated against the
+SMPL-X sole vertices, so shaped identities keep the same ground plane. The
+editable source is [`authoring/mannequin.blend`](authoring/mannequin.blend);
+the installed package ships only the compact numpy assets.

mannequin_x-0.0.1/README.md

@@ -0,0 +1,62 @@
+# SMPL-X Mannequin
+
+A rigid mannequin driven directly by SMPL-X parameters — no skinning, no
+blend shapes. Every part, down to the fingers, is a rigid mesh owned by one
+SMPL-X joint; shape coefficients change bone lengths without changing part
+thickness. Numpy-only and fully standalone: the SMPL-X shape response is
+baked into a small bundled table, so neither `body-models` nor the SMPL-X
+model files are needed.
+
+```bash
+pip install mannequin-x
+```
+
+## Usage
+
+```python
+from mannequin import SmplxMannequin
+
+model = SmplxMannequin(lod=1)
+params = model.get_rest_pose()
+vertices = model.forward_vertices(**params)
+```
+
+`forward_vertices`, `forward_skeleton`, `forward_links`, and `forward_meshes`
+take SMPL-X parameters (axis-angle, optionally batched) and use the native
+SMPL-X origin: identical parameters place the pelvis and neutral foot surface
+in the same coordinates as SMPL-X. For repeated calls with the same betas,
+prepare the identity once with `prepare_identity` and pass it as `identity=`.
+
+## Viser
+
+Each link mesh is uploaded to the [viser](https://viser.studio) scene once,
+parented to its joint's frame; pose and shape updates only send the per-joint
+frame transforms (~10 KB per full pose).
+
+```python
+import viser
+from mannequin import SmplxMannequin, add_mannequin
+
+server = viser.ViserServer()
+model = SmplxMannequin(lod=1)
+handle = add_mannequin(server.scene, "/mannequin", model)
+handle.set_shape(betas)
+handle.set_pose(**model.get_apose())
+```
+
+`set_pose` accepts any subset of the SMPL-X pose parameters, and full
+per-frame parameter dicts work directly (`shape` is routed to `set_shape`,
+`expression` is ignored). Unchanged values are skipped.
+
+`add_mannequin` takes a `palette` — one of the built-in armor/joint pairs in
+`PALETTES` (`sand`, `ivory`, `charcoal`, `sage`, `clay`, `slate`; see
+[`renders/palettes.jpg`](renders/palettes.jpg)) or a custom
+`(armor, joint)` RGB pair.
+
+## Assets
+
+Three exactly mirrored levels of detail are bundled: `lod=0` (~40k vertices),
+`lod=1` (~15k), and `lod=2` (<5k). Lower-leg length is calibrated against the
+SMPL-X sole vertices, so shaped identities keep the same ground plane. The
+editable source is [`authoring/mannequin.blend`](authoring/mannequin.blend);
+the installed package ships only the compact numpy assets.

mannequin_x-0.0.1/pyproject.toml

@@ -0,0 +1,52 @@
+[project]
+name = "mannequin-x"
+version = "0.0.1"
+description = "Rigid, non-skinned mannequins driven directly by SMPL-X motion"
+readme = "README.md"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+dependencies = [
+    "jaxtyping>=0.2.28",
+    "nanomanifold>=0.8.0",
+    "numpy>=2.0.0",
+    "trimesh>=4.0.0",
+]
+
+[[project.authors]]
+name = "Andrea Boscolo Camiletto"
+email = "abcamiletto@gmail.com"
+
+[project.optional-dependencies]
+viser = ["viser>=0.2.0"]
+
+[build-system]
+requires = ["uv_build>=0.11.11,<0.12.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "mannequin"
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+ignore = [
+    "F722",
+    "F821",
+    "UP037",
+]
+
+[tool.ty.src]
+exclude = [
+    "authoring/",
+    "tests/",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "ruff>=0.16.0",
+    "ty>=0.0.1a13",
+    "viser>=0.2.0",
+]

mannequin_x-0.0.1/pyproject.toml.orig

@@ -0,0 +1,44 @@
+[project]
+name = "mannequin-x"
+version = "0.0.1"
+description = "Rigid, non-skinned mannequins driven directly by SMPL-X motion"
+readme = "README.md"
+authors = [
+    { name = "Andrea Boscolo Camiletto", email = "abcamiletto@gmail.com" }
+]
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+dependencies = [
+    "jaxtyping>=0.2.28",
+    "nanomanifold>=0.8.0",
+    "numpy>=2.0.0",
+    "trimesh>=4.0.0",
+]
+
+[project.optional-dependencies]
+viser = ["viser>=0.2.0"]
+
+[build-system]
+requires = ["uv_build>=0.11.11,<0.12.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "mannequin"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "ruff>=0.16.0",
+    "ty>=0.0.1a13",
+    "viser>=0.2.0",
+]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+ignore = ["F722", "F821", "UP037"]
+
+[tool.ty.src]
+exclude = ["authoring/", "tests/"]

mannequin_x-0.0.1/src/mannequin/__init__.py

@@ -0,0 +1,6 @@
+"""Rigid, non-skinned mannequin driven directly by SMPL-X motion."""
+
+from mannequin._model import SmplxMannequin
+from mannequin._viser import PALETTES, ViserMannequinHandle, add_mannequin
+
+__all__ = ["PALETTES", "SmplxMannequin", "ViserMannequinHandle", "add_mannequin"]

mannequin_x-0.0.1/src/mannequin/_constants.py

@@ -0,0 +1,4 @@
+"""SMPL-X ordering constants."""
+
+# Mannequin body order as indices into SMPL-X's 23-joint body pose.
+SMPLX_BODY_ORDER = (0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11, 14, 12, 15, 17, 19, 21, 13, 16, 18, 20, 22)

mannequin_x-0.0.1/src/mannequin/_io.py

@@ -0,0 +1,83 @@
+"""Native mannequin asset loading."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib.resources import files
+from typing import Any
+
+import numpy as np
+from jaxtyping import Float, Int
+
+Array = Any
+
+
+@dataclass(frozen=True)
+class ShapeCalibration:
+    """Affine SMPL-X shape response baked in mannequin joint order.
+
+    Rest joints are exactly linear in the first ten SMPL-X betas, and the
+    shaped-body floor is the minimum over the (also linear) heights of the
+    neutral sole vertices, so this small table reproduces the SMPL-X model's
+    skeleton lengths and ground plane without the SMPL-X assets.
+    """
+
+    joint_rest: Float[Array, "J 3"]
+    joint_dirs: Float[Array, "J 3 10"]
+    sole_y_rest: Float[Array, "K"]
+    sole_y_dirs: Float[Array, "K 10"]
+    body_a_pose: Float[Array, "21 3"]
+    hand_flat: Float[Array, "30 3"]
+    hand_rest: Float[Array, "30 3"]
+
+
+def load_calibration(*, dtype=np.float64) -> ShapeCalibration:
+    """Load the baked SMPL-X shape calibration."""
+    resource = files("mannequin") / "assets" / "smplx_calibration.npz"
+    with resource.open("rb") as archive, np.load(archive, allow_pickle=False) as data:
+        return ShapeCalibration(**{key: data[key].astype(dtype) for key in data.files})
+
+
+@dataclass(frozen=True)
+class MannequinWeights:
+    joint_names: list[str]
+    parents: list[int]
+    local_offsets: Float[Array, "J 3"]
+    rest_local_rotations: Float[Array, "J 3 3"]
+    vertices: Float[Array, "V 3"]
+    faces: Int[Array, "F 3"]
+    link_joint_indices: list[int]
+    link_vertex_starts: list[int]
+    link_vertex_counts: list[int]
+    link_face_starts: list[int]
+    link_face_counts: list[int]
+    link_geom_positions: Float[Array, "L 3"]
+    link_geom_rotations: Float[Array, "L 3 3"]
+    link_names: list[str]
+    actuated_joint_indices: list[int]
+
+
+def load(lod: int = 0, *, dtype=np.float32) -> MannequinWeights:
+    """Load one bundled mannequin LOD."""
+    if lod not in (0, 1, 2):
+        raise ValueError(f"lod must be 0, 1, or 2; got {lod!r}")
+
+    resource = files("mannequin") / "assets" / f"lod{lod}.npz"
+    with resource.open("rb") as archive, np.load(archive, allow_pickle=False) as data:
+        return MannequinWeights(
+            joint_names=data["joint_names"].tolist(),
+            parents=data["parents"].tolist(),
+            local_offsets=data["local_offsets"].astype(dtype),
+            rest_local_rotations=data["rest_local_rotations"].astype(dtype),
+            vertices=data["vertices"].astype(dtype),
+            faces=data["faces"].astype(np.int64),
+            link_joint_indices=data["link_joint_indices"].tolist(),
+            link_vertex_starts=data["link_vertex_starts"].tolist(),
+            link_vertex_counts=data["link_vertex_counts"].tolist(),
+            link_face_starts=data["link_face_starts"].tolist(),
+            link_face_counts=data["link_face_counts"].tolist(),
+            link_geom_positions=data["link_geom_positions"].astype(dtype),
+            link_geom_rotations=data["link_geom_rotations"].astype(dtype),
+            link_names=data["link_names"].tolist(),
+            actuated_joint_indices=data["actuated_joint_indices"].tolist(),
+        )

mannequin_x-0.0.1/src/mannequin/_model.py

@@ -0,0 +1,289 @@
+"""Rigid SMPL-X mannequin model (numpy-only)."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from functools import cached_property
+from typing import Any, Literal
+
+import numpy as np
+from jaxtyping import Float, Int
+from nanomanifold import SO3
+from trimesh import Trimesh
+
+from mannequin import _constants as constants
+from mannequin import _io as io
+from mannequin import _rigid as rigid
+from mannequin import identity as identity_ops
+
+Array = Any
+MannequinLod = Literal[0, 1, 2]
+
+
+class SmplxMannequin:
+    """Rigid mannequin with SMPL-X pose and shape parameters.
+
+    Shape changes alter symmetric bone lengths and reposition rigid parts; they
+    never change link thickness or introduce skinning. All arrays are numpy.
+    """
+
+    NUM_BODY_JOINTS = 21
+    NUM_HAND_JOINTS = 30
+    NUM_HEAD_JOINTS = 3
+    NUM_SHAPE_COEFFS = 10
+    NUM_EXPR_COEFFS = 10
+
+    def __init__(self, *, lod: MannequinLod = 0) -> None:
+        self._weights = io.load(lod)
+        self._identity_template = identity_ops.build_template(self._weights)
+        self._calibration: io.ShapeCalibration | None = None
+
+    # ------------------------------------------------------------- structure
+    @property
+    def faces(self) -> Int[Array, "F 3"]:
+        return self._weights.faces
+
+    @property
+    def joint_names(self) -> list[str]:
+        return list(self._weights.joint_names)
+
+    @property
+    def parents(self) -> list[int]:
+        return list(self._weights.parents)
+
+    @property
+    def num_joints(self) -> int:
+        return len(self._weights.parents)
+
+    @property
+    def num_vertices(self) -> int:
+        return self._weights.vertices.shape[0]
+
+    @property
+    def link_names(self) -> list[str]:
+        return list(self._weights.link_names)
+
+    @cached_property
+    def link_meshes(self) -> Sequence[Trimesh]:
+        """Link-local meshes aligned with :attr:`link_names` and ``forward_links()``."""
+        return rigid.link_meshes(
+            self._weights.vertices,
+            self._weights.faces,
+            self._weights.link_vertex_starts,
+            self._weights.link_vertex_counts,
+            self._weights.link_face_starts,
+            self._weights.link_face_counts,
+        )
+
+    # --------------------------------------------------------------- forward
+    def prepare_identity(
+        self,
+        shape: Float[Array, "10"],
+        expression: Float[Array, "10"] | None = None,
+        *,
+        skip_vertices: bool = False,
+    ) -> identity_ops.SmplxMannequinIdentity:
+        """Prepare one reusable, length-only identity from an unbatched beta vector."""
+        del expression
+        shape_np = np.asarray(shape)
+        if np.any(shape_np) and self._calibration is None:
+            self._calibration = io.load_calibration()
+        return identity_ops.prepare(
+            self._weights,
+            self._identity_template,
+            self._calibration,
+            shape_np,
+            skip_vertices=skip_vertices,
+        )
+
+    def forward_skeleton(
+        self,
+        body_pose: Float[Array, "*batch 21 3"],
+        head_pose: Float[Array, "*batch 3 3"],
+        hand_pose: Float[Array, "*batch 30 3"],
+        *,
+        pelvis_rotation: Float[Array, "*batch 3"] | None = None,
+        shape: Float[Array, "10"] | None = None,
+        expression: Float[Array, "10"] | None = None,
+        identity: identity_ops.SmplxMannequinIdentity | None = None,
+        global_rotation: Float[Array, "*batch 3"] | None = None,
+        global_translation: Float[Array, "*batch 3"] | None = None,
+    ) -> Float[Array, "*batch J 4 4"]:
+        """Compute shape-adjusted mannequin joint transforms."""
+        identity = self._resolve_identity(identity, shape, expression, skip_vertices=True)
+        root_translation = identity["local_joint_offsets"][0]
+        if global_rotation is not None:
+            rotation = SO3.convert(global_rotation, src="axis_angle", dst="rotmat", xp=np)
+            root_translation = np.squeeze(rotation @ root_translation[..., None], axis=-1)
+        if global_translation is not None:
+            root_translation = root_translation + global_translation
+        if pelvis_rotation is not None:
+            if global_rotation is None:
+                global_rotation = pelvis_rotation
+            else:
+                global_rotation = SO3.convert(
+                    SO3.multiply(
+                        SO3.convert(global_rotation, src="axis_angle", dst="quat", xp=np),
+                        SO3.convert(pelvis_rotation, src="axis_angle", dst="quat", xp=np),
+                        xp=np,
+                    ),
+                    src="quat",
+                    dst="axis_angle",
+                    xp=np,
+                )
+        return rigid.forward_skeleton_from_local_rotations(
+            self._local_rotations_from_smplx(body_pose, hand_pose),
+            local_offsets=identity["local_joint_offsets"],
+            rest_local_rotations=self._weights.rest_local_rotations,
+            actuated_joint_indices=self._weights.actuated_joint_indices,
+            parents=self._weights.parents,
+            global_rotation=global_rotation,
+            global_translation=root_translation,
+        )
+
+    def forward_vertices(
+        self,
+        body_pose: Float[Array, "*batch 21 3"],
+        head_pose: Float[Array, "*batch 3 3"],
+        hand_pose: Float[Array, "*batch 30 3"],
+        *,
+        pelvis_rotation: Float[Array, "*batch 3"] | None = None,
+        shape: Float[Array, "10"] | None = None,
+        expression: Float[Array, "10"] | None = None,
+        identity: identity_ops.SmplxMannequinIdentity | None = None,
+        global_rotation: Float[Array, "*batch 3"] | None = None,
+        global_translation: Float[Array, "*batch 3"] | None = None,
+    ) -> Float[Array, "*batch V 3"]:
+        """Compute vertices for the shape-adjusted rigid parts."""
+        identity = self._resolve_identity(identity, shape, expression, skip_vertices=False)
+        skeleton = self.forward_skeleton(
+            body_pose,
+            head_pose,
+            hand_pose,
+            pelvis_rotation=pelvis_rotation,
+            identity=identity,
+            global_rotation=global_rotation,
+            global_translation=global_translation,
+        )
+        return self._vertices_from_skeleton(skeleton, identity["link_local_vertices"])
+
+    def forward_links(self, *args: Any, **kwargs: Any) -> Float[Array, "*batch L 4 4"]:
+        """Compute link transforms from SMPL-X parameters."""
+        skeleton = self.forward_skeleton(*args, **kwargs)
+        return rigid.forward_link_transforms(
+            skeleton,
+            self._weights.link_joint_indices,
+            self._weights.link_geom_positions,
+            self._weights.link_geom_rotations,
+        )
+
+    def forward_meshes(self, *args: Any, **kwargs: Any) -> list[Trimesh]:
+        """Build one posed mannequin mesh per batch element."""
+        vertices = np.asarray(self.forward_vertices(*args, **kwargs))
+        if vertices.ndim == 2:
+            vertices = vertices[None]
+        vertices = vertices.reshape(-1, vertices.shape[-2], 3)
+        return [Trimesh(vertices=item, faces=self.faces, process=False) for item in vertices]
+
+    # ----------------------------------------------------------------- poses
+    def get_rest_pose(
+        self,
+        *,
+        batch_dims: tuple[int, ...] = (),
+        dtype: Any | None = None,
+        hands: Literal["default", "flat", "rest"] = "default",
+    ) -> dict[str, Float[Array, "..."]]:
+        """Return the SMPL-X rest pose with configurable hand means."""
+        if hands not in ("default", "flat", "rest"):
+            raise ValueError(f"Invalid hands: {hands!r}")
+        dtype = np.float32 if dtype is None else dtype
+        shapes = {
+            "shape": (self.NUM_SHAPE_COEFFS,),
+            "expression": (self.NUM_EXPR_COEFFS,),
+            "body_pose": (self.NUM_BODY_JOINTS, 3),
+            "head_pose": (self.NUM_HEAD_JOINTS, 3),
+            "hand_pose": (self.NUM_HAND_JOINTS, 3),
+            "pelvis_rotation": (3,),
+            "global_rotation": (3,),
+            "global_translation": (3,),
+        }
+        params = {name: np.zeros((*batch_dims, *shape), dtype=dtype) for name, shape in shapes.items()}
+        if hands != "default":
+            hand_pose = np.asarray(getattr(self._load_calibration(), f"hand_{hands}"), dtype=dtype)
+            params["hand_pose"] = np.broadcast_to(hand_pose, (*batch_dims, *hand_pose.shape)).copy()
+        return params
+
+    def get_apose(
+        self,
+        *,
+        batch_dims: tuple[int, ...] = (),
+        dtype: Any | None = None,
+        hands: Literal["default", "flat", "rest"] = "default",
+    ) -> dict[str, Float[Array, "..."]]:
+        """Return the SMPL-X A-pose."""
+        params = self.get_rest_pose(batch_dims=batch_dims, dtype=dtype, hands=hands)
+        body_pose = np.asarray(self._load_calibration().body_a_pose, dtype=params["body_pose"].dtype)
+        params["body_pose"] = np.broadcast_to(body_pose, (*batch_dims, *body_pose.shape)).copy()
+        return params
+
+    # -------------------------------------------------------------- internals
+    def _load_calibration(self) -> io.ShapeCalibration:
+        if self._calibration is None:
+            self._calibration = io.load_calibration()
+        return self._calibration
+
+    def _local_rotations_from_smplx(
+        self,
+        body_pose: Float[Array, "*batch 21 3"],
+        hand_pose: Float[Array, "*batch 30 3"],
+    ) -> Float[Array, "*batch Q 3 3"]:
+        if body_pose.shape[-2:] != (self.NUM_BODY_JOINTS, 3):
+            raise ValueError(f"body_pose must have shape [..., 21, 3], got {tuple(body_pose.shape)}")
+        if hand_pose.shape[-2:] != (self.NUM_HAND_JOINTS, 3):
+            raise ValueError(f"hand_pose must have shape [..., 30, 3], got {tuple(hand_pose.shape)}")
+        padding = np.zeros((*body_pose.shape[:-2], 2, 3), dtype=body_pose.dtype)
+        padded_body_pose = np.concatenate((body_pose, padding), axis=-2)
+        ordered_body_pose = np.stack(
+            [padded_body_pose[..., index, :] for index in constants.SMPLX_BODY_ORDER],
+            axis=-2,
+        )
+        axis_angle = np.concatenate((ordered_body_pose, hand_pose), axis=-2)
+        return SO3.convert(axis_angle, src="axis_angle", dst="rotmat", xp=np)
+
+    def _resolve_identity(
+        self,
+        identity: identity_ops.SmplxMannequinIdentity | None,
+        shape: Float[Array, "10"] | None,
+        expression: Float[Array, "10"] | None,
+        *,
+        skip_vertices: bool,
+    ) -> identity_ops.SmplxMannequinIdentity:
+        if identity is not None:
+            conflicts = [name for name, value in (("shape", shape), ("expression", expression)) if value is not None]
+            if conflicts:
+                raise ValueError(f"identity cannot be combined with raw identity parameters: {', '.join(conflicts)}")
+            return identity
+        if shape is None:
+            shape = np.zeros((self.NUM_SHAPE_COEFFS,), dtype=self._weights.vertices.dtype)
+        return self.prepare_identity(shape, expression, skip_vertices=skip_vertices)
+
+    def _vertices_from_skeleton(
+        self,
+        skeleton: Float[Array, "*batch J 4 4"],
+        local_vertices: Float[Array, "V 3"],
+    ) -> Float[Array, "*batch V 3"]:
+        parts = []
+        for owner, start, count in zip(
+            self._weights.link_joint_indices,
+            self._weights.link_vertex_starts,
+            self._weights.link_vertex_counts,
+            strict=True,
+        ):
+            rotation = skeleton[..., owner, :3, :3]
+            translation = skeleton[..., owner, :3, 3]
+            local = local_vertices[start : start + count]
+            parts.append(np.squeeze(rotation[..., None, :, :] @ local[..., None], axis=-1) + translation[..., None, :])
+        return np.concatenate(parts, axis=-2)
+
+
+__all__ = ["SmplxMannequin"]

mannequin_x-0.0.1/src/mannequin/_rigid.py

@@ -0,0 +1,108 @@
+"""Numpy forward kinematics for the rigid mannequin."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from jaxtyping import Float, Int
+from nanomanifold import SO3
+from trimesh import Trimesh
+
+Array = Any
+
+
+def affine_transforms(
+    rotations: Float[Array, "... 3 3"],
+    translations: Float[Array, "... 3"],
+) -> Float[Array, "... 4 4"]:
+    """Assemble 4x4 transforms from rotations and translations."""
+    batch = np.broadcast_shapes(rotations.shape[:-2], translations.shape[:-1])
+    out = np.zeros((*batch, 4, 4), dtype=rotations.dtype)
+    out[..., :3, :3] = rotations
+    out[..., :3, 3] = translations
+    out[..., 3, 3] = 1.0
+    return out
+
+
+def forward_skeleton_from_local_rotations(
+    body_rotations: Float[Array, "... Q 3 3"],
+    *,
+    local_offsets: Float[Array, "J 3"],
+    rest_local_rotations: Float[Array, "J 3 3"],
+    actuated_joint_indices: list[int],
+    parents: list[int],
+    global_translation: Float[Array, "... 3"] | None = None,
+    global_rotation: Float[Array, "... 3"] | None = None,
+) -> Float[Array, "... J 4 4"]:
+    """Compute rigid hierarchy transforms from local actuated joint rotations."""
+    batch_shape = tuple(body_rotations.shape[:-3])
+    dtype = body_rotations.dtype
+    num_joints = len(parents)
+
+    local_rot = np.broadcast_to(np.eye(3, dtype=dtype), (*batch_shape, num_joints, 3, 3)).copy()
+    local_rot[..., actuated_joint_indices, :, :] = body_rotations
+    local_rot = np.asarray(rest_local_rotations, dtype=dtype) @ local_rot
+    local_t = np.asarray(local_offsets, dtype=dtype)
+
+    rot_world: list[Any] = [None] * num_joints
+    pos_world: list[Any] = [None] * num_joints
+    rot_world[0] = local_rot[..., 0, :, :]
+    pos_world[0] = np.zeros((*batch_shape, 3), dtype=dtype)
+    for joint in range(1, num_joints):
+        parent = parents[joint]
+        rot_world[joint] = rot_world[parent] @ local_rot[..., joint, :, :]
+        pos_world[joint] = pos_world[parent] + np.squeeze(rot_world[parent] @ local_t[joint][..., None], axis=-1)
+
+    rot = np.stack(rot_world, axis=-3)
+    trans = np.stack(pos_world, axis=-2)
+    if global_rotation is not None:
+        global_rot = SO3.convert(global_rotation, src="axis_angle", dst="rotmat", xp=np)
+        rot = global_rot[..., None, :, :] @ rot
+        trans = np.squeeze(global_rot[..., None, :, :] @ trans[..., None], axis=-1)
+    if global_translation is not None:
+        trans = trans + global_translation[..., None, :]
+
+    return affine_transforms(rot, trans)
+
+
+def forward_link_transforms(
+    skeleton: Float[Array, "... J 4 4"],
+    link_joint_indices: list[int],
+    link_geom_positions: Float[Array, "L 3"],
+    link_geom_rotations: Float[Array, "L 3 3"],
+) -> Float[Array, "... L 4 4"]:
+    """Apply each link's local geom transform to its parent joint transform."""
+    indices = list(link_joint_indices)
+    joint_rot = skeleton[..., indices, :3, :3]
+    joint_pos = skeleton[..., indices, :3, 3]
+    geom_pos = np.asarray(link_geom_positions, dtype=skeleton.dtype)
+    geom_rot = np.asarray(link_geom_rotations, dtype=skeleton.dtype)
+    rot = joint_rot @ geom_rot
+    trans = joint_pos + np.squeeze(joint_rot @ geom_pos[..., None], axis=-1)
+    return affine_transforms(rot, trans)
+
+
+def link_meshes(
+    vertices: Float[Array, "V 3"],
+    faces: Int[Array, "F 3"],
+    link_vertex_starts: list[int],
+    link_vertex_counts: list[int],
+    link_face_starts: list[int],
+    link_face_counts: list[int],
+) -> list[Trimesh]:
+    """Build one link-local mesh per packed geometry range."""
+    vertices = np.asarray(vertices)
+    faces = np.asarray(faces)
+    meshes = []
+    for vertex_start, vertex_count, face_start, face_count in zip(
+        link_vertex_starts,
+        link_vertex_counts,
+        link_face_starts,
+        link_face_counts,
+        strict=True,
+    ):
+        link_vertices = vertices[vertex_start : vertex_start + vertex_count]
+        link_faces = faces[face_start : face_start + face_count] - vertex_start
+        meshes.append(Trimesh(vertices=link_vertices, faces=link_faces, process=False))
+    return meshes

mannequin_x-0.0.1/src/mannequin/_viser.py

@@ -0,0 +1,195 @@
+"""Viser integration for the rigid mannequin.
+
+The mannequin has no skinning, so geometry is uploaded to the scene exactly
+once: each link mesh sits under its owning joint's frame with a static local
+offset, and pose updates only move the per-joint frame transforms (two
+messages per joint instead of two per mesh, so a full pose fits in a single
+viser message window).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+from jaxtyping import Float
+from nanomanifold import SO3
+
+from mannequin._model import SmplxMannequin
+
+if TYPE_CHECKING:
+    import viser
+
+Array = Any
+
+Color = tuple[int, int, int]
+
+PALETTES: dict[str, tuple[Color, Color]] = {
+    "sand": ((196, 163, 112), (143, 107, 66)),
+    "ivory": ((236, 231, 221), (139, 131, 120)),
+    "charcoal": ((70, 72, 77), (176, 180, 187)),
+    "sage": ((168, 181, 157), (98, 113, 90)),
+    "clay": ((198, 124, 92), (117, 69, 49)),
+    "slate": ((128, 146, 167), (69, 82, 99)),
+}
+"""Predefined (armor, joint) RGB pairs for :func:`add_mannequin`."""
+
+
+class ViserMannequinHandle:
+    """Mannequin added to a viser scene as static meshes under per-joint frames.
+
+    ``set_pose`` accepts the same parameter names as ``SmplxMannequin`` forward
+    calls (so ``handle.set_pose(**params)`` works with full SMPL-X parameter
+    dicts); ``shape`` entries are routed to :meth:`set_shape` and
+    ``expression`` is ignored. Unchanged values are skipped, and meshes are
+    never re-uploaded.
+    """
+
+    def __init__(
+        self,
+        model: SmplxMannequin,
+        pose: dict[str, Float[np.ndarray, "..."]],
+        root_frame: viser.FrameHandle,
+        frames: list[viser.FrameHandle],
+        frame_joints: list[int],
+        links: list[viser.MeshHandle],
+    ) -> None:
+        self._model = model
+        self._pose = pose
+        self._root_frame = root_frame
+        self._frames = frames
+        self._frame_joints = frame_joints
+        self._links = links
+        self._shape = np.zeros(model.NUM_SHAPE_COEFFS, dtype=np.float32)
+        self._identity = model.prepare_identity(self._shape, skip_vertices=True)
+
+    @property
+    def name(self) -> str:
+        return self._root_frame.name
+
+    @property
+    def visible(self) -> bool:
+        return self._root_frame.visible
+
+    @visible.setter
+    def visible(self, value: bool) -> None:
+        self._root_frame.visible = value
+
+    @property
+    def shape(self) -> Float[np.ndarray, "10"]:
+        return self._shape.copy()
+
+    def set_shape(self, shape: Float[Array, "10"]) -> None:
+        """Update the SMPL-X betas; bone lengths are re-solved, meshes stay."""
+        if self._update_shape(shape):
+            self._apply_pose()
+
+    def get_pose(self) -> dict[str, Float[np.ndarray, "..."]]:
+        """Return a copy of the currently applied pose parameters."""
+        return {name: value.copy() for name, value in self._pose.items()}
+
+    def set_pose(self, **params: Float[Array, "..."]) -> None:
+        """Update any subset of the SMPL-X parameters and move the link meshes."""
+        changed = False
+        for name, value in params.items():
+            if name == "expression":
+                continue
+            if name == "shape":
+                changed |= self._update_shape(value)
+                continue
+            if name not in self._pose:
+                raise KeyError(f"Unknown parameter {name!r}; expected one of {sorted(self._pose)}")
+            value = np.asarray(value, dtype=self._pose[name].dtype)
+            if value.shape != self._pose[name].shape:
+                raise ValueError(
+                    f"{name} must be unbatched with shape {self._pose[name].shape}, got {tuple(value.shape)}"
+                )
+            if np.array_equal(self._pose[name], value):
+                continue
+            self._pose[name] = value
+            changed = True
+        if changed:
+            self._apply_pose()
+
+    def remove(self) -> None:
+        """Remove the mannequin from the scene."""
+        for handle in (*self._links, *self._frames, self._root_frame):
+            handle.remove()
+
+    def _update_shape(self, shape: Float[Array, "10"]) -> bool:
+        shape = np.asarray(shape, dtype=self._shape.dtype)
+        if shape.shape != self._shape.shape:
+            raise ValueError(f"shape must be unbatched with shape {self._shape.shape}, got {tuple(shape.shape)}")
+        if np.array_equal(self._shape, shape):
+            return False
+        self._shape = shape
+        self._identity = self._model.prepare_identity(shape, skip_vertices=True)
+        return True
+
+    def _apply_pose(self) -> None:
+        skeleton = np.asarray(
+            self._model.forward_skeleton(
+                self._pose["body_pose"],
+                self._pose["head_pose"],
+                self._pose["hand_pose"],
+                pelvis_rotation=self._pose["pelvis_rotation"],
+                identity=self._identity,
+                global_rotation=self._pose["global_rotation"],
+                global_translation=self._pose["global_translation"],
+            )
+        )[self._frame_joints]
+        wxyzs = SO3.conversions.from_rotmat_to_quat(skeleton[:, :3, :3], convention="wxyz", xp=np)
+        positions = skeleton[:, :3, 3]
+        for frame, wxyz, position in zip(self._frames, wxyzs, positions, strict=True):
+            frame.wxyz = wxyz
+            frame.position = position
+
+
+def add_mannequin(
+    scene: viser.SceneApi,
+    name: str,
+    model: SmplxMannequin,
+    *,
+    palette: str | tuple[Color, Color] = "sand",
+    flat_shading: bool = True,
+) -> ViserMannequinHandle:
+    """Add a mannequin to a viser scene and return a handle for posing it.
+
+    ``palette`` is either a name from :data:`PALETTES` or a custom
+    ``(armor, joint)`` RGB pair.
+    """
+    if isinstance(palette, str):
+        if palette not in PALETTES:
+            raise ValueError(f"Unknown palette {palette!r}; available: {sorted(PALETTES)}")
+        palette = PALETTES[palette]
+    armor_color, joint_color = palette
+
+    pose = model.get_rest_pose()
+    del pose["shape"], pose["expression"]
+    weights = model._weights
+
+    root_frame = scene.add_frame(name, show_axes=False)
+    frame_joints = sorted(set(weights.link_joint_indices))
+    frames = [scene.add_frame(f"{name}/{weights.joint_names[joint]}", show_axes=False) for joint in frame_joints]
+
+    links = []
+    for link, (link_name, mesh) in enumerate(zip(model.link_names, model.link_meshes, strict=True)):
+        part = link_name.split("__")[1]
+        joint_name = weights.joint_names[weights.link_joint_indices[link]]
+        links.append(
+            scene.add_mesh_simple(
+                f"{name}/{joint_name}/{part}",
+                vertices=np.asarray(mesh.vertices, dtype=np.float32),
+                faces=np.asarray(mesh.faces),
+                color=joint_color if "__joint_" in link_name else armor_color,
+                flat_shading=flat_shading,
+                wxyz=SO3.conversions.from_rotmat_to_quat(weights.link_geom_rotations[link], convention="wxyz", xp=np),
+                position=weights.link_geom_positions[link],
+            )
+        )
+    handle = ViserMannequinHandle(model, pose, root_frame, frames, frame_joints, links)
+    handle._apply_pose()
+    return handle
+
+
+__all__ = ["PALETTES", "ViserMannequinHandle", "add_mannequin"]

mannequin_x-0.0.1/src/mannequin/identity.py

@@ -0,0 +1,199 @@
+"""Shape-dependent identities for the rigid SMPL-X mannequin."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, NotRequired, TypedDict
+
+import numpy as np
+from jaxtyping import Float
+
+from mannequin import _io as io
+
+Array = Any
+
+
+class SmplxMannequinIdentity(TypedDict):
+    """Skeleton and rigid geometry prepared once for one beta vector."""
+
+    rest_joints: Float[Array, "J 3"]
+    local_joint_offsets: Float[Array, "J 3"]
+    rest_vertices: NotRequired[Float[Array, "V 3"]]
+    link_local_vertices: NotRequired[Float[Array, "V 3"]]
+
+
+@dataclass(frozen=True)
+class IdentityTemplate:
+    local_offsets: np.ndarray
+    rest_joints: np.ndarray
+    link_local_vertices: np.ndarray
+    joint_geom_anchors: tuple[int, ...]
+
+
+def build_template(weights: io.MannequinWeights) -> IdentityTemplate:
+    """Convert the neutral asset geometry into its owning joints' frames."""
+    rest_joints = _joints_from_offsets(weights.local_offsets, weights.parents)
+    local_vertices = np.empty_like(weights.vertices)
+    anchors = list(weights.link_joint_indices)
+
+    for link, (start, count) in enumerate(zip(weights.link_vertex_starts, weights.link_vertex_counts, strict=True)):
+        vertices = weights.vertices[start : start + count]
+        rotation = weights.link_geom_rotations[link]
+        position = weights.link_geom_positions[link]
+        local_vertices[start : start + count] = vertices @ rotation.T + position
+
+        name = weights.link_names[link]
+        if "shoulder_ball_L" in name:
+            anchors[link] = weights.joint_names.index("L_Shoulder")
+        elif "shoulder_ball_R" in name:
+            anchors[link] = weights.joint_names.index("R_Shoulder")
+
+    return IdentityTemplate(
+        local_offsets=np.asarray(weights.local_offsets),
+        rest_joints=rest_joints,
+        link_local_vertices=local_vertices,
+        joint_geom_anchors=tuple(anchors),
+    )
+
+
+def prepare(
+    weights: io.MannequinWeights,
+    template: IdentityTemplate,
+    calibration: io.ShapeCalibration | None,
+    shape: np.ndarray,
+    *,
+    skip_vertices: bool,
+) -> SmplxMannequinIdentity:
+    """Prepare a symmetric, length-only identity from one SMPL-X beta vector."""
+    shape = np.asarray(shape)
+    if shape.ndim != 1:
+        raise ValueError(f"shape must have shape [S], got {shape.shape}.")
+
+    local_offsets = template.local_offsets.copy()
+    if np.any(shape):
+        if calibration is None:
+            calibration = io.load_calibration()
+        shaped_joints = (calibration.joint_rest + calibration.joint_dirs @ shape).astype(local_offsets.dtype)
+        measured_offsets = _offsets_from_joints(shaped_joints, weights.parents)
+        local_offsets = _symmetric_length_offsets(template.local_offsets, measured_offsets, weights.joint_names)
+        rest_joints = _joints_from_offsets(local_offsets, weights.parents)
+        _, mannequin_vertices = _shape_vertices(weights, template, local_offsets, rest_joints)
+        smplx_floor = (calibration.sole_y_rest + calibration.sole_y_dirs @ shape).min()
+        floor_correction = smplx_floor - mannequin_vertices[:, 1].min()
+        ankle_indices = [weights.joint_names.index(name) for name in ("L_Ankle", "R_Ankle")]
+        local_offsets[ankle_indices, 1] += floor_correction
+
+    rest_joints = _joints_from_offsets(local_offsets, weights.parents)
+    identity: SmplxMannequinIdentity = {
+        "rest_joints": rest_joints,
+        "local_joint_offsets": local_offsets,
+    }
+    if skip_vertices:
+        return identity
+
+    local_vertices, rest_vertices = _shape_vertices(weights, template, local_offsets, rest_joints)
+    identity["link_local_vertices"] = local_vertices
+    identity["rest_vertices"] = rest_vertices
+    return identity
+
+
+def _offsets_from_joints(joints: np.ndarray, parents: list[int]) -> np.ndarray:
+    offsets = np.zeros_like(joints)
+    offsets[0] = joints[0]
+    for joint in range(1, len(parents)):
+        offsets[joint] = joints[joint] - joints[parents[joint]]
+    return offsets
+
+
+def _symmetric_length_offsets(
+    neutral_offsets: np.ndarray,
+    measured_offsets: np.ndarray,
+    joint_names: list[str],
+) -> np.ndarray:
+    result = neutral_offsets.copy()
+    result[0] = measured_offsets[0]
+    indices = {name: index for index, name in enumerate(joint_names)}
+    paired = set()
+    reflection = np.array((-1.0, 1.0, 1.0), dtype=result.dtype)
+
+    for name, left in indices.items():
+        if not name.startswith("L_"):
+            continue
+        right = indices[f"R_{name[2:]}"]
+        paired.update((left, right))
+        neutral_length = np.linalg.norm(neutral_offsets[left])
+        if neutral_length == 0.0:
+            result[[left, right]] = 0.0
+            continue
+        length = 0.5 * (np.linalg.norm(measured_offsets[left]) + np.linalg.norm(measured_offsets[right]))
+        result[left] *= length / neutral_length
+        result[right] = result[left] * reflection
+
+    for joint in range(1, len(result)):
+        if joint in paired:
+            continue
+        neutral_length = np.linalg.norm(neutral_offsets[joint])
+        if neutral_length > 0.0:
+            result[joint] *= np.linalg.norm(measured_offsets[joint]) / neutral_length
+    return result
+
+
+def _shape_vertices(
+    weights: io.MannequinWeights,
+    template: IdentityTemplate,
+    local_offsets: np.ndarray,
+    rest_joints: np.ndarray,
+) -> tuple[np.ndarray, np.ndarray]:
+    transforms = _joint_transforms(template.local_offsets, local_offsets, weights.parents)
+    local_parts = []
+    rest_parts = []
+    for link, (owner, start, count, name) in enumerate(
+        zip(
+            weights.link_joint_indices,
+            weights.link_vertex_starts,
+            weights.link_vertex_counts,
+            weights.link_names,
+            strict=True,
+        )
+    ):
+        vertices = template.link_local_vertices[start : start + count]
+        if "__joint_" in name:
+            anchor = template.joint_geom_anchors[link]
+            neutral_anchor = template.rest_joints[anchor] - template.rest_joints[owner]
+            shaped_anchor = rest_joints[anchor] - rest_joints[owner]
+            vertices = vertices + shaped_anchor - neutral_anchor
+        else:
+            vertices = vertices @ transforms[owner].T
+        local_parts.append(vertices)
+        rest_parts.append(vertices + rest_joints[owner])
+    return np.concatenate(local_parts), np.concatenate(rest_parts)
+
+
+def _joint_transforms(
+    neutral_offsets: np.ndarray,
+    target_offsets: np.ndarray,
+    parents: list[int],
+) -> np.ndarray:
+    transforms = np.repeat(np.eye(3, dtype=target_offsets.dtype)[None], len(parents), axis=0)
+    children = [[] for _ in parents]
+    for joint, parent in enumerate(parents):
+        if parent >= 0:
+            children[parent].append(joint)
+
+    for joint, joint_children in enumerate(children):
+        if joint_children:
+            neutral_axes = neutral_offsets[joint_children].T
+            target_axes = target_offsets[joint_children].T
+            transforms[joint] += (target_axes - neutral_axes) @ np.linalg.pinv(neutral_axes)
+    return transforms
+
+
+def _joints_from_offsets(offsets: np.ndarray, parents: list[int]) -> np.ndarray:
+    joints = np.zeros_like(offsets)
+    joints[0] = offsets[0]
+    for joint in range(1, len(parents)):
+        joints[joint] = joints[parents[joint]] + offsets[joint]
+    return joints
+
+
+__all__ = ["IdentityTemplate", "SmplxMannequinIdentity", "build_template", "prepare"]