Skip to content

Datatypes

rerun.datatypes

class Angle

Bases: AngleExt

Datatype: Angle in radians.

def __init__(rad=None, deg=None)

Create a new instance of the Angle datatype.

PARAMETER DESCRIPTION
rad

Angle in radians, specify either rad or deg.

TYPE: float | None DEFAULT: None

deg

Angle in degrees, specify either rad or deg. Converts the angle to radians internally.

TYPE: float | None DEFAULT: None

class AnnotationInfo

Bases: AnnotationInfoExt

Datatype: Annotation info annotating a class id or key-point id.

Color and label will be used to annotate entities/keypoints which reference the id. The id refers either to a class or key-point id

def __init__(id, label=None, color=None)

Create a new instance of the AnnotationInfo datatype.

PARAMETER DESCRIPTION
id

datatypes.ClassId or datatypes.KeypointId to which this annotation info belongs.

TYPE: int

label

The label that will be shown in the UI.

TYPE: Utf8Like | None DEFAULT: None

color

The color that will be applied to the annotated entity.

TYPE: Rgba32Like | None DEFAULT: None

class Blob

Bases: BlobExt

Datatype: A binary blob of data.

def __init__(data)

Create a new instance of the Blob datatype.

class Bool

Datatype: A single boolean.

def __init__(value)

Create a new instance of the Bool datatype.

class ChannelDatatype

Bases: ChannelDatatypeExt, Enum

Datatype: The innermost datatype of an image.

How individual color channel components are encoded.

F16 = 33 class-attribute instance-attribute

16-bit IEEE-754 floating point, also known as half.

F32 = 34 class-attribute instance-attribute

32-bit IEEE-754 floating point, also known as float or single.

F64 = 35 class-attribute instance-attribute

64-bit IEEE-754 floating point, also known as double.

I16 = 9 class-attribute instance-attribute

16-bit signed integer.

I32 = 11 class-attribute instance-attribute

32-bit signed integer.

I64 = 13 class-attribute instance-attribute

64-bit signed integer.

I8 = 7 class-attribute instance-attribute

8-bit signed integer.

U16 = 8 class-attribute instance-attribute

16-bit unsigned integer.

U32 = 10 class-attribute instance-attribute

32-bit unsigned integer.

U64 = 12 class-attribute instance-attribute

64-bit unsigned integer.

U8 = 6 class-attribute instance-attribute

8-bit unsigned integer.

def __str__()

Returns the variant name.

def auto(val) classmethod

Best-effort converter, including a case-insensitive string matcher.

class ClassDescription

Bases: ClassDescriptionExt

Datatype: The description of a semantic Class.

If an entity is annotated with a corresponding components.ClassId, Rerun will use the attached datatypes.AnnotationInfo to derive labels and colors.

Keypoints within an annotation class can similarly be annotated with a components.KeypointId in which case we should defer to the label and color for the datatypes.AnnotationInfo specifically associated with the Keypoint.

Keypoints within the class can also be decorated with skeletal edges. Keypoint-connections are pairs of components.KeypointIds. If an edge is defined, and both keypoints exist within the instance of the class, then the keypoints should be connected with an edge. The edge should be labeled and colored as described by the class's datatypes.AnnotationInfo.

Note that a ClassDescription can be directly logged using rerun.log. This is equivalent to logging a rerun.AnnotationContext containing a single ClassDescription.

def __init__(*, info, keypoint_annotations=[], keypoint_connections=[])

Create a new instance of the ClassDescription datatype.

PARAMETER DESCRIPTION
info

The AnnotationInfo for the class.

TYPE: AnnotationInfoLike

keypoint_annotations

The AnnotationInfo for all the keypoints.

TYPE: Sequence[AnnotationInfoLike] | None DEFAULT: []

keypoint_connections

The connections between keypoints.

TYPE: Sequence[KeypointPairLike] | None DEFAULT: []

class ClassDescriptionMapElem

Bases: ClassDescriptionMapElemExt

Datatype: A helper type for mapping datatypes.ClassIds to class descriptions.

This is internal to components.AnnotationContext.

def __init__(class_id, class_description)

Create a new instance of the ClassDescriptionMapElem datatype.

PARAMETER DESCRIPTION
class_id

The key: the components.ClassId.

TYPE: ClassIdLike

class_description

The value: class name, color, etc.

TYPE: ClassDescriptionLike

class ClassId

Datatype: A 16-bit ID representing a type of semantic class.

def __init__(id)

Create a new instance of the ClassId datatype.

class ColorModel

Bases: Enum

Datatype: Specified what color components are present in an archetypes.Image.

This combined with datatypes.ChannelDatatype determines the pixel format of an image.

BGR = 4 class-attribute instance-attribute

Blue, Green, Red

BGRA = 5 class-attribute instance-attribute

Blue, Green, Red, Alpha

L = 1 class-attribute instance-attribute

Grayscale luminance intencity/brightness/value, sometimes called Y

RGB = 2 class-attribute instance-attribute

Red, Green, Blue

RGBA = 3 class-attribute instance-attribute

Red, Green, Blue, Alpha

def __str__()

Returns the variant name.

def auto(val) classmethod

Best-effort converter, including a case-insensitive string matcher.

class DVec2D

Bases: DVec2DExt

Datatype: A double-precision vector in 2D space.

def __init__(xy)

Create a new instance of the DVec2D datatype.

class EntityPath

Datatype: A path to an entity in the ChunkStore.

def __init__(path)

Create a new instance of the EntityPath datatype.

class Float32

Datatype: A single-precision 32-bit IEEE 754 floating point number.

def __init__(value)

Create a new instance of the Float32 datatype.

class Float64

Datatype: A double-precision 64-bit IEEE 754 floating point number.

def __init__(value)

Create a new instance of the Float64 datatype.

class ImageFormat

Bases: ImageFormatExt

Datatype: The metadata describing the contents of a components.ImageBuffer.

def __init__(width, height, pixel_format=None, color_model=None, channel_datatype=None)

Create a new instance of the ImageFormat datatype.

PARAMETER DESCRIPTION
width

The width of the image in pixels.

TYPE: int

height

The height of the image in pixels.

TYPE: int

pixel_format

Used mainly for chroma downsampled formats and differing number of bits per channel.

If specified, this takes precedence over both datatypes.ColorModel and datatypes.ChannelDatatype (which are ignored).

TYPE: PixelFormatLike | None DEFAULT: None

color_model

L, RGB, RGBA, …

Also requires a datatypes.ChannelDatatype to fully specify the pixel format.

TYPE: ColorModelLike | None DEFAULT: None

channel_datatype

The data type of each channel (e.g. the red channel) of the image data (U8, F16, …).

Also requires a datatypes.ColorModel to fully specify the pixel format.

TYPE: ChannelDatatypeLike | None DEFAULT: None

class KeypointId

Datatype: A 16-bit ID representing a type of semantic keypoint within a class.

KeypointIds are only meaningful within the context of a [rerun.datatypes.ClassDescription].

Used to look up an [rerun.datatypes.AnnotationInfo] for a Keypoint within the [rerun.components.AnnotationContext].

def __init__(id)

Create a new instance of the KeypointId datatype.

class KeypointPair

Bases: KeypointPairExt

Datatype: A connection between two datatypes.KeypointIds.

def __init__(keypoint0, keypoint1)

Create a new instance of the KeypointPair datatype.

PARAMETER DESCRIPTION
keypoint0

The first point of the pair.

TYPE: KeypointIdLike

keypoint1

The second point of the pair.

TYPE: KeypointIdLike

class Mat3x3

Bases: Mat3x3Ext

Datatype: A 3x3 Matrix.

Matrices in Rerun are stored as flat list of coefficients in column-major order: 

            column 0       column 1       column 2
       -------------------------------------------------
row 0 | flat_columns[0] flat_columns[3] flat_columns[6]
row 1 | flat_columns[1] flat_columns[4] flat_columns[7]
row 2 | flat_columns[2] flat_columns[5] flat_columns[8]

However, construction is done from a list of rows, which follows NumPy's convention: 

np.testing.assert_array_equal(
    rr.datatypes.Mat3x3([1, 2, 3, 4, 5, 6, 7, 8, 9]).flat_columns, np.array([1, 4, 7, 2, 5, 8, 3, 6, 9], dtype=np.float32)
)
np.testing.assert_array_equal(
    rr.datatypes.Mat3x3([[1, 2, 3], [4, 5, 6], [7, 8, 9]]).flat_columns,
    np.array([1, 4, 7, 2, 5, 8, 3, 6, 9], dtype=np.float32),
)
If you want to construct a matrix from a list of columns instead, use the named columns parameter: 
np.testing.assert_array_equal(
    rr.datatypes.Mat3x3(columns=[1, 2, 3, 4, 5, 6, 7, 8, 9]).flat_columns,
    np.array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=np.float32),
)
np.testing.assert_array_equal(
    rr.datatypes.Mat3x3(columns=[[1, 2, 3], [4, 5, 6], [7, 8, 9]]).flat_columns,
    np.array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=np.float32),
)

class Mat4x4

Bases: Mat4x4Ext

Datatype: A 4x4 Matrix.

Matrices in Rerun are stored as flat list of coefficients in column-major order: 

           column 0         column 1         column 2         column 3
       --------------------------------------------------------------------
row 0 | flat_columns[0]  flat_columns[4]  flat_columns[8]  flat_columns[12]
row 1 | flat_columns[1]  flat_columns[5]  flat_columns[9]  flat_columns[13]
row 2 | flat_columns[2]  flat_columns[6]  flat_columns[10] flat_columns[14]
row 3 | flat_columns[3]  flat_columns[7]  flat_columns[11] flat_columns[15]

However, construction is done from a list of rows, which follows NumPy's convention: 

np.testing.assert_array_equal(
    rr.datatypes.Mat4x4([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]).flat_columns,
    np.array([1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16], dtype=np.float32),
)
np.testing.assert_array_equal(
    rr.datatypes.Mat4x4([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]).flat_columns,
    np.array([1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16], dtype=np.float32),
)
If you want to construct a matrix from a list of columns instead, use the named columns parameter: 
np.testing.assert_array_equal(
    rr.datatypes.Mat4x4(columns=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]).flat_columns,
    np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], dtype=np.float32),
)
np.testing.assert_array_equal(
    rr.datatypes.Mat4x4(columns=[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]).flat_columns,
    np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], dtype=np.float32),
)

class PixelFormat

Bases: Enum

Datatype: Specifieds a particular format of an archetypes.Image.

Most images can be described by a datatypes.ColorModel and a datatypes.ChannelDatatype, e.g. RGB and U8 respectively.

However, some image formats has chroma downsampling and/or use differing number of bits per channel, and that is what this datatypes.PixelFormat is for.

All these formats support random access.

For more compressed image formats, see archetypes.EncodedImage.

NV12 = 26 class-attribute instance-attribute

NV12 (aka Y_UV12) is a YUV 4:2:0 chroma downsampled form at with 12 bits per pixel and 8 bits per channel.

This uses limited range YUV, i.e. Y is expected to be within [16, 235] and U/V within [16, 240].

First comes entire image in Y in one plane, followed by a plane with interleaved lines ordered as U0, V0, U1, V1, etc.

Y8_FullRange = 30 class-attribute instance-attribute

Monochrome Y plane only, essentially a YUV 4:0:0 planar format.

Also known as just "gray". This is virtually identical to a 8bit luminance/grayscale (see datatypes.ColorModel).

This uses entire range YUV, i.e. Y is expected to be within [0, 255]. (as opposed to "limited range" YUV as used e.g. in NV12).

Y8_LimitedRange = 41 class-attribute instance-attribute

Monochrome Y plane only, essentially a YUV 4:0:0 planar format.

Also known as just "gray".

This uses limited range YUV, i.e. Y is expected to be within [16, 235]. If not for this range limitation/remapping, this is almost identical to 8bit luminace/grayscale (see datatypes.ColorModel).

YUY2 = 27 class-attribute instance-attribute

YUY2 (aka YUYV, YUYV16 or NV21), is a YUV 4:2:2 chroma downsampled format with 16 bits per pixel and 8 bits per channel.

This uses limited range YUV, i.e. Y is expected to be within [16, 235] and U/V within [16, 240].

The order of the channels is Y0, U0, Y1, V0, all in the same plane.

Y_U_V12_FullRange = 44 class-attribute instance-attribute

Y_U_V12 is a YUV 4:2:0 fully planar YUV format without chroma downsampling, also known as I420.

This uses full range YUV with all components ranging from 0 to 255 (as opposed to "limited range" YUV as used e.g. in NV12).

First comes entire image in Y in one plane, followed by the U and V planes, which each only have half the resolution of the Y plane.

Y_U_V12_LimitedRange = 20 class-attribute instance-attribute

Y_U_V12 is a YUV 4:2:0 fully planar YUV format without chroma downsampling, also known as I420.

This uses limited range YUV, i.e. Y is expected to be within [16, 235] and U/V within [16, 240].

First comes entire image in Y in one plane, followed by the U and V planes, which each only have half the resolution of the Y plane.

Y_U_V16_FullRange = 50 class-attribute instance-attribute

Y_U_V16 is a YUV 4:2:2 fully planar YUV format without chroma downsampling, also known as I422.

This uses full range YUV with all components ranging from 0 to 255 (as opposed to "limited range" YUV as used e.g. in NV12).

First comes entire image in Y in one plane, followed by the U and V planes, which each only have half the horizontal resolution of the Y plane.

Y_U_V16_LimitedRange = 49 class-attribute instance-attribute

Y_U_V16 is a YUV 4:2:2 fully planar YUV format without chroma downsampling, also known as I422.

This uses limited range YUV, i.e. Y is expected to be within [16, 235] and U/V within [16, 240].

First comes entire image in Y in one plane, followed by the U and V planes, which each only have half the horizontal resolution of the Y plane.

Y_U_V24_FullRange = 40 class-attribute instance-attribute

Y_U_V24 is a YUV 4:4:4 fully planar YUV format without chroma downsampling, also known as I444.

This uses full range YUV with all components ranging from 0 to 255 (as opposed to "limited range" YUV as used e.g. in NV12).

First comes entire image in Y in one plane, followed by the U and V planes.

Y_U_V24_LimitedRange = 39 class-attribute instance-attribute

Y_U_V24 is a YUV 4:4:4 fully planar YUV format without chroma downsampling, also known as I444.

This uses limited range YUV, i.e. Y is expected to be within [16, 235] and U/V within [16, 240].

First comes entire image in Y in one plane, followed by the U and V planes.

def __str__()

Returns the variant name.

def auto(val) classmethod

Best-effort converter, including a case-insensitive string matcher.

class Quaternion

Bases: QuaternionExt

Datatype: A Quaternion represented by 4 real numbers.

Note: although the x,y,z,w components of the quaternion will be passed through to the datastore as provided, when used in the Viewer Quaternions will always be normalized.

class Range1D

Bases: Range1DExt

Datatype: A 1D range, specifying a lower and upper bound.

def __init__(range)

Create a new instance of the Range1D datatype.

class Range2D

Datatype: An Axis-Aligned Bounding Box in 2D space, implemented as the minimum and maximum corners.

def __init__(x_range, y_range)

Create a new instance of the Range2D datatype.

PARAMETER DESCRIPTION
x_range

The range of the X-axis (usually left and right bounds).

TYPE: Range1DLike

y_range

The range of the Y-axis (usually top and bottom bounds).

TYPE: Range1DLike

class Rgba32

Bases: Rgba32Ext

Datatype: An RGBA color with unmultiplied/separate alpha, in sRGB gamma space with linear alpha.

The color is stored as a 32-bit integer, where the most significant byte is R and the least significant byte is A.

Float colors are assumed to be in 0-1 gamma sRGB space. All other colors are assumed to be in 0-255 gamma sRGB space. If there is an alpha, we assume it is in linear space, and separate (NOT pre-multiplied).

def __init__(rgba)

Create a new instance of the Rgba32 datatype.

class RotationAxisAngle

Bases: RotationAxisAngleExt

Datatype: 3D rotation represented by a rotation around a given axis.

def __init__(axis, angle=None, *, radians=None, degrees=None)

Create a new instance of the RotationAxisAngle datatype.

PARAMETER DESCRIPTION
axis

Axis to rotate around.

This is not required to be normalized. If normalization fails (typically because the vector is length zero), the rotation is silently ignored.

TYPE: Vec3DLike

angle

How much to rotate around the axis.

TYPE: AngleLike | None DEFAULT: None

radians

How much to rotate around the axis, in radians. Specify this instead of degrees or angle.

TYPE: float | None DEFAULT: None

degrees

How much to rotate around the axis, in radians. Specify this instead of radians or angle.

TYPE: float | None DEFAULT: None

class TensorBuffer

Bases: TensorBufferExt

Datatype: The underlying storage for archetypes.Tensor.

Tensor elements are stored in a contiguous buffer of a single type.

inner: Union[npt.NDArray[np.float16], npt.NDArray[np.float32], npt.NDArray[np.float64], npt.NDArray[np.int16], npt.NDArray[np.int32], npt.NDArray[np.int64], npt.NDArray[np.int8], npt.NDArray[np.uint16], npt.NDArray[np.uint32], npt.NDArray[np.uint64], npt.NDArray[np.uint8]] = field(converter=TensorBufferExt.inner__field_converter_override) class-attribute instance-attribute

Must be one of:

  • U8 (npt.NDArray[np.uint8]): 8bit unsigned integer.

  • U16 (npt.NDArray[np.uint16]): 16bit unsigned integer.

  • U32 (npt.NDArray[np.uint32]): 32bit unsigned integer.

  • U64 (npt.NDArray[np.uint64]): 64bit unsigned integer.

  • I8 (npt.NDArray[np.int8]): 8bit signed integer.

  • I16 (npt.NDArray[np.int16]): 16bit signed integer.

  • I32 (npt.NDArray[np.int32]): 32bit signed integer.

  • I64 (npt.NDArray[np.int64]): 64bit signed integer.

  • F16 (npt.NDArray[np.float16]): 16bit IEEE-754 floating point, also known as half.

  • F32 (npt.NDArray[np.float32]): 32bit IEEE-754 floating point, also known as float or single.

  • F64 (npt.NDArray[np.float64]): 64bit IEEE-754 floating point, also known as double.

class TensorData

Bases: TensorDataExt

Datatype: An N-dimensional array of numbers.

The number of dimensions and their respective lengths is specified by the shape field. The dimensions are ordered from outermost to innermost. For example, in the common case of a 2D RGB Image, the shape would be [height, width, channel].

These dimensions are combined with an index to look up values from the buffer field, which stores a contiguous array of typed values.

It's not currently possible to use send_columns with tensors since construction of rerun.components.TensorDataBatch does not support more than a single element. This will be addressed as part of https://github.com/rerun-io/rerun/issues/6832.

def __init__(*, shape=None, buffer=None, array=None, dim_names=None)

Construct a TensorData object.

The TensorData object is internally represented by three fields: shape and buffer.

This constructor provides additional arguments 'array', and 'dim_names'. When passing in a multi-dimensional array such as a np.ndarray, the shape and buffer fields will be populated automagically.

PARAMETER DESCRIPTION
self

The TensorData object to construct.

TYPE: Any

shape

The shape of the tensor. If None, and an array is provided, the shape will be inferred from the shape of the array.

TYPE: Sequence[TensorDimensionLike] | None DEFAULT: None

buffer

The buffer of the tensor. If None, and an array is provided, the buffer will be generated from the array.

TYPE: TensorBufferLike | None DEFAULT: None

array

A numpy array (or The array of the tensor. If None, the array will be inferred from the buffer.

TYPE: TensorLike | None DEFAULT: None

dim_names

The names of the tensor dimensions when generating the shape from an array.

TYPE: Sequence[str | None] | None DEFAULT: None

def numpy(force)

Convert the TensorData back to a numpy array.

class TensorDimension

Datatype: A single dimension within a multi-dimensional tensor.

def __init__(size, name=None)

Create a new instance of the TensorDimension datatype.

PARAMETER DESCRIPTION
size

The length of this dimension.

TYPE: int

name

The name of this dimension, e.g. "width", "height", "channel", "batch', ….

TYPE: str | None DEFAULT: None

class TensorDimensionIndexSelection

Datatype: Indexing a specific tensor dimension.

Selecting dimension=2 and index=42 is similar to doing tensor[:, :, 42, :, :, …] in numpy.

def __init__(dimension, index)

Create a new instance of the TensorDimensionIndexSelection datatype.

PARAMETER DESCRIPTION
dimension

The dimension number to select.

TYPE: int

index

The index along the dimension to use.

TYPE: int

class TensorDimensionSelection

Bases: TensorDimensionSelectionExt

Datatype: Selection of a single tensor dimension.

def __init__(dimension, *, invert=False)

Create a new instance of the TensorDimensionSelection datatype.

PARAMETER DESCRIPTION
dimension

The dimension number to select.

TYPE: int

invert

Invert the direction of the dimension.

TYPE: bool DEFAULT: False

class TimeInt

Bases: TimeIntExt

Datatype: A 64-bit number describing either nanoseconds OR sequence numbers.

def __init__(*, seq=None, seconds=None, nanos=None)

Create a new instance of the TimeInt datatype.

PARAMETER DESCRIPTION
seq

Time as a sequence number. Mutually exclusive with seconds and nanos.

TYPE: int | None DEFAULT: None

seconds

Time in seconds. Mutually exclusive with seq and nanos.

TYPE: float | None DEFAULT: None

nanos

Time in nanoseconds. Mutually exclusive with seq and seconds.

TYPE: int | None DEFAULT: None

class TimeRange

Datatype: Visible time range bounds for a specific timeline.

def __init__(start, end)

Create a new instance of the TimeRange datatype.

PARAMETER DESCRIPTION
start

Low time boundary for sequence timeline.

TYPE: TimeRangeBoundaryLike

end

High time boundary for sequence timeline.

TYPE: TimeRangeBoundaryLike

class TimeRangeBoundary

Bases: TimeRangeBoundaryExt

Datatype: Left or right boundary of a time range.

inner: Union[None, datatypes.TimeInt] = field() class-attribute instance-attribute

Must be one of:

  • CursorRelative (datatypes.TimeInt): Boundary is a value relative to the time cursor.

  • Absolute (datatypes.TimeInt): Boundary is an absolute value.

  • Infinite (None): The boundary extends to infinity.

kind: Literal['cursor_relative', 'absolute', 'infinite'] = field(default='cursor_relative') class-attribute instance-attribute

Possible values:

  • "cursor_relative": Boundary is a value relative to the time cursor.

  • "absolute": Boundary is an absolute value.

  • "infinite": The boundary extends to infinity.

def absolute(time=None, *, seq=None, seconds=None, nanos=None) staticmethod

Boundary that is at an absolute time.

PARAMETER DESCRIPTION
time

Absolute time.

Mutually exclusive with seq, seconds and nanos.

TYPE: TimeInt | None DEFAULT: None

seq

Absolute time in sequence numbers.

Use this for sequence timelines. Mutually exclusive with time, seconds and nanos.

TYPE: int | None DEFAULT: None

seconds

Absolute time in seconds.

Use this for time based timelines. Mutually exclusive with time, seq and nanos.

TYPE: float | None DEFAULT: None

nanos

Absolute time in nanoseconds.

Use this for time based timelines. Mutually exclusive with time, seq and seconds.

TYPE: int | None DEFAULT: None

def cursor_relative(offset=None, *, seq=None, seconds=None, nanos=None) staticmethod

Boundary that is relative to the timeline cursor.

The offset can be positive or negative. An offset of zero (the default) means the cursor time itself.

PARAMETER DESCRIPTION
offset

Offset from the cursor time.

Mutually exclusive with seq, seconds and nanos.

TYPE: TimeInt | None DEFAULT: None

seq

Offset in sequence numbers.

Use this for sequence timelines. Mutually exclusive with time, seconds and nanos.

TYPE: int | None DEFAULT: None

seconds

Offset in seconds.

Use this for time based timelines. Mutually exclusive with time, seq and nanos.

TYPE: float | None DEFAULT: None

nanos

Offset in nanoseconds.

Use this for time based timelines. Mutually exclusive with time, seq and seconds.

TYPE: int | None DEFAULT: None

def infinite() staticmethod

Boundary that extends to infinity.

Depending on the context, this can mean the beginning or the end of the timeline.

class UInt16

Datatype: A 16bit unsigned integer.

def __init__(value)

Create a new instance of the UInt16 datatype.

class UInt32

Datatype: A 32bit unsigned integer.

def __init__(value)

Create a new instance of the UInt32 datatype.

class UInt64

Datatype: A 64bit unsigned integer.

def __init__(value)

Create a new instance of the UInt64 datatype.

class UVec2D

Bases: UVec2DExt

Datatype: A uint32 vector in 2D space.

def __init__(xy)

Create a new instance of the UVec2D datatype.

class UVec3D

Bases: UVec3DExt

Datatype: A uint32 vector in 3D space.

def __init__(xyz)

Create a new instance of the UVec3D datatype.

class UVec4D

Datatype: A uint vector in 4D space.

def __init__(xyzw)

Create a new instance of the UVec4D datatype.

class Utf8

Datatype: A string of text, encoded as UTF-8.

def __init__(value)

Create a new instance of the Utf8 datatype.

class Uuid

Bases: UuidExt

Datatype: A 16-byte UUID.

def __init__(bytes)

Create a new instance of the Uuid datatype.

PARAMETER DESCRIPTION
bytes

The raw bytes representing the UUID.

TYPE: UuidLike

class Vec2D

Bases: Vec2DExt

Datatype: A vector in 2D space.

def __init__(xy)

Create a new instance of the Vec2D datatype.

class Vec3D

Bases: Vec3DExt

Datatype: A vector in 3D space.

def __init__(xyz)

Create a new instance of the Vec3D datatype.

class Vec4D

Bases: Vec4DExt

Datatype: A vector in 4D space.

def __init__(xyzw)

Create a new instance of the Vec4D datatype.

class VideoTimestamp

Datatype: Presentation timestamp within a archetypes.AssetVideo.

Specified in nanoseconds. Presentation timestamps are typically measured as time since video start.

def __init__(timestamp_ns)

Create a new instance of the VideoTimestamp datatype.

PARAMETER DESCRIPTION
timestamp_ns

Presentation timestamp value in nanoseconds.

TYPE: VideoTimestampLike

class ViewCoordinates

Bases: ViewCoordinatesExt

Datatype: How we interpret the coordinate system of an entity/space.

For instance: What is "up"? What does the Z axis mean?

The three coordinates are always ordered as [x, y, z].

For example [Right, Down, Forward] means that the X axis points to the right, the Y axis points down, and the Z axis points forward.

⚠ Rerun does not yet support left-handed coordinate systems.

The following constants are used to represent the different directions: * Up = 1 * Down = 2 * Right = 3 * Left = 4 * Forward = 5 * Back = 6

def __init__(coordinates)

Create a new instance of the ViewCoordinates datatype.

PARAMETER DESCRIPTION
coordinates

The directions of the [x, y, z] axes.

TYPE: ViewCoordinatesLike

class VisibleTimeRange

Bases: VisibleTimeRangeExt

Datatype: Visible time range bounds for a specific timeline.

def __init__(timeline, range=None, *, start=None, end=None)

Create a new instance of the VisibleTimeRange datatype.

PARAMETER DESCRIPTION
timeline

Name of the timeline this applies to.

TYPE: Utf8Like

range

Time range to use for this timeline.

TYPE: TimeRangeLike | None DEFAULT: None

start

Low time boundary for sequence timeline. Specify this instead of range.

TYPE: TimeRangeBoundary | None DEFAULT: None

end

High time boundary for sequence timeline. Specify this instead of range.

TYPE: TimeRangeBoundary | None DEFAULT: None