Update reid.py

reid.py

@@ -1,5 +1,6 @@
 """
-Enhanced ReID with Multiple Embeddings, Sleeping Tracks, and Two-Stage Matching
+Enhanced ReID with SQLite Database Integration
+Combines sleeping tracks + multi-stage matching + rich database storage
 """
 import numpy as np
 import cv2
@@ -8,81 +9,77 @@ import timm
 from sklearn.metrics.pairwise import cosine_similarity
 from typing import Dict, List, Optional, Tuple
 from dataclasses import dataclass, field
-import json
-import pickle
-from pathlib import Path
+from collections import deque
 from datetime import datetime, timedelta
+from pathlib import Path
 import warnings
 warnings.filterwarnings('ignore')
 
+from database import DogDatabase
+
 @dataclass
 class DogFeatures:
-    """Container for dog features with multiple embeddings"""
+    """Container for dog features with metadata"""
     features: np.ndarray
     bbox: List[float] = field(default_factory=list)
     confidence: float = 0.5
     frame_num: int = 0
-    image: Optional[np.ndarray] = None
     timestamp: datetime = field(default_factory=datetime.now)
+    image: Optional[np.ndarray] = None
+    angle: str = "unknown"
+    distance: str = "medium"
 
 @dataclass
 class SleepingTrack:
-    """Track that recently disappeared but kept alive for re-entry"""
-    temp_id: int
-    features_list: List[DogFeatures]
-    last_seen: datetime
+    """Track that recently left the scene"""
+    dog_id: int
     last_position: Tuple[float, float]
-    permanent_name: Optional[str] = None
+    last_seen: datetime
+    features_list: List[DogFeatures]
+    avg_embedding: np.ndarray
 
-class EnhancedMegaDescriptorReID:
-    """Enhanced ReID with sleeping tracks and multi-embedding storage"""
-    
-    TURKISH_DOG_NAMES = [
-        "Karabaş", "Pamuk", "Boncuk", "Fındık", "Paşa", "Aslan", "Duman", "Tarçın",
-        "Kömür", "Bal", "Zeytin", "Kurabiye", "Lokum", "Şeker", "Beyaz", "Kara",
-        "Sarı", "Benekli", "Cesur", "Yıldız", "Ay", "Güneş", "Bulut", "Fırtına",
-        "Şimşek", "Yağmur", "Kar", "Buz", "Ateş", "Alev", "Kıvılcım", "Köpük",
-        "Dalga", "Deniz", "Nehir", "Çakıl", "Toprak", "Orman", "Çiçek", "Gül"
-    ]
+class SQLiteEnhancedReID:
+    """
+    Enhanced ReID with SQLite backend
+    - Stores all embeddings in database
+    - Sleeping tracks for re-entry
+    - Multi-stage matching
+    - Rich querying capabilities
+    """
     
-    def __init__(self, device: str = 'cuda', db_path: str = 'dog_database'):
+    def __init__(self, device: str = 'cuda', db_path: str = 'dog_monitoring.db'):
         self.device = device if torch.cuda.is_available() else 'cpu'
         
-        # Two different thresholds for two-stage matching
-        self.session_threshold = 0.35  # For current session dogs
-        self.database_threshold = 0.28  # Lower threshold for database (more lenient)
-        self.sleeping_threshold = 0.30  # For recently lost tracks
+        # Initialize SQLite database
+        self.db = DogDatabase(db_path)
         
-        self.db_path = Path(db_path)
-        self.db_path.mkdir(exist_ok=True)
-        (self.db_path / 'images').mkdir(exist_ok=True)
+        # Thresholds
+        self.session_threshold = 0.35
+        self.database_threshold = 0.28
+        self.sleeping_threshold = 0.32
         
-        # Load permanent database with multiple embeddings
-        self.permanent_dogs = self.load_permanent_database()
-        self.used_names = {dog['name'] for dog in self.permanent_dogs.values()}
+        # Sleeping tracks system
+        self.sleeping_tracks: List[SleepingTrack] = []
+        self.sleeping_track_timeout = 120
+        self.max_sleeping_tracks = 20
         
-        # Temporary session data with multiple embeddings per dog
-        self.session_dogs = {}  # temp_id -> list of DogFeatures
-        self.session_best_images = {}
-        self.temp_to_permanent = {}
+        # Session tracking (temp IDs map to permanent dog_ids)
+        self.session_dogs = {}  # temp_id -> dog_id in database
+        self.temp_id_features = {}  # temp_id -> list of features
         self.next_temp_id = 1
         self.current_frame = 0
+        self.current_video_source = "unknown"
         
-        # ENHANCEMENT 1: Sleeping tracks for re-identification
-        self.sleeping_tracks: List[SleepingTrack] = []
-        self.sleeping_track_ttl = 60  # Keep sleeping tracks for 60 seconds
-        
-        # Statistics
-        self.known_dog_detections = []
-        self.reentry_matches = 0  # Track successful re-entries
+        # Cache for database embeddings (loaded once)
+        self.db_embeddings_cache = {}
+        self._load_database_embeddings()
         
         # Initialize model
         self._initialize_megadescriptor()
         
-        print(f"✅ Enhanced ReID initialized")
-        print(f"📁 Database: {self.db_path}")
-        print(f"🐕 Known dogs: {len(self.permanent_dogs)}")
-        print(f"🔄 Sleeping track buffer: {self.sleeping_track_ttl}s")
+        print(f"SQLite Enhanced ReID initialized")
+        print(f"Database: {db_path}")
+        print(f"Registered dogs: {len(self.db_embeddings_cache)}")
     
     def _initialize_megadescriptor(self):
         """Initialize MegaDescriptor-L-384"""
@@ -98,184 +95,198 @@ class EnhancedMegaDescriptorReID:
                 mean=[0.5, 0.5, 0.5],
                 std=[0.5, 0.5, 0.5]
             )
-            print("✅ MegaDescriptor-L-384 loaded")
+            print("MegaDescriptor-L-384 loaded")
         except Exception as e:
-            print(f"❌ Model initialization error: {e}")
+            print(f"Error loading model: {e}")
             self.model = None
     
-    def load_permanent_database(self) -> Dict:
-        """Load database with multiple embeddings per dog"""
-        db_file = self.db_path / 'dogs_database.json'
-        embeddings_file = self.db_path / 'embeddings.pkl'
+    def _load_database_embeddings(self):
+        """Load all embeddings from database into memory cache"""
+        self.db_embeddings_cache.clear()
         
-        if not db_file.exists():
-            return {}
+        # Get all active dogs
+        dogs_df = self.db.get_all_dogs(active_only=True)
+        
+        for _, dog in dogs_df.iterrows():
+            dog_id = dog['dog_id']
+            
+            # Get recent features for this dog
+            features = self.db.get_features(dog_id, limit=20)
+            
+            if features:
+                # Store all embeddings for this dog
+                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 with embeddings from database")
+    
+    def set_video_source(self, video_path: str):
+        """Set current video source for tracking"""
+        self.current_video_source = video_path
+    
+    def extract_features(self, image: np.ndarray, bbox: List[float] = None) -> Optional[DogFeatures]:
+        """Extract features using MegaDescriptor-L"""
+        if image is None or image.size == 0 or self.model is None:
+            return None
         
         try:
-            with open(db_file, 'r', encoding='utf-8') as f:
-                dogs_data = json.load(f)
+            img_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            from PIL import Image
+            pil_img = Image.fromarray(img_rgb)
+            img_tensor = self.transform(pil_img).unsqueeze(0).to(self.device)
             
-            if embeddings_file.exists():
-                with open(embeddings_file, 'rb') as f:
-                    embeddings = pickle.load(f)
-                
-                # Support both single and multiple embeddings
-                for dog_name, embedding_data in embeddings.items():
-                    if dog_name in dogs_data:
-                        if isinstance(embedding_data, list):
-                            # Multiple embeddings already stored
-                            dogs_data[dog_name]['embeddings'] = embedding_data
-                        else:
-                            # Legacy single embedding - convert to list
-                            dogs_data[dog_name]['embeddings'] = [embedding_data]
+            with torch.no_grad():
+                features = self.model(img_tensor)
+                features = features.squeeze().cpu().numpy()
+                features = features / (np.linalg.norm(features) + 1e-7)
+            
+            # Classify angle and distance
+            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"
             
-            print(f"📚 Loaded {len(dogs_data)} dogs from database")
-            return dogs_data
+            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
+            )
         except Exception as e:
-            print(f"Error loading database: {e}")
-            return {}
+            print(f"Feature extraction error: {e}")
+            return None
     
-    def save_permanent_database(self):
-        """Save database with multiple embeddings"""
-        db_file = self.db_path / 'dogs_database.json'
-        embeddings_file = self.db_path / 'embeddings.pkl'
-        
-        metadata = {}
-        embeddings = {}
-        
-        for dog_name, dog_data in self.permanent_dogs.items():
-            metadata[dog_name] = {
-                'name': dog_data['name'],
-                'first_seen': dog_data['first_seen'],
-                'last_seen': dog_data['last_seen'],
-                'total_sightings': dog_data['total_sightings'],
-                'image_path': dog_data.get('image_path', ''),
-                'num_embeddings': len(dog_data.get('embeddings', []))
-            }
-            
-            if 'embeddings' in dog_data:
-                embeddings[dog_name] = dog_data['embeddings']
+    def check_sleeping_tracks(self, features: np.ndarray, position: Tuple[float, float]) -> Optional[int]:
+        """
+        Check if detection matches recently lost track
+        Returns: dog_id if match found
+        """
+        if not self.sleeping_tracks:
+            return None
+        
+        current_time = datetime.now()
+        best_match = None
+        best_score = 0
         
-        with open(db_file, 'w', encoding='utf-8') as f:
-            json.dump(metadata, f, indent=2, ensure_ascii=False)
+        # Clean up old sleeping tracks
+        self.sleeping_tracks = [
+            st for st in self.sleeping_tracks
+            if (current_time - st.last_seen).total_seconds() < self.sleeping_track_timeout
+        ]
+        
+        for sleeping_track in self.sleeping_tracks:
+            # Temporal proximity bonus
+            time_diff = (current_time - sleeping_track.last_seen).total_seconds()
+            time_bonus = 0.05 if time_diff < 10 else 0.02 if time_diff < 30 else 0
+            
+            # Spatial proximity 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.05 if spatial_distance < 100 else 0.02 if spatial_distance < 200 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 + spatial_bonus
+            
+            if final_score > best_score and final_score >= self.sleeping_threshold:
+                best_score = final_score
+                best_match = sleeping_track.dog_id
         
-        with open(embeddings_file, 'wb') as f:
-            pickle.dump(embeddings, f)
+        if best_match:
+            print(f"  Re-entry: Dog ID {best_match} (score: {best_score:.3f})")
+            # Remove from sleeping tracks
+            self.sleeping_tracks = [st for st in self.sleeping_tracks if st.dog_id != best_match]
         
-        print(f"💾 Database saved: {len(metadata)} dogs")
+        return best_match
     
-    def check_sleeping_tracks(self, features: np.ndarray, position: Tuple[float, float]) -> Optional[Tuple[int, str]]:
-        """ENHANCEMENT 1: Check recently lost tracks first"""
-        current_time = datetime.now()
-        active_sleeping = []
+    def check_database(self, features: np.ndarray) -> Optional[int]:
+        """Check against database dogs with separate threshold"""
+        if not self.db_embeddings_cache:
+            return None
         
-        for track in self.sleeping_tracks:
-            # Remove expired sleeping tracks
-            time_diff = (current_time - track.last_seen).total_seconds()
-            if time_diff > self.sleeping_track_ttl:
-                continue
-            
-            active_sleeping.append(track)
+        best_match = None
+        best_score = 0
+        all_scores = []
+        
+        for dog_id, dog_data in self.db_embeddings_cache.items():
+            embeddings = dog_data['embeddings']
             
-            # Calculate similarities with all stored embeddings
+            # Compare with all stored embeddings
             similarities = []
-            for stored_feat in track.features_list[-10:]:  # Last 10 embeddings
+            for emb in embeddings:
                 sim = cosine_similarity(
                     features.reshape(1, -1),
-                    stored_feat.features.reshape(1, -1)
+                    emb.reshape(1, -1)
                 )[0, 0]
                 similarities.append(sim)
             
-            if similarities:
-                max_sim = np.max(similarities)
-                avg_sim = np.mean(similarities)
-                final_score = 0.7 * max_sim + 0.3 * avg_sim
-                
-                # Temporal consistency: boost score if position is nearby
-                pos_distance = np.sqrt((position[0] - track.last_position[0])**2 + 
-                                      (position[1] - track.last_position[1])**2)
-                if pos_distance < 200:  # Within reasonable distance
-                    final_score *= 1.1  # 10% boost
-                
-                if final_score >= self.sleeping_threshold:
-                    print(f"  🔄 RE-ENTRY: Temp ID {track.temp_id} (score: {final_score:.3f}, time: {time_diff:.1f}s)")
-                    self.reentry_matches += 1
-                    self.sleeping_tracks = active_sleeping
-                    return (track.temp_id, track.permanent_name)
+            max_sim = max(similarities) if similarities else 0
+            all_scores.append((dog_id, dog_data['name'], max_sim))
+            
+            if max_sim > best_score:
+                best_score = max_sim
+                best_match = dog_id
+        
+        # Debug output
+        if all_scores:
+            all_scores.sort(key=lambda x: x[2], reverse=True)
+            print(f"  DB matches: {[(n, f'{s:.3f}') for _, n, s in all_scores[:3]]}")
+        
+        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
         
-        self.sleeping_tracks = active_sleeping
         return None
     
-    def check_permanent_database_enhanced(self, features: np.ndarray) -> Optional[str]:
-        """ENHANCEMENT 2: Check permanent database with multiple embeddings"""
-        if not self.permanent_dogs:
-            return None
-        
-        best_match = None
-        best_score = 0
+    def check_session(self, features: np.ndarray) -> Optional[int]:
+        """Check against current session dogs (temp IDs)"""
+        best_temp_id = None
+        best_score = -1.0
         
-        for dog_name, dog_data in self.permanent_dogs.items():
-            if 'embeddings' not in dog_data:
-                continue
-            
-            # Compare against all stored embeddings
+        for temp_id, features_list in self.temp_id_features.items():
             similarities = []
-            for embedding in dog_data['embeddings']:
+            for stored_feat in features_list[-30:]:
                 sim = cosine_similarity(
                     features.reshape(1, -1),
-                    embedding.reshape(1, -1)
+                    stored_feat.features.reshape(1, -1)
                 )[0, 0]
                 similarities.append(sim)
             
             if similarities:
-                # Use best match from multiple embeddings
                 max_sim = np.max(similarities)
-                avg_sim = np.mean(similarities)
-                final_score = 0.6 * max_sim + 0.4 * avg_sim
+                avg_sim = np.mean(similarities[-10:])
+                final_score = 0.7 * max_sim + 0.3 * avg_sim
                 
                 if final_score > best_score:
                     best_score = final_score
-                    best_match = dog_name
+                    best_temp_id = temp_id
         
-        # Lower threshold for database matching
-        if best_score >= self.database_threshold:
-            print(f"  ✅ DATABASE MATCH: {best_match} (score: {best_score:.3f})")
-            return best_match
+        if best_temp_id is not None and best_score >= self.session_threshold:
+            return best_temp_id
         
         return None
     
-    def extract_features(self, image: np.ndarray, bbox: List[float] = None) -> Optional[DogFeatures]:
-        """Extract features using MegaDescriptor-L"""
-        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
-            pil_img = Image.fromarray(img_rgb)
-            img_tensor = self.transform(pil_img).unsqueeze(0).to(self.device)
-            
-            with torch.no_grad():
-                features = self.model(img_tensor)
-            
-            features = features.squeeze().cpu().numpy()
-            features = features / (np.linalg.norm(features) + 1e-7)
-            
-            return DogFeatures(
-                features=features,
-                bbox=bbox if bbox else [0, 0, 100, 100],
-                frame_num=self.current_frame,
-                image=image.copy(),
-                timestamp=datetime.now()
-            )
-        except Exception as e:
-            print(f"Feature extraction error: {e}")
-            return None
-    
-    def match_or_register(self, track, image_crop=None) -> Tuple[int, float, Optional[str]]:
-        """Enhanced matching with two-stage approach and sleeping tracks"""
+    def match_or_register(self, track, image_crop=None) -> Tuple[int, int, float, bool]:
+        """
+        Three-stage matching with SQLite storage
+        Returns: (temp_id, dog_id, confidence, is_known)
+        """
         self.current_frame += 1
         
+        # Get detection
         detection = None
         for det in reversed(track.detections[-3:]):
             if det.image_crop is not None:
@@ -284,245 +295,250 @@ class EnhancedMegaDescriptorReID:
                 break
         
         if detection is None or image_crop is None:
-            return 0, 0.0, None
+            return 0, 0, 0.0, False
         
-        features = self.extract_features(
+        # Extract features
+        features_obj = self.extract_features(
             image_crop,
             detection.bbox if hasattr(detection, 'bbox') else None
         )
         
-        if features is None:
-            return 0, 0.0, None
+        if features_obj is None:
+            return 0, 0, 0.0, False
         
-        features.confidence = detection.confidence if hasattr(detection, 'confidence') else 0.5
+        features_obj.confidence = detection.confidence if hasattr(detection, 'confidence') else 0.5
+        features = features_obj.features
         
-        # Get position for temporal consistency
-        bbox = features.bbox
-        position = ((bbox[0] + bbox[2])/2, (bbox[1] + bbox[3])/2)
+        # Get position
+        bbox = features_obj.bbox
+        position = ((bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2)
         
-        # STAGE 1: Check sleeping tracks (recently lost)
-        sleeping_result = self.check_sleeping_tracks(features.features, position)
-        if sleeping_result:
-            temp_id, permanent_name = sleeping_result
-            # Reactivate the track
-            if temp_id in self.session_dogs:
-                self.session_dogs[temp_id].append(features)
-                self.update_best_image(temp_id, features)
-            else:
-                # Restore from sleeping
-                self.session_dogs[temp_id] = [features]
-                self.session_best_images[temp_id] = features
-            
-            if permanent_name:
-                self.temp_to_permanent[temp_id] = permanent_name
+        # STAGE 1: Check sleeping tracks
+        sleeping_dog_id = self.check_sleeping_tracks(features, position)
+        if sleeping_dog_id:
+            # Restore to active session
+            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.temp_id_features[temp_id].append(features_obj)
             
-            # Remove from sleeping tracks
-            self.sleeping_tracks = [t for t in self.sleeping_tracks if t.temp_id != temp_id]
+            # Save to database
+            self._save_to_database(sleeping_dog_id, features_obj, detection)
             
-            return temp_id, 0.95, permanent_name
+            return temp_id, sleeping_dog_id, 1.0, True
         
-        # STAGE 2: Check permanent database
-        permanent_name = self.check_permanent_database_enhanced(features.features)
+        # STAGE 2: Check database
+        db_dog_id = self.check_database(features)
         
-        # STAGE 3: Check current session dogs
-        best_temp_id = None
-        best_score = -1.0
+        # STAGE 3: Check session
+        session_temp_id = self.check_session(features)
         
-        for temp_id, dog_features_list in self.session_dogs.items():
-            similarities = []
-            for stored_feat in dog_features_list[-20:]:
-                sim = cosine_similarity(
-                    features.features.reshape(1, -1),
-                    stored_feat.features.reshape(1, -1)
-                )[0, 0]
-                similarities.append(sim)
+        if session_temp_id is not None:
+            # Existing session dog
+            self.temp_id_features[session_temp_id].append(features_obj)
+            if len(self.temp_id_features[session_temp_id]) > 50:
+                self.temp_id_features[session_temp_id] = self.temp_id_features[session_temp_id][-50:]
             
-            if similarities:
-                max_sim = np.max(similarities)
-                avg_sim = np.mean(similarities)
-                final_score = 0.6 * max_sim + 0.4 * avg_sim
-                
-                if final_score > best_score:
-                    best_score = final_score
-                    best_temp_id = temp_id
-        
-        if best_temp_id is not None and best_score >= self.session_threshold:
-            # Match found in session
-            self.session_dogs[best_temp_id].append(features)
-            if len(self.session_dogs[best_temp_id]) > 30:
-                self.session_dogs[best_temp_id] = self.session_dogs[best_temp_id][-30:]
-            
-            self.update_best_image(best_temp_id, features)
+            # Get or create dog_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  # Will be created on save
             
-            if permanent_name:
-                self.temp_to_permanent[best_temp_id] = permanent_name
-                self.known_dog_detections.append(permanent_name)
+            if dog_id > 0:
+                self._save_to_database(dog_id, features_obj, detection)
             
-            return best_temp_id, best_score, permanent_name
+            return session_temp_id, dog_id, 0.8, (db_dog_id is not None)
+        
         else:
             # New dog in session
             new_temp_id = self.next_temp_id
             self.next_temp_id += 1
-            self.session_dogs[new_temp_id] = [features]
-            self.session_best_images[new_temp_id] = features
+            self.temp_id_features[new_temp_id] = [features_obj]
             
-            if permanent_name:
-                self.temp_to_permanent[new_temp_id] = permanent_name
-                self.known_dog_detections.append(permanent_name)
-                print(f"  ℹ️ Known dog {permanent_name} got temp ID {new_temp_id}")
+            if db_dog_id:
+                # Known dog from database
+                self.session_dogs[new_temp_id] = db_dog_id
+                self._save_to_database(db_dog_id, features_obj, detection)
+                print(f"  Known dog (ID {db_dog_id}) -> Temp ID {new_temp_id}")
+                return new_temp_id, db_dog_id, 1.0, True
             else:
-                print(f"  🆕 New dog: Temp ID {new_temp_id}")
-            
-            return new_temp_id, 1.0, permanent_name
+                # Completely new dog
+                print(f"  New dog: Temp ID {new_temp_id}")
+                return new_temp_id, 0, 1.0, False
     
-    def move_to_sleeping(self, temp_id: int):
-        """Move a lost track to sleeping tracks"""
-        if temp_id in self.session_dogs:
-            features_list = self.session_dogs[temp_id]
-            if features_list:
-                last_features = features_list[-1]
-                bbox = last_features.bbox
-                position = ((bbox[0] + bbox[2])/2, (bbox[1] + bbox[3])/2)
-                
-                sleeping_track = SleepingTrack(
-                    temp_id=temp_id,
-                    features_list=features_list.copy(),
-                    last_seen=datetime.now(),
-                    last_position=position,
-                    permanent_name=self.temp_to_permanent.get(temp_id)
-                )
-                
-                self.sleeping_tracks.append(sleeping_track)
-                print(f"  💤 Moved dog {temp_id} to sleeping tracks")
+    def _get_temp_id_for_dog(self, dog_id: int) -> int:
+        """Get existing temp_id for dog_id or create new one"""
+        for temp_id, stored_dog_id in self.session_dogs.items():
+            if stored_dog_id == dog_id:
+                return temp_id
+        
+        # Create new 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 update_best_image(self, temp_id: int, features: DogFeatures):
-        """Update best quality image"""
-        current_best = self.session_best_images.get(temp_id)
-        
-        if features.image is not None:
-            quality = features.confidence * np.prod(features.image.shape[:2])
+    def _save_to_database(self, dog_id: int, features: DogFeatures, detection):
+        """Save features and image to database"""
+        try:
+            # Update dog sighting
+            self.db.update_dog_sighting(dog_id)
             
-            if current_best is None or current_best.image is None:
-                self.session_best_images[temp_id] = features
-            else:
-                current_quality = current_best.confidence * np.prod(current_best.image.shape[:2])
-                if quality > current_quality:
-                    self.session_best_images[temp_id] = features
+            # Save features
+            # Create dummy color histogram (you can compute real one if needed)
+            color_histogram = np.zeros(256)
+            
+            self.db.save_features(
+                dog_id=dog_id,
+                resnet_features=features.features,
+                color_histogram=color_histogram,
+                confidence=features.confidence
+            )
+            
+            # Save image
+            image_id = 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
+            )
+            
+            # Add sighting
+            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 move_to_sleeping_tracks(self, temp_id: int, last_position: Tuple[float, float]):
+        """Move lost track to sleeping tracks"""
+        if temp_id not in self.temp_id_features:
+            return
+        
+        features_list = self.temp_id_features[temp_id]
+        if not features_list:
+            return
+        
+        # Get dog_id if known
+        dog_id = self.session_dogs.get(temp_id, 0)
+        if dog_id == 0:
+            return  # Don't store unknown dogs in sleeping
+        
+        # Calculate average embedding
+        embeddings = [f.features for f in features_list]
+        avg_embedding = np.mean(embeddings, axis=0)
+        avg_embedding = avg_embedding / np.linalg.norm(avg_embedding)
+        
+        sleeping_track = SleepingTrack(
+            dog_id=dog_id,
+            last_position=last_position,
+            last_seen=datetime.now(),
+            features_list=features_list[-10:],
+            avg_embedding=avg_embedding
+        )
+        
+        self.sleeping_tracks.append(sleeping_track)
+        
+        if len(self.sleeping_tracks) > self.max_sleeping_tracks:
+            self.sleeping_tracks = sorted(
+                self.sleeping_tracks,
+                key=lambda x: x.last_seen,
+                reverse=True
+            )[:self.max_sleeping_tracks]
+        
+        print(f"  Sleeping: Dog {dog_id} (total: {len(self.sleeping_tracks)})")
     
     def save_session_to_permanent(self) -> Dict:
-        """Save session dogs with multiple embeddings"""
+        """Save new dogs to database"""
         saved_dogs = {}
         
-        for temp_id, features_list in self.session_dogs.items():
-            if temp_id in self.temp_to_permanent:
-                # Update existing dog with new embeddings
-                dog_name = self.temp_to_permanent[temp_id]
-                if dog_name in self.permanent_dogs:
-                    # Add new diverse embeddings
-                    existing_embeddings = self.permanent_dogs[dog_name].get('embeddings', [])
-                    new_embeddings = [f.features for f in features_list[-5:]]  # Last 5
-                    
-                    # Combine and limit to 10 embeddings per dog
-                    all_embeddings = existing_embeddings + new_embeddings
-                    self.permanent_dogs[dog_name]['embeddings'] = all_embeddings[-10:]
-                    self.permanent_dogs[dog_name]['last_seen'] = datetime.now().isoformat()
-                    self.permanent_dogs[dog_name]['total_sightings'] += 1
-                    print(f"  🔄 Updated {dog_name} (now {len(self.permanent_dogs[dog_name]['embeddings'])} embeddings)")
+        for temp_id, features_list in self.temp_id_features.items():
+            # Skip if already has dog_id
+            if temp_id in self.session_dogs:
                 continue
             
-            # New dog - save with multiple embeddings
-            dog_name = self.get_next_turkish_name()
-            
-            # Store multiple diverse embeddings (up to 5)
-            embeddings = [f.features for f in features_list[-5:]]
+            # Create new dog in database
+            dog_id = self.db.add_dog(name=f"Dog_{datetime.now().strftime('%Y%m%d_%H%M%S')}")
+            self.session_dogs[temp_id] = dog_id
             
-            # Save best image
-            best_features = self.session_best_images.get(temp_id)
-            image_path = None
-            if best_features and best_features.image is not None:
-                image_filename = f"{dog_name.lower()}.jpg"
-                image_path = self.db_path / 'images' / image_filename
-                cv2.imwrite(str(image_path), best_features.image)
-                image_path = str(image_path.relative_to(self.db_path))
-            
-            self.permanent_dogs[dog_name] = {
-                'name': dog_name,
-                'embeddings': embeddings,  # Multiple embeddings
-                'first_seen': datetime.now().isoformat(),
-                'last_seen': datetime.now().isoformat(),
-                'total_sightings': 1,
-                'image_path': image_path
-            }
+            # Save all features and images
+            for features in features_list:
+                # Create dummy detection-like object
+                class DummyDetection:
+                    pass
+                det = DummyDetection()
+                det.bbox = features.bbox
+                det.confidence = features.confidence
+                det.image_crop = features.image
+                
+                self._save_to_database(dog_id, features, det)
             
-            saved_dogs[temp_id] = dog_name
-            self.used_names.add(dog_name)
-            print(f"  ✅ Saved new dog: {dog_name} ({len(embeddings)} embeddings)")
+            saved_dogs[temp_id] = dog_id
+            print(f"  Saved: Temp {temp_id} -> Dog ID {dog_id}")
         
-        if saved_dogs or self.temp_to_permanent:
-            self.save_permanent_database()
+        # Reload cache
+        if saved_dogs:
+            self._load_database_embeddings()
         
         return saved_dogs
     
-    def get_next_turkish_name(self) -> str:
-        """Get next available Turkish dog name"""
-        for name in self.TURKISH_DOG_NAMES:
-            if name not in self.used_names:
-                return name
-        
-        counter = 2
-        while True:
-            for name in self.TURKISH_DOG_NAMES:
-                numbered_name = f"{name}_{counter}"
-                if numbered_name not in self.used_names:
-                    return numbered_name
-            counter += 1
-    
     def match_or_register_all(self, track) -> Dict:
         """Compatible interface"""
-        temp_id, confidence, permanent_name = self.match_or_register(track)
+        temp_id, dog_id, confidence, is_known = self.match_or_register(track)
         return {
             'MegaDescriptor': {
                 'dog_id': temp_id,
+                'permanent_id': dog_id,
                 'confidence': confidence,
-                'permanent_name': permanent_name
+                'is_known': is_known,
+                'permanent_name': self.db_embeddings_cache.get(dog_id, {}).get('name') if dog_id > 0 else None
             }
         }
     
     def set_all_thresholds(self, threshold: float):
         """Update thresholds"""
         self.session_threshold = max(0.15, min(0.95, threshold))
-        self.database_threshold = self.session_threshold * 0.8  # 20% lower
-        self.sleeping_threshold = self.session_threshold * 0.85  # 15% lower
-        print(f"📊 Thresholds - Session: {self.session_threshold:.2f}, Database: {self.database_threshold:.2f}, Sleeping: {self.sleeping_threshold:.2f}")
+        self.database_threshold = self.session_threshold - 0.07
+        self.sleeping_threshold = self.session_threshold - 0.03
+        print(f"Thresholds - Session: {self.session_threshold:.2f}, DB: {self.database_threshold:.2f}")
     
     def reset_all(self):
         """Reset session"""
-        print("\n📈 Session Summary:")
-        print(f"  • Session dogs: {len(self.session_dogs)}")
-        print(f"  • Known dogs detected: {len(set(self.known_dog_detections))}")
-        print(f"  • Successful re-entries: {self.reentry_matches}")
-        
+        print(f"\nSession Summary: {len(self.temp_id_features)} dogs, {len(self.sleeping_tracks)} sleeping")
+        self.temp_id_features.clear()
         self.session_dogs.clear()
-        self.session_best_images.clear()
-        self.temp_to_permanent.clear()
         self.sleeping_tracks.clear()
         self.next_temp_id = 1
         self.current_frame = 0
-        self.known_dog_detections.clear()
-        self.reentry_matches = 0
-        print("🔄 Session reset\n")
+        print("Session reset\n")
     
     def get_statistics(self) -> Dict:
         """Get statistics"""
+        dogs_df = self.db.get_all_dogs()
+        db_stats = self.db.get_dog_statistics()
+        
         return {
-            'session_dogs': len(self.session_dogs),
-            'permanent_dogs': len(self.permanent_dogs),
+            'session_dogs': len(self.temp_id_features),
+            'database_dogs': len(dogs_df),
             'sleeping_tracks': len(self.sleeping_tracks),
-            'known_detected': list(set(self.known_dog_detections)),
-            'reentry_matches': self.reentry_matches,
-            'threshold': self.session_threshold
+            'total_images': db_stats.get('total_images', 0),
+            'total_sightings': db_stats.get('total_sightings', 0)
         }
 
 # Compatibility aliases
-MegaDescriptorReID = EnhancedMegaDescriptorReID
-MultiComponentReID = EnhancedMegaDescriptorReID
+MegaDescriptorReID = SQLiteEnhancedReID
+EnhancedMegaDescriptorReID = SQLiteEnhancedReID