{analysis}
{para}
' 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"""