1st commit

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+training_history/2019-12-19[[:space:]]01%3A53%3A15.480800.hdf5 filter=lfs diff=lfs merge=lfs -text
+training_history/2025-08-07_16-25-27.hdf5 filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,1786 @@
+import glob
+import gradio as gr
+import matplotlib
+import numpy as np
+from PIL import Image
+import torch
+import tempfile
+from gradio_imageslider import ImageSlider
+import plotly.graph_objects as go
+import plotly.express as px
+import open3d as o3d
+from depth_anything_v2.dpt import DepthAnythingV2
+import os
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+
+# Classification imports
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+import google.generativeai as genai
+
+import gdown
+import spaces
+import cv2
+
+
+# Import actual segmentation model components
+from models.deeplab import Deeplabv3, relu6, DepthwiseConv2D, BilinearUpsampling
+from utils.learning.metrics import dice_coef, precision, recall
+from utils.io.data import normalize
+
+# --- Classification Model Setup ---
+# Load classification model and processor
+classification_processor = AutoImageProcessor.from_pretrained("Hemg/Wound-classification")
+classification_model = AutoModelForImageClassification.from_pretrained("Hemg/Wound-classification")
+
+# Configure Gemini AI
+try:
+    # Try to get API key from Hugging Face secrets
+    gemini_api_key = os.getenv("GOOGLE_API_KEY")
+    if not gemini_api_key:
+        raise ValueError("GEMINI_API_KEY not found in environment variables")
+    
+    genai.configure(api_key=gemini_api_key)
+    gemini_model = genai.GenerativeModel("gemini-2.5-pro")
+    print("✅ Gemini AI configured successfully with API key from secrets")
+except Exception as e:
+    print(f"❌ Error configuring Gemini AI: {e}")
+    print("Please make sure GEMINI_API_KEY is set in your Hugging Face Space secrets")
+    gemini_model = None
+
+# --- Classification Functions ---
+def analyze_wound_with_gemini(image, predicted_label):
+    """
+    Analyze wound image using Gemini AI with classification context
+    
+    Args:
+        image: PIL Image
+        predicted_label: The predicted wound type from classification model
+    
+    Returns:
+        str: Gemini AI analysis
+    """
+    if image is None:
+        return "No image provided for analysis."
+    
+    if gemini_model is None:
+        return "Gemini AI is not available. Please check that GEMINI_API_KEY is properly configured in your Hugging Face Space secrets."
+    
+    try:
+        # Ensure image is in RGB format
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Create prompt that includes the classification result
+        prompt = f"""You are assisting in a medical education and research task. 
+
+Based on the wound classification model, this image has been identified as: {predicted_label}
+
+Please provide an educational analysis of this wound image focusing on:
+1. Visible characteristics of the wound (size, color, texture, edges, surrounding tissue)
+2. Educational explanation about this type of wound based on the classification: {predicted_label}
+3. General wound healing stages if applicable
+4. Key features that are typically associated with this wound type
+
+Important guidelines:
+- This is for educational and research purposes only
+- Do not provide medical advice or diagnosis
+- Keep the analysis objective and educational
+- Focus on visible features and general wound characteristics
+- Do not recommend treatments or medical interventions
+
+Please provide a comprehensive educational analysis."""
+
+        response = gemini_model.generate_content([prompt, image])
+        return response.text
+        
+    except Exception as e:
+        return f"Error analyzing image with Gemini: {str(e)}"
+
+def analyze_wound_depth_with_gemini(image, depth_map, depth_stats):
+    """
+    Analyze wound depth and severity using Gemini AI with depth analysis context
+    
+    Args:
+        image: Original wound image (PIL Image or numpy array)
+        depth_map: Depth map (numpy array)
+        depth_stats: Dictionary containing depth analysis statistics
+    
+    Returns:
+        str: Gemini AI medical assessment based on depth analysis
+    """
+    if image is None or depth_map is None:
+        return "No image or depth map provided for analysis."
+    
+    if gemini_model is None:
+        return "Gemini AI is not available. Please check that GEMINI_API_KEY is properly configured in your Hugging Face Space secrets."
+    
+    try:
+        # Convert numpy array to PIL Image if needed
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+        
+        # Ensure image is in RGB format
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Convert depth map to PIL Image for Gemini
+        if isinstance(depth_map, np.ndarray):
+            # Normalize depth map for visualization
+            norm_depth = (depth_map - depth_map.min()) / (depth_map.max() - depth_map.min()) * 255.0
+            depth_image = Image.fromarray(norm_depth.astype(np.uint8))
+        else:
+            depth_image = depth_map
+        
+        # Create detailed prompt with depth statistics
+        prompt = f"""You are a medical AI assistant specializing in wound assessment. Analyze this wound using both the original image and depth map data.
+
+DEPTH ANALYSIS DATA PROVIDED:
+- Total Wound Area: {depth_stats['total_area_cm2']:.2f} cm²
+- Mean Depth: {depth_stats['mean_depth_mm']:.1f} mm
+- Maximum Depth: {depth_stats['max_depth_mm']:.1f} mm
+- Depth Standard Deviation: {depth_stats['depth_std_mm']:.1f} mm
+- Wound Volume: {depth_stats['wound_volume_cm3']:.2f} cm³
+- Deep Tissue Involvement: {depth_stats['deep_ratio']*100:.1f}%
+- Analysis Quality: {depth_stats['analysis_quality']}
+- Depth Consistency: {depth_stats['depth_consistency']}
+
+TISSUE DEPTH DISTRIBUTION:
+- Superficial Areas (0-2mm): {depth_stats['superficial_area_cm2']:.2f} cm²
+- Partial Thickness (2-4mm): {depth_stats['partial_thickness_area_cm2']:.2f} cm²
+- Full Thickness (4-6mm): {depth_stats['full_thickness_area_cm2']:.2f} cm²
+- Deep Areas (>6mm): {depth_stats['deep_area_cm2']:.2f} cm²
+
+STATISTICAL DEPTH ANALYSIS:
+- 25th Percentile Depth: {depth_stats['depth_percentiles']['25']:.1f} mm
+- Median Depth: {depth_stats['depth_percentiles']['50']:.1f} mm
+- 75th Percentile Depth: {depth_stats['depth_percentiles']['75']:.1f} mm
+
+Please provide a comprehensive medical assessment focusing on:
+
+1. **WOUND CHARACTERISTICS ANALYSIS**
+   - Visible wound features from the original image
+   - Correlation between visual appearance and depth measurements
+   - Tissue quality assessment based on color, texture, and depth data
+
+2. **DEPTH-BASED SEVERITY ASSESSMENT**
+   - Clinical significance of the measured depths
+   - Tissue layer involvement based on depth measurements
+   - Risk assessment based on deep tissue involvement percentage
+
+3. **HEALING PROGNOSIS**
+   - Expected healing timeline based on depth and area measurements
+   - Factors that may affect healing based on depth distribution
+   - Complexity assessment based on wound volume and depth variation
+
+4. **CLINICAL CONSIDERATIONS**
+   - Significance of depth consistency/inconsistency
+   - Areas of particular concern based on depth analysis
+   - Educational insights about this type of wound presentation
+
+5. **MEASUREMENT INTERPRETATION**
+   - Clinical relevance of the statistical depth measurements
+   - What the depth distribution tells us about wound progression
+   - Comparison to typical wound depth classifications
+
+IMPORTANT GUIDELINES:
+- This is for educational and research purposes only
+- Do not provide specific medical advice or treatment recommendations
+- Focus on objective analysis of the provided measurements
+- Correlate visual findings with quantitative depth data
+- Maintain educational and clinical terminology
+- Emphasize the relationship between depth measurements and clinical significance
+
+Provide a detailed, structured medical assessment that integrates both visual and quantitative depth analysis."""
+
+        # Send both images to Gemini for analysis
+        response = gemini_model.generate_content([prompt, image, depth_image])
+        return response.text
+        
+    except Exception as e:
+        return f"Error analyzing wound with Gemini AI: {str(e)}"
+
+def classify_wound(image):
+    """
+    Classify wound type from uploaded image
+    
+    Args:
+        image: PIL Image or numpy array
+    
+    Returns:
+        dict: Classification results with confidence scores
+    """
+    if image is None:
+        return "Please upload an image"
+    
+    # Convert to PIL Image if needed
+    if isinstance(image, np.ndarray):
+        image = Image.fromarray(image)
+    
+    # Ensure image is in RGB format
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    
+    try:
+        # Process the image
+        inputs = classification_processor(images=image, return_tensors="pt")
+        
+        # Get model predictions
+        with torch.no_grad():
+            outputs = classification_model(**inputs)
+            predictions = torch.nn.functional.softmax(outputs.logits[0], dim=-1)
+        
+        # Get the predicted class labels and confidence scores
+        confidence_scores = predictions.numpy()
+        
+        # Create results dictionary
+        results = {}
+        for i, score in enumerate(confidence_scores):
+            # Get class name from model config
+            class_name = classification_model.config.id2label[i] if hasattr(classification_model.config, 'id2label') else f"Class {i}"
+            results[class_name] = float(score)
+        
+        return results
+        
+    except Exception as e:
+        return f"Error processing image: {str(e)}"
+
+def classify_and_analyze_wound(image):
+    """
+    Combined function to classify wound and get Gemini analysis
+    
+    Args:
+        image: PIL Image or numpy array
+    
+    Returns:
+        tuple: (classification_results, gemini_analysis)
+    """
+    if image is None:
+        return "Please upload an image", "Please upload an image for analysis"
+    
+    # Get classification results
+    classification_results = classify_wound(image)
+    
+    # Get the top predicted label for Gemini analysis
+    if isinstance(classification_results, dict) and classification_results:
+        # Get the label with highest confidence
+        top_label = max(classification_results.items(), key=lambda x: x[1])[0]
+        
+        # Get Gemini analysis
+        gemini_analysis = analyze_wound_with_gemini(image, top_label)
+    else:
+        top_label = "Unknown"
+        gemini_analysis = "Unable to analyze due to classification error"
+    
+    return classification_results, gemini_analysis
+
+def format_gemini_analysis(analysis):
+    """Format Gemini analysis as properly structured HTML"""
+    if not analysis or "Error" in analysis:
+        return f"""
+        <div style="
+            background-color: #fee2e2;
+            border-radius: 12px;
+            padding: 16px;
+            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+            font-family: Arial, sans-serif;
+            min-height: 300px;
+            border-left: 4px solid #ef4444;
+        ">
+            <h4 style="color: #dc2626; margin-top: 0;">Analysis Error</h4>
+            <p style="color: #991b1b;">{analysis}</p>
+        </div>
+        """
+    
+    # Parse the markdown-style response and convert to HTML
+    formatted_analysis = parse_markdown_to_html(analysis)
+    
+    return f"""
+    <div style="
+        border-radius: 12px;
+        padding: 25px;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        min-height: 300px;
+        border-left: 4px solid #d97706;
+        max-height: 600px;
+        overflow-y: auto;
+    ">
+        <h3 style="color: #d97706; margin-top: 0; margin-bottom: 20px; display: flex; align-items: center; gap: 8px;">
+            Initial Wound Analysis
+        </h3>
+        <div style="color: white; line-height: 1.7;">
+            {formatted_analysis}
+        </div>
+    </div>
+    """
+
+def format_gemini_depth_analysis(analysis):
+    """Format Gemini depth analysis as properly structured HTML for medical assessment"""
+    if not analysis or "Error" in analysis:
+        return f"""
+        <div style="color: #ffffff; line-height: 1.6;">
+            <div style="font-size: 16px; font-weight: bold; margin-bottom: 10px; color: #f44336;">
+                ❌ AI Analysis Error
+            </div>
+            <div style="color: #cccccc;">
+                {analysis}
+            </div>
+        </div>
+        """
+    
+    # Parse the markdown-style response and convert to HTML
+    formatted_analysis = parse_markdown_to_html(analysis)
+    
+    return f"""
+    <div style="color: #ffffff; line-height: 1.6;">
+        <div style="font-size: 16px; font-weight: bold; margin-bottom: 15px; color: #4CAF50;">
+            🤖 AI-Powered Medical Assessment
+        </div>
+        <div style="color: #cccccc; max-height: 400px; overflow-y: auto; padding-right: 10px;">
+            {formatted_analysis}
+        </div>
+    </div>
+    """
+
+def parse_markdown_to_html(text):
+    """Convert markdown-style text to HTML"""
+    import re
+    
+    # Replace markdown headers
+    text = re.sub(r'^### \*\*(.*?)\*\*$', r'<h4 style="color: #d97706; margin: 20px 0 10px 0; font-weight: bold;">\1</h4>', text, flags=re.MULTILINE)
+    text = re.sub(r'^#### \*\*(.*?)\*\*$', r'<h5 style="color: #f59e0b; margin: 15px 0 8px 0; font-weight: bold;">\1</h5>', text, flags=re.MULTILINE)
+    text = re.sub(r'^### (.*?)$', r'<h4 style="color: #d97706; margin: 20px 0 10px 0; font-weight: bold;">\1</h4>', text, flags=re.MULTILINE)
+    text = re.sub(r'^#### (.*?)$', r'<h5 style="color: #f59e0b; margin: 15px 0 8px 0; font-weight: bold;">\1</h5>', text, flags=re.MULTILINE)
+    
+    # Replace bold text
+    text = re.sub(r'\*\*(.*?)\*\*', r'<strong style="color: #fbbf24;">\1</strong>', text)
+    
+    # Replace italic text
+    text = re.sub(r'\*(.*?)\*', r'<em style="color: #fde68a;">\1</em>', text)
+    
+    # Replace bullet points
+    text = re.sub(r'^\*   (.*?)$', r'<li style="margin: 5px 0; color: white;">\1</li>', text, flags=re.MULTILINE)
+    text = re.sub(r'^    \*   (.*?)$', r'<li style="margin: 3px 0; margin-left: 20px; color: white;">\1</li>', text, flags=re.MULTILINE)
+    
+    # Wrap consecutive list items in ul tags
+    text = re.sub(r'(<li.*?</li>(?:\s*<li.*?</li>)*)', r'<ul style="margin: 10px 0; padding-left: 20px;">\1</ul>', text, flags=re.DOTALL)
+    
+    # Replace numbered lists
+    text = re.sub(r'^(\d+)\.\s+(.*?)$', r'<div style="margin: 8px 0; color: white;"><strong style="color: #d97706;">\1.</strong> \2</div>', text, flags=re.MULTILINE)
+    
+    # Convert paragraphs (double newlines)
+    paragraphs = text.split('\n\n')
+    formatted_paragraphs = []
+    
+    for para in paragraphs:
+        para = para.strip()
+        if para:
+            # Skip if it's already wrapped in HTML tags
+            if not (para.startswith('<') or para.endswith('>')):
+                para = f'<p style="margin: 12px 0; color: white; text-align: justify;">{para}</p>'
+            formatted_paragraphs.append(para)
+    
+    return '\n'.join(formatted_paragraphs)
+
+def combined_analysis(image):
+    """Combined function for UI that returns both outputs"""
+    classification, gemini_analysis = classify_and_analyze_wound(image)
+    formatted_analysis = format_gemini_analysis(gemini_analysis)
+    return classification, formatted_analysis
+
+
+
+
+
+# Define path and file ID
+checkpoint_dir = "checkpoints"
+os.makedirs(checkpoint_dir, exist_ok=True)
+
+model_file = os.path.join(checkpoint_dir, "depth_anything_v2_vitl.pth")
+gdrive_url = "https://drive.google.com/uc?id=141Mhq2jonkUBcVBnNqNSeyIZYtH5l4K5"
+
+# Download if not already present
+if not os.path.exists(model_file):
+    print("Downloading model from Google Drive...")
+    gdown.download(gdrive_url, model_file, quiet=False)
+
+# --- TensorFlow: Check GPU Availability ---
+gpus = tf.config.list_physical_devices('GPU')
+if gpus:
+    print("TensorFlow is using GPU")
+else:
+    print("TensorFlow is using CPU")
+
+
+
+# --- Load Actual Wound Segmentation Model ---
+class WoundSegmentationModel:
+    def __init__(self):
+        self.input_dim_x = 224
+        self.input_dim_y = 224
+        self.model = None
+        self.load_model()
+    
+    def load_model(self):
+        """Load the trained wound segmentation model"""
+        try:
+            # Try to load the most recent model
+            weight_file_name = '2025-08-07_16-25-27.hdf5'
+            model_path = f'./training_history/{weight_file_name}'
+            
+            self.model = load_model(model_path, 
+                                  custom_objects={
+                                      'recall': recall,
+                                      'precision': precision,
+                                      'dice_coef': dice_coef,
+                                      'relu6': relu6,
+                                      'DepthwiseConv2D': DepthwiseConv2D,
+                                      'BilinearUpsampling': BilinearUpsampling
+                                  })
+            print(f"Segmentation model loaded successfully from {model_path}")
+        except Exception as e:
+            print(f"Error loading segmentation model: {e}")
+            # Fallback to the older model
+            try:
+                weight_file_name = '2019-12-19 01%3A53%3A15.480800.hdf5'
+                model_path = f'./training_history/{weight_file_name}'
+                
+                self.model = load_model(model_path, 
+                                      custom_objects={
+                                          'recall': recall,
+                                          'precision': precision,
+                                          'dice_coef': dice_coef,
+                                          'relu6': relu6,
+                                          'DepthwiseConv2D': DepthwiseConv2D,
+                                          'BilinearUpsampling': BilinearUpsampling
+                                      })
+                print(f"Segmentation model loaded successfully from {model_path}")
+            except Exception as e2:
+                print(f"Error loading fallback segmentation model: {e2}")
+                self.model = None
+    
+    def preprocess_image(self, image):
+        """Preprocess the uploaded image for model input"""
+        if image is None:
+            return None
+        
+        # Convert to RGB if needed
+        if len(image.shape) == 3 and image.shape[2] == 3:
+            # Convert BGR to RGB if needed
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        
+        # Resize to model input size
+        image = cv2.resize(image, (self.input_dim_x, self.input_dim_y))
+        
+        # Normalize the image
+        image = image.astype(np.float32) / 255.0
+        
+        # Add batch dimension
+        image = np.expand_dims(image, axis=0)
+        
+        return image
+    
+    def postprocess_prediction(self, prediction):
+        """Postprocess the model prediction"""
+        # Remove batch dimension
+        prediction = prediction[0]
+        
+        # Apply threshold to get binary mask
+        threshold = 0.5
+        binary_mask = (prediction > threshold).astype(np.uint8) * 255
+        
+        return binary_mask
+    
+    def segment_wound(self, input_image):
+        """Main function to segment wound from uploaded image"""
+        if self.model is None:
+            return None, "Error: Segmentation model not loaded. Please check the model files."
+        
+        if input_image is None:
+            return None, "Please upload an image."
+        
+        try:
+            # Preprocess the image
+            processed_image = self.preprocess_image(input_image)
+            
+            if processed_image is None:
+                return None, "Error processing image."
+            
+            # Make prediction
+            prediction = self.model.predict(processed_image, verbose=0)
+            
+            # Postprocess the prediction
+            segmented_mask = self.postprocess_prediction(prediction)
+            
+            return segmented_mask, "Segmentation completed successfully!"
+            
+        except Exception as e:
+            return None, f"Error during segmentation: {str(e)}"
+
+# Initialize the segmentation model
+segmentation_model = WoundSegmentationModel()
+
+# --- PyTorch: Set Device and Load Depth Model ---
+map_device = torch.device("cuda" if torch.cuda.is_available() and torch.cuda.device_count() > 0 else "cpu")
+print(f"Using PyTorch device: {map_device}")
+
+model_configs = {
+    'vits': {'encoder': 'vits', 'features': 64, 'out_channels': [48, 96, 192, 384]},
+    'vitb': {'encoder': 'vitb', 'features': 128, 'out_channels': [96, 192, 384, 768]},
+    'vitl': {'encoder': 'vitl', 'features': 256, 'out_channels': [256, 512, 1024, 1024]},
+    'vitg': {'encoder': 'vitg', 'features': 384, 'out_channels': [1536, 1536, 1536, 1536]}
+}
+encoder = 'vitl'
+depth_model = DepthAnythingV2(**model_configs[encoder])
+state_dict = torch.load(
+    f'checkpoints/depth_anything_v2_{encoder}.pth',
+    map_location=map_device
+)
+depth_model.load_state_dict(state_dict)
+depth_model = depth_model.to(map_device).eval()
+
+
+# --- Custom CSS for unified dark theme ---
+css = """
+.gradio-container {
+    font-family: 'Segoe UI', sans-serif;
+    background-color: #121212;
+    color: #ffffff;
+    padding: 20px;
+}
+.gr-button {
+    background-color: #2c3e50;
+    color: white;
+    border-radius: 10px;
+}
+.gr-button:hover {
+    background-color: #34495e;
+}
+.gr-html, .gr-html div {
+    white-space: normal !important;
+    overflow: visible !important;
+    text-overflow: unset !important;
+    word-break: break-word !important;
+}
+#img-display-container {
+    max-height: 100vh;
+}
+#img-display-input {
+    max-height: 80vh;
+}
+#img-display-output {
+    max-height: 80vh;
+}
+#download {
+    height: 62px;
+}
+h1 {
+    text-align: center;
+    font-size: 3rem;
+    font-weight: bold;
+    margin: 2rem 0;
+    color: #ffffff;
+}
+h2 {
+    color: #ffffff;
+    text-align: center;
+    margin: 1rem 0;
+}
+.gr-tabs {
+    background-color: #1e1e1e;
+    border-radius: 10px;
+    padding: 10px;
+}
+.gr-tab-nav {
+    background-color: #2c3e50;
+    border-radius: 8px;
+}
+.gr-tab-nav button {
+    color: #ffffff !important;
+}
+.gr-tab-nav button.selected {
+    background-color: #34495e !important;
+}
+/* Card styling for consistent heights */
+.wound-card {
+    min-height: 200px !important;
+    display: flex !important;
+    flex-direction: column !important;
+    justify-content: space-between !important;
+}
+.wound-card-content {
+    flex-grow: 1 !important;
+    display: flex !important;
+    flex-direction: column !important;
+    justify-content: center !important;
+}
+/* Loading animation */
+.loading-spinner {
+    display: inline-block;
+    width: 20px;
+    height: 20px;
+    border: 3px solid #f3f3f3;
+    border-top: 3px solid #3498db;
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+}
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+"""
+
+
+
+
+
+# --- Enhanced Wound Severity Estimation Functions ---
+
+def compute_enhanced_depth_statistics(depth_map, mask, pixel_spacing_mm=0.5, depth_calibration_mm=15.0):
+    """
+    Enhanced depth analysis with proper calibration and medical standards
+    Based on wound depth classification standards:
+    - Superficial: 0-2mm (epidermis only)
+    - Partial thickness: 2-4mm (epidermis + partial dermis)
+    - Full thickness: 4-6mm (epidermis + full dermis)
+    - Deep: >6mm (involving subcutaneous tissue)
+    """
+    # Convert pixel spacing to mm
+    pixel_spacing_mm = float(pixel_spacing_mm)
+    
+    # Calculate pixel area in cm²
+    pixel_area_cm2 = (pixel_spacing_mm / 10.0) ** 2
+    
+    # Extract wound region (binary mask)
+    wound_mask = (mask > 127).astype(np.uint8)
+    
+    # Apply morphological operations to clean the mask
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+    wound_mask = cv2.morphologyEx(wound_mask, cv2.MORPH_CLOSE, kernel)
+    
+    # Get depth values only for wound region
+    wound_depths = depth_map[wound_mask > 0]
+    
+    if len(wound_depths) == 0:
+        return {
+            'total_area_cm2': 0,
+            'superficial_area_cm2': 0,
+            'partial_thickness_area_cm2': 0,
+            'full_thickness_area_cm2': 0,
+            'deep_area_cm2': 0,
+            'mean_depth_mm': 0,
+            'max_depth_mm': 0,
+            'depth_std_mm': 0,
+            'deep_ratio': 0,
+            'wound_volume_cm3': 0,
+            'depth_percentiles': {'25': 0, '50': 0, '75': 0}
+        }
+    
+    # Normalize depth relative to nearest point in wound area
+    normalized_depth_map, nearest_point_coords, max_relative_depth = normalize_depth_relative_to_nearest_point(depth_map, wound_mask)
+    
+    # Calibrate the normalized depth map for more accurate measurements
+    calibrated_depth_map = calibrate_depth_map(normalized_depth_map, reference_depth_mm=depth_calibration_mm)
+    
+    # Get calibrated depth values for wound region
+    wound_depths_mm = calibrated_depth_map[wound_mask > 0]
+    
+    # Medical depth classification
+    superficial_mask = wound_depths_mm < 2.0
+    partial_thickness_mask = (wound_depths_mm >= 2.0) & (wound_depths_mm < 4.0)
+    full_thickness_mask = (wound_depths_mm >= 4.0) & (wound_depths_mm < 6.0)
+    deep_mask = wound_depths_mm >= 6.0
+    
+    # Calculate areas
+    total_pixels = np.sum(wound_mask > 0)
+    total_area_cm2 = total_pixels * pixel_area_cm2
+    
+    superficial_area_cm2 = np.sum(superficial_mask) * pixel_area_cm2
+    partial_thickness_area_cm2 = np.sum(partial_thickness_mask) * pixel_area_cm2
+    full_thickness_area_cm2 = np.sum(full_thickness_mask) * pixel_area_cm2
+    deep_area_cm2 = np.sum(deep_mask) * pixel_area_cm2
+    
+    # Calculate depth statistics
+    mean_depth_mm = np.mean(wound_depths_mm)
+    max_depth_mm = np.max(wound_depths_mm)
+    depth_std_mm = np.std(wound_depths_mm)
+    
+    # Calculate depth percentiles
+    depth_percentiles = {
+        '25': np.percentile(wound_depths_mm, 25),
+        '50': np.percentile(wound_depths_mm, 50),
+        '75': np.percentile(wound_depths_mm, 75)
+    }
+    
+    # Calculate depth distribution statistics
+    depth_distribution = {
+        'shallow_ratio': np.sum(wound_depths_mm < 2.0) / len(wound_depths_mm) if len(wound_depths_mm) > 0 else 0,
+        'moderate_ratio': np.sum((wound_depths_mm >= 2.0) & (wound_depths_mm < 5.0)) / len(wound_depths_mm) if len(wound_depths_mm) > 0 else 0,
+        'deep_ratio': np.sum(wound_depths_mm >= 5.0) / len(wound_depths_mm) if len(wound_depths_mm) > 0 else 0
+    }
+    
+    # Calculate wound volume (approximate)
+    # Volume = area * average depth
+    wound_volume_cm3 = total_area_cm2 * (mean_depth_mm / 10.0)
+    
+    # Deep tissue ratio
+    deep_ratio = deep_area_cm2 / total_area_cm2 if total_area_cm2 > 0 else 0
+    
+    # Calculate analysis quality metrics
+    wound_pixel_count = len(wound_depths_mm)
+    analysis_quality = "High" if wound_pixel_count > 1000 else "Medium" if wound_pixel_count > 500 else "Low"
+    
+    # Calculate depth consistency (lower std dev = more consistent)
+    depth_consistency = "High" if depth_std_mm < 2.0 else "Medium" if depth_std_mm < 4.0 else "Low"
+    
+    return {
+        'total_area_cm2': total_area_cm2,
+        'superficial_area_cm2': superficial_area_cm2,
+        'partial_thickness_area_cm2': partial_thickness_area_cm2,
+        'full_thickness_area_cm2': full_thickness_area_cm2,
+        'deep_area_cm2': deep_area_cm2,
+        'mean_depth_mm': mean_depth_mm,
+        'max_depth_mm': max_depth_mm,
+        'depth_std_mm': depth_std_mm,
+        'deep_ratio': deep_ratio,
+        'wound_volume_cm3': wound_volume_cm3,
+        'depth_percentiles': depth_percentiles,
+        'depth_distribution': depth_distribution,
+        'analysis_quality': analysis_quality,
+        'depth_consistency': depth_consistency,
+        'wound_pixel_count': wound_pixel_count,
+        'nearest_point_coords': nearest_point_coords,
+        'max_relative_depth': max_relative_depth,
+        'normalized_depth_map': normalized_depth_map
+    }
+
+def classify_wound_severity_by_enhanced_metrics(depth_stats):
+    """
+    Enhanced wound severity classification based on medical standards
+    Uses multiple criteria: depth, area, volume, and tissue involvement
+    """
+    if depth_stats['total_area_cm2'] == 0:
+        return "Unknown"
+    
+    # Extract key metrics
+    total_area = depth_stats['total_area_cm2']
+    deep_area = depth_stats['deep_area_cm2']
+    full_thickness_area = depth_stats['full_thickness_area_cm2']
+    mean_depth = depth_stats['mean_depth_mm']
+    max_depth = depth_stats['max_depth_mm']
+    wound_volume = depth_stats['wound_volume_cm3']
+    deep_ratio = depth_stats['deep_ratio']
+    
+    # Medical severity classification criteria
+    severity_score = 0
+    
+    # Criterion 1: Maximum depth
+    if max_depth >= 10.0:
+        severity_score += 3  # Very severe
+    elif max_depth >= 6.0:
+        severity_score += 2  # Severe
+    elif max_depth >= 4.0:
+        severity_score += 1  # Moderate
+    
+    # Criterion 2: Mean depth
+    if mean_depth >= 5.0:
+        severity_score += 2
+    elif mean_depth >= 3.0:
+        severity_score += 1
+    
+    # Criterion 3: Deep tissue involvement ratio
+    if deep_ratio >= 0.5:
+        severity_score += 3  # More than 50% deep tissue
+    elif deep_ratio >= 0.25:
+        severity_score += 2  # 25-50% deep tissue
+    elif deep_ratio >= 0.1:
+        severity_score += 1  # 10-25% deep tissue
+    
+    # Criterion 4: Total wound area
+    if total_area >= 10.0:
+        severity_score += 2  # Large wound (>10 cm²)
+    elif total_area >= 5.0:
+        severity_score += 1  # Medium wound (5-10 cm²)
+    
+    # Criterion 5: Wound volume
+    if wound_volume >= 5.0:
+        severity_score += 2  # High volume
+    elif wound_volume >= 2.0:
+        severity_score += 1  # Medium volume
+    
+    # Determine severity based on total score
+    if severity_score >= 8:
+        return "Very Severe"
+    elif severity_score >= 6:
+        return "Severe"
+    elif severity_score >= 4:
+        return "Moderate"
+    elif severity_score >= 2:
+        return "Mild"
+    else:
+        return "Superficial"
+
+
+
+
+
+def analyze_wound_severity(image, depth_map, wound_mask, pixel_spacing_mm=0.5, depth_calibration_mm=15.0):
+    """Enhanced wound severity analysis based on depth measurements"""
+    if image is None or depth_map is None or wound_mask is None:
+        return "❌ Please upload image, depth map, and wound mask."
+
+    # Convert wound mask to grayscale if needed
+    if len(wound_mask.shape) == 3:
+        wound_mask = np.mean(wound_mask, axis=2)
+
+    # Ensure depth map and mask have same dimensions
+    if depth_map.shape[:2] != wound_mask.shape[:2]:
+        # Resize mask to match depth map
+        from PIL import Image
+        mask_pil = Image.fromarray(wound_mask.astype(np.uint8))
+        mask_pil = mask_pil.resize((depth_map.shape[1], depth_map.shape[0]))
+        wound_mask = np.array(mask_pil)
+
+    # Compute enhanced statistics with relative depth normalization
+    stats = compute_enhanced_depth_statistics(depth_map, wound_mask, pixel_spacing_mm, depth_calibration_mm)
+    
+    # Get severity based on enhanced metrics
+    severity_level = classify_wound_severity_by_enhanced_metrics(stats)
+    severity_description = get_enhanced_severity_description(severity_level)
+    
+    # Get Gemini AI analysis based on depth data
+    gemini_analysis = analyze_wound_depth_with_gemini(image, depth_map, stats)
+    
+    # Format Gemini analysis for display
+    formatted_gemini_analysis = format_gemini_depth_analysis(gemini_analysis)
+    
+    # Create depth analysis visualization
+    depth_visualization = create_depth_analysis_visualization(
+        stats['normalized_depth_map'], wound_mask, 
+        stats['nearest_point_coords'], stats['max_relative_depth']
+    )
+
+    # Enhanced severity color coding
+    severity_color = {
+        "Superficial": "#4CAF50",    # Green
+        "Mild": "#8BC34A",           # Light Green
+        "Moderate": "#FF9800",       # Orange
+        "Severe": "#F44336",         # Red
+        "Very Severe": "#9C27B0"     # Purple
+    }.get(severity_level, "#9E9E9E")    # Gray for unknown
+
+    # Create comprehensive medical report
+    report = f"""
+    <div style='padding: 20px; background-color: #1e1e1e; border-radius: 12px; box-shadow: 0 0 10px rgba(0,0,0,0.5);'>
+        <div style='font-size: 24px; font-weight: bold; color: {severity_color}; margin-bottom: 15px;'>
+            🩹 Enhanced Wound Severity Analysis
+        </div>
+
+        <div style='background-color: #2c2c2c; padding: 15px; border-radius: 8px; margin-bottom: 20px;'>
+            <div style='font-size: 18px; font-weight: bold; color: #ffffff; margin-bottom: 15px; text-align: center;'>
+                📊 Depth & Quality Analysis
+            </div>
+            <div style='color: #cccccc; line-height: 1.6; display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 20px;'>
+                <div>
+                    <div style='font-size: 16px; font-weight: bold; color: #ff9800; margin-bottom: 8px;'>� Basic Measurements</div>
+                    <div>�📏 <b>Mean Relative Depth:</b> {stats['mean_depth_mm']:.1f} mm</div>
+                    <div>📐 <b>Max Relative Depth:</b> {stats['max_depth_mm']:.1f} mm</div>
+                    <div>📊 <b>Depth Std Dev:</b> {stats['depth_std_mm']:.1f} mm</div>
+                    <div>📦 <b>Wound Volume:</b> {stats['wound_volume_cm3']:.2f} cm³</div>
+                    <div>🔥 <b>Deep Tissue Ratio:</b> {stats['deep_ratio']*100:.1f}%</div>
+                </div>
+                <div>
+                    <div style='font-size: 16px; font-weight: bold; color: #4CAF50; margin-bottom: 8px;'>📈 Statistical Analysis</div>
+                    <div>� <b>25th Percentile:</b> {stats['depth_percentiles']['25']:.1f} mm</div>
+                    <div>📊 <b>Median (50th):</b> {stats['depth_percentiles']['50']:.1f} mm</div>
+                    <div>📊 <b>75th Percentile:</b> {stats['depth_percentiles']['75']:.1f} mm</div>
+                    <div>📊 <b>Shallow Areas:</b> {stats['depth_distribution']['shallow_ratio']*100:.1f}%</div>
+                    <div>📊 <b>Moderate Areas:</b> {stats['depth_distribution']['moderate_ratio']*100:.1f}%</div>
+                </div>
+                <div>
+                    <div style='font-size: 16px; font-weight: bold; color: #2196F3; margin-bottom: 8px;'>🔍 Quality Metrics</div>
+                    <div>🔍 <b>Analysis Quality:</b> {stats['analysis_quality']}</div>
+                    <div>📏 <b>Depth Consistency:</b> {stats['depth_consistency']}</div>
+                    <div>📊 <b>Data Points:</b> {stats['wound_pixel_count']:,}</div>
+                    <div>📊 <b>Deep Areas:</b> {stats['depth_distribution']['deep_ratio']*100:.1f}%</div>
+                    <div>🎯 <b>Reference Point:</b> Nearest to camera</div>
+                </div>
+            </div>
+        </div>
+
+        <div style='background-color: #2c2c2c; padding: 15px; border-radius: 8px; margin-bottom: 20px; border-left: 4px solid {severity_color};'>
+            <div style='font-size: 18px; font-weight: bold; color: {severity_color}; margin-bottom: 10px;'>
+                📊 Medical Assessment Based on Depth Analysis
+            </div>
+            {formatted_gemini_analysis}
+        </div>
+    </div>
+    """
+
+    return report
+
+def normalize_depth_relative_to_nearest_point(depth_map, wound_mask):
+    """
+    Normalize depth map relative to the nearest point in the wound area
+    This assumes a top-down camera perspective where the closest point to camera = 0 depth
+    
+    Args:
+        depth_map: Raw depth map
+        wound_mask: Binary mask of wound region
+    
+    Returns:
+        normalized_depth: Depth values relative to nearest point (0 = nearest, positive = deeper)
+        nearest_point_coords: Coordinates of the nearest point
+        max_relative_depth: Maximum relative depth in the wound
+    """
+    if depth_map is None or wound_mask is None:
+        return depth_map, None, 0
+    
+    # Convert mask to binary
+    binary_mask = (wound_mask > 127).astype(np.uint8)
+    
+    # Find wound region coordinates
+    wound_coords = np.where(binary_mask > 0)
+    
+    if len(wound_coords[0]) == 0:
+        return depth_map, None, 0
+    
+    # Get depth values only for wound region
+    wound_depths = depth_map[wound_coords]
+    
+    # Find the nearest point (minimum depth value in wound region)
+    nearest_depth = np.min(wound_depths)
+    nearest_indices = np.where(wound_depths == nearest_depth)
+    
+    # Get coordinates of the nearest point(s)
+    nearest_point_coords = (wound_coords[0][nearest_indices[0][0]], 
+                           wound_coords[1][nearest_indices[0][0]])
+    
+    # Create normalized depth map (relative to nearest point)
+    normalized_depth = depth_map.copy()
+    normalized_depth = normalized_depth - nearest_depth
+    
+    # Ensure all values are non-negative (nearest point = 0, others = positive)
+    normalized_depth = np.maximum(normalized_depth, 0)
+    
+    # Calculate maximum relative depth in wound region
+    wound_normalized_depths = normalized_depth[wound_coords]
+    max_relative_depth = np.max(wound_normalized_depths)
+    
+    return normalized_depth, nearest_point_coords, max_relative_depth
+
+def calibrate_depth_map(depth_map, reference_depth_mm=10.0):
+    """
+    Calibrate depth map to real-world measurements using reference depth
+    This helps convert normalized depth values to actual millimeters
+    """
+    if depth_map is None:
+        return depth_map
+    
+    # Find the maximum depth value in the depth map
+    max_depth_value = np.max(depth_map)
+    min_depth_value = np.min(depth_map)
+    
+    if max_depth_value == min_depth_value:
+        return depth_map
+    
+    # Apply calibration to convert to millimeters
+    # Assuming the maximum depth in the map corresponds to reference_depth_mm
+    calibrated_depth = (depth_map - min_depth_value) / (max_depth_value - min_depth_value) * reference_depth_mm
+    
+    return calibrated_depth
+
+def create_depth_analysis_visualization(depth_map, wound_mask, nearest_point_coords, max_relative_depth):
+    """
+    Create a visualization showing the depth analysis with nearest point and deepest point highlighted
+    """
+    if depth_map is None or wound_mask is None:
+        return None
+    
+    # Create a copy of the depth map for visualization
+    vis_depth = depth_map.copy()
+    
+    # Apply colormap for better visualization
+    normalized_depth = (vis_depth - np.min(vis_depth)) / (np.max(vis_depth) - np.min(vis_depth))
+    colored_depth = (matplotlib.colormaps.get_cmap('Spectral_r')(normalized_depth)[:, :, :3] * 255).astype(np.uint8)
+    
+    # Convert to RGB if grayscale
+    if len(colored_depth.shape) == 3 and colored_depth.shape[2] == 1:
+        colored_depth = cv2.cvtColor(colored_depth, cv2.COLOR_GRAY2RGB)
+    
+    # Highlight the nearest point (reference point) with a red circle
+    if nearest_point_coords is not None:
+        y, x = nearest_point_coords
+        cv2.circle(colored_depth, (x, y), 10, (255, 0, 0), 2)  # Red circle for nearest point
+        cv2.putText(colored_depth, "REF", (x+15, y-5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)
+    
+    # Find and highlight the deepest point
+    binary_mask = (wound_mask > 127).astype(np.uint8)
+    wound_coords = np.where(binary_mask > 0)
+    
+    if len(wound_coords[0]) > 0:
+        # Get depth values for wound region
+        wound_depths = vis_depth[wound_coords]
+        max_depth_idx = np.argmax(wound_depths)
+        deepest_point_coords = (wound_coords[0][max_depth_idx], wound_coords[1][max_depth_idx])
+        
+        # Highlight the deepest point with a blue circle
+        y, x = deepest_point_coords
+        cv2.circle(colored_depth, (x, y), 12, (0, 0, 255), 3)  # Blue circle for deepest point
+        cv2.putText(colored_depth, "DEEP", (x+15, y+5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
+    
+    # Overlay wound mask outline
+    contours, _ = cv2.findContours(binary_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    cv2.drawContours(colored_depth, contours, -1, (0, 255, 0), 2)  # Green outline for wound boundary
+    
+    return colored_depth
+
+def get_enhanced_severity_description(severity):
+    """Get comprehensive medical description for severity level"""
+    descriptions = {
+        "Superficial": "Epidermis-only damage. Minimal tissue loss, typically heals within 1-2 weeks with basic wound care.",
+        "Mild": "Superficial to partial thickness wound. Limited tissue involvement, good healing potential with proper care.",
+        "Moderate": "Partial to full thickness involvement. Requires careful monitoring and may need advanced wound care techniques.",
+        "Severe": "Full thickness with deep tissue involvement. High risk of complications, requires immediate medical attention.",
+        "Very Severe": "Extensive deep tissue damage. Critical condition requiring immediate surgical intervention and specialized care.",
+        "Unknown": "Unable to determine severity due to insufficient data or poor image quality."
+    }
+    return descriptions.get(severity, "Severity assessment unavailable.")
+
+def create_sample_wound_mask(image_shape, center=None, radius=50):
+    """Create a sample circular wound mask for testing"""
+    if center is None:
+        center = (image_shape[1] // 2, image_shape[0] // 2)
+
+    mask = np.zeros(image_shape[:2], dtype=np.uint8)
+    y, x = np.ogrid[:image_shape[0], :image_shape[1]]
+
+    # Create circular mask
+    dist_from_center = np.sqrt((x - center[0])**2 + (y - center[1])**2)
+    mask[dist_from_center <= radius] = 255
+
+    return mask
+
+def create_realistic_wound_mask(image_shape, method='elliptical'):
+    """Create a more realistic wound mask with irregular shapes"""
+    h, w = image_shape[:2]
+    mask = np.zeros((h, w), dtype=np.uint8)
+
+    if method == 'elliptical':
+        # Create elliptical wound mask
+        center = (w // 2, h // 2)
+        radius_x = min(w, h) // 3
+        radius_y = min(w, h) // 4
+
+        y, x = np.ogrid[:h, :w]
+        # Add some irregularity to make it more realistic
+        ellipse = ((x - center[0])**2 / (radius_x**2) +
+                   (y - center[1])**2 / (radius_y**2)) <= 1
+
+        # Add some noise and irregularity
+        noise = np.random.random((h, w)) > 0.8
+        mask = (ellipse | noise).astype(np.uint8) * 255
+
+    elif method == 'irregular':
+        # Create irregular wound mask
+        center = (w // 2, h // 2)
+        radius = min(w, h) // 4
+
+        y, x = np.ogrid[:h, :w]
+        base_circle = np.sqrt((x - center[0])**2 + (y - center[1])**2) <= radius
+
+        # Add irregular extensions
+        extensions = np.zeros_like(base_circle)
+        for i in range(3):
+            angle = i * 2 * np.pi / 3
+            ext_x = int(center[0] + radius * 0.8 * np.cos(angle))
+            ext_y = int(center[1] + radius * 0.8 * np.sin(angle))
+            ext_radius = radius // 3
+
+            ext_circle = np.sqrt((x - ext_x)**2 + (y - ext_y)**2) <= ext_radius
+            extensions = extensions | ext_circle
+
+        mask = (base_circle | extensions).astype(np.uint8) * 255
+
+    # Apply morphological operations to smooth the mask
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+
+    return mask
+
+# --- Depth Estimation Functions ---
+
+def predict_depth(image):
+    return depth_model.infer_image(image)
+
+def calculate_max_points(image):
+    """Calculate maximum points based on image dimensions (3x pixel count)"""
+    if image is None:
+        return 10000  # Default value
+    h, w = image.shape[:2]
+    max_points = h * w * 3
+    # Ensure minimum and reasonable maximum values
+    return max(1000, min(max_points, 300000))
+
+def update_slider_on_image_upload(image):
+    """Update the points slider when an image is uploaded"""
+    max_points = calculate_max_points(image)
+    default_value = min(10000, max_points // 10)  # 10% of max points as default
+    return gr.Slider(minimum=1000, maximum=max_points, value=default_value, step=1000,
+                     label=f"Number of 3D points (max: {max_points:,})")
+
+
+def create_point_cloud(image, depth_map, focal_length_x=470.4, focal_length_y=470.4, max_points=30000):
+    """Create a point cloud from depth map using camera intrinsics with high detail"""
+    h, w = depth_map.shape
+
+    # Use smaller step for higher detail (reduced downsampling)
+    step = max(1, int(np.sqrt(h * w / max_points) * 0.5))  # Reduce step size for more detail
+
+    # Create mesh grid for camera coordinates
+    y_coords, x_coords = np.mgrid[0:h:step, 0:w:step]
+
+    # Convert to camera coordinates (normalized by focal length)
+    x_cam = (x_coords - w / 2) / focal_length_x
+    y_cam = (y_coords - h / 2) / focal_length_y
+
+    # Get depth values
+    depth_values = depth_map[::step, ::step]
+
+    # Calculate 3D points: (x_cam * depth, y_cam * depth, depth)
+    x_3d = x_cam * depth_values
+    y_3d = y_cam * depth_values
+    z_3d = depth_values
+
+    # Flatten arrays
+    points = np.stack([x_3d.flatten(), y_3d.flatten(), z_3d.flatten()], axis=1)
+
+    # Get corresponding image colors
+    image_colors = image[::step, ::step, :]
+    colors = image_colors.reshape(-1, 3) / 255.0
+
+    # Create Open3D point cloud
+    pcd = o3d.geometry.PointCloud()
+    pcd.points = o3d.utility.Vector3dVector(points)
+    pcd.colors = o3d.utility.Vector3dVector(colors)
+
+    return pcd
+
+
+def reconstruct_surface_mesh_from_point_cloud(pcd):
+    """Convert point cloud to a mesh using Poisson reconstruction with very high detail."""
+    # Estimate and orient normals with high precision
+    pcd.estimate_normals(search_param=o3d.geometry.KDTreeSearchParamHybrid(radius=0.005, max_nn=50))
+    pcd.orient_normals_consistent_tangent_plane(k=50)
+
+    # Create surface mesh with maximum detail (depth=12 for very high resolution)
+    mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(pcd, depth=12)
+
+    # Return mesh without filtering low-density vertices
+    return mesh
+
+
+def create_enhanced_3d_visualization(image, depth_map, max_points=10000):
+    """Create an enhanced 3D visualization using proper camera projection"""
+    h, w = depth_map.shape
+
+    # Downsample to avoid too many points for performance
+    step = max(1, int(np.sqrt(h * w / max_points)))
+
+    # Create mesh grid for camera coordinates
+    y_coords, x_coords = np.mgrid[0:h:step, 0:w:step]
+
+    # Convert to camera coordinates (normalized by focal length)
+    focal_length = 470.4  # Default focal length
+    x_cam = (x_coords - w / 2) / focal_length
+    y_cam = (y_coords - h / 2) / focal_length
+
+    # Get depth values
+    depth_values = depth_map[::step, ::step]
+
+    # Calculate 3D points: (x_cam * depth, y_cam * depth, depth)
+    x_3d = x_cam * depth_values
+    y_3d = y_cam * depth_values
+    z_3d = depth_values
+
+    # Flatten arrays
+    x_flat = x_3d.flatten()
+    y_flat = y_3d.flatten()
+    z_flat = z_3d.flatten()
+
+    # Get corresponding image colors
+    image_colors = image[::step, ::step, :]
+    colors_flat = image_colors.reshape(-1, 3)
+
+    # Create 3D scatter plot with proper camera projection
+    fig = go.Figure(data=[go.Scatter3d(
+        x=x_flat,
+        y=y_flat,
+        z=z_flat,
+        mode='markers',
+        marker=dict(
+            size=1.5,
+            color=colors_flat,
+            opacity=0.9
+        ),
+        hovertemplate='<b>3D Position:</b> (%{x:.3f}, %{y:.3f}, %{z:.3f})<br>' +
+                     '<b>Depth:</b> %{z:.2f}<br>' +
+                     '<extra></extra>'
+    )])
+
+    fig.update_layout(
+        title="3D Point Cloud Visualization (Camera Projection)",
+        scene=dict(
+            xaxis_title="X (meters)",
+            yaxis_title="Y (meters)",
+            zaxis_title="Z (meters)",
+            camera=dict(
+                eye=dict(x=2.0, y=2.0, z=2.0),
+                center=dict(x=0, y=0, z=0),
+                up=dict(x=0, y=0, z=1)
+            ),
+            aspectmode='data'
+        ),
+        width=700,
+        height=600
+    )
+
+    return fig
+
+def on_depth_submit(image, num_points, focal_x, focal_y):
+    original_image = image.copy()
+
+    h, w = image.shape[:2]
+
+    # Predict depth using the model
+    depth = predict_depth(image[:, :, ::-1])  # RGB to BGR if needed
+
+    # Save raw 16-bit depth
+    raw_depth = Image.fromarray(depth.astype('uint16'))
+    tmp_raw_depth = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
+    raw_depth.save(tmp_raw_depth.name)
+
+    # Normalize and convert to grayscale for display
+    norm_depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
+    norm_depth = norm_depth.astype(np.uint8)
+    colored_depth = (matplotlib.colormaps.get_cmap('Spectral_r')(norm_depth)[:, :, :3] * 255).astype(np.uint8)
+
+    gray_depth = Image.fromarray(norm_depth)
+    tmp_gray_depth = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
+    gray_depth.save(tmp_gray_depth.name)
+
+    # Create point cloud
+    pcd = create_point_cloud(original_image, norm_depth, focal_x, focal_y, max_points=num_points)
+
+    # Reconstruct mesh from point cloud
+    mesh = reconstruct_surface_mesh_from_point_cloud(pcd)
+
+    # Save mesh with faces as .ply
+    tmp_pointcloud = tempfile.NamedTemporaryFile(suffix='.ply', delete=False)
+    o3d.io.write_triangle_mesh(tmp_pointcloud.name, mesh)
+
+    # Create enhanced 3D scatter plot visualization
+    depth_3d = create_enhanced_3d_visualization(original_image, norm_depth, max_points=num_points)
+
+    return [(original_image, colored_depth), tmp_gray_depth.name, tmp_raw_depth.name, tmp_pointcloud.name, depth_3d]
+
+# --- Actual Wound Segmentation Functions ---
+def create_automatic_wound_mask(image, method='deep_learning'):
+    """
+    Automatically generate wound mask from image using the actual deep learning model
+
+    Args:
+        image: Input image (numpy array)
+        method: Segmentation method (currently only 'deep_learning' supported)
+
+    Returns:
+        mask: Binary wound mask
+    """
+    if image is None:
+        return None
+
+    # Use the actual deep learning model for segmentation
+    if method == 'deep_learning':
+        mask, _ = segmentation_model.segment_wound(image)
+        return mask
+    else:
+        # Fallback to deep learning if method not recognized
+        mask, _ = segmentation_model.segment_wound(image)
+        return mask
+
+def post_process_wound_mask(mask, min_area=100):
+    """Post-process the wound mask to remove noise and small objects"""
+    if mask is None:
+        return None
+
+    # Convert to binary if needed
+    if mask.dtype != np.uint8:
+        mask = mask.astype(np.uint8)
+
+    # Apply morphological operations to clean up
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (10, 10))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+
+    # Remove small objects using OpenCV
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    mask_clean = np.zeros_like(mask)
+
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area >= min_area:
+            cv2.fillPoly(mask_clean, [contour], 255)
+
+    # Fill holes
+    mask_clean = cv2.morphologyEx(mask_clean, cv2.MORPH_CLOSE, kernel)
+
+    return mask_clean
+
+def analyze_wound_severity_auto(image, depth_map, pixel_spacing_mm=0.5, segmentation_method='deep_learning'):
+    """Analyze wound severity with automatic mask generation using actual segmentation model"""
+    if image is None or depth_map is None:
+        return "❌ Please provide both image and depth map."
+
+    # Generate automatic wound mask using the actual model
+    auto_mask = create_automatic_wound_mask(image, method=segmentation_method)
+
+    if auto_mask is None:
+        return "❌ Failed to generate automatic wound mask. Please check if the segmentation model is loaded."
+
+    # Post-process the mask
+    processed_mask = post_process_wound_mask(auto_mask, min_area=500)
+
+    if processed_mask is None or np.sum(processed_mask > 0) == 0:
+        return "❌ No wound region detected by the segmentation model. Try uploading a different image or use manual mask."
+
+    # Analyze severity using the automatic mask
+    return analyze_wound_severity(image, depth_map, processed_mask, pixel_spacing_mm)
+
+# --- Main Gradio Interface ---
+with gr.Blocks(css=css, title="Wound Analysis System") as demo:
+    gr.HTML("<h1>Wound Analysis System</h1>")
+    #gr.Markdown("### Complete workflow: Classification → Depth Estimation → Wound Severity Analysis")
+
+    # Shared states
+    shared_image = gr.State()
+    shared_depth_map = gr.State()
+
+    with gr.Tabs():
+        
+        # Tab 1: Wound Classification
+        with gr.Tab("1. 🔍 Wound Classification & Initial Analysis"):
+            gr.Markdown("### Step 1: Classify wound type and get initial AI analysis")
+            #gr.Markdown("Upload an image to identify the wound type and receive detailed analysis from our Vision AI.")
+            
+
+            with gr.Row():
+                # Left Column - Image Upload
+                with gr.Column(scale=1):
+                    gr.HTML('<h2 style="text-align: left; color: #d97706; margin-top: 0; font-weight: bold; font-size: 1.8rem;">Upload Wound Image</h2>')
+                    classification_image_input = gr.Image(
+                        label="",
+                        type="pil",
+                        height=400
+                    )
+                    # Place Clear and Analyse buttons side by side
+                    with gr.Row():
+                        classify_clear_btn = gr.Button(
+                            "Clear",
+                            variant="secondary",
+                            size="lg",
+                            scale=1
+                        )
+                        analyse_btn = gr.Button(
+                            "Analyse",
+                            variant="primary",
+                            size="lg",
+                            scale=1
+                        )
+                # Right Column - Classification Results
+                with gr.Column(scale=1):
+                    gr.HTML('<h2 style="text-align: left; color: #d97706; margin-top: 0; font-weight: bold; font-size: 1.8rem;">Classification Results</h2>')
+                    classification_output = gr.Label(
+                        label="",
+                        num_top_classes=5,
+                        show_label=False
+                    )
+
+            # Second Row - Full Width AI Analysis
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.HTML('<h2 style="text-align: left; color: #d97706; margin-top: 2rem; margin-bottom: 1rem; font-weight: bold; font-size: 1.8rem;">Wound Visual Analysis</h2>')
+                    gemini_output = gr.HTML(
+                        value="""
+                        <div style="
+                            border-radius: 12px;
+                            padding: 20px;
+                            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+                            font-family: Arial, sans-serif;
+                            min-height: 200px;
+                            display: flex;
+                            align-items: center;
+                            justify-content: center;
+                            color: white;
+                            width: 100%;
+                            border-left: 4px solid #d97706;
+                            font-weight: bold;
+                        ">
+                            Upload an image to get AI-powered wound analysis
+                        </div>
+                        """
+                    )
+
+            # Event handlers for classification tab
+            classify_clear_btn.click(
+                fn=lambda: (None, None, """
+                    <div style="
+                        border-radius: 12px;
+                        padding: 20px;
+                        box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+                        font-family: Arial, sans-serif;
+                        min-height: 200px;
+                        display: flex;
+                        align-items: center;
+                        justify-content: center;
+                        color: white;
+                        width: 100%;
+                        border-left: 4px solid #d97706;
+                        font-weight: bold;
+                    ">
+                        Upload an image to get AI-powered wound analysis
+                    </div>
+                """),
+                inputs=None,
+                outputs=[classification_image_input, classification_output, gemini_output]
+            )
+
+            # Only run classification on image upload
+            def classify_and_store(image):
+                result = classify_wound(image)
+                return result
+
+            classification_image_input.change(
+                fn=classify_and_store,
+                inputs=classification_image_input,
+                outputs=classification_output
+            )
+
+            # Store image in shared state for next tabs
+            def store_shared_image(image):
+                return image
+
+            classification_image_input.change(
+                fn=store_shared_image,
+                inputs=classification_image_input,
+                outputs=shared_image
+            )
+
+            # Run Gemini analysis only when Analyse button is clicked
+            def run_gemini_on_click(image, classification):
+                # Get top label
+                if isinstance(classification, dict) and classification:
+                    top_label = max(classification.items(), key=lambda x: x[1])[0]
+                else:
+                    top_label = "Unknown"
+                gemini_analysis = analyze_wound_with_gemini(image, top_label)
+                formatted_analysis = format_gemini_analysis(gemini_analysis)
+                return formatted_analysis
+
+            analyse_btn.click(
+                fn=run_gemini_on_click,
+                inputs=[classification_image_input, classification_output],
+                outputs=gemini_output
+            )
+
+        # Tab 2: Depth Estimation
+        with gr.Tab("2. 📏 Depth Estimation & 3D Visualization"):
+            gr.Markdown("### Step 2: Generate depth maps and 3D visualizations")
+            gr.Markdown("This module creates depth maps and 3D point clouds from your images.")
+
+            with gr.Row():
+                load_from_classification_btn = gr.Button("🔄 Load Image from Classification Tab", variant="secondary")
+
+            with gr.Row():
+                depth_input_image = gr.Image(label="Input Image", type='numpy', elem_id='img-display-input')
+                depth_image_slider = ImageSlider(label="Depth Map with Slider View", elem_id='img-display-output')
+
+            with gr.Row():
+                depth_submit = gr.Button(value="Compute Depth", variant="primary")
+
+                points_slider = gr.Slider(minimum=1000, maximum=10000, value=10000, step=1000,
+                                         label="Number of 3D points (upload image to update max)")
+
+            with gr.Row():
+                focal_length_x = gr.Slider(minimum=100, maximum=1000, value=470.4, step=10,
+                                          label="Focal Length X (pixels)")
+                focal_length_y = gr.Slider(minimum=100, maximum=1000, value=470.4, step=10,
+                                          label="Focal Length Y (pixels)")
+
+            # Reorganized layout: 2 columns - 3D visualization on left, file outputs stacked on right
+            with gr.Row():
+                with gr.Column(scale=2):
+                    # 3D Visualization
+                    gr.Markdown("### 3D Point Cloud Visualization")
+                    gr.Markdown("Enhanced 3D visualization using proper camera projection. Hover over points to see 3D coordinates.")
+                    depth_3d_plot = gr.Plot(label="3D Point Cloud")
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("### Download Files")
+                    gray_depth_file = gr.File(label="Grayscale depth map", elem_id="download")
+                    raw_file = gr.File(label="16-bit raw output (can be considered as disparity)", elem_id="download")
+                    point_cloud_file = gr.File(label="Point Cloud (.ply)", elem_id="download")
+
+
+
+        # Tab 3: Wound Severity Analysis
+        with gr.Tab("3. 🩹 Wound Severity Analysis"):
+            gr.Markdown("### Step 3: Analyze wound severity using depth maps")
+            gr.Markdown("This module analyzes wound severity based on depth distribution and area measurements.")
+
+            with gr.Row():
+                # Load depth map from previous tab
+                load_depth_btn = gr.Button("🔄 Load Depth Map from Tab 2", variant="secondary")
+
+            with gr.Row():
+                severity_input_image = gr.Image(label="Original Image", type='numpy')
+                severity_depth_map = gr.Image(label="Depth Map (from Tab 2)", type='numpy')
+
+            with gr.Row():
+                wound_mask_input = gr.Image(label="Auto-Generated Wound Mask", type='numpy')
+                
+            with gr.Row():
+                severity_output = gr.HTML(
+                    label="🤖 AI-Powered Medical Assessment",
+                    value="""
+                    <div style='padding: 30px; background-color: #1e1e1e; border-radius: 12px; box-shadow: 0 0 10px rgba(0,0,0,0.5); text-align: center;'>
+                        <div style='font-size: 24px; font-weight: bold; color: #ff9800; margin-bottom: 15px;'>
+                            🩹 Wound Severity Analysis
+                        </div>
+                        <div style='font-size: 18px; color: #cccccc; margin-bottom: 20px;'>
+                            ⏳ Waiting for Input...
+                        </div>
+                        <div style='color: #888888; font-size: 14px;'>
+                            Please upload an image and depth map, then click "🤖 Analyze Severity with Auto-Generated Mask" to begin AI-powered medical assessment.
+                        </div>
+                    </div>
+                    """
+                )
+
+            gr.Markdown("**Note:** The deep learning segmentation model will automatically generate a wound mask when you upload an image or load a depth map.")
+
+            with gr.Row():
+                auto_severity_button = gr.Button("🤖 Analyze Severity with Auto-Generated Mask", variant="primary", size="lg")
+                pixel_spacing_slider = gr.Slider(minimum=0.1, maximum=2.0, value=0.5, step=0.1,
+                                               label="Pixel Spacing (mm/pixel)")
+                depth_calibration_slider = gr.Slider(minimum=5.0, maximum=30.0, value=15.0, step=1.0,
+                                                   label="Depth Calibration (mm)", 
+                                                   info="Adjust based on expected maximum wound depth")
+
+            #gr.Markdown("**Pixel Spacing:** Adjust based on your camera calibration. Default is 0.5 mm/pixel.")
+            #gr.Markdown("**Depth Calibration:** Adjust the maximum expected wound depth to improve measurement accuracy. For shallow wounds use 5-10mm, for deep wounds use 15-30mm.")
+
+            #gr.Markdown("**Note:** When you load a depth map or upload an image, the segmentation model will automatically generate a wound mask.")
+
+            # Update slider when image is uploaded
+            depth_input_image.change(
+                fn=update_slider_on_image_upload,
+                inputs=[depth_input_image],
+                outputs=[points_slider]
+            )
+
+            # Modified depth submit function to store depth map
+            def on_depth_submit_with_state(image, num_points, focal_x, focal_y):
+                results = on_depth_submit(image, num_points, focal_x, focal_y)
+                # Extract depth map from results for severity analysis
+                depth_map = None
+                if image is not None:
+                    depth = predict_depth(image[:, :, ::-1])  # RGB to BGR if needed
+                    # Normalize depth for severity analysis
+                    norm_depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
+                    depth_map = norm_depth.astype(np.uint8)
+                return results + [depth_map]
+
+            depth_submit.click(on_depth_submit_with_state,
+                             inputs=[depth_input_image, points_slider, focal_length_x, focal_length_y],
+                             outputs=[depth_image_slider, gray_depth_file, raw_file, point_cloud_file, depth_3d_plot, shared_depth_map])
+
+            # Function to load image from classification to depth tab
+            def load_image_from_classification(shared_img):
+                if shared_img is None:
+                    return None, "❌ No image available from classification tab. Please upload an image in Tab 1 first."
+                
+                # Convert PIL image to numpy array for depth estimation
+                if hasattr(shared_img, 'convert'):
+                    # It's a PIL image, convert to numpy
+                    img_array = np.array(shared_img)
+                    return img_array, "✅ Image loaded from classification tab successfully!"
+                else:
+                    # Already numpy array
+                    return shared_img, "✅ Image loaded from classification tab successfully!"
+            
+            # Connect the load button
+            load_from_classification_btn.click(
+                fn=load_image_from_classification,
+                inputs=shared_image,
+                outputs=[depth_input_image, gr.HTML()]
+            )
+
+            # Load depth map to severity tab and auto-generate mask
+            def load_depth_to_severity(depth_map, original_image):
+                if depth_map is None:
+                    return None, None, None, "❌ No depth map available. Please compute depth in Tab 2 first."
+                
+                # Auto-generate wound mask using segmentation model
+                if original_image is not None:
+                    auto_mask, _ = segmentation_model.segment_wound(original_image)
+                    if auto_mask is not None:
+                        # Post-process the mask
+                        processed_mask = post_process_wound_mask(auto_mask, min_area=500)
+                        if processed_mask is not None and np.sum(processed_mask > 0) > 0:
+                            return depth_map, original_image, processed_mask, "✅ Depth map loaded and wound mask auto-generated!"
+                        else:
+                            return depth_map, original_image, None, "✅ Depth map loaded but no wound detected. Try uploading a different image."
+                    else:
+                        return depth_map, original_image, None, "✅ Depth map loaded but segmentation failed. Try uploading a different image."
+                else:
+                    return depth_map, original_image, None, "✅ Depth map loaded successfully!"
+
+            load_depth_btn.click(
+                fn=load_depth_to_severity,
+                inputs=[shared_depth_map, depth_input_image],
+                outputs=[severity_depth_map, severity_input_image, wound_mask_input, gr.HTML()]
+            )
+
+            # Loading state function
+            def show_loading_state():
+                return """
+                <div style='padding: 30px; background-color: #1e1e1e; border-radius: 12px; box-shadow: 0 0 10px rgba(0,0,0,0.5); text-align: center;'>
+                    <div style='font-size: 24px; font-weight: bold; color: #ff9800; margin-bottom: 15px;'>
+                        🩹 Wound Severity Analysis
+                    </div>
+                    <div style='font-size: 18px; color: #4CAF50; margin-bottom: 20px;'>
+                        🔄 AI Analysis in Progress...
+                    </div>
+                    <div style='color: #cccccc; font-size: 14px; margin-bottom: 15px;'>
+                        • Generating wound mask with deep learning model<br>
+                        • Computing depth measurements and statistics<br>
+                        • Analyzing wound characteristics with Gemini AI<br>
+                        • Preparing comprehensive medical assessment
+                    </div>
+                    <div style='display: inline-block; width: 30px; height: 30px; border: 3px solid #f3f3f3; border-top: 3px solid #4CAF50; border-radius: 50%; animation: spin 1s linear infinite;'></div>
+                    <style>
+                        @keyframes spin {
+                            0% { transform: rotate(0deg); }
+                            100% { transform: rotate(360deg); }
+                        }
+                    </style>
+                </div>
+                """
+
+            # Automatic severity analysis function
+            def run_auto_severity_analysis(image, depth_map, pixel_spacing, depth_calibration):
+                if depth_map is None:
+                    return """
+                    <div style='padding: 30px; background-color: #1e1e1e; border-radius: 12px; box-shadow: 0 0 10px rgba(0,0,0,0.5); text-align: center;'>
+                        <div style='font-size: 24px; font-weight: bold; color: #f44336; margin-bottom: 15px;'>
+                            ❌ Error
+                        </div>
+                        <div style='font-size: 16px; color: #cccccc;'>
+                            Please load depth map from Tab 1 first.
+                        </div>
+                    </div>
+                    """
+
+                # Generate automatic wound mask using the actual model
+                auto_mask = create_automatic_wound_mask(image, method='deep_learning')
+
+                if auto_mask is None:
+                    return """
+                    <div style='padding: 30px; background-color: #1e1e1e; border-radius: 12px; box-shadow: 0 0 10px rgba(0,0,0,0.5); text-align: center;'>
+                        <div style='font-size: 24px; font-weight: bold; color: #f44336; margin-bottom: 15px;'>
+                            ❌ Error
+                        </div>
+                        <div style='font-size: 16px; color: #cccccc;'>
+                            Failed to generate automatic wound mask. Please check if the segmentation model is loaded.
+                        </div>
+                    </div>
+                    """
+
+                # Post-process the mask with fixed minimum area
+                processed_mask = post_process_wound_mask(auto_mask, min_area=500)
+
+                if processed_mask is None or np.sum(processed_mask > 0) == 0:
+                    return """
+                    <div style='padding: 30px; background-color: #1e1e1e; border-radius: 12px; box-shadow: 0 0 10px rgba(0,0,0,0.5); text-align: center;'>
+                        <div style='font-size: 24px; font-weight: bold; color: #ff9800; margin-bottom: 15px;'>
+                            ⚠️ No Wound Detected
+                        </div>
+                        <div style='font-size: 16px; color: #cccccc;'>
+                            No wound region detected by the segmentation model. Try uploading a different image or use manual mask.
+                        </div>
+                    </div>
+                    """
+
+                # Analyze severity using the automatic mask
+                return analyze_wound_severity(image, depth_map, processed_mask, pixel_spacing, depth_calibration)
+
+            # Connect event handler with loading state
+            auto_severity_button.click(
+                fn=show_loading_state,
+                inputs=[],
+                outputs=[severity_output]
+            ).then(
+                fn=run_auto_severity_analysis,
+                inputs=[severity_input_image, severity_depth_map, pixel_spacing_slider, depth_calibration_slider],
+                outputs=[severity_output]
+            )
+
+
+
+            # Auto-generate mask when image is uploaded
+            def auto_generate_mask_on_image_upload(image):
+                if image is None:
+                    return None, "❌ No image uploaded."
+                
+                # Generate automatic wound mask using segmentation model
+                auto_mask, _ = segmentation_model.segment_wound(image)
+                if auto_mask is not None:
+                    # Post-process the mask
+                    processed_mask = post_process_wound_mask(auto_mask, min_area=500)
+                    if processed_mask is not None and np.sum(processed_mask > 0) > 0:
+                        return processed_mask, "✅ Wound mask auto-generated using deep learning model!"
+                    else:
+                        return None, "✅ Image uploaded but no wound detected. Try uploading a different image."
+                else:
+                    return None, "✅ Image uploaded but segmentation failed. Try uploading a different image."
+
+            # Load shared image from classification tab
+            def load_shared_image(shared_img):
+                if shared_img is None:
+                    return gr.Image(), "❌ No image available from classification tab"
+
+                # Convert PIL image to numpy array for depth estimation
+                if hasattr(shared_img, 'convert'):
+                    # It's a PIL image, convert to numpy
+                    img_array = np.array(shared_img)
+                    return img_array, "✅ Image loaded from classification tab"
+                else:
+                    # Already numpy array
+                    return shared_img, "✅ Image loaded from classification tab"
+
+            # Auto-generate mask when image is uploaded to severity tab
+            severity_input_image.change(
+                fn=auto_generate_mask_on_image_upload,
+                inputs=[severity_input_image],
+                outputs=[wound_mask_input, gr.HTML()]
+            )
+
+
+
+if __name__ == '__main__':
+    demo.queue().launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )

depth_anything_v2/dinov2.py

@@ -0,0 +1,415 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/main/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/models/vision_transformer.py
+
+from functools import partial
+import math
+import logging
+from typing import Sequence, Tuple, Union, Callable
+
+import torch
+import torch.nn as nn
+import torch.utils.checkpoint
+from torch.nn.init import trunc_normal_
+
+from .dinov2_layers import Mlp, PatchEmbed, SwiGLUFFNFused, MemEffAttention, NestedTensorBlock as Block
+
+
+logger = logging.getLogger("dinov2")
+
+
+def named_apply(fn: Callable, module: nn.Module, name="", depth_first=True, include_root=False) -> nn.Module:
+    if not depth_first and include_root:
+        fn(module=module, name=name)
+    for child_name, child_module in module.named_children():
+        child_name = ".".join((name, child_name)) if name else child_name
+        named_apply(fn=fn, module=child_module, name=child_name, depth_first=depth_first, include_root=True)
+    if depth_first and include_root:
+        fn(module=module, name=name)
+    return module
+
+
+class BlockChunk(nn.ModuleList):
+    def forward(self, x):
+        for b in self:
+            x = b(x)
+        return x
+
+
+class DinoVisionTransformer(nn.Module):
+    def __init__(
+        self,
+        img_size=224,
+        patch_size=16,
+        in_chans=3,
+        embed_dim=768,
+        depth=12,
+        num_heads=12,
+        mlp_ratio=4.0,
+        qkv_bias=True,
+        ffn_bias=True,
+        proj_bias=True,
+        drop_path_rate=0.0,
+        drop_path_uniform=False,
+        init_values=None,  # for layerscale: None or 0 => no layerscale
+        embed_layer=PatchEmbed,
+        act_layer=nn.GELU,
+        block_fn=Block,
+        ffn_layer="mlp",
+        block_chunks=1,
+        num_register_tokens=0,
+        interpolate_antialias=False,
+        interpolate_offset=0.1,
+    ):
+        """
+        Args:
+            img_size (int, tuple): input image size
+            patch_size (int, tuple): patch size
+            in_chans (int): number of input channels
+            embed_dim (int): embedding dimension
+            depth (int): depth of transformer
+            num_heads (int): number of attention heads
+            mlp_ratio (int): ratio of mlp hidden dim to embedding dim
+            qkv_bias (bool): enable bias for qkv if True
+            proj_bias (bool): enable bias for proj in attn if True
+            ffn_bias (bool): enable bias for ffn if True
+            drop_path_rate (float): stochastic depth rate
+            drop_path_uniform (bool): apply uniform drop rate across blocks
+            weight_init (str): weight init scheme
+            init_values (float): layer-scale init values
+            embed_layer (nn.Module): patch embedding layer
+            act_layer (nn.Module): MLP activation layer
+            block_fn (nn.Module): transformer block class
+            ffn_layer (str): "mlp", "swiglu", "swiglufused" or "identity"
+            block_chunks: (int) split block sequence into block_chunks units for FSDP wrap
+            num_register_tokens: (int) number of extra cls tokens (so-called "registers")
+            interpolate_antialias: (str) flag to apply anti-aliasing when interpolating positional embeddings
+            interpolate_offset: (float) work-around offset to apply when interpolating positional embeddings
+        """
+        super().__init__()
+        norm_layer = partial(nn.LayerNorm, eps=1e-6)
+
+        self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
+        self.num_tokens = 1
+        self.n_blocks = depth
+        self.num_heads = num_heads
+        self.patch_size = patch_size
+        self.num_register_tokens = num_register_tokens
+        self.interpolate_antialias = interpolate_antialias
+        self.interpolate_offset = interpolate_offset
+
+        self.patch_embed = embed_layer(img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
+        num_patches = self.patch_embed.num_patches
+
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim))
+        assert num_register_tokens >= 0
+        self.register_tokens = (
+            nn.Parameter(torch.zeros(1, num_register_tokens, embed_dim)) if num_register_tokens else None
+        )
+
+        if drop_path_uniform is True:
+            dpr = [drop_path_rate] * depth
+        else:
+            dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  # stochastic depth decay rule
+
+        if ffn_layer == "mlp":
+            logger.info("using MLP layer as FFN")
+            ffn_layer = Mlp
+        elif ffn_layer == "swiglufused" or ffn_layer == "swiglu":
+            logger.info("using SwiGLU layer as FFN")
+            ffn_layer = SwiGLUFFNFused
+        elif ffn_layer == "identity":
+            logger.info("using Identity layer as FFN")
+
+            def f(*args, **kwargs):
+                return nn.Identity()
+
+            ffn_layer = f
+        else:
+            raise NotImplementedError
+
+        blocks_list = [
+            block_fn(
+                dim=embed_dim,
+                num_heads=num_heads,
+                mlp_ratio=mlp_ratio,
+                qkv_bias=qkv_bias,
+                proj_bias=proj_bias,
+                ffn_bias=ffn_bias,
+                drop_path=dpr[i],
+                norm_layer=norm_layer,
+                act_layer=act_layer,
+                ffn_layer=ffn_layer,
+                init_values=init_values,
+            )
+            for i in range(depth)
+        ]
+        if block_chunks > 0:
+            self.chunked_blocks = True
+            chunked_blocks = []
+            chunksize = depth // block_chunks
+            for i in range(0, depth, chunksize):
+                # this is to keep the block index consistent if we chunk the block list
+                chunked_blocks.append([nn.Identity()] * i + blocks_list[i : i + chunksize])
+            self.blocks = nn.ModuleList([BlockChunk(p) for p in chunked_blocks])
+        else:
+            self.chunked_blocks = False
+            self.blocks = nn.ModuleList(blocks_list)
+
+        self.norm = norm_layer(embed_dim)
+        self.head = nn.Identity()
+
+        self.mask_token = nn.Parameter(torch.zeros(1, embed_dim))
+
+        self.init_weights()
+
+    def init_weights(self):
+        trunc_normal_(self.pos_embed, std=0.02)
+        nn.init.normal_(self.cls_token, std=1e-6)
+        if self.register_tokens is not None:
+            nn.init.normal_(self.register_tokens, std=1e-6)
+        named_apply(init_weights_vit_timm, self)
+
+    def interpolate_pos_encoding(self, x, w, h):
+        previous_dtype = x.dtype
+        npatch = x.shape[1] - 1
+        N = self.pos_embed.shape[1] - 1
+        if npatch == N and w == h:
+            return self.pos_embed
+        pos_embed = self.pos_embed.float()
+        class_pos_embed = pos_embed[:, 0]
+        patch_pos_embed = pos_embed[:, 1:]
+        dim = x.shape[-1]
+        w0 = w // self.patch_size
+        h0 = h // self.patch_size
+        # we add a small number to avoid floating point error in the interpolation
+        # see discussion at https://github.com/facebookresearch/dino/issues/8
+        # DINOv2 with register modify the interpolate_offset from 0.1 to 0.0
+        w0, h0 = w0 + self.interpolate_offset, h0 + self.interpolate_offset
+        # w0, h0 = w0 + 0.1, h0 + 0.1
+        
+        sqrt_N = math.sqrt(N)
+        sx, sy = float(w0) / sqrt_N, float(h0) / sqrt_N
+        patch_pos_embed = nn.functional.interpolate(
+            patch_pos_embed.reshape(1, int(sqrt_N), int(sqrt_N), dim).permute(0, 3, 1, 2),
+            scale_factor=(sx, sy),
+            # (int(w0), int(h0)), # to solve the upsampling shape issue
+            mode="bicubic",
+            antialias=self.interpolate_antialias
+        )
+        
+        assert int(w0) == patch_pos_embed.shape[-2]
+        assert int(h0) == patch_pos_embed.shape[-1]
+        patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
+        return torch.cat((class_pos_embed.unsqueeze(0), patch_pos_embed), dim=1).to(previous_dtype)
+
+    def prepare_tokens_with_masks(self, x, masks=None):
+        B, nc, w, h = x.shape
+        x = self.patch_embed(x)
+        if masks is not None:
+            x = torch.where(masks.unsqueeze(-1), self.mask_token.to(x.dtype).unsqueeze(0), x)
+
+        x = torch.cat((self.cls_token.expand(x.shape[0], -1, -1), x), dim=1)
+        x = x + self.interpolate_pos_encoding(x, w, h)
+
+        if self.register_tokens is not None:
+            x = torch.cat(
+                (
+                    x[:, :1],
+                    self.register_tokens.expand(x.shape[0], -1, -1),
+                    x[:, 1:],
+                ),
+                dim=1,
+            )
+
+        return x
+
+    def forward_features_list(self, x_list, masks_list):
+        x = [self.prepare_tokens_with_masks(x, masks) for x, masks in zip(x_list, masks_list)]
+        for blk in self.blocks:
+            x = blk(x)
+
+        all_x = x
+        output = []
+        for x, masks in zip(all_x, masks_list):
+            x_norm = self.norm(x)
+            output.append(
+                {
+                    "x_norm_clstoken": x_norm[:, 0],
+                    "x_norm_regtokens": x_norm[:, 1 : self.num_register_tokens + 1],
+                    "x_norm_patchtokens": x_norm[:, self.num_register_tokens + 1 :],
+                    "x_prenorm": x,
+                    "masks": masks,
+                }
+            )
+        return output
+
+    def forward_features(self, x, masks=None):
+        if isinstance(x, list):
+            return self.forward_features_list(x, masks)
+
+        x = self.prepare_tokens_with_masks(x, masks)
+
+        for blk in self.blocks:
+            x = blk(x)
+
+        x_norm = self.norm(x)
+        return {
+            "x_norm_clstoken": x_norm[:, 0],
+            "x_norm_regtokens": x_norm[:, 1 : self.num_register_tokens + 1],
+            "x_norm_patchtokens": x_norm[:, self.num_register_tokens + 1 :],
+            "x_prenorm": x,
+            "masks": masks,
+        }
+
+    def _get_intermediate_layers_not_chunked(self, x, n=1):
+        x = self.prepare_tokens_with_masks(x)
+        # If n is an int, take the n last blocks. If it's a list, take them
+        output, total_block_len = [], len(self.blocks)
+        blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n
+        for i, blk in enumerate(self.blocks):
+            x = blk(x)
+            if i in blocks_to_take:
+                output.append(x)
+        assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found"
+        return output
+
+    def _get_intermediate_layers_chunked(self, x, n=1):
+        x = self.prepare_tokens_with_masks(x)
+        output, i, total_block_len = [], 0, len(self.blocks[-1])
+        # If n is an int, take the n last blocks. If it's a list, take them
+        blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n
+        for block_chunk in self.blocks:
+            for blk in block_chunk[i:]:  # Passing the nn.Identity()
+                x = blk(x)
+                if i in blocks_to_take:
+                    output.append(x)
+                i += 1
+        assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found"
+        return output
+
+    def get_intermediate_layers(
+        self,
+        x: torch.Tensor,
+        n: Union[int, Sequence] = 1,  # Layers or n last layers to take
+        reshape: bool = False,
+        return_class_token: bool = False,
+        norm=True
+    ) -> Tuple[Union[torch.Tensor, Tuple[torch.Tensor]]]:
+        if self.chunked_blocks:
+            outputs = self._get_intermediate_layers_chunked(x, n)
+        else:
+            outputs = self._get_intermediate_layers_not_chunked(x, n)
+        if norm:
+            outputs = [self.norm(out) for out in outputs]
+        class_tokens = [out[:, 0] for out in outputs]
+        outputs = [out[:, 1 + self.num_register_tokens:] for out in outputs]
+        if reshape:
+            B, _, w, h = x.shape
+            outputs = [
+                out.reshape(B, w // self.patch_size, h // self.patch_size, -1).permute(0, 3, 1, 2).contiguous()
+                for out in outputs
+            ]
+        if return_class_token:
+            return tuple(zip(outputs, class_tokens))
+        return tuple(outputs)
+
+    def forward(self, *args, is_training=False, **kwargs):
+        ret = self.forward_features(*args, **kwargs)
+        if is_training:
+            return ret
+        else:
+            return self.head(ret["x_norm_clstoken"])
+
+
+def init_weights_vit_timm(module: nn.Module, name: str = ""):
+    """ViT weight initialization, original timm impl (for reproducibility)"""
+    if isinstance(module, nn.Linear):
+        trunc_normal_(module.weight, std=0.02)
+        if module.bias is not None:
+            nn.init.zeros_(module.bias)
+
+
+def vit_small(patch_size=16, num_register_tokens=0, **kwargs):
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=384,
+        depth=12,
+        num_heads=6,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+    return model
+
+
+def vit_base(patch_size=16, num_register_tokens=0, **kwargs):
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=768,
+        depth=12,
+        num_heads=12,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+    return model
+
+
+def vit_large(patch_size=16, num_register_tokens=0, **kwargs):
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=1024,
+        depth=24,
+        num_heads=16,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+    return model
+
+
+def vit_giant2(patch_size=16, num_register_tokens=0, **kwargs):
+    """
+    Close to ViT-giant, with embed-dim 1536 and 24 heads => embed-dim per head 64
+    """
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=1536,
+        depth=40,
+        num_heads=24,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+    return model
+
+
+def DINOv2(model_name):
+    model_zoo = {
+        "vits": vit_small, 
+        "vitb": vit_base, 
+        "vitl": vit_large, 
+        "vitg": vit_giant2
+    }
+    
+    return model_zoo[model_name](
+        img_size=518,
+        patch_size=14,
+        init_values=1.0,
+        ffn_layer="mlp" if model_name != "vitg" else "swiglufused",
+        block_chunks=0,
+        num_register_tokens=0,
+        interpolate_antialias=False,
+        interpolate_offset=0.1
+    )

depth_anything_v2/dinov2_layers/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from .mlp import Mlp
+from .patch_embed import PatchEmbed
+from .swiglu_ffn import SwiGLUFFN, SwiGLUFFNFused
+from .block import NestedTensorBlock
+from .attention import MemEffAttention

depth_anything_v2/dinov2_layers/attention.py

@@ -0,0 +1,83 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/models/vision_transformer.py
+
+import logging
+
+from torch import Tensor
+from torch import nn
+
+
+logger = logging.getLogger("dinov2")
+
+
+try:
+    from xformers.ops import memory_efficient_attention, unbind, fmha
+
+    XFORMERS_AVAILABLE = True
+except ImportError:
+    logger.warning("xFormers not available")
+    XFORMERS_AVAILABLE = False
+
+
+class Attention(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int = 8,
+        qkv_bias: bool = False,
+        proj_bias: bool = True,
+        attn_drop: float = 0.0,
+        proj_drop: float = 0.0,
+    ) -> None:
+        super().__init__()
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+        self.scale = head_dim**-0.5
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim, bias=proj_bias)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+    def forward(self, x: Tensor) -> Tensor:
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+
+        q, k, v = qkv[0] * self.scale, qkv[1], qkv[2]
+        attn = q @ k.transpose(-2, -1)
+
+        attn = attn.softmax(dim=-1)
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class MemEffAttention(Attention):
+    def forward(self, x: Tensor, attn_bias=None) -> Tensor:
+        if not XFORMERS_AVAILABLE:
+            assert attn_bias is None, "xFormers is required for nested tensors usage"
+            return super().forward(x)
+
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads)
+
+        q, k, v = unbind(qkv, 2)
+
+        x = memory_efficient_attention(q, k, v, attn_bias=attn_bias)
+        x = x.reshape([B, N, C])
+
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+        

depth_anything_v2/dinov2_layers/block.py

@@ -0,0 +1,252 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/patch_embed.py
+
+import logging
+from typing import Callable, List, Any, Tuple, Dict
+
+import torch
+from torch import nn, Tensor
+
+from .attention import Attention, MemEffAttention
+from .drop_path import DropPath
+from .layer_scale import LayerScale
+from .mlp import Mlp
+
+
+logger = logging.getLogger("dinov2")
+
+
+try:
+    from xformers.ops import fmha
+    from xformers.ops import scaled_index_add, index_select_cat
+
+    XFORMERS_AVAILABLE = True
+except ImportError:
+    logger.warning("xFormers not available")
+    XFORMERS_AVAILABLE = False
+
+
+class Block(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int,
+        mlp_ratio: float = 4.0,
+        qkv_bias: bool = False,
+        proj_bias: bool = True,
+        ffn_bias: bool = True,
+        drop: float = 0.0,
+        attn_drop: float = 0.0,
+        init_values=None,
+        drop_path: float = 0.0,
+        act_layer: Callable[..., nn.Module] = nn.GELU,
+        norm_layer: Callable[..., nn.Module] = nn.LayerNorm,
+        attn_class: Callable[..., nn.Module] = Attention,
+        ffn_layer: Callable[..., nn.Module] = Mlp,
+    ) -> None:
+        super().__init__()
+        # print(f"biases: qkv: {qkv_bias}, proj: {proj_bias}, ffn: {ffn_bias}")
+        self.norm1 = norm_layer(dim)
+        self.attn = attn_class(
+            dim,
+            num_heads=num_heads,
+            qkv_bias=qkv_bias,
+            proj_bias=proj_bias,
+            attn_drop=attn_drop,
+            proj_drop=drop,
+        )
+        self.ls1 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+        self.drop_path1 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.norm2 = norm_layer(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = ffn_layer(
+            in_features=dim,
+            hidden_features=mlp_hidden_dim,
+            act_layer=act_layer,
+            drop=drop,
+            bias=ffn_bias,
+        )
+        self.ls2 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+        self.drop_path2 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.sample_drop_ratio = drop_path
+
+    def forward(self, x: Tensor) -> Tensor:
+        def attn_residual_func(x: Tensor) -> Tensor:
+            return self.ls1(self.attn(self.norm1(x)))
+
+        def ffn_residual_func(x: Tensor) -> Tensor:
+            return self.ls2(self.mlp(self.norm2(x)))
+
+        if self.training and self.sample_drop_ratio > 0.1:
+            # the overhead is compensated only for a drop path rate larger than 0.1
+            x = drop_add_residual_stochastic_depth(
+                x,
+                residual_func=attn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+            )
+            x = drop_add_residual_stochastic_depth(
+                x,
+                residual_func=ffn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+            )
+        elif self.training and self.sample_drop_ratio > 0.0:
+            x = x + self.drop_path1(attn_residual_func(x))
+            x = x + self.drop_path1(ffn_residual_func(x))  # FIXME: drop_path2
+        else:
+            x = x + attn_residual_func(x)
+            x = x + ffn_residual_func(x)
+        return x
+
+
+def drop_add_residual_stochastic_depth(
+    x: Tensor,
+    residual_func: Callable[[Tensor], Tensor],
+    sample_drop_ratio: float = 0.0,
+) -> Tensor:
+    # 1) extract subset using permutation
+    b, n, d = x.shape
+    sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1)
+    brange = (torch.randperm(b, device=x.device))[:sample_subset_size]
+    x_subset = x[brange]
+
+    # 2) apply residual_func to get residual
+    residual = residual_func(x_subset)
+
+    x_flat = x.flatten(1)
+    residual = residual.flatten(1)
+
+    residual_scale_factor = b / sample_subset_size
+
+    # 3) add the residual
+    x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor)
+    return x_plus_residual.view_as(x)
+
+
+def get_branges_scales(x, sample_drop_ratio=0.0):
+    b, n, d = x.shape
+    sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1)
+    brange = (torch.randperm(b, device=x.device))[:sample_subset_size]
+    residual_scale_factor = b / sample_subset_size
+    return brange, residual_scale_factor
+
+
+def add_residual(x, brange, residual, residual_scale_factor, scaling_vector=None):
+    if scaling_vector is None:
+        x_flat = x.flatten(1)
+        residual = residual.flatten(1)
+        x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor)
+    else:
+        x_plus_residual = scaled_index_add(
+            x, brange, residual.to(dtype=x.dtype), scaling=scaling_vector, alpha=residual_scale_factor
+        )
+    return x_plus_residual
+
+
+attn_bias_cache: Dict[Tuple, Any] = {}
+
+
+def get_attn_bias_and_cat(x_list, branges=None):
+    """
+    this will perform the index select, cat the tensors, and provide the attn_bias from cache
+    """
+    batch_sizes = [b.shape[0] for b in branges] if branges is not None else [x.shape[0] for x in x_list]
+    all_shapes = tuple((b, x.shape[1]) for b, x in zip(batch_sizes, x_list))
+    if all_shapes not in attn_bias_cache.keys():
+        seqlens = []
+        for b, x in zip(batch_sizes, x_list):
+            for _ in range(b):
+                seqlens.append(x.shape[1])
+        attn_bias = fmha.BlockDiagonalMask.from_seqlens(seqlens)
+        attn_bias._batch_sizes = batch_sizes
+        attn_bias_cache[all_shapes] = attn_bias
+
+    if branges is not None:
+        cat_tensors = index_select_cat([x.flatten(1) for x in x_list], branges).view(1, -1, x_list[0].shape[-1])
+    else:
+        tensors_bs1 = tuple(x.reshape([1, -1, *x.shape[2:]]) for x in x_list)
+        cat_tensors = torch.cat(tensors_bs1, dim=1)
+
+    return attn_bias_cache[all_shapes], cat_tensors
+
+
+def drop_add_residual_stochastic_depth_list(
+    x_list: List[Tensor],
+    residual_func: Callable[[Tensor, Any], Tensor],
+    sample_drop_ratio: float = 0.0,
+    scaling_vector=None,
+) -> Tensor:
+    # 1) generate random set of indices for dropping samples in the batch
+    branges_scales = [get_branges_scales(x, sample_drop_ratio=sample_drop_ratio) for x in x_list]
+    branges = [s[0] for s in branges_scales]
+    residual_scale_factors = [s[1] for s in branges_scales]
+
+    # 2) get attention bias and index+concat the tensors
+    attn_bias, x_cat = get_attn_bias_and_cat(x_list, branges)
+
+    # 3) apply residual_func to get residual, and split the result
+    residual_list = attn_bias.split(residual_func(x_cat, attn_bias=attn_bias))  # type: ignore
+
+    outputs = []
+    for x, brange, residual, residual_scale_factor in zip(x_list, branges, residual_list, residual_scale_factors):
+        outputs.append(add_residual(x, brange, residual, residual_scale_factor, scaling_vector).view_as(x))
+    return outputs
+
+
+class NestedTensorBlock(Block):
+    def forward_nested(self, x_list: List[Tensor]) -> List[Tensor]:
+        """
+        x_list contains a list of tensors to nest together and run
+        """
+        assert isinstance(self.attn, MemEffAttention)
+
+        if self.training and self.sample_drop_ratio > 0.0:
+
+            def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.attn(self.norm1(x), attn_bias=attn_bias)
+
+            def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.mlp(self.norm2(x))
+
+            x_list = drop_add_residual_stochastic_depth_list(
+                x_list,
+                residual_func=attn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+                scaling_vector=self.ls1.gamma if isinstance(self.ls1, LayerScale) else None,
+            )
+            x_list = drop_add_residual_stochastic_depth_list(
+                x_list,
+                residual_func=ffn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+                scaling_vector=self.ls2.gamma if isinstance(self.ls1, LayerScale) else None,
+            )
+            return x_list
+        else:
+
+            def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.ls1(self.attn(self.norm1(x), attn_bias=attn_bias))
+
+            def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.ls2(self.mlp(self.norm2(x)))
+
+            attn_bias, x = get_attn_bias_and_cat(x_list)
+            x = x + attn_residual_func(x, attn_bias=attn_bias)
+            x = x + ffn_residual_func(x)
+            return attn_bias.split(x)
+
+    def forward(self, x_or_x_list):
+        if isinstance(x_or_x_list, Tensor):
+            return super().forward(x_or_x_list)
+        elif isinstance(x_or_x_list, list):
+            assert XFORMERS_AVAILABLE, "Please install xFormers for nested tensors usage"
+            return self.forward_nested(x_or_x_list)
+        else:
+            raise AssertionError

depth_anything_v2/dinov2_layers/drop_path.py

@@ -0,0 +1,35 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/drop.py
+
+
+from torch import nn
+
+
+def drop_path(x, drop_prob: float = 0.0, training: bool = False):
+    if drop_prob == 0.0 or not training:
+        return x
+    keep_prob = 1 - drop_prob
+    shape = (x.shape[0],) + (1,) * (x.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
+    random_tensor = x.new_empty(shape).bernoulli_(keep_prob)
+    if keep_prob > 0.0:
+        random_tensor.div_(keep_prob)
+    output = x * random_tensor
+    return output
+
+
+class DropPath(nn.Module):
+    """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks)."""
+
+    def __init__(self, drop_prob=None):
+        super(DropPath, self).__init__()
+        self.drop_prob = drop_prob
+
+    def forward(self, x):
+        return drop_path(x, self.drop_prob, self.training)

depth_anything_v2/dinov2_layers/layer_scale.py

@@ -0,0 +1,28 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Modified from: https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/vision_transformer.py#L103-L110
+
+from typing import Union
+
+import torch
+from torch import Tensor
+from torch import nn
+
+
+class LayerScale(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        init_values: Union[float, Tensor] = 1e-5,
+        inplace: bool = False,
+    ) -> None:
+        super().__init__()
+        self.inplace = inplace
+        self.gamma = nn.Parameter(init_values * torch.ones(dim))
+
+    def forward(self, x: Tensor) -> Tensor:
+        return x.mul_(self.gamma) if self.inplace else x * self.gamma

depth_anything_v2/dinov2_layers/mlp.py

@@ -0,0 +1,41 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/mlp.py
+
+
+from typing import Callable, Optional
+
+from torch import Tensor, nn
+
+
+class Mlp(nn.Module):
+    def __init__(
+        self,
+        in_features: int,
+        hidden_features: Optional[int] = None,
+        out_features: Optional[int] = None,
+        act_layer: Callable[..., nn.Module] = nn.GELU,
+        drop: float = 0.0,
+        bias: bool = True,
+    ) -> None:
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = nn.Linear(in_features, hidden_features, bias=bias)
+        self.act = act_layer()
+        self.fc2 = nn.Linear(hidden_features, out_features, bias=bias)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x

depth_anything_v2/dinov2_layers/patch_embed.py

@@ -0,0 +1,89 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/patch_embed.py
+
+from typing import Callable, Optional, Tuple, Union
+
+from torch import Tensor
+import torch.nn as nn
+
+
+def make_2tuple(x):
+    if isinstance(x, tuple):
+        assert len(x) == 2
+        return x
+
+    assert isinstance(x, int)
+    return (x, x)
+
+
+class PatchEmbed(nn.Module):
+    """
+    2D image to patch embedding: (B,C,H,W) -> (B,N,D)
+
+    Args:
+        img_size: Image size.
+        patch_size: Patch token size.
+        in_chans: Number of input image channels.
+        embed_dim: Number of linear projection output channels.
+        norm_layer: Normalization layer.
+    """
+
+    def __init__(
+        self,
+        img_size: Union[int, Tuple[int, int]] = 224,
+        patch_size: Union[int, Tuple[int, int]] = 16,
+        in_chans: int = 3,
+        embed_dim: int = 768,
+        norm_layer: Optional[Callable] = None,
+        flatten_embedding: bool = True,
+    ) -> None:
+        super().__init__()
+
+        image_HW = make_2tuple(img_size)
+        patch_HW = make_2tuple(patch_size)
+        patch_grid_size = (
+            image_HW[0] // patch_HW[0],
+            image_HW[1] // patch_HW[1],
+        )
+
+        self.img_size = image_HW
+        self.patch_size = patch_HW
+        self.patches_resolution = patch_grid_size
+        self.num_patches = patch_grid_size[0] * patch_grid_size[1]
+
+        self.in_chans = in_chans
+        self.embed_dim = embed_dim
+
+        self.flatten_embedding = flatten_embedding
+
+        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_HW, stride=patch_HW)
+        self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()
+
+    def forward(self, x: Tensor) -> Tensor:
+        _, _, H, W = x.shape
+        patch_H, patch_W = self.patch_size
+
+        assert H % patch_H == 0, f"Input image height {H} is not a multiple of patch height {patch_H}"
+        assert W % patch_W == 0, f"Input image width {W} is not a multiple of patch width: {patch_W}"
+
+        x = self.proj(x)  # B C H W
+        H, W = x.size(2), x.size(3)
+        x = x.flatten(2).transpose(1, 2)  # B HW C
+        x = self.norm(x)
+        if not self.flatten_embedding:
+            x = x.reshape(-1, H, W, self.embed_dim)  # B H W C
+        return x
+
+    def flops(self) -> float:
+        Ho, Wo = self.patches_resolution
+        flops = Ho * Wo * self.embed_dim * self.in_chans * (self.patch_size[0] * self.patch_size[1])
+        if self.norm is not None:
+            flops += Ho * Wo * self.embed_dim
+        return flops

depth_anything_v2/dinov2_layers/swiglu_ffn.py

@@ -0,0 +1,63 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import Callable, Optional
+
+from torch import Tensor, nn
+import torch.nn.functional as F
+
+
+class SwiGLUFFN(nn.Module):
+    def __init__(
+        self,
+        in_features: int,
+        hidden_features: Optional[int] = None,
+        out_features: Optional[int] = None,
+        act_layer: Callable[..., nn.Module] = None,
+        drop: float = 0.0,
+        bias: bool = True,
+    ) -> None:
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.w12 = nn.Linear(in_features, 2 * hidden_features, bias=bias)
+        self.w3 = nn.Linear(hidden_features, out_features, bias=bias)
+
+    def forward(self, x: Tensor) -> Tensor:
+        x12 = self.w12(x)
+        x1, x2 = x12.chunk(2, dim=-1)
+        hidden = F.silu(x1) * x2
+        return self.w3(hidden)
+
+
+try:
+    from xformers.ops import SwiGLU
+
+    XFORMERS_AVAILABLE = True
+except ImportError:
+    SwiGLU = SwiGLUFFN
+    XFORMERS_AVAILABLE = False
+
+
+class SwiGLUFFNFused(SwiGLU):
+    def __init__(
+        self,
+        in_features: int,
+        hidden_features: Optional[int] = None,
+        out_features: Optional[int] = None,
+        act_layer: Callable[..., nn.Module] = None,
+        drop: float = 0.0,
+        bias: bool = True,
+    ) -> None:
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        hidden_features = (int(hidden_features * 2 / 3) + 7) // 8 * 8
+        super().__init__(
+            in_features=in_features,
+            hidden_features=hidden_features,
+            out_features=out_features,
+            bias=bias,
+        )

depth_anything_v2/dpt.py

@@ -0,0 +1,221 @@
+import cv2
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision.transforms import Compose
+
+from .dinov2 import DINOv2
+from .util.blocks import FeatureFusionBlock, _make_scratch
+from .util.transform import Resize, NormalizeImage, PrepareForNet
+
+
+def _make_fusion_block(features, use_bn, size=None):
+    return FeatureFusionBlock(
+        features,
+        nn.ReLU(False),
+        deconv=False,
+        bn=use_bn,
+        expand=False,
+        align_corners=True,
+        size=size,
+    )
+
+
+class ConvBlock(nn.Module):
+    def __init__(self, in_feature, out_feature):
+        super().__init__()
+        
+        self.conv_block = nn.Sequential(
+            nn.Conv2d(in_feature, out_feature, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(out_feature),
+            nn.ReLU(True)
+        )
+    
+    def forward(self, x):
+        return self.conv_block(x)
+
+
+class DPTHead(nn.Module):
+    def __init__(
+        self, 
+        in_channels, 
+        features=256, 
+        use_bn=False, 
+        out_channels=[256, 512, 1024, 1024], 
+        use_clstoken=False
+    ):
+        super(DPTHead, self).__init__()
+        
+        self.use_clstoken = use_clstoken
+        
+        self.projects = nn.ModuleList([
+            nn.Conv2d(
+                in_channels=in_channels,
+                out_channels=out_channel,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+            ) for out_channel in out_channels
+        ])
+        
+        self.resize_layers = nn.ModuleList([
+            nn.ConvTranspose2d(
+                in_channels=out_channels[0],
+                out_channels=out_channels[0],
+                kernel_size=4,
+                stride=4,
+                padding=0),
+            nn.ConvTranspose2d(
+                in_channels=out_channels[1],
+                out_channels=out_channels[1],
+                kernel_size=2,
+                stride=2,
+                padding=0),
+            nn.Identity(),
+            nn.Conv2d(
+                in_channels=out_channels[3],
+                out_channels=out_channels[3],
+                kernel_size=3,
+                stride=2,
+                padding=1)
+        ])
+        
+        if use_clstoken:
+            self.readout_projects = nn.ModuleList()
+            for _ in range(len(self.projects)):
+                self.readout_projects.append(
+                    nn.Sequential(
+                        nn.Linear(2 * in_channels, in_channels),
+                        nn.GELU()))
+        
+        self.scratch = _make_scratch(
+            out_channels,
+            features,
+            groups=1,
+            expand=False,
+        )
+        
+        self.scratch.stem_transpose = None
+        
+        self.scratch.refinenet1 = _make_fusion_block(features, use_bn)
+        self.scratch.refinenet2 = _make_fusion_block(features, use_bn)
+        self.scratch.refinenet3 = _make_fusion_block(features, use_bn)
+        self.scratch.refinenet4 = _make_fusion_block(features, use_bn)
+        
+        head_features_1 = features
+        head_features_2 = 32
+        
+        self.scratch.output_conv1 = nn.Conv2d(head_features_1, head_features_1 // 2, kernel_size=3, stride=1, padding=1)
+        self.scratch.output_conv2 = nn.Sequential(
+            nn.Conv2d(head_features_1 // 2, head_features_2, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(True),
+            nn.Conv2d(head_features_2, 1, kernel_size=1, stride=1, padding=0),
+            nn.ReLU(True),
+            nn.Identity(),
+        )
+    
+    def forward(self, out_features, patch_h, patch_w):
+        out = []
+        for i, x in enumerate(out_features):
+            if self.use_clstoken:
+                x, cls_token = x[0], x[1]
+                readout = cls_token.unsqueeze(1).expand_as(x)
+                x = self.readout_projects[i](torch.cat((x, readout), -1))
+            else:
+                x = x[0]
+            
+            x = x.permute(0, 2, 1).reshape((x.shape[0], x.shape[-1], patch_h, patch_w))
+            
+            x = self.projects[i](x)
+            x = self.resize_layers[i](x)
+            
+            out.append(x)
+        
+        layer_1, layer_2, layer_3, layer_4 = out
+        
+        layer_1_rn = self.scratch.layer1_rn(layer_1)
+        layer_2_rn = self.scratch.layer2_rn(layer_2)
+        layer_3_rn = self.scratch.layer3_rn(layer_3)
+        layer_4_rn = self.scratch.layer4_rn(layer_4)
+        
+        path_4 = self.scratch.refinenet4(layer_4_rn, size=layer_3_rn.shape[2:])        
+        path_3 = self.scratch.refinenet3(path_4, layer_3_rn, size=layer_2_rn.shape[2:])
+        path_2 = self.scratch.refinenet2(path_3, layer_2_rn, size=layer_1_rn.shape[2:])
+        path_1 = self.scratch.refinenet1(path_2, layer_1_rn)
+        
+        out = self.scratch.output_conv1(path_1)
+        out = F.interpolate(out, (int(patch_h * 14), int(patch_w * 14)), mode="bilinear", align_corners=True)
+        out = self.scratch.output_conv2(out)
+        
+        return out
+
+
+class DepthAnythingV2(nn.Module):
+    def __init__(
+        self, 
+        encoder='vitl', 
+        features=256, 
+        out_channels=[256, 512, 1024, 1024], 
+        use_bn=False, 
+        use_clstoken=False
+    ):
+        super(DepthAnythingV2, self).__init__()
+        
+        self.intermediate_layer_idx = {
+            'vits': [2, 5, 8, 11],
+            'vitb': [2, 5, 8, 11], 
+            'vitl': [4, 11, 17, 23], 
+            'vitg': [9, 19, 29, 39]
+        }
+        
+        self.encoder = encoder
+        self.pretrained = DINOv2(model_name=encoder)
+        
+        self.depth_head = DPTHead(self.pretrained.embed_dim, features, use_bn, out_channels=out_channels, use_clstoken=use_clstoken)
+    
+    def forward(self, x):
+        patch_h, patch_w = x.shape[-2] // 14, x.shape[-1] // 14
+        
+        features = self.pretrained.get_intermediate_layers(x, self.intermediate_layer_idx[self.encoder], return_class_token=True)
+        
+        depth = self.depth_head(features, patch_h, patch_w)
+        depth = F.relu(depth)
+        
+        return depth.squeeze(1)
+    
+    @torch.no_grad()
+    def infer_image(self, raw_image, input_size=518):
+        image, (h, w) = self.image2tensor(raw_image, input_size)
+        
+        depth = self.forward(image)
+        
+        depth = F.interpolate(depth[:, None], (h, w), mode="bilinear", align_corners=True)[0, 0]
+        
+        return depth.cpu().numpy()
+    
+    def image2tensor(self, raw_image, input_size=518):        
+        transform = Compose([
+            Resize(
+                width=input_size,
+                height=input_size,
+                resize_target=False,
+                keep_aspect_ratio=True,
+                ensure_multiple_of=14,
+                resize_method='lower_bound',
+                image_interpolation_method=cv2.INTER_CUBIC,
+            ),
+            NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+            PrepareForNet(),
+        ])
+        
+        h, w = raw_image.shape[:2]
+        
+        image = cv2.cvtColor(raw_image, cv2.COLOR_BGR2RGB) / 255.0
+        
+        image = transform({'image': image})['image']
+        image = torch.from_numpy(image).unsqueeze(0)
+        
+        DEVICE = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu'
+        image = image.to(DEVICE)
+        
+        return image, (h, w)

depth_anything_v2/util/blocks.py

@@ -0,0 +1,148 @@
+import torch.nn as nn
+
+
+def _make_scratch(in_shape, out_shape, groups=1, expand=False):
+    scratch = nn.Module()
+
+    out_shape1 = out_shape
+    out_shape2 = out_shape
+    out_shape3 = out_shape
+    if len(in_shape) >= 4:
+        out_shape4 = out_shape
+
+    if expand:
+        out_shape1 = out_shape
+        out_shape2 = out_shape * 2
+        out_shape3 = out_shape * 4
+        if len(in_shape) >= 4:
+            out_shape4 = out_shape * 8
+
+    scratch.layer1_rn = nn.Conv2d(in_shape[0], out_shape1, kernel_size=3, stride=1, padding=1, bias=False, groups=groups)
+    scratch.layer2_rn = nn.Conv2d(in_shape[1], out_shape2, kernel_size=3, stride=1, padding=1, bias=False, groups=groups)
+    scratch.layer3_rn = nn.Conv2d(in_shape[2], out_shape3, kernel_size=3, stride=1, padding=1, bias=False, groups=groups)
+    if len(in_shape) >= 4:
+        scratch.layer4_rn = nn.Conv2d(in_shape[3], out_shape4, kernel_size=3, stride=1, padding=1, bias=False, groups=groups)
+
+    return scratch
+
+
+class ResidualConvUnit(nn.Module):
+    """Residual convolution module.
+    """
+
+    def __init__(self, features, activation, bn):
+        """Init.
+
+        Args:
+            features (int): number of features
+        """
+        super().__init__()
+
+        self.bn = bn
+
+        self.groups=1
+
+        self.conv1 = nn.Conv2d(features, features, kernel_size=3, stride=1, padding=1, bias=True, groups=self.groups)
+        
+        self.conv2 = nn.Conv2d(features, features, kernel_size=3, stride=1, padding=1, bias=True, groups=self.groups)
+
+        if self.bn == True:
+            self.bn1 = nn.BatchNorm2d(features)
+            self.bn2 = nn.BatchNorm2d(features)
+
+        self.activation = activation
+
+        self.skip_add = nn.quantized.FloatFunctional()
+
+    def forward(self, x):
+        """Forward pass.
+
+        Args:
+            x (tensor): input
+
+        Returns:
+            tensor: output
+        """
+        
+        out = self.activation(x)
+        out = self.conv1(out)
+        if self.bn == True:
+            out = self.bn1(out)
+       
+        out = self.activation(out)
+        out = self.conv2(out)
+        if self.bn == True:
+            out = self.bn2(out)
+
+        if self.groups > 1:
+            out = self.conv_merge(out)
+
+        return self.skip_add.add(out, x)
+
+
+class FeatureFusionBlock(nn.Module):
+    """Feature fusion block.
+    """
+
+    def __init__(
+        self, 
+        features, 
+        activation, 
+        deconv=False, 
+        bn=False, 
+        expand=False, 
+        align_corners=True,
+        size=None
+    ):
+        """Init.
+        
+        Args:
+            features (int): number of features
+        """
+        super(FeatureFusionBlock, self).__init__()
+
+        self.deconv = deconv
+        self.align_corners = align_corners
+
+        self.groups=1
+
+        self.expand = expand
+        out_features = features
+        if self.expand == True:
+            out_features = features // 2
+        
+        self.out_conv = nn.Conv2d(features, out_features, kernel_size=1, stride=1, padding=0, bias=True, groups=1)
+
+        self.resConfUnit1 = ResidualConvUnit(features, activation, bn)
+        self.resConfUnit2 = ResidualConvUnit(features, activation, bn)
+        
+        self.skip_add = nn.quantized.FloatFunctional()
+
+        self.size=size
+
+    def forward(self, *xs, size=None):
+        """Forward pass.
+
+        Returns:
+            tensor: output
+        """
+        output = xs[0]
+
+        if len(xs) == 2:
+            res = self.resConfUnit1(xs[1])
+            output = self.skip_add.add(output, res)
+
+        output = self.resConfUnit2(output)
+
+        if (size is None) and (self.size is None):
+            modifier = {"scale_factor": 2}
+        elif size is None:
+            modifier = {"size": self.size}
+        else:
+            modifier = {"size": size}
+
+        output = nn.functional.interpolate(output, **modifier, mode="bilinear", align_corners=self.align_corners)
+        
+        output = self.out_conv(output)
+
+        return output

depth_anything_v2/util/transform.py

@@ -0,0 +1,158 @@
+import numpy as np
+import cv2
+
+
+class Resize(object):
+    """Resize sample to given size (width, height).
+    """
+
+    def __init__(
+        self,
+        width,
+        height,
+        resize_target=True,
+        keep_aspect_ratio=False,
+        ensure_multiple_of=1,
+        resize_method="lower_bound",
+        image_interpolation_method=cv2.INTER_AREA,
+    ):
+        """Init.
+
+        Args:
+            width (int): desired output width
+            height (int): desired output height
+            resize_target (bool, optional):
+                True: Resize the full sample (image, mask, target).
+                False: Resize image only.
+                Defaults to True.
+            keep_aspect_ratio (bool, optional):
+                True: Keep the aspect ratio of the input sample.
+                Output sample might not have the given width and height, and
+                resize behaviour depends on the parameter 'resize_method'.
+                Defaults to False.
+            ensure_multiple_of (int, optional):
+                Output width and height is constrained to be multiple of this parameter.
+                Defaults to 1.
+            resize_method (str, optional):
+                "lower_bound": Output will be at least as large as the given size.
+                "upper_bound": Output will be at max as large as the given size. (Output size might be smaller than given size.)
+                "minimal": Scale as least as possible.  (Output size might be smaller than given size.)
+                Defaults to "lower_bound".
+        """
+        self.__width = width
+        self.__height = height
+
+        self.__resize_target = resize_target
+        self.__keep_aspect_ratio = keep_aspect_ratio
+        self.__multiple_of = ensure_multiple_of
+        self.__resize_method = resize_method
+        self.__image_interpolation_method = image_interpolation_method
+
+    def constrain_to_multiple_of(self, x, min_val=0, max_val=None):
+        y = (np.round(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if max_val is not None and y > max_val:
+            y = (np.floor(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if y < min_val:
+            y = (np.ceil(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        return y
+
+    def get_size(self, width, height):
+        # determine new height and width
+        scale_height = self.__height / height
+        scale_width = self.__width / width
+
+        if self.__keep_aspect_ratio:
+            if self.__resize_method == "lower_bound":
+                # scale such that output size is lower bound
+                if scale_width > scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "upper_bound":
+                # scale such that output size is upper bound
+                if scale_width < scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "minimal":
+                # scale as least as possbile
+                if abs(1 - scale_width) < abs(1 - scale_height):
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            else:
+                raise ValueError(f"resize_method {self.__resize_method} not implemented")
+
+        if self.__resize_method == "lower_bound":
+            new_height = self.constrain_to_multiple_of(scale_height * height, min_val=self.__height)
+            new_width = self.constrain_to_multiple_of(scale_width * width, min_val=self.__width)
+        elif self.__resize_method == "upper_bound":
+            new_height = self.constrain_to_multiple_of(scale_height * height, max_val=self.__height)
+            new_width = self.constrain_to_multiple_of(scale_width * width, max_val=self.__width)
+        elif self.__resize_method == "minimal":
+            new_height = self.constrain_to_multiple_of(scale_height * height)
+            new_width = self.constrain_to_multiple_of(scale_width * width)
+        else:
+            raise ValueError(f"resize_method {self.__resize_method} not implemented")
+
+        return (new_width, new_height)
+
+    def __call__(self, sample):
+        width, height = self.get_size(sample["image"].shape[1], sample["image"].shape[0])
+        
+        # resize sample
+        sample["image"] = cv2.resize(sample["image"], (width, height), interpolation=self.__image_interpolation_method)
+
+        if self.__resize_target:
+            if "depth" in sample:
+                sample["depth"] = cv2.resize(sample["depth"], (width, height), interpolation=cv2.INTER_NEAREST)
+                
+            if "mask" in sample:
+                sample["mask"] = cv2.resize(sample["mask"].astype(np.float32), (width, height), interpolation=cv2.INTER_NEAREST)
+        
+        return sample
+
+
+class NormalizeImage(object):
+    """Normlize image by given mean and std.
+    """
+
+    def __init__(self, mean, std):
+        self.__mean = mean
+        self.__std = std
+
+    def __call__(self, sample):
+        sample["image"] = (sample["image"] - self.__mean) / self.__std
+
+        return sample
+
+
+class PrepareForNet(object):
+    """Prepare sample for usage as network input.
+    """
+
+    def __init__(self):
+        pass
+
+    def __call__(self, sample):
+        image = np.transpose(sample["image"], (2, 0, 1))
+        sample["image"] = np.ascontiguousarray(image).astype(np.float32)
+
+        if "depth" in sample:
+            depth = sample["depth"].astype(np.float32)
+            sample["depth"] = np.ascontiguousarray(depth)
+        
+        if "mask" in sample:
+            sample["mask"] = sample["mask"].astype(np.float32)
+            sample["mask"] = np.ascontiguousarray(sample["mask"])
+        
+        return sample

models/FCN.py

@@ -0,0 +1,55 @@
+import os
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Conv2D, MaxPooling2D, Dropout, UpSampling2D
+from utils.BilinearUpSampling import BilinearUpSampling2D
+
+
+def FCN_Vgg16_16s(input_shape=None, weight_decay=0., batch_momentum=0.9, batch_shape=None, classes=1):
+    if batch_shape:
+        img_input = Input(batch_shape=batch_shape)
+        image_size = batch_shape[1:3]
+    else:
+        img_input = Input(shape=input_shape)
+        image_size = input_shape[0:2]
+    # Block 1
+    x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1', kernel_regularizer='l2')(img_input)
+    x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2', kernel_regularizer='l2')(x)
+    x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
+
+    # Block 2
+    x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1', kernel_regularizer='l2')(x)
+    x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2', kernel_regularizer='l2')(x)
+    x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
+
+    # Block 3
+    x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1', kernel_regularizer='l2')(x)
+    x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2', kernel_regularizer='l2')(x)
+    x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3', kernel_regularizer='l2')(x)
+    x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)
+
+    # Block 4
+    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1', kernel_regularizer='l2')(x)
+    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2', kernel_regularizer='l2')(x)
+    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3', kernel_regularizer='l2')(x)
+    x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)
+
+    # Block 5
+    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1', kernel_regularizer='l2')(x)
+    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2', kernel_regularizer='l2')(x)
+    x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3', kernel_regularizer='l2')(x)
+
+    # Convolutional layers transfered from fully-connected layers
+    x = Conv2D(4096, (7, 7), activation='relu', padding='same', dilation_rate=(2, 2),
+                      name='fc1', kernel_regularizer='l2')(x)
+    x = Dropout(0.5)(x)
+    x = Conv2D(4096, (1, 1), activation='relu', padding='same', name='fc2', kernel_regularizer='l2')(x)
+    x = Dropout(0.5)(x)
+    #classifying layer
+    x = Conv2D(classes, (1, 1), kernel_initializer='he_normal', activation='linear', padding='valid', strides=(1, 1), kernel_regularizer='l2')(x)
+
+    x = BilinearUpSampling2D(size=(16, 16))(x)
+
+    model = Model(img_input, x)
+    model_name = 'FCN_Vgg16_16'
+    return model, model_name

models/SegNet.py

@@ -0,0 +1,33 @@
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Conv2D, BatchNormalization, MaxPooling2D, Dropout, Concatenate, UpSampling2D
+
+
+class SegNet:
+    def __init__(self, n_filters, input_dim_x, input_dim_y, num_channels):
+        self.input_dim_x = input_dim_x
+        self.input_dim_y = input_dim_y
+        self.n_filters = n_filters
+        self.num_channels = num_channels
+
+    def get_SegNet(self):
+        convnet_input = Input(shape=(self.input_dim_x, self.input_dim_y, self.num_channels))
+
+        encoder_conv1 = Conv2D(self.n_filters, kernel_size=9, activation='relu', padding='same')(convnet_input)
+        pool1 = MaxPooling2D(pool_size=(2, 2))(encoder_conv1)
+        encoder_conv2 = Conv2D(self.n_filters, kernel_size=5, activation='relu', padding='same')(pool1)
+        pool2 = MaxPooling2D(pool_size=(2, 2))(encoder_conv2)
+        encoder_conv3 = Conv2D(self.n_filters * 2, kernel_size=5, activation='relu', padding='same')(pool2)
+        pool3 = MaxPooling2D(pool_size=(2, 2))(encoder_conv3)
+        encoder_conv4 = Conv2D(self.n_filters * 2, kernel_size=5, activation='relu', padding='same')(pool3)
+        pool4 = MaxPooling2D(pool_size=(2, 2))(encoder_conv4)
+
+        conv5 = Conv2D(self.n_filters, kernel_size=5, activation='relu', padding='same')(pool4)
+
+        decoder_conv6 = Conv2D(self.n_filters, kernel_size=7, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(conv5))
+        decoder_conv7 = Conv2D(self.n_filters, kernel_size=5, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(decoder_conv6))
+        decoder_conv8 = Conv2D(self.n_filters, kernel_size=5, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(decoder_conv7))
+        #decoder_conv9 = Conv2D(self.n_filters, kernel_size=5, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(decoder_conv8))
+        decoder_conv9 = Conv2D(1, kernel_size=1, activation='sigmoid', padding='same')(UpSampling2D(size=(2, 2))(decoder_conv8))
+
+        return Model(outputs=decoder_conv9, inputs=convnet_input), 'SegNet'

models/deeplab.py

@@ -0,0 +1,539 @@
+# -*- coding: utf-8 -*-
+
+""" Deeplabv3+ model for Keras.
+This model is based on this repo:
+https://github.com/bonlime/keras-deeplab-v3-plus
+
+MobileNetv2 backbone is based on this repo:
+https://github.com/JonathanCMitchell/mobilenet_v2_keras
+
+# Reference
+- [Encoder-Decoder with Atrous Separable Convolution
+    for Semantic Image Segmentation](https://arxiv.org/pdf/1802.02611.pdf)
+- [Xception: Deep Learning with Depthwise Separable Convolutions]
+    (https://arxiv.org/abs/1610.02357)
+- [Inverted Residuals and Linear Bottlenecks: Mobile Networks for
+    Classification, Detection and Segmentation](https://arxiv.org/abs/1801.04381)
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+import tensorflow as tf
+
+from keras.models import Model
+from keras import layers
+from keras.layers import Input
+from keras.layers import Activation
+from keras.layers import Concatenate
+from keras.layers import Add
+from keras.layers import Dropout
+from keras.layers import BatchNormalization
+from keras.layers import Conv2D
+from keras.layers import DepthwiseConv2D
+from keras.layers import ZeroPadding2D
+from keras.layers import AveragePooling2D
+from keras.layers import Layer
+from tensorflow.keras.layers import InputSpec
+from tensorflow.keras.utils import get_source_inputs
+from keras import backend as K
+from keras.applications import imagenet_utils
+from keras.utils import conv_utils
+from keras.utils.data_utils import get_file
+
+WEIGHTS_PATH_X = "https://github.com/bonlime/keras-deeplab-v3-plus/releases/download/1.1/deeplabv3_xception_tf_dim_ordering_tf_kernels.h5"
+WEIGHTS_PATH_MOBILE = "https://github.com/bonlime/keras-deeplab-v3-plus/releases/download/1.1/deeplabv3_mobilenetv2_tf_dim_ordering_tf_kernels.h5"
+WEIGHTS_PATH_X_CS = "https://github.com/rdiazgar/keras-deeplab-v3-plus/releases/download/1.2/deeplabv3_xception_tf_dim_ordering_tf_kernels_cityscapes.h5"
+WEIGHTS_PATH_MOBILE_CS = "https://github.com/rdiazgar/keras-deeplab-v3-plus/releases/download/1.2/deeplabv3_mobilenetv2_tf_dim_ordering_tf_kernels_cityscapes.h5"
+
+class BilinearUpsampling(Layer):
+    """Just a simple bilinear upsampling layer. Works only with TF.
+       Args:
+           upsampling: tuple of 2 numbers > 0. The upsampling ratio for h and w
+           output_size: used instead of upsampling arg if passed!
+    """
+
+    def __init__(self, upsampling=(2, 2), output_size=None, data_format=None, **kwargs):
+
+        super(BilinearUpsampling, self).__init__(**kwargs)
+
+        self.data_format = K.image_data_format()
+        self.input_spec = InputSpec(ndim=4)
+        if output_size:
+            self.output_size = conv_utils.normalize_tuple(
+                output_size, 2, 'output_size')
+            self.upsampling = None
+        else:
+            self.output_size = None
+            self.upsampling = conv_utils.normalize_tuple(
+                upsampling, 2, 'upsampling')
+
+    def compute_output_shape(self, input_shape):
+        if self.upsampling:
+            height = self.upsampling[0] * \
+                input_shape[1] if input_shape[1] is not None else None
+            width = self.upsampling[1] * \
+                input_shape[2] if input_shape[2] is not None else None
+        else:
+            height = self.output_size[0]
+            width = self.output_size[1]
+        return (input_shape[0],
+                height,
+                width,
+                input_shape[3])
+
+    def call(self, inputs):
+        if self.upsampling:
+            return tf.compat.v1.image.resize_bilinear(inputs, (inputs.shape[1] * self.upsampling[0],
+                                                       inputs.shape[2] * self.upsampling[1]),
+                                              align_corners=True)
+        else:
+            return tf.compat.v1.image.resize_bilinear(inputs, (self.output_size[0],
+                                                       self.output_size[1]),
+                                              align_corners=True)
+
+    def get_config(self):
+        config = {'upsampling': self.upsampling,
+                  'output_size': self.output_size,
+                  'data_format': self.data_format}
+        base_config = super(BilinearUpsampling, self).get_config()
+        return dict(list(base_config.items()) + list(config.items()))
+
+
+def SepConv_BN(x, filters, prefix, stride=1, kernel_size=3, rate=1, depth_activation=False, epsilon=1e-3):
+    """ SepConv with BN between depthwise & pointwise. Optionally add activation after BN
+        Implements right "same" padding for even kernel sizes
+        Args:
+            x: input tensor
+            filters: num of filters in pointwise convolution
+            prefix: prefix before name
+            stride: stride at depthwise conv
+            kernel_size: kernel size for depthwise convolution
+            rate: atrous rate for depthwise convolution
+            depth_activation: flag to use activation between depthwise & poinwise convs
+            epsilon: epsilon to use in BN layer
+    """
+
+    if stride == 1:
+        depth_padding = 'same'
+    else:
+        kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
+        pad_total = kernel_size_effective - 1
+        pad_beg = pad_total // 2
+        pad_end = pad_total - pad_beg
+        x = ZeroPadding2D((pad_beg, pad_end))(x)
+        depth_padding = 'valid'
+
+    if not depth_activation:
+        x = Activation('relu')(x)
+    x = DepthwiseConv2D((kernel_size, kernel_size), strides=(stride, stride), dilation_rate=(rate, rate),
+                        padding=depth_padding, use_bias=False, name=prefix + '_depthwise')(x)
+    x = BatchNormalization(name=prefix + '_depthwise_BN', epsilon=epsilon)(x)
+    if depth_activation:
+        x = Activation('relu')(x)
+    x = Conv2D(filters, (1, 1), padding='same',
+               use_bias=False, name=prefix + '_pointwise')(x)
+    x = BatchNormalization(name=prefix + '_pointwise_BN', epsilon=epsilon)(x)
+    if depth_activation:
+        x = Activation('relu')(x)
+
+    return x
+
+
+def _conv2d_same(x, filters, prefix, stride=1, kernel_size=3, rate=1):
+    """Implements right 'same' padding for even kernel sizes
+        Without this there is a 1 pixel drift when stride = 2
+        Args:
+            x: input tensor
+            filters: num of filters in pointwise convolution
+            prefix: prefix before name
+            stride: stride at depthwise conv
+            kernel_size: kernel size for depthwise convolution
+            rate: atrous rate for depthwise convolution
+    """
+    if stride == 1:
+        return Conv2D(filters,
+                      (kernel_size, kernel_size),
+                      strides=(stride, stride),
+                      padding='same', use_bias=False,
+                      dilation_rate=(rate, rate),
+                      name=prefix)(x)
+    else:
+        kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
+        pad_total = kernel_size_effective - 1
+        pad_beg = pad_total // 2
+        pad_end = pad_total - pad_beg
+        x = ZeroPadding2D((pad_beg, pad_end))(x)
+        return Conv2D(filters,
+                      (kernel_size, kernel_size),
+                      strides=(stride, stride),
+                      padding='valid', use_bias=False,
+                      dilation_rate=(rate, rate),
+                      name=prefix)(x)
+
+
+def _xception_block(inputs, depth_list, prefix, skip_connection_type, stride,
+                    rate=1, depth_activation=False, return_skip=False):
+    """ Basic building block of modified Xception network
+        Args:
+            inputs: input tensor
+            depth_list: number of filters in each SepConv layer. len(depth_list) == 3
+            prefix: prefix before name
+            skip_connection_type: one of {'conv','sum','none'}
+            stride: stride at last depthwise conv
+            rate: atrous rate for depthwise convolution
+            depth_activation: flag to use activation between depthwise & pointwise convs
+            return_skip: flag to return additional tensor after 2 SepConvs for decoder
+            """
+    residual = inputs
+    for i in range(3):
+        residual = SepConv_BN(residual,
+                              depth_list[i],
+                              prefix + '_separable_conv{}'.format(i + 1),
+                              stride=stride if i == 2 else 1,
+                              rate=rate,
+                              depth_activation=depth_activation)
+        if i == 1:
+            skip = residual
+    if skip_connection_type == 'conv':
+        shortcut = _conv2d_same(inputs, depth_list[-1], prefix + '_shortcut',
+                                kernel_size=1,
+                                stride=stride)
+        shortcut = BatchNormalization(name=prefix + '_shortcut_BN')(shortcut)
+        outputs = layers.add([residual, shortcut])
+    elif skip_connection_type == 'sum':
+        outputs = layers.add([residual, inputs])
+    elif skip_connection_type == 'none':
+        outputs = residual
+    if return_skip:
+        return outputs, skip
+    else:
+        return outputs
+
+
+def relu6(x):
+    return K.relu(x, max_value=6)
+
+
+def _make_divisible(v, divisor, min_value=None):
+    if min_value is None:
+        min_value = divisor
+    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
+    # Make sure that round down does not go down by more than 10%.
+    if new_v < 0.9 * v:
+        new_v += divisor
+    return new_v
+
+
+def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id, skip_connection, rate=1):
+    in_channels = inputs.shape[-1]
+    pointwise_conv_filters = int(filters * alpha)
+    pointwise_filters = _make_divisible(pointwise_conv_filters, 8)
+    x = inputs
+    prefix = 'expanded_conv_{}_'.format(block_id)
+    if block_id:
+        # Expand
+
+        x = Conv2D(expansion * in_channels, kernel_size=1, padding='same',
+                   use_bias=False, activation=None,
+                   name=prefix + 'expand')(x)
+        x = BatchNormalization(epsilon=1e-3, momentum=0.999,
+                               name=prefix + 'expand_BN')(x)
+        x = Activation(relu6, name=prefix + 'expand_relu')(x)
+    else:
+        prefix = 'expanded_conv_'
+    # Depthwise
+    x = DepthwiseConv2D(kernel_size=3, strides=stride, activation=None,
+                        use_bias=False, padding='same', dilation_rate=(rate, rate),
+                        name=prefix + 'depthwise')(x)
+    x = BatchNormalization(epsilon=1e-3, momentum=0.999,
+                           name=prefix + 'depthwise_BN')(x)
+
+    x = Activation(relu6, name=prefix + 'depthwise_relu')(x)
+
+    # Project
+    x = Conv2D(pointwise_filters,
+               kernel_size=1, padding='same', use_bias=False, activation=None,
+               name=prefix + 'project')(x)
+    x = BatchNormalization(epsilon=1e-3, momentum=0.999,
+                           name=prefix + 'project_BN')(x)
+
+    if skip_connection:
+        return Add(name=prefix + 'add')([inputs, x])
+
+    # if in_channels == pointwise_filters and stride == 1:
+    #    return Add(name='res_connect_' + str(block_id))([inputs, x])
+
+    return x
+
+
+def Deeplabv3(weights='pascal_voc', input_tensor=None, input_shape=(512, 512, 3), classes=21, backbone='mobilenetv2'
+              , OS=16, alpha=1.):
+    """ Instantiates the Deeplabv3+ architecture
+
+    Optionally loads weights pre-trained
+    on PASCAL VOC. This model is available for TensorFlow only,
+    and can only be used with inputs following the TensorFlow
+    data format `(width, height, channels)`.
+    # Arguments
+        weights: one of 'pascal_voc' (pre-trained on pascal voc)
+            or None (random initialization)
+        input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
+            to use as image input for the model.
+        input_shape: shape of input image. format HxWxC
+            PASCAL VOC model was trained on (512,512,3) images
+        classes: number of desired classes. If classes != 21,
+            last layer is initialized randomly
+        backbone: backbone to use. one of {'xception','mobilenetv2'}
+        OS: determines input_shape/feature_extractor_output ratio. One of {8,16}.
+            Used only for xception backbone.
+        alpha: controls the width of the MobileNetV2 network. This is known as the
+            width multiplier in the MobileNetV2 paper.
+                - If `alpha` < 1.0, proportionally decreases the number
+                    of filters in each layer.
+                - If `alpha` > 1.0, proportionally increases the number
+                    of filters in each layer.
+                - If `alpha` = 1, default number of filters from the paper
+                    are used at each layer.
+            Used only for mobilenetv2 backbone
+
+    # Returns
+        A Keras model instance.
+
+    # Raises
+        RuntimeError: If attempting to run this model with a
+            backend that does not support separable convolutions.
+        ValueError: in case of invalid argument for `weights` or `backbone`
+
+    """
+
+    if not (weights in {'pascal_voc', 'cityscapes', None}):
+        raise ValueError('The `weights` argument should be either '
+                         '`None` (random initialization), `pascal_voc`, or `cityscapes` '
+                         '(pre-trained on PASCAL VOC)')
+
+    if K.backend() != 'tensorflow':
+        raise RuntimeError('The Deeplabv3+ model is only available with '
+                           'the TensorFlow backend.')
+
+    if not (backbone in {'xception', 'mobilenetv2'}):
+        raise ValueError('The `backbone` argument should be either '
+                         '`xception`  or `mobilenetv2` ')
+
+    if input_tensor is None:
+        img_input = Input(shape=input_shape)
+    else:
+        if not K.is_keras_tensor(input_tensor):
+            # Input layer
+            img_input = Input(tensor=input_tensor, shape=input_shape)
+        else:
+            img_input = input_tensor
+
+    if backbone == 'xception':
+        if OS == 8:
+            entry_block3_stride = 1
+            middle_block_rate = 2  # ! Not mentioned in paper, but required
+            exit_block_rates = (2, 4)
+            atrous_rates = (12, 24, 36)
+        else:
+            entry_block3_stride = 2
+            middle_block_rate = 1
+            exit_block_rates = (1, 2)
+            atrous_rates = (6, 12, 18)
+
+        x = Conv2D(32, (3, 3), strides=(2, 2),
+                   name='entry_flow_conv1_1', use_bias=False, padding='same')(img_input)
+        x = BatchNormalization(name='entry_flow_conv1_1_BN')(x)
+        x = Activation('relu')(x)
+
+        x = _conv2d_same(x, 64, 'entry_flow_conv1_2', kernel_size=3, stride=1)
+        x = BatchNormalization(name='entry_flow_conv1_2_BN')(x)
+        x = Activation('relu')(x)
+
+        x = _xception_block(x, [128, 128, 128], 'entry_flow_block1',
+                            skip_connection_type='conv', stride=2,
+                            depth_activation=False)
+        x, skip1 = _xception_block(x, [256, 256, 256], 'entry_flow_block2',
+                                   skip_connection_type='conv', stride=2,
+                                   depth_activation=False, return_skip=True)
+
+        x = _xception_block(x, [728, 728, 728], 'entry_flow_block3',
+                            skip_connection_type='conv', stride=entry_block3_stride,
+                            depth_activation=False)
+        for i in range(16):
+            x = _xception_block(x, [728, 728, 728], 'middle_flow_unit_{}'.format(i + 1),
+                                skip_connection_type='sum', stride=1, rate=middle_block_rate,
+                                depth_activation=False)
+
+        x = _xception_block(x, [728, 1024, 1024], 'exit_flow_block1',
+                            skip_connection_type='conv', stride=1, rate=exit_block_rates[0],
+                            depth_activation=False)
+        x = _xception_block(x, [1536, 1536, 2048], 'exit_flow_block2',
+                            skip_connection_type='none', stride=1, rate=exit_block_rates[1],
+                            depth_activation=True)
+
+    else:
+        OS = 8
+        first_block_filters = _make_divisible(32 * alpha, 8)
+        x = Conv2D(first_block_filters,
+                   kernel_size=3,
+                   strides=(2, 2), padding='same',
+                   use_bias=False, name='Conv')(img_input)
+        x = BatchNormalization(
+            epsilon=1e-3, momentum=0.999, name='Conv_BN')(x)
+        x = Activation(relu6, name='Conv_Relu6')(x)
+
+        x = _inverted_res_block(x, filters=16, alpha=alpha, stride=1,
+                                expansion=1, block_id=0, skip_connection=False)
+
+        x = _inverted_res_block(x, filters=24, alpha=alpha, stride=2,
+                                expansion=6, block_id=1, skip_connection=False)
+        x = _inverted_res_block(x, filters=24, alpha=alpha, stride=1,
+                                expansion=6, block_id=2, skip_connection=True)
+
+        x = _inverted_res_block(x, filters=32, alpha=alpha, stride=2,
+                                expansion=6, block_id=3, skip_connection=False)
+        x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1,
+                                expansion=6, block_id=4, skip_connection=True)
+        x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1,
+                                expansion=6, block_id=5, skip_connection=True)
+
+        # stride in block 6 changed from 2 -> 1, so we need to use rate = 2
+        x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1,  # 1!
+                                expansion=6, block_id=6, skip_connection=False)
+        x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=2,
+                                expansion=6, block_id=7, skip_connection=True)
+        x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=2,
+                                expansion=6, block_id=8, skip_connection=True)
+        x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=2,
+                                expansion=6, block_id=9, skip_connection=True)
+
+        x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=2,
+                                expansion=6, block_id=10, skip_connection=False)
+        x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=2,
+                                expansion=6, block_id=11, skip_connection=True)
+        x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=2,
+                                expansion=6, block_id=12, skip_connection=True)
+
+        x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, rate=2,  # 1!
+                                expansion=6, block_id=13, skip_connection=False)
+        x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, rate=4,
+                                expansion=6, block_id=14, skip_connection=True)
+        x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, rate=4,
+                                expansion=6, block_id=15, skip_connection=True)
+
+        x = _inverted_res_block(x, filters=320, alpha=alpha, stride=1, rate=4,
+                                expansion=6, block_id=16, skip_connection=False)
+
+    # end of feature extractor
+
+    # branching for Atrous Spatial Pyramid Pooling
+
+    # Image Feature branch
+    #out_shape = int(np.ceil(input_shape[0] / OS))
+    b4 = AveragePooling2D(pool_size=(int(np.ceil(input_shape[0] / OS)), int(np.ceil(input_shape[1] / OS))))(x)
+    b4 = Conv2D(256, (1, 1), padding='same',
+                use_bias=False, name='image_pooling')(b4)
+    b4 = BatchNormalization(name='image_pooling_BN', epsilon=1e-5)(b4)
+    b4 = Activation('relu')(b4)
+    b4 = BilinearUpsampling((int(np.ceil(input_shape[0] / OS)), int(np.ceil(input_shape[1] / OS))))(b4)
+
+    # simple 1x1
+    b0 = Conv2D(256, (1, 1), padding='same', use_bias=False, name='aspp0')(x)
+    b0 = BatchNormalization(name='aspp0_BN', epsilon=1e-5)(b0)
+    b0 = Activation('relu', name='aspp0_activation')(b0)
+
+    # there are only 2 branches in mobilenetV2. not sure why
+    if backbone == 'xception':
+        # rate = 6 (12)
+        b1 = SepConv_BN(x, 256, 'aspp1',
+                        rate=atrous_rates[0], depth_activation=True, epsilon=1e-5)
+        # rate = 12 (24)
+        b2 = SepConv_BN(x, 256, 'aspp2',
+                        rate=atrous_rates[1], depth_activation=True, epsilon=1e-5)
+        # rate = 18 (36)
+        b3 = SepConv_BN(x, 256, 'aspp3',
+                        rate=atrous_rates[2], depth_activation=True, epsilon=1e-5)
+
+        # concatenate ASPP branches & project
+        x = Concatenate()([b4, b0, b1, b2, b3])
+    else:
+        x = Concatenate()([b4, b0])
+
+    x = Conv2D(256, (1, 1), padding='same',
+               use_bias=False, name='concat_projection')(x)
+    x = BatchNormalization(name='concat_projection_BN', epsilon=1e-5)(x)
+    x = Activation('relu')(x)
+    x = Dropout(0.1)(x)
+
+    # DeepLab v.3+ decoder
+
+    if backbone == 'xception':
+        # Feature projection
+        # x4 (x2) block
+        x = BilinearUpsampling(output_size=(int(np.ceil(input_shape[0] / 4)),
+                                            int(np.ceil(input_shape[1] / 4))))(x)
+        dec_skip1 = Conv2D(48, (1, 1), padding='same',
+                           use_bias=False, name='feature_projection0')(skip1)
+        dec_skip1 = BatchNormalization(
+            name='feature_projection0_BN', epsilon=1e-5)(dec_skip1)
+        dec_skip1 = Activation('relu')(dec_skip1)
+        x = Concatenate()([x, dec_skip1])
+        x = SepConv_BN(x, 256, 'decoder_conv0',
+                       depth_activation=True, epsilon=1e-5)
+        x = SepConv_BN(x, 256, 'decoder_conv1',
+                       depth_activation=True, epsilon=1e-5)
+
+    # you can use it with arbitary number of classes
+    if classes == 21:
+        last_layer_name = 'logits_semantic'
+    else:
+        last_layer_name = 'custom_logits_semantic'
+
+    x = Conv2D(classes, (1, 1), padding='same', name=last_layer_name)(x)
+    x = BilinearUpsampling(output_size=(input_shape[0], input_shape[1]))(x)
+
+    # Ensure that the model takes into account
+    # any potential predecessors of `input_tensor`.
+    if input_tensor is not None:
+        inputs = get_source_inputs(input_tensor)
+    else:
+        inputs = img_input
+
+    model = Model(inputs, x, name='deeplabv3plus')
+
+    # load weights
+
+    if weights == 'pascal_voc':
+        if backbone == 'xception':
+            weights_path = get_file('deeplabv3_xception_tf_dim_ordering_tf_kernels.h5',
+                                    WEIGHTS_PATH_X,
+                                    cache_subdir='models')
+        else:
+            weights_path = get_file('deeplabv3_mobilenetv2_tf_dim_ordering_tf_kernels.h5',
+                                    WEIGHTS_PATH_MOBILE,
+                                    cache_subdir='models')
+        model.load_weights(weights_path, by_name=True)
+    elif weights == 'cityscapes':
+        if backbone == 'xception':
+            weights_path = get_file('deeplabv3_xception_tf_dim_ordering_tf_kernels_cityscapes.h5',
+                                    WEIGHTS_PATH_X_CS,
+                                    cache_subdir='models')
+        else:
+            weights_path = get_file('deeplabv3_mobilenetv2_tf_dim_ordering_tf_kernels_cityscapes.h5',
+                                    WEIGHTS_PATH_MOBILE_CS,
+                                    cache_subdir='models')
+        model.load_weights(weights_path, by_name=True)
+    return model
+
+
+def preprocess_input(x):
+    """Preprocesses a numpy array encoding a batch of images.
+    # Arguments
+        x: a 4D numpy array consists of RGB values within [0, 255].
+    # Returns
+        Input array scaled to [-1.,1.]
+    """
+    return imagenet_utils.preprocess_input(x, mode='tf')

models/unets.py

@@ -0,0 +1,171 @@
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Conv2D, BatchNormalization, MaxPooling2D, Dropout, Concatenate, UpSampling2D
+
+
+class Unet2D:
+
+    def __init__(self, n_filters, input_dim_x, input_dim_y, num_channels):
+        self.input_dim_x = input_dim_x
+        self.input_dim_y = input_dim_y
+        self.n_filters = n_filters
+        self.num_channels = num_channels
+
+    def get_unet_model_5_levels(self):
+        unet_input = Input(shape=(self.input_dim_x, self.input_dim_y, self.num_channels))
+        
+        conv1 = Conv2D(self.n_filters, kernel_size=3, activation='relu', padding='same')(unet_input)
+        conv1 = Conv2D(self.n_filters, kernel_size=3, activation='relu', padding='same')(conv1)
+        conv1 = BatchNormalization()(conv1)
+        pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
+        
+        conv2 = Conv2D(self.n_filters*2, kernel_size=3, activation='relu', padding='same')(pool1)
+        conv2 = Conv2D(self.n_filters*2, kernel_size=3, activation='relu', padding='same')(conv2)
+        conv2 = BatchNormalization()(conv2)
+        pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
+        
+        conv3 = Conv2D(self.n_filters*4, kernel_size=3, activation='relu', padding='same')(pool2)
+        conv3 = Conv2D(self.n_filters*4, kernel_size=3, activation='relu', padding='same')(conv3)
+        conv3 = BatchNormalization()(conv3)
+        pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
+        
+        conv4 = Conv2D(self.n_filters*8, kernel_size=3, activation='relu', padding='same')(pool3)
+        conv4 = Conv2D(self.n_filters*8, kernel_size=3, activation='relu', padding='same')(conv4)
+        conv4 = BatchNormalization()(conv4)
+        drop4 = Dropout(0.5)(conv4)
+        pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)
+        
+        conv5 = Conv2D(self.n_filters*16, kernel_size=3, activation='relu', padding='same')(pool4)
+        conv5 = Conv2D(self.n_filters*16, kernel_size=3, activation='relu', padding='same')(conv5)
+        conv5 = BatchNormalization()(conv5)
+        drop5 = Dropout(0.5)(conv5)
+        
+        up6 = Conv2D(self.n_filters*16, 2, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(drop5))
+        concat6 = Concatenate()([drop4, up6])
+        conv6 = Conv2D(self.n_filters*8, kernel_size=3, activation='relu', padding='same')(concat6)
+        conv6 = Conv2D(self.n_filters*8, kernel_size=3, activation='relu', padding='same')(conv6)
+        conv6 = BatchNormalization()(conv6)
+        
+        up7 = Conv2D(self.n_filters*8, 2, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(conv6))
+        concat7 = Concatenate()([conv3, up7])
+        conv7 = Conv2D(self.n_filters*4, kernel_size=3, activation='relu', padding='same')(concat7)
+        conv7 = Conv2D(self.n_filters*4, kernel_size=3, activation='relu', padding='same')(conv7)
+        conv7 = BatchNormalization()(conv7)
+        
+        up8 = Conv2D(self.n_filters*4, 2, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(conv7))
+        concat8 = Concatenate()([conv2, up8])
+        conv8 = Conv2D(self.n_filters*2, kernel_size=3, activation='relu', padding='same')(concat8)
+        conv8 = Conv2D(self.n_filters*2, kernel_size=3, activation='relu', padding='same')(conv8)
+        conv8 = BatchNormalization()(conv8)
+        
+        up9 = Conv2D(self.n_filters*2, 2, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(conv8))
+        concat9 = Concatenate()([conv1, up9])
+        conv9 = Conv2D(self.n_filters, kernel_size=3, activation='relu', padding='same')(concat9)
+        conv9 = Conv2D(self.n_filters, kernel_size=3, activation='relu', padding='same')(conv9)
+        conv9 = BatchNormalization()(conv9)
+
+        conv10 = Conv2D(3, kernel_size=1, activation='sigmoid', padding='same')(conv9)
+        
+        return Model(outputs=conv10,  inputs=unet_input), 'unet_model_5_levels'
+
+
+    def get_unet_model_4_levels(self):
+        unet_input = Input(shape=(self.input_dim_x, self.input_dim_y, self.num_channels))
+                
+        conv1 = Conv2D(self.n_filters*2, kernel_size=3, activation='relu', padding='same')(unet_input)
+        conv1 = Conv2D(self.n_filters*2, kernel_size=3, activation='relu', padding='same')(conv1)
+        conv1 = BatchNormalization()(conv1)
+        pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
+        
+        conv2 = Conv2D(self.n_filters*4, kernel_size=3, activation='relu', padding='same')(pool1)
+        conv2 = Conv2D(self.n_filters*4, kernel_size=3, activation='relu', padding='same')(conv2)
+        conv2 = BatchNormalization()(conv2)
+        pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
+        
+        conv3 = Conv2D(self.n_filters*8, kernel_size=3, activation='relu', padding='same')(pool2)
+        conv3 = Conv2D(self.n_filters*8, kernel_size=3, activation='relu', padding='same')(conv3)
+        conv3 = BatchNormalization()(conv3)
+        drop3 = Dropout(0.5)(conv3)
+        pool3 = MaxPooling2D(pool_size=(2, 2))(drop3)
+        
+        conv4 = Conv2D(self.n_filters*16, kernel_size=3, activation='relu', padding='same')(pool3)
+        conv4 = Conv2D(self.n_filters*16, kernel_size=3, activation='relu', padding='same')(conv4)
+        conv4 = BatchNormalization()(conv4)
+        drop4 = Dropout(0.5)(conv4)
+        
+        up5 = Conv2D(self.n_filters*16, 2, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(drop4))
+        concat5 = Concatenate()([drop3, up5])
+        conv5 = Conv2D(self.n_filters*8, kernel_size=3, activation='relu', padding='same')(concat5)
+        conv5 = Conv2D(self.n_filters*8, kernel_size=3, activation='relu', padding='same')(conv5)
+        conv5 = BatchNormalization()(conv5)
+        
+        up6 = Conv2D(self.n_filters*8, 2, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(conv5))
+        concat6 = Concatenate()([conv2, up6])
+        conv6 = Conv2D(self.n_filters*4, kernel_size=3, activation='relu', padding='same')(concat6)
+        conv6 = Conv2D(self.n_filters*4, kernel_size=3, activation='relu', padding='same')(conv6)
+        conv6 = BatchNormalization()(conv6)
+        
+        up7 = Conv2D(self.n_filters*4, 2, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(conv6))
+        concat7 = Concatenate()([conv1, up7])
+        conv7 = Conv2D(self.n_filters*2, kernel_size=3, activation='relu', padding='same')(concat7)
+        conv7 = Conv2D(self.n_filters*2, kernel_size=3, activation='relu', padding='same')(conv7)
+        conv7 = BatchNormalization()(conv7)
+
+        conv9 = Conv2D(3, kernel_size=1, activation='sigmoid', padding='same')(conv7)
+        
+        return Model(outputs=conv9,  inputs=unet_input), 'unet_model_4_levels'
+
+
+    def get_unet_model_yuanqing(self):
+        # Model inspired by https://github.com/yuanqing811/ISIC2018
+        unet_input = Input(shape=(self.input_dim_x, self.input_dim_y, self.num_channels))
+
+        conv1 = Conv2D(self.n_filters, kernel_size=3, activation='relu', padding='same')(unet_input)
+        conv1 = Conv2D(self.n_filters, kernel_size=3, activation='relu', padding='same')(conv1)
+        pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
+
+        conv2 = Conv2D(self.n_filters * 2, kernel_size=3, activation='relu', padding='same')(pool1)
+        conv2 = Conv2D(self.n_filters * 2, kernel_size=3, activation='relu', padding='same')(conv2)
+        pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
+
+        conv3 = Conv2D(self.n_filters * 4, kernel_size=3, activation='relu', padding='same')(pool2)
+        conv3 = Conv2D(self.n_filters * 4, kernel_size=3, activation='relu', padding='same')(conv3)
+        conv3 = Conv2D(self.n_filters * 4, kernel_size=3, activation='relu', padding='same')(conv3)
+        pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
+
+        conv4 = Conv2D(self.n_filters * 8, kernel_size=3, activation='relu', padding='same')(pool3)
+        conv4 = Conv2D(self.n_filters * 8, kernel_size=3, activation='relu', padding='same')(conv4)
+        conv4 = Conv2D(self.n_filters * 8, kernel_size=3, activation='relu', padding='same')(conv4)
+        pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
+
+        conv5 = Conv2D(self.n_filters * 8, kernel_size=3, activation='relu', padding='same')(pool4)
+        conv5 = Conv2D(self.n_filters * 8, kernel_size=3, activation='relu', padding='same')(conv5)
+        conv5 = Conv2D(self.n_filters * 8, kernel_size=3, activation='relu', padding='same')(conv5)
+
+        up6 = Conv2D(self.n_filters * 4, 2, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(conv5))
+        feature4 = Conv2D(self.n_filters * 4, kernel_size=3, activation='relu', padding='same')(conv4)
+        concat6 = Concatenate()([feature4, up6])
+        conv6 = Conv2D(self.n_filters * 4, kernel_size=3, activation='relu', padding='same')(concat6)
+        conv6 = Conv2D(self.n_filters * 4, kernel_size=3, activation='relu', padding='same')(conv6)
+
+        up7 = Conv2D(self.n_filters * 2, 2, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(conv6))
+        feature3 = Conv2D(self.n_filters * 2, kernel_size=3, activation='relu', padding='same')(conv3)
+        concat7 = Concatenate()([feature3, up7])
+        conv7 = Conv2D(self.n_filters * 2, kernel_size=3, activation='relu', padding='same')(concat7)
+        conv7 = Conv2D(self.n_filters * 2, kernel_size=3, activation='relu', padding='same')(conv7)
+
+        up8 = Conv2D(self.n_filters * 1, 2, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(conv7))
+        feature2 = Conv2D(self.n_filters * 1, kernel_size=3, activation='relu', padding='same')(conv2)
+        concat8 = Concatenate()([feature2, up8])
+        conv8 = Conv2D(self.n_filters * 1, kernel_size=3, activation='relu', padding='same')(concat8)
+        conv8 = Conv2D(self.n_filters * 1, kernel_size=3, activation='relu', padding='same')(conv8)
+
+        up9 = Conv2D(int(self.n_filters / 2), 2, activation='relu', padding='same')(UpSampling2D(size=(2, 2))(conv8))
+        feature1 = Conv2D(int(self.n_filters / 2), kernel_size=3, activation='relu', padding='same')(conv1)
+        concat9 = Concatenate()([feature1, up9])
+        conv9 = Conv2D(int(self.n_filters / 2), kernel_size=3, activation='relu', padding='same')(concat9)
+        conv9 = Conv2D(int(self.n_filters / 2), kernel_size=3, activation='relu', padding='same')(conv9)
+        conv9 = Conv2D(3, kernel_size=3, activation='relu', padding='same')(conv9)
+        conv10 = Conv2D(1, kernel_size=1, activation='sigmoid')(conv9)
+
+        return Model(outputs=conv10, inputs=unet_input), 'unet_model_yuanqing'

requirements.txt

@@ -0,0 +1,151 @@
+absl-py==2.3.1
+aiofiles==24.1.0
+annotated-types==0.7.0
+anyio==4.10.0
+asttokens==3.0.0
+astunparse==1.6.3
+attrs==25.3.0
+beautifulsoup4==4.13.4
+blinker==1.9.0
+Brotli==1.1.0
+cachetools==5.5.2
+certifi==2025.8.3
+charset-normalizer==3.4.2
+click==8.2.1
+colorama==0.4.6
+comm==0.2.3
+ConfigArgParse==1.7.1
+contourpy==1.3.2
+cycler==0.12.1
+dash==3.2.0
+decorator==5.2.1
+exceptiongroup==1.3.0
+executing==2.2.0
+fastapi==0.116.1
+fastjsonschema==2.21.1
+ffmpy==0.6.1
+filelock==3.18.0
+Flask==3.1.1
+flatbuffers==25.2.10
+fonttools==4.59.0
+fsspec==2025.7.0
+gast==0.4.0
+google-generativeai 
+gdown==5.2.0
+google-auth==2.40.3
+google-auth-oauthlib==0.4.6
+google-pasta==0.2.0
+gradio==5.41.1
+gradio_client==1.11.0
+gradio_imageslider==0.0.20
+groovy==0.1.2
+grpcio==1.74.0
+h11==0.16.0
+h5py==3.14.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.34.3
+idna==3.10
+imageio==2.37.0
+importlib_metadata==8.7.0
+ipython==8.37.0
+ipywidgets==8.1.7
+itsdangerous==2.2.0
+jedi==0.19.2
+Jinja2==3.1.6
+jsonschema==4.25.0
+jsonschema-specifications==2025.4.1
+jupyter_core==5.8.1
+jupyterlab_widgets==3.0.15
+keras==2.10.0
+Keras-Preprocessing==1.1.2
+kiwisolver==1.4.8
+lazy_loader==0.4
+libclang==18.1.1
+Markdown==3.8.2
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+matplotlib==3.10.5
+matplotlib-inline==0.1.7
+mdurl==0.1.2
+mpmath==1.3.0
+narwhals==2.0.1
+nbformat==5.10.4
+nest-asyncio==1.6.0
+networkx==3.4.2
+numpy==1.26.4
+oauthlib==3.3.1
+open3d==0.19.0
+opencv-python==4.11.0.86
+opt_einsum==3.4.0
+orjson==3.11.1
+packaging==25.0
+pandas==2.3.1
+parso==0.8.4
+pillow==11.3.0
+platformdirs==4.3.8
+plotly==6.2.0
+prompt_toolkit==3.0.51
+protobuf==3.19.6
+psutil==5.9.8
+pure_eval==0.2.3
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pydantic==2.10.6
+pydantic_core==2.27.2
+pydub==0.25.1
+Pygments==2.19.2
+pyparsing==3.2.3
+PySocks==1.7.1
+python-dateutil==2.9.0.post0
+python-multipart==0.0.20
+pytz==2025.2
+PyYAML==6.0.2
+referencing==0.36.2
+requests==2.32.4
+requests-oauthlib==2.0.0
+retrying==1.4.2
+rich==14.1.0
+rpds-py==0.27.0
+rsa==4.9.1
+ruff==0.12.7
+safehttpx==0.1.6
+scikit-image==0.25.2
+scipy==1.15.3
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+soupsieve==2.7
+spaces==0.39.0
+stack-data==0.6.3
+starlette==0.47.2
+sympy==1.14.0
+tensorboard==2.10.1
+tensorboard-data-server==0.6.1
+tensorboard-plugin-wit==1.8.1
+tensorflow==2.10.1
+tensorflow-estimator==2.10.0
+tensorflow-hub==0.16.1
+tensorflow-io-gcs-filesystem==0.31.0
+termcolor==3.1.0
+tf-keras==2.15.0
+tifffile==2025.5.10
+tomlkit==0.13.3
+torch==2.8.0
+torchvision==0.23.0
+tqdm==4.67.1
+traitlets==5.14.3
+typer==0.16.0
+typing-inspection==0.4.1
+typing_extensions==4.14.1
+tzdata==2025.2
+urllib3==2.5.0
+uvicorn==0.35.0
+wcwidth==0.2.13
+websockets==15.0.1
+Werkzeug==3.1.3
+widgetsnbextension==4.0.14
+wrapt==1.17.2
+zipp==3.23.0
+transformers

temp_files/Final_workig_cpu.txt

@@ -0,0 +1,1000 @@
+import glob
+import gradio as gr
+import matplotlib
+import numpy as np
+from PIL import Image
+import torch
+import tempfile
+from gradio_imageslider import ImageSlider
+import plotly.graph_objects as go
+import plotly.express as px
+import open3d as o3d
+from depth_anything_v2.dpt import DepthAnythingV2
+import os
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image as keras_image
+import base64
+from io import BytesIO
+import gdown
+import spaces
+import cv2
+
+# Import actual segmentation model components
+from models.deeplab import Deeplabv3, relu6, DepthwiseConv2D, BilinearUpsampling
+from utils.learning.metrics import dice_coef, precision, recall
+from utils.io.data import normalize
+
+# Define path and file ID
+checkpoint_dir = "checkpoints"
+os.makedirs(checkpoint_dir, exist_ok=True)
+
+model_file = os.path.join(checkpoint_dir, "depth_anything_v2_vitl.pth")
+gdrive_url = "https://drive.google.com/uc?id=141Mhq2jonkUBcVBnNqNSeyIZYtH5l4K5"
+
+# Download if not already present
+if not os.path.exists(model_file):
+    print("Downloading model from Google Drive...")
+    gdown.download(gdrive_url, model_file, quiet=False)
+
+# --- TensorFlow: Check GPU Availability ---
+gpus = tf.config.list_physical_devices('GPU')
+if gpus:
+    print("TensorFlow is using GPU")
+else:
+    print("TensorFlow is using CPU")
+
+# --- Load Wound Classification Model and Class Labels ---
+wound_model = load_model("keras_model.h5")
+with open("labels.txt", "r") as f:
+    class_labels = [line.strip().split(maxsplit=1)[1] for line in f]
+
+# --- Load Actual Wound Segmentation Model ---
+class WoundSegmentationModel:
+    def __init__(self):
+        self.input_dim_x = 224
+        self.input_dim_y = 224
+        self.model = None
+        self.load_model()
+    
+    def load_model(self):
+        """Load the trained wound segmentation model"""
+        try:
+            # Try to load the most recent model
+            weight_file_name = '2025-08-07_16-25-27.hdf5'
+            model_path = f'./training_history/{weight_file_name}'
+            
+            self.model = load_model(model_path, 
+                                  custom_objects={
+                                      'recall': recall,
+                                      'precision': precision,
+                                      'dice_coef': dice_coef,
+                                      'relu6': relu6,
+                                      'DepthwiseConv2D': DepthwiseConv2D,
+                                      'BilinearUpsampling': BilinearUpsampling
+                                  })
+            print(f"Segmentation model loaded successfully from {model_path}")
+        except Exception as e:
+            print(f"Error loading segmentation model: {e}")
+            # Fallback to the older model
+            try:
+                weight_file_name = '2019-12-19 01%3A53%3A15.480800.hdf5'
+                model_path = f'./training_history/{weight_file_name}'
+                
+                self.model = load_model(model_path, 
+                                      custom_objects={
+                                          'recall': recall,
+                                          'precision': precision,
+                                          'dice_coef': dice_coef,
+                                          'relu6': relu6,
+                                          'DepthwiseConv2D': DepthwiseConv2D,
+                                          'BilinearUpsampling': BilinearUpsampling
+                                      })
+                print(f"Segmentation model loaded successfully from {model_path}")
+            except Exception as e2:
+                print(f"Error loading fallback segmentation model: {e2}")
+                self.model = None
+    
+    def preprocess_image(self, image):
+        """Preprocess the uploaded image for model input"""
+        if image is None:
+            return None
+        
+        # Convert to RGB if needed
+        if len(image.shape) == 3 and image.shape[2] == 3:
+            # Convert BGR to RGB if needed
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        
+        # Resize to model input size
+        image = cv2.resize(image, (self.input_dim_x, self.input_dim_y))
+        
+        # Normalize the image
+        image = image.astype(np.float32) / 255.0
+        
+        # Add batch dimension
+        image = np.expand_dims(image, axis=0)
+        
+        return image
+    
+    def postprocess_prediction(self, prediction):
+        """Postprocess the model prediction"""
+        # Remove batch dimension
+        prediction = prediction[0]
+        
+        # Apply threshold to get binary mask
+        threshold = 0.5
+        binary_mask = (prediction > threshold).astype(np.uint8) * 255
+        
+        return binary_mask
+    
+    def segment_wound(self, input_image):
+        """Main function to segment wound from uploaded image"""
+        if self.model is None:
+            return None, "Error: Segmentation model not loaded. Please check the model files."
+        
+        if input_image is None:
+            return None, "Please upload an image."
+        
+        try:
+            # Preprocess the image
+            processed_image = self.preprocess_image(input_image)
+            
+            if processed_image is None:
+                return None, "Error processing image."
+            
+            # Make prediction
+            prediction = self.model.predict(processed_image, verbose=0)
+            
+            # Postprocess the prediction
+            segmented_mask = self.postprocess_prediction(prediction)
+            
+            return segmented_mask, "Segmentation completed successfully!"
+            
+        except Exception as e:
+            return None, f"Error during segmentation: {str(e)}"
+
+# Initialize the segmentation model
+segmentation_model = WoundSegmentationModel()
+
+# --- PyTorch: Set Device and Load Depth Model ---
+map_device = torch.device("cuda" if torch.cuda.is_available() and torch.cuda.device_count() > 0 else "cpu")
+print(f"Using PyTorch device: {map_device}")
+
+model_configs = {
+    'vits': {'encoder': 'vits', 'features': 64, 'out_channels': [48, 96, 192, 384]},
+    'vitb': {'encoder': 'vitb', 'features': 128, 'out_channels': [96, 192, 384, 768]},
+    'vitl': {'encoder': 'vitl', 'features': 256, 'out_channels': [256, 512, 1024, 1024]},
+    'vitg': {'encoder': 'vitg', 'features': 384, 'out_channels': [1536, 1536, 1536, 1536]}
+}
+encoder = 'vitl'
+depth_model = DepthAnythingV2(**model_configs[encoder])
+state_dict = torch.load(
+    f'checkpoints/depth_anything_v2_{encoder}.pth',
+    map_location=map_device
+)
+depth_model.load_state_dict(state_dict)
+depth_model = depth_model.to(map_device).eval()
+
+
+# --- Custom CSS for unified dark theme ---
+css = """
+.gradio-container {
+    font-family: 'Segoe UI', sans-serif;
+    background-color: #121212;
+    color: #ffffff;
+    padding: 20px;
+}
+.gr-button {
+    background-color: #2c3e50;
+    color: white;
+    border-radius: 10px;
+}
+.gr-button:hover {
+    background-color: #34495e;
+}
+.gr-html, .gr-html div {
+    white-space: normal !important;
+    overflow: visible !important;
+    text-overflow: unset !important;
+    word-break: break-word !important;
+}
+#img-display-container {
+    max-height: 100vh;
+}
+#img-display-input {
+    max-height: 80vh;
+}
+#img-display-output {
+    max-height: 80vh;
+}
+#download {
+    height: 62px;
+}
+h1 {
+    text-align: center;
+    font-size: 3rem;
+    font-weight: bold;
+    margin: 2rem 0;
+    color: #ffffff;
+}
+h2 {
+    color: #ffffff;
+    text-align: center;
+    margin: 1rem 0;
+}
+.gr-tabs {
+    background-color: #1e1e1e;
+    border-radius: 10px;
+    padding: 10px;
+}
+.gr-tab-nav {
+    background-color: #2c3e50;
+    border-radius: 8px;
+}
+.gr-tab-nav button {
+    color: #ffffff !important;
+}
+.gr-tab-nav button.selected {
+    background-color: #34495e !important;
+}
+"""
+
+# --- Wound Classification Functions ---
+def preprocess_input(img):
+    img = img.resize((224, 224))
+    arr = keras_image.img_to_array(img)
+    arr = arr / 255.0
+    return np.expand_dims(arr, axis=0)
+
+def get_reasoning_from_gemini(img, prediction):
+    try:
+        # For now, return a simple explanation without Gemini API to avoid typing issues
+        # In production, you would implement the proper Gemini API call here
+        explanations = {
+            "Abrasion": "This appears to be an abrasion wound, characterized by superficial damage to the skin surface. The wound shows typical signs of friction or scraping injury.",
+            "Burn": "This wound exhibits characteristics consistent with a burn injury, showing tissue damage from heat, chemicals, or radiation exposure.",
+            "Laceration": "This wound displays the irregular edges and tissue tearing typical of a laceration, likely caused by blunt force trauma.",
+            "Puncture": "This wound shows a small, deep entry point characteristic of puncture wounds, often caused by sharp, pointed objects.",
+            "Ulcer": "This wound exhibits the characteristics of an ulcer, showing tissue breakdown and potential underlying vascular or pressure issues."
+        }
+
+        return explanations.get(prediction, f"This wound has been classified as {prediction}. Please consult with a healthcare professional for detailed assessment.")
+
+    except Exception as e:
+        return f"(Reasoning unavailable: {str(e)})"
+    
+@spaces.GPU
+def classify_wound_image(img):
+    if img is None:
+        return "<div style='color:#ff5252; font-size:18px;'>No image provided</div>", ""
+
+    img_array = preprocess_input(img)
+    predictions = wound_model.predict(img_array, verbose=0)[0]
+    pred_idx = int(np.argmax(predictions))
+    pred_class = class_labels[pred_idx]
+
+    # Get reasoning from Gemini
+    reasoning_text = get_reasoning_from_gemini(img, pred_class)
+
+    # Prediction Card
+    predicted_card = f"""
+    <div style='padding: 20px; background-color: #1e1e1e; border-radius: 12px;
+                box-shadow: 0 0 10px rgba(0,0,0,0.5);'>
+        <div style='font-size: 22px; font-weight: bold; color: orange; margin-bottom: 10px;'>
+            Predicted Wound Type
+        </div>
+        <div style='font-size: 26px; color: white;'>
+            {pred_class}
+        </div>
+    </div>
+    """
+
+    # Reasoning Card
+    reasoning_card = f"""
+    <div style='padding: 20px; background-color: #1e1e1e; border-radius: 12px;
+                box-shadow: 0 0 10px rgba(0,0,0,0.5);'>
+        <div style='font-size: 22px; font-weight: bold; color: orange; margin-bottom: 10px;'>
+            Reasoning
+        </div>
+        <div style='font-size: 16px; color: white; min-height: 80px;'>
+            {reasoning_text}
+        </div>
+    </div>
+    """
+
+    return predicted_card, reasoning_card
+
+# --- Wound Severity Estimation Functions ---
+@spaces.GPU
+def compute_depth_area_statistics(depth_map, mask, pixel_spacing_mm=0.5):
+    """Compute area statistics for different depth regions"""
+    pixel_area_cm2 = (pixel_spacing_mm / 10.0) ** 2
+
+    # Extract only wound region
+    wound_mask = (mask > 127)
+    wound_depths = depth_map[wound_mask]
+    total_area = np.sum(wound_mask) * pixel_area_cm2
+
+    # Categorize depth regions
+    shallow = wound_depths < 3
+    moderate = (wound_depths >= 3) & (wound_depths < 6)
+    deep = wound_depths >= 6
+
+    shallow_area = np.sum(shallow) * pixel_area_cm2
+    moderate_area = np.sum(moderate) * pixel_area_cm2
+    deep_area = np.sum(deep) * pixel_area_cm2
+
+    deep_ratio = deep_area / total_area if total_area > 0 else 0
+
+    return {
+        'total_area_cm2': total_area,
+        'shallow_area_cm2': shallow_area,
+        'moderate_area_cm2': moderate_area,
+        'deep_area_cm2': deep_area,
+        'deep_ratio': deep_ratio,
+        'max_depth': np.max(wound_depths) if len(wound_depths) > 0 else 0
+    }
+
+def classify_wound_severity_by_area(depth_stats):
+    """Classify wound severity based on area and depth distribution"""
+    total = depth_stats['total_area_cm2']
+    deep = depth_stats['deep_area_cm2']
+    moderate = depth_stats['moderate_area_cm2']
+
+    if total == 0:
+        return "Unknown"
+
+    # Severity classification rules
+    if deep > 2 or (deep / total) > 0.3:
+        return "Severe"
+    elif moderate > 1.5 or (moderate / total) > 0.4:
+        return "Moderate"
+    else:
+        return "Mild"
+
+def analyze_wound_severity(image, depth_map, wound_mask, pixel_spacing_mm=0.5):
+    """Analyze wound severity from depth map and wound mask"""
+    if image is None or depth_map is None or wound_mask is None:
+        return "❌ Please upload image, depth map, and wound mask."
+
+    # Convert wound mask to grayscale if needed
+    if len(wound_mask.shape) == 3:
+        wound_mask = np.mean(wound_mask, axis=2)
+
+    # Ensure depth map and mask have same dimensions
+    if depth_map.shape[:2] != wound_mask.shape[:2]:
+        # Resize mask to match depth map
+        from PIL import Image
+        mask_pil = Image.fromarray(wound_mask.astype(np.uint8))
+        mask_pil = mask_pil.resize((depth_map.shape[1], depth_map.shape[0]))
+        wound_mask = np.array(mask_pil)
+
+    # Compute statistics
+    stats = compute_depth_area_statistics(depth_map, wound_mask, pixel_spacing_mm)
+    severity = classify_wound_severity_by_area(stats)
+
+    # Create severity report with color coding
+    severity_color = {
+        "Mild": "#4CAF50",      # Green
+        "Moderate": "#FF9800",   # Orange
+        "Severe": "#F44336"      # Red
+    }.get(severity, "#9E9E9E")   # Gray for unknown
+
+    report = f"""
+    <div style='padding: 20px; background-color: #1e1e1e; border-radius: 12px; box-shadow: 0 0 10px rgba(0,0,0,0.5);'>
+        <div style='font-size: 24px; font-weight: bold; color: {severity_color}; margin-bottom: 15px;'>
+            🩹 Wound Severity Analysis
+        </div>
+
+        <div style='display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-bottom: 20px;'>
+            <div style='background-color: #2c2c2c; padding: 15px; border-radius: 8px;'>
+                <div style='font-size: 18px; font-weight: bold; color: #ffffff; margin-bottom: 10px;'>
+                    📏 Area Measurements
+                </div>
+                <div style='color: #cccccc; line-height: 1.6;'>
+                    <div>🟢 <b>Total Area:</b> {stats['total_area_cm2']:.2f} cm²</div>
+                    <div>🟩 <b>Shallow (0-3mm):</b> {stats['shallow_area_cm2']:.2f} cm²</div>
+                    <div>🟨 <b>Moderate (3-6mm):</b> {stats['moderate_area_cm2']:.2f} cm²</div>
+                    <div>🟥 <b>Deep (>6mm):</b> {stats['deep_area_cm2']:.2f} cm²</div>
+                </div>
+            </div>
+
+            <div style='background-color: #2c2c2c; padding: 15px; border-radius: 8px;'>
+                <div style='font-size: 18px; font-weight: bold; color: #ffffff; margin-bottom: 10px;'>
+                    📊 Depth Analysis
+                </div>
+                <div style='color: #cccccc; line-height: 1.6;'>
+                    <div>🔥 <b>Deep Coverage:</b> {stats['deep_ratio']*100:.1f}%</div>
+                    <div>📏 <b>Max Depth:</b> {stats['max_depth']:.1f} mm</div>
+                    <div>⚡ <b>Pixel Spacing:</b> {pixel_spacing_mm} mm</div>
+                </div>
+            </div>
+        </div>
+
+        <div style='text-align: center; padding: 15px; background-color: #2c2c2c; border-radius: 8px; border-left: 4px solid {severity_color};'>
+            <div style='font-size: 20px; font-weight: bold; color: {severity_color};'>
+                🎯 Predicted Severity: {severity}
+            </div>
+            <div style='font-size: 14px; color: #cccccc; margin-top: 5px;'>
+                {get_severity_description(severity)}
+            </div>
+        </div>
+    </div>
+    """
+
+    return report
+
+def get_severity_description(severity):
+    """Get description for severity level"""
+    descriptions = {
+        "Mild": "Superficial wound with minimal tissue damage. Usually heals well with basic care.",
+        "Moderate": "Moderate tissue involvement requiring careful monitoring and proper treatment.",
+        "Severe": "Deep tissue damage requiring immediate medical attention and specialized care.",
+        "Unknown": "Unable to determine severity due to insufficient data."
+    }
+    return descriptions.get(severity, "Severity assessment unavailable.")
+
+def create_sample_wound_mask(image_shape, center=None, radius=50):
+    """Create a sample circular wound mask for testing"""
+    if center is None:
+        center = (image_shape[1] // 2, image_shape[0] // 2)
+
+    mask = np.zeros(image_shape[:2], dtype=np.uint8)
+    y, x = np.ogrid[:image_shape[0], :image_shape[1]]
+
+    # Create circular mask
+    dist_from_center = np.sqrt((x - center[0])**2 + (y - center[1])**2)
+    mask[dist_from_center <= radius] = 255
+
+    return mask
+
+def create_realistic_wound_mask(image_shape, method='elliptical'):
+    """Create a more realistic wound mask with irregular shapes"""
+    h, w = image_shape[:2]
+    mask = np.zeros((h, w), dtype=np.uint8)
+
+    if method == 'elliptical':
+        # Create elliptical wound mask
+        center = (w // 2, h // 2)
+        radius_x = min(w, h) // 3
+        radius_y = min(w, h) // 4
+
+        y, x = np.ogrid[:h, :w]
+        # Add some irregularity to make it more realistic
+        ellipse = ((x - center[0])**2 / (radius_x**2) +
+                   (y - center[1])**2 / (radius_y**2)) <= 1
+
+        # Add some noise and irregularity
+        noise = np.random.random((h, w)) > 0.8
+        mask = (ellipse | noise).astype(np.uint8) * 255
+
+    elif method == 'irregular':
+        # Create irregular wound mask
+        center = (w // 2, h // 2)
+        radius = min(w, h) // 4
+
+        y, x = np.ogrid[:h, :w]
+        base_circle = np.sqrt((x - center[0])**2 + (y - center[1])**2) <= radius
+
+        # Add irregular extensions
+        extensions = np.zeros_like(base_circle)
+        for i in range(3):
+            angle = i * 2 * np.pi / 3
+            ext_x = int(center[0] + radius * 0.8 * np.cos(angle))
+            ext_y = int(center[1] + radius * 0.8 * np.sin(angle))
+            ext_radius = radius // 3
+
+            ext_circle = np.sqrt((x - ext_x)**2 + (y - ext_y)**2) <= ext_radius
+            extensions = extensions | ext_circle
+
+        mask = (base_circle | extensions).astype(np.uint8) * 255
+
+    # Apply morphological operations to smooth the mask
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+
+    return mask
+
+# --- Depth Estimation Functions ---
+@spaces.GPU
+def predict_depth(image):
+    return depth_model.infer_image(image)
+
+def calculate_max_points(image):
+    """Calculate maximum points based on image dimensions (3x pixel count)"""
+    if image is None:
+        return 10000  # Default value
+    h, w = image.shape[:2]
+    max_points = h * w * 3
+    # Ensure minimum and reasonable maximum values
+    return max(1000, min(max_points, 300000))
+
+def update_slider_on_image_upload(image):
+    """Update the points slider when an image is uploaded"""
+    max_points = calculate_max_points(image)
+    default_value = min(10000, max_points // 10)  # 10% of max points as default
+    return gr.Slider(minimum=1000, maximum=max_points, value=default_value, step=1000,
+                     label=f"Number of 3D points (max: {max_points:,})")
+
+@spaces.GPU
+def create_point_cloud(image, depth_map, focal_length_x=470.4, focal_length_y=470.4, max_points=30000):
+    """Create a point cloud from depth map using camera intrinsics with high detail"""
+    h, w = depth_map.shape
+
+    # Use smaller step for higher detail (reduced downsampling)
+    step = max(1, int(np.sqrt(h * w / max_points) * 0.5))  # Reduce step size for more detail
+
+    # Create mesh grid for camera coordinates
+    y_coords, x_coords = np.mgrid[0:h:step, 0:w:step]
+
+    # Convert to camera coordinates (normalized by focal length)
+    x_cam = (x_coords - w / 2) / focal_length_x
+    y_cam = (y_coords - h / 2) / focal_length_y
+
+    # Get depth values
+    depth_values = depth_map[::step, ::step]
+
+    # Calculate 3D points: (x_cam * depth, y_cam * depth, depth)
+    x_3d = x_cam * depth_values
+    y_3d = y_cam * depth_values
+    z_3d = depth_values
+
+    # Flatten arrays
+    points = np.stack([x_3d.flatten(), y_3d.flatten(), z_3d.flatten()], axis=1)
+
+    # Get corresponding image colors
+    image_colors = image[::step, ::step, :]
+    colors = image_colors.reshape(-1, 3) / 255.0
+
+    # Create Open3D point cloud
+    pcd = o3d.geometry.PointCloud()
+    pcd.points = o3d.utility.Vector3dVector(points)
+    pcd.colors = o3d.utility.Vector3dVector(colors)
+
+    return pcd
+
+@spaces.GPU
+def reconstruct_surface_mesh_from_point_cloud(pcd):
+    """Convert point cloud to a mesh using Poisson reconstruction with very high detail."""
+    # Estimate and orient normals with high precision
+    pcd.estimate_normals(search_param=o3d.geometry.KDTreeSearchParamHybrid(radius=0.005, max_nn=50))
+    pcd.orient_normals_consistent_tangent_plane(k=50)
+
+    # Create surface mesh with maximum detail (depth=12 for very high resolution)
+    mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(pcd, depth=12)
+
+    # Return mesh without filtering low-density vertices
+    return mesh
+
+@spaces.GPU
+def create_enhanced_3d_visualization(image, depth_map, max_points=10000):
+    """Create an enhanced 3D visualization using proper camera projection"""
+    h, w = depth_map.shape
+
+    # Downsample to avoid too many points for performance
+    step = max(1, int(np.sqrt(h * w / max_points)))
+
+    # Create mesh grid for camera coordinates
+    y_coords, x_coords = np.mgrid[0:h:step, 0:w:step]
+
+    # Convert to camera coordinates (normalized by focal length)
+    focal_length = 470.4  # Default focal length
+    x_cam = (x_coords - w / 2) / focal_length
+    y_cam = (y_coords - h / 2) / focal_length
+
+    # Get depth values
+    depth_values = depth_map[::step, ::step]
+
+    # Calculate 3D points: (x_cam * depth, y_cam * depth, depth)
+    x_3d = x_cam * depth_values
+    y_3d = y_cam * depth_values
+    z_3d = depth_values
+
+    # Flatten arrays
+    x_flat = x_3d.flatten()
+    y_flat = y_3d.flatten()
+    z_flat = z_3d.flatten()
+
+    # Get corresponding image colors
+    image_colors = image[::step, ::step, :]
+    colors_flat = image_colors.reshape(-1, 3)
+
+    # Create 3D scatter plot with proper camera projection
+    fig = go.Figure(data=[go.Scatter3d(
+        x=x_flat,
+        y=y_flat,
+        z=z_flat,
+        mode='markers',
+        marker=dict(
+            size=1.5,
+            color=colors_flat,
+            opacity=0.9
+        ),
+        hovertemplate='<b>3D Position:</b> (%{x:.3f}, %{y:.3f}, %{z:.3f})<br>' +
+                     '<b>Depth:</b> %{z:.2f}<br>' +
+                     '<extra></extra>'
+    )])
+
+    fig.update_layout(
+        title="3D Point Cloud Visualization (Camera Projection)",
+        scene=dict(
+            xaxis_title="X (meters)",
+            yaxis_title="Y (meters)",
+            zaxis_title="Z (meters)",
+            camera=dict(
+                eye=dict(x=2.0, y=2.0, z=2.0),
+                center=dict(x=0, y=0, z=0),
+                up=dict(x=0, y=0, z=1)
+            ),
+            aspectmode='data'
+        ),
+        width=700,
+        height=600
+    )
+
+    return fig
+
+def on_depth_submit(image, num_points, focal_x, focal_y):
+    original_image = image.copy()
+
+    h, w = image.shape[:2]
+
+    # Predict depth using the model
+    depth = predict_depth(image[:, :, ::-1])  # RGB to BGR if needed
+
+    # Save raw 16-bit depth
+    raw_depth = Image.fromarray(depth.astype('uint16'))
+    tmp_raw_depth = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
+    raw_depth.save(tmp_raw_depth.name)
+
+    # Normalize and convert to grayscale for display
+    norm_depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
+    norm_depth = norm_depth.astype(np.uint8)
+    colored_depth = (matplotlib.colormaps.get_cmap('Spectral_r')(norm_depth)[:, :, :3] * 255).astype(np.uint8)
+
+    gray_depth = Image.fromarray(norm_depth)
+    tmp_gray_depth = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
+    gray_depth.save(tmp_gray_depth.name)
+
+    # Create point cloud
+    pcd = create_point_cloud(original_image, norm_depth, focal_x, focal_y, max_points=num_points)
+
+    # Reconstruct mesh from point cloud
+    mesh = reconstruct_surface_mesh_from_point_cloud(pcd)
+
+    # Save mesh with faces as .ply
+    tmp_pointcloud = tempfile.NamedTemporaryFile(suffix='.ply', delete=False)
+    o3d.io.write_triangle_mesh(tmp_pointcloud.name, mesh)
+
+    # Create enhanced 3D scatter plot visualization
+    depth_3d = create_enhanced_3d_visualization(original_image, norm_depth, max_points=num_points)
+
+    return [(original_image, colored_depth), tmp_gray_depth.name, tmp_raw_depth.name, tmp_pointcloud.name, depth_3d]
+
+# --- Actual Wound Segmentation Functions ---
+def create_automatic_wound_mask(image, method='deep_learning'):
+    """
+    Automatically generate wound mask from image using the actual deep learning model
+
+    Args:
+        image: Input image (numpy array)
+        method: Segmentation method (currently only 'deep_learning' supported)
+
+    Returns:
+        mask: Binary wound mask
+    """
+    if image is None:
+        return None
+
+    # Use the actual deep learning model for segmentation
+    if method == 'deep_learning':
+        mask, _ = segmentation_model.segment_wound(image)
+        return mask
+    else:
+        # Fallback to deep learning if method not recognized
+        mask, _ = segmentation_model.segment_wound(image)
+        return mask
+
+def post_process_wound_mask(mask, min_area=100):
+    """Post-process the wound mask to remove noise and small objects"""
+    if mask is None:
+        return None
+
+    # Convert to binary if needed
+    if mask.dtype != np.uint8:
+        mask = mask.astype(np.uint8)
+
+    # Apply morphological operations to clean up
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (10, 10))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+
+    # Remove small objects using OpenCV
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    mask_clean = np.zeros_like(mask)
+
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area >= min_area:
+            cv2.fillPoly(mask_clean, [contour], 255)
+
+    # Fill holes
+    mask_clean = cv2.morphologyEx(mask_clean, cv2.MORPH_CLOSE, kernel)
+
+    return mask_clean
+
+def analyze_wound_severity_auto(image, depth_map, pixel_spacing_mm=0.5, segmentation_method='deep_learning'):
+    """Analyze wound severity with automatic mask generation using actual segmentation model"""
+    if image is None or depth_map is None:
+        return "❌ Please provide both image and depth map."
+
+    # Generate automatic wound mask using the actual model
+    auto_mask = create_automatic_wound_mask(image, method=segmentation_method)
+
+    if auto_mask is None:
+        return "❌ Failed to generate automatic wound mask. Please check if the segmentation model is loaded."
+
+    # Post-process the mask
+    processed_mask = post_process_wound_mask(auto_mask, min_area=500)
+
+    if processed_mask is None or np.sum(processed_mask > 0) == 0:
+        return "❌ No wound region detected by the segmentation model. Try uploading a different image or use manual mask."
+
+    # Analyze severity using the automatic mask
+    return analyze_wound_severity(image, depth_map, processed_mask, pixel_spacing_mm)
+
+# --- Main Gradio Interface ---
+with gr.Blocks(css=css, title="Wound Analysis & Depth Estimation") as demo:
+    gr.HTML("<h1>Wound Analysis & Depth Estimation System</h1>")
+    gr.Markdown("### Comprehensive wound analysis with classification and 3D depth mapping capabilities")
+
+    # Shared image state
+    shared_image = gr.State()
+
+    with gr.Tabs():
+        # Tab 1: Wound Classification
+        with gr.Tab("1. Wound Classification"):
+            gr.Markdown("### Step 1: Upload and classify your wound image")
+            gr.Markdown("This module analyzes wound images and provides classification with AI-powered reasoning.")
+
+            with gr.Row():
+                with gr.Column(scale=1):
+                    wound_image_input = gr.Image(label="Upload Wound Image", type="pil", height=350)
+
+                with gr.Column(scale=1):
+                    wound_prediction_box = gr.HTML()
+                    wound_reasoning_box = gr.HTML()
+
+            # Button to pass image to depth estimation
+            with gr.Row():
+                pass_to_depth_btn = gr.Button("📊 Pass Image to Depth Analysis", variant="secondary", size="lg")
+                pass_status = gr.HTML("")
+
+            wound_image_input.change(fn=classify_wound_image, inputs=wound_image_input,
+                                   outputs=[wound_prediction_box, wound_reasoning_box])
+
+            # Store image when uploaded for classification
+            wound_image_input.change(
+                fn=lambda img: img,
+                inputs=[wound_image_input],
+                outputs=[shared_image]
+            )
+
+        # Tab 2: Depth Estimation
+        with gr.Tab("2. Depth Estimation & 3D Visualization"):
+            gr.Markdown("### Step 2: Generate depth maps and 3D visualizations")
+            gr.Markdown("This module creates depth maps and 3D point clouds from your images.")
+
+            with gr.Row():
+                depth_input_image = gr.Image(label="Input Image", type='numpy', elem_id='img-display-input')
+                depth_image_slider = ImageSlider(label="Depth Map with Slider View", elem_id='img-display-output')
+
+            with gr.Row():
+                depth_submit = gr.Button(value="Compute Depth", variant="primary")
+                load_shared_btn = gr.Button("🔄 Load Image from Classification", variant="secondary")
+                points_slider = gr.Slider(minimum=1000, maximum=10000, value=10000, step=1000,
+                                         label="Number of 3D points (upload image to update max)")
+
+            with gr.Row():
+                focal_length_x = gr.Slider(minimum=100, maximum=1000, value=470.4, step=10,
+                                          label="Focal Length X (pixels)")
+                focal_length_y = gr.Slider(minimum=100, maximum=1000, value=470.4, step=10,
+                                          label="Focal Length Y (pixels)")
+
+            with gr.Row():
+                gray_depth_file = gr.File(label="Grayscale depth map", elem_id="download")
+                raw_file = gr.File(label="16-bit raw output (can be considered as disparity)", elem_id="download")
+                point_cloud_file = gr.File(label="Point Cloud (.ply)", elem_id="download")
+
+            # 3D Visualization
+            gr.Markdown("### 3D Point Cloud Visualization")
+            gr.Markdown("Enhanced 3D visualization using proper camera projection. Hover over points to see 3D coordinates.")
+            depth_3d_plot = gr.Plot(label="3D Point Cloud")
+
+            # Store depth map for severity analysis
+            depth_map_state = gr.State()
+
+        # Tab 3: Wound Severity Analysis
+        with gr.Tab("3. 🩹 Wound Severity Analysis"):
+            gr.Markdown("### Step 3: Analyze wound severity using depth maps")
+            gr.Markdown("This module analyzes wound severity based on depth distribution and area measurements.")
+
+            with gr.Row():
+                severity_input_image = gr.Image(label="Original Image", type='numpy')
+                severity_depth_map = gr.Image(label="Depth Map (from Tab 2)", type='numpy')
+
+            with gr.Row():
+                wound_mask_input = gr.Image(label="Auto-Generated Wound Mask", type='numpy')
+                severity_output = gr.HTML(label="Severity Analysis Report")
+
+            gr.Markdown("**Note:** The deep learning segmentation model will automatically generate a wound mask when you upload an image or load a depth map.")
+
+            with gr.Row():
+                auto_severity_button = gr.Button("🤖 Analyze Severity with Auto-Generated Mask", variant="primary", size="lg")
+                manual_severity_button = gr.Button("🔍 Manual Mask Analysis", variant="secondary", size="lg")
+                pixel_spacing_slider = gr.Slider(minimum=0.1, maximum=2.0, value=0.5, step=0.1,
+                                               label="Pixel Spacing (mm/pixel)")
+
+            gr.Markdown("**Pixel Spacing:** Adjust based on your camera calibration. Default is 0.5 mm/pixel.")
+
+            with gr.Row():
+                # Load depth map from previous tab
+                load_depth_btn = gr.Button("🔄 Load Depth Map from Tab 2", variant="secondary")
+
+            gr.Markdown("**Note:** When you load a depth map or upload an image, the segmentation model will automatically generate a wound mask.")
+
+            # Update slider when image is uploaded
+            depth_input_image.change(
+                fn=update_slider_on_image_upload,
+                inputs=[depth_input_image],
+                outputs=[points_slider]
+            )
+
+            # Modified depth submit function to store depth map
+            def on_depth_submit_with_state(image, num_points, focal_x, focal_y):
+                results = on_depth_submit(image, num_points, focal_x, focal_y)
+                # Extract depth map from results for severity analysis
+                depth_map = None
+                if image is not None:
+                    depth = predict_depth(image[:, :, ::-1])  # RGB to BGR if needed
+                    # Normalize depth for severity analysis
+                    norm_depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
+                    depth_map = norm_depth.astype(np.uint8)
+                return results + [depth_map]
+
+            depth_submit.click(on_depth_submit_with_state,
+                             inputs=[depth_input_image, points_slider, focal_length_x, focal_length_y],
+                             outputs=[depth_image_slider, gray_depth_file, raw_file, point_cloud_file, depth_3d_plot, depth_map_state])
+
+            # Load depth map to severity tab and auto-generate mask
+            def load_depth_to_severity(depth_map, original_image):
+                if depth_map is None:
+                    return None, None, None, "❌ No depth map available. Please compute depth in Tab 2 first."
+                
+                # Auto-generate wound mask using segmentation model
+                if original_image is not None:
+                    auto_mask, _ = segmentation_model.segment_wound(original_image)
+                    if auto_mask is not None:
+                        # Post-process the mask
+                        processed_mask = post_process_wound_mask(auto_mask, min_area=500)
+                        if processed_mask is not None and np.sum(processed_mask > 0) > 0:
+                            return depth_map, original_image, processed_mask, "✅ Depth map loaded and wound mask auto-generated!"
+                        else:
+                            return depth_map, original_image, None, "✅ Depth map loaded but no wound detected. Try uploading a different image."
+                    else:
+                        return depth_map, original_image, None, "✅ Depth map loaded but segmentation failed. Try uploading a different image."
+                else:
+                    return depth_map, original_image, None, "✅ Depth map loaded successfully!"
+
+            load_depth_btn.click(
+                fn=load_depth_to_severity,
+                inputs=[depth_map_state, depth_input_image],
+                outputs=[severity_depth_map, severity_input_image, wound_mask_input, gr.HTML()]
+            )
+
+            # Automatic severity analysis function
+            def run_auto_severity_analysis(image, depth_map, pixel_spacing):
+                if depth_map is None:
+                    return "❌ Please load depth map from Tab 2 first."
+
+                # Generate automatic wound mask using the actual model
+                auto_mask = create_automatic_wound_mask(image, method='deep_learning')
+
+                if auto_mask is None:
+                    return "❌ Failed to generate automatic wound mask. Please check if the segmentation model is loaded."
+
+                # Post-process the mask with fixed minimum area
+                processed_mask = post_process_wound_mask(auto_mask, min_area=500)
+
+                if processed_mask is None or np.sum(processed_mask > 0) == 0:
+                    return "❌ No wound region detected by the segmentation model. Try uploading a different image or use manual mask."
+
+                # Analyze severity using the automatic mask
+                return analyze_wound_severity(image, depth_map, processed_mask, pixel_spacing)
+
+            # Manual severity analysis function
+            def run_manual_severity_analysis(image, depth_map, wound_mask, pixel_spacing):
+                if depth_map is None:
+                    return "❌ Please load depth map from Tab 2 first."
+                if wound_mask is None:
+                    return "❌ Please upload a wound mask (binary image where white pixels represent the wound area)."
+
+                return analyze_wound_severity(image, depth_map, wound_mask, pixel_spacing)
+
+            # Connect event handlers
+            auto_severity_button.click(
+                fn=run_auto_severity_analysis,
+                inputs=[severity_input_image, severity_depth_map, pixel_spacing_slider],
+                outputs=[severity_output]
+            )
+
+            manual_severity_button.click(
+                fn=run_manual_severity_analysis,
+                inputs=[severity_input_image, severity_depth_map, wound_mask_input, pixel_spacing_slider],
+                outputs=[severity_output]
+            )
+
+
+
+            # Auto-generate mask when image is uploaded
+            def auto_generate_mask_on_image_upload(image):
+                if image is None:
+                    return None, "❌ No image uploaded."
+                
+                # Generate automatic wound mask using segmentation model
+                auto_mask, _ = segmentation_model.segment_wound(image)
+                if auto_mask is not None:
+                    # Post-process the mask
+                    processed_mask = post_process_wound_mask(auto_mask, min_area=500)
+                    if processed_mask is not None and np.sum(processed_mask > 0) > 0:
+                        return processed_mask, "✅ Wound mask auto-generated using deep learning model!"
+                    else:
+                        return None, "✅ Image uploaded but no wound detected. Try uploading a different image."
+                else:
+                    return None, "✅ Image uploaded but segmentation failed. Try uploading a different image."
+
+            # Load shared image from classification tab
+            def load_shared_image(shared_img):
+                if shared_img is None:
+                    return gr.Image(), "�� No image available from classification tab"
+
+                # Convert PIL image to numpy array for depth estimation
+                if hasattr(shared_img, 'convert'):
+                    # It's a PIL image, convert to numpy
+                    img_array = np.array(shared_img)
+                    return img_array, "✅ Image loaded from classification tab"
+                else:
+                    # Already numpy array
+                    return shared_img, "✅ Image loaded from classification tab"
+
+            # Auto-generate mask when image is uploaded to severity tab
+            severity_input_image.change(
+                fn=auto_generate_mask_on_image_upload,
+                inputs=[severity_input_image],
+                outputs=[wound_mask_input, gr.HTML()]
+            )
+
+            load_shared_btn.click(
+                fn=load_shared_image,
+                inputs=[shared_image],
+                outputs=[depth_input_image, gr.HTML()]
+            )
+
+            # Pass image to depth tab function
+            def pass_image_to_depth(img):
+                if img is None:
+                    return "❌ No image uploaded in classification tab"
+                return "✅ Image ready for depth analysis! Switch to tab 2 and click 'Load Image from Classification'"
+
+            pass_to_depth_btn.click(
+                fn=pass_image_to_depth,
+                inputs=[shared_image],
+                outputs=[pass_status]
+            )
+
+if __name__ == '__main__':
+    demo.queue().launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )

temp_files/README.md

@@ -0,0 +1,12 @@
+---
+title: Wound Analysis V22
+emoji: 📉
+colorFrom: purple
+colorTo: green
+sdk: gradio
+sdk_version: 5.41.1
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

temp_files/fw2.txt

@@ -0,0 +1,1175 @@
+import glob
+import gradio as gr
+import matplotlib
+import numpy as np
+from PIL import Image
+import torch
+import tempfile
+from gradio_imageslider import ImageSlider
+import plotly.graph_objects as go
+import plotly.express as px
+import open3d as o3d
+from depth_anything_v2.dpt import DepthAnythingV2
+import os
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image as keras_image
+import base64
+from io import BytesIO
+import gdown
+import spaces
+import cv2
+
+# Import actual segmentation model components
+from models.deeplab import Deeplabv3, relu6, DepthwiseConv2D, BilinearUpsampling
+from utils.learning.metrics import dice_coef, precision, recall
+from utils.io.data import normalize
+
+# Define path and file ID
+checkpoint_dir = "checkpoints"
+os.makedirs(checkpoint_dir, exist_ok=True)
+
+model_file = os.path.join(checkpoint_dir, "depth_anything_v2_vitl.pth")
+gdrive_url = "https://drive.google.com/uc?id=141Mhq2jonkUBcVBnNqNSeyIZYtH5l4K5"
+
+# Download if not already present
+if not os.path.exists(model_file):
+    print("Downloading model from Google Drive...")
+    gdown.download(gdrive_url, model_file, quiet=False)
+
+# --- TensorFlow: Check GPU Availability ---
+gpus = tf.config.list_physical_devices('GPU')
+if gpus:
+    print("TensorFlow is using GPU")
+else:
+    print("TensorFlow is using CPU")
+
+# --- Load Wound Classification Model and Class Labels ---
+wound_model = load_model("keras_model.h5")
+with open("labels.txt", "r") as f:
+    class_labels = [line.strip().split(maxsplit=1)[1] for line in f]
+
+# --- Load Actual Wound Segmentation Model ---
+class WoundSegmentationModel:
+    def __init__(self):
+        self.input_dim_x = 224
+        self.input_dim_y = 224
+        self.model = None
+        self.load_model()
+    
+    def load_model(self):
+        """Load the trained wound segmentation model"""
+        try:
+            # Try to load the most recent model
+            weight_file_name = '2025-08-07_16-25-27.hdf5'
+            model_path = f'./training_history/{weight_file_name}'
+            
+            self.model = load_model(model_path, 
+                                  custom_objects={
+                                      'recall': recall,
+                                      'precision': precision,
+                                      'dice_coef': dice_coef,
+                                      'relu6': relu6,
+                                      'DepthwiseConv2D': DepthwiseConv2D,
+                                      'BilinearUpsampling': BilinearUpsampling
+                                  })
+            print(f"Segmentation model loaded successfully from {model_path}")
+        except Exception as e:
+            print(f"Error loading segmentation model: {e}")
+            # Fallback to the older model
+            try:
+                weight_file_name = '2019-12-19 01%3A53%3A15.480800.hdf5'
+                model_path = f'./training_history/{weight_file_name}'
+                
+                self.model = load_model(model_path, 
+                                      custom_objects={
+                                          'recall': recall,
+                                          'precision': precision,
+                                          'dice_coef': dice_coef,
+                                          'relu6': relu6,
+                                          'DepthwiseConv2D': DepthwiseConv2D,
+                                          'BilinearUpsampling': BilinearUpsampling
+                                      })
+                print(f"Segmentation model loaded successfully from {model_path}")
+            except Exception as e2:
+                print(f"Error loading fallback segmentation model: {e2}")
+                self.model = None
+    
+    def preprocess_image(self, image):
+        """Preprocess the uploaded image for model input"""
+        if image is None:
+            return None
+        
+        # Convert to RGB if needed
+        if len(image.shape) == 3 and image.shape[2] == 3:
+            # Convert BGR to RGB if needed
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        
+        # Resize to model input size
+        image = cv2.resize(image, (self.input_dim_x, self.input_dim_y))
+        
+        # Normalize the image
+        image = image.astype(np.float32) / 255.0
+        
+        # Add batch dimension
+        image = np.expand_dims(image, axis=0)
+        
+        return image
+    
+    def postprocess_prediction(self, prediction):
+        """Postprocess the model prediction"""
+        # Remove batch dimension
+        prediction = prediction[0]
+        
+        # Apply threshold to get binary mask
+        threshold = 0.5
+        binary_mask = (prediction > threshold).astype(np.uint8) * 255
+        
+        return binary_mask
+    
+    def segment_wound(self, input_image):
+        """Main function to segment wound from uploaded image"""
+        if self.model is None:
+            return None, "Error: Segmentation model not loaded. Please check the model files."
+        
+        if input_image is None:
+            return None, "Please upload an image."
+        
+        try:
+            # Preprocess the image
+            processed_image = self.preprocess_image(input_image)
+            
+            if processed_image is None:
+                return None, "Error processing image."
+            
+            # Make prediction
+            prediction = self.model.predict(processed_image, verbose=0)
+            
+            # Postprocess the prediction
+            segmented_mask = self.postprocess_prediction(prediction)
+            
+            return segmented_mask, "Segmentation completed successfully!"
+            
+        except Exception as e:
+            return None, f"Error during segmentation: {str(e)}"
+
+# Initialize the segmentation model
+segmentation_model = WoundSegmentationModel()
+
+# --- PyTorch: Set Device and Load Depth Model ---
+map_device = torch.device("cuda" if torch.cuda.is_available() and torch.cuda.device_count() > 0 else "cpu")
+print(f"Using PyTorch device: {map_device}")
+
+model_configs = {
+    'vits': {'encoder': 'vits', 'features': 64, 'out_channels': [48, 96, 192, 384]},
+    'vitb': {'encoder': 'vitb', 'features': 128, 'out_channels': [96, 192, 384, 768]},
+    'vitl': {'encoder': 'vitl', 'features': 256, 'out_channels': [256, 512, 1024, 1024]},
+    'vitg': {'encoder': 'vitg', 'features': 384, 'out_channels': [1536, 1536, 1536, 1536]}
+}
+encoder = 'vitl'
+depth_model = DepthAnythingV2(**model_configs[encoder])
+state_dict = torch.load(
+    f'checkpoints/depth_anything_v2_{encoder}.pth',
+    map_location=map_device
+)
+depth_model.load_state_dict(state_dict)
+depth_model = depth_model.to(map_device).eval()
+
+
+# --- Custom CSS for unified dark theme ---
+css = """
+.gradio-container {
+    font-family: 'Segoe UI', sans-serif;
+    background-color: #121212;
+    color: #ffffff;
+    padding: 20px;
+}
+.gr-button {
+    background-color: #2c3e50;
+    color: white;
+    border-radius: 10px;
+}
+.gr-button:hover {
+    background-color: #34495e;
+}
+.gr-html, .gr-html div {
+    white-space: normal !important;
+    overflow: visible !important;
+    text-overflow: unset !important;
+    word-break: break-word !important;
+}
+#img-display-container {
+    max-height: 100vh;
+}
+#img-display-input {
+    max-height: 80vh;
+}
+#img-display-output {
+    max-height: 80vh;
+}
+#download {
+    height: 62px;
+}
+h1 {
+    text-align: center;
+    font-size: 3rem;
+    font-weight: bold;
+    margin: 2rem 0;
+    color: #ffffff;
+}
+h2 {
+    color: #ffffff;
+    text-align: center;
+    margin: 1rem 0;
+}
+.gr-tabs {
+    background-color: #1e1e1e;
+    border-radius: 10px;
+    padding: 10px;
+}
+.gr-tab-nav {
+    background-color: #2c3e50;
+    border-radius: 8px;
+}
+.gr-tab-nav button {
+    color: #ffffff !important;
+}
+.gr-tab-nav button.selected {
+    background-color: #34495e !important;
+}
+"""
+
+# --- Wound Classification Functions ---
+def preprocess_input(img):
+    img = img.resize((224, 224))
+    arr = keras_image.img_to_array(img)
+    arr = arr / 255.0
+    return np.expand_dims(arr, axis=0)
+
+def get_reasoning_from_gemini(img, prediction):
+    try:
+        # For now, return a simple explanation without Gemini API to avoid typing issues
+        # In production, you would implement the proper Gemini API call here
+        explanations = {
+            "Abrasion": "This appears to be an abrasion wound, characterized by superficial damage to the skin surface. The wound shows typical signs of friction or scraping injury.",
+            "Burn": "This wound exhibits characteristics consistent with a burn injury, showing tissue damage from heat, chemicals, or radiation exposure.",
+            "Laceration": "This wound displays the irregular edges and tissue tearing typical of a laceration, likely caused by blunt force trauma.",
+            "Puncture": "This wound shows a small, deep entry point characteristic of puncture wounds, often caused by sharp, pointed objects.",
+            "Ulcer": "This wound exhibits the characteristics of an ulcer, showing tissue breakdown and potential underlying vascular or pressure issues."
+        }
+
+        return explanations.get(prediction, f"This wound has been classified as {prediction}. Please consult with a healthcare professional for detailed assessment.")
+
+    except Exception as e:
+        return f"(Reasoning unavailable: {str(e)})"
+    
+@spaces.GPU
+def classify_wound_image(img):
+    if img is None:
+        return "<div style='color:#ff5252; font-size:18px;'>No image provided</div>", ""
+
+    img_array = preprocess_input(img)
+    predictions = wound_model.predict(img_array, verbose=0)[0]
+    pred_idx = int(np.argmax(predictions))
+    pred_class = class_labels[pred_idx]
+
+    # Get reasoning from Gemini
+    reasoning_text = get_reasoning_from_gemini(img, pred_class)
+
+    # Prediction Card
+    predicted_card = f"""
+    <div style='padding: 20px; background-color: #1e1e1e; border-radius: 12px;
+                box-shadow: 0 0 10px rgba(0,0,0,0.5);'>
+        <div style='font-size: 22px; font-weight: bold; color: orange; margin-bottom: 10px;'>
+            Predicted Wound Type
+        </div>
+        <div style='font-size: 26px; color: white;'>
+            {pred_class}
+        </div>
+    </div>
+    """
+
+    # Reasoning Card
+    reasoning_card = f"""
+    <div style='padding: 20px; background-color: #1e1e1e; border-radius: 12px;
+                box-shadow: 0 0 10px rgba(0,0,0,0.5);'>
+        <div style='font-size: 22px; font-weight: bold; color: orange; margin-bottom: 10px;'>
+            Reasoning
+        </div>
+        <div style='font-size: 16px; color: white; min-height: 80px;'>
+            {reasoning_text}
+        </div>
+    </div>
+    """
+
+    return predicted_card, reasoning_card
+
+# --- Enhanced Wound Severity Estimation Functions ---
+@spaces.GPU
+def compute_enhanced_depth_statistics(depth_map, mask, pixel_spacing_mm=0.5, depth_calibration_mm=15.0):
+    """
+    Enhanced depth analysis with proper calibration and medical standards
+    Based on wound depth classification standards:
+    - Superficial: 0-2mm (epidermis only)
+    - Partial thickness: 2-4mm (epidermis + partial dermis)
+    - Full thickness: 4-6mm (epidermis + full dermis)
+    - Deep: >6mm (involving subcutaneous tissue)
+    """
+    # Convert pixel spacing to mm
+    pixel_spacing_mm = float(pixel_spacing_mm)
+    
+    # Calculate pixel area in cm²
+    pixel_area_cm2 = (pixel_spacing_mm / 10.0) ** 2
+    
+    # Extract wound region (binary mask)
+    wound_mask = (mask > 127).astype(np.uint8)
+    
+    # Apply morphological operations to clean the mask
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+    wound_mask = cv2.morphologyEx(wound_mask, cv2.MORPH_CLOSE, kernel)
+    
+    # Get depth values only for wound region
+    wound_depths = depth_map[wound_mask > 0]
+    
+    if len(wound_depths) == 0:
+        return {
+            'total_area_cm2': 0,
+            'superficial_area_cm2': 0,
+            'partial_thickness_area_cm2': 0,
+            'full_thickness_area_cm2': 0,
+            'deep_area_cm2': 0,
+            'mean_depth_mm': 0,
+            'max_depth_mm': 0,
+            'depth_std_mm': 0,
+            'deep_ratio': 0,
+            'wound_volume_cm3': 0,
+            'depth_percentiles': {'25': 0, '50': 0, '75': 0}
+        }
+    
+    # Calibrate depth map for more accurate measurements
+    calibrated_depth_map = calibrate_depth_map(depth_map, reference_depth_mm=depth_calibration_mm)
+    
+    # Get calibrated depth values for wound region
+    wound_depths_mm = calibrated_depth_map[wound_mask > 0]
+    
+    # Medical depth classification
+    superficial_mask = wound_depths_mm < 2.0
+    partial_thickness_mask = (wound_depths_mm >= 2.0) & (wound_depths_mm < 4.0)
+    full_thickness_mask = (wound_depths_mm >= 4.0) & (wound_depths_mm < 6.0)
+    deep_mask = wound_depths_mm >= 6.0
+    
+    # Calculate areas
+    total_pixels = np.sum(wound_mask > 0)
+    total_area_cm2 = total_pixels * pixel_area_cm2
+    
+    superficial_area_cm2 = np.sum(superficial_mask) * pixel_area_cm2
+    partial_thickness_area_cm2 = np.sum(partial_thickness_mask) * pixel_area_cm2
+    full_thickness_area_cm2 = np.sum(full_thickness_mask) * pixel_area_cm2
+    deep_area_cm2 = np.sum(deep_mask) * pixel_area_cm2
+    
+    # Calculate depth statistics
+    mean_depth_mm = np.mean(wound_depths_mm)
+    max_depth_mm = np.max(wound_depths_mm)
+    depth_std_mm = np.std(wound_depths_mm)
+    
+    # Calculate depth percentiles
+    depth_percentiles = {
+        '25': np.percentile(wound_depths_mm, 25),
+        '50': np.percentile(wound_depths_mm, 50),
+        '75': np.percentile(wound_depths_mm, 75)
+    }
+    
+    # Calculate wound volume (approximate)
+    # Volume = area * average depth
+    wound_volume_cm3 = total_area_cm2 * (mean_depth_mm / 10.0)
+    
+    # Deep tissue ratio
+    deep_ratio = deep_area_cm2 / total_area_cm2 if total_area_cm2 > 0 else 0
+    
+    # Calculate analysis quality metrics
+    wound_pixel_count = len(wound_depths_mm)
+    analysis_quality = "High" if wound_pixel_count > 1000 else "Medium" if wound_pixel_count > 500 else "Low"
+    
+    # Calculate depth consistency (lower std dev = more consistent)
+    depth_consistency = "High" if depth_std_mm < 2.0 else "Medium" if depth_std_mm < 4.0 else "Low"
+    
+    return {
+        'total_area_cm2': total_area_cm2,
+        'superficial_area_cm2': superficial_area_cm2,
+        'partial_thickness_area_cm2': partial_thickness_area_cm2,
+        'full_thickness_area_cm2': full_thickness_area_cm2,
+        'deep_area_cm2': deep_area_cm2,
+        'mean_depth_mm': mean_depth_mm,
+        'max_depth_mm': max_depth_mm,
+        'depth_std_mm': depth_std_mm,
+        'deep_ratio': deep_ratio,
+        'wound_volume_cm3': wound_volume_cm3,
+        'depth_percentiles': depth_percentiles,
+        'analysis_quality': analysis_quality,
+        'depth_consistency': depth_consistency,
+        'wound_pixel_count': wound_pixel_count
+    }
+
+def classify_wound_severity_by_enhanced_metrics(depth_stats):
+    """
+    Enhanced wound severity classification based on medical standards
+    Uses multiple criteria: depth, area, volume, and tissue involvement
+    """
+    if depth_stats['total_area_cm2'] == 0:
+        return "Unknown"
+    
+    # Extract key metrics
+    total_area = depth_stats['total_area_cm2']
+    deep_area = depth_stats['deep_area_cm2']
+    full_thickness_area = depth_stats['full_thickness_area_cm2']
+    mean_depth = depth_stats['mean_depth_mm']
+    max_depth = depth_stats['max_depth_mm']
+    wound_volume = depth_stats['wound_volume_cm3']
+    deep_ratio = depth_stats['deep_ratio']
+    
+    # Medical severity classification criteria
+    severity_score = 0
+    
+    # Criterion 1: Maximum depth
+    if max_depth >= 10.0:
+        severity_score += 3  # Very severe
+    elif max_depth >= 6.0:
+        severity_score += 2  # Severe
+    elif max_depth >= 4.0:
+        severity_score += 1  # Moderate
+    
+    # Criterion 2: Mean depth
+    if mean_depth >= 5.0:
+        severity_score += 2
+    elif mean_depth >= 3.0:
+        severity_score += 1
+    
+    # Criterion 3: Deep tissue involvement ratio
+    if deep_ratio >= 0.5:
+        severity_score += 3  # More than 50% deep tissue
+    elif deep_ratio >= 0.25:
+        severity_score += 2  # 25-50% deep tissue
+    elif deep_ratio >= 0.1:
+        severity_score += 1  # 10-25% deep tissue
+    
+    # Criterion 4: Total wound area
+    if total_area >= 10.0:
+        severity_score += 2  # Large wound (>10 cm²)
+    elif total_area >= 5.0:
+        severity_score += 1  # Medium wound (5-10 cm²)
+    
+    # Criterion 5: Wound volume
+    if wound_volume >= 5.0:
+        severity_score += 2  # High volume
+    elif wound_volume >= 2.0:
+        severity_score += 1  # Medium volume
+    
+    # Determine severity based on total score
+    if severity_score >= 8:
+        return "Very Severe"
+    elif severity_score >= 6:
+        return "Severe"
+    elif severity_score >= 4:
+        return "Moderate"
+    elif severity_score >= 2:
+        return "Mild"
+    else:
+        return "Superficial"
+
+def analyze_wound_severity(image, depth_map, wound_mask, pixel_spacing_mm=0.5, depth_calibration_mm=15.0):
+    """Enhanced wound severity analysis with medical-grade metrics"""
+    if image is None or depth_map is None or wound_mask is None:
+        return "❌ Please upload image, depth map, and wound mask."
+
+    # Convert wound mask to grayscale if needed
+    if len(wound_mask.shape) == 3:
+        wound_mask = np.mean(wound_mask, axis=2)
+
+    # Ensure depth map and mask have same dimensions
+    if depth_map.shape[:2] != wound_mask.shape[:2]:
+        # Resize mask to match depth map
+        from PIL import Image
+        mask_pil = Image.fromarray(wound_mask.astype(np.uint8))
+        mask_pil = mask_pil.resize((depth_map.shape[1], depth_map.shape[0]))
+        wound_mask = np.array(mask_pil)
+
+    # Compute enhanced statistics
+    stats = compute_enhanced_depth_statistics(depth_map, wound_mask, pixel_spacing_mm, depth_calibration_mm)
+    severity = classify_wound_severity_by_enhanced_metrics(stats)
+
+    # Enhanced severity color coding
+    severity_color = {
+        "Superficial": "#4CAF50",    # Green
+        "Mild": "#8BC34A",           # Light Green
+        "Moderate": "#FF9800",       # Orange
+        "Severe": "#F44336",         # Red
+        "Very Severe": "#9C27B0"     # Purple
+    }.get(severity, "#9E9E9E")       # Gray for unknown
+
+    # Create comprehensive medical report
+    report = f"""
+    <div style='padding: 20px; background-color: #1e1e1e; border-radius: 12px; box-shadow: 0 0 10px rgba(0,0,0,0.5);'>
+        <div style='font-size: 24px; font-weight: bold; color: {severity_color}; margin-bottom: 15px;'>
+            🩹 Enhanced Wound Severity Analysis
+        </div>
+
+        <div style='display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-bottom: 20px;'>
+            <div style='background-color: #2c2c2c; padding: 15px; border-radius: 8px;'>
+                <div style='font-size: 18px; font-weight: bold; color: #ffffff; margin-bottom: 10px;'>
+                    📏 Tissue Involvement Analysis
+                </div>
+                <div style='color: #cccccc; line-height: 1.6;'>
+                    <div>🟢 <b>Superficial (0-2mm):</b> {stats['superficial_area_cm2']:.2f} cm²</div>
+                    <div>🟡 <b>Partial Thickness (2-4mm):</b> {stats['partial_thickness_area_cm2']:.2f} cm²</div>
+                    <div>🟠 <b>Full Thickness (4-6mm):</b> {stats['full_thickness_area_cm2']:.2f} cm²</div>
+                    <div>🟥 <b>Deep (>6mm):</b> {stats['deep_area_cm2']:.2f} cm²</div>
+                    <div>📊 <b>Total Area:</b> {stats['total_area_cm2']:.2f} cm²</div>
+                </div>
+            </div>
+
+            <div style='background-color: #2c2c2c; padding: 15px; border-radius: 8px;'>
+                <div style='font-size: 18px; font-weight: bold; color: #ffffff; margin-bottom: 10px;'>
+                    📊 Depth Statistics
+                </div>
+                <div style='color: #cccccc; line-height: 1.6;'>
+                    <div>📏 <b>Mean Depth:</b> {stats['mean_depth_mm']:.1f} mm</div>
+                    <div>📐 <b>Max Depth:</b> {stats['max_depth_mm']:.1f} mm</div>
+                    <div>📊 <b>Depth Std Dev:</b> {stats['depth_std_mm']:.1f} mm</div>
+                    <div>📦 <b>Wound Volume:</b> {stats['wound_volume_cm3']:.2f} cm³</div>
+                    <div>🔥 <b>Deep Tissue Ratio:</b> {stats['deep_ratio']*100:.1f}%</div>
+                </div>
+            </div>
+        </div>
+
+        <div style='background-color: #2c2c2c; padding: 15px; border-radius: 8px; margin-bottom: 20px;'>
+            <div style='font-size: 18px; font-weight: bold; color: #ffffff; margin-bottom: 10px;'>
+                📈 Depth Percentiles & Quality Metrics
+            </div>
+            <div style='color: #cccccc; line-height: 1.6; display: grid; grid-template-columns: 1fr 1fr; gap: 15px;'>
+                <div>
+                    <div>📊 <b>25th Percentile:</b> {stats['depth_percentiles']['25']:.1f} mm</div>
+                    <div>📊 <b>Median (50th):</b> {stats['depth_percentiles']['50']:.1f} mm</div>
+                    <div>📊 <b>75th Percentile:</b> {stats['depth_percentiles']['75']:.1f} mm</div>
+                </div>
+                <div>
+                    <div>🔍 <b>Analysis Quality:</b> {stats['analysis_quality']}</div>
+                    <div>📏 <b>Depth Consistency:</b> {stats['depth_consistency']}</div>
+                    <div>📊 <b>Data Points:</b> {stats['wound_pixel_count']:,}</div>
+                </div>
+            </div>
+        </div>
+
+        <div style='text-align: center; padding: 15px; background-color: #2c2c2c; border-radius: 8px; border-left: 4px solid {severity_color};'>
+            <div style='font-size: 20px; font-weight: bold; color: {severity_color};'>
+                🎯 Medical Severity Assessment: {severity}
+            </div>
+            <div style='font-size: 14px; color: #cccccc; margin-top: 5px;'>
+                {get_enhanced_severity_description(severity)}
+            </div>
+        </div>
+    </div>
+    """
+
+    return report
+
+def calibrate_depth_map(depth_map, reference_depth_mm=10.0):
+    """
+    Calibrate depth map to real-world measurements using reference depth
+    This helps convert normalized depth values to actual millimeters
+    """
+    if depth_map is None:
+        return depth_map
+    
+    # Find the maximum depth value in the depth map
+    max_depth_value = np.max(depth_map)
+    min_depth_value = np.min(depth_map)
+    
+    if max_depth_value == min_depth_value:
+        return depth_map
+    
+    # Apply calibration to convert to millimeters
+    # Assuming the maximum depth in the map corresponds to reference_depth_mm
+    calibrated_depth = (depth_map - min_depth_value) / (max_depth_value - min_depth_value) * reference_depth_mm
+    
+    return calibrated_depth
+
+def get_enhanced_severity_description(severity):
+    """Get comprehensive medical description for severity level"""
+    descriptions = {
+        "Superficial": "Epidermis-only damage. Minimal tissue loss, typically heals within 1-2 weeks with basic wound care.",
+        "Mild": "Superficial to partial thickness wound. Limited tissue involvement, good healing potential with proper care.",
+        "Moderate": "Partial to full thickness involvement. Requires careful monitoring and may need advanced wound care techniques.",
+        "Severe": "Full thickness with deep tissue involvement. High risk of complications, requires immediate medical attention.",
+        "Very Severe": "Extensive deep tissue damage. Critical condition requiring immediate surgical intervention and specialized care.",
+        "Unknown": "Unable to determine severity due to insufficient data or poor image quality."
+    }
+    return descriptions.get(severity, "Severity assessment unavailable.")
+
+def create_sample_wound_mask(image_shape, center=None, radius=50):
+    """Create a sample circular wound mask for testing"""
+    if center is None:
+        center = (image_shape[1] // 2, image_shape[0] // 2)
+
+    mask = np.zeros(image_shape[:2], dtype=np.uint8)
+    y, x = np.ogrid[:image_shape[0], :image_shape[1]]
+
+    # Create circular mask
+    dist_from_center = np.sqrt((x - center[0])**2 + (y - center[1])**2)
+    mask[dist_from_center <= radius] = 255
+
+    return mask
+
+def create_realistic_wound_mask(image_shape, method='elliptical'):
+    """Create a more realistic wound mask with irregular shapes"""
+    h, w = image_shape[:2]
+    mask = np.zeros((h, w), dtype=np.uint8)
+
+    if method == 'elliptical':
+        # Create elliptical wound mask
+        center = (w // 2, h // 2)
+        radius_x = min(w, h) // 3
+        radius_y = min(w, h) // 4
+
+        y, x = np.ogrid[:h, :w]
+        # Add some irregularity to make it more realistic
+        ellipse = ((x - center[0])**2 / (radius_x**2) +
+                   (y - center[1])**2 / (radius_y**2)) <= 1
+
+        # Add some noise and irregularity
+        noise = np.random.random((h, w)) > 0.8
+        mask = (ellipse | noise).astype(np.uint8) * 255
+
+    elif method == 'irregular':
+        # Create irregular wound mask
+        center = (w // 2, h // 2)
+        radius = min(w, h) // 4
+
+        y, x = np.ogrid[:h, :w]
+        base_circle = np.sqrt((x - center[0])**2 + (y - center[1])**2) <= radius
+
+        # Add irregular extensions
+        extensions = np.zeros_like(base_circle)
+        for i in range(3):
+            angle = i * 2 * np.pi / 3
+            ext_x = int(center[0] + radius * 0.8 * np.cos(angle))
+            ext_y = int(center[1] + radius * 0.8 * np.sin(angle))
+            ext_radius = radius // 3
+
+            ext_circle = np.sqrt((x - ext_x)**2 + (y - ext_y)**2) <= ext_radius
+            extensions = extensions | ext_circle
+
+        mask = (base_circle | extensions).astype(np.uint8) * 255
+
+    # Apply morphological operations to smooth the mask
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+
+    return mask
+
+# --- Depth Estimation Functions ---
+@spaces.GPU
+def predict_depth(image):
+    return depth_model.infer_image(image)
+
+def calculate_max_points(image):
+    """Calculate maximum points based on image dimensions (3x pixel count)"""
+    if image is None:
+        return 10000  # Default value
+    h, w = image.shape[:2]
+    max_points = h * w * 3
+    # Ensure minimum and reasonable maximum values
+    return max(1000, min(max_points, 300000))
+
+def update_slider_on_image_upload(image):
+    """Update the points slider when an image is uploaded"""
+    max_points = calculate_max_points(image)
+    default_value = min(10000, max_points // 10)  # 10% of max points as default
+    return gr.Slider(minimum=1000, maximum=max_points, value=default_value, step=1000,
+                     label=f"Number of 3D points (max: {max_points:,})")
+
+@spaces.GPU
+def create_point_cloud(image, depth_map, focal_length_x=470.4, focal_length_y=470.4, max_points=30000):
+    """Create a point cloud from depth map using camera intrinsics with high detail"""
+    h, w = depth_map.shape
+
+    # Use smaller step for higher detail (reduced downsampling)
+    step = max(1, int(np.sqrt(h * w / max_points) * 0.5))  # Reduce step size for more detail
+
+    # Create mesh grid for camera coordinates
+    y_coords, x_coords = np.mgrid[0:h:step, 0:w:step]
+
+    # Convert to camera coordinates (normalized by focal length)
+    x_cam = (x_coords - w / 2) / focal_length_x
+    y_cam = (y_coords - h / 2) / focal_length_y
+
+    # Get depth values
+    depth_values = depth_map[::step, ::step]
+
+    # Calculate 3D points: (x_cam * depth, y_cam * depth, depth)
+    x_3d = x_cam * depth_values
+    y_3d = y_cam * depth_values
+    z_3d = depth_values
+
+    # Flatten arrays
+    points = np.stack([x_3d.flatten(), y_3d.flatten(), z_3d.flatten()], axis=1)
+
+    # Get corresponding image colors
+    image_colors = image[::step, ::step, :]
+    colors = image_colors.reshape(-1, 3) / 255.0
+
+    # Create Open3D point cloud
+    pcd = o3d.geometry.PointCloud()
+    pcd.points = o3d.utility.Vector3dVector(points)
+    pcd.colors = o3d.utility.Vector3dVector(colors)
+
+    return pcd
+
+@spaces.GPU
+def reconstruct_surface_mesh_from_point_cloud(pcd):
+    """Convert point cloud to a mesh using Poisson reconstruction with very high detail."""
+    # Estimate and orient normals with high precision
+    pcd.estimate_normals(search_param=o3d.geometry.KDTreeSearchParamHybrid(radius=0.005, max_nn=50))
+    pcd.orient_normals_consistent_tangent_plane(k=50)
+
+    # Create surface mesh with maximum detail (depth=12 for very high resolution)
+    mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(pcd, depth=12)
+
+    # Return mesh without filtering low-density vertices
+    return mesh
+
+@spaces.GPU
+def create_enhanced_3d_visualization(image, depth_map, max_points=10000):
+    """Create an enhanced 3D visualization using proper camera projection"""
+    h, w = depth_map.shape
+
+    # Downsample to avoid too many points for performance
+    step = max(1, int(np.sqrt(h * w / max_points)))
+
+    # Create mesh grid for camera coordinates
+    y_coords, x_coords = np.mgrid[0:h:step, 0:w:step]
+
+    # Convert to camera coordinates (normalized by focal length)
+    focal_length = 470.4  # Default focal length
+    x_cam = (x_coords - w / 2) / focal_length
+    y_cam = (y_coords - h / 2) / focal_length
+
+    # Get depth values
+    depth_values = depth_map[::step, ::step]
+
+    # Calculate 3D points: (x_cam * depth, y_cam * depth, depth)
+    x_3d = x_cam * depth_values
+    y_3d = y_cam * depth_values
+    z_3d = depth_values
+
+    # Flatten arrays
+    x_flat = x_3d.flatten()
+    y_flat = y_3d.flatten()
+    z_flat = z_3d.flatten()
+
+    # Get corresponding image colors
+    image_colors = image[::step, ::step, :]
+    colors_flat = image_colors.reshape(-1, 3)
+
+    # Create 3D scatter plot with proper camera projection
+    fig = go.Figure(data=[go.Scatter3d(
+        x=x_flat,
+        y=y_flat,
+        z=z_flat,
+        mode='markers',
+        marker=dict(
+            size=1.5,
+            color=colors_flat,
+            opacity=0.9
+        ),
+        hovertemplate='<b>3D Position:</b> (%{x:.3f}, %{y:.3f}, %{z:.3f})<br>' +
+                     '<b>Depth:</b> %{z:.2f}<br>' +
+                     '<extra></extra>'
+    )])
+
+    fig.update_layout(
+        title="3D Point Cloud Visualization (Camera Projection)",
+        scene=dict(
+            xaxis_title="X (meters)",
+            yaxis_title="Y (meters)",
+            zaxis_title="Z (meters)",
+            camera=dict(
+                eye=dict(x=2.0, y=2.0, z=2.0),
+                center=dict(x=0, y=0, z=0),
+                up=dict(x=0, y=0, z=1)
+            ),
+            aspectmode='data'
+        ),
+        width=700,
+        height=600
+    )
+
+    return fig
+
+def on_depth_submit(image, num_points, focal_x, focal_y):
+    original_image = image.copy()
+
+    h, w = image.shape[:2]
+
+    # Predict depth using the model
+    depth = predict_depth(image[:, :, ::-1])  # RGB to BGR if needed
+
+    # Save raw 16-bit depth
+    raw_depth = Image.fromarray(depth.astype('uint16'))
+    tmp_raw_depth = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
+    raw_depth.save(tmp_raw_depth.name)
+
+    # Normalize and convert to grayscale for display
+    norm_depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
+    norm_depth = norm_depth.astype(np.uint8)
+    colored_depth = (matplotlib.colormaps.get_cmap('Spectral_r')(norm_depth)[:, :, :3] * 255).astype(np.uint8)
+
+    gray_depth = Image.fromarray(norm_depth)
+    tmp_gray_depth = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
+    gray_depth.save(tmp_gray_depth.name)
+
+    # Create point cloud
+    pcd = create_point_cloud(original_image, norm_depth, focal_x, focal_y, max_points=num_points)
+
+    # Reconstruct mesh from point cloud
+    mesh = reconstruct_surface_mesh_from_point_cloud(pcd)
+
+    # Save mesh with faces as .ply
+    tmp_pointcloud = tempfile.NamedTemporaryFile(suffix='.ply', delete=False)
+    o3d.io.write_triangle_mesh(tmp_pointcloud.name, mesh)
+
+    # Create enhanced 3D scatter plot visualization
+    depth_3d = create_enhanced_3d_visualization(original_image, norm_depth, max_points=num_points)
+
+    return [(original_image, colored_depth), tmp_gray_depth.name, tmp_raw_depth.name, tmp_pointcloud.name, depth_3d]
+
+# --- Actual Wound Segmentation Functions ---
+def create_automatic_wound_mask(image, method='deep_learning'):
+    """
+    Automatically generate wound mask from image using the actual deep learning model
+
+    Args:
+        image: Input image (numpy array)
+        method: Segmentation method (currently only 'deep_learning' supported)
+
+    Returns:
+        mask: Binary wound mask
+    """
+    if image is None:
+        return None
+
+    # Use the actual deep learning model for segmentation
+    if method == 'deep_learning':
+        mask, _ = segmentation_model.segment_wound(image)
+        return mask
+    else:
+        # Fallback to deep learning if method not recognized
+        mask, _ = segmentation_model.segment_wound(image)
+        return mask
+
+def post_process_wound_mask(mask, min_area=100):
+    """Post-process the wound mask to remove noise and small objects"""
+    if mask is None:
+        return None
+
+    # Convert to binary if needed
+    if mask.dtype != np.uint8:
+        mask = mask.astype(np.uint8)
+
+    # Apply morphological operations to clean up
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (10, 10))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+
+    # Remove small objects using OpenCV
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    mask_clean = np.zeros_like(mask)
+
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area >= min_area:
+            cv2.fillPoly(mask_clean, [contour], 255)
+
+    # Fill holes
+    mask_clean = cv2.morphologyEx(mask_clean, cv2.MORPH_CLOSE, kernel)
+
+    return mask_clean
+
+def analyze_wound_severity_auto(image, depth_map, pixel_spacing_mm=0.5, segmentation_method='deep_learning'):
+    """Analyze wound severity with automatic mask generation using actual segmentation model"""
+    if image is None or depth_map is None:
+        return "❌ Please provide both image and depth map."
+
+    # Generate automatic wound mask using the actual model
+    auto_mask = create_automatic_wound_mask(image, method=segmentation_method)
+
+    if auto_mask is None:
+        return "❌ Failed to generate automatic wound mask. Please check if the segmentation model is loaded."
+
+    # Post-process the mask
+    processed_mask = post_process_wound_mask(auto_mask, min_area=500)
+
+    if processed_mask is None or np.sum(processed_mask > 0) == 0:
+        return "❌ No wound region detected by the segmentation model. Try uploading a different image or use manual mask."
+
+    # Analyze severity using the automatic mask
+    return analyze_wound_severity(image, depth_map, processed_mask, pixel_spacing_mm)
+
+# --- Main Gradio Interface ---
+with gr.Blocks(css=css, title="Wound Analysis & Depth Estimation") as demo:
+    gr.HTML("<h1>Wound Analysis & Depth Estimation System</h1>")
+    gr.Markdown("### Comprehensive wound analysis with classification and 3D depth mapping capabilities")
+
+    # Shared image state
+    shared_image = gr.State()
+
+    with gr.Tabs():
+        # Tab 1: Wound Classification
+        with gr.Tab("1. Wound Classification"):
+            gr.Markdown("### Step 1: Upload and classify your wound image")
+            gr.Markdown("This module analyzes wound images and provides classification with AI-powered reasoning.")
+
+            with gr.Row():
+                with gr.Column(scale=1):
+                    wound_image_input = gr.Image(label="Upload Wound Image", type="pil", height=350)
+
+                with gr.Column(scale=1):
+                    wound_prediction_box = gr.HTML()
+                    wound_reasoning_box = gr.HTML()
+
+            # Button to pass image to depth estimation
+            with gr.Row():
+                pass_to_depth_btn = gr.Button("📊 Pass Image to Depth Analysis", variant="secondary", size="lg")
+                pass_status = gr.HTML("")
+
+            wound_image_input.change(fn=classify_wound_image, inputs=wound_image_input,
+                                   outputs=[wound_prediction_box, wound_reasoning_box])
+
+            # Store image when uploaded for classification
+            wound_image_input.change(
+                fn=lambda img: img,
+                inputs=[wound_image_input],
+                outputs=[shared_image]
+            )
+
+        # Tab 2: Depth Estimation
+        with gr.Tab("2. Depth Estimation & 3D Visualization"):
+            gr.Markdown("### Step 2: Generate depth maps and 3D visualizations")
+            gr.Markdown("This module creates depth maps and 3D point clouds from your images.")
+
+            with gr.Row():
+                depth_input_image = gr.Image(label="Input Image", type='numpy', elem_id='img-display-input')
+                depth_image_slider = ImageSlider(label="Depth Map with Slider View", elem_id='img-display-output')
+
+            with gr.Row():
+                depth_submit = gr.Button(value="Compute Depth", variant="primary")
+                load_shared_btn = gr.Button("🔄 Load Image from Classification", variant="secondary")
+                points_slider = gr.Slider(minimum=1000, maximum=10000, value=10000, step=1000,
+                                         label="Number of 3D points (upload image to update max)")
+
+            with gr.Row():
+                focal_length_x = gr.Slider(minimum=100, maximum=1000, value=470.4, step=10,
+                                          label="Focal Length X (pixels)")
+                focal_length_y = gr.Slider(minimum=100, maximum=1000, value=470.4, step=10,
+                                          label="Focal Length Y (pixels)")
+
+            with gr.Row():
+                gray_depth_file = gr.File(label="Grayscale depth map", elem_id="download")
+                raw_file = gr.File(label="16-bit raw output (can be considered as disparity)", elem_id="download")
+                point_cloud_file = gr.File(label="Point Cloud (.ply)", elem_id="download")
+
+            # 3D Visualization
+            gr.Markdown("### 3D Point Cloud Visualization")
+            gr.Markdown("Enhanced 3D visualization using proper camera projection. Hover over points to see 3D coordinates.")
+            depth_3d_plot = gr.Plot(label="3D Point Cloud")
+
+            # Store depth map for severity analysis
+            depth_map_state = gr.State()
+
+        # Tab 3: Wound Severity Analysis
+        with gr.Tab("3. 🩹 Wound Severity Analysis"):
+            gr.Markdown("### Step 3: Analyze wound severity using depth maps")
+            gr.Markdown("This module analyzes wound severity based on depth distribution and area measurements.")
+
+            with gr.Row():
+                severity_input_image = gr.Image(label="Original Image", type='numpy')
+                severity_depth_map = gr.Image(label="Depth Map (from Tab 2)", type='numpy')
+
+            with gr.Row():
+                wound_mask_input = gr.Image(label="Auto-Generated Wound Mask", type='numpy')
+                severity_output = gr.HTML(label="Severity Analysis Report")
+
+            gr.Markdown("**Note:** The deep learning segmentation model will automatically generate a wound mask when you upload an image or load a depth map.")
+
+            with gr.Row():
+                auto_severity_button = gr.Button("🤖 Analyze Severity with Auto-Generated Mask", variant="primary", size="lg")
+                manual_severity_button = gr.Button("🔍 Manual Mask Analysis", variant="secondary", size="lg")
+                pixel_spacing_slider = gr.Slider(minimum=0.1, maximum=2.0, value=0.5, step=0.1,
+                                               label="Pixel Spacing (mm/pixel)")
+                depth_calibration_slider = gr.Slider(minimum=5.0, maximum=30.0, value=15.0, step=1.0,
+                                                   label="Depth Calibration (mm)", 
+                                                   info="Adjust based on expected maximum wound depth")
+
+            gr.Markdown("**Pixel Spacing:** Adjust based on your camera calibration. Default is 0.5 mm/pixel.")
+            gr.Markdown("**Depth Calibration:** Adjust the maximum expected wound depth to improve measurement accuracy. For shallow wounds use 5-10mm, for deep wounds use 15-30mm.")
+
+            with gr.Row():
+                # Load depth map from previous tab
+                load_depth_btn = gr.Button("🔄 Load Depth Map from Tab 2", variant="secondary")
+
+            gr.Markdown("**Note:** When you load a depth map or upload an image, the segmentation model will automatically generate a wound mask.")
+
+            # Update slider when image is uploaded
+            depth_input_image.change(
+                fn=update_slider_on_image_upload,
+                inputs=[depth_input_image],
+                outputs=[points_slider]
+            )
+
+            # Modified depth submit function to store depth map
+            def on_depth_submit_with_state(image, num_points, focal_x, focal_y):
+                results = on_depth_submit(image, num_points, focal_x, focal_y)
+                # Extract depth map from results for severity analysis
+                depth_map = None
+                if image is not None:
+                    depth = predict_depth(image[:, :, ::-1])  # RGB to BGR if needed
+                    # Normalize depth for severity analysis
+                    norm_depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
+                    depth_map = norm_depth.astype(np.uint8)
+                return results + [depth_map]
+
+            depth_submit.click(on_depth_submit_with_state,
+                             inputs=[depth_input_image, points_slider, focal_length_x, focal_length_y],
+                             outputs=[depth_image_slider, gray_depth_file, raw_file, point_cloud_file, depth_3d_plot, depth_map_state])
+
+            # Load depth map to severity tab and auto-generate mask
+            def load_depth_to_severity(depth_map, original_image):
+                if depth_map is None:
+                    return None, None, None, "❌ No depth map available. Please compute depth in Tab 2 first."
+                
+                # Auto-generate wound mask using segmentation model
+                if original_image is not None:
+                    auto_mask, _ = segmentation_model.segment_wound(original_image)
+                    if auto_mask is not None:
+                        # Post-process the mask
+                        processed_mask = post_process_wound_mask(auto_mask, min_area=500)
+                        if processed_mask is not None and np.sum(processed_mask > 0) > 0:
+                            return depth_map, original_image, processed_mask, "✅ Depth map loaded and wound mask auto-generated!"
+                        else:
+                            return depth_map, original_image, None, "✅ Depth map loaded but no wound detected. Try uploading a different image."
+                    else:
+                        return depth_map, original_image, None, "✅ Depth map loaded but segmentation failed. Try uploading a different image."
+                else:
+                    return depth_map, original_image, None, "✅ Depth map loaded successfully!"
+
+            load_depth_btn.click(
+                fn=load_depth_to_severity,
+                inputs=[depth_map_state, depth_input_image],
+                outputs=[severity_depth_map, severity_input_image, wound_mask_input, gr.HTML()]
+            )
+
+            # Automatic severity analysis function
+            def run_auto_severity_analysis(image, depth_map, pixel_spacing, depth_calibration):
+                if depth_map is None:
+                    return "❌ Please load depth map from Tab 2 first."
+
+                # Generate automatic wound mask using the actual model
+                auto_mask = create_automatic_wound_mask(image, method='deep_learning')
+
+                if auto_mask is None:
+                    return "❌ Failed to generate automatic wound mask. Please check if the segmentation model is loaded."
+
+                # Post-process the mask with fixed minimum area
+                processed_mask = post_process_wound_mask(auto_mask, min_area=500)
+
+                if processed_mask is None or np.sum(processed_mask > 0) == 0:
+                    return "❌ No wound region detected by the segmentation model. Try uploading a different image or use manual mask."
+
+                # Analyze severity using the automatic mask
+                return analyze_wound_severity(image, depth_map, processed_mask, pixel_spacing, depth_calibration)
+
+            # Manual severity analysis function
+            def run_manual_severity_analysis(image, depth_map, wound_mask, pixel_spacing, depth_calibration):
+                if depth_map is None:
+                    return "❌ Please load depth map from Tab 2 first."
+                if wound_mask is None:
+                    return "❌ Please upload a wound mask (binary image where white pixels represent the wound area)."
+
+                return analyze_wound_severity(image, depth_map, wound_mask, pixel_spacing, depth_calibration)
+
+            # Connect event handlers
+            auto_severity_button.click(
+                fn=run_auto_severity_analysis,
+                inputs=[severity_input_image, severity_depth_map, pixel_spacing_slider, depth_calibration_slider],
+                outputs=[severity_output]
+            )
+
+            manual_severity_button.click(
+                fn=run_manual_severity_analysis,
+                inputs=[severity_input_image, severity_depth_map, wound_mask_input, pixel_spacing_slider, depth_calibration_slider],
+                outputs=[severity_output]
+            )
+
+
+
+            # Auto-generate mask when image is uploaded
+            def auto_generate_mask_on_image_upload(image):
+                if image is None:
+                    return None, "❌ No image uploaded."
+                
+                # Generate automatic wound mask using segmentation model
+                auto_mask, _ = segmentation_model.segment_wound(image)
+                if auto_mask is not None:
+                    # Post-process the mask
+                    processed_mask = post_process_wound_mask(auto_mask, min_area=500)
+                    if processed_mask is not None and np.sum(processed_mask > 0) > 0:
+                        return processed_mask, "✅ Wound mask auto-generated using deep learning model!"
+                    else:
+                        return None, "✅ Image uploaded but no wound detected. Try uploading a different image."
+                else:
+                    return None, "✅ Image uploaded but segmentation failed. Try uploading a different image."
+
+            # Load shared image from classification tab
+            def load_shared_image(shared_img):
+                if shared_img is None:
+                    return gr.Image(), "❌ No image available from classification tab"
+
+                # Convert PIL image to numpy array for depth estimation
+                if hasattr(shared_img, 'convert'):
+                    # It's a PIL image, convert to numpy
+                    img_array = np.array(shared_img)
+                    return img_array, "✅ Image loaded from classification tab"
+                else:
+                    # Already numpy array
+                    return shared_img, "✅ Image loaded from classification tab"
+
+            # Auto-generate mask when image is uploaded to severity tab
+            severity_input_image.change(
+                fn=auto_generate_mask_on_image_upload,
+                inputs=[severity_input_image],
+                outputs=[wound_mask_input, gr.HTML()]
+            )
+
+            load_shared_btn.click(
+                fn=load_shared_image,
+                inputs=[shared_image],
+                outputs=[depth_input_image, gr.HTML()]
+            )
+
+            # Pass image to depth tab function
+            def pass_image_to_depth(img):
+                if img is None:
+                    return "❌ No image uploaded in classification tab"
+                return "✅ Image ready for depth analysis! Switch to tab 2 and click 'Load Image from Classification'"
+
+            pass_to_depth_btn.click(
+                fn=pass_image_to_depth,
+                inputs=[shared_image],
+                outputs=[pass_status]
+            )
+
+if __name__ == '__main__':
+    demo.queue().launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )

temp_files/predict.py

@@ -0,0 +1,64 @@
+import cv2
+from keras.models import load_model
+from keras.utils.generic_utils import CustomObjectScope
+
+from models.unets import Unet2D
+from models.deeplab import Deeplabv3, relu6, BilinearUpsampling, DepthwiseConv2D
+from models.FCN import FCN_Vgg16_16s
+
+from utils.learning.metrics import dice_coef, precision, recall
+from utils.BilinearUpSampling import BilinearUpSampling2D
+from utils.io.data import load_data, save_results, save_rgb_results, save_history, load_test_images, DataGen
+
+
+# settings
+input_dim_x = 224
+input_dim_y = 224
+color_space = 'rgb'
+path = './data/Medetec_foot_ulcer_224/'
+weight_file_name = '2019-12-19 01%3A53%3A15.480800.hdf5'
+pred_save_path = '2019-12-19 01%3A53%3A15.480800/'
+
+data_gen = DataGen(path, split_ratio=0.0, x=input_dim_x, y=input_dim_y, color_space=color_space)
+x_test, test_label_filenames_list = load_test_images(path)
+
+# ### get unet model
+# unet2d = Unet2D(n_filters=64, input_dim_x=input_dim_x, input_dim_y=input_dim_y, num_channels=3)
+# model = unet2d.get_unet_model_yuanqing()
+# model = load_model('./azh_wound_care_center_diabetic_foot_training_history/' + weight_file_name
+#                , custom_objects={'recall':recall,
+#                                  'precision':precision,
+#                                  'dice_coef': dice_coef,
+#                                  'relu6':relu6,
+#                                  'DepthwiseConv2D':DepthwiseConv2D,
+#                                  'BilinearUpsampling':BilinearUpsampling})
+
+# ### get separable unet model
+# sep_unet = Separable_Unet2D(n_filters=64, input_dim_x=input_dim_x, input_dim_y=input_dim_y, num_channels=3)
+# model, model_name = sep_unet.get_sep_unet_v2()
+# model = load_model('./azh_wound_care_center_diabetic_foot_training_history/' + weight_file_name
+#                , custom_objects={'dice_coef': dice_coef,
+#                                  'relu6':relu6,
+#                                  'DepthwiseConv2D':DepthwiseConv2D,
+#                                  'BilinearUpsampling':BilinearUpsampling})
+
+# ### get VGG16 model
+# model, model_name = FCN_Vgg16_16s(input_shape=(input_dim_x, input_dim_y, 3))
+# with CustomObjectScope({'BilinearUpSampling2D':BilinearUpSampling2D}):
+#     model = load_model('./azh_wound_care_center_diabetic_foot_training_history/' + weight_file_name
+#                    , custom_objects={'dice_coef': dice_coef})
+
+# ### get mobilenetv2 model
+model = Deeplabv3(input_shape=(input_dim_x, input_dim_y, 3), classes=1)
+model = load_model('./training_history/' + weight_file_name
+               , custom_objects={'recall':recall,
+                                 'precision':precision,
+                                 'dice_coef': dice_coef,
+                                 'relu6':relu6,
+                                 'DepthwiseConv2D':DepthwiseConv2D,
+                                 'BilinearUpsampling':BilinearUpsampling})
+
+for image_batch, label_batch in data_gen.generate_data(batch_size=len(x_test), test=True):
+    prediction = model.predict(image_batch, verbose=1)
+    save_results(prediction, 'rgb', path + 'test/predictions/' + pred_save_path, test_label_filenames_list)
+    break

temp_files/requirements.txt

@@ -0,0 +1,109 @@
+aiofiles
+annotated-types
+anyio
+asttokens
+attrs
+blinker
+certifi
+charset-normalizer
+click
+colorama
+comm
+ConfigArgParse
+contourpy
+cycler
+dash
+decorator
+executing
+fastapi
+fastjsonschema
+ffmpy
+filelock
+Flask
+fonttools
+fsspec
+gdown
+gradio
+gradio_client
+gradio_imageslider
+groovy
+h11
+httpcore
+httpx
+huggingface-hub
+idna
+importlib_metadata
+itsdangerous
+jedi
+Jinja2
+jsonschema
+jsonschema-specifications
+jupyter_core
+jupyterlab_widgets
+kiwisolver
+markdown-it-py
+MarkupSafe
+matplotlib
+matplotlib-inline
+mdurl
+mpmath
+narwhals
+nbformat
+nest-asyncio
+networkx
+numpy<2
+open3d
+opencv-python
+orjson
+packaging
+pandas
+parso
+pillow
+platformdirs
+plotly
+prompt_toolkit
+pure_eval
+pydantic_core
+pydub
+Pygments
+pyparsing
+python-dateutil
+python-multipart
+pytz
+PyYAML
+referencing
+requests
+retrying
+rich
+rpds-py
+ruff
+safehttpx
+scikit-image
+semantic-version
+setuptools
+shellingham
+six
+sniffio
+stack-data
+starlette
+sympy
+tensorflow<2.11
+tensorflow_hub
+tomlkit
+torch
+torchvision
+tqdm
+traitlets
+typer
+typing-inspection
+typing_extensions
+tzdata
+urllib3
+uvicorn
+wcwidth
+websockets
+Werkzeug
+wheel
+widgetsnbextension
+zipp
+pydantic==2.10.6

temp_files/run_gradio_app.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+Simple launcher for the Wound Segmentation Gradio App
+"""
+
+import sys
+import os
+
+def check_dependencies():
+    """Check if required dependencies are installed"""
+    required_packages = ['gradio', 'tensorflow', 'cv2', 'numpy']
+    missing_packages = []
+    
+    for package in required_packages:
+        try:
+            if package == 'cv2':
+                import cv2
+            else:
+                __import__(package)
+        except ImportError:
+            missing_packages.append(package)
+    
+    if missing_packages:
+        print("❌ Missing required packages:")
+        for package in missing_packages:
+            print(f"   - {package}")
+        print("\n📦 Install missing packages with:")
+        print("   pip install -r requirements.txt")
+        return False
+    
+    print("✅ All required packages are installed!")
+    return True
+
+def check_model_files():
+    """Check if model files exist"""
+    model_files = [
+        'training_history/2025-08-07_12-30-43.hdf5',
+        'training_history/2019-12-19 01%3A53%3A15.480800.hdf5'
+    ]
+    
+    existing_models = []
+    for model_file in model_files:
+        if os.path.exists(model_file):
+            existing_models.append(model_file)
+    
+    if not existing_models:
+        print("❌ No model files found!")
+        print("   Please ensure you have trained models in the training_history/ directory")
+        return False
+    
+    print(f"✅ Found {len(existing_models)} model file(s):")
+    for model in existing_models:
+        print(f"   - {model}")
+    return True
+
+def main():
+    """Main function to launch the Gradio app"""
+    print("🚀 Starting Wound Segmentation Gradio App...")
+    print("=" * 50)
+    
+    # Check dependencies
+    if not check_dependencies():
+        sys.exit(1)
+    
+    # Check model files
+    if not check_model_files():
+        sys.exit(1)
+    
+    print("\n🎯 Launching Gradio interface...")
+    print("   The app will be available at: http://localhost:7860")
+    print("   Press Ctrl+C to stop the server")
+    print("=" * 50)
+    
+    try:
+        # Import and run the Gradio app
+        from gradio_app import create_gradio_interface
+        
+        interface = create_gradio_interface()
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=True,
+            show_error=True
+        )
+    except KeyboardInterrupt:
+        print("\n👋 Gradio app stopped by user")
+    except Exception as e:
+        print(f"\n❌ Error launching Gradio app: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main() 

temp_files/segmentation_app.py

@@ -0,0 +1,222 @@
+import gradio as gr
+import cv2
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+from keras.models import load_model
+from keras.utils.generic_utils import CustomObjectScope
+
+# Import custom modules
+from models.deeplab import Deeplabv3, relu6, DepthwiseConv2D, BilinearUpsampling
+from utils.learning.metrics import dice_coef, precision, recall
+from utils.io.data import normalize
+
+class WoundSegmentationApp:
+    def __init__(self):
+        self.input_dim_x = 224
+        self.input_dim_y = 224
+        self.model = None
+        self.load_model()
+    
+    def load_model(self):
+        """Load the trained wound segmentation model"""
+        try:
+            # Load the model with custom objects
+            weight_file_name = '2025-08-07_12-30-43.hdf5'  # Use the most recent model
+            model_path = f'./training_history/{weight_file_name}'
+            
+            self.model = load_model(model_path, 
+                                  custom_objects={
+                                      'recall': recall,
+                                      'precision': precision,
+                                      'dice_coef': dice_coef,
+                                      'relu6': relu6,
+                                      'DepthwiseConv2D': DepthwiseConv2D,
+                                      'BilinearUpsampling': BilinearUpsampling
+                                  })
+            print(f"Model loaded successfully from {model_path}")
+        except Exception as e:
+            print(f"Error loading model: {e}")
+            # Fallback to the older model if the newer one fails
+            try:
+                weight_file_name = '2019-12-19 01%3A53%3A15.480800.hdf5'
+                model_path = f'./training_history/{weight_file_name}'
+                
+                self.model = load_model(model_path, 
+                                      custom_objects={
+                                          'recall': recall,
+                                          'precision': precision,
+                                          'dice_coef': dice_coef,
+                                          'relu6': relu6,
+                                          'DepthwiseConv2D': DepthwiseConv2D,
+                                          'BilinearUpsampling': BilinearUpsampling
+                                      })
+                print(f"Model loaded successfully from {model_path}")
+            except Exception as e2:
+                print(f"Error loading fallback model: {e2}")
+                self.model = None
+    
+    def preprocess_image(self, image):
+        """Preprocess the uploaded image for model input"""
+        if image is None:
+            return None
+        
+        # Convert to RGB if needed
+        if len(image.shape) == 3 and image.shape[2] == 3:
+            # Convert BGR to RGB if needed
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        
+        # Resize to model input size
+        image = cv2.resize(image, (self.input_dim_x, self.input_dim_y))
+        
+        # Normalize the image
+        image = image.astype(np.float32) / 255.0
+        
+        # Add batch dimension
+        image = np.expand_dims(image, axis=0)
+        
+        return image
+    
+    def postprocess_prediction(self, prediction):
+        """Postprocess the model prediction"""
+        # Remove batch dimension
+        prediction = prediction[0]
+        
+        # Apply threshold to get binary mask
+        threshold = 0.5
+        binary_mask = (prediction > threshold).astype(np.uint8) * 255
+        
+        # Convert to 3-channel image for visualization
+        mask_rgb = cv2.cvtColor(binary_mask, cv2.COLOR_GRAY2RGB)
+        
+        return mask_rgb
+    
+    def segment_wound(self, input_image):
+        """Main function to segment wound from uploaded image"""
+        if self.model is None:
+            return None, "Error: Model not loaded. Please check the model files."
+        
+        if input_image is None:
+            return None, "Please upload an image."
+        
+        try:
+            # Preprocess the image
+            processed_image = self.preprocess_image(input_image)
+            
+            if processed_image is None:
+                return None, "Error processing image."
+            
+            # Make prediction
+            prediction = self.model.predict(processed_image, verbose=0)
+            
+            # Postprocess the prediction
+            segmented_mask = self.postprocess_prediction(prediction)
+            
+            # Create overlay image (original image with segmentation overlay)
+            original_resized = cv2.resize(input_image, (self.input_dim_x, self.input_dim_y))
+            if len(original_resized.shape) == 3:
+                original_resized = cv2.cvtColor(original_resized, cv2.COLOR_RGB2BGR)
+            
+            # Create overlay with red segmentation
+            overlay = original_resized.copy()
+            mask_red = np.zeros_like(original_resized)
+            mask_red[:, :, 2] = segmented_mask[:, :, 0]  # Red channel
+            
+            # Blend overlay with original image
+            alpha = 0.6
+            overlay = cv2.addWeighted(overlay, 1-alpha, mask_red, alpha, 0)
+            
+            return segmented_mask, overlay
+            
+        except Exception as e:
+            return None, f"Error during segmentation: {str(e)}"
+
+def create_gradio_interface():
+    """Create and return the Gradio interface"""
+    
+    # Initialize the app
+    app = WoundSegmentationApp()
+    
+    # Define the interface
+    with gr.Blocks(title="Wound Segmentation Tool", theme=gr.themes.Soft()) as interface:
+        gr.Markdown(
+            """
+            # 🩹 Wound Segmentation Tool
+            
+            Upload an image of a wound to get an automated segmentation mask.
+            The model will identify and highlight the wound area in the image.
+            
+            **Instructions:**
+            1. Upload an image of a wound
+            2. Click "Segment Wound" to process the image
+            3. View the segmentation mask and overlay results
+            """
+        )
+        
+        with gr.Row():
+            with gr.Column():
+                input_image = gr.Image(
+                    label="Upload Wound Image",
+                    type="numpy",
+                    height=400
+                )
+                
+                segment_btn = gr.Button(
+                    "🔍 Segment Wound",
+                    variant="primary",
+                    size="lg"
+                )
+            
+            with gr.Column():
+                mask_output = gr.Image(
+                    label="Segmentation Mask",
+                    height=400
+                )
+                
+                overlay_output = gr.Image(
+                    label="Overlay Result",
+                    height=400
+                )
+        
+        # Status message
+        status_msg = gr.Textbox(
+            label="Status",
+            interactive=False,
+            placeholder="Ready to process images..."
+        )
+        
+        # Example images
+        gr.Markdown("### 📸 Example Images")
+        gr.Markdown("You can test the tool with wound images from the dataset.")
+        
+        # Connect the button to the segmentation function
+        def process_image(image):
+            mask, overlay = app.segment_wound(image)
+            if mask is None:
+                return None, None, overlay  # overlay contains error message
+            return mask, overlay, "Segmentation completed successfully!"
+        
+        segment_btn.click(
+            fn=process_image,
+            inputs=[input_image],
+            outputs=[mask_output, overlay_output, status_msg]
+        )
+        
+        # Auto-process when image is uploaded
+        input_image.change(
+            fn=process_image,
+            inputs=[input_image],
+            outputs=[mask_output, overlay_output, status_msg]
+        )
+    
+    return interface
+
+if __name__ == "__main__":
+    # Create and launch the interface
+    interface = create_gradio_interface()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    ) 

temp_files/test1.txt

@@ -0,0 +1,843 @@
+import glob
+import gradio as gr
+import matplotlib
+import numpy as np
+from PIL import Image
+import torch
+import tempfile
+from gradio_imageslider import ImageSlider
+import plotly.graph_objects as go
+import plotly.express as px
+import open3d as o3d
+from depth_anything_v2.dpt import DepthAnythingV2
+import os
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image as keras_image
+import base64
+from io import BytesIO
+import gdown
+import spaces
+import cv2
+from skimage import filters, morphology, measure
+from skimage.segmentation import clear_border
+
+# --- LINEAR INITIALIZATION - NO MODULAR FUNCTIONS ---
+print("Starting linear initialization for ZeroGPU compatibility...")
+
+# Define path and file ID
+checkpoint_dir = "checkpoints"
+os.makedirs(checkpoint_dir, exist_ok=True)
+
+model_file = os.path.join(checkpoint_dir, "depth_anything_v2_vitl.pth")
+gdrive_url = "https://drive.google.com/uc?id=141Mhq2jonkUBcVBnNqNSeyIZYtH5l4K5"
+
+# Download if not already present
+if not os.path.exists(model_file):
+    print("Downloading model from Google Drive...")
+    gdown.download(gdrive_url, model_file, quiet=False)
+
+# --- TensorFlow: Check GPU Availability ---
+gpus = tf.config.list_physical_devices('GPU')
+if gpus:
+    print("TensorFlow is using GPU")
+else:
+    print("TensorFlow is using CPU")
+
+# --- Load Wound Classification Model and Class Labels ---
+wound_model = load_model("/home/user/app/keras_model.h5")
+with open("/home/user/app/labels.txt", "r") as f:
+    class_labels = [line.strip().split(maxsplit=1)[1] for line in f]
+
+# --- PyTorch: Set Device and Load Depth Model ---
+print("Initializing PyTorch device...")
+map_device = torch.device("cuda" if torch.cuda.is_available() and torch.cuda.device_count() > 0 else "cpu")
+print(f"Using PyTorch device: {map_device}")
+
+model_configs = {
+    'vits': {'encoder': 'vits', 'features': 64, 'out_channels': [48, 96, 192, 384]},
+    'vitb': {'encoder': 'vitb', 'features': 128, 'out_channels': [96, 192, 384, 768]},
+    'vitl': {'encoder': 'vitl', 'features': 256, 'out_channels': [256, 512, 1024, 1024]},
+    'vitg': {'encoder': 'vitg', 'features': 384, 'out_channels': [1536, 1536, 1536, 1536]}
+}
+encoder = 'vitl'
+depth_model = DepthAnythingV2(**model_configs[encoder])
+state_dict = torch.load(
+    f'/home/user/app/checkpoints/depth_anything_v2_{encoder}.pth',
+    map_location=map_device
+)
+depth_model.load_state_dict(state_dict)
+depth_model = depth_model.to(map_device).eval()
+
+# --- Custom CSS for unified dark theme ---
+css = """
+.gradio-container {
+    font-family: 'Segoe UI', sans-serif;
+    background-color: #121212;
+    color: #ffffff;
+    padding: 20px;
+}
+.gr-button {
+    background-color: #2c3e50;
+    color: white;
+    border-radius: 10px;
+}
+.gr-button:hover {
+    background-color: #34495e;
+}
+.gr-html, .gr-html div {
+    white-space: normal !important;
+    overflow: visible !important;
+    text-overflow: unset !important;
+    word-break: break-word !important;
+}
+#img-display-container {
+    max-height: 100vh;
+}
+#img-display-input {
+    max-height: 80vh;
+}
+#img-display-output {
+    max-height: 80vh;
+}
+#download {
+    height: 62px;
+}
+h1 {
+    text-align: center;
+    font-size: 3rem;
+    font-weight: bold;
+    margin: 2rem 0;
+    color: #ffffff;
+}
+h2 {
+    color: #ffffff;
+    text-align: center;
+    margin: 1rem 0;
+}
+.gr-tabs {
+    background-color: #1e1e1e;
+    border-radius: 10px;
+    padding: 10px;
+}
+.gr-tab-nav {
+    background-color: #2c3e50;
+    border-radius: 8px;
+}
+.gr-tab-nav button {
+    color: #ffffff !important;
+}
+.gr-tab-nav button.selected {
+    background-color: #34495e !important;
+}
+"""
+
+# --- LINEAR FUNCTION DEFINITIONS (NO MODULAR CALLS) ---
+
+# Wound Classification Functions
+def preprocess_input(img):
+    img = img.resize((224, 224))
+    arr = keras_image.img_to_array(img)
+    arr = arr / 255.0
+    return np.expand_dims(arr, axis=0)
+
+def get_reasoning_from_gemini(img, prediction):
+    try:
+        explanations = {
+            "Abrasion": "This appears to be an abrasion wound, characterized by superficial damage to the skin surface. The wound shows typical signs of friction or scraping injury.",
+            "Burn": "This wound exhibits characteristics consistent with a burn injury, showing tissue damage from heat, chemicals, or radiation exposure.",
+            "Laceration": "This wound displays the irregular edges and tissue tearing typical of a laceration, likely caused by blunt force trauma.",
+            "Puncture": "This wound shows a small, deep entry point characteristic of puncture wounds, often caused by sharp, pointed objects.",
+            "Ulcer": "This wound exhibits the characteristics of an ulcer, showing tissue breakdown and potential underlying vascular or pressure issues."
+        }
+        return explanations.get(prediction, f"This wound has been classified as {prediction}. Please consult with a healthcare professional for detailed assessment.")
+    except Exception as e:
+        return f"(Reasoning unavailable: {str(e)})"
+    
+@spaces.GPU
+def classify_wound_image(img):
+    if img is None:
+        return "<div style='color:#ff5252; font-size:18px;'>No image provided</div>", ""
+
+    img_array = preprocess_input(img)
+    predictions = wound_model.predict(img_array, verbose=0)[0]
+    pred_idx = int(np.argmax(predictions))
+    pred_class = class_labels[pred_idx]
+
+    reasoning_text = get_reasoning_from_gemini(img, pred_class)
+
+    predicted_card = f"""
+    <div style='padding: 20px; background-color: #1e1e1e; border-radius: 12px;
+                box-shadow: 0 0 10px rgba(0,0,0,0.5);'>
+        <div style='font-size: 22px; font-weight: bold; color: orange; margin-bottom: 10px;'>
+            Predicted Wound Type
+        </div>
+        <div style='font-size: 26px; color: white;'>
+            {pred_class}
+        </div>
+    </div>
+    """
+
+    reasoning_card = f"""
+    <div style='padding: 20px; background-color: #1e1e1e; border-radius: 12px;
+                box-shadow: 0 0 10px rgba(0,0,0,0.5);'>
+        <div style='font-size: 22px; font-weight: bold; color: orange; margin-bottom: 10px;'>
+            Reasoning
+        </div>
+        <div style='font-size: 16px; color: white; min-height: 80px;'>
+            {reasoning_text}
+        </div>
+    </div>
+    """
+
+    return predicted_card, reasoning_card
+
+# Depth Estimation Functions
+@spaces.GPU
+def predict_depth(image):
+    return depth_model.infer_image(image)
+
+def calculate_max_points(image):
+    if image is None:
+        return 10000
+    h, w = image.shape[:2]
+    max_points = h * w * 3
+    return max(1000, min(max_points, 300000))
+
+def update_slider_on_image_upload(image):
+    max_points = calculate_max_points(image)
+    default_value = min(10000, max_points // 10)
+    return gr.Slider(minimum=1000, maximum=max_points, value=default_value, step=1000,
+                     label=f"Number of 3D points (max: {max_points:,})")
+
+@spaces.GPU
+def create_point_cloud(image, depth_map, focal_length_x=470.4, focal_length_y=470.4, max_points=30000):
+    h, w = depth_map.shape
+    step = max(1, int(np.sqrt(h * w / max_points) * 0.5))
+    
+    y_coords, x_coords = np.mgrid[0:h:step, 0:w:step]
+    x_cam = (x_coords - w / 2) / focal_length_x
+    y_cam = (y_coords - h / 2) / focal_length_y
+    depth_values = depth_map[::step, ::step]
+    
+    x_3d = x_cam * depth_values
+    y_3d = y_cam * depth_values
+    z_3d = depth_values
+    
+    points = np.stack([x_3d.flatten(), y_3d.flatten(), z_3d.flatten()], axis=1)
+    image_colors = image[::step, ::step, :]
+    colors = image_colors.reshape(-1, 3) / 255.0
+    
+    pcd = o3d.geometry.PointCloud()
+    pcd.points = o3d.utility.Vector3dVector(points)
+    pcd.colors = o3d.utility.Vector3dVector(colors)
+    
+    return pcd
+
+@spaces.GPU
+def reconstruct_surface_mesh_from_point_cloud(pcd):
+    pcd.estimate_normals(search_param=o3d.geometry.KDTreeSearchParamHybrid(radius=0.005, max_nn=50))
+    pcd.orient_normals_consistent_tangent_plane(k=50)
+    mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(pcd, depth=12)
+    return mesh
+
+@spaces.GPU
+def create_enhanced_3d_visualization(image, depth_map, max_points=10000):
+    h, w = depth_map.shape
+    step = max(1, int(np.sqrt(h * w / max_points)))
+    
+    y_coords, x_coords = np.mgrid[0:h:step, 0:w:step]
+    focal_length = 470.4
+    x_cam = (x_coords - w / 2) / focal_length
+    y_cam = (y_coords - h / 2) / focal_length
+    depth_values = depth_map[::step, ::step]
+    
+    x_3d = x_cam * depth_values
+    y_3d = y_cam * depth_values
+    z_3d = depth_values
+    
+    x_flat = x_3d.flatten()
+    y_flat = y_3d.flatten()
+    z_flat = z_3d.flatten()
+    
+    image_colors = image[::step, ::step, :]
+    colors_flat = image_colors.reshape(-1, 3)
+    
+    fig = go.Figure(data=[go.Scatter3d(
+        x=x_flat,
+        y=y_flat,
+        z=z_flat,
+        mode='markers',
+        marker=dict(
+            size=1.5,
+            color=colors_flat,
+            opacity=0.9
+        ),
+        hovertemplate='<b>3D Position:</b> (%{x:.3f}, %{y:.3f}, %{z:.3f})<br>' +
+                     '<b>Depth:</b> %{z:.2f}<br>' +
+                     '<extra></extra>'
+    )])
+
+    fig.update_layout(
+        title="3D Point Cloud Visualization (Camera Projection)",
+        scene=dict(
+            xaxis_title="X (meters)",
+            yaxis_title="Y (meters)",
+            zaxis_title="Z (meters)",
+            camera=dict(
+                eye=dict(x=2.0, y=2.0, z=2.0),
+                center=dict(x=0, y=0, z=0),
+                up=dict(x=0, y=0, z=1)
+            ),
+            aspectmode='data'
+        ),
+        width=700,
+        height=600
+    )
+
+    return fig
+
+def on_depth_submit(image, num_points, focal_x, focal_y):
+    original_image = image.copy()
+    h, w = image.shape[:2]
+    
+    depth = predict_depth(image[:, :, ::-1])
+    
+    raw_depth = Image.fromarray(depth.astype('uint16'))
+    tmp_raw_depth = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
+    raw_depth.save(tmp_raw_depth.name)
+    
+    norm_depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
+    norm_depth = norm_depth.astype(np.uint8)
+    colored_depth = (matplotlib.colormaps.get_cmap('Spectral_r')(norm_depth)[:, :, :3] * 255).astype(np.uint8)
+    
+    gray_depth = Image.fromarray(norm_depth)
+    tmp_gray_depth = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
+    gray_depth.save(tmp_gray_depth.name)
+    
+    pcd = create_point_cloud(original_image, norm_depth, focal_x, focal_y, max_points=num_points)
+    mesh = reconstruct_surface_mesh_from_point_cloud(pcd)
+    
+    tmp_pointcloud = tempfile.NamedTemporaryFile(suffix='.ply', delete=False)
+    o3d.io.write_triangle_mesh(tmp_pointcloud.name, mesh)
+    
+    depth_3d = create_enhanced_3d_visualization(original_image, norm_depth, max_points=num_points)
+    
+    return [(original_image, colored_depth), tmp_gray_depth.name, tmp_raw_depth.name, tmp_pointcloud.name, depth_3d]
+
+# Wound Severity Analysis Functions
+@spaces.GPU
+def compute_depth_area_statistics(depth_map, mask, pixel_spacing_mm=0.5):
+    pixel_area_cm2 = (pixel_spacing_mm / 10.0) ** 2
+    wound_mask = (mask > 127)
+    wound_depths = depth_map[wound_mask]
+    total_area = np.sum(wound_mask) * pixel_area_cm2
+    
+    shallow = wound_depths < 3
+    moderate = (wound_depths >= 3) & (wound_depths < 6)
+    deep = wound_depths >= 6
+    
+    shallow_area = np.sum(shallow) * pixel_area_cm2
+    moderate_area = np.sum(moderate) * pixel_area_cm2
+    deep_area = np.sum(deep) * pixel_area_cm2
+    deep_ratio = deep_area / total_area if total_area > 0 else 0
+    
+    return {
+        'total_area_cm2': total_area,
+        'shallow_area_cm2': shallow_area,
+        'moderate_area_cm2': moderate_area,
+        'deep_area_cm2': deep_area,
+        'deep_ratio': deep_ratio,
+        'max_depth': np.max(wound_depths) if len(wound_depths) > 0 else 0
+    }
+
+def classify_wound_severity_by_area(depth_stats):
+    total = depth_stats['total_area_cm2']
+    deep = depth_stats['deep_area_cm2']
+    moderate = depth_stats['moderate_area_cm2']
+    
+    if total == 0:
+        return "Unknown"
+    
+    if deep > 2 or (deep / total) > 0.3:
+        return "Severe"
+    elif moderate > 1.5 or (moderate / total) > 0.4:
+        return "Moderate"
+    else:
+        return "Mild"
+
+def get_severity_description(severity):
+    descriptions = {
+        "Mild": "Superficial wound with minimal tissue damage. Usually heals well with basic care.",
+        "Moderate": "Moderate tissue involvement requiring careful monitoring and proper treatment.",
+        "Severe": "Deep tissue damage requiring immediate medical attention and specialized care.",
+        "Unknown": "Unable to determine severity due to insufficient data."
+    }
+    return descriptions.get(severity, "Severity assessment unavailable.")
+
+def analyze_wound_severity(image, depth_map, wound_mask, pixel_spacing_mm=0.5):
+    if image is None or depth_map is None or wound_mask is None:
+        return "❌ Please upload image, depth map, and wound mask."
+
+    if len(wound_mask.shape) == 3:
+        wound_mask = np.mean(wound_mask, axis=2)
+
+    if depth_map.shape[:2] != wound_mask.shape[:2]:
+        from PIL import Image
+        mask_pil = Image.fromarray(wound_mask.astype(np.uint8))
+        mask_pil = mask_pil.resize((depth_map.shape[1], depth_map.shape[0]))
+        wound_mask = np.array(mask_pil)
+
+    stats = compute_depth_area_statistics(depth_map, wound_mask, pixel_spacing_mm)
+    severity = classify_wound_severity_by_area(stats)
+
+    severity_color = {
+        "Mild": "#4CAF50",
+        "Moderate": "#FF9800",
+        "Severe": "#F44336"
+    }.get(severity, "#9E9E9E")
+
+    report = f"""
+    <div style='padding: 20px; background-color: #1e1e1e; border-radius: 12px; box-shadow: 0 0 10px rgba(0,0,0,0.5);'>
+        <div style='font-size: 24px; font-weight: bold; color: {severity_color}; margin-bottom: 15px;'>
+            🩹 Wound Severity Analysis
+        </div>
+
+        <div style='display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-bottom: 20px;'>
+            <div style='background-color: #2c2c2c; padding: 15px; border-radius: 8px;'>
+                <div style='font-size: 18px; font-weight: bold; color: #ffffff; margin-bottom: 10px;'>
+                    📏 Area Measurements
+                </div>
+                <div style='color: #cccccc; line-height: 1.6;'>
+                    <div>🟢 <b>Total Area:</b> {stats['total_area_cm2']:.2f} cm²</div>
+                    <div>🟩 <b>Shallow (0-3mm):</b> {stats['shallow_area_cm2']:.2f} cm²</div>
+                    <div>🟨 <b>Moderate (3-6mm):</b> {stats['moderate_area_cm2']:.2f} cm²</div>
+                    <div>🟥 <b>Deep (>6mm):</b> {stats['deep_area_cm2']:.2f} cm²</div>
+                </div>
+            </div>
+
+            <div style='background-color: #2c2c2c; padding: 15px; border-radius: 8px;'>
+                <div style='font-size: 18px; font-weight: bold; color: #ffffff; margin-bottom: 10px;'>
+                    📊 Depth Analysis
+                </div>
+                <div style='color: #cccccc; line-height: 1.6;'>
+                    <div>🔥 <b>Deep Coverage:</b> {stats['deep_ratio']*100:.1f}%</div>
+                    <div>📏 <b>Max Depth:</b> {stats['max_depth']:.1f} mm</div>
+                    <div>⚡ <b>Pixel Spacing:</b> {pixel_spacing_mm} mm</div>
+                </div>
+            </div>
+        </div>
+
+        <div style='text-align: center; padding: 15px; background-color: #2c2c2c; border-radius: 8px; border-left: 4px solid {severity_color};'>
+            <div style='font-size: 20px; font-weight: bold; color: {severity_color};'>
+                🎯 Predicted Severity: {severity}
+            </div>
+            <div style='font-size: 14px; color: #cccccc; margin-top: 5px;'>
+                {get_severity_description(severity)}
+            </div>
+        </div>
+    </div>
+    """
+
+    return report
+
+# Automatic Wound Mask Generation Functions
+def create_automatic_wound_mask(image, method='adaptive'):
+    if image is None:
+        return None
+
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    else:
+        gray = image.copy()
+
+    if method == 'adaptive':
+        mask = adaptive_threshold_segmentation(gray)
+    elif method == 'otsu':
+        mask = otsu_threshold_segmentation(gray)
+    elif method == 'color':
+        mask = color_based_segmentation(image)
+    elif method == 'combined':
+        mask = combined_segmentation(image, gray)
+    else:
+        mask = adaptive_threshold_segmentation(gray)
+
+    return mask
+
+def adaptive_threshold_segmentation(gray):
+    blurred = cv2.GaussianBlur(gray, (15, 15), 0)
+    thresh = cv2.adaptiveThreshold(
+        blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 25, 5
+    )
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (15, 15))
+    mask = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+    
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    mask_clean = np.zeros_like(mask)
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area > 1000:
+            cv2.fillPoly(mask_clean, [contour], 255)
+    
+    return mask_clean
+
+def otsu_threshold_segmentation(gray):
+    blurred = cv2.GaussianBlur(gray, (15, 15), 0)
+    _, thresh = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+    
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (10, 10))
+    mask = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+    
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    mask_clean = np.zeros_like(mask)
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area > 800:
+            cv2.fillPoly(mask_clean, [contour], 255)
+    
+    return mask_clean
+
+def color_based_segmentation(image):
+    hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+    
+    lower_red1 = np.array([0, 30, 30])
+    upper_red1 = np.array([15, 255, 255])
+    lower_red2 = np.array([160, 30, 30])
+    upper_red2 = np.array([180, 255, 255])
+    
+    mask1 = cv2.inRange(hsv, lower_red1, upper_red1)
+    mask2 = cv2.inRange(hsv, lower_red2, upper_red2)
+    red_mask = mask1 + mask2
+    
+    lower_yellow = np.array([15, 30, 30])
+    upper_yellow = np.array([35, 255, 255])
+    yellow_mask = cv2.inRange(hsv, lower_yellow, upper_yellow)
+    
+    lower_brown = np.array([10, 50, 20])
+    upper_brown = np.array([20, 255, 200])
+    brown_mask = cv2.inRange(hsv, lower_brown, upper_brown)
+    
+    color_mask = red_mask + yellow_mask + brown_mask
+    
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (15, 15))
+    color_mask = cv2.morphologyEx(color_mask, cv2.MORPH_CLOSE, kernel)
+    color_mask = cv2.morphologyEx(color_mask, cv2.MORPH_OPEN, kernel)
+    
+    contours, _ = cv2.findContours(color_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    mask_clean = np.zeros_like(color_mask)
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area > 600:
+            cv2.fillPoly(mask_clean, [contour], 255)
+    
+    return mask_clean
+
+def combined_segmentation(image, gray):
+    adaptive_mask = adaptive_threshold_segmentation(gray)
+    otsu_mask = otsu_threshold_segmentation(gray)
+    color_mask = color_based_segmentation(image)
+    
+    combined_mask = cv2.bitwise_or(adaptive_mask, otsu_mask)
+    combined_mask = cv2.bitwise_or(combined_mask, color_mask)
+    
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (20, 20))
+    combined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_CLOSE, kernel)
+    
+    contours, _ = cv2.findContours(combined_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    mask_clean = np.zeros_like(combined_mask)
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area > 500:
+            cv2.fillPoly(mask_clean, [contour], 255)
+    
+    if np.sum(mask_clean) == 0:
+        mask_clean = create_realistic_wound_mask(combined_mask.shape, method='elliptical')
+    
+    return mask_clean
+
+def create_realistic_wound_mask(image_shape, method='elliptical'):
+    h, w = image_shape[:2]
+    mask = np.zeros((h, w), dtype=np.uint8)
+    
+    if method == 'elliptical':
+        center = (w // 2, h // 2)
+        radius_x = min(w, h) // 3
+        radius_y = min(w, h) // 4
+        
+        y, x = np.ogrid[:h, :w]
+        ellipse = ((x - center[0])**2 / (radius_x**2) +
+                   (y - center[1])**2 / (radius_y**2)) <= 1
+        
+        noise = np.random.random((h, w)) > 0.8
+        mask = (ellipse | noise).astype(np.uint8) * 255
+    
+    elif method == 'irregular':
+        center = (w // 2, h // 2)
+        radius = min(w, h) // 4
+        
+        y, x = np.ogrid[:h, :w]
+        base_circle = np.sqrt((x - center[0])**2 + (y - center[1])**2) <= radius
+        
+        extensions = np.zeros_like(base_circle)
+        for i in range(3):
+            angle = i * 2 * np.pi / 3
+            ext_x = int(center[0] + radius * 0.8 * np.cos(angle))
+            ext_y = int(center[1] + radius * 0.8 * np.sin(angle))
+            ext_radius = radius // 3
+            
+            ext_circle = np.sqrt((x - ext_x)**2 + (y - ext_y)**2) <= ext_radius
+            extensions = extensions | ext_circle
+        
+        mask = (base_circle | extensions).astype(np.uint8) * 255
+    
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    
+    return mask
+
+def post_process_wound_mask(mask, min_area=100):
+    if mask is None:
+        return None
+
+    if mask.dtype != np.uint8:
+        mask = mask.astype(np.uint8)
+
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (10, 10))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+    
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    mask_clean = np.zeros_like(mask)
+    
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area >= min_area:
+            cv2.fillPoly(mask_clean, [contour], 255)
+    
+    mask_clean = cv2.morphologyEx(mask_clean, cv2.MORPH_CLOSE, kernel)
+    
+    return mask_clean
+
+def create_sample_wound_mask(image_shape, center=None, radius=50):
+    if center is None:
+        center = (image_shape[1] // 2, image_shape[0] // 2)
+    
+    mask = np.zeros(image_shape[:2], dtype=np.uint8)
+    y, x = np.ogrid[:image_shape[0], :image_shape[1]]
+    
+    dist_from_center = np.sqrt((x - center[0])**2 + (y - center[1])**2)
+    mask[dist_from_center <= radius] = 255
+    
+    return mask
+
+# --- MAIN GRADIO INTERFACE (LINEAR EXECUTION) ---
+print("Creating Gradio interface...")
+
+with gr.Blocks(css=css, title="Wound Analysis & Depth Estimation") as demo:
+    gr.HTML("<h1>Wound Analysis & Depth Estimation System</h1>")
+    gr.Markdown("### Comprehensive wound analysis with classification and 3D depth mapping capabilities")
+
+    shared_image = gr.State()
+
+    with gr.Tabs():
+        # Tab 1: Wound Classification
+        with gr.Tab("1. Wound Classification"):
+            gr.Markdown("### Step 1: Upload and classify your wound image")
+            gr.Markdown("This module analyzes wound images and provides classification with AI-powered reasoning.")
+
+            with gr.Row():
+                with gr.Column(scale=1):
+                    wound_image_input = gr.Image(label="Upload Wound Image", type="pil", height=350)
+
+                with gr.Column(scale=1):
+                    wound_prediction_box = gr.HTML()
+                    wound_reasoning_box = gr.HTML()
+
+            with gr.Row():
+                pass_to_depth_btn = gr.Button("📊 Pass Image to Depth Analysis", variant="secondary", size="lg")
+                pass_status = gr.HTML("")
+
+            wound_image_input.change(fn=classify_wound_image, inputs=wound_image_input,
+                                   outputs=[wound_prediction_box, wound_reasoning_box])
+
+            wound_image_input.change(
+                fn=lambda img: img,
+                inputs=[wound_image_input],
+                outputs=[shared_image]
+            )
+
+        # Tab 2: Depth Estimation
+        with gr.Tab("2. Depth Estimation & 3D Visualization"):
+            gr.Markdown("### Step 2: Generate depth maps and 3D visualizations")
+            gr.Markdown("This module creates depth maps and 3D point clouds from your images.")
+
+            with gr.Row():
+                depth_input_image = gr.Image(label="Input Image", type='numpy', elem_id='img-display-input')
+                depth_image_slider = ImageSlider(label="Depth Map with Slider View", elem_id='img-display-output')
+
+            with gr.Row():
+                depth_submit = gr.Button(value="Compute Depth", variant="primary")
+                load_shared_btn = gr.Button("🔄 Load Image from Classification", variant="secondary")
+                points_slider = gr.Slider(minimum=1000, maximum=10000, value=10000, step=1000,
+                                         label="Number of 3D points (upload image to update max)")
+
+            with gr.Row():
+                focal_length_x = gr.Slider(minimum=100, maximum=1000, value=470.4, step=10,
+                                          label="Focal Length X (pixels)")
+                focal_length_y = gr.Slider(minimum=100, maximum=1000, value=470.4, step=10,
+                                          label="Focal Length Y (pixels)")
+
+            with gr.Row():
+                gray_depth_file = gr.File(label="Grayscale depth map", elem_id="download")
+                raw_file = gr.File(label="16-bit raw output (can be considered as disparity)", elem_id="download")
+                point_cloud_file = gr.File(label="Point Cloud (.ply)", elem_id="download")
+
+            gr.Markdown("### 3D Point Cloud Visualization")
+            gr.Markdown("Enhanced 3D visualization using proper camera projection. Hover over points to see 3D coordinates.")
+            depth_3d_plot = gr.Plot(label="3D Point Cloud")
+
+            depth_map_state = gr.State()
+
+        # Tab 3: Wound Severity Analysis
+        with gr.Tab("3. 🩹 Wound Severity Analysis"):
+            gr.Markdown("### Step 3: Analyze wound severity using depth maps")
+            gr.Markdown("This module analyzes wound severity based on depth distribution and area measurements.")
+
+            with gr.Row():
+                severity_input_image = gr.Image(label="Original Image", type='numpy')
+                severity_depth_map = gr.Image(label="Depth Map (from Tab 2)", type='numpy')
+
+            with gr.Row():
+                wound_mask_input = gr.Image(label="Wound Mask (Optional)", type='numpy')
+                severity_output = gr.HTML(label="Severity Analysis Report")
+
+            gr.Markdown("**Note:** You can either upload a manual mask or use automatic mask generation.")
+
+            with gr.Row():
+                auto_severity_button = gr.Button("🤖 Auto-Analyze Severity", variant="primary", size="lg")
+                manual_severity_button = gr.Button("🔍 Manual Mask Analysis", variant="secondary", size="lg")
+                pixel_spacing_slider = gr.Slider(minimum=0.1, maximum=2.0, value=0.5, step=0.1,
+                                               label="Pixel Spacing (mm/pixel)")
+
+            gr.Markdown("**Pixel Spacing:** Adjust based on your camera calibration. Default is 0.5 mm/pixel.")
+
+            with gr.Row():
+                segmentation_method = gr.Dropdown(
+                    choices=["combined", "adaptive", "otsu", "color"],
+                    value="combined",
+                    label="Segmentation Method",
+                    info="Choose automatic segmentation method"
+                )
+                min_area_slider = gr.Slider(minimum=100, maximum=2000, value=500, step=100,
+                                          label="Minimum Area (pixels)",
+                                          info="Minimum wound area to detect")
+
+            with gr.Row():
+                load_depth_btn = gr.Button("🔄 Load Depth Map from Tab 2", variant="secondary")
+                sample_mask_btn = gr.Button("🎯 Generate Sample Mask", variant="secondary")
+                realistic_mask_btn = gr.Button("🏥 Generate Realistic Mask", variant="secondary")
+                preview_mask_btn = gr.Button("👁️ Preview Auto Mask", variant="secondary")
+
+            gr.Markdown("**Options:** Load depth map, generate sample mask, or preview automatic segmentation.")
+
+            # Event handlers
+            def generate_sample_mask(image):
+                if image is None:
+                    return None, "❌ Please load an image first."
+                sample_mask = create_sample_wound_mask(image.shape)
+                return sample_mask, "✅ Sample circular wound mask generated!"
+
+            def generate_realistic_mask(image):
+                if image is None:
+                    return None, "❌ Please load an image first."
+                realistic_mask = create_realistic_wound_mask(image.shape, method='elliptical')
+                return realistic_mask, "✅ Realistic elliptical wound mask generated!"
+
+            def load_depth_to_severity(depth_map, original_image):
+                if depth_map is None:
+                    return None, None, "❌ No depth map available. Please compute depth in Tab 2 first."
+                return depth_map, original_image, "✅ Depth map loaded successfully!"
+
+            def run_auto_severity_analysis(image, depth_map, pixel_spacing, seg_method, min_area):
+                if depth_map is None:
+                    return "❌ Please load depth map from Tab 2 first."
+
+                def post_process_with_area(mask):
+                    return post_process_wound_mask(mask, min_area=min_area)
+
+                auto_mask = create_automatic_wound_mask(image, method=seg_method)
+
+                if auto_mask is None:
+                    return "❌ Failed to generate automatic wound mask."
+
+                processed_mask = post_process_with_area(auto_mask)
+
+                if processed_mask is None or np.sum(processed_mask > 0) == 0:
+                    return "❌ No wound region detected. Try adjusting segmentation parameters or use manual mask."
+
+                return analyze_wound_severity(image, depth_map, processed_mask, pixel_spacing)
+
+            def run_manual_severity_analysis(image, depth_map, wound_mask, pixel_spacing):
+                if depth_map is None:
+                    return "❌ Please load depth map from Tab 2 first."
+                if wound_mask is None:
+                    return "❌ Please upload a wound mask (binary image where white pixels represent the wound area)."
+                return analyze_wound_severity(image, depth_map, wound_mask, pixel_spacing)
+
+            def preview_auto_mask(image, seg_method, min_area):
+                if image is None:
+                    return None, "❌ Please load an image first."
+                auto_mask = create_automatic_wound_mask(image, method=seg_method)
+                if auto_mask is None:
+                    return None, "❌ Failed to generate automatic wound mask."
+                processed_mask = post_process_wound_mask(auto_mask, min_area=min_area)
+                if processed_mask is None or np.sum(processed_mask > 0) == 0:
+                    return None, "❌ No wound region detected. Try adjusting parameters."
+                return processed_mask, f"✅ Auto mask generated using {seg_method} method!"
+
+            def load_shared_image(shared_img):
+                if shared_img is None:
+                    return gr.Image(), "❌ No image available from classification tab"
+                if hasattr(shared_img, 'convert'):
+                    img_array = np.array(shared_img)
+                    return img_array, "✅ Image loaded from classification tab"
+                else:
+                    return shared_img, "✅ Image loaded from classification tab"
+
+            def pass_image_to_depth(img):
+                if img is None:
+                    return "❌ No image uploaded in classification tab"
+                return "✅ Image ready for depth analysis! Switch to tab 2 and click 'Load Image from Classification'"
+
+            def on_depth_submit_with_state(image, num_points, focal_x, focal_y):
+                results = on_depth_submit(image, num_points, focal_x, focal_y)
+                depth_map = None
+                if image is not None:
+                    depth = predict_depth(image[:, :, ::-1])
+                    norm_depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
+                    depth_map = norm_depth.astype(np.uint8)
+                return results + [depth_map]
+
+            # Connect all event handlers
+            sample_mask_btn.click(fn=generate_sample_mask, inputs=[severity_input_image], outputs=[wound_mask_input, gr.HTML()])
+            realistic_mask_btn.click(fn=generate_realistic_mask, inputs=[severity_input_image], outputs=[wound_mask_input, gr.HTML()])
+            depth_input_image.change(fn=update_slider_on_image_upload, inputs=[depth_input_image], outputs=[points_slider])
+            depth_submit.click(on_depth_submit_with_state, inputs=[depth_input_image, points_slider, focal_length_x, focal_length_y], outputs=[depth_image_slider, gray_depth_file, raw_file, point_cloud_file, depth_3d_plot, depth_map_state])
+            load_depth_btn.click(fn=load_depth_to_severity, inputs=[depth_map_state, depth_input_image], outputs=[severity_depth_map, severity_input_image, gr.HTML()])
+            auto_severity_button.click(fn=run_auto_severity_analysis, inputs=[severity_input_image, severity_depth_map, pixel_spacing_slider, segmentation_method, min_area_slider], outputs=[severity_output])
+            manual_severity_button.click(fn=run_manual_severity_analysis, inputs=[severity_input_image, severity_depth_map, wound_mask_input, pixel_spacing_slider], outputs=[severity_output])
+            preview_mask_btn.click(fn=preview_auto_mask, inputs=[severity_input_image, segmentation_method, min_area_slider], outputs=[wound_mask_input, gr.HTML()])
+            load_shared_btn.click(fn=load_shared_image, inputs=[shared_image], outputs=[depth_input_image, gr.HTML()])
+            pass_to_depth_btn.click(fn=pass_image_to_depth, inputs=[shared_image], outputs=[pass_status])
+
+print("Gradio interface created successfully!")
+
+if __name__ == '__main__':
+    print("Launching app...")
+    demo.queue().launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )

temp_files/test2.txt

@@ -0,0 +1,1063 @@
+import glob
+import gradio as gr
+import matplotlib
+import numpy as np
+from PIL import Image
+import torch
+import tempfile
+from gradio_imageslider import ImageSlider
+import plotly.graph_objects as go
+import plotly.express as px
+import open3d as o3d
+from depth_anything_v2.dpt import DepthAnythingV2
+import os
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image as keras_image
+import base64
+from io import BytesIO
+import gdown
+import spaces
+
+# Define path and file ID
+checkpoint_dir = "checkpoints"
+os.makedirs(checkpoint_dir, exist_ok=True)
+
+model_file = os.path.join(checkpoint_dir, "depth_anything_v2_vitl.pth")
+gdrive_url = "https://drive.google.com/uc?id=141Mhq2jonkUBcVBnNqNSeyIZYtH5l4K5"
+
+# Download if not already present
+if not os.path.exists(model_file):
+    print("Downloading model from Google Drive...")
+    gdown.download(gdrive_url, model_file, quiet=False)
+
+# --- TensorFlow: Check GPU Availability ---
+gpus = tf.config.list_physical_devices('GPU')
+if gpus:
+    print("TensorFlow is using GPU")
+else:
+    print("TensorFlow is using CPU")
+
+# --- Load Wound Classification Model and Class Labels ---
+wound_model = load_model("/home/user/app/keras_model.h5")
+with open("/home/user/app/labels.txt", "r") as f:
+    class_labels = [line.strip().split(maxsplit=1)[1] for line in f]
+
+# --- PyTorch: Set Device and Load Depth Model ---
+map_device = torch.device("cuda" if torch.cuda.is_available() and torch.cuda.device_count() > 0 else "cpu")
+print(f"Using PyTorch device: {map_device}")
+
+model_configs = {
+    'vits': {'encoder': 'vits', 'features': 64, 'out_channels': [48, 96, 192, 384]},
+    'vitb': {'encoder': 'vitb', 'features': 128, 'out_channels': [96, 192, 384, 768]},
+    'vitl': {'encoder': 'vitl', 'features': 256, 'out_channels': [256, 512, 1024, 1024]},
+    'vitg': {'encoder': 'vitg', 'features': 384, 'out_channels': [1536, 1536, 1536, 1536]}
+}
+encoder = 'vitl'
+depth_model = DepthAnythingV2(**model_configs[encoder])
+state_dict = torch.load(
+    f'/home/user/app/checkpoints/depth_anything_v2_{encoder}.pth',
+    map_location=map_device
+)
+depth_model.load_state_dict(state_dict)
+depth_model = depth_model.to(map_device).eval()
+
+
+# --- Custom CSS for unified dark theme ---
+css = """
+.gradio-container {
+    font-family: 'Segoe UI', sans-serif;
+    background-color: #121212;
+    color: #ffffff;
+    padding: 20px;
+}
+.gr-button {
+    background-color: #2c3e50;
+    color: white;
+    border-radius: 10px;
+}
+.gr-button:hover {
+    background-color: #34495e;
+}
+.gr-html, .gr-html div {
+    white-space: normal !important;
+    overflow: visible !important;
+    text-overflow: unset !important;
+    word-break: break-word !important;
+}
+#img-display-container {
+    max-height: 100vh;
+}
+#img-display-input {
+    max-height: 80vh;
+}
+#img-display-output {
+    max-height: 80vh;
+}
+#download {
+    height: 62px;
+}
+h1 {
+    text-align: center;
+    font-size: 3rem;
+    font-weight: bold;
+    margin: 2rem 0;
+    color: #ffffff;
+}
+h2 {
+    color: #ffffff;
+    text-align: center;
+    margin: 1rem 0;
+}
+.gr-tabs {
+    background-color: #1e1e1e;
+    border-radius: 10px;
+    padding: 10px;
+}
+.gr-tab-nav {
+    background-color: #2c3e50;
+    border-radius: 8px;
+}
+.gr-tab-nav button {
+    color: #ffffff !important;
+}
+.gr-tab-nav button.selected {
+    background-color: #34495e !important;
+}
+"""
+
+# --- Wound Classification Functions ---
+def preprocess_input(img):
+    img = img.resize((224, 224))
+    arr = keras_image.img_to_array(img)
+    arr = arr / 255.0
+    return np.expand_dims(arr, axis=0)
+
+def get_reasoning_from_gemini(img, prediction):
+    try:
+        # For now, return a simple explanation without Gemini API to avoid typing issues
+        # In production, you would implement the proper Gemini API call here
+        explanations = {
+            "Abrasion": "This appears to be an abrasion wound, characterized by superficial damage to the skin surface. The wound shows typical signs of friction or scraping injury.",
+            "Burn": "This wound exhibits characteristics consistent with a burn injury, showing tissue damage from heat, chemicals, or radiation exposure.",
+            "Laceration": "This wound displays the irregular edges and tissue tearing typical of a laceration, likely caused by blunt force trauma.",
+            "Puncture": "This wound shows a small, deep entry point characteristic of puncture wounds, often caused by sharp, pointed objects.",
+            "Ulcer": "This wound exhibits the characteristics of an ulcer, showing tissue breakdown and potential underlying vascular or pressure issues."
+        }
+
+        return explanations.get(prediction, f"This wound has been classified as {prediction}. Please consult with a healthcare professional for detailed assessment.")
+
+    except Exception as e:
+        return f"(Reasoning unavailable: {str(e)})"
+    
+@spaces.GPU
+def classify_wound_image(img):
+    if img is None:
+        return "<div style='color:#ff5252; font-size:18px;'>No image provided</div>", ""
+
+    img_array = preprocess_input(img)
+    predictions = wound_model.predict(img_array, verbose=0)[0]
+    pred_idx = int(np.argmax(predictions))
+    pred_class = class_labels[pred_idx]
+
+    # Get reasoning from Gemini
+    reasoning_text = get_reasoning_from_gemini(img, pred_class)
+
+    # Prediction Card
+    predicted_card = f"""
+    <div style='padding: 20px; background-color: #1e1e1e; border-radius: 12px;
+                box-shadow: 0 0 10px rgba(0,0,0,0.5);'>
+        <div style='font-size: 22px; font-weight: bold; color: orange; margin-bottom: 10px;'>
+            Predicted Wound Type
+        </div>
+        <div style='font-size: 26px; color: white;'>
+            {pred_class}
+        </div>
+    </div>
+    """
+
+    # Reasoning Card
+    reasoning_card = f"""
+    <div style='padding: 20px; background-color: #1e1e1e; border-radius: 12px;
+                box-shadow: 0 0 10px rgba(0,0,0,0.5);'>
+        <div style='font-size: 22px; font-weight: bold; color: orange; margin-bottom: 10px;'>
+            Reasoning
+        </div>
+        <div style='font-size: 16px; color: white; min-height: 80px;'>
+            {reasoning_text}
+        </div>
+    </div>
+    """
+
+    return predicted_card, reasoning_card
+
+# --- Wound Severity Estimation Functions ---
+@spaces.GPU
+def compute_depth_area_statistics(depth_map, mask, pixel_spacing_mm=0.5):
+    """Compute area statistics for different depth regions"""
+    pixel_area_cm2 = (pixel_spacing_mm / 10.0) ** 2
+
+    # Extract only wound region
+    wound_mask = (mask > 127)
+    wound_depths = depth_map[wound_mask]
+    total_area = np.sum(wound_mask) * pixel_area_cm2
+
+    # Categorize depth regions
+    shallow = wound_depths < 3
+    moderate = (wound_depths >= 3) & (wound_depths < 6)
+    deep = wound_depths >= 6
+
+    shallow_area = np.sum(shallow) * pixel_area_cm2
+    moderate_area = np.sum(moderate) * pixel_area_cm2
+    deep_area = np.sum(deep) * pixel_area_cm2
+
+    deep_ratio = deep_area / total_area if total_area > 0 else 0
+
+    return {
+        'total_area_cm2': total_area,
+        'shallow_area_cm2': shallow_area,
+        'moderate_area_cm2': moderate_area,
+        'deep_area_cm2': deep_area,
+        'deep_ratio': deep_ratio,
+        'max_depth': np.max(wound_depths) if len(wound_depths) > 0 else 0
+    }
+
+def classify_wound_severity_by_area(depth_stats):
+    """Classify wound severity based on area and depth distribution"""
+    total = depth_stats['total_area_cm2']
+    deep = depth_stats['deep_area_cm2']
+    moderate = depth_stats['moderate_area_cm2']
+
+    if total == 0:
+        return "Unknown"
+
+    # Severity classification rules
+    if deep > 2 or (deep / total) > 0.3:
+        return "Severe"
+    elif moderate > 1.5 or (moderate / total) > 0.4:
+        return "Moderate"
+    else:
+        return "Mild"
+
+def analyze_wound_severity(image, depth_map, wound_mask, pixel_spacing_mm=0.5):
+    """Analyze wound severity from depth map and wound mask"""
+    if image is None or depth_map is None or wound_mask is None:
+        return "❌ Please upload image, depth map, and wound mask."
+
+    # Convert wound mask to grayscale if needed
+    if len(wound_mask.shape) == 3:
+        wound_mask = np.mean(wound_mask, axis=2)
+
+    # Ensure depth map and mask have same dimensions
+    if depth_map.shape[:2] != wound_mask.shape[:2]:
+        # Resize mask to match depth map
+        from PIL import Image
+        mask_pil = Image.fromarray(wound_mask.astype(np.uint8))
+        mask_pil = mask_pil.resize((depth_map.shape[1], depth_map.shape[0]))
+        wound_mask = np.array(mask_pil)
+
+    # Compute statistics
+    stats = compute_depth_area_statistics(depth_map, wound_mask, pixel_spacing_mm)
+    severity = classify_wound_severity_by_area(stats)
+
+    # Create severity report with color coding
+    severity_color = {
+        "Mild": "#4CAF50",      # Green
+        "Moderate": "#FF9800",   # Orange
+        "Severe": "#F44336"      # Red
+    }.get(severity, "#9E9E9E")   # Gray for unknown
+
+    report = f"""
+    <div style='padding: 20px; background-color: #1e1e1e; border-radius: 12px; box-shadow: 0 0 10px rgba(0,0,0,0.5);'>
+        <div style='font-size: 24px; font-weight: bold; color: {severity_color}; margin-bottom: 15px;'>
+            🩹 Wound Severity Analysis
+        </div>
+
+        <div style='display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-bottom: 20px;'>
+            <div style='background-color: #2c2c2c; padding: 15px; border-radius: 8px;'>
+                <div style='font-size: 18px; font-weight: bold; color: #ffffff; margin-bottom: 10px;'>
+                    📏 Area Measurements
+                </div>
+                <div style='color: #cccccc; line-height: 1.6;'>
+                    <div>🟢 <b>Total Area:</b> {stats['total_area_cm2']:.2f} cm²</div>
+                    <div>🟩 <b>Shallow (0-3mm):</b> {stats['shallow_area_cm2']:.2f} cm²</div>
+                    <div>🟨 <b>Moderate (3-6mm):</b> {stats['moderate_area_cm2']:.2f} cm²</div>
+                    <div>🟥 <b>Deep (>6mm):</b> {stats['deep_area_cm2']:.2f} cm²</div>
+                </div>
+            </div>
+
+            <div style='background-color: #2c2c2c; padding: 15px; border-radius: 8px;'>
+                <div style='font-size: 18px; font-weight: bold; color: #ffffff; margin-bottom: 10px;'>
+                    📊 Depth Analysis
+                </div>
+                <div style='color: #cccccc; line-height: 1.6;'>
+                    <div>🔥 <b>Deep Coverage:</b> {stats['deep_ratio']*100:.1f}%</div>
+                    <div>📏 <b>Max Depth:</b> {stats['max_depth']:.1f} mm</div>
+                    <div>⚡ <b>Pixel Spacing:</b> {pixel_spacing_mm} mm</div>
+                </div>
+            </div>
+        </div>
+
+        <div style='text-align: center; padding: 15px; background-color: #2c2c2c; border-radius: 8px; border-left: 4px solid {severity_color};'>
+            <div style='font-size: 20px; font-weight: bold; color: {severity_color};'>
+                🎯 Predicted Severity: {severity}
+            </div>
+            <div style='font-size: 14px; color: #cccccc; margin-top: 5px;'>
+                {get_severity_description(severity)}
+            </div>
+        </div>
+    </div>
+    """
+
+    return report
+
+def get_severity_description(severity):
+    """Get description for severity level"""
+    descriptions = {
+        "Mild": "Superficial wound with minimal tissue damage. Usually heals well with basic care.",
+        "Moderate": "Moderate tissue involvement requiring careful monitoring and proper treatment.",
+        "Severe": "Deep tissue damage requiring immediate medical attention and specialized care.",
+        "Unknown": "Unable to determine severity due to insufficient data."
+    }
+    return descriptions.get(severity, "Severity assessment unavailable.")
+
+def create_sample_wound_mask(image_shape, center=None, radius=50):
+    """Create a sample circular wound mask for testing"""
+    if center is None:
+        center = (image_shape[1] // 2, image_shape[0] // 2)
+
+    mask = np.zeros(image_shape[:2], dtype=np.uint8)
+    y, x = np.ogrid[:image_shape[0], :image_shape[1]]
+
+    # Create circular mask
+    dist_from_center = np.sqrt((x - center[0])**2 + (y - center[1])**2)
+    mask[dist_from_center <= radius] = 255
+
+    return mask
+
+def create_realistic_wound_mask(image_shape, method='elliptical'):
+    """Create a more realistic wound mask with irregular shapes"""
+    h, w = image_shape[:2]
+    mask = np.zeros((h, w), dtype=np.uint8)
+
+    if method == 'elliptical':
+        # Create elliptical wound mask
+        center = (w // 2, h // 2)
+        radius_x = min(w, h) // 3
+        radius_y = min(w, h) // 4
+
+        y, x = np.ogrid[:h, :w]
+        # Add some irregularity to make it more realistic
+        ellipse = ((x - center[0])**2 / (radius_x**2) +
+                   (y - center[1])**2 / (radius_y**2)) <= 1
+
+        # Add some noise and irregularity
+        noise = np.random.random((h, w)) > 0.8
+        mask = (ellipse | noise).astype(np.uint8) * 255
+
+    elif method == 'irregular':
+        # Create irregular wound mask
+        center = (w // 2, h // 2)
+        radius = min(w, h) // 4
+
+        y, x = np.ogrid[:h, :w]
+        base_circle = np.sqrt((x - center[0])**2 + (y - center[1])**2) <= radius
+
+        # Add irregular extensions
+        extensions = np.zeros_like(base_circle)
+        for i in range(3):
+            angle = i * 2 * np.pi / 3
+            ext_x = int(center[0] + radius * 0.8 * np.cos(angle))
+            ext_y = int(center[1] + radius * 0.8 * np.sin(angle))
+            ext_radius = radius // 3
+
+            ext_circle = np.sqrt((x - ext_x)**2 + (y - ext_y)**2) <= ext_radius
+            extensions = extensions | ext_circle
+
+        mask = (base_circle | extensions).astype(np.uint8) * 255
+
+    # Apply morphological operations to smooth the mask
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+
+    return mask
+
+# --- Depth Estimation Functions ---
+@spaces.GPU
+def predict_depth(image):
+    return depth_model.infer_image(image)
+
+def calculate_max_points(image):
+    """Calculate maximum points based on image dimensions (3x pixel count)"""
+    if image is None:
+        return 10000  # Default value
+    h, w = image.shape[:2]
+    max_points = h * w * 3
+    # Ensure minimum and reasonable maximum values
+    return max(1000, min(max_points, 300000))
+
+def update_slider_on_image_upload(image):
+    """Update the points slider when an image is uploaded"""
+    max_points = calculate_max_points(image)
+    default_value = min(10000, max_points // 10)  # 10% of max points as default
+    return gr.Slider(minimum=1000, maximum=max_points, value=default_value, step=1000,
+                     label=f"Number of 3D points (max: {max_points:,})")
+
+@spaces.GPU
+def create_point_cloud(image, depth_map, focal_length_x=470.4, focal_length_y=470.4, max_points=30000):
+    """Create a point cloud from depth map using camera intrinsics with high detail"""
+    h, w = depth_map.shape
+
+    # Use smaller step for higher detail (reduced downsampling)
+    step = max(1, int(np.sqrt(h * w / max_points) * 0.5))  # Reduce step size for more detail
+
+    # Create mesh grid for camera coordinates
+    y_coords, x_coords = np.mgrid[0:h:step, 0:w:step]
+
+    # Convert to camera coordinates (normalized by focal length)
+    x_cam = (x_coords - w / 2) / focal_length_x
+    y_cam = (y_coords - h / 2) / focal_length_y
+
+    # Get depth values
+    depth_values = depth_map[::step, ::step]
+
+    # Calculate 3D points: (x_cam * depth, y_cam * depth, depth)
+    x_3d = x_cam * depth_values
+    y_3d = y_cam * depth_values
+    z_3d = depth_values
+
+    # Flatten arrays
+    points = np.stack([x_3d.flatten(), y_3d.flatten(), z_3d.flatten()], axis=1)
+
+    # Get corresponding image colors
+    image_colors = image[::step, ::step, :]
+    colors = image_colors.reshape(-1, 3) / 255.0
+
+    # Create Open3D point cloud
+    pcd = o3d.geometry.PointCloud()
+    pcd.points = o3d.utility.Vector3dVector(points)
+    pcd.colors = o3d.utility.Vector3dVector(colors)
+
+    return pcd
+
+@spaces.GPU
+def reconstruct_surface_mesh_from_point_cloud(pcd):
+    """Convert point cloud to a mesh using Poisson reconstruction with very high detail."""
+    # Estimate and orient normals with high precision
+    pcd.estimate_normals(search_param=o3d.geometry.KDTreeSearchParamHybrid(radius=0.005, max_nn=50))
+    pcd.orient_normals_consistent_tangent_plane(k=50)
+
+    # Create surface mesh with maximum detail (depth=12 for very high resolution)
+    mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(pcd, depth=12)
+
+    # Return mesh without filtering low-density vertices
+    return mesh
+
+@spaces.GPU
+def create_enhanced_3d_visualization(image, depth_map, max_points=10000):
+    """Create an enhanced 3D visualization using proper camera projection"""
+    h, w = depth_map.shape
+
+    # Downsample to avoid too many points for performance
+    step = max(1, int(np.sqrt(h * w / max_points)))
+
+    # Create mesh grid for camera coordinates
+    y_coords, x_coords = np.mgrid[0:h:step, 0:w:step]
+
+    # Convert to camera coordinates (normalized by focal length)
+    focal_length = 470.4  # Default focal length
+    x_cam = (x_coords - w / 2) / focal_length
+    y_cam = (y_coords - h / 2) / focal_length
+
+    # Get depth values
+    depth_values = depth_map[::step, ::step]
+
+    # Calculate 3D points: (x_cam * depth, y_cam * depth, depth)
+    x_3d = x_cam * depth_values
+    y_3d = y_cam * depth_values
+    z_3d = depth_values
+
+    # Flatten arrays
+    x_flat = x_3d.flatten()
+    y_flat = y_3d.flatten()
+    z_flat = z_3d.flatten()
+
+    # Get corresponding image colors
+    image_colors = image[::step, ::step, :]
+    colors_flat = image_colors.reshape(-1, 3)
+
+    # Create 3D scatter plot with proper camera projection
+    fig = go.Figure(data=[go.Scatter3d(
+        x=x_flat,
+        y=y_flat,
+        z=z_flat,
+        mode='markers',
+        marker=dict(
+            size=1.5,
+            color=colors_flat,
+            opacity=0.9
+        ),
+        hovertemplate='<b>3D Position:</b> (%{x:.3f}, %{y:.3f}, %{z:.3f})<br>' +
+                     '<b>Depth:</b> %{z:.2f}<br>' +
+                     '<extra></extra>'
+    )])
+
+    fig.update_layout(
+        title="3D Point Cloud Visualization (Camera Projection)",
+        scene=dict(
+            xaxis_title="X (meters)",
+            yaxis_title="Y (meters)",
+            zaxis_title="Z (meters)",
+            camera=dict(
+                eye=dict(x=2.0, y=2.0, z=2.0),
+                center=dict(x=0, y=0, z=0),
+                up=dict(x=0, y=0, z=1)
+            ),
+            aspectmode='data'
+        ),
+        width=700,
+        height=600
+    )
+
+    return fig
+
+def on_depth_submit(image, num_points, focal_x, focal_y):
+    original_image = image.copy()
+
+    h, w = image.shape[:2]
+
+    # Predict depth using the model
+    depth = predict_depth(image[:, :, ::-1])  # RGB to BGR if needed
+
+    # Save raw 16-bit depth
+    raw_depth = Image.fromarray(depth.astype('uint16'))
+    tmp_raw_depth = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
+    raw_depth.save(tmp_raw_depth.name)
+
+    # Normalize and convert to grayscale for display
+    norm_depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
+    norm_depth = norm_depth.astype(np.uint8)
+    colored_depth = (matplotlib.colormaps.get_cmap('Spectral_r')(norm_depth)[:, :, :3] * 255).astype(np.uint8)
+
+    gray_depth = Image.fromarray(norm_depth)
+    tmp_gray_depth = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
+    gray_depth.save(tmp_gray_depth.name)
+
+    # Create point cloud
+    pcd = create_point_cloud(original_image, norm_depth, focal_x, focal_y, max_points=num_points)
+
+    # Reconstruct mesh from point cloud
+    mesh = reconstruct_surface_mesh_from_point_cloud(pcd)
+
+    # Save mesh with faces as .ply
+    tmp_pointcloud = tempfile.NamedTemporaryFile(suffix='.ply', delete=False)
+    o3d.io.write_triangle_mesh(tmp_pointcloud.name, mesh)
+
+    # Create enhanced 3D scatter plot visualization
+    depth_3d = create_enhanced_3d_visualization(original_image, norm_depth, max_points=num_points)
+
+    return [(original_image, colored_depth), tmp_gray_depth.name, tmp_raw_depth.name, tmp_pointcloud.name, depth_3d]
+
+# --- Automatic Wound Mask Generation Functions ---
+import cv2
+from skimage import filters, morphology, measure
+from skimage.segmentation import clear_border
+
+def create_automatic_wound_mask(image, method='adaptive'):
+    """
+    Automatically generate wound mask from image using various segmentation methods
+
+    Args:
+        image: Input image (numpy array)
+        method: Segmentation method ('adaptive', 'otsu', 'color', 'combined')
+
+    Returns:
+        mask: Binary wound mask
+    """
+    if image is None:
+        return None
+
+    # Convert to grayscale if needed
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    else:
+        gray = image.copy()
+
+    # Apply different segmentation methods
+    if method == 'adaptive':
+        mask = adaptive_threshold_segmentation(gray)
+    elif method == 'otsu':
+        mask = otsu_threshold_segmentation(gray)
+    elif method == 'color':
+        mask = color_based_segmentation(image)
+    elif method == 'combined':
+        mask = combined_segmentation(image, gray)
+    else:
+        mask = adaptive_threshold_segmentation(gray)
+
+    return mask
+
+def adaptive_threshold_segmentation(gray):
+    """Use adaptive thresholding for wound segmentation"""
+    # Apply Gaussian blur to reduce noise
+    blurred = cv2.GaussianBlur(gray, (15, 15), 0)
+
+    # Adaptive thresholding with larger block size
+    thresh = cv2.adaptiveThreshold(
+        blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 25, 5
+    )
+
+    # Morphological operations to clean up the mask
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (15, 15))
+    mask = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+
+    # Find contours and keep only the largest ones
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # Create a new mask with only large contours
+    mask_clean = np.zeros_like(mask)
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area > 1000:  # Minimum area threshold
+            cv2.fillPoly(mask_clean, [contour], 255)
+
+    return mask_clean
+
+def otsu_threshold_segmentation(gray):
+    """Use Otsu's thresholding for wound segmentation"""
+    # Apply Gaussian blur
+    blurred = cv2.GaussianBlur(gray, (15, 15), 0)
+
+    # Otsu's thresholding
+    _, thresh = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+
+    # Morphological operations
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (10, 10))
+    mask = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+
+    # Find contours and keep only the largest ones
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # Create a new mask with only large contours
+    mask_clean = np.zeros_like(mask)
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area > 800:  # Minimum area threshold
+            cv2.fillPoly(mask_clean, [contour], 255)
+
+    return mask_clean
+
+def color_based_segmentation(image):
+    """Use color-based segmentation for wound detection"""
+    # Convert to different color spaces
+    hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+
+    # Create masks for different color ranges (wound-like colors)
+    # Reddish/brownish wound colors in HSV - broader ranges
+    lower_red1 = np.array([0, 30, 30])
+    upper_red1 = np.array([15, 255, 255])
+    lower_red2 = np.array([160, 30, 30])
+    upper_red2 = np.array([180, 255, 255])
+
+    mask1 = cv2.inRange(hsv, lower_red1, upper_red1)
+    mask2 = cv2.inRange(hsv, lower_red2, upper_red2)
+    red_mask = mask1 + mask2
+
+    # Yellowish wound colors - broader range
+    lower_yellow = np.array([15, 30, 30])
+    upper_yellow = np.array([35, 255, 255])
+    yellow_mask = cv2.inRange(hsv, lower_yellow, upper_yellow)
+
+    # Brownish wound colors
+    lower_brown = np.array([10, 50, 20])
+    upper_brown = np.array([20, 255, 200])
+    brown_mask = cv2.inRange(hsv, lower_brown, upper_brown)
+
+    # Combine color masks
+    color_mask = red_mask + yellow_mask + brown_mask
+
+    # Clean up the mask with larger kernels
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (15, 15))
+    color_mask = cv2.morphologyEx(color_mask, cv2.MORPH_CLOSE, kernel)
+    color_mask = cv2.morphologyEx(color_mask, cv2.MORPH_OPEN, kernel)
+
+    # Find contours and keep only the largest ones
+    contours, _ = cv2.findContours(color_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # Create a new mask with only large contours
+    mask_clean = np.zeros_like(color_mask)
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area > 600:  # Minimum area threshold
+            cv2.fillPoly(mask_clean, [contour], 255)
+
+    return mask_clean
+
+def combined_segmentation(image, gray):
+    """Combine multiple segmentation methods for better results"""
+    # Get masks from different methods
+    adaptive_mask = adaptive_threshold_segmentation(gray)
+    otsu_mask = otsu_threshold_segmentation(gray)
+    color_mask = color_based_segmentation(image)
+
+    # Combine masks (union)
+    combined_mask = cv2.bitwise_or(adaptive_mask, otsu_mask)
+    combined_mask = cv2.bitwise_or(combined_mask, color_mask)
+
+    # Apply additional morphological operations to clean up
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (20, 20))
+    combined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_CLOSE, kernel)
+
+    # Find contours and keep only the largest ones
+    contours, _ = cv2.findContours(combined_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # Create a new mask with only large contours
+    mask_clean = np.zeros_like(combined_mask)
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area > 500:  # Minimum area threshold
+            cv2.fillPoly(mask_clean, [contour], 255)
+
+    # If no large contours found, create a realistic wound mask
+    if np.sum(mask_clean) == 0:
+        mask_clean = create_realistic_wound_mask(combined_mask.shape, method='elliptical')
+
+    return mask_clean
+
+def post_process_wound_mask(mask, min_area=100):
+    """Post-process the wound mask to remove noise and small objects"""
+    if mask is None:
+        return None
+
+    # Convert to binary if needed
+    if mask.dtype != np.uint8:
+        mask = mask.astype(np.uint8)
+
+    # Apply morphological operations to clean up
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (10, 10))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+
+    # Remove small objects using OpenCV
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    mask_clean = np.zeros_like(mask)
+
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area >= min_area:
+            cv2.fillPoly(mask_clean, [contour], 255)
+
+    # Fill holes
+    mask_clean = cv2.morphologyEx(mask_clean, cv2.MORPH_CLOSE, kernel)
+
+    return mask_clean
+
+def analyze_wound_severity_auto(image, depth_map, pixel_spacing_mm=0.5, segmentation_method='combined'):
+    """Analyze wound severity with automatic mask generation"""
+    if image is None or depth_map is None:
+        return "❌ Please provide both image and depth map."
+
+    # Generate automatic wound mask
+    auto_mask = create_automatic_wound_mask(image, method=segmentation_method)
+
+    if auto_mask is None:
+        return "❌ Failed to generate automatic wound mask."
+
+    # Post-process the mask
+    processed_mask = post_process_wound_mask(auto_mask, min_area=500)
+
+    if processed_mask is None or np.sum(processed_mask > 0) == 0:
+        return "❌ No wound region detected. Try adjusting segmentation parameters or upload a manual mask."
+
+    # Analyze severity using the automatic mask
+    return analyze_wound_severity(image, depth_map, processed_mask, pixel_spacing_mm)
+
+# --- Main Gradio Interface ---
+with gr.Blocks(css=css, title="Wound Analysis & Depth Estimation") as demo:
+    gr.HTML("<h1>Wound Analysis & Depth Estimation System</h1>")
+    gr.Markdown("### Comprehensive wound analysis with classification and 3D depth mapping capabilities")
+
+    # Shared image state
+    shared_image = gr.State()
+
+    with gr.Tabs():
+        # Tab 1: Wound Classification
+        with gr.Tab("1. Wound Classification"):
+            gr.Markdown("### Step 1: Upload and classify your wound image")
+            gr.Markdown("This module analyzes wound images and provides classification with AI-powered reasoning.")
+
+            with gr.Row():
+                with gr.Column(scale=1):
+                    wound_image_input = gr.Image(label="Upload Wound Image", type="pil", height=350)
+
+                with gr.Column(scale=1):
+                    wound_prediction_box = gr.HTML()
+                    wound_reasoning_box = gr.HTML()
+
+            # Button to pass image to depth estimation
+            with gr.Row():
+                pass_to_depth_btn = gr.Button("📊 Pass Image to Depth Analysis", variant="secondary", size="lg")
+                pass_status = gr.HTML("")
+
+            wound_image_input.change(fn=classify_wound_image, inputs=wound_image_input,
+                                   outputs=[wound_prediction_box, wound_reasoning_box])
+
+            # Store image when uploaded for classification
+            wound_image_input.change(
+                fn=lambda img: img,
+                inputs=[wound_image_input],
+                outputs=[shared_image]
+            )
+
+        # Tab 2: Depth Estimation
+        with gr.Tab("2. Depth Estimation & 3D Visualization"):
+            gr.Markdown("### Step 2: Generate depth maps and 3D visualizations")
+            gr.Markdown("This module creates depth maps and 3D point clouds from your images.")
+
+            with gr.Row():
+                depth_input_image = gr.Image(label="Input Image", type='numpy', elem_id='img-display-input')
+                depth_image_slider = ImageSlider(label="Depth Map with Slider View", elem_id='img-display-output')
+
+            with gr.Row():
+                depth_submit = gr.Button(value="Compute Depth", variant="primary")
+                load_shared_btn = gr.Button("🔄 Load Image from Classification", variant="secondary")
+                points_slider = gr.Slider(minimum=1000, maximum=10000, value=10000, step=1000,
+                                         label="Number of 3D points (upload image to update max)")
+
+            with gr.Row():
+                focal_length_x = gr.Slider(minimum=100, maximum=1000, value=470.4, step=10,
+                                          label="Focal Length X (pixels)")
+                focal_length_y = gr.Slider(minimum=100, maximum=1000, value=470.4, step=10,
+                                          label="Focal Length Y (pixels)")
+
+            with gr.Row():
+                gray_depth_file = gr.File(label="Grayscale depth map", elem_id="download")
+                raw_file = gr.File(label="16-bit raw output (can be considered as disparity)", elem_id="download")
+                point_cloud_file = gr.File(label="Point Cloud (.ply)", elem_id="download")
+
+            # 3D Visualization
+            gr.Markdown("### 3D Point Cloud Visualization")
+            gr.Markdown("Enhanced 3D visualization using proper camera projection. Hover over points to see 3D coordinates.")
+            depth_3d_plot = gr.Plot(label="3D Point Cloud")
+
+            # Store depth map for severity analysis
+            depth_map_state = gr.State()
+
+        # Tab 3: Wound Severity Analysis
+        with gr.Tab("3. 🩹 Wound Severity Analysis"):
+            gr.Markdown("### Step 3: Analyze wound severity using depth maps")
+            gr.Markdown("This module analyzes wound severity based on depth distribution and area measurements.")
+
+            with gr.Row():
+                severity_input_image = gr.Image(label="Original Image", type='numpy')
+                severity_depth_map = gr.Image(label="Depth Map (from Tab 2)", type='numpy')
+
+            with gr.Row():
+                wound_mask_input = gr.Image(label="Wound Mask (Optional)", type='numpy')
+                severity_output = gr.HTML(label="Severity Analysis Report")
+
+            gr.Markdown("**Note:** You can either upload a manual mask or use automatic mask generation.")
+
+            with gr.Row():
+                auto_severity_button = gr.Button("🤖 Auto-Analyze Severity", variant="primary", size="lg")
+                manual_severity_button = gr.Button("🔍 Manual Mask Analysis", variant="secondary", size="lg")
+                pixel_spacing_slider = gr.Slider(minimum=0.1, maximum=2.0, value=0.5, step=0.1,
+                                               label="Pixel Spacing (mm/pixel)")
+
+            gr.Markdown("**Pixel Spacing:** Adjust based on your camera calibration. Default is 0.5 mm/pixel.")
+
+            with gr.Row():
+                segmentation_method = gr.Dropdown(
+                    choices=["combined", "adaptive", "otsu", "color"],
+                    value="combined",
+                    label="Segmentation Method",
+                    info="Choose automatic segmentation method"
+                )
+                min_area_slider = gr.Slider(minimum=100, maximum=2000, value=500, step=100,
+                                          label="Minimum Area (pixels)",
+                                          info="Minimum wound area to detect")
+
+            with gr.Row():
+                # Load depth map from previous tab
+                load_depth_btn = gr.Button("🔄 Load Depth Map from Tab 2", variant="secondary")
+                sample_mask_btn = gr.Button("🎯 Generate Sample Mask", variant="secondary")
+                realistic_mask_btn = gr.Button("🏥 Generate Realistic Mask", variant="secondary")
+                preview_mask_btn = gr.Button("👁️ Preview Auto Mask", variant="secondary")
+
+            gr.Markdown("**Options:** Load depth map, generate sample mask, or preview automatic segmentation.")
+
+            # Generate sample mask function
+            def generate_sample_mask(image):
+                if image is None:
+                    return None, "❌ Please load an image first."
+
+                sample_mask = create_sample_wound_mask(image.shape)
+                return sample_mask, "✅ Sample circular wound mask generated!"
+
+            # Generate realistic mask function
+            def generate_realistic_mask(image):
+                if image is None:
+                    return None, "❌ Please load an image first."
+
+                realistic_mask = create_realistic_wound_mask(image.shape, method='elliptical')
+                return realistic_mask, "✅ Realistic elliptical wound mask generated!"
+
+            sample_mask_btn.click(
+                fn=generate_sample_mask,
+                inputs=[severity_input_image],
+                outputs=[wound_mask_input, gr.HTML()]
+            )
+
+            realistic_mask_btn.click(
+                fn=generate_realistic_mask,
+                inputs=[severity_input_image],
+                outputs=[wound_mask_input, gr.HTML()]
+            )
+
+            # Update slider when image is uploaded
+            depth_input_image.change(
+                fn=update_slider_on_image_upload,
+                inputs=[depth_input_image],
+                outputs=[points_slider]
+            )
+
+            # Modified depth submit function to store depth map
+            def on_depth_submit_with_state(image, num_points, focal_x, focal_y):
+                results = on_depth_submit(image, num_points, focal_x, focal_y)
+                # Extract depth map from results for severity analysis
+                depth_map = None
+                if image is not None:
+                    depth = predict_depth(image[:, :, ::-1])  # RGB to BGR if needed
+                    # Normalize depth for severity analysis
+                    norm_depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
+                    depth_map = norm_depth.astype(np.uint8)
+                return results + [depth_map]
+
+            depth_submit.click(on_depth_submit_with_state,
+                             inputs=[depth_input_image, points_slider, focal_length_x, focal_length_y],
+                             outputs=[depth_image_slider, gray_depth_file, raw_file, point_cloud_file, depth_3d_plot, depth_map_state])
+
+            # Load depth map to severity tab
+            def load_depth_to_severity(depth_map, original_image):
+                if depth_map is None:
+                    return None, None, "❌ No depth map available. Please compute depth in Tab 2 first."
+                return depth_map, original_image, "✅ Depth map loaded successfully!"
+
+            load_depth_btn.click(
+                fn=load_depth_to_severity,
+                inputs=[depth_map_state, depth_input_image],
+                outputs=[severity_depth_map, severity_input_image, gr.HTML()]
+            )
+
+            # Automatic severity analysis function
+            def run_auto_severity_analysis(image, depth_map, pixel_spacing, seg_method, min_area):
+                if depth_map is None:
+                    return "❌ Please load depth map from Tab 2 first."
+
+                # Update post-processing with user-defined minimum area
+                def post_process_with_area(mask):
+                    return post_process_wound_mask(mask, min_area=min_area)
+
+                # Generate automatic wound mask
+                auto_mask = create_automatic_wound_mask(image, method=seg_method)
+
+                if auto_mask is None:
+                    return "❌ Failed to generate automatic wound mask."
+
+                # Post-process the mask
+                processed_mask = post_process_with_area(auto_mask)
+
+                if processed_mask is None or np.sum(processed_mask > 0) == 0:
+                    return "❌ No wound region detected. Try adjusting segmentation parameters or use manual mask."
+
+                # Analyze severity using the automatic mask
+                return analyze_wound_severity(image, depth_map, processed_mask, pixel_spacing)
+
+            # Manual severity analysis function
+            def run_manual_severity_analysis(image, depth_map, wound_mask, pixel_spacing):
+                if depth_map is None:
+                    return "❌ Please load depth map from Tab 2 first."
+                if wound_mask is None:
+                    return "❌ Please upload a wound mask (binary image where white pixels represent the wound area)."
+
+                return analyze_wound_severity(image, depth_map, wound_mask, pixel_spacing)
+
+            # Preview automatic mask function
+            def preview_auto_mask(image, seg_method, min_area):
+                if image is None:
+                    return None, "❌ Please load an image first."
+
+                # Generate automatic wound mask
+                auto_mask = create_automatic_wound_mask(image, method=seg_method)
+
+                if auto_mask is None:
+                    return None, "❌ Failed to generate automatic wound mask."
+
+                # Post-process the mask
+                processed_mask = post_process_wound_mask(auto_mask, min_area=min_area)
+
+                if processed_mask is None or np.sum(processed_mask > 0) == 0:
+                    return None, "❌ No wound region detected. Try adjusting parameters."
+
+                return processed_mask, f"✅ Auto mask generated using {seg_method} method!"
+
+            # Connect event handlers
+            auto_severity_button.click(
+                fn=run_auto_severity_analysis,
+                inputs=[severity_input_image, severity_depth_map, pixel_spacing_slider,
+                       segmentation_method, min_area_slider],
+                outputs=[severity_output]
+            )
+
+            manual_severity_button.click(
+                fn=run_manual_severity_analysis,
+                inputs=[severity_input_image, severity_depth_map, wound_mask_input, pixel_spacing_slider],
+                outputs=[severity_output]
+            )
+
+            preview_mask_btn.click(
+                fn=preview_auto_mask,
+                inputs=[severity_input_image, segmentation_method, min_area_slider],
+                outputs=[wound_mask_input, gr.HTML()]
+            )
+
+            # Load shared image from classification tab
+            def load_shared_image(shared_img):
+                if shared_img is None:
+                    return gr.Image(), "❌ No image available from classification tab"
+
+                # Convert PIL image to numpy array for depth estimation
+                if hasattr(shared_img, 'convert'):
+                    # It's a PIL image, convert to numpy
+                    img_array = np.array(shared_img)
+                    return img_array, "✅ Image loaded from classification tab"
+                else:
+                    # Already numpy array
+                    return shared_img, "✅ Image loaded from classification tab"
+
+            load_shared_btn.click(
+                fn=load_shared_image,
+                inputs=[shared_image],
+                outputs=[depth_input_image, gr.HTML()]
+            )
+
+            # Pass image to depth tab function
+            def pass_image_to_depth(img):
+                if img is None:
+                    return "❌ No image uploaded in classification tab"
+                return "✅ Image ready for depth analysis! Switch to tab 2 and click 'Load Image from Classification'"
+
+            pass_to_depth_btn.click(
+                fn=pass_image_to_depth,
+                inputs=[shared_image],
+                outputs=[pass_status]
+            )
+
+if __name__ == '__main__':
+    demo.queue().launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )