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::vector<Pose> iwaypoints, bool fast = false)

Creates a motion profiled path between the given waypoints.

Parameters

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

• fast – If true, the path optimization process will stop as soon as the constraints are met. If false, the optimizer will find the smoothest possible path between the points.

Returns

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

std::vector<ProfilePoint> generate(std::initializer_list<Pose> iwaypoints, bool fast = false)

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

Creates a motion profiled path between the given waypoints.

Parameters

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

Returns

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

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

std::vector<GeneratedVector> gen_single_raw_path(ControlVector start, ControlVector end, int duration, double start_vel, double end_vel)

std::vector<GeneratedPoint> gradient_descent(ControlVector &start, ControlVector &end, bool fast)

Runs a Gradient Descent algorithm to minimize the linear acceleration, linear jerk, and curvature for the generated path.

This is used when there is not a start/end velocity specified for a given path.

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

The actual function called by the “generate” functions.

Parameters

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

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

Returns

The points from each path concatenated together

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

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, const double start_time)

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.

Public Members

const double K_DEFAULT_VEL = 1.0

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.

Public Static Attributes

static constexpr double K_EPSILON = 1e-5

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

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 int MAX_GRAD_DESCENT_ITERATIONS = 10

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

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

ConstrainedState() = default

inline std::string to_string() const

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

inline GeneratedPoint(Pose ipose, double icurvature = 0.0)

inline std::string to_string() const

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

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

inline std::string to_string() const

Public Members

GeneratedPoint point

double vel

double accel

double jerk