Struct adder_codec_rs::framer::driver::FrameSequence

pub struct FrameSequence<T> {
    pub state: FrameSequenceState,
    pub chunk_rows: usize,
    /* private fields */
}

A sequence of frames, each of which is a 3D array of FrameValues

Fields

state: FrameSequenceState

The state of the frame sequence

chunk_rows: usize

Number of rows per chunk (per thread)

Implementations

impl<T: Clone + Default + FrameValue<Output = T> + Serialize> FrameSequence<T>

pub fn get_frames_len(&self) -> usize

Get the number of frames queue’d up to be written

pub fn get_frame_chunks_num(&self) -> usize

Get the number of chunks in a frame

pub fn px_at_current( &self, y: usize, x: usize, c: usize ) -> Result<&Option<T>, FrameSequenceError>

Get the reference for the pixel at the given coordinates

Arguments

• y - The y coordinate of the pixel
• x - The x coordinate of the pixel
• c - The channel of the pixel

Returns

• Option<&T> - The reference to the pixel value

Errors

• If the frame has not been initialized

pub fn px_at_frame( &self, y: usize, x: usize, c: usize, frame_idx: usize ) -> Result<&Option<T>, FrameSequenceError>

Get the reference for the pixel at the given coordinates and frame index

Arguments

• y - The y coordinate of the pixel
• x - The x coordinate of the pixel
• c - The channel of the pixel
• frame_idx - The index of the frame to get the pixel from

Returns

• Option<&T> - The reference to the pixel value

Errors

• If the frame at the given index has not been initialized

pub fn is_frame_filled( &self, frame_idx: usize ) -> Result<bool, FrameSequenceError>

Get whether or not the frame at the given index is “filled” (i.e., all pixels have been written to)

Arguments

• frame_idx - The index of the frame to check

Returns

• bool - Whether or not the frame is filled

Errors

• If the frame at the given index has not been initialized
• If the frame index is out of bounds
• If the frame is not aligned with the chunk division

pub fn is_frame_0_filled(&self) -> bool

Get whether or not the next frame is “filled” (i.e., all pixels have been written to)

pub fn get_running_intensities(&self) -> &Array3<u8>

Get the instantaneous intensity for each pixel

pub fn pop_features(&mut self) -> Option<FeatureInterval>

Get the features detected for the next frame, and pop that off the feature vec

pub fn pop_next_frame(&mut self) -> Option<Vec<Array3<Option<T>>>>

Pop the next frame for all chunks

returns: the frame

pub fn pop_next_frame_for_chunk( &mut self, chunk_num: usize ) -> Option<Array3<Option<T>>>

Pop the next frame from the given chunk

Arguments

• chunk_num: the y-index of the chunk to pop the frame from

returns: the chunk of frame values

pub fn write_frame_bytes( &mut self, writer: &mut BufWriter<File> ) -> Result<(), Box<dyn Error>>

Write out the next frame to the given writer

Arguments

• writer - The writer to write the frame to

Returns

• Result<(), FrameSequenceError> - Whether or not the write was successful

Errors

• If the frame chunk has not been initialized
• If the data cannot be written

pub fn write_multi_frame_bytes( &mut self, writer: &mut BufWriter<File> ) -> Result<i32, Box<dyn Error>>

Write out next frames to the given writer so long as the frame is filled

Arguments

• writer - The writer to write the frames to

Returns

• Result<(), FrameSequenceError> - Whether or not the write was successful

Errors

• If a frame could not be written

Trait Implementations

impl<T: Clone + Default + FrameValue<Output = T> + Copy + Serialize + Send + Sync + Zero + Into<f64>> Framer for FrameSequence<T>

fn ingest_event(&mut self, event: &mut Event, last_event: Option<Event>) -> bool

Examples

let mut frame_sequence: FrameSequence<u8> =
FramerBuilder::new(
            PlaneSize::new(10,10,3).unwrap(), 64)
            .codec_version(1, TimeMode::DeltaT)
            .time_parameters(50000, 1000, 1000, Some(50.0))
            .mode(INSTANTANEOUS)
            .source(U8, FramedU8)
            .finish();
let mut event: Event = Event {
        coord: Coord {
            x: 5,
            y: 5,
            c: Some(1)
        },
        d: 5,
        t: 1000
    };
frame_sequence.ingest_event(&mut event, None);
let elem = frame_sequence.px_at_current(5, 5, 1).unwrap();
assert_eq!(*elem, Some(32));

fn flush_frame_buffer(&mut self) -> bool

For all frames left that we haven’t written out yet, for any None pixels, set them to the last recorded intensity for that pixel.

Returns true if there are frames now ready to write out

type Output = T

The type of the output frame.

fn new(builder: FramerBuilder) -> Self

Create a new Framer with the given FramerBuilder.

fn ingest_events_events(&mut self, events: Vec<Vec<Event>>) -> bool

Ingest a vector of a vector of ADΔER events.