placo 0.6.2__tar.gz → 0.6.4__tar.gz

{placo-0.6.2 → placo-0.6.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
 

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

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

{placo-0.6.2 → placo-0.6.4}/bindings/expose-footsteps.cpp

@@ -23,16 +23,18 @@ 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)
-      .def_readwrite("frame", &FootstepsPlanner::Footstep::frame)
+      .def_readwrite("raw_frame", &FootstepsPlanner::Footstep::raw_frame)
+      .add_property("dx", &FootstepsPlanner::Footstep::dx, &FootstepsPlanner::Footstep::dx)
+      .add_property("dy", &FootstepsPlanner::Footstep::dy, &FootstepsPlanner::Footstep::dy)
       .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)
       .def("overlap", &FootstepsPlanner::Footstep::overlap)
       .def("polygon_contains", &FootstepsPlanner::Footstep::polygon_contains)
-      .staticmethod("polygon_contains")
-      .add_property("kick", &FootstepsPlanner::Footstep::kick, &FootstepsPlanner::Footstep::kick);
+      .def("frame", &FootstepsPlanner::Footstep::frame)
+      .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)
@@ -42,14 +44,16 @@ void exposeFootsteps()
           "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("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.2 → placo-0.6.4}/bindings/expose-kinematics.cpp

@@ -93,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<>())
@@ -232,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.2 → placo-0.6.4}/bindings/expose-parameters.cpp

@@ -18,16 +18,10 @@ using namespace placo::humanoid;
 void exposeParameters()
 {
   class__<HumanoidParameters>("HumanoidParameters")
-      .add_property("single_support_duration", &HumanoidParameters::single_support_duration,
-                    &HumanoidParameters::single_support_duration)
-      .add_property("single_support_timesteps", &HumanoidParameters::single_support_timesteps,
-                    &HumanoidParameters::single_support_timesteps)
-      .add_property("double_support_ratio", &HumanoidParameters::double_support_ratio,
-                    &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("single_support_duration", &HumanoidParameters::single_support_duration, &HumanoidParameters::single_support_duration)
+      .add_property("single_support_timesteps", &HumanoidParameters::single_support_timesteps, &HumanoidParameters::single_support_timesteps)
+      .add_property("double_support_ratio", &HumanoidParameters::double_support_ratio, &HumanoidParameters::double_support_ratio)
+      .add_property("startend_double_support_ratio", &HumanoidParameters::startend_double_support_ratio, &HumanoidParameters::startend_double_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)
@@ -52,12 +46,10 @@ void exposeParameters()
       .add_property("walk_dtheta_spacing", &HumanoidParameters::walk_dtheta_spacing,
                     &HumanoidParameters::walk_dtheta_spacing)
       .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.2 → placo-0.6.4}/bindings/expose-problem.cpp

@@ -12,6 +12,7 @@
 #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>
@@ -24,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()
@@ -90,10 +93,14 @@ void exposeProblem()
       .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);

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

@@ -9,6 +9,9 @@
 #include "placo/tools/cubic_spline_3d.h"
 #include "placo/tools/axises_mask.h"
 #include "placo/tools/prioritized.h"
+#include "placo/tools/directions.h"
+#include "placo/tools/polynom.h"
+#include "placo/tools/segment.h"
 #include "expose-utils.hpp"
 #ifdef HAVE_RHOBAN_UTILS
 #include "rhoban_utils/history/history.h"
@@ -24,6 +27,8 @@ BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(loadReplays_overloads, loadReplays, 1, 2)
 
 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_axises_overloads, set_axises, 1, 2);
 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(configure_overloads, configure, 2, 3);
+BOOST_PYTHON_FUNCTION_OVERLOADS(directions_3d_overloads, directions_3d, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(value_overloads, value, 1, 2);
 
 void exposeTools()
 {
@@ -33,6 +38,8 @@ void exposeTools()
   def("frame_yaw", &frame_yaw);
   def("flatten_on_floor", &flatten_on_floor);
   def("optimal_transformation", &optimal_transformation);
+  def("directions_2d", &directions_2d);
+  def("directions_3d", &directions_3d, directions_3d_overloads());
 
   exposeStdVector<int>("vector_int");
   exposeStdVector<double>("vector_double");
@@ -73,6 +80,23 @@ void exposeTools()
       .def("clear", &CubicSpline3D::clear)
       .def("duration", &CubicSpline3D::duration);
 
+  class__<Polynom>("Polynom", init<Eigen::VectorXd>())
+      .def("value", &Polynom::value, value_overloads())
+      .def("derivative_coefficient", &Polynom::derivative_coefficient)
+      .staticmethod("derivative_coefficient")
+      .def_readwrite("coefficients", &Polynom::coefficients);
+
+  class__<Segment>("Segment", init<Eigen::Vector2d, Eigen::Vector2d>())
+      .add_property("start", &Segment::start, &Segment::start)
+      .add_property("end", &Segment::end, &Segment::start)
+      .def("is_parallel", +[](Segment& s1, const Segment& s2) { return s1.is_parallel(s2); })
+      .def("is_point_aligned", +[](Segment& s, const Eigen::Vector2d& point) { return s.is_point_aligned(point); })
+      .def("is_collinear", +[](Segment& s1, const Segment& s2) { return s1.is_collinear(s2); })
+      .def("is_point_in_segment", +[](Segment& s, const Eigen::Vector2d& point) { return s.is_point_in_segment(point); })
+      .def("intersects", &Segment::intersects)
+      .def("line_pass_through", &Segment::line_pass_through)
+      .def("lines_intersection", &Segment::lines_intersection);
+
 #ifdef HAVE_RHOBAN_UTILS
   using namespace rhoban_utils;
 

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

@@ -22,13 +22,22 @@ using namespace placo::humanoid;
 
 void exposeWalkPatternGenerator()
 {
-  class__<WalkPatternGenerator::Trajectory>("WalkTrajectory")
+  class__<WalkPatternGenerator::TrajectoryPart>("WPGTrajectoryPart", init<FootstepsPlanner::Support, double>())
+      .add_property("t_start", &WalkPatternGenerator::TrajectoryPart::t_start)
+      .add_property("t_end", &WalkPatternGenerator::TrajectoryPart::t_end, &WalkPatternGenerator::TrajectoryPart::t_end)
+      .add_property("support", &WalkPatternGenerator::TrajectoryPart::support);
+
+  class__<WalkPatternGenerator::Trajectory>("WPGTrajectory", init<double, double, double>())
       .add_property("t_start", &WalkPatternGenerator::Trajectory::t_start)
       .add_property("t_end", &WalkPatternGenerator::Trajectory::t_end)
-      .add_property("jerk_planner_timesteps", &WalkPatternGenerator::Trajectory::jerk_planner_timesteps)
+      .add_property("com_target_z", &WalkPatternGenerator::Trajectory::com_target_z)
+      .add_property("trunk_pitch", &WalkPatternGenerator::Trajectory::trunk_pitch)
+      .add_property("trunk_roll", &WalkPatternGenerator::Trajectory::trunk_roll)
+      .add_property("kept_ts", &WalkPatternGenerator::Trajectory::kept_ts)
       .def("get_T_world_left", &WalkPatternGenerator::Trajectory::get_T_world_left)
-      .def("get_supports", &WalkPatternGenerator::Trajectory::get_supports)
       .def("get_T_world_right", &WalkPatternGenerator::Trajectory::get_T_world_right)
+      .def("get_v_world_right", &WalkPatternGenerator::Trajectory::get_v_world_right)
+      .def("get_v_world_foot", &WalkPatternGenerator::Trajectory::get_v_world_foot)
       .def("get_p_world_CoM", &WalkPatternGenerator::Trajectory::get_p_world_CoM)
       .def("get_v_world_CoM", &WalkPatternGenerator::Trajectory::get_v_world_CoM)
       .def("get_a_world_CoM", &WalkPatternGenerator::Trajectory::get_a_world_CoM)
@@ -38,11 +47,13 @@ void exposeWalkPatternGenerator()
       .def("get_R_world_trunk", &WalkPatternGenerator::Trajectory::get_R_world_trunk)
       .def("support_side", &WalkPatternGenerator::Trajectory::support_side)
       .def("support_is_both", &WalkPatternGenerator::Trajectory::support_is_both)
+      .def("get_supports", &WalkPatternGenerator::Trajectory::get_supports)
       .def("get_support", &WalkPatternGenerator::Trajectory::get_support)
       .def("get_next_support", &WalkPatternGenerator::Trajectory::get_next_support)
       .def("get_prev_support", &WalkPatternGenerator::Trajectory::get_prev_support)
       .def("get_part_t_start", &WalkPatternGenerator::Trajectory::get_part_t_start)
-      .def("apply_transform", &WalkPatternGenerator::Trajectory::apply_transform);
+      .def("apply_transform", &WalkPatternGenerator::Trajectory::apply_transform)
+      .def("print_parts_timings", &WalkPatternGenerator::Trajectory::print_parts_timings);
 
   class__<WalkPatternGenerator>("WalkPatternGenerator", init<HumanoidRobot&, HumanoidParameters&>())
       .def("plan", &WalkPatternGenerator::plan)
@@ -125,16 +136,24 @@ void exposeWalkPatternGenerator()
       .def("dzmp", &LIPM::Trajectory::dzmp)
       .def("dcm", &LIPM::Trajectory::dcm);
 
-  class__<LIPM>("LIPM", init<problem::Problem&, int, double, Eigen::Vector2d, Eigen::Vector2d, Eigen::Vector2d>())
+  class__<LIPM>("LIPM", init<problem::Problem&, double, int, double, Eigen::Vector2d, Eigen::Vector2d, Eigen::Vector2d>())
+      .def("compute_omega", &LIPM::compute_omega)
+      .def("get_trajectory", &LIPM::get_trajectory)
       .def("pos", &LIPM::pos)
       .def("vel", &LIPM::vel)
       .def("acc", &LIPM::acc)
       .def("jerk", &LIPM::jerk)
+      .def("dcm", &LIPM::dcm)
       .def("zmp", &LIPM::zmp)
       .def("dzmp", &LIPM::dzmp)
-      .def("dcm", &LIPM::dcm)
-      .def("compute_omega", &LIPM::compute_omega)
+      .def("build_LIPM_from_previous", &LIPM::build_LIPM_from_previous)
       .def("get_trajectory", &LIPM::get_trajectory)
-      .add_property("x", &LIPM::x)
-      .add_property("y", &LIPM::y);
+      .add_property("dt", &LIPM::dt, &LIPM::dt)
+      .add_property("timesteps", &LIPM::timesteps, &LIPM::timesteps)
+      .add_property("t_start", &LIPM::t_start, &LIPM::t_start)
+      .add_property("t_end", &LIPM::t_end, &LIPM::t_end)
+      .add_property("x_var", &LIPM::x_var, &LIPM::x_var)
+      .add_property("y_var", &LIPM::y_var, &LIPM::y_var)
+      .add_property("x", &LIPM::x, &LIPM::x)
+      .add_property("y", &LIPM::y, &LIPM::y);
 }

{placo-0.6.2 → placo-0.6.4}/doxygen_parse.py

@@ -1,5 +1,6 @@
 import glob
 import re
+from typing import Union
 import xml.etree.ElementTree as ET
 
 # Mapping member definitions (id) to all informations
@@ -148,7 +149,7 @@ def parse_xml(xml_file: str):
             parse_compound(compounddef_node)
 
 
-def resolve_doxygen_id(id: list|str):
+def resolve_doxygen_id(id: Union[list,str]):
     if type(id) == list:
         tpl = resolve_doxygen_id(id[0])
         typ = resolve_doxygen_id(id[1])