Update app.py

app.py

@@ -1,51 +1,50 @@
 """
-sokak_dostlari_app.py - Sokak Dostları AI Tanıma Sistemi
-Hugging Face Spaces T4 GPU için tam Türkçe versiyon
+sokak_dostlari_app.py - Complete Integrated System
+With pose detection, health assessment, and optimizations
 """
+
 import gradio as gr
 import cv2
 import numpy as np
 import pandas as pd
-import random
+import folium
 import json
 import time
-import folium
 from pathlib import Path
 from typing import List, Dict, Optional, Tuple
-import sqlite3
-import base64
-import pickle
 from datetime import datetime
-from io import BytesIO
-from PIL import Image
+from ultralytics import YOLO
+import base64
 
 # Import core modules
 from detection import DogDetector
 from tracking import SimpleTracker
 from reid import SimplifiedDogReID
+from database import DogDatabase
+from health_module import DogHealthAssessment, HealthScore
 
-# ========== TURKISH DOG NAMES ==========
+# ========== TURKISH NAMES WITH ENGLISH ALPHABET ==========
 class TurkishDogNames:
-    """Türkçe köpek isimleri üretici"""
+    """Turkish dog names with English alphabet"""
     
     NAMES = [
-        "Karabaş", "Pamuk", "Boncuk", "Çomar", "Duman", "Paşa", 
-        "Aslan", "Kömür", "Bal", "Fındık", "Zeytin", "Tarçın",
-        "Minnoş", "Cesur", "Kara", "Beyaz", "Benekli", "Sarı",
-        "Kuyruk", "Pati", "Şanslı", "Dostum", "Kont", "Prenses",
-        "Sultan", "Reis", "Kaptan", "Yıldız", "Ay", "Güneş",
-        "Bulut", "Rüzgar", "Fırtına", "Şimşek", "Kar", "Buz"
+        "Karabas", "Pamuk", "Boncuk", "Comar", "Duman", "Pasa",
+        "Aslan", "Komur", "Bal", "Findik", "Zeytin", "Tarcin",
+        "Minnos", "Cesur", "Kara", "Beyaz", "Benekli", "Sari",
+        "Kuyruk", "Pati", "Sansli", "Dostum", "Kont", "Prenses",
+        "Sultan", "Reis", "Kaptan", "Yildiz", "Ay", "Gunes",
+        "Bulut", "Ruzgar", "Firtina", "Simsek", "Kar", "Buz",
+        "Tatli", "Seker", "Lokum", "Badem", "Ceviz", "Kestane"
     ]
     
     def __init__(self):
         self.used_names = set()
-        self.name_counter = {}
-        
+        self.name_mapping = {}
+    
     def get_name(self, dog_id: int) -> str:
-        """ID'ye göre benzersiz isim döndür"""
-        if dog_id in self.name_counter:
-            return self.name_counter[dog_id]
-            
+        if dog_id in self.name_mapping:
+            return self.name_mapping[dog_id]
+        
         base_name = self.NAMES[dog_id % len(self.NAMES)]
         
         if base_name in self.used_names:
@@ -55,264 +54,215 @@ class TurkishDogNames:
             name = f"{base_name} {counter}"
         else:
             name = base_name
-            
+        
         self.used_names.add(name)
-        self.name_counter[dog_id] = name
+        self.name_mapping[dog_id] = name
         return name
 
 # ========== BODRUM LOCATIONS ==========
 class BodrumLocations:
-    """Bodrum lokasyonları"""
+    """Fixed Bodrum locations for demo"""
     
     LOCATIONS = [
         ("Marina Sokak", "Bodrum Marina", 37.0318, 27.4305),
-        ("Kale Meydanı", "Bodrum Kalesi", 37.0325, 27.4298),
-        ("Çarşı İçi", "Merkez Çarşı", 37.0334, 27.4312),
+        ("Kale Meydani", "Bodrum Kalesi", 37.0325, 27.4298),
+        ("Carsi Ici", "Merkez Carsi", 37.0334, 27.4312),
         ("Neyzen Tevfik Caddesi", "Sahil", 37.0341, 27.4289),
         ("Cumhuriyet Caddesi", "Merkez", 37.0357, 27.4301),
         ("Dr. Alim Bey Caddesi", "Hastane Yolu", 37.0365, 27.4276),
-        ("Gümbet Mahallesi", "Gümbet Plajı", 37.0298, 27.4088),
-        ("Konacık Merkez", "Konacık", 37.0445, 27.4189),
-        ("Ortakent Yolu", "Ortakent", 37.0521, 27.3412),
-        ("Yalıkavak Marina", "Yalıkavak", 37.0983, 27.2891)
+        ("Gumbet Mahallesi", "Gumbet Plaji", 37.0298, 27.4088),
+        ("Konacik Merkez", "Konacik", 37.0445, 27.4189)
     ]
     
     @classmethod
-    def get_random_location(cls) -> Tuple[str, str, float, float]:
-        """Rastgele lokasyon seç"""
+    def get_random_location(cls):
+        import random
         return random.choice(cls.LOCATIONS)
 
-# ========== IMAGE QUALITY SCORER ==========
-class ImageQualityScorer:
-    """Görüntü kalitesi skorlayıcı"""
+# ========== MAIN APPLICATION ==========
+class SokakDostlariAI:
+    """Complete Sokak Dostları AI System"""
     
-    @staticmethod
-    def score_image_with_head(image: np.ndarray) -> float:
-        """Baş görünürlüğü ile birlikte görüntü kalitesi"""
-        if image is None or image.size == 0:
-            return 0
+    def __init__(self):
+        # Core AI components
+        self.detector = DogDetector(device='cuda', confidence_threshold=0.4)
+        self.tracker = SimpleTracker()
+        self.reid = SimplifiedDogReID(device='cuda', similarity_threshold=0.65)
         
-        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        # Load pose model
+        try:
+            self.pose_model = YOLO('dog-pose-trained.pt')
+            self.pose_available = True
+            print("Dog pose model loaded")
+        except:
+            try:
+                self.pose_model = YOLO('yolov8m-pose.pt')
+                self.pose_available = True
+                print("Using default pose model")
+            except:
+                self.pose_available = False
+                print("Pose model not available")
+        
+        if self.pose_available:
+            self.pose_model.to('cuda')
+        
+        # Helper modules
+        self.db = DogDatabase()
+        self.health_module = DogHealthAssessment()
+        self.name_gen = TurkishDogNames()
         
-        # Bulanıklık (Laplacian)
-        sharpness = cv2.Laplacian(gray, cv2.CV_64F).var()
+        # Session state
+        self.current_dogs = {}
+        self.current_location = None
+        self.processing_active = False
         
-        # Baş bölgesi (üst %40)
-        h, w = image.shape[:2]
-        head_region = gray[:int(h * 0.4), :]
-        head_detail = np.std(head_region) if head_region.size > 0 else 0
+        # Dog pose skeleton connections
+        self.dog_skeleton = [
+            [0, 1], [1, 2], [2, 3],  # Head
+            [3, 4], [4, 5], [5, 6],  # Spine
+            [5, 7], [7, 9],  # Front left
+            [6, 8], [8, 10],  # Front right
+            [11, 13], [13, 15],  # Back left
+            [12, 14], [14, 16]  # Back right
+        ]
+        
+        # Performance settings
+        self.process_every_n = 10  # Process every 10th frame
+        self.pose_every_n = 15  # Run pose every 15th frame
+    
+    def optimize_video(self, video_path: str) -> str:
+        """Optimize video for faster processing"""
+        cap = cv2.VideoCapture(video_path)
         
-        # Parlaklık
-        brightness = np.mean(gray)
-        good_brightness = 1.0 if 50 < brightness < 200 else 0.5
+        fps = int(cap.get(cv2.CAP_PROP_FPS))
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
         
-        # Toplam skor
-        total = (sharpness * 0.4 + head_detail * 0.4 + good_brightness * 0.2)
-        return total
-    
-    @staticmethod
-    def select_best_image(images: List[np.ndarray]) -> Tuple[np.ndarray, int]:
-        """En iyi kaliteli görüntüyü seç"""
-        if not images:
-            return None, -1
+        # Target: 854x480 @ 15fps
+        if width > 854 or height > 480 or fps > 15:
+            scale = min(854/width, 480/height, 1.0)
+            new_width = int(width * scale)
+            new_height = int(height * scale)
+            new_fps = min(fps, 15)
             
-        best_score = -1
-        best_idx = 0
-        
-        for idx, img in enumerate(images):
-            score = ImageQualityScorer.score_image_with_head(img)
-            if score > best_score:
-                best_score = score
-                best_idx = idx
-                
-        return images[best_idx], best_idx
-
-# ========== DATABASE MANAGER ==========
-class DogDatabase:
-    """Basitleştirilmiş veritabanı"""
-    
-    def __init__(self, db_path: str = "sokak_dostlari.db"):
-        self.conn = sqlite3.connect(db_path, check_same_thread=False)
-        self.conn.row_factory = sqlite3.Row
-        self.cursor = self.conn.cursor()
-        self._create_tables()
-        
-    def _create_tables(self):
-        """Tabloları oluştur"""
-        self.cursor.execute("""
-            CREATE TABLE IF NOT EXISTS dogs (
-                dog_id INTEGER PRIMARY KEY,
-                name TEXT,
-                profile_image BLOB,
-                best_head_image BLOB,
-                first_seen TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                total_sightings INTEGER DEFAULT 1,
-                features BLOB,
-                current_location TEXT,
-                current_place TEXT
-            )
-        """)
-        
-        self.cursor.execute("""
-            CREATE TABLE IF NOT EXISTS sightings (
-                sighting_id INTEGER PRIMARY KEY AUTOINCREMENT,
-                dog_id INTEGER,
-                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                location TEXT,
-                place TEXT,
-                lat REAL,
-                lon REAL,
-                confidence REAL,
-                FOREIGN KEY (dog_id) REFERENCES dogs(dog_id)
-            )
-        """)
-        
-        self.conn.commit()
-    
-    def save_or_update_dog(self, dog_id: int, name: str, image: np.ndarray,
-                           features: np.ndarray, location: str, place: str) -> Dict:
-        """Köpek kaydet veya güncelle"""
-        # Mevcut köpeği kontrol et
-        self.cursor.execute("SELECT * FROM dogs WHERE dog_id = ?", (dog_id,))
-        existing = self.cursor.fetchone()
-        
-        # Görüntüyü encode et
-        _, img_buffer = cv2.imencode('.jpg', image, [cv2.IMWRITE_JPEG_QUALITY, 85])
-        img_data = base64.b64encode(img_buffer).decode('utf-8')
-        
-        # Baş görüntüsü
-        h, w = image.shape[:2]
-        head_img = image[:int(h * 0.4), :]
-        _, head_buffer = cv2.imencode('.jpg', head_img, [cv2.IMWRITE_JPEG_QUALITY, 85])
-        head_data = base64.b64encode(head_buffer).decode('utf-8')
-        
-        features_blob = pickle.dumps(features)
-        
-        if existing:
-            # Güncelle
-            self.cursor.execute("""
-                UPDATE dogs SET 
-                    total_sightings = total_sightings + 1,
-                    current_location = ?,
-                    current_place = ?
-                WHERE dog_id = ?
-            """, (location, place, dog_id))
+            output_path = "optimized_temp.mp4"
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            out = cv2.VideoWriter(output_path, fourcc, new_fps, (new_width, new_height))
             
-            # Profil resmini decode et
-            profile_bytes = base64.b64decode(existing['profile_image'])
-            nparr = np.frombuffer(profile_bytes, np.uint8)
-            profile_img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+            frame_skip = max(1, fps // new_fps)
+            frame_count = 0
             
-            result = {
-                'is_new': False,
-                'name': existing['name'],
-                'profile_image': profile_img,
-                'total_sightings': existing['total_sightings'] + 1
-            }
-        else:
-            # Yeni köpek
-            self.cursor.execute("""
-                INSERT INTO dogs (dog_id, name, profile_image, best_head_image,
-                                 features, current_location, current_place)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-            """, (dog_id, name, img_data, head_data, features_blob, location, place))
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                
+                if frame_count % frame_skip == 0:
+                    resized = cv2.resize(frame, (new_width, new_height))
+                    out.write(resized)
+                
+                frame_count += 1
             
-            result = {
-                'is_new': True,
-                'name': name,
-                'profile_image': image,
-                'total_sightings': 1
-            }
+            cap.release()
+            out.release()
+            return output_path
         
-        self.conn.commit()
-        return result
+        cap.release()
+        return video_path
     
-    def get_all_dogs_for_table(self) -> pd.DataFrame:
-        """Tablo için köpek verisi"""
-        self.cursor.execute("""
-            SELECT dog_id, name, current_location, current_place, total_sightings, profile_image
-            FROM dogs ORDER BY dog_id DESC
-        """)
-        
-        data = []
-        for row in self.cursor.fetchall():
-            # Mini thumbnail oluştur
-            img_bytes = base64.b64decode(row['profile_image'])
-            nparr = np.frombuffer(img_bytes, np.uint8)
-            img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-            img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-            img_small = cv2.resize(img_rgb, (60, 60))
-            
-            data.append({
-                'Fotoğraf': img_small,
-                'Adı': f"Adı: {row['name']}",
-                'Bulunduğu Yer': f"{row['current_location']}, {row['current_place']}",
-                'Görülme Sayısı': row['total_sightings']
-            })
+    def draw_pose_skeleton(self, frame: np.ndarray, keypoints: np.ndarray,
+                          bbox: List[float], color: Tuple = None):
+        """Draw pose skeleton on frame"""
+        if keypoints is None or len(keypoints) < 17:
+            return
         
-        return pd.DataFrame(data) if data else pd.DataFrame(columns=['Fotoğraf', 'Adı', 'Bulunduğu Yer', 'Görülme Sayısı'])
-
-# ========== MAIN APPLICATION ==========
-class SokakDostlariApp:
-    """Ana uygulama - T4 GPU optimize"""
+        x1, y1 = int(bbox[0]), int(bbox[1])
+        
+        # Use health color if not specified
+        if color is None:
+            color = (255, 0, 255)  # Default magenta
+        
+        # Draw connections
+        for connection in self.dog_skeleton:
+            if connection[0] < len(keypoints) and connection[1] < len(keypoints):
+                kp1 = keypoints[connection[0]]
+                kp2 = keypoints[connection[1]]
+                
+                if kp1[0] > 0 and kp1[1] > 0 and kp2[0] > 0 and kp2[1] > 0:
+                    pt1 = (int(kp1[0] + x1), int(kp1[1] + y1))
+                    pt2 = (int(kp2[0] + x1), int(kp2[1] + y1))
+                    cv2.line(frame, pt1, pt2, color, 1)
+        
+        # Draw keypoints
+        for kp in keypoints:
+            if kp[0] > 0 and kp[1] > 0:
+                cv2.circle(frame, (int(kp[0] + x1), int(kp[1] + y1)), 2, color, -1)
     
-    def __init__(self):
-        # Core components
-        self.detector = DogDetector(device='cuda', confidence_threshold=0.4)
-        self.tracker = SimpleTracker()
-        self.reid = SimplifiedDogReID(device='cuda', similarity_threshold=0.65)
+    def draw_detection_info(self, frame: np.ndarray, bbox: List[float],
+                           name: str, health_score: HealthScore,
+                           is_new: bool = False):
+        """Draw bounding box with dog info"""
+        x1, y1, x2, y2 = map(int, bbox)
         
-        # Helpers
-        self.db = DogDatabase()
-        self.name_gen = TurkishDogNames()
-        self.quality_scorer = ImageQualityScorer()
+        # Draw bounding box with health color
+        cv2.rectangle(frame, (x1, y1), (x2, y2), health_score.color, 2)
         
-        # Session state
-        self.current_dogs = {}
-        self.reid_threshold = 0.65
-        self.current_video_location = None
-        self.current_video_place = None
-        self.current_lat = None
-        self.current_lon = None
-        self.processing_active = False
-        self.live_detections = []
+        # Prepare text
+        name_text = f"Adi: {name}"
+        health_text = f"Saglik: {health_score.score_text}"
+        
+        # Draw name
+        name_size = cv2.getTextSize(name_text, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2)[0]
+        cv2.rectangle(frame, (x1, y1 - 35), (x1 + name_size[0] + 10, y1), (0, 0, 0), -1)
+        cv2.putText(frame, name_text, (x1 + 5, y1 - 15),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
         
+        # Draw health score
+        cv2.putText(frame, health_text, (x1 + 5, y1 - 5),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, health_score.color, 2)
+        
+        # Add "Yeni" tag if new dog
+        if is_new:
+            cv2.putText(frame, "YENI", (x2 - 50, y1 + 20),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2)
+    
     def process_video_with_live_display(self, video_path: str, mirror_fix: bool = False):
-        """Process video with live display of detection"""
+        """Process video with live display of detections"""
         if not video_path:
-            yield None, None, pd.DataFrame(), "Video yüklenmedi"
+            yield None, "Video yuklenmedi", pd.DataFrame()
             return
         
-        # Reset
+        # Reset state
         self.tracker = SimpleTracker()
         self.reid.reset()
         self.current_dogs = {}
-        self.live_detections = []
         self.processing_active = True
         
-        # Choose single location for video
+        # Choose single location for entire video
         street, place, lat, lon = BodrumLocations.get_random_location()
-        self.current_video_location = street
-        self.current_video_place = place
-        self.current_lat = lat
-        self.current_lon = lon
+        self.current_location = f"{street}, {place}"
+        
+        # Optimize video
+        optimized_path = self.optimize_video(video_path)
         
         # Open video
-        cap = cv2.VideoCapture(video_path)
+        cap = cv2.VideoCapture(optimized_path)
+        cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
+        
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
         fps = cap.get(cv2.CAP_PROP_FPS)
-        
-        # Prepare output
         width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        output_path = "processed_output.mp4"
+        
+        # Output video
+        output_path = "output_processed.mp4"
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
         out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
         
         frame_count = 0
-        detected_names = []
+        detected_count = 0
         
-        while self.processing_active:
+        while self.processing_active and frame_count < total_frames:
             ret, frame = cap.read()
             if not ret:
                 break
@@ -321,347 +271,404 @@ class SokakDostlariApp:
                 frame = cv2.flip(frame, 1)
             
             frame_count += 1
-            display_frame = frame.copy()
             
-            # Process every 3rd frame
-            if frame_count % 3 == 0:
+            # Process every Nth frame
+            if frame_count % self.process_every_n == 0:
+                # Detect dogs
                 detections = self.detector.detect(frame)
+                
+                # Update tracking
                 tracks = self.tracker.update(detections)
                 
                 for track in tracks:
-                    # Draw YOLO box immediately
                     bbox = track.bbox
                     x1, y1, x2, y2 = map(int, bbox)
-                    cv2.rectangle(display_frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
                     
-                    # Get best image for ReID
-                    images = []
-                    for det in track.detections[-5:]:
+                    # Get best detection with image
+                    detection = None
+                    for det in reversed(track.detections):
                         if det.image_crop is not None:
-                            images.append(det.image_crop)
+                            detection = det
+                            break
                     
-                    if images:
-                        best_img, _ = self.quality_scorer.select_best_image(images)
+                    if not detection:
+                        continue
+                    
+                    # ReID
+                    dog_id, confidence = self.reid.match_or_register(track)
+                    
+                    if dog_id > 0:
+                        # Get or assign name
+                        name = self.name_gen.get_name(dog_id)
                         
-                        # ReID
-                        dog_id, confidence = self.reid.match_or_register(track)
+                        # Pose detection (if available and on pose frame)
+                        keypoints = None
+                        if self.pose_available and frame_count % self.pose_every_n == 0:
+                            try:
+                                pose_results = self.pose_model(detection.image_crop)
+                                if pose_results and len(pose_results) > 0:
+                                    if hasattr(pose_results[0], 'keypoints'):
+                                        kpts = pose_results[0].keypoints
+                                        if kpts is not None:
+                                            keypoints = kpts.xy[0].cpu().numpy()
+                            except:
+                                pass
                         
-                        if dog_id > 0:
-                            name = self.name_gen.get_name(dog_id)
-                            
-                            # Show name being assigned with animation
-                            cv2.putText(display_frame, f">>> {name}", (x1, y1-10),
-                                       cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 255), 2)
-                            
-                            # Save to database
-                            result = self.db.save_or_update_dog(
-                                dog_id, name, best_img,
-                                np.zeros(2048),
-                                self.current_video_location,
-                                self.current_video_place
-                            )
-                            
-                            # Add to current dogs
-                            if result['is_new']:
-                                self.live_detections.append(f"🟢 Yeni: {name}")
-                                detected_names.append(name)
-                                color = (0, 255, 255)  # Yellow for new
-                            else:
-                                self.live_detections.append(f"🔄 Tanıdık: {name} (#{result['total_sightings']})")
-                                color = (0, 255, 0)  # Green for known
-                                
-                                # Show mini profile
-                                if result['profile_image'] is not None:
-                                    try:
-                                        mini = cv2.resize(result['profile_image'], (50, 50))
-                                        if y1 > 50:
-                                            display_frame[y1-50:y1, x1:x1+50] = mini
-                                    except:
-                                        pass
-                            
-                            # Draw final box with color
-                            cv2.rectangle(display_frame, (x1, y1), (x2, y2), color, 3)
-                            
-                            self.current_dogs[dog_id] = result
+                        # Health assessment
+                        center_x = (bbox[0] + bbox[2]) / 2
+                        center_y = (bbox[1] + bbox[3]) / 2
+                        
+                        health_score = self.health_module.calculate_overall_health(
+                            dog_id=dog_id,
+                            keypoints=keypoints,
+                            dog_crop=detection.image_crop,
+                            bbox=bbox,
+                            current_pos=(center_x, center_y)
+                        )
+                        
+                        # Check if new dog
+                        is_new = dog_id not in self.current_dogs
+                        
+                        if is_new:
+                            detected_count += 1
+                            # Add to database
+                            self.db.add_dog(dog_id, name)
+                        
+                        # Update sighting
+                        self.db.update_dog_sighting(dog_id)
+                        
+                        # Save image
+                        image_id = self.db.save_image(
+                            dog_id=dog_id,
+                            image=detection.image_crop,
+                            frame_number=frame_count,
+                            video_source=video_path,
+                            bbox=bbox,
+                            confidence=confidence,
+                            pose_keypoints=keypoints.tolist() if keypoints is not None else None
+                        )
+                        
+                        # Save features
+                        if hasattr(self.reid, 'dog_database') and dog_id in self.reid.dog_database:
+                            features = self.reid.dog_database[dog_id][-1]
+                            if hasattr(features, 'full_features'):
+                                self.db.save_features(
+                                    dog_id=dog_id,
+                                    resnet_features=features.full_features,
+                                    color_histogram=features.color_histogram if hasattr(features, 'color_histogram') else np.zeros(170),
+                                    confidence=confidence
+                                )
+                        
+                        # Add sighting
+                        self.db.add_sighting(
+                            dog_id=dog_id,
+                            position=(center_x, center_y),
+                            video_source=video_path,
+                            frame_number=frame_count,
+                            confidence=confidence
+                        )
+                        
+                        # Draw on frame
+                        self.draw_detection_info(frame, bbox, name, health_score, is_new)
+                        
+                        # Draw pose if available
+                        if keypoints is not None:
+                            self.draw_pose_skeleton(frame, keypoints, bbox, health_score.color)
+                        
+                        # Store in current dogs
+                        self.current_dogs[dog_id] = {
+                            'name': name,
+                            'health_score': health_score.score,
+                            'health_status': health_score.status,
+                            'location': self.current_location
+                        }
+            
+            # Add overlay with statistics
+            overlay_height = 60
+            overlay = np.zeros((overlay_height, width, 3), dtype=np.uint8)
             
-            # Add overlay
-            self._add_live_overlay(display_frame, frame_count, len(self.current_dogs), self.live_detections[-3:])
+            # Text info
+            info_text = f"Kopek Sayisi: {len(self.current_dogs)} | Konum: {self.current_location}"
+            cv2.putText(overlay, info_text, (10, 25),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
             
-            # Convert for display
-            frame_rgb = cv2.cvtColor(display_frame, cv2.COLOR_BGR2RGB)
+            progress_text = f"Kare: {frame_count}/{total_frames}"
+            cv2.putText(overlay, progress_text, (10, 45),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (200, 200, 200), 1)
             
-            # Write original frame to video
-            self._add_live_overlay(frame, frame_count, len(self.current_dogs), self.live_detections[-3:])
+            # Add overlay to frame top
+            frame[:overlay_height, :] = cv2.addWeighted(frame[:overlay_height, :], 0.3, overlay, 0.7, 0)
+            
+            # Write to output video
             out.write(frame)
             
-            # Yield frame for live display
-            yield frame_rgb, None, pd.DataFrame(), f"İşleniyor: {frame_count}/{total_frames} | Bulunan: {len(self.current_dogs)}"
+            # Yield for live display (every 5 frames)
+            if frame_count % 5 == 0:
+                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                status = f"Isleniyor: %{int(frame_count/total_frames*100)} | Bulunan: {len(self.current_dogs)} kopek"
+                
+                # Create simple dataframe
+                dogs_data = []
+                for dog_id, info in self.current_dogs.items():
+                    dogs_data.append({
+                        'Adi': info['name'],
+                        'Saglik': f"{info['health_score']}/10",
+                        'Durum': info['health_status'],
+                        'Konum': info['location']
+                    })
+                df = pd.DataFrame(dogs_data) if dogs_data else pd.DataFrame()
+                
+                yield frame_rgb, status, df
         
         # Cleanup
         cap.release()
         out.release()
         
-        # Prepare final results
-        df = self.db.get_all_dogs_for_table()
-        map_html = self._create_map()
-        status = f"✅ {len(self.current_dogs)} köpek bulundu\n📍 Konum: {self.current_video_location}, {self.current_video_place}"
+        # Final status
+        final_status = f"✅ Tamamlandi! {len(self.current_dogs)} kopek bulundu | Konum: {self.current_location}"
+        
+        # Create final dataframe
+        final_dogs_data = []
+        for dog_id, info in self.current_dogs.items():
+            final_dogs_data.append({
+                'Adi': info['name'],
+                'Saglik': f"{info['health_score']}/10",
+                'Durum': info['health_status'],
+                'Konum': info['location']
+            })
+        final_df = pd.DataFrame(final_dogs_data) if final_dogs_data else pd.DataFrame()
         
-        # Final yield with complete results
-        yield None, output_path, df, map_html, status
+        # Loop the processed video
+        yield output_path, final_status, final_df
     
-    def _draw_detection_with_info(self, frame, track, dog_info, name):
-        """Tespit kutusunu çiz"""
-        bbox = track.bbox
-        x1, y1, x2, y2 = map(int, bbox)
-        
-        if dog_info['is_new']:
-            # Yeni köpek - turuncu
-            color = (255, 165, 0)
-            label = f"Yeni: {name}"
+    def create_map_html(self) -> str:
+        """Create HTML map with dog locations"""
+        if not self.current_location or not self.current_dogs:
+            return "<p>Henuz veri yok</p>"
+        
+        # Get location coordinates
+        for loc in BodrumLocations.LOCATIONS:
+            if loc[0] in self.current_location:
+                lat, lon = loc[2], loc[3]
+                break
         else:
-            # Tanıdık - yeşil
-            color = (0, 255, 0)
-            label = f"Tanıdık: {name} (#{dog_info['total_sightings']})"
-            
-            # Mini profil göster
-            if dog_info['profile_image'] is not None:
-                try:
-                    mini = cv2.resize(dog_info['profile_image'], (50, 50))
-                    if y1 > 50:
-                        frame[y1-50:y1, x1:x1+50] = mini
-                except:
-                    pass
-        
-        # Kutu ve etiket
-        cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
-        
-        # Etiket arka planı
-        label_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)[0]
-        cv2.rectangle(frame, (x1, y1 - label_size[1] - 10), 
-                     (x1 + label_size[0], y1), color, -1)
-        cv2.putText(frame, label, (x1, y1 - 5),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
-    
-    def _add_live_overlay(self, frame, frame_count, dog_count, recent_detections):
-        """Canlı bilgi overlay"""
-        h, w = frame.shape[:2]
-        
-        # Üst bilgi çubuğu
-        overlay = frame.copy()
-        cv2.rectangle(overlay, (0, 0), (w, 80), (0, 0, 0), -1)
-        frame[:80, :] = cv2.addWeighted(overlay[:80, :], 0.4, frame[:80, :], 0.6, 0)
-        
-        # Ana bilgi
-        cv2.putText(frame, f"Kare: {frame_count} | Bulunan: {dog_count} kopek", 
-                   (10, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
-        
-        # Son tespitler
-        y_pos = 50
-        for detection in recent_detections[-2:]:
-            cv2.putText(frame, detection, (10, y_pos),
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1)
-            y_pos += 20
-    
-    def _create_map(self):
-        """Harita oluştur"""
-        if not self.current_lat:
-            return "<p>Harita yüklenemedi</p>"
-        
-        # Folium harita
-        m = folium.Map(location=[self.current_lat, self.current_lon], zoom_start=16)
-        
-        # Köpek isimleri
-        dog_names = [dog['name'] for dog in self.current_dogs.values()]
-        popup_text = f"""
-        <b>📍 {self.current_video_location}</b><br>
-        {self.current_video_place}<br><br>
-        <b>Bu konumdaki köpekler:</b><br>
-        {'<br>'.join([f'• {name}' for name in dog_names])}
+            lat, lon = 37.0334, 27.4312  # Default center
+        
+        # Create map
+        m = folium.Map(location=[lat, lon], zoom_start=16)
+        
+        # Create popup content
+        popup_html = f"""
+        <div style="width: 200px;">
+            <h4>{self.current_location}</h4>
+            <p><b>Bulunan Kopekler ({len(self.current_dogs)}):</b></p>
+            <ul>
         """
         
-        # Marker ekle
+        for dog_id, info in self.current_dogs.items():
+            color = "🟢" if info['health_score'] >= 7 else "🟡" if info['health_score'] >= 5 else "🔴"
+            popup_html += f"<li>{info['name']} {color} ({info['health_score']}/10)</li>"
+        
+        popup_html += "</ul></div>"
+        
+        # Add marker
         folium.Marker(
-            [self.current_lat, self.current_lon],
-            popup=folium.Popup(popup_text, max_width=300),
+            [lat, lon],
+            popup=folium.Popup(popup_html, max_width=300),
             icon=folium.Icon(color='blue', icon='paw', prefix='fa')
         ).add_to(m)
         
         return m._repr_html_()
     
-    def update_threshold(self, value):
-        """Eşik değerini güncelle"""
-        self.reid_threshold = value
-        self.reid.set_threshold(value)
-        
-        # Tahmini köpek sayısı
-        if value < 0.5:
-            estimate = "~2-4 köpek (benzerler birleşir)"
-        elif value < 0.7:
-            estimate = "~4-6 köpek (orta hassasiyet)"
-        else:
-            estimate = "~6+ köpek (yüksek hassasiyet)"
-        
-        return estimate
-    
-    def save_session(self):
-        """Oturumu kaydet"""
-        count = len(self.current_dogs)
-        if count > 0:
-            return f"✅ {count} köpek veritabanına kaydedildi!"
-        return "❌ Kaydedilecek köpek bulunamadı"
-    
-    def search_dogs(self, search_term):
-        """Köpek ara"""
-        df = self.db.get_all_dogs_for_table()
-        if search_term:
-            df = df[df['Adı'].str.contains(search_term, case=False, na=False)]
-        return df
-    
     def create_interface(self):
-        """Gradio arayüzü"""
+        """Create Gradio interface optimized for mobile"""
+        
         with gr.Blocks(
-            title="Sokak Dostları AI",
+            title="Sokak Dostlari AI",
             theme=gr.themes.Soft(),
             css="""
-            .gradio-container {font-family: 'Segoe UI', Tahoma, sans-serif;}
+            .gradio-container {
+                max-width: 100% !important;
+                padding: 10px !important;
+            }
             @media (max-width: 768px) {
-                .gr-button {min-height: 50px !important; font-size: 16px !important;}
-                .gr-slider {padding: 20px 0 !important;}
+                .gr-button {
+                    min-height: 50px !important;
+                    font-size: 16px !important;
+                    margin: 5px 0 !important;
+                }
+                #single_video {
+                    max-height: 50vh !important;
+                }
             }
             """
         ) as app:
             
             # Header
             gr.Markdown("""
-            # 🐕 Sokak Dostları AI Tanıma Sistemi
+            # 🐕 Sokak Dostlari AI Tanima Sistemi
             
-            **Yapay Zeka** ile sokak köpeklerini takip edin:
+            **Yapay Zeka** ile sokak kopeklerini takip edin:
             
-            - 📹 Videodaki köpekleri otomatik tespit eder
-            - 🆔 Aynı köpeği farklı videolarda tanır
-            - 🖼️ Her köpek için profil oluşturur
-            - 🗺️ Bodrum haritasında yerlerini gösterir
-            - 📊 Uzun süreli takip için veri saklar
+            - 📹 Videodaki kopekleri otomatik tespit eder
+            - 🆔 Ayni kopegi farkli videolarda tanir
+            - 🏥 Saglik durumunu degerlendirir
+            - 🗺️ Bodrum haritasinda yerlerini gosterir
             """)
             
-            with gr.Tabs() as tabs:
-                # Video Tab
-                with gr.Tab("📹 Video İşle"):
-                    with gr.Accordion("⚡ Hızlı Kullanım", open=False):
-                        gr.Markdown("""
-                        1. Köpek videosu yükleyin
-                        2. Tanıma hassasiyetini ayarlayın
-                        3. İşlenmiş videoyu inceleyin
-                        4. Veritabanına kaydedin
-                        5. Haritada konumu görün
+            with gr.Tabs():
+                # Video Processing Tab
+                with gr.Tab("📹 Video Isle"):
+                    with gr.Column():
+                        # Single video component
+                        video_display = gr.Video(
+                            label="Video",
+                            elem_id="single_video",
+                            autoplay=True,
+                            loop=True
+                        )
                         
-                        **ℹ️ Önemli Notlar:**
-                        - Genel AI modeli kullanılmaktadır, yerel köpek verisi yoktur → doğruluk değişebilir
-                        - Harita konumları **demo için simüle edilmiştir**
-                        - Bazı manuel düzeltmeler gerekebilir
+                        status_text = gr.Textbox(
+                            label="Durum",
+                            value="Video yukleyin"
+                        )
                         
-                        ✅ Bu demo, AI'nın **belediyeler ve STK'lar** için sokak köpeklerini daha verimli takip edebileceğini göstermektedir.
-                        """)
-                    
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            video_input = gr.Video(label="Video Yükle")
-                            
-                            mirror_fix = gr.Checkbox(label="Kamera ters mi? (Düzelt)", value=False)
-                            
-                            # Mobile-friendly layout
-                            find_btn = gr.Button("🔍 Dostları Bul", variant="primary", size="lg")
-                            
-                            gr.Markdown("### Kaç köpek var?")
-                            threshold_slider = gr.Slider(
-                                0.4, 0.9, 0.65, step=0.05,
-                                label="Düşük: Benzerler birleşir | Yüksek: Ayrı sayılır",
-                                interactive=True
-                            )
-                            threshold_info = gr.Textbox(
-                                value="~4-6 köpek (orta hassasiyet)",
-                                label="Tahmini köpek sayısı",
-                                interactive=False
+                        # Controls
+                        with gr.Row():
+                            upload_btn = gr.UploadButton(
+                                "📁 Video Yukle",
+                                file_types=["video"]
                             )
                             
-                            save_btn = gr.Button("💾 Kaydet", size="lg")
-                            status = gr.Textbox(label="Durum", lines=2)
+                            mirror_checkbox = gr.Checkbox(
+                                label="Ters Duzelt",
+                                value=False
+                            )
                         
-                        with gr.Column(scale=2):
-                            live_frame = gr.Image(label="Canlı İşleme", type="numpy")
-                            video_output = gr.Video(label="Final Video", visible=False)
-                            map_display = gr.HTML(label="Konum")
+                        find_btn = gr.Button(
+                            "🔍 Dostlari Bul",
+                            variant="primary",
+                            size="lg"
+                        )
+                        
+                        # Dog table
+                        with gr.Accordion("Bulunan Kopekler", open=False):
+                            dogs_table = gr.Dataframe(
+                                headers=["Adi", "Saglik", "Durum", "Konum"],
+                                datatype=["str", "str", "str", "str"]
+                            )
                 
-                # Dog List Tab
-                with gr.Tab("🐶 Köpek Listesi"):
-                    search_box = gr.Textbox(
-                        label="",
-                        placeholder="Köpek ara...",
-                        interactive=True
+                # Map Tab
+                with gr.Tab("🗺️ Harita"):
+                    map_html = gr.HTML(
+                        label="Kopek Konumlari"
                     )
                     
-                    dogs_table = gr.Dataframe(
-                        headers=["Fotoğraf", "Adı", "Bulunduğu Yer", "Görülme Sayısı"],
-                        datatype=["image", "str", "str", "number"],
-                        interactive=False,
-                        label="Kayıtlı Köpekler"
+                    refresh_map_btn = gr.Button("🔄 Haritayi Guncelle")
+                
+                # Statistics Tab
+                with gr.Tab("📊 Istatistikler"):
+                    stats_text = gr.Textbox(
+                        label="Veritabani Istatistikleri",
+                        lines=10
                     )
                     
-                    refresh_btn = gr.Button("🔄 Listeyi Yenile")
+                    refresh_stats_btn = gr.Button("🔄 Istatistikleri Guncelle")
                 
-                # Map Tab
-                with gr.Tab("🗺️ Harita"):
-                    map_html = gr.HTML(label="Bodrum Haritası")
+                # Help Tab
+                with gr.Tab("ℹ️ Yardim"):
                     gr.Markdown("""
-                    📍 **Not:** Harita konumları demo için simüle edilmiştir.
-                    Gerçek uygulamada GPS veya sabit kamera konumları kullanılacaktır.
+                    ### ⚡ Hizli Kullanim
+                    1. Kopek videosu yukleyin
+                    2. "Dostlari Bul" butonuna tiklayin
+                    3. Islenirken kopeklerin tespit edilisini izleyin
+                    4. Harita sekmesinde konumlari gorun
+                    
+                    ### 📝 Onemli Notlar
+                    - Genel AI modeli kullanilmaktadir
+                    - Harita konumlari demo icin simuledir
+                    - Saglik degerlendirmesi tahminidir
+                    
+                    ✅ Bu demo, belediyelerin sokak kopeklerini daha verimli takip edebilecegini gostermektedir.
                     """)
             
-            # Event handlers
-            find_btn.click(
-                self.process_video_with_live_display,
-                inputs=[video_input, mirror_fix],
-                outputs=[live_frame, video_output, dogs_table, status],
-                show_progress=True
-            )
+            # Event Handlers
+            def handle_upload(file):
+                if file:
+                    return file.name, "Video yuklendi, 'Dostlari Bul' tiklayin"
+                return None, "Video yukleyin"
+            
+            def process_video(video_path, mirror_fix):
+                if not video_path:
+                    yield None, "Lutfen once video yukleyin", pd.DataFrame()
+                    return
+                
+                for result in self.process_video_with_live_display(video_path, mirror_fix):
+                    if isinstance(result[0], str):  # Final result with video path
+                        yield result[0], result[1], result[2]
+                    else:  # Live frame
+                        yield result[0], result[1], result[2]
             
+            def get_stats():
+                stats = self.db.get_dog_statistics()
+                return f"""
+                📊 Veritabani Istatistikleri:
+                
+                Toplam Aktif Kopek: {stats.get('total_active_dogs', 0)}
+                Toplam Goruntu: {stats.get('total_images', 0)}
+                Toplam Goruntulenme: {stats.get('total_sightings', 0)}
+                
+                En Cok Gorulen: {stats.get('most_seen_dog', {}).get('name', 'Yok')}
+                """
             
-            threshold_slider.change(
-                self.update_threshold,
-                inputs=[threshold_slider],
-                outputs=[threshold_info]
+            # Connect events
+            upload_btn.upload(
+                handle_upload,
+                inputs=[upload_btn],
+                outputs=[video_display, status_text]
             )
             
-            save_btn.click(
-                self.save_session,
-                outputs=[status]
+            find_btn.click(
+                process_video,
+                inputs=[video_display, mirror_checkbox],
+                outputs=[video_display, status_text, dogs_table]
             )
             
-            search_box.submit(
-                self.search_dogs,
-                inputs=[search_box],
-                outputs=[dogs_table]
+            refresh_map_btn.click(
+                self.create_map_html,
+                outputs=[map_html]
             )
             
-            refresh_btn.click(
-                lambda: self.db.get_all_dogs_for_table(),
-                outputs=[dogs_table]
+            refresh_stats_btn.click(
+                get_stats,
+                outputs=[stats_text]
             )
             
-            # Auto-refresh map on tab change
-            tabs.select(
-                lambda: self._create_map() if self.current_lat else "<p>Henüz video işlenmedi</p>",
-                outputs=[map_html]
+            # Load initial stats
+            app.load(
+                get_stats,
+                outputs=[stats_text]
             )
         
         return app
 
 # ========== LAUNCH ==========
 def main():
-    app = SokakDostlariApp()
+    """Main entry point"""
+    
+    # First, update database with health fields (run once)
+    try:
+        from database_health_update import add_health_fields_to_database
+        add_health_fields_to_database()
+        print("Database updated with health fields")
+    except Exception as e:
+        print(f"Database update info: {e}")
+    
+    # Create and launch app
+    app = SokakDostlariAI()
     interface = app.create_interface()
     
-    # Hugging Face Spaces settings
+    # Launch settings optimized for Hugging Face Spaces
     interface.launch(
         server_name="0.0.0.0",
         server_port=7860,