@camera.ui/rust-postprocessor 0.0.1 → 0.0.2

package/src/tracker.rs

@@ -1,1064 +0,0 @@
-//! Object tracker — thin wrapper around `norfair-rs` providing per-class
-//! IoU tracking with stable global track ids.
-//!
-//! Architecture: one underlying `norfair_rs::Tracker` instance per class
-//! label (Frigate's pattern). Each frame's detections are bucketed by label
-//! and dispatched to the matching sub-tracker. Track ids returned to the
-//! consumer are remapped from norfair's per-instance counter into a single
-//! globally-unique namespace owned by this struct, so different classes
-//! never collide.
-//!
-//! Lifetime model: tracks live as long as norfair's `hit_counter_max`
-//! window allows. The consumer can call `reset()` at any time to drop all
-//! per-class trackers and start fresh — used to align tracker state with
-//! external segment boundaries (e.g. cascade activate/deactivate in the
-//! detection coordinator).
-
-use std::collections::{HashMap, HashSet};
-
-use nalgebra::DMatrix;
-use norfair_rs::distances::distance_function_by_name;
-use norfair_rs::{Detection as NfDetection, Tracker, TrackerConfig};
-
-use crate::line_crossing::{
-  prepare_lines, segment_intersection, CrossingDirection, DetectionLineInput, LineCrossingEvent,
-  LineDirectionFilter, PreparedLine,
-};
-use crate::types::{Detection, TrackedDetection};
-use crate::zone_filter::{filter_indices, prepare_zones, PreparedZones, ZoneInput};
-
-/// Move items out of `src` at the given sorted indices. Avoids cloning.
-fn extract_by_indices(mut src: Vec<Detection>, indices: &[u32]) -> Vec<Detection> {
-  if indices.len() == src.len() {
-    return src; // all kept — no work needed
-  }
-  let mut out = Vec::with_capacity(indices.len());
-  // Mark slots to keep, then drain in-order via swap with sentinel.
-  // Since Detection has a String (label), we use Option to take ownership.
-  let mut slots: Vec<Option<Detection>> = src.drain(..).map(Some).collect();
-  for &i in indices {
-    if let Some(det) = slots[i as usize].take() {
-      out.push(det);
-    }
-  }
-  out
-}
-
-/// Configuration for [`ObjectTracker`].
-#[derive(Debug, Clone)]
-pub struct ObjectTrackerConfig {
-  /// IoU threshold below which a candidate detection is considered a match
-  /// for an existing track. Higher = stricter. Typical values: 0.3 — 0.5.
-  pub iou_threshold: f32,
-  /// Frames a track survives without a fresh detection before being
-  /// dropped (Kalman extrapolation continues during this window). Higher
-  /// values bridge longer occlusions at the cost of stale tracks.
-  pub hit_counter_max: i32,
-  /// Frames a new track must be matched before it gets a permanent id
-  /// (filters one-frame false positives).
-  pub initialization_delay: i32,
-  /// Frames a dead track (hit_counter < 0) stays available for ReID
-  /// re-matching. When a new detection appears near a dead track, norfair
-  /// merges them — the old track ID is preserved and the Kalman filter is
-  /// replaced with the new track's state. Set to 0 or None to disable.
-  pub reid_hit_counter_max: Option<i32>,
-}
-
-impl Default for ObjectTrackerConfig {
-  fn default() -> Self {
-    Self {
-      iou_threshold: 0.3,
-      hit_counter_max: 15,
-      initialization_delay: 3,
-      reid_hit_counter_max: None,
-    }
-  }
-}
-
-/// One norfair sub-tracker plus its local-id → global-id remapping.
-struct ClassTracker {
-  tracker: Tracker,
-  /// Maps norfair's internal `global_id` (which is per-tracker-instance) to
-  /// the externally-visible track id we hand back to the consumer.
-  id_map: HashMap<i32, u32>,
-  /// Previous-frame centroid `(cx, cy)` per track, used for the line
-  /// crossing prev→curr segment. Updated at the end of every frame.
-  prev_centroid_map: HashMap<u32, (f32, f32)>,
-}
-
-/// Payload embedded in each norfair Detection's `data` field. After
-/// `tracker.update()`, we check each TrackedObject's `last_detection.data`
-/// — if its `frame_seq` matches the current frame, the track was matched.
-/// This is 100% reliable regardless of hit_counter semantics or sustain mode.
-#[derive(Debug, Clone)]
-struct FrameTag {
-  frame_seq: u64,
-}
-
-/// Result of one frame of [`ObjectTracker::update`].
-#[derive(Debug, Default)]
-pub struct UpdateResult {
-  pub tracked: Vec<TrackedDetection>,
-  pub crossings: Vec<LineCrossingEvent>,
-}
-
-/// Multi-class object tracker.
-pub struct ObjectTracker {
-  config: ObjectTrackerConfig,
-  trackers: HashMap<String, ClassTracker>,
-  next_track_id: u32,
-  prepared_lines: Vec<PreparedLine>,
-  /// `(track_id, line_name)` set tracking which crossings have already
-  /// fired, so a single track can't trigger the same line twice in its
-  /// lifetime.
-  crossing_memory: HashSet<(u32, String)>,
-  /// Configured detection zones (privacy masks + active include/exclude
-  /// regions). Empty when no zones are set, in which case `update()`
-  /// only applies the confidence threshold to incoming detections.
-  prepared_zones: PreparedZones,
-  /// Minimum detection confidence — detections below this threshold are
-  /// dropped before they reach the tracker.
-  min_confidence: f32,
-  /// Monotonically increasing frame counter. Embedded in each Detection's
-  /// `data` field so we can reliably determine "matched this frame" after
-  /// `tracker.update()` — independent of hit_counter semantics.
-  frame_seq: u64,
-  /// Reusable scratch buffer for per-frame label bucketing. Cleared and
-  /// re-populated in every `update()` call — avoids re-allocating the
-  /// HashMap on every frame.
-  by_label: HashMap<String, Vec<Detection>>,
-}
-
-impl ObjectTracker {
-  pub fn new(config: ObjectTrackerConfig) -> Self {
-    Self {
-      config,
-      trackers: HashMap::new(),
-      next_track_id: 1,
-      prepared_lines: Vec::new(),
-      crossing_memory: HashSet::new(),
-      prepared_zones: PreparedZones::default(),
-      min_confidence: 0.0,
-      frame_seq: 0,
-      by_label: HashMap::new(),
-    }
-  }
-
-  /// Replace the configured detection zones (privacy masks + include/
-  /// exclude regions). Pass an empty list to disable zone filtering
-  /// entirely. Coordinates are in `[0, 100]` UI space — internally
-  /// normalized to `[0.0, 1.0]` and the polygon is auto-closed.
-  pub fn set_zones(&mut self, zones: Vec<ZoneInput>) {
-    self.prepared_zones = prepare_zones(&zones);
-  }
-
-  /// Set the global minimum confidence threshold. Detections below this
-  /// score are dropped before they enter the tracker.
-  pub fn set_min_confidence(&mut self, min_confidence: f32) {
-    self.min_confidence = min_confidence.max(0.0);
-  }
-
-  /// Apply the configured zones + confidence threshold to a list of
-  /// detections WITHOUT advancing the tracker state. Returns the indices
-  /// of the detections that pass the filter — the caller can then map
-  /// the indices back onto a parallel array of richer values (face/lpd
-  /// items wrapped as Detection with a substitute label).
-  ///
-  /// Used for the external sensor write path where a plugin reports
-  /// detections directly and we need to apply zone filtering without
-  /// running the full tracker.
-  pub fn filter_indices(&self, detections: &[Detection]) -> Vec<u32> {
-    filter_indices(detections, &self.prepared_zones, self.min_confidence)
-  }
-
-  /// Replace the configured crossing lines. The aspect ratio is the
-  /// camera's `width / height`, used so the perpendicular crossing line
-  /// matches what the user drew in visual space.
-  ///
-  /// Crossing memory is cleared on every reconfigure — re-firing the same
-  /// crossing event for an existing track immediately after a line edit
-  /// is the desired behavior so the user can validate their changes.
-  pub fn set_lines(&mut self, lines: Vec<DetectionLineInput>, aspect_ratio: f32) {
-    self.prepared_lines = prepare_lines(&lines, aspect_ratio);
-    self.crossing_memory.clear();
-  }
-
-  /// Set how many frames a dead track stays available for ReID re-matching.
-  /// Pass 0 or negative to disable ReID entirely. When enabled, tracks
-  /// that expire (hit_counter < 0) enter a ReID phase where they can be
-  /// re-matched to new detections via IoU — preserving the old track ID.
-  pub fn set_reid_hit_counter_max(&mut self, frames: i32) {
-    let value = if frames > 0 { Some(frames) } else { None };
-    self.config.reid_hit_counter_max = value;
-    // Update all existing sub-trackers
-    for class in self.trackers.values_mut() {
-      class.tracker.config.reid_hit_counter_max = value;
-    }
-  }
-
-  /// Refresh the ReID counter for all dead tracks back to max. Call this
-  /// every frame while an external cascade is active — dead tracks will
-  /// never expire as long as the cascade keeps refreshing them. When the
-  /// cascade ends, stop calling this and tracks expire naturally.
-  pub fn refresh_reid(&mut self) {
-    let max = match self.config.reid_hit_counter_max {
-      Some(m) => m,
-      None => return,
-    };
-    for class in self.trackers.values_mut() {
-      for obj in &mut class.tracker.tracked_objects {
-        if obj.hit_counter < 0 {
-          if let Some(ref mut rc) = obj.reid_hit_counter {
-            *rc = max;
-          }
-        }
-      }
-    }
-  }
-
-  /// Drop all tracks across all classes. The next call to `update` starts
-  /// from a clean slate; track ids restart from 1.
-  pub fn reset(&mut self) {
-    self.trackers.clear();
-    self.next_track_id = 1;
-    self.crossing_memory.clear();
-  }
-
-  /// Total number of active tracks across all class trackers — useful for
-  /// diagnostics.
-  pub fn track_count(&self) -> usize {
-    self
-      .trackers
-      .values()
-      .map(|c| c.tracker.tracked_objects.len())
-      .sum()
-  }
-
-  /// Process a frame's detections and return the active tracks plus any
-  /// line-crossing events that fired this frame.
-  ///
-  /// Pipeline applied to the input list:
-  ///   1. Confidence threshold filter (`min_confidence`).
-  ///   2. Zone filter (privacy masks + include/exclude regions).
-  ///   3. Per-class IoU + Kalman tracker (`norfair-rs`).
-  ///   4. Line-crossing detection.
-  ///
-  /// `timestamp_ms` is forwarded onto the emitted crossing events so the
-  /// consumer can sequence them with external state. The tracker itself
-  /// doesn't use it.
-  pub fn update(&mut self, detections: Vec<Detection>, timestamp_ms: f64) -> UpdateResult {
-    self.frame_seq += 1;
-
-    // Steps 1+2: drop detections that fail the confidence threshold or
-    // sit outside any configured zones. Use filter_indices + index-based
-    // extraction to move detections out of the original Vec without
-    // cloning any label Strings.
-    let detections = {
-      let indices = filter_indices(&detections, &self.prepared_zones, self.min_confidence);
-      extract_by_indices(detections, &indices)
-    };
-
-    let mut tracked: Vec<TrackedDetection> = Vec::new();
-
-    if detections.is_empty() {
-      // Even with no detections we still tick all sub-trackers so their
-      // Kalman filters extrapolate and aging works correctly.
-      tracked.extend(self.tick_empty(timestamp_ms));
-    } else {
-      // Bucket detections by class label. Reuse the struct-level HashMap
-      // (clear + re-populate) so we don't allocate a new one every frame.
-      // The inner Vec buffers are also reused across frames.
-      for vec in self.by_label.values_mut() {
-        vec.clear();
-      }
-      for det in detections {
-        self
-          .by_label
-          .entry(det.label.clone())
-          .or_default()
-          .push(det);
-      }
-
-      // Collect labels that need ticking: existing trackers without
-      // detections this frame get an empty update, labels with detections
-      // get their bucket. We collect keys upfront to avoid borrowing
-      // `self.trackers` / `self.by_label` while calling `run_class`.
-      let empty_labels: Vec<String> = self
-        .trackers
-        .keys()
-        .filter(|k| self.by_label.get(k.as_str()).is_none_or(|v| v.is_empty()))
-        .cloned()
-        .collect();
-      for label in &empty_labels {
-        tracked.extend(self.run_class(label, Vec::new(), timestamp_ms));
-      }
-
-      let active_labels: Vec<String> = self
-        .by_label
-        .keys()
-        .filter(|k| !self.by_label[k.as_str()].is_empty())
-        .cloned()
-        .collect();
-      for label in active_labels {
-        let dets = std::mem::take(self.by_label.get_mut(&label).unwrap());
-        tracked.extend(self.run_class(&label, dets, timestamp_ms));
-      }
-    }
-
-    // Line crossing: only compute when lines are configured. Skip the
-    // centroid history bookkeeping entirely when there are no lines — it
-    // would just accumulate entries that are never read.
-    let crossings = if self.prepared_lines.is_empty() {
-      Vec::new()
-    } else {
-      let c = self.compute_crossings(&tracked, timestamp_ms);
-      self.refresh_centroid_history(&tracked);
-      self.gc_crossing_memory();
-      c
-    };
-
-    UpdateResult { tracked, crossings }
-  }
-
-  /// Tick every sub-tracker with an empty detection list. Used when the
-  /// consumer reports zero detections for a frame.
-  fn tick_empty(&mut self, timestamp_ms: f64) -> Vec<TrackedDetection> {
-    let labels: Vec<String> = self.trackers.keys().cloned().collect();
-    let mut output = Vec::new();
-    for label in labels {
-      output.extend(self.run_class(&label, Vec::new(), timestamp_ms));
-    }
-    output
-  }
-
-  /// Walk every tracked detection's prev → current centroid segment and
-  /// emit one event per (line × first crossing) pair. Memory is updated
-  /// in-place so each (track_id, line_name) only fires once.
-  fn compute_crossings(
-    &mut self,
-    tracked: &[TrackedDetection],
-    timestamp_ms: f64,
-  ) -> Vec<LineCrossingEvent> {
-    if self.prepared_lines.is_empty() || tracked.is_empty() {
-      return Vec::new();
-    }
-    let mut events = Vec::new();
-
-    for det in tracked {
-      // Look up previous centroid via the per-class store. We have to
-      // know which class bucket holds this track id — since trackers are
-      // keyed by label and we have det.label, that's a direct lookup.
-      let class = match self.trackers.get(&det.label) {
-        Some(c) => c,
-        None => continue,
-      };
-      let prev = match class.prev_centroid_map.get(&det.track_id) {
-        Some(&p) => p,
-        None => continue, // first frame for this track — no segment yet
-      };
-      let curr_cx = det.x + det.width * 0.5;
-      let curr_cy = det.y + det.height * 0.5;
-      // Skip degenerate "no movement" updates — they can't cross anything
-      // and just waste cycles.
-      if (prev.0 - curr_cx).abs() < 1e-9 && (prev.1 - curr_cy).abs() < 1e-9 {
-        continue;
-      }
-
-      let det_label_lc = det.label.to_lowercase();
-      for line in &self.prepared_lines {
-        if !line.labels.is_empty() && !line.labels.contains(&det_label_lc) {
-          continue;
-        }
-        let memory_key = (det.track_id, line.name.clone());
-        if self.crossing_memory.contains(&memory_key) {
-          continue;
-        }
-
-        let cross = segment_intersection(
-          prev.0,
-          prev.1,
-          curr_cx,
-          curr_cy,
-          line.line_a[0],
-          line.line_a[1],
-          line.line_b[0],
-          line.line_b[1],
-        );
-        if cross == 0.0 {
-          continue;
-        }
-
-        let direction = if cross > 0.0 {
-          CrossingDirection::AToB
-        } else {
-          CrossingDirection::BToA
-        };
-        let allowed = match line.direction {
-          LineDirectionFilter::Both => true,
-          LineDirectionFilter::AToB => direction == CrossingDirection::AToB,
-          LineDirectionFilter::BToA => direction == CrossingDirection::BToA,
-        };
-        if !allowed {
-          continue;
-        }
-
-        self.crossing_memory.insert(memory_key);
-        events.push(LineCrossingEvent {
-          line_name: line.name.clone(),
-          direction,
-          track_id: det.track_id,
-          label: det.label.clone(),
-          confidence: det.confidence,
-          timestamp_ms,
-          prev_pos: [prev.0, prev.1],
-          curr_pos: [curr_cx, curr_cy],
-        });
-      }
-    }
-
-    events
-  }
-
-  /// After crossings have been computed, store the latest centroid for
-  /// each track so the next frame has a "previous" to compare against.
-  fn refresh_centroid_history(&mut self, tracked: &[TrackedDetection]) {
-    // Group ids by class first to do fewer hashmap lookups.
-    let mut by_class: HashMap<String, Vec<(u32, f32, f32)>> = HashMap::new();
-    for det in tracked {
-      let cx = det.x + det.width * 0.5;
-      let cy = det.y + det.height * 0.5;
-      by_class
-        .entry(det.label.clone())
-        .or_default()
-        .push((det.track_id, cx, cy));
-    }
-    for (label, entries) in by_class {
-      if let Some(class) = self.trackers.get_mut(&label) {
-        for (id, cx, cy) in entries {
-          class.prev_centroid_map.insert(id, (cx, cy));
-        }
-      }
-    }
-  }
-
-  /// Drop crossing memory entries whose track id has expired. Without
-  /// this the set would grow unboundedly across a long-running tracker.
-  fn gc_crossing_memory(&mut self) {
-    if self.crossing_memory.is_empty() {
-      return;
-    }
-    let mut alive: HashSet<u32> = HashSet::new();
-    for class in self.trackers.values() {
-      for id in class.id_map.values() {
-        alive.insert(*id);
-      }
-    }
-    self
-      .crossing_memory
-      .retain(|(track_id, _)| alive.contains(track_id));
-  }
-
-  /// Run one frame through the sub-tracker for `label`, creating it if it
-  /// doesn't exist yet.
-  fn run_class(
-    &mut self,
-    label: &str,
-    detections: Vec<Detection>,
-    _timestamp_ms: f64,
-  ) -> Vec<TrackedDetection> {
-    let current_frame = self.frame_seq;
-
-    // Lazily construct sub-tracker on first sight of a class.
-    if !self.trackers.contains_key(label) {
-      let nf_config = self.build_nf_config();
-      let tracker = match Tracker::new(nf_config) {
-        Ok(t) => t,
-        Err(_) => return Vec::new(),
-      };
-      self.trackers.insert(
-        label.to_string(),
-        ClassTracker {
-          tracker,
-          id_map: HashMap::new(),
-          prev_centroid_map: HashMap::new(),
-        },
-      );
-    }
-
-    // Convert Detection → norfair Detection. All detections in a frame
-    // share a single Arc<FrameTag> — one allocation instead of N.
-    let tag: std::sync::Arc<dyn std::any::Any + Send + Sync> = std::sync::Arc::new(FrameTag {
-      frame_seq: current_frame,
-    });
-    let nf_detections: Vec<NfDetection> = detections
-      .iter()
-      .filter_map(|det| {
-        let x2 = det.x + det.width;
-        let y2 = det.y + det.height;
-        let points =
-          DMatrix::from_row_slice(1, 4, &[det.x as f64, det.y as f64, x2 as f64, y2 as f64]);
-        let mut nf = NfDetection::new(points).ok()?;
-        nf.label = Some(det.label.clone());
-        nf.scores = Some(vec![det.confidence as f64]);
-        nf.data = Some(tag.clone());
-        Some(nf)
-      })
-      .collect();
-
-    let class = self.trackers.get_mut(label).expect("inserted above");
-    let active = class.tracker.update(nf_detections, 1, None);
-
-    // Snapshot data from norfair tracked objects before releasing borrow.
-    struct Raw {
-      norfair_global_id: i32,
-      x1: f64,
-      y1: f64,
-      x2: f64,
-      y2: f64,
-      confidence: f32,
-      age: u32,
-      speed: f32,
-      /// True when last_detection carries the current frame's FrameTag.
-      matched_this_frame: bool,
-    }
-    let raw: Vec<Raw> = active
-      .into_iter()
-      .filter_map(|obj| {
-        let est = &obj.estimate;
-        if est.ncols() < 4 || est.nrows() < 1 {
-          return None;
-        }
-        let confidence = obj
-          .last_detection
-          .as_ref()
-          .and_then(|d| d.scores.as_ref())
-          .and_then(|s| s.first().copied())
-          .unwrap_or(0.0) as f32;
-        let vel = &obj.estimate_velocity;
-        let speed = if vel.ncols() >= 4 && vel.nrows() >= 1 {
-          let vcx = ((vel[(0, 0)] + vel[(0, 2)]) / 2.0) as f32;
-          let vcy = ((vel[(0, 1)] + vel[(0, 3)]) / 2.0) as f32;
-          (vcx * vcx + vcy * vcy).sqrt()
-        } else {
-          0.0
-        };
-        let matched_this_frame = obj
-          .last_detection
-          .as_ref()
-          .and_then(|d| d.data.as_ref())
-          .and_then(|d| d.downcast_ref::<FrameTag>())
-          .is_some_and(|tag| tag.frame_seq == current_frame);
-
-        Some(Raw {
-          norfair_global_id: obj.global_id,
-          x1: est[(0, 0)],
-          y1: est[(0, 1)],
-          x2: est[(0, 2)],
-          y2: est[(0, 3)],
-          confidence,
-          age: obj.age.max(0) as u32,
-          speed,
-          matched_this_frame,
-        })
-      })
-      .collect();
-
-    // Build output TrackedDetections. Allocate the label String once and
-    // clone it for each track — avoids repeated `label.to_string()` calls.
-    let label_owned = label.to_string();
-    let mut output: Vec<TrackedDetection> = Vec::with_capacity(raw.len());
-    for r in raw {
-      let track_id = match class.id_map.get(&r.norfair_global_id) {
-        Some(&id) => id,
-        None => {
-          let id = self.next_track_id;
-          self.next_track_id = self.next_track_id.wrapping_add(1).max(1);
-          class.id_map.insert(r.norfair_global_id, id);
-          id
-        }
-      };
-      let width = (r.x2 - r.x1).max(0.0) as f32;
-      let height = (r.y2 - r.y1).max(0.0) as f32;
-
-      output.push(TrackedDetection {
-        x: r.x1 as f32,
-        y: r.y1 as f32,
-        width,
-        height,
-        confidence: r.confidence,
-        label: label_owned.clone(),
-        track_id,
-        track_age: r.age,
-        track_lost: !r.matched_this_frame,
-        track_speed: r.speed,
-      });
-    }
-
-    // Garbage-collect remap entries for tracks no longer in norfair's store
-    // (neither active NOR in ReID phase). We must keep id_map entries for
-    // ReID-phase tracks (hit_counter < 0 but still in tracked_objects) so
-    // that when norfair merges them back, the old track_id is preserved.
-    let norfair_alive: HashSet<i32> = class
-      .tracker
-      .tracked_objects
-      .iter()
-      .map(|o| o.global_id)
-      .collect();
-    class
-      .id_map
-      .retain(|nf_id, _| norfair_alive.contains(nf_id));
-    let mapped_ids: HashSet<u32> = class.id_map.values().copied().collect();
-    class
-      .prev_centroid_map
-      .retain(|k, _| mapped_ids.contains(k));
-
-    output
-  }
-
-  fn build_nf_config(&self) -> TrackerConfig {
-    // norfair's IoU distance returns 1 - IoU, so the threshold for matching
-    // is "1 - iou_threshold". A configured iou_threshold of 0.3 means a
-    // detection matches a track when IoU >= 0.3, i.e. distance < 0.7.
-    let distance_threshold = (1.0 - self.config.iou_threshold).max(0.0) as f64;
-    let mut cfg = TrackerConfig::new(distance_function_by_name("iou"), distance_threshold);
-    cfg.hit_counter_max = self.config.hit_counter_max;
-    cfg.initialization_delay = self.config.initialization_delay;
-
-    // ReID: when a track dies (hit_counter < 0), keep it for re-matching
-    // using the same IoU distance function. A new detection near the dead
-    // track's last estimate triggers merge() → old ID preserved, new
-    // Kalman state replaces old (no drift problem).
-    if let Some(reid_max) = self.config.reid_hit_counter_max {
-      cfg.reid_distance_function = Some(distance_function_by_name("iou"));
-      cfg.reid_distance_threshold = distance_threshold;
-      cfg.reid_hit_counter_max = Some(reid_max);
-    }
-
-    cfg
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use super::*;
-
-  fn det(x: f32, y: f32, w: f32, h: f32, label: &str) -> Detection {
-    Detection {
-      x,
-      y,
-      width: w,
-      height: h,
-      confidence: 0.9,
-      label: label.to_string(),
-    }
-  }
-
-  #[test]
-  fn assigns_ids_to_new_detections() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 5,
-      initialization_delay: 0,
-      ..Default::default()
-    });
-    let res = t.update(vec![det(0.1, 0.1, 0.2, 0.2, "person")], 0.0);
-    assert!(!res.tracked.is_empty());
-    assert!(res.tracked[0].track_id >= 1);
-  }
-
-  #[test]
-  fn maintains_id_across_frames() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 5,
-      initialization_delay: 0,
-      ..Default::default()
-    });
-    let res1 = t.update(vec![det(0.1, 0.1, 0.2, 0.2, "person")], 0.0);
-    let res2 = t.update(vec![det(0.11, 0.11, 0.2, 0.2, "person")], 1.0);
-    if !res1.tracked.is_empty() && !res2.tracked.is_empty() {
-      assert_eq!(res1.tracked[0].track_id, res2.tracked[0].track_id);
-    }
-  }
-
-  #[test]
-  fn different_classes_get_different_ids() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 5,
-      initialization_delay: 0,
-      ..Default::default()
-    });
-    let res = t.update(
-      vec![
-        det(0.1, 0.1, 0.2, 0.2, "person"),
-        det(0.5, 0.5, 0.2, 0.2, "car"),
-      ],
-      0.0,
-    );
-    let ids: std::collections::HashSet<u32> = res.tracked.iter().map(|d| d.track_id).collect();
-    assert_eq!(ids.len(), 2);
-  }
-
-  #[test]
-  fn matched_frame_not_lost() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 5,
-      initialization_delay: 0,
-      ..Default::default()
-    });
-    let r1 = t.update(vec![det(0.1, 0.1, 0.2, 0.2, "person")], 0.0);
-    let r2 = t.update(vec![det(0.11, 0.11, 0.2, 0.2, "person")], 1.0);
-    let r3 = t.update(vec![det(0.12, 0.12, 0.2, 0.2, "person")], 2.0);
-    assert!(
-      !r1.tracked.is_empty() && !r1.tracked[0].track_lost,
-      "first frame must be matched"
-    );
-    assert!(
-      !r2.tracked.is_empty() && !r2.tracked[0].track_lost,
-      "second matched frame"
-    );
-    assert!(
-      !r3.tracked.is_empty() && !r3.tracked[0].track_lost,
-      "third matched frame"
-    );
-  }
-
-  #[test]
-  fn unmatched_frame_marked_lost() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 5,
-      initialization_delay: 0,
-      ..Default::default()
-    });
-    let _ = t.update(vec![det(0.1, 0.1, 0.2, 0.2, "person")], 0.0);
-    let _ = t.update(vec![det(0.11, 0.11, 0.2, 0.2, "person")], 1.0);
-    let res = t.update(Vec::new(), 2.0);
-    if !res.tracked.is_empty() {
-      assert!(res.tracked[0].track_lost, "unmatched frame must be lost");
-    }
-  }
-
-  #[test]
-  fn reset_clears_state() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 5,
-      initialization_delay: 0,
-      ..Default::default()
-    });
-    t.update(vec![det(0.1, 0.1, 0.2, 0.2, "person")], 0.0);
-    assert!(t.track_count() >= 1);
-    t.reset();
-    assert_eq!(t.track_count(), 0);
-  }
-
-  #[test]
-  fn line_crossing_a_to_b() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 5,
-      initialization_delay: 0,
-      ..Default::default()
-    });
-    // Vertical handle at x=50 in 0..100 UI space → perpendicular crossing
-    // line is horizontal across the middle.
-    t.set_lines(
-      vec![DetectionLineInput {
-        name: "gate".to_string(),
-        direction: LineDirectionFilter::Both,
-        labels: vec![],
-        points: [[30.0, 50.0], [70.0, 50.0]],
-      }],
-      16.0 / 9.0,
-    );
-
-    // Move a person across the perpendicular line. Track centroid moves
-    // from (0.4, 0.5) to (0.6, 0.5) — crossing the horizontal line at y=0.5.
-    // Centroid (0.45, 0.5) → (0.55, 0.5). Boxes overlap enough for IoU
-    // matching (~0.33) and the track segment crosses the vertical line at
-    // x=0.5 between y=0.3 and y=0.7.
-    let r1 = t.update(vec![det(0.35, 0.40, 0.20, 0.20, "person")], 0.0);
-    assert_eq!(r1.crossings.len(), 0, "first frame: no prev → no crossing");
-    let r2 = t.update(vec![det(0.45, 0.40, 0.20, 0.20, "person")], 1.0);
-    assert_eq!(r2.crossings.len(), 1, "movement should fire one crossing");
-    let crossing = &r2.crossings[0];
-    assert_eq!(crossing.line_name, "gate");
-    assert_eq!(crossing.label, "person");
-  }
-
-  #[test]
-  fn line_crossing_label_filter() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 5,
-      initialization_delay: 0,
-      ..Default::default()
-    });
-    t.set_lines(
-      vec![DetectionLineInput {
-        name: "vehicle-only".to_string(),
-        direction: LineDirectionFilter::Both,
-        labels: vec!["car".to_string()],
-        points: [[30.0, 50.0], [70.0, 50.0]],
-      }],
-      16.0 / 9.0,
-    );
-    let _ = t.update(vec![det(0.35, 0.40, 0.20, 0.20, "person")], 0.0);
-    let r2 = t.update(vec![det(0.45, 0.40, 0.20, 0.20, "person")], 1.0);
-    assert_eq!(
-      r2.crossings.len(),
-      0,
-      "person should not match vehicle-only line"
-    );
-  }
-
-  #[test]
-  fn track_speed_static_then_moving() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 5,
-      initialization_delay: 0,
-      ..Default::default()
-    });
-    // Static frames — Kalman velocity should be ~0.
-    let r1 = t.update(vec![det(0.10, 0.10, 0.20, 0.20, "person")], 0.0);
-    assert_eq!(r1.tracked.len(), 1);
-    assert!(
-      r1.tracked[0].track_speed < 0.01,
-      "first frame speed should be ~0"
-    );
-
-    let r2 = t.update(vec![det(0.10, 0.10, 0.20, 0.20, "person")], 100.0);
-    assert!(
-      r2.tracked[0].track_speed < 0.01,
-      "static frame speed should be ~0"
-    );
-
-    // Move consistently for several frames so Kalman velocity builds up.
-    // Each step moves +0.05 in x.
-    let mut last_speed = 0.0f32;
-    for i in 2..8 {
-      let x = 0.10 + (i - 1) as f32 * 0.05;
-      let r = t.update(vec![det(x, 0.10, 0.20, 0.20, "person")], (i * 100) as f64);
-      last_speed = r.tracked[0].track_speed;
-    }
-    assert!(
-      last_speed > 0.001,
-      "expected Kalman velocity > 0 after sustained movement, got {}",
-      last_speed
-    );
-  }
-
-  #[test]
-  fn tracked_detection_carries_input_confidence() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 5,
-      initialization_delay: 0,
-      ..Default::default()
-    });
-    let mut d = det(0.10, 0.10, 0.20, 0.20, "person");
-    d.confidence = 0.87;
-    let r = t.update(vec![d], 0.0);
-    assert!(!r.tracked.is_empty());
-    // Confidence flowing through norfair's scores -> TrackedDetection.confidence
-    assert!(
-      (r.tracked[0].confidence - 0.87).abs() < 1e-3,
-      "expected ~0.87, got {}",
-      r.tracked[0].confidence
-    );
-  }
-
-  #[test]
-  fn confidence_threshold_drops_low_score() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 5,
-      initialization_delay: 0,
-      ..Default::default()
-    });
-    t.set_min_confidence(0.5);
-    let mut low = det(0.1, 0.1, 0.2, 0.2, "person");
-    low.confidence = 0.4;
-    let mut high = det(0.5, 0.5, 0.2, 0.2, "person");
-    high.confidence = 0.8;
-    let res = t.update(vec![low, high], 0.0);
-    assert_eq!(res.tracked.len(), 1);
-    assert!((res.tracked[0].x - 0.5).abs() < 1e-6);
-  }
-
-  #[test]
-  fn zone_exclude_drops_detection_in_zone() {
-    use crate::zone_filter::{ZoneFilterMode, ZoneInput, ZoneMatchType};
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 5,
-      initialization_delay: 0,
-      ..Default::default()
-    });
-    t.set_zones(vec![ZoneInput {
-      labels: vec![],
-      filter: ZoneFilterMode::Exclude,
-      match_type: ZoneMatchType::Intersect,
-      is_privacy_mask: false,
-      // Top-left quadrant
-      points: vec![[0.0, 0.0], [50.0, 0.0], [50.0, 50.0], [0.0, 50.0]],
-    }]);
-    let inside = det(0.10, 0.10, 0.20, 0.20, "person"); // dropped
-    let outside = det(0.60, 0.60, 0.20, 0.20, "person"); // kept
-    let res = t.update(vec![inside, outside], 0.0);
-    assert_eq!(res.tracked.len(), 1);
-    assert!(res.tracked[0].x > 0.5);
-  }
-
-  #[test]
-  fn line_crossing_only_fires_once_per_track() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 5,
-      initialization_delay: 0,
-      ..Default::default()
-    });
-    t.set_lines(
-      vec![DetectionLineInput {
-        name: "gate".to_string(),
-        direction: LineDirectionFilter::Both,
-        labels: vec![],
-        points: [[30.0, 50.0], [70.0, 50.0]],
-      }],
-      16.0 / 9.0,
-    );
-    let _ = t.update(vec![det(0.35, 0.40, 0.20, 0.20, "person")], 0.0);
-    let r2 = t.update(vec![det(0.45, 0.40, 0.20, 0.20, "person")], 1.0);
-    // After crossing, keep moving — same track id, but the line memory
-    // must prevent a second event for this (track, line) pair.
-    let r3 = t.update(vec![det(0.55, 0.40, 0.20, 0.20, "person")], 2.0);
-    assert_eq!(r2.crossings.len(), 1);
-    assert_eq!(r3.crossings.len(), 0, "memory should suppress repeat");
-  }
-
-  #[test]
-  fn track_expires_without_reid() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 3,
-      initialization_delay: 0,
-      ..Default::default() // reid_hit_counter_max: None
-    });
-    let _ = t.update(vec![det(0.1, 0.1, 0.2, 0.2, "person")], 0.0);
-    let _ = t.update(vec![det(0.11, 0.11, 0.2, 0.2, "person")], 100.0);
-
-    let mut alive_count = 0;
-    for i in 2..20 {
-      let r = t.update(Vec::new(), (i * 100) as f64);
-      if !r.tracked.is_empty() {
-        alive_count += 1;
-      }
-    }
-    assert!(
-      alive_count < 18,
-      "without ReID, track should expire (alive for {} frames)",
-      alive_count
-    );
-  }
-
-  #[test]
-  fn reid_preserves_id_after_gap() {
-    // ReID: track dies after hit_counter_max, enters ReID phase.
-    // When person reappears, norfair merges → old ID preserved.
-    // initialization_delay=1 is required so the new track enters the
-    // "initializing" phase — norfair's ReID Stage 5 only matches
-    // dead tracks against newly-matched INITIALIZING objects.
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 3,
-      initialization_delay: 1,
-      reid_hit_counter_max: Some(20),
-      ..Default::default()
-    });
-
-    // Establish track (need init_delay+1 frames to fully initialize)
-    let _ = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 0.0);
-    let r2 = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 100.0);
-    assert_eq!(r2.tracked.len(), 1);
-    let id = r2.tracked[0].track_id;
-    let _ = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 200.0);
-
-    // Disappear for 10 frames — exceeds hit_counter_max=3, track "dies"
-    // but stays in ReID phase (reid_hit_counter_max=20)
-    for i in 3..13 {
-      t.update(Vec::new(), (i * 100) as f64);
-    }
-
-    // Reappear at same position — ReID should match and restore old ID.
-    // First frame: new initializing track created.
-    // Second frame: norfair promotes it → ReID matches with dead track → merge.
-    let _ = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 1300.0);
-    let r_back = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 1400.0);
-
-    let found = r_back.tracked.iter().any(|t| t.track_id == id);
-    assert!(
-      found,
-      "ReID should restore old track id {} (got: {:?})",
-      id,
-      r_back
-        .tracked
-        .iter()
-        .map(|t| t.track_id)
-        .collect::<Vec<_>>()
-    );
-  }
-
-  #[test]
-  fn reid_expires_after_reid_hit_counter_max() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 3,
-      initialization_delay: 1,
-      reid_hit_counter_max: Some(5),
-      ..Default::default()
-    });
-
-    // Establish track
-    let _ = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 0.0);
-    let r2 = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 100.0);
-    let id = r2.tracked[0].track_id;
-
-    // Let track die (hit_counter_max=3) AND exhaust ReID window (5 frames)
-    for i in 2..20 {
-      t.update(Vec::new(), (i * 100) as f64);
-    }
-
-    // Reappear — ReID window expired, should get a NEW id
-    let _ = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 2000.0);
-    let r_back = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 2100.0);
-
-    let has_old = r_back.tracked.iter().any(|t| t.track_id == id);
-    assert!(
-      !has_old,
-      "ReID should have expired — old id {} should not appear",
-      id
-    );
-  }
-
-  #[test]
-  fn set_reid_hit_counter_max_dynamically() {
-    let mut t = ObjectTracker::new(ObjectTrackerConfig {
-      hit_counter_max: 3,
-      initialization_delay: 1,
-      reid_hit_counter_max: None, // disabled initially
-      ..Default::default()
-    });
-
-    // Enable ReID dynamically (e.g. cascade activated)
-    t.set_reid_hit_counter_max(50);
-
-    // Establish track
-    let _ = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 0.0);
-    let r2 = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 100.0);
-    let id = r2.tracked[0].track_id;
-    let _ = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 200.0);
-
-    // Let track die
-    for i in 3..13 {
-      t.update(Vec::new(), (i * 100) as f64);
-    }
-
-    // Reappear — should get old ID via ReID
-    let _ = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 1300.0);
-    let r_back = t.update(vec![det(0.30, 0.30, 0.20, 0.20, "person")], 1400.0);
-
-    let found = r_back.tracked.iter().any(|t| t.track_id == id);
-    assert!(found, "Dynamic ReID should restore old track id {}", id);
-
-    // Disable ReID (cascade deactivated)
-    t.set_reid_hit_counter_max(0);
-  }
-}