Geometry

Two dimensional

type Vector2 = numpy.ndarray[tuple[Literal[2]], numpy.dtype[numpy.float64]]

A two dimensional numpy.ndarray of type ng_float_t.

type Vector2Like = Vector2 | tuple[float, float] | list[float]

An object convertible to Vector2.

Note

Any pybind11 function that accepts Vector2 does in fact accept the less restrictive type Vector2Like, which is difficult to encode exactly using the Python type system. For example, property navground.core.Pose2.position can be set to a tuple of two numbers without any issue:

>>> from navground import core
>>> pose = core.Pose2()
>>> pose.position = (1, 2)
array([1., 2.])

On the contrary, pybind11 functions documented to return Vector2 do return this type.

class Frame

__init__(value: int) → None

absolute = <Frame.absolute: 1>

property name

Type:

str

relative = <Frame.relative: 0>

property value

Type:

int

class Pose2

Two-dimensional pose composed of planar position and orientation. When not specified, poses are assumed to be in the world-fixed frame.

Poses are also associated to rigid transformations in SE(2) translation(pose.position) . rotation(pose.orientation). We define the group operations as a multiplication and add methods like transform_pose() for a pose to operate as a rigid transformation.

__init__(position: Vector2 = array([0., 0.], dtype=float32), orientation: float = 0) → None

absolute(reference: navground.core.Pose2) → navground.core.Pose2

Transform a relative pose to an absolute pose.

Equivalent to reference.transform_pose(self) = reference * self

Parameters:

reference – The reference pose

Returns:

The absolute pose

get_transformation_in_frame(frame: navground.core.Pose2) → navground.core.Pose2

Returns this transformation in the desired frame of reference.

The returned transformation is defined as frame.inverse() * self * frame, so that, for any frame f, the following expressions are equivalent:

• pose.transform(other).relative(f)

• pose.get_transformation_in_frame(frame).transform(other.relative(f ))

Parameters:

frame – A posed defining the desired frame of reference for the transformation.

Returns:

The transformation with respect to frame

integrate(twist: navground.core.Twist2, time_step: float) → navground.core.Pose2

Rotate the pose by an angle.

Parameters:

angle – The rotation angle in radians.

Returns:

The rotated pose.

inverse() → navground.core.Pose2

Invert a transformation, i.e., SE(2) inversion

Returns:

The inverse transformation

relative(reference: navground.core.Pose2) → navground.core.Pose2

Transform an absolute pose to a relative pose.

Equivalent to reference.inverse().transform_pose(self) = reference.inverse() * self

Parameters:

reference – The reference pose

Returns:

The relative pose

rotate(angle: float) → navground.core.Pose2

Rotate the pose by an angle.

Parameters:

angle – The rotation angle in radians.

Returns:

The rotated pose.

transform_point(point: Vector2) → Vector2

Applies this rigid transformation to a point

Equivalent to to_absolute_point(point, self)

Parameters:

point – The point to transform

Returns:

The roto-translated point

transform_pose(pose: navground.core.Pose2) → navground.core.Pose2

Applies this rigid transformation to another pose

Equivalent to pose.absolute(self)

Parameters:

pose – The pose to transform

Returns:

self * pose

transform_vector(vector: Vector2) → Vector2

Applies the rigid transformation to a vector

Equivalent to to_absolute(vector, self)

Parameters:

vector – The vector to transform

Returns:

The rotated vector

property orientation

Type:

float

Orientation in world frame

property position

Type:

Vector2

Position in world frame

class Twist2

Two-dimensional twist composed of planar velocity and angular speed.

Twist coordinates are in the frame specified by frame.

__init__(velocity: Vector2 = array([0., 0.], dtype=float32), angular_speed: float = 0, frame: navground.core.Frame = navground.core.Frame.absolute) → None

absolute(reference: navground.core.Pose2) → navground.core.Twist2

Transform a twist to Frame.absolute().

Parameters:

reference – The pose of reference of this relative twist

Returns:

The same twist in Frame.absolute() (unchanged if already in Frame.absolute())

interpolate(target: navground.core.Twist2, time_step: float, max_acceleration: float, max_angular_acceleration: float) → navground.core.Twist2

is_almost_zero(epsilon_speed: float = 1e-06, epsilon_angular_speed: float = 1e-06) → bool

Determines if almost zero.

Parameters:

• epsilon_speed – The epsilon speed

• epsilon_angular_speed – The epsilon angular speed

Returns:

True if almost zero, False otherwise.

relative(reference: navground.core.Pose2) → navground.core.Twist2

Transform a twist to Frame.relative() relative to a pose.

Parameters:

reference – The desired pose of reference

Returns:

The same twist in Frame.relative() (unchanged if already in Frame.relative())

rotate(angle: float) → navground.core.Twist2

Rotate the twist by an angle.

Parameters:

angle – The rotation angle in radians.

Returns:

The rotated twist.

snap_to_zero(epsilon: float = 1e-06) → None

Snap components to zero if their module is smaller than epsilon.

Parameters:

epsilon – The tolerance

property angular_speed

Type:

float

Angular speed

property frame

Type:

navground.core.Frame

Frame of reference.

property velocity

Type:

Vector2

Velocity

orientation_of(vector: Vector2) → float

The orientation of a two dimensional vector

Parameters:

vector – The vector

Returns:

The orientation of the vector

normalize_angle(angle: float) → float

Normalize an angle to a value in \([-\pi, \pi]\). Apply it when computing angular differences.

Parameters:

value – The original unbounded angle

Returns:

The equivalent angle in \([-\pi, \pi]\)

to_relative(value: Vector2, reference: navground.core.Pose2) → Vector2

Transform an absolute to a relative vector.

Equivalent to reference.inverse().transform_vector(value)

Parameters:

• value – The absolute vector

• reference – The reference pose

Returns:

The absolute vector

to_absolute(value: Vector2, reference: navground.core.Pose2) → Vector2

Transform a relative to an absolute vector.

Equivalent to reference.transform_vector(value)

Parameters:

• value – The relative vector

• reference – The reference pose

Returns:

The relative vector

to_relative_point(value: Vector2, reference: navground.core.Pose2) → Vector2

Transform an absolute to a relative vector.

Equivalent to reference.inverse().transform_point(value)

Parameters:

• value – The absolute vector

• reference – The reference pose

Returns:

The absolute point

to_absolute_point(value: Vector2, reference: navground.core.Pose2) → Vector2

Transform a relative to an absolute point.

Equivalent to reference.transform_point(value)

Parameters:

• value – The relative point

• reference – The reference pose

Returns:

The relative point

unit(angle: float) → Vector2

Unit vector with a desired orientated.

Parameters:

angle – The desired orientation

Returns:

Vector of norm one and desired orientation

rotate(vector: Vector2, angle: float) → Vector2

Rotate a two-dimensional vector.

Parameters:

• vector – The original vector

• angle – The rotation angle in radians

Returns:

The rotated vector

clamp_norm(vector: Vector2, max_length: float) → Vector2

Clamp the norm of a vector

Parameters:

• vector – The original vector

• max_length – The maximum length

Returns:

A vector with the original orientation but norm clamped to max_length.