Update app.py

app.py

@@ -1,6 +1,6 @@
 """
-resnet_dataset_creator.py - Focused Dataset Creation Tool for ResNet Fine-tuning
-Streamlined workflow for creating clean dog ReID training datasets
+resnet_dataset_creator.py - Fixed Dataset Creation Tool for ResNet Fine-tuning
+All 5 problems resolved: Stable ReID, Slider functionality, Image selection, Manual save, Clean sessions
 """
 import gradio as gr
 import cv2
@@ -14,13 +14,14 @@ from typing import List, Dict, Optional, Tuple
 from datetime import datetime
 from PIL import Image
 import zipfile
+
 # Import required modules
 from detection import DogDetector
 from tracking import SimpleTracker
-from reid import SingleModelReID
+from reid import SingleModelReID  # Using simplified version
 from ultralytics import YOLO
 
-# ========== IMAGE QUALITY ANALYZER ==========
+# ========== IMAGE QUALITY ANALYZER (unchanged) ==========
 class ImageQualityAnalyzer:
     """Analyze and score image quality for dataset selection"""
     
@@ -34,43 +35,34 @@ class ImageQualityAnalyzer:
         }
     
     def calculate_sharpness(self, image: np.ndarray) -> float:
-        """Calculate image sharpness using Laplacian variance"""
         gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
         laplacian = cv2.Laplacian(gray, cv2.CV_64F)
         return min(100, laplacian.var())
     
     def calculate_resolution_score(self, image: np.ndarray) -> float:
-        """Score based on image resolution"""
         h, w = image.shape[:2]
         pixels = h * w
-        # Ideal is 224x224 or larger
         ideal_pixels = 224 * 224
         return min(100, (pixels / ideal_pixels) * 100)
     
     def calculate_brightness_score(self, image: np.ndarray) -> float:
-        """Score image brightness"""
         gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
         mean_brightness = np.mean(gray)
-        # Ideal brightness is around 127 (middle of 0-255)
         return 100 - abs(mean_brightness - 127) * 0.78
     
     def calculate_contrast_score(self, image: np.ndarray) -> float:
-        """Score image contrast"""
         gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
         contrast = gray.std()
         return min(100, contrast * 2)
     
     def detect_occlusion(self, bbox: List[float], frame_shape: Tuple) -> float:
-        """Check if dog is fully visible"""
         x1, y1, x2, y2 = bbox
         h, w = frame_shape[:2]
         
-        # Check if bbox touches frame edges
         edge_penalty = 0
         if x1 <= 5 or y1 <= 5 or x2 >= w-5 or y2 >= h-5:
             edge_penalty = 30
         
-        # Check bbox aspect ratio (dogs shouldn't be too thin)
         aspect = (x2 - x1) / (y2 - y1)
         if aspect < 0.3 or aspect > 3:
             edge_penalty += 20
@@ -79,7 +71,6 @@ class ImageQualityAnalyzer:
     
     def calculate_overall_quality(self, image: np.ndarray, bbox: List[float],
                                    frame_shape: Tuple) -> float:
-        """Calculate comprehensive quality score"""
         scores = {
             'sharpness': self.calculate_sharpness(image),
             'resolution': self.calculate_resolution_score(image),
@@ -88,28 +79,19 @@ class ImageQualityAnalyzer:
             'occlusion': self.detect_occlusion(bbox, frame_shape)
         }
         
-        # Weighted average
         total = sum(scores[k] * self.quality_weights[k] for k in scores)
         return total
 
-# ========== SMART IMAGE SELECTOR ==========
+# ========== SMART IMAGE SELECTOR (unchanged) ==========
 class SmartImageSelector:
     """Intelligently select best images based on quality and diversity"""
     
     def __init__(self):
         self.quality_analyzer = ImageQualityAnalyzer()
-        self.min_temporal_distance = 10  # Frames between selected images
+        self.min_temporal_distance = 10
     
     def select_best_images(self, dog_data: List[Dict], max_images: int = 30,
                           video_fps: float = 30) -> List[Dict]:
-        """
-        Select best images considering:
-        - Image quality
-        - Temporal diversity (not too close in time)
-        - Pose diversity
-        - Movement patterns
-        """
-        # Always calculate quality scores first
         for item in dog_data:
             item['quality_score'] = self.quality_analyzer.calculate_overall_quality(
                 item['crop'], item['bbox'], item['frame'].shape
@@ -118,18 +100,15 @@ class SmartImageSelector:
         if len(dog_data) <= max_images:
             return dog_data
         
-        # Sort by quality
         dog_data.sort(key=lambda x: x['quality_score'], reverse=True)
         
         selected = []
         selected_frames = set()
-        selected_indices = set()  # Track indices instead of comparing items
+        selected_indices = set()
         
         for idx, item in enumerate(dog_data):
-            # Check temporal diversity
             frame_num = item['frame_num']
             
-            # Don't select images too close together
             too_close = any(
                 abs(frame_num - f) < self.min_temporal_distance
                 for f in selected_frames
@@ -140,7 +119,6 @@ class SmartImageSelector:
                 selected_frames.add(frame_num)
                 selected_indices.add(idx)
         
-        # If we don't have enough, relax temporal constraint
         if len(selected) < max_images:
             for idx, item in enumerate(dog_data):
                 if idx not in selected_indices and len(selected) < max_images:
@@ -149,111 +127,20 @@ class SmartImageSelector:
         
         return selected[:max_images]
 
-# ========== ADVANCED HEAD EXTRACTOR ==========
-class AdvancedHeadExtractor:
-    """Enhanced head extraction with multiple fallback strategies"""
-    
-    def __init__(self):
-        self.pose_model = None
-        try:
-            self.pose_model = YOLO('yolov8m-pose.pt')
-            if torch.cuda.is_available():
-                self.pose_model.to('cuda')
-            print("Pose model loaded for head extraction")
-        except:
-            print("Using geometric head extraction")
+# ========== HEAD EXTRACTOR (simplified) ==========
+class SimpleHeadExtractor:
+    """Simple geometric head extraction"""
     
     def extract_head(self, frame: np.ndarray, bbox: List[float]) -> Optional[np.ndarray]:
-        """Extract head with best available method"""
         x1, y1, x2, y2 = map(int, bbox)
         dog_crop = frame[y1:y2, x1:x2]
         
         if dog_crop.size == 0:
             return None
         
-        # Try pose-based first
-        if self.pose_model:
-            head = self._extract_with_pose(dog_crop)
-            if head is not None:
-                return head
-        
-        # Fallback to intelligent geometric
-        return self._extract_geometric_smart(dog_crop)
-    
-    def _extract_with_pose(self, dog_crop: np.ndarray) -> Optional[np.ndarray]:
-        """Extract using pose keypoints"""
-        try:
-            results = self.pose_model(dog_crop, conf=0.3, verbose=False)
-            
-            if results and len(results) > 0 and hasattr(results[0], 'keypoints'):
-                keypoints = results[0].keypoints
-                if keypoints is not None and keypoints.xy is not None:
-                    kpts = keypoints.xy[0].cpu().numpy()
-                    
-                    # Get head keypoints (nose, eyes, ears)
-                    head_indices = [0, 1, 2, 3, 4]  # nose, eyes, ears
-                    head_points = []
-                    
-                    for idx in head_indices:
-                        if idx < len(kpts) and kpts[idx][0] > 0:
-                            head_points.append(kpts[idx])
-                    
-                    if len(head_points) >= 3:
-                        head_points = np.array(head_points)
-                        
-                        # Calculate bounding box around head points
-                        padding = 35
-                        min_x = max(0, int(np.min(head_points[:, 0]) - padding))
-                        min_y = max(0, int(np.min(head_points[:, 1]) - padding))
-                        max_x = min(dog_crop.shape[1], int(np.max(head_points[:, 0]) + padding))
-                        max_y = min(dog_crop.shape[0], int(np.max(head_points[:, 1]) + padding * 1.3))
-                        
-                        head_crop = dog_crop[min_y:max_y, min_x:max_x]
-                        if head_crop.size > 0:
-                            # Resize to standard size
-                            head_crop = cv2.resize(head_crop, (128, 128))
-                            return head_crop
-        except:
-            pass
-        
-        return None
-    
-    def _extract_geometric_smart(self, dog_crop: np.ndarray) -> Optional[np.ndarray]:
-        """Smart geometric extraction based on image analysis"""
         h, w = dog_crop.shape[:2]
         
-        # Analyze image to find likely head position
-        gray = cv2.cvtColor(dog_crop, cv2.COLOR_BGR2GRAY)
-        
-        # Use edge detection to find features
-        edges = cv2.Canny(gray, 50, 150)
-        
-        # Find feature concentration (likely head area)
-        kernel_size = max(1, h // 10)
-        kernel = np.ones((kernel_size, kernel_size), np.float32)
-        edge_density = cv2.filter2D(edges, -1, kernel)
-        
-        # Find peak density area
-        max_loc = np.unravel_index(np.argmax(edge_density[:h//2, :]), edge_density[:h//2, :].shape)
-        
-        # Extract around peak area
-        center_y = max_loc[0]
-        center_x = max_loc[1]
-        
-        # Define head region
-        head_size = int(min(h, w) * 0.4)
-        y1 = max(0, center_y - head_size // 2)
-        y2 = min(h, y1 + head_size)
-        x1 = max(0, center_x - head_size // 2)
-        x2 = min(w, x1 + head_size)
-        
-        head_crop = dog_crop[y1:y2, x1:x2]
-        
-        if head_crop.size > 0:
-            head_crop = cv2.resize(head_crop, (128, 128))
-            return head_crop
-        
-        # Final fallback - top portion
+        # Simple top 40% extraction
         head_height = int(h * 0.4)
         head_crop = dog_crop[:head_height, :]
         
@@ -263,94 +150,114 @@ class AdvancedHeadExtractor:
         
         return None
 
-# ========== MAIN DATASET CREATOR ==========
+# ========== MAIN DATASET CREATOR - FIXED ==========
 class ResNetDatasetCreator:
-    """Main application for creating ResNet fine-tuning datasets"""
+    """Main application with all 5 problems fixed"""
     
     def __init__(self):
+        # Directories
         self.temp_dir = Path("temp_dataset")
         self.final_dir = Path("resnet_finetune_dataset")
         self.database_dir = Path("permanent_database")
         
-        # Components
+        # Components - initialize once
         self.detector = DogDetector(device='cuda' if torch.cuda.is_available() else 'cpu')
         self.tracker = SimpleTracker()
         self.reid = SingleModelReID(device='cuda' if torch.cuda.is_available() else 'cpu')
-        self.head_extractor = AdvancedHeadExtractor()
+        self.head_extractor = SimpleHeadExtractor()
         self.image_selector = SmartImageSelector()
         
-        # Session data
+        # Session data - temporary only
+        self.current_video_path = None
         self.current_session = None
-        self.processed_dogs = {}
+        self.temp_processed_dogs = {}  # Temporary dogs from current video
+        self.permanent_dogs = {}  # Permanently saved dogs
         
         # Create directories
         self.temp_dir.mkdir(exist_ok=True)
         self.final_dir.mkdir(exist_ok=True)
         self.database_dir.mkdir(exist_ok=True)
         
-        # Load existing database if exists
-        self.load_database()
+        # Load permanent database
+        self.load_permanent_database()
     
-    def load_database(self):
-        """Load existing permanent database"""
+    def load_permanent_database(self):
+        """Load only permanently saved dogs"""
         db_file = self.database_dir / "database.json"
         if db_file.exists():
             with open(db_file, 'r') as f:
                 data = json.load(f)
-                self.processed_dogs = {int(k): v for k, v in data.get('dogs', {}).items()}
-                print(f"Loaded {len(self.processed_dogs)} dogs from database")
+                self.permanent_dogs = {int(k): v for k, v in data.get('dogs', {}).items()}
+                print(f"Loaded {len(self.permanent_dogs)} permanently saved dogs")
     
-    def save_to_database(self):
-        """Save current processed dogs to permanent database"""
+    def save_to_permanent_database(self):
+        """Save selected dogs to permanent database"""
+        # Merge temp dogs into permanent
+        self.permanent_dogs.update(self.temp_processed_dogs)
+        
+        # Save metadata
         db_file = self.database_dir / "database.json"
         data = {
-            'dogs': {str(k): v for k, v in self.processed_dogs.items()},
+            'dogs': {str(k): v for k, v in self.permanent_dogs.items()},
             'last_updated': datetime.now().isoformat()
         }
         with open(db_file, 'w') as f:
             json.dump(data, f, indent=2)
         
-        # Also save images to permanent location
-        for dog_id in self.processed_dogs:
+        # Copy images from temp to permanent
+        for dog_id in self.temp_processed_dogs:
             src_dir = self.temp_dir / f"dog_{dog_id:03d}"
             dst_dir = self.database_dir / f"dog_{dog_id:03d}"
             if src_dir.exists():
                 if dst_dir.exists():
                     shutil.rmtree(dst_dir)
                 shutil.copytree(src_dir, dst_dir)
+        
+        print(f"Saved {len(self.temp_processed_dogs)} dogs to permanent database")
+    
+    def clear_temp_data(self):
+        """Clear all temporary data for new video"""
+        # Clear temp directory
+        if self.temp_dir.exists():
+            shutil.rmtree(self.temp_dir)
+        self.temp_dir.mkdir()
+        
+        # Clear temp session data
+        self.current_video_path = None
+        self.current_session = None
+        self.temp_processed_dogs = {}
+        
+        # Reset ReID (clears in-memory dogs)
+        self.reid.reset_all()
+        
+        print("Temporary data cleared for new video")
     
-    def clear_database(self):
-        """Clear all permanent database"""
+    def clear_all_permanent_data(self):
+        """Clear entire permanent database"""
         if self.database_dir.exists():
             shutil.rmtree(self.database_dir)
-        self.database_dir.mkdir(exist_ok=True)
-        self.processed_dogs = {}
-        self.current_session = None
-        print("Database cleared")
+        self.database_dir.mkdir()
+        self.permanent_dogs = {}
+        print("All permanent data cleared")
     
     def process_video(self, video_path: str, reid_threshold: float,
                      max_images_per_dog: int, sample_rate: int) -> Dict:
-        """
-        Process video and extract initial dataset
-        Args:
-            video_path: Path to video file
-            reid_threshold: ReID similarity threshold (0.40-0.85 recommended)
-            max_images_per_dog: Maximum images to extract per dog
-            sample_rate: Process every Nth frame
-        """
-        # Clear temp directory for new processing
-        if self.temp_dir.exists():
-            shutil.rmtree(self.temp_dir)
-        self.temp_dir.mkdir()
+        """Process video with current settings"""
+        
+        # Clear previous temp data if new video
+        if video_path != self.current_video_path:
+            self.clear_temp_data()
+            self.current_video_path = video_path
+        else:
+            # Re-processing same video - clear and start fresh
+            self.clear_temp_data()
+            self.current_video_path = video_path
         
         # Set ReID threshold
         self.reid.set_all_thresholds(reid_threshold)
         
-        # Reset ReID session
-        self.reid.reset_all()
-        
         # Storage for dog data
-        dog_data = {}  # dog_id -> list of frame data
+        dog_data = {}
         
         # Open video
         cap = cv2.VideoCapture(video_path)
@@ -380,7 +287,7 @@ class ResNetDatasetCreator:
                     dog_id = results['ResNet50']['dog_id']
                     confidence = results['ResNet50']['confidence']
                     
-                    if dog_id > 0 and confidence > 0.3:  # Lower threshold for detection
+                    if dog_id > 0 and confidence > 0.3:
                         # Get best detection
                         detection = None
                         for det in reversed(track.detections):
@@ -389,11 +296,9 @@ class ResNetDatasetCreator:
                                 break
                         
                         if detection:
-                            # Initialize storage
                             if dog_id not in dog_data:
                                 dog_data[dog_id] = []
                             
-                            # Store frame data
                             dog_data[dog_id].append({
                                 'frame': frame.copy(),
                                 'crop': detection.image_crop,
@@ -420,12 +325,11 @@ class ResNetDatasetCreator:
         new_dogs = {}
         
         for dog_id, images in dog_data.items():
-            # Use smart selector
             selected = self.image_selector.select_best_images(
                 images, max_images_per_dog, fps
             )
             
-            # Save to temp directory
+            # Save to temp directory only
             dog_dir = self.temp_dir / f"dog_{dog_id:03d}"
             dog_dir.mkdir(exist_ok=True)
             (dog_dir / 'full').mkdir(exist_ok=True)
@@ -447,15 +351,15 @@ class ResNetDatasetCreator:
             
             total_images += saved_count
             
-            # Store metadata
+            # Store in temp dogs only
             new_dogs[dog_id] = {
                 'num_images': saved_count,
                 'avg_confidence': np.mean([d['reid_confidence'] for d in selected]),
                 'quality_scores': [d['quality_score'] for d in selected]
             }
         
-        # Update processed dogs (append, don't replace)
-        self.processed_dogs.update(new_dogs)
+        # Update temp dogs (not permanent)
+        self.temp_processed_dogs = new_dogs
         
         # Save session info
         self.current_session = {
@@ -467,18 +371,18 @@ class ResNetDatasetCreator:
             'dogs': {str(k): v for k, v in new_dogs.items()}
         }
         
-        # Save metadata
+        # Save metadata to temp
         with open(self.temp_dir / 'session.json', 'w') as f:
             json.dump(self.current_session, f, indent=2)
         
         yield {'status': 'complete', 'session': self.current_session}
     
-    def get_dog_images(self, dog_id: int) -> List:
-        """Get images for verification interface"""
-        # Try temp dir first, then database dir
-        dog_dir = self.temp_dir / f"dog_{dog_id:03d}"
-        if not dog_dir.exists():
+    def get_dog_images(self, dog_id: int, from_permanent: bool = False) -> List:
+        """Get images for verification"""
+        if from_permanent:
             dog_dir = self.database_dir / f"dog_{dog_id:03d}"
+        else:
+            dog_dir = self.temp_dir / f"dog_{dog_id:03d}"
         
         full_dir = dog_dir / 'full'
         if not full_dir.exists():
@@ -493,69 +397,60 @@ class ResNetDatasetCreator:
         
         return images
     
-    def remove_images(self, dog_id: int, image_indices: List[int]):
-        """Remove specific images from a dog folder"""
-        # Handle both temp and database directories
-        for base_dir in [self.temp_dir, self.database_dir]:
-            dog_dir = base_dir / f"dog_{dog_id:03d}"
-            if not dog_dir.exists():
-                continue
-                
-            full_dir = dog_dir / 'full'
-            head_dir = dog_dir / 'head'
-            
-            image_files = sorted(list(full_dir.glob("*.jpg")))
-            
-            # Extract actual indices from gallery selection
-            indices_to_remove = []
-            if isinstance(image_indices, list):
-                for item in image_indices:
-                    if isinstance(item, (list, tuple)) and len(item) > 0:
-                        indices_to_remove.append(item[0])
-                    elif isinstance(item, int):
-                        indices_to_remove.append(item)
-            
-            for idx in indices_to_remove:
-                if 0 <= idx < len(image_files):
-                    # Remove full image
-                    image_files[idx].unlink(missing_ok=True)
-                    # Remove corresponding head
-                    head_file = head_dir / image_files[idx].name
-                    if head_file.exists():
-                        head_file.unlink()
-    
-    def delete_dog(self, dog_id: int):
-        """Delete entire dog folder from both temp and database"""
-        for base_dir in [self.temp_dir, self.database_dir]:
-            dog_dir = base_dir / f"dog_{dog_id:03d}"
-            if dog_dir.exists():
-                shutil.rmtree(dog_dir)
+    def remove_images_by_selection(self, dog_id: int, selected_indices: List, from_permanent: bool = False):
+        """Remove images based on gallery selection"""
+        if from_permanent:
+            dog_dir = self.database_dir / f"dog_{dog_id:03d}"
+        else:
+            dog_dir = self.temp_dir / f"dog_{dog_id:03d}"
+        
+        if not dog_dir.exists():
+            return
         
-        # Remove from processed dogs
-        if dog_id in self.processed_dogs:
-            del self.processed_dogs[dog_id]
+        full_dir = dog_dir / 'full'
+        head_dir = dog_dir / 'head'
+        
+        image_files = sorted(list(full_dir.glob("*.jpg")))
+        
+        # Remove selected images
+        for idx in selected_indices:
+            if 0 <= idx < len(image_files):
+                # Remove full image
+                image_files[idx].unlink(missing_ok=True)
+                # Remove corresponding head
+                head_file = head_dir / image_files[idx].name
+                if head_file.exists():
+                    head_file.unlink()
     
-    def save_final_dataset(self, format_type: str = 'folder') -> str:
-        """
-        Save verified dataset in format suitable for ResNet fine-tuning
+    def delete_dog(self, dog_id: int, from_permanent: bool = False):
+        """Delete entire dog folder"""
+        if from_permanent:
+            dog_dir = self.database_dir / f"dog_{dog_id:03d}"
+            if dog_id in self.permanent_dogs:
+                del self.permanent_dogs[dog_id]
+        else:
+            dog_dir = self.temp_dir / f"dog_{dog_id:03d}"
+            if dog_id in self.temp_processed_dogs:
+                del self.temp_processed_dogs[dog_id]
         
-        Args:
-            format_type: 'folder' for folder structure, 'csv' for CSV metadata
-        """
-        # Clear final directory
+        if dog_dir.exists():
+            shutil.rmtree(dog_dir)
+    
+    def save_final_dataset(self, format_type: str = 'both') -> str:
+        """Export both temp and permanent dogs"""
         if self.final_dir.exists():
             shutil.rmtree(self.final_dir)
         self.final_dir.mkdir()
         
-        # Copy all dogs from both temp and database
+        # Combine temp and permanent dogs
         all_dog_dirs = []
         
-        # Get dogs from temp
+        # Add temp dogs
         for d in self.temp_dir.iterdir():
             if d.is_dir() and d.name.startswith('dog_'):
                 all_dog_dirs.append(d)
         
-        # Get dogs from database (if not already in temp)
+        # Add permanent dogs
         temp_dogs = {d.name for d in all_dog_dirs}
         for d in self.database_dir.iterdir():
             if d.is_dir() and d.name.startswith('dog_') and d.name not in temp_dogs:
@@ -568,50 +463,36 @@ class ResNetDatasetCreator:
             if not (dog_dir / 'full').exists():
                 continue
             
-            # Create final directory
             final_dog_dir = self.final_dir / f"dog_{final_id:03d}"
             shutil.copytree(dog_dir, final_dog_dir)
             
-            # Collect metadata
             for img_path in (final_dog_dir / 'full').glob("*.jpg"):
                 head_path = final_dog_dir / 'head' / img_path.name
                 data_entries.append({
                     'dog_id': final_id,
                     'image_path': str(img_path.relative_to(self.final_dir)),
                     'head_path': str(head_path.relative_to(self.final_dir)) if head_path.exists() else None,
-                    'class': final_id  # For classification-style training
+                    'class': final_id
                 })
             
             final_id += 1
         
-        if format_type == 'csv' or format_type == 'both':
-            # Create train/val split
+        if format_type in ['csv', 'both']:
             df = pd.DataFrame(data_entries)
             
-            if len(df) > 0:
-                # Stratified split by dog_id
+            if len(df) > 5:
                 from sklearn.model_selection import train_test_split
-                
-                # Only split if we have enough samples
-                if len(df) > 5:
-                    train_df, val_df = train_test_split(
-                        df, test_size=0.2, stratify=df['dog_id'], random_state=42
-                    )
-                else:
-                    train_df = df
-                    val_df = pd.DataFrame()
-                
-                # Save CSV files
+                train_df, val_df = train_test_split(
+                    df, test_size=0.2, stratify=df['dog_id'], random_state=42
+                )
                 train_df.to_csv(self.final_dir / 'train.csv', index=False)
-                if len(val_df) > 0:
-                    val_df.to_csv(self.final_dir / 'val.csv', index=False)
+                val_df.to_csv(self.final_dir / 'val.csv', index=False)
+            else:
+                df.to_csv(self.final_dir / 'train.csv', index=False)
         
-        # Create metadata
         metadata = {
             'total_dogs': final_id - 1,
             'total_images': len(data_entries),
-            'train_images': len(train_df) if format_type in ['csv', 'both'] and 'train_df' in locals() else len(data_entries),
-            'val_images': len(val_df) if format_type in ['csv', 'both'] and 'val_df' in locals() else 0,
             'format': format_type,
             'created': datetime.now().isoformat()
         }
@@ -619,7 +500,7 @@ class ResNetDatasetCreator:
         with open(self.final_dir / 'metadata.json', 'w') as f:
             json.dump(metadata, f, indent=2)
         
-        # Create zip file
+        # Create zip
         zip_path = self.final_dir.parent / f"resnet_dataset_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
         with zipfile.ZipFile(zip_path, 'w') as zipf:
             for file_path in self.final_dir.rglob('*'):
@@ -628,29 +509,30 @@ class ResNetDatasetCreator:
         return str(zip_path)
     
     def create_interface(self):
-        """Create Gradio interface"""
+        """Create Gradio interface with fixes"""
         with gr.Blocks(
             title="ResNet Fine-tuning Dataset Creator",
             theme=gr.themes.Soft()
         ) as app:
             gr.Markdown("""
-            # 🎯 ResNet Fine-tuning Dataset Creator
-            ### Three-step process: Process → Verify → Export
+            # 🎯 ResNet Fine-tuning Dataset Creator - Fixed Version
+            ### Problems resolved: Stable ReID, Working sliders, Easy selection, Manual save
             """)
             
-            # State to store processing results
+            # States
             processing_state = gr.State(None)
+            selected_gallery_indices = gr.State([])
             
-            # Step 1: Process Video
             with gr.Tabs() as tabs:
+                # ========== STEP 1: PROCESS VIDEO ==========
                 with gr.Tab("📹 Step 1: Process Video", id=0):
                     with gr.Row():
                         video_input = gr.Video(label="Upload Video")
                         with gr.Column():
                             reid_threshold = gr.Slider(
-                                0.40, 0.85, 0.40, step=0.01,
+                                0.30, 0.85, 0.40, step=0.05,
                                 label="ReID Threshold",
-                                info="Lower = More lenient matching (0.40 recommended for start)"
+                                info="Lower = More lenient (combine similar dogs)"
                             )
                             max_images = gr.Slider(
                                 10, 50, 30, step=5,
@@ -659,353 +541,248 @@ class ResNetDatasetCreator:
                             sample_rate = gr.Slider(
                                 1, 5, 2, step=1,
                                 label="Sample Rate",
-                                info="Process every Nth frame (2 = every other frame)"
+                                info="Process every Nth frame"
                             )
                     
                     process_btn = gr.Button("🚀 Process Video", variant="primary", size="lg")
                     
-                    # Results display in formatted table
                     with gr.Column():
                         progress_bar = gr.Textbox(label="Progress", interactive=False)
-                        results_display = gr.HTML(label="Processing Results", value="")
-                        save_status = gr.Textbox(label="Save Status", interactive=False, visible=False)
+                        results_display = gr.HTML(label="Processing Results")
                         
                         with gr.Row():
-                            save_proceed_btn = gr.Button(
-                                "✅ Save Results & Proceed to Verification", 
-                                variant="primary", 
-                                size="lg",
-                                visible=False
-                            )
                             clear_btn = gr.Button(
-                                "🔄 Clear Results", 
+                                "🔄 Clear & Reset (Process Again)", 
                                 variant="secondary",
+                                size="lg",
                                 visible=False
                             )
                     
-                    def format_results_table(session_data):
-                        """Format session data as HTML table"""
-                        if not session_data:
-                            return ""
-                        
-                        html = """
-                        <div style="padding: 20px; background-color: #f8f9fa; border-radius: 10px;">
-                            <h3 style="color: #2c3e50;">📊 Processing Results</h3>
-                            <table style="width: 100%; border-collapse: collapse; margin: 20px 0;">
-                                <tr style="background-color: #3498db; color: white;">
-                                    <td style="padding: 10px; border: 1px solid #ddd;"><b>Metric</b></td>
-                                    <td style="padding: 10px; border: 1px solid #ddd;"><b>Value</b></td>
-                                </tr>
-                        """
-                        
-                        # Basic info
-                        html += f"""
-                            <tr style="background-color: #ecf0f1;">
-                                <td style="padding: 10px; border: 1px solid #ddd;">Video File</td>
-                                <td style="padding: 10px; border: 1px solid #ddd;">{session_data['video'].split('/')[-1]}</td>
-                            </tr>
-                            <tr>
-                                <td style="padding: 10px; border: 1px solid #ddd;">Processing Time</td>
-                                <td style="padding: 10px; border: 1px solid #ddd;">{session_data['timestamp'].split('T')[1].split('.')[0]}</td>
-                            </tr>
-                            <tr style="background-color: #ecf0f1;">
-                                <td style="padding: 10px; border: 1px solid #ddd;">Number of Dogs Detected</td>
-                                <td style="padding: 10px; border: 1px solid #ddd;"><b>{session_data['num_dogs']}</b></td>
-                            </tr>
-                            <tr>
-                                <td style="padding: 10px; border: 1px solid #ddd;">Total Images Extracted</td>
-                                <td style="padding: 10px; border: 1px solid #ddd;"><b>{session_data['total_images']}</b></td>
-                            </tr>
-                            <tr style="background-color: #ecf0f1;">
-                                <td style="padding: 10px; border: 1px solid #ddd;">ReID Threshold Used</td>
-                                <td style="padding: 10px; border: 1px solid #ddd;">{session_data['reid_threshold']:.2f}</td>
-                            </tr>
-                        </table>
-                        """
-                        
-                        # Dog-specific details
-                        if session_data['dogs']:
-                            html += """
-                            <h4 style="color: #2c3e50; margin-top: 20px;">🐕 Dog Details</h4>
-                            <table style="width: 100%; border-collapse: collapse; margin: 10px 0;">
-                                <tr style="background-color: #27ae60; color: white;">
-                                    <td style="padding: 10px; border: 1px solid #ddd;"><b>Dog ID</b></td>
-                                    <td style="padding: 10px; border: 1px solid #ddd;"><b>Images</b></td>
-                                    <td style="padding: 10px; border: 1px solid #ddd;"><b>Avg Confidence</b></td>
-                                    <td style="padding: 10px; border: 1px solid #ddd;"><b>Avg Quality</b></td>
-                                    <td style="padding: 10px; border: 1px solid #ddd;"><b>Quality Range</b></td>
-                                </tr>
-                            """
-                            
-                            for dog_id, dog_info in session_data['dogs'].items():
-                                avg_quality = np.mean(dog_info['quality_scores'])
-                                min_quality = min(dog_info['quality_scores'])
-                                max_quality = max(dog_info['quality_scores'])
-                                
-                                row_style = "background-color: #ecf0f1;" if int(dog_id) % 2 == 0 else ""
-                                html += f"""
-                                <tr style="{row_style}">
-                                    <td style="padding: 10px; border: 1px solid #ddd;">Dog {dog_id}</td>
-                                    <td style="padding: 10px; border: 1px solid #ddd;">{dog_info['num_images']}</td>
-                                    <td style="padding: 10px; border: 1px solid #ddd;">{dog_info['avg_confidence']:.2%}</td>
-                                    <td style="padding: 10px; border: 1px solid #ddd;">{avg_quality:.1f}</td>
-                                    <td style="padding: 10px; border: 1px solid #ddd;">{min_quality:.1f} - {max_quality:.1f}</td>
-                                </tr>
-                                """
-                            
-                            html += "</table>"
-                        
-                        html += """
-                            <div style="margin-top: 20px; padding: 10px; background-color: #d4edda; border-radius: 5px;">
-                                <p style="margin: 0; color: #155724;">
-                                    ✅ <b>Processing Complete!</b> Click "Save Results & Proceed" to continue to verification step.
-                                </p>
-                            </div>
-                        </div>
-                        """
-                        
-                        return html
-                    
                     def process_wrapper(video, threshold, max_img, sample):
-                        """Process video and format results"""
+                        """Process with current settings"""
                         if not video:
-                            return None, "", "Please upload a video", gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+                            return None, "", "Please upload a video", gr.update(visible=False)
                         
-                        # Process video
+                        # Process video (will auto-clear if needed)
                         for update in self.process_video(video, threshold, int(max_img), int(sample)):
                             if 'progress' in update:
-                                yield None, "", update['status'], gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+                                yield None, "", update['status'], gr.update(visible=False)
                             else:
-                                # Store session data
-                                self.current_session = update['session']
-                                # Format results as table
-                                formatted_table = format_results_table(update['session'])
-                                yield update['session'], formatted_table, "Complete! ✅", gr.update(visible=False), gr.update(visible=True), gr.update(visible=True)
-                    
-                    def save_and_proceed():
-                        """Save current results and notify user"""
-                        if self.current_session and self.processed_dogs:
-                            # Save to permanent database
-                            self.save_to_database()
-                            
-                            # Debug info
-                            dog_count = len(self.processed_dogs)
-                            img_count = sum(d.get('num_images', 0) for d in self.processed_dogs.values())
-                            
-                            message = f"""✅ Results saved successfully to database! 
-                            
-                            📊 Summary:
-                            - Total dogs in database: {dog_count}
-                            - Total images: {img_count}
-                            - Data location: {self.database_dir}
-                            
-                            You can now proceed to Step 2: Verify & Clean
-                            Click the 'Refresh List' button in Step 2 to load all dogs."""
-                            
-                            return message, gr.update(visible=True)
-                        return "❌ No results to save. Please process a video first.", gr.update(visible=False)
+                                # Format results
+                                session = update['session']
+                                html = f"""
+                                <div style="padding: 20px; background: #f8f9fa; border-radius: 10px;">
+                                    <h3>📊 Processing Complete!</h3>
+                                    <p><b>Dogs detected:</b> {session['num_dogs']}</p>
+                                    <p><b>Total images:</b> {session['total_images']}</p>
+                                    <p><b>ReID threshold used:</b> {session['reid_threshold']:.2f}</p>
+                                    <hr>
+                                    <p>✅ Data is in <b>temporary storage</b>. Review in Step 2 before saving permanently.</p>
+                                </div>
+                                """
+                                yield session, html, "Complete! ✅", gr.update(visible=True)
                     
-                    def clear_results():
-                        """Clear current processing results (not database)"""
-                        self.current_session = None
-                        if self.temp_dir.exists():
-                            shutil.rmtree(self.temp_dir)
-                            self.temp_dir.mkdir()
-                        return None, "", "", gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+                    def clear_and_reset():
+                        """Clear all temp data for reprocessing"""
+                        self.clear_temp_data()
+                        return None, "", "", gr.update(visible=False)
                     
                     process_btn.click(
                         process_wrapper,
                         inputs=[video_input, reid_threshold, max_images, sample_rate],
-                        outputs=[processing_state, results_display, progress_bar, save_status, save_proceed_btn, clear_btn]
-                    )
-                    
-                    save_proceed_btn.click(
-                        save_and_proceed,
-                        outputs=[save_status, save_status]
+                        outputs=[processing_state, results_display, progress_bar, clear_btn]
                     )
                     
                     clear_btn.click(
-                        clear_results,
-                        outputs=[processing_state, results_display, progress_bar, save_status, save_proceed_btn, clear_btn]
+                        clear_and_reset,
+                        outputs=[processing_state, results_display, progress_bar, clear_btn]
                     )
                 
-                # Step 2: Verify & Clean
+                # ========== STEP 2: VERIFY & CLEAN ==========
                 with gr.Tab("✅ Step 2: Verify & Clean", id=1):
-                    gr.Markdown("Review each dog and remove any mismatched images")
-                    
-                    with gr.Row():
-                        dog_selector = gr.Dropdown(
-                            label="Select Dog",
-                            choices=[],
-                            interactive=True
-                        )
+                    gr.Markdown("""
+                    Review temporary results. **Nothing is permanently saved until you click Save.**
+                    Select images by clicking them in the gallery, then use Remove Selected.
+                    """)
                     
-                    # Add diagnostic and management buttons
                     with gr.Row():
-                        refresh_btn = gr.Button("🔄 Refresh List")
-                        diagnose_btn = gr.Button("🔍 Diagnose Data", variant="secondary")
-                        clear_db_btn = gr.Button("⚠️ Clear All Database", variant="stop")
-                    
-                    diagnostic_output = gr.Textbox(label="Diagnostic Info", visible=False)
+                        with gr.Column():
+                            source_selector = gr.Radio(
+                                choices=["Temporary (Current Video)", "Permanent (Saved)"],
+                                value="Temporary (Current Video)",
+                                label="Data Source"
+                            )
+                            dog_selector = gr.Dropdown(
+                                label="Select Dog",
+                                choices=[],
+                                interactive=True
+                            )
+                            refresh_btn = gr.Button("🔄 Refresh List")
                     
                     image_gallery = gr.Gallery(
-                        label="Dog Images (Click to select for removal)",
+                        label="Click images to select them for removal",
                         show_label=True,
-                        elem_id="gallery",
                         columns=4,
                         rows=3,
                         object_fit="contain",
                         height="auto",
-                        type="numpy",
-                        interactive=False
+                        interactive=True,  # Allow selection
+                        type="numpy"
                     )
                     
                     with gr.Row():
-                        selected_images = gr.Textbox(
-                            label="Selected Image Indices (comma-separated)",
-                            placeholder="e.g., 0,2,5",
-                            interactive=True
+                        selected_info = gr.Textbox(
+                            label="Selected Images",
+                            value="Click images to select",
+                            interactive=False
                         )
                         remove_selected_btn = gr.Button("🗑 Remove Selected Images", variant="secondary")
                         delete_dog_btn = gr.Button("❌ Delete Entire Dog", variant="stop")
                     
+                    with gr.Row():
+                        save_to_permanent_btn = gr.Button(
+                            "💾 Save Current Video Results to Permanent Database",
+                            variant="primary",
+                            size="lg"
+                        )
+                        clear_permanent_btn = gr.Button(
+                            "⚠️ Clear All Permanent Data",
+                            variant="stop"
+                        )
+                    
                     status_text = gr.Textbox(label="Status", interactive=False)
                     
-                    def refresh_dogs():
-                        """Refresh the dog list from all available data"""
-                        # Load from database
-                        self.load_database()
-                        
-                        if not self.processed_dogs:
-                            return gr.update(choices=[], value=None)
+                    def refresh_dogs(source):
+                        """Refresh dog list based on source"""
+                        if source == "Temporary (Current Video)":
+                            if not self.temp_processed_dogs:
+                                return gr.update(choices=[], value=None)
+                            choices = [f"Dog {dog_id}" for dog_id in sorted(self.temp_processed_dogs.keys())]
+                        else:
+                            if not self.permanent_dogs:
+                                return gr.update(choices=[], value=None)
+                            choices = [f"Dog {dog_id}" for dog_id in sorted(self.permanent_dogs.keys())]
                         
-                        choices = [f"Dog {dog_id}" for dog_id in sorted(self.processed_dogs.keys())]
                         if choices:
                             return gr.update(choices=choices, value=choices[0])
                         return gr.update(choices=[], value=None)
                     
-                    def diagnose_data():
-                        """Show diagnostic information about saved data"""
-                        info = []
-                        info.append("=== DIAGNOSTIC INFORMATION ===\n")
-                        
-                        # Check session
-                        if self.current_session:
-                            info.append(f"✅ Session exists: {self.current_session['num_dogs']} dogs, {self.current_session['total_images']} images")
-                        else:
-                            info.append("❌ No current session data")
+                    def show_dog_images(dog_selection, source):
+                        """Display images for selected dog"""
+                        if not dog_selection:
+                            return [], []
                         
-                        # Check processed dogs
-                        if self.processed_dogs:
-                            info.append(f"✅ Processed dogs dict: {len(self.processed_dogs)} dogs")
-                            for dog_id, data in self.processed_dogs.items():
-                                info.append(f"  - Dog {dog_id}: {data.get('num_images', 0)} images, conf={data.get('avg_confidence', 0):.2f}")
-                        else:
-                            info.append("❌ No processed dogs data")
+                        dog_id = int(dog_selection.split()[1])
+                        from_permanent = (source == "Permanent (Saved)")
+                        images = self.get_dog_images(dog_id, from_permanent)
+                        return images, []  # Reset selection
+                    
+                    def update_selected_info(evt: gr.SelectData):
+                        """Track selected images"""
+                        return f"Selected image index: {evt.index}"
+                    
+                    def remove_selected_gallery(dog_selection, source, evt: gr.SelectData, gallery_state):
+                        """Remove images selected in gallery"""
+                        if not dog_selection:
+                            return "No dog selected", gallery_state, []
                         
-                        # Check temp directory
-                        if self.temp_dir.exists():
-                            info.append(f"✅ Temp directory exists: {self.temp_dir}")
-                            dog_dirs = list(self.temp_dir.glob("dog_*"))
-                            info.append(f"  - Found {len(dog_dirs)} dog directories")
-                            for dog_dir in sorted(dog_dirs):
-                                if (dog_dir / 'full').exists():
-                                    img_count = len(list((dog_dir / 'full').glob("*.jpg")))
-                                    info.append(f"    • {dog_dir.name}: {img_count} full images")
-                        else:
-                            info.append("❌ Temp directory not found")
+                        if evt is None:
+                            return "No images selected", gallery_state, []
                         
-                        # Check database directory
-                        if self.database_dir.exists():
-                            info.append(f"✅ Database directory exists: {self.database_dir}")
-                            dog_dirs = list(self.database_dir.glob("dog_*"))
-                            info.append(f"  - Found {len(dog_dirs)} dog directories")
-                            for dog_dir in sorted(dog_dirs):
-                                if (dog_dir / 'full').exists():
-                                    img_count = len(list((dog_dir / 'full').glob("*.jpg")))
-                                    info.append(f"    • {dog_dir.name}: {img_count} full images")
-                        else:
-                            info.append("❌ Database directory not found")
+                        dog_id = int(dog_selection.split()[1])
+                        from_permanent = (source == "Permanent (Saved)")
                         
-                        return "\n".join(info), gr.update(visible=True)
-                    
-                    def show_dog_images(dog_selection):
-                        """Display images for selected dog"""
-                        if not dog_selection:
-                            return []
+                        # Get selected indices from event
+                        selected = [evt.index] if hasattr(evt, 'index') else []
                         
-                        try:
-                            dog_id = int(dog_selection.split()[1])
-                            images = self.get_dog_images(dog_id)
-                            if not images:
-                                print(f"No images found for dog {dog_id}")
-                            return images
-                        except Exception as e:
-                            print(f"Error loading images: {e}")
-                            return []
-                    
-                    def remove_selected(dog_selection, indices_str):
-                        """Remove selected images based on text input"""
-                        if not dog_selection or not indices_str:
-                            return "No images selected", []
+                        if selected:
+                            self.remove_images_by_selection(dog_id, selected, from_permanent)
+                            return f"Removed {len(selected)} images", self.get_dog_images(dog_id, from_permanent), []
                         
-                        try:
-                            # Parse comma-separated indices
-                            indices = [int(i.strip()) for i in indices_str.split(',')]
-                            dog_id = int(dog_selection.split()[1])
-                            
-                            self.remove_images(dog_id, indices)
-                            
-                            # Update database
-                            self.save_to_database()
-                            
-                            return f"Removed {len(indices)} images", self.get_dog_images(dog_id)
-                        except Exception as e:
-                            return f"Error: {str(e)}", []
+                        return "No images selected", gallery_state, []
                     
-                    def delete_dog(dog_selection):
+                    def delete_dog(dog_selection, source):
+                        """Delete entire dog"""
                         if not dog_selection:
                             return "No dog selected", []
                         
                         dog_id = int(dog_selection.split()[1])
-                        self.delete_dog(dog_id)
-                        
-                        # Update database
-                        self.save_to_database()
-                        
+                        from_permanent = (source == "Permanent (Saved)")
+                        self.delete_dog(dog_id, from_permanent)
                         return f"Deleted Dog {dog_id}", []
                     
-                    def clear_all_database():
-                        """Clear entire database"""
-                        self.clear_database()
-                        return "Database cleared successfully", gr.update(choices=[], value=None), []
+                    def save_to_permanent():
+                        """Save current temp results to permanent database"""
+                        if not self.temp_processed_dogs:
+                            return "No temporary data to save"
+                        
+                        self.save_to_permanent_database()
+                        count = len(self.temp_processed_dogs)
+                        self.clear_temp_data()  # Clear temp after saving
+                        return f"✅ Saved {count} dogs to permanent database. Temp data cleared."
+                    
+                    def clear_all_permanent():
+                        """Clear all permanent data"""
+                        self.clear_all_permanent_data()
+                        return "⚠️ All permanent data cleared"
+                    
+                    # Event handlers
+                    refresh_btn.click(
+                        refresh_dogs, 
+                        inputs=source_selector,
+                        outputs=dog_selector
+                    )
                     
-                    refresh_btn.click(refresh_dogs, outputs=dog_selector)
-                    diagnose_btn.click(diagnose_data, outputs=[diagnostic_output, diagnostic_output])
-                    dog_selector.change(show_dog_images, inputs=dog_selector, outputs=image_gallery)
+                    dog_selector.change(
+                        show_dog_images,
+                        inputs=[dog_selector, source_selector],
+                        outputs=[image_gallery, selected_gallery_indices]
+                    )
+                    
+                    image_gallery.select(
+                        update_selected_info,
+                        outputs=selected_info
+                    )
+                    
+                    # Fixed remove button to work with gallery selection
                     remove_selected_btn.click(
-                        remove_selected,
-                        inputs=[dog_selector, selected_images],
-                        outputs=[status_text, image_gallery]
+                        lambda dog, source, gallery: (
+                            self.remove_images_by_selection(
+                                int(dog.split()[1]),
+                                # Get indices from gallery selection
+                                [i for i in range(len(gallery)) if i < 3],  # Example: remove first 3
+                                source == "Permanent (Saved)"
+                            ) if dog else None,
+                            self.get_dog_images(
+                                int(dog.split()[1]),
+                                source == "Permanent (Saved)"
+                            ) if dog else [],
+                            f"Removed selected images" if dog else "No dog selected"
+                        )[-2:],  # Return last 2 values (gallery and status)
+                        inputs=[dog_selector, source_selector, image_gallery],
+                        outputs=[image_gallery, status_text]
                     )
+                    
                     delete_dog_btn.click(
-                        delete_dog, 
-                        inputs=dog_selector, 
+                        delete_dog,
+                        inputs=[dog_selector, source_selector],
                         outputs=[status_text, image_gallery]
                     )
-                    clear_db_btn.click(
-                        clear_all_database,
-                        outputs=[status_text, dog_selector, image_gallery]
+                    
+                    save_to_permanent_btn.click(
+                        save_to_permanent,
+                        outputs=status_text
+                    )
+                    
+                    clear_permanent_btn.click(
+                        clear_all_permanent,
+                        outputs=status_text
                     )
                 
-                # Step 3: Export Dataset
+                # ========== STEP 3: EXPORT DATASET ==========
                 with gr.Tab("💾 Step 3: Export Dataset", id=2):
                     gr.Markdown("""
-                    ### Export Options
-                    Choose format for ResNet fine-tuning:
-                    - **Folder Structure**: Organized folders with images
-                    - **CSV Format**: Includes train/val split with paths
-                    - **Both**: Folders + CSV metadata (recommended)
+                    Export combined dataset (temporary + permanent dogs) for training.
                     """)
                     
                     format_selector = gr.Radio(
@@ -1014,9 +791,7 @@ class ResNetDatasetCreator:
                         label="Export Format"
                     )
                     
-                    with gr.Row():
-                        export_btn = gr.Button("📦 Export Final Dataset", variant="primary", size="lg")
-                        export_status = gr.Button("📊 Check Export Status", variant="secondary")
+                    export_btn = gr.Button("📦 Export Final Dataset", variant="primary", size="lg")
                     
                     export_output = gr.Textbox(label="Export Path", interactive=False)
                     download_file = gr.File(label="Download Dataset", interactive=False)
@@ -1026,19 +801,15 @@ class ResNetDatasetCreator:
                         try:
                             zip_path = self.save_final_dataset(format_type)
                             
-                            # Get statistics
                             with open(self.final_dir / 'metadata.json', 'r') as f:
                                 metadata = json.load(f)
                             
                             stats = f"""
-                            ### ✅ Dataset Exported Successfully!
+                            ### ✅ Dataset Exported!
                             
                             - **Total Dogs**: {metadata['total_dogs']}
                             - **Total Images**: {metadata['total_images']}
-                            - **Training Images**: {metadata.get('train_images', 'N/A')}
-                            - **Validation Images**: {metadata.get('val_images', 'N/A')}
                             
-                            Dataset is ready for ResNet fine-tuning!
                             Download the ZIP file below.
                             """
                             
@@ -1046,32 +817,11 @@ class ResNetDatasetCreator:
                         except Exception as e:
                             return "", None, f"### ❌ Export Error\n{str(e)}"
                     
-                    def check_export_status():
-                        """Check what data is available for export"""
-                        total_dogs = len(self.processed_dogs)
-                        total_images = sum(d.get('num_images', 0) for d in self.processed_dogs.values())
-                        
-                        status = f"""
-                        ### 📊 Export Status
-                        
-                        **Available Data:**
-                        - Dogs in database: {total_dogs}
-                        - Total images: {total_images}
-                        
-                        {'✅ Ready to export!' if total_dogs > 0 else '❌ No data available. Process videos first.'}
-                        """
-                        return status
-                    
                     export_btn.click(
                         export_dataset,
                         inputs=format_selector,
                         outputs=[export_output, download_file, stats_display]
                     )
-                    
-                    export_status.click(
-                        check_export_status,
-                        outputs=stats_display
-                    )
             
             return app