Momentum

https://facebookresearch.github.io/momentum/
Admin
Momentum is a library for human kinematic motion and numerical optimization solvers that enables...
Tokens:1,861,902
Snippets:9,747
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Run Hello World Example

Source: https://facebookresearch.github.io/momentum/docs/user_guide/getting_started

Execute the 'hello_world' example using Pixi.

```bash
pixi run hello_world
```

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

### Run Other Momentum Examples

Source: https://facebookresearch.github.io/momentum/docs/user_guide/getting_started

Launch other examples, such as 'glb_viewer', and view their help information using Pixi.

```bash
pixi run glb_viewer --help
```

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

### Install Momentum from Source

Source: https://facebookresearch.github.io/momentum/pymomentum/developer_guide/conda_publishing

Install the Momentum project after cloning and setting up the environment. This command installs the package using pip.

```bash
pip install .
```

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

### Install PyMomentum with PyPI or uv

Source: https://facebookresearch.github.io/momentum/pymomentum/user_guide/getting_started

Experimental installation method using uv or pip for standard Python projects.

```bash
# Using uv (preferred over pip)  
uv add pymomentum-cpu   # CPU version  
uv add pymomentum-gpu   # GPU version (requires CUDA)  
  
# Alternative: Using pip  
pip install pymomentum-cpu  
pip install pymomentum-gpu  
```

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

### Install PyMomentum with Pixi

Source: https://facebookresearch.github.io/momentum/pymomentum/user_guide/getting_started

Use Pixi to manage dependencies and install PyMomentum for development or reproducible environments.

```bash
# Auto-detects GPU/CPU based on system  
pixi add pymomentum  
  
# Explicit backend selection  
pixi add pymomentum-cpu  # CPU-only  
pixi add pymomentum-gpu  # GPU (CUDA) support  
```

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

### Install core dependencies

Source: https://facebookresearch.github.io/momentum/pymomentum/user_guide/getting_started

Install the required PyTorch, Eigen, and Ceres-solver libraries using conda.

```bash
conda install -c conda-forge pytorch eigen ceres-solver
```

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

### Get PyMomentum Package Information

Source: https://facebookresearch.github.io/momentum/pymomentum/developer_guide/conda_publishing

Use these conda commands to inspect details and installed files of the PyMomentum package.

```bash
# Show package info  
conda info pymomentum  
  
# List installed files  
conda list pymomentum --show-channel-urls  
```

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

### Get Universal Locator Parameter Set

Source: https://facebookresearch.github.io/momentum/doxygen/multipose__solver__function_8cpp_source.html

Constructs a parameter set for universal locator parameters. It iterates through all model parameters and identifies those marked as universal and starting with an underscore.

```cpp
158ParameterSet MultiposeSolverFunctionT<T>::getUniversalLocatorParameterSet() const {
159 ParameterSet res = ParameterSet();
160
161 size_t count = 0;
162 for (Eigen::Index i = 0; i < parameterTransform_->numAllModelParameters(); i++) {
163 if (universal_[i] > 0.0f) {
164 if (parameterTransform_->name[i][0] == '_') {
165 res.set(genericParameters_.size() * getNumFrames() + count);
166 }
167 count++;
168 }
169 }
170
171 return res;
172}
```

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

### Initialize a camera with pymomentum

Source: https://facebookresearch.github.io/momentum/pymomentum/examples/visualization_pymomentum_rasterizer

Demonstrates creating a pinhole camera model, setting extrinsics, and framing 3D vertices within the view.

```python
import pymomentum.camera as pym_camera  
import pymomentum.renderer as pym_renderer  
import numpy as np  
  
image_height, image_width = 800, 1000  
  
# Create a pinhole intrinsics model  
intrinsics = pym_camera.PinholeIntrinsicsModel(  
    image_width=image_width,  
    image_height=image_height,  
    fx=800.0,  # focal length in pixels  
    fy=800.0,  
    cx=image_width / 2.0,  # principal point  
    cy=image_height / 2.0  
)  
  
# Create a camera with the intrinsics  
camera = pym_camera.Camera(intrinsics)  
  
# Move the camera along -z and look at the origin  
camera = camera.look_at(  
    position=np.array([0, 0, 1]), target=np.zeros(3), up=np.array([0, 1, 0])  
)  
  
# Make sure the entire object is in view:  
camera = camera.frame(vertex_positions)  
```

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

### Initialize all parameters

Source: https://facebookresearch.github.io/momentum/doxygen/math_2utility_8h_source.html

Creates and returns a ParameterSet with all parameters enabled.

```cpp
inline ParameterSet allParams() {
 ParameterSet params;
 params.set();
 return params;
}
```

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

### Install PyMomentum from Conda-Forge

Source: https://facebookresearch.github.io/momentum/pymomentum/developer_guide/conda_publishing

Use this command to install the PyMomentum package from the conda-forge channel.

```bash
conda install -c conda-forge pymomentum
```

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

### Open Project in Visual Studio

Source: https://facebookresearch.github.io/momentum/docs/developer_guide/development_environment

Launch the project in Microsoft Visual Studio 2022 on Windows.

```bash
pixi run open_vs
```

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

### Initialize Solver

Source: https://facebookresearch.github.io/momentum/doxygen/gauss__newton__solver_8cpp_source.html

Prepares the solver by updating the mapping of enabled parameters.

```cpp
template <typename T>
void GaussNewtonSolverT<T>::initializeSolver() {
 // This is called from the solver base class .solve()

 // Build enabled parameters mapping from activeParameters_ bitset
 updateEnabledParameters();
}
```

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

### Install Momentum C++ with Conda

Source: https://facebookresearch.github.io/momentum/docs/user_guide/getting_started

Use this command to install the Momentum C++ library from the conda-forge channel.

```bash
conda install -c conda-forge momentum-cpp
```

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

### Generate and Inspect PyPI Configurations

Source: https://facebookresearch.github.io/momentum/pymomentum/developer_guide/pypi_publishing

Run these commands locally to generate the PyPI configuration files and inspect the CPU and GPU constraints.

```bash
pixi run generate_pyproject  
cat pyproject-pypi-cpu.toml    # Check CPU constraints  
cat pyproject-pypi-gpu.toml    # Check GPU constraints  
```

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

### Initialize SequenceSolverT Solver

Source: https://facebookresearch.github.io/momentum/doxygen/sequence__solver_8cpp_source.html

Initializes the solver by calculating the bandwidth based on the number of frames in the error functions.

```cpp
template <typename T>
void SequenceSolverT<T>::initializeSolver() {
   MT_PROFILE_FUNCTION();
   
   auto* fn = dynamic_cast<SequenceSolverFunctionT<T>*>(this->solverFunction_);
   MT_CHECK(fn != nullptr);
   
   this->bandwidth_ = 1;
   for (const auto& frameErrf : fn->sequenceErrorFunctions_) {
      for (const auto& errf : frameErrf) {
         this->bandwidth_ = std::max(this->bandwidth_, errf->numFrames());
      }
   }
}
```

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

### Install specific version with CUDA constraints

Source: https://facebookresearch.github.io/momentum/pymomentum/user_guide/getting_started

Install a specific version of PyMomentum compatible with a specific CUDA version.

```bash
# Example: Install version 0.1.74 with CUDA 12.9
conda install -c conda-forge pymomentum=0.1.74="cuda129*"
```

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

### Solver Configuration and Initialization

Source: https://facebookresearch.github.io/momentum/doxygen/classmomentum_1_1SolverT.html

Methods for initializing the solver and configuring its behavior.

```APIDOC
## POST /solver/initialize

### Description
Initializes solver state before optimization begins. This is a protected virtual method and typically called internally by derived classes.

### Method
POST

### Endpoint
/solver/initialize

### Response
#### Success Response (200)
- **status** (string) - Indicates successful initialization.

#### Response Example
```json
{
  "status": "initialized"
}
```

## PUT /solver/enabledParameters

### Description
Specifies which parameters should be optimized. This is done using a bitset where each bit indicates if the corresponding parameter is enabled.

### Method
PUT

### Endpoint
/solver/enabledParameters

### Parameters
#### Request Body
- **parameters** (ParameterSet) - Bitset where each bit indicates if the corresponding parameter is enabled.

### Request Example
```json
{
  "parameters": "10110" 
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates successful update of enabled parameters.

#### Response Example
```json
{
  "status": "enabled parameters updated"
}
```

## PUT /solver/options

### Description
Updates solver configuration with new options.

### Method
PUT

### Endpoint
/solver/options

### Parameters
#### Request Body
- **options** (SolverOptions) - An object containing the new solver configuration options.

### Request Example
```json
{
  "options": {
    "maxIterations": 500,
    "tolerance": 1e-6
  }
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates successful update of solver options.

#### Response Example
```json
{
  "status": "options updated"
}
```

## PUT /solver/parameters

### Description
Sets the current parameter values without initiating a solve.

### Method
PUT

### Endpoint
/solver/parameters

### Parameters
#### Request Body
- **params** (Eigen::VectorX<T>) - A vector containing the new parameter values.

### Request Example
```json
{
  "params": [1.0, 2.5, 3.0, ...]
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates successful update of parameters.

#### Response Example
```json
{
  "status": "parameters set"
}
```

## PUT /solver/storeHistory

### Description
Controls whether to store iteration history for debugging and analysis.

### Method
PUT

### Endpoint
/solver/storeHistory

### Parameters
#### Request Body
- **b** (bool) - A boolean value; true to enable history storage, false to disable.

### Request Example
```json
{
  "b": true
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates whether history storage is enabled or disabled.

#### Response Example
```json
{
  "status": "history storage enabled"
}
```
```

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

### Build and Check Test Wheels Locally

Source: https://facebookresearch.github.io/momentum/pymomentum/developer_guide/pypi_publishing

Execute these commands to clean previous builds, create a test wheel for a specific Python version, and check its PyPI compatibility.

```bash
pixi run -e py312 clean_dist  
pixi run -e py312 build_pypi_wheel  
pixi run -e py312 check_pypi  
```

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

### Get Jacobian Size (Templated)

Source: https://facebookresearch.github.io/momentum/doxygen/collision__error__function__stateless_8cpp_source.html

Templated function to get the size of the Jacobian matrix. This is used to pre-allocate memory for the Jacobian.

```cpp
template <typename T>
size_t CollisionErrorFunctionStatelessT<T>::getJacobianSize() const {
 return validPairs_.size();
}
size_t CollisionErrorFunctionStatelessT::getJacobianSize() const  {…}
```

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

### Install Specific PyMomentum Versions

Source: https://facebookresearch.github.io/momentum/pymomentum/developer_guide/conda_publishing

Commands for installing specific versions of PyMomentum, including version with CUDA constraints and specific Python versions.

```bash
# Install specific version  
conda install -c conda-forge pymomentum=0.1.77  
  
# Install specific version with CUDA constraint  
conda install -c conda-forge "pymomentum=0.1.77=cuda129*"  
  
# Install specific Python version  
conda install -c conda-forge "pymomentum=0.1.77=*py312*"  
```

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

### Initialize FBX Exporter

Source: https://facebookresearch.github.io/momentum/doxygen/fbx__io_8cpp_source.html

Initializes the FBX SDK manager, I/O settings, and exporter. Sets up the output filename and checks for initialization errors.

```cpp
void saveFbxCommon(
    const filesystem::path& filename,
    const Character& character,
    const MatrixXf& jointValues,
    const double framerate,
    const bool saveMesh,
    const bool skipActiveJointParamCheck,
    const FbxCoordSystemInfo& coordSystemInfo,
    Permissive permissive,
    std::span<const std::vector<Marker>> markerSequence,
    std::string_view fbxNamespace,
    const MatrixXf& poses) {
    // ---------------------------------------------
    // initialize FBX SDK and prepare for export
    // ---------------------------------------------
    auto* manager = ::fbxsdk::FbxManager::Create();
    auto* ios = ::fbxsdk::FbxIOSettings::Create(manager, IOSROOT);
    manager->SetIOSettings(ios);

    // Create an exporter.
    ::fbxsdk::FbxExporter* lExporter = ::fbxsdk::FbxExporter::Create(manager, "");

    // Declare the path and filename of the file containing the scene.
    // In this case, we are assuming the file is in the same directory as the executable.
    // Going through string() because on windows, wchar_t (native filesystem path) are different from
    // char https://en.cppreference.com/w/cpp/language/types This avoids a build error on windows
    // only.
    std::string sFilename = filename.string();
    const char* lFilename = sFilename.c_str();

    // Initialize the exporter.
    bool lExportStatus = lExporter->Initialize(lFilename, -1, manager->GetIOSettings());

    MT_THROW_IF(
        !lExportStatus,
        "Unable to initialize fbx exporter {}",
        lExporter->GetStatus().GetErrorString());

    // Normalize namespace: ensure it ends with ':' if not empty
    std::string namespacePrefix(fbxNamespace);
    if (!namespacePrefix.empty() && namespacePrefix.back() != ':') {
        namespacePrefix += ":";
    }

    // ---------------------------------------------
    // create the scene
    // ---------------------------------------------
    ::fbxsdk::FbxScene* scene = ::fbxsdk::FbxScene::Create(manager, "momentum_scene");
    ::fbxsdk::FbxNode* root = scene->GetRootNode();
    MT_THROW_IF(root == nullptr, "Unable to get root node from FBX scene");

    // set the coordinate system
    ::fbxsdk::FbxAxisSystem axis = toFbx(coordSystemInfo);
    axis.ConvertScene(scene);

    // Create skeleton hierarchy
    auto skeletonResult = createSkeletonNodes(character, scene);
    addMetaData(skeletonResult.rootNode, character);
    createLocatorNodes(character, scene, skeletonResult.nodes);
    createCollisionGeometryNodes(character, scene, skeletonResult.nodes);

    // Create mesh with blend shapes
    MeshBlendShapeResult meshResult;
    if (saveMesh && character.mesh != nullptr) {
        meshResult =
            createMeshNode(character, scene, root, skeletonResult.jointToNodeMap, permissive, filename);
    }

    // Add skeleton to scene root
    if (!skeletonResult.nodes.empty()) {

```

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

### Install Momentum using Pixi

Source: https://facebookresearch.github.io/momentum/docs/user_guide/creating_your_applications

Install Momentum and its dependencies within a Pixi virtual environment. This command builds Momentum in Release mode and sets up environment variables for CMake.

```bash
pixi run install  
```

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

### Get Input Vector by Name (Internal Implementation)

Source: https://facebookresearch.github.io/momentum/doxygen/fully__differentiable__skeleton__error__function_8cpp_source.html

Internal function to get an input vector by name, populating the provided reference. Assumes size validation has already occurred.

```cpp
void FullyDifferentiableSkeletonErrorFunctionT<T>::getInput(
 const std::string& name,
 Eigen::Ref<Eigen::VectorX<T>> value) const {
 const auto expectedSize = getInputSize(name);
 MT_THROW_IF(
 value.size() != expectedSize,
 "In {}::getInput({}): expected size {} but got {}",
 this->name(),
 name,
 expectedSize,
 value.size());

 getInputImp(name, value);
}
```

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

### Build Momentum Project

Source: https://facebookresearch.github.io/momentum/docs/user_guide/getting_started

Build the Momentum project using Pixi. The first run may take a few minutes to install dependencies.

```bash
pixi run build
```

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

### Momentum Namespace Members - Functions starting with 'b'

Source: https://facebookresearch.github.io/momentum/doxygen/namespacemembers_b.html

This section lists functions within the 'momentum' namespace whose names start with the letter 'b'. These functions are related to various kinematic and optimization tasks.

```APIDOC
## Namespace Members - Functions starting with 'b'

### Description
This section lists functions within the 'momentum' namespace whose names start with the letter 'b'. These functions are related to various kinematic and optimization tasks.

### Method
N/A (These are library functions, not API endpoints)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## Functions

### bakeGloveOffsetsFromParams()
- **Namespace**: momentum
- **Description**: Adjusts glove offsets based on provided parameters.

### bindMeshToJoint()
- **Namespace**: momentum
- **Description**: Binds a mesh to a specified joint.

### blendTransforms()
- **Namespace**: momentum
- **Description**: Blends multiple transformations together.

### buildHierarchicalPaths()
- **Namespace**: momentum
- **Description**: Constructs hierarchical paths.

### buildJetMat()
- **Namespace**: momentum
- **Description**: Builds a jet matrix.

### buildJetVec()
- **Namespace**: momentum
- **Description**: Builds a jet vector.

### buildTriangleAdjacency()
- **Namespace**: momentum
- **Description**: Computes triangle adjacency information.
```

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

### Build Momentum with FBX SDK on Windows (cmd)

Source: https://facebookresearch.github.io/momentum/docs/user_guide/getting_started

Build Momentum from source on Windows with FBX SDK support enabled using the command prompt. Ensure the FBX SDK is installed separately.

```cmd
set MOMENTUM_BUILD_WITH_FBXSDK=ON && pixi run <target>
```

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

### Run Hello World Executable Directly

Source: https://facebookresearch.github.io/momentum/docs/user_guide/getting_started

Directly execute the compiled 'hello_world' program. The path may vary based on the operating system.

```bash
# Linux and macOS
./build/hello_world
```

```bash
# Windows
./build/Release/hello_world.exe
```

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

### getJacobianSize()

Source: https://facebookresearch.github.io/momentum/doxygen/classmomentum_1_1JointToJointOrientationErrorFunctionT.html

Gets the size of the Jacobian matrix.

```APIDOC
## getJacobianSize()

### Description
Get the size of the Jacobian matrix.

### Method
size_t

### Endpoint
N/A (Class method)

### Response
#### Success Response (200)
- **size** (size_t) - The size of the Jacobian matrix.
```

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

### Solver Configuration and Implementation

Source: https://facebookresearch.github.io/momentum/doxygen/gauss__newton__solver__qr_8cpp_source.html

Overview of the solver options and available implementations for numerical optimization.

```APIDOC
## Solver Options

### Description
Common options for numerical optimization solvers used within the Momentum project.

### Definition
momentum::SolverOptions (solver.h:19)

## Gauss-Newton Solver

### Description
Implementation of the Gauss-Newton solver using QR decomposition.

### Definition
gauss_newton_solver_qr.h:20

## Available Solvers
- character_solver
- gauss_newton_solver_qr.cpp
```

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

### getInput

Source: https://facebookresearch.github.io/momentum/doxygen/classmomentum_1_1FullyDifferentiableOrientationErrorFunctionT.html

Gets the value of a specific input.

```APIDOC
## getInput()

### Description
Gets the value of a specific input.

### Parameters
- **name** (const std::string &) - The name of the input.

### Returns
Eigen::VectorX< T > - The value of the input.
```

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

### Initialize Gradient Descent Solver

Source: https://facebookresearch.github.io/momentum/doxygen/gradient__descent__solver_8cpp_source.html

Empty initialization method for the solver state.

```cpp
template <typename T>
void GradientDescentSolverT<T>::initializeSolver() {}
```

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

### getInputSize()

Source: https://facebookresearch.github.io/momentum/doxygen/classmomentum_1_1FullyDifferentiableMotionErrorFunctionT.html

Gets the size of a specified input.

```APIDOC
## getInputSize()

### Description
Gets the size of a specified input. Implements momentum::FullyDifferentiableSkeletonErrorFunctionT< T >.

### Method
`finalvirtual`

### Endpoint
N/A (Member function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **_name_** (const std::string &) - Description not available

### Request Example
(No specific request example provided)

### Response
#### Success Response (200)
- **Return Value** (Eigen::Index) - Description not available

#### Response Example
(No specific response example provided)
```

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

### SequenceSolverT Initialization

Source: https://facebookresearch.github.io/momentum/doxygen/sequence__solver_8cpp_source.html

Methods for initializing and configuring the SequenceSolverT optimization solver.

```APIDOC
## Constructor: SequenceSolverT

### Description
Initializes a new instance of the SequenceSolverT class.

### Parameters
- **options** (SolverOptions) - Required - Configuration options for the solver.
- **function** (SequenceSolverFunctionT<T>*) - Required - The solver function to be optimized.

## Method: initializeSolver

### Description
Initializes solver state before optimization begins.

### Method
void initializeSolver()

## Method: setOptions

### Description
Updates solver configuration with new options.

### Parameters
- **options** (SolverOptions) - Required - New configuration options.
```

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

### StateSequenceErrorFunctionT::getJacobianSize

Source: https://facebookresearch.github.io/momentum/doxygen/state__sequence__error__function_8h_source.html

Gets the size of the Jacobian matrix.

```APIDOC
## getJacobianSize

### Description
Gets the size of the Jacobian matrix.

### Method
`const` (implied by `final`)

### Endpoint
N/A (This is a C++ class method)

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **Return Value** (size_t) - The size of the Jacobian matrix.

#### Response Example
None
```

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

### Initialize QR Solver

Source: https://facebookresearch.github.io/momentum/doxygen/trust__region__qr_8cpp_source.html

Initializes the QR solver with the number of parameters and a small lambda value to prevent division by zero during back-substitution.

```cpp
const auto nSubsetParams = gsl::narrow_cast<Eigen::Index>(enabledParameters.size());
T lambda = 1e-10;
this->qrSolver_.reset(nSubsetParams, lambda);
```

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

### getNumParameters

Source: https://facebookresearch.github.io/momentum/doxygen/solver__function_8cpp_source.html

Gets the number of parameters managed by the solver.

```APIDOC
## GET /api/solver/num_parameters

### Description
Returns the total number of parameters that the solver function is configured to handle.

### Method
GET

### Endpoint
/api/solver/num_parameters

### Response
#### Success Response (200)
- **numParameters** (size_t) - The number of parameters.

#### Response Example
```json
{
  "numParameters": 10
}
```
```

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

### Initialize Solver

Source: https://facebookresearch.github.io/momentum/doxygen/subset__gauss__newton__solver_8cpp_source.html

Placeholder for solver initialization logic.

```cpp
template <typename T>
void SubsetGaussNewtonSolverT<T>::initializeSolver() {}
```

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

### Get Bandwidth

Source: https://facebookresearch.github.io/momentum/doxygen/online__householder__qr_8h_source.html

Returns the bandwidth of the R matrix.

```cpp
[[nodiscard]] Eigen::Index bandwidth() const {
 return R_band_.rows();
}
```

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

### Create and Rasterize Buffers

Source: https://facebookresearch.github.io/momentum/pymomentum/examples/visualization_pymomentum_rasterizer

Demonstrates the creation of index and RGB buffers, followed by rasterizing a character. Ensure all necessary buffers are initialized before rasterization.

```python
vertex_index_buffer = pym_renderer.create_index_buffer(camera)
triangle_index_buffer = pym_renderer.create_index_buffer(camera)
normals_buffer = pym_renderer.create_rgb_buffer(camera)

pym_renderer.rasterize_character(character, skel_state, camera,
    z_buffer=z_buffer,
    surface_normals_buffer=normals_buffer,
    vertex_index_buffer=vertex_index_buffer,
    triangle_index_buffer=triangle_index_buffer,
)
```

```python
random_colors = torch.rand(
    max(triangles.shape[0], vertices.shape[0]), 3, dtype=torch.float32
)
# Need to shift by 1 since empty pixels are set to -1 (torch tensor indexing doesn't
# appear to support -1).
triangle_colors = random_colors[triangle_index_buffer.flatten() + 1, :].reshape(
    rgb_buffer.shape
)
vertex_colors = random_colors[vertex_index_buffer.flatten() + 1, :].reshape(
    rgb_buffer.shape
)
```

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

### Get Jacobian

Source: https://facebookresearch.github.io/momentum/doxygen/joint__to__joint__distance__error__function_8h_source.html

Computes the Jacobian of the error function.

```APIDOC
## double getJacobian(const ModelParametersT< T > &params, const SkeletonStateT< T > &state, const MeshStateT< T > &meshState, Ref< MatrixX< T > > jacobian, Ref< VectorX< T > > residual, int &usedRows) override

### Description
Computes the Jacobian of the error function.

### Method
double

### Parameters
#### Path Parameters
- **params** (const ModelParametersT< T > &) - Required - Model parameters.
- **state** (const SkeletonStateT< T > &) - Required - Skeleton state.
- **meshState** (const MeshStateT< T > &) - Required - Mesh state.
- **jacobian** (Ref< MatrixX< T > >) - Required - Matrix to store the computed Jacobian.
- **residual** (Ref< VectorX< T > >) - Required - Vector to store the residual.
- **usedRows** (int &) - Required - Number of rows used in the Jacobian.

### Definition
joint_to_joint_distance_error_function.cpp:165
```

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

### Get Constraints

Source: https://facebookresearch.github.io/momentum/doxygen/joint__to__joint__distance__error__function_8h_source.html

Retrieves all the currently set constraints.

```APIDOC
## const std::vector< JointToJointDistanceConstraintT< T > > & getConstraints() const

### Description
Get all constraints.

### Method
const std::vector< JointToJointDistanceConstraintT< T > > &

### Definition
joint_to_joint_distance_error_function.h:107
```

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

### Configure and Initialize Skeleton Solver

Source: https://facebookresearch.github.io/momentum/doxygen/marker__tracker_8cpp_source.html

Sets up the Gauss-Newton solver with specific parameter masks and registers various error functions for constraints like limits, markers, and floor penetration.

```cpp
const ParameterTransform& pt = character.parameterTransform;
const size_t numMarkers = markerData[0].size();

std::vector<size_t> sortedFrames = frameIndices;
std::sort(sortedFrames.begin(), sortedFrames.end());

// pose parameters need to exclude "locators"
ParameterSet poseParams = pt.getPoseParameters();
const auto& locatorSet = pt.parameterSets.find("locators");
if (locatorSet != pt.parameterSets.end()) {
	poseParams &= ~locatorSet->second;
}

// Exclude glove DOFs from per-frame pose solving
if (gloveConfig) {
	poseParams &= ~pt.getParameterSet("gloves", true);
}

// Apply caller-specified parameter mask
if (config.activeParams) {
	poseParams &= *config.activeParams;
}

// set up the solver
auto solverFunc = SkeletonSolverFunction(character, pt);
GaussNewtonSolverQROptions solverOptions;
solverOptions.maxIterations = config.maxIter;
solverOptions.minIterations = 2;
solverOptions.doLineSearch = false;
solverOptions.verbose = config.debug;
solverOptions.threshold = 1.f;
solverOptions.regularization = config.regularization;
auto solver = GaussNewtonSolverQR(solverOptions, &solverFunc);
solver.setEnabledParameters(poseParams);

// parameter limits constraint
auto limitConstrFunc = std::make_shared<LimitErrorFunction>(character);
limitConstrFunc->setWeight(0.1);
solverFunc.addErrorFunction(limitConstrFunc);

// positional constraint function for markers
auto posConstrFunc = std::make_shared<PositionErrorFunction>(character, config.lossAlpha);
posConstrFunc->setWeight(PositionErrorFunction::kLegacyWeight * config.markerWeight);
solverFunc.addErrorFunction(posConstrFunc);

auto skinnedLocatorPosConstrFunc = std::make_shared<SkinnedLocatorErrorFunction>(character);
skinnedLocatorPosConstrFunc->setWeight(
	PositionErrorFunction::kLegacyWeight * config.markerWeight);
solverFunc.addErrorFunction(skinnedLocatorPosConstrFunc);

// floor penetration constraint data; we assume the world is y-up and floor is y=0 for mocap data.
const auto& floorConstraints = createFloorConstraints<float>(
	"Floor_",
	character.locators,
	Vector3f::UnitY(),
	/* y offset */ 0.0f,
	/* weight */ 5.0f);
auto halfPlaneConstrFunc = std::make_shared<PlaneErrorFunction>(character, /*half plane*/ true);
halfPlaneConstrFunc->setConstraints(floorConstraints);
halfPlaneConstrFunc->setWeight(PlaneErrorFunction::kLegacyWeight);
solverFunc.addErrorFunction(halfPlaneConstrFunc);

// marker constraint data
auto constrData = createConstraintData(markerData, character.locators);
auto skinnedConstrData = createSkinnedConstraintData(markerData, character.skinnedLocators);

// smoothness constraint only for the joints and exclude global dofs because the global transform
// needs to be accurate (may not matter in practice?)
// Only use temporal smoothness if isContinuous is true
std::shared_ptr<ModelParametersErrorFunction> smoothConstrFunc;
if (isContinuous) {
	smoothConstrFunc = std::make_shared<ModelParametersErrorFunction>(
		character, poseParams & ~pt.getRigidParameters());
	smoothConstrFunc->setWeight(config.smoothing);
	solverFunc.addErrorFunction(smoothConstrFunc);
}

// add collision error
std::shared_ptr<CollisionErrorFunction> collisionErrorFunction;
if (config.collisionErrorWeight != 0 && character.collision != nullptr) {
	collisionErrorFunction = std::make_shared<CollisionErrorFunction>(character);
	collisionErrorFunction->setWeight(config.collisionErrorWeight);
	solverFunc.addErrorFunction(collisionErrorFunction);
}

// set up glove error functions (registered once, constraints swapped per frame)
std::optional<GloveErrorFunctions> leftGloveFuncs, rightGloveFuncs;
if (gloveConfig) {
	leftGloveFuncs =
		setupGloveErrorFunctions(solverFunc, character, leftGloveData, *gloveConfig, 0);
	rightGloveFuncs =
		setupGloveErrorFunctions(solverFunc, character, rightGloveData, *gloveConfig, 1);
}

// initialize parameters to contain identity information
// the identity fields will be used but untouched during optimization
// globalParams could also be repurposed to pass in initial pose value
Eigen::VectorXf dof = initialMotion.col(sortedFrames.empty() ? 0 : sortedFrames[0]);
size_t solverFrame = 0;
double priorError = 0.0;
double error = 0.0;

// Use the initial global transform if it's not zero
bool needsInit = isGlobalTransformZero(dof, pt.getRigidParameters());

MatrixXf outMotion = initialMotion;
Eigen::Index outputIndex = 0;
{ // scope the ProgressBar so it returns
	ProgressBar progress(progressLabel, sortedFrames.size());
	for (const auto iFrame : sortedFrames) {
		// For continuous tracking, keep the solved dof from previous frame (temporal coherence)
```

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

### getWeight()

Source: https://facebookresearch.github.io/momentum/doxygen/classmomentum_1_1SkeletonErrorFunctionT.html

Gets the current weight of the error function.

```APIDOC
## getWeight()

| T momentum::SkeletonErrorFunctionT< T >::getWeight () const


```

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

### Run GLB Viewer

Source: https://facebookresearch.github.io/momentum/docs/examples/viewers

Executes the GLB file viewer using the pixi environment.

```bash
pixi run glb_viewer --input <my_file.glb>  
```

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

### SimdPlaneErrorFunction::getJacobianSize

Source: https://facebookresearch.github.io/momentum/doxygen/classmomentum_1_1SimdPlaneErrorFunction.html

Gets the size of the Jacobian for the SimdPlaneErrorFunction.

```APIDOC
## Member Function Documentation
## ◆ getJacobianSize()

### Description
Gets the size of the Jacobian for the SimdPlaneErrorFunction.

### Method
`size_t momentum::SimdPlaneErrorFunction::getJacobianSize() const

### Response
*   **size_t** - The size of the Jacobian.
```

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

### Initialize and Configure SolverT

Source: https://facebookresearch.github.io/momentum/doxygen/solver_8cpp_source.html

The constructor initializes the solver with a function and parameters, while setOptions updates the iteration constraints.

```cpp
/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

#include "momentum/solver/solver.h"

#include "momentum/common/checks.h"
#include "momentum/common/log.h"
#include "momentum/common/profile.h"
#include "momentum/solver/solver_function.h"

#include <gsl/narrow>

namespace momentum {

template <typename T>
SolverT<T>::SolverT(const SolverOptions& options, SolverFunctionT<T>* solver)
 : solverFunction_(solver) {
 numParameters_ = solverFunction_->getNumParameters();
 actualParameters_ = gsl::narrow<int>(numParameters_);
 parameters_.setZero(numParameters_);
 activeParameters_.flip();

 newParameterPattern_ = true;
 setOptions(options);
}
20SolverT<T>::SolverT(const SolverOptions& options, SolverFunctionT<T>* solver) {…}

template <typename T>
void SolverT<T>::setOptions(const SolverOptions& options) {
 minIterations_ = options.minIterations;
 maxIterations_ = options.maxIterations;
```

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

### numConstraints()

Source: https://facebookresearch.github.io/momentum/doxygen/classmomentum_1_1JointToJointOrientationErrorFunctionT.html

Gets the number of currently added constraints.

```APIDOC
## numConstraints()

### Description
Get number of constraints.

### Method
size_t

### Endpoint
N/A (Class method)

### Response
#### Success Response (200)
- **count** (size_t) - The number of constraints.
```

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

### getCharacter

Source: https://facebookresearch.github.io/momentum/doxygen/classmomentum_1_1FullyDifferentiableOrientationErrorFunctionT.html

Gets the character associated with the error function.

```APIDOC
## getCharacter()

### Description
For mesh-based error functions, get access to the underlying character.

### Returns
virtual const Character * - The character.
```

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

### initializeSolver()

Source: https://facebookresearch.github.io/momentum/doxygen/classmomentum_1_1GradientDescentSolverT.html

Initializes the solver state before the optimization process begins.

```APIDOC
## initializeSolver()

### Description
Initializes solver state before optimization begins. Implements momentum::SolverT< T >.

### Method
void

### Endpoint
momentum::GradientDescentSolverT< T >::initializeSolver()
```

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

### Momentum Namespace Members - Types starting with 'b'

Source: https://facebookresearch.github.io/momentum/doxygen/namespacemembers_b.html

This section lists types (classes, structs, enums, etc.) within the 'momentum' namespace whose names start with the letter 'b'. These types represent various data structures and concepts used in the library.

```APIDOC
## Namespace Members - Types starting with 'b'

### Description
This section lists types (classes, structs, enums, etc.) within the 'momentum' namespace whose names start with the letter 'b'. These types represent various data structures and concepts used in the library.

### Method
N/A (These are library types, not API endpoints)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## Types

### BlendShape_const_p
- **Namespace**: momentum
- **Description**: Constant parameter for BlendShape.

### BlendShape_const_u
- **Namespace**: momentum
- **Description**: Constant parameter for BlendShape.

### BlendShape_const_w
- **Namespace**: momentum
- **Description**: Constant parameter for BlendShape.

### BlendShape_p
- **Namespace**: momentum
- **Description**: Parameter for BlendShape.

### BlendShape_u
- **Namespace**: momentum
- **Description**: Parameter for BlendShape.

### BlendShape_w
- **Namespace**: momentum
- **Description**: Parameter for BlendShape.

### BlendShapeBase_const_p
- **Namespace**: momentum
- **Description**: Constant parameter for BlendShapeBase.

### BlendShapeBase_const_u
- **Namespace**: momentum
- **Description**: Constant parameter for BlendShapeBase.

### BlendShapeBase_const_w
- **Namespace**: momentum
- **Description**: Constant parameter for BlendShapeBase.

### BlendShapeBase_p
- **Namespace**: momentum
- **Description**: Parameter for BlendShapeBase.

### BlendShapeBase_u
- **Namespace**: momentum
- **Description**: Parameter for BlendShapeBase.

### BlendShapeBase_w
- **Namespace**: momentum
- **Description**: Parameter for BlendShapeBase.

### BlendWeights
- **Namespace**: momentum
- **Description**: Represents blend weights.

### BlendWeightsd
- **Namespace**: momentum
- **Description**: Represents blend weights (double precision).

### Box
- **Namespace**: momentum
- **Description**: Represents a 3D bounding box.

### Box2
- **Namespace**: momentum
- **Description**: Represents a 2D bounding box.

### Box2d
- **Namespace**: momentum
- **Description**: Represents a 2D bounding box (double precision).

### Box2f
- **Namespace**: momentum
- **Description**: Represents a 2D bounding box (float precision).

### Box2i
- **Namespace**: momentum
- **Description**: Represents a 2D bounding box (integer precision).

### Box3
- **Namespace**: momentum
- **Description**: Represents a 3D bounding box.

### Box3d
- **Namespace**: momentum
- **Description**: Represents a 3D bounding box (double precision).

### Box3f
- **Namespace**: momentum
- **Description**: Represents a 3D bounding box (float precision).

### Box3i
- **Namespace**: momentum
- **Description**: Represents a 3D bounding box (integer precision).

### Boxd
- **Namespace**: momentum
- **Description**: Represents a 3D bounding box (double precision).

### Boxf
- **Namespace**: momentum
- **Description**: Represents a 3D bounding box (float precision).

### Boxi
- **Namespace**: momentum
- **Description**: Represents a 3D bounding box (integer precision).

### ByteP
- **Namespace**: momentum
- **Description**: Represents a byte pointer.
```

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

### Build and Test Momentum

Source: https://facebookresearch.github.io/momentum/pymomentum/user_guide/getting_started

Compile the project and run tests using Pixi.

```bash
pixi run build  
```

```bash
pixi run test_py  
```

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

### Get Constraints

Source: https://facebookresearch.github.io/momentum/doxygen/vertex__error__function_8h_source.html

Retrieves the list of currently defined constraints.

```cpp
const std::vector< Data > & getConstraints() const
```

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

### GradientDescentSolverT Constructor and Name Method

Source: https://facebookresearch.github.io/momentum/doxygen/gradient__descent__solver_8cpp_source.html

Initializes the solver with options and provides the solver name.

```cpp
/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

#include "momentum/solver/gradient_descent_solver.h"

#include "momentum/common/profile.h"
#include "momentum/solver/solver_function.h"

namespace momentum {

template <typename T>
GradientDescentSolverT<T>::GradientDescentSolverT(
 const SolverOptions& options,
 SolverFunctionT<T>* solver)
 : SolverT<T>(options, solver) {
 // Set default values from GradientDescentSolverOptions
 learningRate_ = GradientDescentSolverOptions().learningRate;

 // Update values based on provided options
 setOptions(options);
}
16GradientDescentSolverT<T>::GradientDescentSolverT( {…}

template <typename T>
std::string_view GradientDescentSolverT<T>::getName() const {
 return "GradientDescent";
}
28std::string_view GradientDescentSolverT<T>::getName() const  {…}

template <typename T>
void GradientDescentSolverT<T>::setOptions(const SolverOptions& options) {
```

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

### Run Marker Tracking with Calibrated Model (Config)

Source: https://facebookresearch.github.io/momentum/docs/examples/process_markers

Use this command to track motion data using a pre-calibrated model. Specify the tracking configuration file.

```bash
pixi run process_markers -c process_markers_tracking.config  
```

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

### Get Solver Name

Source: https://facebookresearch.github.io/momentum/doxygen/subset__gauss__newton__solver_8cpp_source.html

Returns the identifier string for the solver.

```cpp
35 return "SubsetGaussNewton";
36}
```

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

### Get Jacobian Size

Source: https://facebookresearch.github.io/momentum/doxygen/skeleton__error__function_8h_source.html

Returns the size of the Jacobian matrix.

```cpp
[[nodiscard]] virtual size_t getJacobianSize() const {
			return 0;
		}
```

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

### Configure and Execute Sequence Solver

Source: https://facebookresearch.github.io/momentum/doxygen/marker__tracker_8cpp_source.html

Initializes character constraints, sets up the sequence solver with various error functions, and executes the optimization process.

```cpp
skinnedLocatorMeshContraints = createSkinnedLocatorMeshConstraints(character);
MT_LOGI(
"Created {} mesh constraints for {} skinned locators",
skinnedLocatorMeshContraints.size(),
character.skinnedLocators.size());
}

// set up the solver function
std::vector<size_t> sortedFrames = frames;
std::sort(sortedFrames.begin(), sortedFrames.end());
size_t solvedFrames = sortedFrames.size();
auto solverFunc = SequenceSolverFunction(
character, character.parameterTransform, universalParams, solvedFrames);

// floor penetration constraints; we assume the world is y-up and floor is y=0 for mocap data.
const auto& floorConstraints = createFloorConstraints<float>(
"Floor_",
character.locators,
Vector3f::UnitY(),
/* y offset */ 0.0f,
/* weight */ 5.0f);

// marker constraints
const auto constrData = createConstraintData(markerData, character.locators);
const auto skinnedConstData = createSkinnedConstraintData(markerData, character.skinnedLocators);

// glove constraint data (one per hand × position/orientation)
std::vector<std::vector<JointToJointPositionDataT<float>>> leftGlovePosData, rightGlovePosData;
std::vector<std::vector<JointToJointOrientationDataT<float>>> leftGloveOriData, rightGloveOriData;
if (gloveConfig) {
leftGlovePosData = createGlovePositionConstraintData(leftGloveData, character, *gloveConfig, 0);
leftGloveOriData =
createGloveOrientationConstraintData(leftGloveData, character, *gloveConfig, 0);
rightGlovePosData =
createGlovePositionConstraintData(rightGloveData, character, *gloveConfig, 1);
rightGloveOriData =
createGloveOrientationConstraintData(rightGloveData, character, *gloveConfig, 1);
}

// add per-frame constraint data to the solver
for (size_t solverFrame = 0; solverFrame < solvedFrames; ++solverFrame) {
const size_t& iFrame = sortedFrames[solverFrame];
if ((constrData.at(iFrame).size() + skinnedConstData.at(iFrame).size()) >
numMarkers * config.minVisPercent) {
addSequenceFrameConstraints(
solverFunc,
solverFrame,
iFrame,
solvedFrames,
character,
config,
constrData,
skinnedConstData,
skinnedLocatorMeshContraints,
floorConstraints,
enforceFloorInFirstFrame,
firstFramePoseConstraintSet,
targetHeightCm,
gloveConfig,
leftGlovePosData,
leftGloveOriData,
rightGlovePosData,
rightGloveOriData);
}
// Set per-frame initial value
solverFunc.setFrameParameters(solverFrame, initialMotion.col(iFrame));
}

// add parameter limits
auto limitConstrFunc = std::make_shared<LimitErrorFunction>(character);
limitConstrFunc->setWeight(0.1);
solverFunc.addErrorFunction(kAllFrames, limitConstrFunc);

// add collision error
if (config.collisionErrorWeight != 0 && character.collision != nullptr) {
auto collisionConstrFunc = std::make_shared<CollisionErrorFunctionStateless>(character);
collisionConstrFunc->setWeight(config.collisionErrorWeight);
solverFunc.addErrorFunction(kAllFrames, collisionConstrFunc);
}

// add a smoothness constraint in parameter space
if (config.smoothing != 0) {
auto smoothConstrFunc = std::make_shared<ModelParametersSequenceErrorFunction>(character);
smoothConstrFunc->setWeight(config.smoothing);
solverFunc.addSequenceErrorFunction(kAllFrames, smoothConstrFunc);
}

// minimize the change to global params
if (globalParams.count() > 0 && regularizer != 0) {
auto regularizerFunc = std::make_shared<ModelParametersErrorFunction>(character);
Eigen::VectorXf universalMask(pt.numAllModelParameters());
for (size_t i = 0; i < universalMask.size(); ++i) {
if (globalParams.test(i)) {
universalMask[i] = regularizer;
} else {
universalMask[i] = 0.0;
}
}
regularizerFunc->setTargetParameters(initialMotion.col(0), universalMask);
// Sufficient to add to the first frame since it won't change.
solverFunc.addErrorFunction(0, regularizerFunc);
}

// solver configration
SequenceSolverOptions solverOptions;
solverOptions.maxIterations = config.maxIter;
solverOptions.minIterations = 2;
solverOptions.progressBar = config.debug;
solverOptions.doLineSearch = false;
solverOptions.multithreaded = true;
solverOptions.verbose = config.debug;
solverOptions.threshold = 1.f;
solverOptions.regularization = config.regularization;

// solve the problem
SequenceSolver solver = SequenceSolver(solverOptions, &solverFunc);
solver.setEnabledParameters(poseParams | globalParams);
// returns all the dofs with initial values nicely packed into a vector
VectorXf dofs = solverFunc.getJoinedParameterVector();
solver.solve(dofs);
double error = solverFunc.getError(dofs);
MT_LOGI_IF(config.debug, "Solver residual: {}", error);
```

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

### Initialize Depth and RGB Buffers

Source: https://facebookresearch.github.io/momentum/pymomentum/examples/visualization_pymomentum_rasterizer

Create buffers for rendering based on a camera object. Note that buffer sizes are padded to multiples of 8 for SIMD performance.

```python
import pymomentum.renderer as pym_renderer  
z_buffer = pym_renderer.create_z_buffer(camera)  
rgb_buffer = pym_renderer.create_rgb_buffer(camera)  
```

```python
z_buffer = z_buffer[:,:camera.image_width]  
rgb_buffer = rgb_buffer[:,:camera.image_height]  
```

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

### Get Weight

Source: https://facebookresearch.github.io/momentum/doxygen/skeleton__error__function_8h_source.html

Returns the current weight of this error function.

```cpp
T getWeight() const {
 return weight_;
 }
```

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

### Get SequenceSolverT Name

Source: https://facebookresearch.github.io/momentum/doxygen/sequence__solver_8cpp_source.html

Returns the name of the SequenceSolverT, which is 'SequenceSolver'.

```cpp
template <typename T>
std::string_view SequenceSolverT<T>::getName() const {
   return "SequenceSolver";
}
```

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

### SequenceSolverT::init

Source: https://facebookresearch.github.io/momentum/doxygen/classmomentum_1_1SequenceSolverT.html

Initializes the solver state before optimization begins.

```APIDOC
## SequenceSolverT::init

### Description
Initializes solver state before optimization begins.

### Method
POST

### Endpoint
N/A (Member function)

### Parameters
None

### Request Example
```cpp
solver.init();
```

### Response
None
```

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

### Build Momentum with FBX SDK on Windows (PowerShell)

Source: https://facebookresearch.github.io/momentum/docs/user_guide/getting_started

Build Momentum from source on Windows with FBX SDK support enabled using PowerShell. Ensure the FBX SDK is installed separately.

```powershell
$env:MOMENTUM_BUILD_WITH_FBXSDK = "ON"; pixi run <target>
```

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

### Get Rows in ColumnIndexedMatrix

Source: https://facebookresearch.github.io/momentum/doxygen/online__householder__qr_8h_source.html

Returns the number of rows in the matrix.

```cpp
[[nodiscard]] auto rows() const {
return mat_.rows();
}
```

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

### Get Solver Name

Source: https://facebookresearch.github.io/momentum/doxygen/multipose__solver_8cpp_source.html

Returns the name of the MultiposeSolver implementation.

```cpp
template <typename T>
std::string_view MultiposeSolverT<T>::getName() const {
 return "MultiposeSolver";
}

```

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

### Build in Custom Conda Environment

Source: https://facebookresearch.github.io/momentum/pymomentum/user_guide/getting_started

Steps to activate a specific environment and navigate to the source directory.

```bash
conda activate your_environment_name  
```

```bash
cd path/to/momentum  
```
Tokens:
Raw