Update medpy/mcp_output/mcp_plugin/mcp_service.py

medpy/mcp_output/mcp_plugin/mcp_service.py

@@ -3,6 +3,11 @@ import sys
 import numpy as np
 import json
 
+try:
+    from scipy import ndimage
+except ImportError:
+    ndimage = None
+
 source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
 sys.path.insert(0, source_path)
 
@@ -386,6 +391,126 @@ def otsu_threshold_tool(image_data: list) -> dict:
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
 
+@mcp.tool(name="detect_lesions", description="Detect lesion regions in medical images and return detailed location information.")
+def detect_lesions_tool(image_data: list, method: str = "otsu", min_size: int = 10) -> dict:
+    """
+    Detects lesion regions in medical images and provides detailed location information.
+    
+    This tool automatically segments lesion regions and returns:
+    - Lesion locations (coordinates)
+    - Lesion sizes (pixel counts)
+    - Lesion area percentage
+    - Visual description of lesion distribution
+    
+    Parameters:
+    - image_data: Input medical image as 2D array (list of lists).
+    - method: Segmentation method - "otsu" for automatic thresholding (default) or "manual" for manual threshold.
+    - min_size: Minimum lesion size in pixels to filter noise (default: 10).
+    
+    Returns:
+    - dict: Contains detailed lesion information including locations, sizes, and distribution.
+    """
+    try:
+        image_array = np.asarray(image_data)
+        
+        # Step 1: Apply Otsu thresholding to detect lesion regions
+        threshold = otsu(image_array)
+        binary_result = (image_array >= threshold).astype(int)
+        
+        # Step 2: Find lesion regions (connected components)
+        lesion_mask = binary_result.astype(bool)
+        
+        # Step 3: Calculate lesion statistics
+        total_pixels = lesion_mask.size
+        lesion_pixels = np.sum(lesion_mask)
+        background_pixels = total_pixels - lesion_pixels
+        lesion_percentage = (lesion_pixels / total_pixels * 100) if total_pixels > 0 else 0
+        
+        # Step 4: Find lesion boundaries and bounding boxes
+        lesion_coords = []
+        lesion_info = []
+        
+        if np.any(lesion_mask):
+            # Find all connected components
+            if ndimage is not None:
+                labeled, num_features = ndimage.label(lesion_mask)
+            else:
+                # Fallback: use simple detection without connected components
+                num_features = 1 if np.any(lesion_mask) else 0
+                labeled = lesion_mask.astype(int)
+            
+            for label in range(1, num_features + 1):
+                # Get coordinates of this lesion
+                lesion_indices = np.where(labeled == label)
+                coords = list(zip(lesion_indices[0], lesion_indices[1]))
+                lesion_coords.append(coords)
+                
+                # Calculate bounding box
+                if coords:
+                    rows = [c[0] for c in coords]
+                    cols = [c[1] for c in coords]
+                    min_row, max_row = min(rows), max(rows)
+                    min_col, max_col = min(cols), max(cols)
+                    
+                    lesion_info.append({
+                        "id": label,
+                        "pixel_count": len(coords),
+                        "top_left": [int(min_row), int(min_col)],
+                        "bottom_right": [int(max_row), int(max_col)],
+                        "width": int(max_col - min_col + 1),
+                        "height": int(max_row - min_row + 1),
+                        "area_percentage": (len(coords) / total_pixels * 100)
+                    })
+            
+            # Filter by min_size
+            lesion_info = [lesion for lesion in lesion_info if lesion["pixel_count"] >= min_size]
+            
+            # Find largest lesion
+            if lesion_info:
+                largest_lesion = max(lesion_info, key=lambda x: x["pixel_count"])
+                lesion_description = f"检测到 {len(lesion_info)} 个病变区域。最大病变位于: 行{largest_lesion['top_left'][0]}-{largest_lesion['bottom_right'][0]}, 列{largest_lesion['top_left'][1]}-{largest_lesion['bottom_right'][1]}, 面积为 {largest_lesion['area_percentage']:.2f}%"
+            else:
+                lesion_description = "未检测到符合尺寸要求的病变区域"
+        else:
+            lesion_description = "未检测到病变区域"
+        
+        # Step 5: Calculate intensity statistics for lesion vs background
+        lesion_intensities = image_array[lesion_mask]
+        background_intensities = image_array[~lesion_mask]
+        
+        result = {
+            "success": True,
+            "result": {
+                "detection_summary": lesion_description,
+                "total_lesions": len(lesion_info),
+                "lesion_details": lesion_info,
+                "statistics": {
+                    "total_pixels": int(total_pixels),
+                    "lesion_pixels": int(lesion_pixels),
+                    "background_pixels": int(background_pixels),
+                    "lesion_percentage": round(lesion_percentage, 2),
+                    "threshold_used": round(float(threshold), 4),
+                    "lesion_intensity_range": {
+                        "min": float(np.min(lesion_intensities)) if len(lesion_intensities) > 0 else 0,
+                        "max": float(np.max(lesion_intensities)) if len(lesion_intensities) > 0 else 0,
+                        "mean": float(np.mean(lesion_intensities)) if len(lesion_intensities) > 0 else 0
+                    },
+                    "background_intensity_range": {
+                        "min": float(np.min(background_intensities)) if len(background_intensities) > 0 else 0,
+                        "max": float(np.max(background_intensities)) if len(background_intensities) > 0 else 0,
+                        "mean": float(np.mean(background_intensities)) if len(background_intensities) > 0 else 0
+                    }
+                },
+                "binary_mask": binary_result.tolist()
+            },
+            "error": None
+        }
+        
+        return result
+        
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
 @mcp.tool(name="gaussian_gradient_magnitude", description="Compute Gaussian gradient magnitude of image.")
 def gaussian_gradient_magnitude_tool(image_data: list, sigma: float = 1.0) -> dict:
     """