placo 0.5.4__tar.gz → 0.7.4__tar.gz

{placo-0.5.4 → placo-0.7.4}/CMakeLists.txt

@@ -51,6 +51,9 @@ add_library(libplaco SHARED
     src/placo/tools/prioritized.cpp
     src/placo/tools/cubic_spline.cpp
     src/placo/tools/cubic_spline_3d.cpp
+    src/placo/tools/directions.cpp
+    src/placo/tools/polynom.cpp
+    src/placo/tools/segment.cpp
 
     # Problem formulation
     src/placo/problem/problem.cpp
@@ -58,6 +61,7 @@ add_library(libplaco SHARED
     src/placo/problem/variable.cpp
     src/placo/problem/expression.cpp
     src/placo/problem/integrator.cpp
+    src/placo/problem/problem_polynom.cpp
     src/placo/problem/constraint.cpp
     src/placo/problem/polygon_constraint.cpp
     src/placo/problem/sparsity.cpp
@@ -83,6 +87,7 @@ add_library(libplaco SHARED
     src/placo/kinematics/constraint.cpp
     src/placo/kinematics/avoid_self_collisions_constraint.cpp
     src/placo/kinematics/com_polygon_constraint.cpp
+    src/placo/kinematics/joint_space_half_spaces_constraint.cpp
     src/placo/kinematics/cone_constraint.cpp
     src/placo/kinematics/axis_align_task.cpp
 
@@ -102,7 +107,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}  
@@ -123,7 +127,7 @@ target_link_libraries(libplaco PUBLIC
     ${PROTOBUF_LIBRARIES}
   ${PROTOBUF_LIBRARIES}
 )
-target_compile_definitions(libplaco PUBLIC -DPINOCCHIO_WITH_HPP_FCL)
+target_compile_definitions(libplaco PUBLIC)
 
 if(TARGET rhoban_utils)
   message("Placo: Rhoban utils is present, enabling it")
@@ -135,6 +139,7 @@ set(CMAKE_SHARED_MODULE_PREFIX "")
 
 find_package(Python3 REQUIRED)
 find_package(Boost COMPONENTS python REQUIRED)
+find_package(Python REQUIRED COMPONENTS Interpreter)
 
 add_library(placo MODULE 
     bindings/expose-eigen.cpp
@@ -147,16 +152,19 @@ add_library(placo MODULE
     bindings/expose-walk-pattern-generator.cpp
     bindings/expose-dynamics.cpp
     bindings/module.cpp
-    bindings/registry.cpp
 )
 set_target_properties(placo PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${PYTHON_SITELIB})
 
 target_link_libraries(placo ${Boost_LIBRARIES} ${PYTHON_LIBRARIES} libplaco)
 target_include_directories(placo PRIVATE ${PYTHON_INCLUDE_DIRS})
 
-add_custom_command(TARGET placo POST_BUILD
-    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/stubs.py > placo.pyi
-    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${PYTHON_SITELIB}
+add_custom_command(
+    TARGET placo POST_BUILD
+    COMMAND doxystub
+        --module placo
+        --doxygen_directory "${CMAKE_CURRENT_SOURCE_DIR}"
+        --output "${CMAKE_BINARY_DIR}/${PYTHON_SITELIB}/placo.pyi"
+    WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/${PYTHON_SITELIB}"
     COMMENT "Generating stubs..."
 )
 
@@ -171,4 +179,4 @@ set_target_properties(libplaco PROPERTIES INSTALL_RPATH "\$ORIGIN")
 install(TARGETS libplaco DESTINATION lib)
 install(TARGETS placo DESTINATION ${PYTHON_SITELIB})
 install(FILES ${CMAKE_BINARY_DIR}/${PYTHON_SITELIB}/placo.pyi DESTINATION ${PYTHON_SITELIB})
-install(DIRECTORY ${CMAKE_BINARY_DIR}/${PYTHON_SITELIB}/placo_utils DESTINATION ${PYTHON_SITELIB})
+install(DIRECTORY ${CMAKE_BINARY_DIR}/${PYTHON_SITELIB}/placo_utils DESTINATION ${PYTHON_SITELIB})

{placo-0.5.4 → placo-0.7.4}/Makefile

@@ -2,7 +2,7 @@
 # Building Python wheel
 all:
 	@rm -rf dist/*
-	python -m build --sdist --wheel
+	bash build_wheel.sh
 	bash tweak_sdist.sh
 
 upload:

placo-0.7.4/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: placo
+Version: 0.7.4
+Summary: PlaCo: Rhoban Planning and Control
+Requires-Python: >= 3.9
+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 >= 3
+Requires-Dist: rhoban-cmeel-jsoncpp
+Requires-Dist: meshcat
+Requires-Dist: ischedule
+Provides-Extra: build
+Requires-Dist: pin[build] >=  3 ; extra == "build"
+Requires-Dist: doxystub ; extra == "build"
+Description-Content-Type: text/markdown
+
+<img width="400" src="https://placo.readthedocs.io/en/latest/_static/placo.png" />
+
+## Planning & Control
+
+PlaCo is Rhoban's planning and control library. It is built on the top of [pinocchio](https://github.com/stack-of-tasks/pinocchio), [eiquadprog](https://github.com/stack-of-tasks/eiquadprog) QP solver, and fully written in C++ with Python bindings, allowing fast prototyping with good runtime performances. It features task-space inverse kinematics and dynamics (see below) high-level API for whole-body control tasks.
+
+### Task-Space Inverse Kinematics
+
+[![Quadruoped 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)
+
+High-level API to specify tasks for constrained inverse kinematics (IK).
+
+- [See documentation](https://placo.readthedocs.io/en/latest/kinematics/getting_started.html)
+- [Examples](https://placo.readthedocs.io/en/latest/kinematics/examples_gallery.html)
+
+### Task-Space Inverse Dynamics
+
+[![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)
+
+High-level API to specify tasks for constrained inverse dynamics (ID).
+
+- [See documentation](https://placo.readthedocs.io/en/latest/dynamics/getting_started.html)
+- [Examples](https://placo.readthedocs.io/en/latest/dynamics/examples_gallery.html)
+
+
+## Installing
+
+PlaCo can be installed from ``pip``
+
+```
+pip install placo
+```
+
+Or [built from sources](https://placo.readthedocs.io/en/latest/basics/installation_source.html)
+
+## Resources
+
+* [Documentation](https://placo.readthedocs.io/en/latest/)
+* [Examples](https://github.com/rhoban/placo-examples) repository

placo-0.7.4/README.md

@@ -0,0 +1,39 @@
+<img width="400" src="https://placo.readthedocs.io/en/latest/_static/placo.png" />
+
+## Planning & Control
+
+PlaCo is Rhoban's planning and control library. It is built on the top of [pinocchio](https://github.com/stack-of-tasks/pinocchio), [eiquadprog](https://github.com/stack-of-tasks/eiquadprog) QP solver, and fully written in C++ with Python bindings, allowing fast prototyping with good runtime performances. It features task-space inverse kinematics and dynamics (see below) high-level API for whole-body control tasks.
+
+### Task-Space Inverse Kinematics
+
+[![Quadruoped 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)
+
+High-level API to specify tasks for constrained inverse kinematics (IK).
+
+- [See documentation](https://placo.readthedocs.io/en/latest/kinematics/getting_started.html)
+- [Examples](https://placo.readthedocs.io/en/latest/kinematics/examples_gallery.html)
+
+### Task-Space Inverse Dynamics
+
+[![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)
+
+High-level API to specify tasks for constrained inverse dynamics (ID).
+
+- [See documentation](https://placo.readthedocs.io/en/latest/dynamics/getting_started.html)
+- [Examples](https://placo.readthedocs.io/en/latest/dynamics/examples_gallery.html)
+
+
+## Installing
+
+PlaCo can be installed from ``pip``
+
+```
+pip install placo
+```
+
+Or [built from sources](https://placo.readthedocs.io/en/latest/basics/installation_source.html)
+
+## Resources
+
+* [Documentation](https://placo.readthedocs.io/en/latest/)
+* [Examples](https://github.com/rhoban/placo-examples) repository

placo-0.7.4/bindings/doxystub.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <boost/python.hpp>
+
+/**
+ * This wrapper adds a __cxx_class__ method on the exposed class, allowing to retrieve the original
+ * C++ type of the object from Python.
+ */
+template <class W, class X1 = boost::python::detail::not_specified, class X2 = boost::python::detail::not_specified,
+          class X3 = boost::python::detail::not_specified, typename... Args>
+boost::python::class_<W, X1, X2, X3> class__(Args... args)
+{
+  return boost::python::class_<W, X1, X2>(args...).def(
+      "__cxx_class__", +[]() { return boost::core::demangle(typeid(W).name()); });
+}

{placo-0.5.4 → placo-0.7.4}/bindings/expose-dynamics.cpp

@@ -2,30 +2,31 @@
 
 #include "expose-utils.hpp"
 #include "module.h"
-#include "registry.h"
+
+#include "doxystub.h"
 #include "placo/model/robot_wrapper.h"
 #include "placo/dynamics/dynamics_solver.h"
 #include <Eigen/Dense>
 #include <boost/python.hpp>
+#include <eigenpy/eigen-to-python.hpp>
 
 using namespace placo;
 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(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()
 {
   class__<DynamicsSolver::Result>("DynamicsSolverResult")
       .add_property("success", &DynamicsSolver::Result::success)
-      .add_property(
-          "tau", +[](const DynamicsSolver::Result& result) { return result.tau; })
-      .add_property(
-          "qdd", +[](const DynamicsSolver::Result& result) { return result.qdd; })
-      .add_property(
-          "tau_contacts", +[](const DynamicsSolver::Result& result) { return result.tau_contacts; })
+      .def_readwrite("tau", &DynamicsSolver::Result::tau)
+      .def_readwrite("qdd", &DynamicsSolver::Result::qdd)
+      .def_readwrite("tau_contacts", &DynamicsSolver::Result::tau_contacts)
       .def(
           "tau_dict", +[](const DynamicsSolver::Result& result, RobotWrapper& robot) {
             boost::python::dict dict;
@@ -42,15 +43,16 @@ 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; });
+      .def_readonly("wrench", &Contact::wrench);
 
   class__<PointContact, bases<Contact>>("PointContact", init<PositionTask&, bool>())
       .def(
           "position_task", +[](PointContact& contact) -> PositionTask& { return *contact.position_task; },
           return_internal_reference<>())
-      .def_readwrite("unilateral", &PointContact::unilateral);
+      .def_readwrite("unilateral", &PointContact::unilateral)
+      .def_readwrite("R_world_surface", &PointContact::R_world_surface);
 
   class__<Contact6D, bases<Contact>>("Contact6D", init<FrameTask&, bool>())
       .def(
@@ -64,14 +66,23 @@ 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)
-      .add_property(
-          "w_ext", +[](ExternalWrenchContact& contact) { return contact.w_ext; }, &ExternalWrenchContact::w_ext);
+      .def_readwrite("w_ext", &ExternalWrenchContact::w_ext);
 
   class__<PuppetContact, bases<Contact>>("PuppetContact", init<>());
 
@@ -79,29 +90,28 @@ 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)
+      .add_property(
+          "extra_force", +[](DynamicsSolver& solver) { return solver.extra_force; },
+          +[](DynamicsSolver& solver, Eigen::VectorXd force) { solver.extra_force = force; })
       .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("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 +126,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(
@@ -147,64 +159,44 @@ void exposeDynamics()
                                                                         &DynamicsSolver::add_frame_task);
 
   class__<Task, bases<tools::Prioritized>, boost::noncopyable>("DynamicsTask", no_init)
-      .add_property(
-          "A", +[](const Task& task) { return task.A; })
-      .add_property(
-          "b", +[](const Task& task) { return task.b; })
+      .def_readwrite("A", &Task::A)
+      .def_readwrite("b", &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);
 
   class__<PositionTask, bases<Task>>("DynamicsPositionTask", init<RobotWrapper::FrameIndex, Eigen::Vector3d>())
       .add_property("frame_index", &PositionTask::frame_index)
-      .add_property(
-          "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)
+      .def_readwrite("target_world", &PositionTask::target_world)
+      .def_readwrite("dtarget_world", &PositionTask::dtarget_world)
+      .def_readwrite("ddtarget_world", &PositionTask::ddtarget_world)
       .add_property("mask", &PositionTask::mask, &PositionTask::mask);
 
   class__<CoMTask, bases<Task>>("DynamicsCoMTask", init<Eigen::Vector3d>())
-      .add_property(
-          "target_world", +[](const CoMTask& task) { return task.target_world; }, &CoMTask::target_world)
-      .add_property(
-          "dtarget_world", +[](const CoMTask& task) { return task.dtarget_world; }, &CoMTask::dtarget_world)
-      .add_property(
-          "ddtarget_world", +[](const CoMTask& task) { return task.dtarget_world; }, &CoMTask::ddtarget_world)
+      .def_readwrite("target_world", &CoMTask::target_world)
+      .def_readwrite("dtarget_world", &CoMTask::dtarget_world)
+      .def_readwrite("ddtarget_world", &CoMTask::ddtarget_world)
       .add_property("mask", &CoMTask::mask, &CoMTask::mask);
 
   class__<RelativePositionTask, bases<Task>>(
       "DynamicsRelativePositionTask", init<RobotWrapper::FrameIndex, RobotWrapper::FrameIndex, Eigen::Vector3d>())
-      .add_property(
-          "target", +[](const RelativePositionTask& task) { return task.target; }, &RelativePositionTask::target)
-      .add_property(
-          "dtarget", +[](const RelativePositionTask& task) { return task.dtarget; }, &RelativePositionTask::dtarget)
-      .add_property(
-          "ddtarget", +[](const RelativePositionTask& task) { return task.ddtarget; }, &RelativePositionTask::ddtarget)
+      .def_readwrite("target", &RelativePositionTask::target)
+      .def_readwrite("dtarget", &RelativePositionTask::dtarget)
+      .def_readwrite("ddtarget", &RelativePositionTask::ddtarget)
       .add_property("mask", &RelativePositionTask::mask, &RelativePositionTask::mask);
 
   class__<RelativeOrientationTask, bases<Task>>(
       "DynamicsRelativeOrientationTask", init<RobotWrapper::FrameIndex, RobotWrapper::FrameIndex, Eigen::Matrix3d>())
-      .add_property(
-          "R_a_b", +[](const RelativeOrientationTask& task) { return task.R_a_b; }, &RelativeOrientationTask::R_a_b)
-      .add_property(
-          "omega_a_b", +[](const RelativeOrientationTask& task) { return task.omega_a_b; },
-          &RelativeOrientationTask::omega_a_b)
-      .add_property(
-          "domega_a_b", +[](const RelativeOrientationTask& task) { return task.domega_a_b; },
-          &RelativeOrientationTask::domega_a_b)
+      .def_readwrite("R_a_b", &RelativeOrientationTask::R_a_b)
+      .def_readwrite("omega_a_b", &RelativeOrientationTask::omega_a_b)
+      .def_readwrite("domega_a_b", &RelativeOrientationTask::domega_a_b)
       .add_property("mask", &RelativeOrientationTask::mask, &RelativeOrientationTask::mask);
 
   class__<OrientationTask, bases<Task>>("DynamicsOrientationTask", init<RobotWrapper::FrameIndex, Eigen::Matrix3d>())
-      .add_property(
-          "R_world_frame", +[](const OrientationTask& task) { return task.R_world_frame; },
-          &OrientationTask::R_world_frame)
-      .add_property(
-          "omega_world", +[](const OrientationTask& task) { return task.omega_world; }, &OrientationTask::omega_world)
-      .add_property(
-          "domega_world", +[](const OrientationTask& task) { return task.domega_world; },
-          &OrientationTask::domega_world)
+      .def_readwrite("R_world_frame", &OrientationTask::R_world_frame)
+      .def_readwrite("omega_world", &OrientationTask::omega_world)
+      .def_readwrite("domega_world", &OrientationTask::domega_world)
       .add_property("mask", &OrientationTask::mask, &OrientationTask::mask);
 
   class__<FrameTask>("DynamicsFrameTask", init<>())
@@ -215,7 +207,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<>())
@@ -230,7 +222,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); })
@@ -239,7 +232,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 +245,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.4 → placo-0.7.4}/bindings/expose-footsteps.cpp

@@ -2,12 +2,13 @@
 
 #include "expose-utils.hpp"
 #include "module.h"
-#include "registry.h"
+#include "doxystub.h"
 #include "placo/humanoid/footsteps_planner.h"
 #include "placo/humanoid/footsteps_planner_naive.h"
 #include "placo/humanoid/footsteps_planner_repetitive.h"
 #include <Eigen/Dense>
 #include <boost/python.hpp>
+#include <eigenpy/eigen-to-python.hpp>
 
 using namespace boost::python;
 using namespace placo::humanoid;
@@ -20,37 +21,37 @@ void exposeFootsteps()
       .value("right", HumanoidRobot::Side::Right);
 
   class__<FootstepsPlanner::Footstep>("Footstep", init<double, double>())
-      .def("support_polygon", &FootstepsPlanner::Footstep::support_polygon)
       .add_property("side", &FootstepsPlanner::Footstep::side, &FootstepsPlanner::Footstep::side)
-      .add_property(
-          "frame", +[](const FootstepsPlanner::Footstep& footstep) { return footstep.frame; },
-          &FootstepsPlanner::Footstep::frame)
       .add_property("foot_length", &FootstepsPlanner::Footstep::foot_length, &FootstepsPlanner::Footstep::foot_length)
       .add_property("foot_width", &FootstepsPlanner::Footstep::foot_width, &FootstepsPlanner::Footstep::foot_width)
+      .add_property("frame", &FootstepsPlanner::Footstep::frame, &FootstepsPlanner::Footstep::frame)
       .def("support_polygon", &FootstepsPlanner::Footstep::support_polygon)
       .def("overlap", &FootstepsPlanner::Footstep::overlap)
       .def("polygon_contains", &FootstepsPlanner::Footstep::polygon_contains)
-      .staticmethod("polygon_contains")
-      .add_property("kick", &FootstepsPlanner::Footstep::kick, &FootstepsPlanner::Footstep::kick);
+      .staticmethod("polygon_contains");
 
-  class__<FootstepsPlanner::Support>("Support")
+  class__<FootstepsPlanner::Support>("Support", init<>())
       .def("support_polygon", &FootstepsPlanner::Support::support_polygon)
       .def("frame", &FootstepsPlanner::Support::frame)
       .def("footstep_frame", &FootstepsPlanner::Support::footstep_frame)
+      .def("apply_offset", &FootstepsPlanner::Support::apply_offset)
       .def("side", &FootstepsPlanner::Support::side)
       .def("is_both", &FootstepsPlanner::Support::is_both)
       .def(
           "set_start", +[](FootstepsPlanner::Support& support, bool b) { support.start = b; })
       .def(
           "set_end", +[](FootstepsPlanner::Support& support, bool b) { support.end = b; })
-      .def("kick", &FootstepsPlanner::Support::kick)
-      .add_property("footsteps", &FootstepsPlanner::Support::footsteps)
+      .add_property("footsteps", &FootstepsPlanner::Support::footsteps, &FootstepsPlanner::Support::footsteps)
+      .add_property("t_start", &FootstepsPlanner::Support::t_start, &FootstepsPlanner::Support::t_start)
+      .add_property("elapsed_ratio", &FootstepsPlanner::Support::elapsed_ratio,
+                    &FootstepsPlanner::Support::elapsed_ratio)
+      .add_property("time_ratio", &FootstepsPlanner::Support::time_ratio, &FootstepsPlanner::Support::time_ratio)
       .add_property("start", &FootstepsPlanner::Support::start, &FootstepsPlanner::Support::start)
-      .add_property("end", &FootstepsPlanner::Support::end, &FootstepsPlanner::Support::end);
+      .add_property("end", &FootstepsPlanner::Support::end, &FootstepsPlanner::Support::end)
+      .add_property("replanned", &FootstepsPlanner::Support::replanned, &FootstepsPlanner::Support::replanned);
 
   class__<FootstepsPlanner, boost::noncopyable>("FootstepsPlanner", no_init)
       .def("make_supports", &FootstepsPlanner::make_supports)
-      .def("add_first_support", &FootstepsPlanner::add_first_support)
       .def("opposite_footstep", &FootstepsPlanner::opposite_footstep);
 
   class__<FootstepsPlannerNaive, bases<FootstepsPlanner>>("FootstepsPlannerNaive", init<HumanoidParameters&>())

{placo-0.5.4 → placo-0.7.4}/bindings/expose-kinematics.cpp

@@ -2,11 +2,12 @@
 
 #include "expose-utils.hpp"
 #include "module.h"
-#include "registry.h"
+#include "doxystub.h"
 #include "placo/kinematics/kinematics_solver.h"
 #include <boost/python/return_internal_reference.hpp>
 #include <Eigen/Dense>
 #include <boost/python.hpp>
+#include <eigenpy/eigen-to-python.hpp>
 
 using namespace boost::python;
 using namespace placo;
@@ -92,6 +93,10 @@ void exposeKinematics()
           .def("add_com_polygon_constraint", &KinematicsSolver::add_com_polygon_constraint,
                return_internal_reference<>())
 
+          // Joint-space half-spaces
+          .def("add_joint_space_half_spaces_constraint", &KinematicsSolver::add_joint_space_half_spaces_constraint,
+               return_internal_reference<>())
+
           // Cone constraint
           .def<ConeConstraint& (KinematicsSolver::*)(std::string, std::string, double)>(
               "add_cone_constraint", &KinematicsSolver::add_cone_constraint, return_internal_reference<>())
@@ -114,14 +119,11 @@ 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(
-          "A", +[](const Task& task) { return task.A; })
-      .add_property(
-          "b", +[](const Task& task) { return task.b; })
+      .def_readonly("A", &Task::A)
+      .def_readonly("b", &Task::b)
       .def("error", &Task::error)
       .def("error_norm", &Task::error_norm)
       .def("update", &Task::update);
@@ -136,8 +138,7 @@ void exposeKinematics()
       "RelativePositionTask", init<RobotWrapper::FrameIndex, RobotWrapper::FrameIndex, Eigen::Vector3d>())
       .add_property("frame_a", &RelativePositionTask::frame_a)
       .add_property("frame_b", &RelativePositionTask::frame_b)
-      .add_property(
-          "target", +[](const RelativePositionTask& task) { return task.target; }, &RelativePositionTask::target)
+      .def_readwrite("target", &RelativePositionTask::target)
       .add_property("mask", &RelativePositionTask::mask, &RelativePositionTask::mask);
 
   class__<CoMTask, bases<Task>>("CoMTask", init<Eigen::Vector3d>())
@@ -147,17 +148,14 @@ void exposeKinematics()
 
   class__<OrientationTask, bases<Task>>("OrientationTask", init<RobotWrapper::FrameIndex, Eigen::Matrix3d>())
       .add_property("frame_index", &OrientationTask::frame_index)
-      .add_property(
-          "R_world_frame", +[](const OrientationTask& task) { return task.R_world_frame; },
-          &OrientationTask::R_world_frame)
+      .def_readwrite("R_world_frame", &OrientationTask::R_world_frame)
       .add_property("mask", &OrientationTask::mask, &OrientationTask::mask);
 
   class__<RelativeOrientationTask, bases<Task>>(
       "RelativeOrientationTask", init<RobotWrapper::FrameIndex, RobotWrapper::FrameIndex, Eigen::Matrix3d>())
       .add_property("frame_a", &RelativeOrientationTask::frame_a)
       .add_property("frame_b", &RelativeOrientationTask::frame_b)
-      .add_property(
-          "R_a_b", +[](const RelativeOrientationTask& task) { return task.R_a_b; }, &RelativeOrientationTask::R_a_b)
+      .def_readwrite("R_a_b", &RelativeOrientationTask::R_a_b)
       .add_property("mask", &RelativeOrientationTask::mask, &RelativeOrientationTask::mask);
 
   class__<FrameTask>("FrameTask", init<>())
@@ -187,12 +185,11 @@ void exposeKinematics()
       .add_property("frame_index", &AxisAlignTask::frame_index)
       .add_property(
           "axis_frame", +[](const AxisAlignTask& task) { return task.axis_frame; }, &AxisAlignTask::axis_frame)
-      .add_property(
-          "targetAxis_world", +[](const AxisAlignTask& task) { return task.targetAxis_world; },
-          &AxisAlignTask::targetAxis_world);
+      .def_readwrite("targetAxis_world", &AxisAlignTask::targetAxis_world);
 
   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);
@@ -206,8 +203,7 @@ void exposeKinematics()
       .add_property("joint", &WheelTask::joint)
       .add_property("radius", &WheelTask::radius)
       .add_property("omniwheel", &WheelTask::omniwheel)
-      .add_property(
-          "T_world_surface", +[](const WheelTask& task) { return task.T_world_surface; }, &WheelTask::T_world_surface);
+      .def_readwrite("T_world_surface", &WheelTask::T_world_surface);
 
   class__<DistanceTask, bases<Task>>("DistanceTask", init<RobotWrapper::FrameIndex, RobotWrapper::FrameIndex, double>())
       .add_property("frame_a", &DistanceTask::frame_a)
@@ -240,6 +236,11 @@ void exposeKinematics()
       .def_readwrite("omega", &CoMPolygonConstraint::omega)
       .def_readwrite("margin", &CoMPolygonConstraint::margin);
 
+  class__<JointSpaceHalfSpacesConstraint, bases<Constraint>>("JointSpaceHalfSpacesConstraint",
+                                                             init<Eigen::MatrixXd, Eigen::VectorXd>())
+      .def_readwrite("A", &JointSpaceHalfSpacesConstraint::A)
+      .def_readwrite("b", &JointSpaceHalfSpacesConstraint::b);
+
   class__<ConeConstraint, bases<Constraint>>(
       "ConeConstraint", init<model::RobotWrapper::FrameIndex, model::RobotWrapper::FrameIndex, double>())
       .def_readwrite("angle_max", &ConeConstraint::angle_max)