Create app.py

app.py

@@ -0,0 +1,370 @@
+import gradio as gr
+import cv2
+import numpy as np
+import pandas as pd
+import pydicom
+import io
+from PIL import Image
+
+class DicomAnalyzer:
+    def __init__(self):
+        self.results = []
+        self.circle_diameter = 9
+        self.zoom_factor = 1.0
+        self.current_image = None
+        self.dicom_data = None
+        self.display_image = None
+        self.marks = []  # Store (x, y, diameter) for each mark
+        self.original_image = None
+        self.original_display = None
+        # Pan position
+        self.pan_x = 0
+        self.pan_y = 0
+        self.max_pan_x = 0
+        self.max_pan_y = 0
+
+    def load_dicom(self, file):
+        try:
+            if file is None:
+                return None, "No file uploaded"
+            
+            if hasattr(file, 'name'):
+                dicom_data = pydicom.dcmread(file.name)
+            else:
+                dicom_data = pydicom.dcmread(file)
+                
+            image = dicom_data.pixel_array.astype(np.float32)
+            
+            rescale_slope = getattr(dicom_data, 'RescaleSlope', 1)
+            rescale_intercept = getattr(dicom_data, 'RescaleIntercept', 0)
+            image = (image * rescale_slope) + rescale_intercept
+            
+            self.current_image = image
+            self.original_image = image.copy()
+            self.dicom_data = dicom_data
+            
+            self.display_image = self.normalize_image(image)
+            self.original_display = self.display_image.copy()
+            
+            # Reset view on new image
+            self.reset_view()
+            
+            return self.display_image, "DICOM file loaded successfully"
+        except Exception as e:
+            return None, f"Error loading DICOM file: {str(e)}"
+
+    def normalize_image(self, image):
+        try:
+            normalized = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+            if len(normalized.shape) == 2:
+                normalized = cv2.cvtColor(normalized, cv2.COLOR_GRAY2RGB)
+            return normalized
+        except Exception as e:
+            print(f"Error normalizing image: {str(e)}")
+            return None
+
+    def reset_view(self):
+        """Reset zoom and center the image"""
+        self.zoom_factor = 1.0
+        self.pan_x = 0
+        self.pan_y = 0
+        if self.original_display is not None:
+            return self.update_display()
+        return None
+
+    def update_display(self):
+        """Update display with current zoom and pan"""
+        try:
+            if self.original_display is None:
+                return None
+
+            # Calculate zoomed size
+            height, width = self.original_display.shape[:2]
+            new_height = int(height * self.zoom_factor)
+            new_width = int(width * self.zoom_factor)
+
+            # Update max pan values
+            self.max_pan_x = max(0, new_width - width)
+            self.max_pan_y = max(0, new_height - height)
+
+            # Create zoomed image
+            zoomed = cv2.resize(self.original_display, (new_width, new_height), 
+                              interpolation=cv2.INTER_CUBIC)
+
+            # Draw marks
+            for x, y, diameter in self.marks:
+                display_x = int(x * self.zoom_factor - self.pan_x)
+                display_y = int(y * self.zoom_factor - self.pan_y)
+                display_diameter = int(diameter * self.zoom_factor)
+                
+                # Only draw if mark is in view
+                if (0 <= display_x < new_width and 0 <= display_y < new_height):
+                    cv2.circle(zoomed,
+                             (display_x, display_y),
+                             display_diameter // 2,
+                             (0, 255, 255),  # Yellow in BGR
+                             1,
+                             lineType=cv2.LINE_AA)
+
+            # Extract visible portion
+            visible = zoomed[
+                self.pan_y:self.pan_y + height,
+                self.pan_x:self.pan_x + width
+            ]
+
+            return visible
+        except Exception as e:
+            print(f"Error updating display: {str(e)}")
+            return self.original_display
+
+    def handle_keyboard(self, key):
+        """Handle keyboard inputs for pan"""
+        try:
+            # Pan amount depends on zoom level
+            pan_amount = int(20 / self.zoom_factor)
+            
+            if key == 'ArrowLeft':
+                self.pan_x = max(0, self.pan_x - pan_amount)
+            elif key == 'ArrowRight':
+                self.pan_x = min(self.max_pan_x, self.pan_x + pan_amount)
+            elif key == 'ArrowUp':
+                self.pan_y = max(0, self.pan_y - pan_amount)
+            elif key == 'ArrowDown':
+                self.pan_y = min(self.max_pan_y, self.pan_y + pan_amount)
+            
+            return self.update_display()
+        except Exception as e:
+            print(f"Error handling keyboard input: {str(e)}")
+            return self.display_image
+
+    def analyze_roi(self, evt: gr.SelectData):
+        try:
+            if self.current_image is None:
+                return None, "No image loaded"
+
+            # Convert clicked coordinates to original image coordinates
+            x = int((evt.index[0] + self.pan_x) / self.zoom_factor)
+            y = int((evt.index[1] + self.pan_y) / self.zoom_factor)
+
+            mask = np.zeros_like(self.current_image, dtype=np.uint8)
+            y_indices, x_indices = np.ogrid[:self.current_image.shape[0], :self.current_image.shape[1]]
+            distance_from_center = np.sqrt((x_indices - x) ** 2 + (y_indices - y) ** 2)
+            mask[distance_from_center <= self.circle_diameter / 2] = 1
+
+            roi_pixels = self.current_image[mask == 1]
+
+            pixel_spacing = float(self.dicom_data.PixelSpacing[0])
+            area_pixels = np.sum(mask)
+            area_mm2 = area_pixels * (pixel_spacing ** 2)
+            mean = np.mean(roi_pixels)
+            stddev = np.std(roi_pixels)
+            min_val = np.min(roi_pixels)
+            max_val = np.max(roi_pixels)
+
+            result = {
+                'Area (mm²)': f"{area_mm2:.3f}",
+                'Mean': f"{mean:.3f}",
+                'StdDev': f"{stddev:.3f}",
+                'Min': f"{min_val:.3f}",
+                'Max': f"{max_val:.3f}",
+                'Point': f"({x}, {y})"
+            }
+            self.results.append(result)
+            self.marks.append((x, y, self.circle_diameter))
+
+            return self.update_display(), self.format_results()
+        except Exception as e:
+            print(f"Error analyzing ROI: {str(e)}")
+            return self.display_image, f"Error analyzing ROI: {str(e)}"
+
+    def update_zoom(self, zoom_factor, image):
+        try:
+            if self.original_display is None:
+                return image
+
+            self.zoom_factor = zoom_factor
+            return self.update_display()
+        except Exception as e:
+            print(f"Error updating zoom: {str(e)}")
+            return image
+
+    def format_results(self):
+        if not self.results:
+            return "No measurements yet"
+        df = pd.DataFrame(self.results)
+        columns_order = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
+        df = df[columns_order]
+        return df.to_string(index=False)
+
+    def add_blank_row(self, image):
+        self.results.append({
+            'Area (mm²)': '',
+            'Mean': '',
+            'StdDev': '',
+            'Min': '',
+            'Max': '',
+            'Point': ''
+        })
+        return image, self.format_results()
+
+    def add_zero_row(self, image):
+        self.results.append({
+            'Area (mm²)': '0.000',
+            'Mean': '0.000',
+            'StdDev': '0.000',
+            'Min': '0.000',
+            'Max': '0.000',
+            'Point': '(0, 0)'
+        })
+        return image, self.format_results()
+
+    def undo_last(self, image):
+        if self.results:
+            self.results.pop()
+        if self.marks:
+            self.marks.pop()
+        return self.update_display(), self.format_results()
+
+    def save_results(self):
+        try:
+            if not self.results:
+                return None, "No results to save"
+            
+            df = pd.DataFrame(self.results)
+            columns_order = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
+            df = df[columns_order]
+            
+            temp_file = "analysis_results.xlsx"
+            df.to_excel(temp_file, index=False)
+            
+            return temp_file, "Results saved successfully"
+        except Exception as e:
+            return None, f"Error saving results: {str(e)}"
+
+def create_interface():
+    analyzer = DicomAnalyzer()
+    
+    with gr.Blocks(css="#image_display { outline: none; }") as interface:
+        gr.Markdown("# DICOM Image Analyzer")
+        
+        with gr.Row():
+            with gr.Column():
+                file_input = gr.File(label="Upload DICOM file")
+                diameter_slider = gr.Slider(
+                    minimum=1,
+                    maximum=20,
+                    value=9,
+                    step=1,
+                    label="ROI Diameter (pixels)"
+                )
+                zoom_slider = gr.Slider(
+                    minimum=1.0,
+                    maximum=20.0,
+                    value=1.0,
+                    step=0.5,
+                    label="Zoom Factor"
+                )
+                reset_btn = gr.Button("Reset View")
+                
+            with gr.Column():
+                image_display = gr.Image(label="DICOM Image", interactive=True, elem_id="image_display")
+                
+        with gr.Row():
+            blank_btn = gr.Button("Add Blank Row")
+            zero_btn = gr.Button("Add Zero Row")
+            undo_btn = gr.Button("Undo Last")
+            save_btn = gr.Button("Save Results")
+            
+        results_display = gr.Textbox(label="Results", interactive=False)
+        file_output = gr.File(label="Download Results")
+        key_press = gr.Textbox(visible=False)  # Hidden textbox for keyboard events
+        
+        # Instructions
+        gr.Markdown("""
+        ### Controls:
+        - Use arrow keys to pan when zoomed in
+        - Click points to measure
+        - Press 'Reset View' to center image and reset zoom
+        """)
+        
+        def update_diameter(x):
+            analyzer.circle_diameter = x
+            return f"Diameter set to {x} pixels"
+
+        # Event handlers
+        file_input.change(
+            fn=analyzer.load_dicom,
+            inputs=file_input,
+            outputs=[image_display, results_display]
+        )
+        
+        image_display.select(
+            fn=analyzer.analyze_roi,
+            outputs=[image_display, results_display]
+        )
+        
+        diameter_slider.change(
+            fn=update_diameter,
+            inputs=diameter_slider,
+            outputs=gr.Textbox(label="Status")
+        )
+        
+        zoom_slider.change(
+            fn=analyzer.update_zoom,
+            inputs=[zoom_slider, image_display],
+            outputs=image_display
+        )
+        
+        reset_btn.click(
+            fn=analyzer.reset_view,
+            outputs=image_display
+        )
+        
+        key_press.change(
+            fn=analyzer.handle_keyboard,
+            inputs=[key_press],
+            outputs=[image_display]
+        )
+        
+        blank_btn.click(
+            fn=analyzer.add_blank_row,
+            inputs=image_display,
+            outputs=[image_display, results_display]
+        )
+        
+        zero_btn.click(
+            fn=analyzer.add_zero_row,
+            inputs=image_display,
+            outputs=[image_display, results_display]
+        )
+        
+        undo_btn.click(
+            fn=analyzer.undo_last,
+            inputs=image_display,
+            outputs=[image_display, results_display]
+        )
+        
+        save_btn.click(
+            fn=analyzer.save_results,
+            outputs=[file_output, results_display]
+        )
+
+        # Add JavaScript for keyboard handling
+        gr.HTML("""
+        <script>
+        function handleKey(e) {
+            if (['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'].includes(e.key)) {
+                e.preventDefault();
+                document.querySelector('#key_press textarea').value = e.key;
+                document.querySelector('#key_press textarea').dispatchEvent(new Event('input'));
+            }
+        }
+        document.addEventListener('keydown', handleKey);
+        </script>
+        """)
+    
+    return interface
+
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch()