Struct adder_codec_rs::transcoder::source::davis::Davis

pub struct Davis<W: Write> {
    pub start_of_frame_timestamp: Option<i64>,
    pub end_of_frame_timestamp: Option<i64>,
    pub rt: Runtime,
    pub dvs_last_timestamps: Array3<i64>,
    pub dvs_last_ln_val: Array3<f64>,
    pub mode: TranscoderMode,
    pub time_mode: TimeMode,
    /* private fields */
}

Attributes of a framed video -> ADΔER transcode

Fields

start_of_frame_timestamp: Option<i64>

The timestamp for the start of the APS frame exposure

end_of_frame_timestamp: Option<i64>

The timestamp for the end of the APS frame exposure

rt: Runtime

The tokio runtime

dvs_last_timestamps: Array3<i64>

The timestamp of the last DVS event integrated for each pixel

dvs_last_ln_val: Array3<f64>

The log-space last intensity value for each pixel

mode: TranscoderMode

The EDI reconstruction mode, determining how intensities are integrated for the ADΔER model

time_mode: TimeMode

The time mode of the transcoded ADΔER video

Implementations

impl<W: Write + 'static> Davis<W>

pub fn new( reconstructor: Reconstructor, rt: Runtime ) -> Result<Self, Box<dyn Error>>

Create a new Davis transcoder

pub fn optimize_adder_controller(self, optimize: bool) -> Self

Set whether to optimize the EDI controller (default: false) during EDI reconstruction.

If true, then the program will regularly re-calculate the optimal DVS contrast threshold.

pub fn mode(self, mode: TranscoderMode) -> Self

Set the TranscoderMode (default: TranscoderMode::Framed)

pub fn time_mode(self, time_mode: TimeMode) -> Self

Set the TimeMode

pub fn integrate_dvs_events<F: Fn(i64, i64) -> bool + Send + 'static + Sync>( &mut self, dvs_events: &Vec<DvsEvent>, frame_timestamp: &i64, event_check: F ) -> Result<(), CodecError>

Integrate a sequence of DVS events into the ADΔER video model

pub fn get_reconstructor(&self) -> &Reconstructor

Get an immutable reference to the Reconstructor

pub fn get_reconstructor_mut(&mut self) -> &mut Reconstructor

Get a mutable reference to the Reconstructor

Trait Implementations

impl<W: Write + 'static> Source<W> for Davis<W>

fn consume( &mut self, view_interval: u32, thread_pool: &ThreadPool ) -> Result<Vec<Vec<Event>>, SourceError>

Intake one input interval worth of data from the source stream into the ADΔER model as intensities.

fn get_video_mut(&mut self) -> &mut Video<W>

Get a mutable reference to the Video object associated with this Source.

fn get_video_ref(&self) -> &Video<W>

Get an immutable reference to the Video object associated with this Source.

fn get_video(self) -> Video<W>

Get the Video object associated with this Source, consuming the Source in the process.

impl<W: Write + 'static> VideoBuilder<W> for Davis<W>

fn contrast_thresholds(self, c_thresh_pos: u8, c_thresh_neg: u8) -> Self

Set both the positive and negative contrast thresholds

fn c_thresh_pos(self, c_thresh_pos: u8) -> Self

Set the positive contrast threshold

fn c_thresh_neg(self, c_thresh_neg: u8) -> Self

Set the negative contrast threshold

fn chunk_rows(self, chunk_rows: usize) -> Self

Set the chunk rows

fn time_parameters( self, tps: DeltaT, ref_time: DeltaT, delta_t_max: DeltaT ) -> Result<Self, SourceError>

Set the time parameters

fn write_out( self, source_camera: SourceCamera, time_mode: TimeMode, write: W ) -> Result<Box<Self>, SourceError>

Set the Encoder

fn show_display(self, show_display: bool) -> Self

Set whether or not the show the live display

impl<W: Write> Sync for Davis<W>