Support unknown thresholds and add debug mode (#13)

Author: ferjm

Cargo.lock

@@ -5,6 +5,7 @@ edition = "2021"
 description = "GStreamer plugin to run AI/ML inference via Edge Impulse machine learning models"
 authors = ["Fernando Jiménez Moreno <[email protected]>"]
 license = "BSD-3-Clause-Clear"
+rust-version = "1.75"  # Minimum Rust version that supports edition 2024 features
 
 [lib]
 name = "gstedgeimpulse"

Cargo.toml

@@ -110,7 +110,7 @@ This plugin depends on:
 * GStreamer 1.20 or newer
 * [edge-impulse-runner-rs](https://github.com/edgeimpulse/edge-impulse-runner-rs) - Rust bindings for Edge Impulse Linux SDK
 * A trained Edge Impulse model file (.eim)
-* Rust toolchain (via rustup)
+* Rust nightly toolchain (via rustup) - required for edition 2024 support
 
 ## Installation
 
@@ -124,6 +124,12 @@ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 
 Follow the prompts to complete the installation. After installation, restart your terminal to ensure the Rust tools are in your PATH.
 
+**Note:** This plugin requires Rust nightly due to the `edge-impulse-runner` dependency using edition 2024. Switch to nightly after installation:
+
+```bash
+rustup override set nightly
+```
+
 ### 2. Install GStreamer
 Download and install GStreamer from the official binaries:
 

README.md

@@ -160,8 +160,12 @@ fn create_pipeline(args: &VideoClassifyParams) -> Result<gst::Pipeline, Box<dyn
         .build()
         .expect("Could not create queue element.");
 
-    let mut classifier_factory =
-        gst::ElementFactory::make("edgeimpulsevideoinfer").property("model-path", &args.model);
+    let mut classifier_factory = if args.debug {
+        gst::ElementFactory::make("edgeimpulsevideoinfer")
+            .property("model-path-with-debug", &args.model)
+    } else {
+        gst::ElementFactory::make("edgeimpulsevideoinfer").property("model-path", &args.model)
+    };
 
     // Set thresholds if provided
     for threshold in &args.threshold {
@@ -327,15 +331,21 @@ fn example_main() -> Result<(), Box<dyn Error>> {
                                         let y = cell["y"].as_u64().unwrap_or(0);
                                         let width = cell["width"].as_u64().unwrap_or(0);
                                         let height = cell["height"].as_u64().unwrap_or(0);
-                                        let score = cell["score"].as_f64().unwrap_or(0.0);
-                                        println!(
-                                            "    Cell at ({}, {}) size {}x{}: score {:.2}%",
-                                            x,
-                                            y,
-                                            width,
-                                            height,
-                                            score * 100.0
-                                        );
+                                        let score = cell
+                                            .get("score")
+                                            .and_then(|v| v.as_f64())
+                                            .or_else(|| cell.get("value").and_then(|v| v.as_f64()));
+                                        if let Some(score) = score {
+                                            println!(
+                                                "    Cell at ({}, {}) size {}x{}: score {:.2}%",
+                                                x, y, width, height, score
+                                            );
+                                        } else {
+                                            println!(
+                                                "    Cell at ({}, {}) size {}x{}: score N/A",
+                                                x, y, width, height
+                                            );
+                                        }
                                     }
                                 }
                             }

examples/video_inference.rs

@@ -29,6 +29,10 @@ pub fn create_common_properties() -> Vec<glib::ParamSpec> {
             .nick("Model Path")
             .blurb("Path to Edge Impulse model file")
             .build(),
+        glib::ParamSpecString::builder("model-path-with-debug")
+            .nick("Model Path With Debug")
+            .blurb("Path to Edge Impulse model file (debug mode enabled)")
+            .build(),
         glib::ParamSpecString::builder("threshold")
             .nick("Model Block Threshold")
             .blurb("Threshold value for model blocks in format 'blockId.type=value'. Examples: '5.min_score=0.6' for object detection blocks, '4.min_anomaly_score=0.35' for anomaly detection blocks. Multiple thresholds can be set by calling the property multiple times.")
@@ -50,15 +54,35 @@ pub fn set_common_property<T>(
         "model-path" => {
             let mut state = state.lock().unwrap();
             let model_path: Option<String> = value.get().expect("type checked upstream");
-
-            // Initialize the model when the path is set
             if let Some(model_path) = model_path {
-                match edge_impulse_runner::EimModel::new(&model_path) {
+                let model_result = edge_impulse_runner::EimModel::new(&model_path);
+                match model_result {
+                    Ok(model) => {
+                        gst::debug!(
+                            cat,
+                            obj = obj,
+                            "Successfully loaded model from {} (debug=false)",
+                            model_path
+                        );
+                        *state.as_mut() = Some(model);
+                    }
+                    Err(err) => {
+                        gst::error!(cat, obj = obj, "Failed to load model: {}", err);
+                    }
+                }
+            }
+        }
+        "model-path-with-debug" => {
+            let mut state = state.lock().unwrap();
+            let model_path: Option<String> = value.get().expect("type checked upstream");
+            if let Some(model_path) = model_path {
+                let model_result = edge_impulse_runner::EimModel::new_with_debug(&model_path, true);
+                match model_result {
                     Ok(model) => {
                         gst::debug!(
                             cat,
                             obj = obj,
-                            "Successfully loaded model from {}",
+                            "Successfully loaded model from {} (debug=true)",
                             model_path
                         );
                         *state.as_mut() = Some(model);
@@ -171,6 +195,7 @@ where
                 None::<String>.to_value()
             }
         }
+        "model-path-with-debug" => None::<String>.to_value(),
         "threshold" => {
             let state = state.lock().unwrap();
             if let Some(ref model) = *state.as_ref() {
@@ -200,6 +225,9 @@ where
                             } => {
                                 format!("{}.threshold={}", id, threshold)
                             }
+                            edge_impulse_runner::types::ModelThreshold::Unknown { id, unknown } => {
+                                format!("{}.unknown={}", id, unknown)
+                            }
                         })
                         .collect();
 

src/common.rs

@@ -258,8 +258,18 @@ impl ObjectSubclass for EdgeImpulseVideoInfer {
 
 impl ObjectImpl for EdgeImpulseVideoInfer {
     fn properties() -> &'static [glib::ParamSpec] {
-        static PROPERTIES: Lazy<Vec<glib::ParamSpec>> =
-            Lazy::new(crate::common::create_common_properties);
+        static PROPERTIES: Lazy<Vec<glib::ParamSpec>> = Lazy::new(|| {
+            let mut props = crate::common::create_common_properties();
+            if !props.iter().any(|p| p.name() == "model-path-with-debug") {
+                props.push(
+                    glib::ParamSpecString::builder("model-path-with-debug")
+                        .nick("Model Path With Debug")
+                        .blurb("Path to Edge Impulse model file (debug mode enabled)")
+                        .build(),
+                );
+            }
+            props
+        });
         PROPERTIES.as_ref()
     }