Class SplineGenerator

• Defined in File spline.hpp

Nested Relationships

Nested Types

• Struct SplineGenerator::ConstrainedState

• Struct SplineGenerator::GeneratedPoint

• Struct SplineGenerator::GeneratedVector

Class Documentation

class squiggles::SplineGenerator

Public Functions

SplineGenerator(Constraints iconstraints, std::shared_ptr<PhysicalModel> imodel = std::make_shared<PassthroughModel>(), double idt = 0.1)

Generates curves that match the given motion constraints.

Parameters

• iconstraints: The maximum allowable values for the robot’s motion.

• imodel: The robot’s physical characteristics and constraints

• idt: The difference in time in seconds between each state for the generated paths.

std::vector<ProfilePoint> generate(std::initializer_list<Pose> iwaypoints)

Creates a motion profiled path between the given waypoints.

Note

currently only two waypoints are supported for a given path.

Return

A series of robot states defining a path between the poses.

Parameters

• iwaypoints: The list of poses that the robot should reach along the path.

std::vector<ProfilePoint> generate(std::initializer_list<ControlVector> iwaypoints)

Creates a motion profiled path between the given waypoints.

NOTE: currently only two waypoints are supported for a given path.

Return

A series of robot states defining a path between the vectors.

Parameters

• iwaypoints: The list of vectors that the robot should reach along the path.

Protected Functions

template<class Iter>
std::vector<ProfilePoint> _generate(Iter start, Iter end)

The actual function called by the “generate” functions.

Return

The points from each path concatenated together

Parameters

• start: An iterator pointing to the first ControlVector in the path

• end: An iterator pointting to the last ControlVector in the path

std::vector<GeneratedPoint> gen_raw_path(ControlVector start, ControlVector end)

Performs the “naive” generation step.

This step calculates the spline polynomials that fit within the SplineGenerator’s acceleration and jerk constraints and returns the points that form the curve.

std::vector<ProfilePoint> parameterize(const ControlVector start, const ControlVector end, const std::vector<GeneratedPoint> &raw_path, const double preferred_start_vel, const double preferred_end_vel)

Imposes a linear motion profile on the raw path.

This step creates the velocity and acceleration values to command the robot at each point along the curve.

std::vector<ProfilePoint> integrate_constrained_states(std::vector<ConstrainedState> constrainedStates)

Finds the new timestamps for each point along the curve based on the motion profile.

ProfilePoint get_point_at_time(const ControlVector start, const ControlVector end, std::vector<ProfilePoint> points, double t)

Finds the ProfilePoint on the profiled curve for the given timestamp.

This with interpolate between points on the curve if a point with an exact matching timestamp is not found.

ProfilePoint lerp_point(QuinticPolynomial x_qp, QuinticPolynomial y_qp, ProfilePoint start, ProfilePoint end, double i)

Linearly interpolates between points along the profiled curve.

QuinticPolynomial get_x_spline(const ControlVector start, const ControlVector end, const double duration)

Returns the spline curve for the given control vectors and path duration.

QuinticPolynomial get_y_spline(const ControlVector start, const ControlVector end, const double duration)

void enforce_accel_lims(ConstrainedState *state)

Applies the general constraints and model constraints to the given state.

void forward_pass(ConstrainedState *predecessor, ConstrainedState *successor)

Imposes the motion profile constraints on a segment of the path from the perspective of iterating forwards through the path.

void backward_pass(ConstrainedState *predecessor, ConstrainedState *successor)

Imposes the motion profile constraints on a segment of the path from the perspective of iterating backwards through the path.

double vf(double vi, double a, double ds)

Calculates the final velocity for a path segment.

double ai(double vf, double vi, double s)

Calculates the initial acceleration needed to match the segments’ velocities.

Protected Attributes

Constraints constraints

The maximum allowable values for the robot’s motion.

std::shared_ptr<PhysicalModel> model

Defines the physical structure of the robot and translates the linear kinematics to wheel velocities.

double dt

The time difference between each value in the generated path.

const int T_MIN = 2

The minimum and maximum durations for a path to take. A larger range allows for longer possible paths at the expense of a longer path generation time.

const int T_MAX = 15

const double K_DEFAULT_VEL = 0.12

This is factor is used to create a “dummy velocity” in the initial path generation step one or both of the preferred start or end velocities is zero. The velocity will be replaced with the preferred start/end velocity in parameterization but a nonzero velocity is needed for the spline calculation.

This was 1.2 in the WPILib example but that large of a value seems to create wild paths, 0.12 worked better in testing with VEX-sized paths.

Protected Static Attributes

constexpr double K_EPSILON = 1e-5

Values that are closer to each other than this value are considered equal.

struct ConstrainedState

An intermediate value used in the parameterization step. Adds the constrained values from the motion profile to the output from the “naive” generation step.

Public Functions

ConstrainedState(Pose ipose, double icurvature, double idistance, double imax_vel, double imin_accel, double imax_accel)

ConstrainedState() = default

std::string to_string()

Public Members

Pose pose = Pose()

double curvature = 0

double distance = 0

double max_vel = 0

double min_accel = 0

double max_accel = 0

struct GeneratedPoint

The output of the initial, “naive” generation step. We discard the derivative values to replace them with values from a motion profile.

Public Functions

GeneratedPoint(Pose ipose, double icurvature = 0.0)

std::string to_string()

Public Members

Pose pose

double curvature

struct GeneratedVector

An intermediate value used in the “naive” generation step. Contains the final GeneratedPoint value that will be returned as well as the spline’s derivative values to perform the initial check against the constraints.

Public Functions

GeneratedVector(GeneratedPoint ipoint, double ivel, double iaccel, double ijerk)

std::string to_string()

Public Members

GeneratedPoint point

double vel

double accel

double jerk