pydrake.multibody.optimization
Optimization module for MultibodyPlant motion planning
- class pydrake.multibody.optimization.CalcGridPointsOptions
- __init__(self: pydrake.multibody.optimization.CalcGridPointsOptions, **kwargs) None
- property max_err
- property max_iter
- property max_seg_length
- property min_points
- class pydrake.multibody.optimization.CentroidalMomentumConstraint
Bases:
pydrake.solvers.Constraint
Impose the constraint CentroidalMomentum(q, v) - h_WC = 0 with decision variables [q;v;h_WC] or CentroidalAngularMomentum(q, v) - k_WC = 0 with decision variables [q; v; k_WC] h_WC is the 6D spatial momentum (linear and angular momentum about the center of mass C) expressed in the world frame (W). k_WC is the 3D vector representing the angular momentum about the center of mass C expressed in the world frame W.
- __init__(self: pydrake.multibody.optimization.CentroidalMomentumConstraint, plant: pydrake.multibody.plant.MultibodyPlant_[AutoDiffXd], model_instances: Optional[list[pydrake.multibody.tree.ModelInstanceIndex]], plant_context: pydrake.systems.framework.Context_[AutoDiffXd], angular_only: bool) None
Construct centroidal momentum constraint If
angular_only
= false, we impose the constraint CentroidalMomentum(q, v) - h_WC = 0 where CentroidalMomentum computes the spatial momentum of the robot about its center-of-mass, expressed in the world frame. The decision variables are [q;v;h_WC]. Ifangular_only
= true, we impose the constraint CentroidalAngularMomentum(q, v) - k_WC = 0 where CentroidalAngularMomentum(q, v) computes the angular momentum of the robot about its center-of-mass, expressed in the world frame. The decision variables are [q; v; k_WC]Note
Currently, we can only construct this constraint using MultibodyPlant<AutoDiffXd> instead of MultibodyPlant<double>, since we can’t compute the Jacobian of the momentum using MultibodyPlant<double> yet.
- Parameter
plant
: The plant for which the constraint is imposed.
- Parameter
model_instances
: We compute the model with these model instances in
plant
. If model_instances=std::nullopt, then we compute the momentum of all model instances except the world.
- Parameter
- class pydrake.multibody.optimization.ContactWrench
Stores the contact wrench (spatial force) from Body A to Body B applied at point Cb.
- __init__(*args, **kwargs)
- property bodyA_index
The index of Body A.
- property bodyB_index
The index of Body B.
- property F_Cb_W
F_Cb_W_in The wrench (spatial force) applied at point Cb from Body A to Body B, measured in the world frame.
- property p_WCb_W
The position of the point Cb (where the wrench is applied) expressed in the world frame W.
- class pydrake.multibody.optimization.ContactWrenchFromForceInWorldFrameEvaluator
Bases:
pydrake.solvers.EvaluatorBase
The contact wrench is τ_AB_W = 0, f_AB_W = λ Namely we assume that λ is the contact force from A to B, applied directly at B’s witness point.
- __init__(self: pydrake.multibody.optimization.ContactWrenchFromForceInWorldFrameEvaluator, plant: pydrake.multibody.plant.MultibodyPlant_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], geometry_id_pair: Tuple[pydrake.geometry.GeometryId]) None
- Parameter
plant
: The MultibodyPlant on which the contact wrench is computed. The lifetime of
plant
should outlive this object.- Parameter
context
: The context of the MultibodyPlant. The lifetime of
context
should outlive this object.- Parameter
geometry_id_pair
: The pair of geometries for which the contact wrench is computed. Notice that the order of the geometries in the pair should match with that in SceneGraphInspector::GetCollisionCandidates().
- Parameter
description
: The description of this evaluator. Default to none.
- Parameter
- class pydrake.multibody.optimization.QuaternionEulerIntegrationConstraint
Bases:
pydrake.solvers.Constraint
If we have a body with orientation quaternion z₁ at time t₁, and a quaternion z₂ at time t₂ = t₁ + h, with the angular velocity ω (expressed in the world frame), we impose the constraint that the body rotates at a constant velocity ω from quaternion z₁ to quaternion z₂ within time interval h. Namely we want to enforce the relationship that z₂ and Δz⊗z₁ represent the same orientation, where Δz is the quaternion [cos(|ω|h/2), ω/|ω|*sin(|ω|h/2)], and ⊗ is the Hamiltonian product between quaternions.
It is well-known that for any quaternion z, its element-wise negation -z correspond to the same rotation matrix as z does. One way to understand this is that -z represents the rotation that first rotate the frame by a quaternion z, and then continue to rotate about that axis for 360 degrees. We provide the option
allow_quaternion_negation
flag, that if set to true, then we require that the quaternion z₂ = ±Δz⊗z₁. Otherwise we require z₂ = Δz⊗z₁. Mathematically, the constraint we impose isIf allow_quaternion_negation = true:
(z₂ • (Δz⊗z₁))² = 1
else
z₂ • (Δz⊗z₁) = 1
If your robot link orientation only changes slightly, and you are free to search for both z₁ and z₂, then we would recommend to set allow_quaternion_negation to false, as the left hand side of constraint z₂ • (Δz⊗z₁) = 1 is less nonlinear than the left hand side of (z₂ • (Δz⊗z₁))² = 1.
The operation • is the dot product between two quaternions, which computes the cosine of the half angle between these two orientations. Dot product equals to ±1 means that angle between the two quaternions are 2kπ, hence they represent the same orientation.
Note
The constraint is not differentiable at ω=0 (due to the non-differentiability of |ω| at ω = 0). So it is better to initialize the angular velocity to a non-zero value in the optimization.
The decision variables of this constraint are [z₁, z₂, ω, h]
Note
We need to evaluate sin(|ω|h/2)/|ω|, when h is huge (larger than 1/machine_epsilon), and |ω| is tiny (less than machine epsilon), this evaluation is inaccurate. So don’t use this constraint if you have a huge h (which would be bad practice in trajectory optimization anyway).
- __init__(self: pydrake.multibody.optimization.QuaternionEulerIntegrationConstraint, allow_quaternion_negation: bool) None
- Parameter
allow_quaternion_negation
: . Refer to the class documentation.
- Parameter
- allow_quaternion_negation(self: pydrake.multibody.optimization.QuaternionEulerIntegrationConstraint) bool
- ComposeVariable(*args, **kwargs)
Overloaded function.
ComposeVariable(self: pydrake.multibody.optimization.QuaternionEulerIntegrationConstraint, quat1: numpy.ndarray[numpy.float64[4, 1]], quat2: numpy.ndarray[numpy.float64[4, 1]], angular_vel: numpy.ndarray[numpy.float64[3, 1]], h: float) -> numpy.ndarray[numpy.float64[12, 1]]
ComposeVariable(self: pydrake.multibody.optimization.QuaternionEulerIntegrationConstraint, quat1: numpy.ndarray[object[4, 1]], quat2: numpy.ndarray[object[4, 1]], angular_vel: numpy.ndarray[object[3, 1]], h: pydrake.symbolic.Variable) -> numpy.ndarray[object[12, 1]]
ComposeVariable(self: pydrake.multibody.optimization.QuaternionEulerIntegrationConstraint, quat1: numpy.ndarray[object[4, 1]], quat2: numpy.ndarray[object[4, 1]], angular_vel: numpy.ndarray[object[3, 1]], h: pydrake.symbolic.Expression) -> numpy.ndarray[object[12, 1]]
- class pydrake.multibody.optimization.SpatialVelocityConstraint
Bases:
pydrake.solvers.Constraint
Constrains the spatial velocity of a frame C, rigidly attached to a frame B, measured and expressed in frame A. It should be bound with decision variables corresponding to the multibody state x=[q,v] of the
plant
passed to the constructor.- __init__(self: pydrake.multibody.optimization.SpatialVelocityConstraint, plant: pydrake.multibody.plant.MultibodyPlant_[AutoDiffXd], frameA: pydrake.multibody.tree.Frame_[AutoDiffXd], v_AC_lower: numpy.ndarray[numpy.float64[3, 1]], v_AC_upper: numpy.ndarray[numpy.float64[3, 1]], frameB: pydrake.multibody.tree.Frame_[AutoDiffXd], p_BCo: numpy.ndarray[numpy.float64[3, 1]], plant_context: pydrake.systems.framework.Context_[AutoDiffXd], w_AC_bounds: Optional[drake::multibody::SpatialVelocityConstraint::AngularVelocityBounds] = None) None
Constructs SpatialVelocityConstraint object.
- Parameter
plant
: The MultibodyPlant on which the constraint is imposed.
plant
should be alive during the lifetime of this constraint.- Parameter
frameA
: The frame in which frame C’s spatial velocity is measured and expressed.
- Parameter
v_AC_lower
: The lower bound on the translational velocity of C, expressed in frame A.
- Parameter
v_AC_upper
: The upper bound on the translational velocity of C, expressed in frame A.
- Parameter
frameB
: The frame to which frame C is rigidly attached.
- Parameter
p_BCo
: The position of the origin of frame C, rigidly attached to frame B, expressed in frame B. We take R_BC to be the identity rotation.
- Parameter
plant_context
: The Context that has been allocated for this
plant
. We will update the context when evaluating the constraint.plant_context
should be alive during the lifetime of this constraint.- Parameter
w_AC_bounds
: If provided, then the number of constraints will be 5: 3 for translational velocities and then two more for the angular velocity magnitude and angle.
- Precondition:
frameA
andframeB
must belong toplant
.- Precondition:
v_AC_lower(i) <= v_AC_upper(i) for i = 1, 2, 3.
- Raises
RuntimeError if plant is nullptr. –
RuntimeError if plant_context is nullptr. –
RuntimeError if invalid w_AC_bounds are provided. –
- Parameter
- class AngularVelocityBounds
Parametrizes bounds on the magnitude and direction of the angular velocity vector.
- __init__(self: pydrake.multibody.optimization.SpatialVelocityConstraint.AngularVelocityBounds) None
Constructs SpatialVelocityConstraint object.
- Parameter
plant
: The MultibodyPlant on which the constraint is imposed.
plant
should be alive during the lifetime of this constraint.- Parameter
frameA
: The frame in which frame C’s spatial velocity is measured and expressed.
- Parameter
v_AC_lower
: The lower bound on the translational velocity of C, expressed in frame A.
- Parameter
v_AC_upper
: The upper bound on the translational velocity of C, expressed in frame A.
- Parameter
frameB
: The frame to which frame C is rigidly attached.
- Parameter
p_BCo
: The position of the origin of frame C, rigidly attached to frame B, expressed in frame B. We take R_BC to be the identity rotation.
- Parameter
plant_context
: The Context that has been allocated for this
plant
. We will update the context when evaluating the constraint.plant_context
should be alive during the lifetime of this constraint.- Parameter
w_AC_bounds
: If provided, then the number of constraints will be 5: 3 for translational velocities and then two more for the angular velocity magnitude and angle.
- Precondition:
frameA
andframeB
must belong toplant
.- Precondition:
v_AC_lower(i) <= v_AC_upper(i) for i = 1, 2, 3.
- Raises
RuntimeError if plant is nullptr. –
RuntimeError if plant_context is nullptr. –
RuntimeError if invalid w_AC_bounds are provided. –
- Parameter
- property magnitude_lower
Lower bound on the magnitude of the angular velocity vector. Must be non-negative. The actual constraint will be implemented as a constraint on the squared magnitude.
- property magnitude_upper
Upper bound on the magnitude of the angular velocity vector. Must be ≥ magnitude_lower. The actual constraint will be implemented as a constraint on the squared magnitude.
- property reference_direction
Reference direction of the angular velocity vector. (Only the direction matters, the magnitude does not).
- property theta_bound
The angle difference between w_AC and reference_direction will be constrained to θ ∈ [0,π] ≤ θ_bound. Must be nonnegative. The actual constraint will be implemented as cos(θ_bound) ≤ cos(θ) ≤ 1. When the norm of w_AC is very close to zero, we add a small number to the norm to avoid numerical difficulties.
- class pydrake.multibody.optimization.StaticEquilibriumProblem
Finds the static equilibrium pose of a multibody system through optimization. The constraints are 1. 0 = g(q) + Bu + ∑ᵢ JᵢᵀFᵢ_AB_W(λᵢ) (generalized force equals to 0). 2. Fᵢ_AB_W(λᵢ) is within the admissible contact wrench (for example, contact force is in the friction cone). 3. sdf(q) >= 0 (signed distance function is no smaller than 0, hence no penetration). 4. complementarity condition between the contact force and the signed distance. 5. q within the joint limit.
- __init__(self: pydrake.multibody.optimization.StaticEquilibriumProblem, plant: pydrake.multibody.plant.MultibodyPlant_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], ignored_collision_pairs: set[tuple[pydrake.geometry.GeometryId, pydrake.geometry.GeometryId]]) None
- Parameter
plant
: The plant for which the static equilibrium posture is computed.
plant
should remain alive as long as this StaticEquilibriumProblem exists.- Parameter
context
: The context for
plant
.context
should remain alive as long as this StaticEquilibriumProblem exists.- Parameter
ignored_collision_pairs
: The contact between the pair of geometry in
ignored_collision_pairs
will be ignored. We will not impose non-penetration constraint between these pairs, and no contact wrench will be applied between these pairs.
- Parameter
- get_mutable_prog(self: pydrake.multibody.optimization.StaticEquilibriumProblem) pydrake.solvers.MathematicalProgram
- GetContactWrenchSolution(self: pydrake.multibody.optimization.StaticEquilibriumProblem, result: pydrake.solvers.MathematicalProgramResult) list[pydrake.multibody.optimization.ContactWrench]
Retrieve the solution to all contact wrenches.
- Parameter
result
: The result of solving prog().
- Parameter
- prog(self: pydrake.multibody.optimization.StaticEquilibriumProblem) pydrake.solvers.MathematicalProgram
Getter for the immutable optimization program.
- q_vars(self: pydrake.multibody.optimization.StaticEquilibriumProblem) numpy.ndarray[object[m, 1]]
Getter for q, the decision variable for the generalized position.
- u_vars(self: pydrake.multibody.optimization.StaticEquilibriumProblem) numpy.ndarray[object[m, 1]]
Getter for u, the decision variable for the input.
- UpdateComplementarityTolerance(self: pydrake.multibody.optimization.StaticEquilibriumProblem, tol: float) None
Updates the tolerance on all the complementarity constraints α * β = 0. The complementarity constraint is relaxed as 0 ≤ α * β ≤ tol. See AddStaticFrictionConeComplementarityConstraint() for more details.
- class pydrake.multibody.optimization.Toppra
Solves a Time Optimal Path Parameterization based on Reachability Analysis (TOPPRA) to find the fastest traversal of a given path, satisfying the given constraints. The approach is described in “A new approach to Time-Optimal Path Parameterization based on Reachability Analysis” by Hung Pham and Quang Cuong Pham, IEEE Transactions on Robotics, 2018.
- __init__(self: pydrake.multibody.optimization.Toppra, path: pydrake.trajectories.Trajectory, plant: pydrake.multibody.plant.MultibodyPlant, gridpoints: numpy.ndarray[numpy.float64[m, 1]]) None
Constructs an inverse kinematics problem for a MultibodyPlant. This constructor will create and own a context for
- Parameter
plant
: .
- Parameter
path
: The trajectory on which the TOPPRA problem will be solved.
- Parameter
plant
: The robot that will follow the solved trajectory. Used for enforcing torque and frame specific constraints.
- Parameter
gridpoints
: The points along the path to discretize the problem and enforce constraints at. The first and last gridpoint must equal the path start and end time respectively. Gridpoints must also be monotonically increasing.
Note
Toppra does not currently support plants that contain bodies with quaternion degrees of freedom. In addition, any plant where q̇ ≠ v will have undefined behavior.
Note
The path velocity, ṡ(t), is limited to be between 0 and 1e8 to ensure the reachable set calculated in the backward pass is always bounded.
- Parameter
- AddFrameAccelerationLimit(*args, **kwargs)
Overloaded function.
AddFrameAccelerationLimit(self: pydrake.multibody.optimization.Toppra, constraint_frame: pydrake.multibody.tree.Frame, lower_limit: numpy.ndarray[numpy.float64[6, 1]], upper_limit: numpy.ndarray[numpy.float64[6, 1]], discretization: pydrake.multibody.optimization.ToppraDiscretization = <ToppraDiscretization.kInterpolation: 1>) -> tuple[pydrake.solvers.Binding[LinearConstraint], pydrake.solvers.Binding[LinearConstraint]]
Adds a limit on the elements of the spatial acceleration of the given frame, measured and expressed in the world frame. The limits should be given as [α_WF, a_WF], where α_WF is the frame’s angular acceleration and a_WF is the frame’s translational acceleration.
- Parameter
constraint_frame
: The frame to limit the acceleration of.
- Parameter
lower_limit
: The lower acceleration limit for constraint_frame.
- Parameter
upper_limit
: The upper acceleration limit for constraint_frame.
- Parameter
discretization
: The discretization scheme to use for this linear constraint. See ToppraDiscretization for details.
- Returns
A pair containing the linear constraints that will enforce the frame acceleration limit on the backward pass and forward pass respectively.
AddFrameAccelerationLimit(self: pydrake.multibody.optimization.Toppra, constraint_frame: pydrake.multibody.tree.Frame, lower_limit: pydrake.trajectories.Trajectory, upper_limit: pydrake.trajectories.Trajectory, discretization: pydrake.multibody.optimization.ToppraDiscretization = <ToppraDiscretization.kInterpolation: 1>) -> tuple[pydrake.solvers.Binding[LinearConstraint], pydrake.solvers.Binding[LinearConstraint]]
A version of acceleration limit that uses a trajectory for the upper and lower limits.
- Parameter
constraint_frame
: The frame to limit the acceleration of.
- Parameter
lower_limit
: The lower acceleration limit trajectory for constraint_frame.
- Parameter
upper_limit
: The upper acceleration limit trajectory for constraint_frame.
- Parameter
discretization
: The discretization scheme to use for this linear constraint. See ToppraDiscretization for details.
- Returns
A pair containing the linear constraints that will enforce the frame acceleration limit on the backward pass and forward pass respectively.
- Precondition:
Both lower_limit and upper_limit trajectories must have values in ℜ⁶. The six-dimensional column vector is interpreted as [α_WF, a_WF], where α_WF is the frame’s angular acceleration and a_WF is the frame’s translational acceleration.
- Raises
If the intervals [upper_limit.start_time(), –
upper_limit.end_time()] and [lower_limit.start_time(), –
lower_limit.end_time()] don't overlap with [path.start_time(), –
path.end_time()] –
Note
The constraints are only added in the constraint trajectories domains (where they overlap the path). The rest of the path is not constrained.
- AddFrameTranslationalSpeedLimit(*args, **kwargs)
Overloaded function.
AddFrameTranslationalSpeedLimit(self: pydrake.multibody.optimization.Toppra, constraint_frame: pydrake.multibody.tree.Frame, upper_limit: float) -> pydrake.solvers.Binding[BoundingBoxConstraint]
Adds a limit on the magnitude of the translational velocity of the given frame, measured and expressed in the world frame.
- Parameter
constraint_frame
: The frame to limit the translational speed of.
- Parameter
upper_limit
: The upper translational speed limit for constraint_frame.
- Returns
The bounding box constraint that will enforce the frame translational speed limit during the backward pass.
AddFrameTranslationalSpeedLimit(self: pydrake.multibody.optimization.Toppra, constraint_frame: pydrake.multibody.tree.Frame, upper_limit: pydrake.trajectories.Trajectory) -> pydrake.solvers.Binding[BoundingBoxConstraint]
A version of the frame translational speed limit that uses a trajectory for the limit.
- Parameter
constraint_frame
: The frame to limit the translational speed of.
- Parameter
upper_limit
: The upper translational speed limit trajectory for constraint_frame.
- Precondition:
upper_limit must have scalar values (a 1x1 matrix).
- Returns
The bounding box constraint that will enforce the frame translational speed limit during the backward pass.
- Raises
If the interval [upper_limit.start_time(), upper_limit.end_time()] –
doesn't overlap with [path.start_time(), path.end_time()] –
Note
The constraints are only added between upper_limit.start_time() and upper_limit.end_time(). The rest of the path is not constrained.
- AddFrameVelocityLimit(self: pydrake.multibody.optimization.Toppra, constraint_frame: pydrake.multibody.tree.Frame, lower_limit: numpy.ndarray[numpy.float64[6, 1]], upper_limit: numpy.ndarray[numpy.float64[6, 1]]) pydrake.solvers.Binding[BoundingBoxConstraint]
Adds a limit on the elements of the spatial velocity of the given frame, measured and and expressed in the world frame. The limits should be given as [ω_WF, v_WF], where ω_WF is the frame’s angular velocity and v_WF is the frame’s translational velocity.
- Parameter
constraint_frame
: The frame to limit the velocity of.
- Parameter
lower_limit
: The lower velocity limit for constraint_frame.
- Parameter
upper_limit
: The upper velocity limit for constraint_frame.
- Returns
The bounding box constraint that will enforce the frame velocity limit during the backward pass.
- Parameter
- AddJointAccelerationLimit(self: pydrake.multibody.optimization.Toppra, lower_limit: numpy.ndarray[numpy.float64[m, 1]], upper_limit: numpy.ndarray[numpy.float64[m, 1]], discretization: pydrake.multibody.optimization.ToppraDiscretization = <ToppraDiscretization.kInterpolation: 1>) tuple[pydrake.solvers.Binding[LinearConstraint], pydrake.solvers.Binding[LinearConstraint]]
Adds an acceleration limit to all the degrees of freedom in the plant. The limits must be arranged in the same order as the entries in the path.
- Parameter
lower_limit
: The lower acceleration limit for each degree of freedom.
- Parameter
upper_limit
: The upper acceleration limit for each degree of freedom.
- Parameter
discretization
: The discretization scheme to use for this linear constraint. See ToppraDiscretization for details.
- Returns
A pair containing the linear constraints that will enforce the acceleration limit on the backward pass and forward pass respectively.
- Parameter
- AddJointTorqueLimit(self: pydrake.multibody.optimization.Toppra, lower_limit: numpy.ndarray[numpy.float64[m, 1]], upper_limit: numpy.ndarray[numpy.float64[m, 1]], discretization: pydrake.multibody.optimization.ToppraDiscretization = <ToppraDiscretization.kInterpolation: 1>) tuple[pydrake.solvers.Binding[LinearConstraint], pydrake.solvers.Binding[LinearConstraint]]
Adds a torque limit to all the degrees of freedom in the plant. The limits must be arranged in the same order as the entries in the path. This constrains the generalized torques applied to the plant and does not reason about contact forces.
- Parameter
lower_limit
: The lower torque limit for each degree of freedom.
- Parameter
upper_limit
: The upper torque limit for each degree of freedom.
- Parameter
discretization
: The discretization scheme to use for this linear constraint. See ToppraDiscretization for details.
- Returns
A pair containing the linear constraints that will enforce the torque limit on the backward pass and forward pass respectively.
- Parameter
- AddJointVelocityLimit(self: pydrake.multibody.optimization.Toppra, lower_limit: numpy.ndarray[numpy.float64[m, 1]], upper_limit: numpy.ndarray[numpy.float64[m, 1]]) pydrake.solvers.Binding[BoundingBoxConstraint]
Adds a velocity limit to all the degrees of freedom in the plant. The limits must be arranged in the same order as the entries in the path.
- Parameter
lower_limit
: The lower velocity limit for each degree of freedom.
- Parameter
upper_limit
: The upper velocity limit for each degree of freedom.
- Parameter
- static CalcGridPoints(path: pydrake.trajectories.Trajectory, options: pydrake.multibody.optimization.CalcGridPointsOptions) numpy.ndarray[numpy.float64[m, 1]]
Takes a path and generates a sequence of gridpoints selected to control the interpolation error of the optimization. The gridpoints are selected such that the distance between them is below
max_seg_length
, there are at leastmin_points
number of gridpoints and the interpolation error, estimated with the equationClick to expand C++ code...
errₑₛₜ = max(|q̈ Δₛ²|) / 2
where Δₛ is the distance between sequential gridpoints, is less than
max_err
. Gridpoints are selected by adding the midpoint between two gridpoints whenever the distance between them is too large or the estimated error is too high. This results in more points in parts of the path with higher curvature. All grid points will lie between path.start_time() and path.end_time().
- SolvePathParameterization(self: pydrake.multibody.optimization.Toppra, s_dot_start: float = 0, s_dot_end: float = 0) Optional[pydrake.trajectories.PiecewisePolynomial]
Solves the TOPPRA optimization and returns the time optimized path parameterization s(t). This can be used with the original path q(s) to generate a time parameterized trajectory. The path parameterization has the same start time as the original path’s starting break.
- Parameter
s_dot_start
: ṡ(0). The default value is zero (trajectory starts at zero velocity).
- Parameter
s_dot_end
: ṡ(T), where T is the end break of the path. The default value is zero (trajectory ends at zero velocity).
- Parameter
- class pydrake.multibody.optimization.ToppraDiscretization
Selects how linear constraints are enforced for TOPPRA’s optimization. kCollocation - enforces constraints only at each gridpoint. kInterpolation - enforces constraints at each gridpoint and at the following gridpoint using forward integration. Yields higher accuracy at minor computational cost.
Members:
kCollocation :
kInterpolation :
- __init__(self: pydrake.multibody.optimization.ToppraDiscretization, value: int) None
- kCollocation = <ToppraDiscretization.kCollocation: 0>
- kInterpolation = <ToppraDiscretization.kInterpolation: 1>
- property name
- property value