Update app.py

app.py

@@ -2,7 +2,6 @@ import gradio as gr
 import numpy as np
 import cv2
 from PIL import Image
-import io
 import matplotlib.pyplot as plt
 
 def extract_frames(gif_path):
@@ -22,27 +21,44 @@ def extract_frames(gif_path):
         return None, f"Error loading GIF: {str(e)}"
 
 def preprocess_frame(frame):
-    """Preprocess a frame: apply Gaussian blur to reduce noise."""
-    return cv2.GaussianBlur(frame, (5, 5), 0)
+    """Preprocess a frame: apply Gaussian blur and adaptive thresholding."""
+    # Apply Gaussian blur to reduce noise
+    blurred = cv2.GaussianBlur(frame, (9, 9), 0)
+    # Adaptive thresholding to enhance lighter regions (CME features)
+    thresh = cv2.adaptiveThreshold(
+        blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2
+    )
+    return thresh
 
-def detect_circles(frame_diff, min_radius=20, max_radius=200):
-    """Detect circles in a frame difference image using Hough Circle Transform."""
+def detect_circles(frame_diff, image_center, min_radius=20, max_radius=200):
+    """Detect circles in a frame difference image, centered at the Sun."""
     circles = cv2.HoughCircles(
         frame_diff,
         cv2.HOUGH_GRADIENT,
-        dp=1.2,  # Inverse ratio of resolution
-        minDist=50,  # Minimum distance between detected centers
-        param1=50,  # Canny edge detector threshold
-        param2=30,  # Accumulator threshold for circle detection
+        dp=1.5,  # Increase resolution for better detection
+        minDist=100,  # Prevent overlapping circles
+        param1=100,  # Higher edge threshold to reduce noise
+        param2=20,  # Lower accumulator threshold to detect faint circles
         minRadius=min_radius,
         maxRadius=max_radius
     )
-    return circles
+
+    if circles is not None:
+        circles = np.round(circles[0, :]).astype("int")
+        # Filter circles: only keep those centered near the image center
+        filtered_circles = []
+        center_tolerance = 30  # Allow 30-pixel deviation from the center
+        for (x, y, r) in circles:
+            if (abs(x - image_center[0]) < center_tolerance and 
+                abs(y - image_center[1]) < center_tolerance):
+                filtered_circles.append((x, y, r))
+        return filtered_circles if filtered_circles else None
+    return None
 
 def analyze_gif(gif_file):
-    """Analyze a GIF for growing concentric circles."""
+    """Analyze a GIF for growing concentric circles centered at the Sun."""
     try:
-        # For Gradio, gif_file is a NamedString object with a 'name' attribute
+        # Handle Gradio file input
         gif_path = gif_file.name if hasattr(gif_file, 'name') else gif_file
 
         # Extract frames
@@ -53,11 +69,15 @@ def analyze_gif(gif_file):
         if len(frames) < 2:
             return "GIF must have at least 2 frames for analysis.", []
 
+        # Determine the image center (Sun's position)
+        height, width = frames[0].shape
+        image_center = (width // 2, height // 2)  # Assume Sun is at the center
+
         # Initialize results
         results = []
         circle_data = []
         min_radius = 20
-        max_radius = min(max(frames[0].shape) // 2, 200)  # Limit max radius based on image size
+        max_radius = min(height, width) // 2  # Limit max radius to half the image size
 
         # Process frames
         for i in range(len(frames) - 1):
@@ -67,25 +87,26 @@ def analyze_gif(gif_file):
             # Compute absolute difference between consecutive frames
             frame_diff = cv2.absdiff(frame2, frame1)
             # Enhance contrast for lighter pixels
-            frame_diff = cv2.convertScaleAbs(frame_diff, alpha=2.0, beta=0)
-
-            # Detect circles in the difference image
-            circles = detect_circles(frame_diff, min_radius, max_radius)
-
-            if circles is not None:
-                circles = np.round(circles[0, :]).astype("int")
-                for (x, y, r) in circles:
-                    circle_data.append({
-                        "frame": i + 1,
-                        "center": (x, y),
-                        "radius": r
-                    })
-
-            # Save frame with detected circles for visualization
+            frame_diff = cv2.convertScaleAbs(frame_diff, alpha=3.0, beta=0)
+
+            # Detect circles centered at the Sun
+            circles = detect_circles(frame_diff, image_center, min_radius, max_radius)
+
+            if circles:
+                # Take the largest circle (most prominent CME feature)
+                largest_circle = max(circles, key=lambda c: c[2])  # Sort by radius
+                x, y, r = largest_circle
+                circle_data.append({
+                    "frame": i + 1,
+                    "center": (x, y),
+                    "radius": r
+                })
+
+            # Visualize the frame with detected circle
             output_frame = cv2.cvtColor(frames[i + 1], cv2.COLOR_GRAY2RGB)
-            if circles is not None:
-                for (x, y, r) in circles:
-                    cv2.circle(output_frame, (x, y), r, (0, 255, 0), 2)
+            if circles:
+                x, y, r = largest_circle
+                cv2.circle(output_frame, (x, y), r, (0, 255, 0), 2)
             # Convert to PIL Image for Gradio
             output_frame = Image.fromarray(output_frame)
             results.append(output_frame)