Components

`rerun.components`

`class AggregationPolicy`

Bases: Enum

Component: Policy for aggregation of multiple scalar plot values.

This is used for lines in plots when the X axis distance of individual points goes below a single pixel, i.e. a single pixel covers more than one tick worth of data. It can greatly improve performance (and readability) in such situations as it prevents overdraw.

`Average = 2` `class-attribute` `instance-attribute`

Average all points in the range together.

`Max = 3` `class-attribute` `instance-attribute`

Keep only the maximum values in the range.

`Min = 4` `class-attribute` `instance-attribute`

Keep only the minimum values in the range.

`MinMax = 5` `class-attribute` `instance-attribute`

Keep both the minimum and maximum values in the range.

This will yield two aggregated points instead of one, effectively creating a vertical line.

`MinMaxAverage = 6` `class-attribute` `instance-attribute`

Find both the minimum and maximum values in the range, then use the average of those.

`Off = 1` `class-attribute` `instance-attribute`

No aggregation.

`def str()`

Returns the variant name.

`def auto(val)` `classmethod`

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

`class AlbedoFactor`

Bases: Rgba32, ComponentMixin

Component: A color multiplier, usually applied to a whole entity, e.g. a mesh.

`def init(rgba)`

Create a new instance of the Rgba32 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class AnnotationContext`

Bases: AnnotationContextExt, ComponentMixin

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

Entities can use datatypes.ClassIds and datatypes.KeypointIds to provide annotations, and the labels and colors will be looked up in the appropriate annotation context. 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`

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class AxisLength`

Bases: Float32, ComponentMixin

Component: The length of an axis in local units of the space.

`def init(value)`

Create a new instance of the Float32 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Blob`

Bases: Blob, ComponentMixin

Component: A binary blob of data.

`def init(data)`

Create a new instance of the Blob datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class ClassId`

Bases: ClassId, ComponentMixin

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

`def init(id)`

Create a new instance of the ClassId datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class ClearIsRecursive`

Bases: ClearIsRecursiveExt, Bool, ComponentMixin

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

`def init(recursive=True)`

Disconnect an entity from its parent.

PARAMETER	DESCRIPTION
`recursive`	If true, also clears all recursive children entities. TYPE: `bool` DEFAULT: `True`

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Color`

Bases: Rgba32, ComponentMixin

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

`def init(rgba)`

Create a new instance of the Rgba32 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Colormap`

Bases: Enum

Component: Colormap for mapping scalar values within a given range to a color.

This provides a number of popular pre-defined colormaps. In the future, the Rerun Viewer will allow users to define their own colormaps, but currently the Viewer is limited to the types defined here.

`CyanToYellow = 7` `class-attribute` `instance-attribute`

Rasmusgo's Cyan to Yellow colormap

This is a perceptually uniform colormap which is robust to color blindness. It is especially suited for visualizing signed values. It interpolates from cyan to blue to dark gray to brass to yellow.

`Grayscale = 1` `class-attribute` `instance-attribute`

A simple black to white gradient.

This is a sRGB gray gradient which is perceptually uniform.

`Inferno = 2` `class-attribute` `instance-attribute`

The Inferno colormap from Matplotlib.

This is a perceptually uniform colormap. It interpolates from black to red to bright yellow.

`Magma = 3` `class-attribute` `instance-attribute`

The Magma colormap from Matplotlib.

This is a perceptually uniform colormap. It interpolates from black to purple to white.

`Plasma = 4` `class-attribute` `instance-attribute`

The Plasma colormap from Matplotlib.

This is a perceptually uniform colormap. It interpolates from dark blue to purple to yellow.

`Turbo = 5` `class-attribute` `instance-attribute`

Google's Turbo colormap map.

This is a perceptually non-uniform rainbow colormap addressing many issues of more traditional rainbow colormaps like Jet. It is more perceptually uniform without sharp transitions and is more colorblind-friendly. Details: https://research.google/blog/turbo-an-improved-rainbow-colormap-for-visualization/

`Viridis = 6` `class-attribute` `instance-attribute`

The Viridis colormap from Matplotlib

This is a perceptually uniform colormap which is robust to color blindness. It interpolates from dark purple to green to yellow.

`def str()`

Returns the variant name.

`def auto(val)` `classmethod`

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

`class DepthMeter`

Bases: Float32, ComponentMixin

Component: The world->depth map scaling factor.

This measures how many depth map units are in a world unit. For instance, if a depth map uses millimeters and the world uses meters, this value would be 1000.

Note that the only effect on 2D views is the physical depth values shown when hovering the image. In 3D views on the other hand, this affects where the points of the point cloud are placed.

`def init(value)`

Create a new instance of the Float32 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class DisconnectedSpace`

Bases: DisconnectedSpaceExt, Bool, ComponentMixin

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`

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class DrawOrder`

Bases: Float32, ComponentMixin

Component: Draw 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 Float32 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class FillMode`

Bases: Enum

Component: How a geometric shape is drawn and colored.

`DenseWireframe = 2` `class-attribute` `instance-attribute`

Many lines are drawn to represent the surface of the shape in a see-through fashion.

Examples of what this means:

An archetypes.Ellipsoids3D will draw a wireframe triangle mesh that approximates each ellipsoid.
For archetypes.Boxes3D, it is the edges of the box, identical to MajorWireframe.

`MajorWireframe = 1` `class-attribute` `instance-attribute`

Lines are drawn around the parts of the shape which directly correspond to the logged data.

Examples of what this means:

An archetypes.Ellipsoids3D will draw three axis-aligned ellipses that are cross-sections of each ellipsoid, each of which displays two out of three of the sizes of the ellipsoid.
For archetypes.Boxes3D, it is the edges of the box, identical to DenseWireframe.

`Solid = 3` `class-attribute` `instance-attribute`

The surface of the shape is filled in with a solid color. No lines are drawn.

`def str()`

Returns the variant name.

`def auto(val)` `classmethod`

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

`class FillRatio`

Bases: Float32, ComponentMixin

Component: How much a primitive fills out the available space.

Used for instance to scale the points of the point cloud created from archetypes.DepthImage projection in 3D views. Valid range is from 0 to max float although typically values above 1.0 are not useful.

Defaults to 1.0.

`def init(value)`

Create a new instance of the Float32 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class GammaCorrection`

Bases: Float32, ComponentMixin

Component: A gamma correction value to be used with a scalar value or color.

Used to adjust the gamma of a color or scalar value between 0 and 1 before rendering. new_value = old_value ^ gamma

Valid range is from 0 (excluding) to max float. Defaults to 1.0 unless otherwise specified.

`def init(value)`

Create a new instance of the Float32 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class HalfSize2D`

Bases: Vec2D, ComponentMixin

Component: Half-size (radius) of a 2D box.

Measured in its local coordinate system.

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.

`def init(xy)`

Create a new instance of the Vec2D datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class HalfSize3D`

Bases: Vec3D, ComponentMixin

Component: Half-size (radius) of a 3D box.

Measured in its local coordinate system.

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.

`def init(xyz)`

Create a new instance of the Vec3D datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class ImageBuffer`

Bases: Blob, ComponentMixin

Component: A buffer that is known to store image data.

To interpret the contents of this buffer, see, components.ImageFormat.

`def init(data)`

Create a new instance of the Blob datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class ImageFormat`

Bases: ImageFormat, ComponentMixin

Component: 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`

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class ImagePlaneDistance`

Bases: Float32, ComponentMixin

Component: The distance from the camera origin to the image plane when the projection is shown in a 3D viewer.

This is only used for visualization purposes, and does not affect the projection itself.

`def init(value)`

Create a new instance of the Float32 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class KeypointId`

Bases: KeypointId, ComponentMixin

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

`def init(id)`

Create a new instance of the KeypointId datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class LineStrip2D`

Bases: LineStrip2DExt, ComponentMixin

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.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class LineStrip3D`

Bases: LineStrip3DExt, ComponentMixin

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.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class MagnificationFilter`

Bases: Enum

Component: Filter used when magnifying an image/texture such that a single pixel/texel is displayed as multiple pixels on screen.

`Linear = 2` `class-attribute` `instance-attribute`

Linearly interpolate the nearest neighbors, creating a smoother look when zooming in.

Used as default for mesh rendering.

`Nearest = 1` `class-attribute` `instance-attribute`

Show the nearest pixel value.

This will give a blocky appearance when zooming in. Used as default when rendering 2D images.

`def str()`

Returns the variant name.

`def auto(val)` `classmethod`

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

`class MarkerShape`

Bases: Enum

Component: The visual appearance of a point in e.g. a 2D plot.

`Asterisk = 10` `class-attribute` `instance-attribute`

*

`Circle = 1` `class-attribute` `instance-attribute`

⏺

`Cross = 4` `class-attribute` `instance-attribute`

x

`Diamond = 2` `class-attribute` `instance-attribute`

◆

`Down = 7` `class-attribute` `instance-attribute`

▼

`Left = 8` `class-attribute` `instance-attribute`

◀

`Plus = 5` `class-attribute` `instance-attribute`

+

`Right = 9` `class-attribute` `instance-attribute`

▶

`Square = 3` `class-attribute` `instance-attribute`

◼️

`Up = 6` `class-attribute` `instance-attribute`

▲

`def str()`

Returns the variant name.

`def auto(val)` `classmethod`

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

`class MarkerSize`

Bases: Float32, ComponentMixin

Component: Radius of a marker of a point in e.g. a 2D plot, measured in UI points.

`def init(value)`

Create a new instance of the Float32 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class MediaType`

Bases: MediaTypeExt, Utf8, ComponentMixin

Component: A standardized media type (RFC2046, formerly known as MIME types), encoded as a 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.

`GLB: MediaType = None` `class-attribute` `instance-attribute`

Binary glTF: model/gltf-binary.

https://www.iana.org/assignments/media-types/model/gltf-binary

`GLTF: MediaType = None` `class-attribute` `instance-attribute`

glTF: model/gltf+json.

https://www.iana.org/assignments/media-types/model/gltf+json

`JPEG: MediaType = None` `class-attribute` `instance-attribute`

JPEG image: image/jpeg.

`MARKDOWN: MediaType = None` `class-attribute` `instance-attribute`

Markdown: text/markdown.

https://www.iana.org/assignments/media-types/text/markdown

`OBJ: MediaType = None` `class-attribute` `instance-attribute`

Wavefront .obj: model/obj.

https://www.iana.org/assignments/media-types/model/obj

`PNG: MediaType = None` `class-attribute` `instance-attribute`

PNG image: image/png.

https://www.iana.org/assignments/media-types/image/png

`STL: MediaType = None` `class-attribute` `instance-attribute`

Stereolithography Model stl: model/stl. Either binary or ASCII.

https://www.iana.org/assignments/media-types/model/stl

`TEXT: MediaType = None` `class-attribute` `instance-attribute`

Plain text: text/plain.

`def init(value)`

Create a new instance of the Utf8 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Name`

Bases: Utf8, ComponentMixin

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

`def init(value)`

Create a new instance of the Utf8 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Opacity`

Bases: Float32, ComponentMixin

Component: Degree of transparency ranging from 0.0 (fully transparent) to 1.0 (fully opaque).

The final opacity value may be a result of multiplication with alpha values as specified by other color sources. Unless otherwise specified, the default value is 1.

`def init(value)`

Create a new instance of the Float32 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class PinholeProjection`

Bases: Mat3x3, ComponentMixin

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

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

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class PoseRotationAxisAngle`

Bases: RotationAxisAngle, ComponentMixin

Component: 3D rotation represented by a rotation around a given axis that doesn't propagate in the transform hierarchy.

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

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class PoseRotationQuat`

Bases: Quaternion, ComponentMixin

Component: A 3D rotation expressed as a quaternion that doesn't propagate in the transform hierarchy.

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.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class PoseScale3D`

Bases: PoseScale3DExt, Vec3D, ComponentMixin

Component: A 3D scale factor that doesn't propagate in the transform hierarchy.

A scale of 1.0 means no scaling. A scale of 2.0 means doubling the size. Each component scales along the corresponding axis.

`def init(uniform_or_per_axis=True)`

3D scaling factor.

A scale of 1.0 means no scaling. A scale of 2.0 means doubling the size. Each component scales along the corresponding axis.

PARAMETER	DESCRIPTION
`uniform_or_per_axis`	If a single value is given, it is applied the same to all three axis (uniform scaling). TYPE: `Union[Vec3DLike, Float32Like]` DEFAULT: `True`

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class PoseTransformMat3x3`

Bases: Mat3x3, ComponentMixin

Component: A 3x3 transformation matrix Matrix that doesn't propagate in the transform hierarchy.

3x3 matrixes are able to represent any affine transformation in 3D space, i.e. rotation, scaling, shearing, reflection etc.

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.components.PoseTransformMat3x3([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.components.PoseTransformMat3x3([[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.components.PoseTransformMat3x3(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.components.PoseTransformMat3x3(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)`

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class PoseTranslation3D`

Bases: Vec3D, ComponentMixin

Component: A translation vector in 3D space that doesn't propagate in the transform hierarchy.

`def init(xyz)`

Create a new instance of the Vec3D datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Position2D`

Bases: Vec2D, ComponentMixin

Component: A position in 2D space.

`def init(xy)`

Create a new instance of the Vec2D datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Position3D`

Bases: Vec3D, ComponentMixin

Component: A position in 3D space.

`def init(xyz)`

Create a new instance of the Vec3D datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Radius`

Bases: RadiusExt, Float32, ComponentMixin

Component: The radius of something, e.g. a point.

Internally, positive values indicate scene units, whereas negative values are interpreted as UI points.

UI points are independent of zooming in Views, but are sensitive to the application UI scaling. at 100% UI scaling, UI points are equal to pixels The Viewer's UI scaling defaults to the OS scaling which typically is 100% for full HD screens and 200% for 4k screens.

`def init(value)`

Create a new instance of the Float32 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`def ui_points(radii)` `staticmethod`

Create a radius or list of radii in UI points.

By default, radii are interpreted as scene units. Ui points on the other hand are independent of zooming in Views, but are sensitive to the application UI scaling. at 100% UI scaling, UI points are equal to pixels The Viewer's UI scaling defaults to the OS scaling which typically is 100% for full HD screens and 200% for 4k screens.

Internally, ui radii are stored as negative values. Therefore, all this method does is to ensure that all returned values are negative.

`class Range1D`

Bases: Range1D, ComponentMixin

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

`def init(range)`

Create a new instance of the Range1D datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Resolution`

Bases: Vec2D, ComponentMixin

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.

`def init(xy)`

Create a new instance of the Vec2D datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class RotationAxisAngle`

Bases: RotationAxisAngle, ComponentMixin

Component: 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`

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class RotationQuat`

Bases: Quaternion, ComponentMixin

Component: A 3D rotation expressed as a quaternion.

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.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Scalar`

Bases: Float64, ComponentMixin

Component: A scalar value, encoded as a 64-bit floating point.

Used for time series plots.

`def init(value)`

Create a new instance of the Float64 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Scale3D`

Bases: Scale3DExt, Vec3D, ComponentMixin

Component: A 3D scale factor.

A scale of 1.0 means no scaling. A scale of 2.0 means doubling the size. Each component scales along the corresponding axis.

`def init(uniform_or_per_axis=True)`

3D scaling factor.

A scale of 1.0 means no scaling. A scale of 2.0 means doubling the size. Each component scales along the corresponding axis.

PARAMETER	DESCRIPTION
`uniform_or_per_axis`	If a single value is given, it is applied the same to all three axis (uniform scaling). TYPE: `Union[Vec3DLike, Float32Like]` DEFAULT: `True`

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class StrokeWidth`

Bases: Float32, ComponentMixin

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

`def init(value)`

Create a new instance of the Float32 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class TensorData`

Bases: TensorData, ComponentMixin

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

`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 as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`def numpy(force)`

Convert the TensorData back to a numpy array.

`class TensorDimensionIndexSelection`

Bases: TensorDimensionIndexSelection, ComponentMixin

Component: Specifies a concrete index on a tensor dimension.

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

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class TensorHeightDimension`

Bases: TensorDimensionSelection, ComponentMixin

Component: Specifies which dimension to use for height.

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

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class TensorWidthDimension`

Bases: TensorDimensionSelection, ComponentMixin

Component: Specifies which dimension to use for width.

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

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Texcoord2D`

Bases: Vec2D, ComponentMixin

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.

`def init(xy)`

Create a new instance of the Vec2D datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Text`

Bases: Utf8, ComponentMixin

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

`def init(value)`

Create a new instance of the Utf8 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class TextLogLevel`

Bases: TextLogLevelExt, Utf8, ComponentMixin

Component: The severity level of a text log message.

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

`CRITICAL: TextLogLevel = None` `class-attribute` `instance-attribute`

Designates catastrophic failures.

`DEBUG: TextLogLevel = None` `class-attribute` `instance-attribute`

Designates lower priority information.

`ERROR: TextLogLevel = None` `class-attribute` `instance-attribute`

Designates very serious errors.

`INFO: TextLogLevel = None` `class-attribute` `instance-attribute`

Designates useful information.

`TRACE: TextLogLevel = None` `class-attribute` `instance-attribute`

Designates very low priority, often extremely verbose, information.

`WARN: TextLogLevel = None` `class-attribute` `instance-attribute`

Designates hazardous situations.

`def init(value)`

Create a new instance of the Utf8 datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class TransformMat3x3`

Bases: Mat3x3, ComponentMixin

Component: A 3x3 transformation matrix Matrix.

3x3 matrixes are able to represent any affine transformation in 3D space, i.e. rotation, scaling, shearing, reflection etc.

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.components.TransformMat3x3([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.components.TransformMat3x3([[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.components.TransformMat3x3(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.components.TransformMat3x3(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)`

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class TransformRelation`

Bases: Enum

Component: Specifies relation a spatial transform describes.

`ChildFromParent = 2` `class-attribute` `instance-attribute`

The transform describes how to transform into the child entity's space.

E.g. a translation of (0, 1, 0) with this components.TransformRelation logged at parent/child means that from the point of view of parent, parent/child is translated -1 unit along parent's Y axis. From perspective of parent/child, the parent entity is translated 1 unit along parent/child's Y axis.

`ParentFromChild = 1` `class-attribute` `instance-attribute`

The transform describes how to transform into the parent entity's space.

E.g. a translation of (0, 1, 0) with this components.TransformRelation logged at parent/child means that from the point of view of parent, parent/child is translated 1 unit along parent's Y axis. From perspective of parent/child, the parent entity is translated -1 unit along parent/child's Y axis.

`def str()`

Returns the variant name.

`def auto(val)` `classmethod`

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

`class Translation3D`

Bases: Vec3D, ComponentMixin

Component: A translation vector in 3D space.

`def init(xyz)`

Create a new instance of the Vec3D datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class TriangleIndices`

Bases: UVec3D, ComponentMixin

Component: The three indices of a triangle in a triangle mesh.

`def init(xyz)`

Create a new instance of the UVec3D datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Vector2D`

Bases: Vec2D, ComponentMixin

Component: A vector in 2D space.

`def init(xy)`

Create a new instance of the Vec2D datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class Vector3D`

Bases: Vec3D, ComponentMixin

Component: A vector in 3D space.

`def init(xyz)`

Create a new instance of the Vec3D datatype.

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

`class ViewCoordinates`

Bases: ViewCoordinatesExt, ViewCoordinates, ComponentMixin

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

`BDL: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Back, Y=Down, Z=Left

`BDR: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Back, Y=Down, Z=Right

`BLD: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Back, Y=Left, Z=Down

`BLU: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Back, Y=Left, Z=Up

`BRD: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Back, Y=Right, Z=Down

`BRU: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Back, Y=Right, Z=Up

`BUL: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Back, Y=Up, Z=Left

`BUR: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Back, Y=Up, Z=Right

`DBL: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Down, Y=Back, Z=Left

`DBR: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Down, Y=Back, Z=Right

`DFL: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Down, Y=Forward, Z=Left

`DFR: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Down, Y=Forward, Z=Right

`DLB: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Down, Y=Left, Z=Back

`DLF: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Down, Y=Left, Z=Forward

`DRB: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Down, Y=Right, Z=Back

`DRF: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Down, Y=Right, Z=Forward

`FDL: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Forward, Y=Down, Z=Left

`FDR: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Forward, Y=Down, Z=Right

`FLD: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Forward, Y=Left, Z=Down

`FLU: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Forward, Y=Left, Z=Up

`FRD: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Forward, Y=Right, Z=Down

`FRU: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Forward, Y=Right, Z=Up

`FUL: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Forward, Y=Up, Z=Left

`FUR: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Forward, Y=Up, Z=Right

`LBD: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Left, Y=Back, Z=Down

`LBU: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Left, Y=Back, Z=Up

`LDB: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Left, Y=Down, Z=Back

`LDF: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Left, Y=Down, Z=Forward

`LEFT_HAND_X_DOWN: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Down, Y=Right, Z=Forward

`LEFT_HAND_X_UP: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Up, Y=Right, Z=Back

`LEFT_HAND_Y_DOWN: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Down, Z=Back

`LEFT_HAND_Y_UP: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Up, Z=Forward

`LEFT_HAND_Z_DOWN: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Forward, Z=Down

`LEFT_HAND_Z_UP: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Back, Z=Up

`LFD: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Left, Y=Forward, Z=Down

`LFU: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Left, Y=Forward, Z=Up

`LUB: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Left, Y=Up, Z=Back

`LUF: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Left, Y=Up, Z=Forward

`RBD: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Back, Z=Down

`RBU: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Back, Z=Up

`RDB: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Down, Z=Back

`RDF: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Down, Z=Forward

`RFD: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Forward, Z=Down

`RFU: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Forward, Z=Up

`RIGHT_HAND_X_DOWN: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Down, Y=Right, Z=Back

`RIGHT_HAND_X_UP: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Up, Y=Right, Z=Forward

`RIGHT_HAND_Y_DOWN: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Down, Z=Forward

`RIGHT_HAND_Y_UP: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Up, Z=Back

`RIGHT_HAND_Z_DOWN: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Back, Z=Down

`RIGHT_HAND_Z_UP: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Forward, Z=Up

`RUB: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Up, Z=Back

`RUF: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Right, Y=Up, Z=Forward

`UBL: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Up, Y=Back, Z=Left

`UBR: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Up, Y=Back, Z=Right

`UFL: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Up, Y=Forward, Z=Left

`UFR: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Up, Y=Forward, Z=Right

`ULB: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Up, Y=Left, Z=Back

`ULF: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Up, Y=Left, Z=Forward

`URB: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Up, Y=Right, Z=Back

`URF: ViewCoordinates = None` `class-attribute` `instance-attribute`

X=Up, Y=Right, Z=Forward

`def init(coordinates)`

Create a new instance of the ViewCoordinates datatype.

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

`def as_arrow_array()`

The component as an arrow batch.

Part of the ComponentBatchLike logging interface.

`def component_name()`

The name of the component.

Part of the ComponentBatchLike logging interface.

Components

rerun.components

class AggregationPolicy

Average = 2 class-attribute instance-attribute

Max = 3 class-attribute instance-attribute

Min = 4 class-attribute instance-attribute

MinMax = 5 class-attribute instance-attribute

MinMaxAverage = 6 class-attribute instance-attribute

Off = 1 class-attribute instance-attribute

def __str__()

def auto(val) classmethod

class AlbedoFactor

def __init__(rgba)

def as_arrow_array()

def component_name()

class AnnotationContext

def __init__(class_map)

def as_arrow_array()

def component_name()

class AxisLength

def __init__(value)

def as_arrow_array()

def component_name()

class Blob

def __init__(data)

def as_arrow_array()

def component_name()

class ClassId

def __init__(id)

def as_arrow_array()

def component_name()

class ClearIsRecursive

def __init__(recursive=True)

def as_arrow_array()

def component_name()

class Color

def __init__(rgba)

def as_arrow_array()

def component_name()

class Colormap

CyanToYellow = 7 class-attribute instance-attribute

Grayscale = 1 class-attribute instance-attribute

Inferno = 2 class-attribute instance-attribute

Magma = 3 class-attribute instance-attribute

Plasma = 4 class-attribute instance-attribute

Turbo = 5 class-attribute instance-attribute

Viridis = 6 class-attribute instance-attribute

def __str__()

def auto(val) classmethod

class DepthMeter

def __init__(value)

def as_arrow_array()

def component_name()

class DisconnectedSpace

def __init__(is_disconnected=True)

def as_arrow_array()

def component_name()

class DrawOrder

def __init__(value)

def as_arrow_array()

def component_name()

class FillMode

DenseWireframe = 2 class-attribute instance-attribute

MajorWireframe = 1 class-attribute instance-attribute

Solid = 3 class-attribute instance-attribute

def __str__()

def auto(val) classmethod

class FillRatio

def __init__(value)

def as_arrow_array()

def component_name()

class GammaCorrection

def __init__(value)

def as_arrow_array()

def component_name()

class HalfSize2D

def __init__(xy)

def as_arrow_array()

def component_name()

class HalfSize3D

`rerun.components`

`class AggregationPolicy`

`Average = 2` `class-attribute` `instance-attribute`

`Max = 3` `class-attribute` `instance-attribute`

`Min = 4` `class-attribute` `instance-attribute`

`MinMax = 5` `class-attribute` `instance-attribute`

`MinMaxAverage = 6` `class-attribute` `instance-attribute`

`Off = 1` `class-attribute` `instance-attribute`

`def str()`

`def auto(val)` `classmethod`

`class AlbedoFactor`

`def init(rgba)`

`def as_arrow_array()`

`def component_name()`

`class AnnotationContext`

`def init(class_map)`

`def as_arrow_array()`

`def component_name()`

`class AxisLength`

`def init(value)`

`def as_arrow_array()`

`def component_name()`

`class Blob`

`def init(data)`

`def as_arrow_array()`

`def component_name()`

`class ClassId`

`def init(id)`

`def as_arrow_array()`

`def component_name()`

`class ClearIsRecursive`

`def init(recursive=True)`

`def as_arrow_array()`

`def component_name()`

`class Color`

`def init(rgba)`

`def as_arrow_array()`

`def component_name()`

`class Colormap`

`CyanToYellow = 7` `class-attribute` `instance-attribute`

`Grayscale = 1` `class-attribute` `instance-attribute`

`Inferno = 2` `class-attribute` `instance-attribute`

`Magma = 3` `class-attribute` `instance-attribute`

`Plasma = 4` `class-attribute` `instance-attribute`

`Turbo = 5` `class-attribute` `instance-attribute`

`Viridis = 6` `class-attribute` `instance-attribute`

`def str()`

`def auto(val)` `classmethod`

`class DepthMeter`

`def init(value)`

`def as_arrow_array()`

`def component_name()`

`class DisconnectedSpace`

`def init(is_disconnected=True)`

`def as_arrow_array()`

`def component_name()`

`class DrawOrder`

`def init(value)`

`def as_arrow_array()`

`def component_name()`

`class FillMode`

`DenseWireframe = 2` `class-attribute` `instance-attribute`

`MajorWireframe = 1` `class-attribute` `instance-attribute`

`Solid = 3` `class-attribute` `instance-attribute`

`def str()`

`def auto(val)` `classmethod`

`class FillRatio`

`def init(value)`

`def as_arrow_array()`

`def component_name()`

`class GammaCorrection`

`def init(value)`

`def as_arrow_array()`

`def component_name()`

`class HalfSize2D`

`def init(xy)`

`def as_arrow_array()`

`def component_name()`

`class HalfSize3D`

`def init(xyz)`