Update App.py

App.py

@@ -1,219 +1,306 @@
-import gradio as gr
-import cv2
-import numpy as np
-import pandas as pd
-import pydicom
-import tempfile
-import os
-
-class DicomAnalyzer:
-    def __init__(self):
-        self.results = []
-        self.current_image1 = None
-        self.image_display1 = None
-        self.dicom_data1 = None
-        self.marks1 = []  # Store (x, y, diameter) for each circle
-
-    def load_dicom(self, file):
-        try:
-            if file is None:
-                return None, None, None
-
-            dicom_data = pydicom.dcmread(file.name)
-            image = dicom_data.pixel_array.astype(np.float32)
-
-            # Apply rescale slope and intercept
-            rescale_slope = getattr(dicom_data, 'RescaleSlope', 1)
-            rescale_intercept = getattr(dicom_data, 'RescaleIntercept', 0)
-            image = (image * rescale_slope) + rescale_intercept
-
-            # Store original image for analysis
-            original_image = image.copy()
-
-            # Normalize for display
-            image_display = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
-
-            # Convert to BGR for visualization
-            if len(image_display.shape) == 2:
-                image_display = cv2.cvtColor(image_display, cv2.COLOR_GRAY2BGR)
-
-            return original_image, image_display, dicom_data
-        except Exception as e:
-            print(f"Error loading DICOM file: {str(e)}")
-            return None, None, None
-
-    def analyze_point(self, image, dicom_data, x, y, diameter):
-        try:
-            # 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 - x)**2 + (y_indices - y)**2)
-            mask[distance_from_center <= diameter / 2] = 1
-
-            # Extract pixel values within the circle
-            pixels = image[mask == 1]
-
-            # Calculate metrics
-            area_pixels = np.sum(mask)
-            pixel_spacing = float(dicom_data.PixelSpacing[0])
-            area_mm2 = area_pixels * (pixel_spacing**2)
-            mean = np.mean(pixels)
-            stddev = np.std(pixels)
-            min_val = np.min(pixels)
-            max_val = np.max(pixels)
-
-            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}"
-            }
-        except Exception as e:
-            print(f"Error analyzing point: {str(e)}")
-            return None
-
-    def draw_circle(self, image, marks):
-        try:
-            image_copy = image.copy()
-
-            # Draw all marks using their stored diameters
-            for mark_x, mark_y, diameter in marks:
-                cv2.circle(image_copy, 
-                          (int(mark_x), int(mark_y)), 
-                          int(diameter / 2), 
-                          (255, 255, 0), 1,  # Yellow outer ring (thin)
-                          lineType=cv2.LINE_AA)
-                cv2.circle(image_copy,
-                          (int(mark_x), int(mark_y)),
-                          int(diameter / 2) - 1,
-                          (255, 255, 255), 1,  # White inner ring (thin)
-                          lineType=cv2.LINE_AA)
-
-            return image_copy
-        except Exception as e:
-            print(f"Error drawing circle: {str(e)}")
-            return image
-
-    def process_image(self, file):
-        image, image_display, dicom_data = self.load_dicom(file)
-        self.current_image1 = image
-        self.image_display1 = image_display
-        self.dicom_data1 = dicom_data
-        return image_display
-
-    def handle_click(self, evt: gr.SelectData, marks, diameter):
-        if self.current_image1 is None:
-            return self.image_display1, "Please load an image first"
-
-        try:
-            x, y = evt.index
-            marks.append((x, y, diameter))  # Store the diameter with the mark
-            marked_image = self.draw_circle(self.image_display1, marks)
-            self.image_display1 = marked_image
-
-            results = self.analyze_point(self.current_image1, self.dicom_data1, x, y, diameter)
-            if results:
-                results['Point'] = f"({x}, {y})"
-                self.results.append(results)
-
-            return self.image_display1, self.format_results()
-        except Exception as e:
-            print(f"Error in handle_click: {str(e)}")
-            return self.image_display1, f"Error: {str(e)}"
-
-    def format_results(self):
-        if not self.results:
-            return "No results yet"
-        df = pd.DataFrame(self.results)
-        return df.to_string()
-
-    def clear_results(self):
-        self.results = []
-        self.marks1 = []  # Clear all marks
-        if self.current_image1 is not None:
-            self.image_display1 = cv2.cvtColor(
-                cv2.normalize(self.current_image1, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8),
-                cv2.COLOR_GRAY2BGR
-            )
-        return "Results cleared", self.image_display1
-
-    def save_results(self):
-        try:
-            if not self.results:
-                return None, "No results to save"
-
-            df = pd.DataFrame(self.results)
-
-            # Create temporary file
-            temp_dir = tempfile.gettempdir()
-            temp_file = os.path.join(temp_dir, "analysis_results.xlsx")
-
-            # Save to Excel
-            df.to_excel(temp_file, index=False, engine='openpyxl')
-
-            return temp_file, "Results saved successfully. Click to download."
-        except Exception as e:
-            print(f"Error saving results: {str(e)}")
-            return None, f"Error saving results: {str(e)}"
-
-def create_interface():
-    analyzer = DicomAnalyzer()
-
-    with gr.Blocks() as interface:
-        gr.Markdown("# CT DICOM Image Analyzer")
-
-        # Session-specific states
-        circle_diameter_state = gr.State(9)
-        marks_state = gr.State([])
-
-        with gr.Row():
-            file1 = gr.File(label="Upload DICOM file")
-            image1 = gr.Image(label="DICOM Image", interactive=True, type="numpy")
-            file1.change(fn=analyzer.process_image, inputs=file1, outputs=image1)
-
-        with gr.Row():
-            circle_diameter = gr.Slider(
-                minimum=1, 
-                maximum=20, 
-                value=9, 
-                step=1, 
-                label="Circle Diameter"
-            )
-
-        with gr.Row():
-            clear_btn = gr.Button("Clear Results")
-            save_btn = gr.Button("Save Results")
-
-        results = gr.Textbox(label="Results", interactive=False)
-        file_output = gr.File(label="Download Results")
-        status = gr.Textbox(label="Status")
-
-        # Connect events
-        circle_diameter.change(
-            fn=lambda value: value,
-            inputs=circle_diameter,
-            outputs=circle_diameter_state
-        )
-
-        image1.select(
-            fn=analyzer.handle_click,
-            inputs=[marks_state, circle_diameter_state],
-            outputs=[image1, results]
-        )
-
-        clear_btn.click(
-            fn=analyzer.clear_results,
-            outputs=[status, image1]
-        )
-
-        save_btn.click(
-            fn=analyzer.save_results,
-            outputs=[file_output, status]
-        )
-
-    return interface
-
-if __name__ == "__main__":
-    interface = create_interface()
-    interface.launch()
+import gradio as gr
+import cv2
+import numpy as np
+import pandas as pd
+import pydicom
+import tempfile
+import os
+
+class DicomAnalyzer:
+    def __init__(self):
+        self.results = []
+        self.circle_diameter = 9
+        self.current_image1 = None
+        self.image_display1 = None
+        self.dicom_data1 = None
+        self.marks1 = []
+        self.zoom_factor = 1.0
+        self.offset_x = 0
+        self.offset_y = 0
+
+    def load_dicom(self, file):
+        try:
+            if file is None:
+                return None, None, None
+
+            dicom_data = pydicom.dcmread(file.name)
+            image = dicom_data.pixel_array.astype(np.float32)
+
+            # Apply rescale slope and intercept
+            rescale_slope = getattr(dicom_data, 'RescaleSlope', 1)
+            rescale_intercept = getattr(dicom_data, 'RescaleIntercept', 0)
+            image = (image * rescale_slope) + rescale_intercept
+
+            # Store original image for analysis
+            original_image = image.copy()
+
+            # Normalize for display
+            image_display = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+
+            # Convert to BGR for visualization
+            if len(image_display.shape) == 2:
+                image_display = cv2.cvtColor(image_display, cv2.COLOR_GRAY2BGR)
+
+            return original_image, image_display, dicom_data
+        except Exception as e:
+            print(f"Error loading DICOM file: {str(e)}")
+            return None, None, None
+
+    def analyze_point(self, image, dicom_data, x, y):
+        try:
+            # Map coordinates to original image
+            x = int((x - self.offset_x) / self.zoom_factor)
+            y = int((y - self.offset_y) / self.zoom_factor)
+
+            # 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 - x)**2 + (y_indices - y)**2)
+            mask[distance_from_center <= self.circle_diameter / 2] = 1
+
+            # Extract pixel values within the circle
+            pixels = image[mask == 1]
+
+            # Calculate metrics
+            area_pixels = np.sum(mask)
+            pixel_spacing = float(dicom_data.PixelSpacing[0])
+            area_mm2 = area_pixels * (pixel_spacing**2)
+            mean = np.mean(pixels)
+            stddev = np.std(pixels)
+            min_val = np.min(pixels)
+            max_val = np.max(pixels)
+
+            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}"
+            }
+        except Exception as e:
+            print(f"Error analyzing point: {str(e)}")
+            return None
+
+    def draw_circle(self, image, x, y):
+        try:
+            image_copy = image.copy()
+
+            # Map coordinates to original image
+            x = int((x - self.offset_x) / self.zoom_factor)
+            y = int((y - self.offset_y) / self.zoom_factor)
+
+            # Draw all previous marks
+            for mark_x, mark_y in self.marks1:
+                cv2.circle(image_copy, 
+                          (int(mark_x * self.zoom_factor + self.offset_x), int(mark_y * self.zoom_factor + self.offset_y)), 
+                          int(self.circle_diameter / 2 * self.zoom_factor), 
+                          (255, 255, 0), 1,  # Thinner yellow outline
+                          lineType=cv2.LINE_AA)
+
+            # Draw the new mark
+            cv2.circle(image_copy, 
+                      (int(x * self.zoom_factor + self.offset_x), int(y * self.zoom_factor + self.offset_y)), 
+                      int(self.circle_diameter / 2 * self.zoom_factor), 
+                      (255, 255, 0), 1,  # Thinner yellow outline
+                      lineType=cv2.LINE_AA)
+
+            # Store the new mark
+            self.marks1.append((x, y))
+
+            return image_copy
+        except Exception as e:
+            print(f"Error drawing circle: {str(e)}")
+            return image
+
+    def process_image(self, file):
+        image, image_display, dicom_data = self.load_dicom(file)
+        self.current_image1 = image
+        self.image_display1 = image_display
+        self.dicom_data1 = dicom_data
+        return image_display
+
+    def handle_click(self, evt: gr.SelectData):
+        if self.current_image1 is None:
+            return self.image_display1, "Please load an image first"
+
+        try:
+            x, y = evt.index
+            marked_image = self.draw_circle(self.image_display1, x, y)
+            self.image_display1 = marked_image
+
+            results = self.analyze_point(self.current_image1, self.dicom_data1, x, y)
+            if results:
+                results['Point'] = f"({x}, {y})"
+                self.results.append(results)
+
+            return self.image_display1, self.format_results()
+        except Exception as e:
+            print(f"Error in handle_click: {str(e)}")
+            return self.image_display1, f"Error: {str(e)}"
+
+    def format_results(self):
+        if not self.results:
+            return "No results yet"
+        df = pd.DataFrame(self.results)
+        return df.to_string()
+
+    def clear_results(self):
+        self.results = []
+        self.marks1 = []
+        if self.current_image1 is not None:
+            self.image_display1 = cv2.cvtColor(
+                cv2.normalize(self.current_image1, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8),
+                cv2.COLOR_GRAY2BGR
+            )
+        return "Results cleared", self.image_display1
+
+    def add_blank_row(self):
+        self.results.append({
+            'Point': '',
+            'Area (mm²)': '',
+            'Mean': '',
+            'StdDev': '',
+            'Min': '',
+            'Max': ''
+        })
+        return self.format_results()
+
+    def add_zero_row(self):
+        self.results.append({
+            'Point': '0',
+            'Area (mm²)': '0',
+            'Mean': '0',
+            'StdDev': '0',
+            'Min': '0',
+            'Max': '0'
+        })
+        return self.format_results()
+
+    def undo_last_action(self):
+        if self.results:
+            self.results.pop()
+        if self.marks1:
+            self.marks1.pop()
+        return self.format_results()
+
+    def update_circle_diameter(self, value):
+        self.circle_diameter = value
+        return f"Circle diameter set to {value}"
+
+    def update_zoom(self, zoom_factor):
+        self.zoom_factor = zoom_factor
+        if self.current_image1 is not None:
+            height, width = self.current_image1.shape
+            resized = cv2.resize(self.image_display1, None, fx=self.zoom_factor, fy=self.zoom_factor, interpolation=cv2.INTER_LINEAR)
+            self.offset_x = (resized.shape[1] - width * self.zoom_factor) // 2
+            self.offset_y = (resized.shape[0] - height * self.zoom_factor) // 2
+            return resized
+        return self.image_display1
+
+    def save_results(self):
+        try:
+            if not self.results:
+                return None, "No results to save"
+
+            df = pd.DataFrame(self.results)
+
+            # Create temporary file
+            temp_dir = tempfile.gettempdir()
+            temp_file = os.path.join(temp_dir, "analysis_results.xlsx")
+
+            # Save to Excel
+            df.to_excel(temp_file, index=False, engine='openpyxl')
+
+            return temp_file, "Results saved successfully. Click to download."
+        except Exception as e:
+            print(f"Error saving results: {str(e)}")
+            return None, f"Error saving results: {str(e)}"
+
+def create_interface():
+    analyzer = DicomAnalyzer()
+
+    with gr.Blocks() as interface:
+        gr.Markdown("# CT DICOM Image Analyzer")
+
+        with gr.Row():
+            with gr.Column():
+                file1 = gr.File(label="Upload DICOM file")
+                image1 = gr.Image(label="DICOM Image", interactive=True, type="numpy")
+                file1.change(fn=analyzer.process_image, inputs=file1, outputs=image1)
+
+        with gr.Row():
+            circle_diameter = gr.Slider(
+                minimum=1, 
+                maximum=20, 
+                value=9, 
+                step=1, 
+                label="Circle Diameter"
+            )
+
+            zoom_slider = gr.Slider(
+                minimum=1.0, 
+                maximum=5.0, 
+                value=1.0, 
+                step=0.1, 
+                label="Zoom Factor"
+            )
+
+        with gr.Row():
+            clear_btn = gr.Button("Clear Results")
+            blank_row_btn = gr.Button("Add Blank Row")
+            zero_row_btn = gr.Button("Add '0' Row")
+            undo_btn = gr.Button("Undo Last Action")
+            save_btn = gr.Button("Save Results")
+
+        results = gr.Textbox(label="Results", interactive=False)
+        file_output = gr.File(label="Download Results")
+        status = gr.Textbox(label="Status")
+
+        # Connect events
+        circle_diameter.change(
+            fn=analyzer.update_circle_diameter, 
+            inputs=circle_diameter, 
+            outputs=status
+        )
+
+        zoom_slider.change(
+            fn=analyzer.update_zoom,
+            inputs=zoom_slider,
+            outputs=image1
+        )
+
+        image1.select(
+            fn=analyzer.handle_click, 
+            outputs=[image1, results]
+        )
+
+        clear_btn.click(
+            fn=analyzer.clear_results, 
+            outputs=[status, image1]
+        )
+
+        blank_row_btn.click(
+            fn=analyzer.add_blank_row, 
+            outputs=results
+        )
+
+        zero_row_btn.click(
+            fn=analyzer.add_zero_row, 
+            outputs=results
+        )
+
+        undo_btn.click(
+            fn=analyzer.undo_last_action, 
+            outputs=results
+        )
+
+        save_btn.click(
+            fn=analyzer.save_results, 
+            outputs=[file_output, status]
+        )
+
+    return interface
+
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch()