Struct adder_codec_rs::framer::event_framer::FrameSequence

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

Fields

chunk_rows: usize

Implementations

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

pub fn px_at_current(&self, row: usize, col: usize, channel: usize) -> &Option<T>

pub fn px_at_frame(
    &self,
    row: usize,
    col: usize,
    channel: usize,
    frame_idx: usize
) -> Result<&Option<T>, FrameSequenceError>

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

pub fn is_frame_0_filled(&self) -> Result<bool, FrameSequenceError>

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

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

pub fn write_frame_bytes(&mut self, writer: &mut BufWriter<File>)

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

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

use adder_codec_rs::SourceCamera::FramedU8;

let mut frame_sequence: FrameSequence<u8> =
FramerBuilder::new(
            10, 10, 3, 64)
            .codec_version(1)
            .time_parameters(50000, 1500, 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);
assert_eq!(*elem, Some(32));

type Output = T

fn new(builder: FramerBuilder) -> Self

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