Spaces:
Paused
Paused
| import gradio as gr | |
| import numpy as np | |
| import cv2 | |
| from PIL import Image | |
| 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, None | |
| except Exception as e: | |
| return None, f"Error loading GIF: {str(e)}" | |
| def preprocess_frame(frame): | |
| """Preprocess a frame: isolate mid-to-light pixels and enhance circular patterns.""" | |
| # Apply Gaussian blur to reduce noise | |
| blurred = cv2.GaussianBlur(frame, (9, 9), 0) | |
| # Isolate mid-to-light pixels (intensity range 100–200 in grayscale) | |
| lower_bound = 150 | |
| upper_bound = 255 | |
| mask = cv2.inRange(blurred, lower_bound, upper_bound) | |
| # Apply morphological operation to enhance circular patterns | |
| kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)) | |
| enhanced = cv2.dilate(mask, kernel, iterations=2) | |
| return enhanced | |
| 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.5, # Resolution for better detection | |
| minDist=100, # Prevent overlapping circles | |
| param1=80, # Lower edge threshold to capture fainter edges | |
| param2=15, # Lower accumulator threshold to detect faint circles | |
| minRadius=min_radius, | |
| maxRadius=max_radius | |
| ) | |
| 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 of mid-to-light pixels.""" | |
| try: | |
| # Handle Gradio file input | |
| gif_path = gif_file.name if hasattr(gif_file, 'name') else gif_file | |
| # Extract frames | |
| frames, error = extract_frames(gif_path) | |
| if error: | |
| return error, [] | |
| 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 | |
| all_circle_data = [] # Store all detected circles | |
| min_radius = 20 | |
| max_radius = min(height, width) // 2 # Limit max radius to half the image size | |
| # Process frames and detect circles | |
| 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 the difference image | |
| 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 | |
| all_circle_data.append({ | |
| "frame": i + 1, | |
| "center": (x, y), | |
| "radius": r, | |
| "output_frame": frames[i + 1] # Store the frame for visualization | |
| }) | |
| # Filter frames where the circle is growing | |
| growing_circle_data = [] | |
| if all_circle_data: | |
| # Start with the first detection | |
| growing_circle_data.append(all_circle_data[0]) | |
| for i in range(1, len(all_circle_data)): | |
| # Compare radius with the last growing circle | |
| if all_circle_data[i]["radius"] > growing_circle_data[-1]["radius"]: | |
| growing_circle_data.append(all_circle_data[i]) | |
| # Generate output frames and report | |
| results = [] | |
| report = "Analysis Report (as of 07:34 PM PDT, May 24, 2025):\n" | |
| if growing_circle_data: | |
| report += f"Detected {len(growing_circle_data)} frames with growing concentric circles of mid-to-light pixels:\n" | |
| for c in growing_circle_data: | |
| # Visualize the frame with detected circle | |
| output_frame = cv2.cvtColor(c["output_frame"], cv2.COLOR_GRAY2RGB) | |
| cv2.circle(output_frame, (c["center"][0], c["center"][1]), c["radius"], (0, 255, 0), 2) | |
| # Convert to PIL Image for Gradio | |
| output_frame = Image.fromarray(output_frame) | |
| results.append(output_frame) | |
| report += f"Frame {c['frame']}: Center at {c['center']}, Radius {c['radius']} pixels\n" | |
| report += "\nConclusion: Growing concentric circles of mid-to-light pixels detected, indicative of a potential Earth-directed CME." | |
| else: | |
| report += "No growing concentric circles of mid-to-light pixels detected. CME may not be Earth-directed." | |
| 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", file_types=[".gif"]), | |
| outputs=[ | |
| gr.Textbox(label="Analysis Report"), | |
| gr.Gallery(label="Frames with Growing Circles") | |
| ], | |
| title="Solar CME Detection", | |
| description="Upload a GIF of solar images to detect growing concentric circles of mid-to-light pixels indicative of Earth-directed coronal mass ejections (CMEs)." | |
| ) | |
| if __name__ == "__main__": | |
| iface.launch() |