# pose2sim turns ordinary cameras into a motion capture lab

> pose2sim is a Python workflow for markerless 3D kinematics that goes from 2D pose estimation to OpenSim joint angles using phones, webcams or GoPros. It trades the hardware budget of a motion capture lab for a calibration and processing pipeline you have to drive yourself.

**perfanalytics/pose2sim** — Markerless kinematics with any cameras — From 2D Pose estimation to 3D OpenSim motion

- Repository: https://github.com/perfanalytics/pose2sim
- Website: https://perfanalytics.github.io/pose2sim/
- Stars: 855 · Forks: 118
- Language: Python
- License: BSD-3-Clause
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/perfanalytics-pose2sim

## From 2D keypoints to OpenSim joint angles without markers

pose2sim describes itself as a workflow for 3D markerless kinematics, for humans or animals, offered as an alternative to traditional marker based motion capture. The name is a description of the pipeline: the project stands for OpenPose to OpenSim, because it originally took OpenPose 2D keypoint coordinates as input and produced OpenSim results in the form of full body 3D joint angles. Pose estimation is now performed with newer models from RTMPose, and custom models, for example from DeepLabCut, can be used as well.

The hardware story is the reason it exists. Any combination of phones, webcams or GoPros can be used, and the subjects can be fully clothed. That suits the sports field, the doctor office, and outdoor 3D animation capture, where a marker based lab setup is not practical. The README claims research grade accuracy with 2 to 6 degrees of joint angle error, validated by peer reviewed studies, and states that the pipeline runs locally, which matters when recorded data of a person cannot leave the clinic.

The trade is that the pipeline is long. Getting from video to a result means estimating 2D pose, synchronising cameras, calibrating them, associating a person across views, triangulating keypoints into 3D, and filtering the 3D coordinates. Each of those steps has parameters the user controls, which the README presents as a feature, maximum control over clearly explained parameters.

## The eight steps the README lists between raw video and motion

The contents section of the README lays out the operating procedure, and it reads like a checklist rather than a black box. After installation and the demonstration parts, the section titled Use on your own data starts with Start filming, then Set up your project, then Estimate 2D pose, with separate subsections for RTMPose as the default, MMPose marked as coming soon, DeepLabCut, OpenPose as legacy, Mediapipe BlazePose, and AlphaPose as legacy.

After pose estimation come Synchronize your cameras, Calibrate your cameras, Associate persons across cameras, Triangulate keypoints, and Filter 3D coordinates. The order matters, because each step consumes the output of the previous one. A user who skips calibration still gets a triangulation step, but a triangulation step without accurate camera parameters produces 3D coordinates that are wrong in a way that is hard to see without ground truth.

Several of these stages have been around long enough to accumulate converters. The calibration section lists a conversion path from Caliscope, AniPose, FreeMocap, Qualisys, Optitrack, Vicon, OpenCap, EasyMocap, or bioCV. That list is itself informative about the ecosystem position: pose2sim is often the last stage of a chain rather than the first, and a team that already owns calibration results from a Qualisys or Vicon workflow can feed them in instead of recalibrating.

The repository layout supports a pipeline view of the project. The top level entries include a Pose2Sim directory for the code, a Content directory, a pose2sim.yaml configuration file, pyproject.toml, and CITATION.cff for citation metadata.

## Calibration comes in two flavours and both are unavoidable

The camera calibration section splits into intrinsic parameters and extrinsic parameters, and the extrinsic part offers four routes. Intrinsic parameters, the internal properties of a camera lens, can be calculated with a board, meaning a printed calibration target photographed by the cameras. Extrinsic parameters, the position and orientation of each camera in the shared scene, can be obtained from scene landmarks, from a static or moving board, or from pose estimation keypoints.

That third extrinsic option is what makes the low cost claim work. If the pose model already finds anatomical keypoints on the athlete, those keypoints can serve as correspondence points for calibrating the camera arrangement, which removes the need for a dedicated calibration rig. The cost is that calibration quality then depends on the pose model behaving well on the same footage.

The README also offers conversion from existing calibration formats, which is the practical route for many teams. This is the step where most of the effort concentrates, and the project is candid about the layout: the tooling covers board based intrinsic calibration, several extrinsic strategies, and importers for other tools.

The multi camera part adds its own failure modes. Associating persons across cameras means deciding which detected person in camera one is the same individual in camera two, and the demo includes a section for trying multi person and batch analyses, so the project supports tracking several people at once. Ambiguity in that step, when two people overlap in the frame, propagates into triangulation and then into every joint angle derived from it.

## What the packaging says about installation and dependencies

The README directs readers to the project website for the full walkthrough, and the cleaned README does not contain the install commands themselves, so the installation steps live at the site rather than in the repository text. The packaging metadata in pyproject.toml still tells you a lot about what you are installing. The project requires Python 3.11 or newer:

```toml
[project]
name = "pose2sim"
dynamic = ["version"] # Generate version from git tags
authors = [
    {name = "David Pagnon", email = "contact@david-pagnon.com"},
]
```

The version is generated from git tags, which means the release you get from the package index is tied to a tag in the repository, and the version string follows the tag rather than a hand maintained number. The same file names David Pagnon as author and maintainer, and points the bug tracker at the repository issue tracker.

The dependency list is the real weight of this project. It is long, and it includes the OpenSim binding, the video and toolchain packages, and the pose estimation stack:

```toml
dependencies = [
    "opensim", 
    "rtoml",
    "lxml",
    "mpl_interactions",
    "PySide6-essentials",
    "tqdm",
    "anytree",
    "pandas>=1.5", # pulls in numpy and matplotlib
    "scipy",
    "statsmodels",
    "filterpy",
    "ipython",
    "c3d",
    "rtmlib", # pulls in onnxruntime and opencv-python
    "openvino",
    "av",
    "caliscope",
    "bvhsdk"
```

Two of these deserve attention. The comment on pandas notes that it pulls in numpy and matplotlib, and the comment on rtmlib notes that it pulls in onnxruntime and opencv-python, so the runtime inference stack arrives as a transitive dependency rather than something you choose. The presence of openvino suggests an alternative inference backend, and bvhsdk and c3d relate to the camera and motion capture file formats involved in the workflow. The classifier list marks the development status as 3 - Alpha, which is the packaging metadata telling you plainly that this is pre release software.

The project is also published on PyPI as Pose2Sim, and the README lists a continuous integration badge, a journal of open source software paper with a DOI on Zenodo, and a Discord community.

## pose2sim against a marker based lab, and Sports2D for one camera

The real alternative to pose2sim is a traditional marker based motion capture system, and the comparison is a straight trade of budget against control. A marker based system gives you measured trajectories with a known uncertainty and a calibration procedure that a technician has already validated. pose2sim gives you the same category of output from consumer cameras, which makes field based studies possible, but the accuracy then depends on your calibration, your camera placement, and the pose model you chose. The 2 to 6 degrees of joint angle error figure in the README comes from peer reviewed validation studies, not from your setup.

The project itself points at a narrower alternative in a tip box. For real time analysis with a single camera, the README suggests Sports2D, with the condition that the motion must lie in the sagittal or frontal plane. The difference in approach is concrete: Sports2D works on 2D coordinates from one view, which is fast enough to run live, while pose2sim reconstructs 3D from multiple synchronised and calibrated views. The price of the 3D reconstruction is the pipeline length and the processing time, and for a single planar movement the 2D route gives you the same joint angles for a fraction of the work.

A third comparison point is the older OpenPose path inside pose2sim itself. RTMPose is now the default, and OpenPose is labelled legacy. The release history shows why: v0.10.47 was a fix for OpenMMLab servers having shut down, which broke the server based path that the legacy OpenPose workflow depended on. If you have recordings produced with the legacy configuration, expect the project to be adapting around dependencies that no longer exist.

## Release history, alpha status and what the licence allows

The repository is not archived and the last push was on 2026-10-14. Recent tagged releases are v0.10.49 on 2026-07-10, which added MacOS support and an enhanced sorting function, v0.10.47 on 2026-06-08, the fix for the OpenMMLab server shutdown, and v0.10.45 on 2026-05-19, which brought the new website.

The distribution pattern says something about the project. The version numbers sit around 0.10.x, and the packaging metadata still declares development status 3 - Alpha, so you should plan for breaking changes in configuration or in the workflow rather than treating a minor version bump as safe. The website move in v0.10.45 also means older documentation links in the wild may point somewhere else, which is worth remembering when you follow an old tutorial.

Licensing is straightforward. The project is BSD-3-Clause, and the pyproject.toml names the licence file as LICENSE with the same identifier, while the README carries a BSD-3-Clause badge. A permissive three clause licence is generally friendly to commercial use and to redistribution in a larger pipeline, and it carries the usual obligation to retain the copyright notice and licence text, though you should read the LICENSE file yourself for the exact wording rather than relying on a summary.

Data handling is a separate practical advantage the README highlights. Because the pipeline runs locally, footage of a patient, a client, or an athlete does not have to be uploaded to a third party service, which keeps the workflow inside data protection rules that a hosted service would complicate.

## Conclusion

pose2sim fits labs, clinics and sports teams that need full body 3D kinematics from cheap cameras and can afford to do calibration, person association and filtering properly. It does not fit a single camera, real time recording, or a study that needs results in minutes rather than hours. Before adopting it, read the installation instructions on the project website, since the repository README does not spell out the install commands, and confirm that the accuracy claim of 2-6 degrees of joint angle error holds for the movement you care about rather than taking it for granted.

## FAQ

### What are the installation requirements for pose2sim?

The packaging metadata in pyproject.toml requires Python 3.11 or newer, and the project depends on packages including opensim, rtmlib, openvino, av, caliscope and bvhsdk. The README sends readers to the project website for the actual installation steps rather than listing them in the repository.

### How accurate is pose2sim compared with marker based motion capture?

The README states research grade accuracy of 2 to 6 degrees of joint angle error, validated by peer reviewed studies. It presents the tool as an alternative to traditional marker based MoCap that runs on low cost hardware such as phones, webcams or GoPros.

### Do I need more than one camera to use pose2sim?

The workflow is built around multiple synchronised and calibrated views, with steps for associating persons across cameras and triangulating keypoints. For real time analysis with a single camera, the README points to Sports2D instead, with the restriction that the motion must lie in the sagittal or frontal plane.

### What licence is pose2sim released under?

pose2sim is released under the BSD-3-Clause licence. The pyproject.toml lists license = "BSD-3-Clause" and points to the LICENSE file at the top of the repository, and the README carries a matching licence badge.

## Sources

- [License: BSD-3-Clause](https://github.com/perfanalytics/pose2sim/blob/main/LICENSE)
- [perfanalytics/pose2sim on GitHub](https://github.com/perfanalytics/pose2sim)
- [Project website](https://perfanalytics.github.io/pose2sim/)
- [README](https://github.com/perfanalytics/pose2sim/blob/main/README.md)
- [Releases](https://github.com/perfanalytics/pose2sim/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/perfanalytics-pose2sim