import gradio as gr import matplotlib.pyplot as plt import numpy as np import random # --- Configure Matplotlib --- plt.style.use('ggplot') plt.rcParams['figure.figsize'] = [10, 10] # --- Core Data Structure: Circle Class --- class Circle: """Represents a circle in the drawing and its state""" def __init__(self, x, y, radius, color): self.x = x self.y = y self.radius = radius self.color = color def __repr__(self): return f"Circle(Center:({self.x:.2f}, {self.y:.2f}), R:{self.radius}, Color:{self.color})" # --- Shape Grammar Core Function --- def run_shape_grammar(N_iterations): """ Runs the shape grammar iterative process N times and yields the state after each iteration. """ # 1. Initial Condition (Start) circles = [Circle(0, 0, 2, 'blue')] lines = [] # Stores all line segments for plotting current_iteration = 0 print(f"--- Starting Shape Grammar: Target Iterations N = {N_iterations} ---") # Yield initial state before any iterations yield circles, lines while current_iteration < N_iterations: # Filter out non-red circles active_circles = [c for c in circles if c.color != 'red'] # 2. Stop Condition Check if not active_circles: print(f"\n✅ Stop: All circles have turned red. Total iterations: {current_iteration}") break # 3. Randomly select an original circle (Pick a random circle) C_original = random.choice(active_circles) # 4. Determine Direction and Line Segment (Direction and Line) # Random angle (multiple of 45°) angle_deg = random.choice([0, 45, 90, 135, 180, 225, 270, 315]) angle_rad = np.deg2rad(angle_deg) # Random line length L_length = random.choice([6, 8, 10]) # Randomly choose starting point (center or tangent point) start_from_center = random.choice([True, False]) if start_from_center: # Option A: Start from the center P_start_x, P_start_y = C_original.x, C_original.y else: # Option B: Start from a tangent point on the circumference # The tangent point is the center translated by R in the opposite direction of 'angle_rad' P_start_x = C_original.x + C_original.radius * np.cos(angle_rad + np.pi) P_start_y = C_original.y + C_original.radius * np.sin(angle_rad + np.pi) # Calculate the end point of the line segment P_end_x = P_start_x + L_length * np.cos(angle_rad) P_end_y = P_start_y + L_length * np.sin(angle_rad) # Store the line segment lines.append(((P_start_x, P_start_y), (P_end_x, P_end_y))) # 5. Create New Circle (New Circle) # Random radius and color R_new = random.choice([1, 2, 3, 4]) # Color selection: Kept uniformly random for faster generation colors = ['blue'] * 9 + ['green'] * 9 + ['red'] * 2 # 9:9:2 比例 Color_new = random.choice(colors) # Random placement position placement_option = random.choice(['tangential_left', 'tangential_right', 'centered']) if placement_option == 'centered': # Option C: Centered at the end point of the line segment C_new_x, C_new_y = P_end_x, P_end_y else: # Option A/B: Tangential to the line segment # Normal direction: Angle plus/minus 90 degrees # Tangential to the line (L) left or right normal_angle = angle_rad + (np.pi/2 if placement_option == 'tangential_left' else -np.pi/2) # The center of the new circle is located at the end point P_end, moved by R_new distance along the normal direction C_new_x = P_end_x + R_new * np.cos(normal_angle) # Corrected the calculation for C_new_y - it should use P_end_y C_new_y = P_end_y + R_new * np.sin(normal_angle) C_new = Circle(C_new_x, C_new_y, R_new, Color_new) circles.append(C_new) # 6. Color Updates (Color Updates) - Modifying Green's mortality rate if C_original.color == 'blue': C_original.color = 'green' elif C_original.color == 'green': # 只有 50% 的概率从 Green 变为 Red，另 50% 保持 Green if random.random() < 0.5: C_original.color = 'red' # 否则 C_original.color 保持 'green' current_iteration += 1 print(f"Iteration {current_iteration}/{N_iterations}: Original circle turned {C_original.color}, New circle {C_new.color}, Total circles: {len(circles)}") # Yield the current state yield circles, lines if current_iteration == N_iterations: print(f"\n✅ Stop: Maximum number of iterations N = {N_iterations} reached.") # --- Plotting Function --- def plot_grammar_result(circles, lines): """ Plots the generated shape using Matplotlib and returns the figure. """ fig, ax = plt.subplots() # Plot all circles for c in circles: # Plot using matplotlib.patches.Circle circle_patch = plt.Circle((c.x, c.y), c.radius, color=c.color, alpha=0.6, # Transparency fill=True, linewidth=1, edgecolor='black') ax.add_patch(circle_patch) # Plot all line segments for (start, end) in lines: ax.plot([start[0], end[0]], [start[1], end[1]], color='gray', linestyle='-', linewidth=0.5, zorder=-1) # Place below circles # Set axes and limits if circles: all_x = [c.x for c in circles] all_y = [c.y for c in circles] # Automatically calculate boundaries to ensure all circles are visible x_min, x_max = min(all_x), max(all_x) y_min, y_max = min(all_y), max(all_y) padding = 10 # Additional padding # Add a check to prevent errors if min/max are the same (e.g., only one circle at 0,0) if x_min == x_max: x_min -= padding x_max += padding if y_min == y_max: y_min -= padding y_max += padding ax.set_xlim(x_min - padding, x_max + padding) ax.set_ylim(y_min - padding, y_max + padding) ax.set_aspect('equal', adjustable='box') # Maintain equal aspect ratio ax.set_title(f"Shape Grammar Generation Result (Total {len(circles)} circles)") ax.set_xlabel("X Coordinate") ax.set_ylabel("Y Coordinate") # Don't call plt.show() here, return the figure object return fig # Store the generated plots generated_plots = [] def run_shape_grammar_and_generate_plots(num_iterations): """ Runs the shape grammar and generates plots for each iteration. Returns a list of Matplotlib figure objects. """ global generated_plots generated_plots = [] # Clear previous plots print(f"run_shape_grammar_and_generate_plots called with {num_iterations} iterations") # Ensure the input is a positive integer if num_iterations is None or num_iterations <= 0: num_iterations = 50 # Default to 50 if invalid # Run the generation process and iterate through yielded results for i, (circles, lines) in enumerate(run_shape_grammar(int(num_iterations))): # Plot the result for the current step and get the figure object fig = plot_grammar_result(circles, lines) generated_plots.append(fig) # Close the figure to free up memory plt.close(fig) print(f"Generated {len(generated_plots)} plots.") return generated_plots def display_iteration(iteration_index): """ Displays the plot for a specific iteration based on the slider value. """ global generated_plots print(f"display_iteration called with index {iteration_index}") if generated_plots and 0 <= iteration_index < len(generated_plots): print(f"Displaying plot for iteration {iteration_index}") return generated_plots[int(iteration_index)] # Ensure index is integer else: print("No plot available or index out of range.") # Return an empty plot or a placeholder if no plots are available or index is out of range fig, ax = plt.subplots() ax.text(0.5, 0.5, "No plot available", horizontalalignment='center', verticalalignment='center') ax.set_title("Error") return fig # Create the Gradio interface with gr.Blocks() as demo: gr.Markdown("## Shape Grammar Generator with Iteration Slider") gr.Markdown("Generate abstract shapes using a simple shape grammar and explore each step of the process.") with gr.Row(): num_iterations_input = gr.Number(label="Number of Iterations", value=50, precision=0) generate_button = gr.Button("Generate") # Output area for the plots plot_output = gr.Plot() # Slider to control the displayed iteration iteration_slider = gr.Slider(minimum=0, maximum=0, step=1, label="Iteration") # Link the generate button to the function that runs the grammar and generates plots # Update the slider's maximum value after generation generate_button.click( fn=run_shape_grammar_and_generate_plots, inputs=num_iterations_input, outputs=None # We don't directly output here, we just generate and store plots ).then( fn=lambda: gr.update(maximum=len(generated_plots)-1, value=0), # Update slider max and reset to 0 inputs=None, # No direct input needed, accessing global variable outputs=iteration_slider ).then( fn=lambda: generated_plots[0] if generated_plots else None, # Display the first plot initially inputs=None, # No direct input needed, accessing global variable outputs=plot_output ) # Link the slider to the function that displays the selected iteration's plot iteration_slider.change( fn=display_iteration, inputs=iteration_slider, outputs=plot_output ) # Launch the interface for Hugging Face Spaces if __name__ == "__main__": # Modified to include share=True for Colab/hosted environments demo.launch(share=True)