Struct ChargedFeatureView 

pub struct ChargedFeatureView<'a, X, Y> {
    pub charge: i32,
    /* private fields */
}

A non-owning version of ChargedFeature

Fields

charge: i32

Implementations

impl<'a, X, Y> ChargedFeatureView<'a, X, Y>

pub fn new(feature: FeatureView<'a, X, Y>, charge: i32) -> Self

pub fn empty(charge: i32) -> Self

pub fn into_inner(self) -> (FeatureView<'a, X, Y>, i32)

pub fn as_inner(&self) -> (&FeatureView<'a, X, Y>, i32)

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> Iter<'a, X, Y>

pub fn to_owned(&self) -> ChargedFeature<X, Y>

Trait Implementations

impl<'a, X: Clone, Y: Clone> Clone for ChargedFeatureView<'a, X, Y>

fn clone(&self) -> ChargedFeatureView<'a, X, Y>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<X, Y> CoordinateLike<X> for ChargedFeatureView<'_, X, Y>

fn coordinate(&self) -> f64

The trait method for accessing the coordinate of the object on coordinate system T

impl<'a, X: Debug, Y: Debug> Debug for ChargedFeatureView<'a, X, Y>

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

Formats the value using the given formatter.

impl<'a, X, Y> FeatureLike<X, Y> for ChargedFeatureView<'a, X, Y>

where ChargedFeatureView<'a, X, Y>: TimeInterval<Y>,

fn len(&self) -> usize

The number of points in the feature

fn iter(&self) -> impl Iterator<Item = (f64, f64, f32)>

Create an iterator that yields (x, y, intensity) references

fn is_empty(&self) -> bool

Check if the feature has any points in it

fn at(&self, index: usize) -> Option<(f64, f64, f32)>

Get an immutable reference to feature data at a specified index

fn first(&self) -> Option<(f64, f64, f32)>

Retrieve the first time point, if it exists

fn last(&self) -> Option<(f64, f64, f32)>

Retrieve the last time point, if it exists

fn at_time(&self, time: f64) -> Option<(f64, f64, f32)>

Get an immutable reference to feature data at a specified time.Analogous to combining TimeInterval::find_time with FeatureLike::at

impl<X, Y> IntensityMeasurement for ChargedFeatureView<'_, X, Y>

fn intensity(&self) -> f32

impl<'a, X, Y> IntoIterator for ChargedFeatureView<'a, X, Y>

type Item = (f64, f64, f32)

The type of the elements being iterated over.

type IntoIter = Iter<'a, X, Y>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<X, Y> KnownCharge for ChargedFeatureView<'_, X, Y>

fn charge(&self) -> i32

impl<X, Y> PartialEq for ChargedFeatureView<'_, X, Y>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<X, Y> PartialOrd for ChargedFeatureView<'_, X, Y>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, X, Y> SplittableFeatureLike<'a, X, Y> for ChargedFeatureView<'a, X, Y>

type ViewType = ChargedFeatureView<'a, X, Y>

The type that will hold the split feature parts. They could be borrowed or own a copy of their original data.

fn split_at_time(&'a self, point: f64) -> (Self::ViewType, Self::ViewType)

Split the feature at time.

fn slice<I: RangeBounds<usize> + Clone>(&'a self, bounds: I) -> Self::ViewType

Select the positions given by the range of positions in bounds

fn split_at(&'a self, index: usize) -> (Self::ViewType, Self::ViewType)

Split the feature at index, segmenting before and after it. The position at index should be retained in the second segment.

fn split_mask(&'a self, mask: &[bool]) -> Vec<Self::ViewType>

Retain all positions where mask is true, keeping contiguous positions part of the same feature segments.

fn split_when<F>(&'a self, f: F) -> Vec<Self::ViewType>

where F: FnMut((f64, f64, f32), (f64, f64, f32)) -> bool,

Given a function f that takes successive pairs of points of (dim1, dim2, intensity) and returns a bool, mask all out all positions where f returns true.

fn split_sparse(&'a self, max_gap_size: f64) -> Vec<Self::ViewType>

Split the feature when there is a gap of size max_gap_size or more in the time dimension

impl<X, Y> TimeArray<Y> for ChargedFeatureView<'_, X, Y>

fn time_view(&self) -> &[f64]

A slice over the complete time dimension

fn intensity_view(&self) -> &[f32]

A slice over the complete intensity dimension

impl<'a, X, Y> TimeInterval<Y> for ChargedFeatureView<'a, X, Y>

fn apex_time(&self) -> Option<f64>

The time point where the feature reaches its greatest intensity

fn area(&self) -> f32

Integrate the feature in the time dimension

fn end_time(&self) -> Option<f64>

The latest time point recorded

fn start_time(&self) -> Option<f64>

The earliest time point recorded

fn iter_time(&self) -> impl Iterator<Item = f64>

Return an iterator over the time dimension

fn find_time(&self, time: f64) -> (Option<usize>, f64)

Find the position in the interval closest to the requested time and the magnitude of the error

fn as_range(&self) -> CoordinateRange<T>

Represent the TimeInterval into a CoordinateRange

fn spans(&self, time: f64) -> bool

Check if a time point is spanned by TimeInterval

impl<'a, X: Copy, Y: Copy> Copy for ChargedFeatureView<'a, X, Y>