pymomentum-cpu 0.1.78.post11__cp312-cp312-win_amd64.whl

include/momentum/character_sequence_solver/fwd.h

@@ -0,0 +1,200 @@
+/*
+ * 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 {
+
+struct MultiposeSolverOptions;
+
+using MultiposeSolverOptions_p = ::std::shared_ptr<MultiposeSolverOptions>;
+using MultiposeSolverOptions_u = ::std::unique_ptr<MultiposeSolverOptions>;
+using MultiposeSolverOptions_w = ::std::weak_ptr<MultiposeSolverOptions>;
+using MultiposeSolverOptions_const_p = ::std::shared_ptr<const MultiposeSolverOptions>;
+using MultiposeSolverOptions_const_u = ::std::unique_ptr<const MultiposeSolverOptions>;
+using MultiposeSolverOptions_const_w = ::std::weak_ptr<const MultiposeSolverOptions>;
+
+struct SequenceSolverOptions;
+
+using SequenceSolverOptions_p = ::std::shared_ptr<SequenceSolverOptions>;
+using SequenceSolverOptions_u = ::std::unique_ptr<SequenceSolverOptions>;
+using SequenceSolverOptions_w = ::std::weak_ptr<SequenceSolverOptions>;
+using SequenceSolverOptions_const_p = ::std::shared_ptr<const SequenceSolverOptions>;
+using SequenceSolverOptions_const_u = ::std::unique_ptr<const SequenceSolverOptions>;
+using SequenceSolverOptions_const_w = ::std::weak_ptr<const SequenceSolverOptions>;
+
+template <typename T>
+class SequenceErrorFunctionT;
+using SequenceErrorFunction = SequenceErrorFunctionT<float>;
+using SequenceErrorFunctiond = SequenceErrorFunctionT<double>;
+
+using SequenceErrorFunction_p = ::std::shared_ptr<SequenceErrorFunction>;
+using SequenceErrorFunction_u = ::std::unique_ptr<SequenceErrorFunction>;
+using SequenceErrorFunction_w = ::std::weak_ptr<SequenceErrorFunction>;
+using SequenceErrorFunction_const_p = ::std::shared_ptr<const SequenceErrorFunction>;
+using SequenceErrorFunction_const_u = ::std::unique_ptr<const SequenceErrorFunction>;
+using SequenceErrorFunction_const_w = ::std::weak_ptr<const SequenceErrorFunction>;
+
+using SequenceErrorFunctiond_p = ::std::shared_ptr<SequenceErrorFunctiond>;
+using SequenceErrorFunctiond_u = ::std::unique_ptr<SequenceErrorFunctiond>;
+using SequenceErrorFunctiond_w = ::std::weak_ptr<SequenceErrorFunctiond>;
+using SequenceErrorFunctiond_const_p = ::std::shared_ptr<const SequenceErrorFunctiond>;
+using SequenceErrorFunctiond_const_u = ::std::unique_ptr<const SequenceErrorFunctiond>;
+using SequenceErrorFunctiond_const_w = ::std::weak_ptr<const SequenceErrorFunctiond>;
+
+template <typename T>
+class ModelParametersSequenceErrorFunctionT;
+using ModelParametersSequenceErrorFunction = ModelParametersSequenceErrorFunctionT<float>;
+using ModelParametersSequenceErrorFunctiond = ModelParametersSequenceErrorFunctionT<double>;
+
+using ModelParametersSequenceErrorFunction_p =
+    ::std::shared_ptr<ModelParametersSequenceErrorFunction>;
+using ModelParametersSequenceErrorFunction_u =
+    ::std::unique_ptr<ModelParametersSequenceErrorFunction>;
+using ModelParametersSequenceErrorFunction_w =
+    ::std::weak_ptr<ModelParametersSequenceErrorFunction>;
+using ModelParametersSequenceErrorFunction_const_p =
+    ::std::shared_ptr<const ModelParametersSequenceErrorFunction>;
+using ModelParametersSequenceErrorFunction_const_u =
+    ::std::unique_ptr<const ModelParametersSequenceErrorFunction>;
+using ModelParametersSequenceErrorFunction_const_w =
+    ::std::weak_ptr<const ModelParametersSequenceErrorFunction>;
+
+using ModelParametersSequenceErrorFunctiond_p =
+    ::std::shared_ptr<ModelParametersSequenceErrorFunctiond>;
+using ModelParametersSequenceErrorFunctiond_u =
+    ::std::unique_ptr<ModelParametersSequenceErrorFunctiond>;
+using ModelParametersSequenceErrorFunctiond_w =
+    ::std::weak_ptr<ModelParametersSequenceErrorFunctiond>;
+using ModelParametersSequenceErrorFunctiond_const_p =
+    ::std::shared_ptr<const ModelParametersSequenceErrorFunctiond>;
+using ModelParametersSequenceErrorFunctiond_const_u =
+    ::std::unique_ptr<const ModelParametersSequenceErrorFunctiond>;
+using ModelParametersSequenceErrorFunctiond_const_w =
+    ::std::weak_ptr<const ModelParametersSequenceErrorFunctiond>;
+
+template <typename T>
+class MultiposeSolverT;
+using MultiposeSolver = MultiposeSolverT<float>;
+using MultiposeSolverd = MultiposeSolverT<double>;
+
+using MultiposeSolver_p = ::std::shared_ptr<MultiposeSolver>;
+using MultiposeSolver_u = ::std::unique_ptr<MultiposeSolver>;
+using MultiposeSolver_w = ::std::weak_ptr<MultiposeSolver>;
+using MultiposeSolver_const_p = ::std::shared_ptr<const MultiposeSolver>;
+using MultiposeSolver_const_u = ::std::unique_ptr<const MultiposeSolver>;
+using MultiposeSolver_const_w = ::std::weak_ptr<const MultiposeSolver>;
+
+using MultiposeSolverd_p = ::std::shared_ptr<MultiposeSolverd>;
+using MultiposeSolverd_u = ::std::unique_ptr<MultiposeSolverd>;
+using MultiposeSolverd_w = ::std::weak_ptr<MultiposeSolverd>;
+using MultiposeSolverd_const_p = ::std::shared_ptr<const MultiposeSolverd>;
+using MultiposeSolverd_const_u = ::std::unique_ptr<const MultiposeSolverd>;
+using MultiposeSolverd_const_w = ::std::weak_ptr<const MultiposeSolverd>;
+
+template <typename T>
+class MultiposeSolverFunctionT;
+using MultiposeSolverFunction = MultiposeSolverFunctionT<float>;
+using MultiposeSolverFunctiond = MultiposeSolverFunctionT<double>;
+
+using MultiposeSolverFunction_p = ::std::shared_ptr<MultiposeSolverFunction>;
+using MultiposeSolverFunction_u = ::std::unique_ptr<MultiposeSolverFunction>;
+using MultiposeSolverFunction_w = ::std::weak_ptr<MultiposeSolverFunction>;
+using MultiposeSolverFunction_const_p = ::std::shared_ptr<const MultiposeSolverFunction>;
+using MultiposeSolverFunction_const_u = ::std::unique_ptr<const MultiposeSolverFunction>;
+using MultiposeSolverFunction_const_w = ::std::weak_ptr<const MultiposeSolverFunction>;
+
+using MultiposeSolverFunctiond_p = ::std::shared_ptr<MultiposeSolverFunctiond>;
+using MultiposeSolverFunctiond_u = ::std::unique_ptr<MultiposeSolverFunctiond>;
+using MultiposeSolverFunctiond_w = ::std::weak_ptr<MultiposeSolverFunctiond>;
+using MultiposeSolverFunctiond_const_p = ::std::shared_ptr<const MultiposeSolverFunctiond>;
+using MultiposeSolverFunctiond_const_u = ::std::unique_ptr<const MultiposeSolverFunctiond>;
+using MultiposeSolverFunctiond_const_w = ::std::weak_ptr<const MultiposeSolverFunctiond>;
+
+template <typename T>
+class SequenceSolverT;
+using SequenceSolver = SequenceSolverT<float>;
+using SequenceSolverd = SequenceSolverT<double>;
+
+using SequenceSolver_p = ::std::shared_ptr<SequenceSolver>;
+using SequenceSolver_u = ::std::unique_ptr<SequenceSolver>;
+using SequenceSolver_w = ::std::weak_ptr<SequenceSolver>;
+using SequenceSolver_const_p = ::std::shared_ptr<const SequenceSolver>;
+using SequenceSolver_const_u = ::std::unique_ptr<const SequenceSolver>;
+using SequenceSolver_const_w = ::std::weak_ptr<const SequenceSolver>;
+
+using SequenceSolverd_p = ::std::shared_ptr<SequenceSolverd>;
+using SequenceSolverd_u = ::std::unique_ptr<SequenceSolverd>;
+using SequenceSolverd_w = ::std::weak_ptr<SequenceSolverd>;
+using SequenceSolverd_const_p = ::std::shared_ptr<const SequenceSolverd>;
+using SequenceSolverd_const_u = ::std::unique_ptr<const SequenceSolverd>;
+using SequenceSolverd_const_w = ::std::weak_ptr<const SequenceSolverd>;
+
+template <typename T>
+class SequenceSolverFunctionT;
+using SequenceSolverFunction = SequenceSolverFunctionT<float>;
+using SequenceSolverFunctiond = SequenceSolverFunctionT<double>;
+
+using SequenceSolverFunction_p = ::std::shared_ptr<SequenceSolverFunction>;
+using SequenceSolverFunction_u = ::std::unique_ptr<SequenceSolverFunction>;
+using SequenceSolverFunction_w = ::std::weak_ptr<SequenceSolverFunction>;
+using SequenceSolverFunction_const_p = ::std::shared_ptr<const SequenceSolverFunction>;
+using SequenceSolverFunction_const_u = ::std::unique_ptr<const SequenceSolverFunction>;
+using SequenceSolverFunction_const_w = ::std::weak_ptr<const SequenceSolverFunction>;
+
+using SequenceSolverFunctiond_p = ::std::shared_ptr<SequenceSolverFunctiond>;
+using SequenceSolverFunctiond_u = ::std::unique_ptr<SequenceSolverFunctiond>;
+using SequenceSolverFunctiond_w = ::std::weak_ptr<SequenceSolverFunctiond>;
+using SequenceSolverFunctiond_const_p = ::std::shared_ptr<const SequenceSolverFunctiond>;
+using SequenceSolverFunctiond_const_u = ::std::unique_ptr<const SequenceSolverFunctiond>;
+using SequenceSolverFunctiond_const_w = ::std::weak_ptr<const SequenceSolverFunctiond>;
+
+template <typename T>
+class StateSequenceErrorFunctionT;
+using StateSequenceErrorFunction = StateSequenceErrorFunctionT<float>;
+using StateSequenceErrorFunctiond = StateSequenceErrorFunctionT<double>;
+
+using StateSequenceErrorFunction_p = ::std::shared_ptr<StateSequenceErrorFunction>;
+using StateSequenceErrorFunction_u = ::std::unique_ptr<StateSequenceErrorFunction>;
+using StateSequenceErrorFunction_w = ::std::weak_ptr<StateSequenceErrorFunction>;
+using StateSequenceErrorFunction_const_p = ::std::shared_ptr<const StateSequenceErrorFunction>;
+using StateSequenceErrorFunction_const_u = ::std::unique_ptr<const StateSequenceErrorFunction>;
+using StateSequenceErrorFunction_const_w = ::std::weak_ptr<const StateSequenceErrorFunction>;
+
+using StateSequenceErrorFunctiond_p = ::std::shared_ptr<StateSequenceErrorFunctiond>;
+using StateSequenceErrorFunctiond_u = ::std::unique_ptr<StateSequenceErrorFunctiond>;
+using StateSequenceErrorFunctiond_w = ::std::weak_ptr<StateSequenceErrorFunctiond>;
+using StateSequenceErrorFunctiond_const_p = ::std::shared_ptr<const StateSequenceErrorFunctiond>;
+using StateSequenceErrorFunctiond_const_u = ::std::unique_ptr<const StateSequenceErrorFunctiond>;
+using StateSequenceErrorFunctiond_const_w = ::std::weak_ptr<const StateSequenceErrorFunctiond>;
+
+template <typename T>
+class VertexSequenceErrorFunctionT;
+using VertexSequenceErrorFunction = VertexSequenceErrorFunctionT<float>;
+using VertexSequenceErrorFunctiond = VertexSequenceErrorFunctionT<double>;
+
+using VertexSequenceErrorFunction_p = ::std::shared_ptr<VertexSequenceErrorFunction>;
+using VertexSequenceErrorFunction_u = ::std::unique_ptr<VertexSequenceErrorFunction>;
+using VertexSequenceErrorFunction_w = ::std::weak_ptr<VertexSequenceErrorFunction>;
+using VertexSequenceErrorFunction_const_p = ::std::shared_ptr<const VertexSequenceErrorFunction>;
+using VertexSequenceErrorFunction_const_u = ::std::unique_ptr<const VertexSequenceErrorFunction>;
+using VertexSequenceErrorFunction_const_w = ::std::weak_ptr<const VertexSequenceErrorFunction>;
+
+using VertexSequenceErrorFunctiond_p = ::std::shared_ptr<VertexSequenceErrorFunctiond>;
+using VertexSequenceErrorFunctiond_u = ::std::unique_ptr<VertexSequenceErrorFunctiond>;
+using VertexSequenceErrorFunctiond_w = ::std::weak_ptr<VertexSequenceErrorFunctiond>;
+using VertexSequenceErrorFunctiond_const_p = ::std::shared_ptr<const VertexSequenceErrorFunctiond>;
+using VertexSequenceErrorFunctiond_const_u = ::std::unique_ptr<const VertexSequenceErrorFunctiond>;
+using VertexSequenceErrorFunctiond_const_w = ::std::weak_ptr<const VertexSequenceErrorFunctiond>;
+
+} // namespace momentum

include/momentum/character_sequence_solver/model_parameters_sequence_error_function.h

@@ -0,0 +1,65 @@
+/*
+ * 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/skeleton_state.h>
+#include <momentum/character_sequence_solver/fwd.h>
+#include <momentum/character_sequence_solver/sequence_error_function.h>
+
+namespace momentum {
+
+template <typename T>
+class ModelParametersSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
+ public:
+  ModelParametersSequenceErrorFunctionT(const Skeleton& skel, const ParameterTransform& pt);
+  explicit ModelParametersSequenceErrorFunctionT(const Character& character);
+
+  [[nodiscard]] size_t numFrames() const final {
+    return 2;
+  }
+
+  double getError(
+      gsl::span<const ModelParametersT<T>> modelParameters,
+      gsl::span<const SkeletonStateT<T>> skelStates,
+      gsl::span<const MeshStateT<T>> meshStates) const final;
+  double getGradient(
+      gsl::span<const ModelParametersT<T>> modelParameters,
+      gsl::span<const SkeletonStateT<T>> skelStates,
+      gsl::span<const MeshStateT<T>> meshStates,
+      Eigen::Ref<Eigen::VectorX<T>> gradient) const final;
+
+  // modelParameters: [numFrames() * parameterTransform] parameter vector
+  // skelStates: [numFrames()] array of skeleton states
+  // jacobian: [getJacobianSize()] x [numFrames() * parameterTransform] Jacobian matrix
+  // residual: [getJacobianSize()] residual vector.
+  double getJacobian(
+      gsl::span<const ModelParametersT<T>> modelParameters,
+      gsl::span<const SkeletonStateT<T>> skelStates,
+      gsl::span<const MeshStateT<T>> meshStates,
+      Eigen::Ref<Eigen::MatrixX<T>> jacobian,
+      Eigen::Ref<Eigen::VectorX<T>> residual,
+      int& usedRows) const final;
+
+  [[nodiscard]] size_t getJacobianSize() const final;
+
+  void setTargetWeights(const Eigen::VectorX<T>& weights) {
+    this->targetWeights_ = weights;
+  }
+
+  [[nodiscard]] const Eigen::VectorX<T>& getTargetWeights() const {
+    return this->targetWeights_;
+  }
+
+ private:
+  Eigen::VectorX<T> targetWeights_;
+
+ public:
+  static constexpr T kMotionWeight = 1e-1;
+};
+
+} // namespace momentum

include/momentum/character_sequence_solver/multipose_solver.h

@@ -0,0 +1,65 @@
+/*
+ * 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_sequence_solver/fwd.h>
+#include <momentum/character_sequence_solver/multipose_solver_function.h>
+#include <momentum/solver/solver.h>
+
+namespace momentum {
+
+/// Multipose solver specific options.
+struct MultiposeSolverOptions : SolverOptions {
+  /// Regularization parameter for QR decomposition.
+  float regularization = 0.05f;
+
+  MultiposeSolverOptions() = default;
+
+  /* implicit */ MultiposeSolverOptions(const SolverOptions& baseOptions)
+      : SolverOptions(baseOptions) {
+    // Empty
+  }
+};
+
+template <typename T>
+class MultiposeSolverT : public SolverT<T> {
+ public:
+  MultiposeSolverT(const SolverOptions& options, MultiposeSolverFunctionT<T>* function);
+  ~MultiposeSolverT() override;
+
+  [[nodiscard]] std::string_view getName() const override;
+
+  void setOptions(const SolverOptions& options) final;
+
+  void iter() {
+    doIteration();
+    this->iteration_++;
+  }
+
+  void init() {
+    this->iteration_ = 0;
+    initializeSolver();
+  }
+
+  Eigen::VectorX<T> getP() {
+    return this->parameters_;
+  }
+
+ protected:
+  void doIteration() final;
+  void initializeSolver() final;
+
+ private:
+  Eigen::MatrixX<T> jacobianBlock_;
+  Eigen::VectorX<T> residualBlock_;
+  std::unique_ptr<MeshStateT<T>> meshState_;
+
+  float regularization_;
+};
+
+} // namespace momentum

include/momentum/character_sequence_solver/multipose_solver_function.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 <momentum/character/fwd.h>
+#include <momentum/character/parameter_transform.h>
+#include <momentum/character/types.h>
+#include <momentum/character_sequence_solver/fwd.h>
+#include <momentum/character_solver/fwd.h>
+#include <momentum/solver/solver_function.h>
+
+namespace momentum {
+
+template <typename T>
+class MultiposeSolverFunctionT : public SolverFunctionT<T> {
+ public:
+  MultiposeSolverFunctionT(
+      const Skeleton* skel,
+      const ParameterTransformT<T>* parameterTransform,
+      gsl::span<const int> universal,
+      size_t frames);
+  ~MultiposeSolverFunctionT() override;
+
+  double getError(const Eigen::VectorX<T>& parameters) final;
+
+  double getGradient(const Eigen::VectorX<T>& parameters, Eigen::VectorX<T>& gradient) final;
+
+  double getJacobian(
+      const Eigen::VectorX<T>& parameters,
+      Eigen::MatrixX<T>& jacobian,
+      Eigen::VectorX<T>& residual,
+      size_t& actualRows) final;
+
+  void updateParameters(Eigen::VectorX<T>& parameters, const Eigen::VectorX<T>& gradient) final;
+  void setEnabledParameters(const ParameterSet& parameterSet) final;
+
+  void addErrorFunction(size_t frame, SkeletonErrorFunctionT<T>* errorFunction);
+
+  [[nodiscard]] size_t getNumFrames() const {
+    return states_.size();
+  }
+
+  [[nodiscard]] const ModelParametersT<T>& getFrameParameters(const size_t frame) const {
+    return frameParameters_[frame];
+  }
+
+  void setFrameParameters(size_t frame, const ModelParametersT<T>& parameters);
+  [[nodiscard]] Eigen::VectorX<T> getUniversalParameters() const;
+  [[nodiscard]] Eigen::VectorX<T> getJoinedParameterVector() const;
+  void setJoinedParameterVector(const Eigen::VectorX<T>& joinedParameters);
+
+  [[nodiscard]] ParameterSet getUniversalParameterSet() const;
+  [[nodiscard]] ParameterSet getUniversalLocatorParameterSet() const;
+
+ private:
+  void setFrameParametersFromJoinedParameterVector(const Eigen::VectorX<T>& parameters);
+
+ private:
+  const Skeleton* skeleton_;
+  const ParameterTransformT<T>* parameterTransform_;
+  std::vector<SkeletonStateT<T>> states_;
+  std::vector<MeshStateT<T>> meshStates_;
+  VectorX<bool> activeJointParams_;
+
+  std::vector<ModelParametersT<T>> frameParameters_;
+  Eigen::VectorX<T> universal_;
+  std::vector<size_t> parameterIndexMap_;
+
+  std::vector<size_t> genericParameters_;
+  std::vector<size_t> universalParameters_;
+
+  std::vector<std::vector<SkeletonErrorFunctionT<T>*>> errorFunctions_;
+
+  friend class MultiposeSolverT<T>;
+};
+
+} // namespace momentum

include/momentum/character_sequence_solver/sequence_error_function.h

@@ -0,0 +1,104 @@
+/*
+ * 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/fwd.h>
+#include <momentum/character/parameter_transform.h>
+#include <momentum/character/types.h>
+#include <momentum/character_sequence_solver/fwd.h>
+
+namespace momentum {
+
+template <typename T>
+class SequenceErrorFunctionT {
+ public:
+  SequenceErrorFunctionT(const Skeleton& skel, const ParameterTransform& pt)
+      : skeleton_(skel), parameterTransform_(pt), activeJointParams_(pt.activeJointParams) {
+    enabledParameters_.flip(); // all parameters enabled by default
+  }
+  virtual ~SequenceErrorFunctionT() = default;
+
+  // Number of contiguous frames that this error function affects.
+  [[nodiscard]] virtual size_t numFrames() const = 0;
+
+  void setWeight(T w) {
+    weight_ = w;
+  }
+  [[nodiscard]] float getWeight() const {
+    return weight_;
+  }
+
+  void setActiveJoints(const VectorX<bool>& aj) {
+    activeJointParams_ = aj;
+  }
+
+  void setEnabledParameters(const ParameterSet& ps) {
+    enabledParameters_ = ps;
+  }
+
+  [[nodiscard]] virtual bool needsMesh() const {
+    return false;
+  }
+
+  [[nodiscard]] virtual double getError(
+      gsl::span<const ModelParametersT<T>> /* modelParameters */,
+      gsl::span<const SkeletonStateT<T>> /* skelStates */,
+      gsl::span<const MeshStateT<T>> /* meshStates */) const {
+    return 0.0f;
+  }
+
+  // Get the gradient of the error.
+  // modelParameters: numFrames() array of parameter vectors
+  // skelStates: [numFrames()] array of skeleton states
+  // meshStates: [numFrames()] array of mesh states
+  // gradient: [numFrames() * parameterTransform] gradient vector
+  virtual double getGradient(
+      gsl::span<const ModelParametersT<T>> /* modelParameters */,
+      gsl::span<const SkeletonStateT<T>> /* skelStates */,
+      gsl::span<const MeshStateT<T>> /* meshStates */,
+      Eigen::Ref<Eigen::VectorX<T>> /* gradient */) const {
+    return 0.0f;
+  }
+
+  // modelParameters: [numFrames() * parameterTransform] parameter vector
+  // skelStates: [numFrames()] array of skeleton states
+  // meshStates: [numFrames()] array of mesh states
+  // jacobian: [getJacobianSize()] x [numFrames() * parameterTransform] Jacobian matrix
+  // residual: [getJacobianSize()] residual vector.
+  virtual double getJacobian(
+      gsl::span<const ModelParametersT<T>> /* modelParameters */,
+      gsl::span<const SkeletonStateT<T>> /* skelStates */,
+      gsl::span<const MeshStateT<T>> /* meshStates */,
+      Eigen::Ref<Eigen::MatrixX<T>> /* jacobian */,
+      Eigen::Ref<Eigen::VectorX<T>> /* residual */,
+      int& usedRows) const {
+    usedRows = 0;
+    return 0.0f;
+  }
+
+  [[nodiscard]] virtual size_t getJacobianSize() const {
+    return 0;
+  }
+
+  [[nodiscard]] const Skeleton& getSkeleton() const {
+    return this->skeleton_;
+  }
+
+  [[nodiscard]] const ParameterTransform& getParameterTransform() const {
+    return this->parameterTransform_;
+  }
+
+ protected:
+  const Skeleton& skeleton_;
+  const ParameterTransform& parameterTransform_;
+  T weight_ = 1.0f;
+  VectorX<bool> activeJointParams_;
+  ParameterSet enabledParameters_; // set to zero by default constr
+};
+
+} // namespace momentum

include/momentum/character_sequence_solver/sequence_solver.h

@@ -0,0 +1,144 @@
+/*
+ * 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_sequence_solver/fwd.h>
+#include <momentum/common/fwd.h>
+#include <momentum/math/fwd.h>
+#include <momentum/math/online_householder_qr.h>
+#include <momentum/solver/solver.h>
+
+#include <functional>
+
+namespace momentum {
+
+/// Sequence solver specific options
+struct SequenceSolverOptions : SolverOptions {
+  /// Regularization parameter for QR decomposition.
+  float regularization = 0.05f;
+
+  /// Flag to enable line search during optimization.
+  bool doLineSearch = false;
+
+  /// Flag to enable multithreading for the Sequence solver.
+  bool multithreaded = false;
+
+  /// Flag to enable a progress bar during optimization.
+  bool progressBar = false;
+
+  SequenceSolverOptions() = default;
+
+  /* implicit */ SequenceSolverOptions(const SolverOptions& baseOptions)
+      : SolverOptions(baseOptions) {
+    // Empty
+  }
+};
+
+template <typename T>
+class SequenceSolverT : public SolverT<T> {
+ public:
+  SequenceSolverT(const SolverOptions& options, SequenceSolverFunctionT<T>* function);
+
+  [[nodiscard]] std::string_view getName() const override;
+
+  void setOptions(const SolverOptions& options) final;
+
+  // "numParameters" has a different meaning here than in Solver.
+  // For Solver class, numParameters = ParameterTransform.numAllModelParameters() * numFrames; but
+  // it means #variables here. To hack around this discrepancy, we update numParameters when a new
+  // set of variables are defined.
+  // XXX To be fixed as part of T118191244
+  void setEnabledParameters(const ParameterSet& parameters) final {
+    SolverT<T>::setEnabledParameters(parameters);
+    this->numParameters_ = this->solverFunction_->getNumParameters();
+  }
+
+  void iter() {
+    doIteration();
+    this->iteration_++;
+  }
+
+  void init() {
+    this->iteration_ = 0;
+    initializeSolver();
+  }
+
+  Eigen::VectorX<T> getP() {
+    return this->parameters_;
+  }
+
+ protected:
+  void doIteration() final;
+  void initializeSolver() final;
+
+ private:
+  static double processPerFrameErrors_parallel(
+      SequenceSolverFunctionT<T>* fn,
+      OnlineBandedHouseholderQR<T>& qrSolver,
+      ProgressBar* progress);
+  static double processPerFrameErrors_serial(
+      SequenceSolverFunctionT<T>* fn,
+      OnlineBandedHouseholderQR<T>& qrSolver,
+      ProgressBar* progress);
+
+  static double processSequenceErrors_serial(
+      SequenceSolverFunctionT<T>* fn,
+      OnlineBandedHouseholderQR<T>& qrSolver,
+      ProgressBar* progress);
+
+  struct UniversalJacobianResid {
+    size_t frameIndex = SIZE_MAX;
+    Eigen::MatrixX<T> jacobian;
+    Eigen::VectorX<T> residual;
+    double error;
+    size_t nFunctions;
+
+    bool operator<(const UniversalJacobianResid& rhs) const {
+      return frameIndex < rhs.frameIndex;
+    }
+
+    bool operator>(const UniversalJacobianResid& rhs) const {
+      return frameIndex > rhs.frameIndex;
+    }
+  };
+
+  // Here, the processJac function computes the Jacobian/residual, applies it to the banded
+  // part of the matrix, and then returns the universal part.
+  static double processErrorFunctions_parallel(
+      const std::function<UniversalJacobianResid(
+          size_t,
+          SequenceSolverFunctionT<T>*,
+          OnlineBandedHouseholderQR<T>&)>& processJac,
+      SequenceSolverFunctionT<T>* fn,
+      OnlineBandedHouseholderQR<T>& qrSolver,
+      ProgressBar* progress);
+
+  // Returns the [Jacobian, residual, error] for all the error functions applying to a single frame:
+  static std::tuple<Eigen::MatrixX<T>, Eigen::VectorX<T>, double, size_t> computePerFrameJacobian(
+      SequenceSolverFunctionT<T>* fn,
+      size_t iFrame);
+
+  // Returns the [Jacobian, residual, error] for all the sequence error functions starting from a
+  // single frame:
+  static std::tuple<Eigen::MatrixX<T>, Eigen::VectorX<T>, double, size_t>
+  computeSequenceJacobian(SequenceSolverFunctionT<T>* fn, size_t iFrame, size_t bandwidth);
+
+  static std::vector<Eigen::Index> buildSequenceColumnIndices(
+      const SequenceSolverFunctionT<T>* fn,
+      size_t bandwidth);
+
+  float regularization_ = 0.05f;
+  bool doLineSearch_ = false;
+  bool multithreaded_ = false;
+  bool progressBar_ = false;
+
+  // bandwidth in frames:
+  size_t bandwidth_ = 0;
+};
+
+} // namespace momentum