placo::kinematics

class placo.AvoidSelfCollisionsKinematicsConstraint

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

self_collisions_margin: any

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

C++ signature :

double {lvalue} None(placo::kinematics::AvoidSelfCollisionsConstraint {lvalue})

self_collisions_trigger: any

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

C++ signature :

double {lvalue} None(placo::kinematics::AvoidSelfCollisionsConstraint {lvalue})

class placo.AxisAlignTask(frame_index: any, axis_frame: ndarray, targetAxis_world: ndarray)

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

axis_frame: any

None( (placo.AxisAlignTask)arg1) -> numpy.ndarray :

C++ signature :

Eigen::Matrix<double, 3, 1, 0, 3, 1> None(placo::kinematics::AxisAlignTask)

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

frame_index: any

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

C++ signature :

unsigned long {lvalue} None(placo::kinematics::AxisAlignTask {lvalue})

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

targetAxis_world: any

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

C++ signature :

Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::kinematics::AxisAlignTask {lvalue})

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.CentroidalMomentumTask(L_world: ndarray)

See KinematicsSolver::add_centroidal_momentum_task.

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

L_world: any

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

C++ signature :

Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::kinematics::CentroidalMomentumTask {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

mask: any

None( (placo.CentroidalMomentumTask)arg1) -> placo.AxisesMask :

C++ signature :

placo::tools::AxisesMask {lvalue} None(placo::kinematics::CentroidalMomentumTask {lvalue})

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.CoMPolygonConstraint(polygon: list[ndarray], margin: float = 0.0)

Ensures that the CoM (2D) lies inside the given polygon.

Parameters:

polygon (list[numpy.ndarray]) – Clockwise polygon

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

dcm: any

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

C++ signature :

bool {lvalue} None(placo::kinematics::CoMPolygonConstraint {lvalue})

margin: any

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

C++ signature :

double {lvalue} None(placo::kinematics::CoMPolygonConstraint {lvalue})

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

omega: any

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

C++ signature :

double {lvalue} None(placo::kinematics::CoMPolygonConstraint {lvalue})

polygon: any

None( (placo.CoMPolygonConstraint)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::kinematics::CoMPolygonConstraint {lvalue})

priority: str

Priority [str]

class placo.CoMTask(target_world: ndarray)

See KinematicsSolver::add_com_task.

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

mask: any

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

C++ signature :

placo::tools::AxisesMask {lvalue} None(placo::kinematics::CoMTask {lvalue})

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

target_world: any

None( (placo.CoMTask)arg1) -> numpy.ndarray :

C++ signature :

Eigen::Matrix<double, 3, 1, 0, 3, 1> None(placo::kinematics::CoMTask)

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.ConeConstraint(frame_a: any, frame_b: any, angle_max: float)

With a cone constraint, the z-axis of frame a and frame b should remaine within a cone of angle angle_max.

N: any

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

C++ signature :

int {lvalue} None(placo::kinematics::ConeConstraint {lvalue})

angle_max: any

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

C++ signature :

double {lvalue} None(placo::kinematics::ConeConstraint {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

range: any

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

C++ signature :

double {lvalue} None(placo::kinematics::ConeConstraint {lvalue})

class placo.DistanceConstraint(frame_a: any, frame_b: any, distance_max: float)

Constraints the distance betweek two points in the robot.

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

distance_max: any

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

C++ signature :

double {lvalue} None(placo::kinematics::DistanceConstraint {lvalue})

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

class placo.DistanceTask(frame_a: any, frame_b: any, distance: float)

see KinematicsSolver::add_distance_task

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

distance: any

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

C++ signature :

double {lvalue} None(placo::kinematics::DistanceTask {lvalue})

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

frame_a: any

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

C++ signature :

unsigned long {lvalue} None(placo::kinematics::DistanceTask {lvalue})

frame_b: any

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

C++ signature :

unsigned long {lvalue} None(placo::kinematics::DistanceTask {lvalue})

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.FrameTask

see KinematicsSolver::add_frame_task

T_world_frame: any

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

C++ signature :

Eigen::Transform<double, 3, 2, 0> None(placo::kinematics::FrameTask {lvalue})

configure(name: str, priority: str = 'soft', position_weight: float = 1.0, orientation_weight: float = 1.0) → None

Configures the frame task.

Parameters:

• name (str) – task name

• priority (str) – task priority

• position_weight (float) – weight for the position task

• orientation_weight (float) – weight for the orientation task

orientation() → OrientationTask

position() → PositionTask

class placo.GearTask

see KinematicsSolver::add_gear_task

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

add_gear(target: str, source: str, ratio: float) → None

Adds a gear constraint, you can add multiple source for the same target, they will be summed.

Parameters:

• target (str) – target joint

• source (str) – source joint

• ratio (float) – ratio

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

set_gear(target: str, source: str, ratio: float) → None

Sets a gear constraint.

Parameters:

• target (str) – target joint

• source (str) – source joint

• ratio (float) – ratio

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.JointSpaceHalfSpacesConstraint(A: ndarray, b: ndarray)

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.

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::JointSpaceHalfSpacesConstraint {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::kinematics::JointSpaceHalfSpacesConstraint {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

class placo.JointsTask

see KinematicsSolver::add_joints_task

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

get_joint(joint: str) → float

Returns the target value of a joint.

Parameters:

joint (str) – joint

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

set_joint(joint: str, target: float) → None

Sets a joint target.

Parameters:

• joint (str) – joint

• target (float) – target value

set_joints(arg2: dict) → None

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.KinematicsConstraint

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

class placo.KinematicsSolver(robot_: RobotWrapper)

N: any

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

C++ signature :

int {lvalue} None(placo::kinematics::KinematicsSolver {lvalue})

add_avoid_self_collisions_constraint() → AvoidSelfCollisionsKinematicsConstraint

Adds a self collision avoidance constraint.

add_axisalign_task(frame: any, axis_frame: ndarray, targetAxis_world: ndarray) → AxisAlignTask

Adds an axis alignment task. The goal here is to keep the given axis (expressed in the given frame) aligned with another one (given in the world)

Parameters:

• frame (any) – the robot frame we want to control

• axis_frame (numpy.ndarray) – the axis to align, expressed in the robot frame

• targetAxis_world (numpy.ndarray) – the target axis (in the world) we want to be aligned with

add_centroidal_momentum_task(L_world: ndarray) → CentroidalMomentumTask

Adding a centroidal momentum task.

Parameters:

L_world (numpy.ndarray) – desired centroidal angular momentum in the world

add_com_polygon_constraint(polygon: list[ndarray], margin: float = 0.0) → CoMPolygonConstraint

Adds a CoM polygon constraint.

Parameters:

• polygon (list[numpy.ndarray]) – clockwise polygon

• margin (float) – margin

add_com_task(targetCom_world: ndarray) → CoMTask

Adds a com position task.

Parameters:

targetCom_world (numpy.ndarray) – the target position, expressed in the world (as T_world_frame)

add_cone_constraint(frame_a: str, frame_b: str, alpha_max: float) → ConeConstraint

Adds a Cone constraint.

Parameters:

• frame_a (str) – frame A

• frame_b (str) – frame B

• alpha_max (float) – alpha max (in radians) between the frame z-axis and the cone frame zt-axis

add_constraint(constraint: KinematicsConstraint) → None

Adds a custom constraint to the solver.

add_distance_constraint(frame_a: str, frame_b: str, distance_max: float) → DistanceConstraint

Adds a distance constraint.

Parameters:

• frame_a (str) – frame A

• frame_b (str) – frame B

• distance_max (float) – maximum distance between the two frames

add_distance_task(frame_a: str, frame_b: str, distance: float) → DistanceTask

Adds a distance task to be maintained between two frames.

Parameters:

• frame_a (str) – frame a

• frame_b (str) – frame b

• distance (float) – distance to maintain

add_frame_task(frame: str, T_world_frame: ndarray = None) → FrameTask

Adds a frame task, this is equivalent to a position + orientation task, resulting in decoupled tasks for a given frame.

Parameters:

• frame (str) – the robot frame we want to control

• T_world_frame (numpy.ndarray) – the target for the frame we want to control, expressed in the world (as T_world_frame)

add_gear_task() → GearTask

Adds a gear task, allowing replication of joints.

add_joint_space_half_spaces_constraint(A: ndarray, b: ndarray) → JointSpaceHalfSpacesConstraint

Adds a joint-space half-spaces constraint, such that Aq <= b.

Parameters:

• A (numpy.ndarray) – matrix A in Aq <= b

• b (numpy.ndarray) – vector b in Aq <= b

add_joints_task() → JointsTask

Adds joints task.

add_kinetic_energy_regularization_task(magnitude: float = 1e-06) → KineticEnergyRegularizationTask

Adds a kinetic energy regularization task for a given magnitude.

Parameters:

magnitude (float) – regularization magnitude

add_manipulability_task(frame: any, type: any, lambda_: float = 1.0) → ManipulabilityTask

Adds a manipulability regularization task for a given magnitude.

add_orientation_task(frame: str, R_world_frame: ndarray) → OrientationTask

Adds an orientation task.

Parameters:

• frame (str) – the robot frame we want to control

• R_world_frame (numpy.ndarray) – the target orientation we want to achieve, expressed in the world (as T_world_frame)

add_position_task(frame: str, target_world: ndarray) → PositionTask

Adds a position task.

Parameters:

• frame (str) – the robot frame we want to control

• target_world (numpy.ndarray) – the target position, expressed in the world (as T_world_frame)

add_regularization_task(magnitude: float = 1e-06) → RegularizationTask

Adds a regularization task for a given magnitude.

Parameters:

magnitude (float) – regularization magnitude

add_relative_frame_task(frame_a: str, frame_b: str, T_a_b: ndarray) → RelativeFrameTask

Adds a relative frame task.

Parameters:

• frame_a (str) – frame a

• frame_b (str) – frame b

• T_a_b (numpy.ndarray) – desired transformation

add_relative_orientation_task(frame_a: str, frame_b: str, R_a_b: ndarray) → RelativeOrientationTask

Adds a relative orientation task.

Parameters:

• frame_a (str) – frame a

• frame_b (str) – frame b

• R_a_b (numpy.ndarray) – the desired orientation

add_relative_position_task(frame_a: str, frame_b: str, target: ndarray) → RelativePositionTask

Adds a relative position task.

Parameters:

• frame_a (str) – frame a

• frame_b (str) – frame b

• target (numpy.ndarray) – the target vector between frame a and b (expressed in world)

add_task(task: Task) → None

Adds a custom task to the solver.

add_wheel_task(joint: str, radius: float, omniwheel: bool = False) → WheelTask

Adds a wheel task.

Parameters:

• joint (str) – joint name

• radius (float) – wheel radius

• omniwheel (bool) – true if it’s an omniwheel (can slide laterally)

add_yaw_constraint(frame_a: str, frame_b: str, alpha_max: float) → YawConstraint

Adds a yaw constraint.

Parameters:

• frame_a (str) – frame A

• frame_b (str) – frame B

• alpha_max (float) – angle max for yaw of x-axis in frame b in a

clear() → None

Clears the internal tasks.

dt: any

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

C++ signature :

double {lvalue} None(placo::kinematics::KinematicsSolver {lvalue})

dump_status() → None

Shows the tasks status.

enable_joint_limits(enable: bool) → None

Enables/disables joint limits inequalities.

enable_velocity_limits(enable: bool) → None

Enables/disables joint velocity inequalities.

mask_dof(dof: str) → None

Masks (disables a DoF) from being used by the QP solver (it can’t provide speed)

Parameters:

dof (str) – the dof name

mask_fbase(masked: bool) → None

Decides if the floating base should be masked.

problem: any

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

C++ signature :

placo::problem::Problem {lvalue} None(placo::kinematics::KinematicsSolver {lvalue})

remove_constraint(constraint: KinematicsConstraint) → None

Removes aconstraint from the solver.

Parameters:

constraint (KinematicsConstraint) – constraint

remove_task(task: Task) → None

Removes a task from the solver.

Parameters:

task (Task) – task

robot: any

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

C++ signature :

placo::model::RobotWrapper None(placo::kinematics::KinematicsSolver)

scale: any

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

C++ signature :

double {lvalue} None(placo::kinematics::KinematicsSolver {lvalue})

solve(apply: bool = False) → ndarray

Constructs the QP problem and solves it.

Parameters:

apply (bool) – apply the solution to the robot model

tasks_count() → int

Number of tasks.

unmask_dof(dof: str) → None

Unmsks (enables a DoF) from being used by the QP solver (it can provide speed)

Parameters:

dof (str) – the dof name

class placo.KineticEnergyRegularizationTask

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.ManipulabilityTask(frame_index: any, type: any, lambda_: float = 1.0)

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

lambda_: any

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

C++ signature :

double {lvalue} None(placo::kinematics::ManipulabilityTask {lvalue})

manipulability: any

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

C++ signature :

double {lvalue} None(placo::kinematics::ManipulabilityTask {lvalue})

minimize: any

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

C++ signature :

bool {lvalue} None(placo::kinematics::ManipulabilityTask {lvalue})

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.OrientationTask(frame_index: any, R_world_frame: ndarray)

See KinematicsSolver::add_orientation_task.

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

R_world_frame: any

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

C++ signature :

Eigen::Matrix<double, 3, 3, 0, 3, 3> {lvalue} None(placo::kinematics::OrientationTask {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

frame_index: any

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

C++ signature :

unsigned long {lvalue} None(placo::kinematics::OrientationTask {lvalue})

mask: any

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

C++ signature :

placo::tools::AxisesMask {lvalue} None(placo::kinematics::OrientationTask {lvalue})

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.PositionTask(frame_index: any, target_world: ndarray)

See KinematicsSolver::add_position_task.

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

frame_index: any

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

C++ signature :

unsigned long {lvalue} None(placo::kinematics::PositionTask {lvalue})

mask: any

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

C++ signature :

placo::tools::AxisesMask {lvalue} None(placo::kinematics::PositionTask {lvalue})

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

target_world: any

None( (placo.PositionTask)arg1) -> numpy.ndarray :

C++ signature :

Eigen::Matrix<double, 3, 1, 0, 3, 1> None(placo::kinematics::PositionTask)

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.RegularizationTask

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.RelativeFrameTask(position: RelativePositionTask, orientation: RelativeOrientationTask)

see KinematicsSolver::add_relative_frame_task

T_a_b: any

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

C++ signature :

Eigen::Transform<double, 3, 2, 0> None(placo::kinematics::RelativeFrameTask {lvalue})

configure(name: str, priority: str = 'soft', position_weight: float = 1.0, orientation_weight: float = 1.0) → None

Configures the relative frame task.

Parameters:

• name (str) – task name

• priority (str) – task priority

• position_weight (float) – weight for the position task

• orientation_weight (float) – weight for the orientation task

orientation() → RelativeOrientationTask

position() → RelativePositionTask

class placo.RelativeOrientationTask(frame_a: any, frame_b: any, R_a_b: ndarray)

See KinematicsSolver::add_relative_orientation_task.

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

R_a_b: any

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

C++ signature :

Eigen::Matrix<double, 3, 3, 0, 3, 3> {lvalue} None(placo::kinematics::RelativeOrientationTask {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

frame_a: any

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

C++ signature :

unsigned long {lvalue} None(placo::kinematics::RelativeOrientationTask {lvalue})

frame_b: any

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

C++ signature :

unsigned long {lvalue} None(placo::kinematics::RelativeOrientationTask {lvalue})

mask: any

None( (placo.RelativeOrientationTask)arg1) -> placo.AxisesMask :

C++ signature :

placo::tools::AxisesMask {lvalue} None(placo::kinematics::RelativeOrientationTask {lvalue})

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.RelativePositionTask(frame_a: any, frame_b: any, target: ndarray)

See KinematicsSolver::add_relative_position_task.

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

frame_a: any

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

C++ signature :

unsigned long {lvalue} None(placo::kinematics::RelativePositionTask {lvalue})

frame_b: any

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

C++ signature :

unsigned long {lvalue} None(placo::kinematics::RelativePositionTask {lvalue})

mask: any

None( (placo.RelativePositionTask)arg1) -> placo.AxisesMask :

C++ signature :

placo::tools::AxisesMask {lvalue} None(placo::kinematics::RelativePositionTask {lvalue})

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

target: any

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

C++ signature :

Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::kinematics::RelativePositionTask {lvalue})

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.Task

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.WheelTask(joint: str, radius: float, omniwheel: bool = False)

See KinematicsSolver::add_wheel_task.

A: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

T_world_surface: any

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

C++ signature :

Eigen::Transform<double, 3, 2, 0> {lvalue} None(placo::kinematics::WheelTask {lvalue})

b: any

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

C++ signature :

Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

error() → ndarray

Task errors (vector)

error_norm() → float

The task error norm.

joint: any

None( (placo.WheelTask)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::kinematics::WheelTask {lvalue})

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

omniwheel: any

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

C++ signature :

bool {lvalue} None(placo::kinematics::WheelTask {lvalue})

priority: str

Priority [str]

radius: any

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

C++ signature :

double {lvalue} None(placo::kinematics::WheelTask {lvalue})

update() → None

Update the task A and b matrices from the robot state and targets.

class placo.YawConstraint(frame_a: any, frame_b: any, angle_max: float)

Constrains the yaw of frame b in frame a, such that the x-axis of frame b should remain with +- angle_max.

angle_max: any

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

C++ signature :

double {lvalue} None(placo::kinematics::YawConstraint {lvalue})

configure(name: str, priority: str = 'soft', weight: float = 1.0) → None

Configures the object.

Parameters:

• name (str) – task name

• priority (str) – task priority (hard, soft or scaled)

• weight (float) – task weight

name: any

None( (placo.Prioritized)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})

priority: str

Priority [str]