placo::humanoid

class placo.Footstep(foot_width: float, foot_length: float)

foot_length: any

None( (placo.Footstep)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::FootstepsPlanner::Footstep {lvalue})

foot_width: any

None( (placo.Footstep)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::FootstepsPlanner::Footstep {lvalue})

frame: any

None( (placo.Footstep)arg1) -> object :

C++ signature :

Eigen::Transform<double, 3, 2, 0> {lvalue} None(placo::humanoid::FootstepsPlanner::Footstep {lvalue})

overlap(other: Footstep, margin: float = 0.0) → bool

static polygon_contains(self, polygon: list[ndarray], point: ndarray) → bool

set_frame_xy(arg2: float, arg3: float) → None

side: any

None( (placo.Footstep)arg1) -> placo.HumanoidRobot_Side :

C++ signature :

placo::humanoid::HumanoidRobot::Side {lvalue} None(placo::humanoid::FootstepsPlanner::Footstep {lvalue})

support_polygon() → list[ndarray]

class placo.FootstepsPlanner(parameters: HumanoidParameters)

Initializes the planner.

Parameters:

parameters (HumanoidParameters) – Parameters of the walk

static make_supports(self, footsteps: list[Footstep], t_start: float, start: bool = True, middle: bool = False, end: bool = True) → list[Support]

Generate the supports from the footsteps.

Parameters:

• start (bool) – should we add a double support at the begining of the move?

• middle (bool) – should we add a double support between each step ?

• end (bool) – should we add a double support at the end of the move?

opposite_footstep(footstep: Footstep, d_x: float = 0.0, d_y: float = 0.0, d_theta: float = 0.0) → Footstep

Return the opposite footstep in a neutral position (i.e. at a distance parameters.feet_spacing from the given footstep)

truncate_supports(arg2: int, arg3: bool) → Supports

class placo.FootstepsPlannerNaive(parameters: HumanoidParameters)

configure(T_world_left_target: ndarray, T_world_right_target: ndarray) → None

Configure the naive footsteps planner.

Parameters:

• T_world_left_target (numpy.ndarray) – Targetted frame for the left foot

• T_world_right_target (numpy.ndarray) – Targetted frame for the right foot

static make_supports(self, footsteps: list[Footstep], t_start: float, start: bool = True, middle: bool = False, end: bool = True) → list[Support]

Generate the supports from the footsteps.

Parameters:

• start (bool) – should we add a double support at the begining of the move?

• middle (bool) – should we add a double support between each step ?

• end (bool) – should we add a double support at the end of the move?

opposite_footstep(footstep: Footstep, d_x: float = 0.0, d_y: float = 0.0, d_theta: float = 0.0) → Footstep

Return the opposite footstep in a neutral position (i.e. at a distance parameters.feet_spacing from the given footstep)

plan(flying_side: any, T_world_left: ndarray, T_world_right: ndarray) → list[Footstep]

Generate the footsteps.

Parameters:

• flying_side (any) – first step side

• T_world_left (numpy.ndarray) – frame of the initial left foot

• T_world_right (numpy.ndarray) – frame of the initial right foot

truncate_supports(arg2: int, arg3: bool) → Supports

class placo.FootstepsPlannerRepetitive(parameters: HumanoidParameters)

configure(x: float, y: float, theta: float, steps: int) → None

Compute the next footsteps based on coordinates expressed in the support frame laterally translated of +/- feet_spacing.

Parameters:

• x (float) – Longitudinal distance

• y (float) – Lateral distance

• theta (float) – Angle

• steps (int) – Number of steps

static make_supports(self, footsteps: list[Footstep], t_start: float, start: bool = True, middle: bool = False, end: bool = True) → list[Support]

Generate the supports from the footsteps.

Parameters:

• start (bool) – should we add a double support at the begining of the move?

• middle (bool) – should we add a double support between each step ?

• end (bool) – should we add a double support at the end of the move?

opposite_footstep(footstep: Footstep, d_x: float = 0.0, d_y: float = 0.0, d_theta: float = 0.0) → Footstep

Return the opposite footstep in a neutral position (i.e. at a distance parameters.feet_spacing from the given footstep)

plan(flying_side: any, T_world_left: ndarray, T_world_right: ndarray) → list[Footstep]

Generate the footsteps.

Parameters:

• flying_side (any) – first step side

• T_world_left (numpy.ndarray) – frame of the initial left foot

• T_world_right (numpy.ndarray) – frame of the initial right foot

truncate_supports(arg2: int, arg3: bool) → Supports

class placo.HumanoidParameters

dcm_offset_polygon: any

None( (placo.HumanoidParameters)arg1) -> placo.vector_Vector2d :

C++ signature :

std::vector<Eigen::Matrix<double, 2, 1, 0, 2, 1>, std::allocator<Eigen::Matrix<double, 2, 1, 0, 2, 1> > > {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

double_support_duration() → float

Default duration [s] of a double support.

double_support_ratio: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

double_support_timesteps() → int

Default number of timesteps for one double support.

dt() → float

Timestep duration for planning [s].

ellipsoid_clip(step: ndarray) → ndarray

Applies the ellipsoid clipping to a given step size (dx, dy, dtheta)

feet_spacing: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

foot_length: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

foot_width: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

foot_zmp_target_x: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

foot_zmp_target_y: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

has_double_support() → bool

Checks if the walk resulting from those parameters will have double supports.

op_space_polygon: any

None( (placo.HumanoidParameters)arg1) -> placo.vector_Vector2d :

C++ signature :

std::vector<Eigen::Matrix<double, 2, 1, 0, 2, 1>, std::allocator<Eigen::Matrix<double, 2, 1, 0, 2, 1> > > {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

planned_timesteps: any

None( (placo.HumanoidParameters)arg1) -> int :

C++ signature :

int {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

single_support_duration: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

single_support_timesteps: any

None( (placo.HumanoidParameters)arg1) -> int :

C++ signature :

int {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

startend_double_support_duration() → float

Default duration [s] of a start/end double support.

startend_double_support_ratio: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

startend_double_support_timesteps() → int

Default number of timesteps for one start/end double support.

walk_com_height: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

walk_dtheta_spacing: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

walk_foot_height: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

walk_foot_rise_ratio: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

walk_max_dtheta: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

walk_max_dx_backward: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

walk_max_dx_forward: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

walk_max_dy: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

walk_trunk_pitch: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

zmp_margin: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

zmp_reference_weight: any

None( (placo.HumanoidParameters)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})

class placo.HumanoidRobot(model_directory: str = 'robot', flags: int = 0, urdf_content: str = '')

add_q_noise(noise: float) → None

Adds some noise to the configuration.

centroidal_map() → ndarray

Centroidal map.

collision_model: any

None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryModel :

C++ signature :

pinocchio::GeometryModel {lvalue} None(placo::humanoid::HumanoidRobot {lvalue})

com_jacobian() → ndarray

Jacobian of the CoM position expressed in the world.

com_jacobian_time_variation() → ndarray

Jacobian time variation of the CoM expressed in the world.

com_world() → ndarray

Gets the CoM position in the world.

compute_hessians() → None

Compute kinematics hessians.

dcm(omega: float, com_velocity: ndarray) → ndarray

Compute the Divergent Component of Motion (DCM)

Parameters:

• omega (float) – Natural frequency of the LIP (= sqrt(g/h))

• com_velocity (numpy.ndarray) – CoM velocity

distances() → list[Distance]

Computes all minimum distances between current collision pairs.

Returns:

<Element ‘para’ at 0xff164265f100>

ensure_on_floor() → None

Place the robot on its support on the floor.

ensure_on_floor_oriented(R_world_trunk: ndarray) → None

Place the robot on its support on the floor according to the trunk orientation and the kinematic configuration.

Parameters:

R_world_trunk (numpy.ndarray) – Orientation of the trunk

frame_jacobian(frame: any, ref: any = None) → ndarray

Frame jacobian, default reference is LOCAL_WORLD_ALIGNED.

Parameters:

frame (any) – the frame for which we want the jacobian

Returns:

<Element ‘para’ at 0xff164265fba0>

frame_jacobian_time_variation(frame: any, ref: any = None) → ndarray

Jacobian time variation $dot J$, default reference is LOCAL_WORLD_ALIGNED.

Parameters:

frame (any) – the frame for which we want the jacobian time variation

Returns:

<Element ‘para’ at 0xff1642669530>

frame_names() → list[str]

All the frame names.

generalized_gravity() → ndarray

Computes generalized gravity.

get_T_a_b(index_a: any, index_b: any) → ndarray

Gets the transformation matrix from frame b to a.

Parameters:

• index_a (any) – frame a

• index_b (any) – frame b

get_T_world_fbase() → ndarray

Returns the transformation matrix from the fbase frame (which is the root of the URDF) to the world.

get_T_world_frame(index: any) → ndarray

Gets the frame to world transformation matrix for a given frame.

Parameters:

index (any) – frame index

get_T_world_left() → ndarray

get_T_world_right() → ndarray

get_T_world_support() → object

get_T_world_trunk() → ndarray

get_com_velocity(support: any, omega_b: ndarray) → ndarray

Compute the center of mass velocity from the speed of the motors and the orientation of the trunk.

Parameters:

• support (any) – Support side

• omega_b (numpy.ndarray) – Trunk angular velocity in the body frame

get_frame_hessian(frame: any, joint_v_index: int) → ndarray

Get the component for the hessian of a given frame for a given joint.

get_joint(name: str) → float

Retrieves a joint value from state.q.

Parameters:

name (str) – joint name

get_joint_acceleration(name: str) → float

Gets the joint acceleration from state.qd.

Parameters:

name (str) – joint name

get_joint_limits(name: str) → any

Gets the limits for a given joint.

Parameters:

name (str) – joint name

get_joint_offset(name: str) → int

Gets the offset for a given joint in the state (in State::q)

Parameters:

name (str) – joint name

get_joint_v_offset(name: str) → int

Gets the offset for a given joint in the state (in State::qd and State::qdd)

Parameters:

name (str) – joint name

get_joint_velocity(name: str) → float

Gets the joint velocity from state.qd.

Parameters:

name (str) – joint name

get_support_side() → HumanoidRobot_Side

get_torques(acc_a: ndarray, contact_forces: ndarray, use_non_linear_effects: bool = False) → ndarray

Compute the torques of the motors from the contact forces.

Parameters:

• acc_a (numpy.ndarray) – Accelerations of the actuated DoFs

• contact_forces (numpy.ndarray) – Contact forces from the feet (forces are supposed normal to the ground)

• use_non_linear_effects (bool) – If true, non linear effects are taken into account (state.qd necessary)

get_torques_dict(arg2: ndarray, arg3: ndarray, arg4: bool) → dict

integrate(dt: float) → None

Integrates the internal state for a given dt

Parameters:

dt (float) – delta time for integration expressed in seconds

joint_jacobian(joint: str, reference: str = 'local_world_aligned') → ndarray

Joint jacobian, default reference is LOCAL_WORLD_ALIGNED.

joint_names(include_floating_base: bool = False) → list[str]

All the joint names.

Parameters:

include_floating_base (bool) – whether to include the floating base joint (false by default)

load_collision_pairs(filename: str) → None

Loads collision pairs from a given JSON file.

Parameters:

filename (str) – path to collisions.json file

make_solver() → KinematicsSolver

mass_matrix() → ndarray

Computes the mass matrix.

model: any

None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.Model :

C++ signature :

pinocchio::ModelTpl<double, 0, pinocchio::JointCollectionDefaultTpl> {lvalue} None(placo::humanoid::HumanoidRobot {lvalue})

neutral_state() → RobotWrapper_State

builds a neutral state (neutral position, zero speed)

non_linear_effects() → ndarray

Computes non-linear effects (Corriolis, centrifual and gravitationnal effects)

static other_side(self, side: any) → any

relative_position_jacobian(frame_a: any, frame_b: any) → ndarray

Jacobian of the relative position of the position of b expressed in a.

Parameters:

• frame_a (any) – frame index A

• frame_b (any) – frame index B

reset() → None

Reset internal states, this sets q to the neutral position, qd and qdd to zero.

self_collisions(stop_at_first: bool = False) → list[Collision]

Finds the self collision in current state, if stop_at_first is true, it will stop at the first collision found.

Parameters:

stop_at_first (bool) – whether to stop at the first collision found

Returns:

<Element ‘para’ at 0xff164265ea20>

set_T_world_fbase(T_world_fbase: ndarray) → None

Updates the floating base to match the given transformation matrix.

Parameters:

T_world_fbase (numpy.ndarray) – transformation matrix

set_T_world_frame(frame: any, T_world_frameTarget: ndarray) → None

Updates the floating base status so that the given frame has the given transformation matrix.

Parameters:

• frame (any) – frame to update

• T_world_frameTarget (numpy.ndarray) – transformation matrix

set_T_world_support(arg2: ndarray) → None

set_gear_ratio(joint_name: str, rotor_gear_ratio: float) → None

Updates the rotor gear ratio (used for apparent inertia computation in the dynamics)

set_gravity(gravity: ndarray) → None

Sets the gravity vector.

set_joint(name: str, value: float) → None

Sets the value of a joint in state.q.

Parameters:

• name (str) – joint name

• value (float) – joint value (e.g rad for revolute or meters for prismatic)

set_joint_acceleration(name: str, value: float) → None

Sets the joint acceleration in state.qd.

Parameters:

• name (str) – joint name

• value (float) – joint acceleration

set_joint_limits(name: str, lower: float, upper: float) → None

Sets the limits for a given joint.

Parameters:

• name (str) – joint name

• lower (float) – lower limit

• upper (float) – upper limit

set_joint_velocity(name: str, value: float) → None

Sets the joint velocity in state.qd.

Parameters:

• name (str) – joint name

• value (float) – joint velocity

set_rotor_inertia(joint_name: str, rotor_inertia: float) → None

Updates the rotor inertia (used for apparent inertia computation in the dynamics)

set_torque_limit(name: str, limit: float) → None

Sets the torque limit for a given joint.

Parameters:

• name (str) – joint name

• limit (float) – torque limit

set_velocity_limit(name: str, limit: float) → None

Sets the velocity limit for a given joint.

Parameters:

• name (str) – joint name

• limit (float) – joint limit

set_velocity_limits(limit: float) → None

Set the velocity limits for all the joints.

Parameters:

limit (float) – limit

state: any

None( (placo.HumanoidRobot)arg1) -> placo.RobotWrapper_State :

C++ signature :

placo::model::RobotWrapper::State {lvalue} None(placo::humanoid::HumanoidRobot {lvalue})

static_gravity_compensation_torques(frameIndex: any) → ndarray

Computes torques needed by the robot to compensate for the generalized gravity, assuming that the given frame is the (only) contact supporting the robot.

static_gravity_compensation_torques_dict(arg2: str) → dict

support_is_both: any

None( (placo.HumanoidRobot)arg1) -> bool :

C++ signature :

bool {lvalue} None(placo::humanoid::HumanoidRobot {lvalue})

support_side: any

None( (placo.HumanoidRobot)arg1) -> placo.HumanoidRobot_Side :

C++ signature :

placo::humanoid::HumanoidRobot::Side {lvalue} None(placo::humanoid::HumanoidRobot {lvalue})

torques_from_acceleration_with_fixed_frame(qdd_a: ndarray, frameIndex: any) → ndarray

Computes required torques in the robot DOFs for a given acceleration of the actuated DOFs, assuming that the given frame is fixed.

Parameters:

qdd_a (numpy.ndarray) – acceleration of the actuated DOFs

torques_from_acceleration_with_fixed_frame_dict(qdd_a: ndarray, frame: str) → dict

Computes the torque required to reach given acceleration in fixed frame

total_mass() → float

Total mass.

update_from_imu(R_world_trunk: ndarray) → None

Rotate the robot around its support.

Parameters:

R_world_trunk (numpy.ndarray) – Orientation of the trunk from the IMU

update_kinematics() → None

Update internal computation for kinematics (frames, jacobian). This method should be called when the robot state has changed.

update_support_side(new_side: any) → None

Updates which frame should be the current support.

visual_model: any

None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryModel :

C++ signature :

pinocchio::GeometryModel {lvalue} None(placo::humanoid::HumanoidRobot {lvalue})

zmp(omega: float, com_acceleration: ndarray) → ndarray

Compute the Zero-tilting Moment Point (ZMP)

Parameters:

• omega (float) – Natural frequency of the LIP (= sqrt(g/h))

• com_acceleration (numpy.ndarray) – CoM acceleration

class placo.LIPM

LIPM is an helper that can be used to build problem involving LIPM dynamics. The decision variables introduced here are jerks, which is piecewise constant.

acc(timestep: int) → Expression

static build_LIPM_from_previous(self, problem: Problem, dt: float, timesteps: int, t_start: float, previous: LIPM) → LIPM

static compute_omega(self, com_height: float) → float

Compute the natural frequency of a LIPM given its height (omega = sqrt(g / h))

dcm(timestep: int, omega: float) → Expression

dt: any

None( (placo.LIPM)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::LIPM {lvalue})

dzmp(timestep: int, omega_2: float) → Expression

get_trajectory() → LIPMTrajectory

Get the LIPM trajectory. Should be used after solving the problem.

jerk(timestep: int) → Expression

pos(timestep: int) → Expression

t_end: any

None( (placo.LIPM)arg1) -> float :

C++ signature :

double None(placo::humanoid::LIPM {lvalue})

t_start: any

None( (placo.LIPM)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::LIPM {lvalue})

timesteps: any

None( (placo.LIPM)arg1) -> int :

C++ signature :

int {lvalue} None(placo::humanoid::LIPM {lvalue})

vel(timestep: int) → Expression

x: any

None( (placo.LIPM)arg1) -> placo.Integrator :

C++ signature :

placo::problem::Integrator {lvalue} None(placo::humanoid::LIPM {lvalue})

x_var: any

None( (placo.LIPM)arg1) -> object :

C++ signature :

placo::problem::Variable* {lvalue} None(placo::humanoid::LIPM {lvalue})

y: any

None( (placo.LIPM)arg1) -> placo.Integrator :

C++ signature :

placo::problem::Integrator {lvalue} None(placo::humanoid::LIPM {lvalue})

y_var: any

None( (placo.LIPM)arg1) -> object :

C++ signature :

placo::problem::Variable* {lvalue} None(placo::humanoid::LIPM {lvalue})

zmp(timestep: int, omega_2: float) → Expression

class placo.LIPMTrajectory

acc(t: float) → ndarray

dcm(t: float, omega: float) → ndarray

dzmp(t: float, omega_2: float) → ndarray

jerk(t: float) → ndarray

pos(t: float) → ndarray

vel(t: float) → ndarray

zmp(t: float, omega_2: float) → ndarray

class placo.Support

apply_offset(offset: ndarray) → None

elapsed_ratio: any

None( (placo.Support)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})

end: any

None( (placo.Support)arg1) -> bool :

C++ signature :

bool {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})

footstep_frame(side: any) → ndarray

Returns the frame for a given side (if present)

Parameters:

side (any) – the side we want the frame (left or right foot)

footsteps: any

None( (placo.Support)arg1) -> object :

C++ signature :

std::vector<placo::humanoid::FootstepsPlanner::Footstep, std::allocator<placo::humanoid::FootstepsPlanner::Footstep> > {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})

frame() → ndarray

Returns the frame for the support. It will be the (interpolated) average of footsteps frames.

is_both() → bool

Checks whether this support is a double support.

set_end(arg2: bool) → None

set_start(arg2: bool) → None

side() → any

The support side (you should call is_both() to be sure it’s not a double support before)

start: any

None( (placo.Support)arg1) -> bool :

C++ signature :

bool {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})

support_polygon() → list[ndarray]

t_start: any

None( (placo.Support)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})

target_world_dcm: any

None( (placo.Support)arg1) -> object :

C++ signature :

Eigen::Matrix<double, 2, 1, 0, 2, 1> {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})

time_ratio: any

None( (placo.Support)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})

class placo.SwingFoot

A cubic fitting of swing foot, see: https://scaron.info/doc/pymanoid/walking-pattern-generation.html#pymanoid.swing_foot.SwingFoot.

static make_trajectory(self, t_start: float, t_end: float, height: float, start: ndarray, target: ndarray) → SwingFootTrajectory

static remake_trajectory(self, old_trajectory: SwingFootTrajectory, t: float, target: ndarray) → SwingFootTrajectory

class placo.SwingFootCubic

static make_trajectory(self, t_start: float, virt_duration: float, height: float, rise_ratio: float, start: ndarray, target: ndarray, elapsed_ratio: float = 0.0, start_vel: ndarray = None) → SwingFootCubicTrajectory

class placo.SwingFootCubicTrajectory

pos(t: float) → ndarray

vel(t: float) → ndarray

class placo.SwingFootQuintic

static make_trajectory(self, t_start: float, t_end: float, height: float, start: ndarray, target: ndarray) → SwingFootQuinticTrajectory

class placo.SwingFootQuinticTrajectory

pos(t: float) → ndarray

vel(t: float) → ndarray

class placo.SwingFootTrajectory

pos(t: float) → ndarray

vel(t: float) → ndarray

class placo.WPGTrajectory(arg2: float, arg3: float, arg4: float, arg5: float)

apply_transform(T: ndarray) → None

Applies a given transformation to the left of all values issued by the trajectory.

com_target_z: any

None( (placo.WPGTrajectory)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})

get_R_world_trunk(t: float) → ndarray

get_T_world_left(t: float) → ndarray

get_T_world_right(t: float) → ndarray

get_a_world_CoM(t: float) → ndarray

get_j_world_CoM(t: float) → ndarray

get_next_support(t: float, n: int = 1) → Support

Returns the nth next support corresponding to the given time in the trajectory. If n is greater than the number of remaining supports, the last support is returned.

get_p_support_CoM(t: float) → ndarray

get_p_support_DCM(t: float, omega: float) → ndarray

get_p_world_CoM(t: float) → ndarray

get_p_world_DCM(t: float, omega: float) → ndarray

get_p_world_ZMP(t: float, omega: float) → ndarray

get_part_end_dcm(t: float, omega: float) → ndarray

Returns the DCM at the end of the trajectory part corresponding to the given time.

get_part_t_end(t: float) → float

Returns the end time of the trajectory part corresponding to the given time.

get_part_t_start(t: float) → float

Returns the start time of the trajectory part corresponding to the given time.

get_prev_support(t: float, n: int = 1) → Support

Returns the nth previous support corresponding to the given time in the trajectory. If n is greater than the number of previous supports, the first support is returned.

get_support(t: float) → Support

Returns the support corresponding to the given time in the trajectory.

get_supports() → list[Support]

get_v_support_CoM(t: float) → ndarray

get_v_world_CoM(t: float) → ndarray

get_v_world_foot(side: any, t: float) → ndarray

get_v_world_right(t: float) → ndarray

parts: any

None( (placo.WPGTrajectory)arg1) -> object :

C++ signature :

std::vector<placo::humanoid::WalkPatternGenerator::TrajectoryPart, std::allocator<placo::humanoid::WalkPatternGenerator::TrajectoryPart> > {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})

print_parts_timings() → None

replan_success: any

None( (placo.WPGTrajectory)arg1) -> bool :

C++ signature :

bool {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})

support_is_both(t: float) → bool

support_side(t: float) → any

t_end: any

None( (placo.WPGTrajectory)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})

t_start: any

None( (placo.WPGTrajectory)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})

trunk_pitch: any

None( (placo.WPGTrajectory)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})

trunk_roll: any

None( (placo.WPGTrajectory)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})

class placo.WPGTrajectoryPart(arg2: Support, arg3: float)

support: any

None( (placo.WPGTrajectoryPart)arg1) -> placo.Support :

C++ signature :

placo::humanoid::FootstepsPlanner::Support {lvalue} None(placo::humanoid::WalkPatternGenerator::TrajectoryPart {lvalue})

t_end: any

None( (placo.WPGTrajectoryPart)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::WalkPatternGenerator::TrajectoryPart {lvalue})

t_start: any

None( (placo.WPGTrajectoryPart)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::WalkPatternGenerator::TrajectoryPart {lvalue})

class placo.WalkPatternGenerator(robot: HumanoidRobot, parameters: HumanoidParameters)

can_replan_supports(trajectory: WPGTrajectory, t_replan: float) → bool

Checks if a trajectory can be replanned for supports.

get_optimal_zmp(world_dcm_start: ndarray, world_dcm_end: ndarray, duration: float, support: Support) → ndarray

Computes the best ZMP in the support polygon to move de DCM from world_dcm_start to world_dcm_end in duration.

Parameters:

• world_dcm_start (numpy.ndarray) – Initial DCM position in world frame

• world_dcm_end (numpy.ndarray) – Desired final DCM position in world frame

• duration (float) – Duration

• support (Support) – Support

plan(supports: list[Support], initial_com_world: ndarray, t_start: float = 0.0) → WPGTrajectory

Plans a walk trajectory following given footsteps based on the parameters of the WPG.

Parameters:

supports (list[Support]) – Supports generated from the foosteps to follow

replan(supports: list[Support], old_trajectory: WPGTrajectory, t_replan: float) → WPGTrajectory

Updates the walk trajectory to follow given footsteps based on the parameters of the WPG.

Parameters:

• supports (list[Support]) – Supports generated from the current foosteps or the new ones to follow. Contain the current support

• old_trajectory (WPGTrajectory) – Current walk trajectory

• t_replan (float) – The time (in the original trajectory) where the replan happens

replan_supports(planner: FootstepsPlanner, trajectory: WPGTrajectory, t_replan: float, t_last_replan: float) → list[Support]

Replans the supports for a given trajectory given a footsteps planner.

soft: any

None( (placo.WalkPatternGenerator)arg1) -> bool :

C++ signature :

bool {lvalue} None(placo::humanoid::WalkPatternGenerator {lvalue})

stop_end_support_weight: any

None( (placo.WalkPatternGenerator)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::WalkPatternGenerator {lvalue})

support_default_duration(support: Support) → float

support_default_timesteps(support: Support) → int

update_supports(t: float, supports: list[Support], world_measured_dcm: ndarray) → list[Support]

Updates the supports to ensure DCM viability by adjusting the duration and the target of the current swing trajectory.

Parameters:

• t (float) – Current time

• supports (list[Support]) – Planned supports

• world_measured_dcm (numpy.ndarray) – Measured DCM in world frame

zmp_in_support_weight: any

None( (placo.WalkPatternGenerator)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::WalkPatternGenerator {lvalue})

class placo.WalkTasks

com_task: any

None( (placo.WalkTasks)arg1) -> placo.CoMTask :

C++ signature :

placo::kinematics::CoMTask {lvalue} None(placo::humanoid::WalkTasks {lvalue})

com_x: any

None( (placo.WalkTasks)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::WalkTasks {lvalue})

com_y: any

None( (placo.WalkTasks)arg1) -> float :

C++ signature :

double {lvalue} None(placo::humanoid::WalkTasks {lvalue})

get_tasks_error() → dict[str, ndarray]

initialize_tasks(solver: KinematicsSolver, robot: HumanoidRobot) → None

left_foot_task: any

None( (placo.WalkTasks)arg1) -> placo.FrameTask :

C++ signature :

placo::kinematics::FrameTask {lvalue} None(placo::humanoid::WalkTasks {lvalue})

reach_initial_pose(T_world_left: ndarray, feet_spacing: float, com_height: float, trunk_pitch: float) → None

remove_tasks() → None

right_foot_task: any

None( (placo.WalkTasks)arg1) -> placo.FrameTask :

C++ signature :

placo::kinematics::FrameTask {lvalue} None(placo::humanoid::WalkTasks {lvalue})

scaled: any

None( (placo.WalkTasks)arg1) -> bool :

C++ signature :

bool {lvalue} None(placo::humanoid::WalkTasks {lvalue})

solver: any

None( (placo.WalkTasks)arg1) -> placo.KinematicsSolver :

C++ signature :

placo::kinematics::KinematicsSolver None(placo::humanoid::WalkTasks {lvalue})

trunk_mode: any

None( (placo.WalkTasks)arg1) -> bool :

C++ signature :

bool {lvalue} None(placo::humanoid::WalkTasks {lvalue})

trunk_orientation_task: any

None( (placo.WalkTasks)arg1) -> placo.OrientationTask :

C++ signature :

placo::kinematics::OrientationTask {lvalue} None(placo::humanoid::WalkTasks {lvalue})

trunk_task: any

None( (placo.WalkTasks)arg1) -> placo.PositionTask :

C++ signature :

placo::kinematics::PositionTask {lvalue} None(placo::humanoid::WalkTasks {lvalue})

update_tasks(trajectory: WPGTrajectory, t: float) → None

update_tasks_from_trajectory(arg2: WPGTrajectory, arg3: float) → None