Target

type Curve = Callable[[float], Vector2, float, float]]

The parametrization of a (G2) curve by length.

The function returns position, tangential orientation and curvature at a coordinate, like:

def curve(coordinate: float) -> tuple[Vector2, float, float]]:
   ...
   return (position, orientation, curvature)

type Projection = Callable[[Vector2, float, float], float]

The projection of a curve parametrized by length.

The function finds the coordinate in [begin, end] where curve(coordinate) is nearest to the given point point, like:

def projection(point: Vector2, begin: float, end: float) -> float:
   ...
   return coordinate

class Path

A generic, twice differentiable, curve (to follow), parametrized by length.

__init__(project: Projection, curve: Curve, length: float, loop: bool = False) → None

Constructs a new instance.

Parameters:

• projection – The projection

• curve_fn – The parametrized curve

• length – The curve length

• loop – Whether the path is an infinite loop

get_point(position: Vector2, look_ahead: float = 0) → tuple[Vector2, float, float]

Returns the point the point corresponding the track() coordinate.

Parameters:

• position – The position

• look_ahead – The look ahead distance

Returns:

The point.

track(position: Vector2, look_ahead: float = 0) → float

Returns the coordinate ahead of a position

It projects the point to the curve using project, updates coordinate with this value. It returns the value advanced by the look- ahead distance.

Parameters:

• position – The position

• look_ahead – The look ahead distance

Returns:

The coordinate.

property coordinate

Type:

float

The current coordinate during tracking. A negative value means undefined.

property curve

Type:

Curve

The parametrized curve

property length

Type:

float

The curve length

property loop

Type:

bool

Whether the path is an infinite loop

property project

Type:

Projection

The projection

class Target

Represents the union of all targets supported by a generic Behavior

• poses

• positions

• orientations

• directions

• velocities

• twists

• paths to be followed to reach a position

static Direction(direction: Vector2) → navground.core.Target

Constructs a target to follow a direction.

Parameters:

direction – The direction

Returns:

The target

static Orientation(orientation: float, tolerance: float = 0) → navground.core.Target

Constructs a target to reach an orietation.

Parameters:

• orientation – The orientation

• tolerance – The tolerance

Returns:

The target

static Point(point: Vector2, tolerance: float = 0, along_path: navground.core.Path | None = None) → navground.core.Target

Constructs a target to reach a point.

Parameters:

• position – The target position

• tolerance – The tolerance

• along_path – The path to follow

Returns:

The target

static Pose(pose: navground.core.Pose2, position_tolerance: float = 0, orientation_tolerance: float = 0, along_path: navground.core.Path | None = None) → navground.core.Target

Constructs a target to reach a pose.

Parameters:

• pose – The pose

• position_tolerance – The position tolerance

• orientation_tolerance – The orientation tolerance

• along_path – The path to follow

Returns:

The target

static Stop() → navground.core.Target

Constructs a target to stop.

Returns:

The target

static Twist(twist: navground.core.Twist2) → navground.core.Target

Constructs a target to follow a twist.

Parameters:

twist – The twist

Returns:

The target

static Velocity(velocity: Vector2) → navground.core.Target

Constructs a target to follow a velocity.

Parameters:

velocity – The velocity

Returns:

The target

__init__(position: Vector2 | None = None, orientation: float | None = None, speed: float | None = None, direction: Vector2 | None = None, angular_speed: float | None = None, path: int | None = None, angular_direction: navground.core.Path | None = None, position_tolerance: float = 0, orientation_tolerance: float = 0) → None

Constructs a new instance.

Parameters:

• position – The position

• orientation – The orientation

• speed – The speed

• direction – The direction

• angular_speed – The angular speed

• angular_direction – The angular direction

• path – The path

• position_tolerance – The position tolerance

• orientation_tolerance – The orientation tolerance

satisfied(*args, **kwargs)

Overloaded function.

1. satisfied(point: Vector2) -> bool

Returns whether a given orientation satisfies the target.

The target is satisfied if it does not have an angular speed and if the given value is near to the target’s orientation.

Parameters:

angle – The orientation

Returns:

True if the target is satisfied.

2. satisfied(angle: float) -> bool

Returns whether a given position satisfies the target.

The target is satisfied if it does not have an linear speed and if the given value is near to the target’s position.

Parameters:

point – The position

Returns:

True if the target is satisfied.

3. satisfied(pose: navground.core.Pose2) -> bool

Returns whether a given pose satisfies the target.

The target is satisfied if the position and orientation are both satisfied.

Parameters:

pose – The pose

Returns:

True if the target is satisfied.

property angular_direction

Type:

Optional[int]

The angular direction

property angular_speed

Type:

Optional[float]

The angular speed

property direction

Type:

Optional[Vector2]

The direction

property orientation

Type:

Optional[float]

The orientation

property orientation_tolerance

Type:

float

The orientation tolerance

property path

Type:

Optional[navground.core.Path]

The path to follow.

property position

Type:

Optional[Vector2]

The position

property position_tolerance

Type:

float

The position tolerance

property speed

Type:

Optional[float]

The speed

property valid

Type:

bool

Verify that a target is set.

Returns:

True if the target is not empty.