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 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> Framer for FrameSequence<T>

fn ingest_event(&mut self, event: &mut 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, 50.0)
            .mode(INSTANTANEOUS)
            .source(U8, FramedU8)
            .finish();
let mut event: Event = Event {
        coord: Coord {
            x: 5,
            y: 5,
            c: Some(1)
        },
        d: 5,
        delta_t: 1000
    };
frame_sequence.ingest_event(&mut event);
let elem = frame_sequence.px_at_current(5, 5, 1).unwrap();
assert_eq!(*elem, Some(32));

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.