Components

`rerun.components`

`class AnnotationContext`

Bases: AnnotationContextExt

Component: The AnnotationContext provides additional information on how to display entities.

Entities can use ClassIds and KeypointIds to provide annotations, and the labels and colors will be looked up in the appropriate AnnotationContext. We use the first annotation context we find in the path-hierarchy when searching up through the ancestors of a given entity path.

`def init(class_map)`

Create a new instance of the AnnotationContext component.

PARAMETER	DESCRIPTION
`class_map`	List of class descriptions, mapping class indices to class names, colors etc. TYPE: `AnnotationContextLike`

`class Blob`

Bases: BlobExt

Component: A binary blob of data.

`def init(data)`

Create a new instance of the Blob component.

`class ClassId`

Bases: ClassId

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

`class ClearIsRecursive`

Bases: ClearIsRecursiveExt

Component: Configures how a clear operation should behave - recursive or not.

`def init(recursive)`

Create a new instance of the ClearIsRecursive component.

PARAMETER	DESCRIPTION
`recursive`	If true, also clears all recursive children entities. TYPE: `ClearIsRecursiveLike`

`class Color`

Bases: Rgba32

Component: 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).

`class DepthMeter`

Bases: DepthMeterExt

Component: A component indicating how long a meter is, expressed in native units.

`def init(value)`

Create a new instance of the DepthMeter component.

`class DisconnectedSpace`

Bases: DisconnectedSpaceExt

Component: Spatially disconnect this entity from its parent.

Specifies that the entity path at which this is logged is spatially disconnected from its parent, making it impossible to transform the entity path into its parent's space and vice versa. It only applies to space views that work with spatial transformations, i.e. 2D & 3D space views. This is useful for specifying that a subgraph is independent of the rest of the scene.

`def init(is_disconnected=True)`

Disconnect an entity from its parent.

PARAMETER	DESCRIPTION
`is_disconnected`	Whether or not the entity should be disconnected from the rest of the scene. Set to `True` to disconnect the entity from its parent. Set to `False` to disable the effects of this component, (re-)connecting the entity to its parent again. TYPE: `bool` DEFAULT: `True`

`class DrawOrder`

Bases: DrawOrderExt

Component: Draw order used for the display order of 2D elements.

Higher values are drawn on top of lower values. An entity can have only a single draw order component. Within an entity draw order is governed by the order of the components.

Draw order for entities with the same draw order is generally undefined.

`def init(value)`

Create a new instance of the DrawOrder component.

`class HalfSizes2D`

Bases: Vec2D

Component: Half-sizes (extents) of a 2D box along its local axis, starting at its local origin/center.

The box extends both in negative and positive direction along each axis. Negative sizes indicate that the box is flipped along the respective axis, but this has no effect on how it is displayed.

`class HalfSizes3D`

Bases: Vec3D

Component: Half-sizes (extents) of a 3D box along its local axis, starting at its local origin/center.

The box extends both in negative and positive direction along each axis. Negative sizes indicate that the box is flipped along the respective axis, but this has no effect on how it is displayed.

`class InstanceKey`

Bases: InstanceKeyExt

Component: A unique numeric identifier for each individual instance within a batch.

`def init(value)`

Create a new instance of the InstanceKey component.

`class KeypointId`

Bases: KeypointId

Component: 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].

`class LineStrip2D`

Bases: LineStrip2DExt

Component: A line strip in 2D space.

A line strip is a list of points connected by line segments. It can be used to draw approximations of smooth curves.

The points will be connected in order, like so:

       2------3     5
      /        \   /
0----1          \ /
                 4

`def init(points)`

Create a new instance of the LineStrip2D component.

`class LineStrip3D`

Bases: LineStrip3DExt

Component: A line strip in 3D space.

A line strip is a list of points connected by line segments. It can be used to draw approximations of smooth curves.

The points will be connected in order, like so:

       2------3     5
      /        \   /
0----1          \ /
                 4

`def init(points)`

Create a new instance of the LineStrip3D component.

`class MarkerShape`

Bases: MarkerShapeExt

Component: Shape of a marker.

`def init(shape)`

Create a new instance of the MarkerShape component.

`class MarkerSize`

Bases: MarkerSizeExt

Component: Size of a marker in UI points.

`def init(value)`

Create a new instance of the MarkerSize component.

`class Material`

Bases: Material

Component: Material properties of a mesh.

`class MediaType`

Bases: MediaTypeExt, Utf8

Component: A standardized media type (RFC2046, formerly known as MIME types), encoded as a utf8 string.

The complete reference of officially registered media types is maintained by the IANA and can be consulted at https://www.iana.org/assignments/media-types/media-types.xhtml.

`class MeshProperties`

Bases: MeshProperties

Component: Optional triangle indices for a mesh.

`class Name`

Bases: Utf8

Component: A display name, typically for an entity or a item like a plot series.

`class OutOfTreeTransform3D`

Bases: Transform3D

Component: An out-of-tree affine transform between two 3D spaces, represented in a given direction.

"Out-of-tree" means that the transform only affects its own entity: children don't inherit from it.

`class PinholeProjection`

Bases: Mat3x3

Component: Camera projection, from image coordinates to view coordinates.

Child from parent. Image coordinates from camera view coordinates.

Example:

1496.1     0.0  980.5
   0.0  1496.1  744.5
   0.0     0.0    1.0

`class Position2D`

Bases: Vec2D

Component: A position in 2D space.

`class Position3D`

Bases: Vec3D

Component: A position in 3D space.

`class Radius`

Bases: RadiusExt

Component: A Radius component.

`def init(value)`

Create a new instance of the Radius component.

`class Range1D`

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

`def init(range)`

Create a new instance of the Range1D component.

`class Resolution`

Bases: Vec2D

Component: Pixel resolution width & height, e.g. of a camera sensor.

Typically in integer units, but for some use cases floating point may be used.

`class Rotation3D`

Bases: Rotation3D

Component: A 3D rotation, represented either by a quaternion or a rotation around axis.

`class Scalar`

Bases: ScalarExt

Component: A double-precision scalar.

Used for time series plots.

`def init(value)`

Create a new instance of the Scalar component.

`class ScalarScattering`

Bases: ScalarScatteringExt

Component: If true, a scalar will be shown as individual point in a scatter plot.

`def init(scattered)`

Create a new instance of the ScalarScattering component.

`class StrokeWidth`

Bases: StrokeWidthExt

Component: The width of a stroke specified in UI points.

`def init(width)`

Create a new instance of the StrokeWidth component.

`class TensorData`

Bases: TensorData

Component: A multi-dimensional Tensor of data.

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.

Note that the buffer may be encoded in a compressed format such as jpeg or in a format with downsampled chroma, such as NV12 or YUY2. For file formats, the shape is used as a hint, for chroma downsampled format the shape has to be the shape of the decoded image.

`class Texcoord2D`

Bases: Vec2D

Component: A 2D texture UV coordinate.

Texture coordinates specify a position on a 2D texture. A range from 0-1 covers the entire texture in the respective dimension. Unless configured otherwise, the texture repeats outside of this range. Rerun uses top-left as the origin for UV coordinates.

0 U 1 0 + --------- → | . V | . | . 1 ↓ . . . . . .

This is the same convention as in Vulkan/Metal/DX12/WebGPU, but (!) unlike OpenGL, which places the origin at the bottom-left.

`class Text`

Bases: Utf8

Component: A string of text, e.g. for labels and text documents.

`class TextLogLevel`

Bases: TextLogLevelExt, Utf8

Component: The severity level of a text log message.

Recommended to be one of: * "CRITICAL" * "ERROR" * "WARN" * "INFO" * "DEBUG" * "TRACE"

`class Transform3D`

Bases: Transform3D

Component: An affine transform between two 3D spaces, represented in a given direction.

`class Vector2D`

Bases: Vec2D

Component: A vector in 2D space.

`class Vector3D`

Bases: Vec3D

Component: A vector in 3D space.

`class ViewCoordinates`

Bases: ViewCoordinatesExt

Component: 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 component.

PARAMETER	DESCRIPTION
`coordinates`	The directions of the [x, y, z] axes. TYPE: `ViewCoordinatesLike`

`class VisualizerOverrides`

Component: The name of a visualizer.

`def init(value)`

Create a new instance of the VisualizerOverrides component.

Components

rerun.components

class AnnotationContext

def __init__(class_map)

class Blob

def __init__(data)

class ClassId

class ClearIsRecursive

def __init__(recursive)

class Color

class DepthMeter

def __init__(value)

class DisconnectedSpace

def __init__(is_disconnected=True)

class DrawOrder

def __init__(value)

class HalfSizes2D

class HalfSizes3D

class InstanceKey

def __init__(value)

class KeypointId

class LineStrip2D

def __init__(points)

class LineStrip3D

def __init__(points)

class MarkerShape

def __init__(shape)

class MarkerSize

def __init__(value)

class Material

class MediaType

class MeshProperties

class Name

class OutOfTreeTransform3D

class PinholeProjection

class Position2D

class Position3D

class Radius

def __init__(value)

class Range1D

def __init__(range)

class Resolution

class Rotation3D

class Scalar

def __init__(value)

class ScalarScattering

def __init__(scattered)

class StrokeWidth

def __init__(width)

class TensorData

class Texcoord2D

class Text

class TextLogLevel

class Transform3D

class Vector2D

class Vector3D

class ViewCoordinates

def __init__(coordinates)

class VisualizerOverrides

def __init__(value)

`rerun.components`

`class AnnotationContext`

`def init(class_map)`

`class Blob`

`def init(data)`

`class ClassId`

`class ClearIsRecursive`

`def init(recursive)`

`class Color`

`class DepthMeter`

`def init(value)`

`class DisconnectedSpace`

`def init(is_disconnected=True)`

`class DrawOrder`

`def init(value)`

`class HalfSizes2D`

`class HalfSizes3D`

`class InstanceKey`

`def init(value)`

`class KeypointId`

`class LineStrip2D`

`def init(points)`

`class LineStrip3D`

`def init(points)`

`class MarkerShape`

`def init(shape)`

`class MarkerSize`

`def init(value)`

`class Material`

`class MediaType`

`class MeshProperties`

`class Name`

`class OutOfTreeTransform3D`

`class PinholeProjection`

`class Position2D`

`class Position3D`

`class Radius`

`def init(value)`

`class Range1D`

`def init(range)`

`class Resolution`

`class Rotation3D`

`class Scalar`

`def init(value)`

`class ScalarScattering`

`def init(scattered)`

`class StrokeWidth`

`def init(width)`

`class TensorData`

`class Texcoord2D`

`class Text`

`class TextLogLevel`

`class Transform3D`

`class Vector2D`

`class Vector3D`

`class ViewCoordinates`

`def init(coordinates)`

`class VisualizerOverrides`

`def init(value)`