Update reid.py

reid.py

@@ -1,145 +1,39 @@
 """
-Enhanced ReID with Recommendations 1-9 Applied
-Includes comprehensive debugging system for diagnostics
+Simplified ReID - Basic threshold matching only
+No adaptive thresholds, no quality scoring, no smart storage
 """
 import numpy as np
 import cv2
 import torch
 import timm
 from sklearn.metrics.pairwise import cosine_similarity
-from typing import Dict, List, Optional, Tuple
-from dataclasses import dataclass, field
-from collections import defaultdict, deque
-from datetime import datetime, timedelta
-from pathlib import Path
-import warnings
-import json
-warnings.filterwarnings('ignore')
+from typing import Dict, Optional
+from collections import defaultdict
+from datetime import datetime
 
-from database import DogDatabase
 
-# Debug configuration
-DEBUG_CONFIG = {
-    'VERBOSE': True,  # Master switch for debugging
-    'LOG_THRESHOLDS': True,  # Log threshold decisions
-    'LOG_QUALITY': True,  # Log feature quality scores
-    'LOG_ADAPTIVE': True,  # Log adaptive threshold calculations
-    'LOG_STORAGE': True,  # Log storage reduction
-    'LOG_AGGREGATION': True,  # Log mean embedding stats
-    'LOG_MATCHES': True,  # Log matching decisions
-    'SAVE_DEBUG_FILE': True,  # Save debug info to file
-    'DEBUG_FILE_PATH': 'reid_debug.json'
-}
-
-@dataclass
-class DebugInfo:
-    """Stores debug information for analysis"""
-    timestamp: datetime = field(default_factory=datetime.now)
-    frame_num: int = 0
-    operation: str = ""
-    details: Dict = field(default_factory=dict)
-    
-    def to_dict(self):
-        return {
-            'timestamp': self.timestamp.isoformat(),
-            'frame': self.frame_num,
-            'operation': self.operation,
-            'details': self.details
-        }
-
-@dataclass
-class DogFeatures:
-    features: np.ndarray
-    bbox: List[float] = field(default_factory=list)
-    confidence: float = 0.5
-    quality: float = 0.5  # ADDED: Recommendation #7
-    frame_num: int = 0
-    timestamp: datetime = field(default_factory=datetime.now)
-    image: Optional[np.ndarray] = None
-    angle: str = "unknown"
-    distance: str = "medium"
+class SimplifiedReID:
+    """Simplified ReID with basic threshold matching"""
     
-    # Debug info
-    quality_components: Dict = field(default_factory=dict)  # Breakdown of quality score
-
-@dataclass
-class SleepingTrack:
-    dog_id: int
-    last_position: Tuple[float, float]
-    last_seen: datetime
-    last_frame: int
-    features_list: List[DogFeatures]
-    avg_embedding: np.ndarray
-
-@dataclass
-class ActiveDog:
-    temp_id: int
-    dog_id: int
-    features_list: List[DogFeatures]
-    last_frame_seen: int
-    last_position: Tuple[float, float]
-    
-    # Debug tracking
-    match_history: List[float] = field(default_factory=list)  # Similarity scores over time
-    threshold_history: List[float] = field(default_factory=list)  # Applied thresholds
-
-class SQLiteEnhancedReID:
-    """ReID with Recommendations 1-9 and comprehensive debugging"""
-    
-    def __init__(self, device: str = 'cuda', db_path: str = 'dog_monitoring.db'):
+    def __init__(self, device: str = 'cuda'):
         self.device = device if torch.cuda.is_available() else 'cpu'
-        self.db = DogDatabase(db_path)
         
-        # RECOMMENDATION #1: Fixed threshold hierarchy (DB > Session)
-        self.session_threshold = 0.35  # Base threshold for session matching
-        self.database_threshold = 0.55  # STRICTER for database (was incorrectly lower)
-        self.sleeping_threshold = 0.30  # More lenient for sleeping tracks
+        # Single threshold for all matching
+        self.threshold = 0.40
         
-        self.sleeping_tracks: List[SleepingTrack] = []
-        self.sleeping_track_timeout = 300
-        self.sleeping_frame_timeout = 180
-        self.max_sleeping_tracks = 30
-        
-        self.active_dogs: Dict[int, ActiveDog] = {}
-        self.session_dogs = {}
-        self.temp_id_features = {}
+        # Session tracking (temp IDs)
+        self.temp_id_features = {}  # temp_id -> list of feature vectors
         self.next_temp_id = 1
         self.current_frame = 0
         self.current_video_source = "unknown"
         
-        self.db_embeddings_cache = {}
-        self._load_database_embeddings()
-        self._initialize_megadescriptor()
-        
-        # Debug system
-        self.debug_log = []
-        self.debug_stats = defaultdict(list)
+        # Initialize model
+        self._initialize_model()
         
-        # Quality tracking
-        self.quality_history = defaultdict(list)
-        self.feature_reduction_stats = defaultdict(int)
-        
-        # Aggregation tracking
-        self.aggregation_stats = {
-            'mean_computations': 0,
-            'individual_comparisons': 0,
-            'mean_effectiveness': []
-        }
-        
-        print("="*80)
-        print("Enhanced ReID with Debugging Initialized")
-        print("="*80)
-        print(f"Device: {self.device}")
-        print(f"Database: {db_path}")
-        print(f"Registered dogs: {len(self.db_embeddings_cache)}")
-        print("\n📊 RECOMMENDATION #1: Fixed Thresholds")
-        print(f"  Session threshold: {self.session_threshold:.2f}")
-        print(f"  Database threshold: {self.database_threshold:.2f} (STRICTER)")
-        print(f"  Sleeping threshold: {self.sleeping_threshold:.2f}")
-        print(f"  ✅ Database > Session: {self.database_threshold > self.session_threshold}")
-        print("="*80)
-        
-    def _initialize_megadescriptor(self):
+        print(f"Simplified ReID initialized on {self.device}")
+    
+    def _initialize_model(self):
+        """Load MegaDescriptor model"""
         try:
             self.model = timm.create_model(
                 'hf-hub:BVRA/MegaDescriptor-L-384',
@@ -153,36 +47,32 @@ class SQLiteEnhancedReID:
                 mean=[0.5, 0.5, 0.5],
                 std=[0.5, 0.5, 0.5]
             )
-            print("✅ MegaDescriptor-L-384 loaded successfully")
+            print("MegaDescriptor-L-384 loaded")
         except Exception as e:
-            print(f"❌ Error loading model: {e}")
+            print(f"Error loading model: {e}")
             self.model = None
-            
-    def _load_database_embeddings(self):
-        self.db_embeddings_cache.clear()
-        dogs_df = self.db.get_all_dogs(active_only=True)
-        
-        for _, dog in dogs_df.iterrows():
-            dog_id = dog['dog_id']
-            features = self.db.get_features(dog_id, limit=20)
-            
-            if features:
-                embeddings = [f['resnet_features'] for f in features]
-                self.db_embeddings_cache[dog_id] = {
-                    'name': dog['name'] or f"Dog #{dog_id}",
-                    'embeddings': embeddings,
-                    'total_sightings': dog['total_sightings']
-                }
-        
-        print(f"📁 Loaded {len(self.db_embeddings_cache)} dogs from database")
-        
+    
+    def set_threshold(self, threshold: float):
+        """Set matching threshold"""
+        self.threshold = max(0.10, min(0.95, threshold))
+        print(f"Threshold set to: {self.threshold:.2f}")
+    
     def set_video_source(self, video_path: str):
+        """Set current video source"""
         self.current_video_source = video_path
-        
-    def extract_features(self, image: np.ndarray, bbox: List[float] = None) -> Optional[DogFeatures]:
+    
+    def reset_session(self):
+        """Clear session data"""
+        self.temp_id_features.clear()
+        self.next_temp_id = 1
+        self.current_frame = 0
+        print("Session reset")
+    
+    def extract_features(self, image: np.ndarray) -> Optional[np.ndarray]:
+        """Extract feature vector from image"""
         if image is None or image.size == 0 or self.model is None:
             return None
-            
+        
         try:
             img_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
             from PIL import Image
@@ -191,788 +81,87 @@ class SQLiteEnhancedReID:
             
             with torch.no_grad():
                 features = self.model(img_tensor)
-                
+            
             features = features.squeeze().cpu().numpy()
             features = features / (np.linalg.norm(features) + 1e-7)
             
-            # Check for degenerate features
-            if np.allclose(features, 1.0) or np.allclose(features, 0.0):
-                print(f"⚠️ WARNING: Degenerate features at frame {self.current_frame}")
-                return None
-                
-            h, w = image.shape[:2]
-            aspect_ratio = w / h if h > 0 else 1.0
-            angle = "side" if 0.8 < aspect_ratio < 1.5 else "front" if aspect_ratio > 1.5 else "angled"
-            distance = "close" if max(h, w) > 200 else "far" if max(h, w) < 80 else "medium"
-            
-            return DogFeatures(
-                features=features,
-                bbox=bbox if bbox else [0, 0, 100, 100],
-                frame_num=self.current_frame,
-                timestamp=datetime.now(),
-                image=image.copy(),
-                angle=angle,
-                distance=distance
-            )
+            return features
         except Exception as e:
-            print(f"❌ Feature extraction error: {e}")
+            print(f"Feature extraction error: {e}")
             return None
-            
-    def compute_feature_quality(self, image: np.ndarray, bbox: List[float], 
-                                confidence: float) -> Tuple[float, Dict]:
-        """
-        RECOMMENDATION #7: Feature quality scoring with detailed breakdown
-        Returns: (quality_score, components_dict)
-        """
-        components = {}
-        score = 0.0
-        
-        # Factor 1: Detection confidence (30%)
-        conf_score = confidence
-        components['detection_confidence'] = conf_score
-        score += 0.3 * conf_score
-        
-        # Factor 2: Bounding box size (20%)
-        h, w = image.shape[:2]
-        bbox_area = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
-        frame_area = h * w
-        size_ratio = bbox_area / frame_area if frame_area > 0 else 0
-        size_score = min(1.0, size_ratio / 0.15)  # Ideal is 15% of frame
-        components['bbox_size'] = size_score
-        score += 0.2 * size_score
-        
-        # Factor 3: Image sharpness using Laplacian variance (30%)
-        try:
-            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-            laplacian_var = cv2.Laplacian(gray, cv2.CV_64F).var()
-            sharp_score = min(1.0, laplacian_var / 500)
-            components['sharpness'] = sharp_score
-            score += 0.3 * sharp_score
-        except:
-            components['sharpness'] = 0.5
-            score += 0.15
-            
-        # Factor 4: Centrality in frame (20%)
-        center_x = (bbox[0] + bbox[2]) / 2
-        center_y = (bbox[1] + bbox[3]) / 2
-        frame_center_x = w / 2
-        frame_center_y = h / 2
-        dist_from_center = np.sqrt((center_x - frame_center_x)**2 + (center_y - frame_center_y)**2)
-        max_dist = np.sqrt((w/2)**2 + (h/2)**2)
-        center_score = 1.0 - (dist_from_center / max_dist) if max_dist > 0 else 0.5
-        components['centrality'] = center_score
-        score += 0.2 * center_score
-        
-        # Log quality if debugging enabled
-        if DEBUG_CONFIG['LOG_QUALITY']:
-            self.debug_log.append(DebugInfo(
-                frame_num=self.current_frame,
-                operation="quality_scoring",
-                details={
-                    'total_score': score,
-                    'components': components,
-                    'bbox_area_px': bbox_area,
-                    'frame_coverage': f"{size_ratio*100:.1f}%"
-                }
-            ))
-            
-        return score, components
-        
-    def check_sleeping_tracks(self, features: np.ndarray, position: Tuple[float, float]) -> Optional[int]:
-        """Check sleeping tracks with detailed debugging"""
-        if not self.sleeping_tracks:
-            return None
-            
-        current_time = datetime.now()
-        best_match = None
-        best_score = 0
-        all_scores = []
-        
-        # Clean old sleeping tracks
-        old_count = len(self.sleeping_tracks)
-        self.sleeping_tracks = [
-            st for st in self.sleeping_tracks
-            if (current_time - st.last_seen).total_seconds() < self.sleeping_track_timeout
-            and (self.current_frame - st.last_frame) < self.sleeping_frame_timeout
-        ]
-        
-        if old_count != len(self.sleeping_tracks):
-            print(f"🧹 Cleaned {old_count - len(self.sleeping_tracks)} old sleeping tracks")
-            
-        for sleeping_track in self.sleeping_tracks:
-            time_diff = (current_time - sleeping_track.last_seen).total_seconds()
-            frame_diff = self.current_frame - sleeping_track.last_frame
-            
-            # Temporal bonuses
-            time_bonus = 0.08 if time_diff < 5 else 0.05 if time_diff < 15 else 0.02
-            frame_bonus = 0.05 if frame_diff < 30 else 0.02 if frame_diff < 90 else 0
-            
-            # Spatial bonus
-            last_x, last_y = sleeping_track.last_position
-            curr_x, curr_y = position
-            spatial_distance = np.sqrt((curr_x - last_x)**2 + (curr_y - last_y)**2)
-            spatial_bonus = 0.06 if spatial_distance < 80 else 0.03 if spatial_distance < 150 else 0
-            
-            # Feature similarity
-            similarity = cosine_similarity(
-                features.reshape(1, -1),
-                sleeping_track.avg_embedding.reshape(1, -1)
-            )[0, 0]
-            
-            final_score = similarity + time_bonus + frame_bonus + spatial_bonus
-            
-            all_scores.append({
-                'dog_id': sleeping_track.dog_id,
-                'similarity': similarity,
-                'time_bonus': time_bonus,
-                'frame_bonus': frame_bonus,
-                'spatial_bonus': spatial_bonus,
-                'final_score': final_score,
-                'time_gap': time_diff,
-                'frame_gap': frame_diff,
-                'spatial_dist': spatial_distance
-            })
-            
-            if final_score > best_score and final_score >= self.sleeping_threshold:
-                best_score = final_score
-                best_match = sleeping_track.dog_id
-                
-        # Debug logging
-        if DEBUG_CONFIG['VERBOSE'] and all_scores:
-            print(f"\n🛏️ Sleeping Track Check (Frame {self.current_frame}):")
-            for s in sorted(all_scores, key=lambda x: x['final_score'], reverse=True)[:3]:
-                print(f"  Dog {s['dog_id']}: score={s['final_score']:.3f} "
-                      f"(sim={s['similarity']:.3f}, time_gap={s['time_gap']:.1f}s, "
-                      f"spatial={s['spatial_dist']:.1f}px)")
-                      
-        if best_match:
-            print(f"  ✅ RE-ENTRY: Dog ID {best_match} (score: {best_score:.3f})")
-            self.sleeping_tracks = [st for st in self.sleeping_tracks if st.dog_id != best_match]
-            
-        return best_match
-        
-    def check_database(self, features: np.ndarray) -> Optional[int]:
-        """Database matching with debugging"""
-        if not self.db_embeddings_cache:
-            return None
-            
-        best_match = None
-        best_score = 0
-        all_scores = []
-        
-        for dog_id, dog_data in self.db_embeddings_cache.items():
-            embeddings = dog_data['embeddings']
-            similarities = []
-            
-            for emb in embeddings:
-                sim = cosine_similarity(
-                    features.reshape(1, -1),
-                    emb.reshape(1, -1)
-                )[0, 0]
-                similarities.append(sim)
-                
-            max_sim = max(similarities) if similarities else 0
-            avg_sim = np.mean(similarities) if similarities else 0
-            
-            all_scores.append({
-                'dog_id': dog_id,
-                'name': dog_data['name'],
-                'max_sim': max_sim,
-                'avg_sim': avg_sim,
-                'num_embeddings': len(embeddings)
-            })
-            
-            if max_sim > best_score:
-                best_score = max_sim
-                best_match = dog_id
-                
-        # Debug output
-        if DEBUG_CONFIG['LOG_MATCHES'] and all_scores:
-            all_scores.sort(key=lambda x: x['max_sim'], reverse=True)
-            print(f"\n🗄️ Database Matching (threshold={self.database_threshold:.2f}):")
-            for s in all_scores[:3]:
-                status = "✅" if s['max_sim'] >= self.database_threshold else "❌"
-                print(f"  {status} {s['name']}: max={s['max_sim']:.3f}, "
-                      f"avg={s['avg_sim']:.3f} ({s['num_embeddings']} samples)")
-                      
-        if best_score >= self.database_threshold:
-            dog_name = self.db_embeddings_cache[best_match]['name']
-            print(f"  🎯 DATABASE MATCH: {dog_name} (ID: {best_match}, score: {best_score:.3f})")
-            return best_match
-            
-        return None
-        
-    def compute_mean_embedding(self, features_list: List[DogFeatures]) -> np.ndarray:
-        """
-        RECOMMENDATION #9: Mean embedding aggregation with quality weighting
-        """
-        if not features_list:
-            return None
-    
-        # Extract embeddings and qualities
-        embeddings = []
-        qualities = []
-    
-        for feat in features_list[-20:]:  # Use last 20
-            embeddings.append(feat.features)
-            qualities.append(feat.quality)
-    
-        embeddings = np.array(embeddings)
-        qualities = np.array(qualities)
     
-        # Quality-weighted mean
-        weights = np.array([])  # ✅ ensure weights always exists
-        if np.sum(qualities) > 0:
-            weights = qualities / np.sum(qualities)
-            mean_embedding = np.average(embeddings, axis=0, weights=weights)
-        else:
-            mean_embedding = np.mean(embeddings, axis=0)
-    
-        # Normalize
-        mean_embedding = mean_embedding / (np.linalg.norm(mean_embedding) + 1e-7)
-    
-        # Track aggregation stats
-        self.aggregation_stats['mean_computations'] += 1
-    
-        if DEBUG_CONFIG['LOG_AGGREGATION']:
-            variance = np.var(embeddings, axis=0).mean()
-            self.debug_log.append(DebugInfo(
-                frame_num=self.current_frame,
-                operation="mean_aggregation",
-                details={
-                    'num_embeddings': len(embeddings),
-                    'avg_quality': float(np.mean(qualities)) if qualities.size > 0 else 0,
-                    'embedding_variance': float(variance),
-                    'weight_range': [float(weights.min()), float(weights.max())] if weights.size > 0 else [0, 0]
-                }
-            ))
-    
-        return mean_embedding
-
-        
-    def check_session(self, features: np.ndarray, threshold: float = None) -> Optional[int]:
-        """
-        Session matching with hierarchical search and mean aggregation
-        """
-        if threshold is None:
-            threshold = self.session_threshold
-            
-        # Stage 1: Active IDs (seen in last 30 frames)
-        active_ids = [
-            temp_id for temp_id in self.temp_id_features.keys()
-            if temp_id in self.active_dogs and
-            (self.current_frame - self.active_dogs[temp_id].last_frame_seen) < 30
-        ]
-        
-        # Stage 2: Recently active (30-90 frames)
-        recent_ids = [
-            temp_id for temp_id in self.temp_id_features.keys()
-            if temp_id in self.active_dogs and
-            30 <= (self.current_frame - self.active_dogs[temp_id].last_frame_seen) < 90
-        ]
-        
-        # Stage 3: Inactive IDs
-        all_ids = set(self.temp_id_features.keys())
-        inactive_ids = list(all_ids - set(active_ids) - set(recent_ids))
-        
-        # Search with different thresholds
-        stages = [
-            ('active', active_ids, threshold),
-            ('recent', recent_ids, threshold + 0.05),
-            ('inactive', inactive_ids, threshold + 0.10)
-        ]
-        
-        best_match = None
-        best_score = -1.0
-        best_stage = None
-        
-        for stage_name, ids, stage_threshold in stages:
-            if not ids:
-                continue
-                
-            for temp_id in ids:
-                # RECOMMENDATION #9: Use mean embedding
-                mean_emb = self.compute_mean_embedding(self.temp_id_features[temp_id])
-                if mean_emb is None:
-                    continue
-                    
-                similarity = cosine_similarity(
-                    features.reshape(1, -1),
-                    mean_emb.reshape(1, -1)
-                )[0, 0]
-                
-                if similarity > best_score:
-                    best_score = similarity
-                    best_match = temp_id if similarity >= stage_threshold else None
-                    best_stage = stage_name
-                    
-        # Debug output
-        if DEBUG_CONFIG['LOG_MATCHES']:
-            print(f"\n🔍 Session Matching (Frame {self.current_frame}):")
-            print(f"  Searching: {len(active_ids)} active, {len(recent_ids)} recent, "
-                  f"{len(inactive_ids)} inactive")
-            if best_match:
-                print(f"  ✅ MATCH: Temp ID {best_match} (stage={best_stage}, "
-                      f"score={best_score:.3f}, threshold={threshold:.2f})")
-            else:
-                print(f"  ❌ No match (best_score={best_score:.3f} < threshold={threshold:.2f})")
-                
-        return best_match
-        
-    def compute_adaptive_threshold(self, track_metadata: Dict) -> float:
-        """
-        RECOMMENDATION #6: Adaptive thresholding based on DeepSORT confidence
-        """
-        base_threshold = self.session_threshold
-        adjustment = 0.0
-        
-        hits = track_metadata.get('deepsort_hits', 0)
-        age = track_metadata.get('deepsort_age', 0)
-        time_since_update = track_metadata.get('frames_since_update', 0)
-        
-        # Calculate confidence level
-        if hits > 10 and time_since_update == 0:
-            confidence_level = 'high'
-            adjustment = -0.20  # More lenient
-        elif hits > 5 and time_since_update == 0:
-            confidence_level = 'medium'
-            adjustment = -0.10
-        elif hits > 2 and time_since_update < 5:
-            confidence_level = 'low'
-            adjustment = -0.05
-        else:
-            confidence_level = 'none'
-            adjustment = 0.0
-            
-        effective_threshold = max(0.15, base_threshold + adjustment)
-        
-        # Debug logging
-        if DEBUG_CONFIG['LOG_ADAPTIVE']:
-            self.debug_log.append(DebugInfo(
-                frame_num=self.current_frame,
-                operation="adaptive_threshold",
-                details={
-                    'base_threshold': base_threshold,
-                    'adjustment': adjustment,
-                    'effective_threshold': effective_threshold,
-                    'confidence_level': confidence_level,
-                    'deepsort_hits': hits,
-                    'deepsort_age': age,
-                    'time_since_update': time_since_update
-                }
-            ))
-            
-        if DEBUG_CONFIG['VERBOSE'] and adjustment != 0:
-            print(f"  🎯 Adaptive Threshold: {base_threshold:.2f} → {effective_threshold:.2f} "
-                  f"(confidence={confidence_level}, hits={hits})")
-                  
-        return effective_threshold
-        
-    def smart_feature_storage(self, temp_id: int, new_feature: DogFeatures) -> bool:
-        """
-        RECOMMENDATION #8: Reduce storage to 20 best features
-        Returns: True if feature was stored, False if rejected
-        """
-        features_list = self.temp_id_features[temp_id]
-        
-        # Always store if we have less than 5
-        if len(features_list) < 5:
-            features_list.append(new_feature)
-            self.feature_reduction_stats['stored_initial'] += 1
-            return True
-            
-        # Check quality threshold
-        if new_feature.quality < 0.4:
-            self.feature_reduction_stats['rejected_quality'] += 1
-            if DEBUG_CONFIG['LOG_STORAGE']:
-                print(f"  ❌ Feature rejected: quality {new_feature.quality:.2f} < 0.4")
-            return False
-            
-        # Check diversity (avoid redundant features)
-        recent_features = features_list[-5:]
-        max_similarity = max([
-            np.dot(new_feature.features, f.features)
-            for f in recent_features
-        ])
-        
-        if max_similarity > 0.95:
-            self.feature_reduction_stats['rejected_redundant'] += 1
-            if DEBUG_CONFIG['LOG_STORAGE']:
-                print(f"  ❌ Feature rejected: too similar ({max_similarity:.3f}) to existing")
-            return False
-            
-        # Add the feature
-        features_list.append(new_feature)
-        self.feature_reduction_stats['stored_diverse'] += 1
-        
-        # RECOMMENDATION #8: Keep only top 20 by quality
-        if len(features_list) > 20:
-            # Sort by quality
-            features_list.sort(key=lambda x: x.quality, reverse=True)
-            removed_count = len(features_list) - 20
-            features_list = features_list[:20]
-            self.temp_id_features[temp_id] = features_list
-            self.feature_reduction_stats['pruned'] += removed_count
-            
-            if DEBUG_CONFIG['LOG_STORAGE']:
-                qualities = [f.quality for f in features_list]
-                print(f"  🗑️ Pruned {removed_count} features. Quality range: "
-                      f"[{min(qualities):.2f}-{max(qualities):.2f}]")
-                
-        return True
-        
-    def match_or_register_all(self, track, deepsort_hits=0, deepsort_age=0,
-                              frames_since_update=0) -> Dict:
+    def match_or_register(self, track) -> Dict:
         """
-        RECOMMENDATION #5: Main matching with DeepSORT metadata integration
+        Simple matching: compare features against existing temp_ids
+        If match found -> return temp_id
+        If no match -> create new temp_id
         """
         self.current_frame += 1
-        self._auto_move_inactive_to_sleeping()
         
-        # Get detection and image
+        # Get image crop from track
         detection = None
         for det in reversed(track.detections[-3:]):
             if det.image_crop is not None:
                 detection = det
                 break
-                
-        if detection is None or detection.image_crop is None:
-            return self._empty_result()
-            
-        # Extract features
-        features_obj = self.extract_features(
-            detection.image_crop,
-            detection.bbox if hasattr(detection, 'bbox') else None
-        )
-        
-        if features_obj is None:
-            return self._empty_result()
-            
-        # RECOMMENDATION #7: Compute quality score
-        features_obj.quality, features_obj.quality_components = self.compute_feature_quality(
-            detection.image_crop,
-            features_obj.bbox,
-            detection.confidence if hasattr(detection, 'confidence') else 0.5
-        )
-        
-        features = features_obj.features
-        bbox = features_obj.bbox
-        position = ((bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2)
         
-        # Log current state
-        if DEBUG_CONFIG['VERBOSE']:
-            print(f"\n{'='*60}")
-            print(f"Frame {self.current_frame} | Track {track.track_id}")
-            print(f"Feature quality: {features_obj.quality:.2f} | "
-                  f"DeepSORT: hits={deepsort_hits}, age={deepsort_age}, "
-                  f"since_update={frames_since_update}")
-            
-        # STAGE 1: Check sleeping tracks
-        sleeping_dog_id = self.check_sleeping_tracks(features, position)
-        if sleeping_dog_id:
-            temp_id = self._get_temp_id_for_dog(sleeping_dog_id)
-            if temp_id not in self.temp_id_features:
-                self.temp_id_features[temp_id] = []
-            self.smart_feature_storage(temp_id, features_obj)
-            self._update_active_dog(temp_id, sleeping_dog_id, features_obj, position)
-            self._save_to_database(sleeping_dog_id, features_obj, detection)
-            return self._create_result(temp_id, sleeping_dog_id, 1.0, True, "sleeping_reentry")
-            
-        # STAGE 2: Check database
-        db_dog_id = self.check_database(features)
+        if detection is None or detection.image_crop is None:
+            return {'temp_id': 0}
         
-        # RECOMMENDATION #6: Compute adaptive threshold
-        track_metadata = {
-            'deepsort_hits': deepsort_hits,
-            'deepsort_age': deepsort_age,
-            'frames_since_update': frames_since_update
-        }
-        effective_threshold = self.compute_adaptive_threshold(track_metadata)
+        # Extract features
+        features = self.extract_features(detection.image_crop)
+        if features is None:
+            return {'temp_id': 0}
         
-        # STAGE 3: Check session with adaptive threshold
-        session_temp_id = self.check_session(features, effective_threshold)
+        # Search for match in existing temp_ids
+        best_temp_id = None
+        best_score = -1.0
         
-        if session_temp_id is not None:
-            # RECOMMENDATION #8: Smart storage
-            self.smart_feature_storage(session_temp_id, features_obj)
-            
-            # Determine permanent ID
-            if session_temp_id in self.session_dogs:
-                dog_id = self.session_dogs[session_temp_id]
-            elif db_dog_id:
-                dog_id = db_dog_id
-                self.session_dogs[session_temp_id] = dog_id
-            else:
-                dog_id = 0
-                
-            self._update_active_dog(session_temp_id, dog_id, features_obj, position)
+        for temp_id, features_list in self.temp_id_features.items():
+            # Compare against all stored features for this temp_id
+            similarities = []
+            for stored_features in features_list:
+                sim = np.dot(features, stored_features)
+                similarities.append(sim)
             
-            if dog_id > 0:
-                self._save_to_database(dog_id, features_obj, detection)
-                
-            return self._create_result(session_temp_id, dog_id, 0.8, 
-                                       (db_dog_id is not None), "session_match")
+            if similarities:
+                max_sim = max(similarities)
+                if max_sim > best_score:
+                    best_score = max_sim
+                    best_temp_id = temp_id
+        
+        # Check if best score passes threshold
+        if best_temp_id is not None and best_score >= self.threshold:
+            # Match found - add features to existing temp_id
+            self.temp_id_features[best_temp_id].append(features)
+            
+            # Limit storage (keep last 30)
+            if len(self.temp_id_features[best_temp_id]) > 30:
+                self.temp_id_features[best_temp_id] = self.temp_id_features[best_temp_id][-30:]
+            
+            return {
+                'temp_id': best_temp_id,
+                'confidence': best_score,
+                'match_type': 'existing'
+            }
         else:
-            # New temp ID
+            # No match - create new temp_id
             new_temp_id = self.next_temp_id
             self.next_temp_id += 1
-            self.temp_id_features[new_temp_id] = [features_obj]
+            self.temp_id_features[new_temp_id] = [features]
             
-            if db_dog_id:
-                self.session_dogs[new_temp_id] = db_dog_id
-                self._update_active_dog(new_temp_id, db_dog_id, features_obj, position)
-                self._save_to_database(db_dog_id, features_obj, detection)
-                print(f"  📂 Known dog (ID {db_dog_id}) → New Temp ID {new_temp_id}")
-                return self._create_result(new_temp_id, db_dog_id, 1.0, True, "database_new")
-            else:
-                self._update_active_dog(new_temp_id, 0, features_obj, position)
-                print(f"  🆕 New dog: Temp ID {new_temp_id}")
-                return self._create_result(new_temp_id, 0, 1.0, False, "completely_new")
-                
-    def _create_result(self, temp_id: int, dog_id: int, confidence: float,
-                       is_known: bool, match_type: str) -> Dict:
-        """Create result dictionary with debug info"""
-        result = {
-            'MegaDescriptor': {
-                'dog_id': temp_id,
-                'permanent_id': dog_id,
-                'confidence': confidence,
-                'is_known': is_known,
-                'permanent_name': self.db_embeddings_cache.get(dog_id, {}).get('name') if dog_id > 0 else None,
-                'match_type': match_type
-            }
-        }
-        
-        # Add debug info
-        if DEBUG_CONFIG['VERBOSE']:
-            result['debug'] = {
-                'frame': self.current_frame,
-                'match_type': match_type,
-                'active_dogs': len(self.active_dogs),
-                'sleeping_tracks': len(self.sleeping_tracks),
-                'temp_ids': len(self.temp_id_features)
-            }
+            print(f"New temp_id: {new_temp_id} (threshold: {self.threshold:.2f})")
             
-        return result
-        
-    def _empty_result(self) -> Dict:
-        """Return empty result when no match possible"""
-        return {
-            'MegaDescriptor': {
-                'dog_id': 0,
-                'permanent_id': 0,
-                'confidence': 0.0,
-                'is_known': False,
-                'permanent_name': None,
-                'match_type': 'no_detection'
+            return {
+                'temp_id': new_temp_id,
+                'confidence': 1.0,
+                'match_type': 'new'
             }
-        }
-        
-    def _update_active_dog(self, temp_id: int, dog_id: int, features: DogFeatures, 
-                          position: Tuple[float, float]):
-        """Update active dog with match history"""
-        if temp_id in self.active_dogs:
-            active = self.active_dogs[temp_id]
-            active.last_frame_seen = self.current_frame
-            active.last_position = position
-            active.features_list.append(features)
-            
-            # Keep last 30 features
-            if len(active.features_list) > 30:
-                active.features_list = active.features_list[-30:]
-        else:
-            self.active_dogs[temp_id] = ActiveDog(
-                temp_id=temp_id,
-                dog_id=dog_id,
-                features_list=[features],
-                last_frame_seen=self.current_frame,
-                last_position=position
-            )
-            
-    def _auto_move_inactive_to_sleeping(self):
-        """Automatically move inactive dogs to sleeping"""
-        inactive_temp_ids = []
-        
-        for temp_id, active_dog in self.active_dogs.items():
-            frames_since_seen = self.current_frame - active_dog.last_frame_seen
-            if frames_since_seen > 30 and active_dog.dog_id > 0:
-                inactive_temp_ids.append(temp_id)
-                
-        for temp_id in inactive_temp_ids:
-            active_dog = self.active_dogs[temp_id]
-            if active_dog.features_list:
-                # Use mean embedding for sleeping track
-                mean_emb = self.compute_mean_embedding(active_dog.features_list)
-                
-                sleeping_track = SleepingTrack(
-                    dog_id=active_dog.dog_id,
-                    last_position=active_dog.last_position,
-                    last_seen=datetime.now(),
-                    last_frame=active_dog.last_frame_seen,
-                    features_list=active_dog.features_list[-10:],
-                    avg_embedding=mean_emb
-                )
-                
-                self.sleeping_tracks.append(sleeping_track)
-                
-                # Limit sleeping tracks
-                if len(self.sleeping_tracks) > self.max_sleeping_tracks:
-                    self.sleeping_tracks = sorted(
-                        self.sleeping_tracks,
-                        key=lambda x: x.last_frame,
-                        reverse=True
-                    )[:self.max_sleeping_tracks]
-                    
-                print(f"  💤 Moved Dog ID {active_dog.dog_id} to sleeping "
-                      f"(inactive for {frames_since_seen} frames)")
-                      
-            del self.active_dogs[temp_id]
-            
-    def _get_temp_id_for_dog(self, dog_id: int) -> int:
-        """Get or create temp ID for a permanent dog ID"""
-        for temp_id, stored_dog_id in self.session_dogs.items():
-            if stored_dog_id == dog_id:
-                return temp_id
-                
-        new_temp_id = self.next_temp_id
-        self.next_temp_id += 1
-        self.session_dogs[new_temp_id] = dog_id
-        return new_temp_id
-        
-    def _save_to_database(self, dog_id: int, features: DogFeatures, detection):
-        """Save to database with error handling"""
-        try:
-            self.db.update_dog_sighting(dog_id)
-            
-            color_histogram = np.zeros(256)
-            self.db.save_features(
-                dog_id=dog_id,
-                resnet_features=features.features,
-                color_histogram=color_histogram,
-                confidence=features.confidence
-            )
-            
-            self.db.save_image(
-                dog_id=dog_id,
-                image=features.image,
-                frame_number=features.frame_num,
-                video_source=self.current_video_source,
-                bbox=features.bbox,
-                confidence=features.confidence
-            )
-            
-            position = ((features.bbox[0] + features.bbox[2]) / 2,
-                       (features.bbox[1] + features.bbox[3]) / 2)
-                       
-            self.db.add_sighting(
-                dog_id=dog_id,
-                position=position,
-                video_source=self.current_video_source,
-                frame_number=features.frame_num,
-                confidence=features.confidence
-            )
-        except Exception as e:
-            print(f"❌ Database save error: {e}")
-            
-    def set_all_thresholds(self, threshold: float):
-        """
-        RECOMMENDATION #1: Fixed threshold hierarchy
-        Database MUST be stricter than session
-        """
-        self.session_threshold = max(0.15, min(0.95, threshold))
-        self.database_threshold = self.session_threshold + 0.20  # STRICTER
-        self.sleeping_threshold = self.session_threshold - 0.05  # More lenient
-        
-        print(f"\n📊 Threshold Update:")
-        print(f"  Session: {self.session_threshold:.2f}")
-        print(f"  Database: {self.database_threshold:.2f} (stricter)")
-        print(f"  Sleeping: {self.sleeping_threshold:.2f} (lenient)")
-        print(f"  ✅ Correct hierarchy: DB > Session > Sleeping")
-        
-    def print_debug_summary(self):
-        """Print comprehensive debug summary"""
-        print("\n" + "="*80)
-        print("DEBUG SUMMARY")
-        print("="*80)
-        all_qualities = []
-        # Feature quality stats
-        if self.quality_history:
-           
-            for qualities in self.quality_history.values():
-                all_qualities.extend(qualities)
-            print(f"\n📊 Feature Quality Stats:")
-            print(f"  Average: {np.mean(all_qualities):.3f}")
-            print(f"  Range: [{min(all_qualities):.3f} - {max(all_qualities):.3f}]")
-            
-        # Storage reduction stats
-        print(f"\n💾 Storage Reduction Stats:")
-        for key, value in self.feature_reduction_stats.items():
-            print(f"  {key}: {value}")
-            
-        # Aggregation stats
-        print(f"\n🔄 Aggregation Stats:")
-        print(f"  Mean computations: {self.aggregation_stats['mean_computations']}")
-        print(f"  Individual comparisons: {self.aggregation_stats['individual_comparisons']}")
-        
-        # Save debug file if enabled
-        if DEBUG_CONFIG['SAVE_DEBUG_FILE'] and self.debug_log:
-            debug_data = {
-                'summary': {
-                    'total_frames': self.current_frame,
-                    'temp_ids_created': self.next_temp_id - 1,
-                    'active_dogs': len(self.active_dogs),
-                    'sleeping_tracks': len(self.sleeping_tracks),
-                    'quality_stats': {
-                        'avg': float(np.mean(all_qualities)) if all_qualities else 0,
-                        'min': float(min(all_qualities)) if all_qualities else 0,
-                        'max': float(max(all_qualities)) if all_qualities else 0
-                    },
-                    'storage_stats': dict(self.feature_reduction_stats),
-                    'aggregation_stats': dict(self.aggregation_stats)
-                },
-                'log': [log.to_dict() for log in self.debug_log[-1000:]]  # Last 1000 entries
-            }
-            
-            with open(DEBUG_CONFIG['DEBUG_FILE_PATH'], 'w') as f:
-                json.dump(debug_data, f, indent=2, default=str)
-                
-            print(f"\n💾 Debug log saved to {DEBUG_CONFIG['DEBUG_FILE_PATH']}")
-            
-    def reset_all(self):
-        """Reset with summary"""
-        self.print_debug_summary()
-        
-        self.temp_id_features.clear()
-        self.session_dogs.clear()
-        self.sleeping_tracks.clear()
-        self.active_dogs.clear()
-        self.next_temp_id = 1
-        self.current_frame = 0
-        self.debug_log.clear()
-        self.debug_stats.clear()
-        self.quality_history.clear()
-        self.feature_reduction_stats.clear()
-        
-        print("\n🔄 Session reset complete\n")
-        
+    
     def get_statistics(self) -> Dict:
-        """Get statistics with debug info"""
-        dogs_df = self.db.get_all_dogs()
-        db_stats = self.db.get_dog_statistics()
-        
+        """Get simple statistics"""
         return {
-            'session_dogs': len(self.temp_id_features),
-            'database_dogs': len(dogs_df),
-            'sleeping_tracks': len(self.sleeping_tracks),
-            'active_dogs': len(self.active_dogs),
-            'total_images': db_stats.get('total_images', 0),
-            'total_sightings': db_stats.get('total_sightings', 0),
-            'debug': {
-                'feature_reduction': dict(self.feature_reduction_stats),
-                'aggregation_count': self.aggregation_stats['mean_computations']
-            }
-        }
-
-# Compatibility aliases
-MegaDescriptorReID = SQLiteEnhancedReID
-EnhancedMegaDescriptorReID = SQLiteEnhancedReID
+            'temp_ids': len(self.temp_id_features),
+            'threshold': self.threshold,
+            'current_frame': self.current_frame
+        }