Update app.py

app.py

@@ -1,97 +1,102 @@
-import gradio as gr
-import pydicom
-import numpy as np
 import cv2
+import numpy as np
 import pandas as pd
+import pydicom
+import gradio as gr
+import os
 
-def load_dicom(file):
-    """Load a DICOM file and extract pixel data with rescale slope and intercept applied."""
-    dicom_data = pydicom.dcmread(file)
+# Global variables to mimic the local functionality
+results = []
+image_display = None
+circle_diameter = 9
+zoom_factor = 1.0
+
+# Function to load DICOM files
+def load_dicom(file_path):
+    dicom_data = pydicom.dcmread(file_path)
     image = dicom_data.pixel_array.astype(np.float32)
-    rescale_slope = getattr(dicom_data, "RescaleSlope", 1)
-    rescale_intercept = getattr(dicom_data, "RescaleIntercept", 0)
+    rescale_slope = getattr(dicom_data, 'RescaleSlope', 1)
+    rescale_intercept = getattr(dicom_data, 'RescaleIntercept', 0)
     image = (image * rescale_slope) + rescale_intercept
-    pixel_spacing = getattr(dicom_data, "PixelSpacing", [1, 1])
-    return image, pixel_spacing
+    pixel_spacing = dicom_data.PixelSpacing
+    return image, dicom_data, pixel_spacing
+
+# Function to analyze ROI
+def analyze_roi(image, pixel_spacing, x, y, circle_diameter):
+    mask = np.zeros_like(image, dtype=np.uint8)
+    y_indices, x_indices = np.ogrid[:image.shape[0], :image.shape[1]]
+    distance_from_center = np.sqrt((x_indices - x)**2 + (y_indices - y)**2)
+    mask[distance_from_center <= circle_diameter / 2] = 1
+    pixels = image[mask == 1]
 
-def analyze_dicom(file, circle_diameter):
-    """
-    Analyze the DICOM file:
-    - Load image and pixel spacing
-    - Display the image
-    - Analyze a circular region of interest
-    """
-    try:
-        # Load DICOM file
-        image, pixel_spacing = load_dicom(file)
-        pixel_size_mm = float(pixel_spacing[0])  # Assuming square pixels
-        
-        # Normalize image for display
-        image_display = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
-        
-        # Convert to RGB for overlay purposes
-        image_rgb = cv2.cvtColor(image_display, cv2.COLOR_GRAY2RGB)
+    # Calculate metrics
+    area_mm2 = np.sum(mask) * (float(pixel_spacing[0])**2)
+    mean = np.mean(pixels)
+    stddev = np.std(pixels)
+    min_val = np.min(pixels)
+    max_val = np.max(pixels)
 
-        # Analyze center of the image as a circular ROI
-        h, w = image.shape
-        center_x, center_y = w // 2, h // 2
+    return {
+        "Area (mm²)": f"{area_mm2:.3f}",
+        "Mean": f"{mean:.3f}",
+        "StdDev": f"{stddev:.3f}",
+        "Min": f"{min_val:.3f}",
+        "Max": f"{max_val:.3f}"
+    }
 
-        # Create a circular mask
-        mask = np.zeros_like(image, dtype=np.uint8)
-        y_indices, x_indices = np.ogrid[:image.shape[0], :image.shape[1]]
-        distance_from_center = np.sqrt((x_indices - center_x) ** 2 + (y_indices - center_y) ** 2)
-        mask[distance_from_center <= circle_diameter / 2] = 1
+# Gradio callback function to simulate the local analyzer
+def process_image(file, x, y, zoom, diameter):
+    global results, image_display, circle_diameter, zoom_factor
 
-        # Extract pixel values within the circle
-        pixels = image[mask == 1]
+    # Load the DICOM image
+    image, dicom_data, pixel_spacing = load_dicom(file.name)
+    image_display = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+    
+    # Adjust zoom and diameter
+    zoom_factor = float(zoom)
+    circle_diameter = int(diameter)
 
-        # Calculate metrics
-        area_pixels = np.sum(mask)
-        area_mm2 = area_pixels * (pixel_size_mm**2)
-        mean = np.mean(pixels)
-        stddev = np.std(pixels)
-        min_val = np.min(pixels)
-        max_val = np.max(pixels)
+    # Analyze the clicked point
+    x_original = int(float(x) / zoom_factor)
+    y_original = int(float(y) / zoom_factor)
+    analysis_result = analyze_roi(image, pixel_spacing, x_original, y_original, circle_diameter)
 
-        # Save the result
-        results = {
-            "Area (mm²)": f"{area_mm2:.3f}",
-            "Mean Intensity": f"{mean:.3f}",
-            "Standard Deviation": f"{stddev:.3f}",
-            "Minimum Intensity": f"{min_val:.3f}",
-            "Maximum Intensity": f"{max_val:.3f}",
-        }
+    # Append to results
+    results.append(analysis_result)
+    return analysis_result
 
-        # Draw the circle on the image
-        cv2.circle(image_rgb, (center_x, center_y), int(circle_diameter / 2), (0, 255, 0), 2)
-        
-        # Convert the image back to BGR for display
-        annotated_image = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR)
+# Gradio app definition
+def reset_results():
+    global results
+    results = []
+    return "Results cleared!"
 
-        return annotated_image, pd.DataFrame([results]).to_csv(index=False)
-    except Exception as e:
-        return None, f"Error: {str(e)}"
+with gr.Blocks() as app:
+    gr.Markdown("## DICOM Analyzer - Matches Local Features")
+    
+    with gr.Row():
+        file_input = gr.File(label="Upload DICOM File", type="filepath")
+        x_input = gr.Number(label="X Coordinate (px)", value=50)
+        y_input = gr.Number(label="Y Coordinate (px)", value=50)
+        zoom_input = gr.Number(label="Zoom Factor", value=1.0)
+        diameter_input = gr.Number(label="Circle Diameter (px)", value=9)
+    
+    output_text = gr.Textbox(label="Analysis Results")
+    clear_button = gr.Button("Clear Results")
 
-# Define the Gradio interface
-inputs = [
-    gr.File(label="Upload DICOM File (.IMA or .dcm)", type="filepath"),
-    gr.Number(label="Circle Diameter (in pixels)", value=50, precision=1),
-]
+    with gr.Row():
+        analyze_button = gr.Button("Analyze")
+        reset_button = gr.Button("Reset")
 
-outputs = [
-    gr.Image(label="Annotated DICOM Image"),
-    gr.File(label="Analysis Results (CSV)"),
-]
+    analyze_button.click(
+        process_image,
+        inputs=[file_input, x_input, y_input, zoom_input, diameter_input],
+        outputs=output_text
+    )
+    
+    reset_button.click(
+        reset_results,
+        outputs=output_text
+    )
 
-# Launch the app
-gr.Interface(
-    fn=analyze_dicom,
-    inputs=inputs,
-    outputs=outputs,
-    title="DICOM Analyzer Tool",
-    description=(
-        "Upload a DICOM file and analyze a circular region of interest (ROI). "
-        "The tool calculates metrics such as mean intensity, standard deviation, and area in mm²."
-    ),
-    theme="compact",
-).launch()
+app.launch()