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.

`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 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),
)

`def init(rows=None, *, columns=None)`

`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),
)

`def init(rows=None, *, columns=None)`

`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 format with 12 bits per pixel and 8 bits per channel.

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

`YUY2 = 27` `class-attribute` `instance-attribute`

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

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

`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 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 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? Is this right-handed or left-handed?

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.

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`

Datatypes

rerun.datatypes

class Angle

def __init__(rad=None, deg=None)

class AnnotationInfo

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

class Blob

def __init__(data)

class Bool

def __init__(value)

class ChannelDatatype

F16 = 33 class-attribute instance-attribute

F32 = 34 class-attribute instance-attribute

F64 = 35 class-attribute instance-attribute

I16 = 9 class-attribute instance-attribute

I32 = 11 class-attribute instance-attribute

I64 = 13 class-attribute instance-attribute

I8 = 7 class-attribute instance-attribute

U16 = 8 class-attribute instance-attribute

U32 = 10 class-attribute instance-attribute

U64 = 12 class-attribute instance-attribute

U8 = 6 class-attribute instance-attribute

def __str__()

def auto(val) classmethod

class ClassDescription

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

class ClassDescriptionMapElem

def __init__(class_id, class_description)

class ClassId

def __init__(id)

class ColorModel

L = 1 class-attribute instance-attribute

RGB = 2 class-attribute instance-attribute

RGBA = 3 class-attribute instance-attribute

def __str__()

def auto(val) classmethod

class EntityPath

def __init__(path)

class Float32

def __init__(value)

class Float64

def __init__(value)

class ImageFormat

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

class KeypointId

def __init__(id)

class KeypointPair

def __init__(keypoint0, keypoint1)

class Mat3x3

def __init__(rows=None, *, columns=None)

class Mat4x4

def __init__(rows=None, *, columns=None)

class PixelFormat

NV12 = 26 class-attribute instance-attribute

YUY2 = 27 class-attribute instance-attribute

def __str__()

def auto(val) classmethod

class Quaternion

class Range1D

def __init__(range)

class Range2D

def __init__(x_range, y_range)

class Rgba32

def __init__(rgba)

class RotationAxisAngle

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

class TensorBuffer

class TensorData

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

def numpy(force)

class TensorDimension

def __init__(size, name=None)

class TensorDimensionIndexSelection

def __init__(dimension, index)

class TensorDimensionSelection

def __init__(dimension, *, invert=False)

class TimeInt

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

class TimeRange

def __init__(start, end)

`rerun.datatypes`

`class Angle`

`def init(rad=None, deg=None)`

`class AnnotationInfo`

`def init(id, label=None, color=None)`

`class Blob`

`def init(data)`

`class Bool`

`def init(value)`

`class ChannelDatatype`

`F16 = 33` `class-attribute` `instance-attribute`

`F32 = 34` `class-attribute` `instance-attribute`

`F64 = 35` `class-attribute` `instance-attribute`

`I16 = 9` `class-attribute` `instance-attribute`

`I32 = 11` `class-attribute` `instance-attribute`

`I64 = 13` `class-attribute` `instance-attribute`

`I8 = 7` `class-attribute` `instance-attribute`

`U16 = 8` `class-attribute` `instance-attribute`

`U32 = 10` `class-attribute` `instance-attribute`

`U64 = 12` `class-attribute` `instance-attribute`

`U8 = 6` `class-attribute` `instance-attribute`

`def str()`

`def auto(val)` `classmethod`

`class ClassDescription`

`def init(*, info, keypoint_annotations=[], keypoint_connections=[])`

`class ClassDescriptionMapElem`

`def init(class_id, class_description)`

`class ClassId`

`def init(id)`

`class ColorModel`

`L = 1` `class-attribute` `instance-attribute`

`RGB = 2` `class-attribute` `instance-attribute`

`RGBA = 3` `class-attribute` `instance-attribute`

`def str()`

`def auto(val)` `classmethod`

`class EntityPath`

`def init(path)`

`class Float32`

`def init(value)`

`class Float64`

`def init(value)`

`class ImageFormat`

`def init(width, height, pixel_format=None, color_model=None, channel_datatype=None)`

`class KeypointId`

`def init(id)`

`class KeypointPair`

`def init(keypoint0, keypoint1)`

`class Mat3x3`

`def init(rows=None, *, columns=None)`

`class Mat4x4`

`def init(rows=None, *, columns=None)`

`class PixelFormat`

`NV12 = 26` `class-attribute` `instance-attribute`

`YUY2 = 27` `class-attribute` `instance-attribute`

`def str()`

`def auto(val)` `classmethod`

`class Quaternion`

`class Range1D`

`def init(range)`

`class Range2D`

`def init(x_range, y_range)`

`class Rgba32`

`def init(rgba)`

`class RotationAxisAngle`

`def init(axis, angle=None, *, radians=None, degrees=None)`

`class TensorBuffer`

`class TensorData`

`def init(*, shape=None, buffer=None, array=None, dim_names=None)`

`def numpy(force)`

`class TensorDimension`

`def init(size, name=None)`

`class TensorDimensionIndexSelection`

`def init(dimension, index)`

`class TensorDimensionSelection`

`def init(dimension, *, invert=False)`

`class TimeInt`

`def init(*, seq=None, seconds=None, nanos=None)`

`class TimeRange`

`def init(start, end)`

`class TimeRangeBoundary`