pymomentum-cpu 0.1.93.post0__cp312-cp312-macosx_14_0_arm64.whl

include/momentum/marker_tracking/tracker_utils.h

@@ -0,0 +1,99 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <momentum/character/character.h>
+#include <momentum/character/locator.h>
+#include <momentum/character/marker.h>
+#include <momentum/character_solver/fwd.h>
+#include <momentum/character_solver/skinned_locator_triangle_error_function.h>
+
+namespace momentum {
+
+std::vector<std::vector<momentum::PositionData>> createConstraintData(
+    std::span<const std::vector<momentum::Marker>> markerData,
+    const momentum::LocatorList& locators);
+
+std::vector<std::vector<momentum::SkinnedLocatorConstraint>> createSkinnedConstraintData(
+    std::span<const std::vector<momentum::Marker>> markerData,
+    const momentum::SkinnedLocatorList& locators);
+
+// TODO: remove the one in momentum
+
+// Create a LocatorCharacter where each locator is a bone in its skeleton. This character is used
+// for calibrating locator offsets (as bone offset parameters).
+momentum::Character createLocatorCharacter(
+    const momentum::Character& sourceCharacter,
+    const std::string& prefix);
+
+/// Convert locators to skinned locators by finding the closest point on the mesh surface that
+/// matches the correct bone index and using the skinned weights from that point.  Does not add
+/// parameters for the skinned locators, however, that should be a separate step if you are planning
+/// to solve for their locations.
+/// @param sourceCharacter Character with locators to convert
+/// @param maxDistance Maximum distance to search for the closest point on the mesh surface.  If the
+/// locator is further than this distance, it will not be converted.
+momentum::Character locatorsToSkinnedLocators(
+    const momentum::Character& sourceCharacter,
+    float maxDistance = 3.0f);
+
+/// Convert skinned locators to regular locators by selecting the bone with the highest skin weight.
+/// This is useful when exporting to file formats that don't support skinned locators (e.g., Maya).
+/// Each skinned locator will be converted to a regular locator attached to the bone with the
+/// highest weight. The position will be transformed from the rest pose space to the local space
+/// of the selected bone.
+/// @param sourceCharacter Character with skinned locators to convert
+/// @return Character with skinned locators converted to regular locators
+momentum::Character skinnedLocatorsToLocators(const momentum::Character& sourceCharacter);
+
+std::vector<momentum::SkinnedLocatorTriangleConstraintT<float>> createSkinnedLocatorMeshConstraints(
+    const momentum::Character& character,
+    float targetDepth = 1.0f);
+
+// Extract locator offsets from a LocatorCharacter for a normal Character given input calibrated
+// parameters
+momentum::LocatorList extractLocatorsFromCharacter(
+    const momentum::Character& locatorCharacter,
+    const momentum::CharacterParameters& calibParams);
+
+// TODO: move to momentum proper
+momentum::ModelParameters extractParameters(
+    const momentum::ModelParameters& params,
+    const momentum::ParameterSet& parameterSet);
+
+std::tuple<Eigen::VectorXf, momentum::LocatorList, momentum::SkinnedLocatorList>
+extractIdAndLocatorsFromParams(
+    const momentum::ModelParameters& param,
+    const momentum::Character& sourceCharacter,
+    const momentum::Character& targetCharacter);
+
+Mesh extractBlendShapeFromParams(
+    const momentum::ModelParameters& param,
+    const momentum::Character& sourceCharacter);
+
+void fillIdentity(
+    const momentum::ParameterSet& idSet,
+    const momentum::ModelParameters& identity,
+    Eigen::MatrixXf& motion);
+
+// convert from joint to model parameters using only the parameters active in idSet
+ModelParameters jointIdentityToModelIdentity(
+    const Character& c,
+    const ParameterSet& idSet,
+    const JointParameters& jointIdentity);
+
+void removeIdentity(
+    const momentum::ParameterSet& idSet,
+    const momentum::ModelParameters& identity,
+    Eigen::MatrixXf& motion);
+
+std::vector<std::vector<momentum::Marker>> extractMarkersFromMotion(
+    const momentum::Character& character,
+    const Eigen::MatrixXf& motion);
+
+} // namespace momentum

include/momentum/math/constants.h

@@ -0,0 +1,82 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <limits>
+#include <type_traits>
+
+namespace momentum {
+
+template <typename T = float>
+[[nodiscard]] constexpr T nan() noexcept {
+  return std::numeric_limits<T>::quiet_NaN();
+}
+
+/// Returns the tolerance value based on the provided type T
+template <typename T>
+[[nodiscard]] constexpr T Eps(T FloatEps = T(1e-7), T DoubleEps = T(1e-16)) {
+  if constexpr (std::is_same_v<T, float>) {
+    return FloatEps;
+  } else if constexpr (std::is_same_v<T, double>) {
+    return DoubleEps;
+  }
+}
+
+template <typename T = float>
+[[nodiscard]] constexpr T ln2() noexcept {
+  return 0.69314718055994530942; ///< log_e 2
+}
+
+template <typename T = float>
+[[nodiscard]] constexpr T pi() noexcept {
+  return 3.14159265358979323846;
+}
+
+template <typename T = float>
+[[nodiscard]] constexpr T twopi() noexcept {
+  return T(2) * pi<T>();
+}
+
+/// Converts the given angle x (in degrees) to radians.
+///
+/// If called without an argument, it returns the conversion factor from degrees to radians.
+template <typename T = float>
+[[nodiscard]] constexpr T toRad(T x = T(1)) noexcept {
+  static_assert(std::is_floating_point_v<T>, "toRad requires a floating point argument.");
+  return x * pi<T>() / T(180);
+}
+// TODO: Support Eigen types to provide consistent conversion function usage with a single argument.
+
+/// Converts the given angle x (in radians) to degrees.
+///
+/// If called without an argument, it returns the conversion factor from radians to degrees.
+template <typename T = float>
+[[nodiscard]] constexpr T toDeg(T x = T(1)) noexcept {
+  static_assert(std::is_floating_point_v<T>, "toDeg requires a floating point argument.");
+  return x * T(180) / pi<T>();
+}
+
+/// Converts the given length x (in centimeters) to meters.
+///
+/// If called without an argument, it returns the conversion factor from centimeters to meters.
+template <typename T = float>
+[[nodiscard]] constexpr T toM(T x = T(1)) noexcept {
+  static_assert(std::is_floating_point_v<T>, "toM requires a floating point argument.");
+  return x * T(0.01);
+}
+
+/// Converts the given length x (in meters) to centimeters.
+///
+/// If called without an argument, it returns the conversion factor from meters to centimeters.
+template <typename T = float>
+[[nodiscard]] constexpr T toCm(T x = T(1)) noexcept {
+  static_assert(std::is_floating_point_v<T>, "toCm requires a floating point argument.");
+  return x * T(100);
+}
+
+} // namespace momentum

include/momentum/math/covariance_matrix.h

@@ -0,0 +1,84 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <momentum/math/online_householder_qr.h>
+#include <momentum/math/types.h>
+
+namespace momentum {
+
+//
+// Efficient and numerically stable representation of the generalized
+// Gaussian covariance
+//   C = (sigma^2 * I + A^T * A)
+// providing access to the inverse covariance matrix (computed using
+// QR factorization).
+//
+// Note the dimensionality here: C and I are [n x n], A is [m x n]
+// where m can be either larger or smaller than n.
+template <typename T>
+class LowRankCovarianceMatrixT {
+ public:
+  LowRankCovarianceMatrixT() = default;
+
+  void reset(T sigma, Eigen::Ref<const Eigen::MatrixX<T>> A);
+
+  [[nodiscard]] Eigen::Index dimension() const;
+
+  [[nodiscard]] const Eigen::MatrixX<T>& basis() const;
+
+  [[nodiscard]] T sigma() const;
+
+  [[nodiscard]] Eigen::VectorX<T> inverse_times_vec(Eigen::Ref<const Eigen::VectorX<T>> rhs) const;
+  [[nodiscard]] Eigen::VectorX<T> times_vec(Eigen::Ref<const Eigen::VectorX<T>> rhs) const;
+
+  [[nodiscard]] Eigen::MatrixX<T> inverse_times_mat(Eigen::Ref<const Eigen::MatrixX<T>> rhs) const;
+  [[nodiscard]] Eigen::MatrixX<T> times_mat(Eigen::Ref<const Eigen::MatrixX<T>> rhs) const;
+
+  [[nodiscard]] const Eigen::MatrixX<T>& R() const;
+
+  // The log of the determinant of the covariance matrix
+  [[nodiscard]] T logDeterminant() const;
+
+  // The log of the determinant of the inverse covariance matrix
+  [[nodiscard]] T inverse_logDeterminant() const;
+
+ private:
+  // The QR factorization of A is defined by:
+  //   A = Q*R
+  // where Q is orthonormal and R is upper triangular.  This online QR solver
+  // used here happens to be particularly efficient for the case where the A
+  // matrix looks like:
+  //    A = [ lambda*I ]
+  //        [    B     ]
+  // The reason for this is that it allows initialization of the R matrix by
+  // a diagonal, and hence only needs to process the rows in W.  The
+  // resulting factorization is O(m*n^2) to compute, which may (for m << n)
+  // be a touch cheaper than the fully general O(n^3) that a "standard" QR
+  // factorization or Cholesky would require.
+  //
+  // Once we have A = Q*R, we can compute (A^T*A)^{-1} by
+  //     (A^T * A)^{-1} = (R^T * Q^T * Q * R)^{-1}
+  //                    = (R^T * R)^{-1}            by orthonormality
+  //                    = (R^{-1}) * R^{-T}         distributing the inverse
+  //
+  // Note that OnlineHouseholderQR does _not_ store the Q matrix (or the
+  // information required to reconstruct it, as is more typical) because it
+  // assumes that it will be used to solve least squares problems of the form
+  // min |Ax - b|_2 and hence can apply Q to b as it is being computed.  In
+  // our case, however, as noted above we won't be using the Q matrix so this
+  // is not a limitation.
+  OnlineHouseholderQR<T> qrFactorization_{0};
+
+  // Low-rank basis:
+  Eigen::MatrixX<T> A_;
+
+  T sigma_ = 0;
+};
+
+} // namespace momentum

include/momentum/math/fmt_eigen.h

@@ -0,0 +1,23 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <fmt/ostream.h>
+#include <Eigen/Core>
+
+#if FMT_VERSION > 100000
+
+// https://stackoverflow.com/a/73755864
+#ifndef MOMENTUM_FMT_EIGEN_SHARED_PTR_FORMATTER
+#define MOMENTUM_FMT_EIGEN_SHARED_PTR_FORMATTER
+template <typename T>
+struct fmt::formatter<T, std::enable_if_t<std::is_base_of_v<Eigen::DenseBase<T>, T>, char>>
+    : ostream_formatter {};
+#endif
+
+#endif

include/momentum/math/fwd.h

@@ -0,0 +1,132 @@
+/*
+ * 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.
+ */
+
+// This file is @generated by gen_fwd.py
+// Do not edit this file directly, instead update gen_fwd_input.toml and run:
+// buck run @arvr/mode/platform010/opt //arvr/libraries/momentum:gen_fwd
+
+#pragma once
+
+#include <memory>
+
+namespace momentum {
+
+template <typename T>
+struct MeshT;
+using Mesh = MeshT<float>;
+using Meshd = MeshT<double>;
+
+using Mesh_p = ::std::shared_ptr<Mesh>;
+using Mesh_u = ::std::unique_ptr<Mesh>;
+using Mesh_w = ::std::weak_ptr<Mesh>;
+using Mesh_const_p = ::std::shared_ptr<const Mesh>;
+using Mesh_const_u = ::std::unique_ptr<const Mesh>;
+using Mesh_const_w = ::std::weak_ptr<const Mesh>;
+
+using Meshd_p = ::std::shared_ptr<Meshd>;
+using Meshd_u = ::std::unique_ptr<Meshd>;
+using Meshd_w = ::std::weak_ptr<Meshd>;
+using Meshd_const_p = ::std::shared_ptr<const Meshd>;
+using Meshd_const_u = ::std::unique_ptr<const Meshd>;
+using Meshd_const_w = ::std::weak_ptr<const Meshd>;
+
+template <typename T>
+struct MppcaT;
+using Mppca = MppcaT<float>;
+using Mppcad = MppcaT<double>;
+
+using Mppca_p = ::std::shared_ptr<Mppca>;
+using Mppca_u = ::std::unique_ptr<Mppca>;
+using Mppca_w = ::std::weak_ptr<Mppca>;
+using Mppca_const_p = ::std::shared_ptr<const Mppca>;
+using Mppca_const_u = ::std::unique_ptr<const Mppca>;
+using Mppca_const_w = ::std::weak_ptr<const Mppca>;
+
+using Mppcad_p = ::std::shared_ptr<Mppcad>;
+using Mppcad_u = ::std::unique_ptr<Mppcad>;
+using Mppcad_w = ::std::weak_ptr<Mppcad>;
+using Mppcad_const_p = ::std::shared_ptr<const Mppcad>;
+using Mppcad_const_u = ::std::unique_ptr<const Mppcad>;
+using Mppcad_const_w = ::std::weak_ptr<const Mppcad>;
+
+template <typename T>
+struct TransformT;
+using Transform = TransformT<float>;
+using Transformd = TransformT<double>;
+
+using Transform_p = ::std::shared_ptr<Transform>;
+using Transform_u = ::std::unique_ptr<Transform>;
+using Transform_w = ::std::weak_ptr<Transform>;
+using Transform_const_p = ::std::shared_ptr<const Transform>;
+using Transform_const_u = ::std::unique_ptr<const Transform>;
+using Transform_const_w = ::std::weak_ptr<const Transform>;
+
+using Transformd_p = ::std::shared_ptr<Transformd>;
+using Transformd_u = ::std::unique_ptr<Transformd>;
+using Transformd_w = ::std::weak_ptr<Transformd>;
+using Transformd_const_p = ::std::shared_ptr<const Transformd>;
+using Transformd_const_u = ::std::unique_ptr<const Transformd>;
+using Transformd_const_w = ::std::weak_ptr<const Transformd>;
+
+template <typename T>
+class LowRankCovarianceMatrixT;
+using LowRankCovarianceMatrix = LowRankCovarianceMatrixT<float>;
+using LowRankCovarianceMatrixd = LowRankCovarianceMatrixT<double>;
+
+using LowRankCovarianceMatrix_p = ::std::shared_ptr<LowRankCovarianceMatrix>;
+using LowRankCovarianceMatrix_u = ::std::unique_ptr<LowRankCovarianceMatrix>;
+using LowRankCovarianceMatrix_w = ::std::weak_ptr<LowRankCovarianceMatrix>;
+using LowRankCovarianceMatrix_const_p = ::std::shared_ptr<const LowRankCovarianceMatrix>;
+using LowRankCovarianceMatrix_const_u = ::std::unique_ptr<const LowRankCovarianceMatrix>;
+using LowRankCovarianceMatrix_const_w = ::std::weak_ptr<const LowRankCovarianceMatrix>;
+
+using LowRankCovarianceMatrixd_p = ::std::shared_ptr<LowRankCovarianceMatrixd>;
+using LowRankCovarianceMatrixd_u = ::std::unique_ptr<LowRankCovarianceMatrixd>;
+using LowRankCovarianceMatrixd_w = ::std::weak_ptr<LowRankCovarianceMatrixd>;
+using LowRankCovarianceMatrixd_const_p = ::std::shared_ptr<const LowRankCovarianceMatrixd>;
+using LowRankCovarianceMatrixd_const_u = ::std::unique_ptr<const LowRankCovarianceMatrixd>;
+using LowRankCovarianceMatrixd_const_w = ::std::weak_ptr<const LowRankCovarianceMatrixd>;
+
+template <typename T>
+class GeneralizedLossT;
+using GeneralizedLoss = GeneralizedLossT<float>;
+using GeneralizedLossd = GeneralizedLossT<double>;
+
+using GeneralizedLoss_p = ::std::shared_ptr<GeneralizedLoss>;
+using GeneralizedLoss_u = ::std::unique_ptr<GeneralizedLoss>;
+using GeneralizedLoss_w = ::std::weak_ptr<GeneralizedLoss>;
+using GeneralizedLoss_const_p = ::std::shared_ptr<const GeneralizedLoss>;
+using GeneralizedLoss_const_u = ::std::unique_ptr<const GeneralizedLoss>;
+using GeneralizedLoss_const_w = ::std::weak_ptr<const GeneralizedLoss>;
+
+using GeneralizedLossd_p = ::std::shared_ptr<GeneralizedLossd>;
+using GeneralizedLossd_u = ::std::unique_ptr<GeneralizedLossd>;
+using GeneralizedLossd_w = ::std::weak_ptr<GeneralizedLossd>;
+using GeneralizedLossd_const_p = ::std::shared_ptr<const GeneralizedLossd>;
+using GeneralizedLossd_const_u = ::std::unique_ptr<const GeneralizedLossd>;
+using GeneralizedLossd_const_w = ::std::weak_ptr<const GeneralizedLossd>;
+
+template <typename T>
+class SimdGeneralizedLossT;
+using SimdGeneralizedLoss = SimdGeneralizedLossT<float>;
+using SimdGeneralizedLossd = SimdGeneralizedLossT<double>;
+
+using SimdGeneralizedLoss_p = ::std::shared_ptr<SimdGeneralizedLoss>;
+using SimdGeneralizedLoss_u = ::std::unique_ptr<SimdGeneralizedLoss>;
+using SimdGeneralizedLoss_w = ::std::weak_ptr<SimdGeneralizedLoss>;
+using SimdGeneralizedLoss_const_p = ::std::shared_ptr<const SimdGeneralizedLoss>;
+using SimdGeneralizedLoss_const_u = ::std::unique_ptr<const SimdGeneralizedLoss>;
+using SimdGeneralizedLoss_const_w = ::std::weak_ptr<const SimdGeneralizedLoss>;
+
+using SimdGeneralizedLossd_p = ::std::shared_ptr<SimdGeneralizedLossd>;
+using SimdGeneralizedLossd_u = ::std::unique_ptr<SimdGeneralizedLossd>;
+using SimdGeneralizedLossd_w = ::std::weak_ptr<SimdGeneralizedLossd>;
+using SimdGeneralizedLossd_const_p = ::std::shared_ptr<const SimdGeneralizedLossd>;
+using SimdGeneralizedLossd_const_u = ::std::unique_ptr<const SimdGeneralizedLossd>;
+using SimdGeneralizedLossd_const_w = ::std::weak_ptr<const SimdGeneralizedLossd>;
+
+} // namespace momentum

include/momentum/math/generalized_loss.h

@@ -0,0 +1,61 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+namespace momentum {
+
+/// Implementation of "A General and Adaptive Robust Loss Function"
+/// (https://arxiv.org/abs/1701.03077).
+/// This loss transforms a squared error value with parameters alpha and c.
+/// Alpha can be approximately thought of as the norm: alpha=2 is the squared L2 norm loss; alpha=1
+/// is a soft L1 norm or the L2-L1/pseudo-Huber loss. Alpha controls the effect of "outliers" (ie.
+/// "robust"). Smaller alpha reduces the contribution of large errors so they don't affect the
+/// result as much. c scales the gradient with respect to the squared error term inversely.
+/// This does not implement solving for alpha. It assumes alpha and c are given as input.
+template <typename T>
+class GeneralizedLossT {
+ public:
+  // Special case alpha values that are either at singularity or would simplify computation
+  static constexpr T kL2 = T(2);
+  static constexpr T kL1 = T(1);
+  static constexpr T kCauchy = T(0);
+  static constexpr T kWelsch = -1e-9; // any number smaller is considered -inf
+
+  // Alpha can be [-inf, inf] in theory, but it will be numerically unstable if
+  // alpha is too large, eg. >100 (large alpha not needed in practice).
+  // Similarly, c scales the gradient inversely and quadratically. So too small a value for c will
+  // lead to instability.
+  // Calculations with log and exp usually require double precision.
+  GeneralizedLossT(const T& a = kL2, const T& c = T(1));
+
+  [[nodiscard]] T value(const T& sqrError) const;
+
+  /// Derivative of the loss with respective to the input squared error.
+  /// This effectively scales the gradient of what's being squared.
+  [[nodiscard]] T deriv(const T& sqrError) const;
+
+ protected:
+  enum class LossType {
+    L1,
+    L2,
+    Cauchy,
+    Welsch,
+    General,
+  };
+
+  // A small threshold for special values
+  static constexpr T kEps = 1e-9;
+
+  const T alpha_;
+
+  // store 1/c^2 instead of c as a small optimization
+  const T invC2_;
+
+  LossType lossType_;
+};
+} // namespace momentum

include/momentum/math/intersection.h

@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <momentum/math/fwd.h>
+#include <momentum/math/types.h>
+
+namespace momentum {
+
+/// test whether two given faces of a mesh intersect with each other
+template <typename T>
+bool intersectFace(
+    const MeshT<T>& mesh,
+    const std::vector<Vector3<T>>& faceNormals,
+    int32_t face0,
+    int32_t face1);
+
+/// test if the mesh self intersects anywhere and return all intersecting face pairs using brute
+/// force
+template <typename T>
+std::vector<std::pair<int32_t, int32_t>> intersectMeshBruteForce(const MeshT<T>& mesh);
+/// test if the mesh self intersects anywhere and return all intersecting face pairs using a bvh
+/// tree
+template <typename T>
+std::vector<std::pair<int32_t, int32_t>> intersectMesh(const MeshT<T>& mesh);
+
+} // namespace momentum

include/momentum/math/mesh.h

@@ -0,0 +1,84 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <momentum/math/fwd.h>
+#include <momentum/math/types.h>
+
+namespace momentum {
+
+/// A generic mesh representation with support for vertices, faces, lines, and texture coordinates.
+///
+/// @tparam T The scalar type used for vertex coordinates and confidence values (typically float or
+/// double)
+template <typename T>
+struct MeshT {
+  /// List of mesh vertices in 3D space
+  std::vector<Eigen::Vector3<T>> vertices;
+
+  /// List of vertex normals (same size as vertices when computed)
+  std::vector<Eigen::Vector3<T>> normals;
+
+  /// List of triangular faces defined by vertex indices
+  std::vector<Eigen::Vector3i> faces;
+
+  /// List of polylines defined by vertex indices
+  /// Each inner vector represents a single polyline
+  std::vector<std::vector<int32_t>> lines;
+
+  /// List of per-vertex RGB colors (0-255 for each channel)
+  std::vector<Eigen::Vector3b> colors;
+
+  /// List of per-vertex confidence values
+  /// Higher values typically indicate higher confidence in the vertex position
+  std::vector<T> confidence;
+
+  /// List of texture coordinates (UV coordinates).
+  ///
+  /// The texture coordinates are format-agnostic, and it's the user's responsibility to ensure
+  /// their consistent use.
+  ///
+  /// For GLTF, Momentum stores and saves the texture coordinates as they are represented by the
+  /// underlying GLTF parser. When dealing with FBX, the Y-axis is flipped. This distinction is
+  /// crucial to understand when working with different formats.
+  std::vector<Eigen::Vector2f> texcoords;
+
+  /// List of texture coordinate indices per face
+  /// Maps each face to its corresponding texture coordinates
+  std::vector<Eigen::Vector3i> texcoord_faces;
+
+  /// List of texture coordinate indices per line
+  /// Maps each line to its corresponding texture coordinates
+  std::vector<std::vector<int32_t>> texcoord_lines;
+
+  /// Compute vertex normals by averaging connected face normals.
+  ///
+  /// This method calculates normals for each vertex by averaging the normals of all
+  /// connected faces. The resulting normals are normalized to unit length.
+  /// If a vertex is part of a degenerate face (e.g., colinear vertices), that face
+  /// will not contribute to the vertex normal.
+  void updateNormals();
+
+  /// Cast the mesh to a different scalar type.
+  ///
+  /// This method creates a new mesh with all numeric data converted to the target type.
+  /// Vertex positions, normals, and confidence values are cast to the new type.
+  /// Non-numeric data like faces and lines remain unchanged.
+  ///
+  /// @tparam T2 The target scalar type
+  /// @return A new mesh with the target scalar type
+  template <typename T2>
+  [[nodiscard]] MeshT<T2> cast() const;
+
+  /// Reset the mesh by clearing all data.
+  ///
+  /// This method clears all vectors, effectively resetting the mesh to an empty state.
+  void reset();
+};
+
+} // namespace momentum

include/momentum/math/mppca.h

@@ -0,0 +1,67 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <momentum/math/utility.h>
+
+namespace momentum {
+
+/// Mixture of Probabilistic Principal Component Analysis (MPPCA)
+/// Based on: http://www.miketipping.com/papers/met-mppca.pdf
+///
+/// @tparam T Scalar type (float or double)
+template <typename T>
+struct MppcaT {
+  /// Dimension of data space
+  size_t d = 0;
+
+  /// Number of mixture components
+  size_t p = 0;
+
+  /// Parameter names (should match dimension d)
+  std::vector<std::string> names;
+
+  /// Mean vectors (p×d matrix)
+  Eigen::MatrixX<T> mu;
+
+  /// Inverse covariance matrices
+  std::vector<Eigen::MatrixX<T>> Cinv;
+
+  /// Matrices for efficient computation
+  std::vector<Eigen::MatrixX<T>> L;
+
+  /// Precomputed responsibility terms
+  Eigen::VectorX<T> Rpre;
+
+  /// Sets model parameters and precomputes matrices
+  ///
+  /// @param[in] pi Mixture weights
+  /// @param[in] mmu Mean vectors
+  /// @param[in] W Principal axes matrices
+  /// @param[in] sigma2 Noise variances
+  void set(
+      const VectorX<T>& pi,
+      const MatrixX<T>& mmu,
+      std::span<const MatrixX<T>> W,
+      const VectorX<T>& sigma2);
+
+  /// Converts to a different scalar type
+  ///
+  /// @tparam T2 Target scalar type
+  /// @return Converted MPPCA model
+  template <typename T2>
+  [[nodiscard]] MppcaT<T2> cast() const;
+
+  /// Checks approximate equality with another model
+  ///
+  /// @param[in] mppcaT Model to compare with
+  /// @return true if approximately equal
+  [[nodiscard]] bool isApprox(const MppcaT<T>& mppcaT) const;
+};
+
+} // namespace momentum