Skip to content

tesseract_robotics.tesseract_command_language

Motion program instructions and waypoints.

Overview

The command language defines motion tasks as a tree of instructions:

Text Only
CompositeInstruction (program)
├── MoveInstruction (freespace to via point)
├── MoveInstruction (linear to target)
└── CompositeInstruction (sub-program)
    ├── MoveInstruction
    └── MoveInstruction

Waypoints

StateWaypoint

Joint-space target (specific joint values).

Python
from tesseract_robotics.tesseract_command_language import (
    StateWaypoint, StateWaypointPoly, StateWaypointPoly_wrap_StateWaypoint
)
import numpy as np

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

# Create waypoint
wp = StateWaypoint(joint_names, joint_values)

# Wrap in polymorphic type (required for instructions)
wp_poly = StateWaypointPoly_wrap_StateWaypoint(wp)

# Access values
print(f"Names: {wp.getNames()}")
print(f"Position: {wp.getPosition()}")

CartesianWaypoint

Cartesian-space target (pose).

Python
from tesseract_robotics.tesseract_command_language import (
    CartesianWaypoint, CartesianWaypointPoly, CartesianWaypointPoly_wrap_CartesianWaypoint
)
from tesseract_robotics.tesseract_common import Isometry3d
import numpy as np

# Create target pose (build the 4x4 matrix then wrap)
mat = np.eye(4)
mat[:3, 3] = [0.5, 0.2, 0.3]
pose = Isometry3d(mat)

# Create waypoint
wp = CartesianWaypoint(pose)

# With seed (initial joint guess for IK)
wp = CartesianWaypoint(pose)
wp.setSeed(seed_state)  # StateWaypointPoly

# Wrap in polymorphic type
wp_poly = CartesianWaypointPoly_wrap_CartesianWaypoint(wp)

JointWaypoint

Named joint positions (subset of joints).

Python
from tesseract_robotics.tesseract_command_language import (
    JointWaypoint, JointWaypointPoly, JointWaypointPoly_wrap_JointWaypoint
)

names = ["joint_1", "joint_3"]
values = np.array([0.5, -0.5])

wp = JointWaypoint(names, values)
wp_poly = JointWaypointPoly_wrap_JointWaypoint(wp)

Instructions

MoveInstruction

Single motion command.

Python
from tesseract_robotics.tesseract_command_language import (
    MoveInstruction, MoveInstructionPoly, MoveInstructionPoly_wrap_MoveInstruction,
    MoveInstructionType
)

# Create move instruction
instr = MoveInstruction(wp_poly, MoveInstructionType.FREESPACE, "DEFAULT")

# With specific profile
instr = MoveInstruction(wp_poly, MoveInstructionType.LINEAR, "my_profile")

# Wrap in polymorphic type
instr_poly = MoveInstructionPoly_wrap_MoveInstruction(instr)

# Access properties
print(f"Profile: {instr.getProfile()}")
print(f"Type: {instr.getMoveType()}")
waypoint = instr.getWaypoint()

MoveInstructionType

Type Description Typical Planner
FREESPACE Any collision-free path OMPL
LINEAR Straight Cartesian line TrajOpt
CIRCULAR Circular arc Specialized

CompositeInstruction

Container for multiple instructions.

Python
from tesseract_robotics.tesseract_command_language import (
    CompositeInstruction, CompositeInstructionOrder
)

# Create program
program = CompositeInstruction("DEFAULT")

# Set manipulator info
from tesseract_robotics.tesseract_common import ManipulatorInfo
manip_info = ManipulatorInfo()
manip_info.manipulator = "manipulator"
manip_info.tcp_frame = "tool0"
manip_info.working_frame = "base_link"
program.setManipulatorInfo(manip_info)

# Add instructions
program.appendMoveInstruction(move1)
program.appendMoveInstruction(move2)

# push_back accepts either a single Instruction or a nested CompositeInstruction
# (0.35+) so raster-style programs can be built the same way they are in C++:
program.push_back(sub_composite)

# Iterate instructions
for instr in program.getInstructions():
    pass

CompositeInstructionOrder

Order Description
ORDERED Execute in sequence
UNORDERED Can be reordered
ORDERED_AND_REVERTED Sequence, can reverse

Non-Motion Instructions

Programs can also contain non-motion instructions: timed waits, IO handshakes, analog/digital setpoint changes, and tool changes. These are typically passed through the planning pipeline unchanged and acted on at runtime by the trajectory executor.

Concrete instruction types (WaitInstruction, TimerInstruction, SetAnalogInstruction, SetDigitalInstruction, SetToolInstruction) can be pushed directly into a CompositeInstruction via push_back — implicit conversion to InstructionPoly is registered so no explicit wrap is needed.

WaitInstruction

Pause execution for a fixed duration or until an IO line transitions.

Python
from tesseract_robotics.tesseract_command_language import (
    WaitInstruction, WaitInstructionType,
)

# Time-based wait
program.push_back(WaitInstruction(0.5))  # wait 0.5 seconds

# IO handshake — wait until digital input 3 goes high
program.push_back(WaitInstruction(WaitInstructionType.DIGITAL_INPUT_HIGH, 3))
WaitInstructionType Behaviour
TIME Wait time seconds
DIGITAL_INPUT_HIGH / DIGITAL_INPUT_LOW Block until input io is high / low
DIGITAL_OUTPUT_HIGH / DIGITAL_OUTPUT_LOW Block until output io is high / low

TimerInstruction

Start a timer that, on expiry, drives a digital output high or low.

Python
from tesseract_robotics.tesseract_command_language import (
    TimerInstruction, TimerInstructionType,
)

program.push_back(
    TimerInstruction(TimerInstructionType.DIGITAL_OUTPUT_HIGH, 2.0, 4)
)

SetAnalogInstruction / SetDigitalInstruction

Drive an analog or digital channel.

Python
from tesseract_robotics.tesseract_command_language import (
    SetAnalogInstruction, SetDigitalInstruction,
)

# Analog: set channel ("speed", index 1) to 0.75
program.push_back(SetAnalogInstruction("speed", 1, 0.75))

# Digital: open the gripper
program.push_back(SetDigitalInstruction("gripper", 2, True))

SetToolInstruction

Activate a tool by ID.

Python
from tesseract_robotics.tesseract_command_language import SetToolInstruction

program.push_back(SetToolInstruction(5))

Iteration and dispatch

When iterating a CompositeInstruction, each child is an InstructionPoly. Use the is*Instruction predicates to dispatch and as*Instruction to obtain the concrete value.

Python
for i in range(len(program)):
    child = program[i]
    if child.isMoveInstruction():
        mi = child.asMoveInstruction()
    elif child.isWaitInstruction():
        wi = child.asWaitInstruction()
    elif child.isTimerInstruction():
        ti = child.asTimerInstruction()
    elif child.isSetAnalogInstruction():
        si = child.asSetAnalogInstruction()
    elif child.isSetDigitalInstruction():
        si = child.asSetDigitalInstruction()
    elif child.isSetToolInstruction():
        si = child.asSetToolInstruction()
    elif child.isCompositeInstruction():
        sub = child.asCompositeInstruction()

as*Instruction raises RuntimeError if the underlying type does not match — always guard with the matching is*Instruction predicate.

Traversal into child composites

flatten, getFirst/LastInstruction, getFirst/LastMoveInstruction and the counts descend into child composites. They return references into the program: an edit through a returned instruction changes the program, and the returned objects keep it alive. A filter is any callable filter(instruction, parent) -> bool; moveFilter keeps move instructions.

References returned by flatten, __getitem__, front and back dangle after insert, __delitem__/erase or push_back on the composite; take a copy (copy.copy) if you need to keep one.

Python
from tesseract_robotics.tesseract_command_language import moveFilter, toJointTrajectory

moves = program.flatten(moveFilter)        # every move, at any depth
first = program.getFirstMoveInstruction()  # MoveInstructionPoly, or None
trajectory = toJointTrajectory(program)    # tesseract_common.JointTrajectory

toJointTrajectory, getJointPosition, formatJointPosition, clampToJointLimits and the other functions of tesseract/command_language/utils.h take a WaypointPoly. The in-place ones (formatJointPosition, setJointPosition, clampToJointLimits) edit the WaypointPoly passed in, for example move.getWaypoint().

Equality, UUIDs and copies

Waypoints, instructions and their Polys compare by value (==) and are unhashable. Every instruction carries a UUID and a parent UUID, read and set as canonical strings (getUUID, setUUID, getParentUUID, setParentUUID, regenerateUUID; a malformed string raises ValueError). MoveInstruction equality compares both UUIDs, so two move instructions built separately from the same arguments are unequal until the UUIDs are copied over. copy.copy and copy.deepcopy copy any of these types; both give an independent copy that keeps the UUIDs.

Profiles

ProfileDictionary

Container for planner profiles.

Python
from tesseract_robotics.tesseract_command_language import (
    ProfileDictionary, ProfileDictionary_addProfile
)

profiles = ProfileDictionary()

# Add profiles (type-specific functions)
from tesseract_robotics.tesseract_motion_planners_ompl import (
    ProfileDictionary_addOMPLProfile
)
ProfileDictionary_addOMPLProfile(profiles, "DEFAULT", ompl_profile)

Type Erasure Helpers

The command language uses type erasure. Use these functions to wrap/unwrap types:

Wrapping (concrete → polymorphic)

Python
# Waypoints
StateWaypointPoly_wrap_StateWaypoint(wp)
CartesianWaypointPoly_wrap_CartesianWaypoint(wp)
JointWaypointPoly_wrap_JointWaypoint(wp)

# Instructions
MoveInstructionPoly_wrap_MoveInstruction(instr)

# AnyPoly (for data storage; import from tesseract_task_composer)
AnyPoly_wrap_CompositeInstruction(program)
AnyPoly_wrap_ProfileDictionary(profiles)

CompositeInstruction.push_back accepts any concrete instruction type (MoveInstructionPoly, CompositeInstruction, WaitInstruction, TimerInstruction, SetAnalogInstruction, SetDigitalInstruction, SetToolInstruction) directly — implicit conversion to InstructionPoly removes the need for an explicit wrap call.

Unwrapping (polymorphic → concrete)

Python
# Waypoints
WaypointPoly_as_StateWaypointPoly(wp_poly)
WaypointPoly_as_CartesianWaypointPoly(wp_poly)
WaypointPoly_as_JointWaypointPoly(wp_poly)

# Instructions
InstructionPoly_as_MoveInstructionPoly(instr_poly)
InstructionPoly_as_WaitInstruction(instr_poly)
InstructionPoly_as_TimerInstruction(instr_poly)
InstructionPoly_as_SetAnalogInstruction(instr_poly)
InstructionPoly_as_SetDigitalInstruction(instr_poly)
InstructionPoly_as_SetToolInstruction(instr_poly)

# AnyPoly (import from tesseract_task_composer)
AnyPoly_as_CompositeInstruction(any_poly)

These free functions mirror the as*Instruction methods on InstructionPoly and raise RuntimeError when the underlying type does not match.

Complete Example

Python
from tesseract_robotics.tesseract_command_language import (
    StateWaypoint, StateWaypointPoly_wrap_StateWaypoint,
    CartesianWaypoint, CartesianWaypointPoly_wrap_CartesianWaypoint,
    MoveInstruction, MoveInstructionType,
    MoveInstructionPoly_wrap_MoveInstruction,
    CompositeInstruction,
)
from tesseract_robotics.tesseract_common import ManipulatorInfo, Isometry3d
import numpy as np

# Setup
joint_names = ["j1", "j2", "j3", "j4", "j5", "j6"]
start_joints = np.zeros(6)

goal_mat = np.eye(4)
goal_mat[:3, 3] = [0.5, 0.2, 0.3]
goal_pose = Isometry3d(goal_mat)

# Create waypoints
start_wp = StateWaypointPoly_wrap_StateWaypoint(
    StateWaypoint(joint_names, start_joints)
)
goal_wp = CartesianWaypointPoly_wrap_CartesianWaypoint(
    CartesianWaypoint(goal_pose)
)

# Create instructions (wrap in MoveInstructionPoly before appending)
start_instr = MoveInstructionPoly_wrap_MoveInstruction(
    MoveInstruction(start_wp, MoveInstructionType.FREESPACE, "DEFAULT")
)
goal_instr = MoveInstructionPoly_wrap_MoveInstruction(
    MoveInstruction(goal_wp, MoveInstructionType.LINEAR, "DEFAULT")
)

# Create program
program = CompositeInstruction("DEFAULT")

manip_info = ManipulatorInfo()
manip_info.manipulator = "manipulator"
manip_info.tcp_frame = "tool0"
manip_info.working_frame = "base_link"
program.setManipulatorInfo(manip_info)

program.appendMoveInstruction(start_instr)
program.appendMoveInstruction(goal_instr)

# Program is ready for TaskComposer

Auto-generated API Reference

tesseract_command_language Python bindings

DEFAULT_PROFILE_KEY module-attribute

Python
DEFAULT_PROFILE_KEY: str = 'DEFAULT'

MoveInstructionType_LINEAR module-attribute

Python
MoveInstructionType_LINEAR: MoveInstructionType = MoveInstructionType.LINEAR

MoveInstructionType_FREESPACE module-attribute

Python
MoveInstructionType_FREESPACE: MoveInstructionType = MoveInstructionType.FREESPACE

MoveInstructionType_CIRCULAR module-attribute

Python
MoveInstructionType_CIRCULAR: MoveInstructionType = MoveInstructionType.CIRCULAR

JointWaypoint

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

setNames

Python
setNames(names: Sequence[str]) -> None

getNames

Python
getNames() -> list[str]

setPosition

Python
setPosition(position: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getPosition

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

setUpperTolerance

Python
setUpperTolerance(upper_tol: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getUpperTolerance

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

setLowerTolerance

Python
setLowerTolerance(lower_tol: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getLowerTolerance

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

setIsConstrained

Python
setIsConstrained(value: bool) -> None

isConstrained

Python
isConstrained() -> bool

setName

Python
setName(name: str) -> None

getName

Python
getName() -> str

print

Python
print(prefix: str = '') -> None

__eq__

Python
__eq__(arg: JointWaypoint) -> bool

__ne__

Python
__ne__(arg: JointWaypoint) -> bool

__copy__

Python
__copy__() -> JointWaypoint

__deepcopy__

Python
__deepcopy__(memo: dict) -> JointWaypoint

CartesianWaypoint

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

setTransform

Python
setTransform(transform: Isometry3d) -> None

getTransform

Python
getTransform() -> tesseract_robotics.tesseract_common._tesseract_common.Isometry3d

setUpperTolerance

Python
setUpperTolerance(upper_tol: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getUpperTolerance

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

setLowerTolerance

Python
setLowerTolerance(lower_tol: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getLowerTolerance

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

setSeed

Python
setSeed(seed: JointState) -> None

getSeed

Python
getSeed() -> tesseract_robotics.tesseract_common._tesseract_common.JointState

setName

Python
setName(name: str) -> None

getName

Python
getName() -> str

print

Python
print(prefix: str = '') -> None

__eq__

Python
__eq__(arg: CartesianWaypoint) -> bool

__ne__

Python
__ne__(arg: CartesianWaypoint) -> bool

__copy__

Python
__copy__() -> CartesianWaypoint

__deepcopy__

Python
__deepcopy__(memo: dict) -> CartesianWaypoint

StateWaypoint

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

setNames

Python
setNames(names: Sequence[str]) -> None

getNames

Python
getNames() -> list[str]

setPosition

Python
setPosition(position: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getPosition

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

setVelocity

Python
setVelocity(velocity: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getVelocity

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

setAcceleration

Python
setAcceleration(acceleration: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getAcceleration

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

setEffort

Python
setEffort(effort: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getEffort

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

setTime

Python
setTime(time: float) -> None

getTime

Python
getTime() -> float

setName

Python
setName(name: str) -> None

getName

Python
getName() -> str

print

Python
print(prefix: str = '') -> None

__eq__

Python
__eq__(arg: StateWaypoint) -> bool

__ne__

Python
__ne__(arg: StateWaypoint) -> bool

__copy__

Python
__copy__() -> StateWaypoint

__deepcopy__

Python
__deepcopy__(memo: dict) -> StateWaypoint

MoveInstructionType

Bases: Enum

LINEAR class-attribute instance-attribute

Python
LINEAR = 0

FREESPACE class-attribute instance-attribute

Python
FREESPACE = 1

CIRCULAR class-attribute instance-attribute

Python
CIRCULAR = 2

CompositeInstructionOrder

Bases: Enum

ORDERED class-attribute instance-attribute

Python
ORDERED = 0

UNORDERED class-attribute instance-attribute

Python
UNORDERED = 1

ORDERED_AND_REVERABLE class-attribute instance-attribute

Python
ORDERED_AND_REVERABLE = 2

WaypointPoly

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

setName

Python
setName(name: str) -> None

getName

Python
getName() -> str

print

Python
print(prefix: str = '') -> None

isCartesianWaypoint

Python
isCartesianWaypoint() -> bool

isJointWaypoint

Python
isJointWaypoint() -> bool

isStateWaypoint

Python
isStateWaypoint() -> bool

isNull

Python
isNull() -> bool

asCartesianWaypoint

Python
asCartesianWaypoint() -> CartesianWaypointPoly

The stored CartesianWaypointPoly, by reference.

asJointWaypoint

Python
asJointWaypoint() -> JointWaypointPoly

The stored JointWaypointPoly, by reference.

asStateWaypoint

Python
asStateWaypoint() -> StateWaypointPoly

The stored StateWaypointPoly, by reference.

__eq__

Python
__eq__(arg: WaypointPoly) -> bool

__ne__

Python
__ne__(arg: WaypointPoly) -> bool

__copy__

Python
__copy__() -> WaypointPoly

__deepcopy__

Python
__deepcopy__(memo: dict) -> WaypointPoly

CartesianWaypointPoly

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

getTransform

Python
getTransform() -> tesseract_robotics.tesseract_common._tesseract_common.Isometry3d

setTransform

Python
setTransform(transform: Isometry3d) -> None

hasSeed

Python
hasSeed() -> bool

getSeed

Python
getSeed() -> tesseract_robotics.tesseract_common._tesseract_common.JointState

clearSeed

Python
clearSeed() -> None

setSeed

Python
setSeed(seed: JointState) -> None

setUpperTolerance

Python
setUpperTolerance(upper_tol: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getUpperTolerance

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

setLowerTolerance

Python
setLowerTolerance(lower_tol: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getLowerTolerance

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

isToleranced

Python
isToleranced() -> bool

asCartesianWaypoint

Python
asCartesianWaypoint() -> CartesianWaypoint

The stored CartesianWaypoint, by reference.

setName

Python
setName(name: str) -> None

getName

Python
getName() -> str

print

Python
print(prefix: str = '') -> None

isNull

Python
isNull() -> bool

__eq__

Python
__eq__(arg: CartesianWaypointPoly) -> bool

__ne__

Python
__ne__(arg: CartesianWaypointPoly) -> bool

__copy__

Python
__copy__() -> CartesianWaypointPoly

__deepcopy__

Python
__deepcopy__(memo: dict) -> CartesianWaypointPoly

JointWaypointPoly

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

getNames

Python
getNames() -> list[str]

setNames

Python
setNames(names: Sequence[str]) -> None

getPosition

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

setPosition

Python
setPosition(position: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

isConstrained

Python
isConstrained() -> bool

setIsConstrained

Python
setIsConstrained(value: bool) -> None

setUpperTolerance

Python
setUpperTolerance(upper_tol: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getUpperTolerance

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

setLowerTolerance

Python
setLowerTolerance(lower_tol: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getLowerTolerance

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

isToleranced

Python
isToleranced() -> bool

asJointWaypoint

Python
asJointWaypoint() -> JointWaypoint

The stored JointWaypoint, by reference.

setName

Python
setName(name: str) -> None

getName

Python
getName() -> str

print

Python
print(prefix: str = '') -> None

isNull

Python
isNull() -> bool

__eq__

Python
__eq__(arg: JointWaypointPoly) -> bool

__ne__

Python
__ne__(arg: JointWaypointPoly) -> bool

__copy__

Python
__copy__() -> JointWaypointPoly

__deepcopy__

Python
__deepcopy__(memo: dict) -> JointWaypointPoly

StateWaypointPoly

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

getNames

Python
getNames() -> list[str]

setNames

Python
setNames(names: Sequence[str]) -> None

getPosition

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

setPosition

Python
setPosition(position: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getVelocity

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

setVelocity

Python
setVelocity(velocity: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getAcceleration

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

setAcceleration

Python
setAcceleration(acceleration: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getEffort

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

setEffort

Python
setEffort(effort: Annotated[NDArray[float64], dict(shape=(None,), order=C)] | Sequence[float]) -> None

getTime

Python
getTime() -> float

setTime

Python
setTime(time: float) -> None

setName

Python
setName(name: str) -> None

getName

Python
getName() -> str

print

Python
print(prefix: str = '') -> None

isNull

Python
isNull() -> bool

asStateWaypoint

Python
asStateWaypoint() -> StateWaypoint

The stored StateWaypoint, by reference.

__eq__

Python
__eq__(arg: StateWaypointPoly) -> bool

__ne__

Python
__ne__(arg: StateWaypointPoly) -> bool

__copy__

Python
__copy__() -> StateWaypointPoly

__deepcopy__

Python
__deepcopy__(memo: dict) -> StateWaypointPoly

InstructionPoly

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

getDescription

Python
getDescription() -> str

setDescription

Python
setDescription(description: str) -> None

print

Python
print(prefix: str = '') -> None

isCompositeInstruction

Python
isCompositeInstruction() -> bool

isMoveInstruction

Python
isMoveInstruction() -> bool

isWaitInstruction

Python
isWaitInstruction() -> bool

isTimerInstruction

Python
isTimerInstruction() -> bool

isSetAnalogInstruction

Python
isSetAnalogInstruction() -> bool

isSetDigitalInstruction

Python
isSetDigitalInstruction() -> bool

isSetToolInstruction

Python
isSetToolInstruction() -> bool

isNull

Python
isNull() -> bool

asMoveInstruction

Python
asMoveInstruction() -> MoveInstructionPoly

Cast to MoveInstructionPoly. Raises RuntimeError if not a move instruction.

asCompositeInstruction

Python
asCompositeInstruction() -> CompositeInstruction

Cast to CompositeInstruction. Raises RuntimeError if not a composite instruction.

asWaitInstruction

Python
asWaitInstruction() -> WaitInstruction

Cast to WaitInstruction. Raises RuntimeError if not a wait instruction.

asTimerInstruction

Python
asTimerInstruction() -> TimerInstruction

Cast to TimerInstruction. Raises RuntimeError if not a timer instruction.

asSetAnalogInstruction

Python
asSetAnalogInstruction() -> SetAnalogInstruction

Cast to SetAnalogInstruction. Raises RuntimeError if not a set analog instruction.

asSetDigitalInstruction

Python
asSetDigitalInstruction() -> SetDigitalInstruction

Cast to SetDigitalInstruction. Raises RuntimeError if not a set digital instruction.

asSetToolInstruction

Python
asSetToolInstruction() -> SetToolInstruction

Cast to SetToolInstruction. Raises RuntimeError if not a set tool instruction.

__eq__

Python
__eq__(arg: InstructionPoly) -> bool

__ne__

Python
__ne__(arg: InstructionPoly) -> bool

__copy__

Python
__copy__() -> InstructionPoly

__deepcopy__

Python
__deepcopy__(memo: dict) -> InstructionPoly

getUUID

Python
getUUID() -> str

setUUID

Python
setUUID(uuid: str) -> None

regenerateUUID

Python
regenerateUUID() -> None

getParentUUID

Python
getParentUUID() -> str

setParentUUID

Python
setParentUUID(uuid: str) -> None

MoveInstructionPoly

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

getWaypoint

Python
getWaypoint() -> WaypointPoly

assignCartesianWaypoint

Python
assignCartesianWaypoint(waypoint: CartesianWaypointPoly) -> None

assignJointWaypoint

Python
assignJointWaypoint(waypoint: JointWaypointPoly) -> None

assignStateWaypoint

Python
assignStateWaypoint(waypoint: StateWaypointPoly) -> None

getMoveType

Python
getMoveType() -> MoveInstructionType

setMoveType

Python
setMoveType(move_type: MoveInstructionType) -> None

getProfile

Python
getProfile(ns: str = '') -> str

setProfile

Python
setProfile(profile: str) -> None

getPathProfile

Python
getPathProfile(ns: str = '') -> str

setPathProfile

Python
setPathProfile(profile: str) -> None

setProfileOverrides

Python
setProfileOverrides(profile_overrides: Mapping[str, str]) -> None

getProfileOverrides

Python
getProfileOverrides() -> dict[str, str]

A copy of the namespace -> profile overrides.

setPathProfileOverrides

Python
setPathProfileOverrides(profile_overrides: Mapping[str, str]) -> None

getPathProfileOverrides

Python
getPathProfileOverrides() -> dict[str, str]

A copy of the namespace -> path profile overrides.

createCartesianWaypoint

Python
createCartesianWaypoint() -> CartesianWaypointPoly

createJointWaypoint

Python
createJointWaypoint() -> JointWaypointPoly

createStateWaypoint

Python
createStateWaypoint() -> StateWaypointPoly

createChild

Python
createChild() -> MoveInstructionPoly

A copy whose parent UUID is this instruction's UUID, with a new UUID of its own.

isChild

Python
isChild() -> bool

True if the parent UUID is not nil.

isLinear

Python
isLinear() -> bool

isFreespace

Python
isFreespace() -> bool

isCircular

Python
isCircular() -> bool

getManipulatorInfo

Python
getManipulatorInfo() -> tesseract_robotics.tesseract_common._tesseract_common.ManipulatorInfo

setManipulatorInfo

Python
setManipulatorInfo(info: ManipulatorInfo) -> None

getDescription

Python
getDescription() -> str

setDescription

Python
setDescription(description: str) -> None

print

Python
print(prefix: str = '') -> None

isNull

Python
isNull() -> bool

asMoveInstruction

Python
asMoveInstruction() -> MoveInstruction

The stored MoveInstruction, by reference.

__eq__

Python
__eq__(arg: MoveInstructionPoly) -> bool

__ne__

Python
__ne__(arg: MoveInstructionPoly) -> bool

__copy__

Python
__copy__() -> MoveInstructionPoly

__deepcopy__

Python
__deepcopy__(memo: dict) -> MoveInstructionPoly

getUUID

Python
getUUID() -> str

setUUID

Python
setUUID(uuid: str) -> None

regenerateUUID

Python
regenerateUUID() -> None

getParentUUID

Python
getParentUUID() -> str

setParentUUID

Python
setParentUUID(uuid: str) -> None

MoveInstruction

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

getWaypoint

Python
getWaypoint() -> WaypointPoly

assignCartesianWaypoint

Python
assignCartesianWaypoint(waypoint: CartesianWaypointPoly) -> None

assignJointWaypoint

Python
assignJointWaypoint(waypoint: JointWaypointPoly) -> None

assignStateWaypoint

Python
assignStateWaypoint(waypoint: StateWaypointPoly) -> None

getMoveType

Python
getMoveType() -> MoveInstructionType

setMoveType

Python
setMoveType(move_type: MoveInstructionType) -> None

getProfile

Python
getProfile(ns: str = '') -> str

setProfile

Python
setProfile(profile: str) -> None

getPathProfile

Python
getPathProfile(ns: str = '') -> str

setPathProfile

Python
setPathProfile(profile: str) -> None

setProfileOverrides

Python
setProfileOverrides(profile_overrides: Mapping[str, str]) -> None

getProfileOverrides

Python
getProfileOverrides() -> dict[str, str]

A copy of the namespace -> profile overrides.

setPathProfileOverrides

Python
setPathProfileOverrides(profile_overrides: Mapping[str, str]) -> None

getPathProfileOverrides

Python
getPathProfileOverrides() -> dict[str, str]

A copy of the namespace -> path profile overrides.

createCartesianWaypoint

Python
createCartesianWaypoint() -> CartesianWaypointPoly

createJointWaypoint

Python
createJointWaypoint() -> JointWaypointPoly

createStateWaypoint

Python
createStateWaypoint() -> StateWaypointPoly

getManipulatorInfo

Python
getManipulatorInfo() -> tesseract_robotics.tesseract_common._tesseract_common.ManipulatorInfo

setManipulatorInfo

Python
setManipulatorInfo(info: ManipulatorInfo) -> None

print

Python
print(prefix: str = '') -> None

getDescription

Python
getDescription() -> str

setDescription

Python
setDescription(description: str) -> None

__eq__

Python
__eq__(arg: MoveInstruction) -> bool

__ne__

Python
__ne__(arg: MoveInstruction) -> bool

__copy__

Python
__copy__() -> MoveInstruction

__deepcopy__

Python
__deepcopy__(memo: dict) -> MoveInstruction

getUUID

Python
getUUID() -> str

setUUID

Python
setUUID(uuid: str) -> None

regenerateUUID

Python
regenerateUUID() -> None

getParentUUID

Python
getParentUUID() -> str

setParentUUID

Python
setParentUUID(uuid: str) -> None

WaitInstructionType

Bases: Enum

TIME class-attribute instance-attribute

Python
TIME = 0

DIGITAL_INPUT_HIGH class-attribute instance-attribute

Python
DIGITAL_INPUT_HIGH = 1

DIGITAL_INPUT_LOW class-attribute instance-attribute

Python
DIGITAL_INPUT_LOW = 2

DIGITAL_OUTPUT_HIGH class-attribute instance-attribute

Python
DIGITAL_OUTPUT_HIGH = 3

DIGITAL_OUTPUT_LOW class-attribute instance-attribute

Python
DIGITAL_OUTPUT_LOW = 4

WaitInstruction

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

getWaitType

Python
getWaitType() -> WaitInstructionType

setWaitType

Python
setWaitType(type: WaitInstructionType) -> None

getWaitTime

Python
getWaitTime() -> float

setWaitTime

Python
setWaitTime(time: float) -> None

getWaitIO

Python
getWaitIO() -> int

setWaitIO

Python
setWaitIO(io: int) -> None

getDescription

Python
getDescription() -> str

setDescription

Python
setDescription(description: str) -> None

print

Python
print(prefix: str = '') -> None

__eq__

Python
__eq__(arg: WaitInstruction) -> bool

__ne__

Python
__ne__(arg: WaitInstruction) -> bool

__copy__

Python
__copy__() -> WaitInstruction

__deepcopy__

Python
__deepcopy__(memo: dict) -> WaitInstruction

getUUID

Python
getUUID() -> str

setUUID

Python
setUUID(uuid: str) -> None

regenerateUUID

Python
regenerateUUID() -> None

getParentUUID

Python
getParentUUID() -> str

setParentUUID

Python
setParentUUID(uuid: str) -> None

TimerInstructionType

Bases: Enum

DIGITAL_OUTPUT_HIGH class-attribute instance-attribute

Python
DIGITAL_OUTPUT_HIGH = 0

DIGITAL_OUTPUT_LOW class-attribute instance-attribute

Python
DIGITAL_OUTPUT_LOW = 1

TimerInstruction

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

__init__

Python
__init__(type: TimerInstructionType, time: float, io: int) -> None

Construct a timer that, after time seconds, drives digital output io HIGH or LOW per type.

getTimerType

Python
getTimerType() -> TimerInstructionType

setTimerType

Python
setTimerType(type: TimerInstructionType) -> None

getTimerTime

Python
getTimerTime() -> float

setTimerTime

Python
setTimerTime(time: float) -> None

getTimerIO

Python
getTimerIO() -> int

setTimerIO

Python
setTimerIO(io: int) -> None

getDescription

Python
getDescription() -> str

setDescription

Python
setDescription(description: str) -> None

print

Python
print(prefix: str = '') -> None

__eq__

Python
__eq__(arg: TimerInstruction) -> bool

__ne__

Python
__ne__(arg: TimerInstruction) -> bool

__copy__

Python
__copy__() -> TimerInstruction

__deepcopy__

Python
__deepcopy__(memo: dict) -> TimerInstruction

getUUID

Python
getUUID() -> str

setUUID

Python
setUUID(uuid: str) -> None

regenerateUUID

Python
regenerateUUID() -> None

getParentUUID

Python
getParentUUID() -> str

setParentUUID

Python
setParentUUID(uuid: str) -> None

SetAnalogInstruction

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

__init__

Python
__init__(key: str, index: int, value: float) -> None

Set analog channel identified by (key, index) to value.

getKey

Python
getKey() -> str

getIndex

Python
getIndex() -> int

getValue

Python
getValue() -> float

getDescription

Python
getDescription() -> str

setDescription

Python
setDescription(description: str) -> None

print

Python
print(prefix: str = '') -> None

__eq__

Python
__eq__(arg: SetAnalogInstruction) -> bool

__ne__

Python
__ne__(arg: SetAnalogInstruction) -> bool

__copy__

Python
__copy__() -> SetAnalogInstruction

__deepcopy__

Python
__deepcopy__(memo: dict) -> SetAnalogInstruction

getUUID

Python
getUUID() -> str

setUUID

Python
setUUID(uuid: str) -> None

regenerateUUID

Python
regenerateUUID() -> None

getParentUUID

Python
getParentUUID() -> str

setParentUUID

Python
setParentUUID(uuid: str) -> None

SetDigitalInstruction

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

__init__

Python
__init__(key: str, index: int, value: bool) -> None

Set digital channel identified by (key, index) to value.

getKey

Python
getKey() -> str

getIndex

Python
getIndex() -> int

getValue

Python
getValue() -> bool

getDescription

Python
getDescription() -> str

setDescription

Python
setDescription(description: str) -> None

print

Python
print(prefix: str = '') -> None

__eq__

Python
__eq__(arg: SetDigitalInstruction) -> bool

__ne__

Python
__ne__(arg: SetDigitalInstruction) -> bool

__copy__

Python
__copy__() -> SetDigitalInstruction

__deepcopy__

Python
__deepcopy__(memo: dict) -> SetDigitalInstruction

getUUID

Python
getUUID() -> str

setUUID

Python
setUUID(uuid: str) -> None

regenerateUUID

Python
regenerateUUID() -> None

getParentUUID

Python
getParentUUID() -> str

setParentUUID

Python
setParentUUID(uuid: str) -> None

SetToolInstruction

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

__init__

Python
__init__(tool_id: int) -> None

Activate the tool with the given ID.

getTool

Python
getTool() -> int

getDescription

Python
getDescription() -> str

setDescription

Python
setDescription(description: str) -> None

print

Python
print(prefix: str = '') -> None

__eq__

Python
__eq__(arg: SetToolInstruction) -> bool

__ne__

Python
__ne__(arg: SetToolInstruction) -> bool

__copy__

Python
__copy__() -> SetToolInstruction

__deepcopy__

Python
__deepcopy__(memo: dict) -> SetToolInstruction

getUUID

Python
getUUID() -> str

setUUID

Python
setUUID(uuid: str) -> None

regenerateUUID

Python
regenerateUUID() -> None

getParentUUID

Python
getParentUUID() -> str

setParentUUID

Python
setParentUUID(uuid: str) -> None

CompositeInstruction

__hash__ class-attribute instance-attribute

Python
__hash__: None = None

getOrder

Python
getOrder() -> CompositeInstructionOrder

getDescription

Python
getDescription() -> str

setDescription

Python
setDescription(description: str) -> None

print

Python
print(prefix: str = '') -> None

getProfile

Python
getProfile(ns: str = '') -> str

setProfile

Python
setProfile(profile: str) -> None

setProfileOverrides

Python
setProfileOverrides(profile_overrides: Mapping[str, str]) -> None

getProfileOverrides

Python
getProfileOverrides() -> dict[str, str]

A copy of the namespace -> profile overrides.

getUserData

Python
getUserData() -> dict[str, None | bool | int | float | str]

A copy of the user data.

C++ int, long and size_t values all read back as int; float and double as float. An AnyPoly value raises TypeError: AnyPoly is bound in tesseract_task_composer.

setUserData

Python
setUserData(data: dict[str, None | bool | int | float | str]) -> None

Replace the user data.

None is stored as std::monostate, bool as bool, float as double, str as std::string. An int is stored as the first of int, long and size_t that holds it, so a C++ size_t written as a small value reads back as int. Any other value raises TypeError and leaves the user data unchanged.

getManipulatorInfo

Python
getManipulatorInfo() -> tesseract_robotics.tesseract_common._tesseract_common.ManipulatorInfo

setManipulatorInfo

Python
setManipulatorInfo(info: ManipulatorInfo) -> None

getInstructions

Python
getInstructions() -> list[InstructionPoly]

setInstructions

Python
setInstructions(instructions: Sequence[InstructionPoly]) -> None

appendMoveInstruction

Python
appendMoveInstruction(mi: MoveInstructionPoly) -> None

size

Python
size() -> int

empty

Python
empty() -> bool

clear

Python
clear() -> None

max_size

Python
max_size() -> int

reserve

Python
reserve(n: int) -> None

capacity

Python
capacity() -> int

shrink_to_fit

Python
shrink_to_fit() -> None

front

Python
front() -> InstructionPoly

back

Python
back() -> InstructionPoly

at

Python
at(n: int) -> InstructionPoly

pop_back

Python
pop_back() -> None

flatten

Python
flatten(filter: Callable[[InstructionPoly, CompositeInstruction], bool] | None = None) -> list[InstructionPoly]

Every leaf instruction, descending into child composites, that filter accepts (all if None).

getFirstMoveInstruction

Python
getFirstMoveInstruction() -> MoveInstructionPoly

The first move instruction, descending into children, or None.

getLastMoveInstruction

Python
getLastMoveInstruction() -> MoveInstructionPoly

The last move instruction, descending into children, or None.

getMoveInstructionCount

Python
getMoveInstructionCount() -> int

getFirstInstruction

Python
getFirstInstruction(locate_filter: Callable[[InstructionPoly, CompositeInstruction], bool] | None = None, process_child_composites: bool = True) -> InstructionPoly

The first instruction locate_filter accepts, or None.

getLastInstruction

Python
getLastInstruction(locate_filter: Callable[[InstructionPoly, CompositeInstruction], bool] | None = None, process_child_composites: bool = True) -> InstructionPoly

The last instruction locate_filter accepts, or None.

getInstructionCount

Python
getInstructionCount(locate_filter: Callable[[InstructionPoly, CompositeInstruction], bool] | None = None, process_child_composites: bool = True) -> int

__len__

Python
__len__() -> int

__getitem__

Python
__getitem__(arg: int) -> InstructionPoly

__iter__

Python
__iter__() -> Iterator[InstructionPoly]

__eq__

Python
__eq__(arg: CompositeInstruction) -> bool

__ne__

Python
__ne__(arg: CompositeInstruction) -> bool

__copy__

Python
__copy__() -> CompositeInstruction

__deepcopy__

Python
__deepcopy__(memo: dict) -> CompositeInstruction

getUUID

Python
getUUID() -> str

setUUID

Python
setUUID(uuid: str) -> None

regenerateUUID

Python
regenerateUUID() -> None

getParentUUID

Python
getParentUUID() -> str

setParentUUID

Python
setParentUUID(uuid: str) -> None

Profile

getKey

Python
getKey() -> int

ProfileDictionary

__init__

Python
__init__() -> None

hasProfile

Python
hasProfile(key: int, ns: str, profile_name: str) -> bool

getProfile

Python
getProfile(key: int, ns: str, profile_name: str) -> Profile

removeProfile

Python
removeProfile(key: int, ns: str, profile_name: str) -> None

hasProfileEntry

Python
hasProfileEntry(key: int, ns: str) -> bool

removeProfileEntry

Python
removeProfileEntry(key: int, ns: str) -> None

getProfileEntry

Python
getProfileEntry(key: int, ns: str) -> dict[str, Profile]

Profile name -> profile for key in ns. A copy of the map; the profiles are shared.

getAllProfileEntries

Python
getAllProfileEntries() -> dict[str, dict[int, dict[str, Profile]]]

ns -> key -> profile name -> profile. A copy of the maps; the profiles are shared.

clear

Python
clear() -> None

CartesianWaypointPoly_wrap_CartesianWaypoint

Python
CartesianWaypointPoly_wrap_CartesianWaypoint(waypoint: CartesianWaypoint) -> CartesianWaypointPoly

JointWaypointPoly_wrap_JointWaypoint

Python
JointWaypointPoly_wrap_JointWaypoint(waypoint: JointWaypoint) -> JointWaypointPoly

StateWaypointPoly_wrap_StateWaypoint

Python
StateWaypointPoly_wrap_StateWaypoint(waypoint: StateWaypoint) -> StateWaypointPoly

MoveInstructionPoly_wrap_MoveInstruction

Python
MoveInstructionPoly_wrap_MoveInstruction(instruction: MoveInstruction) -> MoveInstructionPoly

InstructionPoly_as_MoveInstructionPoly

Python
InstructionPoly_as_MoveInstructionPoly(instruction: InstructionPoly) -> MoveInstructionPoly

InstructionPoly_as_CompositeInstruction

Python
InstructionPoly_as_CompositeInstruction(instruction: InstructionPoly) -> CompositeInstruction

InstructionPoly_as_WaitInstruction

Python
InstructionPoly_as_WaitInstruction(instruction: InstructionPoly) -> WaitInstruction

InstructionPoly_as_TimerInstruction

Python
InstructionPoly_as_TimerInstruction(instruction: InstructionPoly) -> TimerInstruction

InstructionPoly_as_SetAnalogInstruction

Python
InstructionPoly_as_SetAnalogInstruction(instruction: InstructionPoly) -> SetAnalogInstruction

InstructionPoly_as_SetDigitalInstruction

Python
InstructionPoly_as_SetDigitalInstruction(instruction: InstructionPoly) -> SetDigitalInstruction

InstructionPoly_as_SetToolInstruction

Python
InstructionPoly_as_SetToolInstruction(instruction: InstructionPoly) -> SetToolInstruction

WaypointPoly_as_StateWaypointPoly

Python
WaypointPoly_as_StateWaypointPoly(waypoint: WaypointPoly) -> StateWaypointPoly

WaypointPoly_as_CartesianWaypointPoly

Python
WaypointPoly_as_CartesianWaypointPoly(waypoint: WaypointPoly) -> CartesianWaypointPoly

WaypointPoly_as_JointWaypointPoly

Python
WaypointPoly_as_JointWaypointPoly(waypoint: WaypointPoly) -> JointWaypointPoly

moveFilter

Python
moveFilter(instruction: InstructionPoly, composite: CompositeInstruction) -> bool

Filter for flatten/getFirstInstruction/...: True for a move instruction.

ProfileDictionary_addProfile

Python
ProfileDictionary_addProfile(dict: ProfileDictionary, ns: str, profile_name: str, profile: Profile) -> None

Add a profile to the dictionary (cross-module helper)

getJointNames

Python
getJointNames(waypoint: WaypointPoly) -> list[str]

The joint names of a joint or state waypoint; raises for a Cartesian waypoint.

formatJointPosition

Python
formatJointPosition(joint_names: Sequence[str], waypoint: WaypointPoly) -> bool

Reorder waypoint in place to joint_names; True if it was reordered.

checkJointPositionFormat

Python
checkJointPositionFormat(joint_names: Sequence[str], waypoint: WaypointPoly) -> bool

True if the waypoint's joints are ordered as joint_names.

setJointPosition

Python
setJointPosition(waypoint: WaypointPoly, position: Annotated[NDArray[float64], dict(shape=(None,), writable=False)] | Sequence[float]) -> bool

Set the joint position in place; False for a Cartesian waypoint.

isWithinJointLimits

Python
isWithinJointLimits(waypoint: WaypointPoly, limits: Annotated[NDArray[float64], dict(shape=(None, 2), writable=False)] | Sequence[Sequence[float]]) -> bool

limits is (n, 2): lower, upper. True for a Cartesian waypoint.

toDelimitedFile

Python
toDelimitedFile(composite_instructions: CompositeInstruction, file_path: str | PathLike, separator: str = ',') -> bool

Write the joint positions of every move instruction to file_path; True on success.

makeTimeMonotonicallyIncreasing

Python
makeTimeMonotonicallyIncreasing(composite_instructions: CompositeInstruction) -> None

A time that drops below the previous one starts a new segment appended after it; repeated times are left as they are; in place.