Update main.py

main.py

@@ -1,701 +1,765 @@
-"""
-Archaeological Site Detection - Gradio Frontend
-================================================
-Interactive web interface for SONAR 2.0 archaeological detection system
-with GATE model predictions and multi-model analysis.
-
-Run: python gradio_app.py
-"""
-
-import gradio as gr
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-import matplotlib
-matplotlib.use('Agg')
-from matplotlib.patches import Rectangle
-import plotly.graph_objects as go
-from pathlib import Path
-import torch
-import json
-from typing import Dict, List, Tuple, Optional
-import io
-from PIL import Image
-import warnings
-warnings.filterwarnings('ignore')
-
-# Import your existing utilities
-from utils import (
-    ResUNetAutoencoder, ResUNetEncoder, load_patches,
-    load_model, load_kmeans_model, compute_autoencoder_probabilities,
-    compute_iforest_probabilities, compute_kmeans_probabilities,
-    load_unified_probability_matrix
-)
-from arch_similarity_utils import compute_arch_similarity_channel
-from visualization import (
-    generate_2d_patch_preview, generate_3d_terrain_json,
-    generate_gate_prediction_heatmap, generate_gate_positive_patches_visualization,
-    generate_probability_matrix_visualization, generate_full_aoi_heatmap,
-    generate_gate_statistics_json
-)
-
-# ==============================================================================
-# CONFIGURATION
-# ==============================================================================
-
-class Config:
-    """Application configuration"""
-    # Model paths
-    AUTOENCODER_PATH = Path('models/best_model_aoi.pth')
-    ENCODER_DIM = 128
-    IFOREST_PATH = Path('models/isolation_forest_model_128dim.pkl')
-    KMEANS_PATH = Path('models/kmeans_model_128dim.pkl')
-    ARCH_EMBEDDINGS_CSV = Path('GATE/Arch_embedding_only_128dim.csv')
-    GATE_MODEL_PKL = Path('GATE/gate_mlp_model.pkl')
-    GATE_SCALER_PATH = Path('GATE/gate_scaler.pkl')
-    
-    # Data paths
-    PATCHES_DIR = Path('patches/patches_final')
-    UNIFIED_PROB_DIR = Path('src/unified_probability_matrices_with_gate')
-    
-    # Processing
-    BATCH_SIZE = 32
-    DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-    
-    # UI
-    THEME = gr.themes.Soft(
-        primary_hue="blue",
-        secondary_hue="slate",
-    )
-
-config = Config()
-
-# ==============================================================================
-# MODEL MANAGER
-# ==============================================================================
-
-class ModelManager:
-    """Manages all trained models"""
-    
-    def __init__(self):
-        self.models_loaded = False
-        self.autoencoder = None
-        self.encoder = None
-        self.iforest = None
-        self.scaler_iforest = None
-        self.kmeans = None
-        self.scaler_kmeans = None
-        self.gate_model = None
-        self.gate_scaler = None
-        
-    def load_all_models(self):
-        """Load all models"""
-        status_messages = []
-        
-        try:
-            # Autoencoder
-            self.autoencoder = ResUNetAutoencoder(in_channels=7).to(config.DEVICE)
-            self.autoencoder.load_state_dict(
-                torch.load(config.AUTOENCODER_PATH, map_location=config.DEVICE)
-            )
-            self.autoencoder.eval()
-            status_messages.append("✅ Autoencoder loaded")
-            
-            # Encoder
-            self.encoder = ResUNetEncoder(
-                in_channels=7, 
-                embedding_dim=config.ENCODER_DIM
-            ).to(config.DEVICE)
-            self.encoder.load_from_autoencoder(str(config.AUTOENCODER_PATH))
-            self.encoder.eval()
-            status_messages.append("✅ Encoder loaded")
-            
-            # Isolation Forest
-            self.iforest, self.scaler_iforest = load_model(str(config.IFOREST_PATH))
-            status_messages.append("✅ Isolation Forest loaded")
-            
-            # K-Means
-            self.kmeans, self.scaler_kmeans = load_kmeans_model(str(config.KMEANS_PATH))
-            status_messages.append("✅ K-Means loaded")
-            
-            # GATE Model
-            import joblib
-            self.gate_model = joblib.load(config.GATE_MODEL_PKL)
-            self.gate_scaler = joblib.load(config.GATE_SCALER_PATH)
-            status_messages.append("✅ GATE model loaded")
-            
-            self.models_loaded = True
-            status_messages.append("\n🎉 All models loaded successfully!")
-            
-        except Exception as e:
-            status_messages.append(f"❌ Error loading models: {e}")
-            import traceback
-            status_messages.append(traceback.format_exc())
-        
-        return "\n".join(status_messages)
-    
-    def get_models_dict(self):
-        """Return models as dictionary"""
-        return {
-            'autoencoder': self.autoencoder,
-            'encoder': self.encoder,
-            'iforest': self.iforest,
-            'scaler_iforest': self.scaler_iforest,
-            'kmeans': self.kmeans,
-            'scaler_kmeans': self.scaler_kmeans,
-            'gate_model': self.gate_model,
-            'gate_scaler': self.gate_scaler
-        }
-
-# Global model manager
-model_manager = ModelManager()
-
-# ==============================================================================
-# DATA MANAGER
-# ==============================================================================
-
-class DataManager:
-    """Manages AOI data and patches"""
-    
-    def __init__(self):
-        self.aoi_list = self._discover_aois()
-        self.current_aoi = None
-        self.current_patches = None
-        self.current_metadata = None
-        self.current_unified_matrix = None
-        
-    def _discover_aois(self):
-        """Discover all available AOIs"""
-        if not config.PATCHES_DIR.exists():
-            return []
-        
-        patch_files = list(config.PATCHES_DIR.glob("AOI_*_all_patches.npz"))
-        aoi_names = sorted([f.stem.replace('_all_patches', '') for f in patch_files])
-        return aoi_names
-    
-    def load_aoi(self, aoi_name: str):
-        """Load patches and unified matrix for an AOI"""
-        try:
-            # Load patches
-            patches_file = config.PATCHES_DIR / f"{aoi_name}_all_patches.npz"
-            self.current_patches, self.current_metadata = load_patches(patches_file)
-            
-            # Load unified probability matrix
-            matrix_file = config.UNIFIED_PROB_DIR / f"{aoi_name}_unified_prob_matrix.npz"
-            if matrix_file.exists():
-                self.current_unified_matrix, _, _ = load_unified_probability_matrix(
-                    aoi_name, config.UNIFIED_PROB_DIR
-                )
-            else:
-                self.current_unified_matrix = None
-            
-            self.current_aoi = aoi_name
-            
-            return f"✅ Loaded {aoi_name}: {len(self.current_patches)} patches"
-        
-        except Exception as e:
-            return f"❌ Error loading {aoi_name}: {e}"
-    
-    def get_aoi_info(self):
-        """Get current AOI information"""
-        if self.current_aoi is None:
-            return "No AOI loaded"
-        
-        info = [
-            f"**AOI:** {self.current_aoi}",
-            f"**Total Patches:** {len(self.current_patches)}",
-            f"**Patch Shape:** {self.current_patches[0].shape}",
-        ]
-        
-        if self.current_unified_matrix is not None:
-            info.append(f"**Unified Matrix:** {self.current_unified_matrix.shape}")
-            info.append(f"**Channels:** 5 (incl. GATE)")
-        
-        return "\n".join(info)
-    
-    def get_patch(self, patch_idx: int):
-        """Get specific patch"""
-        if self.current_patches is None or patch_idx >= len(self.current_patches):
-            return None, None
-        
-        return self.current_patches[patch_idx], self.current_metadata[patch_idx]
-
-# Global data manager
-data_manager = DataManager()
-
-# ==============================================================================
-# VISUALIZATION FUNCTIONS
-# ==============================================================================
-
-def create_patch_visualization(patch: np.ndarray, metadata: Dict):
-    """Create 2D visualization of patch"""
-    channel_names = ['DTM', 'Slope', 'Roughness', 'NDVI', 'NDWI', 'FlowAcc', 'FlowDir']
-    
-    fig, axes = plt.subplots(2, 4, figsize=(16, 8))
-    axes = axes.flatten()
-    
-    for i in range(7):
-        ax = axes[i]
-        data = patch[i]
-        
-        # Choose colormap
-        if i == 0:  # DTM
-            cmap = 'terrain'
-        elif i == 1:  # Slope
-            cmap = 'YlOrRd'
-        elif i == 3:  # NDVI
-            cmap = 'RdYlGn'
-        elif i == 4:  # NDWI
-            cmap = 'Blues'
-        else:
-            cmap = 'viridis'
-        
-        im = ax.imshow(data, cmap=cmap, interpolation='bilinear')
-        ax.set_title(f'{channel_names[i]}\nμ={np.nanmean(data):.2f}', fontweight='bold')
-        ax.axis('off')
-        plt.colorbar(im, ax=ax, fraction=0.046)
-    
-    # Hide last subplot
-    axes[7].axis('off')
-    
-    plt.suptitle(f"Patch {metadata['patch_id']} (row={metadata['row']}, col={metadata['col']})", 
-                 fontsize=14, fontweight='bold')
-    plt.tight_layout()
-    
-    # Convert to image
-    buf = io.BytesIO()
-    plt.savefig(buf, format='png', dpi=150, bbox_inches='tight')
-    plt.close(fig)
-    buf.seek(0)
-    
-    return Image.open(buf)
-
-def create_3d_terrain(patch: np.ndarray, metadata: Dict):
-    """Create 3D terrain visualization"""
-    dtm = patch[0]  # First channel is DTM
-    
-    # Create coordinate grids
-    rows, cols = dtm.shape
-    x = np.arange(cols)
-    y = np.arange(rows)
-    X, Y = np.meshgrid(x, y)
-    
-    # Handle NaN
-    dtm_clean = np.nan_to_num(dtm, nan=np.nanmedian(dtm))
-    
-    # Create surface
-    fig = go.Figure(data=[go.Surface(
-        z=dtm_clean,
-        x=X,
-        y=Y,
-        colorscale='earth',
-        colorbar=dict(title='Elevation (m)'),
-        lighting=dict(
-            ambient=0.4,
-            diffuse=0.8,
-            fresnel=0.2,
-            specular=0.3,
-            roughness=0.5
-        )
-    )])
-    
-    fig.update_layout(
-        title=f"3D Terrain - {metadata['patch_id']}",
-        scene=dict(
-            xaxis_title='X (pixels)',
-            yaxis_title='Y (pixels)',
-            zaxis_title='Elevation (m)',
-            camera=dict(eye=dict(x=1.5, y=1.5, z=1.3)),
-            aspectmode='manual',
-            aspectratio=dict(x=1, y=1, z=0.5)
-        ),
-        width=800,
-        height=600
-    )
-    
-    return fig
-
-def create_probability_channels_viz(unified_matrix: np.ndarray, patch_idx: int):
-    """Visualize all 5 probability channels"""
-    patch_data = unified_matrix[patch_idx]
-    channel_names = ['Autoencoder', 'IForest', 'K-Means', 'Arch Similarity', 'GATE Prediction']
-    
-    fig, axes = plt.subplots(2, 3, figsize=(15, 10))
-    axes = axes.flatten()
-    
-    for i in range(5):
-        ax = axes[i]
-        data = patch_data[:, :, i]
-        
-        im = ax.imshow(data, cmap='hot', vmin=0, vmax=1, interpolation='bilinear')
-        ax.set_title(f'{channel_names[i]}\nμ={data.mean():.3f}, max={data.max():.3f}', 
-                     fontweight='bold')
-        ax.axis('off')
-        plt.colorbar(im, ax=ax, fraction=0.046)
-    
-    # Hide last subplot
-    axes[5].axis('off')
-    
-    plt.suptitle(f'Probability Channels - Patch {patch_idx}', 
-                 fontsize=14, fontweight='bold')
-    plt.tight_layout()
-    
-    # Convert to image
-    buf = io.BytesIO()
-    plt.savefig(buf, format='png', dpi=150, bbox_inches='tight')
-    plt.close(fig)
-    buf.seek(0)
-    
-    return Image.open(buf)
-
-def create_gate_heatmap(unified_matrix: np.ndarray, metadata: List[Dict], aoi_name: str):
-    """Create GATE prediction heatmap"""
-    # Determine AOI shape
-    max_row = max(m['row'] + 64 for m in metadata)
-    max_col = max(m['col'] + 64 for m in metadata)
-    aoi_shape = (max_row, max_col)
-    
-    # Generate heatmap
-    heatmap_bytes = generate_gate_prediction_heatmap(
-        unified_matrix, metadata, aoi_shape, aoi_name, threshold=0.5
-    )
-    
-    return Image.open(io.BytesIO(heatmap_bytes))
-
-def create_top_candidates(unified_matrix: np.ndarray, metadata: List[Dict], 
-                         patches: np.ndarray, threshold: float = 0.5):
-    """Visualize top archaeological candidates"""
-    # Get patches as dict
-    patches_dict = {'dtm': patches[:, 0, :, :]}
-    
-    candidates_bytes = generate_gate_positive_patches_visualization(
-        unified_matrix, metadata, patches_dict, threshold=threshold, top_n=16
-    )
-    
-    return Image.open(io.BytesIO(candidates_bytes))
-
-# ==============================================================================
-# GRADIO INTERFACE FUNCTIONS
-# ==============================================================================
-
-def load_models_ui():
-    """Load models button handler"""
-    status = model_manager.load_all_models()
-    
-    if model_manager.models_loaded:
-        return status, gr.update(interactive=True)  # Enable analysis tab
-    else:
-        return status, gr.update(interactive=False)
-
-def load_aoi_ui(aoi_name):
-    """Load AOI handler"""
-    status = data_manager.load_aoi(aoi_name)
-    info = data_manager.get_aoi_info()
-    
-    # Update patch slider range
-    if data_manager.current_patches is not None:
-        max_patches = len(data_manager.current_patches) - 1
-        return status, info, gr.update(maximum=max_patches, value=0)
-    
-    return status, info, gr.update()
-
-def view_patch_ui(patch_idx):
-    """View specific patch"""
-    if data_manager.current_patches is None:
-        return None, None, None, "⚠️ Load an AOI first"
-    
-    patch, metadata = data_manager.get_patch(patch_idx)
-    
-    if patch is None:
-        return None, None, None, "❌ Invalid patch index"
-    
-    # Create visualizations
-    img_2d = create_patch_visualization(patch, metadata)
-    fig_3d = create_3d_terrain(patch, metadata)
-    
-    # Probability channels if available
-    prob_img = None
-    if data_manager.current_unified_matrix is not None:
-        prob_img = create_probability_channels_viz(
-            data_manager.current_unified_matrix, patch_idx
-        )
-    
-    info = f"**Patch {patch_idx}:** {metadata['patch_id']}\n" \
-           f"**Position:** (row={metadata['row']}, col={metadata['col']})"
-    
-    return img_2d, fig_3d, prob_img, info
-
-def analyze_aoi_gate(threshold):
-    """Analyze full AOI with GATE"""
-    if data_manager.current_unified_matrix is None:
-        return None, None, "⚠️ No unified matrix available for this AOI"
-    
-    # Generate heatmap
-    heatmap = create_gate_heatmap(
-        data_manager.current_unified_matrix,
-        data_manager.current_metadata,
-        data_manager.current_aoi
-    )
-    
-    # Generate top candidates
-    candidates = create_top_candidates(
-        data_manager.current_unified_matrix,
-        data_manager.current_metadata,
-        data_manager.current_patches,
-        threshold=threshold
-    )
-    
-    # Statistics
-    stats = generate_gate_statistics_json(
-        data_manager.current_unified_matrix,
-        threshold=threshold
-    )
-    
-    stats_text = f"""
-    **GATE Analysis Results**
-    
-    - Total Patches: {stats['total_patches']}
-    - Positive Predictions: {stats['positive_patches']} ({stats['positive_percentage']:.1f}%)
-    - Mean GATE Score: {stats['mean_gate_score']:.3f}
-    - Max GATE Score: {stats['max_gate_score']:.3f}
-    - Threshold: {stats['threshold']}
-    """
-    
-    return heatmap, candidates, stats_text
-
-def batch_process_ui(start_aoi, end_aoi, progress=gr.Progress()):
-    """Batch process multiple AOIs"""
-    if not model_manager.models_loaded:
-        return "❌ Load models first"
-    
-    aoi_list = data_manager.aoi_list[start_aoi:end_aoi+1]
-    results = []
-    
-    for i, aoi_name in enumerate(progress.tqdm(aoi_list, desc="Processing AOIs")):
-        try:
-            data_manager.load_aoi(aoi_name)
-            
-            if data_manager.current_unified_matrix is not None:
-                stats = generate_gate_statistics_json(
-                    data_manager.current_unified_matrix, threshold=0.5
-                )
-                
-                results.append({
-                    'AOI': aoi_name,
-                    'Patches': stats['total_patches'],
-                    'Positives': stats['positive_patches'],
-                    'Positive %': f"{stats['positive_percentage']:.1f}%",
-                    'Mean Score': f"{stats['mean_gate_score']:.3f}"
-                })
-        except Exception as e:
-            results.append({
-                'AOI': aoi_name,
-                'Error': str(e)
-            })
-    
-    df = pd.DataFrame(results)
-    return df
-
-# ==============================================================================
-# BUILD GRADIO INTERFACE
-# ==============================================================================
-
-def build_interface():
-    """Build the main Gradio interface"""
-    
-    with gr.Blocks(theme=config.THEME, title="Archaeological Site Detection") as app:
-        
-        # Header
-        gr.Markdown("""
-        # 🏛️ Archaeological Site Detection System
-        ### SONAR 2.0 - Multi-Model Analysis with GATE Predictions
-        
-        Explore archaeological sites using advanced AI detection across multiple AOIs.
-        """)
-        
-        # Model Loading Section
-        with gr.Row():
-            with gr.Column(scale=3):
-                gr.Markdown("### 🤖 Step 1: Load AI Models")
-                gr.Markdown("Load all trained models (Autoencoder, Isolation Forest, K-Means, GATE)")
-            
-            with gr.Column(scale=1):
-                load_models_btn = gr.Button("🔄 Load Models", variant="primary", size="lg")
-        
-        model_status = gr.Textbox(label="Model Status", lines=8, max_lines=10)
-        
-        gr.Markdown("---")
-        
-        # Main Interface
-        with gr.Tabs():
-            
-            # TAB 1: Patch Explorer
-            with gr.Tab("🔍 Patch Explorer"):
-                gr.Markdown("### Explore individual patches from any AOI")
-                
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        aoi_dropdown = gr.Dropdown(
-                            choices=data_manager.aoi_list,
-                            label="Select AOI",
-                            value=data_manager.aoi_list[0] if data_manager.aoi_list else None
-                        )
-                        
-                        load_aoi_btn = gr.Button("📂 Load AOI", variant="secondary")
-                        
-                        aoi_status = gr.Textbox(label="Load Status", lines=2)
-                        aoi_info = gr.Markdown("*No AOI loaded*")
-                        
-                        gr.Markdown("---")
-                        
-                        patch_slider = gr.Slider(
-                            minimum=0, maximum=100, step=1, value=0,
-                            label="Select Patch"
-                        )
-                        
-                        view_patch_btn = gr.Button("👁️ View Patch", variant="primary")
-                        
-                        patch_info = gr.Markdown("*Select a patch*")
-                    
-                    with gr.Column(scale=2):
-                        with gr.Tabs():
-                            with gr.Tab("📊 2D View"):
-                                patch_2d = gr.Image(label="Patch Layers", type="pil")
-                            
-                            with gr.Tab("🏔️ 3D Terrain"):
-                                patch_3d = gr.Plot(label="3D Visualization")
-                            
-                            with gr.Tab("🎯 Probability Channels"):
-                                prob_channels = gr.Image(label="5 Probability Channels", type="pil")
-            
-            # TAB 2: GATE Analysis
-            with gr.Tab("🎯 GATE Analysis", id="gate_tab"):
-                gr.Markdown("### Full AOI Analysis with GATE Model")
-                
-                with gr.Row():
-                    threshold_slider = gr.Slider(
-                        minimum=0.0, maximum=1.0, value=0.5, step=0.05,
-                        label="GATE Threshold (higher = stricter)"
-                    )
-                    
-                    analyze_btn = gr.Button("🔥 Analyze AOI", variant="primary", size="lg")
-                
-                gate_stats = gr.Markdown("*Run analysis to see statistics*")
-                
-                with gr.Row():
-                    with gr.Column():
-                        gate_heatmap = gr.Image(label="GATE Prediction Heatmap", type="pil")
-                    
-                    with gr.Column():
-                        gate_candidates = gr.Image(label="Top Archaeological Candidates", type="pil")
-            
-            # TAB 3: Batch Processing
-            with gr.Tab("⚡ Batch Processing"):
-                gr.Markdown("### Process Multiple AOIs")
-                
-                with gr.Row():
-                    start_idx = gr.Number(label="Start AOI Index", value=0, precision=0)
-                    end_idx = gr.Number(label="End AOI Index", value=10, precision=0)
-                
-                batch_btn = gr.Button("🚀 Process Batch", variant="primary")
-                
-                batch_results = gr.Dataframe(
-                    headers=["AOI", "Patches", "Positives", "Positive %", "Mean Score"],
-                    label="Batch Results"
-                )
-            
-            # TAB 4: Documentation
-            with gr.Tab("📖 Documentation"):
-                gr.Markdown("""
-                ## System Overview
-                
-                This system combines multiple AI models for archaeological site detection:
-                
-                ### Models
-                1. **Autoencoder (ResUNet)** - Detects anomalies via reconstruction error
-                2. **Isolation Forest** - Identifies outliers in latent space
-                3. **K-Means Clustering** - Matches against known archaeological signatures
-                4. **Archaeological Similarity** - Compares against verified sites
-                5. **GATE Model** - Meta-learner that combines all models for final prediction
-                
-                ### Workflow
-                1. Load models (one-time operation)
-                2. Select an AOI to analyze
-                3. Explore individual patches or run full AOI analysis
-                4. Review GATE predictions to identify high-probability archaeological sites
-                5. Batch process multiple AOIs for comprehensive surveys
-                
-                ### Channels
-                The system uses 7 input channels:
-                - **DTM**: Digital Terrain Model (LiDAR)
-                - **Slope**: Terrain slope
-                - **Roughness**: Surface roughness
-                - **NDVI**: Normalized Difference Vegetation Index
-                - **NDWI**: Normalized Difference Water Index
-                - **Flow Accumulation**: Hydrological flow
-                - **Flow Direction**: Water flow direction
-                
-                ### Output
-                - **Probability Maps**: 5 probability channels (4 models + GATE)
-                - **Heatmaps**: Full AOI visualization of predictions
-                - **Candidate List**: Top archaeological site candidates
-                
-                ### Thresholding
-                - **0.3-0.5**: Low threshold - more candidates, higher false positives
-                - **0.5-0.7**: Balanced - recommended for initial surveys
-                - **0.7-0.9**: High threshold - fewer candidates, high confidence
-                """)
-        
-        # Event Handlers
-        load_models_btn.click(
-            fn=load_models_ui,
-            outputs=[model_status, gr.Tabs.update(selected="gate_tab")]
-        )
-        
-        load_aoi_btn.click(
-            fn=load_aoi_ui,
-            inputs=[aoi_dropdown],
-            outputs=[aoi_status, aoi_info, patch_slider]
-        )
-        
-        view_patch_btn.click(
-            fn=view_patch_ui,
-            inputs=[patch_slider],
-            outputs=[patch_2d, patch_3d, prob_channels, patch_info]
-        )
-        
-        analyze_btn.click(
-            fn=analyze_aoi_gate,
-            inputs=[threshold_slider],
-            outputs=[gate_heatmap, gate_candidates, gate_stats]
-        )
-        
-        batch_btn.click(
-            fn=batch_process_ui,
-            inputs=[start_idx, end_idx],
-            outputs=[batch_results]
-        )
-    
-    return app
-
-# ==============================================================================
-# MAIN
-# ==============================================================================
-
-if __name__ == "__main__":
-    print("🏛️ Archaeological Site Detection System")
-    print("=" * 60)
-    print(f"Device: {config.DEVICE}")
-    print(f"Discovered AOIs: {len(data_manager.aoi_list)}")
-    print("=" * 60)
-    
-    app = build_interface()
-    
-    # Launch with options
-    app.launch(
-        server_name="0.0.0.0",  # Allow external access
-        server_port=7860,
-        share=False,  # Set to True for public URL
-        show_error=True,
-        show_api=True
+"""
+SONAR 2.0 - Archaeological Site Detection
+Beautiful Interactive Interface with Full AOI Visualization
+"""
+
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib
+matplotlib.use('Agg')
+import plotly.graph_objects as go
+from pathlib import Path
+import torch
+import io
+from PIL import Image
+import warnings
+import zipfile
+from scipy.ndimage import sobel, gaussian_filter
+from matplotlib import cm
+import rasterio
+from rasterio.transform import rowcol
+import folium
+import base64
+warnings.filterwarnings('ignore')
+
+from utils import (
+    ResUNetAutoencoder, ResUNetEncoder, load_patches,
+    load_model, load_kmeans_model, load_unified_probability_matrix
+)
+
+# ==============================================================================
+# CONFIGURATION
+# ==============================================================================
+
+class Config:
+    AUTOENCODER_PATH = Path('models/best_model_aoi.pth')
+    ENCODER_DIM = 128
+    IFOREST_PATH = Path('models/isolation_forest_model_128dim.pkl')
+    KMEANS_PATH = Path('models/kmeans_model_128dim.pkl')
+    GATE_MODEL_PKL = Path('models/gate_mlp_model.pkl')
+    GATE_SCALER_PATH = Path('models/gate_scaler.pkl')
+    
+    DATA_BASE = Path('Test_dataset')
+    PATCHES_DIR = Path('patches_final_file')
+    UNIFIED_PROB_DIR = Path('test_unified_probablity_matrices_with_gate')
+    
+    MODELS_ZIP = Path('models.zip')
+    PATCHES_ZIP = Path('patches_final_file.zip')
+    UNIFIED_PROB_ZIP = Path('test_unified_probablity_matrices_with_gate.zip')
+    DATASET_ZIP = Path('Test_dataset.zip')
+    
+    BATCH_SIZE = 32
+    DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    
+    @staticmethod
+    def extract_data_files():
+        print("\n" + "="*50)
+        print("Starting SONAR 2.0...")
+        print("="*50)
+        
+        if Config.MODELS_ZIP.exists() and (not Path('models').exists() or not any(Path('models').iterdir())):
+            print("Extracting models...")
+            with zipfile.ZipFile(Config.MODELS_ZIP, 'r') as zip_ref:
+                zip_ref.extractall('.')
+        
+        if Config.PATCHES_ZIP.exists() and (not Config.PATCHES_DIR.exists() or not any(Config.PATCHES_DIR.iterdir())):
+            print("Extracting patches...")
+            with zipfile.ZipFile(Config.PATCHES_ZIP, 'r') as zip_ref:
+                zip_ref.extractall('.')
+        
+        if Config.UNIFIED_PROB_ZIP.exists() and (not Config.UNIFIED_PROB_DIR.exists() or not any(Config.UNIFIED_PROB_DIR.iterdir())):
+            print("Extracting probability matrices...")
+            with zipfile.ZipFile(Config.UNIFIED_PROB_ZIP, 'r') as zip_ref:
+                zip_ref.extractall('.')
+        
+        if Config.DATASET_ZIP.exists() and not Config.DATA_BASE.exists():
+            print("Extracting Test_dataset.zip...")
+            with zipfile.ZipFile(Config.DATASET_ZIP, 'r') as zip_ref:
+                zip_ref.extractall('.')
+            print("✓ Test dataset extracted")
+        
+        print("Ready!\n")
+
+config = Config()
+
+# ==============================================================================
+# DATA MANAGER
+# ==============================================================================
+
+class DataManager:
+    def __init__(self):
+        self.aoi_list = []
+        self.current_aoi = None
+        self.current_patches = None
+        self.current_metadata = None
+        self.current_unified_matrix = None
+        self.full_dtm = None
+        self.reference_transform = None
+        self.reference_shape = None
+        self.reference_bounds = None
+        self.reference_crs = None
+        
+    def discover_aois(self):
+        if not config.PATCHES_DIR.exists():
+            return []
+        patch_files = list(config.PATCHES_DIR.glob("AOI_*_all_patches.npz"))
+        aoi_names = sorted([f.stem.replace('_all_patches', '') for f in patch_files])
+        self.aoi_list = aoi_names
+        return aoi_names
+    
+    def load_original_raster(self, aoi_name: str):
+        """Load original DTM from Test_dataset"""
+        try:
+            meta_dir = config.DATA_BASE / aoi_name / 'meta'
+            if not meta_dir.exists():
+                return None
+            
+            tif_files = list(meta_dir.glob('*.tif'))
+            if not tif_files:
+                return None
+            
+            dtm_path = tif_files[0]
+            print(f"✓ Loading DTM: {dtm_path.name}")
+            
+            with rasterio.open(dtm_path) as src:
+                dtm = src.read(1).astype(np.float32)
+                if src.nodata is not None:
+                    dtm[dtm == src.nodata] = np.nan
+                
+                self.reference_transform = src.transform
+                self.reference_shape = (src.height, src.width)
+                self.reference_bounds = src.bounds
+                self.reference_crs = src.crs
+                
+                return dtm
+        except Exception as e:
+            print(f"Error loading raster: {e}")
+            return None
+    
+    def load_aoi(self, aoi_name: str):
+        try:
+            patches_file = config.PATCHES_DIR / f"{aoi_name}_all_patches.npz"
+            self.current_patches, self.current_metadata = load_patches(patches_file)
+            
+            matrix_file = config.UNIFIED_PROB_DIR / f"{aoi_name}_unified_prob_matrix.npz"
+            if matrix_file.exists():
+                self.current_unified_matrix, _, _ = load_unified_probability_matrix(
+                    aoi_name, config.UNIFIED_PROB_DIR
+                )
+            
+            self.full_dtm = self.load_original_raster(aoi_name)
+            
+            if self.full_dtm is not None:
+                max_row = max(m['row'] + 64 for m in self.current_metadata)
+                max_col = max(m['col'] + 64 for m in self.current_metadata)
+                dtm_height, dtm_width = self.full_dtm.shape
+                
+                if max_row > dtm_height or max_col > dtm_width:
+                    print(f"⚠️ Patch bounds exceed raster, falling back to reconstruction")
+                    self.full_dtm = None
+            
+            self.current_aoi = aoi_name
+            return f"✅ {aoi_name} loaded ({len(self.current_patches)} patches)"
+        except Exception as e:
+            return f"❌ Error: {e}"
+    
+    def get_patch(self, patch_idx: int):
+        if self.current_patches is None or patch_idx >= len(self.current_patches):
+            return None, None
+        return self.current_patches[patch_idx], self.current_metadata[patch_idx]
+    
+    def find_patch_at_pixel(self, row: int, col: int):
+        for idx, meta in enumerate(self.current_metadata):
+            patch_row, patch_col = meta['row'], meta['col']
+            if (patch_row <= row < patch_row + 64 and patch_col <= col < patch_col + 64):
+                return idx
+        return None
+
+data_manager = DataManager()
+
+# ==============================================================================
+# MAP GENERATION WITH MULTIPLE OVERLAYS (LIKE STREAMLIT VERSION)
+# ==============================================================================
+
+def create_interactive_map(aoi_name, threshold=0.5):
+    """
+    Create beautiful Folium map with multiple terrain overlays
+    Matches the Streamlit visualization quality
+    """
+    
+    if data_manager.full_dtm is None or data_manager.reference_bounds is None:
+        # Fallback: create a simple map showing patches without terrain overlays
+        if data_manager.current_patches is None:
+            return "<div style='padding: 20px; text-align: center;'>⚠️ Load an AOI first</div>"
+        
+        # Calculate approximate center from patches
+        if data_manager.current_metadata:
+            rows = [m['row'] for m in data_manager.current_metadata]
+            cols = [m['col'] for m in data_manager.current_metadata]
+            center_row = (min(rows) + max(rows)) / 2
+            center_col = (min(cols) + max(cols)) / 2
+            
+            # Use approximate lat/lon (this is a fallback)
+            center_lat, center_lon = 0, 0  # Will be set properly below
+            
+            m = folium.Map(
+                location=[center_lat, center_lon],
+                zoom_start=14,
+                tiles='OpenStreetMap'
+            )
+            
+            # Add patch markers
+            if data_manager.current_unified_matrix is not None:
+                gate_channel = data_manager.current_unified_matrix[:, :, :, 4]
+                
+                for idx, meta in enumerate(data_manager.current_metadata):
+                    patch_score = np.mean(gate_channel[idx])
+                    
+                    if patch_score >= threshold:
+                        # For fallback, just use patch indices as approximate locations
+                        popup_html = f"""
+                        <b>🔴 Anomaly Detected</b><br>
+                        <hr>
+                        <b>Score:</b> {patch_score:.3f}<br>
+                        <b>Patch ID:</b> {idx}<br>
+                        <hr>
+                        <i>⚠️ DTM not available - using patch coordinates</i>
+                        """
+                        
+                        # This is approximate - will work better with actual DTM
+                        lat_approx = meta['row'] / 1000.0
+                        lon_approx = meta['col'] / 1000.0
+                        
+                        folium.CircleMarker(
+                            location=[lat_approx, lon_approx],
+                            radius=8,
+                            popup=folium.Popup(popup_html, max_width=300),
+                            tooltip=f"Patch {idx} - Score: {patch_score:.3f}",
+                            color='red',
+                            fill=True,
+                            fillColor='orange',
+                            fillOpacity=0.7,
+                            weight=2
+                        ).add_to(m)
+            
+            folium.LayerControl().add_to(m)
+            
+            return m._repr_html_()
+        
+        return "<div style='padding: 20px; text-align: center; background: #fff3cd; border-radius: 8px;'>⚠️ No DTM data available for this AOI. Map visualization limited.</div>"
+    
+    bounds = data_manager.reference_bounds
+    center_lat = (bounds.bottom + bounds.top) / 2
+    center_lon = (bounds.left + bounds.right) / 2
+    
+    # Create base map
+    m = folium.Map(
+        location=[center_lat, center_lon],
+        zoom_start=14,
+        tiles='OpenStreetMap'
+    )
+    
+    # Add center marker
+    folium.Marker(
+        location=[center_lat, center_lon],
+        popup=f'AOI Center<br>Lat: {center_lat:.6f}<br>Lon: {center_lon:.6f}',
+        tooltip='AOI Center',
+        icon=folium.Icon(color='blue', icon='info-sign')
+    ).add_to(m)
+    
+    # Generate terrain overlays
+    dtm = data_manager.full_dtm
+    valid_mask = ~np.isnan(dtm)
+    
+    if valid_mask.any():
+        dtm_filled = dtm.copy()
+        dtm_filled[~valid_mask] = np.nanmedian(dtm)
+        
+        # ============================================================
+        # LAYER 1: Local Relief Model (ARCHAEOLOGICAL GOLD!)
+        # ============================================================
+        dtm_smooth = gaussian_filter(dtm_filled, sigma=10)
+        local_relief = dtm_filled - dtm_smooth
+        
+        relief_clipped = np.clip(local_relief, -2, 2)
+        relief_norm = (relief_clipped + 2) / 4
+        
+        rdbu_cmap = cm.get_cmap('RdBu_r')
+        relief_rgba = rdbu_cmap(relief_norm)
+        relief_rgb = (relief_rgba[:, :, :3] * 255).astype(np.uint8)
+        relief_rgb[~valid_mask] = [128, 128, 128]
+        
+        img_relief = Image.fromarray(relief_rgb, mode='RGB')
+        buffered = io.BytesIO()
+        img_relief.save(buffered, format="PNG")
+        img_str = base64.b64encode(buffered.getvalue()).decode()
+        
+        folium.raster_layers.ImageOverlay(
+            image=f'data:image/png;base64,{img_str}',
+            bounds=[[bounds.bottom, bounds.left], [bounds.top, bounds.right]],
+            opacity=0.75,
+            name='🏛️ Local Relief Model (Archaeological)',
+            overlay=True,
+            control=True,
+            show=True  # DEFAULT ON
+        ).add_to(m)
+        
+        # ============================================================
+        # LAYER 2: Multi-Directional Hillshade
+        # ============================================================
+        dx = sobel(dtm_filled, axis=1) / 8.0
+        dy = sobel(dtm_filled, axis=0) / 8.0
+        slope = np.arctan(np.sqrt(dx**2 + dy**2))
+        aspect = np.arctan2(-dy, dx)
+        
+        azimuths = [315, 45, 225, 135]
+        altitude = 45
+        hillshades = []
+        
+        for az_deg in azimuths:
+            azimuth = np.radians(az_deg)
+            alt_rad = np.radians(altitude)
+            hs = (np.sin(alt_rad) * np.sin(slope) + 
+                  np.cos(alt_rad) * np.cos(slope) * 
+                  np.cos(azimuth - aspect))
+            hillshades.append(hs)
+        
+        hillshade_multi = np.mean(hillshades, axis=0)
+        hillshade_multi = np.clip(hillshade_multi, -1, 1)
+        hillshade_multi = ((hillshade_multi + 1) / 2 * 255).astype(np.uint8)
+        hillshade_multi[~valid_mask] = 128
+        
+        hillshade_multi_rgb = np.stack([hillshade_multi, hillshade_multi, hillshade_multi], axis=-1)
+        
+        # Add color tinting
+        dtm_norm = (dtm - np.nanpercentile(dtm[valid_mask], 2)) / \
+                   (np.nanpercentile(dtm[valid_mask], 98) - 
+                    np.nanpercentile(dtm[valid_mask], 2))
+        dtm_norm = np.clip(dtm_norm, 0, 1)
+        
+        terrain_cmap = cm.get_cmap('terrain')
+        terrain_rgba = terrain_cmap(dtm_norm)
+        terrain_rgb = (terrain_rgba[:, :, :3] * 255).astype(np.uint8)
+        
+        hillshade_multi_rgb = (hillshade_multi_rgb * 0.75 + terrain_rgb * 0.25).astype(np.uint8)
+        hillshade_multi_rgb[~valid_mask] = [128, 128, 128]
+        
+        img_multi = Image.fromarray(hillshade_multi_rgb, mode='RGB')
+        buffered_multi = io.BytesIO()
+        img_multi.save(buffered_multi, format="PNG")
+        img_str_multi = base64.b64encode(buffered_multi.getvalue()).decode()
+        
+        folium.raster_layers.ImageOverlay(
+            image=f'data:image/png;base64,{img_str_multi}',
+            bounds=[[bounds.bottom, bounds.left], [bounds.top, bounds.right]],
+            opacity=0.7,
+            name='🗻 Multi-Directional Hillshade',
+            overlay=True,
+            control=True,
+            show=False
+        ).add_to(m)
+        
+        # ============================================================
+        # LAYER 3: Standard Terrain
+        # ============================================================
+        dtm_norm_basic = (dtm - np.nanpercentile(dtm[valid_mask], 2)) / \
+                         (np.nanpercentile(dtm[valid_mask], 98) - 
+                          np.nanpercentile(dtm[valid_mask], 2))
+        dtm_norm_basic = np.clip(dtm_norm_basic, 0, 1)
+        
+        terrain_basic_rgba = terrain_cmap(dtm_norm_basic)
+        terrain_basic_rgb = (terrain_basic_rgba[:, :, :3] * 255).astype(np.uint8)
+        terrain_basic_rgb[~valid_mask] = [128, 128, 128]
+        
+        img_basic = Image.fromarray(terrain_basic_rgb, mode='RGB')
+        buffered_basic = io.BytesIO()
+        img_basic.save(buffered_basic, format="PNG")
+        img_str_basic = base64.b64encode(buffered_basic.getvalue()).decode()
+        
+        folium.raster_layers.ImageOverlay(
+            image=f'data:image/png;base64,{img_str_basic}',
+            bounds=[[bounds.bottom, bounds.left], [bounds.top, bounds.right]],
+            opacity=0.65,
+            name='🌍 Standard Terrain',
+            overlay=True,
+            control=True,
+            show=False
+        ).add_to(m)
+    
+    # Add anomaly markers
+    if data_manager.current_unified_matrix is not None:
+        gate_channel = data_manager.current_unified_matrix[:, :, :, 4]
+        
+        for idx, meta in enumerate(data_manager.current_metadata):
+            patch_score = np.mean(gate_channel[idx])
+            
+            if patch_score >= threshold:
+                row, col = meta['row'], meta['col']
+                center_row = row + 32
+                center_col = col + 32
+                x, y = rasterio.transform.xy(data_manager.reference_transform, center_row, center_col)
+                
+                if data_manager.reference_crs != 'EPSG:4326':
+                    from rasterio.warp import transform as transform_coords
+                    lon, lat = transform_coords(data_manager.reference_crs, 'EPSG:4326', [x], [y])
+                    lat, lon = lat[0], lon[0]
+                else:
+                    lat, lon = y, x
+                
+                popup_html = f"""
+                <b>🔴 Anomaly Detected</b><br>
+                <hr>
+                <b>Score:</b> {patch_score:.3f}<br>
+                <b>Patch ID:</b> {idx}<br>
+                <b>Location:</b><br>
+                Lat: {lat:.6f}<br>
+                Lon: {lon:.6f}<br>
+                <hr>
+                <i>Click map at this location to inspect</i>
+                """
+                
+                folium.CircleMarker(
+                    location=[lat, lon],
+                    radius=8,
+                    popup=folium.Popup(popup_html, max_width=300),
+                    tooltip=f"Anomaly Score: {patch_score:.3f}",
+                    color='red',
+                    fill=True,
+                    fillColor='orange',
+                    fillOpacity=0.7,
+                    weight=2
+                ).add_to(m)
+    
+    # Add boundary
+    folium.Rectangle(
+        bounds=[[bounds.bottom, bounds.left], [bounds.top, bounds.right]],
+        color='red',
+        fill=False,
+        weight=2,
+        popup=f'{aoi_name} boundary'
+    ).add_to(m)
+    
+    folium.LayerControl().add_to(m)
+    
+    return m._repr_html_()
+
+# ==============================================================================
+# PATCH VISUALIZATION
+# ==============================================================================
+
+def create_patch_viz(patch: np.ndarray, metadata: dict):
+    """Beautiful 2D patch visualization"""
+    channel_names = ['DTM', 'Slope', 'Roughness', 'NDVI', 'NDWI', 'Flow Acc', 'Flow Dir']
+    
+    fig, axes = plt.subplots(2, 4, figsize=(16, 8), facecolor='white')
+    axes = axes.flatten()
+    
+    for i in range(7):
+        ax = axes[i]
+        data = patch[i]
+        cmap = ['terrain', 'YlOrRd', 'viridis', 'RdYlGn', 'Blues', 'cividis', 'twilight'][i]
+        
+        im = ax.imshow(data, cmap=cmap, interpolation='bilinear')
+        ax.set_title(channel_names[i], fontsize=12, fontweight='bold', pad=8)
+        ax.axis('off')
+        plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
+    
+    axes[7].axis('off')
+    
+    plt.suptitle(f"Patch {metadata['patch_id']} | Row {metadata['row']} | Col {metadata['col']}", 
+                 fontsize=16, fontweight='bold', y=0.98)
+    plt.tight_layout()
+    
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', dpi=150, bbox_inches='tight', facecolor='white')
+    plt.close(fig)
+    buf.seek(0)
+    
+    return Image.open(buf)
+
+def create_3d_terrain(patch: np.ndarray, metadata: dict):
+    """Enhanced 3D terrain visualization"""
+    dtm = patch[0]
+    dtm_clean = np.nan_to_num(dtm, nan=np.nanmedian(dtm))
+    
+    rows, cols = dtm.shape
+    x, y = np.arange(cols), np.arange(rows)
+    X, Y = np.meshgrid(x, y)
+    
+    fig = go.Figure(data=[go.Surface(
+        z=dtm_clean, x=X, y=Y,
+        colorscale='earth',
+        showscale=True,
+        lighting=dict(
+            ambient=0.4,
+            diffuse=0.8,
+            fresnel=0.2,
+            specular=0.3,
+            roughness=0.5
+        ),
+        contours=dict(
+            z=dict(
+                show=True,
+                usecolormap=True,
+                highlightcolor="limegreen",
+                project=dict(z=True)
+            )
+        )
+    )])
+    
+    fig.update_layout(
+        title=f"3D Terrain · Patch {metadata['patch_id']}",
+        scene=dict(
+            xaxis_title='X (pixels)',
+            yaxis_title='Y (pixels)',
+            zaxis_title='Elevation (m)',
+            camera=dict(eye=dict(x=1.5, y=1.5, z=1.3)),
+            aspectmode='manual',
+            aspectratio=dict(x=1, y=1, z=0.5)
+        ),
+        height=600,
+        margin=dict(l=0, r=0, t=40, b=0)
+    )
+    
+    return fig
+
+# ==============================================================================
+# UI FUNCTIONS
+# ==============================================================================
+
+def load_aoi_and_generate_map(aoi_name, threshold):
+    """Load AOI and generate beautiful map"""
+    status = data_manager.load_aoi(aoi_name)
+    
+    if "✅" in status:
+        map_html = create_interactive_map(aoi_name, threshold)
+        
+        # Generate statistics (with safe access)
+        stats_html = f"""
+        <div style='padding: 15px; background: #f0f7ff; border-radius: 8px; margin: 10px 0;'>
+            <h3 style='margin-top: 0; color: #1976d2;'>📊 AOI Statistics</h3>
+            <p><b>Total Patches:</b> {len(data_manager.current_patches)}</p>
+        """
+        
+        if data_manager.reference_shape:
+            stats_html += f"<p><b>Raster Shape:</b> {data_manager.reference_shape}</p>"
+        
+        if data_manager.reference_crs:
+            stats_html += f"<p><b>CRS:</b> {data_manager.reference_crs}</p>"
+        
+        if data_manager.reference_bounds:
+            center_lat = (data_manager.reference_bounds.bottom + data_manager.reference_bounds.top) / 2
+            center_lon = (data_manager.reference_bounds.left + data_manager.reference_bounds.right) / 2
+            stats_html += f"<p><b>Center:</b> {center_lat:.6f}, {center_lon:.6f}</p>"
+        
+        if data_manager.full_dtm is not None:
+            stats_html += "<p><b>DTM Status:</b> ✅ Loaded</p>"
+        else:
+            stats_html += "<p><b>DTM Status:</b> ⚠️ Not available (using reconstructed patches)</p>"
+        
+        stats_html += "</div>"
+        
+        return status, map_html, stats_html, "", None, None
+    
+    return status, "<div style='padding: 20px;'>❌ Failed to load AOI</div>", "", "", None, None
+
+def update_threshold(threshold):
+    """Update anomaly detection threshold"""
+    if data_manager.current_aoi:
+        return create_interactive_map(data_manager.current_aoi, threshold)
+    return "<div style='padding: 20px;'>⚠️ Load an AOI first</div>"
+
+def handle_map_click(lat, lon):
+    """Handle click on map - extract and visualize patch"""
+    if data_manager.full_dtm is None:
+        return "⚠️ Load an AOI first", None, None
+    
+    from rasterio.warp import transform as transform_coords
+    
+    if data_manager.reference_crs != 'EPSG:4326':
+        x, y = transform_coords('EPSG:4326', data_manager.reference_crs, [lon], [lat])
+        lon, lat = x[0], y[0]
+    
+    row, col = rowcol(data_manager.reference_transform, lon, lat)
+    patch_idx = data_manager.find_patch_at_pixel(row, col)
+    
+    if patch_idx is None:
+        return f"❌ No patch at ({row}, {col})", None, None
+    
+    patch, metadata = data_manager.get_patch(patch_idx)
+    
+    if patch is None:
+        return "❌ Error loading patch", None, None
+    
+    # Generate visualizations
+    img_2d = create_patch_viz(patch, metadata)
+    fig_3d = create_3d_terrain(patch, metadata)
+    
+    # Get score
+    score_text = ""
+    if data_manager.current_unified_matrix is not None:
+        gate_channel = data_manager.current_unified_matrix[:, :, :, 4]
+        patch_score = np.mean(gate_channel[patch_idx])
+        score_text = f" | <span style='color: {'red' if patch_score > 0.5 else 'green'}; font-weight: bold;'>Score: {patch_score:.3f}</span>"
+    
+    info = f"<div style='padding: 10px; background: #e8f5e9; border-radius: 5px;'><b>✅ Patch {patch_idx}</b> | ID: {metadata['patch_id']}{score_text}</div>"
+    
+    return info, img_2d, fig_3d
+
+# ==============================================================================
+# BUILD INTERFACE
+# ==============================================================================
+
+def build_interface():
+    
+    custom_css = """
+    .gradio-container {
+        max-width: 1400px !important;
+    }
+    .map-container {
+        border: 2px solid #1976d2;
+        border-radius: 8px;
+        overflow: hidden;
+    }
+    """
+    
+    with gr.Blocks(theme=gr.themes.Soft(), css=custom_css, title="SONAR 2.0") as app:
+        
+        gr.Markdown("""
+        # 🗺️ SONAR 2.0 - Archaeological Anomaly Detection System
+        ### Interactive geospatial analysis with multi-layer terrain visualization
+        """)
+        
+        with gr.Row():
+            # Left sidebar - Controls
+            with gr.Column(scale=1):
+                gr.Markdown("### 🎛️ Control Panel")
+                
+                aoi_dropdown = gr.Dropdown(
+                    choices=data_manager.aoi_list,
+                    label="📍 Select Area of Interest (AOI)",
+                    value=data_manager.aoi_list[0] if data_manager.aoi_list else None,
+                    info="Choose an AOI to analyze"
+                )
+                
+                threshold_slider = gr.Slider(
+                    minimum=0.0, 
+                    maximum=1.0, 
+                    value=0.5, 
+                    step=0.05,
+                    label="🎯 Detection Threshold",
+                    info="Higher = fewer, more confident detections"
+                )
+                
+                load_btn = gr.Button("🚀 Load AOI & Generate Map", variant="primary", size="lg")
+                
+                status_box = gr.HTML(label="Status")
+                stats_box = gr.HTML(label="Statistics")
+                
+                gr.Markdown("""
+                ---
+                ### 📖 How to Use
+                
+                1. **Select AOI** from dropdown
+                2. **Click "Load AOI"** to generate map
+                3. **Explore layers** using map controls:
+                   - 🏛️ Local Relief (archaeological features)
+                   - 🗻 Multi-directional hillshade
+                   - 🌍 Standard terrain
+                4. **Click anywhere** on the map to inspect
+                5. **View 2D/3D** visualizations below
+                
+                🔴 **Red markers** = Detected anomalies  
+                🔵 **Blue marker** = AOI center
+                """)
+            
+            # Right side - Map
+            with gr.Column(scale=3):
+                gr.Markdown("### 🗺️ Interactive Map (Click to Inspect)")
+                map_display = gr.HTML(
+                    value="<div style='padding: 40px; text-align: center; background: #f5f5f5; border-radius: 8px;'>👈 Select an AOI and click 'Load AOI' to view map</div>",
+                    elem_classes=["map-container"]
+                )
+                
+                gr.Markdown("### 🔍 Manual Inspection")
+                gr.Markdown("*Enter coordinates from map click (Lat/Lon):*")
+                
+                with gr.Row():
+                    lat_input = gr.Number(label="Latitude", precision=6, scale=1)
+                    lon_input = gr.Number(label="Longitude", precision=6, scale=1)
+                    inspect_btn = gr.Button("🔎 Inspect Patch", variant="primary", scale=1)
+                
+                patch_info = gr.HTML(label="Patch Information")
+        
+        gr.Markdown("---")
+        gr.Markdown("### 📊 Detailed Patch Analysis")
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("#### 🖼️ Multi-Channel 2D View")
+                patch_2d = gr.Image(label="2D Layer Analysis", type="pil")
+            
+            with gr.Column():
+                gr.Markdown("#### 🏔️ 3D Terrain Model")
+                terrain_3d = gr.Plot(label="Interactive 3D Visualization")
+        
+        # Event handlers
+        load_btn.click(
+            fn=load_aoi_and_generate_map,
+            inputs=[aoi_dropdown, threshold_slider],
+            outputs=[status_box, map_display, stats_box, patch_info, patch_2d, terrain_3d]
+        )
+        
+        threshold_slider.change(
+            fn=update_threshold,
+            inputs=[threshold_slider],
+            outputs=[map_display]
+        )
+        
+        inspect_btn.click(
+            fn=handle_map_click,
+            inputs=[lat_input, lon_input],
+            outputs=[patch_info, patch_2d, terrain_3d]
+        )
+        
+        gr.Markdown("""
+        ---
+        ### 💡 Tips
+        - Toggle between layers using the map control (top-right)
+        - Adjust threshold to see more/fewer anomalies
+        - Click directly on red markers for quick inspection
+        - Use 3D view to assess terrain relief and features
+        
+        **Powered by SONAR 2.0** | Archaeological AI Detection System
+        """)
+    
+    return app
+
+# ==============================================================================
+# MAIN
+# ==============================================================================
+
+if __name__ == "__main__":
+    print("\n" + "="*60)
+    print("🗺️  SONAR 2.0 - Archaeological Site Detection")
+    print("="*60)
+    
+    config.extract_data_files()
+    data_manager.discover_aois()
+    
+    print(f"\n📊 System Information:")
+    print(f"   Device: {config.DEVICE}")
+    print(f"   Available AOIs: {len(data_manager.aoi_list)}")
+    print(f"   AOI Names: {', '.join(data_manager.aoi_list)}")
+    print("="*60 + "\n")
+    
+    app = build_interface()
+    
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,  # Set to True for public URL
+        show_error=True,
+        show_api=True
     )