Create app.py

app.py

@@ -0,0 +1,136 @@
+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):
+    """Extract frames from a GIF and return as a list of numpy arrays."""
+    try:
+        img = Image.open(gif_path)
+        frames = []
+        while True:
+            frame = img.convert('L')  # Convert to grayscale
+            frames.append(np.array(frame))
+            try:
+                img.seek(img.tell() + 1)
+            except EOFError:
+                break
+        return frames
+    except Exception as e:
+        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)
+
+def detect_circles(frame_diff, min_radius=20, max_radius=200):
+    """Detect circles in a frame difference image using Hough Circle Transform."""
+    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
+        minRadius=min_radius,
+        maxRadius=max_radius
+    )
+    return circles
+
+def analyze_gif(gif_file):
+    """Analyze a GIF for growing concentric circles."""
+    try:
+        # Save uploaded GIF to temporary file
+        with open("temp.gif", "wb") as f:
+            f.write(gif_file.read())
+
+        # Extract frames
+        frames, error = extract_frames("temp.gif")
+        if error:
+            return error
+
+        if len(frames) < 2:
+            return "GIF must have at least 2 frames for analysis."
+
+        # Initialize results
+        results = []
+        circle_data = []
+        min_radius = 20
+        max_radius = min(max(frames[0].shape) // 2, 200)  # Limit max radius based on image size
+
+        # Process frames
+        for i in range(len(frames) - 1):
+            frame1 = preprocess_frame(frames[i])
+            frame2 = preprocess_frame(frames[i + 1])
+
+            # 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
+                    })
+
+            # Optional: Save frame with detected circles for visualization
+            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)
+            # Convert to PIL Image for Gradio
+            output_frame = Image.fromarray(output_frame)
+            results.append(output_frame)
+
+        # Analyze circle data for growth
+        report = "Analysis Report:\n"
+        if circle_data:
+            radii = [c["radius"] for c in circle_data]
+            centers = [c["center"] for c in circle_data]
+            frames_with_circles = [c["frame"] for c in circle_data]
+
+            # Check if radii are increasing over frames
+            is_growing = all(radii[i] < radii[i + 1] for i in range(len(radii) - 1))
+            center_consistent = all(
+                abs(centers[i][0] - centers[0][0]) < 20 and
+                abs(centers[i][1] - centers[0][1]) < 20
+                for i in range(1, len(centers))
+            )
+
+            report += f"Detected {len(circle_data)} circles across frames.\n"
+            for c in circle_data:
+                report += f"Frame {c['frame']}: Center at {c['center']}, Radius {c['radius']} pixels\n"
+            if is_growing and center_consistent:
+                report += "\nConclusion: Growing concentric circles detected, indicative of a potential Earth-directed CME."
+            else:
+                report += "\nConclusion: Detected circles, but growth pattern or center consistency does not confirm a clear CME."
+        else:
+            report += "No concentric circles detected."
+
+        return report, results
+    except Exception as e:
+        return f"Error during analysis: {str(e)}", []
+
+# Gradio interface
+iface = gr.Interface(
+    fn=analyze_gif,
+    inputs=gr.File(label="Upload Solar GIF"),
+    outputs=[
+        gr.Textbox(label="Analysis Report"),
+        gr.Gallery(label="Frames with Detected Circles")
+    ],
+    title="Solar CME Detection",
+    description="Upload a GIF of solar images to detect growing concentric circles indicative of Earth-directed coronal mass ejections (CMEs)."
+)
+
+if __name__ == "__main__":
+    iface.launch()