Update app.py

app.py

@@ -1,1215 +1,74 @@
 """
-Complete Dog Detection, Tracking, ReID, and Health Assessment System
-Optimized for HuggingFace Spaces with T4 GPU
-All 57 improvements implemented
+Enhanced Dog Detection Demo with Health Integration and Database Management
+Implements Enhancements 3 and 4
 """
 import gradio as gr
 import cv2
 import numpy as np
 import torch
-import torch.nn as nn
-import timm
-from typing import Dict, List, Optional, Tuple, Any
-from dataclasses import dataclass, field
-from collections import deque
-from pathlib import Path
-from datetime import datetime, timedelta
-import json
-import pickle
+from typing import Dict, List, Optional
+import gc
 import base64
 from io import BytesIO
 from PIL import Image
-import gc
-import warnings
-from scipy.optimize import linear_sum_assignment
-from sklearn.metrics.pairwise import cosine_similarity
-import uuid
-
-warnings.filterwarnings('ignore')
-
-# ==================== DETECTION MODULE ====================
-
-@dataclass
-class Detection:
-    """Detection with pose keypoints"""
-    bbox: List[float]
-    confidence: float
-    image_crop: Optional[np.ndarray] = None
-    keypoints: Optional[np.ndarray] = None  # 24x3 for dog pose
-
-
-class DogDetector:
-    """Dog detector with pose estimation using dog-pose trained model"""
-    
-    def __init__(self, confidence_threshold: float = 0.45, device: str = 'cuda'):
-        self.confidence_threshold = confidence_threshold
-        self.device = device if torch.cuda.is_available() else 'cpu'
-        
-        # Load dog-pose trained model
-        try:
-            from ultralytics import YOLO
-            self.model = YOLO('dog-pose-trained.pt')  # Will be replaced with dog-pose-trained.pt
-            self.model.to(self.device)
-            print(f"✅ Detector loaded on {self.device}")
-        except Exception as e:
-            print(f"❌ Detector error: {e}")
-            self.model = None
-        
-        self.dog_class_id = 0  # Dog class in pose model
-    
-    def detect(self, frames) -> List[List[Detection]]:
-        """Batch detection supporting single frame or list of frames"""
-        if self.model is None:
-            return [[]] if not isinstance(frames, list) else [[] for _ in frames]
-        
-        # Handle single frame
-        if not isinstance(frames, list):
-            frames = [frames]
-            single_mode = True
-        else:
-            single_mode = False
-        
-        all_detections = []
-        
-        try:
-            # Batch inference
-            results = self.model(frames, conf=self.confidence_threshold, verbose=False)
-            
-            for frame_idx, (frame, result) in enumerate(zip(frames, results)):
-                detections = []
-                
-                if result.boxes is not None and len(result.boxes) > 0:
-                    boxes = result.boxes
-                    keypoints_data = result.keypoints if hasattr(result, 'keypoints') else None
-                    
-                    for i in range(len(boxes)):
-                        x1, y1, x2, y2 = boxes.xyxy[i].cpu().numpy()
-                        x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
-                        
-                        h, w = frame.shape[:2]
-                        x1, y1 = max(0, x1), max(0, y1)
-                        x2, y2 = min(w, x2), min(h, y2)
-                        
-                        if x2 <= x1 or y2 <= y1:
-                            continue
-                        
-                        dog_crop = frame[y1:y2, x1:x2].copy()
-                        
-                        # Extract keypoints if available
-                        kpts = None
-                        if keypoints_data is not None and len(keypoints_data) > i:
-                            kpts = keypoints_data[i].data.cpu().numpy().reshape(-1, 3)
-                        
-                        detection = Detection(
-                            bbox=[x1, y1, x2, y2],
-                            confidence=float(boxes.conf[i]),
-                            image_crop=dog_crop,
-                            keypoints=kpts
-                        )
-                        detections.append(detection)
-                
-                all_detections.append(detections)
-        
-        except Exception as e:
-            print(f"Detection error: {e}")
-            all_detections = [[] for _ in frames]
-        
-        return all_detections[0] if single_mode else all_detections
-
-
-# ==================== TRACKING MODULE ====================
-
-class Track:
-    """Enhanced track with pose support and robust state management"""
-    
-    def __init__(self, detection: Detection, track_id: Optional[int] = None):
-        self.track_id = track_id if track_id else int(uuid.uuid4().int % 100000)
-        self.bbox = detection.bbox.copy()
-        self.detections = [detection]
-        self.confidence = detection.confidence
-        self.keypoints = detection.keypoints
-        
-        self.age = 1
-        self.time_since_update = 0
-        self.state = 'tentative'
-        self.hits = 1
-        self.consecutive_misses = 0
-        
-        cx = (self.bbox[0] + self.bbox[2]) / 2
-        cy = (self.bbox[1] + self.bbox[3]) / 2
-        self.trajectory = deque(maxlen=30)
-        self.trajectory.append((cx, cy))
-        
-        self.velocity = np.array([0.0, 0.0])
-        self.sizes = deque(maxlen=10)
-        width = max(1, self.bbox[2] - self.bbox[0])
-        height = max(1, self.bbox[3] - self.bbox[1])
-        self.sizes.append((width, height))
-        
-        self.avg_confidence = self.confidence
-        self.appearance_features = []
-    
-    def predict(self):
-        """Motion prediction"""
-        self.age += 1
-        self.time_since_update += 1
-        self.consecutive_misses += 1
-        
-        try:
-            if len(self.trajectory) >= 3:
-                positions = np.array(list(self.trajectory))[-3:]
-                self.velocity = positions[-1] - positions[-2]
-                
-                max_velocity = 50
-                velocity_magnitude = np.linalg.norm(self.velocity)
-                if velocity_magnitude > max_velocity:
-                    self.velocity = self.velocity / velocity_magnitude * max_velocity
-                
-                predicted_pos = positions[-1] + self.velocity * 0.7
-                
-                avg_width = np.mean([s[0] for s in self.sizes]) if self.sizes else 50
-                avg_height = np.mean([s[1] for s in self.sizes]) if self.sizes else 50
-                
-                self.bbox = [
-                    predicted_pos[0] - avg_width/2,
-                    predicted_pos[1] - avg_height/2,
-                    predicted_pos[0] + avg_width/2,
-                    predicted_pos[1] + avg_height/2
-                ]
-        except:
-            pass
-    
-    def update(self, detection: Detection):
-        """Update with new detection"""
-        self.bbox = detection.bbox.copy()
-        self.detections.append(detection)
-        self.confidence = detection.confidence
-        self.keypoints = detection.keypoints
-        
-        self.avg_confidence = self.avg_confidence * 0.9 + self.confidence * 0.1
-        self.hits += 1
-        self.time_since_update = 0
-        self.consecutive_misses = 0
-        
-        cx = (self.bbox[0] + self.bbox[2]) / 2
-        cy = (self.bbox[1] + self.bbox[3]) / 2
-        self.trajectory.append((cx, cy))
-        
-        width = max(1, self.bbox[2] - self.bbox[0])
-        height = max(1, self.bbox[3] - self.bbox[1])
-        self.sizes.append((width, height))
-        
-        if self.state == 'tentative' and self.hits >= 2:
-            self.state = 'confirmed'
-        
-        if len(self.detections) > 5:
-            for old_det in self.detections[:-5]:
-                if hasattr(old_det, 'image_crop'):
-                    old_det.image_crop = None
-            self.detections = self.detections[-5:]
-    
-    def mark_missed(self):
-        """Mark as missed - TASK 1: Increased thresholds"""
-        if self.state == 'confirmed':
-            if self.consecutive_misses > 60 or self.time_since_update > 90:  # TASK 1
-                self.state = 'deleted'
-        elif self.state == 'tentative':
-            if self.consecutive_misses > 3:
-                self.state = 'deleted'
-
-
-class RobustTracker:
-    """Production tracker with appearance-based fallback and pose matching"""
-    
-    def __init__(self, match_threshold: float = 0.35, track_buffer: int = 90,
-                 use_appearance: bool = True, use_pose: bool = True):
-        self.match_threshold = match_threshold
-        self.track_buffer = track_buffer  # TASK 1: Increased from 30 to 90
-        self.use_appearance = use_appearance
-        self.use_pose = use_pose
-        
-        self.tracks: List[Track] = []
-        self.track_id_count = 1
-        self.recently_deleted_tracks = {}  # TASK 1: Store recently deleted
-        self.max_lost_time = timedelta(minutes=5)  # TASK 1: 5 minute buffer
-        
-        self.max_center_distance = 150
-        self.min_iou_for_match = 0.15
-    
-    def update(self, detections: List[Detection]) -> List[Track]:
-        """Update with appearance and pose fallback"""
-        if not detections:
-            for track in self.tracks:
-                track.predict()
-                track.mark_missed()
-            
-            # Store deleted tracks - TASK 1
-            current_time = datetime.now()
-            for track in [t for t in self.tracks if t.state == 'deleted']:
-                self.recently_deleted_tracks[track.track_id] = {
-                    'track': track,
-                    'deleted_time': current_time
-                }
-            
-            self.tracks = [t for t in self.tracks if t.state != 'deleted']
-            self._cleanup_old_deleted()  # TASK 1
-            return [t for t in self.tracks if t.state == 'confirmed']
-        
-        try:
-            for track in self.tracks:
-                track.predict()
-            
-            confirmed_tracks = [t for t in self.tracks if t.state == 'confirmed']
-            tentative_tracks = [t for t in self.tracks if t.state == 'tentative']
-            
-            matched_track_indices = set()
-            matched_det_indices = set()
-            
-            # Stage 1: Match confirmed tracks
-            if confirmed_tracks:
-                matched_track_indices, matched_det_indices = self._associate_tracks(
-                    confirmed_tracks, detections, matched_track_indices, 
-                    matched_det_indices, threshold_mult=1.0
-                )
-            
-            # Stage 2: Match tentative tracks
-            if tentative_tracks:
-                unmatched_dets = [detections[i] for i in range(len(detections))
-                                 if i not in matched_det_indices]
-                if unmatched_dets:
-                    temp_det_mapping = [i for i in range(len(detections))
-                                       if i not in matched_det_indices]
-                    
-                    tent_matched_tracks, tent_matched_dets = self._associate_tracks(
-                        tentative_tracks, unmatched_dets, set(), set(), threshold_mult=0.7
-                    )
-                    
-                    for det_idx in tent_matched_dets:
-                        matched_det_indices.add(temp_det_mapping[det_idx])
-            
-            for i, track in enumerate(confirmed_tracks):
-                if i not in matched_track_indices:
-                    track.mark_missed()
-            
-            for track in tentative_tracks:
-                if track.time_since_update > 0:
-                    track.mark_missed()
-            
-            # Create new tracks - TASK 1: Check recently deleted first
-            for det_idx in range(len(detections)):
-                if det_idx not in matched_det_indices:
-                    detection = detections[det_idx]
-                    
-                    # Check if matches recently deleted track
-                    revived_track = self._check_recently_deleted(detection)
-                    if revived_track:
-                        revived_track.update(detection)
-                        revived_track.state = 'confirmed'
-                        self.tracks.append(revived_track)
-                    elif self._is_new_track(detection):
-                        new_track = Track(detection, self.track_id_count)
-                        self.track_id_count += 1
-                        self.tracks.append(new_track)
-            
-            # Store deleted tracks - TASK 1
-            current_time = datetime.now()
-            for track in [t for t in self.tracks if t.state == 'deleted']:
-                self.recently_deleted_tracks[track.track_id] = {
-                    'track': track,
-                    'deleted_time': current_time
-                }
-            
-            self.tracks = [t for t in self.tracks if t.state != 'deleted']
-            self._cleanup_old_deleted()  # TASK 1
-            
-            return [t for t in self.tracks if t.state == 'confirmed']
-        
-        except Exception as e:
-            print(f"Tracker error: {e}")
-            return [t for t in self.tracks if t.state == 'confirmed']
-    
-    def _check_recently_deleted(self, detection: Detection) -> Optional[Track]:
-        """TASK 1: Check if detection matches recently deleted track"""
-        if not self.recently_deleted_tracks:
-            return None
-        
-        best_match = None
-        best_score = 0.25  # Lower threshold for re-entry
-        
-        for track_id, data in self.recently_deleted_tracks.items():
-            track = data['track']
-            
-            # IoU check
-            iou = self._iou(track.bbox, detection.bbox)
-            
-            # Center distance
-            track_center = self._get_center(track.bbox)
-            det_center = self._get_center(detection.bbox)
-            distance = np.linalg.norm(np.array(track_center) - np.array(det_center))
-            
-            # Combined score
-            if iou > 0.1 and distance < 200:
-                score = iou * 0.7 + (1 - distance/200) * 0.3
-                if score > best_score:
-                    best_score = score
-                    best_match = track
-        
-        if best_match:
-            # Remove from deleted
-            del self.recently_deleted_tracks[best_match.track_id]
-            print(f"🔄 Revived track {best_match.track_id}")
-        
-        return best_match
-    
-    def _cleanup_old_deleted(self):
-        """TASK 1: Remove tracks deleted >5 minutes ago"""
-        current_time = datetime.now()
-        to_remove = []
-        
-        for track_id, data in self.recently_deleted_tracks.items():
-            if current_time - data['deleted_time'] > self.max_lost_time:
-                to_remove.append(track_id)
-        
-        for track_id in to_remove:
-            del self.recently_deleted_tracks[track_id]
-    
-    def _associate_tracks(self, tracks, detections, existing_matched_tracks,
-                         existing_matched_dets, threshold_mult=1.0):
-        """Associate with appearance and pose fallback"""
-        if not tracks or not detections:
-            return existing_matched_tracks, existing_matched_dets
-        
-        try:
-            cost_matrix = self._calculate_enhanced_cost_matrix(tracks, detections)
-            
-            if cost_matrix.size == 0:
-                return existing_matched_tracks, existing_matched_dets
-            
-            row_ind, col_ind = linear_sum_assignment(cost_matrix)
-            
-            matched_tracks = existing_matched_tracks.copy()
-            matched_dets = existing_matched_dets.copy()
-            
-            threshold = (1 - self.match_threshold * threshold_mult)
-            
-            for r, c in zip(row_ind, col_ind):
-                if r >= len(tracks) or c >= len(detections):
-                    continue
-                
-                if cost_matrix[r, c] < threshold:
-                    tracks[r].update(detections[c])
-                    matched_tracks.add(r)
-                    matched_dets.add(c)
-            
-            return matched_tracks, matched_dets
-        
-        except Exception as e:
-            print(f"Association error: {e}")
-            return existing_matched_tracks, existing_matched_dets
-    
-    def _calculate_enhanced_cost_matrix(self, tracks, detections):
-        """Cost matrix with appearance and pose support"""
-        n_tracks, n_dets = len(tracks), len(detections)
-        cost_matrix = np.ones((n_tracks, n_dets))
-        
-        for t_idx, track in enumerate(tracks):
-            track_center = np.array(self._get_center(track.bbox))
-            track_size = np.array([
-                max(1, track.bbox[2] - track.bbox[0]),
-                max(1, track.bbox[3] - track.bbox[1])
-            ])
-            
-            for d_idx, detection in enumerate(detections):
-                iou = self._iou(track.bbox, detection.bbox)
-                det_center = np.array(self._get_center(detection.bbox))
-                distance = np.linalg.norm(track_center - det_center)
-                
-                det_size = np.array([
-                    max(1, detection.bbox[2] - detection.bbox[0]),
-                    max(1, detection.bbox[3] - detection.bbox[1])
-                ])
-                
-                size_ratio = np.minimum(track_size, det_size) / (np.maximum(track_size, det_size) + 1e-6)
-                size_cost = 1 - np.mean(size_ratio)
-                
-                if iou >= self.min_iou_for_match and distance < self.max_center_distance:
-                    iou_cost = 1 - iou
-                    dist_cost = distance / self.max_center_distance
-                    total_cost = 0.6 * iou_cost + 0.25 * dist_cost + 0.15 * size_cost
-                    
-                    # Pose-based matching - TASK: OPTIONAL
-                    if self.use_pose and track.keypoints is not None and detection.keypoints is not None:
-                        pose_cost = self._keypoint_distance(track.keypoints, detection.keypoints)
-                        total_cost = 0.5 * iou_cost + 0.2 * dist_cost + 0.15 * size_cost + 0.15 * pose_cost
-                    
-                    cost_matrix[t_idx, d_idx] = total_cost
-                else:
-                    # Appearance fallback when spatial matching fails
-                    if self.use_appearance and hasattr(track, 'appearance_features') and track.appearance_features:
-                        cost_matrix[t_idx, d_idx] = 0.9  # High but not impossible
-                    else:
-                        cost_matrix[t_idx, d_idx] = 1.0
-        
-        return cost_matrix
-    
-    def _keypoint_distance(self, kpts1, kpts2):
-        """Calculate normalized keypoint distance"""
-        try:
-            valid_idx = (kpts1[:, 2] > 0.5) & (kpts2[:, 2] > 0.5)
-            if not np.any(valid_idx):
-                return 1.0
-            
-            diff = np.linalg.norm(kpts1[valid_idx, :2] - kpts2[valid_idx, :2], axis=1)
-            return min(1.0, np.mean(diff) / 100.0)
-        except:
-            return 1.0
-    
-    def _is_new_track(self, detection):
-        """Check if detection is new"""
-        det_center = self._get_center(detection.bbox)
-        for track in self.tracks:
-            if track.state == 'deleted':
-                continue
-            track_center = self._get_center(track.bbox)
-            dist = np.linalg.norm(np.array(det_center) - np.array(track_center))
-            if dist < 30:
-                return False
-        return True
-    
-    def _get_center(self, bbox):
-        return ((bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2)
-    
-    def _iou(self, bbox1, bbox2):
-        x1 = max(bbox1[0], bbox2[0])
-        y1 = max(bbox1[1], bbox2[1])
-        x2 = min(bbox1[2], bbox2[2])
-        y2 = min(bbox1[3], bbox2[3])
-        
-        if x2 < x1 or y2 < y1:
-            return 0.0
-        
-        intersection = (x2 - x1) * (y2 - y1)
-        area1 = max(1, (bbox1[2] - bbox1[0]) * (bbox1[3] - bbox1[1]))
-        area2 = max(1, (bbox2[2] - bbox2[0]) * (bbox2[3] - bbox2[1]))
-        union = area1 + area2 - intersection
-        
-        return max(0, min(1, intersection / (union + 1e-6)))
-    
-    def reset(self):
-        self.tracks.clear()
-        self.recently_deleted_tracks.clear()
-        self.track_id_count = 1
-
-
-# ==================== REID MODULE ====================
-
-@dataclass
-class DogFeatures:
-    features: np.ndarray
-    bbox: List[float] = field(default_factory=list)
-    confidence: float = 0.5
-    frame_num: int = 0
-    image: Optional[np.ndarray] = None
-    keypoints: Optional[np.ndarray] = None
-
-
-class MegaDescriptorReID:
-    """ReID with multiple embeddings per dog and pose support"""
-    
-    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"
-    ]
-    
-    def __init__(self, device: str = 'cuda', db_path: str = 'dog_database', use_pose: bool = True):
-        self.device = device if torch.cuda.is_available() else 'cpu'
-        self.base_threshold = 0.35
-        self.db_threshold = 0.25  # TASK 2: Lower threshold for database
-        self.db_path = Path(db_path)
-        self.use_pose = use_pose
-        
-        self.db_path.mkdir(exist_ok=True)
-        (self.db_path / 'images').mkdir(exist_ok=True)
-        
-        self.permanent_dogs = self.load_permanent_database()
-        self.used_names = {dog['name'] for dog in self.permanent_dogs.values()}
-        
-        self.session_dogs = {}
-        self.session_best_images = {}
-        self.temp_to_permanent = {}
-        self.next_temp_id = 1
-        self.current_frame = 0
-        
-        # Comparison logging - OPTIONAL TASK
-        self.pose_impact_log = {'improved': 0, 'prevented_false': 0}
-        
-        self._initialize_megadescriptor()
-        print(f"✅ ReID initialized | Known dogs: {len(self.permanent_dogs)}")
-    
-    def _initialize_megadescriptor(self):
-        try:
-            self.model = timm.create_model('hf-hub:BVRA/MegaDescriptor-L-384', pretrained=True)
-            self.model.to(self.device).eval()
-            self.transform = timm.data.create_transform(
-                input_size=(384, 384), is_training=False,
-                mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]
-            )
-            print("✅ MegaDescriptor loaded")
-        except Exception as e:
-            print(f"❌ MegaDescriptor error: {e}")
-            self.model = None
-    
-    def load_permanent_database(self):
-        """TASK 2: Load with multiple embeddings support"""
-        db_file = self.db_path / 'dogs_database.json'
-        embeddings_file = self.db_path / 'embeddings.pkl'
-        
-        if not db_file.exists():
-            return {}
-        
-        try:
-            with open(db_file, 'r', encoding='utf-8') as f:
-                dogs_data = json.load(f)
-            
-            if embeddings_file.exists():
-                with open(embeddings_file, 'rb') as f:
-                    embeddings = pickle.load(f)
-                
-                for dog_name, embedding_list in embeddings.items():
-                    if dog_name in dogs_data:
-                        # Support both old (single) and new (multiple) format
-                        if isinstance(embedding_list, np.ndarray):
-                            dogs_data[dog_name]['embeddings'] = [embedding_list]
-                        else:
-                            dogs_data[dog_name]['embeddings'] = embedding_list
-            
-            print(f"📚 Loaded {len(dogs_data)} dogs")
-            return dogs_data
-        
-        except Exception as e:
-            print(f"Database load error: {e}")
-            return {}
-    
-    def save_permanent_database(self):
-        """Save database"""
-        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', '')
-            }
-            
-            if 'embeddings' in dog_data:
-                embeddings[dog_name] = dog_data['embeddings']
-        
-        with open(db_file, 'w', encoding='utf-8') as f:
-            json.dump(metadata, f, indent=2, ensure_ascii=False)
-        
-        with open(embeddings_file, 'wb') as f:
-            pickle.dump(embeddings, f)
-        
-        print(f"💾 Database saved: {len(metadata)} dogs")
-    
-    def check_permanent_database(self, features: np.ndarray) -> Optional[str]:
-        """TASK 2: Check against all embeddings with lower threshold"""
-        if not self.permanent_dogs:
-            return None
-        
-        best_match = None
-        best_score = 0
-        
-        for dog_name, dog_data in self.permanent_dogs.items():
-            if 'embeddings' not in dog_data:
-                continue
-            
-            # Compare against all embeddings - TASK 2
-            embeddings_list = dog_data['embeddings']
-            similarities = []
-            
-            for emb in embeddings_list:
-                sim = cosine_similarity(
-                    features.reshape(1, -1),
-                    emb.reshape(1, -1)
-                )[0, 0]
-                similarities.append(sim)
-            
-            # Use maximum similarity - TASK 2
-            if similarities:
-                max_sim = max(similarities)
-                if max_sim > best_score:
-                    best_score = max_sim
-                    best_match = dog_name
-        
-        # Lower threshold for database - TASK 2
-        if best_score >= self.db_threshold:
-            print(f"  ✅ Database match: {best_match} ({best_score:.3f})")
-            return best_match
-        
-        return None
-    
-    def extract_features(self, images, bboxes=None) -> List[Optional[DogFeatures]]:
-        """Batch feature extraction"""
-        if not isinstance(images, list):
-            images = [images]
-            bboxes = [bboxes] if bboxes else [None]
-            single_mode = True
-        else:
-            single_mode = False
-            if bboxes is None:
-                bboxes = [None] * len(images)
-        
-        if self.model is None:
-            return [None] * len(images)
-        
-        results = []
-        
-        try:
-            # Batch processing
-            tensors = []
-            valid_indices = []
-            
-            for idx, img in enumerate(images):
-                if img is None or img.size == 0:
-                    results.append(None)
-                    continue
-                
-                try:
-                    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-                    pil_img = Image.fromarray(img_rgb)
-                    tensor = self.transform(pil_img)
-                    tensors.append(tensor)
-                    valid_indices.append(idx)
-                except:
-                    results.append(None)
-            
-            if tensors:
-                batch_tensor = torch.stack(tensors).to(self.device)
-                
-                with torch.no_grad():
-                    features_batch = self.model(batch_tensor)
-                
-                features_list = features_batch.cpu().numpy()
-                
-                result_idx = 0
-                for idx in range(len(images)):
-                    if idx in valid_indices:
-                        feat = features_list[result_idx]
-                        feat = feat / (np.linalg.norm(feat) + 1e-7)
-                        
-                        dog_feat = DogFeatures(
-                            features=feat,
-                            bbox=bboxes[idx] if bboxes[idx] else [0, 0, 100, 100],
-                            frame_num=self.current_frame,
-                            image=images[idx].copy()
-                        )
-                        
-                        # Insert at correct position
-                        while len(results) <= idx:
-                            results.append(None)
-                        results[idx] = dog_feat
-                        result_idx += 1
-        
-        except Exception as e:
-            print(f"Feature extraction error: {e}")
-            return [None] * len(images)
-        
-        return results[0] if single_mode else results
-    
-    def match_or_register(self, track, image_crop=None):
-        """Match with pose comparison logging"""
-        self.current_frame += 1
-        
-        detection = None
-        for det in reversed(track.detections[-3:]):
-            if det.image_crop is not None:
-                detection = det
-                image_crop = det.image_crop
-                break
-        
-        if detection is None or image_crop is None:
-            return 0, 0.0, None
-        
-        features = self.extract_features(image_crop, detection.bbox)
-        if features is None:
-            return 0, 0.0, None
-        
-        features.confidence = detection.confidence
-        features.keypoints = detection.keypoints
-        
-        # Check permanent database
-        permanent_name = self.check_permanent_database(features.features)
-        
-        # Check session - with pose comparison if enabled
-        best_temp_id = None
-        best_score = -1.0
-        best_score_without_pose = -1.0  # OPTIONAL: Comparison
-        
-        for temp_id, dog_features_list in self.session_dogs.items():
-            similarities = []
-            similarities_no_pose = []
-            
-            for stored_feat in dog_features_list[-20:]:
-                # Appearance similarity
-                app_sim = cosine_similarity(
-                    features.features.reshape(1, -1),
-                    stored_feat.features.reshape(1, -1)
-                )[0, 0]
-                
-                similarities_no_pose.append(app_sim)
-                
-                # Add pose if enabled - OPTIONAL
-                if self.use_pose and features.keypoints is not None and stored_feat.keypoints is not None:
-                    pose_sim = self._pose_similarity(features.keypoints, stored_feat.keypoints)
-                    combined_sim = 0.85 * app_sim + 0.15 * pose_sim
-                    similarities.append(combined_sim)
-                else:
-                    similarities.append(app_sim)
-            
-            if similarities:
-                final_score = 0.6 * max(similarities) + 0.4 * np.mean(similarities)
-                score_no_pose = 0.6 * max(similarities_no_pose) + 0.4 * np.mean(similarities_no_pose)
-                
-                if final_score > best_score:
-                    best_score = final_score
-                    best_score_without_pose = score_no_pose
-                    best_temp_id = temp_id
-        
-        # Log pose impact - OPTIONAL
-        if self.use_pose and best_temp_id is not None:
-            if best_score >= self.base_threshold and best_score_without_pose < self.base_threshold:
-                self.pose_impact_log['improved'] += 1
-            elif best_score < self.base_threshold and best_score_without_pose >= self.base_threshold:
-                self.pose_impact_log['prevented_false'] += 1
-        
-        threshold = self.base_threshold
-        
-        if best_temp_id is not None and best_score >= threshold:
-            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)
-            
-            if permanent_name:
-                self.temp_to_permanent[best_temp_id] = permanent_name
-            
-            return best_temp_id, best_score, permanent_name
-        else:
-            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
-            
-            if permanent_name:
-                self.temp_to_permanent[new_temp_id] = permanent_name
-                print(f"  ℹ️ Known dog {permanent_name} -> ID {new_temp_id}")
-            
-            return new_temp_id, 1.0, permanent_name
-    
-    def _pose_similarity(self, kpts1, kpts2):
-        """Calculate pose similarity"""
-        try:
-            valid = (kpts1[:, 2] > 0.5) & (kpts2[:, 2] > 0.5)
-            if not np.any(valid):
-                return 0.5
-            
-            diff = np.linalg.norm(kpts1[valid, :2] - kpts2[valid, :2], axis=1)
-            similarity = 1.0 - min(1.0, np.mean(diff) / 100.0)
-            return similarity
-        except:
-            return 0.5
-    
-    def update_best_image(self, temp_id, features):
-        current_best = self.session_best_images.get(temp_id)
-        
-        if features.image is not None:
-            quality = features.confidence * np.prod(features.image.shape[:2])
-            
-            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
-    
-    def save_session_to_permanent(self):
-        """TASK 2: Save with multiple embeddings (5-10 best)"""
-        saved_dogs = {}
-        
-        for temp_id, features_list in self.session_dogs.items():
-            if temp_id in self.temp_to_permanent:
-                continue
-            
-            dog_name = self.get_next_turkish_name()
-            
-            # Store top 5-10 embeddings - TASK 2
-            embeddings = [f.features for f in features_list]
-            
-            # Sort by quality
-            qualities = [f.confidence * np.prod(f.image.shape[:2]) if f.image is not None else 0 
-                        for f in features_list]
-            
-            sorted_indices = np.argsort(qualities)[::-1]
-            top_embeddings = [embeddings[i] for i in sorted_indices[:min(10, len(embeddings))]]
-            
-            # Normalize
-            top_embeddings = [e / np.linalg.norm(e) for e in top_embeddings]
-            
-            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': top_embeddings,  # TASK 2: Multiple embeddings
-                'first_seen': datetime.now().isoformat(),
-                'last_seen': datetime.now().isoformat(),
-                'total_sightings': 1,
-                'image_path': image_path
-            }
-            
-            saved_dogs[temp_id] = dog_name
-            self.used_names.add(dog_name)
-            print(f"  ✅ Saved: {dog_name}")
-        
-        for temp_id, permanent_name in self.temp_to_permanent.items():
-            if permanent_name in self.permanent_dogs:
-                self.permanent_dogs[permanent_name]['last_seen'] = datetime.now().isoformat()
-                self.permanent_dogs[permanent_name]['total_sightings'] += 1
-        
-        if saved_dogs:
-            self.save_permanent_database()
-        
-        return saved_dogs
-    
-    def delete_dog_from_database(self, dog_name: str):
-        """TASK 4: Delete dog from database"""
-        if dog_name not in self.permanent_dogs:
-            return False
-        
-        # Delete image
-        dog_data = self.permanent_dogs[dog_name]
-        if dog_data.get('image_path'):
-            img_path = self.db_path / dog_data['image_path']
-            if img_path.exists():
-                img_path.unlink()
-        
-        # Remove from database
-        del self.permanent_dogs[dog_name]
-        self.used_names.discard(dog_name)
-        
-        # Save
-        self.save_permanent_database()
-        print(f"🗑️ Deleted: {dog_name}")
-        return True
-    
-    def get_next_turkish_name(self):
-        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):
-        temp_id, confidence, permanent_name = self.match_or_register(track)
-        return {
-            'MegaDescriptor': {
-                'dog_id': temp_id,
-                'confidence': confidence,
-                'permanent_name': permanent_name
-            }
-        }
-    
-    def set_all_thresholds(self, threshold: float):
-        self.base_threshold = max(0.15, min(0.95, threshold))
-    
-    def reset_all(self):
-        self.session_dogs.clear()
-        self.session_best_images.clear()
-        self.temp_to_permanent.clear()
-        self.next_temp_id = 1
-        self.current_frame = 0
-        self.pose_impact_log = {'improved': 0, 'prevented_false': 0}
-    
-    def get_pose_impact_stats(self):
-        """OPTIONAL: Get pose comparison stats"""
-        return self.pose_impact_log.copy()
-
-
-# ==================== HEALTH MODULE ====================
-
-@dataclass
-class HealthScore:
-    score: float
-    score_text: str
-    color: Tuple[int, int, int]
-    status: str
-    alerts: List[str]
-    confidence: float
-
-
-class DogHealthAssessment:
-    """Health assessment using pose and appearance"""
-    
-    def __init__(self):
-        self.thresholds = {
-            'head_low_ratio': 0.7,
-            'leg_asymmetry_ratio': 0.1,
-            'body_condition_thin': 0.35,
-            'body_condition_obese': 0.65,
-        }
-        
-        self.keypoints_map = {
-            'nose': 0, 'left_eye': 1, 'right_eye': 2,
-            'left_ear': 3, 'right_ear': 4,
-            'left_shoulder': 5, 'right_shoulder': 6,
-            'left_elbow': 7, 'right_elbow': 8,
-            'left_wrist': 9, 'right_wrist': 10,
-            'left_hip': 11, 'right_hip': 12,
-            'left_knee': 13, 'right_knee': 14,
-            'left_ankle': 15, 'right_ankle': 16
-        }
-    
-    def assess_from_pose(self, keypoints, bbox):
-        """Analyze health from pose"""
-        scores = {'posture': 10.0, 'gait_symmetry': 10.0, 'head_position': 10.0}
-        
-        if keypoints is None or len(keypoints) < 17:
-            return scores
-        
-        body_height = max(1, bbox[3] - bbox[1])
-        body_width = max(1, bbox[2] - bbox[0])
-        
-        # Head position
-        nose_kp = keypoints[self.keypoints_map['nose']]
-        if nose_kp[2] > 0.5:
-            head_relative_y = (nose_kp[1] - bbox[1]) / body_height
-            if head_relative_y > self.thresholds['head_low_ratio']:
-                scores['head_position'] -= 4.0
-            elif head_relative_y > 0.5:
-                scores['head_position'] -= 2.0
-        
-        # Leg symmetry
-        left_wrist = keypoints[self.keypoints_map['left_wrist']]
-        right_wrist = keypoints[self.keypoints_map['right_wrist']]
-        left_shoulder = keypoints[self.keypoints_map['left_shoulder']]
-        right_shoulder = keypoints[self.keypoints_map['right_shoulder']]
-        
-        if all(kp[2] > 0.5 for kp in [left_wrist, right_wrist, left_shoulder, right_shoulder]):
-            left_len = abs(left_wrist[1] - left_shoulder[1])
-            right_len = abs(right_wrist[1] - right_shoulder[1])
-            
-            if left_len > 0 and right_len > 0:
-                asym = abs(left_len - right_len) / max(left_len, right_len)
-                if asym > self.thresholds['leg_asymmetry_ratio']:
-                    scores['gait_symmetry'] -= 3.0
-        
-        for key in scores:
-            scores[key] = max(0, scores[key])
-        
-        return scores
-    
-    def assess_body_condition(self, bbox, dog_crop):
-        """Body condition assessment"""
-        scores = {'weight': 10.0, 'coat_quality': 10.0}
-        
-        width = bbox[2] - bbox[0]
-        height = bbox[3] - bbox[1]
-        
-        if height > 0:
-            aspect_ratio = width / height
-            if aspect_ratio < self.thresholds['body_condition_thin']:
-                scores['weight'] = 3.0
-            elif aspect_ratio > self.thresholds['body_condition_obese']:
-                scores['weight'] = 4.0
-        
-        # Coat quality
-        try:
-            gray = cv2.cvtColor(dog_crop, cv2.COLOR_BGR2GRAY)
-            texture_score = np.std(gray)
-            
-            if texture_score < 15:
-                scores['coat_quality'] = 3.0
-            elif texture_score < 25:
-                scores['coat_quality'] = 6.0
-        except:
-            pass
-        
-        return scores
-    
-    def calculate_overall_health(self, dog_id, keypoints, dog_crop, bbox):
-        """TASK 3: Calculate comprehensive health score"""
-        pose_scores = self.assess_from_pose(keypoints, bbox) if keypoints is not None else {
-            'posture': 7.0, 'gait_symmetry': 7.0, 'head_position': 7.0
-        }
-        
-        body_scores = self.assess_body_condition(bbox, dog_crop)
-        
-        weights = {'pose': 0.5, 'body': 0.5}
-        
-        avg_pose = np.mean(list(pose_scores.values()))
-        avg_body = np.mean(list(body_scores.values()))
-        
-        final_score = avg_pose * weights['pose'] + avg_body * weights['body']
-        final_score = round(final_score, 1)
-        
-        # Status
-        if final_score >= 8.0:
-            status = "Sağlıklı"
-            color = (0, 255, 0)
-        elif final_score >= 6.0:
-            status = "İyi"
-            color = (0, 255, 255)
-        elif final_score >= 4.0:
-            status = "Dikkat"
-            color = (0, 165, 255)
-        else:
-            status = "Kritik"
-            color = (0, 0, 255)
-        
-        # Alerts
-        alerts = []
-        if pose_scores['head_position'] < 6.0:
-            alerts.append("Baş pozisyonu düşük")
-        if pose_scores['gait_symmetry'] < 6.0:
-            alerts.append("Yürüyüş bozukluğu")
-        if body_scores['weight'] < 5.0:
-            alerts.append("Kilo problemi")
-        if body_scores['coat_quality'] < 6.0:
-            alerts.append("Tüy kalitesi düşük")
-        
-        confidence = 0.7
-        
-        return HealthScore(
-            score=final_score,
-            score_text=f"{final_score}/10",
-            color=color,
-            status=status,
-            alerts=alerts,
-            confidence=confidence
-        )
-
+from pathlib import Path
+from datetime import datetime
 
-# ==================== MAIN DEMO ====================
+# Import modules
+from detection import EnhancedDogDetector as DogDetector
+from tracking import EnhancedTracker as SimpleTracker
+from reid import EnhancedMegaDescriptorReID as MegaDescriptorReID
+from health_module import DogHealthAssessment
+from database import DogDatabase
 
-class DogDetectionDemo:
-    """Complete demo with all 57 tasks implemented"""
+class EnhancedDogDetectionDemo:
+    """Enhanced demo with health assessment and database management"""
     
     def __init__(self):
         device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        
         self.detector = DogDetector(device=device)
-        self.tracker = RobustTracker(match_threshold=0.2, use_pose=True)  # OPTIONAL: pose enabled
-        self.reid = MegaDescriptorReID(device=device, use_pose=True)  # OPTIONAL: pose enabled
-        self.health_assessor = DogHealthAssessment()  # TASK 3
+        self.tracker = SimpleTracker(match_threshold=0.2)
+        self.reid = MegaDescriptorReID(device=device)
+        
+        # ENHANCEMENT 3: Health assessment module
+        self.health_assessor = DogHealthAssessment()
+        
+        # ENHANCEMENT 4: Database integration
+        self.db = DogDatabase("dog_monitoring.db")
         
         self.current_session_data = {}
-        self.health_scores = {}  # TASK 3
         self.is_processing = False
         self.known_dogs_alerts = []
         
-        print("✅ System initialized")
+        # ENHANCEMENT 3: Health tracking
+        self.dog_health_scores = {}  # temp_id -> health_score
+        
+        # Set up callback for sleeping tracks
+        self.tracker.set_reid_callback(self.reid.move_to_sleeping)
+        
+        print("✅ Enhanced Demo initialized with health assessment and database")
     
     def reset_session(self):
+        """Reset current session"""
         self.is_processing = False
         self.current_session_data.clear()
-        self.health_scores.clear()
         self.known_dogs_alerts.clear()
+        self.dog_health_scores.clear()
         self.tracker.reset()
         self.reid.reset_all()
         gc.collect()
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
+        print("🔄 Session reset")
     
-    def correct_video_orientation(self, video_path: str) -> str:
-        """TASK 6: Correct video orientation from mobile"""
-        try:
-            cap = cv2.VideoCapture(video_path)
-            
-            # Check rotation metadata
-            rotation = cap.get(cv2.CAP_PROP_ORIENTATION_META)
-            
-            if rotation in [90, 180, 270]:
-                print(f"🔄 Correcting rotation: {rotation}°")
-                
-                # Create corrected video
-                output_path = video_path.replace('.mp4', '_corrected.mp4')
-                
-                fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-                fps = cap.get(cv2.CAP_PROP_FPS)
-                
-                # Read first frame to get dimensions
-                ret, frame = cap.read()
-                if ret:
-                    if rotation in [90, 270]:
-                        h, w = frame.shape[1], frame.shape[0]
-                    else:
-                        h, w = frame.shape[:2]
-                    
-                    out = cv2.VideoWriter(output_path, fourcc, fps, (w, h))
-                    
-                    # Process all frames
-                    cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-                    while True:
-                        ret, frame = cap.read()
-                        if not ret:
-                            break
-                        
-                        if rotation == 90:
-                            frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
-                        elif rotation == 180:
-                            frame = cv2.rotate(frame, cv2.ROTATE_180)
-                        elif rotation == 270:
-                            frame = cv2.rotate(frame, cv2.ROTATE_90_COUNTERCLOCKWISE)
-                        
-                        out.write(frame)
-                    
-                    out.release()
-                    cap.release()
-                    return output_path
-            
-            cap.release()
-            return video_path
-        
-        except Exception as e:
-            print(f"Orientation correction error: {e}")
-            return video_path
-    
-    def process_video(self, video_path: str, reid_threshold: float, 
-                     sample_rate: int, use_pose: bool):
-        """Process video with batch optimization - TASK 5"""
+    def process_video(self, video_path: str, reid_threshold: float, sample_rate: int):
+        """Process video with health assessment"""
         if not video_path:
-            return None, "Please upload video", None, None
+            return None, "Please upload a video", None, None
         
         self.reset_session()
         self.is_processing = True
-        
-        # TASK 6: Correct orientation
-        video_path = self.correct_video_orientation(video_path)
-        
         self.reid.set_all_thresholds(reid_threshold)
-        self.reid.use_pose = use_pose  # OPTIONAL
-        self.tracker.use_pose = use_pose  # OPTIONAL
         
         try:
             cap = cv2.VideoCapture(video_path)
@@ -1219,11 +78,7 @@ class DogDetectionDemo:
             frame_num = 0
             processed_frames = 0
             
-            # TASK 5: Batch processing
-            frame_buffer = []
-            frame_indices = []
-            
-            print(f"\n🎥 Processing: {total_frames} frames")
+            print(f"\n🎥 Processing video: {total_frames} frames")
             
             while cap.isOpened() and self.is_processing:
                 ret, frame = cap.read()
@@ -1231,27 +86,55 @@ class DogDetectionDemo:
                     break
                 
                 if frame_num % sample_rate == 0:
-                    frame_buffer.append(frame)
-                    frame_indices.append(frame_num)
+                    detections = self.detector.detect(frame)
+                    tracks = self.tracker.update(detections)
                     
-                    # Process in batches of 4-8 frames - TASK 5
-                    if len(frame_buffer) >= 4:
-                        self._process_frame_batch(frame_buffer, temp_id_to_crops)
-                        frame_buffer.clear()
-                        frame_indices.clear()
-                        processed_frames += 4
+                    for track in tracks:
+                        if not self.is_processing:
+                            break
+                        
+                        result = self.reid.match_or_register_all(track)
+                        temp_id = result['MegaDescriptor']['dog_id']
+                        permanent_name = result['MegaDescriptor'].get('permanent_name')
+                        
+                        if temp_id > 0:
+                            # Store crops
+                            for det in reversed(track.detections[-3:]):
+                                if det.image_crop is not None:
+                                    if temp_id not in temp_id_to_crops:
+                                        temp_id_to_crops[temp_id] = []
+                                    
+                                    if len(temp_id_to_crops[temp_id]) < 10:
+                                        temp_id_to_crops[temp_id].append(det.image_crop.copy())
+                                    
+                                    # ENHANCEMENT 3: Assess health
+                                    if temp_id not in self.dog_health_scores:
+                                        bbox = det.bbox if hasattr(det, 'bbox') else [0,0,100,100]
+                                        position = ((bbox[0]+bbox[2])/2, (bbox[1]+bbox[3])/2)
+                                        
+                                        health_score = self.health_assessor.calculate_overall_health(
+                                            dog_id=temp_id,
+                                            keypoints=None,  # Can add pose detection later
+                                            dog_crop=det.image_crop,
+                                            bbox=bbox,
+                                            current_pos=position
+                                        )
+                                        
+                                        self.dog_health_scores[temp_id] = health_score
+                                    
+                                    break
+                            
+                            # Track known dogs
+                            if permanent_name and permanent_name not in self.known_dogs_alerts:
+                                self.known_dogs_alerts.append(permanent_name)
                 
-                frame_num += 1
+                processed_frames += 1
+                if frame_num % 100 == 0:
+                    gc.collect()
                 
+                frame_num += 1
                 if frame_num % 30 == 0:
                     print(f"Progress: {int((frame_num / total_frames) * 100)}%")
-                
-                if frame_num % 100 == 0:
-                    gc.collect()
-            
-            # Process remaining frames
-            if frame_buffer:
-                self._process_frame_batch(frame_buffer, temp_id_to_crops)
             
             cap.release()
             
@@ -1259,72 +142,107 @@ class DogDetectionDemo:
             if temp_id_to_crops:
                 self.current_session_data = {
                     'crops': temp_id_to_crops,
-                    'temp_to_permanent': self.reid.temp_to_permanent
+                    'temp_to_permanent': self.reid.temp_to_permanent,
+                    'health_scores': self.dog_health_scores
                 }
                 
                 gallery_html = self._create_gallery_html(temp_id_to_crops)
                 alerts_html = self._create_alerts_html()
+                health_html = self._create_health_summary_html()
                 
-                # OPTIONAL: Pose impact stats
-                pose_stats = ""
-                if use_pose:
-                    stats = self.reid.get_pose_impact_stats()
-                    pose_stats = f"\n📊 Pose Impact: Improved {stats['improved']} tracks, Prevented {stats['prevented_false']} false matches"
-                
-                stats_msg = f"✅ Found {len(temp_id_to_crops)} dogs | {processed_frames} frames{pose_stats}"
+                stats_msg = f"✅ Found {len(temp_id_to_crops)} dogs | {processed_frames} frames"
                 
-                return gallery_html, stats_msg, alerts_html, None
+                return gallery_html, stats_msg, alerts_html, health_html
             else:
                 return "<p>No dogs detected</p>", "No dogs detected", None, None
         
         except Exception as e:
             print(f"Error: {e}")
-            import traceback
-            traceback.print_exc()
             return f"<p>Error: {str(e)}</p>", f"Error: {str(e)}", None, None
         finally:
             self.is_processing = False
     
-    def _process_frame_batch(self, frames, temp_id_to_crops):
-        """Process batch of frames - TASK 5"""
-        # Batch detection
-        all_detections = self.detector.detect(frames)
+    def _create_health_summary_html(self) -> str:
+        """ENHANCEMENT 3: Create health summary display"""
+        if not self.dog_health_scores:
+            return "<p>No health data available</p>"
+        
+        html = """
+        <div style='padding: 20px; background: #f0f8ff; border-radius: 10px;'>
+            <h2 style='text-align:center; color: #2c3e50;'>🏥 Health Assessment Summary</h2>
+            <div style='display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 15px; margin-top: 20px;'>
+        """
+        
+        # Calculate overall statistics
+        all_scores = [hs.score for hs in self.dog_health_scores.values()]
+        avg_health = np.mean(all_scores) if all_scores else 0
+        
+        # Overall health indicator
+        if avg_health >= 8.0:
+            overall_color = "#28a745"
+            overall_status = "Sağlıklı"
+        elif avg_health >= 6.0:
+            overall_color = "#ffc107"
+            overall_status = "İyi"
+        elif avg_health >= 4.0:
+            overall_color = "#fd7e14"
+            overall_status = "Dikkat"
+        else:
+            overall_color = "#dc3545"
+            overall_status = "Kritik"
+        
+        html += f"""
+        <div style='background: white; padding: 15px; border-radius: 8px; border-left: 4px solid {overall_color};'>
+            <h3 style='margin: 0; color: {overall_color};'>Genel Durum</h3>
+            <p style='font-size: 24px; font-weight: bold; margin: 10px 0;'>{avg_health:.1f}/10</p>
+            <p style='margin: 0; color: #666;'>{overall_status}</p>
+            <p style='margin: 5px 0; font-size: 14px; color: #666;'>Toplam {len(self.dog_health_scores)} köpek</p>
+        </div>
+        """
         
-        for frame, detections in zip(frames, all_detections):
-            tracks = self.tracker.update(detections)
+        # Individual dog health cards
+        for temp_id, health_score in sorted(self.dog_health_scores.items(), key=lambda x: x[1].score):
+            permanent_name = self.reid.temp_to_permanent.get(temp_id)
+            dog_name = permanent_name if permanent_name else f"Köpek #{temp_id}"
             
-            for track in tracks:
-                if not self.is_processing:
-                    break
-                
-                result = self.reid.match_or_register_all(track)
-                temp_id = result['MegaDescriptor']['dog_id']
-                permanent_name = result['MegaDescriptor'].get('permanent_name')
-                
-                if temp_id > 0:
-                    # Store crops
-                    for det in reversed(track.detections[-3:]):
-                        if det.image_crop is not None:
-                            if temp_id not in temp_id_to_crops:
-                                temp_id_to_crops[temp_id] = []
-                            
-                            if len(temp_id_to_crops[temp_id]) < 10:
-                                temp_id_to_crops[temp_id].append(det.image_crop.copy())
-                    
-                    # TASK 3: Health assessment
-                    if temp_id not in self.health_scores and len(track.detections) > 0:
-                        det = track.detections[-1]
-                        if det.image_crop is not None:
-                            health_score = self.health_assessor.calculate_overall_health(
-                                temp_id, det.keypoints, det.image_crop, det.bbox
-                            )
-                            self.health_scores[temp_id] = health_score
-                    
-                    # Track known dogs
-                    if permanent_name and permanent_name not in self.known_dogs_alerts:
-                        self.known_dogs_alerts.append(permanent_name)
+            # Get trend if available
+            trend = self.health_assessor.get_health_trend(temp_id)
+            
+            html += f"""
+            <div style='background: white; padding: 15px; border-radius: 8px; 
+                        border-left: 4px solid {self._rgb_to_hex(health_score.color)};'>
+                <h4 style='margin: 0 0 10px 0; color: #2c3e50;'>{dog_name}</h4>
+                <div style='display: flex; align-items: center; gap: 10px; margin-bottom: 10px;'>
+                    <span style='font-size: 20px; font-weight: bold; color: {self._rgb_to_hex(health_score.color)};'>
+                        {health_score.score_text}
+                    </span>
+                    <span style='background: {self._rgb_to_hex(health_score.color)}20; 
+                                 padding: 4px 8px; border-radius: 4px; font-size: 12px;'>
+                        {health_score.status}
+                    </span>
+                </div>
+                <p style='margin: 5px 0; font-size: 13px; color: #666;'>Trend: {trend}</p>
+            """
+            
+            # Add alerts if any
+            if health_score.alerts:
+                html += "<div style='margin-top: 10px;'>"
+                for alert in health_score.alerts[:3]:  # Show top 3 alerts
+                    html += f"<p style='margin: 3px 0; font-size: 12px; color: #856404;'>⚠️ {alert}</p>"
+                html += "</div>"
+            
+            html += "</div>"
+        
+        html += "</div></div>"
+        return html
     
-    def _create_alerts_html(self):
+    def _rgb_to_hex(self, rgb_tuple):
+        """Convert BGR to hex color"""
+        b, g, r = rgb_tuple
+        return f"#{r:02x}{g:02x}{b:02x}"
+    
+    def _create_alerts_html(self) -> Optional[str]:
+        """Create alerts for known dogs"""
         if not self.known_dogs_alerts:
             return None
         
@@ -1332,9 +250,8 @@ class DogDetectionDemo:
         for dog_name in self.known_dogs_alerts:
             dog_data = self.reid.permanent_dogs.get(dog_name, {})
             alert_html = f"""
-            <div style='padding: 10px; margin: 10px 0; background: #fff3cd; 
-                 border: 2px solid #ffc107; border-radius: 8px;'>
-                <h4 style='color: #856404; margin: 0;'>⚠ Known Dog: {dog_name}</h4>
+            <div style='padding: 10px; margin: 10px 0; background: #fff3cd; border: 2px solid #ffc107; border-radius: 8px;'>
+                <h4 style='color: #856404; margin: 0;'>⚠️ Known Dog Detected: {dog_name}</h4>
             """
             
             if dog_data.get('image_path'):
@@ -1345,12 +262,11 @@ class DogDetectionDemo:
                     img_base64 = self._img_to_base64(img_rgb)
                     alert_html += f"""
                     <img src='data:image/jpeg;base64,{img_base64}'
-                         style='width: 100px; height: 100px; object-fit: cover; 
-                         margin: 10px 0; border-radius: 5px;'>
+                         style='width: 100px; height: 100px; object-fit: cover; margin: 10px 0; border-radius: 5px;'>
                     """
             
             alert_html += f"""
-                <p style='margin: 5px 0;'>Registered: {dog_data.get('first_seen', 'Unknown')[:10]}</p>
+                <p style='margin: 5px 0;'>First seen: {dog_data.get('first_seen', 'Unknown')[:10]}</p>
                 <p style='margin: 5px 0;'>Total sightings: {dog_data.get('total_sightings', 1)}</p>
             </div>
             """
@@ -1358,8 +274,8 @@ class DogDetectionDemo:
         
         return "".join(alerts)
     
-    def _create_gallery_html(self, temp_id_to_crops):
-        """TASK 3: Gallery with health scores"""
+    def _create_gallery_html(self, temp_id_to_crops: Dict) -> str:
+        """Create HTML gallery with health indicators"""
         html = """
         <div style='padding: 20px;'>
             <h2 style='text-align:center;'>🐕 Detected Dogs</h2>
@@ -1370,6 +286,10 @@ class DogDetectionDemo:
             crops = temp_id_to_crops[temp_id]
             permanent_name = self.reid.temp_to_permanent.get(temp_id)
             
+            # Get health score
+            health_score = self.dog_health_scores.get(temp_id)
+            health_color = self._rgb_to_hex(health_score.color) if health_score else "#28a745"
+            
             if permanent_name:
                 title = f"{permanent_name} (Known)"
                 border_color = "#ffc107"
@@ -1377,28 +297,33 @@ class DogDetectionDemo:
                 title = f"New Dog #{temp_id}"
                 border_color = "#28a745"
             
-            # TASK 3: Add health score
-            health_html = ""
-            if temp_id in self.health_scores:
-                hs = self.health_scores[temp_id]
-                color_hex = f"#{hs.color[2]:02x}{hs.color[1]:02x}{hs.color[0]:02x}"
-                health_html = f"""
-                <div style='margin: 10px 0; padding: 8px; background: {color_hex}20; 
-                     border-left: 4px solid {color_hex}; border-radius: 4px;'>
-                    <strong>Health: {hs.score_text} - {hs.status}</strong>
-                    {' | ' + ', '.join(hs.alerts) if hs.alerts else ''}
-                </div>
-                """
-            
             html += f"""
-            <div style='border: 2px solid {border_color}; border-radius: 10px; 
-                 padding: 15px; background: #f8f9fa;'>
-                <h3 style='color: #333; margin: 0 0 10px 0;'>{title}</h3>
-                {health_html}
-                <p style='margin: 5px 0; color: #666;'>Images: {len(crops)}</p>
-                <div style='display: grid; grid-template-columns: repeat(5, 1fr); gap: 5px;'>
+            <div style='border: 3px solid {border_color}; border-radius: 10px; padding: 15px; background: #f8f9fa;'>
+                <div style='display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px;'>
+                    <h3 style='color: #333; margin: 0;'>{title}</h3>
             """
             
+            # Add health indicator
+            if health_score:
+                html += f"""
+                    <div style='background: {health_color}; color: white; padding: 5px 15px; 
+                                border-radius: 20px; font-weight: bold; font-size: 14px;'>
+                        {health_score.score_text} - {health_score.status}
+                    </div>
+                """
+            
+            html += "</div>"
+            html += f"<p style='margin: 5px 0; color: #666;'>Images: {len(crops)}</p>"
+            
+            # Show health alerts if any
+            if health_score and health_score.alerts:
+                html += "<div style='background: #fff3cd; padding: 8px; border-radius: 5px; margin: 10px 0;'>"
+                for alert in health_score.alerts[:2]:
+                    html += f"<p style='margin: 3px 0; font-size: 12px;'>⚠️ {alert}</p>"
+                html += "</div>"
+            
+            html += "<div style='display: grid; grid-template-columns: repeat(5, 1fr); gap: 5px;'>"
+            
             for crop in crops:
                 img_rgb = cv2.cvtColor(crop, cv2.COLOR_BGR2RGB)
                 img_base64 = self._img_to_base64(img_rgb)
@@ -1413,51 +338,50 @@ class DogDetectionDemo:
         return html
     
     def save_to_database(self):
+        """Save current session to permanent database with health data"""
         if not self.current_session_data:
             return "No data to save", None
         
         saved = self.reid.save_session_to_permanent()
         
+        # ENHANCEMENT 3: Save health assessments to database
+        for temp_id, health_score in self.dog_health_scores.items():
+            permanent_name = self.reid.temp_to_permanent.get(temp_id)
+            if permanent_name and permanent_name in self.reid.permanent_dogs:
+                # Find dog_id in database (would need to implement dog_id mapping)
+                # For now, just show in message
+                pass
+        
         if saved:
-            msg = f"✅ Saved {len(saved)} new dogs:\n"
+            msg = f"✅ Saved {len(saved)} new dogs to database:\n"
             for temp_id, name in saved.items():
-                msg += f" • {name}\n"
-        else:
-            msg = "ℹ️ No new dogs (all in database)"
-        
-        db_html = self._show_database()
-        return msg, db_html
-    
-    def delete_dog(self, dog_name: str):
-        """TASK 4: Delete dog from database"""
-        if not dog_name or dog_name.strip() == "":
-            return "Please select a dog", self._show_database()
-        
-        success = self.reid.delete_dog_from_database(dog_name)
-        
-        if success:
-            msg = f"✅ Deleted: {dog_name}"
+                health = self.dog_health_scores.get(temp_id)
+                if health:
+                    msg += f" • {name} (Health: {health.score_text} - {health.status})\n"
+                else:
+                    msg += f" • {name}\n"
         else:
-            msg = f"❌ Dog not found: {dog_name}"
+            msg = "ℹ️ No new dogs to save (all were already in database)"
         
         db_html = self._show_database()
         return msg, db_html
     
-    def _show_database(self):
-        """Show database with delete buttons - TASK 4"""
+    def _show_database(self) -> str:
+        """Show current database"""
         if not self.reid.permanent_dogs:
             return "<p>Database is empty</p>"
         
         html = """
         <div style='padding: 20px;'>
             <h2>📚 Dog Database</h2>
-            <div style='display: grid; grid-template-columns: repeat(auto-fill, minmax(220px, 1fr)); gap: 15px;'>
+            <div style='display: grid; grid-template-columns: repeat(auto-fill, minmax(200px, 1fr)); gap: 15px;'>
         """
         
         for dog_name, dog_data in self.reid.permanent_dogs.items():
+            num_embeddings = len(dog_data.get('embeddings', []))
+            
             html += f"""
-            <div style='border: 1px solid #ddd; border-radius: 8px; padding: 10px; 
-                 text-align: center; background: white;'>
+            <div style='border: 1px solid #ddd; border-radius: 8px; padding: 10px; text-align: center;'>
                 <h4 style='margin: 0 0 10px 0;'>{dog_name}</h4>
             """
             
@@ -1473,150 +397,206 @@ class DogDetectionDemo:
                     """
             
             html += f"""
-                <p style='font-size: 12px; margin: 5px 0;'>Registered: {dog_data['first_seen'][:10]}</p>
+                <p style='font-size: 12px; margin: 5px 0;'>First: {dog_data['first_seen'][:10]}</p>
                 <p style='font-size: 12px; margin: 5px 0;'>Sightings: {dog_data['total_sightings']}</p>
-                <p style='font-size: 10px; margin: 5px 0; color: #666;'>ID: {dog_name}</p>
+                <p style='font-size: 11px; margin: 5px 0; color: #666;'>{num_embeddings} embeddings</p>
             </div>
             """
         
         html += "</div></div>"
         return html
     
+    def delete_dog_from_database(self, dog_name: str, hard_delete: bool = False):
+        """ENHANCEMENT 4: Delete dog from database"""
+        if dog_name in self.reid.permanent_dogs:
+            if hard_delete:
+                # Permanently delete
+                del self.reid.permanent_dogs[dog_name]
+                self.reid.used_names.discard(dog_name)
+                self.reid.save_permanent_database()
+                return f"🗑️ Permanently deleted {dog_name}", self._show_database()
+            else:
+                # Soft delete - mark as inactive (can implement status field)
+                self.reid.permanent_dogs[dog_name]['status'] = 'deleted'
+                self.reid.save_permanent_database()
+                return f"📦 Archived {dog_name} (soft delete)", self._show_database()
+        
+        return f"❌ Dog {dog_name} not found", self._show_database()
+    
+    def merge_dogs(self, keep_name: str, merge_name: str):
+        """ENHANCEMENT 4: Merge duplicate dogs"""
+        if keep_name in self.reid.permanent_dogs and merge_name in self.reid.permanent_dogs:
+            # Merge embeddings
+            keep_dog = self.reid.permanent_dogs[keep_name]
+            merge_dog = self.reid.permanent_dogs[merge_name]
+            
+            # Combine embeddings (keep up to 10 most diverse)
+            keep_embeddings = keep_dog.get('embeddings', [])
+            merge_embeddings = merge_dog.get('embeddings', [])
+            combined = keep_embeddings + merge_embeddings
+            keep_dog['embeddings'] = combined[-10:]  # Keep last 10
+            
+            # Update sightings
+            keep_dog['total_sightings'] += merge_dog.get('total_sightings', 0)
+            
+            # Delete merged dog
+            del self.reid.permanent_dogs[merge_name]
+            self.reid.used_names.discard(merge_name)
+            
+            self.reid.save_permanent_database()
+            
+            return f"✅ Merged {merge_name} into {keep_name}", self._show_database()
+        
+        return "❌ One or both dogs not found", self._show_database()
+    
     def _img_to_base64(self, img):
+        """Convert image to base64"""
         pil_img = Image.fromarray(img)
         buffered = BytesIO()
         pil_img.save(buffered, format="JPEG", quality=85)
         return base64.b64encode(buffered.getvalue()).decode()
     
     def stop_and_reset(self):
+        """Stop and reset"""
         self.reset_session()
         return "<p>Ready</p>", "Ready", None, None
     
     def create_interface(self):
-        """Create Gradio interface - All tasks integrated"""
-        with gr.Blocks(title="Dog Tracking System", theme=gr.themes.Soft()) as app:
+        """Create Gradio interface with management tabs"""
+        with gr.Blocks(title="Enhanced Dog Tracking System", theme=gr.themes.Soft()) as app:
             gr.Markdown("""
-            # 🐕 Dog Tracking System with Health Assessment
-            ### Detect, Track, Identify, and Monitor Dog Health
+            # 🐕 Enhanced Dog Tracking System
+            ### Detect, Track, Remember, and Monitor Dog Health
             """)
             
-            alerts_output = gr.HTML(visible=False)
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    # TASK 6: Force upload mode
-                    video_input = gr.Video(label="Upload Video", sources=["upload"])
-                    
-                    reid_threshold = gr.Slider(
-                        0.15, 0.6, 0.35, step=0.05,
-                        label="ReID Threshold",
-                        info="Lower = more lenient"
-                    )
-                    
-                    sample_rate = gr.Slider(
-                        1, 5, 2, step=1,
-                        label="Frame Sample Rate",
-                        info="Higher = faster but less accurate"
-                    )
-                    
-                    # OPTIONAL: Pose toggle
-                    use_pose = gr.Checkbox(
-                        label="Use Pose Keypoints for Matching",
-                        value=True,
-                        info="Improves accuracy but slightly slower"
-                    )
+            # Main processing tab
+            with gr.Tab("🎥 Video Processing"):
+                alerts_output = gr.HTML(visible=False)
+                health_output = gr.HTML(visible=False)
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        video_input = gr.Video(label="Upload Video")
+                        reid_threshold = gr.Slider(
+                            0.15, 0.6, 0.35, step=0.05,
+                            label="ReID Threshold",
+                            info="Lower = more lenient matching"
+                        )
+                        sample_rate = gr.Slider(
+                            1, 5, 2, step=1,
+                            label="Frame Sample Rate"
+                        )
+                        process_btn = gr.Button("🚀 Process Video", variant="primary", size="lg")
+                        save_btn = gr.Button("💾 Save to Database", variant="secondary", size="lg")
+                        stop_btn = gr.Button("⏹️ Stop", variant="stop")
                     
-                    process_btn = gr.Button("🚀 Process Video", variant="primary", size="lg")
-                    save_btn = gr.Button("💾 Save New Dogs", variant="secondary", size="lg")
-                    stop_btn = gr.Button("⏹ Stop", variant="stop")
+                    with gr.Column(scale=2):
+                        status_text = gr.Textbox(label="Status", interactive=False)
+                        gallery_output = gr.HTML(label="Detected Dogs")
+                
+                # Process video
+                process_btn.click(
+                    self.process_video,
+                    inputs=[video_input, reid_threshold, sample_rate],
+                    outputs=[gallery_output, status_text, alerts_output, health_output]
+                ).then(
+                    lambda x, y: (gr.update(visible=bool(x)), gr.update(visible=bool(y))),
+                    inputs=[alerts_output, health_output],
+                    outputs=[alerts_output, health_output]
+                )
                 
-                with gr.Column(scale=2):
-                    status_text = gr.Textbox(label="Status", interactive=False)
-                    gallery_output = gr.HTML(label="Detected Dogs")
-            
-            with gr.Row():
-                show_db_btn = gr.Button("📚 Show Database", variant="secondary")
+                # Save to database
+                save_btn.click(
+                    self.save_to_database,
+                    outputs=[status_text, gr.HTML(visible=False)]
+                )
                 
-            with gr.Row():
-                with gr.Column():
-                    database_output = gr.HTML(label="Database", visible=False)
-            
-            # TASK 4: Delete functionality
-            with gr.Row():
-                with gr.Column():
-                    delete_input = gr.Textbox(
-                        label="Dog Name to Delete",
-                        placeholder="Enter exact dog name (e.g., Karabaş)"
-                    )
-                    delete_btn = gr.Button("🗑️ Delete Dog", variant="stop")
-                    delete_status = gr.Textbox(label="Delete Status", interactive=False)
-            
-            # Process video
-            process_btn.click(
-                self.process_video,
-                inputs=[video_input, reid_threshold, sample_rate, use_pose],
-                outputs=[gallery_output, status_text, alerts_output, database_output]
-            ).then(
-                lambda x: gr.update(visible=bool(x)),
-                inputs=[alerts_output],
-                outputs=[alerts_output]
-            )
-            
-            # Save to database
-            save_btn.click(
-                self.save_to_database,
-                outputs=[status_text, database_output]
-            ).then(
-                lambda: gr.update(visible=True),
-                outputs=[database_output]
-            )
+                # Stop and reset
+                stop_btn.click(
+                    self.stop_and_reset,
+                    outputs=[gallery_output, status_text, alerts_output, health_output]
+                )
             
-            # Show database
-            show_db_btn.click(
-                self._show_database,
-                outputs=[database_output]
-            ).then(
-                lambda: gr.update(visible=True),
-                outputs=[database_output]
-            )
+            # ENHANCEMENT 3: Health Summary Tab
+            with gr.Tab("🏥 Health Summary"):
+                gr.HTML(value=health_output)
             
-            # TASK 4: Delete dog
-            delete_btn.click(
-                self.delete_dog,
-                inputs=[delete_input],
-                outputs=[delete_status, database_output]
-            ).then(
-                lambda: gr.update(visible=True),
-                outputs=[database_output]
-            )
+            # Database viewing tab
+            with gr.Tab("📚 View Database"):
+                with gr.Row():
+                    show_db_btn = gr.Button("🔄 Refresh Database", variant="secondary")
+                database_display = gr.HTML()
+                
+                show_db_btn.click(
+                    self._show_database,
+                    outputs=[database_display]
+                )
             
-            # Stop and reset
-            stop_btn.click(
-                self.stop_and_reset,
-                outputs=[gallery_output, status_text, alerts_output, database_output]
-            )
+            # ENHANCEMENT 4: Database Management Tab
+            with gr.Tab("⚙️ Manage Database"):
+                gr.Markdown("### Delete or Merge Dogs")
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("#### Delete Dog")
+                        delete_name_input = gr.Textbox(label="Dog Name to Delete")
+                        hard_delete_check = gr.Checkbox(label="Permanent Delete (irreversible)", value=False)
+                        delete_btn = gr.Button("🗑️ Delete Dog", variant="stop")
+                        delete_status = gr.Textbox(label="Delete Status", interactive=False)
+                    
+                    with gr.Column():
+                        gr.Markdown("#### Merge Dogs")
+                        gr.Markdown("Combine duplicate dogs into one entry")
+                        keep_name_input = gr.Textbox(label="Keep This Dog (name)")
+                        merge_name_input = gr.Textbox(label="Merge This Dog Into Above")
+                        merge_btn = gr.Button("🔗 Merge Dogs", variant="secondary")
+                        merge_status = gr.Textbox(label="Merge Status", interactive=False)
+                
+                manage_db_display = gr.HTML()
+                
+                # Delete action
+                delete_btn.click(
+                    self.delete_dog_from_database,
+                    inputs=[delete_name_input, hard_delete_check],
+                    outputs=[delete_status, manage_db_display]
+                )
+                
+                # Merge action
+                merge_btn.click(
+                    self.merge_dogs,
+                    inputs=[keep_name_input, merge_name_input],
+                    outputs=[merge_status, manage_db_display]
+                )
+                
+                # Show database in management view
+                gr.Button("📚 Show Current Database").click(
+                    self._show_database,
+                    outputs=[manage_db_display]
+                )
             
-            video_input.change(
-                fn=self.stop_and_reset,
-                outputs=[gallery_output, status_text, alerts_output, database_output]
-            )
+            # Statistics tab
+            with gr.Tab("📊 Statistics"):
+                gr.Markdown("### System Statistics")
+                stats_btn = gr.Button("📈 Get Statistics")
+                stats_output = gr.JSON()
+                
+                def get_all_stats():
+                    return {
+                        'reid_stats': self.reid.get_statistics(),
+                        'tracker_stats': self.tracker.get_statistics(),
+                        'database_dogs': len(self.reid.permanent_dogs),
+                        'current_session_dogs': len(self.current_session_data.get('crops', {})),
+                        'health_assessments': len(self.dog_health_scores)
+                    }
+                
+                stats_btn.click(
+                    get_all_stats,
+                    outputs=[stats_output]
+                )
         
         return app
 
-
-# ==================== LAUNCH ====================
-
 if __name__ == "__main__":
-    print("="*60)
-    print("Dog Tracking System - All 57 Tasks Implemented")
-    print("Optimized for HuggingFace Spaces with T4 GPU")
-    print("="*60)
-    
-    demo = DogDetectionDemo()
+    demo = EnhancedDogDetectionDemo()
     app = demo.create_interface()
-    
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )
+    app.launch(server_name="0.0.0.0", server_port=7860, share=False)