pymomentum-cpu 0.1.77.post30__cp313-cp313-manylinux_2_39_x86_64.whl

include/momentum/marker_tracking/app_utils.h

@@ -0,0 +1,62 @@
+/*
+ * 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/marker.h>
+#include <momentum/marker_tracking/marker_tracker.h>
+
+#include <CLI/CLI.hpp>
+
+namespace momentum {
+
+struct IOOptions {
+  std::string inputFile;
+  std::string outputFile;
+};
+
+struct ModelOptions {
+  std::string model;
+  std::string parameters;
+  std::string locators;
+};
+
+void addIOOptions(CLI::App& app, std::shared_ptr<IOOptions> ioOptions);
+void addModelOptions(CLI::App& app, std::shared_ptr<ModelOptions> modelOptions);
+void addCalibrationOptions(CLI::App& app, std::shared_ptr<CalibrationConfig> config);
+void addTrackingOptions(CLI::App& app, std::shared_ptr<TrackingConfig> config);
+void addRefineOptions(CLI::App& app, std::shared_ptr<RefineConfig> config);
+
+std::tuple<momentum::Character, momentum::ModelParameters> loadCalibratedModel(
+    const std::string& modelFile);
+
+std::tuple<momentum::Character, momentum::ModelParameters> loadCharacterWithIdentity(
+    const ModelOptions& modelFiles);
+
+/// Save the given character and motion to a GLB or FBX file.
+///
+/// @param[in] outFile The GLB/FBX file to save to
+/// @param[in] character The GLB/FBX file to save to
+/// @param[in] identity The identity parameters used for the character
+/// @param[in] finalMotion The motion save to the file. (Note: this may be modified to remove
+/// scaling parameters if saveScaleToMotion is false)
+/// @param[in] markerData Marker data to save to the file
+/// @param[in] fps Framerate of the motion
+/// @param[in] saveMarkerMesh (optional) Whether to save a visible cube mesh for the markers
+/// @param[in] saveScaleToMotion (optional) Whether to save the scale parameters to the motion or
+/// identity parameter vectors (saving to motion is preferred)
+void saveMotion(
+    const std::string& outFile,
+    const momentum::Character& character,
+    const momentum::ModelParameters& identity,
+    Eigen::MatrixXf& finalMotion,
+    gsl::span<const std::vector<momentum::Marker>> markerData,
+    double fps,
+    bool saveMarkerMesh = true);
+
+} // namespace momentum

include/momentum/marker_tracking/marker_tracker.h

@@ -0,0 +1,213 @@
+/*
+ * 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/marker.h>
+
+namespace momentum {
+
+/// Common configuration for a tracking problem
+struct BaseConfig {
+  /// Minimum percentage of visible markers in a frame to consider for tracking. We will skip frames
+  /// with too few visible markers as they may be better filled in through a smoothing pass.
+  float minVisPercent = 0.f;
+  /// Parameter to control what loss function to use. Refer to comments in GeneralizedLoss class for
+  /// details. Use a smaller alpha when data is noisy; otherwise L2 is good.
+  float lossAlpha = 2.0;
+  /// Max number of solver iterations to run.
+  size_t maxIter = 30;
+  /// Regularization parameter (lambda) for Levenberg-Marquardt solver.
+  float regularization = 0.05f;
+  /// True to print and save debug information.
+  bool debug = false;
+};
+
+/// Configuration for running body and/or locator calibration
+struct CalibrationConfig : public BaseConfig {
+  /// Number of frames used in calibration. It will be a uniform sample from the input.
+  size_t calibFrames = 100;
+  /// Number of iterations to run the main calibration loop. It could be larger if calibrating for
+  /// locators only.
+  size_t majorIter = 3;
+  /// True to only solve for a global body scale without changing individual bone length.
+  bool globalScaleOnly = false;
+  /// True to calibrate only the locators and not the body.
+  bool locatorsOnly = false;
+  /// Sample uniformly or do a greedy importance sampling
+  size_t greedySampling = 0;
+  /// True to lock the floor constraints to the floor in the first frame
+  bool enforceFloorInFirstFrame = false;
+  /// Name of a pose constraint set to use for the first frame
+  std::string firstFramePoseConstraintSet;
+  /// Calibrate the character's shape
+  bool calibShape = false;
+};
+
+/// Configuration for pose tracking given a calibrated body and locators
+struct TrackingConfig : public BaseConfig {
+  /// The weight for the smoothness error function.
+  float smoothing = 0;
+  /// The weight for the collision error function.
+  float collisionErrorWeight = 0.0;
+  /// Smoothing weights per model parameter. The size of this vector should be equal to number of
+  /// model parameters and this overrides the value specific in smoothing
+  Eigen::VectorXf smoothingWeights{};
+};
+
+/// Configuration for refining an already tracked motion, eg. add smoothing and/or collision
+/// handling; improve residuals with extra dofs etc.
+struct RefineConfig : public TrackingConfig {
+  /// Minimize changes to calibration parameters when in calibration mode, by regularizing towards
+  /// the input value with this regularizer weight.
+  float regularizer = 0.0;
+  /// Calibrate identity parameters when refining the motion.
+  bool calibId = false;
+  /// Calibrate locators when refining the motion.
+  bool calibLocators = false;
+};
+
+/// Use multiple frames to solve for global parameters such as body proportions and/or marker
+/// offsets together with the motion. It can also be used to smooth out a motion with or without
+/// solving for global parameters, for example to fill gaps when there are missing markers.
+///
+/// @param[in] markerData Marker data.
+/// @param[in] character Character definition.
+/// @param[in] globalParams Bitset to indicate global parameters to solve for; could be all zeros
+/// for post-process a motion.
+/// @param[in] initialMotion Initial values of all parameters. It should be the same length as
+/// markerData, but only frames used in solving are used. Values in unused frames do not matter.
+/// Number of parameters should be the same as defined in character.
+/// @param[in] config Solving options.
+/// @param[in] frameStride Frame stride to select solver frames (ie. uniform sample).
+/// @param[in] enforceFloorInFirstFrame Flag to enforce the floor contact constraints in first frame
+/// @param[in] firstFramePoseConstraintSet Name of a pose constraint set to use for the first frame
+///
+/// @return The solved motion. It has the same length as markerData. It repeats the same solved pose
+/// within a frame stride.
+Eigen::MatrixXf trackSequence(
+    gsl::span<const std::vector<momentum::Marker>> markerData,
+    const momentum::Character& character,
+    const momentum::ParameterSet& globalParams,
+    const Eigen::MatrixXf& initialMotion,
+    const TrackingConfig& config,
+    float regularizer = 0.0,
+    size_t frameStride = 1,
+    bool enforceFloorInFirstFrame = false,
+    const std::string& firstFramePoseConstraintSet = "");
+
+/// Use multiple frames to solve for global parameters such as body proportions and/or marker
+/// offsets together with the motion.
+///
+/// @param[in] markerData Marker data.
+/// @param[in] character Character definition.
+/// @param[in] globalParams Bitset to indicate global parameters to solve for; could be all zeros
+/// for post-process a motion.
+/// @param[in] initialMotion Initial values of all parameters. It should be the same length as
+/// markerData, but only frames used in solving are used. Values in unused frames do not matter.
+/// Number of parameters should be the same as defined in character.
+/// @param[in] config Solving options.
+/// @param[in] frames List of frames to solve for.
+/// @param[in] enforceFloorInFirstFrame Flag to enforce the floor contact constraints in first frame
+/// @param[in] firstFramePoseConstraintSet Name of a pose constraint set to use for the first frame
+///
+/// @return The solved motion. It has the same length as markerData. It repeats the same solved pose
+/// within a frame stride.
+Eigen::MatrixXf trackSequence(
+    gsl::span<const std::vector<momentum::Marker>> markerData,
+    const momentum::Character& character,
+    const momentum::ParameterSet& globalParams,
+    const Eigen::MatrixXf& initialMotion,
+    const TrackingConfig& config,
+    const std::vector<size_t>& frames,
+    float regularizer = 0.0,
+    bool enforceFloorInFirstFrame = false,
+    const std::string& firstFramePoseConstraintSet = "");
+
+/// Track poses per-frame given a calibrated character.
+///
+/// @param[in] markerData Input marker data.
+/// @param[in] character Character definition.
+/// @param[in] globalParams Calibrated identity info; could be repurposed to pass in an initial pose
+/// too.
+/// @param[in] config Solving options.
+/// @param[in] frameStride Frame stride to select solver frames (ie. uniform sample).
+///
+/// @return The solved motion. It has the same length as markerData. It repeats the same solved pose
+/// within a frame stride.
+Eigen::MatrixXf trackPosesPerframe(
+    gsl::span<const std::vector<momentum::Marker>> markerData,
+    const momentum::Character& character,
+    const momentum::ModelParameters& globalParams,
+    const TrackingConfig& config,
+    size_t frameStride = 1);
+
+/// Track poses for given frames.
+///
+/// @param[in] markerData Input marker data.
+/// @param[in] character Character definition.
+/// @param[in] globalParams Calibrated identity info; could be repurposed to pass in an initial pose
+/// too.
+/// @param[in] config Solving options.
+/// @param[in] frameIndices Frame indices of the frames to be solved.
+///
+/// @return The solved motion. It has the same length as markerData. It repeats the same solved pose
+/// within a frame stride.
+Eigen::MatrixXf trackPosesForFrames(
+    gsl::span<const std::vector<momentum::Marker>> markerData,
+    const momentum::Character& character,
+    const Eigen::MatrixXf& initialMotion,
+    const TrackingConfig& config,
+    const std::vector<size_t>& frameIndices);
+
+/// Calibrate body proportions and locator offsets of a character from input marker data.
+///
+/// @param[in] markerData Input marker data.
+/// @param[in] config Solving options.
+/// @param[in,out] character Character definition. It provides input locators offsets which will get
+/// updated in return.
+/// @param[in,out] identity Initial identity parameters that get updated in return. It could also
+/// hold the pose of the first frame for better initialization for tracking later.
+void calibrateModel(
+    gsl::span<const std::vector<momentum::Marker>> markerData,
+    const CalibrationConfig& config,
+    momentum::Character& character,
+    momentum::ModelParameters& identity);
+
+/// Calibrate locator offsets of a character from input identity and marker data.
+///
+/// @param[in] markerData Input marker data.
+/// @param[in] config Solving options.
+/// @param[in] identity Identity parameters of the input character.
+/// @param[in,out] character Character definition. It provides input locators offsets which will get
+/// updated in return. We overwrite the locators in the input character so we don't have to
+/// duplicate the character object inside the function.
+void calibrateLocators(
+    gsl::span<const std::vector<momentum::Marker>> markerData,
+    const CalibrationConfig& config,
+    const momentum::ModelParameters& identity,
+    momentum::Character& character);
+
+Eigen::MatrixXf refineMotion(
+    gsl::span<const std::vector<momentum::Marker>> markerData,
+    const Eigen::MatrixXf& motion,
+    const RefineConfig& config,
+    momentum::Character& character);
+
+/// Get the error of the locator motion vs the markers
+///
+/// @param[in] markerData Input marker data.
+/// @param[in] motion Motion to compare against.
+/// @param[in] character Character definition
+/// @return average per frame error and max marker error
+std::pair<float, float> getLocatorError(
+    gsl::span<const std::vector<momentum::Marker>> markerData,
+    const Eigen::MatrixXf& motion,
+    momentum::Character& character);
+
+} // namespace momentum

include/momentum/marker_tracking/process_markers.h

@@ -0,0 +1,58 @@
+/*
+ * 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/types.h>
+#include <momentum/marker_tracking/app_utils.h>
+#include <momentum/marker_tracking/marker_tracker.h>
+
+#include <string>
+
+namespace momentum {
+
+/// Processes marker data for a character model.
+///
+/// It can calibrate the model and locators based on the calibrationConfig, and track the motion of
+/// the markers.
+///
+/// @param[in,out] character The input character definition with locators. It also holds the output
+/// locators if locators are to be calibrated from the calibrationConfig.
+/// @param[in,out] identity The input identity used for tracking. It also holds the solved identify
+/// if identity is to be calibrated from the calibrationConfig.
+/// @param[in] markerData The per-frame position targets to be tracked.
+/// @param[in] trackingConfig The config for per-frame tracking after the correct identity and
+/// locators are solved for (or from input).
+/// @param[in] calibrationConfig The config for running calibration if calibrate is set to true.
+/// @param[in] calibrate True to run calibration according to calibrationConfig.
+/// @param[in] firstFrame The first frame to start solving. We pass in the first frame instead of
+/// triming markerData to avoid data copy.
+/// @param[in] maxFrames The maximum number of frames to process starting from firstFrame.
+/// @returns The final motion matrix after tracking.
+Eigen::MatrixXf processMarkers(
+    momentum::Character& character,
+    momentum::ModelParameters& identity,
+    const std::vector<std::vector<momentum::Marker>>& markerData,
+    const TrackingConfig& trackingConfig,
+    const CalibrationConfig& calibrationConfig,
+    bool calibrate = true,
+    size_t firstFrame = 0,
+    size_t maxFrames = 0);
+
+/// Runs marker tracking on an input marker file (e.g. c3d) and writes the output motion (e.g. glb)
+/// to outputFile
+void processMarkerFile(
+    const std::string& inputMarkerFile,
+    const std::string& outputFile,
+    const TrackingConfig& trackingConfig,
+    const CalibrationConfig& calibrationConfig,
+    const ModelOptions& modelOptions,
+    bool calibrate,
+    size_t firstFrame = 0,
+    size_t maxFrames = 0);
+
+} // namespace momentum

include/momentum/marker_tracking/tracker_utils.h

@@ -0,0 +1,90 @@
+/*
+ * 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(
+    gsl::span<const std::vector<momentum::Marker>> markerData,
+    const momentum::LocatorList& locators);
+
+std::vector<std::vector<momentum::SkinnedLocatorConstraint>> createSkinnedConstraintData(
+    gsl::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);
+
+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