placo 0.5.6__tar.gz → 0.6.0__tar.gz

{placo-0.5.6 → placo-0.6.0}/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.6.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: placo
+Version: 0.6.0
+Summary: PlaCo: Rhoban Planning and Control
+Requires-Python: >= 3.8
+License-Expression: MIT
+Author-email: Rhoban team <team@rhoban.com>
+Project-URL: Changelog, https://github.com/rhoban/placo/blob/main/CHANGELOG.md
+Home-page: https://placo.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/rhoban/placo.git
+Requires-Dist: cmeel
+Requires-Dist: eiquadprog >= 1.2.6, < 2
+Requires-Dist: pin >= 2.6.18, < 3
+Requires-Dist: rhoban-cmeel-jsoncpp
+Requires-Dist: meshcat
+Requires-Dist: numpy<2
+Requires-Dist: ischedule
+Provides-Extra: build
+Requires-Dist: pin[build] >= 2.6.18, < 3 ; extra == "build"
+Requires-Dist: cmeel-urdfdom[build] ; extra == "build"
+Description-Content-Type: text/markdown
+
+# PlaCo
+
+PlaCo is Rhoban's planning and control library.
+Its main features are:
+
+* Task-space Inverse Kinematics with constraints,
+* Task-space Inverse Dynamics with constraints,
+* QP problem formulation,
+* Built on the top of [pinocchio](https://github.com/stack-of-tasks/pinocchio)
+* Written in C++ with Python bindings
+
+[![Megabot demo](https://github.com/Rhoban/placo-examples/blob/master/kinematics/videos/quadruped_targets.gif?raw=true)](https://github.com/Rhoban/placo-examples/blob/master/kinematics/videos/quadruped_targets.mp4?raw=true)
+
+*Inverse Kinematics Example: a quadruped robot hitting targets with a leg while keeping its three legs on the ground*
+
+[source code (quadruped_targets.py)](https://github.com/Rhoban/placo-examples/blob/master/kinematics/quadruped_targets.py) / [more kinematics examples](https://placo.readthedocs.io/en/latest/kinematics/examples_gallery.html)
+
+[![Megabot demo](https://github.com/Rhoban/placo-examples/blob/master/dynamics/videos/megabot.gif?raw=true)](https://github.com/Rhoban/placo-examples/blob/master/dynamics/videos/megabot.mp4?raw=true)
+
+*Inverse Dynamics Example: a quadruped with many loop closure joints*
+
+[source code (megabot.py)](https://github.com/Rhoban/placo-examples/blob/master/dynamics/megabot.py) / [more dynamics examples](https://placo.readthedocs.io/en/latest/dynamics/examples_gallery.html)
+
+## Installing
+
+PlaCo is available from [pip](https://placo.readthedocs.io/en/latest/basics/installation_pip.html),
+or can be [built from sources](https://placo.readthedocs.io/en/latest/basics/installation_source.html).
+
+## Documentation
+
+Here is the [official documentation](https://placo.readthedocs.io/en/latest/)
+
+You can also find many examples in the [placo-examples](https://github.com/rhoban/placo-examples)
+repository.

placo-0.6.0/README.md

@@ -0,0 +1,34 @@
+# PlaCo
+
+PlaCo is Rhoban's planning and control library.
+Its main features are:
+
+* Task-space Inverse Kinematics with constraints,
+* Task-space Inverse Dynamics with constraints,
+* QP problem formulation,
+* Built on the top of [pinocchio](https://github.com/stack-of-tasks/pinocchio)
+* Written in C++ with Python bindings
+
+[![Megabot demo](https://github.com/Rhoban/placo-examples/blob/master/kinematics/videos/quadruped_targets.gif?raw=true)](https://github.com/Rhoban/placo-examples/blob/master/kinematics/videos/quadruped_targets.mp4?raw=true)
+
+*Inverse Kinematics Example: a quadruped robot hitting targets with a leg while keeping its three legs on the ground*
+
+[source code (quadruped_targets.py)](https://github.com/Rhoban/placo-examples/blob/master/kinematics/quadruped_targets.py) / [more kinematics examples](https://placo.readthedocs.io/en/latest/kinematics/examples_gallery.html)
+
+[![Megabot demo](https://github.com/Rhoban/placo-examples/blob/master/dynamics/videos/megabot.gif?raw=true)](https://github.com/Rhoban/placo-examples/blob/master/dynamics/videos/megabot.mp4?raw=true)
+
+*Inverse Dynamics Example: a quadruped with many loop closure joints*
+
+[source code (megabot.py)](https://github.com/Rhoban/placo-examples/blob/master/dynamics/megabot.py) / [more dynamics examples](https://placo.readthedocs.io/en/latest/dynamics/examples_gallery.html)
+
+## Installing
+
+PlaCo is available from [pip](https://placo.readthedocs.io/en/latest/basics/installation_pip.html),
+or can be [built from sources](https://placo.readthedocs.io/en/latest/basics/installation_source.html).
+
+## Documentation
+
+Here is the [official documentation](https://placo.readthedocs.io/en/latest/)
+
+You can also find many examples in the [placo-examples](https://github.com/rhoban/placo-examples)
+repository.

{placo-0.5.6 → placo-0.6.0}/bindings/expose-dynamics.cpp

@@ -13,8 +13,10 @@ using namespace placo::dynamics;
 using namespace placo::model;
 
 // Overloads
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(frame_configure_overloads, configure, 2, 4);
 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()
 {
@@ -42,6 +44,7 @@ void exposeDynamics()
       .def_readwrite("active", &Contact::active)
       .def_readwrite("mu", &Contact::mu)
       .def_readwrite("weight_forces", &Contact::weight_forces)
+      .def_readwrite("weight_tangentials", &Contact::weight_tangentials)
       .def_readwrite("weight_moments", &Contact::weight_moments)
       .add_property(
           "wrench", +[](Contact& contact) { return contact.wrench; });
@@ -50,7 +53,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,9 +70,19 @@ 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__<LineContact, bases<Contact>>("LineContact", init<FrameTask&, bool>())
+      .def(
+          "position_task", +[](LineContact& contact) -> PositionTask& { return *contact.position_task; },
+          return_internal_reference<>())
+      .def(
+          "orientation_task", +[](LineContact& contact) -> OrientationTask& { return *contact.orientation_task; },
+          return_internal_reference<>())
+      .def_readwrite("unilateral", &LineContact::unilateral)
+      .def_readwrite("length", &LineContact::length)
+      .def("zmp", &LineContact::zmp)
+      .add_property(
+          "R_world_surface", +[](PointContact& contact) { return contact.R_world_surface; },
+          +[](PointContact& contact, Eigen::Matrix3d R) { contact.R_world_surface = R; });
 
   class__<ExternalWrenchContact, bases<Contact>>("ExternalWrenchContact", init<RobotWrapper::FrameIndex>())
       .add_property("frame_index", &ExternalWrenchContact::frame_index)
@@ -81,24 +97,23 @@ void exposeDynamics()
       .add_property("problem", &DynamicsSolver::problem)
       .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("add_line_contact", &DynamicsSolver::add_line_contact, return_internal_reference<>())
+      .def("add_unilateral_line_contact", &DynamicsSolver::add_unilateral_line_contact, return_internal_reference<>())
+      .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("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)
@@ -152,7 +167,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);
 
@@ -162,6 +176,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>())
@@ -214,7 +230,7 @@ void exposeDynamics()
       .def(
           "orientation", +[](const FrameTask& task) -> OrientationTask& { return *task.orientation; },
           return_internal_reference<>())
-      .def("configure", &FrameTask::configure)
+      .def("configure", &FrameTask::configure, frame_configure_overloads())
       .add_property("T_world_frame", &FrameTask::get_T_world_frame, &FrameTask::set_T_world_frame);
 
   class__<RelativeFrameTask>("DynamicsRelativeFrameTask", init<>())
@@ -229,7 +245,8 @@ 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("get_joint", &JointsTask::get_joint)
       .def(
           "set_joints", +[](JointsTask& task,
                             boost::python::dict& py_dict) { update_map<std::string, double>(task.joints, py_dict); })
@@ -251,7 +268,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.6 → placo-0.6.0}/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(
@@ -193,6 +192,7 @@ void exposeKinematics()
 
   class__<JointsTask, bases<Task>>("JointsTask", init<>())
       .def("set_joint", &JointsTask::set_joint)
+      .def("get_joint", &JointsTask::get_joint)
       .def(
           "set_joints", +[](JointsTask& task, boost::python::dict& py_dict) {
             update_map<std::string, double>(task.joints, py_dict);

{placo-0.5.6 → placo-0.6.0}/bindings/expose-problem.cpp

@@ -109,6 +109,7 @@ void exposeProblem()
       .def("clear_variables", &Problem::clear_variables)
       .def("clear_constraints", &Problem::clear_constraints)
       .def("dump_status", &Problem::dump_status)
+      .add_property("x", &Problem::x)
       .add_property("n_variables", &Problem::n_variables, &Problem::n_variables)
       .add_property("n_inequalities", &Problem::n_inequalities, &Problem::n_inequalities)
       .add_property("n_equalities", &Problem::n_equalities, &Problem::n_equalities)
@@ -117,6 +118,7 @@ void exposeProblem()
       .add_property("slack_variables", &Problem::slack_variables, &Problem::slack_variables)
       .add_property("use_sparsity", &Problem::use_sparsity, &Problem::use_sparsity)
       .add_property("rewrite_equalities", &Problem::rewrite_equalities, &Problem::rewrite_equalities)
+      .add_property("regularization", &Problem::regularization, &Problem::regularization)
       .add_property(
           "slacks", +[](const Problem& problem) { return problem.slacks; });
 
@@ -133,6 +135,7 @@ void exposeProblem()
           "b", +[](Expression& e) { return e.b; })
       .def("__len__", &Expression::rows)
       .def("is_scalar", &Expression::is_scalar)
+      .def("is_constant", &Expression::is_constant)
       .def("slice", &Expression::slice)
       .def("rows", &Expression::rows)
       .def("cols", &Expression::cols)
@@ -149,6 +152,7 @@ void exposeProblem()
       .def(self - self)
       .def(self * float())
       .def(float() * self)
+      .def(self * self)
       .def(self + other<Eigen::VectorXd>())
       .def(other<Eigen::VectorXd>() + self)
       .def(self - other<Eigen::VectorXd>())
@@ -158,7 +162,7 @@ void exposeProblem()
       .def(self - float())
       .def(float() - self)
       .def(other<Eigen::MatrixXd>() * self)
-      .def("multiply", &Expression::multiply)
+      .def("left_multiply", &Expression::left_multiply)
       // Compare to build constraints
       .def(self >= self)
       .def(self <= self)

{placo-0.5.6 → placo-0.6.0}/bindings/expose-robot-wrapper.cpp

@@ -61,6 +61,8 @@ void exposeRobotType(class_<RobotType, W1>& type)
       .def("com_jacobian_time_variation", &RobotType::com_jacobian_time_variation)
       .def("generalized_gravity", &RobotType::generalized_gravity)
       .def("non_linear_effects", &RobotType::non_linear_effects)
+      .def("set_rotor_inertia", &RobotType::set_rotor_inertia)
+      .def("set_gear_ratio", &RobotType::set_gear_ratio)
       .def("mass_matrix", &RobotType::mass_matrix)
       .def("set_gravity", &RobotType::set_gravity)
       .def("total_mass", &RobotType::total_mass)
@@ -125,7 +127,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.6 → placo-0.6.0}/bindings/expose-tools.cpp

@@ -63,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);
@@ -70,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);