Struct SeriesPoints

Source

pub struct SeriesPoints {
    pub colors: Option<SerializedComponentBatch>,
    pub markers: Option<SerializedComponentBatch>,
    pub names: Option<SerializedComponentBatch>,
    pub visible_series: Option<SerializedComponentBatch>,
    pub marker_sizes: Option<SerializedComponentBatch>,
}

Expand description

Archetype: Define the style properties for one or more point series (scatter plot) in a chart.

This archetype only provides styling information. Changes over time are supported for most but not all its fields (see respective fields for details), it’s generally recommended to log this type as static.

The underlying data needs to be logged to the same entity-path using archetypes::Scalars. Dimensionality of the scalar arrays logged at each time point is assumed to be the same over time.

§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::SeriesPoints::new()
            .with_colors([[255, 0, 0]])
            .with_names(["sin(0.01t)"])
            .with_markers([rerun::components::MarkerShape::Circle])
            .with_marker_sizes([4.0]),
    )?;
    rec.log_static(
        "trig/cos",
        &rerun::SeriesPoints::new()
            .with_colors([[0, 255, 0]])
            .with_names(["cos(0.01t)"])
            .with_markers([rerun::components::MarkerShape::Cross])
            .with_marker_sizes([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::Scalars::single((t as f64 / 10.0).sin()))?;
        rec.log("trig/cos", &rerun::Scalars::single((t as f64 / 10.0).cos()))?;
    }

    Ok(())
}

Fields§

§colors: Option<SerializedComponentBatch>

Color for the corresponding series.

May change over time, but can cause discontinuities in the line.

§markers: Option<SerializedComponentBatch>

What shape to use to represent the point

May change over time.

§names: Option<SerializedComponentBatch>

Display name of the series.

Used in the legend. Expected to be unchanging over time.

§visible_series: Option<SerializedComponentBatch>

Which lines are visible.

If not set, all line series on this entity are visible. Unlike with the regular visibility property of the entire entity, any series that is hidden via this property will still be visible in the legend.

May change over time.

§marker_sizes: Option<SerializedComponentBatch>

Sizes of the markers.

May change over time.

Struct SeriesPointsCopy item path

§Example

§Point series

Fields§

Implementations§

impl SeriesPoints

pub fn descriptor_colors() -> ComponentDescriptor

pub fn descriptor_markers() -> ComponentDescriptor

pub fn descriptor_names() -> ComponentDescriptor

pub fn descriptor_visible_series() -> ComponentDescriptor

pub fn descriptor_marker_sizes() -> ComponentDescriptor

pub fn descriptor_indicator() -> ComponentDescriptor

impl SeriesPoints

pub const NUM_COMPONENTS: usize = 6usize

impl SeriesPoints

pub fn new() -> SeriesPoints

pub fn update_fields() -> SeriesPoints

pub fn clear_fields() -> SeriesPoints

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

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

pub fn with_colors( self, colors: impl IntoIterator<Item = impl Into<Color>>, ) -> SeriesPoints

pub fn with_markers( self, markers: impl IntoIterator<Item = impl Into<MarkerShape>>, ) -> SeriesPoints

pub fn with_names( self, names: impl IntoIterator<Item = impl Into<Name>>, ) -> SeriesPoints

pub fn with_visible_series( self, visible_series: impl IntoIterator<Item = impl Into<SeriesVisible>>, ) -> SeriesPoints

pub fn with_marker_sizes( self, marker_sizes: impl IntoIterator<Item = impl Into<MarkerSize>>, ) -> SeriesPoints

Trait Implementations§

impl Archetype for SeriesPoints

type Indicator = GenericIndicatorComponent<SeriesPoints>

fn name() -> ArchetypeName

fn display_name() -> &'static str

fn indicator() -> SerializedComponentBatch

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

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

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

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

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

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

impl AsComponents for SeriesPoints

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

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

impl Clone for SeriesPoints

fn clone(&self) -> SeriesPoints

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

impl Debug for SeriesPoints

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

impl Default for SeriesPoints

fn default() -> SeriesPoints

impl SizeBytes for SeriesPoints

fn heap_size_bytes(&self) -> u64

fn total_size_bytes(&self) -> u64

fn stack_size_bytes(&self) -> u64

fn is_pod() -> bool

impl ArchetypeReflectionMarker for SeriesPoints

Auto Trait Implementations§

impl Freeze for SeriesPoints

impl !RefUnwindSafe for SeriesPoints

impl Send for SeriesPoints

impl Sync for SeriesPoints

impl Unpin for SeriesPoints

impl !UnwindSafe for SeriesPoints

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Az for T

fn az<Dst>(self) -> Dstwhere T: Cast<Dst>,

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<Src, Dst> CastFrom<Src> for Dstwhere Src: Cast<Dst>,

fn cast_from(src: Src) -> Dst

impl<T> CheckedAs for T

fn checked_as<Dst>(self) -> Option<Dst>where T: CheckedCast<Dst>,

impl<Src, Dst> CheckedCastFrom<Src> for Dstwhere Src: CheckedCast<Dst>,

fn checked_cast_from(src: Src) -> Option<Dst>

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dst: *mut u8)

impl<T> Conv for T

fn conv<T>(self) -> Twhere Self: Into<T>,

impl<T> Downcast<T> for T

Struct SeriesPoints

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

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

impl<T> Any for T
where T: 'static + ?Sized,

fn az<Dst>(self) -> Dst
where T: Cast<Dst>,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<Src, Dst> CastFrom<Src> for Dst
where Src: Cast<Dst>,

fn checked_as<Dst>(self) -> Option<Dst>
where T: CheckedCast<Dst>,

impl<Src, Dst> CheckedCastFrom<Src> for Dst
where Src: CheckedCast<Dst>,

impl<T> CloneToUninit for T
where T: Clone,

fn conv<T>(self) -> T
where Self: Into<T>,

impl<T> Downcast for T
where T: Any,

impl<T> DowncastSync for T
where T: Any + Send + Sync,

impl<T> FromRef<T> for T
where T: Clone,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<Src, Dst> LosslessTryInto<Dst> for Src
where Dst: LosslessTryFrom<Src>,

impl<Src, Dst> LossyInto<Dst> for Src
where Dst: LossyFrom<Src>,

impl<T> NoneValue for T
where T: Default,

fn overflowing_as<Dst>(self) -> (Dst, bool)
where T: OverflowingCast<Dst>,

impl<Src, Dst> OverflowingCastFrom<Src> for Dst
where Src: OverflowingCast<Dst>,

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

fn saturating_as<Dst>(self) -> Dst
where T: SaturatingCast<Dst>,

impl<Src, Dst> SaturatingCastFrom<Src> for Dst
where Src: SaturatingCast<Dst>,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,