placo 0.6.0__tar.gz → 0.6.2__tar.gz

{placo-0.6.0 → placo-0.6.2}/PKG-INFO

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

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

@@ -7,6 +7,7 @@
 #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 +23,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 +44,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 +81,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<>());
 
@@ -101,6 +95,9 @@ void exposeDynamics()
       .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<>())
@@ -161,10 +158,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)
@@ -172,54 +167,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.0 → placo-0.6.2}/bindings/expose-footsteps.cpp

@@ -8,6 +8,7 @@
 #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;
@@ -22,9 +23,7 @@ void exposeFootsteps()
   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)
+      .def_readwrite("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)
       .def("support_polygon", &FootstepsPlanner::Footstep::support_polygon)

{placo-0.6.0 → placo-0.6.2}/bindings/expose-kinematics.cpp

@@ -7,6 +7,7 @@
 #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;
@@ -117,10 +118,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 +134,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 +144,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 +181,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 +199,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)

{placo-0.6.0 → placo-0.6.2}/bindings/expose-parameters.cpp

@@ -8,6 +8,7 @@
 #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;

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

@@ -16,6 +16,7 @@
 #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;
@@ -84,14 +85,10 @@ 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("value", &Integrator::value)
@@ -129,10 +126,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)

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

@@ -8,6 +8,7 @@
 #include "placo/kinematics/kinematics_solver.h"
 #include <Eigen/Dense>
 #include <boost/python.hpp>
+#include <eigenpy/eigen-to-python.hpp>
 
 using namespace boost::python;
 using namespace placo;
@@ -138,16 +139,9 @@ void exposeRobotWrapper()
       .value("ignore_collisions", RobotWrapper::Flags::IGNORE_COLLISIONS);
 
   class__<RobotWrapper::State>("RobotWrapper_State")
-      .add_property(
-          "q", +[](const RobotWrapper::State& state) { return state.q; },
-          +[](RobotWrapper::State& state, const Eigen::VectorXd& q) { state.q = q; })
-      .add_property(
-          "qd", +[](const RobotWrapper::State& state) { return state.qd; },
-          +[](RobotWrapper::State& state, const Eigen::VectorXd& qd) { state.qd = qd; })
-      .add_property(
-          "qdd", +[](const RobotWrapper::State& state) { return state.qdd; },
-          +[](RobotWrapper::State& state, const Eigen::VectorXd& qdd) { state.qdd = qdd; });
-  ;
+      .def_readwrite("q", &RobotWrapper::State::q)
+      .def_readwrite("qd", &RobotWrapper::State::qd)
+      .def_readwrite("qdd", &RobotWrapper::State::qdd);
 
   class__<RobotWrapper::Collision>("Collision")
       .add_property("objA", &RobotWrapper::Collision::objA)
@@ -164,10 +158,8 @@ void exposeRobotWrapper()
       .add_property("objB", &RobotWrapper::Distance::objB)
       .add_property("parentA", &RobotWrapper::Distance::parentA)
       .add_property("parentB", &RobotWrapper::Distance::parentB)
-      .add_property(
-          "pointA", +[](RobotWrapper::Distance& distance) { return distance.pointA; })
-      .add_property(
-          "pointB", +[](RobotWrapper::Distance& distance) { return distance.pointB; })
+      .def_readwrite("pointA", &RobotWrapper::Distance::pointA)
+      .def_readwrite("pointB", &RobotWrapper::Distance::pointB)
       .add_property("min_distance", &RobotWrapper::Distance::min_distance);
 
   class_<RobotWrapper> robotWrapper =
@@ -210,9 +202,7 @@ void exposeRobotWrapper()
       .def(
           "get_support_side", +[](const HumanoidRobot& robot) { return robot.support_side; })
       .add_property("support_is_both", &HumanoidRobot::support_is_both, &HumanoidRobot::support_is_both)
-      .add_property(
-          "T_world_support", +[](HumanoidRobot& robot) { return robot.T_world_support; },
-          +[](HumanoidRobot& robot, Eigen::Affine3d T_world_support_) { robot.T_world_support = T_world_support_; });
+      .def_readwrite("T_world_support", &HumanoidRobot::T_world_support);
 
   exposeStdVector<RobotWrapper::Collision>("vector_Collision");
   exposeStdVector<RobotWrapper::Distance>("vector_Distance");

{placo-0.6.0 → placo-0.6.2}/bindings/expose-tools.cpp

@@ -13,6 +13,7 @@
 #ifdef HAVE_RHOBAN_UTILS
 #include "rhoban_utils/history/history.h"
 #endif
+#include <eigenpy/eigen-to-python.hpp>
 
 using namespace boost::python;
 using namespace placo::tools;
@@ -45,12 +46,8 @@ void exposeTools()
   class__<AxisesMask>("AxisesMask", init<>())
       .def<void (AxisesMask::*)(std::string, std::string)>("set_axises", &AxisesMask::set_axises,
                                                            set_axises_overloads())
-      .add_property(
-          "R_local_world", +[](AxisesMask& mask) { return mask.R_local_world; },
-          +[](AxisesMask& mask, Eigen::Matrix3d R) { mask.R_local_world = R; })
-      .add_property(
-          "R_custom_world", +[](AxisesMask& mask) { return mask.R_custom_world; },
-          +[](AxisesMask& mask, Eigen::Matrix3d R) { mask.R_custom_world = R; })
+      .def_readwrite("R_local_world", &AxisesMask::R_local_world)
+      .def_readwrite("R_custom_world", &AxisesMask::R_custom_world)
       .def("apply", &AxisesMask::apply);
 
   class__<Prioritized, boost::noncopyable>("Prioritized", no_init)

{placo-0.6.0 → placo-0.6.2}/bindings/expose-walk-pattern-generator.cpp

@@ -13,6 +13,7 @@
 #include "placo/humanoid/lipm.h"
 #include <Eigen/Dense>
 #include <boost/python.hpp>
+#include <eigenpy/eigen-to-python.hpp>
 
 using namespace placo;
 using namespace boost::python;

{placo-0.6.0 → placo-0.6.2}/placo.pyi

@@ -2063,6 +2063,10 @@ class DynamicsSolver:
     """Enables the velocity vs torque inequalities."""
     ...
 
+  extra_force: numpy.ndarray # Eigen::VectorXd
+  """Extra force to be added to the system (similar to non-linear terms) 
+        """
+
   def get_contact(
     arg1: DynamicsSolver,
     arg2: int,

{placo-0.6.0 → placo-0.6.2}/pyproject.toml

@@ -23,7 +23,7 @@ description = "PlaCo: Rhoban Planning and Control"
 license = "MIT"
 name = "placo"
 requires-python = ">= 3.8"
-version = "0.6.0"
+version = "0.6.2"
 
 [project.urls]
 changelog = "https://github.com/rhoban/placo/blob/main/CHANGELOG.md"