evlib 0.8.1

Event Camera Data Processing Library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

// Only compile this module when terminal feature is enabled
#![cfg(feature = "terminal")]

/*!
Python bindings for terminal visualization.

This module provides PyO3 bindings for the terminal event visualizer,
allowing Python code to use the terminal UI features.
*/

use super::terminal::{TerminalEventVisualizer, TerminalVisualizationConfig};
use crate::from_numpy_arrays;
use numpy::PyReadonlyArray1;
use pyo3::prelude::*;

/// Terminal visualization bindings (optional)
#[pyclass]
#[derive(Clone)]
pub struct PyTerminalVisualizationConfig {
    pub inner: TerminalVisualizationConfig,
}

#[pymethods]
impl PyTerminalVisualizationConfig {
    #[new]
    #[pyo3(signature = (
        event_decay_ms = None,
        max_events = None,
        target_fps = None,
        show_stats = None,
        canvas_scale = None
    ))]
    pub fn new(
        event_decay_ms: Option<f32>,
        max_events: Option<usize>,
        target_fps: Option<f32>,
        show_stats: Option<bool>,
        canvas_scale: Option<f32>,
    ) -> Self {
        let mut config = TerminalVisualizationConfig::default();

        if let Some(decay) = event_decay_ms {
            config.event_decay_ms = decay;
        }
        if let Some(max) = max_events {
            config.max_events = max;
        }
        if let Some(fps) = target_fps {
            config.target_fps = fps;
        }
        if let Some(stats) = show_stats {
            config.show_stats = stats;
        }
        if let Some(scale) = canvas_scale {
            config.canvas_scale = scale;
        }

        Self { inner: config }
    }
}

#[pyclass]
pub struct PyTerminalEventVisualizer {
    visualizer: Option<TerminalEventVisualizer>,
}

#[pymethods]
impl PyTerminalEventVisualizer {
    #[new]
    pub fn new(config: &PyTerminalVisualizationConfig) -> PyResult<Self> {
        let visualizer = TerminalEventVisualizer::new(config.inner.clone()).map_err(|e| {
            PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(format!(
                "Failed to create terminal visualizer: {}",
                e
            ))
        })?;

        Ok(Self {
            visualizer: Some(visualizer),
        })
    }

    /// Add events to the visualizer
    pub fn add_events(
        &mut self,
        xs: PyReadonlyArray1<i64>,
        ys: PyReadonlyArray1<i64>,
        ts: PyReadonlyArray1<f64>,
        ps: PyReadonlyArray1<i64>,
    ) -> PyResult<()> {
        if let Some(ref mut viz) = self.visualizer {
            let events = from_numpy_arrays(xs, ys, ts, ps);
            viz.add_events(events);
        }
        Ok(())
    }

    /// Handle input and return whether to continue
    pub fn handle_input(&mut self) -> PyResult<bool> {
        if let Some(ref mut viz) = self.visualizer {
            viz.handle_input().map_err(|e| {
                PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(format!("Input error: {}", e))
            })?;
            Ok(!viz.should_quit())
        } else {
            Ok(false)
        }
    }

    /// Render a frame
    pub fn render_frame(&mut self) -> PyResult<()> {
        if let Some(ref mut viz) = self.visualizer {
            viz.render_frame().map_err(|e| {
                PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(format!("Render error: {}", e))
            })?;
        }
        Ok(())
    }

    /// Check if should quit
    pub fn should_quit(&self) -> bool {
        self.visualizer.as_ref().map_or(true, |v| v.should_quit())
    }

    /// Check if paused
    pub fn is_paused(&self) -> bool {
        self.visualizer.as_ref().map_or(false, |v| v.is_paused())
    }

    /// Get statistics as tuple (frames_rendered, events_processed, fps)
    pub fn get_stats(&self) -> (u64, u64, f32) {
        if let Some(ref viz) = self.visualizer {
            let stats = viz.get_stats();
            (
                stats.frames_rendered,
                stats.events_processed,
                stats.current_fps,
            )
        } else {
            (0, 0, 0.0)
        }
    }
}

/// Create a terminal event stream viewer
#[pyfunction]
pub fn create_terminal_event_viewer(
    config: Option<&PyTerminalVisualizationConfig>,
) -> PyResult<PyTerminalEventVisualizer> {
    let config = config.map(|c| c.inner.clone()).unwrap_or_default();
    PyTerminalEventVisualizer::new(&PyTerminalVisualizationConfig { inner: config })
}