Crocoddyl v3: boost -> std pointers (#278)

nim65s · abussy-aldebaran · ManifoldFR · web-flow · commit 8f25c3ad3809 · 2025-03-25T13:29:36.000+01:00
* nix flake: clean * nix flake update override with NixOS/nixpkgs#390922 * fix pixi warnings * pixi: bump crocoddyl Co-authored-by: Antoine <116184195+abussy-aldebaran@users.noreply.github.com> * pixi update * CMake: require crocoddyl v3 * croco v3: boost -> std pointers Co-authored-by: Wilson <21089660+manifoldfr@users.noreply.github.com> * add changelog entry --------- Co-authored-by: Antoine <116184195+abussy-aldebaran@users.noreply.github.com> Co-authored-by: Wilson <21089660+manifoldfr@users.noreply.github.com>
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- Update for crocoddyl v3: boost -> std pointers ([#278](https://github.com/Simple-Robotics/aligator/issues/278))
+
 ## [0.11.0] - 2025-03-17
 
 ### Changed
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -459,7 +459,7 @@ if(DOWNLOAD_TRACY)
 endif()
 
 if(BUILD_CROCODDYL_COMPAT)
-  ADD_PROJECT_DEPENDENCY(crocoddyl REQUIRED)
+  ADD_PROJECT_DEPENDENCY(crocoddyl 3.0.0 REQUIRED)
   add_subdirectory(src/compat/crocoddyl)
 endif()
 
diff --git a/bench/croc-talos-arm.cpp b/bench/croc-talos-arm.cpp
@@ -39,7 +39,7 @@ static void BM_croc_fddp(benchmark::State &state) {
   const double croc_tol = TOL * TOL * (double)nsteps;
   solver.set_th_stop(croc_tol);
   if (verbose)
-    solver.setCallbacks({boost::make_shared<croc::CallbackVerbose>()});
+    solver.setCallbacks({std::make_shared<croc::CallbackVerbose>()});
 
   for (auto _ : state) {
     solver.solve(xs_i, us_i, maxiters);
diff --git a/bindings/python/src/compat/expose-croco-compat.cpp b/bindings/python/src/compat/expose-croco-compat.cpp
@@ -32,7 +32,7 @@ void exposeCrocoddylCompat() {
 
   bp::class_<ActionModelWrapper, bp::bases<context::StageModel>>(
       "ActionModelWrapper", "Wrapper for Crocoddyl action models.",
-      bp::init<boost::shared_ptr<CrocActionModel>>(bp::args("action_model")))
+      bp::init<shared_ptr<CrocActionModel>>(bp::args("action_model")))
       .def_readonly("action_model", &ActionModelWrapper::action_model_,
                     "Underlying Crocoddyl ActionModel.")
       .def(PolymorphicMultiBaseVisitor<context::StageModel>());
@@ -51,8 +51,7 @@ void exposeCrocoddylCompat() {
 
   bp::class_<StateWrapper, bp::bases<context::Manifold>>(
       "StateWrapper", "Wrapper for a Crocoddyl state.", bp::no_init)
-      .def(
-          bp::init<boost::shared_ptr<StateAbstract>>(bp::args("self", "state")))
+      .def(bp::init<shared_ptr<StateAbstract>>(bp::args("self", "state")))
       .def_readonly("croc_state", &StateWrapper::croc_state)
       .def(PolymorphicMultiBaseVisitor<context::Manifold>());
 }
diff --git a/examples/croc-talos-arm.cpp b/examples/croc-talos-arm.cpp
@@ -22,7 +22,7 @@ void makeTalosArm(pin::Model &model) {
   pin::urdf::buildModel(talos_arm_path, model);
 }
 
-boost::shared_ptr<croc::ShootingProblem>
+std::shared_ptr<croc::ShootingProblem>
 defineCrocoddylProblem(std::size_t nsteps) {
   using croc::ActuationModelFull;
   using croc::CostModelResidual;
@@ -36,67 +36,65 @@ defineCrocoddylProblem(std::size_t nsteps) {
   using DAM = croc::DifferentialActionModelFreeFwdDynamics;
   using ActionModel = croc::ActionModelAbstract;
 
-  auto rmodel = boost::make_shared<pin::Model>();
+  auto rmodel = std::make_shared<pin::Model>();
   makeTalosArm(*rmodel);
-  auto state = boost::make_shared<StateMultibody>(rmodel);
+  auto state = std::make_shared<StateMultibody>(rmodel);
 
-  auto runningCost = boost::make_shared<CostModelSum>(state);
-  auto terminalCost = boost::make_shared<CostModelSum>(state);
+  auto runningCost = std::make_shared<CostModelSum>(state);
+  auto terminalCost = std::make_shared<CostModelSum>(state);
 
   pin::JointIndex joint_id = rmodel->getFrameId("gripper_left_joint");
   pin::SE3 target_frame;
   target_frame.setIdentity();
   target_frame.translation() << 0., 0., 0.4;
 
-  auto framePlacementResidual = boost::make_shared<ResidualModelFramePlacement>(
+  auto framePlacementResidual = std::make_shared<ResidualModelFramePlacement>(
       state, joint_id, target_frame);
 
   auto goalTrackingCost =
-      boost::make_shared<CostModelResidual>(state, framePlacementResidual);
-  auto xregCost = boost::make_shared<CostModelResidual>(
-      state, boost::make_shared<ResidualModelState>(state));
-  auto uregCost = boost::make_shared<CostModelResidual>(
-      state, boost::make_shared<ResidualModelControl>(state));
+      std::make_shared<CostModelResidual>(state, framePlacementResidual);
+  auto xregCost = std::make_shared<CostModelResidual>(
+      state, std::make_shared<ResidualModelState>(state));
+  auto uregCost = std::make_shared<CostModelResidual>(
+      state, std::make_shared<ResidualModelControl>(state));
 
   runningCost->addCost("gripperPose", goalTrackingCost, 1.0);
   runningCost->addCost("xReg", xregCost, 1e-4);
   runningCost->addCost("uReg", uregCost, 1e-4);
 
   terminalCost->addCost("gripperPose", goalTrackingCost, 1.0);
 
-  auto actuationModel = boost::make_shared<ActuationModelFull>(state);
+  auto actuationModel = std::make_shared<ActuationModelFull>(state);
 
   const double dt = 1e-3;
 
   VectorXd armature(7);
   armature << 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.0;
 
-  auto contDyn = boost::make_shared<DAM>(state, actuationModel, runningCost);
+  auto contDyn = std::make_shared<DAM>(state, actuationModel, runningCost);
   contDyn->set_armature(armature);
-  auto runningModel =
-      boost::make_shared<IntegratedActionModelEuler>(contDyn, dt);
+  auto runningModel = std::make_shared<IntegratedActionModelEuler>(contDyn, dt);
 
-  auto termContDyn =
-      boost::make_shared<DAM>(state, actuationModel, terminalCost);
+  auto termContDyn = std::make_shared<DAM>(state, actuationModel, terminalCost);
   termContDyn->set_armature(armature);
   auto terminalModel =
-      boost::make_shared<IntegratedActionModelEuler>(termContDyn, 0.0);
+      std::make_shared<IntegratedActionModelEuler>(termContDyn, 0.0);
 
   VectorXd q0(rmodel->nq);
   q0 << 0.173046, 1.0, -0.52366, 0.0, 0.0, 0.1, -0.005;
   VectorXd x0(state->get_nx());
   x0 << q0, VectorXd::Zero(rmodel->nv);
 
-  std::vector<boost::shared_ptr<ActionModel>> running_models(nsteps,
-                                                             runningModel);
+  std::vector<std::shared_ptr<ActionModel>> running_models(nsteps,
+                                                           runningModel);
 
-  auto shooting_problem = boost::make_shared<croc::ShootingProblem>(
+  auto shooting_problem = std::make_shared<croc::ShootingProblem>(
       x0, running_models, terminalModel);
   return shooting_problem;
 }
 
 void getInitialGuesses(
-    const boost::shared_ptr<croc::ShootingProblem> &croc_problem,
+    const std::shared_ptr<croc::ShootingProblem> &croc_problem,
     std::vector<Eigen::VectorXd> &xs_i, std::vector<Eigen::VectorXd> &us_i) {
   using Eigen::VectorXd;
 
diff --git a/examples/croc-talos-arm.hpp b/examples/croc-talos-arm.hpp
@@ -1,10 +1,9 @@
 /// @file
 /// @copyright Copyright (C) 2022 LAAS-CNRS, INRIA
 
+#include <memory>
 #include <vector>
 
-#include <boost/shared_ptr.hpp>
-
 #include <Eigen/Core>
 
 #include <pinocchio/multibody/fwd.hpp>
@@ -18,9 +17,9 @@ void makeTalosArm(pin::Model &model);
 
 /// This reimplements the Crocoddyl problem defined in
 /// examples/croc_arm_manipulation.py.
-boost::shared_ptr<croc::ShootingProblem>
+std::shared_ptr<croc::ShootingProblem>
 defineCrocoddylProblem(std::size_t nsteps);
 
 void getInitialGuesses(
-    const boost::shared_ptr<croc::ShootingProblem> &croc_problem,
+    const std::shared_ptr<croc::ShootingProblem> &croc_problem,
     std::vector<Eigen::VectorXd> &xs_i, std::vector<Eigen::VectorXd> &us_i);
diff --git a/flake.lock b/flake.lock
diff --git a/flake.nix b/flake.nix
@@ -14,36 +14,9 @@
         {
           pkgs,
           self',
-          system,
           ...
         }:
         {
-          _module.args.pkgs = import inputs.nixpkgs {
-            inherit system;
-            overlays = [
-              (final: prev: {
-                # Fix aba explicit template instanciation
-                # Remove this for pinocchio > 3.3.1
-                pinocchio = prev.pinocchio.overrideAttrs (super: {
-                  patches = (super.patches or [ ]) ++ [
-                    (final.fetchpatch {
-                      url = "https://github.com/stack-of-tasks/pinocchio/pull/2541/commits/23a638ebfb180aa7d4ea75f17e3d89477dcb6509.patch";
-                      hash = "sha256-XIZpq1JK5mY5tv3MqRk/ep6/5cJOjV2gkW1ywLjXUBU=";
-                    })
-                  ];
-                });
-                # Ignore pinocchio #2563
-                # Remove this for pinocchio > 3.3.1 && crocoddyl >= 3.0.0
-                crocoddyl = prev.crocoddyl.overrideAttrs (super: {
-                  cmakeFlags =
-                    (super.cmakeFlags or [ ])
-                    ++ final.lib.optionals final.stdenv.hostPlatform.isDarwin [
-                      (final.lib.cmakeFeature "CMAKE_CTEST_ARGUMENTS" "--exclude-regex;test_pybinds_*")
-                    ];
-                });
-              })
-            ];
-          };
           apps.default = {
             type = "app";
             program = pkgs.python3.withPackages (_: [ self'.packages.default ]);
diff --git a/include/aligator/compat/crocoddyl/action-model-wrap.hpp b/include/aligator/compat/crocoddyl/action-model-wrap.hpp
@@ -47,10 +47,9 @@ struct ActionModelWrapperTpl : StageModelTpl<Scalar> {
   using DynDataWrap = DynamicsDataWrapperTpl<Scalar>;
   using Manifold = ManifoldAbstractTpl<Scalar>;
 
-  boost::shared_ptr<CrocActionModel> action_model_;
+  shared_ptr<CrocActionModel> action_model_;
 
-  explicit ActionModelWrapperTpl(
-      boost::shared_ptr<CrocActionModel> action_model);
+  explicit ActionModelWrapperTpl(shared_ptr<CrocActionModel> action_model);
 
   bool hasDynModel() const override { return false; }
 
@@ -81,7 +80,7 @@ struct ActionDataWrapperTpl : public StageDataTpl<Scalar> {
   using CrocActionData = crocoddyl::ActionDataAbstractTpl<Scalar>;
   using DynamicsDataWrapper = DynamicsDataWrapperTpl<Scalar>;
 
-  boost::shared_ptr<CrocActionData> croc_action_data;
+  shared_ptr<CrocActionData> croc_action_data;
 
   ActionDataWrapperTpl(const ActionModelWrapperTpl<Scalar> &croc_action_model);
 
diff --git a/include/aligator/compat/crocoddyl/action-model-wrap.hxx b/include/aligator/compat/crocoddyl/action-model-wrap.hxx
@@ -12,7 +12,7 @@ namespace croc {
 
 template <typename Scalar>
 ActionModelWrapperTpl<Scalar>::ActionModelWrapperTpl(
-    boost::shared_ptr<CrocActionModel> action_model)
+    shared_ptr<CrocActionModel> action_model)
     : Base(CostAbstract{StateWrapper{action_model->get_state()},
                         int(action_model->get_nu())},
            NoOpDynamics<Scalar>{StateWrapper{action_model->get_state()},
diff --git a/include/aligator/compat/crocoddyl/cost-wrap.hpp b/include/aligator/compat/crocoddyl/cost-wrap.hpp
@@ -19,17 +19,16 @@ struct CrocCostModelWrapperTpl : CostAbstractTpl<_Scalar> {
   using BaseData = CostDataAbstractTpl<Scalar>;
   using StateWrap = StateWrapperTpl<Scalar>;
 
-  boost::shared_ptr<CrocCostModel> croc_cost_;
-  boost::shared_ptr<CrocActionModel> action_model_;
+  shared_ptr<CrocCostModel> croc_cost_;
+  shared_ptr<CrocActionModel> action_model_;
 
   /// Constructor from a crocoddyl cost model.
-  explicit CrocCostModelWrapperTpl(boost::shared_ptr<CrocCostModel> cost)
+  explicit CrocCostModelWrapperTpl(shared_ptr<CrocCostModel> cost)
       : Base(StateWrap(cost->get_state()), (int)cost->get_nu()),
         croc_cost_(cost) {}
 
   /// Constructor using a terminal action model.
-  explicit CrocCostModelWrapperTpl(
-      boost::shared_ptr<CrocActionModel> action_model)
+  explicit CrocCostModelWrapperTpl(shared_ptr<CrocActionModel> action_model)
       : Base(StateWrap(action_model->get_state()), (int)action_model->get_nu()),
         action_model_(action_model) {}
 
@@ -80,7 +79,7 @@ struct CrocCostModelWrapperTpl : CostAbstractTpl<_Scalar> {
 
   shared_ptr<BaseData> createData() const {
     if (action_model_ != 0) {
-      boost::shared_ptr<crocoddyl::ActionDataAbstractTpl<Scalar>> am_data =
+      shared_ptr<crocoddyl::ActionDataAbstractTpl<Scalar>> am_data =
           action_model_->createData();
       return std::make_shared<CrocCostDataWrapperTpl<Scalar>>(am_data);
     } else {
@@ -95,14 +94,14 @@ struct CrocCostDataWrapperTpl : CostDataAbstractTpl<Scalar> {
   using CostData = ::crocoddyl::CostDataAbstractTpl<Scalar>;
   using ActionData = ::crocoddyl::ActionDataAbstractTpl<Scalar>;
   using Base = CostDataAbstractTpl<Scalar>;
-  boost::shared_ptr<CostData> croc_cost_data_;
-  boost::shared_ptr<ActionData> croc_act_data_;
+  shared_ptr<CostData> croc_cost_data_;
+  shared_ptr<ActionData> croc_act_data_;
 
-  explicit CrocCostDataWrapperTpl(const boost::shared_ptr<CostData> &crocdata)
+  explicit CrocCostDataWrapperTpl(const shared_ptr<CostData> &crocdata)
       : Base((int)crocdata->Lx.rows(), (int)crocdata->Lu.rows()),
         croc_cost_data_(crocdata) {}
 
-  explicit CrocCostDataWrapperTpl(const boost::shared_ptr<ActionData> &actdata)
+  explicit CrocCostDataWrapperTpl(const shared_ptr<ActionData> &actdata)
       : Base((int)actdata->Lx.rows(), (int)actdata->Lu.rows()),
         croc_act_data_(actdata) {}
 };
diff --git a/include/aligator/compat/crocoddyl/problem-wrap.hpp b/include/aligator/compat/crocoddyl/problem-wrap.hpp
@@ -12,13 +12,12 @@ namespace aligator::compat::croc {
 /// to an aligator::TrajOptProblemTpl
 template <typename Scalar>
 TrajOptProblemTpl<Scalar> convertCrocoddylProblem(
-    const boost::shared_ptr<crocoddyl::ShootingProblemTpl<Scalar>>
-        &croc_problem);
+    const shared_ptr<crocoddyl::ShootingProblemTpl<Scalar>> &croc_problem);
 
 #ifdef ALIGATOR_ENABLE_TEMPLATE_INSTANTIATION
 extern template ::aligator::context::TrajOptProblem
 convertCrocoddylProblem<context::Scalar>(
-    const boost::shared_ptr<context::CrocShootingProblem> &);
+    const shared_ptr<context::CrocShootingProblem> &);
 #endif
 
 } // namespace aligator::compat::croc
diff --git a/include/aligator/compat/crocoddyl/problem-wrap.hxx b/include/aligator/compat/crocoddyl/problem-wrap.hxx
@@ -11,8 +11,7 @@ namespace aligator::compat::croc {
 
 template <typename Scalar>
 TrajOptProblemTpl<Scalar> convertCrocoddylProblem(
-    const boost::shared_ptr<crocoddyl::ShootingProblemTpl<Scalar>>
-        &croc_problem) {
+    const shared_ptr<crocoddyl::ShootingProblemTpl<Scalar>> &croc_problem) {
   const crocoddyl::ShootingProblemTpl<Scalar> &cpb = *croc_problem;
   using VectorXs = typename math_types<Scalar>::VectorXs;
   using StageModel = StageModelTpl<Scalar>;
diff --git a/include/aligator/compat/crocoddyl/state-wrap.hpp b/include/aligator/compat/crocoddyl/state-wrap.hpp
@@ -19,9 +19,9 @@ struct StateWrapperTpl : ManifoldAbstractTpl<_Scalar> {
 
   using StateAbstract = crocoddyl::StateAbstractTpl<Scalar>;
 
-  boost::shared_ptr<StateAbstract> croc_state;
+  shared_ptr<StateAbstract> croc_state;
 
-  explicit StateWrapperTpl(const boost::shared_ptr<StateAbstract> &state)
+  explicit StateWrapperTpl(const shared_ptr<StateAbstract> &state)
       : croc_state(state) {}
 
   int nx() const { return (int)croc_state->get_nx(); }
diff --git a/pixi.lock b/pixi.lock
diff --git a/pixi.toml b/pixi.toml
diff --git a/src/compat/crocoddyl/problem-wrap.cpp b/src/compat/crocoddyl/problem-wrap.cpp
diff --git a/tests/compat/croc-action-model.cpp b/tests/compat/croc-action-model.cpp
diff --git a/tests/compat/croc-problem.cpp b/tests/compat/croc-problem.cpp
