tesseract_robotics.trajopt_ifopt¶

Robotics-specific constraints and variables for trajectory optimization.

Overview¶

Python

from tesseract_robotics.trajopt_ifopt import (
    # Variables
    JointPosition,
    # Joint constraints
    JointPosConstraint, JointVelConstraint, JointAccelConstraint, JointJerkConstraint,
    # Cartesian constraints
    CartPosInfo, CartPosConstraint, CartLineInfo, CartLineConstraint,
    # Collision constraints
    TrajOptCollisionConfig, DiscreteCollisionConstraint, ContinuousCollisionConstraint,
    # IK constraint
    InverseKinematicsInfo, InverseKinematicsConstraint,
    # Utilities
    interpolate, toBounds,
)

Variables¶

JointPosition¶

Optimization variable representing joint configuration at a timestep.

Python

from tesseract_robotics.trajopt_ifopt import JointPosition
import numpy as np

joint_names = ["joint_1", "joint_2", "joint_3", "joint_4", "joint_5", "joint_6"]
initial_values = np.array([0.0, -0.5, 0.5, 0.0, 0.5, 0.0])

# Create variable
var = JointPosition(initial_values, joint_names, "position_0")

# Access values
print(f"Values: {var.GetValues()}")
print(f"Names: {var.GetJointNames()}")

# Set bounds
from tesseract_robotics.ifopt import Bounds
bounds = [Bounds(-3.14, 3.14) for _ in range(6)]
var.SetBounds(bounds)

Method	Returns	Description
`GetValues()`	`np.ndarray`	Current joint values
`SetVariables(x)`	`None`	Set joint values
`GetJointNames()`	`list[str]`	Joint names
`GetBounds()`	`list[Bounds]`	Joint limits
`SetBounds(bounds)`	`None`	Set joint limits

Joint Constraints¶

JointPosConstraint¶

Constrain joint positions to target values.

Python

from tesseract_robotics.trajopt_ifopt import JointPosConstraint
import numpy as np

targets = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])  # home position
coeffs = np.ones(6)  # weight per joint

constraint = JointPosConstraint(targets, position_var, coeffs, "joint_pos")

JointVelConstraint¶

Constrain joint velocities between consecutive timesteps.

Python

from tesseract_robotics.trajopt_ifopt import JointVelConstraint

targets = np.zeros(6)  # zero velocity
coeffs = np.ones(6)

# Requires two consecutive position variables
constraint = JointVelConstraint(targets, [pos_var_0, pos_var_1], coeffs, "joint_vel")

JointAccelConstraint¶

Constrain joint accelerations (requires 3 consecutive positions).

Python

from tesseract_robotics.trajopt_ifopt import JointAccelConstraint

targets = np.zeros(6)
coeffs = np.ones(6)

constraint = JointAccelConstraint(
    targets, [pos_var_0, pos_var_1, pos_var_2], coeffs, "joint_accel"
)

JointJerkConstraint¶

Constrain joint jerk (requires 4 consecutive positions).

Python

from tesseract_robotics.trajopt_ifopt import JointJerkConstraint

targets = np.zeros(6)
coeffs = np.ones(6)

constraint = JointJerkConstraint(
    targets, [pos_var_0, pos_var_1, pos_var_2, pos_var_3], coeffs, "joint_jerk"
)

Cartesian Constraints¶

CartPosInfo / CartPosConstraint¶

Constrain TCP to a Cartesian pose.

Python

from tesseract_robotics.trajopt_ifopt import CartPosInfo, CartPosInfoType, CartPosConstraint
from tesseract_robotics.tesseract_common import Isometry3d

# Create info struct
info = CartPosInfo()
info.manip = kin_group  # KinematicGroup from env.getKinematicGroup()
info.source_frame = "tool0"
info.target_frame = "base_link"
info.target_frame_offset = target_pose  # Isometry3d

# Constraint indices (which DoFs to constrain)
# CartPosInfoType: FULL (all 6), POSITION_ONLY (xyz), ORIENTATION_ONLY (rpy)
info.indices = [0, 1, 2, 3, 4, 5]  # all 6 DoF

# Create constraint
coeffs = np.array([10.0, 10.0, 10.0, 5.0, 5.0, 5.0])  # xyz, rpy weights
constraint = CartPosConstraint(info, position_var, coeffs, "cart_pos")

# Get current error
values = constraint.GetValues()

CartLineInfo / CartLineConstraint¶

Constrain TCP to lie on a line between two points.

Python

from tesseract_robotics.trajopt_ifopt import CartLineInfo, CartLineConstraint

info = CartLineInfo()
info.manip = kin_group
info.source_frame = "tool0"
info.target_frame = "base_link"
info.target_frame_offset1 = line_start  # Isometry3d
info.target_frame_offset2 = line_end    # Isometry3d

constraint = CartLineConstraint(info, position_var, coeffs, "cart_line")

Collision Constraints¶

TrajOptCollisionConfig¶

Configuration for collision checking.

Python

from tesseract_robotics.trajopt_ifopt import TrajOptCollisionConfig

config = TrajOptCollisionConfig()
config.contact_manager_config.margin_data_override_type = 0
config.contact_manager_config.margin_data.setDefaultCollisionMargin(0.025)
config.collision_margin_buffer = 0.01
config.collision_coeff_data.default_collision_coeff = 20.0

Attribute	Type	Description
`contact_manager_config`	object	Contact manager settings
`collision_margin_buffer`	`float`	Safety margin buffer
`collision_coeff_data`	object	Collision cost coefficients

DiscreteCollisionConstraint¶

Collision avoidance at a single configuration.

Python

from tesseract_robotics.trajopt_ifopt import (
    DiscreteCollisionConstraint, SingleTimestepCollisionEvaluator, CollisionCache
)

# Create evaluator
cache = CollisionCache(100)
evaluator = SingleTimestepCollisionEvaluator(
    cache, kin_group, env, config, True  # True = dynamic environment
)

# Create constraint
constraint = DiscreteCollisionConstraint(
    evaluator,
    position_var,
    max_num_cnt=3,       # max collision pairs
    fixed_sparsity=False,
    name="collision"
)

ContinuousCollisionConstraint¶

Collision avoidance between consecutive configurations (swept volume).

Python

from tesseract_robotics.trajopt_ifopt import (
    ContinuousCollisionConstraint, LVSContinuousCollisionEvaluator
)

# LVS = Longest Valid Segment (interpolates and checks)
evaluator = LVSContinuousCollisionEvaluator(
    cache, kin_group, env, config, True
)

# Constraint between two consecutive position variables
constraint = ContinuousCollisionConstraint(
    evaluator,
    position_var_0,
    position_var_1,
    max_num_cnt=3,
    fixed_sparsity=False,
    name="continuous_collision"
)

Collision Evaluators¶

Class	Description
`SingleTimestepCollisionEvaluator`	Discrete check at single config
`LVSDiscreteCollisionEvaluator`	Discrete checks at interpolated points
`LVSContinuousCollisionEvaluator`	Swept volume collision check

IK Constraint¶

InverseKinematicsInfo / InverseKinematicsConstraint¶

Constrain variables to match IK solution.

Python

from tesseract_robotics.trajopt_ifopt import InverseKinematicsInfo, InverseKinematicsConstraint

info = InverseKinematicsInfo()
info.manip = kin_group
info.working_frame = "base_link"
info.tcp_frame = "tool0"
info.tcp_offset = Isometry3d.Identity()

constraint = InverseKinematicsConstraint(
    target_pose,      # Isometry3d
    info,
    constraint_var,   # variable to constrain
    seed_var,         # seed for IK
    "ik_constraint"
)

Utilities¶

interpolate¶

Linear interpolation between joint configurations.

Python

from tesseract_robotics.trajopt_ifopt import interpolate
import numpy as np

start = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
end = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
steps = 10

trajectory = interpolate(start, end, steps)  # (10, 6) array

toBounds¶

Convert numpy arrays to ifopt Bounds.

Python

from tesseract_robotics.trajopt_ifopt import toBounds
import numpy as np

lower = np.array([-3.14, -3.14, -3.14])
upper = np.array([3.14, 3.14, 3.14])

bounds = toBounds(lower, upper)  # list[Bounds]

Auto-generated API Reference¶

BoundsType ¶

Bases: Enum

UNBOUNDED `class-attribute` `instance-attribute` ¶

Python

UNBOUNDED = 0

EQUALITY `class-attribute` `instance-attribute` ¶

Python

EQUALITY = 1

LOWER_BOUND `class-attribute` `instance-attribute` ¶

Python

LOWER_BOUND = 2

UPPER_BOUND `class-attribute` `instance-attribute` ¶

Python

UPPER_BOUND = 3

RANGE_BOUND `class-attribute` `instance-attribute` ¶

Python

RANGE_BOUND = 4

RangeBoundHandling ¶

Bases: Enum

KEEP_AS_IS `class-attribute` `instance-attribute` ¶

Python

KEEP_AS_IS = 0

SPLIT_TO_TWO_INEQUALITIES `class-attribute` `instance-attribute` ¶

Python

SPLIT_TO_TWO_INEQUALITIES = 1

Bounds ¶

init ¶

Python

__init__(lower: float = 0.0, upper: float = 0.0) -> None

Create bounds with lower and upper limits

set ¶

Python

set(lower: float, upper: float) -> None

Set both lower and upper bounds

setLower ¶

Python

setLower(lower: float) -> None

Set the lower bound

getLower ¶

Python

getLower() -> float

Get the lower bound value

setUpper ¶

Python

setUpper(upper: float) -> None

Set the upper bound

getUpper ¶

Python

getUpper() -> float

Get the upper bound value

getType ¶

Python

getType() -> BoundsType

Get the cached bound classification

Component ¶

getName ¶

Python

getName() -> str

Get the component name

getRows ¶

Python

getRows() -> int

Get the number of rows

Variables ¶

Bases: Component

getValues ¶

Python

getValues() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Get the current variable values

setVariables ¶

Python

setVariables(x: Annotated[NDArray[float64], dict(shape=(None,), order=C)]) -> None

Set the variable values from a flat decision vector

getBounds ¶

Python

getBounds() -> list[Bounds]

Get the variable bounds

getHash ¶

Python

getHash() -> int

Get the variable hash for caching

Differentiable ¶

Bases: Component

isDynamic ¶

Python

isDynamic() -> bool

Whether this component can change its number of rows

isScalar ¶

Python

isScalar() -> bool

Whether this component is scalar or stacked

getNonZeros ¶

Python

getNonZeros() -> int

Estimated number of non-zero entries in the Jacobian

update ¶

Python

update() -> int

Recompute sizing/state for dynamic-sized components

getCoefficients ¶

Python

getCoefficients() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Get the coefficient vector

ConstraintSet ¶

Bases: Differentiable

init ¶

Python

__init__(name: str, n_constraints: int) -> None

Create a constraint set with name and number of constraints

linkWithVariables ¶

Python

linkWithVariables(x: Variables) -> None

Connect the constraint with the optimization variables

getVariables ¶

Python

getVariables() -> Variables

Get the linked optimization variables (protected in C++, exposed via trampoline)

getValues ¶

Python

getValues() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Get the current constraint values

getBounds ¶

Python

getBounds() -> list[Bounds]

Get the constraint bounds

getJacobian ¶

Python

getJacobian() -> scipy.sparse.csr_matrix

Get the constraint Jacobian (sparse matrix)

Var ¶

getIdentifier ¶

Python

getIdentifier() -> str

Get the identifier for the variable segment

getIndex ¶

Python

getIndex() -> int

Get the starting index of this variable segment

size ¶

Python

size() -> int

Get the number of elements in this variable segment

value ¶

Python

value() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Get the current variable values

name ¶

Python

name() -> list[str]

Get the variable names

bounds ¶

Python

bounds() -> list[Bounds]

Get the variable bounds

setVariables ¶

Python

setVariables(x: Annotated[NDArray[float64], dict(shape=(None,), writable=False)]) -> None

Set the variable values from the full decision vector

Node ¶

init ¶

Python

__init__(node_name: str = 'Node') -> None

Create a node with an optional name

getName ¶

Python

getName() -> str

Get the name of this node

hasVar ¶

Python

hasVar(name: str) -> bool

Check whether this node has a variable by name

getVar ¶

Python

getVar(name: str) -> Var

Get a variable by name

getValues ¶

Python

getValues() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Get all variable values as a single vector

getBounds ¶

Python

getBounds() -> list[Bounds]

Get all variable bounds

size ¶

Python

size() -> int

Get total number of scalar decision variables

setVariables ¶

Python

setVariables(x: Annotated[NDArray[float64], dict(shape=(None,), writable=False)]) -> None

Update all variable values from the full decision vector

NodesVariables ¶

Bases: Variables

getNode ¶

Python

getNode(opt_idx: int) -> Node

Get node based on index

getNodes ¶

Python

getNodes() -> list[Node]

Get all nodes

getDim ¶

Python

getDim() -> int

Get the dimensions of every node

CartPosConstraint ¶

Bases: ConstraintSet

use_numeric_differentiation `property` `writable` ¶

Python

use_numeric_differentiation: bool

If true, use numeric differentiation (default: true)

init ¶

Python

__init__(position_var: Var, manip: 'tesseract_kinematics::JointGroup', source_frame: str, target_frame: str, source_frame_offset: 'Eigen::Transform<double, 3, 1, 0>', target_frame_offset: 'Eigen::Transform<double, 3, 1, 0>', name: str = 'CartPos', range_bound_handling: RangeBoundHandling = RangeBoundHandling.SPLIT_TO_TWO_INEQUALITIES) -> None

Create Cartesian position constraint

calcValues ¶

Python

calcValues(joint_vals: Annotated[NDArray[float64], dict(shape=(None,), writable=False)]) -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Calculate error values for given joint values

getValues ¶

Python

getValues() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Get current constraint values

setTargetPose ¶

Python

setTargetPose(target_frame_offset: 'Eigen::Transform<double, 3, 1, 0>') -> None

Set the target pose - critical for online planning!

getTargetPose ¶

Python

getTargetPose() -> 'Eigen::Transform<double, 3, 1, 0>'

Get the target pose for the constraint

getCurrentPose ¶

Python

getCurrentPose() -> 'Eigen::Transform<double, 3, 1, 0>'

Get current TCP pose in world frame

JointPosConstraint ¶

Bases: ConstraintSet

init ¶

Python

__init__(target: Annotated[NDArray[float64], dict(shape=(None,), order=C)], position_var: Var, coeffs: Annotated[NDArray[float64], dict(shape=(None,), order=C)], name: str = 'JointPos', range_bound_handling: RangeBoundHandling = RangeBoundHandling.SPLIT_TO_TWO_INEQUALITIES) -> None

Create joint position constraint with target values

getValues ¶

Python

getValues() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Get current constraint values

JointVelConstraint ¶

Bases: ConstraintSet

init ¶

Python

__init__(targets: Annotated[NDArray[float64], dict(shape=(None,), order=C)], position_vars: Sequence[Var], coeffs: Annotated[NDArray[float64], dict(shape=(None,), order=C)], name: str = 'JointVel') -> None

Create joint velocity constraint with target values

getValues ¶

Python

getValues() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Get current constraint values

JointAccelConstraint ¶

Bases: ConstraintSet

init ¶

Python

__init__(targets: Annotated[NDArray[float64], dict(shape=(None,), order=C)], position_vars: Sequence[Var], coeffs: Annotated[NDArray[float64], dict(shape=(None,), order=C)], name: str = 'JointAccel') -> None

Create joint acceleration constraint with target values

getValues ¶

Python

getValues() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Get current constraint values

CollisionCoeffData ¶

setDefaultCollisionCoeff ¶

Python

setDefaultCollisionCoeff(arg: float) -> None

getDefaultCollisionCoeff ¶

Python

getDefaultCollisionCoeff() -> float

setCollisionCoeff ¶

Python

setCollisionCoeff(obj1: str, obj2: str, collision_coeff: float) -> None

getCollisionCoeff ¶

Python

getCollisionCoeff(obj1: str, obj2: str) -> float

setPairCollisionCoeff ¶

Python

setPairCollisionCoeff(obj1: str, obj2: str, collision_coeff: float) -> None

getPairCollisionCoeff ¶

Python

getPairCollisionCoeff(obj1: str, obj2: str) -> float

TrajOptCollisionConfig ¶

enabled `property` `writable` ¶

Python

enabled: bool

contact_manager_config `property` `writable` ¶

Python

contact_manager_config: ContactManagerConfig

collision_check_config `property` `writable` ¶

Python

collision_check_config: CollisionCheckConfig

collision_coeff_data `property` `writable` ¶

Python

collision_coeff_data: CollisionCoeffData

collision_margin_buffer `property` `writable` ¶

Python

collision_margin_buffer: float

max_num_cnt `property` `writable` ¶

Python

max_num_cnt: int

DiscreteCollisionEvaluator ¶

getCollisionMarginBuffer ¶

Python

getCollisionMarginBuffer() -> float

getCollisionMarginData ¶

Python

getCollisionMarginData() -> 'tesseract_common::CollisionMarginData'

getCollisionCoeffData ¶

Python

getCollisionCoeffData() -> CollisionCoeffData

SingleTimestepCollisionEvaluator ¶

Bases: DiscreteCollisionEvaluator

init ¶

Python

__init__(manip: 'tesseract_kinematics::JointGroup', env: 'tesseract_environment::Environment', collision_config: TrajOptCollisionConfig, dynamic_environment: bool = False) -> None

DiscreteCollisionConstraint ¶

Bases: ConstraintSet

init ¶

Python

__init__(collision_evaluator: DiscreteCollisionEvaluator, position_var: Var, max_num_cnt: int = 1, fixed_sparsity: bool = False, name: str = 'DiscreteCollision') -> None

getValues ¶

Python

getValues() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

getCollisionEvaluator ¶

Python

getCollisionEvaluator() -> DiscreteCollisionEvaluator

ContinuousCollisionEvaluator ¶

getCollisionMarginBuffer ¶

Python

getCollisionMarginBuffer() -> float

getCollisionMarginData ¶

Python

getCollisionMarginData() -> 'tesseract_common::CollisionMarginData'

getCollisionCoeffData ¶

Python

getCollisionCoeffData() -> CollisionCoeffData

LVSDiscreteCollisionEvaluator ¶

Bases: ContinuousCollisionEvaluator

init ¶

Python

__init__(manip: 'tesseract_kinematics::JointGroup', env: 'tesseract_environment::Environment', collision_config: TrajOptCollisionConfig, dynamic_environment: bool = False) -> None

LVSContinuousCollisionEvaluator ¶

Bases: ContinuousCollisionEvaluator

init ¶

Python

__init__(manip: 'tesseract_kinematics::JointGroup', env: 'tesseract_environment::Environment', collision_config: TrajOptCollisionConfig, dynamic_environment: bool = False) -> None

ContinuousCollisionConstraint ¶

Bases: ConstraintSet

init ¶

Python

__init__(collision_evaluator: ContinuousCollisionEvaluator, position_var0: Var, position_var1: Var, fixed0: bool = False, fixed1: bool = False, max_num_cnt: int = 1, fixed_sparsity: bool = False, name: str = 'LVSCollision') -> None

getValues ¶

Python

getValues() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

getCollisionEvaluator ¶

Python

getCollisionEvaluator() -> ContinuousCollisionEvaluator

JointJerkConstraint ¶

Bases: ConstraintSet

init ¶

Python

__init__(targets: Annotated[NDArray[float64], dict(shape=(None,), order=C)], position_vars: Sequence[Var], coeffs: Annotated[NDArray[float64], dict(shape=(None,), order=C)], name: str = 'JointJerk') -> None

Create joint jerk constraint (requires 4+ consecutive waypoints)

getValues ¶

Python

getValues() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Get current constraint values

CartLineInfo ¶

manip `property` `writable` ¶

Python

manip: 'tesseract_kinematics::JointGroup'

The joint group

source_frame `property` `writable` ¶

Python

source_frame: str

TCP frame

target_frame `property` `writable` ¶

Python

target_frame: str

Reference frame

source_frame_offset `property` `writable` ¶

Python

source_frame_offset: 'Eigen::Transform<double, 3, 1, 0>'

TCP offset

target_frame_offset1 `property` `writable` ¶

Python

target_frame_offset1: 'Eigen::Transform<double, 3, 1, 0>'

Line start pose

target_frame_offset2 `property` `writable` ¶

Python

target_frame_offset2: 'Eigen::Transform<double, 3, 1, 0>'

Line end pose

indices `property` `writable` ¶

Python

indices: Annotated[NDArray[int32], dict(shape=(None,), order=C)]

DOF indices to constrain: default {0,1,2,3,4,5}

init ¶

Python

__init__() -> None

CartLineConstraint ¶

Bases: ConstraintSet

use_numeric_differentiation `property` `writable` ¶

Python

use_numeric_differentiation: bool

If true, use numeric differentiation (default: true)

init ¶

Python

__init__(info: CartLineInfo, position_var: Var, coeffs: Annotated[NDArray[float64], dict(shape=(None,), order=C)], name: str = 'CartLine') -> None

Create Cartesian line constraint

getValues ¶

Python

getValues() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Get current constraint values

calcValues ¶

Python

calcValues(joint_vals: Annotated[NDArray[float64], dict(shape=(None,), writable=False)]) -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Calculate error values for given joint values

getLinePoint ¶

Python

getLinePoint(source_tf: 'Eigen::Transform<double, 3, 1, 0>', target_tf1: 'Eigen::Transform<double, 3, 1, 0>', target_tf2: 'Eigen::Transform<double, 3, 1, 0>') -> 'Eigen::Transform<double, 3, 1, 0>'

Find nearest point on line (uses SLERP for orientation)

DiscreteCollisionNumericalConstraint ¶

Bases: ConstraintSet

init ¶

Python

__init__(collision_evaluator: DiscreteCollisionEvaluator, position_var: Var, max_num_cnt: int = 1, fixed_sparsity: bool = False, name: str = 'DiscreteCollisionNumerical') -> None

Create discrete collision constraint with numerical jacobians

getValues ¶

Python

getValues() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

calcValues ¶

Python

calcValues(joint_vals: Annotated[NDArray[float64], dict(shape=(None,), writable=False)]) -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

getCollisionEvaluator ¶

Python

getCollisionEvaluator() -> DiscreteCollisionEvaluator

InverseKinematicsInfo ¶

manip `property` `writable` ¶

Python

manip: 'tesseract_kinematics::KinematicGroup'

The kinematic group (with IK solver)

working_frame `property` `writable` ¶

Python

working_frame: str

Working frame (not currently used)

tcp_frame `property` `writable` ¶

Python

tcp_frame: str

TCP frame (not currently used)

tcp_offset `property` `writable` ¶

Python

tcp_offset: 'Eigen::Transform<double, 3, 1, 0>'

TCP offset (not currently used)

init ¶

Python

__init__() -> None

InverseKinematicsConstraint ¶

Bases: ConstraintSet

init ¶

Python

__init__(target_pose: 'Eigen::Transform<double, 3, 1, 0>', kinematic_info: InverseKinematicsInfo, constraint_var: Var, seed_var: Var, name: str = 'InverseKinematics') -> None

Create IK constraint (constraint_var constrained to IK solution seeded from seed_var)

getValues ¶

Python

getValues() -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]

Get current constraint values

createNodesVariables ¶

Python

createNodesVariables(variable_name: str, joint_names: Sequence[str], initial_values: Sequence[Annotated[NDArray[float64], dict(shape=(None,), order=C)]], bounds: Sequence[Bounds]) -> NodesVariables

Create NodesVariables with one vector Var per node.

Parameters:

Name	Type	Description	Default
`variable_name`	`str`	Name for the variable set	required
`joint_names`	`Sequence[str]`	Joint name for each DOF	required
`initial_values`	`Sequence[Annotated[NDArray[float64], dict(shape=(None,), order=C)]]`	List of initial joint value vectors (one per waypoint)	required
`bounds`	`Sequence[Bounds]`	Joint bounds (shared across all waypoints)	required

interpolate ¶

Python

interpolate(start: Annotated[NDArray[float64], dict(shape=(None,), writable=False)], end: Annotated[NDArray[float64], dict(shape=(None,), writable=False)], steps: int) -> list[Annotated[NDArray[numpy.float64], dict(shape=(None,), order=C)]]

Interpolate between two joint vectors, returning 'steps' waypoints

tesseract_robotics.trajopt_ifopt¶

Overview¶

Variables¶

JointPosition¶

Joint Constraints¶

JointPosConstraint¶

JointVelConstraint¶

JointAccelConstraint¶

JointJerkConstraint¶

Cartesian Constraints¶

CartPosInfo / CartPosConstraint¶

CartLineInfo / CartLineConstraint¶

Collision Constraints¶

TrajOptCollisionConfig¶

DiscreteCollisionConstraint¶

ContinuousCollisionConstraint¶

Collision Evaluators¶

IK Constraint¶

InverseKinematicsInfo / InverseKinematicsConstraint¶

Utilities¶

interpolate¶

toBounds¶

Auto-generated API Reference¶

BoundsType ¶

UNBOUNDED class-attribute instance-attribute ¶

EQUALITY class-attribute instance-attribute ¶

LOWER_BOUND class-attribute instance-attribute ¶

UPPER_BOUND class-attribute instance-attribute ¶

RANGE_BOUND class-attribute instance-attribute ¶

RangeBoundHandling ¶

KEEP_AS_IS class-attribute instance-attribute ¶

SPLIT_TO_TWO_INEQUALITIES class-attribute instance-attribute ¶

Bounds ¶

__init__ ¶

set ¶

setLower ¶

getLower ¶

setUpper ¶

getUpper ¶

getType ¶

Component ¶

getName ¶

getRows ¶

Variables ¶

getValues ¶

setVariables ¶

getBounds ¶

getHash ¶

Differentiable ¶

isDynamic ¶

isScalar ¶

getNonZeros ¶

update ¶

getCoefficients ¶

ConstraintSet ¶

__init__ ¶

linkWithVariables ¶

getVariables ¶

getValues ¶

getBounds ¶

getJacobian ¶

Var ¶

getIdentifier ¶

getIndex ¶

size ¶

value ¶

name ¶

bounds ¶

setVariables ¶

Node ¶

__init__ ¶

getName ¶

hasVar ¶

getVar ¶

getValues ¶

getBounds ¶

size ¶

setVariables ¶

NodesVariables ¶

getNode ¶

UNBOUNDED `class-attribute` `instance-attribute` ¶

EQUALITY `class-attribute` `instance-attribute` ¶

LOWER_BOUND `class-attribute` `instance-attribute` ¶

UPPER_BOUND `class-attribute` `instance-attribute` ¶

RANGE_BOUND `class-attribute` `instance-attribute` ¶

KEEP_AS_IS `class-attribute` `instance-attribute` ¶

SPLIT_TO_TWO_INEQUALITIES `class-attribute` `instance-attribute` ¶

init ¶

init ¶

init ¶

use_numeric_differentiation `property` `writable` ¶

init ¶

init ¶

init ¶

init ¶

enabled `property` `writable` ¶

contact_manager_config `property` `writable` ¶

collision_check_config `property` `writable` ¶

collision_coeff_data `property` `writable` ¶

collision_margin_buffer `property` `writable` ¶

max_num_cnt `property` `writable` ¶

init ¶

init ¶

init ¶

init ¶

init ¶

init ¶

manip `property` `writable` ¶

source_frame `property` `writable` ¶

target_frame `property` `writable` ¶

source_frame_offset `property` `writable` ¶

target_frame_offset1 `property` `writable` ¶

target_frame_offset2 `property` `writable` ¶

indices `property` `writable` ¶

init ¶

use_numeric_differentiation `property` `writable` ¶

init ¶