Observation And Recipes¶

Target-independent scene observations and built-in experiment recipes.

observation ¶

Target-independent scene observations.

Modules:

Name	Description
`contact`	Target-independent semantic contact observations.
`spec`	Canonical target-independent scene observations.
`support`	Typed support-contact classification for observed point tracks.

Classes:

Name	Description
`SemanticContactSequence`	Robot-independent semantic contacts and support geometry.
`SemanticContactTrack`	Categorical contact state for one observed subject and patch.
`ObservedObject`	Observed object geometry and pose, independent of a target robot.
`SceneObservation`	Shared-timeline result of capture processing before robot adaptation.
`FootSupportClassificationConfig`	Thresholds for ground and moving-object foot support.
`FootSupportStates`	Typed categorical values emitted by support classification.

Functions:

Name	Description
`classify_foot_support`	Classify feet as air, ground, or supported by an observed object.

Attributes:

Name	Type	Description
`__all__`

Attributes¶

all `module-attribute` ¶

__all__ = [
    "FootSupportClassificationConfig",
    "FootSupportStates",
    "ObservedObject",
    "SceneObservation",
    "SemanticContactSequence",
    "SemanticContactTrack",
    "classify_foot_support",
]

Classes¶

SemanticContactSequence `dataclass` ¶

SemanticContactSequence(
    timeline: SampleTimeline,
    tracks: tuple[SemanticContactTrack, ...],
    support: SupportPlane | None = None,
    provenance: dict[str, object] = dict(),
)

Robot-independent semantic contacts and support geometry.

Methods:

Name	Description
`resolve`	Resolve semantic subjects to concrete robot links.

Attributes:

Name	Type	Description
`timeline`	`SampleTimeline`
`tracks`	`tuple[SemanticContactTrack, ...]`
`support`	`SupportPlane \| None`
`provenance`	`dict[str, object]`

Attributes¶

timeline `instance-attribute` ¶

timeline: SampleTimeline

tracks `instance-attribute` ¶

tracks: tuple[SemanticContactTrack, ...]

support `class-attribute` `instance-attribute` ¶

support: SupportPlane | None = None

provenance `class-attribute` `instance-attribute` ¶

provenance: dict[str, object] = field(default_factory=dict)

Functions¶

resolve ¶

resolve(link_mapping: Mapping[ContactSubject, Sequence[RobotLink]]) -> ContactPlan

Resolve semantic subjects to concrete robot links.

SemanticContactTrack `dataclass` ¶

SemanticContactTrack(
    subject: ContactSubject,
    states: tuple[ContactState, ...],
    patch: ContactPatch | None = None,
    active_states: tuple[ContactState, ...] = (),
    support_states: tuple[ContactState, ...] = (),
    validity: ndarray | None = None,
    provenance: dict[str, object] = dict(),
)

Categorical contact state for one observed subject and patch.

Attributes:

Name	Type	Description
`subject`	`ContactSubject`
`states`	`tuple[ContactState, ...]`
`patch`	`ContactPatch \| None`
`active_states`	`tuple[ContactState, ...]`
`support_states`	`tuple[ContactState, ...]`
`validity`	`ndarray \| None`
`provenance`	`dict[str, object]`
`sample_count`	`int`	Number of samples.

Attributes¶

subject `instance-attribute` ¶

subject: ContactSubject

states `instance-attribute` ¶

states: tuple[ContactState, ...]

patch `class-attribute` `instance-attribute` ¶

patch: ContactPatch | None = None

active_states `class-attribute` `instance-attribute` ¶

active_states: tuple[ContactState, ...] = ()

support_states `class-attribute` `instance-attribute` ¶

support_states: tuple[ContactState, ...] = ()

validity `class-attribute` `instance-attribute` ¶

validity: ndarray | None = None

provenance `class-attribute` `instance-attribute` ¶

provenance: dict[str, object] = field(default_factory=dict)

sample_count `property` ¶

sample_count: int

Number of samples.

ObservedObject `dataclass` ¶

ObservedObject(
    role: ObservationRole,
    pose: PoseTrack,
    geometry: ObjectSpec,
    provenance: dict[str, object] = dict(),
)

Observed object geometry and pose, independent of a target robot.

Attributes:

Name	Type	Description
`role`	`ObservationRole`
`pose`	`PoseTrack`
`geometry`	`ObjectSpec`
`provenance`	`dict[str, object]`

Attributes¶

role `instance-attribute` ¶

role: ObservationRole

pose `instance-attribute` ¶

pose: PoseTrack

geometry `instance-attribute` ¶

geometry: ObjectSpec

provenance `class-attribute` `instance-attribute` ¶

provenance: dict[str, object] = field(default_factory=dict)

SceneObservation `dataclass` ¶

SceneObservation(
    name: str,
    timeline: SampleTimeline,
    world_frame: FrameConvention,
    actor: MotionSequence[Any],
    landmarks: tuple[PointTrack, ...] = (),
    rigid_bodies: tuple[PoseTrack, ...] = (),
    objects: tuple[ObservedObject, ...] = (),
    contacts: SemanticContactSequence | None = None,
    terrain: TerrainSpec | None = None,
    alignment_reports: tuple[AlignmentReport, ...] = (),
    provenance: dict[str, object] = dict(),
)

Shared-timeline result of capture processing before robot adaptation.

Methods:

Name	Description
`landmark`	Return a semantic landmark track.
`observed_object`	Return an observed object.
`save_npz`	Explicitly save this observation checkpoint without pickle.
`load_npz`	Load an explicit observation checkpoint.

Attributes:

Name	Type	Description
`name`	`str`
`timeline`	`SampleTimeline`
`world_frame`	`FrameConvention`
`actor`	`MotionSequence[Any]`
`landmarks`	`tuple[PointTrack, ...]`
`rigid_bodies`	`tuple[PoseTrack, ...]`
`objects`	`tuple[ObservedObject, ...]`
`contacts`	`SemanticContactSequence \| None`
`terrain`	`TerrainSpec \| None`
`alignment_reports`	`tuple[AlignmentReport, ...]`
`provenance`	`dict[str, object]`

Attributes¶

name `instance-attribute` ¶

name: str

timeline `instance-attribute` ¶

timeline: SampleTimeline

world_frame `instance-attribute` ¶

world_frame: FrameConvention

actor `instance-attribute` ¶

actor: MotionSequence[Any]

landmarks `class-attribute` `instance-attribute` ¶

landmarks: tuple[PointTrack, ...] = ()

rigid_bodies `class-attribute` `instance-attribute` ¶

rigid_bodies: tuple[PoseTrack, ...] = ()

objects `class-attribute` `instance-attribute` ¶

objects: tuple[ObservedObject, ...] = ()

contacts `class-attribute` `instance-attribute` ¶

contacts: SemanticContactSequence | None = None

terrain `class-attribute` `instance-attribute` ¶

terrain: TerrainSpec | None = None

alignment_reports `class-attribute` `instance-attribute` ¶

alignment_reports: tuple[AlignmentReport, ...] = ()

provenance `class-attribute` `instance-attribute` ¶

provenance: dict[str, object] = field(default_factory=dict)

Functions¶

landmark ¶

landmark(role: ObservationRole) -> PointTrack

Return a semantic landmark track.

observed_object ¶

observed_object(role: ObservationRole) -> ObservedObject

Return an observed object.

save_npz ¶

save_npz(path: str | Path) -> Path

Explicitly save this observation checkpoint without pickle.

load_npz `classmethod` ¶

load_npz(path: str | Path) -> SceneObservation

Load an explicit observation checkpoint.

FootSupportClassificationConfig `dataclass` ¶

FootSupportClassificationConfig(
    ground_height_percentile: float = 8.0,
    ground_clearance_m: float = 0.035,
    ground_speed_mps: float = 0.18,
    object_horizontal_distance_m: float = 0.35,
    object_height_min_m: float = 0.0,
    object_height_max_m: float = 0.14,
    object_relative_speed_mps: float = 0.15,
)

Thresholds for ground and moving-object foot support.

Attributes:

Name	Type	Description
`ground_height_percentile`	`float`
`ground_clearance_m`	`float`
`ground_speed_mps`	`float`
`object_horizontal_distance_m`	`float`
`object_height_min_m`	`float`
`object_height_max_m`	`float`
`object_relative_speed_mps`	`float`

Attributes¶

ground_height_percentile `class-attribute` `instance-attribute` ¶

ground_height_percentile: float = 8.0

ground_clearance_m `class-attribute` `instance-attribute` ¶

ground_clearance_m: float = 0.035

ground_speed_mps `class-attribute` `instance-attribute` ¶

ground_speed_mps: float = 0.18

object_horizontal_distance_m `class-attribute` `instance-attribute` ¶

object_horizontal_distance_m: float = 0.35

object_height_min_m `class-attribute` `instance-attribute` ¶

object_height_min_m: float = 0.0

object_height_max_m `class-attribute` `instance-attribute` ¶

object_height_max_m: float = 0.14

object_relative_speed_mps `class-attribute` `instance-attribute` ¶

object_relative_speed_mps: float = 0.15

FootSupportStates `dataclass` ¶

FootSupportStates(
    air: ContactState, ground: ContactState, observed_object: ContactState
)

Typed categorical values emitted by support classification.

Attributes:

Name	Type	Description
`air`	`ContactState`
`ground`	`ContactState`
`observed_object`	`ContactState`

Attributes¶

air `instance-attribute` ¶

air: ContactState

ground `instance-attribute` ¶

ground: ContactState

observed_object `instance-attribute` ¶

observed_object: ContactState

Functions¶

classify_foot_support ¶

classify_foot_support(
    *,
    timeline: SampleTimeline,
    left_foot: PointTrack,
    right_foot: PointTrack,
    observed_object: PointTrack,
    left_subject: ContactSubject,
    right_subject: ContactSubject,
    left_patch: ContactPatch,
    right_patch: ContactPatch,
    states: FootSupportStates,
    config: FootSupportClassificationConfig | None = None,
) -> SemanticContactSequence

Classify feet as air, ground, or supported by an observed object.

ObservationRecipe ¶

Bases: Protocol

Process native recordings into a target-independent observation.

Methods:

Name	Description
`observe`	Return a shared-timeline scene observation.

Functions¶

observe ¶

observe() -> SceneObservation

Return a shared-timeline scene observation.

RetargetingRecipe ¶

Bases: Protocol

Adapt a scene observation to one target robot.

Methods:

Name	Description
`build_problem`	Build a complete retargeting problem.

Functions¶

build_problem ¶

build_problem(observation: SceneObservation, robot: RobotSpec) -> RetargetingProblem

Build a complete retargeting problem.

generic ¶

Generic typed recipes for registered motion files and configured runs.

Classes:

Name	Description
`MotionFormatKind`	Base enum for motion-format registrations.
`MotionJoint`	Base enum for source motion joint names.
`RobotRole`	Base enum for semantic roles resolved by a robot specification.
`TaskKind`	Supported high-level retargeting workflows.
`PoseSequence`	Time-indexed sequence of poses.
`InteractionMeshSpec`	Configuration for interaction mesh construction.
`MotionFormatSpec`	Concrete source-motion vocabulary and storage conventions.
`SceneObservation`	Shared-timeline result of capture processing before robot adaptation.
`ConstraintConfig`	Base class for constraint configs keyed by an extensible enum member.
`ObjectiveConfig`	Base class for objective configs keyed by an extensible enum member.
`OptimizationProfile`	Reusable typed objective/constraint composition.
`SolverSpec`	Solver selection and common options.
`QposVariableSpec`	Configuration describing which qpos coordinates the optimizer may change.
`JointBinding`	Explicit source-motion joint to robot-joint binding.
`LinkBinding`	Explicit source-motion joint to robot-link binding.
`RetargetingProblem`	Complete typed run specification before backend compilation.
`SceneRecipe`	Build target-independent runtime scene data from an observation.
`RobotSpec`	Robot description that preserves enum identity until backend compilation.
`SceneSpec`	Scene configuration for a retargeting run.
`TerrainSpec`	Static terrain information.
`MotionFileObservationRecipe`	Load a registered motion file into a typed scene observation.
`RobotOnlySceneRecipe`	Build a flat-ground robot-only scene.
`StaticSceneRecipe`	Return a predeclared target-independent scene specification.
`RoleRetargetingRecipe`	Resolve typed motion joints through semantic robot roles.

Functions:

Name	Description
`load_motion`	Load a motion sequence using a registered format and suffix loader.

Attributes:

Name	Type	Description
`motion_formats`	`Registry[MotionFormatKind, MotionFormatSpec]`	Registry of built-in :class:`~retarget.motion.spec.MotionFormatSpec` entries.

Attributes¶

motion_formats `module-attribute` ¶

motion_formats: Registry[MotionFormatKind, MotionFormatSpec] = Registry(
    "motion format", MotionFormatKind, decorator_transform=_motion_format_from_decorator
)

Registry of built-in :class:~retarget.motion.spec.MotionFormatSpec entries.

Classes¶

MotionFormatKind ¶

Bases: RegistryKind

Base enum for motion-format registrations.

MotionJoint ¶

Bases: NameEnum

Base enum for source motion joint names.

RobotRole ¶

Bases: NameEnum

Base enum for semantic roles resolved by a robot specification.

TaskKind ¶

Bases: StrEnum

Supported high-level retargeting workflows.

Attributes:

Name	Type	Description
`ROBOT_ONLY`	`str`	Retarget humanoid motion without scene props (`"robot_only"`).
`OBJECT_INTERACTION`	`str`	Retarget with manipulated objects and contact (`"object_interaction"`).
`CLIMBING`	`str`	Climbing / terrain interaction workflow (`"climbing"`).

ROBOT_ONLY `member` ¶

ROBOT_ONLY = 'robot_only'

OBJECT_INTERACTION `member` ¶

OBJECT_INTERACTION = 'object_interaction'

CLIMBING `member` ¶

CLIMBING = 'climbing'

PoseSequence ¶

Bases: BaseModel

Time-indexed sequence of poses.

Attributes:

Name	Type	Description
`poses`	`tuple[Pose, ...]`	Per-frame rigid transforms sharing one `frame`.
`fps`	`float`	Sampling rate in Hz for time-based resampling.

Methods:

Name	Description
`quaternions`	Stacked quaternions with shape `(T, 4)`.
`identity`	Return `frame_count` identity poses.
`from_arrays`	Build a pose sequence from position and quaternion arrays.
`to_frame`	Return this sequence represented in another coordinate frame convention.
`scaled`	Return this sequence with translations scaled and rotations preserved.
`resampled`	Return this pose sequence sampled on a new FPS grid.

Attributes¶

model_config `class-attribute` `instance-attribute` ¶

model_config = ConfigDict(arbitrary_types_allowed=True)

poses `instance-attribute` ¶

poses: tuple[Pose, ...]

fps `class-attribute` `instance-attribute` ¶

fps: float = 30.0

frame_count `property` ¶

frame_count: int

Number of poses.

frame `property` ¶

frame: FrameConvention

Coordinate frame used by every pose.

positions `property` ¶

positions: FloatArray

Stacked translations with shape (T, 3).

Functions¶

quaternions ¶

quaternions(order: QuaternionOrder = WXYZ) -> FloatArray

Stacked quaternions with shape (T, 4).

Parameters:

Name	Type	Description	Default
`order`	`QuaternionOrder`	Storage order for each frame's quaternion.	`WXYZ`

Returns:

Name	Type	Description
`FloatArray`	`FloatArray`	Quaternion array with shape `(T, 4)`.

identity `classmethod` ¶

identity(
    frame_count: int, *, fps: float = 30.0, frame: FrameConvention = Z_UP_RIGHT_HANDED
) -> PoseSequence

Return frame_count identity poses.

Parameters:

Name	Type	Description	Default
`frame_count`	`int`	Number of frames to create.	required
`fps`	`float`	Sampling rate in Hz.	`30.0`
`frame`	`FrameConvention`	World coordinate convention for every pose.	`Z_UP_RIGHT_HANDED`

Returns:

Name	Type	Description
`PoseSequence`	`PoseSequence`	Sequence of identity transforms.

from_arrays `classmethod` ¶

from_arrays(
    positions: Any,
    quaternions: Any,
    *,
    fps: float = 30.0,
    quaternion_order: QuaternionOrder = WXYZ,
    frame: FrameConvention = Z_UP_RIGHT_HANDED,
) -> PoseSequence

Build a pose sequence from position and quaternion arrays.

Parameters:

Name	Type	Description	Default
`positions`	`Any`	Translations with shape `(T, 3)`.	required
`quaternions`	`Any`	Orientations with shape `(T, 4)` in `quaternion_order`.	required
`fps`	`float`	Sampling rate in Hz.	`30.0`
`quaternion_order`	`QuaternionOrder`	Layout of each row in `quaternions`.	`WXYZ`
`frame`	`FrameConvention`	World coordinate convention for every pose.	`Z_UP_RIGHT_HANDED`

Returns:

Name	Type	Description
`PoseSequence`	`PoseSequence`	One `Pose` per matched time index.

to_frame ¶

to_frame(target: FrameConvention) -> PoseSequence

Return this sequence represented in another coordinate frame convention.

Parameters:

Name	Type	Description	Default
`target`	`FrameConvention`	Desired world coordinate convention.	required

Returns:

Name	Type	Description
`PoseSequence`	`PoseSequence`	Copy with each pose converted to `target`.

scaled ¶

scaled(factor: float) -> PoseSequence

Return this sequence with translations scaled and rotations preserved.

Parameters:

Name	Type	Description	Default
`factor`	`float`	Multiplier applied to every pose translation.	required

Returns:

Name	Type	Description
`PoseSequence`	`PoseSequence`	Copy with scaled translations and unchanged orientations.

resampled ¶

resampled(fps: float) -> PoseSequence

Return this pose sequence sampled on a new FPS grid.

Parameters:

Name	Type	Description	Default
`fps`	`float`	Target sampling rate in Hz.	required

Returns:

Name	Type	Description
`PoseSequence`	`PoseSequence`	Endpoint-preserving resample with linear translation and spherical-linear rotation interpolation.

InteractionMeshSpec ¶

Bases: BaseModel

Configuration for interaction mesh construction.

Attributes:

Name	Type	Description
`topology`	`MeshTopology`	Graph construction policy.
`k_neighbors`	`int`	Neighbor count when `topology` is `K_NEAREST` or Delaunay fallback.
`laplacian_weighting`	`LaplacianWeighting`	Neighbor weighting used by Laplacian objectives.
`laplacian_epsilon`	`float`	Small positive value used by distance-weighted Laplacians.

Attributes¶

model_config `class-attribute` `instance-attribute` ¶

model_config = ConfigDict(extra='forbid')

topology `class-attribute` `instance-attribute` ¶

topology: MeshTopology = DELAUNAY

k_neighbors `class-attribute` `instance-attribute` ¶

k_neighbors: int = 4

laplacian_weighting `class-attribute` `instance-attribute` ¶

laplacian_weighting: LaplacianWeighting = UNIFORM

laplacian_epsilon `class-attribute` `instance-attribute` ¶

laplacian_epsilon: float = 1e-06

MotionFormatSpec ¶

Bases: BaseModel, Generic[JointT]

Concrete source-motion vocabulary and storage conventions.

Methods:

Name	Description
`joint_index`	Return the index of a typed joint.

Attributes:

Name	Type	Description
`model_config`
`name`	`str`
`joint_vocabulary`	`type[JointT]`
`root_joint`	`JointT`
`quaternion_order`	`QuaternionOrder`
`frame_convention`	`FrameConvention`
`default_fps`	`float`
`default_height_m`	`float \| None`
`description`	`str`
`joints`	`tuple[JointT, ...]`	Ordered joints declared by this format.

Attributes¶

model_config `class-attribute` `instance-attribute` ¶

model_config = ConfigDict(arbitrary_types_allowed=True)

name `instance-attribute` ¶

name: str

joint_vocabulary `instance-attribute` ¶

joint_vocabulary: type[JointT]

root_joint `instance-attribute` ¶

root_joint: JointT

quaternion_order `class-attribute` `instance-attribute` ¶

quaternion_order: QuaternionOrder = WXYZ

frame_convention `class-attribute` `instance-attribute` ¶

frame_convention: FrameConvention = Z_UP_RIGHT_HANDED

default_fps `class-attribute` `instance-attribute` ¶

default_fps: float = 30.0

default_height_m `class-attribute` `instance-attribute` ¶

default_height_m: float | None = None

description `class-attribute` `instance-attribute` ¶

description: str = ''

joints `property` ¶

joints: tuple[JointT, ...]

Ordered joints declared by this format.

Functions¶

joint_index ¶

joint_index(joint: JointT) -> int

Return the index of a typed joint.

SceneObservation `dataclass` ¶

SceneObservation(
    name: str,
    timeline: SampleTimeline,
    world_frame: FrameConvention,
    actor: MotionSequence[Any],
    landmarks: tuple[PointTrack, ...] = (),
    rigid_bodies: tuple[PoseTrack, ...] = (),
    objects: tuple[ObservedObject, ...] = (),
    contacts: SemanticContactSequence | None = None,
    terrain: TerrainSpec | None = None,
    alignment_reports: tuple[AlignmentReport, ...] = (),
    provenance: dict[str, object] = dict(),
)

Shared-timeline result of capture processing before robot adaptation.

Methods:

Name	Description
`landmark`	Return a semantic landmark track.
`observed_object`	Return an observed object.
`save_npz`	Explicitly save this observation checkpoint without pickle.
`load_npz`	Load an explicit observation checkpoint.

Attributes:

Name	Type	Description
`name`	`str`
`timeline`	`SampleTimeline`
`world_frame`	`FrameConvention`
`actor`	`MotionSequence[Any]`
`landmarks`	`tuple[PointTrack, ...]`
`rigid_bodies`	`tuple[PoseTrack, ...]`
`objects`	`tuple[ObservedObject, ...]`
`contacts`	`SemanticContactSequence \| None`
`terrain`	`TerrainSpec \| None`
`alignment_reports`	`tuple[AlignmentReport, ...]`
`provenance`	`dict[str, object]`

Attributes¶

name `instance-attribute` ¶

name: str

timeline `instance-attribute` ¶

timeline: SampleTimeline

world_frame `instance-attribute` ¶

world_frame: FrameConvention

actor `instance-attribute` ¶

actor: MotionSequence[Any]

landmarks `class-attribute` `instance-attribute` ¶

landmarks: tuple[PointTrack, ...] = ()

rigid_bodies `class-attribute` `instance-attribute` ¶

rigid_bodies: tuple[PoseTrack, ...] = ()

objects `class-attribute` `instance-attribute` ¶

objects: tuple[ObservedObject, ...] = ()

contacts `class-attribute` `instance-attribute` ¶

contacts: SemanticContactSequence | None = None

terrain `class-attribute` `instance-attribute` ¶

terrain: TerrainSpec | None = None

alignment_reports `class-attribute` `instance-attribute` ¶

alignment_reports: tuple[AlignmentReport, ...] = ()

provenance `class-attribute` `instance-attribute` ¶

provenance: dict[str, object] = field(default_factory=dict)

Functions¶

landmark ¶

landmark(role: ObservationRole) -> PointTrack

Return a semantic landmark track.

observed_object ¶

observed_object(role: ObservationRole) -> ObservedObject

Return an observed object.

save_npz ¶

save_npz(path: str | Path) -> Path

Explicitly save this observation checkpoint without pickle.

load_npz `classmethod` ¶

load_npz(path: str | Path) -> SceneObservation

Load an explicit observation checkpoint.

ConstraintConfig ¶

Bases: BaseModel

Base class for constraint configs keyed by an extensible enum member.

Methods:

Name	Description
`with_enabled`	Return a copy with a different enabled state.
`disabled`	Return a disabled copy.

Attributes:

Name	Type	Description
`model_config`
`kind`	`ConstraintKind`
`enabled`	`bool`

Attributes¶

model_config `class-attribute` `instance-attribute` ¶

model_config = ConfigDict(extra='forbid', arbitrary_types_allowed=True)

kind `class-attribute` ¶

kind: ConstraintKind

enabled `class-attribute` `instance-attribute` ¶

enabled: bool = True

Functions¶

with_enabled ¶

with_enabled(enabled: bool = True) -> Self

Return a copy with a different enabled state.

disabled ¶

disabled() -> Self

Return a disabled copy.

ObjectiveConfig ¶

Bases: BaseModel

Base class for objective configs keyed by an extensible enum member.

Methods:

Name	Description
`with_weight`	Return a copy with a different objective weight.

Attributes:

Name	Type	Description
`model_config`
`kind`	`ObjectiveKind`
`weight`	`float`

Attributes¶

model_config `class-attribute` `instance-attribute` ¶

model_config = ConfigDict(extra='forbid', arbitrary_types_allowed=True)

kind `class-attribute` ¶

kind: ObjectiveKind

weight `class-attribute` `instance-attribute` ¶

weight: float = 1.0

Functions¶

with_weight ¶

with_weight(weight: float) -> Self

Return a copy with a different objective weight.

OptimizationProfile ¶

Bases: BaseModel

Reusable typed objective/constraint composition.

Methods:

Name	Description
`defaults`	Return default robot-only optimization terms.
`objective`	Return the last objective matching `kind`.
`constraint`	Return the last constraint matching `kind`.
`with_objective`
`without_objective`
`with_constraint`
`without_constraint`
`validate_registry_references`

Attributes:

Name	Type	Description
`model_config`
`name`	`str`
`objectives`	`tuple[ObjectiveConfig, ...]`
`constraints`	`tuple[ConstraintConfig, ...]`
`provenance`	`dict[str, object]`
`objective_kinds`	`tuple[ObjectiveKind, ...]`	Objective kinds in profile order.
`constraint_kinds`	`tuple[ConstraintKind, ...]`	Constraint kinds in profile order.

Attributes¶

model_config `class-attribute` `instance-attribute` ¶

model_config = ConfigDict(arbitrary_types_allowed=True)

name `class-attribute` `instance-attribute` ¶

name: str = 'custom'

objectives `class-attribute` `instance-attribute` ¶

objectives: tuple[ObjectiveConfig, ...] = ()

constraints `class-attribute` `instance-attribute` ¶

constraints: tuple[ConstraintConfig, ...] = ()

provenance `class-attribute` `instance-attribute` ¶

provenance: dict[str, object] = Field(default_factory=dict)

objective_kinds `property` ¶

objective_kinds: tuple[ObjectiveKind, ...]

Objective kinds in profile order.

constraint_kinds `property` ¶

constraint_kinds: tuple[ConstraintKind, ...]

Constraint kinds in profile order.

Functions¶

defaults `classmethod` ¶

defaults(*, name: str = 'default') -> OptimizationProfile

Return default robot-only optimization terms.

objective ¶

objective(kind: ObjectiveKind) -> ObjectiveConfig | None

Return the last objective matching kind.

constraint ¶

constraint(kind: ConstraintKind) -> ConstraintConfig | None

Return the last constraint matching kind.

with_objective ¶

with_objective(objective: ObjectiveConfig, *, replace: bool = True) -> Self

without_objective ¶

without_objective(*kinds: ObjectiveKind) -> Self

with_constraint ¶

with_constraint(constraint: ConstraintConfig, *, replace: bool = True) -> Self

without_constraint ¶

without_constraint(*kinds: ConstraintKind) -> Self

validate_registry_references ¶

validate_registry_references(solver: SolverSpec | None = None) -> None

SolverSpec ¶

Bases: BaseModel

Solver selection and common options.

Attributes:

Name	Type	Description
`model_config`
`backend`	`SolverKind`
`max_iterations`	`int`
`first_frame_iterations`	`int \| None`
`trust_radius`	`float`
`tolerance`	`float`
`convergence`	`ConvergenceMode`
`cost_atol`	`float`
`cost_rtol`	`float`
`verbose`	`bool`

Attributes¶

model_config `class-attribute` `instance-attribute` ¶

model_config = ConfigDict(extra='forbid', arbitrary_types_allowed=True)

backend `class-attribute` `instance-attribute` ¶

backend: SolverKind = AUTO

max_iterations `class-attribute` `instance-attribute` ¶

max_iterations: int = 10

first_frame_iterations `class-attribute` `instance-attribute` ¶

first_frame_iterations: int | None = None

trust_radius `class-attribute` `instance-attribute` ¶

trust_radius: float = 0.2

tolerance `class-attribute` `instance-attribute` ¶

tolerance: float = 1e-06

convergence `class-attribute` `instance-attribute` ¶

convergence: ConvergenceMode = STEP_NORM

cost_atol `class-attribute` `instance-attribute` ¶

cost_atol: float = 1e-08

cost_rtol `class-attribute` `instance-attribute` ¶

cost_rtol: float = 1e-05

verbose `class-attribute` `instance-attribute` ¶

verbose: bool = False

QposVariableSpec ¶

Bases: BaseModel

Configuration describing which qpos coordinates the optimizer may change.

actuated preserves the package default: only robot joints are decision variables. qpos_slice and qpos_indices allow floating-base, Holosoma-style, or otherwise custom variable sets without changing terms.

Methods:

Name	Description
`actuated`	Return the default actuated-joint variable policy.
`qpos_slice`	Return a contiguous qpos variable policy.
`qpos_indices`	Return an explicit qpos-index variable policy.
`from_actuated_start_offset`	Return a slice starting relative to `robot.qpos_layout.joint_start`.
`holosoma_q_a`	Return the variable policy matching Holosoma's default `q_a` slice.
`resolve`	Resolve this policy against a robot and concrete qpos width.

Attributes:

Name	Type	Description
`model_config`
`kind`	`QposVariableKind`
`start`	`int \| None`
`stop`	`int \| None`
`indices`	`tuple[int, ...]`
`actuated_start_offset`	`int \| None`
`unbounded_limit`	`float`
`normalize_quaternion`	`bool`

Attributes¶

model_config `class-attribute` `instance-attribute` ¶

model_config = ConfigDict(extra='forbid')

kind `class-attribute` `instance-attribute` ¶

kind: QposVariableKind = ACTUATED

start `class-attribute` `instance-attribute` ¶

start: int | None = None

stop `class-attribute` `instance-attribute` ¶

stop: int | None = None

indices `class-attribute` `instance-attribute` ¶

indices: tuple[int, ...] = ()

actuated_start_offset `class-attribute` `instance-attribute` ¶

actuated_start_offset: int | None = None

unbounded_limit `class-attribute` `instance-attribute` ¶

unbounded_limit: float = 1000000.0

normalize_quaternion `class-attribute` `instance-attribute` ¶

normalize_quaternion: bool = True

Functions¶

actuated `classmethod` ¶

actuated() -> Self

Return the default actuated-joint variable policy.

qpos_slice `classmethod` ¶

qpos_slice(
    *, start: int, stop: int | None = None, normalize_quaternion: bool = True
) -> Self

Return a contiguous qpos variable policy.

qpos_indices `classmethod` ¶

qpos_indices(indices: tuple[int, ...], *, normalize_quaternion: bool = True) -> Self

Return an explicit qpos-index variable policy.

from_actuated_start_offset `classmethod` ¶

from_actuated_start_offset(offset: int, *, stop: int | None = None) -> Self

Return a slice starting relative to robot.qpos_layout.joint_start.

Holosoma's q_a_init_idx=-7 is represented by from_actuated_start_offset(-7) for the default floating-base qpos layout, giving a variable slice from root position through actuated joints.

holosoma_q_a `classmethod` ¶

holosoma_q_a(q_a_init_idx: int = -7) -> Self

Return the variable policy matching Holosoma's default q_a slice.

resolve ¶

resolve(
    robot: RobotSpec[JointT, Any, Any, Any],
    *,
    qpos_size: int,
    joint_limits: Mapping[JointT, tuple[float, float]] | None = None,
) -> ResolvedQposVariables

Resolve this policy against a robot and concrete qpos width.

JointBinding `dataclass` ¶

JointBinding(source: MotionJointT, target: RobotJointT)

Bases: Generic[MotionJointT, RobotJointT]

Explicit source-motion joint to robot-joint binding.

Attributes:

Name	Type	Description
`source`	`MotionJointT`
`target`	`RobotJointT`

Attributes¶

source `instance-attribute` ¶

source: MotionJointT

target `instance-attribute` ¶

target: RobotJointT

LinkBinding `dataclass` ¶

LinkBinding(source: MotionJointT, target: RobotLinkT)

Bases: Generic[MotionJointT, RobotLinkT]

Explicit source-motion joint to robot-link binding.

Attributes:

Name	Type	Description
`source`	`MotionJointT`
`target`	`RobotLinkT`

Attributes¶

source `instance-attribute` ¶

source: MotionJointT

target `instance-attribute` ¶

target: RobotLinkT

RetargetingProblem ¶

Bases: BaseModel, Generic[MotionJointT, RobotJointT, RobotLinkT, RobotGeometryT, RobotRoleT]

Complete typed run specification before backend compilation.

Methods:

Name	Description
`joint_mapping`	Return the typed motion-joint to robot-joint mapping.
`link_mapping`	Return the typed motion-joint to robot-link mapping.
`validate_registry_references`	Validate registered optimization references used by this problem.
`with_optimization_profile`	Return a copy using one reusable optimization profile.
`with_output_fps_applied`	Return a problem whose dynamic data matches `output_fps`.

Attributes:

Name	Type	Description
`model_config`
`name`	`str`
`task_kind`	`TaskKind`
`robot`	`RobotSpec[RobotJointT, RobotLinkT, RobotGeometryT, RobotRoleT]`
`motion`	`MotionSequence[MotionJointT]`
`scene`	`SceneSpec`
`contacts`	`ContactPlan[Any, Any, Any, RobotLinkT] \| None`
`targets`	`LinkTargetPlan[RobotLinkT] \| None`
`initial_qpos`	`InitialQposPlan \| None`
`nominal_qpos`	`NominalQposPlan \| None`
`joint_bindings`	`tuple[JointBinding[MotionJointT, RobotJointT], ...]`
`link_bindings`	`tuple[LinkBinding[MotionJointT, RobotLinkT], ...]`
`mesh`	`InteractionMeshSpec`
`solver`	`SolverSpec`
`variables`	`QposVariableSpec`
`objectives`	`tuple[ObjectiveConfig, ...]`
`constraints`	`tuple[ConstraintConfig, ...]`
`scale_to_robot`	`bool`
`output_fps`	`float \| None`
`show_progress`	`bool`
`progress_description`	`str \| None`
`provenance`	`dict[str, Any]`
`fps`	`float`	Effective playback and result sampling rate.

Attributes¶

model_config `class-attribute` `instance-attribute` ¶

model_config = ConfigDict(arbitrary_types_allowed=True)

name `instance-attribute` ¶

name: str

task_kind `instance-attribute` ¶

task_kind: TaskKind

robot `instance-attribute` ¶

robot: RobotSpec[RobotJointT, RobotLinkT, RobotGeometryT, RobotRoleT]

motion `instance-attribute` ¶

motion: MotionSequence[MotionJointT]

scene `instance-attribute` ¶

scene: SceneSpec

contacts `class-attribute` `instance-attribute` ¶

contacts: ContactPlan[Any, Any, Any, RobotLinkT] | None = None

targets `class-attribute` `instance-attribute` ¶

targets: LinkTargetPlan[RobotLinkT] | None = None

initial_qpos `class-attribute` `instance-attribute` ¶

initial_qpos: InitialQposPlan | None = None

nominal_qpos `class-attribute` `instance-attribute` ¶

nominal_qpos: NominalQposPlan | None = None

joint_bindings `class-attribute` `instance-attribute` ¶

joint_bindings: tuple[JointBinding[MotionJointT, RobotJointT], ...] = ()

link_bindings `class-attribute` `instance-attribute` ¶

link_bindings: tuple[LinkBinding[MotionJointT, RobotLinkT], ...] = ()

mesh `class-attribute` `instance-attribute` ¶

mesh: InteractionMeshSpec = Field(default_factory=InteractionMeshSpec)

solver `class-attribute` `instance-attribute` ¶

solver: SolverSpec = Field(default_factory=SolverSpec)

variables `class-attribute` `instance-attribute` ¶

variables: QposVariableSpec = Field(default_factory=actuated)

objectives `class-attribute` `instance-attribute` ¶

objectives: tuple[ObjectiveConfig, ...] = objectives

constraints `class-attribute` `instance-attribute` ¶

constraints: tuple[ConstraintConfig, ...] = constraints

scale_to_robot `class-attribute` `instance-attribute` ¶

scale_to_robot: bool = True

output_fps `class-attribute` `instance-attribute` ¶

output_fps: float | None = None

show_progress `class-attribute` `instance-attribute` ¶

show_progress: bool = False

progress_description `class-attribute` `instance-attribute` ¶

progress_description: str | None = None

provenance `class-attribute` `instance-attribute` ¶

provenance: dict[str, Any] = Field(default_factory=dict)

fps `property` ¶

fps: float

Effective playback and result sampling rate.

Functions¶

joint_mapping ¶

joint_mapping() -> dict[MotionJointT, RobotJointT]

Return the typed motion-joint to robot-joint mapping.

link_mapping ¶

link_mapping() -> dict[MotionJointT, RobotLinkT]

Return the typed motion-joint to robot-link mapping.

validate_registry_references ¶

validate_registry_references() -> None

Validate registered optimization references used by this problem.

with_optimization_profile ¶

with_optimization_profile(
    profile: OptimizationProfile,
) -> RetargetingProblem[
    MotionJointT, RobotJointT, RobotLinkT, RobotGeometryT, RobotRoleT
]

Return a copy using one reusable optimization profile.

with_output_fps_applied ¶

with_output_fps_applied() -> RetargetingProblem[
    MotionJointT, RobotJointT, RobotLinkT, RobotGeometryT, RobotRoleT
]

Return a problem whose dynamic data matches output_fps.

SceneRecipe ¶

Bases: Protocol

Build target-independent runtime scene data from an observation.

Methods:

Name	Description
`build_scene`	Build a frame-aligned scene.

Functions¶

build_scene ¶

build_scene(observation: SceneObservation) -> SceneSpec

Build a frame-aligned scene.

RobotSpec ¶

Bases: BaseModel, Generic[JointT, LinkT, GeometryT, RoleT]

Robot description that preserves enum identity until backend compilation.

Methods:

Name	Description
`joint_index`	Return the actuated index for a typed joint.
`joint_for_role`	Resolve a semantic robot role to an actuated joint.
`link_for_role`	Resolve a semantic robot role to a link.
`links_for_role`	Resolve a semantic robot role to one or more links.
`qpos_size`	Return qpos size for this robot and object setting.
`load`	Load a robot spec whose config names concrete enum vocabulary classes.
`resolve_paths`	Return a copy with relative asset paths resolved against `base_dir`.
`save_json`	Save a JSON representation with explicit vocabulary references.
`limits_array`	Return joint limits in joint order.

Attributes:

Name	Type	Description
`model_config`
`name`	`str`
`height_m`	`float`
`vocabulary`	`RobotVocabulary[JointT, LinkT, GeometryT, RoleT]`
`joints`	`tuple[JointT, ...]`
`links`	`tuple[LinkT, ...]`
`contact_links`	`tuple[LinkT, ...]`
`geometries`	`tuple[GeometryT, ...]`
`joint_limits`	`dict[JointT, tuple[float, float]]`
`joint_roles`	`dict[RoleT, JointT]`
`link_roles`	`dict[RoleT, LinkT]`
`link_groups`	`dict[RoleT, tuple[LinkT, ...]]`
`mujoco_body_aliases`	`dict[LinkT, str]`
`simple_kinematics`	`dict[LinkT, SimpleKinematicPoint[JointT]]`
`urdf_path`	`Path \| None`
`mujoco_xml_path`	`Path \| None`
`qpos_layout`	`QposLayout`
`provenance`	`dict[str, Any]`
`dof`	`int`	Number of actuated joints.

Attributes¶

model_config `class-attribute` `instance-attribute` ¶

model_config = ConfigDict(arbitrary_types_allowed=True)

name `instance-attribute` ¶

name: str

height_m `instance-attribute` ¶

height_m: float

vocabulary `instance-attribute` ¶

vocabulary: RobotVocabulary[JointT, LinkT, GeometryT, RoleT]

joints `instance-attribute` ¶

joints: tuple[JointT, ...]

links `instance-attribute` ¶

links: tuple[LinkT, ...]

contact_links `class-attribute` `instance-attribute` ¶

contact_links: tuple[LinkT, ...] = ()

geometries `class-attribute` `instance-attribute` ¶

geometries: tuple[GeometryT, ...] = ()

joint_limits `class-attribute` `instance-attribute` ¶

joint_limits: dict[JointT, tuple[float, float]] = Field(default_factory=dict)

joint_roles `class-attribute` `instance-attribute` ¶

joint_roles: dict[RoleT, JointT] = Field(default_factory=dict)

link_roles `class-attribute` `instance-attribute` ¶

link_roles: dict[RoleT, LinkT] = Field(default_factory=dict)

link_groups `class-attribute` `instance-attribute` ¶

link_groups: dict[RoleT, tuple[LinkT, ...]] = Field(default_factory=dict)

mujoco_body_aliases `class-attribute` `instance-attribute` ¶

mujoco_body_aliases: dict[LinkT, str] = Field(default_factory=dict)

simple_kinematics `class-attribute` `instance-attribute` ¶

simple_kinematics: dict[LinkT, SimpleKinematicPoint[JointT]] = Field(
    default_factory=dict
)

urdf_path `class-attribute` `instance-attribute` ¶

urdf_path: Path | None = None

mujoco_xml_path `class-attribute` `instance-attribute` ¶

mujoco_xml_path: Path | None = None

qpos_layout `class-attribute` `instance-attribute` ¶

qpos_layout: QposLayout = Field(default_factory=QposLayout)

provenance `class-attribute` `instance-attribute` ¶

provenance: dict[str, Any] = Field(default_factory=dict)

dof `property` ¶

dof: int

Number of actuated joints.

Functions¶

joint_index ¶

joint_index(joint: JointT) -> int

Return the actuated index for a typed joint.

joint_for_role ¶

joint_for_role(role: RoleT) -> JointT

Resolve a semantic robot role to an actuated joint.

link_for_role ¶

link_for_role(role: RoleT) -> LinkT

Resolve a semantic robot role to a link.

links_for_role ¶

links_for_role(role: RoleT) -> tuple[LinkT, ...]

Resolve a semantic robot role to one or more links.

qpos_size ¶

qpos_size(*, has_object: bool = False) -> int

Return qpos size for this robot and object setting.

load `classmethod` ¶

load(path: str | Path) -> RobotSpec[Any, Any, Any, Any]

Load a robot spec whose config names concrete enum vocabulary classes.

resolve_paths ¶

resolve_paths(base_dir: str | Path) -> RobotSpec[JointT, LinkT, GeometryT, RoleT]

Return a copy with relative asset paths resolved against base_dir.

save_json ¶

save_json(path: str | Path) -> Path

Save a JSON representation with explicit vocabulary references.

limits_array ¶

limits_array() -> tuple[list[float], list[float]]

Return joint limits in joint order.

SceneSpec ¶

Bases: BaseModel

Scene configuration for a retargeting run.

Attributes:

Name	Type	Description
`task_kind`	`TaskKind`	High-level workflow (robot-only, object interaction, climbing).
`object`	`ObjectSpec \| None`	Manipulated or climbable object definition.
`terrain`	`TerrainSpec \| None`	Static ground or climbable terrain definition.
`ground_range`	`tuple[float, float]`	XY extent of the procedural ground grid (meters).
`ground_size`	`int`	Number of samples per axis for :meth:`ground_points`.
`provenance`	`dict[str, Any]`	Origin and processing history for the scene.

Methods:

Name	Description
`robot_only`	Create a robot-only ground scene.
`object_interaction`	Create an object interaction scene.
`climbing`	Create a climbing or terrain-interaction scene.
`has_dynamic_object`	Whether qpos should include appended object poses.
`resampled`	Return a scene with dynamic trajectories sampled on a new FPS grid.
`ground_points`	Create an xy grid of ground points.

Attributes¶

model_config `class-attribute` `instance-attribute` ¶

model_config = ConfigDict(arbitrary_types_allowed=True)

task_kind `instance-attribute` ¶

task_kind: TaskKind

object `class-attribute` `instance-attribute` ¶

object: ObjectSpec | None = None

terrain `class-attribute` `instance-attribute` ¶

terrain: TerrainSpec | None = None

ground_range `class-attribute` `instance-attribute` ¶

ground_range: tuple[float, float] = (-1.0, 1.0)

ground_size `class-attribute` `instance-attribute` ¶

ground_size: int = 15

provenance `class-attribute` `instance-attribute` ¶

provenance: dict[str, Any] = Field(default_factory=dict)

Functions¶

robot_only `classmethod` ¶

robot_only() -> SceneSpec

Create a robot-only ground scene.

Returns:

Name	Type	Description
`SceneSpec`	`SceneSpec`	`ROBOT_ONLY` task with default flat terrain.

object_interaction `classmethod` ¶

object_interaction(object_spec: ObjectSpec) -> SceneSpec

Create an object interaction scene.

Parameters:

Name	Type	Description	Default
`object_spec`	`ObjectSpec`	Manipulated object definition.	required

Returns:

Name	Type	Description
`SceneSpec`	`SceneSpec`	`OBJECT_INTERACTION` task referencing `object_spec`.

climbing `classmethod` ¶

climbing(
    terrain: TerrainSpec | None = None, object_spec: ObjectSpec | None = None
) -> SceneSpec

Create a climbing or terrain-interaction scene.

Parameters:

Name	Type	Description	Default
`terrain`	`TerrainSpec \| None`	Climbable terrain mesh or samples.	`None`
`object_spec`	`ObjectSpec \| None`	Optional climbable object instead of terrain.	`None`

Returns:

Name	Type	Description
`SceneSpec`	`SceneSpec`	`CLIMBING` task; inserts a default terrain spec when both arguments are omitted.

has_dynamic_object ¶

has_dynamic_object() -> bool

Whether qpos should include appended object poses.

resampled ¶

resampled(fps: float) -> SceneSpec

Return a scene with dynamic trajectories sampled on a new FPS grid.

ground_points ¶

ground_points() -> FloatArray

Create an xy grid of ground points.

TerrainSpec ¶

Bases: BaseModel

Static terrain information.

Attributes:

Name	Type	Description
`name`	`str`	Terrain label used in scene exports and logs.
`mesh_path`	`Path \| None`	Optional terrain mesh file.
`sample_points`	`FloatArray \| None`	Precomputed terrain surface points with shape `(N, 3)`.
`provenance`	`dict[str, Any]`	Origin and processing history for terrain.

Attributes¶

model_config `class-attribute` `instance-attribute` ¶

model_config = ConfigDict(arbitrary_types_allowed=True)

name `class-attribute` `instance-attribute` ¶

name: str = 'ground'

mesh_path `class-attribute` `instance-attribute` ¶

mesh_path: Path | None = None

sample_points `class-attribute` `instance-attribute` ¶

sample_points: FloatArray | None = None

provenance `class-attribute` `instance-attribute` ¶

provenance: dict[str, Any] = Field(default_factory=dict)

MotionFileObservationRecipe `dataclass` ¶

MotionFileObservationRecipe(
    path: Path,
    motion_format: MotionFormatSpec,
    name: str | None = None,
    max_frames: int | None = None,
    source_height_m: float | None = None,
)

Load a registered motion file into a typed scene observation.

Methods:

Name	Description
`registered`	Construct from a registered motion-format key.
`observe`	Load the file without creating an intermediate checkpoint.

Attributes:

Name	Type	Description
`path`	`Path`
`motion_format`	`MotionFormatSpec`
`name`	`str \| None`
`max_frames`	`int \| None`
`source_height_m`	`float \| None`

Attributes¶

path `instance-attribute` ¶

path: Path

motion_format `instance-attribute` ¶

motion_format: MotionFormatSpec

name `class-attribute` `instance-attribute` ¶

name: str | None = None

max_frames `class-attribute` `instance-attribute` ¶

max_frames: int | None = None

source_height_m `class-attribute` `instance-attribute` ¶

source_height_m: float | None = None

Functions¶

registered `classmethod` ¶

registered(
    path: str | Path,
    format_kind: MotionFormatKind,
    *,
    name: str | None = None,
    max_frames: int | None = None,
    source_height_m: float | None = None,
) -> MotionFileObservationRecipe

Construct from a registered motion-format key.

observe ¶

observe() -> SceneObservation

Load the file without creating an intermediate checkpoint.

RobotOnlySceneRecipe `dataclass` ¶

RobotOnlySceneRecipe(
    terrain: TerrainSpec = TerrainSpec(),
    ground_range: tuple[float, float] = (-1.0, 1.0),
    ground_size: int = 15,
)

Build a flat-ground robot-only scene.

Methods:

Name	Description
`build_scene`	Build the scene independently of the target robot.

Attributes:

Name	Type	Description
`terrain`	`TerrainSpec`
`ground_range`	`tuple[float, float]`
`ground_size`	`int`

Attributes¶

terrain `class-attribute` `instance-attribute` ¶

terrain: TerrainSpec = field(default_factory=TerrainSpec)

ground_range `class-attribute` `instance-attribute` ¶

ground_range: tuple[float, float] = (-1.0, 1.0)

ground_size `class-attribute` `instance-attribute` ¶

ground_size: int = 15

Functions¶

build_scene ¶

build_scene(observation: SceneObservation) -> SceneSpec

Build the scene independently of the target robot.

StaticSceneRecipe `dataclass` ¶

StaticSceneRecipe(scene: SceneSpec)

Return a predeclared target-independent scene specification.

Methods:

Name	Description
`build_scene`	Validate the scene timeline and return the configured scene.

Attributes:

Name	Type	Description
`scene`	`SceneSpec`

Attributes¶

scene `instance-attribute` ¶

scene: SceneSpec

Functions¶

build_scene ¶

build_scene(observation: SceneObservation) -> SceneSpec

Validate the scene timeline and return the configured scene.

RoleRetargetingRecipe `dataclass` ¶

RoleRetargetingRecipe(
    task_kind: TaskKind,
    motion_format: MotionFormatSpec,
    scene: SceneRecipe,
    joint_roles: dict[MotionJoint, RobotRole] = dict(),
    link_roles: dict[MotionJoint, RobotRole] = dict(),
    mesh: InteractionMeshSpec = InteractionMeshSpec(),
    solver: SolverSpec = SolverSpec(),
    variables: QposVariableSpec = actuated(),
    objectives: tuple[ObjectiveConfig, ...] = objectives,
    constraints: tuple[ConstraintConfig, ...] = constraints,
    scale_to_robot: bool = True,
    output_fps: float | None = None,
    show_progress: bool = False,
    name: str | None = None,
    provenance: dict[str, object] = dict(),
)

Resolve typed motion joints through semantic robot roles.

Methods:

Name	Description
`build_problem`	Build the generic problem through explicit semantic role bindings.

Attributes:

Name	Type	Description
`task_kind`	`TaskKind`
`motion_format`	`MotionFormatSpec`
`scene`	`SceneRecipe`
`joint_roles`	`dict[MotionJoint, RobotRole]`
`link_roles`	`dict[MotionJoint, RobotRole]`
`mesh`	`InteractionMeshSpec`
`solver`	`SolverSpec`
`variables`	`QposVariableSpec`
`objectives`	`tuple[ObjectiveConfig, ...]`
`constraints`	`tuple[ConstraintConfig, ...]`
`scale_to_robot`	`bool`
`output_fps`	`float \| None`
`show_progress`	`bool`
`name`	`str \| None`
`provenance`	`dict[str, object]`

Attributes¶

task_kind `instance-attribute` ¶

task_kind: TaskKind

motion_format `instance-attribute` ¶

motion_format: MotionFormatSpec

scene `instance-attribute` ¶

scene: SceneRecipe

joint_roles `class-attribute` `instance-attribute` ¶

joint_roles: dict[MotionJoint, RobotRole] = field(default_factory=dict)

link_roles `class-attribute` `instance-attribute` ¶

link_roles: dict[MotionJoint, RobotRole] = field(default_factory=dict)

mesh `class-attribute` `instance-attribute` ¶

mesh: InteractionMeshSpec = field(default_factory=InteractionMeshSpec)

solver `class-attribute` `instance-attribute` ¶

solver: SolverSpec = field(default_factory=SolverSpec)

variables `class-attribute` `instance-attribute` ¶

variables: QposVariableSpec = field(default_factory=actuated)

objectives `class-attribute` `instance-attribute` ¶

objectives: tuple[ObjectiveConfig, ...] = objectives

constraints `class-attribute` `instance-attribute` ¶

constraints: tuple[ConstraintConfig, ...] = constraints

scale_to_robot `class-attribute` `instance-attribute` ¶

scale_to_robot: bool = True

output_fps `class-attribute` `instance-attribute` ¶

output_fps: float | None = None

show_progress `class-attribute` `instance-attribute` ¶

show_progress: bool = False

name `class-attribute` `instance-attribute` ¶

name: str | None = None

provenance `class-attribute` `instance-attribute` ¶

provenance: dict[str, object] = field(default_factory=dict)

Functions¶

build_problem ¶

build_problem(observation: SceneObservation, robot: RobotSpec) -> RetargetingProblem

Build the generic problem through explicit semantic role bindings.

Functions¶

load_motion ¶

load_motion(
    path: str | Path,
    motion_format: MotionFormatKind | MotionFormatSpec,
    *,
    name: str | None = None,
) -> MotionSequence

Load a motion sequence using a registered format and suffix loader.

The returned sequence is converted to :attr:~retarget.core.enums.FrameConvention.Z_UP_RIGHT_HANDED.

Parameters:

Name	Type	Description	Default
`path`	`str \| Path`	Motion file path; the suffix selects the loader.	required
`motion_format`	`MotionFormatKind \| MotionFormatSpec`	Typed registered motion format key or a concrete format specification.	required
`name`	`str \| None`	Optional sequence name; defaults to the file stem.	`None`

Returns:

Name	Type	Description
`MotionSequence`	`MotionSequence`	Parsed motion in Z-up world coordinates.

Raises:

Type	Description
`KeyError`	If the format name or file suffix is not registered.
`ValueError`	If the file content fails validation.

skateboarding ¶

Unified capture-to-retarget skateboarding workflow.

Modules:

Name	Description
`adaptation`	Robot adaptation recipe for skateboarding observations.
`alignment`	Temporal and spatial registration for skateboarding capture.
`observation`	Observation recipe for native skateboarding capture.
`scene`	Target-independent and runtime scene construction for skateboarding.
`schema`	Source schemas and semantic mappings for skateboarding.
`targets`	Robot-resolved link targets for skateboarding observations.
`vocabulary`	Typed native, semantic, and contact vocabularies for skateboarding.

Classes:

Name	Description
`SkateboardingRetargetingRecipe`	Adapt a skateboarding observation to a semantic humanoid robot.
`SkateboardingObservationRecipe`	Fuse native mocap and human-pose recordings into one observation.
`SkateboardingContactPatch`	Contact patches.
`SkateboardingContactState`	Foot support states.
`SkateboardingContactSubject`	Semantic contact subjects.
`SkateboardingDemo`	Bundled skateboarding capture identifiers.
`SkateboardingGeometryName`	Observed geometry names.
`SkateboardingMotionJoint`	GVHMR/SMPL-X joints used by the workflow.
`SkateboardingObservationRole`	Target-independent semantic landmarks and objects.
`SkateboardingRigidBody`	Native Vicon rigid bodies.

Attributes:

Name	Type	Description
`GVHMR_SCHEMA`
`VICON_SCHEMA`
`DEFAULT_DEMO`
`__all__`

Attributes¶

GVHMR_SCHEMA `module-attribute` ¶

GVHMR_SCHEMA = HumanPoseSourceSchema(
    joint_indices={
        PELVIS: 0,
        LEFT_HIP: 1,
        RIGHT_HIP: 2,
        LEFT_KNEE: 4,
        RIGHT_KNEE: 5,
        SPINE2: 6,
        LEFT_ANKLE: 7,
        RIGHT_ANKLE: 8,
        SPINE3: 9,
        LEFT_FOOT: 10,
        RIGHT_FOOT: 11,
        NECK: 12,
        HEAD: 15,
        LEFT_SHOULDER: 16,
        RIGHT_SHOULDER: 17,
        LEFT_ELBOW: 18,
        RIGHT_ELBOW: 19,
        LEFT_WRIST: 20,
        RIGHT_WRIST: 21,
        LEFT_BIG_TOE: 60,
        LEFT_SMALL_TOE: 61,
        LEFT_HEEL: 62,
        RIGHT_BIG_TOE: 63,
        RIGHT_SMALL_TOE: 64,
        RIGHT_HEEL: 65,
    }
)

VICON_SCHEMA `module-attribute` ¶

VICON_SCHEMA = ViconSourceSchema(
    rigid_bodies={(value): body for body in SkateboardingRigidBody},
    markers={},
    rigid_body_order=tuple((value) for body in SkateboardingRigidBody),
    marker_order=(),
)

DEFAULT_DEMO `module-attribute` ¶

DEFAULT_DEMO = value

all `module-attribute` ¶

__all__ = [
    "DEFAULT_DEMO",
    "GVHMR_SCHEMA",
    "VICON_SCHEMA",
    "SkateboardingContactPatch",
    "SkateboardingContactState",
    "SkateboardingContactSubject",
    "SkateboardingDemo",
    "SkateboardingGeometryName",
    "SkateboardingMotionJoint",
    "SkateboardingObservationRecipe",
    "SkateboardingObservationRole",
    "SkateboardingRetargetingRecipe",
    "SkateboardingRigidBody",
]

Classes¶

SkateboardingRetargetingRecipe `dataclass` ¶

SkateboardingRetargetingRecipe(
    scale_to_robot: bool = False,
    output_fps: float | None = None,
    show_progress: bool = False,
    solver_backend: SolverBackend = CVXPY_CLARABEL,
)

Adapt a skateboarding observation to a semantic humanoid robot.

Methods:

Name	Description
`build_problem`	Build the complete robot-resolved skateboarding problem.

Attributes:

Name	Type	Description
`scale_to_robot`	`bool`
`output_fps`	`float \| None`
`show_progress`	`bool`
`solver_backend`	`SolverBackend`

Attributes¶

scale_to_robot `class-attribute` `instance-attribute` ¶

scale_to_robot: bool = False

output_fps `class-attribute` `instance-attribute` ¶

output_fps: float | None = None

show_progress `class-attribute` `instance-attribute` ¶

show_progress: bool = False

solver_backend `class-attribute` `instance-attribute` ¶

solver_backend: SolverBackend = CVXPY_CLARABEL

Functions¶

build_problem ¶

build_problem(observation: SceneObservation, robot: RobotSpec) -> RetargetingProblem

Build the complete robot-resolved skateboarding problem.

SkateboardingObservationRecipe `dataclass` ¶

SkateboardingObservationRecipe(
    mocap: ObservationSource[MocapRecording],
    human_pose: ObservationSource[HumanPoseRecording],
    timeline_selection: TimelineSelection = HUMAN_POSE,
    crop_policy: CropPolicy = OVERLAP,
    uniform_fps: float | None = None,
    temporal_registration: TemporalRegistrationConfig = (
        lambda: TemporalRegistrationConfig(
            max_abs_offset_s=20.0, min_overlap_s=1.0, minimum_score=0.28
        )
    )(),
    support_classification: FootSupportClassificationConfig = FootSupportClassificationConfig(),
    max_frames: int | None = None,
    world_frame: FrameConvention = Z_UP_RIGHT_HANDED,
)

Fuse native mocap and human-pose recordings into one observation.

Methods:

Name	Description
`observe`	Load, align, reconstruct, and classify the capture in memory.

Attributes:

Name	Type	Description
`mocap`	`ObservationSource[MocapRecording]`
`human_pose`	`ObservationSource[HumanPoseRecording]`
`timeline_selection`	`TimelineSelection`
`crop_policy`	`CropPolicy`
`uniform_fps`	`float \| None`
`temporal_registration`	`TemporalRegistrationConfig`
`support_classification`	`FootSupportClassificationConfig`
`max_frames`	`int \| None`
`world_frame`	`FrameConvention`

Attributes¶

mocap `instance-attribute` ¶

mocap: ObservationSource[MocapRecording]

human_pose `instance-attribute` ¶

human_pose: ObservationSource[HumanPoseRecording]

timeline_selection `class-attribute` `instance-attribute` ¶

timeline_selection: TimelineSelection = HUMAN_POSE

crop_policy `class-attribute` `instance-attribute` ¶

crop_policy: CropPolicy = OVERLAP

uniform_fps `class-attribute` `instance-attribute` ¶

uniform_fps: float | None = None

temporal_registration `class-attribute` `instance-attribute` ¶

temporal_registration: TemporalRegistrationConfig = field(
    default_factory=lambda: TemporalRegistrationConfig(
        max_abs_offset_s=20.0, min_overlap_s=1.0, minimum_score=0.28
    )
)

support_classification `class-attribute` `instance-attribute` ¶

support_classification: FootSupportClassificationConfig = field(
    default_factory=FootSupportClassificationConfig
)

max_frames `class-attribute` `instance-attribute` ¶

max_frames: int | None = None

world_frame `class-attribute` `instance-attribute` ¶

world_frame: FrameConvention = Z_UP_RIGHT_HANDED

Functions¶

observe ¶

observe() -> SceneObservation

Load, align, reconstruct, and classify the capture in memory.

SkateboardingContactPatch ¶

Bases: ContactPatch

Contact patches.

Attributes:

Name	Type	Description
`LEFT_SHOE_SOLE`
`RIGHT_SHOE_SOLE`

Attributes¶

LEFT_SHOE_SOLE `class-attribute` `instance-attribute` ¶

LEFT_SHOE_SOLE = 'left_shoe_sole'

RIGHT_SHOE_SOLE `class-attribute` `instance-attribute` ¶

RIGHT_SHOE_SOLE = 'right_shoe_sole'

SkateboardingContactState ¶

Bases: ContactState

Foot support states.

Attributes:

Name	Type	Description
`AIR`
`GROUND`
`BOARD`

Attributes¶

AIR `class-attribute` `instance-attribute` ¶

AIR = 'air'

GROUND `class-attribute` `instance-attribute` ¶

GROUND = 'ground'

BOARD `class-attribute` `instance-attribute` ¶

BOARD = 'board'

SkateboardingContactSubject ¶

Bases: ContactSubject

Semantic contact subjects.

Attributes:

Name	Type	Description
`LEFT_SHOE`
`RIGHT_SHOE`

Attributes¶

LEFT_SHOE `class-attribute` `instance-attribute` ¶

LEFT_SHOE = 'left_shoe'

RIGHT_SHOE `class-attribute` `instance-attribute` ¶

RIGHT_SHOE = 'right_shoe'

SkateboardingDemo ¶

Bases: NameEnum

Bundled skateboarding capture identifiers.

Members:

Name	Type	Description
`PUSHOFF5_TWOSHOES`	`int`	Value `'pushoff5_twoshoes'`.

PUSHOFF5_TWOSHOES `member` ¶

PUSHOFF5_TWOSHOES = 'pushoff5_twoshoes'

SkateboardingGeometryName ¶

Bases: SceneGeometry

Observed geometry names.

Attributes:

Name	Type	Description
`BOARD`
`GROUND`

Attributes¶

BOARD `class-attribute` `instance-attribute` ¶

BOARD = 'skateboard_deck'

GROUND `class-attribute` `instance-attribute` ¶

GROUND = 'ground'

SkateboardingMotionJoint ¶

Bases: MotionJoint

GVHMR/SMPL-X joints used by the workflow.

Attributes:

Name	Type	Description
`PELVIS`
`LEFT_HIP`
`RIGHT_HIP`
`LEFT_KNEE`
`RIGHT_KNEE`
`LEFT_ANKLE`
`RIGHT_ANKLE`
`LEFT_FOOT`
`RIGHT_FOOT`
`SPINE2`
`SPINE3`
`NECK`
`HEAD`
`LEFT_SHOULDER`
`RIGHT_SHOULDER`
`LEFT_ELBOW`
`RIGHT_ELBOW`
`LEFT_WRIST`
`RIGHT_WRIST`
`LEFT_BIG_TOE`
`LEFT_SMALL_TOE`
`LEFT_HEEL`
`RIGHT_BIG_TOE`
`RIGHT_SMALL_TOE`
`RIGHT_HEEL`

Attributes¶

PELVIS `class-attribute` `instance-attribute` ¶

PELVIS = 'Pelvis'

LEFT_HIP `class-attribute` `instance-attribute` ¶

LEFT_HIP = 'L_Hip'

RIGHT_HIP `class-attribute` `instance-attribute` ¶

RIGHT_HIP = 'R_Hip'

LEFT_KNEE `class-attribute` `instance-attribute` ¶

LEFT_KNEE = 'L_Knee'

RIGHT_KNEE `class-attribute` `instance-attribute` ¶

RIGHT_KNEE = 'R_Knee'

LEFT_ANKLE `class-attribute` `instance-attribute` ¶

LEFT_ANKLE = 'L_Ankle'

RIGHT_ANKLE `class-attribute` `instance-attribute` ¶

RIGHT_ANKLE = 'R_Ankle'

LEFT_FOOT `class-attribute` `instance-attribute` ¶

LEFT_FOOT = 'L_Foot'

RIGHT_FOOT `class-attribute` `instance-attribute` ¶

RIGHT_FOOT = 'R_Foot'

SPINE2 `class-attribute` `instance-attribute` ¶

SPINE2 = 'Spine2'

SPINE3 `class-attribute` `instance-attribute` ¶

SPINE3 = 'Spine3'

NECK `class-attribute` `instance-attribute` ¶

NECK = 'Neck'

HEAD `class-attribute` `instance-attribute` ¶

HEAD = 'Head'

LEFT_SHOULDER `class-attribute` `instance-attribute` ¶

LEFT_SHOULDER = 'L_Shoulder'

RIGHT_SHOULDER `class-attribute` `instance-attribute` ¶

RIGHT_SHOULDER = 'R_Shoulder'

LEFT_ELBOW `class-attribute` `instance-attribute` ¶

LEFT_ELBOW = 'L_Elbow'

RIGHT_ELBOW `class-attribute` `instance-attribute` ¶

RIGHT_ELBOW = 'R_Elbow'

LEFT_WRIST `class-attribute` `instance-attribute` ¶

LEFT_WRIST = 'L_Wrist'

RIGHT_WRIST `class-attribute` `instance-attribute` ¶

RIGHT_WRIST = 'R_Wrist'

LEFT_BIG_TOE `class-attribute` `instance-attribute` ¶

LEFT_BIG_TOE = 'L_BigToe'

LEFT_SMALL_TOE `class-attribute` `instance-attribute` ¶

LEFT_SMALL_TOE = 'L_SmallToe'

LEFT_HEEL `class-attribute` `instance-attribute` ¶

LEFT_HEEL = 'L_Heel'

RIGHT_BIG_TOE `class-attribute` `instance-attribute` ¶

RIGHT_BIG_TOE = 'R_BigToe'

RIGHT_SMALL_TOE `class-attribute` `instance-attribute` ¶

RIGHT_SMALL_TOE = 'R_SmallToe'

RIGHT_HEEL `class-attribute` `instance-attribute` ¶

RIGHT_HEEL = 'R_Heel'

SkateboardingObservationRole ¶

Bases: ObservationRole

Target-independent semantic landmarks and objects.

Attributes:

Name	Type	Description
`PELVIS`
`LEFT_HIP`
`RIGHT_HIP`
`LEFT_KNEE`
`RIGHT_KNEE`
`LEFT_ANKLE`
`RIGHT_ANKLE`
`LEFT_FOOT`
`RIGHT_FOOT`
`UPPER_BODY_CENTER`
`BOARD`

Attributes¶

PELVIS `class-attribute` `instance-attribute` ¶

PELVIS = 'pelvis'

LEFT_HIP `class-attribute` `instance-attribute` ¶

LEFT_HIP = 'left_hip'

RIGHT_HIP `class-attribute` `instance-attribute` ¶

RIGHT_HIP = 'right_hip'

LEFT_KNEE `class-attribute` `instance-attribute` ¶

LEFT_KNEE = 'left_knee'

RIGHT_KNEE `class-attribute` `instance-attribute` ¶

RIGHT_KNEE = 'right_knee'

LEFT_ANKLE `class-attribute` `instance-attribute` ¶

LEFT_ANKLE = 'left_ankle'

RIGHT_ANKLE `class-attribute` `instance-attribute` ¶

RIGHT_ANKLE = 'right_ankle'

LEFT_FOOT `class-attribute` `instance-attribute` ¶

LEFT_FOOT = 'left_foot'

RIGHT_FOOT `class-attribute` `instance-attribute` ¶

RIGHT_FOOT = 'right_foot'

UPPER_BODY_CENTER `class-attribute` `instance-attribute` ¶

UPPER_BODY_CENTER = 'upper_body_center'

BOARD `class-attribute` `instance-attribute` ¶

BOARD = 'board'

SkateboardingRigidBody ¶

Bases: MocapRigidBody

Native Vicon rigid bodies.

Attributes:

Name	Type	Description
`LEFT_SHOE`
`RIGHT_SHOE`
`BOARD`

Attributes¶

LEFT_SHOE `class-attribute` `instance-attribute` ¶

LEFT_SHOE = 'Left_Shoe'

RIGHT_SHOE `class-attribute` `instance-attribute` ¶

RIGHT_SHOE = 'Right_Shoe'

BOARD `class-attribute` `instance-attribute` ¶

BOARD = 'Skateboard'

holosoma ¶

Unified Holosoma climbing observation and adaptation recipes.

Modules:

Name	Description
`adaptation`	Robot adaptation for the Holosoma climbing subset.
`contacts`	Semantic contact extraction for Holosoma climbing observations.
`geometry`	Geometry-pair policy for Holosoma-compatible object collision.
`layout`	Filesystem layout discovery for Holosoma fixtures and assets.
`motion`	MOCAP motion preprocessing for Holosoma-compatible recipes.
`object`	Object assets and trajectories for Holosoma-compatible recipes.
`observation`	Target-independent Holosoma climbing observation recipe.
`profile`	Optimization profile for Holosoma-compatible climbing.
`robot`	G1 spherehand robot specification for Holosoma-compatible recipes.
`vocabulary`	Typed vocabulary and constants for Holosoma-compatible recipes.

Classes:

Name	Description
`HolosomaClimbRetargetingRecipe`	Adapt a climb observation to a Holosoma-compatible robot.
`HolosomaClimbLayout`	Resolved file layout for the MOCAP climbing fixture.
`HolosomaClimbObservationPolicy`	Capture-processing choices for the Holosoma climbing observation.
`HolosomaClimbObservationRecipe`	Build a climbing observation from one native mocap source.
`HolosomaClimbOptimizationPolicy`	Optimization choices specific to the Holosoma climbing experiment.
`HolosomaContactPatch`	Semantic contact patches for climbing.
`HolosomaContactState`	Contact states emitted by the Holosoma foot-sticking extractor.
`HolosomaContactSubject`	Semantic contact subjects for climbing.
`HolosomaGeometryName`	Named fixture geometries referenced by the climbing recipe.
`HolosomaMocapJoint`	Named MOCAP joints used by Holosoma's climbing fixture.
`HolosomaObservationRole`	Semantic objects observed in the climbing scene.
`HolosomaRobotRole`	Robot roles required by the Holosoma climbing adaptation.

Functions:

Name	Description
`default_holosoma_root`	Return the sibling Holosoma checkout path used by local parity tests.
`holosoma_climb_layout`	Resolve the climb fixture across known Holosoma checkout layouts.
`holosoma_g1_robot_dir`	Resolve the G1 spherehand asset directory across known layouts.
`object_visual_parts_from_urdf`	Read visual mesh parts from a Holosoma multi-box URDF.
`g1_spherehand_robot`	Return a G1 spherehand robot spec matching Holosoma's MOCAP task.

Attributes:

Name	Type	Description
`G1_LEFT_FOOT_STICKING_LINKS`
`G1_RIGHT_FOOT_STICKING_LINKS`
`__all__`

Attributes¶

G1_LEFT_FOOT_STICKING_LINKS `module-attribute` ¶

G1_LEFT_FOOT_STICKING_LINKS = (
    LEFT_ANKLE_ROLL_SPHERE_1,
    LEFT_ANKLE_ROLL_SPHERE_2,
    LEFT_ANKLE_ROLL_SPHERE_3,
    LEFT_ANKLE_ROLL_SPHERE_4,
)

G1_RIGHT_FOOT_STICKING_LINKS `module-attribute` ¶

G1_RIGHT_FOOT_STICKING_LINKS = (
    RIGHT_ANKLE_ROLL_SPHERE_1,
    RIGHT_ANKLE_ROLL_SPHERE_2,
    RIGHT_ANKLE_ROLL_SPHERE_3,
    RIGHT_ANKLE_ROLL_SPHERE_4,
)

all `module-attribute` ¶

__all__ = [
    "G1_LEFT_FOOT_STICKING_LINKS",
    "G1_RIGHT_FOOT_STICKING_LINKS",
    "HolosomaClimbLayout",
    "HolosomaClimbObservationPolicy",
    "HolosomaClimbObservationRecipe",
    "HolosomaClimbOptimizationPolicy",
    "HolosomaClimbRetargetingRecipe",
    "HolosomaContactPatch",
    "HolosomaContactState",
    "HolosomaContactSubject",
    "HolosomaGeometryName",
    "HolosomaMocapJoint",
    "HolosomaObservationRole",
    "HolosomaRobotRole",
    "default_holosoma_root",
    "g1_spherehand_robot",
    "holosoma_climb_layout",
    "holosoma_g1_robot_dir",
    "object_visual_parts_from_urdf",
]

Classes¶

HolosomaClimbRetargetingRecipe `dataclass` ¶

HolosomaClimbRetargetingRecipe(
    holosoma_root: str | Path | None = None,
    include_object_collision: bool = True,
    solver_backend: SolverBackend = CVXPY_CLARABEL,
    show_progress: bool = False,
    optimization_policy: HolosomaClimbOptimizationPolicy = HolosomaClimbOptimizationPolicy(),
)

Adapt a climb observation to a Holosoma-compatible robot.

Methods:

Name	Description
`build_problem`	Build the robot-resolved climb problem.

Attributes:

Name	Type	Description
`holosoma_root`	`str \| Path \| None`
`include_object_collision`	`bool`
`solver_backend`	`SolverBackend`
`show_progress`	`bool`
`optimization_policy`	`HolosomaClimbOptimizationPolicy`

Attributes¶

holosoma_root `class-attribute` `instance-attribute` ¶

holosoma_root: str | Path | None = None

include_object_collision `class-attribute` `instance-attribute` ¶

include_object_collision: bool = True

solver_backend `class-attribute` `instance-attribute` ¶

solver_backend: SolverBackend = CVXPY_CLARABEL

show_progress `class-attribute` `instance-attribute` ¶

show_progress: bool = False

optimization_policy `class-attribute` `instance-attribute` ¶

optimization_policy: HolosomaClimbOptimizationPolicy = field(
    default_factory=HolosomaClimbOptimizationPolicy
)

Functions¶

build_problem ¶

build_problem(observation: SceneObservation, robot: RobotSpec) -> RetargetingProblem

Build the robot-resolved climb problem.

HolosomaClimbLayout `dataclass` ¶

HolosomaClimbLayout(
    fixture_dir: Path,
    motion_path: Path,
    object_mesh_path: Path,
    object_urdf_path: Path,
    scene_xml_path: Path,
)

Resolved file layout for the MOCAP climbing fixture.

Attributes:

Name	Type	Description
`fixture_dir`	`Path`
`motion_path`	`Path`
`object_mesh_path`	`Path`
`object_urdf_path`	`Path`
`scene_xml_path`	`Path`

Attributes¶

fixture_dir `instance-attribute` ¶

fixture_dir: Path

motion_path `instance-attribute` ¶

motion_path: Path

object_mesh_path `instance-attribute` ¶

object_mesh_path: Path

object_urdf_path `instance-attribute` ¶

object_urdf_path: Path

scene_xml_path `instance-attribute` ¶

scene_xml_path: Path

HolosomaClimbObservationPolicy `dataclass` ¶

HolosomaClimbObservationPolicy(
    source_height_m: float = 1.78,
    mat_height_m: float = 0.1,
    contact_velocity_threshold: float = 0.01,
    object_sample_count: int = 100,
    object_sample_seed: int = 42,
)

Capture-processing choices for the Holosoma climbing observation.

Attributes:

Name	Type	Description
`source_height_m`	`float`
`mat_height_m`	`float`
`contact_velocity_threshold`	`float`
`object_sample_count`	`int`
`object_sample_seed`	`int`

Attributes¶

source_height_m `class-attribute` `instance-attribute` ¶

source_height_m: float = 1.78

mat_height_m `class-attribute` `instance-attribute` ¶

mat_height_m: float = 0.1

contact_velocity_threshold `class-attribute` `instance-attribute` ¶

contact_velocity_threshold: float = 0.01

object_sample_count `class-attribute` `instance-attribute` ¶

object_sample_count: int = 100

object_sample_seed `class-attribute` `instance-attribute` ¶

object_sample_seed: int = 42

HolosomaClimbObservationRecipe `dataclass` ¶

HolosomaClimbObservationRecipe(
    mocap: ObservationSource[MocapRecording],
    object_mesh_path: Path,
    object_urdf_path: Path,
    frame_count: int | None = None,
    policy: HolosomaClimbObservationPolicy = HolosomaClimbObservationPolicy(),
)

Build a climbing observation from one native mocap source.

Methods:

Name	Description
`from_fixture`	Construct the observation recipe for the public Holosoma fixture.
`observe`	Load and normalize the native climb capture.

Attributes:

Name	Type	Description
`mocap`	`ObservationSource[MocapRecording]`
`object_mesh_path`	`Path`
`object_urdf_path`	`Path`
`frame_count`	`int \| None`
`policy`	`HolosomaClimbObservationPolicy`

Attributes¶

mocap `instance-attribute` ¶

mocap: ObservationSource[MocapRecording]

object_mesh_path `instance-attribute` ¶

object_mesh_path: Path

object_urdf_path `instance-attribute` ¶

object_urdf_path: Path

frame_count `class-attribute` `instance-attribute` ¶

frame_count: int | None = None

policy `class-attribute` `instance-attribute` ¶

policy: HolosomaClimbObservationPolicy = field(
    default_factory=HolosomaClimbObservationPolicy
)

Functions¶

from_fixture `classmethod` ¶

from_fixture(
    holosoma_root: str | Path | None = None,
    *,
    frame_count: int | None = None,
    source_fps: float = 30.0,
    downsample: int = 4,
    policy: HolosomaClimbObservationPolicy | None = None,
) -> HolosomaClimbObservationRecipe

Construct the observation recipe for the public Holosoma fixture.

observe ¶

observe() -> SceneObservation

Load and normalize the native climb capture.

HolosomaClimbOptimizationPolicy `dataclass` ¶

HolosomaClimbOptimizationPolicy(
    collision_activation_distance: float = 0.1,
    qpos_regularization: tuple[tuple[int, float], ...] = ((19, 0.2), (20, 0.2)),
    nominal_qpos_indices: tuple[int, ...] = tuple(range(19)),
)

Optimization choices specific to the Holosoma climbing experiment.

Attributes:

Name	Type	Description
`collision_activation_distance`	`float`
`qpos_regularization`	`tuple[tuple[int, float], ...]`
`nominal_qpos_indices`	`tuple[int, ...]`

Attributes¶

collision_activation_distance `class-attribute` `instance-attribute` ¶

collision_activation_distance: float = 0.1

qpos_regularization `class-attribute` `instance-attribute` ¶

qpos_regularization: tuple[tuple[int, float], ...] = ((19, 0.2), (20, 0.2))

nominal_qpos_indices `class-attribute` `instance-attribute` ¶

nominal_qpos_indices: tuple[int, ...] = tuple(range(19))

HolosomaContactPatch ¶

Bases: ContactPatch

Semantic contact patches for climbing.

Attributes:

Name	Type	Description
`LEFT_TOE`
`RIGHT_TOE`

Attributes¶

LEFT_TOE `class-attribute` `instance-attribute` ¶

LEFT_TOE = 'left_toe'

RIGHT_TOE `class-attribute` `instance-attribute` ¶

RIGHT_TOE = 'right_toe'

HolosomaContactState ¶

Bases: ContactState

Contact states emitted by the Holosoma foot-sticking extractor.

Attributes:

Name	Type	Description
`AIR`
`STICKING`

Attributes¶

AIR `class-attribute` `instance-attribute` ¶

AIR = 'air'

STICKING `class-attribute` `instance-attribute` ¶

STICKING = 'sticking'

HolosomaContactSubject ¶

Bases: ContactSubject

Semantic contact subjects for climbing.

Attributes:

Name	Type	Description
`LEFT_FOOT`
`RIGHT_FOOT`

Attributes¶

LEFT_FOOT `class-attribute` `instance-attribute` ¶

LEFT_FOOT = 'left_foot'

RIGHT_FOOT `class-attribute` `instance-attribute` ¶

RIGHT_FOOT = 'right_foot'

HolosomaGeometryName ¶

Bases: SceneGeometry

Named fixture geometries referenced by the climbing recipe.

Attributes:

Name	Type	Description
`MULTI_BOX_1`
`MULTI_BOX_2`
`MULTI_BOX_3`
`GROUND`

Attributes¶

MULTI_BOX_1 `class-attribute` `instance-attribute` ¶

MULTI_BOX_1 = 'multi_boxes_link_1'

MULTI_BOX_2 `class-attribute` `instance-attribute` ¶

MULTI_BOX_2 = 'multi_boxes_link_2'

MULTI_BOX_3 `class-attribute` `instance-attribute` ¶

MULTI_BOX_3 = 'multi_boxes_link_3'

GROUND `class-attribute` `instance-attribute` ¶

GROUND = 'ground'

HolosomaMocapJoint ¶

Bases: MotionJoint

Named MOCAP joints used by Holosoma's climbing fixture.

Attributes:

Name	Type	Description
`HIPS`
`SPINE`
`SPINE1`
`NECK`
`HEAD`
`LEFT_SHOULDER`
`LEFT_ARM`
`LEFT_FOREARM`
`LEFT_HAND`
`LEFT_HAND_THUMB1`
`LEFT_HAND_THUMB2`
`LEFT_HAND_THUMB3`
`LEFT_HAND_INDEX1`
`LEFT_HAND_INDEX2`
`LEFT_HAND_INDEX3`
`LEFT_HAND_MIDDLE1`
`LEFT_HAND_MIDDLE2`
`LEFT_HAND_MIDDLE3`
`LEFT_HAND_RING1`
`LEFT_HAND_RING2`
`LEFT_HAND_RING3`
`LEFT_HAND_PINKY1`
`LEFT_HAND_PINKY2`
`LEFT_HAND_PINKY3`
`RIGHT_SHOULDER`
`RIGHT_ARM`
`RIGHT_FOREARM`
`RIGHT_HAND`
`RIGHT_HAND_THUMB1`
`RIGHT_HAND_THUMB2`
`RIGHT_HAND_THUMB3`
`RIGHT_HAND_INDEX1`
`RIGHT_HAND_INDEX2`
`RIGHT_HAND_INDEX3`
`RIGHT_HAND_MIDDLE1`
`RIGHT_HAND_MIDDLE2`
`RIGHT_HAND_MIDDLE3`
`RIGHT_HAND_RING1`
`RIGHT_HAND_RING2`
`RIGHT_HAND_RING3`
`RIGHT_HAND_PINKY1`
`RIGHT_HAND_PINKY2`
`RIGHT_HAND_PINKY3`
`LEFT_UP_LEG`
`LEFT_LEG`
`LEFT_FOOT`
`LEFT_TOE_BASE`
`RIGHT_UP_LEG`
`RIGHT_LEG`
`RIGHT_FOOT`
`RIGHT_TOE_BASE`
`LEFT_FOOT_MOD`
`RIGHT_FOOT_MOD`

Attributes¶

HIPS `class-attribute` `instance-attribute` ¶

HIPS = 'Hips'

SPINE `class-attribute` `instance-attribute` ¶

SPINE = 'Spine'

SPINE1 `class-attribute` `instance-attribute` ¶

SPINE1 = 'Spine1'

NECK `class-attribute` `instance-attribute` ¶

NECK = 'Neck'

HEAD `class-attribute` `instance-attribute` ¶

HEAD = 'Head'

LEFT_SHOULDER `class-attribute` `instance-attribute` ¶

LEFT_SHOULDER = 'LeftShoulder'

LEFT_ARM `class-attribute` `instance-attribute` ¶

LEFT_ARM = 'LeftArm'

LEFT_FOREARM `class-attribute` `instance-attribute` ¶

LEFT_FOREARM = 'LeftForeArm'

LEFT_HAND `class-attribute` `instance-attribute` ¶

LEFT_HAND = 'LeftHand'

LEFT_HAND_THUMB1 `class-attribute` `instance-attribute` ¶

LEFT_HAND_THUMB1 = 'LeftHandThumb1'

LEFT_HAND_THUMB2 `class-attribute` `instance-attribute` ¶

LEFT_HAND_THUMB2 = 'LeftHandThumb2'

LEFT_HAND_THUMB3 `class-attribute` `instance-attribute` ¶

LEFT_HAND_THUMB3 = 'LeftHandThumb3'

LEFT_HAND_INDEX1 `class-attribute` `instance-attribute` ¶

LEFT_HAND_INDEX1 = 'LeftHandIndex1'

LEFT_HAND_INDEX2 `class-attribute` `instance-attribute` ¶

LEFT_HAND_INDEX2 = 'LeftHandIndex2'

LEFT_HAND_INDEX3 `class-attribute` `instance-attribute` ¶

LEFT_HAND_INDEX3 = 'LeftHandIndex3'

LEFT_HAND_MIDDLE1 `class-attribute` `instance-attribute` ¶

LEFT_HAND_MIDDLE1 = 'LeftHandMiddle1'

LEFT_HAND_MIDDLE2 `class-attribute` `instance-attribute` ¶

LEFT_HAND_MIDDLE2 = 'LeftHandMiddle2'

LEFT_HAND_MIDDLE3 `class-attribute` `instance-attribute` ¶

LEFT_HAND_MIDDLE3 = 'LeftHandMiddle3'

LEFT_HAND_RING1 `class-attribute` `instance-attribute` ¶

LEFT_HAND_RING1 = 'LeftHandRing1'

LEFT_HAND_RING2 `class-attribute` `instance-attribute` ¶

LEFT_HAND_RING2 = 'LeftHandRing2'

LEFT_HAND_RING3 `class-attribute` `instance-attribute` ¶

LEFT_HAND_RING3 = 'LeftHandRing3'

LEFT_HAND_PINKY1 `class-attribute` `instance-attribute` ¶

LEFT_HAND_PINKY1 = 'LeftHandPinky1'

LEFT_HAND_PINKY2 `class-attribute` `instance-attribute` ¶

LEFT_HAND_PINKY2 = 'LeftHandPinky2'

LEFT_HAND_PINKY3 `class-attribute` `instance-attribute` ¶

LEFT_HAND_PINKY3 = 'LeftHandPinky3'

RIGHT_SHOULDER `class-attribute` `instance-attribute` ¶

RIGHT_SHOULDER = 'RightShoulder'

RIGHT_ARM `class-attribute` `instance-attribute` ¶

RIGHT_ARM = 'RightArm'

RIGHT_FOREARM `class-attribute` `instance-attribute` ¶

RIGHT_FOREARM = 'RightForeArm'

RIGHT_HAND `class-attribute` `instance-attribute` ¶

RIGHT_HAND = 'RightHand'

RIGHT_HAND_THUMB1 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_THUMB1 = 'RightHandThumb1'

RIGHT_HAND_THUMB2 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_THUMB2 = 'RightHandThumb2'

RIGHT_HAND_THUMB3 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_THUMB3 = 'RightHandThumb3'

RIGHT_HAND_INDEX1 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_INDEX1 = 'RightHandIndex1'

RIGHT_HAND_INDEX2 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_INDEX2 = 'RightHandIndex2'

RIGHT_HAND_INDEX3 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_INDEX3 = 'RightHandIndex3'

RIGHT_HAND_MIDDLE1 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_MIDDLE1 = 'RightHandMiddle1'

RIGHT_HAND_MIDDLE2 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_MIDDLE2 = 'RightHandMiddle2'

RIGHT_HAND_MIDDLE3 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_MIDDLE3 = 'RightHandMiddle3'

RIGHT_HAND_RING1 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_RING1 = 'RightHandRing1'

RIGHT_HAND_RING2 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_RING2 = 'RightHandRing2'

RIGHT_HAND_RING3 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_RING3 = 'RightHandRing3'

RIGHT_HAND_PINKY1 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_PINKY1 = 'RightHandPinky1'

RIGHT_HAND_PINKY2 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_PINKY2 = 'RightHandPinky2'

RIGHT_HAND_PINKY3 `class-attribute` `instance-attribute` ¶

RIGHT_HAND_PINKY3 = 'RightHandPinky3'

LEFT_UP_LEG `class-attribute` `instance-attribute` ¶

LEFT_UP_LEG = 'LeftUpLeg'

LEFT_LEG `class-attribute` `instance-attribute` ¶

LEFT_LEG = 'LeftLeg'

LEFT_FOOT `class-attribute` `instance-attribute` ¶

LEFT_FOOT = 'LeftFoot'

LEFT_TOE_BASE `class-attribute` `instance-attribute` ¶

LEFT_TOE_BASE = 'LeftToeBase'

RIGHT_UP_LEG `class-attribute` `instance-attribute` ¶

RIGHT_UP_LEG = 'RightUpLeg'

RIGHT_LEG `class-attribute` `instance-attribute` ¶

RIGHT_LEG = 'RightLeg'

RIGHT_FOOT `class-attribute` `instance-attribute` ¶

RIGHT_FOOT = 'RightFoot'

RIGHT_TOE_BASE `class-attribute` `instance-attribute` ¶

RIGHT_TOE_BASE = 'RightToeBase'

LEFT_FOOT_MOD `class-attribute` `instance-attribute` ¶

LEFT_FOOT_MOD = 'LeftFootMod'

RIGHT_FOOT_MOD `class-attribute` `instance-attribute` ¶

RIGHT_FOOT_MOD = 'RightFootMod'

HolosomaObservationRole ¶

Bases: ObservationRole

Semantic objects observed in the climbing scene.

Attributes:

Name	Type	Description
`CLIMBING_STRUCTURE`

Attributes¶

CLIMBING_STRUCTURE `class-attribute` `instance-attribute` ¶

CLIMBING_STRUCTURE = 'climbing_structure'

HolosomaRobotRole ¶

Bases: RobotRole

Robot roles required by the Holosoma climbing adaptation.

Attributes:

Name	Type	Description
`PELVIS`
`LEFT_HIP`
`LEFT_KNEE`
`LEFT_TOE`
`RIGHT_HIP`
`RIGHT_KNEE`
`RIGHT_TOE`
`LEFT_SHOULDER`
`LEFT_ELBOW`
`LEFT_HAND`
`RIGHT_SHOULDER`
`RIGHT_ELBOW`
`RIGHT_HAND`
`LEFT_FOOT`
`RIGHT_FOOT`
`LEFT_FOOT_CONTACT`
`RIGHT_FOOT_CONTACT`

Attributes¶

PELVIS `class-attribute` `instance-attribute` ¶

PELVIS = 'pelvis'

LEFT_HIP `class-attribute` `instance-attribute` ¶

LEFT_HIP = 'left_hip'

LEFT_KNEE `class-attribute` `instance-attribute` ¶

LEFT_KNEE = 'left_knee'

LEFT_TOE `class-attribute` `instance-attribute` ¶

LEFT_TOE = 'left_toe'

RIGHT_HIP `class-attribute` `instance-attribute` ¶

RIGHT_HIP = 'right_hip'

RIGHT_KNEE `class-attribute` `instance-attribute` ¶

RIGHT_KNEE = 'right_knee'

RIGHT_TOE `class-attribute` `instance-attribute` ¶

RIGHT_TOE = 'right_toe'

LEFT_SHOULDER `class-attribute` `instance-attribute` ¶

LEFT_SHOULDER = 'left_shoulder'

LEFT_ELBOW `class-attribute` `instance-attribute` ¶

LEFT_ELBOW = 'left_elbow'

LEFT_HAND `class-attribute` `instance-attribute` ¶

LEFT_HAND = 'left_hand'

RIGHT_SHOULDER `class-attribute` `instance-attribute` ¶

RIGHT_SHOULDER = 'right_shoulder'

RIGHT_ELBOW `class-attribute` `instance-attribute` ¶

RIGHT_ELBOW = 'right_elbow'

RIGHT_HAND `class-attribute` `instance-attribute` ¶

RIGHT_HAND = 'right_hand'

LEFT_FOOT `class-attribute` `instance-attribute` ¶

LEFT_FOOT = 'left_foot'

RIGHT_FOOT `class-attribute` `instance-attribute` ¶

RIGHT_FOOT = 'right_foot'

LEFT_FOOT_CONTACT `class-attribute` `instance-attribute` ¶

LEFT_FOOT_CONTACT = 'left_foot_contact'

RIGHT_FOOT_CONTACT `class-attribute` `instance-attribute` ¶

RIGHT_FOOT_CONTACT = 'right_foot_contact'

Functions¶

default_holosoma_root ¶

default_holosoma_root() -> Path

Return the sibling Holosoma checkout path used by local parity tests.

holosoma_climb_layout ¶

holosoma_climb_layout(root: Path) -> HolosomaClimbLayout

Resolve the climb fixture across known Holosoma checkout layouts.

holosoma_g1_robot_dir ¶

holosoma_g1_robot_dir(root: Path) -> Path

Resolve the G1 spherehand asset directory across known layouts.

object_visual_parts_from_urdf ¶

object_visual_parts_from_urdf(urdf_path: str | Path) -> tuple[ObjectVisualPart, ...]

Read visual mesh parts from a Holosoma multi-box URDF.

g1_spherehand_robot ¶

g1_spherehand_robot(
    holosoma_root: str | Path | None = None,
    *,
    scene_xml_path: str | Path | None = None,
    include_object_collision: bool = False,
    height_m: float = 1.32,
) -> RobotSpec[
    G1SpherehandJoint, G1SpherehandLink, G1SpherehandGeometry, HolosomaRobotRole
]

Return a G1 spherehand robot spec matching Holosoma's MOCAP task.

Observation And Recipes¶

observation ¶

Attributes¶

__all__ module-attribute ¶

Classes¶

SemanticContactSequence dataclass ¶

Attributes¶

timeline instance-attribute ¶

tracks instance-attribute ¶

support class-attribute instance-attribute ¶

provenance class-attribute instance-attribute ¶

Functions¶

resolve ¶

SemanticContactTrack dataclass ¶

Attributes¶

subject instance-attribute ¶

states instance-attribute ¶

patch class-attribute instance-attribute ¶

active_states class-attribute instance-attribute ¶

support_states class-attribute instance-attribute ¶

validity class-attribute instance-attribute ¶

provenance class-attribute instance-attribute ¶

sample_count property ¶

ObservedObject dataclass ¶

Attributes¶

role instance-attribute ¶

pose instance-attribute ¶

geometry instance-attribute ¶

provenance class-attribute instance-attribute ¶

SceneObservation dataclass ¶

Attributes¶

name instance-attribute ¶

timeline instance-attribute ¶

world_frame instance-attribute ¶

actor instance-attribute ¶

landmarks class-attribute instance-attribute ¶

rigid_bodies class-attribute instance-attribute ¶

objects class-attribute instance-attribute ¶

contacts class-attribute instance-attribute ¶

terrain class-attribute instance-attribute ¶

alignment_reports class-attribute instance-attribute ¶

provenance class-attribute instance-attribute ¶

Functions¶

landmark ¶

observed_object ¶

save_npz ¶

load_npz classmethod ¶

FootSupportClassificationConfig dataclass ¶

Attributes¶

ground_height_percentile class-attribute instance-attribute ¶

ground_clearance_m class-attribute instance-attribute ¶

ground_speed_mps class-attribute instance-attribute ¶

object_horizontal_distance_m class-attribute instance-attribute ¶

object_height_min_m class-attribute instance-attribute ¶

object_height_max_m class-attribute instance-attribute ¶

object_relative_speed_mps class-attribute instance-attribute ¶

FootSupportStates dataclass ¶

Attributes¶

air instance-attribute ¶

ground instance-attribute ¶

observed_object instance-attribute ¶

Functions¶

classify_foot_support ¶

ObservationRecipe ¶

Functions¶

observe ¶

RetargetingRecipe ¶

Functions¶

build_problem ¶

generic ¶

Attributes¶

motion_formats module-attribute ¶

Classes¶

MotionFormatKind ¶

MotionJoint ¶

RobotRole ¶

TaskKind ¶

ROBOT_ONLY member ¶

OBJECT_INTERACTION member ¶

CLIMBING member ¶

all `module-attribute` ¶

SemanticContactSequence `dataclass` ¶

timeline `instance-attribute` ¶

tracks `instance-attribute` ¶

support `class-attribute` `instance-attribute` ¶

provenance `class-attribute` `instance-attribute` ¶

SemanticContactTrack `dataclass` ¶

subject `instance-attribute` ¶

states `instance-attribute` ¶

patch `class-attribute` `instance-attribute` ¶

active_states `class-attribute` `instance-attribute` ¶

support_states `class-attribute` `instance-attribute` ¶

validity `class-attribute` `instance-attribute` ¶

provenance `class-attribute` `instance-attribute` ¶

sample_count `property` ¶

ObservedObject `dataclass` ¶

role `instance-attribute` ¶

pose `instance-attribute` ¶

geometry `instance-attribute` ¶

provenance `class-attribute` `instance-attribute` ¶

SceneObservation `dataclass` ¶

name `instance-attribute` ¶

timeline `instance-attribute` ¶

world_frame `instance-attribute` ¶

actor `instance-attribute` ¶

landmarks `class-attribute` `instance-attribute` ¶

rigid_bodies `class-attribute` `instance-attribute` ¶

objects `class-attribute` `instance-attribute` ¶

contacts `class-attribute` `instance-attribute` ¶

terrain `class-attribute` `instance-attribute` ¶

alignment_reports `class-attribute` `instance-attribute` ¶

provenance `class-attribute` `instance-attribute` ¶

load_npz `classmethod` ¶

FootSupportClassificationConfig `dataclass` ¶

ground_height_percentile `class-attribute` `instance-attribute` ¶

ground_clearance_m `class-attribute` `instance-attribute` ¶

ground_speed_mps `class-attribute` `instance-attribute` ¶

object_horizontal_distance_m `class-attribute` `instance-attribute` ¶

object_height_min_m `class-attribute` `instance-attribute` ¶

object_height_max_m `class-attribute` `instance-attribute` ¶

object_relative_speed_mps `class-attribute` `instance-attribute` ¶

FootSupportStates `dataclass` ¶

air `instance-attribute` ¶

ground `instance-attribute` ¶

observed_object `instance-attribute` ¶

motion_formats `module-attribute` ¶

ROBOT_ONLY `member` ¶

OBJECT_INTERACTION `member` ¶

CLIMBING `member` ¶

model_config `class-attribute` `instance-attribute` ¶

poses `instance-attribute` ¶

fps `class-attribute` `instance-attribute` ¶

frame_count `property` ¶

frame `property` ¶

positions `property` ¶

identity `classmethod` ¶

from_arrays `classmethod` ¶

model_config `class-attribute` `instance-attribute` ¶

topology `class-attribute` `instance-attribute` ¶

k_neighbors `class-attribute` `instance-attribute` ¶

laplacian_weighting `class-attribute` `instance-attribute` ¶

laplacian_epsilon `class-attribute` `instance-attribute` ¶

model_config `class-attribute` `instance-attribute` ¶

name `instance-attribute` ¶

joint_vocabulary `instance-attribute` ¶

root_joint `instance-attribute` ¶

quaternion_order `class-attribute` `instance-attribute` ¶

frame_convention `class-attribute` `instance-attribute` ¶

default_fps `class-attribute` `instance-attribute` ¶

default_height_m `class-attribute` `instance-attribute` ¶

description `class-attribute` `instance-attribute` ¶

joints `property` ¶

SceneObservation `dataclass` ¶

name `instance-attribute` ¶

timeline `instance-attribute` ¶

world_frame `instance-attribute` ¶

actor `instance-attribute` ¶

landmarks `class-attribute` `instance-attribute` ¶

rigid_bodies `class-attribute` `instance-attribute` ¶

objects `class-attribute` `instance-attribute` ¶