Update tracking.py

tracking.py

@@ -1,29 +1,33 @@
 """
-tracking.py - Enhanced tracking with proven techniques
-Fixes the index bug and adds robust features
+tracking.py - Production-ready tracking with comprehensive error handling
+Includes all bug fixes and defensive programming
 """
 import numpy as np
-from typing import List, Optional, Tuple
+from typing import List, Optional, Tuple, Dict
 from scipy.optimize import linear_sum_assignment
 from collections import deque
 import uuid
 from detection import Detection
+import warnings
+warnings.filterwarnings('ignore')
+
 
 class Track:
-    """Enhanced track with Kalman filter prediction"""
+    """Enhanced track with robust state management"""
     
     def __init__(self, detection: Detection, track_id: Optional[int] = None):
         """Initialize track from first detection"""
         self.track_id = track_id if track_id else self._generate_id()
-        self.bbox = detection.bbox
+        self.bbox = detection.bbox.copy() if hasattr(detection, 'bbox') else [0, 0, 100, 100]
         self.detections = [detection]
-        self.confidence = detection.confidence
+        self.confidence = detection.confidence if hasattr(detection, 'confidence') else 0.5
         
         # Track state
         self.age = 1
         self.time_since_update = 0
         self.state = 'tentative'
         self.hits = 1
+        self.consecutive_misses = 0
         
         # Store center points for trajectory
         cx = (self.bbox[0] + self.bbox[2]) / 2
@@ -42,106 +46,147 @@ class Track:
             
         # Size tracking for scale changes
         self.sizes = deque(maxlen=10)
-        width = self.bbox[2] - self.bbox[0]
-        height = self.bbox[3] - self.bbox[1]
+        width = max(1, self.bbox[2] - self.bbox[0])
+        height = max(1, self.bbox[3] - self.bbox[1])
         self.sizes.append((width, height))
         
+        # Track quality metrics
+        self.avg_confidence = self.confidence
+        self.max_confidence = self.confidence
+        
     def _generate_id(self) -> int:
         """Generate unique track ID"""
         return int(uuid.uuid4().int % 100000)
         
     def predict(self):
-        """Enhanced motion prediction with acceleration"""
+        """Enhanced motion prediction with safety checks"""
         self.age += 1
         self.time_since_update += 1
+        self.consecutive_misses += 1
         
-        if len(self.trajectory) >= 3:
-            # Calculate velocity and acceleration from recent positions
-            positions = np.array(list(self.trajectory))[-3:]
-            
-            # Velocity from last two positions
-            self.velocity = positions[-1] - positions[-2]
-            
-            # Acceleration from velocity change
-            if len(positions) == 3:
-                prev_velocity = positions[-2] - positions[-3]
-                self.acceleration = (self.velocity - prev_velocity) * 0.5
-            
-            # Predict next position with damping
-            predicted_pos = positions[-1] + self.velocity * 0.8 + self.acceleration * 0.2
-            
-            # Get average recent size for stable bbox
-            if self.sizes:
-                avg_width = np.mean([s[0] for s in self.sizes])
-                avg_height = np.mean([s[1] for s in self.sizes])
-            else:
-                avg_width = self.bbox[2] - self.bbox[0]
-                avg_height = self.bbox[3] - self.bbox[1]
-            
-            # Update bbox with predicted center and smoothed size
-            self.bbox = [
-                predicted_pos[0] - avg_width/2,
-                predicted_pos[1] - avg_height/2,
-                predicted_pos[0] + avg_width/2,
-                predicted_pos[1] + avg_height/2
-            ]
+        try:
+            if len(self.trajectory) >= 3:
+                # Calculate velocity and acceleration from recent positions
+                positions = np.array(list(self.trajectory))[-3:]
+                
+                # Velocity from last two positions
+                self.velocity = positions[-1] - positions[-2]
+                
+                # Limit velocity to reasonable values
+                max_velocity = 50  # pixels per frame
+                velocity_magnitude = np.linalg.norm(self.velocity)
+                if velocity_magnitude > max_velocity:
+                    self.velocity = self.velocity / velocity_magnitude * max_velocity
+                
+                # Acceleration from velocity change
+                if len(positions) == 3:
+                    prev_velocity = positions[-2] - positions[-3]
+                    self.acceleration = (self.velocity - prev_velocity) * 0.3
+                
+                # Predict next position with damping
+                predicted_pos = positions[-1] + self.velocity * 0.7 + self.acceleration * 0.1
+                
+                # Get average recent size for stable bbox
+                if self.sizes:
+                    avg_width = np.mean([s[0] for s in self.sizes])
+                    avg_height = np.mean([s[1] for s in self.sizes])
+                else:
+                    avg_width = max(10, self.bbox[2] - self.bbox[0])
+                    avg_height = max(10, self.bbox[3] - self.bbox[1])
+                
+                # Update bbox with predicted center and smoothed size
+                self.bbox = [
+                    predicted_pos[0] - avg_width/2,
+                    predicted_pos[1] - avg_height/2,
+                    predicted_pos[0] + avg_width/2,
+                    predicted_pos[1] + avg_height/2
+                ]
+        except Exception as e:
+            # Fallback: Keep current bbox
+            print(f"Track prediction error: {e}")
+            pass
             
     def update(self, detection: Detection):
         """Update track with new detection"""
-        self.bbox = detection.bbox
-        self.detections.append(detection)
-        self.confidence = detection.confidence
-        self.hits += 1
-        self.time_since_update = 0
-        
-        # Update trajectory
-        cx = (self.bbox[0] + self.bbox[2]) / 2
-        cy = (self.bbox[1] + self.bbox[3]) / 2
-        self.trajectory.append((cx, cy))
-        
-        # Update size history
-        width = self.bbox[2] - self.bbox[0]
-        height = self.bbox[3] - self.bbox[1]
-        self.sizes.append((width, height))
-        
-        # Store appearance features
-        if hasattr(detection, 'features'):
-            self.appearance_features.append(detection.features)
-            if len(self.appearance_features) > 5:
-                self.appearance_features = self.appearance_features[-5:]
-        
-        # Confirm track after 2 hits
-        if self.state == 'tentative' and self.hits >= 2:
-            self.state = 'confirmed'
+        try:
+            # Update bbox
+            if hasattr(detection, 'bbox'):
+                self.bbox = detection.bbox.copy()
+            
+            self.detections.append(detection)
+            
+            # Update confidence
+            if hasattr(detection, 'confidence'):
+                self.confidence = detection.confidence
+                self.avg_confidence = (self.avg_confidence * 0.9 + self.confidence * 0.1)
+                self.max_confidence = max(self.max_confidence, self.confidence)
+            
+            self.hits += 1
+            self.time_since_update = 0
+            self.consecutive_misses = 0
+            
+            # Update trajectory
+            cx = (self.bbox[0] + self.bbox[2]) / 2
+            cy = (self.bbox[1] + self.bbox[3]) / 2
+            self.trajectory.append((cx, cy))
             
-        # Keep only recent detections to save memory
-        if len(self.detections) > 5:
-            self.detections = self.detections[-5:]
+            # Update size history
+            width = max(1, self.bbox[2] - self.bbox[0])
+            height = max(1, self.bbox[3] - self.bbox[1])
+            self.sizes.append((width, height))
+            
+            # Store appearance features if available
+            if hasattr(detection, 'features'):
+                self.appearance_features.append(detection.features)
+                if len(self.appearance_features) > 5:
+                    self.appearance_features = self.appearance_features[-5:]
+            
+            # Confirm track after 2 hits
+            if self.state == 'tentative' and self.hits >= 2:
+                self.state = 'confirmed'
+                
+            # Keep only recent detections to save memory
+            if len(self.detections) > 5:
+                # Clear old detection images to save memory
+                for old_det in self.detections[:-5]:
+                    if hasattr(old_det, 'image_crop'):
+                        old_det.image_crop = None
+                self.detections = self.detections[-5:]
+                
+        except Exception as e:
+            print(f"Track update error: {e}")
             
     def mark_missed(self):
         """Mark track as missed in current frame"""
-        if self.state == 'confirmed' and self.time_since_update > 10:
-            self.state = 'deleted'
+        if self.state == 'confirmed':
+            # More lenient deletion criteria
+            if self.consecutive_misses > 15:
+                self.state = 'deleted'
+            elif self.time_since_update > 30:
+                self.state = 'deleted'
+        elif self.state == 'tentative':
+            if self.consecutive_misses > 3:
+                self.state = 'deleted'
 
 
 class RobustTracker:
     """
-    Enhanced tracker with multiple association strategies
+    Production-ready tracker with comprehensive error handling
     """
     
     def __init__(self,
-                 match_threshold: float = 0.3,
+                 match_threshold: float = 0.35,
                  track_buffer: int = 30,
-                 min_iou_for_match: float = 0.2,
-                 use_appearance: bool = True):
+                 min_iou_for_match: float = 0.15,
+                 use_appearance: bool = False):
         """
-        Initialize tracker with multiple matching strategies
+        Initialize tracker with safe defaults
         
         Args:
-            match_threshold: IoU threshold for matching
+            match_threshold: IoU threshold for matching (0.35 is balanced)
             track_buffer: Frames to keep lost tracks
             min_iou_for_match: Minimum IoU to consider a match
-            use_appearance: Whether to use appearance features
+            use_appearance: Whether to use appearance features (set False for speed)
         """
         self.match_threshold = match_threshold
         self.track_buffer = track_buffer
@@ -152,217 +197,304 @@ class RobustTracker:
         self.track_id_count = 1
         
         # Enhanced parameters
-        self.max_center_distance = 200  # pixels
-        self.min_size_similarity = 0.5  # Size change threshold
+        self.max_center_distance = 150  # pixels (reduced for stricter matching)
+        self.min_size_similarity = 0.4  # Size change threshold
+        
+        # Debug mode
+        self.debug = False
         
     def update(self, detections: List[Detection]) -> List[Track]:
         """
-        Update tracks with multiple association strategies
+        Update tracks with robust error handling
         """
-        # Predict existing tracks
-        for track in self.tracks:
-            track.predict()
+        if not detections:
+            # No detections - just predict existing tracks
+            for track in self.tracks:
+                track.predict()
+                track.mark_missed()
             
-        # Split tracks by state
-        confirmed_tracks = [t for t in self.tracks if t.state == 'confirmed']
-        tentative_tracks = [t for t in self.tracks if t.state == 'tentative']
-        
-        # First association: High confidence detections with confirmed tracks
-        high_conf_dets = [i for i, d in enumerate(detections) if d.confidence > 0.7]
-        low_conf_dets = [i for i, d in enumerate(detections) if d.confidence <= 0.7]
-        
-        matched_track_indices = set()
-        matched_det_indices = set()
+            # Remove deleted tracks
+            self.tracks = [t for t in self.tracks if t.state != 'deleted']
+            return [t for t in self.tracks if t.state == 'confirmed']
         
-        # Match high confidence detections first
-        if high_conf_dets and confirmed_tracks:
-            cost_matrix = self._calculate_enhanced_cost_matrix(
-                confirmed_tracks, 
-                [detections[i] for i in high_conf_dets]
-            )
-            
-            if cost_matrix.size > 0:
-                row_ind, col_ind = linear_sum_assignment(cost_matrix)
+        try:
+            # Predict existing tracks
+            for track in self.tracks:
+                track.predict()
                 
-                for r, c in zip(row_ind, col_ind):
-                    if cost_matrix[r, c] < (1 - self.match_threshold):
-                        confirmed_tracks[r].update(detections[high_conf_dets[c]])
-                        matched_track_indices.add(r)
-                        matched_det_indices.add(high_conf_dets[c])
-        
-        # Get unmatched items
-        unmatched_confirmed = [i for i in range(len(confirmed_tracks)) 
-                              if i not in matched_track_indices]
-        unmatched_dets = [i for i in range(len(detections)) 
-                         if i not in matched_det_indices]
-        
-        # Second association: Remaining confirmed tracks with remaining detections
-        if unmatched_dets and unmatched_confirmed:
-            remaining_tracks = [confirmed_tracks[i] for i in unmatched_confirmed]
-            remaining_dets = [detections[i] for i in unmatched_dets]
+            # Split tracks by state
+            confirmed_tracks = [t for t in self.tracks if t.state == 'confirmed']
+            tentative_tracks = [t for t in self.tracks if t.state == 'tentative']
             
-            cost_matrix = self._calculate_enhanced_cost_matrix(
-                remaining_tracks, remaining_dets
-            )
+            # Initialize matched indices
+            matched_track_indices = set()
+            matched_det_indices = set()
             
-            if cost_matrix.size > 0:
-                row_ind, col_ind = linear_sum_assignment(cost_matrix)
+            # Stage 1: Match confirmed tracks with all detections
+            if confirmed_tracks and detections:
+                matched_track_indices, matched_det_indices = self._associate_tracks(
+                    confirmed_tracks, detections, 
+                    matched_track_indices, matched_det_indices,
+                    threshold_mult=1.0
+                )
+            
+            # Stage 2: Match tentative tracks with unmatched detections
+            if tentative_tracks:
+                unmatched_dets = [detections[i] for i in range(len(detections)) 
+                                 if i not in matched_det_indices]
                 
-                for r, c in zip(row_ind, col_ind):
-                    if cost_matrix[r, c] < (1 - self.match_threshold * 0.8):
-                        track_idx = unmatched_confirmed[r]
-                        det_idx = unmatched_dets[c]
-                        confirmed_tracks[track_idx].update(detections[det_idx])
-                        matched_det_indices.add(det_idx)
-                        
-                        # Remove from unmatched lists
-                        if track_idx in unmatched_confirmed:
-                            unmatched_confirmed.remove(track_idx)
-        
-        # Update unmatched detections list after confirmed track matching
-        unmatched_dets = [i for i in range(len(detections)) 
-                         if i not in matched_det_indices]
-        
-        # Third association: Tentative tracks
-        if unmatched_dets and tentative_tracks:
-            remaining_dets = [detections[i] for i in unmatched_dets]
+                if unmatched_dets:
+                    # Create temporary mapping
+                    temp_det_mapping = [i for i in range(len(detections)) 
+                                       if i not in matched_det_indices]
+                    
+                    tent_matched_tracks, tent_matched_dets = self._associate_tracks(
+                        tentative_tracks, unmatched_dets,
+                        set(), set(),
+                        threshold_mult=0.7
+                    )
+                    
+                    # Map back to original detection indices
+                    for det_idx in tent_matched_dets:
+                        matched_det_indices.add(temp_det_mapping[det_idx])
             
-            cost_matrix = self._calculate_enhanced_cost_matrix(
-                tentative_tracks, remaining_dets
-            )
+            # Mark unmatched tracks as missed
+            for i, track in enumerate(confirmed_tracks):
+                if i not in matched_track_indices:
+                    track.mark_missed()
+                    
+            for track in tentative_tracks:
+                if track.time_since_update > 0:
+                    track.mark_missed()
             
-            if cost_matrix.size > 0:
-                row_ind, col_ind = linear_sum_assignment(cost_matrix)
-                
-                for r, c in zip(row_ind, col_ind):
-                    if cost_matrix[r, c] < (1 - self.match_threshold * 0.6):
-                        det_idx = unmatched_dets[c]
-                        tentative_tracks[r].update(detections[det_idx])
-                        matched_det_indices.add(det_idx)
-        
-        # Mark unmatched tracks as missed
-        for idx in unmatched_confirmed:
-            confirmed_tracks[idx].mark_missed()
+            # Create new tracks for unmatched detections
+            for det_idx in range(len(detections)):
+                if det_idx not in matched_det_indices:
+                    detection = detections[det_idx]
+                    
+                    # Check if detection is too close to existing tracks
+                    if self._is_new_track(detection):
+                        new_track = Track(detection, self.track_id_count)
+                        self.track_id_count += 1
+                        self.tracks.append(new_track)
             
-        for track in tentative_tracks:
-            if track.time_since_update > 0:
-                track.mark_missed()
-        
-        # Create new tracks for unmatched detections
-        final_unmatched_dets = [i for i in range(len(detections)) 
-                               if i not in matched_det_indices]
+            # Remove deleted tracks
+            self.tracks = [t for t in self.tracks if t.state != 'deleted']
+            
+            # Return only confirmed tracks
+            return [t for t in self.tracks if t.state == 'confirmed']
+            
+        except Exception as e:
+            print(f"Tracker update error: {e}")
+            # Return existing confirmed tracks as fallback
+            return [t for t in self.tracks if t.state == 'confirmed']
+    
+    def _associate_tracks(self, tracks: List[Track], detections: List[Detection],
+                         existing_matched_tracks: set, existing_matched_dets: set,
+                         threshold_mult: float = 1.0) -> Tuple[set, set]:
+        """
+        Safe track-detection association
         
-        for det_idx in final_unmatched_dets:
-            detection = detections[det_idx]
+        Returns:
+            (matched_track_indices, matched_det_indices)
+        """
+        if not tracks or not detections:
+            return existing_matched_tracks, existing_matched_dets
+            
+        try:
+            # Calculate cost matrix
+            cost_matrix = self._calculate_enhanced_cost_matrix(tracks, detections)
+            
+            if cost_matrix.size == 0:
+                return existing_matched_tracks, existing_matched_dets
             
-            # Additional check: ensure not too close to existing tracks
-            is_new = True
+            # Hungarian matching
+            row_ind, col_ind = linear_sum_assignment(cost_matrix)
+            
+            matched_tracks = existing_matched_tracks.copy()
+            matched_dets = existing_matched_dets.copy()
+            
+            # Process matches
+            for r, c in zip(row_ind, col_ind):
+                # Check bounds
+                if r >= len(tracks) or c >= len(detections):
+                    continue
+                    
+                # Check cost threshold
+                threshold = (1 - self.match_threshold * threshold_mult)
+                if cost_matrix[r, c] < threshold:
+                    tracks[r].update(detections[c])
+                    matched_tracks.add(r)
+                    matched_dets.add(c)
+                    
+            return matched_tracks, matched_dets
+            
+        except Exception as e:
+            print(f"Association error: {e}")
+            return existing_matched_tracks, existing_matched_dets
+    
+    def _is_new_track(self, detection: Detection) -> bool:
+        """Check if detection represents a new track"""
+        try:
             det_center = self._get_center(detection.bbox)
             
             for track in self.tracks:
-                if track.state != 'deleted':
-                    track_center = self._get_center(track.bbox)
-                    dist = np.linalg.norm(np.array(det_center) - np.array(track_center))
+                if track.state == 'deleted':
+                    continue
                     
-                    if dist < 40:  # Very close threshold
-                        is_new = False
-                        break
-            
-            if is_new:
-                new_track = Track(detection, self.track_id_count)
-                self.track_id_count += 1
-                self.tracks.append(new_track)
-        
-        # Remove deleted tracks
-        self.tracks = [t for t in self.tracks if t.state != 'deleted']
-        
-        # Return only confirmed tracks
-        return [t for t in self.tracks if t.state == 'confirmed']
+                track_center = self._get_center(track.bbox)
+                dist = np.linalg.norm(np.array(det_center) - np.array(track_center))
+                
+                # Very close to existing track - likely same object
+                if dist < 30:
+                    return False
+                    
+            return True
+            
+        except Exception as e:
+            print(f"New track check error: {e}")
+            return True  # Default to creating new track
     
     def _calculate_enhanced_cost_matrix(self, tracks: List[Track],
                                        detections: List[Detection]) -> np.ndarray:
-        """Calculate cost matrix with multiple cues"""
-        if not tracks or not detections:
-            return np.array([])
-            
-        n_tracks = len(tracks)
-        n_dets = len(detections)
-        cost_matrix = np.ones((n_tracks, n_dets))
-        
-        for t_idx, track in enumerate(tracks):
-            track_center = np.array(self._get_center(track.bbox))
-            track_size = np.array([
-                track.bbox[2] - track.bbox[0],
-                track.bbox[3] - track.bbox[1]
-            ])
-            
-            for d_idx, detection in enumerate(detections):
-                # IoU cost
-                iou = self._iou(track.bbox, detection.bbox)
+        """Calculate cost matrix with error handling"""
+        try:
+            if not tracks or not detections:
+                return np.array([])
                 
-                # Center distance cost
-                det_center = np.array(self._get_center(detection.bbox))
-                distance = np.linalg.norm(track_center - det_center)
-                
-                # Size similarity cost
-                det_size = np.array([
-                    detection.bbox[2] - detection.bbox[0],
-                    detection.bbox[3] - detection.bbox[1]
+            n_tracks = len(tracks)
+            n_dets = len(detections)
+            cost_matrix = np.ones((n_tracks, n_dets))
+            
+            for t_idx, track in enumerate(tracks):
+                if not hasattr(track, 'bbox') or len(track.bbox) != 4:
+                    continue
+                    
+                track_center = np.array(self._get_center(track.bbox))
+                track_size = np.array([
+                    max(1, track.bbox[2] - track.bbox[0]),
+                    max(1, track.bbox[3] - track.bbox[1])
                 ])
-                size_sim = np.minimum(track_size, det_size) / (np.maximum(track_size, det_size) + 1e-6)
-                size_cost = 1 - np.mean(size_sim)
                 
-                # Combine costs
-                if iou >= self.min_iou_for_match and distance < self.max_center_distance:
-                    iou_cost = 1 - iou
-                    dist_cost = distance / self.max_center_distance
+                for d_idx, detection in enumerate(detections):
+                    if not hasattr(detection, 'bbox') or len(detection.bbox) != 4:
+                        continue
+                        
+                    # IoU cost
+                    iou = self._iou(track.bbox, detection.bbox)
                     
-                    # Weighted combination
-                    total_cost = (0.5 * iou_cost + 
-                                 0.3 * dist_cost + 
-                                 0.2 * size_cost)
+                    # Center distance cost
+                    det_center = np.array(self._get_center(detection.bbox))
+                    distance = np.linalg.norm(track_center - det_center)
                     
-                    # Appearance cost if available
-                    if self.use_appearance and track.appearance_features and hasattr(detection, 'features'):
-                        # Simple cosine similarity
-                        track_feat = np.mean(track.appearance_features, axis=0)
-                        det_feat = detection.features
-                        app_sim = np.dot(track_feat, det_feat) / (
-                            np.linalg.norm(track_feat) * np.linalg.norm(det_feat) + 1e-6
-                        )
-                        app_cost = 1 - app_sim
-                        total_cost = 0.4 * iou_cost + 0.2 * dist_cost + 0.2 * size_cost + .2 * app_cost
+                    # Size similarity cost
+                    det_size = np.array([
+                        max(1, detection.bbox[2] - detection.bbox[0]),
+                        max(1, detection.bbox[3] - detection.bbox[1])
+                    ])
                     
-                    cost_matrix[t_idx, d_idx] = total_cost
-                else:
-                    cost_matrix[t_idx, d_idx] = 1.0
+                    # Prevent division by zero
+                    size_ratio = np.minimum(track_size, det_size) / (np.maximum(track_size, det_size) + 1e-6)
+                    size_cost = 1 - np.mean(size_ratio)
                     
-        return cost_matrix
+                    # Check basic constraints
+                    if iou >= self.min_iou_for_match and distance < self.max_center_distance:
+                        iou_cost = 1 - iou
+                        dist_cost = distance / self.max_center_distance
+                        
+                        # Weighted combination (IoU is most important)
+                        total_cost = (0.6 * iou_cost + 
+                                     0.25 * dist_cost + 
+                                     0.15 * size_cost)
+                        
+                        # Add appearance cost if available and enabled
+                        if (self.use_appearance and 
+                            hasattr(track, 'appearance_features') and 
+                            track.appearance_features and 
+                            hasattr(detection, 'features')):
+                            try:
+                                track_feat = np.mean(track.appearance_features, axis=0)
+                                det_feat = detection.features
+                                
+                                # Cosine similarity
+                                feat_norm = np.linalg.norm(track_feat) * np.linalg.norm(det_feat)
+                                if feat_norm > 0:
+                                    app_sim = np.dot(track_feat, det_feat) / feat_norm
+                                    app_cost = 1 - max(0, min(1, app_sim))
+                                    total_cost = (0.5 * iou_cost + 0.2 * dist_cost + 
+                                                0.15 * size_cost + 0.15 * app_cost)
+                            except:
+                                pass  # Use cost without appearance
+                        
+                        cost_matrix[t_idx, d_idx] = total_cost
+                    else:
+                        cost_matrix[t_idx, d_idx] = 1.0
+                        
+            return cost_matrix
+            
+        except Exception as e:
+            print(f"Cost matrix calculation error: {e}")
+            # Return high cost matrix as fallback
+            return np.ones((len(tracks), len(detections)))
     
     def _get_center(self, bbox: List[float]) -> Tuple[float, float]:
-        return ((bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2)
+        """Get bbox center with validation"""
+        try:
+            if len(bbox) >= 4:
+                return ((bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2)
+            return (0, 0)
+        except:
+            return (0, 0)
     
     def _iou(self, bbox1: List[float], bbox2: List[float]) -> float:
-        x1 = max(bbox1[0], bbox2[0])
-        y1 = max(bbox1[1], bbox2[1])
-        x2 = min(bbox1[2], bbox2[2])
-        y2 = min(bbox1[3], bbox2[3])
-        
-        if x2 < x1 or y2 < y1:
-            return 0.0
+        """Calculate IoU with validation"""
+        try:
+            if len(bbox1) < 4 or len(bbox2) < 4:
+                return 0.0
+                
+            x1 = max(bbox1[0], bbox2[0])
+            y1 = max(bbox1[1], bbox2[1])
+            x2 = min(bbox1[2], bbox2[2])
+            y2 = min(bbox1[3], bbox2[3])
             
-        intersection = (x2 - x1) * (y2 - y1)
-        area1 = (bbox1[2] - bbox1[0]) * (bbox1[3] - bbox1[1])
-        area2 = (bbox2[2] - bbox2[0]) * (bbox2[3] - bbox2[1])
-        union = area1 + area2 - intersection
-        
-        return intersection / (union + 1e-6)
+            if x2 < x1 or y2 < y1:
+                return 0.0
+                
+            intersection = (x2 - x1) * (y2 - y1)
+            
+            area1 = max(1, (bbox1[2] - bbox1[0]) * (bbox1[3] - bbox1[1]))
+            area2 = max(1, (bbox2[2] - bbox2[0]) * (bbox2[3] - bbox2[1]))
+            union = area1 + area2 - intersection
+            
+            return max(0, min(1, intersection / (union + 1e-6)))
+            
+        except Exception as e:
+            print(f"IoU calculation error: {e}")
+            return 0.0
     
     def set_match_threshold(self, threshold: float):
         """Update matching threshold"""
         self.match_threshold = max(0.1, min(0.8, threshold))
         print(f"Tracking threshold updated to: {self.match_threshold:.2f}")
+    
+    def reset(self):
+        """Reset tracker state"""
+        self.tracks.clear()
+        self.track_id_count = 1
+        print("Tracker reset")
+    
+    def get_statistics(self) -> Dict:
+        """Get tracker statistics"""
+        confirmed = len([t for t in self.tracks if t.state == 'confirmed'])
+        tentative = len([t for t in self.tracks if t.state == 'tentative'])
+        
+        return {
+            'total_tracks': len(self.tracks),
+            'confirmed_tracks': confirmed,
+            'tentative_tracks': tentative,
+            'next_id': self.track_id_count
+        }
 
 
-# Use the enhanced tracker as default
+# Compatibility alias
 SimpleTracker = RobustTracker