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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
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:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class ChannelId
Bases: UInt16, ComponentMixin
Component: A 16-bit ID representing an MCAP channel.
Used to identify specific channels within an MCAP file.
def __init__(value)
Create a new instance of the UInt16 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class ChannelMessageCounts
Bases: ComponentMixin
Component: A mapping of channel IDs to their respective message counts.
Used in MCAP statistics to track how many messages were recorded per channel.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(counts)
Create a new instance of the ChannelMessageCounts component.
| PARAMETER | DESCRIPTION |
|---|---|
counts
|
The channel ID to message count pairs.
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class Color
Bases: ColorExt, 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
def from_string(s)
staticmethod
Generate a random yet deterministic color based on a string.
The color is guaranteed to be identical for the same input string.
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.
Spectral = 8
class-attribute
instance-attribute
The Spectral colormap from Matplotlib.
This is a diverging colormap, often used to visualize data with a meaningful center point, where deviations from that center are important to highlight. It interpolates from red to orange to yellow to green to blue to violet.
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 Count
Bases: UInt64, ComponentMixin
Component: A generic count value.
Used for counting various entities like messages, schemas, channels, etc.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the UInt64 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
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.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Float32 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class EntityPath
Bases: EntityPath, ComponentMixin
Component: A path to an entity, usually to reference some data that is part of the target entity.
def __init__(path)
Create a new instance of the EntityPath datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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.Ellipsoids3Dwill draw a wireframe triangle mesh that approximates each ellipsoid. - For
archetypes.Boxes3D, it is the edges of the box, identical tocomponents.FillMode.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.Ellipsoids3Dwill 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 tocomponents.FillMode.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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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
Must be a positive number. Defaults to 1.0 unless otherwise specified.
def __init__(value)
Create a new instance of the Float32 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class GeoLineString
Bases: GeoLineStringExt, ComponentMixin
Component: A geospatial line string expressed in EPSG:4326 latitude and longitude (North/East-positive degrees).
def __init__(*, lat_lon)
Create a new instance of the GeoLineString component.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class GraphEdge
Bases: Utf8Pair, ComponentMixin
Component: An edge in a graph connecting two nodes.
def __init__(first, second)
Create a new instance of the Utf8Pair datatype.
| PARAMETER | DESCRIPTION |
|---|---|
first
|
The first string.
TYPE:
|
second
|
The second string.
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class GraphNode
Bases: Utf8, ComponentMixin
Component: A string-based ID representing a node in a graph.
def __init__(value)
Create a new instance of the Utf8 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class GraphType
Bases: Enum
Component: Specifies if a graph has directed or undirected edges.
Directed = 2
class-attribute
instance-attribute
The graph has directed edges.
Undirected = 1
class-attribute
instance-attribute
The graph has undirected edges.
def __str__()
Returns the variant name.
def auto(val)
classmethod
Best-effort converter, including a case-insensitive string matcher.
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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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:
|
height
|
The height of the image in pixels.
TYPE:
|
pixel_format
|
Used mainly for chroma downsampled formats and differing number of bits per channel. If specified, this takes precedence over both
TYPE:
|
color_model
|
L, RGB, RGBA, … Also requires a
TYPE:
|
channel_datatype
|
The data type of each channel (e.g. the red channel) of the image data (U8, F16, …). Also requires a
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class Interactive
Bases: Bool, ComponentMixin
Component: Whether the entity can be interacted with.
Non interactive components are still visible, but mouse interactions in the view are disabled.
def __init__(value)
Create a new instance of the Bool datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class KeyValuePairs
Bases: KeyValuePairsExt, ComponentMixin
Component: A map of string keys to string values.
This component can be used to attach arbitrary metadata or annotations to entities. Each key-value pair is stored as a UTF-8 string mapping.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(pairs)
Create a new instance of the KeyValuePairs component.
| PARAMETER | DESCRIPTION |
|---|---|
pairs
|
The key-value pairs that make up this string map.
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class LatLon
Bases: DVec2D, ComponentMixin
Component: A geospatial position expressed in EPSG:4326 latitude and longitude (North/East-positive degrees).
def __init__(xy)
Create a new instance of the DVec2D datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class Length
Bases: Float32, ComponentMixin
Component: Length, or one-dimensional size.
Measured in its local coordinate system; consult the archetype in use to determine which axis or part of the entity this is the length of.
def __init__(value)
Create a new instance of the Float32 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class LinearSpeed
Bases: Float64, ComponentMixin
Component: Linear speed, used for translation speed for example.
def __init__(value)
Create a new instance of the Float64 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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.
MP4: MediaType = None
class-attribute
instance-attribute
OBJ: MediaType = None
class-attribute
instance-attribute
PNG: MediaType = None
class-attribute
instance-attribute
STL: MediaType = None
class-attribute
instance-attribute
Stereolithography Model stl: model/stl.
Either binary or ASCII.
TEXT: MediaType = None
class-attribute
instance-attribute
Plain text: text/plain.
def __init__(value)
Create a new instance of the Utf8 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class Plane3D
Bases: Plane3D, ComponentMixin
Component: An infinite 3D plane represented by a unit normal vector and a distance.
Any point P on the plane fulfills the equation dot(xyz, P) - d = 0,
where xyz is the plane's normal and d the distance of the plane from the origin.
This representation is also known as the Hesse normal form.
Note: although the normal will be passed through to the datastore as provided, when used in the Viewer, planes will always be normalized. I.e. the plane with xyz = (2, 0, 0), d = 1 is equivalent to xyz = (1, 0, 0), d = 0.5
def __init__(normal, distance=None)
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
def distance()
Returns the distance of the plane from the origin.
def normal()
Returns the normal vector of the plane.
def with_distance(distance)
Returns a new plane with the same normal but with the distance set to the given amount.
class PoseRotationAxisAngle
Bases: RotationAxisAngle, ComponentMixin
Component: 3D rotation represented by a rotation around a given axis that doesn't propagate in the transform hierarchy.
If normalization of the rotation axis fails the rotation is treated as an invalid transform, unless the angle is zero in which case it is treated as an identity.
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:
|
angle
|
How much to rotate around the axis.
TYPE:
|
radians
|
How much to rotate around the axis, in radians. Specify this instead of
TYPE:
|
degrees
|
How much to rotate around the axis, in degrees. Specify this instead of
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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. If normalization fails the rotation is treated as an invalid transform.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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),
)
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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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.
If normalization of the rotation axis fails the rotation is treated as an invalid transform, unless the angle is zero in which case it is treated as an identity.
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:
|
angle
|
How much to rotate around the axis.
TYPE:
|
radians
|
How much to rotate around the axis, in radians. Specify this instead of
TYPE:
|
degrees
|
How much to rotate around the axis, in degrees. Specify this instead of
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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. If normalization fails the rotation is treated as an invalid transform.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class SchemaId
Bases: UInt16, ComponentMixin
Component: A 16-bit unique identifier for a schema within the MCAP file.
def __init__(value)
Create a new instance of the UInt16 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class SeriesVisible
Bases: Bool, ComponentMixin
Component: Like components.Visible, but for time series.
TODO(#10632): This is a temporary workaround. Right now we can't use components.Visible since it would conflict with the entity-wide visibility state.
def __init__(value)
Create a new instance of the Bool datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class ShowLabels
Bases: Bool, ComponentMixin
Component: Whether the entity's components.Text label is shown.
The main purpose of this component existing separately from the labels themselves is to be overridden when desired, to allow hiding and showing from the viewer and blueprints.
def __init__(value)
Create a new instance of the Bool datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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:
|
shape
|
The shape of the tensor. If None, and an array is provided, the shape will be inferred from the shape of the array. |
buffer
|
The buffer of the tensor. If None, and an array is provided, the buffer will be generated from the array.
TYPE:
|
array
|
A numpy array (or The array of the tensor. If None, the array will be inferred from the buffer.
TYPE:
|
dim_names
|
The names of the tensor dimensions. |
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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)
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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:
|
invert
|
Invert the direction of the dimension.
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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:
|
invert
|
Invert the direction of the dimension.
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class Timestamp
Bases: TimeInt, ComponentMixin
Component: When the recording started.
Should be an absolute time, i.e. relative to Unix Epoch.
def __init__(*, seq=None, seconds=None, nanos=None)
Create a new instance of the TimeInt datatype.
Exactly one of seq, seconds, or nanos must be provided.
| PARAMETER | DESCRIPTION |
|---|---|
seq
|
Time as a sequence number.
TYPE:
|
seconds
|
Time in seconds. Interpreted either as a duration or time since unix epoch (depending on timeline type).
TYPE:
|
nanos
|
Time in nanoseconds. Interpreted either as a duration or time since unix epoch (depending on timeline type).
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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),
)
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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class ValueRange
Bases: Range1D, ComponentMixin
Component: Range of expected or valid values, specifying a lower and upper bound.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(range)
Create a new instance of the Range1D datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns 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 arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class VideoCodec
Bases: Enum
Component: The codec used to encode video stored in components.VideoSample.
Support of these codecs by the Rerun Viewer is platform dependent. For more details see check the video reference.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
H264 = 1635148593
class-attribute
instance-attribute
Advanced Video Coding (AVC/H.264)
See https://en.wikipedia.org/wiki/Advanced_Video_Coding
components.VideoSamples using this codec should be formatted according to Annex B specification.
(Note that this is different from AVCC format found in MP4 files.
To learn more about Annex B, check for instance https://membrane.stream/learn/h264/3)
Key frames (IDR) require inclusion of a SPS (Sequence Parameter Set)
Enum value is the fourcc for 'avc1' (the WebCodec string assigned to this codec) in big endian.
H265 = 1751479857
class-attribute
instance-attribute
High Efficiency Video Coding (HEVC/H.265)
See https://en.wikipedia.org/wiki/High_Efficiency_Video_Coding
components.VideoSamples using this codec should be formatted according to Annex B specification.
(Note that this is different from AVCC format found in MP4 files.
To learn more about Annex B, check for instance https://membrane.stream/learn/h264/3)
Key frames (IRAP) require inclusion of a SPS (Sequence Parameter Set)
Enum value is the fourcc for 'hev1' (the WebCodec string assigned to this codec) in big endian.
def __str__()
Returns the variant name.
def auto(val)
classmethod
Best-effort converter, including a case-insensitive string matcher.
class VideoSample
Bases: Blob, ComponentMixin
Component: Video sample data (also known as "video chunk").
Each video sample must contain enough data for exactly one video frame (this restriction may be relaxed in the future for some codecs).
Keyframes may require additional data, for details see components.VideoCodec.
def __init__(data)
Create a new instance of the Blob datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class VideoTimestamp
Bases: VideoTimestampExt, VideoTimestamp, ComponentMixin
Component: Timestamp inside a archetypes.AssetVideo.
def __init__(*, nanoseconds=None, seconds=None)
Create a new instance of the VideoTimestamp component.
| PARAMETER | DESCRIPTION |
|---|---|
nanoseconds
|
Presentation timestamp in nanoseconds.
Mutually exclusive with
TYPE:
|
seconds
|
Presentation timestamp in seconds.
Mutually exclusive with
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
def milliseconds(milliseconds)
staticmethod
Create a video timestamp batch from milliseconds since video start.
| PARAMETER | DESCRIPTION |
|---|---|
milliseconds
|
Timestamp values in milliseconds since video start.
TYPE:
|
def nanoseconds(nanoseconds)
staticmethod
Create a video timestamp batch from nanoseconds since video start.
| PARAMETER | DESCRIPTION |
|---|---|
nanoseconds
|
Timestamp values in nanoseconds since video start.
TYPE:
|
def seconds(seconds)
staticmethod
Create a video timestamp batch from seconds since video start.
| PARAMETER | DESCRIPTION |
|---|---|
seconds
|
Timestamp values in seconds since video start.
TYPE:
|
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?
The three coordinates are always ordered as [x, y, z].
For example [Right, Down, Forward] means that the X axis points to the right, the Y axis points down, and the Z axis points forward.
⚠ Rerun does not yet support left-handed coordinate systems.
The following constants are used to represent the different directions: * Up = 1 * Down = 2 * Right = 3 * Left = 4 * Forward = 5 * Back = 6
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
BDL: ViewCoordinates = None
class-attribute
instance-attribute
X=Back, Y=Down, Z=Left
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
BRD: ViewCoordinates = None
class-attribute
instance-attribute
X=Back, Y=Right, Z=Down
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
DFL: ViewCoordinates = None
class-attribute
instance-attribute
X=Down, Y=Forward, Z=Left
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
FLD: ViewCoordinates = None
class-attribute
instance-attribute
X=Forward, Y=Left, Z=Down
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
FUL: ViewCoordinates = None
class-attribute
instance-attribute
X=Forward, Y=Up, Z=Left
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
LEFT_HAND_X_DOWN: ViewCoordinates = None
class-attribute
instance-attribute
X=Down, Y=Right, Z=Forward
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
LEFT_HAND_X_UP: ViewCoordinates = None
class-attribute
instance-attribute
X=Up, Y=Right, Z=Back
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
LEFT_HAND_Y_DOWN: ViewCoordinates = None
class-attribute
instance-attribute
X=Right, Y=Down, Z=Back
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
LEFT_HAND_Y_UP: ViewCoordinates = None
class-attribute
instance-attribute
X=Right, Y=Up, Z=Forward
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
LEFT_HAND_Z_DOWN: ViewCoordinates = None
class-attribute
instance-attribute
X=Right, Y=Forward, Z=Down
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
LEFT_HAND_Z_UP: ViewCoordinates = None
class-attribute
instance-attribute
X=Right, Y=Back, Z=Up
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
LUB: ViewCoordinates = None
class-attribute
instance-attribute
X=Left, Y=Up, Z=Back
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
RDB: ViewCoordinates = None
class-attribute
instance-attribute
X=Right, Y=Down, Z=Back
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
UBL: ViewCoordinates = None
class-attribute
instance-attribute
X=Up, Y=Back, Z=Left
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
URB: ViewCoordinates = None
class-attribute
instance-attribute
X=Up, Y=Right, Z=Back
⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.
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:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.
class Visible
Bases: Bool, ComponentMixin
Component: Whether the container, view, entity or instance is currently visible.
def __init__(value)
Create a new instance of the Bool datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the ComponentBatchLike logging interface.