placo 0.5.5__tar.gz → 0.5.9__tar.gz

{placo-0.5.5 → placo-0.5.9}/CMakeLists.txt

@@ -102,7 +102,6 @@ add_library(libplaco SHARED
     src/placo/dynamics/dynamics_solver.cpp
     src/placo/dynamics/constraint.cpp
     src/placo/dynamics/avoid_self_collisions_constraint.cpp
-    src/placo/dynamics/reaction_ratio_constraint.cpp
 
     ${PROTO_SRCS}
     ${PROTO_HDRS}  

{placo-0.5.5 → placo-0.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: placo
-Version: 0.5.5
+Version: 0.5.9
 Summary: PlaCo: Rhoban Planning and Control
 Requires-Python: >= 3.8
 License-Expression: MIT

{placo-0.5.5 → placo-0.5.9}/bindings/expose-dynamics.cpp

@@ -13,8 +13,9 @@ using namespace placo::dynamics;
 using namespace placo::model;
 
 // Overloads
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_passive_overloads, set_passive, 1, 3);
 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(solve_overloads, solve, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_torque_overloads, set_torque, 2, 4);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_joint_overloads, set_joint, 2, 4);
 
 void exposeDynamics()
 {
@@ -50,7 +51,10 @@ void exposeDynamics()
       .def(
           "position_task", +[](PointContact& contact) -> PositionTask& { return *contact.position_task; },
           return_internal_reference<>())
-      .def_readwrite("unilateral", &PointContact::unilateral);
+      .def_readwrite("unilateral", &PointContact::unilateral)
+      .add_property(
+          "R_world_surface", +[](PointContact& contact) { return contact.R_world_surface; },
+          +[](PointContact& contact, Eigen::Matrix3d R) { contact.R_world_surface = R; });
 
   class__<Contact6D, bases<Contact>>("Contact6D", init<FrameTask&, bool>())
       .def(
@@ -64,10 +68,6 @@ void exposeDynamics()
       .def_readwrite("width", &Contact6D::width)
       .def("zmp", &Contact6D::zmp);
 
-  class__<RelativePointContact, bases<Contact>>("RelativePointContact", init<RelativePositionTask&>());
-
-  class__<Relative6DContact, bases<Contact>>("Relative6DContact", init<RelativeFrameTask&>());
-
   class__<ExternalWrenchContact, bases<Contact>>("ExternalWrenchContact", init<RobotWrapper::FrameIndex>())
       .add_property("frame_index", &ExternalWrenchContact::frame_index)
       .add_property(
@@ -79,29 +79,23 @@ void exposeDynamics()
 
   class__<DynamicsSolver>("DynamicsSolver", init<RobotWrapper&>())
       .add_property("problem", &DynamicsSolver::problem)
-      .def_readwrite("friction", &DynamicsSolver::friction)
+      .def_readwrite("damping", &DynamicsSolver::damping)
       .def_readwrite("dt", &DynamicsSolver::dt)
-      .def_readwrite("qdd_safe", &DynamicsSolver::qdd_safe)
+      .def("set_qdd_safe", &DynamicsSolver::set_qdd_safe)
+      .def("set_torque_limit", &DynamicsSolver::set_torque_limit)
       .def_readwrite("gravity_only", &DynamicsSolver::gravity_only)
       .def_readwrite("torque_cost", &DynamicsSolver::torque_cost)
       .def("mask_fbase", &DynamicsSolver::mask_fbase)
       .def("add_point_contact", &DynamicsSolver::add_point_contact, return_internal_reference<>())
       .def("add_unilateral_point_contact", &DynamicsSolver::add_unilateral_point_contact, return_internal_reference<>())
-      .def("add_relative_point_contact", &DynamicsSolver::add_relative_point_contact, return_internal_reference<>())
-      .def("add_relative_fixed_contact", &DynamicsSolver::add_relative_fixed_contact, return_internal_reference<>())
       .def("add_planar_contact", &DynamicsSolver::add_planar_contact, return_internal_reference<>())
       .def("add_fixed_contact", &DynamicsSolver::add_fixed_contact, return_internal_reference<>())
-      .def<ExternalWrenchContact& (DynamicsSolver::*)(std::string)>(
+      .def<ExternalWrenchContact& (DynamicsSolver::*)(std::string, std::string)>(
           "add_external_wrench_contact", &DynamicsSolver::add_external_wrench_contact, return_internal_reference<>())
       .def("add_puppet_contact", &DynamicsSolver::add_puppet_contact, return_internal_reference<>())
       .def("add_task_contact", &DynamicsSolver::add_task_contact, return_internal_reference<>())
       .def("add_avoid_self_collisions_constraint", &DynamicsSolver::add_avoid_self_collisions_constraint,
            return_internal_reference<>())
-      .def("add_reaction_ratio_constraint", &DynamicsSolver::add_reaction_ratio_constraint,
-           return_internal_reference<>())
-      .def("set_passive", &DynamicsSolver::set_passive, set_passive_overloads())
-      .def("set_tau", &DynamicsSolver::set_tau)
-      .def("reset_joint", &DynamicsSolver::reset_joint)
       .def("enable_velocity_limits", &DynamicsSolver::enable_velocity_limits)
       .def("enable_velocity_vs_torque_limits", &DynamicsSolver::enable_velocity_vs_torque_limits)
       .def("enable_joint_limits", &DynamicsSolver::enable_joint_limits)
@@ -116,6 +110,8 @@ void exposeDynamics()
       .def<void (DynamicsSolver::*)(FrameTask&)>("remove_task", &DynamicsSolver::remove_task)
       .def("remove_contact", &DynamicsSolver::remove_contact)
       .def("remove_constraint", &DynamicsSolver::remove_constraint)
+      .def("set_kp", &DynamicsSolver::set_kp)
+      .def("set_kd", &DynamicsSolver::set_kd)
       .add_property(
           "robot", +[](const DynamicsSolver& solver) { return solver.robot; })
       .def(
@@ -153,7 +149,6 @@ void exposeDynamics()
           "b", +[](const Task& task) { return task.b; })
       .add_property("kp", &Task::kp, &Task::kp)
       .add_property("kd", &Task::kd, &Task::kd)
-      .add_property("critically_damped", &Task::critically_damped, &Task::critically_damped)
       .add_property("error", &Task::error)
       .add_property("derror", &Task::derror);
 
@@ -163,6 +158,8 @@ void exposeDynamics()
           "target_world", +[](const PositionTask& task) { return task.target_world; }, &PositionTask::target_world)
       .add_property(
           "dtarget_world", +[](const PositionTask& task) { return task.dtarget_world; }, &PositionTask::dtarget_world)
+      .add_property(
+          "ddtarget_world", +[](const PositionTask& task) { return task.dtarget_world; }, &PositionTask::ddtarget_world)
       .add_property("mask", &PositionTask::mask, &PositionTask::mask);
 
   class__<CoMTask, bases<Task>>("DynamicsCoMTask", init<Eigen::Vector3d>())
@@ -230,7 +227,7 @@ void exposeDynamics()
       .add_property("T_a_b", &RelativeFrameTask::get_T_a_b, &RelativeFrameTask::set_T_a_b);
 
   class__<JointsTask, bases<Task>>("DynamicsJointsTask", init<>())
-      .def("set_joint", &JointsTask::set_joint)
+      .def("set_joint", &JointsTask::set_joint, set_joint_overloads())
       .def(
           "set_joints", +[](JointsTask& task,
                             boost::python::dict& py_dict) { update_map<std::string, double>(task.joints, py_dict); })
@@ -239,7 +236,9 @@ void exposeDynamics()
             update_map<std::string, double>(task.djoints, py_dict);
           });
 
-  class__<TorqueTask, bases<Task>>("DynamicsTorqueTask", init<>()).def("set_torque", &TorqueTask::set_torque);
+  class__<TorqueTask, bases<Task>>("DynamicsTorqueTask", init<>())
+      .def("set_torque", &TorqueTask::set_torque, set_torque_overloads())
+      .def("reset_torque", &TorqueTask::reset_torque);
 
   class__<GearTask, bases<Task>>("DynamicsGearTask", init<>())
       .def("set_gear", &GearTask::set_gear)
@@ -250,7 +249,4 @@ void exposeDynamics()
   class__<AvoidSelfCollisionsConstraint, bases<Constraint>>("AvoidSelfCollisionsDynamicsConstraint", init<>())
       .def_readwrite("self_collisions_margin", &AvoidSelfCollisionsConstraint::self_collisions_margin)
       .def_readwrite("self_collisions_trigger", &AvoidSelfCollisionsConstraint::self_collisions_trigger);
-
-  class__<ReactionRatioConstraint, bases<Constraint>>("DynamicsReactionRatioConstraint", init<Contact&, double>())
-      .def_readwrite("reaction_ratio", &ReactionRatioConstraint::reaction_ratio);
 }

{placo-0.5.5 → placo-0.5.9}/bindings/expose-kinematics.cpp

@@ -114,8 +114,7 @@ void exposeKinematics()
           .def<void (KinematicsSolver::*)(Task&)>("remove_task", &KinematicsSolver::remove_task)
           .def<void (KinematicsSolver::*)(FrameTask&)>("remove_task", &KinematicsSolver::remove_task)
           .def("remove_constraint", &KinematicsSolver::remove_constraint)
-          .def("solve", &KinematicsSolver::solve)
-          .def("add_q_noise", &KinematicsSolver::add_q_noise);
+          .def("solve", &KinematicsSolver::solve);
 
   class__<Task, bases<tools::Prioritized>, boost::noncopyable>("Task", no_init)
       .add_property(

{placo-0.5.5 → placo-0.5.9}/bindings/expose-robot-wrapper.cpp

@@ -52,6 +52,7 @@ void exposeRobotType(class_<RobotType, W1>& type)
       .def("get_T_world_fbase", &RobotType::get_T_world_fbase)
       .def("set_T_world_fbase", &RobotType::set_T_world_fbase)
       .def("com_world", &RobotType::com_world)
+      .def("centroidal_map", &RobotType::centroidal_map)
       .def("joint_names", &RobotType::joint_names, joint_names_overloads())
       .def("frame_names", &RobotType::frame_names)
       .def("self_collisions", &RobotType::self_collisions)
@@ -124,7 +125,8 @@ void exposeRobotType(class_<RobotType, W1>& type)
           "joint_jacobian", +[](RobotType& robot, const std::string& joint,
                                 const std::string& reference) { return robot.joint_jacobian(joint, reference); })
       .def(
-          "make_solver", +[](RobotType& robot) { return placo::kinematics::KinematicsSolver(robot); });
+          "make_solver", +[](RobotType& robot) { return placo::kinematics::KinematicsSolver(robot); })
+      .def("add_q_noise", &RobotType::add_q_noise);
 }
 
 void exposeRobotWrapper()

{placo-0.5.5 → placo-0.5.9}/bindings/expose-tools.cpp

@@ -31,6 +31,7 @@ void exposeTools()
   def("rotation_from_axis", &rotation_from_axis);
   def("frame_yaw", &frame_yaw);
   def("flatten_on_floor", &flatten_on_floor);
+  def("optimal_transformation", &optimal_transformation);
 
   exposeStdVector<int>("vector_int");
   exposeStdVector<double>("vector_double");
@@ -62,6 +63,7 @@ void exposeTools()
   class__<CubicSpline>("CubicSpline", init<optional<bool>>())
       .def("pos", &CubicSpline::pos)
       .def("vel", &CubicSpline::vel)
+      .def("acc", &CubicSpline::acc)
       .def("add_point", &CubicSpline::add_point)
       .def("clear", &CubicSpline::clear)
       .def("duration", &CubicSpline::duration);
@@ -69,6 +71,7 @@ void exposeTools()
   class__<CubicSpline3D>("CubicSpline3D")
       .def("pos", &CubicSpline3D::pos)
       .def("vel", &CubicSpline3D::vel)
+      .def("acc", &CubicSpline3D::acc)
       .def("add_point", &CubicSpline3D::add_point)
       .def("clear", &CubicSpline3D::clear)
       .def("duration", &CubicSpline3D::duration);

{placo-0.5.5 → placo-0.5.9}/bindings/expose-walk-pattern-generator.cpp

@@ -110,8 +110,10 @@ void exposeWalkPatternGenerator()
       .add_property("trunk_mode", &WalkTasks::trunk_mode, &WalkTasks::trunk_mode)
       .add_property("com_x", &WalkTasks::com_x, &WalkTasks::com_x)
       .add_property("com_y", &WalkTasks::com_y, &WalkTasks::com_y)
-      .add_property(
-          "trunk_orientation_task", +[](WalkTasks& tasks) { return *tasks.trunk_orientation_task; });
+      .add_property("trunk_orientation_task",
+                    make_function(
+                        +[](WalkTasks& tasks) -> OrientationTask& { return *tasks.trunk_orientation_task; },
+                        return_value_policy<reference_existing_object>()));
 
   class__<LIPM::Trajectory>("LIPMTrajectory", init<>())
       .def("pos", &LIPM::Trajectory::pos)