Struct adder_codec_rs::framer::driver::FrameSequence

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

Fields

state: FrameSequenceState

chunk_rows: usize

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

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>
) -> 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

use adder_codec_rs::SourceCamera::FramedU8;

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

fn new(builder: FramerBuilder) -> Self

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