Struct rerun::SeriesPoint

pub struct SeriesPoint {
    pub color: Option<SerializedComponentBatch>,
    pub marker: Option<SerializedComponentBatch>,
    pub name: Option<SerializedComponentBatch>,
    pub marker_size: Option<SerializedComponentBatch>,
}

Archetype: Define the style properties for a point series in a chart.

This archetype only provides styling information and should be logged as static when possible. The underlying data needs to be logged to the same entity-path using archetypes::Scalar.

Example

Point series

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rec = rerun::RecordingStreamBuilder::new("rerun_example_series_point_style").spawn()?;

    // Set up plot styling:
    // They are logged static as they don't change over time and apply to all timelines.
    // Log two point series under a shared root so that they show in the same plot by default.
    rec.log_static(
        "trig/sin",
        &rerun::SeriesPoint::new()
            .with_color([255, 0, 0])
            .with_name("sin(0.01t)")
            .with_marker(rerun::components::MarkerShape::Circle)
            .with_marker_size(4.0),
    )?;
    rec.log_static(
        "trig/cos",
        &rerun::SeriesPoint::new()
            .with_color([0, 255, 0])
            .with_name("cos(0.01t)")
            .with_marker(rerun::components::MarkerShape::Cross)
            .with_marker_size(2.0),
    )?;

    for t in 0..((std::f32::consts::TAU * 2.0 * 10.0) as i64) {
        rec.set_time_sequence("step", t);

        // Log two time series under a shared root so that they show in the same plot by default.
        rec.log("trig/sin", &rerun::Scalar::new((t as f64 / 10.0).sin()))?;
        rec.log("trig/cos", &rerun::Scalar::new((t as f64 / 10.0).cos()))?;
    }

    Ok(())
}

Fields

color: Option<SerializedComponentBatch>

Color for the corresponding series.

marker: Option<SerializedComponentBatch>

What shape to use to represent the point

name: Option<SerializedComponentBatch>

Display name of the series.

Used in the legend.

marker_size: Option<SerializedComponentBatch>

Size of the marker.

Implementations

impl SeriesPoint

pub fn descriptor_color() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::color.

pub fn descriptor_marker() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::marker.

pub fn descriptor_name() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::name.

pub fn descriptor_marker_size() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::marker_size.

pub fn descriptor_indicator() -> ComponentDescriptor

Returns the ComponentDescriptor for the associated indicator component.

impl SeriesPoint

pub const NUM_COMPONENTS: usize = 5usize

The total number of components in the archetype: 0 required, 1 recommended, 4 optional

impl SeriesPoint

pub fn new() -> SeriesPoint

Create a new SeriesPoint.

pub fn update_fields() -> SeriesPoint

Update only some specific fields of a SeriesPoint.

pub fn clear_fields() -> SeriesPoint

Clear all the fields of a SeriesPoint.

pub fn columns<I>( self, _lengths: I, ) -> Result<impl Iterator<Item = SerializedComponentColumn>, SerializationError>

where I: IntoIterator<Item = usize> + Clone,

Partitions the component data into multiple sub-batches.

Specifically, this transforms the existing SerializedComponentBatches data into SerializedComponentColumns instead, via SerializedComponentBatch::partitioned.

This makes it possible to use RecordingStream::send_columns to send columnar data directly into Rerun.

The specified lengths must sum to the total length of the component batch.

pub fn columns_of_unit_batches( self, ) -> Result<impl Iterator<Item = SerializedComponentColumn>, SerializationError>

Helper to partition the component data into unit-length sub-batches.

This is semantically similar to calling Self::columns with std::iter::take(1).repeat(n), where n is automatically guessed.

pub fn with_color(self, color: impl Into<Color>) -> SeriesPoint

Color for the corresponding series.

pub fn with_many_color( self, color: impl IntoIterator<Item = impl Into<Color>>, ) -> SeriesPoint

This method makes it possible to pack multiple crate::components::Color in a single component batch.

This only makes sense when used in conjunction with Self::columns. Self::with_color should be used when logging a single row’s worth of data.

pub fn with_marker(self, marker: impl Into<MarkerShape>) -> SeriesPoint

What shape to use to represent the point

pub fn with_many_marker( self, marker: impl IntoIterator<Item = impl Into<MarkerShape>>, ) -> SeriesPoint

This method makes it possible to pack multiple crate::components::MarkerShape in a single component batch.

This only makes sense when used in conjunction with Self::columns. Self::with_marker should be used when logging a single row’s worth of data.

pub fn with_name(self, name: impl Into<Name>) -> SeriesPoint

Display name of the series.

Used in the legend.

pub fn with_many_name( self, name: impl IntoIterator<Item = impl Into<Name>>, ) -> SeriesPoint

This method makes it possible to pack multiple crate::components::Name in a single component batch.

This only makes sense when used in conjunction with Self::columns. Self::with_name should be used when logging a single row’s worth of data.

pub fn with_marker_size(self, marker_size: impl Into<MarkerSize>) -> SeriesPoint

Size of the marker.

pub fn with_many_marker_size( self, marker_size: impl IntoIterator<Item = impl Into<MarkerSize>>, ) -> SeriesPoint

This method makes it possible to pack multiple crate::components::MarkerSize in a single component batch.

This only makes sense when used in conjunction with Self::columns. Self::with_marker_size should be used when logging a single row’s worth of data.

Trait Implementations

impl Archetype for SeriesPoint

type Indicator = GenericIndicatorComponent<SeriesPoint>

The associated indicator component, whose presence indicates that the high-level archetype-based APIs were used to log the data.

fn name() -> ArchetypeName

The fully-qualified name of this archetype, e.g. rerun.archetypes.Points2D.

fn display_name() -> &'static str

Readable name for displaying in UI.

fn indicator() -> SerializedComponentBatch

Creates a ComponentBatch out of the associated Self::Indicator component.

fn required_components() -> Cow<'static, [ComponentDescriptor]>

Returns all component descriptors that must be provided by the user when constructing this archetype.

fn recommended_components() -> Cow<'static, [ComponentDescriptor]>

Returns all component descriptors that should be provided by the user when constructing this archetype.

fn optional_components() -> Cow<'static, [ComponentDescriptor]>

Returns all component descriptors that may be provided by the user when constructing this archetype.

fn all_components() -> Cow<'static, [ComponentDescriptor]>

Returns all component descriptors that must, should and may be provided by the user when constructing this archetype.

fn from_arrow_components( arrow_data: impl IntoIterator<Item = (ComponentDescriptor, Arc<dyn Array>)>, ) -> Result<SeriesPoint, DeserializationError>

Given an iterator of Arrow arrays and their respective ComponentNames, deserializes them into this archetype.

fn from_arrow( data: impl IntoIterator<Item = (Field, Arc<dyn Array>)>, ) -> Result<Self, DeserializationError>

where Self: Sized,

Given an iterator of Arrow arrays and their respective field metadata, deserializes them into this archetype.

impl AsComponents for SeriesPoint

fn as_serialized_batches(&self) -> Vec<SerializedComponentBatch>

Exposes the object’s contents as a set of SerializedComponentBatches.

fn to_arrow(&self) -> Result<Vec<(Field, Arc<dyn Array>)>, SerializationError>

Serializes all non-null Components of this bundle into Arrow arrays.

impl Clone for SeriesPoint

fn clone(&self) -> SeriesPoint

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SeriesPoint

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for SeriesPoint

fn default() -> SeriesPoint

Returns the “default value” for a type.

impl SizeBytes for SeriesPoint

fn heap_size_bytes(&self) -> u64

Returns how many bytes self uses on the heap.

fn total_size_bytes(&self) -> u64

Returns the total size of self in bytes, accounting for both stack and heap space.

fn stack_size_bytes(&self) -> u64

Returns the total size of self on the stack, in bytes.

fn is_pod() -> bool

Is Self just plain old data?

impl ArchetypeReflectionMarker for SeriesPoint