placo 0.6.1__tar.gz → 0.7.4__tar.gz

{placo-0.6.1 → 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
 
@@ -122,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")
@@ -134,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
@@ -146,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..."
 )
 
@@ -170,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.6.1 → 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.6.1 → placo-0.7.4}/bindings/expose-dynamics.cpp

@@ -2,11 +2,13 @@
 
 #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;
@@ -22,12 +24,9 @@ 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;
@@ -46,17 +45,14 @@ void exposeDynamics()
       .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)
-      .add_property(
-          "R_world_surface", +[](PointContact& contact) { return contact.R_world_surface; },
-          +[](PointContact& contact, Eigen::Matrix3d R) { contact.R_world_surface = R; });
+      .def_readwrite("R_world_surface", &PointContact::R_world_surface);
 
   class__<Contact6D, bases<Contact>>("Contact6D", init<FrameTask&, bool>())
       .def(
@@ -86,8 +82,7 @@ void exposeDynamics()
 
   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<>());
 
@@ -164,10 +159,8 @@ 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("error", &Task::error)
@@ -175,54 +168,35 @@ void exposeDynamics()
 
   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)
-      .add_property(
-          "ddtarget_world", +[](const PositionTask& task) { return task.dtarget_world; }, &PositionTask::ddtarget_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<>())

{placo-0.6.1 → 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.6.1 → 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<>())
@@ -117,10 +122,8 @@ void exposeKinematics()
           .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);
@@ -135,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>())
@@ -146,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<>())
@@ -186,9 +185,7 @@ 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)
@@ -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)

{placo-0.6.1 → placo-0.7.4}/bindings/expose-parameters.cpp

@@ -2,12 +2,13 @@
 
 #include "expose-utils.hpp"
 #include "module.h"
-#include "registry.h"
+#include "doxystub.h"
 #include "placo/model/robot_wrapper.h"
 #include "placo/humanoid/humanoid_robot.h"
 #include "placo/humanoid/humanoid_parameters.h"
 #include <Eigen/Dense>
 #include <boost/python.hpp>
+#include <eigenpy/eigen-to-python.hpp>
 
 using namespace boost::python;
 using namespace placo;
@@ -25,8 +26,6 @@ void exposeParameters()
                     &HumanoidParameters::double_support_ratio)
       .add_property("startend_double_support_ratio", &HumanoidParameters::startend_double_support_ratio,
                     &HumanoidParameters::startend_double_support_ratio)
-      .add_property("kick_support_ratio", &HumanoidParameters::kick_support_ratio,
-                    &HumanoidParameters::kick_support_ratio)
       .add_property("planned_timesteps", &HumanoidParameters::planned_timesteps, &HumanoidParameters::planned_timesteps)
       .add_property("replan_timesteps", &HumanoidParameters::replan_timesteps, &HumanoidParameters::replan_timesteps)
       .add_property("zmp_margin", &HumanoidParameters::zmp_margin, &HumanoidParameters::zmp_margin)
@@ -50,13 +49,13 @@ void exposeParameters()
       .add_property("walk_max_dtheta", &HumanoidParameters::walk_max_dtheta, &HumanoidParameters::walk_max_dtheta)
       .add_property("walk_dtheta_spacing", &HumanoidParameters::walk_dtheta_spacing,
                     &HumanoidParameters::walk_dtheta_spacing)
+      .add_property("op_space_polygon", &HumanoidParameters::op_space_polygon, &HumanoidParameters::op_space_polygon)
+      .add_property("dcm_offset_polygon", &HumanoidParameters::dcm_offset_polygon, &HumanoidParameters::dcm_offset_polygon)
       .def("dt", &HumanoidParameters::dt)
-      .def("double_support_duration", &HumanoidParameters::double_support_duration)
-      .def("startend_double_support_duration", &HumanoidParameters::startend_double_support_duration)
-      .def("kick_support_duration", &HumanoidParameters::kick_support_duration)
       .def("double_support_timesteps", &HumanoidParameters::double_support_timesteps)
       .def("startend_double_support_timesteps", &HumanoidParameters::startend_double_support_timesteps)
-      .def("kick_support_timesteps", &HumanoidParameters::kick_support_timesteps)
+      .def("double_support_duration", &HumanoidParameters::double_support_duration)
+      .def("startend_double_support_duration", &HumanoidParameters::startend_double_support_duration)
       .def("has_double_support", &HumanoidParameters::has_double_support)
       .def("ellipsoid_clip", &HumanoidParameters::ellipsoid_clip);
 }

{placo-0.6.1 → placo-0.7.4}/bindings/expose-problem.cpp

@@ -5,17 +5,19 @@
 
 #include "expose-utils.hpp"
 #include "module.h"
-#include "registry.h"
+#include "doxystub.h"
 #include "placo/problem/problem.h"
 #include "placo/problem/variable.h"
 #include "placo/problem/expression.h"
 #include "placo/problem/constraint.h"
 #include "placo/problem/polygon_constraint.h"
 #include "placo/problem/integrator.h"
+#include "placo/problem/problem_polynom.h"
 #include "placo/problem/sparsity.h"
 #include "placo/problem/qp_error.h"
 #include <Eigen/Dense>
 #include <boost/python.hpp>
+#include <eigenpy/eigen-to-python.hpp>
 
 using namespace boost::python;
 using namespace placo;
@@ -23,6 +25,8 @@ using namespace placo::problem;
 
 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(expr_overloads, expr, 0, 2);
 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(integrator_expr_overloads, expr, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(integrator_expr_t_overloads, expr_t, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(problem_polynom_expr_overloads, expr, 1, 2);
 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(configure_overloads, configure, 1, 2);
 
 void exposeProblem()
@@ -84,19 +88,19 @@ void exposeProblem()
       .def("upper_shift_matrix", &Integrator::upper_shift_matrix)
       .staticmethod("upper_shift_matrix")
       .add_property("t_start", &Integrator::t_start, &Integrator::t_start)
-      .add_property(
-          "M", +[](const Integrator& i) { return i.M; })
-      .add_property(
-          "A", +[](const Integrator& i) { return i.A; })
-      .add_property(
-          "B", +[](const Integrator& i) { return i.B; })
-      .add_property(
-          "final_transition_matrix", +[](const Integrator& i) { return i.final_transition_matrix; })
+      .def_readonly("M", &Integrator::M)
+      .def_readonly("A", &Integrator::A)
+      .def_readonly("B", &Integrator::B)
+      .def_readonly("final_transition_matrix", &Integrator::final_transition_matrix)
       .def("expr", &Integrator::expr, integrator_expr_overloads())
-      .def("expr_t", &Integrator::expr_t)
+      .def("expr_t", &Integrator::expr_t, integrator_expr_t_overloads())
       .def("value", &Integrator::value)
       .def("get_trajectory", &Integrator::get_trajectory);
 
+  class__<ProblemPolynom>("ProblemPolynom", init<Variable&>())
+      .def("expr", &ProblemPolynom::expr, problem_polynom_expr_overloads())
+      .def("get_polynom", &ProblemPolynom::get_polynom);
+
   class__<Integrator::Trajectory>("IntegratorTrajectory")
       .def("value", &Integrator::Trajectory::value)
       .def("duration", &Integrator::Trajectory::duration);
@@ -129,10 +133,8 @@ void exposeProblem()
       .def("expr", &Variable::expr, expr_overloads());
 
   class__<Expression>("Expression")
-      .add_property(
-          "A", +[](Expression& e) { return e.A; })
-      .add_property(
-          "b", +[](Expression& e) { return e.b; })
+      .def_readwrite("A", &Expression::A)
+      .def_readwrite("b", &Expression::b)
       .def("__len__", &Expression::rows)
       .def("is_scalar", &Expression::is_scalar)
       .def("is_constant", &Expression::is_constant)