#![allow(clippy::too_many_lines)]
#![allow(clippy::wildcard_imports)]
#![allow(unused_imports)]
use re_types::blueprint::components::*;
use re_types::components::*;
use re_types_blueprint::blueprint::components::*;
use re_types_core::components::*;
use re_types_core::{
reflection::{
ArchetypeFieldReflection, ArchetypeReflection, ArchetypeReflectionMap, ComponentReflection,
ComponentReflectionMap, Reflection,
},
ArchetypeName, ComponentName, Loggable, LoggableBatch as _, SerializationError,
};
pub fn generate_reflection() -> Result<Reflection, SerializationError> {
re_tracing::profile_function!();
Ok(Reflection {
components: generate_component_reflection()?,
archetypes: generate_archetype_reflection(),
})
}
fn generate_component_reflection() -> Result<ComponentReflectionMap, SerializationError> {
re_tracing::profile_function!();
let array = [
(
<ActiveTab as Loggable>::name(),
ComponentReflection {
docstring_md: "The active tab in a tabbed container.",
custom_placeholder: Some(ActiveTab::default().to_arrow()?),
datatype: ActiveTab::arrow_datatype(),
},
),
(
<ApplyLatestAt as Loggable>::name(),
ComponentReflection {
docstring_md: "Whether empty cells in a dataframe should be filled with a latest-at query.",
custom_placeholder: Some(ApplyLatestAt::default().to_arrow()?),
datatype: ApplyLatestAt::arrow_datatype(),
},
),
(
<AutoLayout as Loggable>::name(),
ComponentReflection {
docstring_md: "Whether the viewport layout is determined automatically.",
custom_placeholder: Some(AutoLayout::default().to_arrow()?),
datatype: AutoLayout::arrow_datatype(),
},
),
(
<AutoSpaceViews as Loggable>::name(),
ComponentReflection {
docstring_md: "Whether or not space views should be created automatically.",
custom_placeholder: Some(AutoSpaceViews::default().to_arrow()?),
datatype: AutoSpaceViews::arrow_datatype(),
},
),
(
<BackgroundKind as Loggable>::name(),
ComponentReflection {
docstring_md: "The type of the background in a view.",
custom_placeholder: Some(BackgroundKind::default().to_arrow()?),
datatype: BackgroundKind::arrow_datatype(),
},
),
(
<ColumnShare as Loggable>::name(),
ComponentReflection {
docstring_md: "The layout share of a column in the container.",
custom_placeholder: Some(ColumnShare::default().to_arrow()?),
datatype: ColumnShare::arrow_datatype(),
},
),
(
<ComponentColumnSelector as Loggable>::name(),
ComponentReflection {
docstring_md: "Describe a component column to be selected in the dataframe view.",
custom_placeholder: Some(ComponentColumnSelector::default().to_arrow()?),
datatype: ComponentColumnSelector::arrow_datatype(),
},
),
(
<ContainerKind as Loggable>::name(),
ComponentReflection {
docstring_md: "The kind of a blueprint container (tabs, grid, …).",
custom_placeholder: Some(ContainerKind::default().to_arrow()?),
datatype: ContainerKind::arrow_datatype(),
},
),
(
<Corner2D as Loggable>::name(),
ComponentReflection {
docstring_md: "One of four 2D corners, typically used to align objects.",
custom_placeholder: Some(Corner2D::default().to_arrow()?),
datatype: Corner2D::arrow_datatype(),
},
),
(
<FilterByRange as Loggable>::name(),
ComponentReflection {
docstring_md: "Configuration for a filter-by-range feature of the dataframe view.",
custom_placeholder: Some(FilterByRange::default().to_arrow()?),
datatype: FilterByRange::arrow_datatype(),
},
),
(
<FilterIsNotNull as Loggable>::name(),
ComponentReflection {
docstring_md: "Configuration for the filter is not null feature of the dataframe view.",
custom_placeholder: Some(FilterIsNotNull::default().to_arrow()?),
datatype: FilterIsNotNull::arrow_datatype(),
},
),
(
<GridColumns as Loggable>::name(),
ComponentReflection {
docstring_md: "How many columns a grid container should have.",
custom_placeholder: Some(GridColumns::default().to_arrow()?),
datatype: GridColumns::arrow_datatype(),
},
),
(
<IncludedContent as Loggable>::name(),
ComponentReflection {
docstring_md: "All the contents in the container.",
custom_placeholder: Some(IncludedContent::default().to_arrow()?),
datatype: IncludedContent::arrow_datatype(),
},
),
(
<IncludedSpaceView as Loggable>::name(),
ComponentReflection {
docstring_md: "The unique id of a space view, used to refer to views in containers.",
custom_placeholder: Some(IncludedSpaceView::default().to_arrow()?),
datatype: IncludedSpaceView::arrow_datatype(),
},
),
(
<Interactive as Loggable>::name(),
ComponentReflection {
docstring_md: "Whether the entity can be interacted with.\n\nNon interactive components are still visible, but mouse interactions in the view are disabled.",
custom_placeholder: Some(Interactive::default().to_arrow()?),
datatype: Interactive::arrow_datatype(),
},
),
(
<LockRangeDuringZoom as Loggable>::name(),
ComponentReflection {
docstring_md: "Indicate whether the range should be locked when zooming in on the data.\n\nDefault is `false`, i.e. zoom will change the visualized range.",
custom_placeholder: Some(LockRangeDuringZoom::default().to_arrow()?),
datatype: LockRangeDuringZoom::arrow_datatype(),
},
),
(
<MapProvider as Loggable>::name(),
ComponentReflection {
docstring_md: "Name of the map provider to be used in Map views.",
custom_placeholder: Some(MapProvider::default().to_arrow()?),
datatype: MapProvider::arrow_datatype(),
},
),
(
<PanelState as Loggable>::name(),
ComponentReflection {
docstring_md: "Tri-state for panel controls.",
custom_placeholder: Some(PanelState::default().to_arrow()?),
datatype: PanelState::arrow_datatype(),
},
),
(
<QueryExpression as Loggable>::name(),
ComponentReflection {
docstring_md: "An individual query expression used to filter a set of [`datatypes.EntityPath`](https://rerun.io/docs/reference/types/datatypes/entity_path)s.\n\nEach expression is either an inclusion or an exclusion expression.\nInclusions start with an optional `+` and exclusions must start with a `-`.\n\nMultiple expressions are combined together as part of `SpaceViewContents`.\n\nThe `/**` suffix matches the whole subtree, i.e. self and any child, recursively\n(`/world/**` matches both `/world` and `/world/car/driver`).\nOther uses of `*` are not (yet) supported.",
custom_placeholder: Some(QueryExpression::default().to_arrow()?),
datatype: QueryExpression::arrow_datatype(),
},
),
(
<RootContainer as Loggable>::name(),
ComponentReflection {
docstring_md: "The container that sits at the root of a viewport.",
custom_placeholder: Some(RootContainer::default().to_arrow()?),
datatype: RootContainer::arrow_datatype(),
},
),
(
<RowShare as Loggable>::name(),
ComponentReflection {
docstring_md: "The layout share of a row in the container.",
custom_placeholder: Some(RowShare::default().to_arrow()?),
datatype: RowShare::arrow_datatype(),
},
),
(
<SelectedColumns as Loggable>::name(),
ComponentReflection {
docstring_md: "Describe a component column to be selected in the dataframe view.",
custom_placeholder: Some(SelectedColumns::default().to_arrow()?),
datatype: SelectedColumns::arrow_datatype(),
},
),
(
<SpaceViewClass as Loggable>::name(),
ComponentReflection {
docstring_md: "The class identifier of view, e.g. `\"2D\"`, `\"TextLog\"`, ….",
custom_placeholder: Some(SpaceViewClass::default().to_arrow()?),
datatype: SpaceViewClass::arrow_datatype(),
},
),
(
<SpaceViewMaximized as Loggable>::name(),
ComponentReflection {
docstring_md: "Whether a space view is maximized.",
custom_placeholder: Some(SpaceViewMaximized::default().to_arrow()?),
datatype: SpaceViewMaximized::arrow_datatype(),
},
),
(
<SpaceViewOrigin as Loggable>::name(),
ComponentReflection {
docstring_md: "The origin of a `SpaceView`.",
custom_placeholder: Some(SpaceViewOrigin::default().to_arrow()?),
datatype: SpaceViewOrigin::arrow_datatype(),
},
),
(
<TensorDimensionIndexSlider as Loggable>::name(),
ComponentReflection {
docstring_md: "Show a slider for the index of some dimension of a slider.",
custom_placeholder: Some(
TensorDimensionIndexSlider::default().to_arrow()?,
),
datatype: TensorDimensionIndexSlider::arrow_datatype(),
},
),
(
<TimelineName as Loggable>::name(),
ComponentReflection {
docstring_md: "A timeline identified by its name.",
custom_placeholder: Some(TimelineName::default().to_arrow()?),
datatype: TimelineName::arrow_datatype(),
},
),
(
<ViewFit as Loggable>::name(),
ComponentReflection {
docstring_md: "Determines whether an image or texture should be scaled to fit the viewport.",
custom_placeholder: Some(ViewFit::default().to_arrow()?),
datatype: ViewFit::arrow_datatype(),
},
),
(
<ViewerRecommendationHash as Loggable>::name(),
ComponentReflection {
docstring_md: "Hash of a viewer recommendation.\n\nThe formation of this hash is considered an internal implementation detail of the viewer.",
custom_placeholder: Some(
ViewerRecommendationHash::default().to_arrow()?,
),
datatype: ViewerRecommendationHash::arrow_datatype(),
},
),
(
<Visible as Loggable>::name(),
ComponentReflection {
docstring_md: "Whether the container, view, entity or instance is currently visible.",
custom_placeholder: Some(Visible::default().to_arrow()?),
datatype: Visible::arrow_datatype(),
},
),
(
<VisibleTimeRange as Loggable>::name(),
ComponentReflection {
docstring_md: "The range of values on a given timeline that will be included in a view's query.\n\nRefer to `VisibleTimeRanges` archetype for more information.",
custom_placeholder: Some(VisibleTimeRange::default().to_arrow()?),
datatype: VisibleTimeRange::arrow_datatype(),
},
),
(
<VisualBounds2D as Loggable>::name(),
ComponentReflection {
docstring_md: "Visual bounds in 2D space used for `Spatial2DView`.",
custom_placeholder: Some(VisualBounds2D::default().to_arrow()?),
datatype: VisualBounds2D::arrow_datatype(),
},
),
(
<VisualizerOverrides as Loggable>::name(),
ComponentReflection {
docstring_md: "Override the visualizers for an entity.\n\nThis component is a stop-gap mechanism based on the current implementation details\nof the visualizer system. It is not intended to be a long-term solution, but provides\nenough utility to be useful in the short term.\n\nThe long-term solution is likely to be based off: <https://github.com/rerun-io/rerun/issues/6626>\n\nThis can only be used as part of blueprints. It will have no effect if used\nin a regular entity.",
custom_placeholder: Some(VisualizerOverrides::default().to_arrow()?),
datatype: VisualizerOverrides::arrow_datatype(),
},
),
(
<ZoomLevel as Loggable>::name(),
ComponentReflection {
docstring_md: "A zoom level determines how much of the world is visible on a map.",
custom_placeholder: Some(ZoomLevel::default().to_arrow()?),
datatype: ZoomLevel::arrow_datatype(),
},
),
(
<AggregationPolicy as Loggable>::name(),
ComponentReflection {
docstring_md: "Policy for aggregation of multiple scalar plot values.\n\nThis is used for lines in plots when the X axis distance of individual points goes below a single pixel,\ni.e. a single pixel covers more than one tick worth of data. It can greatly improve performance\n(and readability) in such situations as it prevents overdraw.",
custom_placeholder: Some(AggregationPolicy::default().to_arrow()?),
datatype: AggregationPolicy::arrow_datatype(),
},
),
(
<AlbedoFactor as Loggable>::name(),
ComponentReflection {
docstring_md: "A color multiplier, usually applied to a whole entity, e.g. a mesh.",
custom_placeholder: Some(AlbedoFactor::default().to_arrow()?),
datatype: AlbedoFactor::arrow_datatype(),
},
),
(
<AnnotationContext as Loggable>::name(),
ComponentReflection {
docstring_md: "The annotation context provides additional information on how to display entities.\n\nEntities can use [`datatypes.ClassId`](https://rerun.io/docs/reference/types/datatypes/class_id)s and [`datatypes.KeypointId`](https://rerun.io/docs/reference/types/datatypes/keypoint_id)s to provide annotations, and\nthe labels and colors will be looked up in the appropriate\nannotation context. We use the *first* annotation context we find in the\npath-hierarchy when searching up through the ancestors of a given entity\npath.",
custom_placeholder: Some(AnnotationContext::default().to_arrow()?),
datatype: AnnotationContext::arrow_datatype(),
},
),
(
<AxisLength as Loggable>::name(),
ComponentReflection {
docstring_md: "The length of an axis in local units of the space.",
custom_placeholder: Some(AxisLength::default().to_arrow()?),
datatype: AxisLength::arrow_datatype(),
},
),
(
<Blob as Loggable>::name(),
ComponentReflection {
docstring_md: "A binary blob of data.",
custom_placeholder: None,
datatype: Blob::arrow_datatype(),
},
),
(
<ClassId as Loggable>::name(),
ComponentReflection {
docstring_md: "A 16-bit ID representing a type of semantic class.",
custom_placeholder: Some(ClassId::default().to_arrow()?),
datatype: ClassId::arrow_datatype(),
},
),
(
<ClearIsRecursive as Loggable>::name(),
ComponentReflection {
docstring_md: "Configures how a clear operation should behave - recursive or not.",
custom_placeholder: Some(ClearIsRecursive::default().to_arrow()?),
datatype: ClearIsRecursive::arrow_datatype(),
},
),
(
<Color as Loggable>::name(),
ComponentReflection {
docstring_md: "An RGBA color with unmultiplied/separate alpha, in sRGB gamma space with linear alpha.\n\nThe color is stored as a 32-bit integer, where the most significant\nbyte is `R` and the least significant byte is `A`.",
custom_placeholder: Some(Color::default().to_arrow()?),
datatype: Color::arrow_datatype(),
},
),
(
<Colormap as Loggable>::name(),
ComponentReflection {
docstring_md: "Colormap for mapping scalar values within a given range to a color.\n\nThis provides a number of popular pre-defined colormaps.\nIn the future, the Rerun Viewer will allow users to define their own colormaps,\nbut currently the Viewer is limited to the types defined here.",
custom_placeholder: Some(Colormap::default().to_arrow()?),
datatype: Colormap::arrow_datatype(),
},
),
(
<DepthMeter as Loggable>::name(),
ComponentReflection {
docstring_md: "The world->depth map scaling factor.\n\nThis measures how many depth map units are in a world unit.\nFor instance, if a depth map uses millimeters and the world uses meters,\nthis value would be `1000`.\n\nNote that the only effect on 2D views is the physical depth values shown when hovering the image.\nIn 3D views on the other hand, this affects where the points of the point cloud are placed.",
custom_placeholder: Some(DepthMeter::default().to_arrow()?),
datatype: DepthMeter::arrow_datatype(),
},
),
(
<DisconnectedSpace as Loggable>::name(),
ComponentReflection {
docstring_md: "Spatially disconnect this entity from its parent.\n\nSpecifies that the entity path at which this is logged is spatially disconnected from its parent,\nmaking it impossible to transform the entity path into its parent's space and vice versa.\nIt *only* applies to space views that work with spatial transformations, i.e. 2D & 3D space views.\nThis is useful for specifying that a subgraph is independent of the rest of the scene.",
custom_placeholder: Some(DisconnectedSpace::default().to_arrow()?),
datatype: DisconnectedSpace::arrow_datatype(),
},
),
(
<DrawOrder as Loggable>::name(),
ComponentReflection {
docstring_md: "Draw order of 2D elements. Higher values are drawn on top of lower values.\n\nAn entity can have only a single draw order component.\nWithin an entity draw order is governed by the order of the components.\n\nDraw order for entities with the same draw order is generally undefined.",
custom_placeholder: Some(DrawOrder::default().to_arrow()?),
datatype: DrawOrder::arrow_datatype(),
},
),
(
<EntityPath as Loggable>::name(),
ComponentReflection {
docstring_md: "A path to an entity, usually to reference some data that is part of the target entity.",
custom_placeholder: Some(EntityPath::default().to_arrow()?),
datatype: EntityPath::arrow_datatype(),
},
),
(
<FillMode as Loggable>::name(),
ComponentReflection {
docstring_md: "How a geometric shape is drawn and colored.",
custom_placeholder: Some(FillMode::default().to_arrow()?),
datatype: FillMode::arrow_datatype(),
},
),
(
<FillRatio as Loggable>::name(),
ComponentReflection {
docstring_md: "How much a primitive fills out the available space.\n\nUsed for instance to scale the points of the point cloud created from [`archetypes.DepthImage`](https://rerun.io/docs/reference/types/archetypes/depth_image) projection in 3D views.\nValid range is from 0 to max float although typically values above 1.0 are not useful.\n\nDefaults to 1.0.",
custom_placeholder: Some(FillRatio::default().to_arrow()?),
datatype: FillRatio::arrow_datatype(),
},
),
(
<GammaCorrection as Loggable>::name(),
ComponentReflection {
docstring_md: "A gamma correction value to be used with a scalar value or color.\n\nUsed to adjust the gamma of a color or scalar value between 0 and 1 before rendering.\n`new_value = old_value ^ gamma`\n\nValid range is from 0 (excluding) to max float.\nDefaults to 1.0 unless otherwise specified.",
custom_placeholder: Some(GammaCorrection::default().to_arrow()?),
datatype: GammaCorrection::arrow_datatype(),
},
),
(
<GeoLineString as Loggable>::name(),
ComponentReflection {
docstring_md: "A geospatial line string expressed in [EPSG:4326](https://epsg.io/4326) latitude and longitude (North/East-positive degrees).",
custom_placeholder: Some(GeoLineString::default().to_arrow()?),
datatype: GeoLineString::arrow_datatype(),
},
),
(
<HalfSize2D as Loggable>::name(),
ComponentReflection {
docstring_md: "Half-size (radius) of a 2D box.\n\nMeasured in its local coordinate system.\n\nThe box extends both in negative and positive direction along each axis.\nNegative sizes indicate that the box is flipped along the respective axis, but this has no effect on how it is displayed.",
custom_placeholder: Some(HalfSize2D::default().to_arrow()?),
datatype: HalfSize2D::arrow_datatype(),
},
),
(
<HalfSize3D as Loggable>::name(),
ComponentReflection {
docstring_md: "Half-size (radius) of a 3D box.\n\nMeasured in its local coordinate system.\n\nThe box extends both in negative and positive direction along each axis.\nNegative sizes indicate that the box is flipped along the respective axis, but this has no effect on how it is displayed.",
custom_placeholder: Some(HalfSize3D::default().to_arrow()?),
datatype: HalfSize3D::arrow_datatype(),
},
),
(
<ImageBuffer as Loggable>::name(),
ComponentReflection {
docstring_md: "A buffer that is known to store image data.\n\nTo interpret the contents of this buffer, see, [`components.ImageFormat`](https://rerun.io/docs/reference/types/components/image_format).",
custom_placeholder: None,
datatype: ImageBuffer::arrow_datatype(),
},
),
(
<ImageFormat as Loggable>::name(),
ComponentReflection {
docstring_md: "The metadata describing the contents of a [`components.ImageBuffer`](https://rerun.io/docs/reference/types/components/image_buffer).",
custom_placeholder: Some(ImageFormat::default().to_arrow()?),
datatype: ImageFormat::arrow_datatype(),
},
),
(
<ImagePlaneDistance as Loggable>::name(),
ComponentReflection {
docstring_md: "The distance from the camera origin to the image plane when the projection is shown in a 3D viewer.\n\nThis is only used for visualization purposes, and does not affect the projection itself.",
custom_placeholder: Some(ImagePlaneDistance::default().to_arrow()?),
datatype: ImagePlaneDistance::arrow_datatype(),
},
),
(
<KeypointId as Loggable>::name(),
ComponentReflection {
docstring_md: "A 16-bit ID representing a type of semantic keypoint within a class.",
custom_placeholder: Some(KeypointId::default().to_arrow()?),
datatype: KeypointId::arrow_datatype(),
},
),
(
<LatLon as Loggable>::name(),
ComponentReflection {
docstring_md: "A geospatial position expressed in [EPSG:4326](https://epsg.io/4326) latitude and longitude (North/East-positive degrees).",
custom_placeholder: Some(LatLon::default().to_arrow()?),
datatype: LatLon::arrow_datatype(),
},
),
(
<Length as Loggable>::name(),
ComponentReflection {
docstring_md: "Length, or one-dimensional size.\n\nMeasured in its local coordinate system; consult the archetype in use to determine which\naxis or part of the entity this is the length of.",
custom_placeholder: Some(Length::default().to_arrow()?),
datatype: Length::arrow_datatype(),
},
),
(
<LineStrip2D as Loggable>::name(),
ComponentReflection {
docstring_md: "A line strip in 2D space.\n\nA line strip is a list of points connected by line segments. It can be used to draw\napproximations of smooth curves.\n\nThe points will be connected in order, like so:\n```text\n 2------3 5\n / \\ /\n0----1 \\ /\n 4\n```",
custom_placeholder: Some(LineStrip2D::default().to_arrow()?),
datatype: LineStrip2D::arrow_datatype(),
},
),
(
<LineStrip3D as Loggable>::name(),
ComponentReflection {
docstring_md: "A line strip in 3D space.\n\nA line strip is a list of points connected by line segments. It can be used to draw\napproximations of smooth curves.\n\nThe points will be connected in order, like so:\n```text\n 2------3 5\n / \\ /\n0----1 \\ /\n 4\n```",
custom_placeholder: Some(LineStrip3D::default().to_arrow()?),
datatype: LineStrip3D::arrow_datatype(),
},
),
(
<MagnificationFilter as Loggable>::name(),
ComponentReflection {
docstring_md: "Filter used when magnifying an image/texture such that a single pixel/texel is displayed as multiple pixels on screen.",
custom_placeholder: Some(MagnificationFilter::default().to_arrow()?),
datatype: MagnificationFilter::arrow_datatype(),
},
),
(
<MarkerShape as Loggable>::name(),
ComponentReflection {
docstring_md: "The visual appearance of a point in e.g. a 2D plot.",
custom_placeholder: Some(MarkerShape::default().to_arrow()?),
datatype: MarkerShape::arrow_datatype(),
},
),
(
<MarkerSize as Loggable>::name(),
ComponentReflection {
docstring_md: "Radius of a marker of a point in e.g. a 2D plot, measured in UI points.",
custom_placeholder: Some(MarkerSize::default().to_arrow()?),
datatype: MarkerSize::arrow_datatype(),
},
),
(
<MediaType as Loggable>::name(),
ComponentReflection {
docstring_md: "A standardized media type (RFC2046, formerly known as MIME types), encoded as a string.\n\nThe complete reference of officially registered media types is maintained by the IANA and can be\nconsulted at <https://www.iana.org/assignments/media-types/media-types.xhtml>.",
custom_placeholder: Some(MediaType::default().to_arrow()?),
datatype: MediaType::arrow_datatype(),
},
),
(
<Name as Loggable>::name(),
ComponentReflection {
docstring_md: "A display name, typically for an entity or a item like a plot series.",
custom_placeholder: Some(Name::default().to_arrow()?),
datatype: Name::arrow_datatype(),
},
),
(
<Opacity as Loggable>::name(),
ComponentReflection {
docstring_md: "Degree of transparency ranging from 0.0 (fully transparent) to 1.0 (fully opaque).\n\nThe final opacity value may be a result of multiplication with alpha values as specified by other color sources.\nUnless otherwise specified, the default value is 1.",
custom_placeholder: Some(Opacity::default().to_arrow()?),
datatype: Opacity::arrow_datatype(),
},
),
(
<PinholeProjection as Loggable>::name(),
ComponentReflection {
docstring_md: "Camera projection, from image coordinates to view coordinates.\n\nChild from parent.\nImage coordinates from camera view coordinates.\n\nExample:\n```text\n1496.1 0.0 980.5\n 0.0 1496.1 744.5\n 0.0 0.0 1.0\n```",
custom_placeholder: Some(PinholeProjection::default().to_arrow()?),
datatype: PinholeProjection::arrow_datatype(),
},
),
(
<PoseRotationAxisAngle as Loggable>::name(),
ComponentReflection {
docstring_md: "3D rotation represented by a rotation around a given axis that doesn't propagate in the transform hierarchy.",
custom_placeholder: Some(PoseRotationAxisAngle::default().to_arrow()?),
datatype: PoseRotationAxisAngle::arrow_datatype(),
},
),
(
<PoseRotationQuat as Loggable>::name(),
ComponentReflection {
docstring_md: "A 3D rotation expressed as a quaternion that doesn't propagate in the transform hierarchy.\n\nNote: although the x,y,z,w components of the quaternion will be passed through to the\ndatastore as provided, when used in the Viewer, quaternions will always be normalized.",
custom_placeholder: Some(PoseRotationQuat::default().to_arrow()?),
datatype: PoseRotationQuat::arrow_datatype(),
},
),
(
<PoseScale3D as Loggable>::name(),
ComponentReflection {
docstring_md: "A 3D scale factor that doesn't propagate in the transform hierarchy.\n\nA scale of 1.0 means no scaling.\nA scale of 2.0 means doubling the size.\nEach component scales along the corresponding axis.",
custom_placeholder: Some(PoseScale3D::default().to_arrow()?),
datatype: PoseScale3D::arrow_datatype(),
},
),
(
<PoseTransformMat3x3 as Loggable>::name(),
ComponentReflection {
docstring_md: "A 3x3 transformation matrix Matrix that doesn't propagate in the transform hierarchy.\n\n3x3 matrixes are able to represent any affine transformation in 3D space,\ni.e. rotation, scaling, shearing, reflection etc.\n\nMatrices in Rerun are stored as flat list of coefficients in column-major order:\n```text\n column 0 column 1 column 2\n -------------------------------------------------\nrow 0 | flat_columns[0] flat_columns[3] flat_columns[6]\nrow 1 | flat_columns[1] flat_columns[4] flat_columns[7]\nrow 2 | flat_columns[2] flat_columns[5] flat_columns[8]\n```",
custom_placeholder: Some(PoseTransformMat3x3::default().to_arrow()?),
datatype: PoseTransformMat3x3::arrow_datatype(),
},
),
(
<PoseTranslation3D as Loggable>::name(),
ComponentReflection {
docstring_md: "A translation vector in 3D space that doesn't propagate in the transform hierarchy.",
custom_placeholder: Some(PoseTranslation3D::default().to_arrow()?),
datatype: PoseTranslation3D::arrow_datatype(),
},
),
(
<Position2D as Loggable>::name(),
ComponentReflection {
docstring_md: "A position in 2D space.",
custom_placeholder: Some(Position2D::default().to_arrow()?),
datatype: Position2D::arrow_datatype(),
},
),
(
<Position3D as Loggable>::name(),
ComponentReflection {
docstring_md: "A position in 3D space.",
custom_placeholder: Some(Position3D::default().to_arrow()?),
datatype: Position3D::arrow_datatype(),
},
),
(
<Radius as Loggable>::name(),
ComponentReflection {
docstring_md: "The radius of something, e.g. a point.\n\nInternally, positive values indicate scene units, whereas negative values\nare interpreted as UI points.\n\nUI points are independent of zooming in Views, but are sensitive to the application UI scaling.\nat 100% UI scaling, UI points are equal to pixels\nThe Viewer's UI scaling defaults to the OS scaling which typically is 100% for full HD screens and 200% for 4k screens.",
custom_placeholder: Some(Radius::default().to_arrow()?),
datatype: Radius::arrow_datatype(),
},
),
(
<Range1D as Loggable>::name(),
ComponentReflection {
docstring_md: "A 1D range, specifying a lower and upper bound.",
custom_placeholder: Some(Range1D::default().to_arrow()?),
datatype: Range1D::arrow_datatype(),
},
),
(
<Resolution as Loggable>::name(),
ComponentReflection {
docstring_md: "Pixel resolution width & height, e.g. of a camera sensor.\n\nTypically in integer units, but for some use cases floating point may be used.",
custom_placeholder: Some(Resolution::default().to_arrow()?),
datatype: Resolution::arrow_datatype(),
},
),
(
<RotationAxisAngle as Loggable>::name(),
ComponentReflection {
docstring_md: "3D rotation represented by a rotation around a given axis.",
custom_placeholder: Some(RotationAxisAngle::default().to_arrow()?),
datatype: RotationAxisAngle::arrow_datatype(),
},
),
(
<RotationQuat as Loggable>::name(),
ComponentReflection {
docstring_md: "A 3D rotation expressed as a quaternion.\n\nNote: although the x,y,z,w components of the quaternion will be passed through to the\ndatastore as provided, when used in the Viewer, quaternions will always be normalized.",
custom_placeholder: Some(RotationQuat::default().to_arrow()?),
datatype: RotationQuat::arrow_datatype(),
},
),
(
<Scalar as Loggable>::name(),
ComponentReflection {
docstring_md: "A scalar value, encoded as a 64-bit floating point.\n\nUsed for time series plots.",
custom_placeholder: Some(Scalar::default().to_arrow()?),
datatype: Scalar::arrow_datatype(),
},
),
(
<Scale3D as Loggable>::name(),
ComponentReflection {
docstring_md: "A 3D scale factor.\n\nA scale of 1.0 means no scaling.\nA scale of 2.0 means doubling the size.\nEach component scales along the corresponding axis.",
custom_placeholder: Some(Scale3D::default().to_arrow()?),
datatype: Scale3D::arrow_datatype(),
},
),
(
<ShowLabels as Loggable>::name(),
ComponentReflection {
docstring_md: "Whether the entity's [`components.Text`](https://rerun.io/docs/reference/types/components/text) label is shown.\n\nThe main purpose of this component existing separately from the labels themselves\nis to be overridden when desired, to allow hiding and showing from the viewer and\nblueprints.",
custom_placeholder: None,
datatype: ShowLabels::arrow_datatype(),
},
),
(
<StrokeWidth as Loggable>::name(),
ComponentReflection {
docstring_md: "The width of a stroke specified in UI points.",
custom_placeholder: Some(StrokeWidth::default().to_arrow()?),
datatype: StrokeWidth::arrow_datatype(),
},
),
(
<TensorData as Loggable>::name(),
ComponentReflection {
docstring_md: "An N-dimensional array of numbers.\n\nThe number of dimensions and their respective lengths is specified by the `shape` field.\nThe dimensions are ordered from outermost to innermost. For example, in the common case of\na 2D RGB Image, the shape would be `[height, width, channel]`.\n\nThese dimensions are combined with an index to look up values from the `buffer` field,\nwhich stores a contiguous array of typed values.",
custom_placeholder: Some(TensorData::default().to_arrow()?),
datatype: TensorData::arrow_datatype(),
},
),
(
<TensorDimensionIndexSelection as Loggable>::name(),
ComponentReflection {
docstring_md: "Specifies a concrete index on a tensor dimension.",
custom_placeholder: Some(
TensorDimensionIndexSelection::default().to_arrow()?,
),
datatype: TensorDimensionIndexSelection::arrow_datatype(),
},
),
(
<TensorHeightDimension as Loggable>::name(),
ComponentReflection {
docstring_md: "Specifies which dimension to use for height.",
custom_placeholder: Some(TensorHeightDimension::default().to_arrow()?),
datatype: TensorHeightDimension::arrow_datatype(),
},
),
(
<TensorWidthDimension as Loggable>::name(),
ComponentReflection {
docstring_md: "Specifies which dimension to use for width.",
custom_placeholder: Some(TensorWidthDimension::default().to_arrow()?),
datatype: TensorWidthDimension::arrow_datatype(),
},
),
(
<Texcoord2D as Loggable>::name(),
ComponentReflection {
docstring_md: "A 2D texture UV coordinate.\n\nTexture coordinates specify a position on a 2D texture.\nA range from 0-1 covers the entire texture in the respective dimension.\nUnless configured otherwise, the texture repeats outside of this range.\nRerun uses top-left as the origin for UV coordinates.\n\n 0 U 1\n0 + --------- →\n | .\nV | .\n | .\n1 ↓ . . . . . .\n\nThis is the same convention as in Vulkan/Metal/DX12/WebGPU, but (!) unlike OpenGL,\nwhich places the origin at the bottom-left.",
custom_placeholder: Some(Texcoord2D::default().to_arrow()?),
datatype: Texcoord2D::arrow_datatype(),
},
),
(
<Text as Loggable>::name(),
ComponentReflection {
docstring_md: "A string of text, e.g. for labels and text documents.",
custom_placeholder: Some(Text::default().to_arrow()?),
datatype: Text::arrow_datatype(),
},
),
(
<TextLogLevel as Loggable>::name(),
ComponentReflection {
docstring_md: "The severity level of a text log message.\n\nRecommended to be one of:\n* `\"CRITICAL\"`\n* `\"ERROR\"`\n* `\"WARN\"`\n* `\"INFO\"`\n* `\"DEBUG\"`\n* `\"TRACE\"`",
custom_placeholder: Some(TextLogLevel::default().to_arrow()?),
datatype: TextLogLevel::arrow_datatype(),
},
),
(
<TransformMat3x3 as Loggable>::name(),
ComponentReflection {
docstring_md: "A 3x3 transformation matrix Matrix.\n\n3x3 matrixes are able to represent any affine transformation in 3D space,\ni.e. rotation, scaling, shearing, reflection etc.\n\nMatrices in Rerun are stored as flat list of coefficients in column-major order:\n```text\n column 0 column 1 column 2\n -------------------------------------------------\nrow 0 | flat_columns[0] flat_columns[3] flat_columns[6]\nrow 1 | flat_columns[1] flat_columns[4] flat_columns[7]\nrow 2 | flat_columns[2] flat_columns[5] flat_columns[8]\n```",
custom_placeholder: Some(TransformMat3x3::default().to_arrow()?),
datatype: TransformMat3x3::arrow_datatype(),
},
),
(
<TransformRelation as Loggable>::name(),
ComponentReflection {
docstring_md: "Specifies relation a spatial transform describes.",
custom_placeholder: Some(TransformRelation::default().to_arrow()?),
datatype: TransformRelation::arrow_datatype(),
},
),
(
<Translation3D as Loggable>::name(),
ComponentReflection {
docstring_md: "A translation vector in 3D space.",
custom_placeholder: Some(Translation3D::default().to_arrow()?),
datatype: Translation3D::arrow_datatype(),
},
),
(
<TriangleIndices as Loggable>::name(),
ComponentReflection {
docstring_md: "The three indices of a triangle in a triangle mesh.",
custom_placeholder: Some(TriangleIndices::default().to_arrow()?),
datatype: TriangleIndices::arrow_datatype(),
},
),
(
<ValueRange as Loggable>::name(),
ComponentReflection {
docstring_md: "Range of expected or valid values, specifying a lower and upper bound.",
custom_placeholder: Some(ValueRange::default().to_arrow()?),
datatype: ValueRange::arrow_datatype(),
},
),
(
<Vector2D as Loggable>::name(),
ComponentReflection {
docstring_md: "A vector in 2D space.",
custom_placeholder: Some(Vector2D::default().to_arrow()?),
datatype: Vector2D::arrow_datatype(),
},
),
(
<Vector3D as Loggable>::name(),
ComponentReflection {
docstring_md: "A vector in 3D space.",
custom_placeholder: Some(Vector3D::default().to_arrow()?),
datatype: Vector3D::arrow_datatype(),
},
),
(
<VideoTimestamp as Loggable>::name(),
ComponentReflection {
docstring_md: "Timestamp inside a [`archetypes.AssetVideo`](https://rerun.io/docs/reference/types/archetypes/asset_video).",
custom_placeholder: Some(VideoTimestamp::default().to_arrow()?),
datatype: VideoTimestamp::arrow_datatype(),
},
),
(
<ViewCoordinates as Loggable>::name(),
ComponentReflection {
docstring_md: "How we interpret the coordinate system of an entity/space.\n\nFor instance: What is \"up\"? What does the Z axis mean?\n\nThe three coordinates are always ordered as [x, y, z].\n\nFor example [Right, Down, Forward] means that the X axis points to the right, the Y axis points\ndown, and the Z axis points forward.\n\n⚠ [Rerun does not yet support left-handed coordinate systems](https://github.com/rerun-io/rerun/issues/5032).\n\nThe following constants are used to represent the different directions:\n * Up = 1\n * Down = 2\n * Right = 3\n * Left = 4\n * Forward = 5\n * Back = 6",
custom_placeholder: Some(ViewCoordinates::default().to_arrow()?),
datatype: ViewCoordinates::arrow_datatype(),
},
),
];
Ok(ComponentReflectionMap::from_iter(array))
}
fn generate_archetype_reflection() -> ArchetypeReflectionMap {
re_tracing::profile_function!();
let array = [
(
ArchetypeName::new("rerun.archetypes.AnnotationContext"),
ArchetypeReflection {
display_name: "Annotation context",
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.AnnotationContext".into(), display_name :
"Context", docstring_md :
"List of class descriptions, mapping class indices to class names, colors etc.",
is_required : true, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Arrows2D"),
ArchetypeReflection {
display_name: "Arrows 2D",
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Arrows3D"),
ArchetypeReflection {
display_name: "Arrows 3D",
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Asset3D"),
ArchetypeReflection {
display_name: "Asset 3D",
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec (if specified).",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.AssetVideo"),
ArchetypeReflection {
display_name: "Asset video",
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { component_name : "rerun.components.Blob"
.into(), display_name : "Blob", docstring_md : "The asset's bytes.",
is_required : true, }, ArchetypeFieldReflection { component_name :
"rerun.components.MediaType".into(), display_name : "Media type",
docstring_md :
"The Media Type of the asset.\n\nSupported values:\n* `video/mp4`\n\nIf omitted, the viewer will try to guess from the data blob.\nIf it cannot guess, it won't be able to render the asset.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.BarChart"),
ArchetypeReflection {
display_name: "Bar chart",
view_types: &["BarChartView"],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.TensorData".into(), display_name : "Values",
docstring_md :
"The values. Should always be a 1-dimensional tensor (i.e. a vector).",
is_required : true, }, ArchetypeFieldReflection { component_name :
"rerun.components.Color".into(), display_name : "Color", docstring_md
: "The color of the bar chart", is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Boxes2D"),
ArchetypeReflection {
display_name: "Boxes 2D",
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vecs for the boxes.\n\nThe [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Boxes3D"),
ArchetypeReflection {
display_name: "Boxes 3D",
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.PoseRotationAxisAngle".into(), display_name :
"Rotation axis angles", docstring_md :
"Rotations via axis + angle.\n\nIf no rotation is specified, the axes of the boxes align with the axes of the local coordinate system.\nNote that this uses a [`components.PoseRotationAxisAngle`](https://rerun.io/docs/reference/types/components/pose_rotation_axis_angle) which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.PoseRotationQuat".into(), display_name :
"Quaternions", docstring_md :
"Rotations via quaternion.\n\nIf no rotation is specified, the axes of the boxes align with the axes of the local coordinate system.\nNote that this uses a [`components.PoseRotationQuat`](https://rerun.io/docs/reference/types/components/pose_rotation_quat) which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Color".into(), display_name : "Colors",
docstring_md : "Optional colors for the boxes.", is_required : false,
}, ArchetypeFieldReflection { component_name :
"rerun.components.Radius".into(), display_name : "Radii",
docstring_md :
"Optional radii for the lines that make up the boxes.", is_required :
false, }, ArchetypeFieldReflection { component_name :
"rerun.components.FillMode".into(), display_name : "Fill mode",
docstring_md :
"Optionally choose whether the boxes are drawn with lines or solid.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Text".into(), display_name : "Labels", docstring_md
:
"Optional text labels for the boxes.\n\nIf there's a single label present, it will be placed at the center of the entity.\nOtherwise, each instance will have its own label.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.ShowLabels".into(), display_name : "Show labels",
docstring_md :
"Optional choice of whether the text labels should be shown by default.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.ClassId".into(), display_name : "Class ids",
docstring_md :
"Optional [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id)s for the boxes.\n\nThe [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Capsules3D"),
ArchetypeReflection {
display_name: "Capsules 3D",
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.PoseRotationAxisAngle".into(), display_name :
"Rotation axis angles", docstring_md :
"Rotations via axis + angle.\n\nIf no rotation is specified, the capsules align with the +Z axis of the local coordinate system.\nNote that this uses a [`components.PoseRotationAxisAngle`](https://rerun.io/docs/reference/types/components/pose_rotation_axis_angle) which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.PoseRotationQuat".into(), display_name :
"Quaternions", docstring_md :
"Rotations via quaternion.\n\nIf no rotation is specified, the capsules align with the +Z axis of the local coordinate system.\nNote that this uses a [`components.PoseRotationQuat`](https://rerun.io/docs/reference/types/components/pose_rotation_quat) which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Color".into(), display_name : "Colors",
docstring_md : "Optional colors for the capsules.", is_required :
false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Text".into(), display_name : "Labels", docstring_md
:
"Optional text labels for the capsules, which will be located at their centers.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.ShowLabels".into(), display_name : "Show labels",
docstring_md :
"Optional choice of whether the text labels should be shown by default.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.ClassId".into(), display_name : "Class ids",
docstring_md :
"Optional class ID for the ellipsoids.\n\nThe class ID provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Clear"),
ArchetypeReflection {
display_name: "Clear",
view_types: &["Spatial2DView", "Spatial3DView", "TimeSeriesView"],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.ClearIsRecursive".into(), display_name :
"Is recursive", docstring_md : "", is_required : true, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.DepthImage"),
ArchetypeReflection {
display_name: "Depth image",
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.ImageBuffer".into(), display_name : "Buffer",
docstring_md : "The raw depth image data.", is_required : true, },
ArchetypeFieldReflection { component_name :
"rerun.components.ImageFormat".into(), display_name : "Format",
docstring_md : "The format of the image.", is_required : true, },
ArchetypeFieldReflection { component_name :
"rerun.components.DepthMeter".into(), display_name : "Meter",
docstring_md :
"An optional floating point value that specifies how long a meter is in the native depth units.\n\nFor instance: with uint16, perhaps meter=1000 which would mean you have millimeter precision\nand a range of up to ~65 meters (2^16 / 1000).\n\nNote that the only effect on 2D views is the physical depth values shown when hovering the image.\nIn 3D views on the other hand, this affects where the points of the point cloud are placed.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Colormap".into(), display_name : "Colormap",
docstring_md :
"Colormap to use for rendering the depth image.\n\nIf not set, the depth image will be rendered using the Turbo colormap.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.ValueRange".into(), display_name : "Depth range",
docstring_md :
"The expected range of depth values.\n\nThis is typically the expected range of valid values.\nEverything outside of the range is clamped to the range for the purpose of colormpaping.\nNote that point clouds generated from this image will still display all points, regardless of this range.\n\nIf not specified, the range will be automatically estimated from the data.\nNote that the Viewer may try to guess a wider range than the minimum/maximum of values\nin the contents of the depth image.\nE.g. if all values are positive, some bigger than 1.0 and all smaller than 255.0,\nthe Viewer will guess that the data likely came from an 8bit image, thus assuming a range of 0-255.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.FillRatio".into(), display_name :
"Point fill ratio", docstring_md :
"Scale the radii of the points in the point cloud generated from this image.\n\nA fill ratio of 1.0 (the default) means that each point is as big as to touch the center of its neighbor\nif it is at the same depth, leaving no gaps.\nA fill ratio of 0.5 means that each point touches the edge of its neighbor if it has the same depth.\n\nTODO(#6744): This applies only to 3D views!",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.DrawOrder".into(), display_name : "Draw order",
docstring_md :
"An optional floating point value that specifies the 2D drawing order, used only if the depth image is shown as a 2D image.\n\nObjects with higher values are drawn on top of those with lower values.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.DisconnectedSpace"),
ArchetypeReflection {
display_name: "Disconnected space",
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.DisconnectedSpace".into(), display_name :
"Disconnected space", docstring_md :
"Whether the entity path at which this is logged is disconnected from its parent.",
is_required : true, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Ellipsoids3D"),
ArchetypeReflection {
display_name: "Ellipsoids 3D",
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.PoseRotationAxisAngle".into(), display_name :
"Rotation axis angles", docstring_md :
"Rotations via axis + angle.\n\nIf no rotation is specified, the axes of the ellipsoid align with the axes of the local coordinate system.\nNote that this uses a [`components.PoseRotationAxisAngle`](https://rerun.io/docs/reference/types/components/pose_rotation_axis_angle) which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.PoseRotationQuat".into(), display_name :
"Quaternions", docstring_md :
"Rotations via quaternion.\n\nIf no rotation is specified, the axes of the ellipsoid align with the axes of the local coordinate system.\nNote that this uses a [`components.PoseRotationQuat`](https://rerun.io/docs/reference/types/components/pose_rotation_quat) which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Color".into(), display_name : "Colors",
docstring_md : "Optional colors for the ellipsoids.", is_required :
false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Radius".into(), display_name : "Line radii",
docstring_md :
"Optional radii for the lines used when the ellipsoid is rendered as a wireframe.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.FillMode".into(), display_name : "Fill mode",
docstring_md :
"Optionally choose whether the ellipsoids are drawn with lines or solid.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Text".into(), display_name : "Labels", docstring_md
: "Optional text labels for the ellipsoids.", is_required : false, },
ArchetypeFieldReflection { component_name :
"rerun.components.ShowLabels".into(), display_name : "Show labels",
docstring_md :
"Optional choice of whether the text labels should be shown by default.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.ClassId".into(), display_name : "Class ids",
docstring_md :
"Optional class ID for the ellipsoids.\n\nThe class ID provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.EncodedImage"),
ArchetypeReflection {
display_name: "Encoded image",
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { component_name : "rerun.components.Blob"
.into(), display_name : "Blob", docstring_md :
"The encoded content of some image file, e.g. a PNG or JPEG.",
is_required : true, }, ArchetypeFieldReflection { component_name :
"rerun.components.MediaType".into(), display_name : "Media type",
docstring_md :
"The Media Type of the asset.\n\nSupported values:\n* `image/jpeg`\n* `image/png`\n\nIf omitted, the viewer will try to guess from the data blob.\nIf it cannot guess, it won't be able to render the asset.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Opacity".into(), display_name : "Opacity",
docstring_md :
"Opacity of the image, useful for layering several images.\n\nDefaults to 1.0 (fully opaque).",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.DrawOrder".into(), display_name : "Draw order",
docstring_md :
"An optional floating point value that specifies the 2D drawing order.\n\nObjects with higher values are drawn on top of those with lower values.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.GeoLineStrings"),
ArchetypeReflection {
display_name: "Geo line strings",
view_types: &["MapView"],
fields: vec coordinates (North/East-positive degrees).",
is_required : true, }, ArchetypeFieldReflection { component_name :
"rerun.components.Radius".into(), display_name : "Radii",
docstring_md :
"Optional radii for the line strings.\n\n*Note*: scene units radiii are interpreted as meters. Currently, the display scale only considers the latitude of\nthe first vertex of each line string (see [this issue](https://github.com/rerun-io/rerun/issues/8013)).",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Color".into(), display_name : "Colors",
docstring_md : "Optional colors for the line strings.", is_required :
false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.GeoPoints"),
ArchetypeReflection {
display_name: "Geo points",
view_types: &["MapView"],
fields: vec coordinates for the points (North/East-positive degrees).",
is_required : true, }, ArchetypeFieldReflection { component_name :
"rerun.components.Radius".into(), display_name : "Radii",
docstring_md :
"Optional radii for the points, effectively turning them into circles.\n\n*Note*: scene units radiii are interpreted as meters.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Color".into(), display_name : "Colors",
docstring_md : "Optional colors for the points.", is_required :
false, }, ArchetypeFieldReflection { component_name :
"rerun.components.ClassId".into(), display_name : "Class ids",
docstring_md :
"Optional class Ids for the points.\n\nThe [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) provides colors if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Image"),
ArchetypeReflection {
display_name: "Image",
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.ImageBuffer".into(), display_name : "Buffer",
docstring_md : "The raw image data.", is_required : true, },
ArchetypeFieldReflection { component_name :
"rerun.components.ImageFormat".into(), display_name : "Format",
docstring_md : "The format of the image.", is_required : true, },
ArchetypeFieldReflection { component_name :
"rerun.components.Opacity".into(), display_name : "Opacity",
docstring_md :
"Opacity of the image, useful for layering several images.\n\nDefaults to 1.0 (fully opaque).",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.DrawOrder".into(), display_name : "Draw order",
docstring_md :
"An optional floating point value that specifies the 2D drawing order.\n\nObjects with higher values are drawn on top of those with lower values.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.InstancePoses3D"),
ArchetypeReflection {
display_name: "Instance poses 3D",
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.PoseTranslation3D".into(), display_name :
"Translations", docstring_md : "Translation vectors.", is_required :
false, }, ArchetypeFieldReflection { component_name :
"rerun.components.PoseRotationAxisAngle".into(), display_name :
"Rotation axis angles", docstring_md : "Rotations via axis + angle.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.PoseRotationQuat".into(), display_name :
"Quaternions", docstring_md : "Rotations via quaternion.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.PoseScale3D".into(), display_name : "Scales",
docstring_md : "Scaling factors.", is_required : false, },
ArchetypeFieldReflection { component_name :
"rerun.components.PoseTransformMat3x3".into(), display_name :
"Mat 3x 3", docstring_md : "3x3 transformation matrices.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.LineStrips2D"),
ArchetypeReflection {
display_name: "Line strips 2D",
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vecs for the lines.\n\nThe [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.LineStrips3D"),
ArchetypeReflection {
display_name: "Line strips 3D",
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vecs for the lines.\n\nThe [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Mesh3D"),
ArchetypeReflection {
display_name: "Mesh 3D",
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec of the mesh.\n\nCurrently supports only sRGB(A) textures, ignoring alpha.\n(meaning that the tensor must have 3 or 4 channels and use the `u8` format)",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.ImageFormat".into(), display_name :
"Albedo texture format", docstring_md :
"The format of the `albedo_texture_buffer`, if any.", is_required :
false, }, ArchetypeFieldReflection { component_name :
"rerun.components.ClassId".into(), display_name : "Class ids",
docstring_md :
"Optional class Ids for the vertices.\n\nThe [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Pinhole"),
ArchetypeReflection {
display_name: "Pinhole",
view_types: &["Spatial2DView", "Spatial2DView"],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.PinholeProjection".into(), display_name :
"Image from camera", docstring_md :
"Camera projection, from image coordinates to view coordinates.",
is_required : true, }, ArchetypeFieldReflection { component_name :
"rerun.components.Resolution".into(), display_name : "Resolution",
docstring_md :
"Pixel resolution (usually integers) of child image space. Width and height.\n\nExample:\n```text\n[1920.0, 1440.0]\n```\n\n`image_from_camera` project onto the space spanned by `(0,0)` and `resolution - 1`.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.ViewCoordinates".into(), display_name :
"Camera xyz", docstring_md :
"Sets the view coordinates for the camera.\n\nAll common values are available as constants on the `components.ViewCoordinates` class.\n\nThe default is `ViewCoordinates::RDF`, i.e. X=Right, Y=Down, Z=Forward, and this is also the recommended setting.\nThis means that the camera frustum will point along the positive Z axis of the parent space,\nand the cameras \"up\" direction will be along the negative Y axis of the parent space.\n\nThe camera frustum will point whichever axis is set to `F` (or the opposite of `B`).\nWhen logging a depth image under this entity, this is the direction the point cloud will be projected.\nWith `RDF`, the default forward is +Z.\n\nThe frustum's \"up\" direction will be whichever axis is set to `U` (or the opposite of `D`).\nThis will match the negative Y direction of pixel space (all images are assumed to have xyz=RDF).\nWith `RDF`, the default is up is -Y.\n\nThe frustum's \"right\" direction will be whichever axis is set to `R` (or the opposite of `L`).\nThis will match the positive X direction of pixel space (all images are assumed to have xyz=RDF).\nWith `RDF`, the default right is +x.\n\nOther common formats are `RUB` (X=Right, Y=Up, Z=Back) and `FLU` (X=Forward, Y=Left, Z=Up).\n\nNOTE: setting this to something else than `RDF` (the default) will change the orientation of the camera frustum,\nand make the pinhole matrix not match up with the coordinate system of the pinhole entity.\n\nThe pinhole matrix (the `image_from_camera` argument) always project along the third (Z) axis,\nbut will be re-oriented to project along the forward axis of the `camera_xyz` argument.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.ImagePlaneDistance".into(), display_name :
"Image plane distance", docstring_md :
"The distance from the camera origin to the image plane when the projection is shown in a 3D viewer.\n\nThis is only used for visualization purposes, and does not affect the projection itself.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Points2D"),
ArchetypeReflection {
display_name: "Points 2D",
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec provides colors and labels if not specified explicitly.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.KeypointId".into(), display_name : "Keypoint ids",
docstring_md :
"Optional keypoint IDs for the points, identifying them within a class.\n\nIf keypoint IDs are passed in but no [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id)s were specified, the [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) will\ndefault to 0.\nThis is useful to identify points within a single classification (which is identified\nwith `class_id`).\nE.g. the classification might be 'Person' and the keypoints refer to joints on a\ndetected skeleton.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Points3D"),
ArchetypeReflection {
display_name: "Points 3D",
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec provides colors and labels if not specified explicitly.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.KeypointId".into(), display_name : "Keypoint ids",
docstring_md :
"Optional keypoint IDs for the points, identifying them within a class.\n\nIf keypoint IDs are passed in but no [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id)s were specified, the [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) will\ndefault to 0.\nThis is useful to identify points within a single classification (which is identified\nwith `class_id`).\nE.g. the classification might be 'Person' and the keypoints refer to joints on a\ndetected skeleton.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Scalar"),
ArchetypeReflection {
display_name: "Scalar",
view_types: &["TimeSeriesView"],
fields: vec![
ArchetypeFieldReflection { component_name : "rerun.components.Scalar"
.into(), display_name : "Scalar", docstring_md :
"The scalar value to log.", is_required : true, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.SegmentationImage"),
ArchetypeReflection {
display_name: "Segmentation image",
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.ImageBuffer".into(), display_name : "Buffer",
docstring_md : "The raw image data.", is_required : true, },
ArchetypeFieldReflection { component_name :
"rerun.components.ImageFormat".into(), display_name : "Format",
docstring_md : "The format of the image.", is_required : true, },
ArchetypeFieldReflection { component_name :
"rerun.components.Opacity".into(), display_name : "Opacity",
docstring_md :
"Opacity of the image, useful for layering the segmentation image on top of another image.\n\nDefaults to 0.5 if there's any other images in the scene, otherwise 1.0.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.DrawOrder".into(), display_name : "Draw order",
docstring_md :
"An optional floating point value that specifies the 2D drawing order.\n\nObjects with higher values are drawn on top of those with lower values.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.SeriesLine"),
ArchetypeReflection {
display_name: "Series line",
view_types: &["TimeSeriesView"],
fields: vec![
ArchetypeFieldReflection { component_name : "rerun.components.Color"
.into(), display_name : "Color", docstring_md :
"Color for the corresponding series.", is_required : false, },
ArchetypeFieldReflection { component_name :
"rerun.components.StrokeWidth".into(), display_name : "Width",
docstring_md : "Stroke width for the corresponding series.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Name".into(), display_name : "Name", docstring_md :
"Display name of the series.\n\nUsed in the legend.", is_required :
false, }, ArchetypeFieldReflection { component_name :
"rerun.components.AggregationPolicy".into(), display_name :
"Aggregation policy", docstring_md :
"Configures the zoom-dependent scalar aggregation.\n\nThis is done only if steps on the X axis go below a single pixel,\ni.e. a single pixel covers more than one tick worth of data. It can greatly improve performance\n(and readability) in such situations as it prevents overdraw.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.SeriesPoint"),
ArchetypeReflection {
display_name: "Series point",
view_types: &["TimeSeriesView"],
fields: vec![
ArchetypeFieldReflection { component_name : "rerun.components.Color"
.into(), display_name : "Color", docstring_md :
"Color for the corresponding series.", is_required : false, },
ArchetypeFieldReflection { component_name :
"rerun.components.MarkerShape".into(), display_name : "Marker",
docstring_md : "What shape to use to represent the point",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Name".into(), display_name : "Name", docstring_md :
"Display name of the series.\n\nUsed in the legend.", is_required :
false, }, ArchetypeFieldReflection { component_name :
"rerun.components.MarkerSize".into(), display_name : "Marker size",
docstring_md : "Size of the marker.", is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Tensor"),
ArchetypeReflection {
display_name: "Tensor",
view_types: &["TensorView", "BarChartView"],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.TensorData".into(), display_name : "Data",
docstring_md : "The tensor data", is_required : true, },
ArchetypeFieldReflection { component_name :
"rerun.components.ValueRange".into(), display_name : "Value range",
docstring_md :
"The expected range of values.\n\nThis is typically the expected range of valid values.\nEverything outside of the range is clamped to the range for the purpose of colormpaping.\nAny colormap applied for display, will map this range.\n\nIf not specified, the range will be automatically estimated from the data.\nNote that the Viewer may try to guess a wider range than the minimum/maximum of values\nin the contents of the tensor.\nE.g. if all values are positive, some bigger than 1.0 and all smaller than 255.0,\nthe Viewer will guess that the data likely came from an 8bit image, thus assuming a range of 0-255.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.TextDocument"),
ArchetypeReflection {
display_name: "Text document",
view_types: &["TextDocumentView"],
fields: vec![
ArchetypeFieldReflection { component_name : "rerun.components.Text"
.into(), display_name : "Text", docstring_md :
"Contents of the text document.", is_required : true, },
ArchetypeFieldReflection { component_name :
"rerun.components.MediaType".into(), display_name : "Media type",
docstring_md :
"The Media Type of the text.\n\nFor instance:\n* `text/plain`\n* `text/markdown`\n\nIf omitted, `text/plain` is assumed.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.TextLog"),
ArchetypeReflection {
display_name: "Text log",
view_types: &["TextLogView"],
fields: vec![
ArchetypeFieldReflection { component_name : "rerun.components.Text"
.into(), display_name : "Text", docstring_md :
"The body of the message.", is_required : true, },
ArchetypeFieldReflection { component_name :
"rerun.components.TextLogLevel".into(), display_name : "Level",
docstring_md :
"The verbosity level of the message.\n\nThis can be used to filter the log messages in the Rerun Viewer.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Color".into(), display_name : "Color", docstring_md
: "Optional color to use for the log line in the Rerun Viewer.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Transform3D"),
ArchetypeReflection {
display_name: "Transform 3D",
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.Translation3D".into(), display_name :
"Translation", docstring_md : "Translation vector.", is_required :
false, }, ArchetypeFieldReflection { component_name :
"rerun.components.RotationAxisAngle".into(), display_name :
"Rotation axis angle", docstring_md : "Rotation via axis + angle.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.RotationQuat".into(), display_name : "Quaternion",
docstring_md : "Rotation via quaternion.", is_required : false, },
ArchetypeFieldReflection { component_name :
"rerun.components.Scale3D".into(), display_name : "Scale",
docstring_md : "Scaling factor.", is_required : false, },
ArchetypeFieldReflection { component_name :
"rerun.components.TransformMat3x3".into(), display_name : "Mat 3x 3",
docstring_md : "3x3 transformation matrix.", is_required : false, },
ArchetypeFieldReflection { component_name :
"rerun.components.TransformRelation".into(), display_name :
"Relation", docstring_md :
"Specifies the relation this transform establishes between this entity and its parent.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.AxisLength".into(), display_name : "Axis length",
docstring_md :
"Visual length of the 3 axes.\n\nThe length is interpreted in the local coordinate system of the transform.\nIf the transform is scaled, the axes will be scaled accordingly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.VideoFrameReference"),
ArchetypeReflection {
display_name: "Video frame reference",
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec.\n\nIf none is specified, the video is assumed to be at the same entity.\nNote that blueprint overrides on the referenced video will be ignored regardless,\nas this is always interpreted as a reference to the data store.\n\nFor a series of video frame references, it is recommended to specify this path only once\nat the beginning of the series and then rely on latest-at query semantics to\nkeep the video reference active.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.ViewCoordinates"),
ArchetypeReflection {
display_name: "View coordinates",
view_types: &["Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.ViewCoordinates".into(), display_name : "Xyz",
docstring_md : "The directions of the [x, y, z] axes.", is_required :
true, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.Background"),
ArchetypeReflection {
display_name: "Background",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.BackgroundKind".into(), display_name :
"Kind", docstring_md : "The type of the background.", is_required :
true, }, ArchetypeFieldReflection { component_name :
"rerun.components.Color".into(), display_name : "Color", docstring_md
: "Color used for the `SolidColor` background type.", is_required :
false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.ContainerBlueprint"),
ArchetypeReflection {
display_name: "Container blueprint",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.ContainerKind".into(), display_name :
"Container kind", docstring_md : "The class of the view.",
is_required : true, }, ArchetypeFieldReflection { component_name :
"rerun.components.Name".into(), display_name : "Display name",
docstring_md : "The name of the container.", is_required : false, },
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.IncludedContent".into(), display_name :
"Contents", docstring_md :
"`ContainerId`s or `SpaceViewId`s that are children of this container.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.ColumnShare".into(), display_name :
"Col shares", docstring_md :
"The layout shares of each column in the container.\n\nFor `Horizontal` containers, the length of this list should always match the number of contents.\n\nIgnored for `Vertical` containers.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.RowShare".into(), display_name :
"Row shares", docstring_md :
"The layout shares of each row of the container.\n\nFor `Vertical` containers, the length of this list should always match the number of contents.\n\nIgnored for `Horizontal` containers.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.ActiveTab".into(), display_name :
"Active tab", docstring_md :
"Which tab is active.\n\nOnly applies to `Tabs` containers.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.Visible".into(), display_name :
"Visible", docstring_md :
"Whether this container is visible.\n\nDefaults to true if not specified.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.GridColumns".into(), display_name :
"Grid columns", docstring_md :
"How many columns this grid should have.\n\nIf unset, the grid layout will be auto.\n\nIgnored for `Horizontal`/`Vertical` containers.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.DataframeQuery"),
ArchetypeReflection {
display_name: "Dataframe query",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.TimelineName".into(), display_name :
"Timeline", docstring_md :
"The timeline for this query.\n\nIf unset, the timeline currently active on the time panel is used.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.FilterByRange".into(), display_name :
"Filter by range", docstring_md :
"If provided, only rows whose timestamp is within this range will be shown.\n\nNote: will be unset as soon as `timeline` is changed.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.FilterIsNotNull".into(), display_name :
"Filter is not null", docstring_md :
"If provided, only show rows which contains a logged event for the specified component.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.ApplyLatestAt".into(), display_name :
"Apply latest at", docstring_md :
"Should empty cells be filled with latest-at queries?", is_required :
false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.SelectedColumns".into(), display_name :
"Select", docstring_md :
"Selected columns. If unset, all columns are selected.", is_required
: false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.MapBackground"),
ArchetypeReflection {
display_name: "Map background",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.MapProvider".into(), display_name :
"Provider", docstring_md :
"Map provider and style to use.\n\n**Note**: Requires a Mapbox API key in the `RERUN_MAPBOX_ACCESS_TOKEN` environment variable.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.MapZoom"),
ArchetypeReflection {
display_name: "Map zoom",
view_types: &[],
fields: vec.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.PanelBlueprint"),
ArchetypeReflection {
display_name: "Panel blueprint",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.PanelState".into(), display_name :
"State", docstring_md : "", is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.PlotLegend"),
ArchetypeReflection {
display_name: "Plot legend",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.Corner2D".into(), display_name :
"Corner", docstring_md :
"To what corner the legend is aligned.\n\nDefaults to the right bottom corner.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.Visible".into(), display_name :
"Visible", docstring_md :
"Whether the legend is shown at all.\n\nTrue by default.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.ScalarAxis"),
ArchetypeReflection {
display_name: "Scalar axis",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.Range1D".into(), display_name : "Range",
docstring_md :
"The range of the axis.\n\nIf unset, the range well be automatically determined based on the queried data.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.LockRangeDuringZoom".into(), display_name
: "Zoom lock", docstring_md :
"If enabled, the Y axis range will remain locked to the specified range when zooming.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.SpaceViewBlueprint"),
ArchetypeReflection {
display_name: "Space view blueprint",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.SpaceViewClass".into(), display_name :
"Class identifier", docstring_md : "The class of the view.",
is_required : true, }, ArchetypeFieldReflection { component_name :
"rerun.components.Name".into(), display_name : "Display name",
docstring_md : "The name of the view.", is_required : false, },
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.SpaceViewOrigin".into(), display_name :
"Space origin", docstring_md :
"The \"anchor point\" of this space view.\n\nDefaults to the root path '/' if not specified.\n\nThe transform at this path forms the reference point for all scene->world transforms in this space view.\nI.e. the position of this entity path in space forms the origin of the coordinate system in this space view.\nFurthermore, this is the primary indicator for heuristics on what entities we show in this space view.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.Visible".into(), display_name :
"Visible", docstring_md :
"Whether this space view is visible.\n\nDefaults to true if not specified.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.SpaceViewContents"),
ArchetypeReflection {
display_name: "Space view contents",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.QueryExpression".into(), display_name :
"Query", docstring_md :
"The `QueryExpression` that populates the contents for the `SpaceView`.\n\nThey determine which entities are part of the spaceview.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.TensorScalarMapping"),
ArchetypeReflection {
display_name: "Tensor scalar mapping",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.MagnificationFilter".into(), display_name :
"Mag filter", docstring_md :
"Filter used when zooming in on the tensor.\n\nNote that the filter is applied to the scalar values *before* they are mapped to color.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.Colormap".into(), display_name : "Colormap",
docstring_md : "How scalar values map to colors.", is_required :
false, }, ArchetypeFieldReflection { component_name :
"rerun.components.GammaCorrection".into(), display_name : "Gamma",
docstring_md :
"Gamma exponent applied to normalized values before mapping to color.\n\nRaises the normalized values to the power of this value before mapping to color.\nActs like an inverse brightness. Defaults to 1.0.\n\nThe final value for display is set as:\n`colormap( ((value - data_display_range.min) / (data_display_range.max - data_display_range.min)) ** gamma )`",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.TensorSliceSelection"),
ArchetypeReflection {
display_name: "Tensor slice selection",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.components.TensorWidthDimension".into(), display_name :
"Width", docstring_md :
"Which dimension to map to width.\n\nIf not specified, the height will be determined automatically based on the name and index of the dimension.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.TensorHeightDimension".into(), display_name :
"Height", docstring_md :
"Which dimension to map to height.\n\nIf not specified, the height will be determined automatically based on the name and index of the dimension.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.components.TensorDimensionIndexSelection".into(), display_name
: "Indices", docstring_md :
"Selected indices for all other dimensions.\n\nIf any of the here listed dimensions is equal to `width` or `height`, it will be ignored.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.TensorDimensionIndexSlider".into(),
display_name : "Slider", docstring_md :
"Any dimension listed here will have a slider for the index.\n\nEdits to the sliders will directly manipulate dimensions on the `indices` list.\nIf any of the here listed dimensions is equal to `width` or `height`, it will be ignored.\nIf not specified, adds slides for any dimension in `indices`.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.TensorViewFit"),
ArchetypeReflection {
display_name: "Tensor view fit",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.ViewFit".into(), display_name :
"Scaling", docstring_md : "How the image is scaled to fit the view.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.ViewportBlueprint"),
ArchetypeReflection {
display_name: "Viewport blueprint",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.RootContainer".into(), display_name :
"Root container", docstring_md : "The layout of the space-views",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.SpaceViewMaximized".into(), display_name
: "Maximized", docstring_md : "Show one tab as maximized?",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.AutoLayout".into(), display_name :
"Auto layout", docstring_md :
"Whether the viewport layout is determined automatically.\n\nIf `true`, the container layout will be reset whenever a new space view is added or removed.\nThis defaults to `false` and is automatically set to `false` when there is user determined layout.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.AutoSpaceViews".into(), display_name :
"Auto space views", docstring_md :
"Whether or not space views should be created automatically.\n\nIf `true`, the viewer will only add space views that it hasn't considered previously (as identified by `past_viewer_recommendations`)\nand which aren't deemed redundant to existing space views.\nThis defaults to `false` and is automatically set to `false` when the user adds space views manually in the viewer.",
is_required : false, }, ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.ViewerRecommendationHash".into(),
display_name : "Past viewer recommendations", docstring_md :
"Hashes of all recommended space views the viewer has already added and that should not be added again.\n\nThis is an internal field and should not be set usually.\nIf you want the viewer from stopping to add space views, you should set `auto_space_views` to `false`.\n\nThe viewer uses this to determine whether it should keep adding space views.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.VisibleTimeRanges"),
ArchetypeReflection {
display_name: "Visible time ranges",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.VisibleTimeRange".into(), display_name :
"Ranges", docstring_md :
"The time ranges to show for each timeline unless specified otherwise on a per-entity basis.\n\nIf a timeline is specified more than once, the first entry will be used.",
is_required : true, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.VisualBounds2D"),
ArchetypeReflection {
display_name: "Visual bounds 2D",
view_types: &[],
fields: vec![
ArchetypeFieldReflection { component_name :
"rerun.blueprint.components.VisualBounds2D".into(), display_name :
"Range", docstring_md :
"Controls the visible range of a 2D view.\n\nUse this to control pan & zoom of the view.",
is_required : true, },
],
},
),
];
ArchetypeReflectionMap::from_iter(array)
}