EasyMocap

https://github.com/zju3dv/easymocap
Admin
EasyMocap is an open-source toolbox for markerless human motion capture and novel view synthesis...
Tokens:64,387
Snippets:761
Trust Score:7.9
Update:6 months ago
Show doc for...
Tokens:
Raw
### Run Basic Annotation Example

Source: https://github.com/zju3dv/easymocap/blob/master/apps/annotation/Readme.md

Execute this script to start the basic annotation example. Replace ${data} with your dataset path. This example demonstrates basic mouse and keyboard controls for annotation.

```bash
python3 apps/annotation/annot_example.py ${data}
```

--------------------------------

### Install EasyMocap

Source: https://github.com/zju3dv/easymocap/blob/master/doc/installation.md

Install EasyMocap using the setup script. This command installs the package in user-editable mode.

```bash
python3 setup.py develop --user
```

--------------------------------

### Install pybind11 from source

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/compiling.md

Standard procedure to build and install pybind11 locally.

```bash
cd pybind11
mkdir build
cd build
cmake ..
make install
```

--------------------------------

### Install Open3D

Source: https://github.com/zju3dv/easymocap/blob/master/doc/realtime_visualization.md

Install the Open3D library, which is a required dependency for EasyMocap's visualization features. Ensure you use version 0.9.0.

```bash
python3 -m pip install open3d==0.9.0
```

--------------------------------

### Install Pybind11 Headers and Configuration Files

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/CMakeLists.txt

Installs pybind11 headers, CMake configuration files (Config.cmake, ConfigVersion.cmake), and helper scripts. It customizes the installation path for CMake configuration files and handles versioning information.

```cmake
if (PYBIND11_INSTALL)
  install(DIRECTORY ${PYBIND11_INCLUDE_DIR}/pybind11 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
  # GNUInstallDirs "DATADIR" wrong here; CMake search path wants "share".
  set(PYBIND11_CMAKECONFIG_INSTALL_DIR "share/cmake/${PROJECT_NAME}" CACHE STRING "install path for pybind11Config.cmake")

  configure_package_config_file(tools/${PROJECT_NAME}Config.cmake.in
                                "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
                                INSTALL_DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
  # Remove CMAKE_SIZEOF_VOID_P from ConfigVersion.cmake since the library does
  # not depend on architecture specific settings or libraries.
  set(_PYBIND11_CMAKE_SIZEOF_VOID_P ${CMAKE_SIZEOF_VOID_P})
  unset(CMAKE_SIZEOF_VOID_P)
  write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
                                   VERSION ${${PROJECT_NAME}_VERSION}
                                   COMPATIBILITY AnyNewerVersion)
  set(CMAKE_SIZEOF_VOID_P ${_PYBIND11_CMAKE_SIZEOF_VOID_P})
  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
                ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
                tools/FindPythonLibsNew.cmake
                tools/pybind11Tools.cmake
          DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})

  if(NOT (CMAKE_VERSION VERSION_LESS 3.0))
    if(NOT PYBIND11_EXPORT_NAME)
      set(PYBIND11_EXPORT_NAME "${PROJECT_NAME}Targets")
    endif()

    install(TARGETS pybind11 module embed
            EXPORT "${PYBIND11_EXPORT_NAME}")
    if(PYBIND11_MASTER_PROJECT)
      install(EXPORT "${PYBIND11_EXPORT_NAME}"
              NAMESPACE "${PROJECT_NAME}::"
              DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
    endif()
  endif()
endif()
```

--------------------------------

### Start Visualization Server

Source: https://github.com/zju3dv/easymocap/blob/master/doc/realtime_visualization.md

Launch the EasyMocap visualization server. You can use a default configuration or specify a host and port.

```bash
python3 apps/vis/vis_server.py --cfg config/vis3d/o3d_scene.yml
```

```bash
python3 apps/vis/vis_server.py --cfg config/vis3d/o3d_scene.yml host <your_ip_address> port <set_a_port>
```

--------------------------------

### Visualize Basic Skeletons

Source: https://github.com/zju3dv/easymocap/blob/master/doc/realtime_visualization.md

Start the server with a scene configuration and send skeleton keypoint data to visualize basic human skeletons.

```bash
python3 apps/vis/vis_server.py --cfg config/vis3d/o3d_scene.yml write True out ${vis}/output/skel-body25 camera.cz 3. camera.cy 0.5
python3 apps/vis/vis_client.py --path ${vis}/smpl/keypoints3d
```

--------------------------------

### Create Python bindings for a function

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/basics.md

Complete example showing the C++ function and the PYBIND11_MODULE macro to expose it to Python.

```cpp
#include <pybind11/pybind11.h>

int add(int i, int j) {
    return i + j;
}

PYBIND11_MODULE(example, m) {
    m.doc() = "pybind11 example plugin"; // optional module docstring

    m.def("add", &add, "A function which adds two numbers");
}
```

--------------------------------

### Global class binding example

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/classes.md

Demonstrates how a class defined in one module can be used in another when bindings are global.

```cpp
// In the module1.cpp binding code for module1:
py::class_<Pet>(m, "Pet")
    .def(py::init<std::string>())
    .def_readonly("name", &Pet::name);
```

```cpp
// In the module2.cpp binding code for module2:
m.def("create_pet", [](std::string name) { return new Pet(name); });
```

```pycon
>>> from module1 import Pet
>>> from module2 import create_pet
>>> pet1 = Pet("Kitty")
>>> pet2 = create_pet("Doggy")
>>> pet2.name()
'Doggy'
```

--------------------------------

### CMake Project Setup

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/tests/test_cmake_build/subdirectory_function/CMakeLists.txt

Initializes the CMake build system and defines the project name. Requires CMake version 2.8.12 or higher.

```cmake
cmake_minimum_required(VERSION 2.8.12)
project(test_subdirectory_module CXX)
```

--------------------------------

### Define header and namespace conventions

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/basics.md

Standard boilerplate headers and namespace aliases used in pybind11 examples.

```cpp
#include <pybind11/pybind11.h>

namespace py = pybind11;
```

--------------------------------

### Create pybind11 module bindings

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/classes.md

Basic setup to expose a C++ class to Python using pybind11.

```cpp
#include <pybind11/pybind11.h>

namespace py = pybind11;

PYBIND11_MODULE(example, m) {
    py::class_<Pet>(m, "Pet")
        .def(py::init<const std::string &>())
        .def("setName", &Pet::setName)
        .def("getName", &Pet::getName);
}
```

--------------------------------

### View overloaded method signatures in Python

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/classes.md

Example of how overloaded signatures appear in the Python help docstring.

```pycon
>>> help(example.Pet)

class Pet(__builtin__.object)
 |  Methods defined here:
 |
 |  __init__(...)
 |      Signature : (Pet, str, int) -> NoneType
 |
 |  set(...)
 |      1. Signature : (Pet, int) -> NoneType
 |
 |      Set the pet's age
 |
 |      2. Signature : (Pet, str) -> NoneType
 |
 |      Set the pet's name
```

--------------------------------

### Applying Policies to Properties

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/functions.md

Examples of how to apply return value policies to class properties using def_property.

```APIDOC
## Applying Policies to Properties

### Description
Policies can be applied to properties to control how data is returned to Python.

### Example
```cpp
// Terse syntax applying policy to both getter and setter
class_<MyClass>(m, "MyClass")
    .def_property("data", &MyClass::getData, &MyClass::setData,
                  py::return_value_policy::copy);

// Targeted syntax using cpp_function
class_<MyClass>(m, "MyClass")
    .def_property("data",
        py::cpp_function(&MyClass::getData, py::return_value_policy::copy),
        py::cpp_function(&MyClass::setData)
    );
```
```

--------------------------------

### Annotate Tracking Example

Source: https://github.com/zju3dv/easymocap/blob/master/apps/annotation/Readme.md

Use this command to run the tracking annotation script. Replace ${data} with your dataset path. This script allows for person selection, ID assignment, bounding box manipulation, and frame-to-frame tracking.

```bash
python3 apps/annotation/annot_track.py ${data}
```

--------------------------------

### Python Dynamic Attributes Example

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/classes.md

Demonstrates how native Python classes can have attributes added or modified dynamically.

```python
>>> class Pet:
...     name = 'Molly'
...
>>> p = Pet()
>>> p.name = 'Charly'  # overwrite existing
>>> p.age = 2  # dynamically add a new attribute
```

--------------------------------

### Interact with bound enumeration in Python

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/classes.md

Example usage of the bound enumeration in Python.

```pycon
>>> p = Pet('Lucy', Pet.Cat)
>>> p.type
Kind.Cat
>>> int(p.type)
1L
```

--------------------------------

### Create Example with std::unique_ptr

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/smart_ptrs.md

Demonstrates how to return a C++ object managed by std::unique_ptr from a C++ function exposed to Python. This allows Python to take ownership of the object.

```cpp
std::unique_ptr<Example> create_example() { return std::unique_ptr<Example>(new Example()); }
```

```cpp
m.def("create_example", &create_example);
```

--------------------------------

### Example Usage of Split Binding Code

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/faq.md

Demonstrates the Python usage of a module built from split binding code. Functions defined in separate C++ files are accessible after importing the main module.

```python
>>> import example
>>> example.add(1, 2)
3
>>> example.sub(1, 1)
0
```

--------------------------------

### C++ Base and Derived Classes for pybind11 Example

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/classes.md

Defines base and derived C++ classes to demonstrate virtual function overriding and inheritance patterns relevant for pybind11 integration.

```cpp
class Animal {
public:
    virtual std::string go(int n_times) = 0;
    virtual std::string name() { return "unknown"; }
};
class Dog : public Animal {
public:
    std::string go(int n_times) override {
        std::string result;
        for (int i=0; i<n_times; ++i)
            result += bark() + " ";
        return result;
    }
    virtual std::string bark() { return "woof!"; }
};
```

--------------------------------

### C++ Inheritance Setup: Base and Derived Classes

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/classes.md

Defines C++ base (`Pet`) and derived (`Dog`) classes with a constructor and a method. These will be exposed to Python.

```cpp
struct Pet {
    Pet(const std::string &name) : name(name) { }
    std::string name;
};

struct Dog : Pet {
    Dog(const std::string &name) : Pet(name) { }
    std::string bark() const { return "woof!"; }
};
```

--------------------------------

### Python Example: Passing Characters

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/cast/strings.md

Illustrates the usage of the `pass_char` function from C++ in Python, showing direct character passing and the need for `chr()` when converting integers.

```python
>>> example.pass_char('A')
'A'
```

```python
>>> example.pass_char(0x65)
TypeError
```

```python
>>> example.pass_char(chr(0x65))
'A'
```

--------------------------------

### Configure Python Include Directory

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/CMakeLists.txt

Conditionally sets the installation include directory relative to the install prefix if 'USE_PYTHON_INCLUDE_DIR' option is enabled. This is useful for custom installation layouts.

```cmake
option (USE_PYTHON_INCLUDE_DIR "Install pybind11 headers in Python include directory instead of default installation prefix" OFF)
if (USE_PYTHON_INCLUDE_DIR)
    file(RELATIVE_PATH CMAKE_INSTALL_INCLUDEDIR ${CMAKE_INSTALL_PREFIX} ${PYTHON_INCLUDE_DIRS})
endif()
```

--------------------------------

### Run Visualization Client

Source: https://github.com/zju3dv/easymocap/blob/master/doc/realtime_visualization.md

Executes the visualization client to display keypoints from a specified path.

```bash
python3 apps/vis/vis_client.py --path ${vis}/manol/smpl --smpl
```

--------------------------------

### Pybind11 Deprecation Warning Example

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/upgrade.md

This is an example of a compile-time warning message shown when using deprecated pybind11 features, such as old-style placement-new constructors or pickling methods. The warning is typically visible in debug builds.

```none
pybind11-bound class 'mymodule.Foo' is using an old-style placement-new '__init__'
which has been deprecated. See the upgrade guide in pybind11's docs.
```

--------------------------------

### Run OpenPose Preprocessing

Source: https://github.com/zju3dv/easymocap/blob/master/doc/quickstart.md

Preprocesses videos using OpenPose to detect keypoints. Specify the OpenPose path with --openpose and enable hand/face detection with --handface.

```bash
data=path/to/data
out=path/to/output
python3 scripts/preprocess/extract_video.py ${data} --openpose <openpose_path> --handface
```

--------------------------------

### Integrate pybind11 using find_package

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/compiling.md

Use an installed pybind11 package to build a module.

```cmake
cmake_minimum_required(VERSION 2.8.12)
project(example)

find_package(pybind11 REQUIRED)
pybind11_add_module(example example.cpp)
```

--------------------------------

### Execute Python Dictionary Iteration

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/functions.md

Example usage of the exported print_dict function in Python.

```pycon
>>> print_dict({'foo': 123, 'bar': 'hello'})
key=foo, value=123
key=bar, value=hello
```

--------------------------------

### Validate Pytest Installation

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/tests/CMakeLists.txt

Checks for the existence and version of pytest, raising a fatal error if the requirements are not met.

```cmake
if(NOT PYBIND11_PYTEST_FOUND)
  execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import pytest; print(pytest.__version__)"
                  RESULT_VARIABLE pytest_not_found OUTPUT_VARIABLE pytest_version ERROR_QUIET)
  if(pytest_not_found)
    message(FATAL_ERROR "Running the tests requires pytest. Please install it manually"
                        " (try: ${PYTHON_EXECUTABLE} -m pip install pytest)")
  elseif(pytest_version VERSION_LESS 3.0)
    message(FATAL_ERROR "Running the tests requires pytest >= 3.0. Found: ${pytest_version}"
                        "Please update it (try: ${PYTHON_EXECUTABLE} -m pip install -U pytest)")
  endif()
  set(PYBIND11_PYTEST_FOUND TRUE CACHE INTERNAL "")
endif()
```

--------------------------------

### Embed Real-time Visualization in Code

Source: https://github.com/zju3dv/easymocap/blob/master/doc/realtime_visualization.md

Integrate EasyMocap's visualization into your own Python code. Import the BaseSocketClient, set the host and port, and send your data.

```python
from easymocap.socket.base_client import BaseSocketClient
client = BaseSocketClient(host, port)
client.send(data)
```

--------------------------------

### Import and execute the module in Python

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/basics.md

Interactive session demonstrating how to import the compiled module and call the bound function.

```pycon
$ python
Python 2.7.10 (default, Aug 22 2015, 20:33:39)
[GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.0.59.1)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import example
>>> example.add(1, 2)
3L
>>>
```

--------------------------------

### Preferred Module Entry Point (PYBIND11_MODULE)

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/changelog.md

The new preferred way to create module entry points. PYBIND11_PLUGIN is deprecated.

```cpp
// new
PYBIND11_MODULE(example, m) {
    m.def("add", [](int a, int b) { return a + b; });
}

// old
PYBIND11_PLUGIN(example) {
    py::module m("example");
    m.def("add", [](int a, int b) { return a + b; });
    return m.ptr();
}
```

--------------------------------

### Call C++ string functions from Python

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/cast/strings.md

Example usage of the defined C++ functions with UTF-8 characters.

```python
>>> utf8_test('🎂')
utf-8 is icing on the cake.
🎂

>>> utf8_charptr('🍕')
My favorite food is
🍕
```

--------------------------------

### Visualize Body, Face, and Hand Skeletons

Source: https://github.com/zju3dv/easymocap/blob/master/doc/realtime_visualization.md

Use a specific configuration file to visualize detailed skeletons including body, face, and hand components. Send the corresponding keypoint data.

```bash
python3 apps/vis/vis_server.py --cfg config/vis3d/o3d_scene_total.yml write True out ${vis}/output/skel-total camera.cz 3. camera.cy 0.5
python3 apps/vis/vis_client.py --path ${vis}/smplx/keypoints3d
```

--------------------------------

### Prepare Dataset Structure

Source: https://github.com/zju3dv/easymocap/blob/master/doc/quickstart.md

Defines the expected directory structure for your own dataset, including camera calibration files and video sequences.

```text
<seq>
├── intri.yml
├── extri.yml
└── videos
    ├── 1.mp4
    ├── 2.mp4
    ├── ...
    ├── 8.mp4
    └── 9.mp4
```

--------------------------------

### Send 3D Data to Visualization Server

Source: https://github.com/zju3dv/easymocap/blob/master/doc/realtime_visualization.md

Use the visualization client to send your 3D keypoint data to the running server. Specify the path to your data and the server's host and port.

```bash
python3 apps/vis/vis_client.py --path <path/to/your/keypoints3d> --host <previous_ip_address> --port <previous_port>
```

--------------------------------

### Incorrect binding example

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/classes.md

Demonstrates an incorrect usage where the trampoline method is bound instead of the base class method.

```cpp
py::class_<Animal, PyAnimal /* <--- trampoline*/>(m, "Animal");
    .def(py::init<>())
    .def("go", &PyAnimal::go); /* <--- THIS IS WRONG, use &Animal::go */
```

--------------------------------

### Directory Structure for SMPL Models

Source: https://github.com/zju3dv/easymocap/blob/master/doc/installation.md

Organize downloaded SMPL, SMPL+H, and SMPL-X models in this directory structure.

```bash
data
└── smplx
    ├── J_regressor_body25.npy
    ├── J_regressor_body25_smplh.txt
    ├── J_regressor_body25_smplx.txt
    ├── J_regressor_mano_LEFT.txt
    ├── J_regressor_mano_RIGHT.txt
    ├── smpl
    │   ├── SMPL_FEMALE.pkl
    │   ├── SMPL_MALE.pkl
    │   └── SMPL_NEUTRAL.pkl
    ├── smplh
    │   ├── MANO_LEFT.pkl
    │   ├── MANO_RIGHT.pkl
    │   ├── SMPLH_FEMALE.pkl
    │   └── SMPLH_MALE.pkl
    └── smplx
        ├── SMPLX_FEMALE.pkl
        ├── SMPLX_MALE.pkl
        └── SMPLX_NEUTRAL.pkl
```

--------------------------------

### Pickle a C++ Object in Python

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/classes.md

Example of serializing the bound C++ object using Python's pickle module.

```python
try:
    import cPickle as pickle  # Use cPickle on Python 2.7
except ImportError:
    import pickle

p = Pickleable("test_value")
p.setExtra(15)
data = pickle.dumps(p, 2)
```

--------------------------------

### Define pybind11 class bindings

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/benchmark.md

Example of binding a C++ class with multiple methods using the pybind11 module macro.

```cpp
...
class cl034 {
public:
    cl279 *fn_000(cl084 *, cl057 *, cl065 *, cl042 *);
    cl025 *fn_001(cl098 *, cl262 *, cl414 *, cl121 *);
    cl085 *fn_002(cl445 *, cl297 *, cl145 *, cl421 *);
    cl470 *fn_003(cl200 *, cl323 *, cl332 *, cl492 *);
};
...

PYBIND11_MODULE(example, m) {
    ...
    py::class_<cl034>(m, "cl034")
        .def("fn_000", &cl034::fn_000)
        .def("fn_001", &cl034::fn_001)
        .def("fn_002", &cl034::fn_002)
        .def("fn_003", &cl034::fn_003)
    ...
}
```

--------------------------------

### Call bound functions with keyword arguments

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/basics.md

Demonstrates calling the bound function from Python using keyword arguments.

```pycon
>>> import example
>>> example.add(i=1, j=2)
3L
```

--------------------------------

### Optimize SMPL Pose Parameters using 3D Keypoints

Source: https://context7.com/zju3dv/easymocap/llms.txt

Optimizes SMPL pose parameters using 3D keypoint constraints and temporal smoothness. Requires a body model, initial parameters, 3D keypoints, and loss weights.

```python
from easymocap.pyfitting.optimize_simple import optimizePose3D, optimizePose2D
from easymocap.pipeline.config import Config
from easymocap.smplmodel import load_model
import numpy as np

body_model = load_model(gender='neutral', model_type='smpl')

# Create configuration
class Args:
    verbose = False
cfg = Config(Args())
cfg.device = body_model.device
cfg.OPT_R = True
cfg.OPT_T = True
cfg.OPT_POSE = True

# Initialize parameters
nFrames = 50
params = body_model.init_params(nFrames=nFrames)

# 3D keypoints
keypoints3d = np.random.rand(nFrames, 25, 4)

# Loss weights
weight = {
    'k3d': 1.0,            # 3D keypoint loss
    'smooth_body': 5.0,    # Temporal smoothness
    'smooth_poses': 1.0,   # Pose parameter smoothness
    'reg_poses': 1e-3,     # Pose regularization
}

# Optimize using 3D keypoints
params = optimizePose3D(body_model, params, keypoints3d, weight, cfg)
```

--------------------------------

### Create a Python extension with CMake

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/compiling.md

Basic configuration for a CMake project to build a pybind11 extension module.

```cmake
cmake_minimum_required(VERSION 2.8.12)
project(example)

add_subdirectory(pybind11)
pybind11_add_module(example example.cpp)
```

--------------------------------

### Embed Python Interpreter

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/changelog.md

Starts the Python interpreter and keeps it alive using py::scoped_interpreter. Use the Python API for interactions.

```cpp
#include <pybind11/embed.h>
namespace py = pybind11;

int main() {
    py::scoped_interpreter guard{}; // start the interpreter and keep it alive

    py::print("Hello, World!"); // use the Python API
}
```

--------------------------------

### Visualize SMPL-X Meshes

Source: https://github.com/zju3dv/easymocap/blob/master/doc/realtime_visualization.md

Visualize SMPL-X models, which include body, face, and hands. Use the specific scene configuration for SMPL-X and send the corresponding data with the '--smpl' flag.

```bash
python3 apps/vis/vis_server.py --cfg config/vis3d/o3d_scene_smplx.yml write True out ${vis}/output/mesh-smplx camera.cz 3. camera.cy 0.5
python3 apps/vis/vis_client.py --path ${vis}/smplx/smpl --smpl
```

--------------------------------

### Compile and test on Windows

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/basics.md

Commands to build and run tests on Windows using CMake and Visual Studio.

```batch
mkdir build
cd build
cmake ..
cmake --build . --config Release --target check
```

--------------------------------

### Unpack arguments

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/pycpp/object.md

Handle *args and **kwargs unpacking using py::tuple and py::dict.

```cpp
// * unpacking
py::tuple args = py::make_tuple(1234, "hello", some_instance);
f(*args);

// ** unpacking
py::dict kwargs = py::dict("number"_a=1234, "say"_a="hello", "to"_a=some_instance);
f(**kwargs);

// mixed keywords, * and ** unpacking
py::tuple args = py::make_tuple(1234);
py::dict kwargs = py::dict("to"_a=some_instance);
f(*args, "say"_a="hello", **kwargs);
```

```cpp
py::dict kwargs1 = py::dict("number"_a=1234);
py::dict kwargs2 = py::dict("to"_a=some_instance);
f(**kwargs1, "say"_a="hello", **kwargs2);
```

--------------------------------

### Mangled C++ Symbol Name

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/faq.md

This is an example of a mangled C++ symbol name generated by template metaprogramming in pybind11. It illustrates the complexity and length that can arise from such techniques.

```cpp
__ZN8pybind1112cpp_functionC1Iv8Example2JRNSt3__16vectorINS3_12basic_stringIwNS3_11char_traitsIwEENS3_9allocatorIwEEEENS8_ISA_EEEEEJNS_4nameENS_7siblingENS_9is_methodEA28_cEEEMT0_FT_DpT1_EDpRKT2_
```

--------------------------------

### Visualize MANO Hand Meshes

Source: https://github.com/zju3dv/easymocap/blob/master/doc/realtime_visualization.md

Render MANO hand models. This requires a specific scene configuration for MANO and sending the hand data with the '--smpl' flag.

```bash
python3 apps/vis/vis_server.py --cfg config/vis3d/o3d_scene_manol.yml write True out ${vis}/output/mesh-manol camera.cz 3. camera.cy 0.5
```

--------------------------------

### Compile and test on Linux/MacOS

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/basics.md

Commands to build and run tests on Unix-like systems using CMake.

```bash
mkdir build
cd build
cmake ..
make check -j 4
```

--------------------------------

### Dataset Directory Structure

Source: https://github.com/zju3dv/easymocap/blob/master/doc/mvmp.md

The expected directory structure for calibrated camera data, including intrinsic/extrinsic parameters, annotations, and video files.

```bash
├── intri.yml
├── extri.yml
├── annots
│   ├── 0
│   ├── 1
│   ├── 2
│   ├── 3
│   ├── 4
│   ├── 5
│   ├── 6
│   └── 7
└── videos
    ├── 0.mp4
    ├── 1.mp4
    ├── 2.mp4
    ├── 3.mp4
    ├── 4.mp4
    ├── 5.mp4
    ├── 6.mp4
    └── 7.mp4
```

--------------------------------

### Custom Constructors with py::init

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/changelog.md

Adds custom constructors using lambdas or factory functions that return class instances. Supersedes the old placement-new technique.

```cpp
struct Example {
    Example(std::string);
};

py::class_<Example>(m, "Example")
    .def(py::init<std::string>()) // existing constructor
    .def(py::init([](int n) { // custom constructor
        return std::make_unique<Example>(std::to_string(n));
    }));
```

--------------------------------

### Python Code Causing Undefined Behavior

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/smart_ptrs.md

Demonstrates the Python code that triggers undefined behavior when interacting with C++ classes that have inconsistent smart pointer management, as shown in the previous example.

```python
from example import Parent
print(Parent().get_child())
```

--------------------------------

### Call C++ Function with Python List

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/cast/overview.md

This is an example of calling the C++ print_list function from Python. The Python list [1, 2, 3] is passed directly, and the C++ function processes it.

```python
>>> print_list([1, 2, 3])
1 2 3
```

--------------------------------

### Inspect function signatures

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/basics.md

Use the help function to view the signature and documentation of bound functions.

```pycon
>>> help(example)

....

FUNCTIONS
    add(...)
        Signature : (i: int, j: int) -> int

        A function which adds two numbers
```

--------------------------------

### Configure Camera Settings

Source: https://github.com/zju3dv/easymocap/blob/master/doc/realtime_visualization.md

Defines camera orientation and position parameters in YAML format.

```yaml
camera:
  phi: 0
  theta: -30
  cx: 0.
  cy: 0.
  cz: 6.
```

--------------------------------

### Inconsistent Smart Pointer Usage Example

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/smart_ptrs.md

Highlights a common pitfall where raw pointers are returned from a C++ class managed by std::shared_ptr. This leads to undefined behavior due to double deallocation.

```cpp
class Child { };

class Parent {
public:
   Parent() : child(std::make_shared<Child>()) { }
   Child *get_child() { return child.get(); }  /* Hint: ** DON'T DO THIS ** */
private:
    std::shared_ptr<Child> child;
};

PYBIND11_MODULE(example, m) {
    py::class_<Child, std::shared_ptr<Child>>(m, "Child");

    py::class_<Parent, std::shared_ptr<Parent>>(m, "Parent")
       .def(py::init<>())
       .def("get_child", &Parent::get_child);
}
```

--------------------------------

### Create Pybind11 Interface Library (CMake >= 3.0)

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/CMakeLists.txt

Defines an INTERFACE library target for pybind11, aliased as 'pybind11::pybind11'. It specifies include directories for build and installation, and compile options. This is for CMake versions 3.0 and above.

```cmake
if(NOT (CMAKE_VERSION VERSION_LESS 3.0))  # CMake >= 3.0
  # Build an interface library target:
  add_library(pybind11 INTERFACE)
  add_library(pybind11::pybind11 ALIAS pybind11)  # to match exported target
  target_include_directories(pybind11 INTERFACE $<BUILD_INTERFACE:${PYBIND11_INCLUDE_DIR}>
                                                $<BUILD_INTERFACE:${PYTHON_INCLUDE_DIRS}>
                                                $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
  target_compile_options(pybind11 INTERFACE $<BUILD_INTERFACE:${PYBIND11_CPP_STANDARD}>)
endif()
```

--------------------------------

### Initialize Aggregate Types with Implicit Constructors

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/changelog.md

Shows how py::init<> now uses C++11 brace initialization, allowing implicit constructors of aggregate types to be bound.

```cpp
struct Aggregate {
    int a;
    std::string b;
};

py::class_<Aggregate>(m, "Aggregate")
    .def(py::init<int, const std::string &>());
```

--------------------------------

### C++ Reference Argument Examples

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/faq.md

Demonstrates C++ functions using mutable references and pointers for argument modification. Note that Python's immutable types prevent direct modification of arguments in a similar fashion.

```cpp
void increment(int &i) { i++; }
void increment_ptr(int *i) { (*i)++; }
```

```cpp
int foo(int &i) { i++; return 123; }
```

--------------------------------

### Annotate Vanishing Line Example

Source: https://github.com/zju3dv/easymocap/blob/master/apps/annotation/Readme.md

Run this script for vanishing line annotation. Replace ${data} with your dataset path. It supports plotting lines, assigning them to vanishing line sets, and calculating intrinsic matrices or vanishing points.

```bash
python3 apps/annotation/annot_vanish.py ${data}
```

--------------------------------

### Project-Specific Build Commands

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/tests/CMakeLists.txt

Adds post-build commands for library size tracking and includes additional test subdirectories.

```cmake
if (NOT PROJECT_NAME STREQUAL "pybind11")
  return()
endif()

# Add a post-build comment to show the primary test suite .so size and, if a previous size, compare it:
add_custom_command(TARGET pybind11_tests POST_BUILD
  COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/tools/libsize.py
  $<TARGET_FILE:pybind11_tests> ${CMAKE_CURRENT_BINARY_DIR}/sosize-$<TARGET_FILE_NAME:pybind11_tests>.txt)

# Test embedding the interpreter. Provides the `cpptest` target.
add_subdirectory(test_embed)

# Test CMake build using functions and targets from subdirectory or installed location
add_subdirectory(test_cmake_build)
```

--------------------------------

### Specialize holder_helper for Custom Pointer Access

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/smart_ptrs.md

If your custom smart pointer does not provide a `.get()` member function to access the underlying raw pointer, specialize pybind11's holder_helper. This example shows how to use `.getPointer()` instead.

```cpp
// Always needed for custom holder types
PYBIND11_DECLARE_HOLDER_TYPE(T, SmartPtr<T>);

// Only needed if the type's ".get()" goes by another name
namespace pybind11 { namespace detail {
    template <typename T>
    struct holder_helper<SmartPtr<T>> { // <-- specialization
        static const T *get(const SmartPtr<T> &p) { return p.getPointer(); }
    };
}}
```

--------------------------------

### Implement Pickling with py::pickle

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/upgrade.md

Use py::pickle() for defining get and set state functions, replacing the deprecated __getstate__ and __setstate__ methods. This change enhances type safety. Warnings for old-style pickling are visible in debug mode.

```cpp
// old -- deprecated (runtime warning shown only in debug mode)
py::class_<Foo>(m, "Foo")
    ...
    .def("__getstate__", [](const Foo &self) {
        return py::make_tuple(self.value1(), self.value2(), ...);
    })
    .def("__setstate__", [](Foo &self, py::tuple t) {
        new (&self) Foo(t[0].cast<std::string>(), ...);
    });

// new
py::class_<Foo>(m, "Foo")
    ...
    .def(py::pickle(
        [](const Foo &self) { // __getstate__
            return py::make_tuple(f.value1(), f.value2(), ...); // unchanged
        },
        [](py::tuple t) { // __setstate__, note: no `self` argument
            return new Foo(t[0].cast<std::string>(), ...);
            // or: return std::make_unique<Foo>(...); // return by holder
            // or: return Foo(...); // return by value (move constructor)
        }
    ));
```

--------------------------------

### Manual NumPy Buffer Access in C++

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/pycpp/numpy.md

Demonstrates manual buffer request and iteration for array operations when standard vectorization is insufficient.

```cpp
#include <pybind11/pybind11.h>
#include <pybind11/numpy.h>

namespace py = pybind11;

py::array_t<double> add_arrays(py::array_t<double> input1, py::array_t<double> input2) {
    py::buffer_info buf1 = input1.request(), buf2 = input2.request();

    if (buf1.ndim != 1 || buf2.ndim != 1)
        throw std::runtime_error("Number of dimensions must be one");

    if (buf1.size != buf2.size)
        throw std::runtime_error("Input shapes must match");

    /* No pointer is passed, so NumPy will allocate the buffer */
    auto result = py::array_t<double>(buf1.size);

    py::buffer_info buf3 = result.request();

    double *ptr1 = (double *) buf1.ptr,
           *ptr2 = (double *) buf2.ptr,
           *ptr3 = (double *) buf3.ptr;

    for (size_t idx = 0; idx < buf1.shape[0]; idx++)
        ptr3[idx] = ptr1[idx] + ptr2[idx];

    return result;
}

PYBIND11_MODULE(test, m) {
    m.def("add_arrays", &add_arrays, "Add two NumPy arrays");
}
```

--------------------------------

### Import and use Python modules

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/embedding.md

Import standard or custom Python modules and interact with their attributes.

```cpp
py::module sys = py::module::import("sys");
py::print(sys.attr("path"));
```

```python
"""calc.py located in the working directory"""

def add(i, j):
    return i + j
```

```cpp
py::module calc = py::module::import("calc");
py::object result = calc.attr("add")(1, 2);
int n = result.cast<int>();
assert(n == 3);
```

--------------------------------

### Specializing polymorphic_type_hook for Custom Downcasting

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/classes.md

Specialize `pybind11::polymorphic_type_hook` to provide runtime type information for downcasting when C++ classes are not polymorphic. The `get` function determines if a downcast is safe and returns the derived type information and pointer. Ensure the returned pointer and type agree.

```cpp
enum class PetKind { Cat, Dog, Zebra };
struct Pet {   // Not polymorphic: has no virtual methods
    const PetKind kind;
    int age = 0;
  protected:
    Pet(PetKind _kind) : kind(_kind) {}
};
struct Dog : Pet {
    Dog() : Pet(PetKind::Dog) {}
    std::string sound = "woof!";
    std::string bark() const { return sound; }
};

namespace pybind11 {
    template<>
    struct polymorphic_type_hook<Pet> {
        static const void *get(const Pet *src, const std::type_info*& type) {
            // note that src may be nullptr
            if (src && src->kind == PetKind::Dog) {
                type = &typeid(Dog);
                return static_cast<const Dog*>(src);
            }
            return src;
        }
    };
} // namespace pybind11
```

--------------------------------

### Set and Get Window Text with Wide Strings

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/cast/strings.md

Demonstrates how to pass Python strings to C++ functions expecting `std::wstring` for setting window text and retrieving it. Strings are automatically encoded/decoded between Python's `str` and C++'s `std::wstring` (UTF-16/UTF-32).

```c++
#define UNICODE
#include <windows.h>

m.def("set_window_text",
    [](HWND hwnd, std::wstring s) {
        // Call SetWindowText with null-terminated UTF-16 string
        ::SetWindowText(hwnd, s.c_str());
    }
);
m.def("get_window_text",
    [](HWND hwnd) {
        const int buffer_size = ::GetWindowTextLength(hwnd) + 1;
        auto buffer = std::make_unique< wchar_t[] >(buffer_size);

        ::GetWindowText(hwnd, buffer.data(), buffer_size);

        std::wstring text(buffer.get());

        // wstring will be converted to Python str
        return text;
    }
);
```

--------------------------------

### MV1PMF Dataset Initialization

Source: https://context7.com/zju3dv/easymocap/llms.txt

Initializes the MV1PMF dataset class for multi-view single-person motion capture. Configure root directory, camera IDs, output path, and model parameters.

```python
from easymocap.dataset import MV1PMF, CONFIG

# Initialize dataset
dataset = MV1PMF(
    root='data/capture',
    cams=['1', '2', '3', '4'],    # Camera subdirectories
    out='data/capture/output',
    config=CONFIG['body25'],
    kpts_type='body25',
    undis=True,                   # Apply undistortion
    no_img=False                  # Load images
)

# Access data
print(f"Total frames: {len(dataset)}")
print(f"Cameras: {dataset.cams}")
print(f"Projection matrices shape: {dataset.Pall.shape}")  # (nViews, 3, 4)

# Get frame data
images, annots = dataset[0]
# images: list of (H, W, 3) arrays
# annots: {'bbox': (nViews, 5), 'keypoints': (nViews, 25, 3)}

# Write results
keypoints3d = np.random.rand(25, 4)
dataset.write_keypoints3d(keypoints3d, nf=0)

smpl_params = {'poses': np.zeros((1, 72)), 'shapes': np.zeros((1, 10)),
               'Rh': np.zeros((1, 3)), 'Th': np.zeros((1, 3))}
dataset.write_smpl(smpl_params, nf=0)
```

--------------------------------

### Create Fortran-ordered NumPy array

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/cast/eigen.md

Demonstrates creating a NumPy array with Fortran storage order to make it compatible with column-major Eigen types.

```python
myarray = np.array(source, order='F')
```

--------------------------------

### MANO Reconstruction Demo (Left Hand)

Source: https://github.com/zju3dv/easymocap/blob/master/doc/quickstart.md

Performs MANO reconstruction for the left hand. Requires the MANO model. Use --body handl and --model manol.

```bash
data=path/to/data
# 2.3 example for MANO reconstruction
#     MANO model is required for this part
python3 apps/demo/mv1p.py ${data} --out ${data}/output/manol --vis_det --vis_repro --undis --sub_vis 1 7 13 19 --body handl --model manol --gender male --vis_smpl
```

--------------------------------

### Visualize Multiple Person Skeletons

Source: https://github.com/zju3dv/easymocap/blob/master/doc/realtime_visualization.md

Visualize skeletons for multiple people simultaneously. This requires sending keypoint data for all individuals and potentially adjusting the client's step parameter.

```bash
python3 apps/vis/vis_server.py --cfg config/vis3d/o3d_scene.yml write True out ${vis}/output/skel-multi camera.cz 3. camera.cy 0.5
python3 apps/vis/vis_client.py --path ${vis}/multi/keypoints3d --step 4
```

--------------------------------

### Initial pybind11 module bindings

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/classes.md

Standard binding code before adding trampoline support.

```cpp
PYBIND11_MODULE(example, m) {
    py::class_<Animal>(m, "Animal")
        .def("go", &Animal::go);

    py::class_<Dog, Animal>(m, "Dog")
        .def(py::init<>());

    m.def("call_go", &call_go);
}
```

--------------------------------

### SMPL Reconstruction Demo

Source: https://github.com/zju3dv/easymocap/blob/master/doc/quickstart.md

Performs SMPL reconstruction from multiview images. Use --vis_det and --vis_repro for visualization, and --undis to undistort images.

```bash
data=path/to/data
# 2.1 example for SMPL reconstruction
python3 apps/demo/mv1p.py ${data} --out ${data}/output/smpl --vis_det --vis_repro --undis --sub_vis 1 7 13 19 --vis_smpl
```

--------------------------------

### Video Composition with ffmpeg_wrapper

Source: https://context7.com/zju3dv/easymocap/llms.txt

Utilizes the ffmpeg_wrapper module to compose frames into a video. This command-line approach is useful for quick video generation from image sequences.

```bash
# Using the ffmpeg_wrapper module
python3 -m easymocap.visualize.ffmpeg_wrapper output/smplmesh --fps 50
```

--------------------------------

### MANO Reconstruction Demo (Right Hand)

Source: https://github.com/zju3dv/easymocap/blob/master/doc/quickstart.md

Performs MANO reconstruction for the right hand. Requires the MANO model. Use --body handr and --model manor.

```bash
data=path/to/data
python3 apps/demo/mv1p.py ${data} --out ${data}/output/manor --vis_det --vis_repro --undis --sub_vis 1 7 13 19 --body handr --model manor --gender male --vis_smpl
```

--------------------------------

### Define Custom Constructors with py::init

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/upgrade.md

The new py::init() approach is preferred over placement-new for defining custom constructors, improving type safety and preventing accidental initialization errors. Warnings for old-style constructors are visible in debug mode.

```cpp
// old -- deprecated (runtime warning shown only in debug mode)
py::class_<Foo>(m, "Foo")
    .def("__init__", [](Foo &self, ...) {
        new (&self) Foo(...); // uses placement-new
    });

// new
py::class_<Foo>(m, "Foo")
    .def(py::init([](...) { // Note: no `self` argument
        return new Foo(...); // return by raw pointer
        // or: return std::make_unique<Foo>(...); // return by holder
        // or: return Foo(...); // return by value (move constructor)
    }));
```

--------------------------------

### Directory Structure for Optional Models

Source: https://github.com/zju3dv/easymocap/blob/master/doc/installation.md

Place optional SPIN and 2D models in this directory structure. SPIN models are used for specific scripts, and 2D models can be skipped if using OpenPose.

```bash
data
└── models
    ├── smpl_mean_params.npz
    ├── spin_checkpoint.pt
    ├── pose_hrnet_w48_384x288.pth
    └── yolov4.weights 
```

--------------------------------

### Advanced Factory Constructor Bindings

Source: https://github.com/zju3dv/easymocap/blob/master/3rdparty/pybind11/docs/advanced/classes.md

Demonstrates mixing factory functions returning values, pointers, or unique_ptrs with standard constructor bindings.

```cpp
class Example {
private:
    Example(int); // private constructor
public:
    // Factory function - returned by value:
    static Example create(int a) { return Example(a); }

    // These constructors are publicly callable:
    Example(double);
    Example(int, int);
    Example(std::string);
};

py::class_<Example>(m, "Example")
    // Bind the factory function as a constructor:
    .def(py::init(&Example::create))
    // Bind a lambda function returning a pointer wrapped in a holder:
    .def(py::init([](std::string arg) {
        return std::unique_ptr<Example>(new Example(arg));
    }))
    // Return a raw pointer:
    .def(py::init([](int a, int b) { return new Example(a, b); }))
    // You can mix the above with regular C++ constructor bindings as well:
    .def(py::init<double>())
    ;
```

--------------------------------

### Mesh Rendering with Pyrender

Source: https://context7.com/zju3dv/easymocap/llms.txt

Renders SMPL meshes onto images using the Renderer class with pyrender for visualization. Requires mesh vertices, faces, camera parameters, and input images.

```python
from easymocap.visualize.renderer import Renderer
import numpy as np
import cv2

# Initialize renderer
renderer = Renderer(
    height=1080,
    width=1920,
    faces=None,  # Will use mesh faces
    bg_color=[0.0, 0.0, 0.0, 0.0]  # Transparent background
)

# Prepare render data
vertices = np.random.rand(6890, 3)  # SMPL vertices
faces = np.random.randint(0, 6890, (13776, 3))  # Mesh faces

render_data = {
    0: {
        'vertices': vertices,
        'faces': faces,
        'vid': 0,
        'name': 'human_0'
    }
}

# Camera parameters
cameras = {
    'K': np.array([[[1000, 0, 960], [0, 1000, 540], [0, 0, 1]]]),
    'R': np.array([np.eye(3)]),
    'T': np.array([[[0], [0], [3]]])
}

# Input images
images = [np.zeros((1080, 1920, 3), dtype=np.uint8)]

# Render
output_images = renderer.render(
    render_data,
    cameras,
    images,
    add_back=True  # Composite with background
)

cv2.imwrite('render_output.jpg', output_images[0])
```
Tokens:
Raw