PathPlanner

https://pathplanner.dev/
Admin
PathPlanner is a motion profile generator for FRC robots, offering precise path creation with Bézier...
Tokens:262,138
Snippets:1,438
Trust Score:6.3
Update:10 months ago
Show doc for...
Tokens:
Raw
### Retrieving Path Start Poses

Source: https://pathplanner.dev/api/cpp/PathPlannerPath_8h_source

Provides methods to get the starting pose of a path. getStartingDifferentialPose returns the starting pose considering differential drive kinematics, while getStartingHolonomicPose returns an optional pose for holonomic drive systems.

```cpp
frc::Pose2d getStartingDifferentialPose();

std::optional<frc::Pose2d> getStartingHolonomicPose();

```

--------------------------------

### PathPlannerAuto Methods

Source: https://pathplanner.dev/api/java/index-all

Provides access to the starting pose of a PathPlannerAuto.

```APIDOC
## GET /pathplanner/auto/starting-pose

### Description
Gets the starting pose of this auto, relative to a blue alliance origin.

### Method
GET

### Endpoint
/pathplanner/auto/starting-pose

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **startingPose** (object) - The starting pose of the auto.

#### Response Example
```json
{
  "startingPose": {
    "x": 0.5,
    "y": 0.5,
    "heading": 0.0
  }
}
```
```

--------------------------------

### Get Ideal Starting State

Source: https://pathplanner.dev/api/java/com/pathplanner/lib/path/PathPlannerPath

Retrieves the ideal starting state for the path. This is useful for initializing the robot's pose and speeds to match the beginning of the planned path.

```java
public IdealStartingState getIdealStartingState()

```

--------------------------------

### Get Ideal Starting State C++

Source: https://pathplanner.dev/api/cpp/PathPlannerPath_8h_source

Returns the ideal starting state for the path, if defined. This can include initial velocity and heading.

```cpp
constexpr std::optional<IdealStartingState>& getIdealStartingState() const {
  return m_idealStartingState;
}
```

--------------------------------

### PathPlannerAuto: Get Starting Pose

Source: https://pathplanner.dev/api/cpp/PathPlannerAuto_8h_source

Retrieves the starting pose for an autonomous routine. This method returns the initial position and orientation of the robot when an autonomous routine begins. It returns a const reference to a frc::Pose2d object.

```cpp
pathplanner::PathPlannerAuto::getStartingPose
constexpr frc::Pose2d getStartingPose() const
```

--------------------------------

### getStartingPose()

Source: https://pathplanner.dev/api/cpp/classpathplanner_1_1PathPlannerAuto

Retrieves the starting pose of the auto, relative to the blue alliance origin.

```APIDOC
## getStartingPose()

### Description
Get the starting pose of this auto, relative to a blue alliance origin. If there are no paths in this auto, the starting pose will be (0, 0, 0).

### Method
GET

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **The blue alliance starting pose** (frc::Pose2d) - The starting pose of the auto relative to the blue alliance origin.

#### Response Example
None
```

--------------------------------

### Pathfinding: setStartPosition Method (C++)

Source: https://pathplanner.dev/api/cpp/Pathfinding_8h_source

Sets the starting position for the pathfinding algorithm. This method takes a constant reference to a frc::Translation2d object representing the start coordinates. It's essential for initializing path calculations.

```cpp
static inline void setStartPosition(
 const frc::Translation2d &startPosition) {
 pathfinder->setStartPosition(startPosition);
 }
```

--------------------------------

### PathPlannerAuto Constructor

Source: https://pathplanner.dev/api/cpp/classpathplanner_1_1PathPlannerAuto

Constructs a PathPlannerAuto object from a custom command and an optional starting pose.

```APIDOC
## PathPlannerAuto()

### Description
Create a PathPlannerAuto from a custom command.

### Method
CONSTRUCTOR

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### PathPlannerPath::getIdealStartingState

Source: https://pathplanner.dev/api/cpp/classpathplanner_1_1PathPlannerPath

Fetches the ideal starting state for this path, if one is defined. This is relevant for starting the path from a specific pose and velocity.

```APIDOC
## PathPlannerPath::getIdealStartingState

### Description
Get the ideal starting state of this path.

### Method
`constexpr const std::optional<IdealStartingState>& getIdealStartingState() const

### Returns
- `const std::optional<IdealStartingState>&` - The ideal starting state.
```

--------------------------------

### Get Starting Holonomic Pose

Source: https://pathplanner.dev/api/java/com/pathplanner/lib/path/PathPlannerPath

Gets the holonomic pose for the start point of this path.

```APIDOC
## Get Starting Holonomic Pose

### Description
Get the holonomic pose for the start point of this path. If the path does not have an ideal starting state, this will return an empty optional.

### Method
GET

### Endpoint
/api/path/getStartingHolonomicPose

### Parameters
None

### Request Example
```
GET /api/path/getStartingHolonomicPose
```

### Response
#### Success Response (200)
- **Pose2d** (Object) - The ideal starting pose if an ideal starting state is present, empty optional otherwise

#### Response Example
```json
{
  "translation": {"x": 0.0, "y": 0.0},
  "rotation": {"degrees": 0.0}
}
```

```

--------------------------------

### PathfindingCommand Methods

Source: https://pathplanner.dev/api/java/com/pathplanner/lib/commands/PathfindingCommand

This section details the core methods for managing the lifecycle and execution of the PathfindingCommand. `initialize` sets up the command, `execute` runs the pathfinding logic each tick, `isFinished` determines when the command should end, and `end` handles cleanup. The `warmupCommand` static method is available to pre-initialize the pathfinder.

```java
void initialize()
void execute()
boolean isFinished()
void end(boolean interrupted)
static Command warmupCommand()
```

--------------------------------

### IdealStartingState

Source: https://pathplanner.dev/api/python/pathplannerlib/path

Defines the ideal starting state for the robot at the beginning of a path, including initial velocity and rotation.

```APIDOC
## IdealStartingState

### Description
Describes the ideal starting state of the robot when starting a path.

### Arguments
- **velocity** (float) - The ideal starting velocity (M/S)
- **rotation** (Rotation2d) - The ideal starting rotation

### Signature
```python
class IdealStartingState: ...
```

### Methods
#### fromJson
```python
@staticmethod
def fromJson(json_dict: dict) -> IdealStartingState: ...
```
```

--------------------------------

### Get Starting Differential Pose

Source: https://pathplanner.dev/api/java/com/pathplanner/lib/path/PathPlannerPath

Gets the differential pose for the start point of this path.

```APIDOC
## Get Starting Differential Pose

### Description
Get the differential pose for the start point of this path.

### Method
GET

### Endpoint
/api/path/getStartingDifferentialPose

### Parameters
None

### Request Example
```
GET /api/path/getStartingDifferentialPose
```

### Response
#### Success Response (200)
- **Pose2d** (Object) - Pose at the path's starting point

#### Response Example
```json
{
  "translation": {"x": 0.0, "y": 0.0},
  "rotation": {"degrees": 0.0}
}
```

```

--------------------------------

### warmupCommand

Source: https://pathplanner.dev/api/java/com/pathplanner/lib/commands/FollowPathCommand

Creates a command to prepare for path following, including on-the-fly generation and replanning.

```APIDOC
## warmupCommand

### Description
Creates a command to warmup on-the-fly generation, replanning, and the path following command.

### Method
`warmupCommand()`

### Endpoint
N/A

### Parameters
None

### Request Body
None

### Request Example
N/A

### Response
#### Success Response (200)
*   **`Command`** - The path following warmup command.

#### Response Example
```json
{
  "warmupCommand": "Command Object"
}
```
```

--------------------------------

### FollowPathCommand Constructor

Source: https://pathplanner.dev/api/java/com/pathplanner/lib/commands/FollowPathCommand

Constructs a FollowPathCommand to guide the robot along a specified path.

```APIDOC
## FollowPathCommand Constructor

### Description
Constructs a base path following command.

### Method
`FollowPathCommand`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Constructor Signature
`public FollowPathCommand(PathPlannerPath path, Supplier<Pose2d> poseSupplier, Supplier<ChassisSpeeds> speedsSupplier, BiConsumer<ChassisSpeeds,DriveFeedforwards> output, PathFollowingController controller, RobotConfig robotConfig, BooleanSupplier shouldFlipPath, Subsystem... requirements)`

### Parameters Explained
*   **`path`** (PathPlannerPath) - The path to follow.
*   **`poseSupplier`** (Supplier<Pose2d>) - Function that supplies the current field-relative pose of the robot.
*   **`speedsSupplier`** (Supplier<ChassisSpeeds>) - Function that supplies the current robot-relative chassis speeds.
*   **`output`** (BiConsumer<ChassisSpeeds,DriveFeedforwards>) - Output function that accepts robot-relative ChassisSpeeds and feedforwards for each drive motor. If using swerve, these feedforwards will be in FL, FR, BL, BR order. If using a differential drive, they will be in L, R order. NOTE: These feedforwards are assuming unoptimized module states. When you optimize your module states, you will need to reverse the feedforwards for modules that have been flipped.
*   **`controller`** (PathFollowingController) - Path following controller that will be used to follow the path.
*   **`robotConfig`** (RobotConfig) - The robot configuration.
*   **`shouldFlipPath`** (BooleanSupplier) - Should the path be flipped to the other side of the field? This will maintain a global blue alliance origin.
*   **`requirements`** (Subsystem...) - Subsystems required by this command, usually just the drive subsystem.

### Request Example
```json
{
  "path": "...",
  "poseSupplier": "...",
  "speedsSupplier": "...",
  "output": "...",
  "controller": "...",
  "robotConfig": "...",
  "shouldFlipPath": true,
  "requirements": ["driveSubsystem"]
}
```

### Response
#### Success Response (200)
N/A (This is a constructor)

#### Response Example
N/A
```

--------------------------------

### Get Starting Differential Pose

Source: https://pathplanner.dev/api/java/com/pathplanner/lib/path/PathPlannerPath

Retrieves the differential pose for the starting point of the path.

```java
public Pose2d getStartingDifferentialPose()
Get the differential pose for the start point of this path. 

Returns:
    Pose at the path's starting point
```

--------------------------------

### Constructor Documentation

Source: https://pathplanner.dev/api/cpp/classpathplanner_1_1PointTowardsZone

Detailed documentation for the constructors of the PointTowardsZone class.

```APIDOC
## Constructor Documentation

### PointTowardsZone() [1/2]
- **Signature**: `pathplanner::PointTowardsZone::PointTowardsZone(std::string _name, frc::Translation2d _targetPosition, frc::Rotation2d _rotationOffset, double _minWaypointRelativePos, double _maxWaypointRelativePos)`
- **Description**: Creates a new point towards zone.
- **Parameters**:
  - `name` (std::string) - The name of this zone. Used for point towards zone triggers.
  - `targetPosition` (frc::Translation2d) - The target field position in meters.
  - `rotationOffset` (frc::Rotation2d) - A rotation offset to add on top of the angle to the target position. For example, if you want the robot to point away from the target position, use a rotation offset of 180 degrees.
  - `minWaypointRelativePos` (double) - Starting position of the zone.
  - `maxWaypointRelativePos` (double) - End position of the zone.

### PointTowardsZone() [2/2]
- **Signature**: `pathplanner::PointTowardsZone::PointTowardsZone(std::string _name, frc::Translation2d _targetPosition, double _minWaypointRelativePos, double _maxWaypointRelativePos)`
- **Description**: Creates a new point towards zone.
- **Parameters**:
  - `name` (std::string) - The name of this zone. Used for point towards zone triggers.
  - `targetPosition` (frc::Translation2d) - The target field position in meters.
  - `minWaypointRelativePos` (double) - Starting position of the zone.
  - `maxWaypointRelativePos` (double) - End position of the zone.
```

--------------------------------

### Get Initial Heading

Source: https://pathplanner.dev/api/java/com/pathplanner/lib/path/PathPlannerPath

Gets the initial heading, or direction of travel, at the start of the path.

```APIDOC
## Get Initial Heading

### Description
Get the initial heading, or direction of travel, at the start of the path.

### Method
GET

### Endpoint
/api/path/getInitialHeading

### Parameters
None

### Request Example
```
GET /api/path/getInitialHeading
```

### Response
#### Success Response (200)
- **Rotation2d** (Object) - Initial heading

#### Response Example
```json
{
  "degrees": 0.0
}
```

```

--------------------------------

### PPLTVController Constructor with Q/R Elements

Source: https://pathplanner.dev/api/cpp/PPLTVController_8h_source

Constructs a PPLTVController with custom Q and R elements, time step, and maximum velocity. This allows for fine-tuning the controller's behavior.

```cpp
PPLTVController(const wpi::array<double, 3> &Qelems,
 const wpi::array<double, 2> &Relems, units::second_t dt,
 units::meters_per_second_t maxVelocity = 9_mps) : LTVUnicycleController(
 Qelems, Relems, dt, maxVelocity), m_lastError(0_m) {
 }
```

--------------------------------

### Get Starting Holonomic Pose

Source: https://pathplanner.dev/api/java/com/pathplanner/lib/path/PathPlannerPath

Retrieves the holonomic pose for the starting point of the path. Returns an empty optional if the path does not have an ideal starting state.

```java
public Optional<Pose2d> getStartingHolonomicPose()
Get the holonomic pose for the start point of this path. If the path does not have an ideal starting state, this will return an empty optional. 

Returns:
    The ideal starting pose if an ideal starting state is present, empty optional otherwise
```

--------------------------------

### FollowPathCommand Methods

Source: https://pathplanner.dev/api/python/pathplannerlib/commands

Provides essential methods for managing the execution of a path following command. The initialize method sets up the command, execute runs a single control loop iteration, isFinished checks if the path has been completed, and end handles cleanup when the command is interrupted or finished.

```python
def end(self, interrupted: bool): ...
```

```python
def execute(self): ...
```

```python
def initialize(self): ...
```

```python
def isFinished(self) -> bool: ...
```

--------------------------------

### Get Ideal Trajectory from PathPlannerPath

Source: https://pathplanner.dev/api/python/pathplannerlib/path

Attempts to retrieve an ideal trajectory for this path, which can be used if the robot is near the start and at the ideal starting state. Returns None if no ideal starting state exists or the trajectory hasn't been generated.

```python
from pathplannerlib.path import PathPlannerPath
from pathplannerlib.geometry import RobotConfig

# Assuming path is a PathPlannerPath object and robotConfig is defined
# ideal_trajectory = path.getIdealTrajectory(robotConfig)
```

--------------------------------

### Path Following Command Utilities

Source: https://pathplanner.dev/api/java/index-all

Provides static methods for creating and configuring path following commands.

```APIDOC
## CLASS com.pathplanner.lib.commands.FollowPathCommand

### Description
Command for following a generated path.

### Static Methods
#### `warmupCommand()`
* **Description**: Create a command to warmup on-the-fly generation, replanning, and the path following command.
* **Returns**: A warmup command.
```

```APIDOC
## CLASS com.pathplanner.lib.commands.PathfindingCommand

### Description
Command for pathfinding.

### Static Methods
#### `warmupCommand()`
* **Description**: Create a command to warmup the pathfinder and pathfinding command.
* **Returns**: A warmup command.
```

--------------------------------

### PathfindingCommand Overview

Source: https://pathplanner.dev/api/cpp/classpathplanner_1_1PathfindingCommand-members

This section details the PathfindingCommand class, including its constructors, methods, and inheritance.

```APIDOC
## PathfindingCommand API

### Description
Provides detailed information about the `PathfindingCommand` class within the `pathplanner` namespace, including its constructors and overridden methods.

### Method
N/A (Class Documentation)

### Endpoint
N/A (Class Documentation)

### Parameters
N/A (Class Documentation)

### Request Example
N/A (Class Documentation)

### Response
#### Class Members
- **End**(bool interrupted) override - Indicates if the command has finished.
- **Execute**() override - Executes a single period of the command.
- **Initialize**() override - Initializes the command.
- **IsFinished**() override - Returns true if the command should be scheduled off.
- **PathfindingCommand**(...) - Constructor for creating a PathfindingCommand with detailed path and controller configurations.
- **PathfindingCommand**(...) - Constructor for creating a PathfindingCommand with a target pose and simplified configurations.

#### Response Example
N/A (Class Documentation)
```

--------------------------------

### IdealStartingState Class API

Source: https://pathplanner.dev/api/cpp/IdealStartingState_8h_source

Documentation for the IdealStartingState class, which represents the ideal starting state for a path, including velocity and rotation.

```APIDOC
## IdealStartingState Class

### Description
Represents the ideal starting state for a path, defined by velocity and rotation.

### Methods

#### Constructor
```cpp
IdealStartingState(units::meters_per_second_t velocity, frc::Rotation2d rotation)
```
- **Description**: Constructs an IdealStartingState object.
- **Parameters**:
  - `velocity` (units::meters_per_second_t) - The initial velocity.
  - `rotation` (frc::Rotation2d) - The initial rotation.

#### static IdealStartingState fromJson(const wpi::json &json)
```cpp
static IdealStartingState fromJson(const wpi::json &json)
```
- **Description**: Creates an IdealStartingState object from a JSON object.
- **Parameters**:
  - `json` (wpi::json) - The JSON object containing the starting state data.
- **Returns**: An IdealStartingState object.

#### constexpr units::meters_per_second_t getVelocity() const
```cpp
constexpr units::meters_per_second_t getVelocity() const
```
- **Description**: Gets the initial velocity of the starting state.
- **Returns**: The initial velocity.

#### constexpr const frc::Rotation2d& getRotation() const
```cpp
constexpr const frc::Rotation2d& getRotation() const
```
- **Description**: Gets the initial rotation of the starting state.
- **Returns**: The initial rotation.

#### inline bool operator==(const IdealStartingState &other) const
```cpp
inline bool operator==(const IdealStartingState &other) const
```
- **Description**: Compares two IdealStartingState objects for equality.
- **Parameters**:
  - `other` (const IdealStartingState&) - The other IdealStartingState object to compare with.
- **Returns**: `true` if the objects are equal, `false` otherwise.

### Class Members
#### Private Members
- **m_velocity** (units::meters_per_second_t)
- **m_rotation** (frc::Rotation2d)

### File
- **Header**: `IdealStartingState.h`
- **Location**: `src/main/native/include/pathplanner/lib/path`
```

--------------------------------

### Get Initial Heading

Source: https://pathplanner.dev/api/java/com/pathplanner/lib/path/PathPlannerPath

Returns the initial heading (direction of travel) at the start of the path.

```java
public Rotation2d getInitialHeading()
Get the initial heading, or direction of travel, at the start of the path. 

Returns:
    Initial heading
```

--------------------------------

### IdealStartingState Record Documentation

Source: https://pathplanner.dev/api/java/com/pathplanner/lib/path/IdealStartingState

Details about the IdealStartingState record, its components, constructors, and methods.

```APIDOC
## IdealStartingState Record

### Description
Describes the ideal starting state of the robot when starting a path.

### Record Components
- **velocityMPS** (double) - The ideal starting velocity (M/S).
- **rotation** (Rotation2d) - The ideal starting rotation.

### Constructors
#### IdealStartingState(double velocityMPS, Rotation2d rotation)
Creates an instance of an `IdealStartingState` record class.

**Parameters:**
- **velocityMPS** (double) - the value for the `velocityMPS` record component.
- **rotation** (Rotation2d) - the value for the `rotation` record component.

#### IdealStartingState(LinearVelocity velocity, Rotation2d rotation)
Describes the ideal starting state of the robot when starting a path.

**Parameters:**
- **velocity** (LinearVelocity) - The ideal starting velocity.
- **rotation** (Rotation2d) - The ideal starting rotation.

### Methods
#### flip()
Flip the ideal starting state for the other side of the field, maintaining a blue alliance origin.

**Returns:**
- (IdealStartingState) The flipped starting state.

#### velocity()
Get the starting linear velocity.

**Returns:**
- (LinearVelocity) Starting linear velocity.

#### velocityMPS()
Returns the value of the `velocityMPS` record component.

**Returns:**
- (double) the value of the `velocityMPS` record component.

#### rotation()
Returns the value of the `rotation` record component.

**Returns:**
- (Rotation2d) the value of the `rotation` record component.

#### toString()
Returns a string representation of this record class. The representation contains the name of the class, followed by the name and value of each of the record components.

**Specified by:**
- `toString` in class `Record`

**Returns:**
- (String) a string representation of this object.

#### hashCode()
Returns a hash code value for this object. The value is derived from the hash code of each of the record components.

**Specified by:**
- `hashCode` in class `Record`

**Returns:**
- (int) a hash code value for this object.

#### equals(Object o)
Indicates whether some other object is "equal to" this one. The objects are equal if the other object is of the same class and if all the record components are equal. Reference components are compared with `Objects::equals(Object,Object)`; primitive components are compared with '=='.

**Specified by:**
- `equals` in class `Record`

**Parameters:**
- **o** (Object) - the object with which to compare.

**Returns:**
- (boolean) `true` if this object is the same as the `o` argument; `false` otherwise.
```

--------------------------------

### Get Starting Holonomic Pose for PathPlannerPath

Source: https://pathplanner.dev/api/python/pathplannerlib/path

Retrieves the holonomic pose at the starting point of a PathPlannerPath. This method returns the ideal starting pose if available, otherwise, it returns None. It's crucial for initializing holonomic drive systems.

```python
def getStartingHolonomicPose(self) -> Union[Pose2d, None]: ...
```

--------------------------------

### Get Ideal Trajectory

Source: https://pathplanner.dev/api/java/com/pathplanner/lib/path/PathPlannerPath

Retrieves the ideal trajectory for the path, if available. This is useful when the robot is near the start of the path and in the ideal starting state. It requires RobotConfig for generation if not already present.

```java
public Optional<PathPlannerTrajectory> getIdealTrajectory(RobotConfig robotConfig)
If possible, get the ideal trajectory for this path. This trajectory can be used if the robot is currently near the start of the path and at the ideal starting state. If there is no ideal starting state, there can be no ideal trajectory. 

Parameters:
    `robotConfig` - The config to generate the ideal trajectory with if it has not already been generated 

Returns:
    An optional containing the ideal trajectory if it exists, an empty optional otherwise
```

--------------------------------

### PathPlannerAuto Constructors and Methods (C++)

Source: https://pathplanner.dev/api/cpp/classpathplanner_1_1PathPlannerAuto

Demonstrates the constructors and various member functions of the PathPlannerAuto class, which is used to load and run autonomous routines. This includes methods for setting starting poses, defining conditions, triggering events, and controlling path execution.

```cpp
#include <PathPlannerAuto.h>

// Constructor 1
PathPlannerAuto::PathPlannerAuto(std::string autoName)

// Constructor 2
PathPlannerAuto::PathPlannerAuto(std::string autoName, bool mirror)

// Constructor 3
PathPlannerAuto::PathPlannerAuto(frc2::CommandPtr &&autoCommand, frc::Pose2d startingPose = frc::Pose2d())

// Member functions
frc::Pose2d PathPlannerAuto::getStartingPose() const
frc2::Trigger PathPlannerAuto::condition(std::function<bool()> condition)
isRunning()
timeElapsed(units::second_t time)
timeRange(units::second_t startTime, units::second_t endTime)
EventTrigger PathPlannerAuto::event(std::string eventName)
PointTowardsZoneTrigger PathPlannerAuto::pointTowardsZone(std::string zoneName)
activePath(std::string pathName)
nearFieldPosition(frc::Translation2d fieldPosition, units::meter_t tolerance)
nearFieldPositionAutoFlipped(frc::Translation2d blueFieldPosition, units::meter_t tolerance)
inFieldArea(frc::Translation2d boundingBoxMin, frc::Translation2d boundingBoxMax)
inFieldAreaAutoFlipped(frc::Translation2d blueBoundingBoxMin, frc::Translation2d blueBoundingBoxMax)

// Overridden methods
void PathPlannerAuto::Initialize() override
void PathPlannerAuto::Execute() override
bool PathPlannerAuto::IsFinished() override
void PathPlannerAuto::End(bool interrupted)

```

--------------------------------

### Get Starting Differential Pose for PathPlannerPath

Source: https://pathplanner.dev/api/python/pathplannerlib/path

Retrieves the differential pose at the starting point of a PathPlannerPath. This method is useful for understanding the initial orientation and position of the robot on the path for differential drive systems.

```python
def getStartingDifferentialPose(self) -> Pose2d: ...
```

--------------------------------

### Pathfind and Follow Path using AutoBuilder

Source: https://pathplanner.dev/pplib-pathfinding

This snippet shows how to use AutoBuilder to create a command that first pathfinds to a target and then follows a predefined path. It involves loading a path from a file and defining path constraints. The constraints set here are specific to the pathfinding portion and may differ from those stored within the path file itself.

```java
// Load the path we want to pathfind to and follow
PathPlannerPath path = PathPlannerPath.fromPathFile("Example Human Player Pickup");

// Create the constraints to use while pathfinding. The constraints defined in the path will only be used for the path.
PathConstraints constraints = new PathConstraints(
        3.0, 4.0,
        Units.degreesToRadians(540), Units.degreesToRadians(720));

// Since AutoBuilder is configured, we can use it to build pathfinding commands
Command pathfindingCommand = AutoBuilder.pathfindThenFollowPath(
        path,
        constraints);

```

```cpp
#include <pathplanner/lib/auto/AutoBuilder.h>

using namespace pathplanner;

// Load the path we want to pathfind to and follow
auto path = PathPlannerPath::fromPathFile("Example Human Player Pickup");

// Create the constraints to use while pathfinding. The constraints defined in the path will only be used for the path.
PathConstraints constraints = PathConstraints(
    3.0_mps, 4.0_mps_sq,
    540_deg_per_s, 720_deg_per_s_sq);

// Since AutoBuilder is configured, we can use it to build pathfinding commands
frc2::CommandPtr pathfindingCommand = AutoBuilder::pathfindThenFollowPath(
    path,
    constraints,
);

```

```python
from pathplannerlib.auto import AutoBuilder
from pathplannerlib.path import PathPlannerPath PathConstraints
from wpimath.units import degreesToRadians

# Load the path we want to pathfind to and follow
path = PathPlannerPath.fromPathFile('Example Human Player Pickup')

# Create the constraints to use while pathfinding. The constraints defined in the path will only be used for the path.
constraints = PathConstraints(
    3.0, 4.0,
    degreesToRadians(540), degreesToRadians(720)
)

# Since AutoBuilder is configured, we can use it to build pathfinding commands
pathfindingCommand = AutoBuilder.pathfindThenFollowPath(
    path,
    constraints,
)
```

--------------------------------

### Get Initial Heading from PathPlannerPath

Source: https://pathplanner.dev/api/python/pathplannerlib/path

Retrieves the initial heading (direction of travel) at the start of the PathPlannerPath. This is represented as a Rotation2d object.

```python
from pathplannerlib.path import PathPlannerPath

# Assuming path is a PathPlannerPath object
# initial_heading = path.getInitialHeading()
```

--------------------------------

### Initialize Pathfinding Implementation

Source: https://pathplanner.dev/api/python/pathplannerlib/pathfinding

Ensures a pathfinding implementation is selected. If none is set, it defaults to the standard implementation. This method is static and returns nothing.

```python
Pathfinding.ensureInitialized()
```

--------------------------------

### PathfindingCommand Constructors

Source: https://pathplanner.dev/api/cpp/PathfindingCommand_8h_source

Provides details on the different ways to construct a PathfindingCommand object.

```APIDOC
## PathfindingCommand Constructors

### Description
These constructors allow you to create a PathfindingCommand object with either a predefined path or a target pose, along with various configuration options.

### Method
- `PathfindingCommand` (Constructor 1)
- `PathfindingCommand` (Constructor 2)

### Endpoint
N/A (Class Constructor)

### Parameters
#### Constructor 1 Parameters:
- **targetPath** (`std::shared_ptr<PathPlannerPath>`): A shared pointer to the PathPlannerPath object to follow.
- **constraints** (`PathConstraints`): The constraints for the path, such as maximum velocity and acceleration.
- **poseSupplier** (`std::function<frc::Pose2d()>`): A function that supplies the current robot pose.
- **speedsSupplier** (`std::function<frc::ChassisSpeeds()>`): A function that supplies the current robot chassis speeds.
- **output** (`std::function<void(const frc::ChassisSpeeds&, const DriveFeedforwards&)>`): A function to send the calculated chassis speeds and feedforwards to the drivetrain.
- **controller** (`std::shared_ptr<PathFollowingController>`): A shared pointer to the PathFollowingController object.
- **robotConfig** (`RobotConfig`): Configuration details for the robot, including wheel diameter and track width.
- **shouldFlipPath** (`std::function<bool()>`): A function that returns true if the path should be flipped (e.g., for mirrored paths).
- **requirements** (`frc2::Requirements`): The requirements for this command.

#### Constructor 2 Parameters:
- **targetPose** (`frc::Pose2d`): The target pose for the robot to reach.
- **constraints** (`PathConstraints`): The constraints for the path.
- **goalEndVel** (`units::meters_per_second_t`): The desired end velocity at the goal.
- **poseSupplier** (`std::function<frc::Pose2d()>`): A function that supplies the current robot pose.
- **speedsSupplier** (`std::function<frc::ChassisSpeeds()>`): A function that supplies the current robot chassis speeds.
- **output** (`std::function<void(const frc::ChassisSpeeds&, const DriveFeedforwards&)>`): A function to send the calculated chassis speeds and feedforwards to the drivetrain.
- **controller** (`std::shared_ptr<PathFollowingController>`): A shared pointer to the PathFollowingController object.
- **robotConfig** (`RobotConfig`): Configuration details for the robot.
- **requirements** (`frc2::Requirements`): The requirements for this command.

### Request Example
```cpp
// Example for Constructor 1 (conceptual)
auto targetPath = std::make_shared<PathPlannerPath>(...);
PathConstraints constraints(...);
auto poseSupplier = []() { return chassis.getPose(); };
auto speedsSupplier = []() { return chassis.getChassisSpeeds(); };
auto output = [&](const frc::ChassisSpeeds& speeds, const DriveFeedforwards& feedforwards) {
    auto command = drivetrain.runVelocity(speeds);
    command.withTimeout(10_s);
};
auto controller = std::make_shared<PathFollowingController>(...);
RobotConfig robotConfig = {...};
auto shouldFlipPath = []() { return frcmath.isRedAlliance(); };rc2::Requirements requirements;
PathfindingCommand cmd1(targetPath, constraints, poseSupplier, speedsSupplier, output, controller, robotConfig, shouldFlipPath, requirements);

// Example for Constructor 2 (conceptual)
frc::Pose2d targetPose(...);
units::meters_per_second_t goalEndVel(0.1_mps);
PathfindingCommand cmd2(targetPose, constraints, goalEndVel, poseSupplier, speedsSupplier, output, controller, robotConfig, requirements);
```

### Response
#### Success Response (N/A for constructors)
Constructors do not return a value in the traditional sense; they initialize the object.

#### Response Example (N/A)
```

--------------------------------

### Get Path States and Properties

Source: https://pathplanner.dev/api/java/com/pathplanner/lib/path/PathPlannerPath

Retrieve the goal end state, ideal starting state, event markers, and orientation properties of the path.

```APIDOC
## GET /websites/pathplanner_dev/idealStartingState

### Description
Get the ideal starting state of this path.

### Method
GET

### Endpoint
/websites/pathplanner_dev/idealStartingState

### Parameters
#### Query Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **idealStartingState** (IdealStartingState) - The ideal starting state of the path.

#### Response Example
```json
{
  "idealStartingState": {
    "pose": {
      "translation": {"x": 0.0, "y": 0.0},
      "rotation": {"degrees": 0.0}
    },
    "velocity": 0.0
  }
}
```

## GET /websites/pathplanner_dev/goalEndState

### Description
Get the goal end state of this path.

### Method
GET

### Endpoint
/websites/pathplanner_dev/goalEndState

### Parameters
#### Query Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **goalEndState** (IdealStartingState) - The goal end state of the path.

#### Response Example
```json
{
  "goalEndState": {
    "pose": {
      "translation": {"x": 1.0, "y": 2.0},
      "rotation": {"degrees": 90.0}
    },
    "velocity": 1.5
  }
}
```

## GET /websites/pathplanner_dev/eventMarkers

### Description
Get all the event markers for this path.

### Method
GET

### Endpoint
/websites/pathplanner_dev/eventMarkers

### Parameters
#### Query Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **eventMarkers** (List<EventMarker>) - A list of event markers for the path.

#### Response Example
```json
{
  "eventMarkers": [
    {
      "time": 0.5,
      "name": "marker1",
      "command": "{}"
    },
    {
      "time": 1.2,
      "name": "marker2",
      "command": "{}"
    }
  ]
}
```

## GET /websites/pathplanner_dev/isReversed

### Description
Should the path be followed reversed (differential drive only).

### Method
GET

### Endpoint
/websites/pathplanner_dev/isReversed

### Parameters
#### Query Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **reversed** (boolean) - True if the path should be followed reversed, false otherwise.

#### Response Example
```json
{
  "reversed": false
}
```

## GET /websites/pathplanner_dev/isChoreoPath

### Description
Check if this path is loaded from a Choreo trajectory.

### Method
GET

### Endpoint
/websites/pathplanner_dev/isChoreoPath

### Parameters
#### Query Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **choreoPath** (boolean) - True if this path is from choreo, false otherwise.

#### Response Example
```json
{
  "choreoPath": true
}
```
```

--------------------------------

### Get Ideal Starting State from PathPlannerPath

Source: https://pathplanner.dev/api/python/pathplannerlib/path

Fetches the IdealStartingState for this PathPlannerPath, if one is defined. This represents the optimal initial condition for the robot to begin following the path.

```python
from pathplannerlib.path import PathPlannerPath

# Assuming path is a PathPlannerPath object
# ideal_start_state = path.getIdealStartingState()
```

--------------------------------

### configure()

Source: https://pathplanner.dev/api/cpp/classpathplanner_1_1AutoBuilder

Configures the AutoBuilder for using PathPlanner's built-in commands. This essential setup step defines the robot's pose, speed, and output functions, along with the path following controller and configuration.

```APIDOC
## POST /configure

### Description
Configures the AutoBuilder for using PathPlanner's built-in commands.

### Method
POST

### Endpoint
/configure

### Parameters
#### Request Body
- **poseSupplier** (function) - Required - A function that returns the robot's current pose.
- **resetPose** (function) - Required - A function used for resetting the robot's pose.
- **robotRelativeSpeedsSupplier** (function) - Required - A function that returns the robot's current robot-relative chassis speeds.
- **output** (function) - Required - Output function that accepts robot-relative ChassisSpeeds.
- **controller** (object) - Required - Path following controller that will be used to follow the path.
- **robotConfig** (object) - Required - The robot configuration.
- **shouldFlipPath** (function) - Required - Supplier that determines if paths should be flipped to the other side of the field. This will maintain a global blue alliance origin.
- **driveSubsystem** (object) - Required - A pointer to the subsystem for the robot's drive.

### Request Example
```json
{
  "poseSupplier": "() => getPose()",
  "resetPose": "(pose) => setPose(pose)",
  "robotRelativeSpeedsSupplier": "() => getChassisSpeeds()",
  "output": "(speeds) => setSpeeds(speeds)",
  "controller": "<PathFollowingControllerObject>",
  "robotConfig": {"maxSpeed": 3.0, "maxAngularSpeed": 3.0},
  "shouldFlipPath": "() => getAlliance() == 'BLUE'",
  "driveSubsystem": "<DriveSubsystemObject>"
}
```

### Response
#### Success Response (200)
- **status** (string) - Configuration status.

#### Response Example
```json
{
  "status": "Configured successfully"
}
```
```

--------------------------------

### Get Initial Heading C++

Source: https://pathplanner.dev/api/cpp/PathPlannerPath_8h_source

Calculates the initial heading of the path based on the first two points. This is useful for setting the robot's starting orientation.

```cpp
inline frc::Rotation2d getInitialHeading() const {
  return (getPoint(1).position - getPoint(0).position).Angle();
}
```

--------------------------------

### PathfindThenFollowPath: Constructor

Source: https://pathplanner.dev/api/cpp/PathfindThenFollowPath_8h_source

Initializes the PathfindThenFollowPath command, which is responsible for pathfinding and then executing the path on the robot. It takes various parameters including the goal path, pathfinding constraints, pose and speed suppliers, output functions, a controller, robot configuration, and requirements.

```C++
PathfindThenFollowPath(std::shared_ptr< PathPlannerPath > goalPath, PathConstraints pathfindingConstraints, std::function< frc::Pose2d()> poseSupplier, std::function< frc::ChassisSpeeds()> currentRobotRelativeSpeeds, std::function< void(const frc::ChassisSpeeds &, const DriveFeedforwards &)> output, std::shared_ptr< PathFollowingController > controller, RobotConfig robotConfig, std::function< bool()> shouldFlipPath, frc2::Requirements requirements)
**Definition:** PathfindThenFollowPath.h:31
```

--------------------------------

### Load Autonomous Command

Source: https://pathplanner.dev/pplib-build-an-auto

Loads a pre-configured autonomous command by its name. It is recommended to load autos when code starts to avoid delays. This example shows loading within the getAutonomousCommand function, which is not the recommended approach for performance.

```java
public Command getAutonomousCommand() {
    // This method loads the auto when it is called, however, it is recommended
    // to first load your paths/autos when code starts, then return the
    // pre-loaded auto/path
    return new PathPlannerAuto("Example Auto");
}
```

```cpp
#include <pathplanner/lib/commands/PathPlannerAuto.h>

using namespace pathplanner;

frc2::CommandPtr RobotContainer::getAutonomousCommand(){
    // This method loads the auto when it is called, however, it is recommended
    // to first load your paths/autos when code starts, then return the
    // pre-loaded auto/path
    return PathPlannerAuto("Example Auto").ToPtr();
}
```

```python
from pathplannerlib.auto import PathPlannerAuto

class RobotContainer:
    def getAutonomousCommand():
        # This method loads the auto when it is called, however, it is recommended
        # to first load your paths/autos when code starts, then return the
        # pre-loaded auto/path
        return PathPlannerAuto('Example Auto')
```

--------------------------------

### Constructor Documentation

Source: https://pathplanner.dev/api/cpp/classpathplanner_1_1PathPlannerPath

Constructs a PathPlannerPath object.

```APIDOC
## Constructors

### `PathPlannerPath()` [1/3]

**Description**: Creates a new PathPlannerPath with detailed waypoint and control information.

**Parameters**:
- `_waypoints` (std::vector<Waypoint>) - List of waypoints representing the path.
- `_rotationTargets` (std::vector<RotationTarget>) - List of rotation targets along the path.
- `_pointTowardsZones` (std::vector<PointTowardsZone>) - List of point towards zones along the path.
- `_constraintZones` (std::vector<ConstraintsZone>) - List of constraint zones along the path.
- `_eventMarkers` (std::vector<EventMarker>) - List of event markers along the path.
- `_globalConstraints` (PathConstraints) - The global constraints of the path.
- `_idealStartingState` (std::optional<IdealStartingState>) - The ideal starting state of the path.
- `_goalEndState` (GoalEndState) - The goal end state of the path.
- `_reversed` (bool) - Should the robot follow the path reversed.

### `PathPlannerPath()` [2/3]

**Description**: Simplified constructor for creating a path with no rotation targets, constraint zones, or event markers.

**Parameters**:
- `_waypoints` (std::vector<Waypoint>) - List of waypoints representing the path.
- `_constraints` (PathConstraints) - The global constraints of the path.
- `_idealStartingState` (std::optional<IdealStartingState>) - The ideal starting state of the path.
- `_goalEndState` (GoalEndState) - The goal end state of the path.
- `_reversed` (bool) - Should the robot follow the path reversed (default is false).

### `PathPlannerPath()` [3/3]

**Description**: Constructor used internally. Not intended for direct use.

**Parameters**:
- `_constraints` (PathConstraints) - The global constraints of the path.
- `_goalEndState` (GoalEndState) - The goal end state of the path.
```

--------------------------------

### Clear Path Cache C++

Source: https://pathplanner.dev/api/cpp/PathPlannerPath_8h_source

A static utility function to clear both the general path cache and the Choreo path cache. This is useful for resetting the path planner's memory, for example, at the start of an autonomous period.

```cpp
static inline void clearPathCache() {
  PathPlannerPath::getPathCache().clear();
  PathPlannerPath::getChoreoPathCache().clear();
}
```

--------------------------------

### PathfindThenFollowPath Command Constructor (C++)

Source: https://pathplanner.dev/api/cpp/classpathplanner_1_1PathfindThenFollowPath

Constructor for the PathfindThenFollowPath command group. It initializes the command with necessary parameters for pathfinding and following, including the goal path, constraints, pose supplier, speed suppliers, output functions, controller, robot configuration, and requirements. Dependencies include PathPlannerPath, PathConstraints, PathFollowingController, and RobotConfig.

```cpp
pathplanner::PathfindThenFollowPath::PathfindThenFollowPath(
    std::shared_ptr<PathPlannerPath> _goalPath,
    PathConstraints _pathfindingConstraints,
    std::function<frc::Pose2d()> _poseSupplier,
    std::function<frc::ChassisSpeeds()> _currentRobotRelativeSpeeds,
    std::function<void(const frc::ChassisSpeeds&, const DriveFeedforwards&)> _output,
    std::shared_ptr<PathFollowingController> _controller,
    RobotConfig _robotConfig,
    std::function<bool()> _shouldFlipPath,
    frc2::Requirements _requirements
)
```
Tokens:
Raw