Update tracking.py

tracking.py

@@ -1,6 +1,5 @@
 """
-tracking.py - Production-ready tracking with comprehensive error handling
-Includes all bug fixes and defensive programming
+Enhanced Tracking with Track Validation and Improved Accuracy (Enhancement 7)
 """
 import numpy as np
 from typing import List, Optional, Tuple, Dict
@@ -11,12 +10,9 @@ from detection import Detection
 import warnings
 warnings.filterwarnings('ignore')
 
-
 class Track:
-    """Enhanced track with robust state management"""
-    
+    """Enhanced track with validation and quality metrics"""
     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.copy() if hasattr(detection, 'bbox') else [0, 0, 100, 100]
         self.detections = [detection]
@@ -29,6 +25,11 @@ class Track:
         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
+        
         # Store center points for trajectory
         cx = (self.bbox[0] + self.bbox[2]) / 2
         cy = (self.bbox[1] + self.bbox[3]) / 2
@@ -39,54 +40,87 @@ class Track:
         self.velocity = np.array([0.0, 0.0])
         self.acceleration = np.array([0.0, 0.0])
         
-        # Appearance features for re-association
+        # Appearance features
         self.appearance_features = []
         if hasattr(detection, 'features'):
             self.appearance_features.append(detection.features)
-            
-        # Size tracking for scale changes
+        
+        # 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
         self.avg_confidence = self.confidence
         self.max_confidence = self.confidence
-        
+        self.confidence_history = deque(maxlen=10)
+        self.confidence_history.append(self.confidence)
+    
     def _generate_id(self) -> int:
-        """Generate unique track ID"""
         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
+    
     def predict(self):
-        """Enhanced motion prediction with safety checks"""
+        """Enhanced motion prediction"""
         self.age += 1
         self.time_since_update += 1
         self.consecutive_misses += 1
         
         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
+                # 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
                 
-                # 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])
@@ -94,7 +128,6 @@ class Track:
                     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,
@@ -102,29 +135,38 @@ class Track:
                     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"""
+        """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)
+                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.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
@@ -135,59 +177,52 @@ class Track:
             height = max(1, self.bbox[3] - self.bbox[1])
             self.sizes.append((width, height))
             
-            # Store appearance features if available
+            # 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:
+            # Confirm track after validation
+            if self.is_validated and self.state == 'tentative':
                 self.state = 'confirmed'
-                
-            # Keep only recent detections to save memory
+            
+            # Keep only recent detections
             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':
-            # More lenient deletion criteria
-            if self.consecutive_misses > 15:
+        """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 > 30:
+            elif self.time_since_update > 40:
                 self.state = 'deleted'
         elif self.state == 'tentative':
             if self.consecutive_misses > 3:
                 self.state = 'deleted'
+        
+        # Reduce validation score when missed
+        self.validation_score = max(0, self.validation_score - 0.5)
 
 
-class RobustTracker:
+class EnhancedTracker:
     """
-    Production-ready tracker with comprehensive error handling
+    Enhanced Tracker with Track Validation (Enhancement 7)
     """
-    
     def __init__(self,
                  match_threshold: float = 0.35,
-                 track_buffer: int = 30,
+                 track_buffer: int = 40,  # Increased from 30
                  min_iou_for_match: float = 0.15,
                  use_appearance: bool = False):
-        """
-        Initialize tracker with safe defaults
         
-        Args:
-            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 (set False for speed)
-        """
         self.match_threshold = match_threshold
         self.track_buffer = track_buffer
         self.min_iou_for_match = min_iou_for_match
@@ -196,24 +231,90 @@ class RobustTracker:
         self.tracks: List[Track] = []
         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
+        
         # Enhanced parameters
-        self.max_center_distance = 150  # pixels (reduced for stricter matching)
-        self.min_size_similarity = 0.4  # Size change threshold
+        self.max_center_distance = 120
+        self.min_size_similarity = 0.4
         
-        # Debug mode
         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
         
-    def update(self, detections: List[Detection]) -> List[Track]:
+        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:
         """
-        Update tracks with robust error handling
+        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
+        
+        det_center = self._get_center(detection.bbox)
+        det_size = (detection.bbox[2] - detection.bbox[0], 
+                   detection.bbox[3] - detection.bbox[1])
+        
+        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
+        
+        return True
+    
+    def update(self, detections: List[Detection]) -> List[Track]:
+        """Update tracks with enhanced validation"""
+        
+        # ENHANCEMENT 7: Filter detections by size
+        valid_detections = [d for d in detections if self._is_valid_detection_size(d)]
+        
+        if len(valid_detections) < len(detections):
+            print(f"  🔍 Filtered {len(detections) - len(valid_detections)} invalid size detections")
+        
+        detections = valid_detections
+        
         if not detections:
-            # No detections - just predict existing tracks
             for track in self.tracks:
                 track.predict()
                 track.mark_missed()
             
-            # Remove deleted tracks
+            # 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']
         
@@ -221,31 +322,29 @@ class RobustTracker:
             # 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']
             
-            # Initialize matched indices
             matched_track_indices = set()
             matched_det_indices = set()
             
-            # Stage 1: Match confirmed tracks with all detections
+            # Stage 1: Match confirmed tracks
             if confirmed_tracks and detections:
                 matched_track_indices, matched_det_indices = self._associate_tracks(
-                    confirmed_tracks, detections, 
+                    confirmed_tracks, detections,
                     matched_track_indices, matched_det_indices,
                     threshold_mult=1.0
                 )
             
-            # Stage 2: Match tentative tracks with unmatched detections
+            # Stage 2: Match tentative tracks
             if tentative_tracks:
-                unmatched_dets = [detections[i] for i in range(len(detections)) 
+                unmatched_dets = [detections[i] for i in range(len(detections))
                                  if i not in matched_det_indices]
                 
                 if unmatched_dets:
-                    # Create temporary mapping
-                    temp_det_mapping = [i for i in range(len(detections)) 
+                    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(
@@ -254,114 +353,101 @@ class RobustTracker:
                         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])
             
-            # Mark unmatched tracks as missed
+            # 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()
             
-            # Create new tracks for unmatched detections
+            # 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 if detection is too close to existing tracks
-                    if self._is_new_track(detection):
+                    # 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 confirmed tracks
-            return [t for t in self.tracks if t.state == 'confirmed']
-            
+            # Return only validated confirmed tracks
+            return [t for t in self.tracks if t.state == 'confirmed' and t.is_validated]
+        
         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 _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]:
-        """
-        Safe track-detection association
-        
-        Returns:
-            (matched_track_indices, matched_det_indices)
-        """
+        """Track-detection association"""
         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
             
-            # 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
             
+            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':
-                    continue
-                    
-                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 error handling"""
+        """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))
@@ -369,7 +455,7 @@ class RobustTracker:
             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]),
@@ -379,66 +465,47 @@ class RobustTracker:
                 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 cost
+                    # Center distance
                     det_center = np.array(self._get_center(detection.bbox))
                     distance = np.linalg.norm(track_center - det_center)
                     
-                    # Size similarity cost
+                    # Size similarity
                     det_size = np.array([
                         max(1, detection.bbox[2] - detection.bbox[0]),
                         max(1, detection.bbox[3] - detection.bbox[1])
                     ])
                     
-                    # 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)
                     
-                    # 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)
+                        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
+                        # Boost validated tracks
+                        if track.is_validated:
+                            total_cost *= 0.9
                         
                         cost_matrix[t_idx, d_idx] = total_cost
                     else:
                         cost_matrix[t_idx, d_idx] = 1.0
-                        
-            return cost_matrix
             
+            return cost_matrix
+        
         except Exception as e:
-            print(f"Cost matrix calculation error: {e}")
-            # Return high cost matrix as fallback
+            print(f"Cost matrix error: {e}")
             return np.ones((len(tracks), len(detections)))
     
     def _get_center(self, bbox: List[float]) -> Tuple[float, float]:
-        """Get bbox center with validation"""
+        """Get bbox center"""
         try:
             if len(bbox) >= 4:
                 return ((bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2)
@@ -447,11 +514,11 @@ class RobustTracker:
             return (0, 0)
     
     def _iou(self, bbox1: List[float], bbox2: List[float]) -> float:
-        """Calculate IoU with validation"""
+        """Calculate IoU"""
         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])
@@ -459,42 +526,42 @@ class RobustTracker:
             
             if x2 < x1 or y2 < y1:
                 return 0.0
-                
-            intersection = (x2 - x1) * (y2 - y1)
             
+            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}")
+        print(f"Tracking threshold: {self.match_threshold:.2f}")
     
     def reset(self):
-        """Reset tracker state"""
+        """Reset tracker"""
         self.tracks.clear()
         self.track_id_count = 1
         print("Tracker reset")
     
     def get_statistics(self) -> Dict:
-        """Get tracker statistics"""
+        """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
         }
 
-
-# Compatibility alias
-SimpleTracker = RobustTracker
+# Compatibility aliases
+SimpleTracker = EnhancedTracker
+RobustTracker = EnhancedTracker