Update reid.py

reid.py

@@ -1,3 +1,7 @@
+"""
+reid.py - Fixed Single-Model Dog Re-Identification System
+Properly respects thresholds to prevent merging different dogs
+"""
 import numpy as np
 import cv2
 import torch
@@ -5,92 +9,53 @@ import torch.nn as nn
 import torchvision.models as models
 import torchvision.transforms as transforms
 from sklearn.metrics.pairwise import cosine_similarity
-from typing import Dict, List, Optional, Tuple, Any
+from typing import Dict, List, Optional, Tuple
 import time
 from dataclasses import dataclass
-from collections import deque
 import warnings
 warnings.filterwarnings('ignore')
 
 @dataclass
 class DogFeatures:
-    """Enhanced container for dog features"""
-    resnet_features: np.ndarray
-    color_histogram: np.ndarray
-    body_keypoints: Optional[np.ndarray] = None
-    size_features: Optional[np.ndarray] = None  # width, height, aspect ratio
+    """Container for dog features"""
+    features: np.ndarray
     confidence: float = 0.5
     quality_score: float = 0.5
     frame_num: int = 0
-    bbox: List[float] = None
 
-@dataclass
-class MatchResult:
-    """Detailed matching result"""
-    dog_id: int
-    confidence: float
-    match_type: str  # 'strong', 'temporal', 'weak', 'new'
-    feature_scores: Dict[str, float]
-
-class RobustReID:
-    """
-    Multi-feature ReID system combining:
-    1. Deep CNN features (ResNet50 + EfficientNet)
-    2. Color histograms (HSV + Lab color spaces)
-    3. Body proportions and size consistency
-    4. Temporal consistency tracking
-    5. Adaptive thresholds based on context
-    """
+class SingleModelReID:
+    """Fixed ReID that properly separates different dogs"""
     
     def __init__(self, device: str = 'cuda'):
         self.device = device if torch.cuda.is_available() else 'cpu'
         
-        # Adaptive threshold system
-        self.thresholds = {
-            'strong_match': 0.75,      # Very confident match
-            'normal_match': 0.55,      # Standard match
-            'temporal_match': 0.45,    # Recently seen dog
-            'weak_match': 0.40,        # Minimum for match
-            'new_dog': 0.65,           # Threshold to create new dog
-            'color_weight': 0.25,      # Weight for color matching
-            'size_weight': 0.15,       # Weight for size consistency
-            'deep_weight': 0.60        # Weight for deep features
-        }
+        # CRITICAL FIX: Higher default threshold to prevent merging
+        # This is the main fix - was 0.40, now 0.65
+        self.similarity_threshold = 0.65
         
-        # Dog database with richer features
-        self.dog_database = {}  # dog_id -> list of DogFeatures
-        self.dog_metadata = {}  # dog_id -> metadata dict
+        # In-memory dog database
+        self.dog_database = {}  # dog_id -> list of features
         self.next_dog_id = 1
         
-        # Tracking data
+        # Track to dog mapping with confidence tracking
         self.track_to_dog = {}  # track_id -> dog_id
-        self.track_history = {}  # track_id -> list of (dog_id, confidence)
-        self.dog_last_seen = {}  # dog_id -> frame_num
+        self.track_confidence_history = {}  # track_id -> list of confidence scores
+        self.dog_last_seen = {}  # dog_id -> frame_number
         self.current_frame = 0
         
-        # Verification cache for efficiency
-        self.verification_cache = {}
+        # Debug mode for troubleshooting
+        self.debug = True  # Set to True to see matching decisions
         
-        # Initialize models
-        self._initialize_models()
-    
-    def _initialize_models(self):
-        """Initialize multiple feature extractors"""
         try:
-            # Primary model: ResNet50
-            self.resnet = models.resnet50(weights='IMAGENET1K_V1')
-            self.resnet = nn.Sequential(*list(self.resnet.children())[:-1])
-            self.resnet.to(self.device).eval()
-            
-            # Secondary model: MobileNetV2 (lighter, different features)
-            self.mobilenet = models.mobilenet_v2(weights='IMAGENET1K_V1')
-            self.mobilenet.features.to(self.device).eval()
+            # Initialize ResNet50 model
+            self.model = models.resnet50(weights='IMAGENET1K_V1')
+            self.model = nn.Sequential(*list(self.model.children())[:-1])
+            self.model.to(self.device).eval()
             
-            # Standard transform
+            # Image preprocessing pipeline
             self.transform = transforms.Compose([
                 transforms.ToPILImage(),
-                transforms.Resize((256, 256)),
-                transforms.CenterCrop(224),
+                transforms.Resize((224, 224)),
                 transforms.ToTensor(),
                 transforms.Normalize(
                     mean=[0.485, 0.456, 0.406],
@@ -98,447 +63,258 @@ class RobustReID:
                 )
             ])
             
-            # Alternative transform for augmentation
-            self.transform_aug = transforms.Compose([
-                transforms.ToPILImage(),
-                transforms.Resize((256, 256)),
-                transforms.RandomCrop(224),
-                transforms.ColorJitter(brightness=0.1, contrast=0.1),
-                transforms.ToTensor(),
-                transforms.Normalize(
-                    mean=[0.485, 0.456, 0.406],
-                    std=[0.229, 0.224, 0.225]
-                )
-            ])
+            print(f"✅ ReID initialized successfully")
+            print(f"   Device: {self.device}")
+            print(f"   Default threshold: {self.similarity_threshold}")
             
-            print("Robust ReID models initialized successfully")
         except Exception as e:
-            print(f"Model initialization error: {e}")
-            self.resnet = None
-            self.mobilenet = None
+            print(f"❌ ReID initialization error: {e}")
+            self.model = None
     
-    def extract_deep_features(self, image: np.ndarray, augment: bool = False) -> Optional[np.ndarray]:
-        """Extract combined deep features from multiple models"""
-        if self.resnet is None or image is None or image.size == 0:
+    def extract_features(self, image: np.ndarray) -> Optional[np.ndarray]:
+        """Extract ResNet50 features from dog image"""
+        if self.model is None or image is None or image.size == 0:
             return None
         
-        # Quality check
+        # Quality check - skip very blurry images
         gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
         laplacian_var = cv2.Laplacian(gray, cv2.CV_64F).var()
-        if laplacian_var < 30:  # Very blurry
+        if laplacian_var < 50:  # Too blurry
+            if self.debug:
+                print(f"   Skipping blurry image (variance: {laplacian_var:.1f})")
             return None
         
         try:
+            # Convert BGR to RGB
             img_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
             
-            # Choose transform
-            transform = self.transform_aug if augment else self.transform
-            img_tensor = transform(img_rgb).unsqueeze(0).to(self.device)
+            # Transform and create batch
+            img_tensor = self.transform(img_rgb).unsqueeze(0).to(self.device)
             
+            # Extract features
             with torch.no_grad():
-                # ResNet features
-                resnet_feat = self.resnet(img_tensor)
-                resnet_feat = resnet_feat.squeeze().cpu().numpy()
-                
-                # MobileNet features
-                mobile_feat = self.mobilenet.features(img_tensor)
-                mobile_feat = torch.nn.functional.adaptive_avg_pool2d(mobile_feat, 1)
-                mobile_feat = mobile_feat.squeeze().cpu().numpy()
-                
-                # Combine features (weighted concatenation)
-                combined = np.concatenate([
-                    resnet_feat * 0.7,  # ResNet weighted more
-                    mobile_feat * 0.3   # MobileNet complementary
-                ])
-                
-                # L2 normalize
-                combined = combined / (np.linalg.norm(combined) + 1e-7)
-                
-            return combined
-        except Exception as e:
-            print(f"Feature extraction error: {e}")
-            return None
-    
-    def extract_color_histogram(self, image: np.ndarray, bbox: List[float] = None) -> np.ndarray:
-        """Extract robust color histogram features"""
-        # Focus on center region if bbox provided
-        if bbox:
-            h, w = image.shape[:2]
-            # Get center 60% of bounding box to avoid background
-            cx = (bbox[0] + bbox[2]) / 2
-            cy = (bbox[1] + bbox[3]) / 2
-            width = (bbox[2] - bbox[0]) * 0.6
-            height = (bbox[3] - bbox[1]) * 0.6
+                features = self.model(img_tensor)
+                features = features.squeeze().cpu().numpy()
             
-            x1 = max(0, int(cx - width/2))
-            y1 = max(0, int(cy - height/2))
-            x2 = min(w, int(cx + width/2))
-            y2 = min(h, int(cy + height/2))
+            # L2 normalize for cosine similarity
+            features = features / (np.linalg.norm(features) + 1e-7)
             
-            if x2 > x1 and y2 > y1:
-                roi = image[y1:y2, x1:x2]
-            else:
-                roi = image
-        else:
-            roi = image
-        
-        # Multi-color space histograms
-        histograms = []
-        
-        # HSV histogram (good for color consistency)
-        hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
-        hist_h = cv2.calcHist([hsv], [0], None, [30], [0, 180])
-        hist_s = cv2.calcHist([hsv], [1], None, [16], [0, 256])
-        hist_v = cv2.calcHist([hsv], [2], None, [16], [0, 256])
-        
-        # LAB histogram (perceptually uniform)
-        lab = cv2.cvtColor(roi, cv2.COLOR_BGR2LAB)
-        hist_l = cv2.calcHist([lab], [0], None, [16], [0, 256])
-        hist_a = cv2.calcHist([lab], [1], None, [16], [0, 256])
-        hist_b = cv2.calcHist([lab], [2], None, [16], [0, 256])
-        
-        # Combine all histograms
-        for hist in [hist_h, hist_s, hist_v, hist_l, hist_a, hist_b]:
-            hist = hist.flatten()
-            hist = hist / (hist.sum() + 1e-7)  # Normalize
-            histograms.append(hist)
-        
-        combined_hist = np.concatenate(histograms)
-        return combined_hist
-    
-    def extract_size_features(self, bbox: List[float]) -> np.ndarray:
-        """Extract size and proportion features"""
-        width = bbox[2] - bbox[0]
-        height = bbox[3] - bbox[1]
-        aspect_ratio = width / (height + 1e-7)
-        area = width * height
-        
-        # Normalize to [0, 1] range
-        features = np.array([
-            width / 1000,  # Assume max width 1000px
-            height / 1000,  # Assume max height 1000px
-            aspect_ratio / 3,  # Aspect ratio typically 0.3-3
-            np.sqrt(area) / 1000  # Square root of area for better scale
-        ])
-        
-        return np.clip(features, 0, 1)
-    
-    def calculate_feature_similarity(self, features1: DogFeatures, features2: DogFeatures) -> Dict[str, float]:
-        """Calculate similarity scores for all feature types"""
-        scores = {}
-        
-        # Deep feature similarity
-        if features1.resnet_features is not None and features2.resnet_features is not None:
-            scores['deep'] = cosine_similarity(
-                features1.resnet_features.reshape(1, -1),
-                features2.resnet_features.reshape(1, -1)
-            )[0, 0]
-        else:
-            scores['deep'] = 0.5
-        
-        # Color histogram similarity
-        if features1.color_histogram is not None and features2.color_histogram is not None:
-            # Use histogram intersection for color
-            hist_intersection = np.minimum(features1.color_histogram, features2.color_histogram).sum()
-            scores['color'] = hist_intersection
-        else:
-            scores['color'] = 0.5
-        
-        # Size consistency
-        if features1.size_features is not None and features2.size_features is not None:
-            size_diff = np.abs(features1.size_features - features2.size_features)
-            scores['size'] = 1.0 - np.mean(size_diff)
-        else:
-            scores['size'] = 0.5
-        
-        # Quality-weighted confidence
-        quality_factor = (features1.quality_score + features2.quality_score) / 2
-        scores['quality'] = quality_factor
-        
-        return scores
-    
-    def calculate_weighted_similarity(self, scores: Dict[str, float], context: str = 'normal') -> float:
-        """Calculate final similarity with adaptive weights"""
-        if context == 'temporal':
-            weights = {
-                'deep': 0.5,
-                'color': 0.3,
-                'size': 0.2
-            }
-        elif context == 'first_sight':
-            weights = {
-                'deep': 0.8,
-                'color': 0.15,
-                'size': 0.05
-            }
-        else:  # normal
-            weights = {
-                'deep': self.thresholds['deep_weight'],
-                'color': self.thresholds['color_weight'],
-                'size': self.thresholds['size_weight']
-            }
-        
-        total_weight = sum(weights.values())
-        weighted_sum = sum(scores.get(k, 0.5) * w for k, w in weights.items())
-        
-        # Apply quality factor
-        quality = scores.get('quality', 1.0)
-        final_score = (weighted_sum / total_weight) * (0.8 + 0.2 * quality)
-        
-        return min(1.0, final_score)
-    
-    def verify_match(self, dog_id: int, new_features: DogFeatures, threshold: float) -> Tuple[bool, float]:
-        """Verify a potential match with multiple samples"""
-        if dog_id not in self.dog_database or not self.dog_database[dog_id]:
-            return False, 0.0
-        
-        # Get recent high-quality features for comparison
-        dog_features = self.dog_database[dog_id]
-        comparison_features = sorted(
-            dog_features[-10:],
-            key=lambda x: x.quality_score * x.confidence,
-            reverse=True
-        )[:5]
-        
-        similarities = []
-        for feat in comparison_features:
-            scores = self.calculate_feature_similarity(new_features, feat)
+            return features
             
-            frame_diff = abs(self.current_frame - feat.frame_num)
-            context = 'temporal' if frame_diff < 30 else 'normal'
-            sim = self.calculate_weighted_similarity(scores, context)
-            similarities.append(sim)
-        
-        if similarities:
-            median_sim = np.median(similarities)
-            max_sim = np.max(similarities)
-            final_score = 0.7 * median_sim + 0.3 * max_sim
-        else:
-            final_score = 0.0
-        
-        return final_score >= threshold, final_score
+        except Exception as e:
+            if self.debug:
+                print(f"   Feature extraction error: {e}")
+            return None
     
-    def match_or_register(self, track) -> MatchResult:
-        """Enhanced matching with multi-stage verification"""
+    def match_or_register(self, track) -> Tuple[int, float]:
+        """
+        Main matching function - FIXED to properly use threshold
+        Returns: (dog_id, confidence)
+        """
         self.current_frame += 1
-
-        # *** NEW: assign a unique track_id if not already set ***
-        if not hasattr(track, 'track_id'):
-            if not hasattr(self, '_anon_id'):  # internal counter
-                self._anon_id = 1
-            track.track_id = self._anon_id
-            self._anon_id += 1
         
         # Get best quality detection from recent frames
-        best_detection = None
-        best_quality = 0
-        
-        for det in track.detections[-5:]:
+        detection = None
+        for det in reversed(track.detections[-3:]):  # Check last 3 detections
             if det.image_crop is not None:
-                gray = cv2.cvtColor(det.image_crop, cv2.COLOR_BGR2GRAY)
-                quality = cv2.Laplacian(gray, cv2.CV_64F).var()
-                if quality > best_quality:
-                    best_quality = quality
-                    best_detection = det
+                detection = det
+                break
         
-        if best_detection is None:
-            return MatchResult(0, 0.0, 'failed', {})
+        if detection is None:
+            return 0, 0.0
         
-        if track.track_id in self.track_history and len(self.track_history[track.track_id]) >= 3:
-            recent_history = self.track_history[track.track_id][-5:]
-            dog_ids = [h[0] for h in recent_history]
-            most_common = max(set(dog_ids), key=dog_ids.count)
+        # Check if track already has a consistent dog ID
+        if track.track_id in self.track_to_dog:
+            existing_dog_id = self.track_to_dog[track.track_id]
             
-            if dog_ids.count(most_common) >= 3:
-                if track.track_id not in self.track_to_dog:
-                    self.track_to_dog[track.track_id] = most_common
-                
-                if self.current_frame % 5 == 0:
-                    self._update_dog_features(most_common, best_detection)
-                
-                avg_conf = np.mean([h[1] for h in recent_history])
-                return MatchResult(most_common, avg_conf, 'temporal', {})
-        
-        deep_features = self.extract_deep_features(best_detection.image_crop)
-        if deep_features is None:
-            return MatchResult(0, 0.0, 'failed', {})
-        
-        color_hist = self.extract_color_histogram(best_detection.image_crop, best_detection.bbox)
-        size_features = self.extract_size_features(best_detection.bbox)
-        
-        new_features = DogFeatures(
-            resnet_features=deep_features,
-            color_histogram=color_hist,
-            size_features=size_features,
-            confidence=best_detection.confidence,
-            quality_score=best_quality / 100,
-            frame_num=self.current_frame,
-            bbox=best_detection.bbox
-        )
-        
-        candidates = []
-        
-        for dog_id in self.dog_database.keys():
-            if self.dog_database[dog_id]:
-                last_color = self.dog_database[dog_id][-1].color_histogram
-                if last_color is not None:
-                    color_sim = np.minimum(color_hist, last_color).sum()
-                    if color_sim < 0.3:
-                        continue
+            # Verify consistency from confidence history
+            if track.track_id in self.track_confidence_history:
+                recent_conf = self.track_confidence_history[track.track_id]
+                if len(recent_conf) >= 3 and np.mean(recent_conf[-3:]) > 0.5:
+                    # Track has been consistent, keep same ID
+                    if self.debug and self.current_frame % 30 == 0:  # Print occasionally
+                        print(f"Frame {self.current_frame}: Track {track.track_id} -> Dog {existing_dog_id} (consistent)")
+                    
+                    # Update last seen
+                    self.dog_last_seen[existing_dog_id] = self.current_frame
+                    return existing_dog_id, np.mean(recent_conf[-3:])
+        
+        # Extract features for new/uncertain detection
+        features = self.extract_features(detection.image_crop)
+        if features is None:
+            return 0, 0.0
+        
+        # Find best matching dog
+        best_dog_id = None
+        best_score = -1.0
+        all_scores = {}  # For debugging
+        
+        for dog_id, feature_list in self.dog_database.items():
+            if not feature_list:
+                continue
             
-            is_match, score = self.verify_match(dog_id, new_features, self.thresholds['weak_match'])
-            if is_match:
-                if dog_id in self.dog_last_seen:
-                    frames_since = self.current_frame - self.dog_last_seen[dog_id]
-                    if frames_since < 60:
-                        score += 0.05 * (1 - frames_since / 60)
-                
-                candidates.append((dog_id, score))
-        
-        if candidates:
-            candidates.sort(key=lambda x: x[1], reverse=True)
-            best_dog_id, best_score = candidates[0]
+            # Calculate similarity with recent features
+            similarities = []
+            for dog_feat in feature_list[-5:]:  # Use last 5 features
+                sim = cosine_similarity(
+                    features.reshape(1, -1),
+                    dog_feat.features.reshape(1, -1)
+                )[0, 0]
+                similarities.append(sim)
+            
+            # Average similarity
+            avg_similarity = np.mean(similarities) if similarities else 0
+            
+            # Bonus for recently seen dogs (temporal consistency)
+            if dog_id in self.dog_last_seen:
+                frames_since = self.current_frame - self.dog_last_seen[dog_id]
+                if frames_since < 30:  # Within ~1 second at 30fps
+                    avg_similarity += 0.05 * (1 - frames_since / 30)
             
-            if best_score >= self.thresholds['strong_match']:
-                match_type = 'strong'
-                threshold = self.thresholds['strong_match']
-            elif best_score >= self.thresholds['normal_match']:
-                match_type = 'normal'
-                threshold = self.thresholds['normal_match']
-            else:
-                match_type = 'weak'
-                threshold = self.thresholds['weak_match']
+            all_scores[dog_id] = avg_similarity
             
-            if len(candidates) > 1:
-                second_score = candidates[1][1]
-                if best_score - second_score < 0.1:
-                    new_dog_id = self._register_new_dog(new_features)
-                    return MatchResult(new_dog_id, 1.0, 'new', {})
+            if avg_similarity > best_score:
+                best_score = avg_similarity
+                best_dog_id = dog_id
+        
+        # CRITICAL: Actually use the threshold!
+        if self.debug:
+            print(f"\nFrame {self.current_frame}, Track {track.track_id}:")
+            print(f"  Best match: Dog {best_dog_id} with score {best_score:.3f}")
+            print(f"  Threshold: {self.similarity_threshold:.3f}")
+            if len(all_scores) > 1:
+                print(f"  All scores: {all_scores}")
+        
+        # Decision: Match or create new dog
+        if best_dog_id is not None and best_score >= self.similarity_threshold:
+            # MATCH FOUND
+            if self.debug:
+                print(f"  ✅ MATCHED to Dog {best_dog_id}")
             
-            self.dog_database[best_dog_id].append(new_features)
-            self._prune_features(best_dog_id)
+            # Update dog database with new features
+            self.dog_database[best_dog_id].append(
+                DogFeatures(
+                    features=features, 
+                    confidence=detection.confidence,
+                    quality_score=laplacian_var / 100 if 'laplacian_var' in locals() else 0.5,
+                    frame_num=self.current_frame
+                )
+            )
+            
+            # Prune old features to save memory
+            if len(self.dog_database[best_dog_id]) > 10:
+                self.dog_database[best_dog_id] = self.dog_database[best_dog_id][-10:]
+            
+            # Update tracking maps
             self.track_to_dog[track.track_id] = best_dog_id
             self.dog_last_seen[best_dog_id] = self.current_frame
             
-            if track.track_id not in self.track_history:
-                self.track_history[track.track_id] = []
-            self.track_history[track.track_id].append((best_dog_id, best_score))
+            # Update confidence history
+            if track.track_id not in self.track_confidence_history:
+                self.track_confidence_history[track.track_id] = []
+            self.track_confidence_history[track.track_id].append(best_score)
+            if len(self.track_confidence_history[track.track_id]) > 10:
+                self.track_confidence_history[track.track_id] = self.track_confidence_history[track.track_id][-10:]
+            
+            return best_dog_id, best_score
             
-            return MatchResult(best_dog_id, best_score, match_type, {'threshold': threshold})
-        
-        new_dog_id = self._register_new_dog(new_features)
-        return MatchResult(new_dog_id, 1.0, 'new', {})
-    
-    def _register_new_dog(self, features: DogFeatures) -> int:
-        new_dog_id = self.next_dog_id
-        self.next_dog_id += 1
-        
-        self.dog_database[new_dog_id] = [features]
-        self.dog_metadata[new_dog_id] = {
-            'first_seen': self.current_frame,
-            'total_sightings': 1,
-            'avg_quality': features.quality_score
-        }
-        self.dog_last_seen[new_dog_id] = self.current_frame
-        
-        return new_dog_id
-    
-    def _update_dog_features(self, dog_id: int, detection):
-        if dog_id not in self.dog_database:
-            return
-        
-        deep_features = self.extract_deep_features(detection.image_crop, augment=True)
-        if deep_features is None:
-            return
-        
-        color_hist = self.extract_color_histogram(detection.image_crop, detection.bbox)
-        size_features = self.extract_size_features(detection.bbox)
-        
-        new_features = DogFeatures(
-            resnet_features=deep_features,
-            color_histogram=color_hist,
-            size_features=size_features,
-            confidence=detection.confidence,
-            quality_score=0.5,
-            frame_num=self.current_frame,
-            bbox=detection.bbox
-        )
-        
-        self.dog_database[dog_id].append(new_features)
-        self._prune_features(dog_id)
-        self.dog_last_seen[dog_id] = self.current_frame
-    
-    def _prune_features(self, dog_id: int):
-        if dog_id not in self.dog_database:
-            return
-        
-        features = self.dog_database[dog_id]
-        if len(features) <= 10:
-            return
-        
-        recent = features[-5:]
-        older = features[:-5]
-        high_quality = sorted(older, key=lambda x: x.quality_score * x.confidence, reverse=True)[:5]
-        
-        if len(older) > 10:
-            step = len(older) // 5
-            spaced = older[::step][:5]
         else:
-            spaced = []
-        
-        kept_features = recent + high_quality
-        for feat in spaced:
-            if feat not in kept_features:
-                kept_features.append(feat)
-        
-        self.dog_database[dog_id] = kept_features[:15]
+            # NO MATCH - Create new dog
+            new_dog_id = self.next_dog_id
+            self.next_dog_id += 1
+            
+            if self.debug:
+                print(f"  🆕 NEW DOG created: Dog {new_dog_id}")
+            
+            # Initialize new dog in database
+            self.dog_database[new_dog_id] = [
+                DogFeatures(
+                    features=features,
+                    confidence=detection.confidence,
+                    quality_score=0.5,
+                    frame_num=self.current_frame
+                )
+            ]
+            
+            # Update tracking maps
+            self.track_to_dog[track.track_id] = new_dog_id
+            self.dog_last_seen[new_dog_id] = self.current_frame
+            self.track_confidence_history[track.track_id] = [1.0]
+            
+            return new_dog_id, 1.0
     
     def match_or_register_all(self, track) -> Dict:
-        result = self.match_or_register(track)
+        """Compatible interface for existing code"""
+        dog_id, confidence = self.match_or_register(track)
+        
         return {
             'ResNet50': {
-                'dog_id': result.dog_id,
-                'confidence': result.confidence,
-                'processing_time': 0,
-                'match_type': result.match_type
+                'dog_id': dog_id,
+                'confidence': confidence,
+                'processing_time': 0
             }
         }
     
+    def set_all_thresholds(self, threshold: float):
+        """
+        CRITICAL FIX: Actually apply the threshold from the slider!
+        This was the main bug - threshold wasn't being applied
+        """
+        old_threshold = self.similarity_threshold
+        self.similarity_threshold = max(0.3, min(0.95, threshold))
+        
+        print(f"📊 ReID threshold changed: {old_threshold:.2f} -> {self.similarity_threshold:.2f}")
+        
+        # Provide guidance based on threshold
+        if self.similarity_threshold < 0.5:
+            print("  ⚠️ LOW threshold - may merge different dogs")
+        elif self.similarity_threshold > 0.75:
+            print("  ⚠️ HIGH threshold - may split same dog")
+        else:
+            print("  ✅ Balanced threshold")
+    
     def reset_all(self):
+        """Reset all temporary data"""
         self.dog_database.clear()
-        self.dog_metadata.clear()
         self.track_to_dog.clear()
-        self.track_history.clear()
+        self.track_confidence_history.clear()
         self.dog_last_seen.clear()
-        self.verification_cache.clear()
         self.next_dog_id = 1
         self.current_frame = 0
-    
-    def set_all_thresholds(self, base_threshold: float):
-        self.thresholds['normal_match'] = max(0.3, min(0.9, base_threshold))
-        self.thresholds['strong_match'] = min(0.9, base_threshold + 0.2)
-        self.thresholds['weak_match'] = max(0.3, base_threshold - 0.15)
-        self.thresholds['temporal_match'] = max(0.3, base_threshold - 0.1)
-        self.thresholds['new_dog'] = min(0.9, base_threshold + 0.1)
+        print("🔄 ReID system reset - all dogs cleared")
     
     def get_statistics(self) -> Dict:
-        active_dogs = len([d for d, f in self.dog_last_seen.items() 
-                          if self.current_frame - f < 150])
-        
-        avg_features = np.mean([len(f) for f in self.dog_database.values()]) if self.dog_database else 0
+        """Get current statistics"""
+        # Count active dogs (seen in last 150 frames)
+        active_dogs = 0
+        for dog_id, last_frame in self.dog_last_seen.items():
+            if self.current_frame - last_frame < 150:
+                active_dogs += 1
+        
+        # Average features per dog
+        if self.dog_database:
+            avg_features = np.mean([len(features) for features in self.dog_database.values()])
+        else:
+            avg_features = 0
         
-        return {
+        stats = {
             'ResNet50': {
                 'total_dogs': self.next_dog_id - 1,
                 'dogs_in_database': len(self.dog_database),
                 'active_dogs': active_dogs,
                 'avg_features_per_dog': avg_features,
-                'thresholds': self.thresholds,
+                'threshold': self.similarity_threshold,
                 'current_frame': self.current_frame
             }
         }
+        
+        return stats
+    
+    def set_debug_mode(self, debug: bool):
+        """Enable/disable debug output"""
+        self.debug = debug
+        print(f"Debug mode: {'ON' if debug else 'OFF'}")
 
-# Convenience aliases
-SingleModelReID = RobustReID
-ImprovedResNet50ReID = RobustReID
-DualModelReID = RobustReID
+# Compatibility aliases for existing code
+ImprovedResNet50ReID = SingleModelReID
+DualModelReID = SingleModelReID