Update app.py

app.py

@@ -0,0 +1,718 @@
+"""
+Complete Industrial Warehouse Image Stitching Application
+Ready for Hugging Face Space Deployment with ZIP Upload
+
+Author: Your Name
+Date: November 2024
+License: MIT
+"""
+
+import gradio as gr
+import cv2
+import numpy as np
+from PIL import Image
+import io
+import json
+from datetime import datetime
+from typing import List, Tuple, Optional
+import tempfile
+import zipfile
+from pathlib import Path
+
+class WarehouseStitcher:
+    """Production-ready warehouse image stitching pipeline"""
+    
+    def __init__(self):
+        self.version = "1.0.0"
+        self.config = {
+            'feature_extractor': 'SIFT',
+            'matcher': 'BF',
+            'use_clahe': True,
+            'detect_rack_labels': True,
+            'ransac_threshold': 5.0,
+            'min_match_count': 10,
+        }
+    
+    def preprocess_image(self, img: np.ndarray) -> np.ndarray:
+        """Apply CLAHE and preprocessing"""
+        if len(img.shape) == 3:
+            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = img
+            
+        if self.config['use_clahe']:
+            clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
+            gray = clahe.apply(gray)
+            
+        return gray
+    
+    def detect_rack_labels(self, img: np.ndarray) -> List[dict]:
+        """Detect warehouse rack labels"""
+        labels = []
+        gray = self.preprocess_image(img)
+        
+        edges = cv2.Canny(gray, 50, 150)
+        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        for contour in contours:
+            area = cv2.contourArea(contour)
+            if 500 < area < 50000:
+                x, y, w, h = cv2.boundingRect(contour)
+                aspect_ratio = w / float(h)
+                if 2.0 < aspect_ratio < 8.0:
+                    labels.append({
+                        'bbox': (x, y, w, h),
+                        'area': area,
+                        'center': (x + w//2, y + h//2)
+                    })
+        
+        return labels
+    
+    def extract_features(self, img: np.ndarray) -> Tuple:
+        """Extract features with selected method"""
+        gray = self.preprocess_image(img)
+        
+        if self.config['feature_extractor'] == 'SIFT':
+            detector = cv2.SIFT_create(nfeatures=2000, contrastThreshold=0.03, edgeThreshold=10)
+        elif self.config['feature_extractor'] == 'ORB':
+            detector = cv2.ORB_create(nfeatures=2000)
+        else:
+            detector = cv2.AKAZE_create()
+        
+        keypoints, descriptors = detector.detectAndCompute(gray, None)
+        
+        # Add rack label keypoints
+        if self.config['detect_rack_labels']:
+            labels = self.detect_rack_labels(gray)
+            for label in labels:
+                cx, cy = label['center']
+                keypoints.append(cv2.KeyPoint(float(cx), float(cy), 10))
+        
+        return keypoints, descriptors, gray
+    
+    def match_features(self, desc1: np.ndarray, desc2: np.ndarray) -> List:
+        """Match features with Lowe's ratio test"""
+        if desc1 is None or desc2 is None:
+            return []
+        
+        if self.config['feature_extractor'] == 'ORB':
+            matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False)
+        else:
+            matcher = cv2.BFMatcher(cv2.NORM_L2, crossCheck=False)
+        
+        matches = matcher.knnMatch(desc1, desc2, k=2)
+        
+        good_matches = []
+        for match_pair in matches:
+            if len(match_pair) == 2:
+                m, n = match_pair
+                if m.distance < 0.75 * n.distance:
+                    good_matches.append(m)
+        
+        return good_matches
+    
+    def estimate_homography(self, kp1, kp2, matches):
+        """Estimate homography with RANSAC"""
+        if len(matches) < self.config['min_match_count']:
+            return None, None, 0.0
+        
+        src_pts = np.float32([kp1[m.queryIdx].pt for m in matches]).reshape(-1, 1, 2)
+        dst_pts = np.float32([kp2[m.trainIdx].pt for m in matches]).reshape(-1, 1, 2)
+        
+        H, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 
+                                     self.config['ransac_threshold'])
+        
+        if H is None:
+            return None, None, 0.0
+        
+        inliers = np.sum(mask)
+        confidence = inliers / len(matches)
+        
+        return H, mask, confidence
+    
+    def blend_images(self, img1: np.ndarray, img2: np.ndarray, H: np.ndarray) -> np.ndarray:
+        """Blend images using homography"""
+        h1, w1 = img1.shape[:2]
+        h2, w2 = img2.shape[:2]
+        
+        pts2 = np.float32([[0, 0], [0, h2], [w2, h2], [w2, 0]]).reshape(-1, 1, 2)
+        pts2_transformed = cv2.perspectiveTransform(pts2, H)
+        
+        pts = np.concatenate((pts2_transformed,
+                             np.float32([[0, 0], [0, h1], [w1, h1], [w1, 0]]).reshape(-1, 1, 2)),
+                            axis=0)
+        
+        [xmin, ymin] = np.int32(pts.min(axis=0).ravel() - 0.5)
+        [xmax, ymax] = np.int32(pts.max(axis=0).ravel() + 0.5)
+        
+        t = [-xmin, -ymin]
+        Ht = np.array([[1, 0, t[0]], [0, 1, t[1]], [0, 0, 1]])
+        
+        result = cv2.warpPerspective(img2, Ht.dot(H), (xmax - xmin, ymax - ymin))
+        result[t[1]:h1 + t[1], t[0]:w1 + t[0]] = img1
+        
+        return result
+    
+    def stitch_images(self, images: List, progress=gr.Progress()) -> Tuple:
+        """Main stitching pipeline with progress tracking"""
+        if not images or len(images) < 2:
+            return None, "❌ Error: Please upload at least 2 images", None
+        
+        logs = []
+        logs.append("=" * 70)
+        logs.append("🏭 INDUSTRIAL WAREHOUSE IMAGE STITCHING PIPELINE")
+        logs.append("=" * 70)
+        logs.append(f"📅 Started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        logs.append(f"📸 Images to process: {len(images)}")
+        logs.append("")
+        
+        # Convert images
+        cv_images = []
+        for i, img in enumerate(images):
+            if isinstance(img, str):
+                img = cv2.imread(img)
+            elif isinstance(img, Image.Image):
+                img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+            cv_images.append(img)
+            logs.append(f"✓ Image {i+1}: {img.shape[1]}x{img.shape[0]} pixels")
+        
+        logs.append("")
+        
+        # Start stitching
+        result = cv_images[0]
+        total_matches = 0
+        total_inliers = 0
+        
+        for i in range(1, len(cv_images)):
+            progress((i / len(cv_images), f"Processing image {i+1}/{len(cv_images)}"))
+            
+            logs.append("-" * 70)
+            logs.append(f"🔄 PROCESSING IMAGE {i+1}/{len(cv_images)}")
+            logs.append("-" * 70)
+            
+            # Extract features
+            kp1, desc1, _ = self.extract_features(result)
+            kp2, desc2, _ = self.extract_features(cv_images[i])
+            logs.append(f"🔍 Features: {len(kp1)} ↔ {len(kp2)}")
+            
+            # Match features
+            matches = self.match_features(desc1, desc2)
+            total_matches += len(matches)
+            logs.append(f"🔗 Matches: {len(matches)} good matches")
+            
+            if len(matches) < self.config['min_match_count']:
+                logs.append(f"⚠️  WARNING: Only {len(matches)} matches")
+                logs.append(f"⏭️  Skipping image {i+1}")
+                continue
+            
+            # Estimate homography
+            H, mask, confidence = self.estimate_homography(kp1, kp2, matches)
+            
+            if H is None:
+                logs.append(f"❌ ERROR: Failed to compute homography")
+                continue
+            
+            inliers = int(np.sum(mask))
+            total_inliers += inliers
+            logs.append(f"📐 Homography: {inliers}/{len(matches)} inliers ({confidence:.1%})")
+            
+            # Blend
+            result = self.blend_images(result, cv_images[i], H)
+            logs.append(f"✅ Success! New size: {result.shape[1]}x{result.shape[0]}")
+            logs.append("")
+        
+        # Final summary
+        logs.append("=" * 70)
+        logs.append("📊 FINAL STATISTICS")
+        logs.append("=" * 70)
+        logs.append(f"✓ Final Resolution: {result.shape[1]} x {result.shape[0]} pixels")
+        logs.append(f"✓ Total Matches: {total_matches:,}")
+        logs.append(f"✓ Total Inliers: {total_inliers:,}")
+        logs.append("=" * 70)
+        
+        # Convert result to RGB
+        result_rgb = cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
+        result_pil = Image.fromarray(result_rgb)
+        
+        # Save for download
+        buf = io.BytesIO()
+        result_pil.save(buf, format='PNG', optimize=True)
+        buf.seek(0)
+        
+        return result_pil, "\n".join(logs), buf
+
+
+class PoseGuidedWarehouseStitcher(WarehouseStitcher):
+    """Enhanced version using drone pose metadata for guided stitching"""
+    
+    def load_metadata_from_file(self, json_path: str) -> dict:
+        """Load JSON metadata file"""
+        with open(json_path, 'r') as f:
+            return json.load(f)
+    
+    def calculate_relative_motion(self, pose1: dict, pose2: dict) -> dict:
+        """Calculate relative motion between two poses"""
+        nav1 = pose1['nav_snapshot']
+        nav2 = pose2['nav_snapshot']
+        
+        dx = nav2['x'] - nav1['x']
+        dy = nav2['y'] - nav1['y']
+        dz = nav2['z'] - nav1['z']
+        dyaw = nav2['yaw'] - nav1['yaw']
+        
+        distance = np.sqrt(dx**2 + dy**2 + dz**2)
+        
+        return {
+            'dx': dx, 'dy': dy, 'dz': dz,
+            'dyaw': dyaw,
+            'distance': distance,
+            'avg_height': (abs(nav1['z']) + abs(nav2['z'])) / 2
+        }
+    
+    def estimate_homography_from_pose(self, motion: dict, img_width: int, img_height: int) -> np.ndarray:
+        """Estimate initial homography from drone pose data"""
+        focal_length_px = img_width * 0.8
+        scale = abs(motion['avg_height']) if motion['avg_height'] != 0 else 10.0
+        
+        tx = (motion['dx'] / scale) * focal_length_px
+        ty = (motion['dy'] / scale) * focal_length_px
+        
+        theta = motion['dyaw']
+        cos_theta = np.cos(theta)
+        sin_theta = np.sin(theta)
+        
+        H = np.array([
+            [cos_theta, -sin_theta, tx],
+            [sin_theta, cos_theta, ty],
+            [0, 0, 1]
+        ], dtype=np.float64)
+        
+        return H
+    
+    def sort_by_capture_sequence(self, image_paths: List[str], metadata_paths: List[str]) -> Tuple[List, List]:
+        """Sort images by capture timestamp"""
+        pairs = []
+        
+        for img_path, meta_path in zip(image_paths, metadata_paths):
+            metadata = self.load_metadata_from_file(meta_path)
+            timestamp = metadata['nav_snapshot']['timestamp_usec']
+            pairs.append((timestamp, img_path, meta_path, metadata))
+        
+        pairs.sort(key=lambda x: x[0])
+        
+        sorted_imgs = [p[1] for p in pairs]
+        sorted_metas = [p[3] for p in pairs]
+        
+        return sorted_imgs, sorted_metas
+    
+    def stitch_with_poses(self, image_paths: List[str], metadata_paths: List[str], 
+                         progress=gr.Progress()) -> Tuple:
+        """Main pose-guided stitching pipeline"""
+        
+        if len(image_paths) != len(metadata_paths):
+            return None, "❌ Error: Number of images and metadata files must match", None
+        
+        if len(image_paths) < 2:
+            return None, "❌ Error: Need at least 2 images", None
+        
+        logs = []
+        logs.append("=" * 70)
+        logs.append("🚁 POSE-GUIDED DRONE IMAGE STITCHING PIPELINE")
+        logs.append("=" * 70)
+        logs.append(f"📅 Started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        logs.append(f"📸 Image pairs to process: {len(image_paths)}")
+        logs.append("")
+        
+        # Sort by timestamp
+        logs.append("🔄 Sorting images by capture sequence...")
+        sorted_imgs, sorted_metas = self.sort_by_capture_sequence(image_paths, metadata_paths)
+        logs.append(f"✓ Images sorted chronologically")
+        logs.append("")
+        
+        # Load first image
+        result = cv2.imread(sorted_imgs[0])
+        logs.append(f"📸 Image 1: {result.shape[1]}x{result.shape[0]} @ z={sorted_metas[0]['nav_snapshot']['z']:.2f}m")
+        
+        total_matches = 0
+        total_inliers = 0
+        
+        # Process each subsequent image
+        for i in range(1, len(sorted_imgs)):
+            progress((i / len(sorted_imgs), f"Stitching image {i+1}/{len(sorted_imgs)}"))
+            
+            logs.append("-" * 70)
+            logs.append(f"🔄 PROCESSING IMAGE PAIR {i}/{len(sorted_imgs)-1}")
+            logs.append("-" * 70)
+            
+            # Load current image
+            current_img = cv2.imread(sorted_imgs[i])
+            logs.append(f"📸 Image {i+1}: {current_img.shape[1]}x{current_img.shape[0]} @ z={sorted_metas[i]['nav_snapshot']['z']:.2f}m")
+            
+            # Calculate relative motion
+            motion = self.calculate_relative_motion(sorted_metas[i-1], sorted_metas[i])
+            logs.append(f"📍 Drone motion: Δx={motion['dx']:.3f}m, Δy={motion['dy']:.3f}m, Δz={motion['dz']:.3f}m")
+            logs.append(f"🧭 Yaw change: {np.degrees(motion['dyaw']):.2f}°")
+            logs.append(f"📏 Distance: {motion['distance']:.3f}m")
+            
+            # Get initial homography estimate from pose
+            H_initial = self.estimate_homography_from_pose(motion, result.shape[1], result.shape[0])
+            logs.append(f"🎯 Initial homography estimated from drone pose")
+            
+            # Extract features
+            kp1, desc1, _ = self.extract_features(result)
+            kp2, desc2, _ = self.extract_features(current_img)
+            logs.append(f"🔍 Features: {len(kp1)} ↔ {len(kp2)}")
+            
+            # Match features
+            matches = self.match_features(desc1, desc2)
+            total_matches += len(matches)
+            logs.append(f"🔗 Matches: {len(matches)} good matches")
+            
+            if len(matches) < self.config['min_match_count']:
+                logs.append(f"⚠️  WARNING: Insufficient matches, using pose-only homography")
+                H_final = H_initial
+            else:
+                # Refine homography with feature matches
+                H_refined, mask, confidence = self.estimate_homography(kp1, kp2, matches)
+                
+                if H_refined is not None:
+                    inliers = int(np.sum(mask))
+                    total_inliers += inliers
+                    logs.append(f"📐 Refined homography: {inliers}/{len(matches)} inliers ({confidence:.1%})")
+                    H_final = H_refined
+                else:
+                    logs.append(f"⚠️  Feature-based homography failed, using pose estimate")
+                    H_final = H_initial
+            
+            # Blend images
+            result = self.blend_images(result, current_img, H_final)
+            logs.append(f"✅ Blended! New size: {result.shape[1]}x{result.shape[0]}")
+            logs.append("")
+        
+        # Final summary
+        logs.append("=" * 70)
+        logs.append("📊 FINAL STATISTICS")
+        logs.append("=" * 70)
+        logs.append(f"✓ Final Resolution: {result.shape[1]} x {result.shape[0]} pixels")
+        logs.append(f"✓ Total Matches: {total_matches:,}")
+        logs.append(f"✓ Total Inliers: {total_inliers:,}")
+        logs.append(f"✓ Completed: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        logs.append("=" * 70)
+        
+        # Convert to RGB
+        result_rgb = cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
+        result_pil = Image.fromarray(result_rgb)
+        
+        # Save for download
+        buf = io.BytesIO()
+        result_pil.save(buf, format='PNG', optimize=True)
+        buf.seek(0)
+        
+        return result_pil, "\n".join(logs), buf
+
+
+def create_demo():
+    """Create and configure Gradio interface"""
+    
+    # Initialize both stitchers
+    basic_stitcher = WarehouseStitcher()
+    pose_stitcher = PoseGuidedWarehouseStitcher()
+    
+    def process_images_basic(files, feature_type, matcher_type, use_clahe, detect_labels, ransac_thresh):
+        """Process uploaded images (basic mode)"""
+        if not files or len(files) < 2:
+            return None, "❌ Please upload at least 2 images for stitching", None
+        
+        # Update configuration
+        basic_stitcher.config['feature_extractor'] = feature_type
+        basic_stitcher.config['matcher'] = matcher_type
+        basic_stitcher.config['use_clahe'] = use_clahe
+        basic_stitcher.config['detect_rack_labels'] = detect_labels
+        basic_stitcher.config['ransac_threshold'] = ransac_thresh
+        
+        # Load images
+        images = [Image.open(f.name) for f in files]
+        
+        # Process
+        return basic_stitcher.stitch_images(images)
+    
+    def process_zip_with_metadata(zip_file, feature_type, matcher_type, use_clahe, detect_labels, ransac_thresh):
+        """Process ZIP file containing images and metadata"""
+        if not zip_file:
+            return None, "❌ Please upload a ZIP file", None
+        
+        try:
+            with tempfile.TemporaryDirectory() as tmpdir:
+                tmpdir_path = Path(tmpdir)
+                
+                # Extract ZIP
+                with zipfile.ZipFile(zip_file.name, 'r') as zip_ref:
+                    zip_ref.extractall(tmpdir_path)
+                
+                # Find images and metadata
+                image_files = sorted(list(tmpdir_path.rglob('*.jpg')) + 
+                                   list(tmpdir_path.rglob('*.png')))
+                json_files = sorted(list(tmpdir_path.rglob('*.json')))
+                
+                if len(image_files) < 2:
+                    return None, f"❌ Found only {len(image_files)} images, need at least 2", None
+                
+                if len(json_files) == 0:
+                    return None, "❌ No JSON metadata files found in ZIP", None
+                
+                # Match images with metadata by filename
+                image_paths = []
+                metadata_paths = []
+                
+                for img_file in image_files:
+                    # Look for matching JSON
+                    json_name = img_file.stem + '.json'
+                    json_candidates = [j for j in json_files if j.name == json_name]
+                    
+                    if json_candidates:
+                        image_paths.append(str(img_file))
+                        metadata_paths.append(str(json_candidates[0]))
+                
+                if len(image_paths) < 2:
+                    return None, f"❌ Only {len(image_paths)} images have matching metadata", None
+                
+                # Update configuration
+                pose_stitcher.config['feature_extractor'] = feature_type
+                pose_stitcher.config['matcher'] = matcher_type
+                pose_stitcher.config['use_clahe'] = use_clahe
+                pose_stitcher.config['detect_rack_labels'] = detect_labels
+                pose_stitcher.config['ransac_threshold'] = ransac_thresh
+                
+                # Process with pose guidance
+                return pose_stitcher.stitch_with_poses(image_paths, metadata_paths)
+                
+        except Exception as e:
+            return None, f"❌ Error processing ZIP: {str(e)}", None
+    
+    # Custom CSS
+    custom_css = """
+    .gradio-container {
+        font-family: 'Arial', sans-serif;
+    }
+    .output-image {
+        border: 2px solid #4CAF50;
+        border-radius: 8px;
+    }
+    """
+    
+    # Create interface
+    with gr.Blocks(title="Warehouse Image Stitching", theme=gr.themes.Soft(), css=custom_css) as demo:
+        
+        # Header
+        gr.Markdown("""
+        # 🏭 Industrial Warehouse Image Stitching Pipeline
+        
+        <div style="background-color: #f0f8ff; padding: 20px; border-radius: 10px; margin-bottom: 20px;">
+        <h3>🎯 Production-Ready Stitching for Warehouse Environments</h3>
+        
+        **Key Features:**
+        - 🚁 **Pose-Guided Stitching**: Uses drone navigation data for intelligent alignment
+        - ✨ Handles specular reflections from shrink wrap and metallic surfaces
+        - 🏷️ Detects and uses warehouse rack labels as alignment anchors
+        - 🔍 CLAHE preprocessing for enhanced contrast
+        - 🎯 RANSAC-based robust homography estimation
+        </div>
+        """)
+        
+        # Mode selection tabs
+        with gr.Tabs():
+            # TAB 1: Basic Mode
+            with gr.TabItem("📸 Basic Mode"):
+                gr.Markdown("""
+                ### Upload images directly (no metadata needed)
+                Perfect for general-purpose panoramas and quick stitching.
+                """)
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("## ⚙️ Configuration")
+                        
+                        feature_type_basic = gr.Radio(
+                            choices=['SIFT', 'ORB', 'AKAZE'],
+                            value='SIFT',
+                            label="🔍 Feature Extractor"
+                        )
+                        
+                        matcher_type_basic = gr.Radio(
+                            choices=['BF', 'FLANN'],
+                            value='BF',
+                            label="🔗 Feature Matcher"
+                        )
+                        
+                        use_clahe_basic = gr.Checkbox(
+                            value=True,
+                            label="✨ Enable CLAHE Enhancement"
+                        )
+                        
+                        detect_labels_basic = gr.Checkbox(
+                            value=True,
+                            label="🏷️ Detect Rack Labels"
+                        )
+                        
+                        ransac_thresh_basic = gr.Slider(
+                            minimum=1.0,
+                            maximum=10.0,
+                            value=5.0,
+                            step=0.5,
+                            label="📐 RANSAC Threshold"
+                        )
+                    
+                    with gr.Column(scale=2):
+                        file_input = gr.File(
+                            file_count="multiple",
+                            file_types=["image"],
+                            label="📸 Upload Warehouse Images (minimum 2)",
+                            type="filepath"
+                        )
+                        
+                        process_basic_btn = gr.Button(
+                            "🔨 Stitch Images",
+                            variant="primary",
+                            size="lg"
+                        )
+            
+            # TAB 2: Pose-Guided Mode
+            with gr.TabItem("🚁 Pose-Guided Mode"):
+                gr.Markdown("""
+                ### Upload ZIP file with images + JSON metadata
+                For drone captures with navigation data - more robust and accurate!
+                
+                <div style="background-color: #e3f2fd; padding: 15px; border-radius: 8px; margin: 10px 0;">
+                <strong>📦 ZIP Structure Example:</strong>
+                <pre style="background: #fff; padding: 10px; border-radius: 5px;">
+dataset.zip
+├── image_001.jpg
+├── image_001.json  (with nav_snapshot)
+├── image_002.jpg
+├── image_002.json
+└── ...
+                </pre>
+                <strong>Or nested folders:</strong>
+                <pre style="background: #fff; padding: 10px; border-radius: 5px;">
+dataset.zip
+├── images/
+│   ├── img1.jpg
+│   └── img2.jpg
+└── metadata/
+    ├── img1.json
+    └── img2.json
+                </pre>
+                </div>
+                """)
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("## ⚙️ Configuration")
+                        
+                        feature_type_pose = gr.Radio(
+                            choices=['SIFT', 'ORB', 'AKAZE'],
+                            value='SIFT',
+                            label="🔍 Feature Extractor"
+                        )
+                        
+                        matcher_type_pose = gr.Radio(
+                            choices=['BF', 'FLANN'],
+                            value='BF',
+                            label="🔗 Feature Matcher"
+                        )
+                        
+                        use_clahe_pose = gr.Checkbox(
+                            value=True,
+                            label="✨ Enable CLAHE Enhancement"
+                        )
+                        
+                        detect_labels_pose = gr.Checkbox(
+                            value=True,
+                            label="🏷️ Detect Rack Labels"
+                        )
+                        
+                        ransac_thresh_pose = gr.Slider(
+                            minimum=1.0,
+                            maximum=10.0,
+                            value=5.0,
+                            step=0.5,
+                            label="📐 RANSAC Threshold"
+                        )
+                    
+                    with gr.Column(scale=2):
+                        zip_input = gr.File(
+                            file_count="single",
+                            file_types=[".zip"],
+                            label="📦 Upload ZIP (images + metadata)",
+                            type="filepath"
+                        )
+                        
+                        process_pose_btn = gr.Button(
+                            "🔨 Stitch with Pose Guidance",
+                            variant="primary",
+                            size="lg"
+                        )
+        
+        # Results section (shared by both tabs)
+        gr.Markdown("## 📊 Results")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                output_image = gr.Image(
+                    label="🖼️ Stitched Panorama",
+                    type="pil",
+                    height=500,
+                    elem_classes=["output-image"]
+                )
+                
+                download_btn = gr.File(
+                    label="⬇️ Download High-Resolution Result",
+                    type="binary"
+                )
+                
+            with gr.Column(scale=1):
+                logs_output = gr.Textbox(
+                    label="📋 Processing Logs",
+                    lines=25,
+                    max_lines=35,
+                    autoscroll=True,
+                    show_copy_button=True
+                )
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        <div style="text-align: center; color: #666;">
+        <p><strong>Industrial Warehouse Image Stitching Pipeline v1.0.0</strong></p>
+        <p>Powered by OpenCV • SIFT • RANSAC • Pose-Guided Alignment</p>
+        </div>
+        """)
+        
+        # Connect events
+        process_basic_btn.click(
+            fn=process_images_basic,
+            inputs=[file_input, feature_type_basic, matcher_type_basic, use_clahe_basic, detect_labels_basic, ransac_thresh_basic],
+            outputs=[output_image, logs_output, download_btn],
+            api_name="stitch"
+        )
+
+        process_pose_btn.click(
+            fn=process_zip_with_metadata,
+            inputs=[zip_input, feature_type_pose, matcher_type_pose, use_clahe_pose, detect_labels_pose, ransac_thresh_pose],
+            outputs=[output_image, logs_output, download_btn],
+            api_name="pose_stitch"
+        )
+    
+    return demo
+
+
+# Main execution
+if __name__ == "__main__":
+    demo = create_demo()
+    demo.queue(max_size=5)  # Enable queuing for multiple users
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )