feat: add video comparison module to find common faces

app.py

@@ -19,6 +19,7 @@ import requests
 import tempfile
 from urllib.parse import urlparse
 import logging
+from core.comparator import VideoComparator, ComparisonResult
 
 logging.basicConfig(
     level=logging.INFO,
@@ -291,7 +292,7 @@ class FaceDetector:
 
     def create_output_directory(self, video_path: str, is_temp: bool = False) -> str:
         logger.info(f"burası {self},{video_path},{is_temp}")
-        """Çıktı dizinini oluşturur - Gradio uyumlu"""
+        
         if is_temp:
             # URL/YouTube için temp dizini kullan
             temp_dir = tempfile.gettempdir()            
@@ -528,6 +529,7 @@ class FaceDetector:
                 self.cleanup_temp_files()
 
 detector_instance = None
+comparator_instance = None
 
 def initialize_detector(frame_skip, face_threshold, clustering_eps, use_gpu):
     global detector_instance
@@ -540,6 +542,21 @@ def initialize_detector(frame_skip, face_threshold, clustering_eps, use_gpu):
     detector_instance = FaceDetector(config)
     return "✅ Ayarlar kaydedildi!"
 
+def initialize_comparator():
+    """Video karşılaştırıcı instance'ını başlat"""
+    global comparator_instance, detector_instance
+    
+    if detector_instance is None:
+        detector_instance = FaceDetector(FaceDetectionConfig())
+    
+    if comparator_instance is None:
+        comparator_instance = VideoComparator(
+            face_detector=detector_instance,
+            similarity_threshold=0.6  # %60 benzerlik eşiği
+        )
+    
+    return comparator_instance
+
 def process_video_gradio(video_file, video_url, progress=gr.Progress()):
     global detector_instance
     
@@ -666,6 +683,78 @@ def compare_two_faces(face1, face2):
     except Exception as e:
         return f"❌ Hata: {str(e)}"
 
+def compare_videos_gradio(video1, video2, url1, url2, similarity_threshold, progress=gr.Progress()):
+    """
+    Gradio callback: İki videoyu karşılaştır
+    """
+    global comparator_instance
+    
+    # Comparator'ı başlat
+    comparator = initialize_comparator()
+    comparator.similarity_threshold = similarity_threshold
+    
+    def update_progress(value, message):
+        progress(value / 100, desc=message)
+    
+    comparator.set_progress_callback(update_progress)
+    
+    try:
+        progress(0, desc="Videolar hazırlanıyor...")
+        
+        # Video 1 kaynağını belirle
+        if url1 and url1.strip() and not IS_HUGGINGFACE:
+            video1_source = url1.strip()
+            is_v1_url = True
+        elif video1:
+            video1_source = video1
+            is_v1_url = False
+        else:
+            return [], "❌ Lütfen Video 1 yükleyin!", "❌ Video 1 eksik"
+        
+        # Video 2 kaynağını belirle
+        if url2 and url2.strip() and not IS_HUGGINGFACE:
+            video2_source = url2.strip()
+            is_v2_url = True
+        elif video2:
+            video2_source = video2
+            is_v2_url = False
+        else:
+            return [], "❌ Lütfen Video 2 yükleyin!", "❌ Video 2 eksik"
+        
+        # Hugging Face kontrolü
+        if IS_HUGGINGFACE and (is_v1_url or is_v2_url):
+            return [], "❌ Hugging Face Spaces'te URL desteği yok!", "❌ URL desteği yok"
+        
+        # Karşılaştırmayı yap
+        result, output_dir, saved_images = comparator.compare_videos(
+            video1_source,
+            video2_source,
+            is_video1_url=is_v1_url,
+            is_video2_url=is_v2_url
+        )
+        
+        # Rapor oluştur
+        report = comparator.generate_report(result)
+        
+        # Özet mesaj
+        summary = f"""
+✅ **Karşılaştırma Tamamlandı!**
+
+🎯 **Sonuçlar:**
+- Ortak Kişi: **{result.common_count}**
+- Sadece Video 1: **{len(result.only_video1)}**
+- Sadece Video 2: **{len(result.only_video2)}**
+
+📁 Çıktı: {output_dir}
+"""
+        
+        return saved_images, report, summary
+        
+    except Exception as e:
+        error_msg = f"❌ Hata: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        return [], error_msg, error_msg
+
 with gr.Blocks(title="Yüz Tanıma Sistemi", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
     # 🎭 Video Yüz Tanıma Sistemi
@@ -747,6 +836,126 @@ with gr.Blocks(title="Yüz Tanıma Sistemi", theme=gr.themes.Soft()) as demo:
                 outputs=compare_result
             )
         
+        with gr.Tab("🎬 Video Karşılaştır"):
+            gr.Markdown("""
+            ## İki Videoyu Karşılaştır
+            İki farklı videodan yüz tespiti yaparak ortak kişileri bulur
+            """)
+            
+            # Hugging Face uyarısı
+            if IS_HUGGINGFACE:
+                gr.Markdown("""
+                ⚠️ **Hugging Face Spaces Modunda**: URL/YouTube desteği kapalı. 
+                Sadece dosya yükleme kullanılabilir.
+                """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### 📹 Video 1")
+                    video1_input = gr.Video(
+                        label="Video 1 Yükle",
+                        height=250,
+                        show_label=True
+                    )
+                    
+                    if not IS_HUGGINGFACE:
+                        gr.Markdown("**VEYA**")
+                        url1_input = gr.Textbox(
+                            label="Video 1 URL",
+                            placeholder="https://example.com/video1.mp4",
+                            lines=1,
+                            interactive=True
+                        )
+                    else:
+                        url1_input = gr.Textbox(
+                            label="Video 1 URL (Devre Dışı)",
+                            placeholder="HF Spaces'te URL desteği yok",
+                            lines=1,
+                            interactive=False
+                        )
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("### 📹 Video 2")
+                    video2_input = gr.Video(
+                        label="Video 2 Yükle",
+                        height=250,
+                        show_label=True
+                    )
+                    
+                    if not IS_HUGGINGFACE:
+                        gr.Markdown("**VEYA**")
+                        url2_input = gr.Textbox(
+                            label="Video 2 URL",
+                            placeholder="https://example.com/video2.mp4",
+                            lines=1,
+                            interactive=True
+                        )
+                    else:
+                        url2_input = gr.Textbox(
+                            label="Video 2 URL (Devre Dışı)",
+                            placeholder="HF Spaces'te URL desteği yok",
+                            lines=1,
+                            interactive=False
+                        )
+            
+            # Ayarlar
+            with gr.Row():
+                similarity_slider = gr.Slider(
+                    minimum=0.4,
+                    maximum=0.9,
+                    value=0.6,
+                    step=0.05,
+                    label="🎯 Benzerlik Eşiği (Düşük = Daha fazla eşleşme)",
+                    info="İki yüzün aynı kişi olarak kabul edilmesi için minimum benzerlik oranı"
+                )
+            
+            compare_videos_btn = gr.Button("🔍 Videoları Karşılaştır", variant="primary", size="lg")
+            status_compare = gr.Textbox(label="Durum", interactive=False, lines=3)
+            
+            gr.Markdown("### 📊 Sonuçlar")
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    gallery_compare = gr.Gallery(
+                        label="Ortak Yüzler (Sol: Video 1, Sağ: Video 2)",
+                        columns=2,
+                        height=500,
+                        object_fit="contain"
+                    )
+                
+                with gr.Column(scale=1):
+                    report_compare = gr.Markdown(label="Detaylı Rapor")
+            
+            gr.Markdown("""
+            ### 💡 Nasıl Çalışır?
+            1. **İki video yükleyin** (veya URL girin)
+            2. **Benzerlik eşiğini ayarlayın** (varsayılan %60)
+            3. **Karşılaştır** butonuna tıklayın
+            4. Sistem her iki videodan yüz tespiti yapar ve ortak kişileri bulur
+            
+            ### 📈 Sonuç Kategorileri
+            - **Ortak Yüzler**: Her iki videoda da görünen kişiler (yan yana gösterilir)
+            - **Sadece Video 1**: Yalnızca ilk videoda görünen kişiler
+            - **Sadece Video 2**: Yalnızca ikinci videoda görünen kişiler
+            """)
+            
+            # Event handler
+            compare_videos_btn.click(
+                fn=compare_videos_gradio,
+                inputs=[
+                    video1_input,
+                    video2_input,
+                    url1_input,
+                    url2_input,
+                    similarity_slider
+                ],
+                outputs=[
+                    gallery_compare,
+                    report_compare,
+                    status_compare
+                ]
+            )
+
         with gr.Tab("⚙️ Ayarlar"):
             gr.Markdown("### Gelişmiş Ayarlar")
             

core/comparator.py

@@ -0,0 +1,423 @@
+"""
+Video Comparator Module
+İki videodan yüz tespiti yaparak ortak kişileri bulur
+"""
+
+import os
+import cv2
+import numpy as np
+from typing import List, Dict, Tuple, Optional
+from dataclasses import dataclass
+from sklearn.metrics.pairwise import cosine_similarity
+import logging
+from datetime import datetime
+import json
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ComparisonResult:
+    """Karşılaştırma sonuç verisi"""
+    common_faces: List[Dict]  # Her iki videoda da bulunan yüzler
+    only_video1: List[Dict]   # Sadece video 1'de bulunan yüzler
+    only_video2: List[Dict]   # Sadece video 2'de bulunan yüzler
+    total_unique_video1: int
+    total_unique_video2: int
+    common_count: int
+    similarity_threshold: float
+    metadata: Dict
+
+
+class VideoComparator:
+    """
+    İki videoyu karşılaştırarak ortak yüzleri bulur
+    Mevcut FaceDetector'ı kullanır
+    """
+    
+    def __init__(self, face_detector, similarity_threshold: float = 0.6):
+        """
+        Args:
+            face_detector: FaceDetector instance
+            similarity_threshold: Yüz benzerlik eşiği (0-1 arası, varsayılan 0.6)
+        """
+        self.detector = face_detector
+        self.similarity_threshold = similarity_threshold
+        self.progress_callback = None
+        
+    def set_progress_callback(self, callback):
+        """Progress callback fonksiyonu ayarla"""
+        self.progress_callback = callback
+        
+    def _update_progress(self, value: float, message: str):
+        """Progress güncelleme"""
+        if self.progress_callback:
+            self.progress_callback(value, message)
+    
+    def compare_videos(
+        self, 
+        video1_path: str, 
+        video2_path: str,
+        is_video1_url: bool = False,
+        is_video2_url: bool = False
+    ) -> Tuple[ComparisonResult, str, List[str]]:
+        """
+        İki videoyu karşılaştır ve ortak yüzleri bul
+        
+        Args:
+            video1_path: İlk video yolu veya URL
+            video2_path: İkinci video yolu veya URL
+            is_video1_url: İlk video URL mi?
+            is_video2_url: İkinci video URL mi?
+            
+        Returns:
+            Tuple[ComparisonResult, output_dir, saved_images]
+        """
+        try:
+            logger.info("Video karşılaştırma başlatılıyor...")
+            start_time = datetime.now()
+            
+            # Video 1'i işle
+            self._update_progress(0, "Video 1 işleniyor...")
+            logger.info(f"Video 1 işleniyor: {video1_path}")
+            
+            output_dir1, faces1, metadata1 = self.detector.detect_faces(
+                video1_path, 
+                is_url=is_video1_url
+            )
+            
+            video1_faces = self._load_face_data(output_dir1, metadata1)
+            logger.info(f"Video 1: {len(video1_faces)} benzersiz yüz bulundu")
+            
+            # Video 2'yi işle
+            self._update_progress(50, "Video 2 işleniyor...")
+            logger.info(f"Video 2 işleniyor: {video2_path}")
+            
+            output_dir2, faces2, metadata2 = self.detector.detect_faces(
+                video2_path,
+                is_url=is_video2_url
+            )
+            
+            video2_faces = self._load_face_data(output_dir2, metadata2)
+            logger.info(f"Video 2: {len(video2_faces)} benzersiz yüz bulundu")
+            
+            # Yüzleri karşılaştır
+            self._update_progress(80, "Yüzler karşılaştırılıyor...")
+            comparison_result = self._compare_face_sets(
+                video1_faces, 
+                video2_faces,
+                metadata1,
+                metadata2
+            )
+            
+            # Sonuçları kaydet
+            self._update_progress(90, "Sonuçlar kaydediliyor...")
+            output_dir, saved_images = self._save_comparison_results(
+                comparison_result,
+                output_dir1,
+                output_dir2
+            )
+            
+            elapsed_time = (datetime.now() - start_time).total_seconds()
+            logger.info(f"Karşılaştırma tamamlandı: {elapsed_time:.1f} saniye")
+            
+            self._update_progress(100, f"✅ Tamamlandı! {comparison_result.common_count} ortak yüz bulundu")
+            
+            return comparison_result, output_dir, saved_images
+            
+        except Exception as e:
+            logger.error(f"Video karşılaştırma hatası: {e}", exc_info=True)
+            raise
+    
+    def _load_face_data(self, output_dir: str, metadata: Dict) -> List[Dict]:
+        """
+        Bir videodan tespit edilen yüzleri yükle
+        
+        Returns:
+            List of dicts with 'embedding', 'face_path', 'cluster_id', 'quality_score'
+        """
+        faces = []
+        
+        for face_info in metadata['faces']:
+            face_path = os.path.join(output_dir, face_info['face_file'])
+            
+            if not os.path.exists(face_path):
+                logger.warning(f"Yüz dosyası bulunamadı: {face_path}")
+                continue
+            
+            # Yüz görselini oku ve embedding çıkar
+            face_img = cv2.imread(face_path)
+            embedding, _ = self.detector.extract_embeddings(face_img)
+            
+            if embedding is not None:
+                faces.append({
+                    'embedding': embedding,
+                    'face_path': face_path,
+                    'cluster_id': face_info['cluster_id'],
+                    'quality_score': face_info['quality_score'],
+                    'cluster_size': face_info.get('cluster_size', 1),
+                    'bbox': face_info.get('bbox', [])
+                })
+        
+        return faces
+    
+    def _compare_face_sets(
+        self, 
+        video1_faces: List[Dict], 
+        video2_faces: List[Dict],
+        metadata1: Dict,
+        metadata2: Dict
+    ) -> ComparisonResult:
+        """
+        İki video yüz setini karşılaştır
+        """
+        common_faces = []
+        only_video1 = []
+        only_video2 = []
+        
+        # Video 1'deki her yüz için Video 2'de eşleşme ara
+        matched_video2_indices = set()
+        
+        for v1_face in video1_faces:
+            best_match = None
+            best_similarity = 0
+            best_v2_idx = -1
+            
+            # Video 2'deki tüm yüzlerle karşılaştır
+            for v2_idx, v2_face in enumerate(video2_faces):
+                if v2_idx in matched_video2_indices:
+                    continue  # Zaten eşleşmiş
+                
+                similarity = cosine_similarity(
+                    [v1_face['embedding']], 
+                    [v2_face['embedding']]
+                )[0][0]
+                
+                if similarity > best_similarity:
+                    best_similarity = similarity
+                    best_match = v2_face
+                    best_v2_idx = v2_idx
+            
+            # Eşik üzerinde eşleşme var mı?
+            if best_similarity >= self.similarity_threshold and best_match:
+                matched_video2_indices.add(best_v2_idx)
+                common_faces.append({
+                    'video1_face': v1_face,
+                    'video2_face': best_match,
+                    'similarity': float(best_similarity),
+                    'match_id': len(common_faces)
+                })
+            else:
+                only_video1.append({
+                    'face': v1_face,
+                    'person_id': v1_face['cluster_id']
+                })
+        
+        # Video 2'de eşleşmeyen yüzler
+        for v2_idx, v2_face in enumerate(video2_faces):
+            if v2_idx not in matched_video2_indices:
+                only_video2.append({
+                    'face': v2_face,
+                    'person_id': v2_face['cluster_id']
+                })
+        
+        return ComparisonResult(
+            common_faces=common_faces,
+            only_video1=only_video1,
+            only_video2=only_video2,
+            total_unique_video1=len(video1_faces),
+            total_unique_video2=len(video2_faces),
+            common_count=len(common_faces),
+            similarity_threshold=self.similarity_threshold,
+            metadata={
+                'video1': {
+                    'path': metadata1['video_path'],
+                    'duration': metadata1['duration'],
+                    'fps': metadata1['fps']
+                },
+                'video2': {
+                    'path': metadata2['video_path'],
+                    'duration': metadata2['duration'],
+                    'fps': metadata2['fps']
+                },
+                'comparison_time': datetime.now().isoformat()
+            }
+        )
+    
+    def _save_comparison_results(
+        self,
+        result: ComparisonResult,
+        output_dir1: str,
+        output_dir2: str
+    ) -> Tuple[str, List[str]]:
+        """
+        Karşılaştırma sonuçlarını kaydet
+        
+        Returns:
+            Tuple[output_directory, list_of_saved_image_paths]
+        """
+        # Ana çıktı dizini oluştur
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_dir = os.path.join(
+            os.path.dirname(output_dir1),
+            f"comparison_{timestamp}"
+        )
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Alt dizinler
+        common_dir = os.path.join(output_dir, "common_faces")
+        only_v1_dir = os.path.join(output_dir, "only_video1")
+        only_v2_dir = os.path.join(output_dir, "only_video2")
+        
+        os.makedirs(common_dir, exist_ok=True)
+        os.makedirs(only_v1_dir, exist_ok=True)
+        os.makedirs(only_v2_dir, exist_ok=True)
+        
+        saved_images = []
+        
+        # Ortak yüzleri kaydet (yan yana)
+        for idx, match in enumerate(result.common_faces):
+            v1_img = cv2.imread(match['video1_face']['face_path'])
+            v2_img = cv2.imread(match['video2_face']['face_path'])
+            
+            # İki resmi yan yana birleştir
+            combined = np.hstack([v1_img, v2_img])
+            
+            # Benzerlik skorunu ekle
+            similarity = match['similarity']
+            cv2.putText(
+                combined, 
+                f"Similarity: {similarity:.2%}", 
+                (10, 30),
+                cv2.FONT_HERSHEY_SIMPLEX, 
+                0.7, 
+                (0, 255, 0), 
+                2
+            )
+            
+            output_path = os.path.join(common_dir, f"match_{idx:03d}.jpg")
+            cv2.imwrite(output_path, combined, [cv2.IMWRITE_JPEG_QUALITY, 95])
+            saved_images.append(output_path)
+        
+        # Sadece Video 1'de olan yüzler
+        for idx, item in enumerate(result.only_video1):
+            face_img = cv2.imread(item['face']['face_path'])
+            output_path = os.path.join(only_v1_dir, f"person_{idx:03d}.jpg")
+            cv2.imwrite(output_path, face_img, [cv2.IMWRITE_JPEG_QUALITY, 95])
+        
+        # Sadece Video 2'de olan yüzler
+        for idx, item in enumerate(result.only_video2):
+            face_img = cv2.imread(item['face']['face_path'])
+            output_path = os.path.join(only_v2_dir, f"person_{idx:03d}.jpg")
+            cv2.imwrite(output_path, face_img, [cv2.IMWRITE_JPEG_QUALITY, 95])
+        
+        # Metadata kaydet
+        metadata = {
+            'comparison_results': {
+                'common_count': result.common_count,
+                'only_video1_count': len(result.only_video1),
+                'only_video2_count': len(result.only_video2),
+                'total_video1': result.total_unique_video1,
+                'total_video2': result.total_unique_video2,
+                'similarity_threshold': result.similarity_threshold
+            },
+            'common_faces': [
+                {
+                    'match_id': m['match_id'],
+                    'similarity': m['similarity'],
+                    'video1_cluster_id': m['video1_face']['cluster_id'],
+                    'video2_cluster_id': m['video2_face']['cluster_id']
+                }
+                for m in result.common_faces
+            ],
+            'metadata': result.metadata
+        }
+        
+        metadata_path = os.path.join(output_dir, 'comparison_metadata.json')
+        with open(metadata_path, 'w', encoding='utf-8') as f:
+            json.dump(metadata, f, indent=2, ensure_ascii=False)
+        
+        logger.info(f"Karşılaştırma sonuçları kaydedildi: {output_dir}")
+        return output_dir, saved_images
+    
+    def generate_report(self, result: ComparisonResult) -> str:
+        """
+        Karşılaştırma raporu oluştur (Markdown formatında)
+        """
+        report = f"""
+# 🔍 Video Karşılaştırma Raporu
+
+## 📊 Özet Bilgiler
+
+| Metrik | Video 1 | Video 2 | Ortak |
+|--------|---------|---------|-------|
+| **Benzersiz Kişi** | {result.total_unique_video1} | {result.total_unique_video2} | {result.common_count} |
+| **Sadece Bu Videoda** | {len(result.only_video1)} | {len(result.only_video2)} | - |
+
+### 🎯 Karşılaştırma Parametreleri
+- **Benzerlik Eşiği**: {result.similarity_threshold:.0%}
+- **Ortak Kişi Oranı**: {(result.common_count / max(result.total_unique_video1, result.total_unique_video2) * 100):.1f}%
+
+---
+
+## 👥 Ortak Yüzler ({result.common_count} kişi)
+
+Her iki videoda da bulunan kişiler:
+
+"""
+        
+        for idx, match in enumerate(result.common_faces, 1):
+            similarity = match['similarity']
+            report += f"""
+**Kişi {idx}**
+- 🎯 Benzerlik Skoru: {similarity:.1%}
+- 📹 Video 1 Cluster ID: {match['video1_face']['cluster_id']}
+- 📹 Video 2 Cluster ID: {match['video2_face']['cluster_id']}
+"""
+        
+        if result.only_video1:
+            report += f"""
+
+---
+
+## 📹 Sadece Video 1'de Bulunanlar ({len(result.only_video1)} kişi)
+
+"""
+            for idx, item in enumerate(result.only_video1, 1):
+                report += f"- Kişi {idx} (Cluster ID: {item['person_id']})\n"
+        
+        if result.only_video2:
+            report += f"""
+
+---
+
+## 📹 Sadece Video 2'de Bulunanlar ({len(result.only_video2)} kişi)
+
+"""
+            for idx, item in enumerate(result.only_video2, 1):
+                report += f"- Kişi {idx} (Cluster ID: {item['person_id']})\n"
+        
+        report += """
+
+---
+
+## ℹ️ Video Bilgileri
+
+"""
+        
+        report += f"""
+### Video 1
+- **Yol**: {result.metadata['video1']['path']}
+- **Süre**: {result.metadata['video1']['duration']:.1f} saniye
+- **FPS**: {result.metadata['video1']['fps']}
+
+### Video 2
+- **Yol**: {result.metadata['video2']['path']}
+- **Süre**: {result.metadata['video2']['duration']:.1f} saniye
+- **FPS**: {result.metadata['video2']['fps']}
+
+---
+*Rapor Oluşturulma: {result.metadata['comparison_time']}*
+"""
+        
+        return report