Update tracking.py

tracking.py

@@ -1,524 +1,440 @@
 """
-Enhanced Tracking with Track Validation and Improved Accuracy (Enhancement 7)
+DeepSORT Tracker Implementation
+Uses Kalman filter for motion prediction + appearance features
 """
 import numpy as np
-from typing import List, Optional, Tuple, Dict
 from scipy.optimize import linear_sum_assignment
+from scipy.spatial.distance import cosine
 from collections import deque
+from typing import List, Optional, Tuple
 import uuid
 from detection import Detection
-import warnings
-warnings.filterwarnings('ignore')
 
-class Track:
-    """Enhanced track with validation and quality metrics"""
+class KalmanFilter:
+    """
+    Kalman Filter for tracking with constant velocity model
+    State: [x, y, w, h, vx, vy, vw, vh]
+    """
+    def __init__(self):
+        # State transition matrix (constant velocity model)
+        self.F = np.eye(8)
+        for i in range(4):
+            self.F[i, i+4] = 1
+        
+        # Measurement matrix (we observe position and size)
+        self.H = np.eye(4, 8)
+        
+        # Process noise
+        self.Q = np.eye(8)
+        self.Q[4:, 4:] *= 0.01  # Smaller noise for velocities
+        
+        # Measurement noise
+        self.R = np.eye(4) * 10
+        
+        # State covariance
+        self.P = np.eye(8) * 1000
+        
+        # State vector [x, y, w, h, vx, vy, vw, vh]
+        self.x = np.zeros(8)
+        
+    def initiate(self, measurement: np.ndarray):
+        """Initialize filter with first measurement [x, y, w, h]"""
+        self.x[:4] = measurement
+        self.x[4:] = 0  # Zero velocity
+        
+    def predict(self):
+        """Predict next state"""
+        self.x = self.F @ self.x
+        self.P = self.F @ self.P @ self.F.T + self.Q
+        return self.x[:4]
+    
+    def update(self, measurement: np.ndarray):
+        """Update with new measurement"""
+        # Innovation
+        y = measurement - self.H @ self.x
+        
+        # Innovation covariance
+        S = self.H @ self.P @ self.H.T + self.R
+        
+        # Kalman gain
+        K = self.P @ self.H.T @ np.linalg.inv(S)
+        
+        # Update state
+        self.x = self.x + K @ y
+        
+        # Update covariance
+        self.P = (np.eye(8) - K @ self.H) @ self.P
+        
+        return self.x[:4]
+    
+    def get_state(self) -> np.ndarray:
+        """Get current state [x, y, w, h]"""
+        return self.x[:4]
+
+class DeepSORTTrack:
+    """
+    DeepSORT Track with Kalman filter and appearance features
+    """
     def __init__(self, detection: Detection, track_id: Optional[int] = None):
         self.track_id = track_id if track_id else self._generate_id()
-        self.bbox = detection.bbox.copy() if hasattr(detection, 'bbox') else [0, 0, 100, 100]
-        self.detections = [detection]
-        self.confidence = detection.confidence if hasattr(detection, 'confidence') else 0.5
+        
+        # Convert bbox to center format [cx, cy, w, h]
+        x1, y1, x2, y2 = detection.bbox
+        cx = (x1 + x2) / 2
+        cy = (y1 + y2) / 2
+        w = x2 - x1
+        h = y2 - y1
+        
+        # Initialize Kalman filter
+        self.kf = KalmanFilter()
+        self.kf.initiate(np.array([cx, cy, w, h]))
         
         # Track state
+        self.detections = [detection]
+        self.confidence = detection.confidence
+        self.hits = 1
         self.age = 1
         self.time_since_update = 0
         self.state = 'tentative'
-        self.hits = 1
-        self.consecutive_misses = 0
         
-        # ENHANCEMENT 7: Track validation
-        self.validation_score = 0  # Increases with consistent detections
-        self.min_validation_hits = 3  # Require 3 consistent detections
-        self.is_validated = False
+        # Appearance features for ReID
+        self.features = deque(maxlen=100)  # Store last 100 features
+        if hasattr(detection, 'features') and detection.features is not None:
+            self.features.append(detection.features)
         
-        # Store center points for trajectory
-        cx = (self.bbox[0] + self.bbox[2]) / 2
-        cy = (self.bbox[1] + self.bbox[3]) / 2
+        # Trajectory
         self.trajectory = deque(maxlen=30)
         self.trajectory.append((cx, cy))
         
-        # Enhanced motion model
-        self.velocity = np.array([0.0, 0.0])
-        self.acceleration = np.array([0.0, 0.0])
-        
-        # Appearance features
-        self.appearance_features = []
-        if hasattr(detection, 'features'):
-            self.appearance_features.append(detection.features)
-        
-        # Size tracking with validation
-        self.sizes = deque(maxlen=10)
-        width = max(1, self.bbox[2] - self.bbox[0])
-        height = max(1, self.bbox[3] - self.bbox[1])
-        self.sizes.append((width, height))
-        self.initial_size = (width, height)
-        
-        # Track quality metrics
+        # Quality metrics
         self.avg_confidence = self.confidence
-        self.max_confidence = self.confidence
-        self.confidence_history = deque(maxlen=10)
-        self.confidence_history.append(self.confidence)
-    
+        self.consecutive_misses = 0
+        
     def _generate_id(self) -> int:
         return int(uuid.uuid4().int % 100000)
     
-    def validate_detection_consistency(self, detection: Detection) -> bool:
-        """
-        ENHANCEMENT 7: Validate detection consistency before accepting
-        Checks size similarity and position consistency
-        """
-        if not hasattr(detection, 'bbox') or len(detection.bbox) != 4:
-            return False
-        
-        # Check size similarity
-        new_width = detection.bbox[2] - detection.bbox[0]
-        new_height = detection.bbox[3] - detection.bbox[1]
-        
-        if self.initial_size[0] > 0 and self.initial_size[1] > 0:
-            width_ratio = new_width / self.initial_size[0]
-            height_ratio = new_height / self.initial_size[1]
-            
-            # Allow 50% size variation max (prevents wild mismatches)
-            if width_ratio < 0.5 or width_ratio > 2.0:
-                return False
-            if height_ratio < 0.5 or height_ratio > 2.0:
-                return False
-        
-        # Check position consistency (not jumping too far)
-        new_cx = (detection.bbox[0] + detection.bbox[2]) / 2
-        new_cy = (detection.bbox[1] + detection.bbox[3]) / 2
-        
-        if len(self.trajectory) > 0:
-            last_cx, last_cy = self.trajectory[-1]
-            distance = np.sqrt((new_cx - last_cx)**2 + (new_cy - last_cy)**2)
-            
-            # Max reasonable movement per frame (adjust based on your video)
-            max_movement = 100  # pixels
-            if distance > max_movement:
-                return False
-        
-        return True
+    @property
+    def bbox(self) -> List[float]:
+        """Get bbox in [x1, y1, x2, y2] format"""
+        cx, cy, w, h = self.kf.get_state()
+        return [
+            cx - w/2,
+            cy - h/2,
+            cx + w/2,
+            cy + h/2
+        ]
     
     def predict(self):
-        """Enhanced motion prediction"""
+        """Predict next state using Kalman filter"""
         self.age += 1
         self.time_since_update += 1
         self.consecutive_misses += 1
         
-        try:
-            if len(self.trajectory) >= 3:
-                positions = np.array(list(self.trajectory))[-3:]
-                self.velocity = positions[-1] - positions[-2]
-                
-                # Limit velocity
-                max_velocity = 50
-                velocity_magnitude = np.linalg.norm(self.velocity)
-                if velocity_magnitude > max_velocity:
-                    self.velocity = self.velocity / velocity_magnitude * max_velocity
-                
-                if len(positions) == 3:
-                    prev_velocity = positions[-2] - positions[-3]
-                    self.acceleration = (self.velocity - prev_velocity) * 0.3
-                
-                predicted_pos = positions[-1] + self.velocity * 0.7 + self.acceleration * 0.1
-                
-                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])
-                
-                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:
-            pass
+        # Predict with Kalman filter
+        self.kf.predict()
     
     def update(self, detection: Detection):
-        """Update track with validation"""
-        try:
-            # ENHANCEMENT 7: Validate consistency
-            if not self.validate_detection_consistency(detection):
-                print(f"  ⚠️ Track {self.track_id}: Rejected inconsistent detection")
-                return
-            
-            # 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.confidence_history.append(self.confidence)
-                self.avg_confidence = np.mean(list(self.confidence_history))
-                self.max_confidence = max(self.max_confidence, self.confidence)
-            
-            self.hits += 1
-            self.time_since_update = 0
-            self.consecutive_misses = 0
-            
-            # ENHANCEMENT 7: Update validation score
-            self.validation_score += 1
-            if self.validation_score >= self.min_validation_hits and not self.is_validated:
-                self.is_validated = True
-                print(f"  ✅ Track {self.track_id} validated after {self.validation_score} consistent hits")
-            
-            # 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 = 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 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 validation
-            if self.is_validated and self.state == 'tentative':
-                self.state = 'confirmed'
-            
-            # Keep only recent detections
-            if len(self.detections) > 5:
-                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}")
+        """Update track with new detection"""
+        # Convert to center format
+        x1, y1, x2, y2 = detection.bbox
+        cx = (x1 + x2) / 2
+        cy = (y1 + y2) / 2
+        w = x2 - x1
+        h = y2 - y1
+        
+        # Update Kalman filter
+        self.kf.update(np.array([cx, cy, w, h]))
+        
+        # Update track state
+        self.detections.append(detection)
+        self.confidence = detection.confidence
+        self.avg_confidence = 0.9 * self.avg_confidence + 0.1 * self.confidence
+        
+        self.hits += 1
+        self.time_since_update = 0
+        self.consecutive_misses = 0
+        
+        # Update features
+        if hasattr(detection, 'features') and detection.features is not None:
+            self.features.append(detection.features)
+        
+        # Update trajectory
+        self.trajectory.append((cx, cy))
+        
+        # Confirm track
+        if self.state == 'tentative' and self.hits >= 3:
+            self.state = 'confirmed'
+        
+        # Keep only recent detections
+        if len(self.detections) > 5:
+            for old_det in self.detections[:-5]:
+                if hasattr(old_det, 'image_crop'):
+                    old_det.image_crop = None
+            self.detections = self.detections[-5:]
     
     def mark_missed(self):
         """Mark track as missed"""
-        # ENHANCEMENT 7: Only delete validated tracks after longer period
-        if self.is_validated and self.state == 'confirmed':
-            if self.consecutive_misses > 20:  # Extended buffer for validated tracks
-                self.state = 'deleted'
-            elif self.time_since_update > 40:
+        if self.state == 'confirmed':
+            if self.consecutive_misses > 30 or self.time_since_update > 60:
                 self.state = 'deleted'
         elif self.state == 'tentative':
-            if self.consecutive_misses > 3:
+            if self.consecutive_misses > 5:
                 self.state = 'deleted'
-        
-        # Reduce validation score when missed
-        self.validation_score = max(0, self.validation_score - 0.5)
-
+    
+    def get_feature(self) -> Optional[np.ndarray]:
+        """Get averaged appearance feature"""
+        if not self.features:
+            return None
+        # Use exponential moving average for recent features
+        features_array = np.array(list(self.features))
+        weights = np.exp(np.linspace(-1, 0, len(features_array)))
+        weights /= weights.sum()
+        return np.average(features_array, axis=0, weights=weights)
 
-class EnhancedTracker:
+class DeepSORTTracker:
     """
-    Enhanced Tracker with Track Validation (Enhancement 7)
+    DeepSORT Tracker combining Kalman filter motion model
+    with appearance feature matching
     """
     def __init__(self,
-                 match_threshold: float = 0.35,
-                 track_buffer: int = 40,  # Increased from 30
-                 min_iou_for_match: float = 0.15,
-                 use_appearance: bool = False):
-        
-        self.match_threshold = match_threshold
-        self.track_buffer = track_buffer
-        self.min_iou_for_match = min_iou_for_match
+                 max_iou_distance: float = 0.7,
+                 max_age: int = 30,
+                 n_init: int = 3,
+                 nn_budget: int = 100,
+                 use_appearance: bool = True):
+        """
+        Args:
+            max_iou_distance: Maximum IoU distance for matching (0.7 = 30% IoU)
+            max_age: Maximum frames to keep lost tracks
+            n_init: Number of frames to confirm a track
+            nn_budget: Maximum size of appearance feature gallery
+            use_appearance: Whether to use appearance features
+        """
+        self.max_iou_distance = max_iou_distance
+        self.max_age = max_age
+        self.n_init = n_init
+        self.nn_budget = nn_budget
         self.use_appearance = use_appearance
         
-        self.tracks: List[Track] = []
+        self.tracks: List[DeepSORTTrack] = []
         self.track_id_count = 1
         
-        # ENHANCEMENT 7: Size constraints for valid dogs
-        self.min_dog_size = 30  # Minimum width/height in pixels
-        self.max_dog_size = 800  # Maximum width/height in pixels
+        # Gating thresholds
+        self.gating_threshold_iou = 0.3  # Minimum IoU for association
+        self.gating_threshold_appearance = 0.5  # Maximum cosine distance
         
-        # Enhanced parameters
-        self.max_center_distance = 120
-        self.min_size_similarity = 0.4
+    def update(self, detections: List[Detection]) -> List[DeepSORTTrack]:
+        """Update tracks with new detections"""
+        # Predict existing tracks
+        for track in self.tracks:
+            track.predict()
         
-        self.debug = False
-    
-    def _is_valid_detection_size(self, detection: Detection) -> bool:
-        """ENHANCEMENT 7: Size-based filtering"""
-        if not hasattr(detection, 'bbox') or len(detection.bbox) != 4:
-            return False
-        
-        width = detection.bbox[2] - detection.bbox[0]
-        height = detection.bbox[3] - detection.bbox[1]
-        
-        # Filter too small or too large
-        if width < self.min_dog_size or height < self.min_dog_size:
-            return False
-        if width > self.max_dog_size or height > self.max_dog_size:
-            return False
-        
-        # Aspect ratio check (dogs shouldn't be super wide or super tall)
-        if width > 0 and height > 0:
-            aspect_ratio = width / height
-            if aspect_ratio < 0.3 or aspect_ratio > 3.0:
-                return False
-        
-        return True
-    
-    def _check_appearance_similarity(self, detection: Detection) -> bool:
-        """
-        ENHANCEMENT 7: Check if detection is too similar to existing tracks
-        Prevents duplicate tracks for the same dog
-        """
-        if not hasattr(detection, 'bbox'):
-            return True
+        # Match detections to tracks
+        matches, unmatched_tracks, unmatched_detections = self._match(
+            detections, self.tracks
+        )
         
-        det_center = self._get_center(detection.bbox)
-        det_size = (detection.bbox[2] - detection.bbox[0], 
-                   detection.bbox[3] - detection.bbox[1])
+        # Update matched tracks
+        for track_idx, det_idx in matches:
+            self.tracks[track_idx].update(detections[det_idx])
         
-        for track in self.tracks:
-            if track.state == 'deleted':
-                continue
-            
-            track_center = self._get_center(track.bbox)
-            track_size = (track.bbox[2] - track.bbox[0],
-                         track.bbox[3] - track.bbox[1])
-            
-            # Check center distance
-            distance = np.linalg.norm(np.array(det_center) - np.array(track_center))
-            
-            # Check size similarity
-            size_diff = abs(det_size[0] - track_size[0]) + abs(det_size[1] - track_size[1])
-            avg_size = (det_size[0] + det_size[1] + track_size[0] + track_size[1]) / 4
-            
-            # If very close and similar size, it's likely the same dog
-            if distance < 40 and size_diff < avg_size * 0.3:
-                return False  # Too similar to existing track
+        # Mark unmatched tracks as missed
+        for track_idx in unmatched_tracks:
+            self.tracks[track_idx].mark_missed()
+        
+        # Create new tracks for unmatched detections
+        for det_idx in unmatched_detections:
+            self._initiate_track(detections[det_idx])
         
-        return True
+        # Remove deleted tracks
+        self.tracks = [t for t in self.tracks if t.state != 'deleted']
+        
+        # Return confirmed tracks
+        return [t for t in self.tracks if t.state == 'confirmed']
     
-    def update(self, detections: List[Detection]) -> List[Track]:
-        """Update tracks with enhanced validation"""
+    def _match(self, detections: List[Detection], tracks: List[DeepSORTTrack]) -> Tuple:
+        """
+        Match detections to tracks using cascade matching
+        Returns: (matches, unmatched_tracks, unmatched_detections)
+        """
+        if not tracks or not detections:
+            return [], list(range(len(tracks))), list(range(len(detections)))
         
-        # ENHANCEMENT 7: Filter detections by size
-        valid_detections = [d for d in detections if self._is_valid_detection_size(d)]
+        # Split tracks by state
+        confirmed_tracks = [i for i, t in enumerate(tracks) if t.state == 'confirmed']
+        unconfirmed_tracks = [i for i, t in enumerate(tracks) if t.state == 'tentative']
         
-        if len(valid_detections) < len(detections):
-            print(f"  🔍 Filtered {len(detections) - len(valid_detections)} invalid size detections")
+        # Stage 1: Match confirmed tracks
+        matches_a, unmatched_tracks_a, unmatched_detections = \
+            self._matching_cascade(detections, tracks, confirmed_tracks)
         
-        detections = valid_detections
+        # Stage 2: Match unconfirmed tracks
+        iou_track_candidates = unconfirmed_tracks + unmatched_tracks_a
         
-        if not detections:
-            for track in self.tracks:
-                track.predict()
-                track.mark_missed()
-            
-            # Move lost tracks to sleeping (call ReID's move_to_sleeping)
-            self._handle_lost_tracks()
-            
-            self.tracks = [t for t in self.tracks if t.state != 'deleted']
-            return [t for t in self.tracks if t.state == 'confirmed']
+        # Filter detections used in stage 1
+        remaining_detections = [detections[i] for i in unmatched_detections]
         
-        try:
-            # Predict existing tracks
-            for track in self.tracks:
-                track.predict()
-            
-            # 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']
-            
-            matched_track_indices = set()
-            matched_det_indices = set()
-            
-            # Stage 1: Match confirmed tracks
-            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
-            if tentative_tracks:
-                unmatched_dets = [detections[i] for i in range(len(detections))
-                                 if i not in matched_det_indices]
-                
-                if unmatched_dets:
-                    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
-                    )
-                    
-                    for det_idx in tent_matched_dets:
-                        matched_det_indices.add(temp_det_mapping[det_idx])
-            
-            # Mark unmatched tracks
-            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()
-            
-            # ENHANCEMENT 7: Create new tracks with validation
-            for det_idx in range(len(detections)):
-                if det_idx not in matched_det_indices:
-                    detection = detections[det_idx]
-                    
-                    # Check appearance similarity before creating track
-                    if self._check_appearance_similarity(detection):
-                        new_track = Track(detection, self.track_id_count)
-                        self.track_id_count += 1
-                        self.tracks.append(new_track)
-                    else:
-                        print(f"  🚫 Rejected duplicate track candidate")
-            
-            # Handle lost tracks
-            self._handle_lost_tracks()
-            
-            # Remove deleted tracks
-            self.tracks = [t for t in self.tracks if t.state != 'deleted']
-            
-            # Return only validated confirmed tracks
-            return [t for t in self.tracks if t.state == 'confirmed' and t.is_validated]
+        matches_b, unmatched_tracks_b, unmatched_detections_b = \
+            self._match_iou(remaining_detections, tracks, iou_track_candidates)
         
-        except Exception as e:
-            print(f"Tracker update error: {e}")
-            return [t for t in self.tracks if t.state == 'confirmed']
-    
-    def _handle_lost_tracks(self):
-        """Handle tracks that are about to be deleted"""
-        for track in self.tracks:
-            # If track is validated and about to be deleted, could move to sleeping
-            if (track.is_validated and 
-                track.state == 'confirmed' and 
-                track.consecutive_misses == 18):  # Just before deletion at 20
-                
-                # This would be called by demo to move to ReID sleeping tracks
-                if hasattr(self, '_reid_callback'):
-                    self._reid_callback(track.track_id)
-    
-    def set_reid_callback(self, callback):
-        """Set callback to ReID for moving tracks to sleeping"""
-        self._reid_callback = callback
-    
-    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]:
-        """Track-detection association"""
-        if not tracks or not detections:
-            return existing_matched_tracks, existing_matched_dets
+        # Remap indices for stage 2
+        matches_b = [(t, unmatched_detections[d]) for t, d in matches_b]
+        unmatched_detections = [unmatched_detections[i] for i in unmatched_detections_b]
         
-        try:
-            cost_matrix = self._calculate_enhanced_cost_matrix(tracks, detections)
-            
-            if cost_matrix.size == 0:
-                return existing_matched_tracks, existing_matched_dets
-            
-            row_ind, col_ind = linear_sum_assignment(cost_matrix)
-            
-            matched_tracks = existing_matched_tracks.copy()
-            matched_dets = existing_matched_dets.copy()
-            
-            for r, c in zip(row_ind, col_ind):
-                if r >= len(tracks) or c >= len(detections):
-                    continue
-                
-                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
+        matches = matches_a + matches_b
+        unmatched_tracks = unmatched_tracks_b
         
-        except Exception as e:
-            print(f"Association error: {e}")
-            return existing_matched_tracks, existing_matched_dets
+        return matches, unmatched_tracks, unmatched_detections
     
-    def _calculate_enhanced_cost_matrix(self, tracks: List[Track],
-                                       detections: List[Detection]) -> np.ndarray:
-        """Calculate cost matrix"""
-        try:
-            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))
+    def _matching_cascade(self, detections: List[Detection], 
+                          tracks: List[DeepSORTTrack],
+                          track_indices: List[int]) -> Tuple:
+        """Cascade matching by time since update"""
+        matches = []
+        unmatched_detections = list(range(len(detections)))
+        
+        # Group tracks by time since update
+        for level in range(self.max_age):
+            if len(unmatched_detections) == 0:
+                break
+            
+            track_indices_l = [
+                k for k in track_indices
+                if tracks[k].time_since_update == level
+            ]
+            
+            if len(track_indices_l) == 0:
+                continue
             
-            for t_idx, track in enumerate(tracks):
-                if not hasattr(track, 'bbox') or len(track.bbox) != 4:
-                    continue
+            # Match at this level
+            matches_l, _, unmatched_detections = self._match_features_and_iou(
+                [detections[i] for i in unmatched_detections],
+                tracks,
+                track_indices_l
+            )
+            
+            # Remap detection indices
+            matches_l = [(t, unmatched_detections[d]) for t, d in matches_l]
+            matches.extend(matches_l)
+            
+            # Update unmatched detections
+            unmatched_detections = [
+                unmatched_detections[i] for i in range(len(unmatched_detections))
+                if i not in [d for _, d in matches_l]
+            ]
+        
+        unmatched_tracks = [
+            k for k in track_indices
+            if k not in [t for t, _ in matches]
+        ]
+        
+        return matches, unmatched_tracks, unmatched_detections
+    
+    def _match_features_and_iou(self, detections: List[Detection],
+                                 tracks: List[DeepSORTTrack],
+                                 track_indices: List[int]) -> Tuple:
+        """Match using both appearance features and IoU"""
+        if not track_indices or not detections:
+            return [], track_indices, list(range(len(detections)))
+        
+        # Calculate cost matrix
+        cost_matrix = np.zeros((len(track_indices), len(detections)))
+        
+        for i, track_idx in enumerate(track_indices):
+            track = tracks[track_idx]
+            track_bbox = track.bbox
+            track_feature = track.get_feature()
+            
+            for j, detection in enumerate(detections):
+                det_bbox = detection.bbox
                 
-                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])
-                ])
+                # IoU cost
+                iou = self._iou(track_bbox, det_bbox)
+                iou_cost = 1 - iou
                 
-                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)
-                    
-                    # Center distance
-                    det_center = np.array(self._get_center(detection.bbox))
-                    distance = np.linalg.norm(track_center - det_center)
-                    
-                    # Size similarity
-                    det_size = np.array([
-                        max(1, detection.bbox[2] - detection.bbox[0]),
-                        max(1, detection.bbox[3] - detection.bbox[1])
-                    ])
-                    
-                    size_ratio = np.minimum(track_size, det_size) / (np.maximum(track_size, det_size) + 1e-6)
-                    size_cost = 1 - np.mean(size_ratio)
-                    
-                    if iou >= self.min_iou_for_match and distance < self.max_center_distance:
-                        iou_cost = 1 - iou
-                        dist_cost = distance / self.max_center_distance
-                        
-                        total_cost = (0.6 * iou_cost +
-                                    0.25 * dist_cost +
-                                    0.15 * size_cost)
-                        
-                        # Boost validated tracks
-                        if track.is_validated:
-                            total_cost *= 0.9
-                        
-                        cost_matrix[t_idx, d_idx] = total_cost
+                # Appearance cost
+                if self.use_appearance and track_feature is not None:
+                    if hasattr(detection, 'features') and detection.features is not None:
+                        cosine_dist = cosine(track_feature, detection.features)
+                        appearance_cost = cosine_dist
                     else:
-                        cost_matrix[t_idx, d_idx] = 1.0
-            
-            return cost_matrix
+                        appearance_cost = 0.5  # Neutral if no features
+                else:
+                    appearance_cost = 0.0
+                
+                # Combined cost (weighted)
+                if self.use_appearance and track_feature is not None:
+                    cost = 0.5 * iou_cost + 0.5 * appearance_cost
+                else:
+                    cost = iou_cost
+                
+                # Gating: set to infinity if outside thresholds
+                if iou < self.gating_threshold_iou:
+                    cost = 1e6
+                if self.use_appearance and appearance_cost > self.gating_threshold_appearance:
+                    cost = 1e6
+                
+                cost_matrix[i, j] = cost
+        
+        # Hungarian algorithm
+        row_indices, col_indices = linear_sum_assignment(cost_matrix)
         
-        except Exception as e:
-            print(f"Cost matrix error: {e}")
-            return np.ones((len(tracks), len(detections)))
+        matches = []
+        unmatched_tracks = list(range(len(track_indices)))
+        unmatched_detections = list(range(len(detections)))
+        
+        for row, col in zip(row_indices, col_indices):
+            if cost_matrix[row, col] < 1e5:
+                matches.append((track_indices[row], col))
+                unmatched_tracks.remove(row)
+                unmatched_detections.remove(col)
+        
+        unmatched_tracks = [track_indices[i] for i in unmatched_tracks]
+        
+        return matches, unmatched_tracks, unmatched_detections
     
-    def _get_center(self, bbox: List[float]) -> Tuple[float, float]:
-        """Get bbox center"""
-        try:
-            if len(bbox) >= 4:
-                return ((bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2)
-            return (0, 0)
-        except:
-            return (0, 0)
+    def _match_iou(self, detections: List[Detection],
+                   tracks: List[DeepSORTTrack],
+                   track_indices: List[int]) -> Tuple:
+        """Simple IoU matching for unconfirmed tracks"""
+        if not track_indices or not detections:
+            return [], track_indices, list(range(len(detections)))
+        
+        # IoU distance matrix
+        iou_matrix = np.zeros((len(track_indices), len(detections)))
+        
+        for i, track_idx in enumerate(track_indices):
+            track = tracks[track_idx]
+            for j, detection in enumerate(detections):
+                iou = self._iou(track.bbox, detection.bbox)
+                iou_matrix[i, j] = 1 - iou
+        
+        # Hungarian matching
+        row_indices, col_indices = linear_sum_assignment(iou_matrix)
+        
+        matches = []
+        unmatched_tracks = list(range(len(track_indices)))
+        unmatched_detections = list(range(len(detections)))
+        
+        for row, col in zip(row_indices, col_indices):
+            if iou_matrix[row, col] < self.max_iou_distance:
+                matches.append((track_indices[row], col))
+                unmatched_tracks.remove(row)
+                unmatched_detections.remove(col)
+        
+        unmatched_tracks = [track_indices[i] for i in unmatched_tracks]
+        
+        return matches, unmatched_tracks, unmatched_detections
+    
+    def _initiate_track(self, detection: Detection):
+        """Create new track"""
+        new_track = DeepSORTTrack(detection, self.track_id_count)
+        self.track_id_count += 1
+        self.tracks.append(new_track)
     
     def _iou(self, bbox1: List[float], bbox2: List[float]) -> float:
-        """Calculate IoU"""
+        """Calculate IoU between two bboxes"""
         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])
@@ -528,40 +444,20 @@ class EnhancedTracker:
                 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]))
+            area1 = (bbox1[2] - bbox1[0]) * (bbox1[3] - bbox1[1])
+            area2 = (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:
+            return intersection / (union + 1e-6)
+        except:
             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: {self.match_threshold:.2f}")
-    
     def reset(self):
         """Reset tracker"""
         self.tracks.clear()
         self.track_id_count = 1
-        print("Tracker reset")
-    
-    def get_statistics(self) -> Dict:
-        """Get statistics"""
-        confirmed = len([t for t in self.tracks if t.state == 'confirmed'])
-        validated = len([t for t in self.tracks if t.is_validated])
-        tentative = len([t for t in self.tracks if t.state == 'tentative'])
-        
-        return {
-            'total_tracks': len(self.tracks),
-            'confirmed_tracks': confirmed,
-            'validated_tracks': validated,
-            'tentative_tracks': tentative,
-            'next_id': self.track_id_count
-        }
+        print("DeepSORT tracker reset")
 
-# Compatibility aliases
-SimpleTracker = EnhancedTracker
-RobustTracker = EnhancedTracker
+# Compatibility alias
+SimpleTracker = DeepSORTTracker
+RobustTracker = DeepSORTTracker