Capture

Native recordings, timelines, tracks, sources, registration, and estimator protocols.

capture

Typed native recordings and capture processing.

Modules:

Name	Description
alignment	Temporal and spatial registration for native recordings.
estimators	Replaceable human-pose estimator interfaces.
recordings	Typed native recording models.
sources	Observation sources for native recordings.
timeline	Native and observation timeline primitives.
tracks	Typed recording tracks with type-specific resampling.

Classes:

Name	Description
AlignmentError	Registration failure carrying the rejected quality report.
AlignmentReport	Quality report for one temporal or spatial registration.
RigidTransform	Rigid point transform target = source @ rotation.T + translation.
TemporalRegistrationConfig	Quality and search policy for offset registration.
GvhmrEstimator	Run a configured local GVHMR checkout in an ephemeral workspace.
HumanPoseEstimator	Estimate a typed human-pose recording from video.
VideoPoseSource	Compose a video recording source with a pose estimator.
HumanPoseRecording	Estimated or measured human pose in one native clock.
MocapRecording	Joints, rigid bodies, and markers sampled in one native mocap clock.
VideoRecording	A video stream and its native frame timeline.
GvhmrOutputSource	Load existing GVHMR arrays as a native human-pose recording.
HumanPoseSourceSchema	Map semantic motion-joint vocabularies to source array columns.
InMemorySource	Source returning an already constructed recording.
MocapArraySource	Load a dense (frames, joints, 3) mocap array.
ObservationSource	Load one native recording without creating a shared timeline.
ViconBagSource	Read a ROS 2 Vicon bag directly into a native mocap recording.
ViconBagTopics	ROS topics carrying Vicon rigid-body transforms and marker samples.
ViconRecordingSource	Load a preconverted Vicon recording directly into typed tracks.
ViconSourceSchema	Map Vicon table names into typed native vocabularies.
ClockTransform	Affine mapping from a native clock into an observation clock.
SampleTimeline	Strictly increasing sample timestamps in one recording's native clock.
CategoricalTrack	A named categorical sequence sampled by nearest neighbor.
JointTrack	A native or estimated human-joint trajectory.
MarkerTrack	A native motion-capture marker trajectory.
PointTrack	A named 3D point trajectory.
PoseTrack	A named rigid-body pose trajectory.
RigidBodyTrack	A native motion-capture rigid-body trajectory.

Functions:

Name	Description
estimate_clock_offset	Estimate an offset mapping moving_timeline into reference_timeline.
register_rigid_points	Estimate a Kabsch rigid transform from corresponding finite points.

Attributes:

Name	Type	Description
__all__

Attributes

__all__ module-attribute

__all__ = [
    "AlignmentError",
    "AlignmentReport",
    "CategoricalTrack",
    "ClockTransform",
    "GvhmrEstimator",
    "GvhmrOutputSource",
    "HumanPoseEstimator",
    "HumanPoseRecording",
    "HumanPoseSourceSchema",
    "InMemorySource",
    "JointTrack",
    "MarkerTrack",
    "MocapArraySource",
    "MocapRecording",
    "ObservationSource",
    "PointTrack",
    "PoseTrack",
    "RigidBodyTrack",
    "RigidTransform",
    "SampleTimeline",
    "TemporalRegistrationConfig",
    "ViconBagSource",
    "ViconBagTopics",
    "ViconRecordingSource",
    "ViconSourceSchema",
    "VideoPoseSource",
    "VideoRecording",
    "estimate_clock_offset",
    "register_rigid_points",
]

Classes

AlignmentError

AlignmentError(message: str, report: AlignmentReport)

Bases: ValueError

Registration failure carrying the rejected quality report.

Attributes:

Name	Type	Description
report

Attributes

report instance-attribute

report = report

AlignmentReport dataclass

AlignmentReport(
    strategy: str,
    accepted: bool,
    score: float,
    sample_count: int,
    overlap_s: float | None = None,
    clock_transform: ClockTransform | None = None,
    rms_error: float | None = None,
    diagnostics: dict[str, object] = dict(),
)

Quality report for one temporal or spatial registration.

Attributes:

Name	Type	Description
strategy	str
accepted	bool
score	float
sample_count	int
overlap_s	float | None
clock_transform	ClockTransform | None
rms_error	float | None
diagnostics	dict[str, object]

Attributes

strategy instance-attribute

strategy: str

accepted instance-attribute

accepted: bool

score instance-attribute

score: float

sample_count instance-attribute

sample_count: int

overlap_s class-attribute instance-attribute

overlap_s: float | None = None

clock_transform class-attribute instance-attribute

clock_transform: ClockTransform | None = None

rms_error class-attribute instance-attribute

rms_error: float | None = None

diagnostics class-attribute instance-attribute

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

RigidTransform dataclass

RigidTransform(rotation: FloatArray, translation: FloatArray)

Rigid point transform target = source @ rotation.T + translation.

Methods:

Name	Description
apply	Transform points with trailing dimension 3.

Attributes:

Name	Type	Description
rotation	FloatArray
translation	FloatArray

Attributes

rotation instance-attribute

rotation: FloatArray

translation instance-attribute

translation: FloatArray

Functions

apply

apply(points: FloatArray) -> FloatArray

Transform points with trailing dimension 3.

TemporalRegistrationConfig dataclass

TemporalRegistrationConfig(
    max_abs_offset_s: float,
    min_overlap_s: float = 0.5,
    minimum_score: float = 0.2,
    coarse_steps: int = 1001,
    activity_weighted: bool = True,
)

Quality and search policy for offset registration.

Attributes:

Name	Type	Description
max_abs_offset_s	float
min_overlap_s	float
minimum_score	float
coarse_steps	int
activity_weighted	bool

Attributes

max_abs_offset_s instance-attribute

max_abs_offset_s: float

min_overlap_s class-attribute instance-attribute

min_overlap_s: float = 0.5

minimum_score class-attribute instance-attribute

minimum_score: float = 0.2

coarse_steps class-attribute instance-attribute

coarse_steps: int = 1001

activity_weighted class-attribute instance-attribute

activity_weighted: bool = True

GvhmrEstimator dataclass

GvhmrEstimator(
    checkout: Path,
    command: tuple[str, ...],
    schema: HumanPoseSourceSchema,
    fps: float,
    frame: FrameConvention = Y_UP_RIGHT_HANDED,
    source_height_m: float | None = None,
)

Run a configured local GVHMR checkout in an ephemeral workspace.

Command entries may contain {video}, {workspace}, {output}, and {checkout} placeholders. The configured command must write joints.npy into {output}.

Methods:

Name	Description
estimate	Run GVHMR and load its output before deleting temporary files.

Attributes:

Name	Type	Description
checkout	Path
command	tuple[str, ...]
schema	HumanPoseSourceSchema
fps	float
frame	FrameConvention
source_height_m	float | None

Attributes

checkout instance-attribute

checkout: Path

command instance-attribute

command: tuple[str, ...]

schema instance-attribute

schema: HumanPoseSourceSchema

fps instance-attribute

fps: float

frame class-attribute instance-attribute

frame: FrameConvention = Y_UP_RIGHT_HANDED

source_height_m class-attribute instance-attribute

source_height_m: float | None = None

Functions

estimate

estimate(recording: VideoRecording) -> HumanPoseRecording

Run GVHMR and load its output before deleting temporary files.

HumanPoseEstimator

Bases: Protocol

Estimate a typed human-pose recording from video.

Methods:

Name	Description
estimate	Estimate pose for recording.

Functions

estimate

estimate(recording: VideoRecording) -> HumanPoseRecording

Estimate pose for recording.

VideoPoseSource dataclass

VideoPoseSource(video: VideoRecording, estimator: HumanPoseEstimator)

Compose a video recording source with a pose estimator.

Methods:

Name	Description
load	Estimate and return human pose.

Attributes:

Name	Type	Description
video	VideoRecording
estimator	HumanPoseEstimator

Attributes

video instance-attribute

video: VideoRecording

estimator instance-attribute

estimator: HumanPoseEstimator

Functions

load

load() -> HumanPoseRecording

Estimate and return human pose.

HumanPoseRecording dataclass

HumanPoseRecording(
    name: str,
    timeline: SampleTimeline,
    frame: FrameConvention,
    joints: tuple[JointTrack, ...],
    root_pose: PoseTrack | None = None,
    source_height_m: float | None = None,
    vertices: FloatArray | None = None,
    provenance: dict[str, object] | None = None,
)

Estimated or measured human pose in one native clock.

Methods:

Name	Description
joint	Return one joint track.
to_motion_sequence	Materialize the canonical shared-timeline actor motion after fusion.

Attributes:

Name	Type	Description
name	str
timeline	SampleTimeline
frame	FrameConvention
joints	tuple[JointTrack, ...]
root_pose	PoseTrack | None
source_height_m	float | None
vertices	FloatArray | None
provenance	dict[str, object] | None
joint_roles	tuple[NameEnum, ...]	Ordered joint vocabulary.

Attributes

name instance-attribute

name: str

timeline instance-attribute

timeline: SampleTimeline

frame instance-attribute

frame: FrameConvention

joints instance-attribute

joints: tuple[JointTrack, ...]

root_pose class-attribute instance-attribute

root_pose: PoseTrack | None = None

source_height_m class-attribute instance-attribute

source_height_m: float | None = None

vertices class-attribute instance-attribute

vertices: FloatArray | None = None

provenance class-attribute instance-attribute

provenance: dict[str, object] | None = None

joint_roles property

joint_roles: tuple[NameEnum, ...]

Ordered joint vocabulary.

Functions

joint

joint(role: NameEnum) -> JointTrack

Return one joint track.

to_motion_sequence

to_motion_sequence(root_joint: MotionJoint) -> MotionSequence[MotionJoint]

Materialize the canonical shared-timeline actor motion after fusion.

MocapRecording dataclass

MocapRecording(
    name: str,
    timeline: SampleTimeline,
    frame: FrameConvention,
    joints: tuple[JointTrack, ...] = (),
    rigid_bodies: tuple[RigidBodyTrack, ...] = (),
    markers: tuple[MarkerTrack, ...] = (),
    provenance: dict[str, object] | None = None,
)

Joints, rigid bodies, and markers sampled in one native mocap clock.

Methods:

Name	Description
rigid_body	Return one rigid-body track.
joint	Return one mocap joint track.
marker	Return one marker track.

Attributes:

Name	Type	Description
name	str
timeline	SampleTimeline
frame	FrameConvention
joints	tuple[JointTrack, ...]
rigid_bodies	tuple[RigidBodyTrack, ...]
markers	tuple[MarkerTrack, ...]
provenance	dict[str, object] | None

Attributes

name instance-attribute

name: str

timeline instance-attribute

timeline: SampleTimeline

frame instance-attribute

frame: FrameConvention

joints class-attribute instance-attribute

joints: tuple[JointTrack, ...] = ()

rigid_bodies class-attribute instance-attribute

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

markers class-attribute instance-attribute

markers: tuple[MarkerTrack, ...] = ()

provenance class-attribute instance-attribute

provenance: dict[str, object] | None = None

Functions

rigid_body

rigid_body(role: NameEnum) -> RigidBodyTrack

Return one rigid-body track.

joint

joint(role: NameEnum) -> JointTrack

Return one mocap joint track.

marker

marker(role: NameEnum) -> MarkerTrack

Return one marker track.

VideoRecording dataclass

VideoRecording(
    name: str,
    path: Path,
    timeline: SampleTimeline,
    frame_size: tuple[int, int] | None = None,
    provenance: dict[str, object] | None = None,
)

A video stream and its native frame timeline.

Attributes:

Name	Type	Description
name	str
path	Path
timeline	SampleTimeline
frame_size	tuple[int, int] | None
provenance	dict[str, object] | None

Attributes

name instance-attribute

name: str

path instance-attribute

path: Path

timeline instance-attribute

timeline: SampleTimeline

frame_size class-attribute instance-attribute

frame_size: tuple[int, int] | None = None

provenance class-attribute instance-attribute

provenance: dict[str, object] | None = None

GvhmrOutputSource dataclass

GvhmrOutputSource(
    path: Path,
    schema: HumanPoseSourceSchema,
    fps: float,
    frame: FrameConvention = Y_UP_RIGHT_HANDED,
    name: str = "",
    source_height_m: float | None = None,
    load_vertices: bool = False,
)

Load existing GVHMR arrays as a native human-pose recording.

Methods:

Name	Description
load	Load GVHMR joint output without creating a synchronized file.

Attributes:

Name	Type	Description
path	Path
schema	HumanPoseSourceSchema
fps	float
frame	FrameConvention
name	str
source_height_m	float | None
load_vertices	bool

Attributes

path instance-attribute

path: Path

schema instance-attribute

schema: HumanPoseSourceSchema

fps instance-attribute

fps: float

frame class-attribute instance-attribute

frame: FrameConvention = Y_UP_RIGHT_HANDED

name class-attribute instance-attribute

name: str = ''

source_height_m class-attribute instance-attribute

source_height_m: float | None = None

load_vertices class-attribute instance-attribute

load_vertices: bool = False

Functions

load

load() -> HumanPoseRecording

Load GVHMR joint output without creating a synchronized file.

HumanPoseSourceSchema dataclass

HumanPoseSourceSchema(joint_indices: Mapping[MotionJoint, int])

Map semantic motion-joint vocabularies to source array columns.

Attributes:

Name	Type	Description
joint_indices	Mapping[MotionJoint, int]

Attributes

joint_indices instance-attribute

joint_indices: Mapping[MotionJoint, int]

InMemorySource dataclass

InMemorySource(recording: RecordingT)

Bases: Generic[RecordingT]

Source returning an already constructed recording.

Methods:

Name	Description
load	Return the stored recording.

Attributes:

Name	Type	Description
recording	RecordingT

Attributes

recording instance-attribute

recording: RecordingT

Functions

load

load() -> RecordingT

Return the stored recording.

MocapArraySource dataclass

MocapArraySource(
    path: Path,
    joint_vocabulary: type[MotionJoint],
    fps: float,
    frame: FrameConvention = Z_UP_RIGHT_HANDED,
    downsample: int = 1,
    name: str = "",
)

Load a dense (frames, joints, 3) mocap array.

Methods:

Name	Description
load	Load the array as typed native mocap joint tracks.

Attributes:

Name	Type	Description
path	Path
joint_vocabulary	type[MotionJoint]
fps	float
frame	FrameConvention
downsample	int
name	str

Attributes

path instance-attribute

path: Path

joint_vocabulary instance-attribute

joint_vocabulary: type[MotionJoint]

fps instance-attribute

fps: float

frame class-attribute instance-attribute

frame: FrameConvention = Z_UP_RIGHT_HANDED

downsample class-attribute instance-attribute

downsample: int = 1

name class-attribute instance-attribute

name: str = ''

Functions

load

load() -> MocapRecording

Load the array as typed native mocap joint tracks.

ObservationSource

Bases: Protocol[RecordingT]

Load one native recording without creating a shared timeline.

Methods:

Name	Description
load	Load the recording.

Functions

load

load() -> RecordingT

Load the recording.

ViconBagSource dataclass

ViconBagSource(
    path: Path,
    schema: ViconSourceSchema,
    topics: ViconBagTopics = ViconBagTopics(),
    frame: FrameConvention = Z_UP_RIGHT_HANDED,
    name: str = "",
    transform_scale_m: float = 1.0,
    marker_scale_m: float = 0.001,
)

Read a ROS 2 Vicon bag directly into a native mocap recording.

The optional capture-ros dependency is imported only when :meth:load runs. The bag is never converted into a persistent table or archive.

Methods:

Name	Description
load	Deserialize configured bag topics into typed Vicon tracks.

Attributes:

Name	Type	Description
path	Path
schema	ViconSourceSchema
topics	ViconBagTopics
frame	FrameConvention
name	str
transform_scale_m	float
marker_scale_m	float

Attributes

path instance-attribute

path: Path

schema instance-attribute

schema: ViconSourceSchema

topics class-attribute instance-attribute

topics: ViconBagTopics = ViconBagTopics()

frame class-attribute instance-attribute

frame: FrameConvention = Z_UP_RIGHT_HANDED

name class-attribute instance-attribute

name: str = ''

transform_scale_m class-attribute instance-attribute

transform_scale_m: float = 1.0

marker_scale_m class-attribute instance-attribute

marker_scale_m: float = 0.001

Functions

load

load() -> MocapRecording

Deserialize configured bag topics into typed Vicon tracks.

ViconBagTopics dataclass

ViconBagTopics(
    transforms: tuple[str, ...] = ("/tf",),
    markers: tuple[str, ...] = ("/vicon/markers",),
)

ROS topics carrying Vicon rigid-body transforms and marker samples.

Attributes:

Name	Type	Description
transforms	tuple[str, ...]
markers	tuple[str, ...]

Attributes

transforms class-attribute instance-attribute

transforms: tuple[str, ...] = ('/tf',)

markers class-attribute instance-attribute

markers: tuple[str, ...] = ('/vicon/markers',)

ViconRecordingSource dataclass

ViconRecordingSource(
    path: Path,
    schema: ViconSourceSchema,
    frame: FrameConvention = Z_UP_RIGHT_HANDED,
    name: str = "",
)

Load a preconverted Vicon recording directly into typed tracks.

Methods:

Name	Description
load	Load vicon.npz without a synchronization intermediate.

Attributes:

Name	Type	Description
path	Path
schema	ViconSourceSchema
frame	FrameConvention
name	str

Attributes

path instance-attribute

path: Path

schema instance-attribute

schema: ViconSourceSchema

frame class-attribute instance-attribute

frame: FrameConvention = Z_UP_RIGHT_HANDED

name class-attribute instance-attribute

name: str = ''

Functions

load

load() -> MocapRecording

Load vicon.npz without a synchronization intermediate.

ViconSourceSchema dataclass

ViconSourceSchema(
    rigid_bodies: Mapping[str, MocapRigidBody],
    markers: Mapping[str, MocapMarker],
    rigid_body_order: tuple[str, ...] | None = None,
    marker_order: tuple[str, ...] | None = None,
)

Map Vicon table names into typed native vocabularies.

Attributes:

Name	Type	Description
rigid_bodies	Mapping[str, MocapRigidBody]
markers	Mapping[str, MocapMarker]
rigid_body_order	tuple[str, ...] | None
marker_order	tuple[str, ...] | None

Attributes

rigid_bodies instance-attribute

rigid_bodies: Mapping[str, MocapRigidBody]

markers instance-attribute

markers: Mapping[str, MocapMarker]

rigid_body_order class-attribute instance-attribute

rigid_body_order: tuple[str, ...] | None = None

marker_order class-attribute instance-attribute

marker_order: tuple[str, ...] | None = None

ClockTransform dataclass

ClockTransform(
    scale: float = 1.0,
    offset_s: float = 0.0,
    source_clock: str = "native",
    target_clock: str = "observation",
)

Affine mapping from a native clock into an observation clock.

The mapping is observation_time = scale * native_time + offset_s.

Methods:

Name	Description
apply	Map timestamps into the target clock.
timeline	Map a complete timeline into the target clock.
inverse	Return the inverse clock mapping.

Attributes:

Name	Type	Description
scale	float
offset_s	float
source_clock	str
target_clock	str

Attributes

scale class-attribute instance-attribute

scale: float = 1.0

offset_s class-attribute instance-attribute

offset_s: float = 0.0

source_clock class-attribute instance-attribute

source_clock: str = 'native'

target_clock class-attribute instance-attribute

target_clock: str = 'observation'

Functions

apply

apply(timestamps: Any) -> FloatArray

Map timestamps into the target clock.

timeline

timeline(timeline: SampleTimeline) -> SampleTimeline

Map a complete timeline into the target clock.

inverse

inverse() -> ClockTransform

Return the inverse clock mapping.

SampleTimeline dataclass

SampleTimeline(timestamps: FloatArray, clock: str = 'native')

Strictly increasing sample timestamps in one recording's native clock.

Methods:

Name	Description
uniform	Create a uniform timeline.
slice	Return a timeline subset.

Attributes:

Name	Type	Description
timestamps	FloatArray
clock	str
sample_count	int	Number of timestamps.
start_s	float	First timestamp.
end_s	float	Last timestamp.
duration_s	float	Duration between first and last timestamps.
nominal_fps	float | None	Median sampling rate, or None for a single sample.

Attributes

timestamps instance-attribute

timestamps: FloatArray

clock class-attribute instance-attribute

clock: str = 'native'

sample_count property

sample_count: int

Number of timestamps.

start_s property

start_s: float

First timestamp.

end_s property

end_s: float

Last timestamp.

duration_s property

duration_s: float

Duration between first and last timestamps.

nominal_fps property

nominal_fps: float | None

Median sampling rate, or None for a single sample.

Functions

uniform classmethod

uniform(
    sample_count: int, fps: float, *, start_s: float = 0.0, clock: str = "native"
) -> SampleTimeline

Create a uniform timeline.

slice

slice(indices: slice | ndarray) -> SampleTimeline

Return a timeline subset.

CategoricalTrack dataclass

CategoricalTrack(
    role: NameEnum,
    values: tuple[NameEnum, ...],
    validity: ndarray | None = None,
    provenance: dict[str, object] | None = None,
)

A named categorical sequence sampled by nearest neighbor.

Methods:

Name	Description
resample	Sample this track at the nearest native timestamp.

Attributes:

Name	Type	Description
role	NameEnum
values	tuple[NameEnum, ...]
validity	ndarray | None
provenance	dict[str, object] | None
sample_count	int	Number of samples.

Attributes

role instance-attribute

role: NameEnum

values instance-attribute

values: tuple[NameEnum, ...]

validity class-attribute instance-attribute

validity: ndarray | None = None

provenance class-attribute instance-attribute

provenance: dict[str, object] | None = None

sample_count property

sample_count: int

Number of samples.

Functions

resample

resample(
    source: SampleTimeline,
    target: SampleTimeline,
    *,
    clock: ClockTransform | None = None,
) -> Self

Sample this track at the nearest native timestamp.

JointTrack dataclass

JointTrack(
    role: NameEnum,
    values: FloatArray,
    validity: ndarray | None = None,
    provenance: dict[str, object] | None = None,
)

Bases: PointTrack

A native or estimated human-joint trajectory.

MarkerTrack dataclass

MarkerTrack(
    role: NameEnum,
    values: FloatArray,
    validity: ndarray | None = None,
    provenance: dict[str, object] | None = None,
)

Bases: PointTrack

A native motion-capture marker trajectory.

PointTrack dataclass

PointTrack(
    role: NameEnum,
    values: FloatArray,
    validity: ndarray | None = None,
    provenance: dict[str, object] | None = None,
)

A named 3D point trajectory.

Methods:

Name	Description
resample	Linearly interpolate this track onto target.

Attributes:

Name	Type	Description
role	NameEnum
values	FloatArray
validity	ndarray | None
provenance	dict[str, object] | None
sample_count	int	Number of samples.

Attributes

role instance-attribute

role: NameEnum

values instance-attribute

values: FloatArray

validity class-attribute instance-attribute

validity: ndarray | None = None

provenance class-attribute instance-attribute

provenance: dict[str, object] | None = None

sample_count property

sample_count: int

Number of samples.

Functions

resample

resample(
    source: SampleTimeline,
    target: SampleTimeline,
    *,
    clock: ClockTransform | None = None,
) -> Self

Linearly interpolate this track onto target.

PoseTrack dataclass

PoseTrack(
    role: NameEnum,
    positions: FloatArray,
    quaternions: FloatArray,
    quaternion_order: QuaternionOrder = WXYZ,
    validity: ndarray | None = None,
    provenance: dict[str, object] | None = None,
)

A named rigid-body pose trajectory.

Methods:

Name	Description
resample	Linearly interpolate translation and SLERP orientation.

Attributes:

Name	Type	Description
role	NameEnum
positions	FloatArray
quaternions	FloatArray
quaternion_order	QuaternionOrder
validity	ndarray | None
provenance	dict[str, object] | None
sample_count	int	Number of samples.

Attributes

role instance-attribute

role: NameEnum

positions instance-attribute

positions: FloatArray

quaternions instance-attribute

quaternions: FloatArray

quaternion_order class-attribute instance-attribute

quaternion_order: QuaternionOrder = WXYZ

validity class-attribute instance-attribute

validity: ndarray | None = None

provenance class-attribute instance-attribute

provenance: dict[str, object] | None = None

sample_count property

sample_count: int

Number of samples.

Functions

resample

resample(
    source: SampleTimeline,
    target: SampleTimeline,
    *,
    clock: ClockTransform | None = None,
) -> Self

Linearly interpolate translation and SLERP orientation.

RigidBodyTrack dataclass

RigidBodyTrack(
    role: NameEnum,
    positions: FloatArray,
    quaternions: FloatArray,
    quaternion_order: QuaternionOrder = WXYZ,
    validity: ndarray | None = None,
    provenance: dict[str, object] | None = None,
)

Bases: PoseTrack

A native motion-capture rigid-body trajectory.

Functions

estimate_clock_offset

estimate_clock_offset(
    reference_timeline: SampleTimeline,
    reference_signal: FloatArray,
    moving_timeline: SampleTimeline,
    moving_signal: FloatArray,
    config: TemporalRegistrationConfig,
    *,
    target_clock: str = "observation",
) -> AlignmentReport

Estimate an offset mapping moving_timeline into reference_timeline.

register_rigid_points

register_rigid_points(
    source: FloatArray, target: FloatArray, *, maximum_rms_error: float | None = None
) -> tuple[RigidTransform, AlignmentReport]

Estimate a Kabsch rigid transform from corresponding finite points.