placo::tools#

class placo.AxisesMask#
R_custom_world: any#

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

C++ signature :

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

R_local_world: any#

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

C++ signature :

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

apply(M: ndarray) → ndarray#

Apply the masking to a given matrix.

Parameters:

M (numpy.ndarray) – the matrix to be masked (3xn)

set_axises(axises: str, frame_: any) → None#

Sets the axises to be masked (kept), for example “xy”.

Parameters:

  • axises (str) – axises to be kept

  • frame (any) – the reference frame where the masking is done (task, local or custom)

class placo.CubicSpline(angular: bool = False)#
acc(x: float) → float#

Retrieve acceleration at a given time.

add_point(t: float, x: float, dx: float) → None#

Adds a point in the spline.

Parameters:

  • t (float) – time

  • x (float) – value

  • dx (float) – speed

clear() → None#

Clears the spline.

duration() → float#

Spline duration.

pos(t: float) → float#

Retrieve the position at a given time.

Parameters:

t (float) – time

vel(x: float) → float#

Retrieve velocity at a given time.

class placo.CubicSpline3D#
acc(t: float) → ndarray#

Returns the spline accleeration at time t.

Parameters:

t (float) – time

add_point(t: float, x: ndarray, dx: ndarray) → None#

Adds a point.

Parameters:

  • t (float) – time

  • x (numpy.ndarray) – value (3D vector)

  • dx (numpy.ndarray) – velocity (3D vector)

clear() → None#

Clears the spline.

duration() → float#

Spline duration.

pos(t: float) → ndarray#

Returns the spline value at time t.

Parameters:

t (float) – time

vel(t: float) → ndarray#

Returns the spline velocity at time t.

Parameters:

t (float) – time

class placo.Polynom(coefficients: ndarray)#
coefficients: any#

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

C++ signature :

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

static derivative_coefficient(self, degree: int, derivative: int) → int#

Computes the coefficient in front of term of degree degree after derivative differentiations.

Parameters:

  • degree (int) – degree

  • derivative (int) – number of differentiations

value(x: float, derivative: int = 0) → float#

Computes the value of polynom.

Parameters:

  • x (float) – abscissa

  • derivative (int) – differentiation order (0: p, 1: p’, 2: p’’ etc.)

class placo.Prioritized#
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.Segment#
end: any#

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

C++ signature :

Eigen::Matrix<double, 2, 1, 0, 2, 1> {lvalue} None(placo::tools::Segment {lvalue})

half_line_pass_through(s: Segment) → bool#

Checks if the half-line starting from the start of this segment and going through its end pass through another segment.

Parameters:

s (Segment) – The other segment.

intersects(s: 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.

Parameters:

s (Segment) – The other segment.

is_parallel(s: Segment, epsilon: float = 1e-05) → bool#

Checks if this segment is parallel to another one.

Parameters:

  • s (Segment) – The segment to check parallelism with.

  • epsilon (float) – The sinus of the error angle accepted for 2 segments to be considered parallel.

is_point_aligned(point: ndarray, epsilon: float = 1e-05) → bool#

Checks if a point is aligned with this segment by checking if the segment is parallel to the segment formed by the start of this segment and the point.

Parameters:

  • point (numpy.ndarray) – The point to check alignment with.

  • epsilon (float) – The sinus of the error angle accepted for 2 segments to be considered parallel.

is_point_in_segment(point: ndarray, epsilon: float = 1e-05) → bool#

Checks if a point is in the segment.

Parameters:

  • point (numpy.ndarray) – The point to check.

  • epsilon (float) – To account for floating point errors.

is_segment_aligned(s: Segment, epsilon: float = 1e-05) → bool#

Checks if this segment is aligned with another one.

Parameters:

  • s (Segment) – The segment to check alignment with.

  • epsilon (float) – To account for floating point errors.

line_pass_through(s: 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.

Parameters:

s (Segment) – The other segment.

lines_intersection(s: Segment) → ndarray#

Return the intersection between the guiding lines of this segment and another one.

Parameters:

s (Segment) – The other segment.

norm() → float#
start: any#

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

C++ signature :

Eigen::Matrix<double, 2, 1, 0, 2, 1> {lvalue} None(placo::tools::Segment {lvalue})