Create app.py

app.py

@@ -0,0 +1,383 @@
+# app.py - Main Hugging Face Spaces application
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.colors import LinearSegmentedColormap
+import io
+from PIL import Image
+import math
+
+class MathArtGenerator:
+    def __init__(self, width=800, height=600):
+        self.width = width
+        self.height = height
+        
+    def generate_coordinates(self, x_range=(-10, 10), y_range=(-6, 6)):
+        """Generate coordinate meshgrid"""
+        x = np.linspace(x_range[0], x_range[1], self.width)
+        y = np.linspace(y_range[0], y_range[1], self.height)
+        return np.meshgrid(x, y)
+    
+    def mountain_function(self, X, Y, complexity=1.0, scale=1.0):
+        """Generate mountain-like terrain"""
+        mountains = (
+            2 * scale * np.sin(0.5 * X) * np.cos(0.3 * Y) +
+            1.5 * scale * np.sin(0.8 * X + 1) * np.cos(0.2 * Y + 0.5) +
+            scale * np.sin(1.2 * X + 2) * np.cos(0.4 * Y + 1) +
+            0.5 * scale * np.sin(2 * X) * np.cos(0.6 * Y)
+        )
+        
+        detail = complexity * (
+            0.3 * np.sin(3 * X) * np.sin(4 * Y) +
+            0.2 * np.cos(5 * X + Y) +
+            0.1 * np.sin(8 * X) * np.cos(6 * Y)
+        )
+        
+        return mountains + detail
+    
+    def lightning_function(self, X, Y, intensity=1.0, branches=3):
+        """Generate lightning patterns"""
+        lightning = np.zeros_like(X)
+        
+        # Main bolt
+        bolt_path = 2 * np.sin(0.5 * X) + 0.5 * np.sin(2 * X)
+        main_bolt = np.abs(Y - bolt_path) < (0.1 + 0.05 * np.sin(5 * X))
+        lightning += intensity * main_bolt.astype(float)
+        
+        # Branches
+        for i in range(int(branches)):
+            offset = (i + 1) * 0.3
+            branch_path = bolt_path + offset * np.sin((i + 2) * X)
+            branch = np.abs(Y - branch_path) < 0.05
+            lightning += 0.5 * intensity * branch.astype(float)
+        
+        return np.clip(lightning, 0, intensity)
+    
+    def wave_interference(self, X, Y, freq1=1.0, freq2=1.5, phase=0):
+        """Create wave interference patterns"""
+        wave1 = np.sin(freq1 * X + phase) * np.cos(freq1 * Y)
+        wave2 = np.sin(freq2 * X) * np.cos(freq2 * Y + phase)
+        return wave1 + wave2
+    
+    def spiral_pattern(self, X, Y, spiral_factor=0.5, frequency=3):
+        """Generate spiral patterns"""
+        r = np.sqrt(X**2 + Y**2)
+        theta = np.arctan2(Y, X)
+        spiral = np.sin(frequency * theta + spiral_factor * r)
+        return spiral * np.exp(-0.1 * r)  # Fade with distance
+    
+    def fractal_noise(self, X, Y, octaves=4, persistence=0.5):
+        """Generate fractal noise"""
+        noise = np.zeros_like(X)
+        amplitude = 1.0
+        frequency = 1.0
+        
+        for i in range(octaves):
+            noise += amplitude * (
+                np.sin(frequency * X) * np.cos(frequency * Y) +
+                0.5 * np.sin(2 * frequency * X + 1) * np.cos(2 * frequency * Y + 1)
+            )
+            amplitude *= persistence
+            frequency *= 2
+        
+        return noise
+
+def create_mathematical_art(
+    art_type="Landscape",
+    width=800,
+    height=600,
+    color_scheme="Blue Mountains",
+    complexity=1.0,
+    scale=1.0,
+    frequency1=1.0,
+    frequency2=1.5,
+    intensity=1.0
+):
+    """Main function to generate mathematical art"""
+    
+    # Initialize generator
+    generator = MathArtGenerator(width, height)
+    X, Y = generator.generate_coordinates()
+    
+    # Generate based on selected type
+    if art_type == "Landscape":
+        image_data = generator.mountain_function(X, Y, complexity, scale)
+        lightning = generator.lightning_function(X, Y, intensity, 3)
+        image_data = image_data + 2 * lightning
+        
+    elif art_type == "Wave Interference":
+        image_data = generator.wave_interference(X, Y, frequency1, frequency2)
+        
+    elif art_type == "Spiral Pattern":
+        image_data = generator.spiral_pattern(X, Y, complexity, frequency1)
+        
+    elif art_type == "Fractal Noise":
+        image_data = generator.fractal_noise(X, Y, int(frequency1), complexity)
+        
+    elif art_type == "Abstract Composition":
+        mountains = generator.mountain_function(X, Y, complexity * 0.5, scale)
+        waves = generator.wave_interference(X, Y, frequency1, frequency2)
+        spirals = generator.spiral_pattern(X, Y, complexity, frequency1 * 2)
+        image_data = mountains + waves * 0.5 + spirals * 0.3
+    
+    # Apply color scheme
+    color_schemes = {
+        "Blue Mountains": ['#000033', '#000066', '#333366', '#666699', '#9999CC', '#CCCCFF', '#FFFFFF'],
+        "Sunset": ['#000011', '#330000', '#660033', '#993366', '#CC6699', '#FFCCFF', '#FFFFFF'],
+        "Forest": ['#001100', '#003300', '#006600', '#339933', '#66CC66', '#99FF99', '#FFFFFF'],
+        "Ocean": ['#000044', '#003366', '#006699', '#3399CC', '#66CCFF', '#99FFFF', '#FFFFFF'],
+        "Grayscale": ['#000000', '#333333', '#666666', '#999999', '#CCCCCC', '#FFFFFF']
+    }
+    
+    colors = color_schemes.get(color_scheme, color_schemes["Blue Mountains"])
+    cmap = LinearSegmentedColormap.from_list('custom', colors, N=256)
+    
+    # Create the plot
+    plt.figure(figsize=(12, 8))
+    plt.imshow(image_data, cmap=cmap, extent=[-10, 10, -6, 6], origin='lower')
+    plt.axis('off')
+    plt.tight_layout()
+    
+    # Convert to PIL Image for Gradio
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', dpi=150, bbox_inches='tight', pad_inches=0)
+    buf.seek(0)
+    plt.close()
+    
+    return Image.open(buf)
+
+def create_polar_art(equation_type="Rose", petals=4, frequency=2.0, amplitude=3.0):
+    """Generate polar coordinate art"""
+    theta = np.linspace(0, 4 * np.pi, 10000)
+    
+    if equation_type == "Rose":
+        r = amplitude * np.sin(petals * theta)
+    elif equation_type == "Spiral":
+        r = amplitude * theta / (2 * np.pi) * np.sin(frequency * theta)
+    elif equation_type == "Cardioid":
+        r = amplitude * (1 + np.cos(theta))
+    elif equation_type == "Lemniscate":
+        r = amplitude * np.sqrt(np.abs(np.cos(2 * theta)))
+    
+    x = r * np.cos(theta)
+    y = r * np.sin(theta)
+    
+    plt.figure(figsize=(10, 10))
+    plt.plot(x, y, linewidth=0.8, color='#3366CC', alpha=0.8)
+    plt.axis('equal')
+    plt.axis('off')
+    plt.grid(False)
+    plt.tight_layout()
+    
+    # Convert to PIL Image
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', dpi=150, bbox_inches='tight', pad_inches=0)
+    buf.seek(0)
+    plt.close()
+    
+    return Image.open(buf)
+
+# Gradio Interface
+def create_interface():
+    """Create the Gradio interface"""
+    
+    with gr.Blocks(title="Mathematical Art Generator", theme=gr.themes.Soft()) as interface:
+        gr.Markdown("""
+        # 🎨 Mathematical Art Generator
+        
+        Create stunning mathematical art using various equations and patterns!
+        Choose from different art types and customize parameters to generate unique mathematical visualizations.
+        """)
+        
+        with gr.Tabs():
+            # Tab 1: Function-based Art
+            with gr.TabItem("Function Art"):
+                with gr.Row():
+                    with gr.Column():
+                        art_type = gr.Dropdown(
+                            choices=["Landscape", "Wave Interference", "Spiral Pattern", "Fractal Noise", "Abstract Composition"],
+                            value="Landscape",
+                            label="Art Type"
+                        )
+                        color_scheme = gr.Dropdown(
+                            choices=["Blue Mountains", "Sunset", "Forest", "Ocean", "Grayscale"],
+                            value="Blue Mountains",
+                            label="Color Scheme"
+                        )
+                        
+                        with gr.Row():
+                            width = gr.Slider(400, 1200, value=800, step=100, label="Width")
+                            height = gr.Slider(300, 900, value=600, step=100, label="Height")
+                        
+                        with gr.Row():
+                            complexity = gr.Slider(0.1, 3.0, value=1.0, step=0.1, label="Complexity")
+                            scale = gr.Slider(0.1, 3.0, value=1.0, step=0.1, label="Scale")
+                        
+                        with gr.Row():
+                            frequency1 = gr.Slider(0.1, 5.0, value=1.0, step=0.1, label="Frequency 1")
+                            frequency2 = gr.Slider(0.1, 5.0, value=1.5, step=0.1, label="Frequency 2")
+                        
+                        intensity = gr.Slider(0.1, 3.0, value=1.0, step=0.1, label="Intensity")
+                        
+                        generate_btn = gr.Button("🎨 Generate Art", variant="primary")
+                    
+                    with gr.Column():
+                        function_output = gr.Image(label="Generated Mathematical Art")
+                
+                generate_btn.click(
+                    fn=create_mathematical_art,
+                    inputs=[art_type, width, height, color_scheme, complexity, scale, frequency1, frequency2, intensity],
+                    outputs=function_output
+                )
+            
+            # Tab 2: Polar Art
+            with gr.TabItem("Polar Art"):
+                with gr.Row():
+                    with gr.Column():
+                        equation_type = gr.Dropdown(
+                            choices=["Rose", "Spiral", "Cardioid", "Lemniscate"],
+                            value="Rose",
+                            label="Equation Type"
+                        )
+                        
+                        with gr.Row():
+                            petals = gr.Slider(2, 20, value=4, step=1, label="Petals/Parameter")
+                            frequency = gr.Slider(0.1, 10.0, value=2.0, step=0.1, label="Frequency")
+                        
+                        amplitude = gr.Slider(1.0, 10.0, value=3.0, step=0.1, label="Amplitude")
+                        
+                        generate_polar_btn = gr.Button("🌸 Generate Polar Art", variant="primary")
+                    
+                    with gr.Column():
+                        polar_output = gr.Image(label="Generated Polar Art")
+                
+                generate_polar_btn.click(
+                    fn=create_polar_art,
+                    inputs=[equation_type, petals, frequency, amplitude],
+                    outputs=polar_output
+                )
+            
+            # Tab 3: Information
+            with gr.TabItem("About"):
+                gr.Markdown("""
+                ## 📐 Mathematical Art Types
+                
+                **Function Art:**
+                - **Landscape**: Mountain ranges using trigonometric functions
+                - **Wave Interference**: Overlapping sine and cosine waves
+                - **Spiral Pattern**: Logarithmic and Archimedean spirals
+                - **Fractal Noise**: Multi-octave noise patterns
+                - **Abstract Composition**: Combination of multiple functions
+                
+                **Polar Art:**
+                - **Rose**: r = a·sin(nθ) or r = a·cos(nθ)
+                - **Spiral**: r = aθ combined with trigonometric functions
+                - **Cardioid**: r = a(1 + cos(θ))
+                - **Lemniscate**: r² = a²cos(2θ)
+                
+                ## 🎛️ Parameter Guide
+                
+                - **Complexity**: Controls detail level and noise
+                - **Scale**: Overall size/amplitude of patterns
+                - **Frequency**: Speed of oscillations
+                - **Intensity**: Brightness/contrast of effects
+                
+                ## 🚀 Deployment Notes
+                
+                This app generates mathematical art in real-time using NumPy and Matplotlib.
+                Higher resolutions may take longer to generate.
+                """)
+        
+        # Example generations on startup
+        gr.Markdown("### 🎭 Example Gallery")
+        with gr.Row():
+            gr.Examples(
+                examples=[
+                    ["Landscape", 800, 600, "Blue Mountains", 1.0, 1.0, 1.0, 1.5, 1.0],
+                    ["Wave Interference", 800, 600, "Ocean", 1.5, 1.0, 2.0, 3.0, 1.0],
+                    ["Spiral Pattern", 800, 600, "Sunset", 0.8, 1.2, 1.5, 1.0, 1.0],
+                ],
+                inputs=[art_type, width, height, color_scheme, complexity, scale, frequency1, frequency2, intensity],
+                outputs=function_output,
+                fn=create_mathematical_art,
+                cache_examples=True
+            )
+    
+    return interface
+
+# Launch the app
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )
+
+# requirements.txt content for Hugging Face
+"""
+gradio>=4.0.0
+numpy>=1.21.0
+matplotlib>=3.5.0
+Pillow>=9.0.0
+"""
+
+# README.md content for Hugging Face
+readme_content = """
+---
+title: Mathematical Art Generator
+emoji: 🎨
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.0.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Mathematical Art Generator 🎨
+
+Generate stunning mathematical art using various equations and mathematical functions!
+
+## Features
+
+- **Function-based Art**: Create landscapes, wave patterns, spirals, and abstract compositions
+- **Polar Coordinate Art**: Generate roses, spirals, cardioids, and lemniscates
+- **Customizable Parameters**: Control complexity, scale, frequency, and color schemes
+- **Real-time Generation**: Interactive parameter adjustment with instant preview
+- **High-Quality Output**: Export-ready images with customizable resolution
+
+## Art Types
+
+### Function Art
+- **Landscape**: Mountain ranges using sine/cosine combinations
+- **Wave Interference**: Beautiful interference patterns
+- **Spiral Patterns**: Logarithmic and mathematical spirals
+- **Fractal Noise**: Multi-octave procedural patterns
+- **Abstract Compositions**: Complex mathematical combinations
+
+### Polar Art
+- **Rose Curves**: r = a·sin(nθ)
+- **Spirals**: Various spiral equations
+- **Cardioid**: Heart-shaped curves
+- **Lemniscate**: Figure-eight patterns
+
+## Usage
+
+1. Choose your art type from the tabs
+2. Adjust parameters to customize the output
+3. Click "Generate Art" to create your mathematical masterpiece
+4. Experiment with different settings for unique results!
+
+## Mathematical Background
+
+This generator uses various mathematical concepts:
+- Trigonometric functions (sin, cos, tan)
+- Polar coordinates (r, θ)
+- Parametric equations
+- Fractal mathematics
+- Wave interference patterns
+
+Perfect for artists, mathematicians, educators, and anyone interested in the beauty of mathematical visualization!
+"""