Struct rerun::SeriesLine

pub struct SeriesLine {
    pub color: Option<SerializedComponentBatch>,
    pub width: Option<SerializedComponentBatch>,
    pub name: Option<SerializedComponentBatch>,
    pub aggregation_policy: Option<SerializedComponentBatch>,
}

Archetype: Define the style properties for a line 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

Line series

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

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

    for t in 0..((std::f32::consts::TAU * 2.0 * 100.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 / 100.0).sin()))?;
        rec.log("trig/cos", &rerun::Scalar::new((t as f64 / 100.0).cos()))?;
    }

    Ok(())
}

Fields

color: Option<SerializedComponentBatch>

Color for the corresponding series.

width: Option<SerializedComponentBatch>

Stroke width for the corresponding series.

name: Option<SerializedComponentBatch>

Display name of the series.

Used in the legend.

aggregation_policy: Option<SerializedComponentBatch>

Configures the zoom-dependent scalar aggregation.

This is done only if steps on the X axis go below a single pixel, i.e. a single pixel covers more than one tick worth of data. It can greatly improve performance (and readability) in such situations as it prevents overdraw.

Implementations

impl SeriesLine

pub fn descriptor_color() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::color.

pub fn descriptor_width() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::width.

pub fn descriptor_name() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::name.

pub fn descriptor_aggregation_policy() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::aggregation_policy.

pub fn descriptor_indicator() -> ComponentDescriptor

Returns the ComponentDescriptor for the associated indicator component.

impl SeriesLine

pub const NUM_COMPONENTS: usize = 5usize

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

impl SeriesLine

pub fn new() -> SeriesLine

Create a new SeriesLine.

pub fn update_fields() -> SeriesLine

Update only some specific fields of a SeriesLine.

pub fn clear_fields() -> SeriesLine

Clear all the fields of a SeriesLine.

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

Color for the corresponding series.

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

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_width(self, width: impl Into<StrokeWidth>) -> SeriesLine

Stroke width for the corresponding series.

pub fn with_many_width( self, width: impl IntoIterator<Item = impl Into<StrokeWidth>>, ) -> SeriesLine

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

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

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

Display name of the series.

Used in the legend.

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

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_aggregation_policy( self, aggregation_policy: impl Into<AggregationPolicy>, ) -> SeriesLine

Configures the zoom-dependent scalar aggregation.

This is done only if steps on the X axis go below a single pixel, i.e. a single pixel covers more than one tick worth of data. It can greatly improve performance (and readability) in such situations as it prevents overdraw.

pub fn with_many_aggregation_policy( self, aggregation_policy: impl IntoIterator<Item = impl Into<AggregationPolicy>>, ) -> SeriesLine

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

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

Trait Implementations

impl Archetype for SeriesLine

type Indicator = GenericIndicatorComponent<SeriesLine>

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<SeriesLine, 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 SeriesLine

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 SeriesLine

fn clone(&self) -> SeriesLine

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SeriesLine

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

Formats the value using the given formatter.

impl Default for SeriesLine

fn default() -> SeriesLine

Returns the “default value” for a type.

impl SizeBytes for SeriesLine

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 SeriesLine