placo 0.6.3__0-cp310-cp310-manylinux_2_35_x86_64.whl → 0.6.5__0-cp310-cp310-manylinux_2_35_x86_64.whl

cmeel.prefix/lib/python3.10/site-packages/placo.pyi

@@ -45,6 +45,7 @@ HumanoidRobot = typing.NewType("HumanoidRobot", None)
 HumanoidRobot_Side = typing.NewType("HumanoidRobot_Side", None)
 Integrator = typing.NewType("Integrator", None)
 IntegratorTrajectory = typing.NewType("IntegratorTrajectory", None)
+JointSpaceHalfSpacesConstraint = typing.NewType("JointSpaceHalfSpacesConstraint", None)
 JointsTask = typing.NewType("JointsTask", None)
 KinematicsConstraint = typing.NewType("KinematicsConstraint", None)
 KinematicsSolver = typing.NewType("KinematicsSolver", None)
@@ -56,10 +57,12 @@ ManipulabilityTask = typing.NewType("ManipulabilityTask", None)
 OrientationTask = typing.NewType("OrientationTask", None)
 PointContact = typing.NewType("PointContact", None)
 PolygonConstraint = typing.NewType("PolygonConstraint", None)
+Polynom = typing.NewType("Polynom", None)
 PositionTask = typing.NewType("PositionTask", None)
 Prioritized = typing.NewType("Prioritized", None)
 Problem = typing.NewType("Problem", None)
 ProblemConstraint = typing.NewType("ProblemConstraint", None)
+ProblemPolynom = typing.NewType("ProblemPolynom", None)
 PuppetContact = typing.NewType("PuppetContact", None)
 QPError = typing.NewType("QPError", None)
 RegularizationTask = typing.NewType("RegularizationTask", None)
@@ -68,6 +71,7 @@ RelativeOrientationTask = typing.NewType("RelativeOrientationTask", None)
 RelativePositionTask = typing.NewType("RelativePositionTask", None)
 RobotWrapper = typing.NewType("RobotWrapper", None)
 RobotWrapper_State = typing.NewType("RobotWrapper_State", None)
+Segment = typing.NewType("Segment", None)
 Sparsity = typing.NewType("Sparsity", None)
 SparsityInterval = typing.NewType("SparsityInterval", None)
 Support = typing.NewType("Support", None)
@@ -81,9 +85,10 @@ SwingFootTrajectory = typing.NewType("SwingFootTrajectory", None)
 Task = typing.NewType("Task", None)
 TaskContact = typing.NewType("TaskContact", None)
 Variable = typing.NewType("Variable", None)
+WPGTrajectory = typing.NewType("WPGTrajectory", None)
+WPGTrajectoryPart = typing.NewType("WPGTrajectoryPart", None)
 WalkPatternGenerator = typing.NewType("WalkPatternGenerator", None)
 WalkTasks = typing.NewType("WalkTasks", None)
-WalkTrajectory = typing.NewType("WalkTrajectory", None)
 WheelTask = typing.NewType("WheelTask", None)
 map_indexing_suite_map_string_double_entry = typing.NewType("map_indexing_suite_map_string_double_entry", None)
 map_string_double = typing.NewType("map_string_double", None)
@@ -2529,7 +2534,7 @@ class ExternalWrenchContact:
   def __init__(
     self: ExternalWrenchContact,
     frame_index: any, # pinocchio::FrameIndex
-    reference: any, # pinocchio::ReferenceFrame
+    reference: any = None, # pinocchio::ReferenceFrame (default: pinocchio::LOCAL_WORLD_ALIGNED)
 
   ) -> any:
     """see DynamicsSolver::add_external_wrench_contact"""
@@ -2636,8 +2641,6 @@ class Footstep:
 
   frame: numpy.ndarray # Eigen::Affine3d
 
-  kick: bool # bool
-
   def overlap(
     self: Footstep,
     other: Footstep, # placo::humanoid::FootstepsPlanner::Footstep
@@ -2697,17 +2700,10 @@ class FootstepsPlanner:
     :param parameters: Parameters of the walk"""
     ...
 
-  @staticmethod
-  def add_first_support(
-    supports: list[Support], # std::vector<placo::humanoid::FootstepsPlanner::Support>
-    support: Support, # placo::humanoid::FootstepsPlanner::Support
-
-  ) -> None:
-    ...
-
   @staticmethod
   def make_supports(
     footsteps: list[Footstep], # std::vector<placo::humanoid::FootstepsPlanner::Footstep>
+    t_start: float, # double
     start: bool = True, # bool
     middle: bool = False, # bool
     end: bool = True, # bool
@@ -2745,14 +2741,6 @@ class FootstepsPlannerNaive:
   ) -> any:
     ...
 
-  @staticmethod
-  def add_first_support(
-    supports: list[Support], # std::vector<placo::humanoid::FootstepsPlanner::Support>
-    support: Support, # placo::humanoid::FootstepsPlanner::Support
-
-  ) -> None:
-    ...
-
   def configure(
     self: FootstepsPlannerNaive,
     T_world_left_target: numpy.ndarray, # Eigen::Affine3d
@@ -2770,6 +2758,7 @@ class FootstepsPlannerNaive:
   @staticmethod
   def make_supports(
     footsteps: list[Footstep], # std::vector<placo::humanoid::FootstepsPlanner::Footstep>
+    t_start: float, # double
     start: bool = True, # bool
     middle: bool = False, # bool
     end: bool = True, # bool
@@ -2824,14 +2813,6 @@ class FootstepsPlannerRepetitive:
   ) -> any:
     ...
 
-  @staticmethod
-  def add_first_support(
-    supports: list[Support], # std::vector<placo::humanoid::FootstepsPlanner::Support>
-    support: Support, # placo::humanoid::FootstepsPlanner::Support
-
-  ) -> None:
-    ...
-
   def configure(
     self: FootstepsPlannerRepetitive,
     x: float, # double
@@ -2855,6 +2836,7 @@ class FootstepsPlannerRepetitive:
   @staticmethod
   def make_supports(
     footsteps: list[Footstep], # std::vector<placo::humanoid::FootstepsPlanner::Footstep>
+    t_start: float, # double
     start: bool = True, # bool
     middle: bool = False, # bool
     end: bool = True, # bool
@@ -3064,7 +3046,7 @@ class HumanoidParameters:
     self: HumanoidParameters,
 
   ) -> float:
-    """Duratuon [s]of a double support."""
+    """Default duration [s]of a double support."""
     ...
 
   double_support_ratio: float # double
@@ -3075,14 +3057,14 @@ class HumanoidParameters:
     self: HumanoidParameters,
 
   ) -> int:
-    """Duration [timesteps] of a double support."""
+    """Default number of timesteps for one double support."""
     ...
 
   def dt(
     self: HumanoidParameters,
 
   ) -> float:
-    """dt for planning [s]"""
+    """Timestep duration for planning [s]."""
     ...
 
   def ellipsoid_clip(
@@ -3120,34 +3102,16 @@ class HumanoidParameters:
     """Checks if the walk resulting from those parameters will have double supports."""
     ...
 
-  def kick_support_duration(
-    self: HumanoidParameters,
-
-  ) -> float:
-    """Duration [s] of a kick support."""
-    ...
-
-  kick_support_ratio: float # double
-  """Duration ratio between single support and kick support. 
-        """
-
-  def kick_support_timesteps(
-    self: HumanoidParameters,
-
-  ) -> int:
-    """Duration [timesteps]of a kick support."""
-    ...
-
   planned_timesteps: int # int
   """Planning horizon for the CoM trajectory. 
         """
 
   replan_timesteps: int # int
-  """Number of timesteps between each replan. Support phases have to last longer than [replan_frequency * dt] or their duration has to be equal to 0. 
+  """Number of timesteps between each replan for the CoM trajectory. 
         """
 
   single_support_duration: float # double
-  """SSP duration [s]. 
+  """Single support duration [s]. 
         """
 
   single_support_timesteps: int # int
@@ -3158,18 +3122,18 @@ class HumanoidParameters:
     self: HumanoidParameters,
 
   ) -> float:
-    """Duration [s] of a start/end double support."""
+    """Default duration [s] of a start/end double support."""
     ...
 
   startend_double_support_ratio: float # double
-  """Duration ratio between single support and double support. 
+  """Duration ratio between single support and start/end double support. 
         """
 
   def startend_double_support_timesteps(
     self: HumanoidParameters,
 
   ) -> int:
-    """Duration [timesteps]of a start/end double support."""
+    """Default number of timesteps for one start/end double support."""
     ...
 
   walk_com_height: float # double
@@ -4001,7 +3965,7 @@ class Integrator:
     """Builds an expression for the given step and differentiation. 
         
 
-    :param step: the step 
+    :param step: the step, (if -1 the last step will be used) 
 
     :param diff: differentiation (if -1, the expression will be a vector of size order with all orders) 
 
@@ -4106,6 +4070,50 @@ class IntegratorTrajectory:
     ...
 
 
+class JointSpaceHalfSpacesConstraint:
+  A: numpy.ndarray # Eigen::MatrixXd
+  """Matrix A in Aq <= b. 
+        """
+
+  def __init__(
+    self: JointSpaceHalfSpacesConstraint,
+    A: numpy.ndarray, # const Eigen::MatrixXd
+    b: numpy.ndarray, # Eigen::VectorXd
+
+  ) -> any:
+    """Ensures that, in joint-space we have Aq <= b Note that the floating base terms will be ignored in A. However, A should still be of dimension n_constraints x n_q."""
+    ...
+
+  b: numpy.ndarray # Eigen::VectorXd
+  """Vector b in Aq <= b. 
+        """
+
+  def configure(
+    self: JointSpaceHalfSpacesConstraint,
+    name: str, # std::string
+    priority: any, # placo::kinematics::ConeConstraint::Priority
+    weight: float = 1.0, # double
+
+  ) -> None:
+    """Configures the object. 
+        
+
+    :param name: task name 
+
+    :param priority: task priority (hard, soft or scaled) 
+
+    :param weight: task weight"""
+    ...
+
+  name: str # std::string
+  """Object name. 
+        """
+
+  priority: any # placo::kinematics::ConeConstraint::Priority
+  """Object priority. 
+        """
+
+
 class JointsTask:
   A: numpy.ndarray # Eigen::MatrixXd
   """Matrix A in the task Ax = b, where x are the joint delta positions. 
@@ -4374,7 +4382,7 @@ class KinematicsSolver:
   def add_frame_task(
     self: KinematicsSolver,
     frame: str, # std::string
-    T_world_frame: numpy.ndarray, # Eigen::Affine3d
+    T_world_frame: numpy.ndarray = None, # Eigen::Affine3d (default: Eigen::Affine3d::Identity())
 
   ) -> FrameTask:
     """Adds a frame task, this is equivalent to a position + orientation task, resulting in decoupled tasks for a given frame. 
@@ -4399,6 +4407,22 @@ class KinematicsSolver:
     :return: gear task"""
     ...
 
+  def add_joint_space_half_spaces_constraint(
+    self: KinematicsSolver,
+    A: numpy.ndarray, # Eigen::MatrixXd
+    b: numpy.ndarray, # Eigen::VectorXd
+
+  ) -> JointSpaceHalfSpacesConstraint:
+    """Adds a joint-space half-spaces constraint, such that Aq <= b. 
+        
+
+    :param A: matrix A in Aq <= b 
+
+    :param b: vector b in Aq <= b 
+
+    :return: the constraint"""
+    ...
+
   def add_joints_task(
     self: KinematicsSolver,
 
@@ -4760,11 +4784,12 @@ class LIPM:
   def __init__(
     self: LIPM,
     problem: Problem, # placo::problem::Problem
-    timesteps: int, # int
     dt: float, # double
+    timesteps: int, # int
+    t_start: float, # double
     initial_pos: numpy.ndarray, # Eigen::Vector2d
-    initial_vel: numpy.ndarray, # Eigen::Vector2d
-    initial_acc: numpy.ndarray, # Eigen::Vector2d
+    initial_vel: numpy.ndarray = None, # Eigen::Vector2d (default: Eigen::Vector2d::Zero())
+    initial_acc: numpy.ndarray = None, # Eigen::Vector2d (default: Eigen::Vector2d::Zero())
 
   ) -> any:
     ...
@@ -4776,6 +4801,17 @@ class LIPM:
   ) -> Expression:
     ...
 
+  @staticmethod
+  def build_LIPM_from_previous(
+    problem: Problem, # placo::problem::Problem
+    dt: float, # double
+    timesteps: int, # int
+    t_start: float, # double
+    previous: LIPM, # placo::humanoid::LIPM
+
+  ) -> LIPM:
+    ...
+
   @staticmethod
   def compute_omega(
     com_height: float, # double
@@ -4792,6 +4828,8 @@ class LIPM:
   ) -> Expression:
     ...
 
+  dt: float # double
+
   def dzmp(
     self: LIPM,
     timestep: int, # int
@@ -4804,6 +4842,7 @@ class LIPM:
     self: LIPM,
 
   ) -> LIPMTrajectory:
+    """Get the LIPM trajectory. Should be used after solving the problem."""
     ...
 
   def jerk(
@@ -4820,6 +4859,12 @@ class LIPM:
   ) -> Expression:
     ...
 
+  t_end: float # double
+
+  t_start: float # double
+
+  timesteps: int # int
+
   def vel(
     self: LIPM,
     timestep: int, # int
@@ -4829,8 +4874,12 @@ class LIPM:
 
   x: Integrator # placo::problem::Integrator
 
+  x_var: Variable # placo::problem::Variable
+
   y: Integrator # placo::problem::Integrator
 
+  y_var: Variable # placo::problem::Variable
+
   def zmp(
     self: LIPM,
     timestep: int, # int
@@ -5215,6 +5264,43 @@ class PolygonConstraint:
     ...
 
 
+class Polynom:
+  def __init__(
+    self: Polynom,
+    coefficients: numpy.ndarray, # Eigen::VectorXd
+
+  ) -> any:
+    ...
+
+  coefficients: numpy.ndarray # Eigen::VectorXd
+  """coefficients, from highest to lowest 
+        """
+
+  @staticmethod
+  def derivative_coefficient(
+    degree: int, # int
+    derivative: int, # int
+
+  ) -> int:
+    ...
+
+  def value(
+    self: Polynom,
+    x: float, # double
+    derivative: int = 0, # int
+
+  ) -> float:
+    """Computes the value of polynom. 
+        
+
+    :param x: abscissa 
+
+    :param derivative: differentiation order (0: p, 1: p', 2: p'' etc.) 
+
+    :return: value"""
+    ...
+
+
 class PositionTask:
   A: numpy.ndarray # Eigen::MatrixXd
   """Matrix A in the task Ax = b, where x are the joint delta positions. 
@@ -5496,6 +5582,43 @@ class ProblemConstraint:
         """
 
 
+class ProblemPolynom:
+  """Represents a polynom for which decision variables are problem coefficients. 
+    """
+  def __init__(
+    self: ProblemPolynom,
+    variable: Variable, # placo::problem::Variable
+
+  ) -> any:
+    ...
+
+  def expr(
+    self: ProblemPolynom,
+    x: float, # double
+    derivative: int = 0, # int
+
+  ) -> Expression:
+    """Builds a problem expression for the value of the polynom. 
+        
+
+    :param x: abscissa 
+
+    :param derivative: differentiation order (0: p, 1: p', 2: p'' etc.) 
+
+    :return: problem expression"""
+    ...
+
+  def get_polynom(
+    self: ProblemPolynom,
+
+  ) -> Polynom:
+    """Obtain resulting polynom (after problem is solved) 
+        
+
+    :return:"""
+    ...
+
+
 class PuppetContact:
   def __init__(
     self: PuppetContact,
@@ -6425,6 +6548,136 @@ class RobotWrapper_State:
         """
 
 
+class Segment:
+  def __init__(
+    self: Segment,
+    start: numpy.ndarray, # const Eigen::Vector2d &
+    end: numpy.ndarray, # const Eigen::Vector2d &
+
+  ) -> any:
+    ...
+
+  end: numpy.ndarray # Eigen::Vector2d
+
+  def half_line_pass_through(
+    self: Segment,
+    s: Segment, # placo::tools::Segment
+
+  ) -> bool:
+    """Checks if the half-line starting from the start of this segment and going through its end pass through another segment. 
+        
+
+    :param s: The other segment. 
+
+    :return: True if the intersection is a point of the other segment."""
+    ...
+
+  def intersects(
+    self: Segment,
+    s: Segment, # placo::tools::Segment
+
+  ) -> bool:
+    """Checks if there is an intersection between this segment and another one, i.e. if the intersection of their guiding lines is a point of both segments. 
+        
+
+    :param s: The other segment. 
+
+    :return: True if there is an intersection."""
+    ...
+
+  def is_collinear(
+    self: Segment,
+    s: Segment, # placo::tools::Segment
+    epsilon: float = 1e-6, # double
+
+  ) -> bool:
+    """Checks if this segment is collinear with another one. 
+        
+
+    :param s: The segment to check collinearity with. 
+
+    :param epsilon: To account for floating point errors. 
+
+    :return: True if the segments are collinear."""
+    ...
+
+  def is_parallel(
+    self: Segment,
+    s: Segment, # placo::tools::Segment
+    epsilon: float = 1e-6, # double
+
+  ) -> bool:
+    """Checks if this segment is parallel to another one. 
+        
+
+    :param s: The segment to check parallelism with. 
+
+    :param epsilon: To account for floating point errors. 
+
+    :return: True if the segments are parallel."""
+    ...
+
+  def is_point_aligned(
+    self: Segment,
+    point: numpy.ndarray, # const Eigen::Vector2d &
+    epsilon: float = 1e-6, # double
+
+  ) -> bool:
+    """Checks if a point is aligned with this segment. 
+        
+
+    :param point: The point to check alignment with. 
+
+    :param epsilon: To account for floating point errors. 
+
+    :return: True if the point is aligned with the segment."""
+    ...
+
+  def is_point_in_segment(
+    self: Segment,
+    point: numpy.ndarray, # const Eigen::Vector2d &
+    epsilon: float = 1e-6, # double
+
+  ) -> bool:
+    """Checks if a point is in the segment. 
+        
+
+    :param point: The point to check. 
+
+    :param epsilon: To account for floating point errors. 
+
+    :return: True if the point is in the segment."""
+    ...
+
+  def line_pass_through(
+    self: Segment,
+    s: Segment, # placo::tools::Segment
+
+  ) -> bool:
+    """Checks if the guiding line of another segment pass through this segment, i.e. if the intersection between the guiding lines of this segment and another one is a point of this segment. 
+        
+
+    :param s: The other segment. 
+
+    :return: True if the intersection is a point of this segment."""
+    ...
+
+  def lines_intersection(
+    self: Segment,
+    s: Segment, # placo::tools::Segment
+
+  ) -> numpy.ndarray:
+    """Return the intersection between the guiding lines of this segment and another one. 
+        
+
+    :param s: The other segment. 
+
+    :return: The intersection point."""
+    ...
+
+  start: numpy.ndarray # Eigen::Vector2d
+
+
 class Sparsity:
   """Internal helper to check the column sparsity of a matrix. 
     """
@@ -6495,11 +6748,21 @@ class Support:
   """A support is a set of footsteps (can be one or two foot on the ground) 
     """
   def __init__(
-    arg1: object,
+    self: Support,
+    footsteps: list[Footstep], # std::vector<placo::humanoid::FootstepsPlanner::Footstep>
+
+  ) -> any:
+    ...
+
+  def apply_offset(
+    self: Support,
+    offset: numpy.ndarray, # Eigen::Vector2d
 
   ) -> None:
     ...
 
+  elapsed_ratio: float # double
+
   end: bool # bool
 
   def footstep_frame(
@@ -6534,11 +6797,7 @@ class Support:
     """Checks whether this support is a double support."""
     ...
 
-  def kick(
-    self: Support,
-
-  ) -> bool:
-    ...
+  replanned: bool # bool
 
   def set_end(
     arg1: Support,
@@ -6569,6 +6828,10 @@ class Support:
   ) -> list[numpy.ndarray]:
     ...
 
+  t_start: float # double
+
+  time_ratio: float # double
+
 
 class Supports:
   def __init__(
@@ -6634,11 +6897,13 @@ class SwingFootCubic:
   @staticmethod
   def make_trajectory(
     t_start: float, # double
-    t_end: float, # double
+    virt_duration: float, # double
     height: float, # double
     rise_ratio: float, # double
     start: numpy.ndarray, # Eigen::Vector3d
     target: numpy.ndarray, # Eigen::Vector3d
+    elapsed_ratio: float = 0., # double
+    start_vel: numpy.ndarray = None, # Eigen::Vector3d (default: Eigen::Vector3d::Zero())
 
   ) -> SwingFootCubicTrajectory:
     ...
@@ -6872,193 +7137,63 @@ class Variable:
         """
 
 
-class WalkPatternGenerator:
+class WPGTrajectory:
   def __init__(
-    self: WalkPatternGenerator,
-    robot: HumanoidRobot, # placo::humanoid::HumanoidRobot
-    parameters: HumanoidParameters, # placo::humanoid::HumanoidParameters
+    arg1: object,
+    arg2: float,
+    arg3: float,
+    arg4: float,
 
-  ) -> any:
+  ) -> None:
     ...
 
-  def can_replan_supports(
-    self: WalkPatternGenerator,
-    trajectory: WalkTrajectory, # placo::humanoid::WalkPatternGenerator::Trajectory
-    t_replan: float, # double
+  def apply_transform(
+    self: WPGTrajectory,
+    T: numpy.ndarray, # Eigen::Affine3d
 
-  ) -> bool:
-    """Checks if a trajectory can be replanned for supports."""
+  ) -> None:
+    """Applies a given transformation to the left of all values issued by the trajectory."""
     ...
 
-  def plan(
-    self: WalkPatternGenerator,
-    supports: list[Support], # std::vector<placo::humanoid::FootstepsPlanner::Support>
-    initial_com_world: numpy.ndarray, # Eigen::Vector3d
-    t_start: float = 0., # double
-
-  ) -> WalkTrajectory:
-    """Plan a walk trajectory following given footsteps based on the parameters of the WPG. 
-        
-
-    :param supports: Supports generated from the foosteps to follow 
-
-    :return: Planned trajectory"""
-    ...
-
-  def replan(
-    self: WalkPatternGenerator,
-    supports: list[Support], # std::vector<placo::humanoid::FootstepsPlanner::Support>
-    old_trajectory: WalkTrajectory, # placo::humanoid::WalkPatternGenerator::Trajectory
-    t_replan: float, # double
-
-  ) -> WalkTrajectory:
-    """Update the walk trajectory to follow given footsteps based on the parameters of the WPG. 
-        
-
-    :param supports: Supports generated from the current foosteps or the new ones to follow. Contain the current support 
-
-    :param old_trajectory: Current walk trajectory 
-
-    :param t_replan: The time (in the original trajectory) where the replan happens 
-
-    :return: True if the trajectory have been replanned, false it hasn't"""
-    ...
-
-  def replan_supports(
-    self: WalkPatternGenerator,
-    planner: FootstepsPlanner, # placo::humanoid::FootstepsPlanner
-    trajectory: WalkTrajectory, # placo::humanoid::WalkPatternGenerator::Trajectory
-    t_replan: float, # double
-
-  ) -> list[Support]:
-    """Replan the supports for a given trajectory given a footsteps planner."""
-    ...
-
-
-class WalkTasks:
-  def __init__(
-    arg1: object,
-
-  ) -> None:
-    ...
-
-  com_x: float # double
-
-  com_y: float # double
-
-  def get_tasks_error(
-    self: WalkTasks,
-
-  ) -> any:
-    ...
-
-  def initialize_tasks(
-    self: WalkTasks,
-    solver: KinematicsSolver, # placo::kinematics::KinematicsSolver
-    robot: HumanoidRobot, # placo::humanoid::HumanoidRobot
-
-  ) -> None:
-    ...
-
-  left_foot_task: FrameTask # placo::kinematics::FrameTask
-
-  def reach_initial_pose(
-    self: WalkTasks,
-    T_world_left: numpy.ndarray, # Eigen::Affine3d
-    feet_spacing: float, # double
-    com_height: float, # double
-    trunk_pitch: float, # double
-
-  ) -> None:
-    ...
-
-  def remove_tasks(
-    self: WalkTasks,
-
-  ) -> None:
-    ...
-
-  right_foot_task: FrameTask # placo::kinematics::FrameTask
-
-  scaled: bool # bool
-
-  solver: KinematicsSolver # placo::kinematics::KinematicsSolver
-
-  trunk_mode: bool # bool
-
-  trunk_orientation_task: OrientationTask # placo::kinematics::OrientationTask
-
-  def update_tasks(
-    self: WalkTasks,
-    T_world_left: numpy.ndarray, # Eigen::Affine3d
-    T_world_right: numpy.ndarray, # Eigen::Affine3d
-    com_world: numpy.ndarray, # Eigen::Vector3d
-    R_world_trunk: numpy.ndarray, # Eigen::Matrix3d
-
-  ) -> None:
-    ...
-
-  def update_tasks_from_trajectory(
-    arg1: WalkTasks,
-    arg2: WalkTrajectory,
-    arg3: float,
-
-  ) -> None:
-    ...
-
-
-class WalkTrajectory:
-  def __init__(
-    arg1: object,
-
-  ) -> None:
-    ...
-
-  def apply_transform(
-    self: WalkTrajectory,
-    T: numpy.ndarray, # Eigen::Affine3d
-
-  ) -> None:
-    """Applies a given transformation to the left of all values issued by the trajectory."""
-    ...
+  com_target_z: float # double
 
   def get_R_world_trunk(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
 
   ) -> numpy.ndarray:
     ...
 
   def get_T_world_left(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
 
   ) -> numpy.ndarray:
     ...
 
   def get_T_world_right(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
 
   ) -> numpy.ndarray:
     ...
 
   def get_a_world_CoM(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
 
   ) -> numpy.ndarray:
     ...
 
   def get_j_world_CoM(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
 
   ) -> numpy.ndarray:
     ...
 
   def get_next_support(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
     n: int = 1, # int
 
@@ -7067,14 +7202,14 @@ class WalkTrajectory:
     ...
 
   def get_p_world_CoM(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
 
   ) -> numpy.ndarray:
     ...
 
   def get_p_world_DCM(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
     omega: float, # double
 
@@ -7082,7 +7217,7 @@ class WalkTrajectory:
     ...
 
   def get_p_world_ZMP(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
     omega: float, # double
 
@@ -7090,7 +7225,7 @@ class WalkTrajectory:
     ...
 
   def get_part_t_start(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
 
   ) -> float:
@@ -7098,7 +7233,7 @@ class WalkTrajectory:
     ...
 
   def get_prev_support(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
     n: int = 1, # int
 
@@ -7107,7 +7242,7 @@ class WalkTrajectory:
     ...
 
   def get_support(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
 
   ) -> Support:
@@ -7115,29 +7250,50 @@ class WalkTrajectory:
     ...
 
   def get_supports(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
 
   ) -> list[Support]:
     ...
 
   def get_v_world_CoM(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
+    t: float, # double
+
+  ) -> numpy.ndarray:
+    ...
+
+  def get_v_world_foot(
+    self: WPGTrajectory,
+    side: any, # placo::humanoid::HumanoidRobot::Side
+    t: float, # double
+
+  ) -> numpy.ndarray:
+    ...
+
+  def get_v_world_right(
+    self: WPGTrajectory,
     t: float, # double
 
   ) -> numpy.ndarray:
     ...
 
-  jerk_planner_timesteps: int # int
+  kept_ts: int # int
+
+  def print_parts_timings(
+    self: WPGTrajectory,
+
+  ) -> None:
+    ...
 
   def support_is_both(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
 
   ) -> bool:
     ...
 
   def support_side(
-    self: WalkTrajectory,
+    self: WPGTrajectory,
     t: float, # double
 
   ) -> any:
@@ -7147,6 +7303,177 @@ class WalkTrajectory:
 
   t_start: float # double
 
+  trunk_pitch: float # double
+
+  trunk_roll: float # double
+
+
+class WPGTrajectoryPart:
+  def __init__(
+    arg1: object,
+    arg2: Support,
+    arg3: float,
+
+  ) -> None:
+    ...
+
+  support: Support # placo::humanoid::FootstepsPlanner::Support
+
+  t_end: float # double
+
+  t_start: float # double
+
+
+class WalkPatternGenerator:
+  def __init__(
+    self: WalkPatternGenerator,
+    robot: HumanoidRobot, # placo::humanoid::HumanoidRobot
+    parameters: HumanoidParameters, # placo::humanoid::HumanoidParameters
+
+  ) -> any:
+    ...
+
+  def can_replan_supports(
+    self: WalkPatternGenerator,
+    trajectory: WPGTrajectory, # placo::humanoid::WalkPatternGenerator::Trajectory
+    t_replan: float, # double
+
+  ) -> bool:
+    """Checks if a trajectory can be replanned for supports."""
+    ...
+
+  def compute_next_support(
+    self: WalkPatternGenerator,
+    t: float, # double
+    current_support: Support, # placo::humanoid::FootstepsPlanner::Support
+    next_support: Support, # placo::humanoid::FootstepsPlanner::Support
+    world_measured_dcm: numpy.ndarray, # Eigen::Vector2d
+    world_initial_dcm: numpy.ndarray, # Eigen::Vector2d
+
+  ) -> any:
+    """Computes the position and time of the next support ensuring the DCM viability based on the measured DCM. 
+        
+
+    :param TODO:"""
+    ...
+
+  def plan(
+    self: WalkPatternGenerator,
+    supports: list[Support], # std::vector<placo::humanoid::FootstepsPlanner::Support>
+    initial_com_world: numpy.ndarray, # Eigen::Vector3d
+    t_start: float = 0., # double
+
+  ) -> WPGTrajectory:
+    """Plans a walk trajectory following given footsteps based on the parameters of the WPG. 
+        
+
+    :param supports: Supports generated from the foosteps to follow 
+
+    :return: Planned trajectory"""
+    ...
+
+  def replan(
+    self: WalkPatternGenerator,
+    supports: list[Support], # std::vector<placo::humanoid::FootstepsPlanner::Support>
+    old_trajectory: WPGTrajectory, # placo::humanoid::WalkPatternGenerator::Trajectory
+    t_replan: float, # double
+
+  ) -> WPGTrajectory:
+    """Updates the walk trajectory to follow given footsteps based on the parameters of the WPG. 
+        
+
+    :param supports: Supports generated from the current foosteps or the new ones to follow. Contain the current support 
+
+    :param old_trajectory: Current walk trajectory 
+
+    :param t_replan: The time (in the original trajectory) where the replan happens 
+
+    :return: Updated trajectory"""
+    ...
+
+  def replan_supports(
+    self: WalkPatternGenerator,
+    planner: FootstepsPlanner, # placo::humanoid::FootstepsPlanner
+    trajectory: WPGTrajectory, # placo::humanoid::WalkPatternGenerator::Trajectory
+    t_replan: float, # double
+    t_last_replan: float, # double
+
+  ) -> list[Support]:
+    """Replans the supports for a given trajectory given a footsteps planner."""
+    ...
+
+
+class WalkTasks:
+  def __init__(
+    arg1: object,
+
+  ) -> None:
+    ...
+
+  com_x: float # double
+
+  com_y: float # double
+
+  def get_tasks_error(
+    self: WalkTasks,
+
+  ) -> any:
+    ...
+
+  def initialize_tasks(
+    self: WalkTasks,
+    solver: KinematicsSolver, # placo::kinematics::KinematicsSolver
+    robot: HumanoidRobot, # placo::humanoid::HumanoidRobot
+
+  ) -> None:
+    ...
+
+  left_foot_task: FrameTask # placo::kinematics::FrameTask
+
+  def reach_initial_pose(
+    self: WalkTasks,
+    T_world_left: numpy.ndarray, # Eigen::Affine3d
+    feet_spacing: float, # double
+    com_height: float, # double
+    trunk_pitch: float, # double
+
+  ) -> None:
+    ...
+
+  def remove_tasks(
+    self: WalkTasks,
+
+  ) -> None:
+    ...
+
+  right_foot_task: FrameTask # placo::kinematics::FrameTask
+
+  scaled: bool # bool
+
+  solver: KinematicsSolver # placo::kinematics::KinematicsSolver
+
+  trunk_mode: bool # bool
+
+  trunk_orientation_task: OrientationTask # placo::kinematics::OrientationTask
+
+  def update_tasks(
+    self: WalkTasks,
+    T_world_left: numpy.ndarray, # Eigen::Affine3d
+    T_world_right: numpy.ndarray, # Eigen::Affine3d
+    com_world: numpy.ndarray, # Eigen::Vector3d
+    R_world_trunk: numpy.ndarray, # Eigen::Matrix3d
+
+  ) -> None:
+    ...
+
+  def update_tasks_from_trajectory(
+    arg1: WalkTasks,
+    arg2: WPGTrajectory,
+    arg3: float,
+
+  ) -> None:
+    ...
+
 
 class WheelTask:
   A: numpy.ndarray # Eigen::MatrixXd
@@ -7567,4 +7894,4 @@ def wrap_angle(
   ...
 
 
-__groups__ = {'placo::dynamics': ['AvoidSelfCollisionsDynamicsConstraint', 'Contact', 'Contact6D', 'DynamicsCoMTask', 'DynamicsConstraint', 'DynamicsFrameTask', 'DynamicsGearTask', 'DynamicsJointsTask', 'DynamicsOrientationTask', 'DynamicsPositionTask', 'DynamicsRelativeFrameTask', 'DynamicsRelativeOrientationTask', 'DynamicsRelativePositionTask', 'DynamicsSolver', 'DynamicsSolverResult', 'DynamicsTask', 'DynamicsTorqueTask', 'ExternalWrenchContact', 'LineContact', 'PointContact', 'PuppetContact', 'TaskContact'], 'placo::kinematics': ['AvoidSelfCollisionsKinematicsConstraint', 'AxisAlignTask', 'CentroidalMomentumTask', 'CoMPolygonConstraint', 'CoMTask', 'ConeConstraint', 'DistanceTask', 'FrameTask', 'GearTask', 'JointsTask', 'KinematicsConstraint', 'KinematicsSolver', 'KineticEnergyRegularizationTask', 'ManipulabilityTask', 'OrientationTask', 'PositionTask', 'RegularizationTask', 'RelativeFrameTask', 'RelativeOrientationTask', 'RelativePositionTask', 'Task', 'WheelTask'], 'placo::tools': ['AxisesMask', 'CubicSpline', 'CubicSpline3D', 'Prioritized'], 'placo::model': ['Collision', 'Distance', 'RobotWrapper', 'RobotWrapper_State'], 'placo::problem': ['Expression', 'Integrator', 'IntegratorTrajectory', 'PolygonConstraint', 'Problem', 'ProblemConstraint', 'QPError', 'Sparsity', 'SparsityInterval', 'Variable'], 'placo::humanoid': ['Footstep', 'FootstepsPlanner', 'FootstepsPlannerNaive', 'FootstepsPlannerRepetitive', 'HumanoidParameters', 'HumanoidRobot', 'LIPM', 'LIPMTrajectory', 'Support', 'SwingFoot', 'SwingFootCubic', 'SwingFootCubicTrajectory', 'SwingFootQuintic', 'SwingFootQuinticTrajectory', 'SwingFootTrajectory', 'WalkPatternGenerator', 'WalkTasks', 'WalkTrajectory']}
+__groups__ = {'placo::dynamics': ['AvoidSelfCollisionsDynamicsConstraint', 'Contact', 'Contact6D', 'DynamicsCoMTask', 'DynamicsConstraint', 'DynamicsFrameTask', 'DynamicsGearTask', 'DynamicsJointsTask', 'DynamicsOrientationTask', 'DynamicsPositionTask', 'DynamicsRelativeFrameTask', 'DynamicsRelativeOrientationTask', 'DynamicsRelativePositionTask', 'DynamicsSolver', 'DynamicsSolverResult', 'DynamicsTask', 'DynamicsTorqueTask', 'ExternalWrenchContact', 'LineContact', 'PointContact', 'PuppetContact', 'TaskContact'], 'placo::kinematics': ['AvoidSelfCollisionsKinematicsConstraint', 'AxisAlignTask', 'CentroidalMomentumTask', 'CoMPolygonConstraint', 'CoMTask', 'ConeConstraint', 'DistanceTask', 'FrameTask', 'GearTask', 'JointSpaceHalfSpacesConstraint', 'JointsTask', 'KinematicsConstraint', 'KinematicsSolver', 'KineticEnergyRegularizationTask', 'ManipulabilityTask', 'OrientationTask', 'PositionTask', 'RegularizationTask', 'RelativeFrameTask', 'RelativeOrientationTask', 'RelativePositionTask', 'Task', 'WheelTask'], 'placo::tools': ['AxisesMask', 'CubicSpline', 'CubicSpline3D', 'Polynom', 'Prioritized', 'Segment'], 'placo::model': ['Collision', 'Distance', 'RobotWrapper', 'RobotWrapper_State'], 'placo::problem': ['Expression', 'Integrator', 'IntegratorTrajectory', 'PolygonConstraint', 'Problem', 'ProblemConstraint', 'ProblemPolynom', 'QPError', 'Sparsity', 'SparsityInterval', 'Variable'], 'placo::humanoid': ['Footstep', 'FootstepsPlanner', 'FootstepsPlannerNaive', 'FootstepsPlannerRepetitive', 'HumanoidParameters', 'HumanoidRobot', 'LIPM', 'LIPMTrajectory', 'Support', 'SwingFoot', 'SwingFootCubic', 'SwingFootCubicTrajectory', 'SwingFootQuintic', 'SwingFootQuinticTrajectory', 'SwingFootTrajectory', 'WPGTrajectory', 'WPGTrajectoryPart', 'WalkPatternGenerator', 'WalkTasks']}

placo-0.6.5.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: placo
+Version: 0.6.5
+Summary: PlaCo: Rhoban Planning and Control
+Requires-Python: >= 3.8
+License-Expression: MIT
+License-File: LICENSE
+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.3.dist-info → placo-0.6.5.dist-info}/RECORD

@@ -1,6 +1,6 @@
-cmeel.prefix/lib/liblibplaco.so,sha256=dW2MV7F2r0WwQcByZhI1l-uvg0WLdISQStZ4AA_cTAI,2616424
-cmeel.prefix/lib/python3.10/site-packages/placo.pyi,sha256=Dv3QaHIsO_eh0FNluw9AFC3Hao09e9gdK0TbYbPHbvk,157676
-cmeel.prefix/lib/python3.10/site-packages/placo.so,sha256=VmJRvX6tkxZoqJoHzssmekDUE4_MQD9Xrh4H8dWbhgo,7766704
+cmeel.prefix/lib/liblibplaco.so,sha256=JHPCSivZCpUJilIWFEzM8EC9fp7mWKb5UMiplzI6Y0Q,2619816
+cmeel.prefix/lib/python3.10/site-packages/placo.pyi,sha256=7qqoiIhhkYkGKgIuYE9NV1InLRwFwO3VBMjnUnL2LaE,165405
+cmeel.prefix/lib/python3.10/site-packages/placo.so,sha256=haijm8VCNbRolUpwCWsZuOmxRJxkr-4UjpuSwocy3X4,8201384
 cmeel.prefix/lib/python3.10/site-packages/placo_utils/__init__.py,sha256=UN-fc5KfBWQ-_qkm0Ajouh-T9tBGm5aUtuzBiH1tRtk,80
 cmeel.prefix/lib/python3.10/site-packages/placo_utils/tf.py,sha256=fFRXNbeLlXzn5VOqYl7hcSuvOOtTDTiLi_Lpd9_l6wA,36
 cmeel.prefix/lib/python3.10/site-packages/placo_utils/view.py,sha256=7KiLYGpTKaPJtFHZ6kjERdOzJiPSDUtkIKHbziHpkYk,928
@@ -8,8 +8,8 @@ cmeel.prefix/lib/python3.10/site-packages/placo_utils/visualization.py,sha256=6E
 cmeel.prefix/lib/python3.10/site-packages/placo_utils/__pycache__/__init__.cpython-310.pyc,sha256=tJrTajdA7hNO9tZkE1oN49rU-61lCNUED-mQXdAvzAs,261
 cmeel.prefix/lib/python3.10/site-packages/placo_utils/__pycache__/tf.cpython-310.pyc,sha256=APWQ5-zKgbEcMnkv6Hxgj_Q46jpnuOyL9YbSrj6Z5Vw,204
 cmeel.prefix/lib/python3.10/site-packages/placo_utils/__pycache__/visualization.cpython-310.pyc,sha256=kMdmKY2LZKM4rkKm4j0y-TOMBQ3PeVIpbfB_YJxNz5c,6781
-placo-0.6.3.dist-info/license/LICENSE,sha256=q2bBXvk4Eh7TmP11LoIOIGSUuJbR30JBI6ZZ37g52T4,1061
-placo-0.6.3.dist-info/METADATA,sha256=nUdBGDAALqcemXjBxMpxSf_Y9VbvknUiwse6wAazGEg,2569
-placo-0.6.3.dist-info/WHEEL,sha256=y7GzdFHC0qrZwnE2SqFjrXxL9NLtXflO9hVb0PhWwIU,115
-placo-0.6.3.dist-info/top_level.txt,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-placo-0.6.3.dist-info/RECORD,,
+placo-0.6.5.dist-info/licenses/LICENSE,sha256=q2bBXvk4Eh7TmP11LoIOIGSUuJbR30JBI6ZZ37g52T4,1061
+placo-0.6.5.dist-info/METADATA,sha256=lvTtWBMQSRl3ZM85U5-DlJ57HNEiDwpnD7cMrrxBNP4,2622
+placo-0.6.5.dist-info/WHEEL,sha256=lhhHTnYbOJzqsg4pPctu5MqgY8RxNHlH5gszBU8FPYs,115
+placo-0.6.5.dist-info/top_level.txt,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+placo-0.6.5.dist-info/RECORD,,

{placo-0.6.3.dist-info → placo-0.6.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: cmeel 0.53.3
+Generator: cmeel 0.57.1
 Root-Is-Purelib: false
 Tag: cp310-cp310-manylinux_2_35_x86_64
 Build: 0

placo-0.6.3.dist-info/METADATA

@@ -1,57 +0,0 @@
-Metadata-Version: 2.1
-Name: placo
-Version: 0.6.3
-Summary: PlaCo: Rhoban Planning and Control
-Requires-Python: >= 3.8
-License-Expression: MIT
-License-File: LICENSE
-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
-
-# PlaCo
-
-PlaCo is Rhoban's planning and control library.
-Its main features are:
-
-* Task-space Inverse Kinematics with constraints,
-* Task-space Inverse Dynamics with constraints,
-* QP problem formulation,
-* Built on the top of [pinocchio](https://github.com/stack-of-tasks/pinocchio)
-* Written in C++ with Python bindings
-
-[![Megabot 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)
-
-*Inverse Kinematics Example: a quadruped robot hitting targets with a leg while keeping its three legs on the ground*
-
-[source code (quadruped_targets.py)](https://github.com/Rhoban/placo-examples/blob/master/kinematics/quadruped_targets.py) / [more kinematics examples](https://placo.readthedocs.io/en/latest/kinematics/examples_gallery.html)
-
-[![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)
-
-*Inverse Dynamics Example: a quadruped with many loop closure joints*
-
-[source code (megabot.py)](https://github.com/Rhoban/placo-examples/blob/master/dynamics/megabot.py) / [more dynamics examples](https://placo.readthedocs.io/en/latest/dynamics/examples_gallery.html)
-
-## Installing
-
-PlaCo is available from [pip](https://placo.readthedocs.io/en/latest/basics/installation_pip.html),
-or can be [built from sources](https://placo.readthedocs.io/en/latest/basics/installation_source.html).
-
-## Documentation
-
-Here is the [official documentation](https://placo.readthedocs.io/en/latest/)
-
-You can also find many examples in the [placo-examples](https://github.com/rhoban/placo-examples)
-repository.