Crf quality (#70)

* Begin setting up naive CRF quality parameter

* Integrate the CRF parameter in adder-viz

* Add a plot to show the live count of events PPC

* Improve setting of threshold parameters with viz

* Get a test passing again

* All tests passing

* Deprecate c_thresh functions

* Add legend to plot

* Setup for feature testing on player

* Move feature detection & drawing functions out to utils

* Move feature detection & drawing functions out to utils

* Simplify cargo deps

* Some cleanup

* Some cleanup

* Start feature detection in player

* Begin implementing feature detection on the player side

* Bugfix for writing out to file

* Don't needlessly slow down when selecting a new encoder type (before selecting the output path)

* Better feature detection on player, but not great yet

* Much better feature detection on player

* Optimizations

* Fixes for standalone player

* More fixes for standalone player

* Also fix fast mode in adder-viz

* Tests passing

Author: ac-freeman

.idea/adder-codec-rs.iml

@@ -7,21 +7,38 @@ use enum_dispatch::enum_dispatch;
 use std::io;
 use std::io::{Read, Seek, Sink, Write};
 
+/// Different options for what to with the events we're given
 #[enum_dispatch(WriteCompression<W>)]
 pub enum WriteCompressionEnum<W: Write> {
+    /// Perform (possibly lossy) compression on the ADΔER stream, and arithmetic coding
     #[cfg(feature = "compression")]
     CompressedOutput(CompressedOutput<W>),
+
+    /// Write the ADΔER stream as raw events
     RawOutput(RawOutput<W>),
+
+    /// Write the ADΔER stream as raw events, but make sure that they are ordered perfectly according
+    /// to their firing times
     RawOutputInterleaved(RawOutputInterleaved<W>),
+
+    /// Do not write any data to the output stream
     EmptyOutput(EmptyOutput<Sink>),
 }
 
-#[derive(Default, Clone, Copy, PartialEq)]
+/// Specifies the output type of the encoder
+#[derive(Default, Clone, Copy, PartialEq, Debug)]
 pub enum EncoderType {
+    /// Perform (possibly lossy) compression on the ADΔER stream, and arithmetic coding
     Compressed,
+
+    /// Write the ADΔER stream as raw events
     Raw,
+
+    /// Write the ADΔER stream as raw events, but make sure that they are ordered perfectly according
+    /// to their firing times
     RawInterleaved,
 
+    /// Do not write any data to the output stream
     #[default]
     Empty,
 }

.idea/runConfigurations/Test_stable.xml

@@ -11,7 +11,7 @@ pub mod codec;
 mod codec_old;
 pub use bitstream_io;
 use bitstream_io::{BigEndian, BitReader};
-use std::cmp::{Ordering};
+use std::cmp::Ordering;
 use std::fs::File;
 use std::io::BufReader;
 use std::ops::Add;
@@ -33,7 +33,7 @@ pub enum PlaneError {
 }
 
 #[allow(missing_docs)]
-#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq)]
 pub enum SourceCamera {
     #[default]
     FramedU8,
@@ -54,7 +54,7 @@ use crate::codec::compressed::blocks::{DeltaTResidual, EventResidual};
 use crate::codec::compressed::stream::CompressedInput;
 use crate::codec::decoder::Decoder;
 use crate::codec::raw::stream::RawInput;
-use crate::codec::{CodecError};
+use crate::codec::CodecError;
 use serde::{Deserialize, Serialize};
 
 /// The type of time used in the ADΔER representation
@@ -154,6 +154,16 @@ impl PlaneSize {
     pub fn volume(&self) -> usize {
         self.area_wh() * self.channels as usize
     }
+
+    /// The smaller of the width and height dimensions
+    pub fn min_resolution(&self) -> u16 {
+        self.width.min(self.height)
+    }
+
+    /// The larger of the width and height dimensions
+    pub fn max_resolution(&self) -> u16 {
+        self.width.max(self.height)
+    }
 }
 
 /// Decimation value; a pixel's sensitivity.
@@ -173,8 +183,13 @@ pub const D_ZERO_INTEGRATION: D = 254;
 
 #[derive(Clone, Copy, PartialEq, Default)]
 pub enum Mode {
+    /// Preserve temporal coherence for framed inputs. When an event fires, the ticks
+    /// remaining for that input frame (and its associated intensity) are discarded. The
+    /// difference in time is implied since the number of ticks per input frame is constant.
     #[default]
     FramePerfect,
+
+    /// Do not do the above ^
     Continuous,
 }
 /// Precision for maximum intensity representable with allowed [`D`] values
@@ -321,6 +336,8 @@ pub const D_START: D = 7;
 /// Number of ticks elapsed since a given pixel last fired an [`Event`]
 pub type DeltaT = u32;
 
+/// Absolute firing time (in ticks) of an event. For a given pixel, this will always
+/// be grater than or equal to that of the pixel's last fired event.
 pub type AbsoluteT = u32;
 
 /// Large count of ticks (e.g., for tracking the running timestamp of a sequence of [Events](Event)
@@ -570,7 +587,14 @@ pub struct EventCoordless {
     pub delta_t: DeltaT,
 }
 
+impl Into<f64> for EventCoordless {
+    fn into(self) -> f64 {
+        panic!("Not implemented")
+    }
+}
+
 impl EventCoordless {
+    /// Get the t or dt value
     #[inline(always)]
     pub fn t(&self) -> AbsoluteT {
         self.delta_t as AbsoluteT

.idea/runConfigurations/adder_video_player.xml

@@ -20,10 +20,10 @@ default-run = "adder_simulproc"
 
 [features]
 default = ["transcoder"]
-transcoder = ["opencv", "dep:fast-math", "dep:adder-codec-core"]
+transcoder = ["opencv", "dep:fast-math", "adder-codec-core"]
 compression = ["opencv", "dep:fast-math", "adder-codec-core/compression"]
 raw-codec = []
-docs-only = ["opencv", "dep:fast-math", "dep:adder-codec-core"]
+docs-only = ["opencv", "dep:fast-math", "adder-codec-core"]
 
 
 [dependencies]

adder-codec-core/src/codec/mod.rs

@@ -48,7 +48,7 @@ fn main() {
     loop {
         match reader.digest_event(&mut bitreader) {
             Ok(mut event) => {
-                if frame_sequence.ingest_event(&mut event) {
+                if frame_sequence.ingest_event(&mut event, None) {
                     match frame_sequence.write_multi_frame_bytes(&mut output_stream) {
                         Ok(0) => {
                             panic!("Should have frame, but didn't")

adder-codec-core/src/lib.rs

@@ -174,8 +174,9 @@ mod tests {
         };
         let mut source = Framed::new(args.input_filename, args.color_input, args.scale)?
             // .chunk_rows(64)
+            .crf(0)
+            .time_parameters(5000 * 30, 5000, 120_000, Some(TimeMode::DeltaT))?
             .frame_start(args.frame_idx_start)?
-            .c_thresh_pos(args.c_thresh_pos)
             .show_display(args.show_display);
 
         let source_fps = source.source_fps;

adder-codec-rs/Cargo.toml

@@ -1,11 +1,12 @@
 use adder_codec_core::codec::decoder::Decoder;
 use adder_codec_core::codec::raw::stream::RawInput;
-use adder_codec_core::SourceCamera;
 use adder_codec_core::D_ZERO_INTEGRATION;
+use adder_codec_core::{SourceCamera, TimeMode};
 use adder_codec_rs::framer::scale_intensity::event_to_intensity;
 use adder_codec_rs::transcoder::source::video::show_display_force;
 use bitstream_io::{BigEndian, BitReader};
 use clap::Parser;
+use ndarray::{Array, Array3};
 use opencv::core::{create_continuous, Mat, MatTraitManual, CV_64F, CV_64FC3};
 use std::cmp::max;
 use std::error::Error;
@@ -72,6 +73,14 @@ fn main() -> Result<(), Box<dyn Error>> {
     let stdout = io::stdout();
     let mut handle = io::BufWriter::new(stdout.lock());
 
+    let mut last_timestamps = Array::zeros((
+        stream.meta().plane.h_usize(),
+        stream.meta().plane.w_usize(),
+        stream.meta().plane.c_usize(),
+    ));
+
+    let time_mode = stream.meta().time_mode;
+
     stream.set_input_stream_position(&mut bitreader, first_event_position)?;
 
     let mut display_mat = Mat::default();
@@ -122,15 +131,55 @@ fn main() -> Result<(), Box<dyn Error>> {
         }
 
         match stream.digest_event(&mut bitreader) {
-            Ok(event) if event.d <= D_ZERO_INTEGRATION => {
+            Ok(mut event) if event.d <= D_ZERO_INTEGRATION => {
                 event_count += 1;
                 let y = i32::from(event.coord.y);
                 let x = i32::from(event.coord.x);
                 let c = i32::from(event.coord.c.unwrap_or(0));
-                if (y | x | c) == 0x0 {
-                    current_t += event.delta_t;
+
+                if time_mode == TimeMode::AbsoluteT {
+                    if event.delta_t > current_t {
+                        current_t = event.delta_t;
+                    }
+                    let dt = event.delta_t - last_timestamps[[y as usize, x as usize, c as usize]];
+                    last_timestamps[[y as usize, x as usize, c as usize]] = event.delta_t;
+                    if last_timestamps[[y as usize, x as usize, c as usize]]
+                        % stream.meta().ref_interval
+                        != 0
+                    {
+                        last_timestamps[[y as usize, x as usize, c as usize]] = ((last_timestamps
+                            [[y as usize, x as usize, c as usize]]
+                            / stream.meta().ref_interval)
+                            + 1)
+                            * stream.meta().ref_interval;
+                    }
+                    event.delta_t = dt;
+                } else {
+                    last_timestamps[[y as usize, x as usize, c as usize]] += event.delta_t;
+                    if last_timestamps[[y as usize, x as usize, c as usize]]
+                        % stream.meta().ref_interval
+                        != 0
+                    {
+                        last_timestamps[[y as usize, x as usize, c as usize]] = ((last_timestamps
+                            [[y as usize, x as usize, c as usize]]
+                            / stream.meta().ref_interval)
+                            + 1)
+                            * stream.meta().ref_interval;
+                    }
+
+                    if last_timestamps[[y as usize, x as usize, c as usize]] > current_t {
+                        current_t = last_timestamps[[y as usize, x as usize, c as usize]];
+                    }
                 }
 
+                // else if (y | x | c) == 0x0 {
+                //     current_t += event.delta_t;
+                //     if stream.meta().source_camera == SourceCamera::FramedU8 {
+                //         current_t = ((current_t / stream.meta().ref_interval) + 1)
+                //             * stream.meta().ref_interval;
+                //     }
+                // }
+
                 let frame_intensity = (event_to_intensity(&event) * f64::from(meta.ref_interval))
                     / match meta.source_camera {
                         SourceCamera::FramedU8 => f64::from(u8::MAX),