placo 0.6.3__tar.gz → 0.6.5__tar.gz

{placo-0.6.3 → placo-0.6.5}/CMakeLists.txt

@@ -52,6 +52,8 @@ add_library(libplaco SHARED
     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
@@ -59,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
@@ -84,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.5/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: placo
+Version: 0.6.5
+Summary: PlaCo: Rhoban Planning and Control
+Requires-Python: >= 3.8
+License-Expression: MIT
+Author-email: Rhoban team <team@rhoban.com>
+Project-URL: Changelog, https://github.com/rhoban/placo/blob/main/CHANGELOG.md
+Home-page: https://placo.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/rhoban/placo.git
+Requires-Dist: cmeel
+Requires-Dist: eiquadprog >= 1.2.6, < 2
+Requires-Dist: pin >= 2.6.18, < 3
+Requires-Dist: rhoban-cmeel-jsoncpp
+Requires-Dist: meshcat
+Requires-Dist: numpy<2
+Requires-Dist: ischedule
+Provides-Extra: build
+Requires-Dist: pin[build] >= 2.6.18, < 3 ; extra == "build"
+Requires-Dist: cmeel-urdfdom[build] ; extra == "build"
+Description-Content-Type: text/markdown
+
+<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.6.5/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.6.3 → placo-0.6.5}/bindings/expose-footsteps.cpp

@@ -21,35 +21,36 @@ 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)
-      .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)
+      .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("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.3 → placo-0.6.5}/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.3 → placo-0.6.5}/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.3 → placo-0.6.5}/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.3 → placo-0.6.5}/bindings/expose-tools.cpp

@@ -10,6 +10,8 @@
 #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"
@@ -26,6 +28,7 @@ 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()
 {
@@ -77,6 +80,24 @@ 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("half_line_pass_through", &Segment::half_line_pass_through)
+      .def("lines_intersection", &Segment::lines_intersection);
+
 #ifdef HAVE_RHOBAN_UTILS
   using namespace rhoban_utils;
 

{placo-0.6.3 → placo-0.6.5}/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,17 +47,20 @@ 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)
       .def("replan", &WalkPatternGenerator::replan)
       .def("can_replan_supports", &WalkPatternGenerator::can_replan_supports)
-      .def("replan_supports", &WalkPatternGenerator::replan_supports);
+      .def("replan_supports", &WalkPatternGenerator::replan_supports)
+      .def("compute_next_support", &WalkPatternGenerator::compute_next_support);
 
   class__<SwingFoot>("SwingFoot", init<>())
       .def("make_trajectory", &SwingFoot::make_trajectory)
@@ -125,16 +137,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);
 }