🌬️ Add interactive global wind map application

- Add main Gradio app with interactive wind visualization
- Include wind vectors showing direction and speed
- Add wind speed heatmap with color coding
- Implement adjustable resolution controls (5-20 degrees)
- Add realistic wind pattern simulation (trade winds, westerlies, polar)
- Include comprehensive documentation and setup instructions
- Add requirements.txt with all dependencies
- Create convenient run script for easy startup

.gitignore

@@ -0,0 +1,25 @@
+# Virtual environment
+venv/
+
+# Python cache
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+
+# Temporary files
+*.tmp
+*.temp
+*.html
+
+# MacOS
+.DS_Store
+
+# IDE
+.vscode/
+.idea/
+
+# Gradio temporary files
+gradio_cached_examples/
+flagged/ 

README.md

@@ -1,6 +1,6 @@
 ---
 title: Windmap
-emoji: 👁
+emoji: 🌬️
 colorFrom: yellow
 colorTo: blue
 sdk: gradio
@@ -10,4 +10,99 @@ pinned: false
 license: gpl-3.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🌬️ Global Wind Map
+
+An interactive web application that displays global wind patterns on a map using Gradio and Folium.
+
+## Features
+
+- **Interactive Wind Visualization**: View global wind patterns with arrows showing direction and speed
+- **Wind Speed Heatmap**: Color-coded overlay showing wind intensity across the globe
+- **Adjustable Resolution**: Control the detail level of wind data (5-20 degree grid spacing)
+- **Real-time Controls**: Toggle wind vectors and heatmap display
+- **Responsive Design**: Clean, modern interface with interactive controls
+
+## Wind Pattern Simulation
+
+The application currently displays simulated wind data with realistic patterns:
+
+- **Trade Winds**: Easterly winds near the equator (-30° to 30° latitude)
+- **Westerlies**: Westerly winds in mid-latitudes (30° to 60° and -60° to -30°)
+- **Polar Winds**: Variable winds in polar regions
+
+## Quick Start
+
+### Option 1: Using the run script
+```bash
+chmod +x run.sh
+./run.sh
+```
+
+### Option 2: Manual setup
+```bash
+# Create and activate virtual environment
+python3 -m venv venv
+source venv/bin/activate
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the application
+python app.py
+```
+
+## Usage
+
+1. **Start the application** using one of the methods above
+2. **Open your browser** to the provided URL (typically `http://localhost:7860`)
+3. **Adjust controls** in the left panel:
+   - **Data Resolution**: Lower values = more detail (but slower rendering)
+   - **Show Wind Vectors**: Toggle wind direction arrows
+   - **Show Wind Speed Heatmap**: Toggle colored wind speed overlay
+4. **Explore the map** by zooming and panning
+5. **Click on wind arrows** to see detailed wind information
+
+## Wind Speed Legend
+
+- 🔵 **Blue (0-3 m/s)**: Light winds
+- 🟢 **Green (3-7 m/s)**: Moderate winds  
+- 🟠 **Orange (7-12 m/s)**: Strong winds
+- 🔴 **Red (12+ m/s)**: Very strong winds
+
+## Dependencies
+
+- **gradio**: Web interface framework
+- **folium**: Interactive mapping library
+- **numpy**: Numerical computations
+- **pandas**: Data manipulation
+- **requests**: HTTP requests (for future API integration)
+
+## Future Enhancements
+
+The current version uses simulated data for demonstration. Planned improvements include:
+
+- **Real Weather Data**: Integration with APIs like:
+  - OpenWeather API
+  - NOAA Global Forecast System
+  - European Centre for Medium-Range Weather Forecasts
+- **Historical Data**: View wind patterns from past dates
+- **Weather Forecast**: Show predicted wind patterns
+- **Additional Layers**: Temperature, pressure, precipitation
+- **Export Features**: Save maps as images or data
+
+## Configuration
+
+For production deployment on Hugging Face Spaces, the application will automatically start when the Space is loaded.
+
+## Development
+
+To extend the application:
+
+1. **Add real data sources** in the `get_wind_data()` function
+2. **Customize map styling** in the `create_wind_map()` function  
+3. **Add new controls** in the Gradio interface section
+4. **Implement additional weather layers** using Folium plugins
+
+## License
+
+GPL-3.0 License - see the LICENSE file for details.

app.py

@@ -0,0 +1,215 @@
+import gradio as gr
+import folium
+import requests
+import numpy as np
+import pandas as pd
+from datetime import datetime, timedelta
+import json
+import tempfile
+import os
+
+def get_wind_data(lat_min=-90, lat_max=90, lon_min=-180, lon_max=180, resolution=5):
+    """
+    Fetch wind data from OpenWeather API or use sample data for demonstration
+    In a real implementation, you'd want to use a proper weather API
+    """
+    # For demo purposes, we'll generate sample wind data
+    # In production, you'd fetch from APIs like OpenWeather, NOAA, etc.
+    
+    lats = np.arange(lat_min, lat_max + resolution, resolution)
+    lons = np.arange(lon_min, lon_max + resolution, resolution)
+    
+    wind_data = []
+    for lat in lats:
+        for lon in lons:
+            # Generate sample wind data with realistic patterns
+            # Simulate trade winds and westerlies
+            if -30 <= lat <= 30:  # Trade winds
+                u_wind = -5 + np.random.normal(0, 2)  # Easterly
+                v_wind = np.random.normal(0, 1)
+            elif 30 < lat <= 60 or -60 <= lat < -30:  # Westerlies
+                u_wind = 5 + np.random.normal(0, 3)  # Westerly
+                v_wind = np.random.normal(0, 2)
+            else:  # Polar regions
+                u_wind = np.random.normal(0, 2)
+                v_wind = np.random.normal(0, 2)
+            
+            wind_speed = np.sqrt(u_wind**2 + v_wind**2)
+            wind_direction = np.degrees(np.arctan2(v_wind, u_wind)) % 360
+            
+            wind_data.append({
+                'lat': lat,
+                'lon': lon,
+                'u_wind': u_wind,
+                'v_wind': v_wind,
+                'wind_speed': wind_speed,
+                'wind_direction': wind_direction
+            })
+    
+    return pd.DataFrame(wind_data)
+
+def create_wind_map(resolution=10, show_vectors=True, show_heatmap=True):
+    """
+    Create an interactive wind map using Folium
+    """
+    # Get wind data
+    wind_df = get_wind_data(resolution=resolution)
+    
+    # Create base map
+    m = folium.Map(
+        location=[20, 0],
+        zoom_start=2,
+        tiles='OpenStreetMap'
+    )
+    
+    # Add wind speed heatmap
+    if show_heatmap:
+        from folium.plugins import HeatMap
+        heat_data = [[row['lat'], row['lon'], row['wind_speed']] 
+                    for _, row in wind_df.iterrows()]
+        HeatMap(heat_data, radius=15, blur=10, gradient={
+            0.0: 'blue',
+            0.3: 'cyan', 
+            0.5: 'lime',
+            0.7: 'yellow',
+            1.0: 'red'
+        }).add_to(m)
+    
+    # Add wind vectors
+    if show_vectors:
+        for _, row in wind_df.iterrows():
+            if row['wind_speed'] > 1:  # Only show significant winds
+                # Calculate arrow end point
+                scale = 0.5  # Adjust this to make arrows longer/shorter
+                end_lat = row['lat'] + (row['v_wind'] * scale)
+                end_lon = row['lon'] + (row['u_wind'] * scale)
+                
+                # Color based on wind speed
+                if row['wind_speed'] < 3:
+                    color = 'blue'
+                elif row['wind_speed'] < 7:
+                    color = 'green'
+                elif row['wind_speed'] < 12:
+                    color = 'orange'
+                else:
+                    color = 'red'
+                
+                # Add arrow
+                folium.PolyLine(
+                    locations=[[row['lat'], row['lon']], [end_lat, end_lon]],
+                    color=color,
+                    weight=2,
+                    opacity=0.7
+                ).add_to(m)
+                
+                # Add arrowhead (simplified)
+                folium.CircleMarker(
+                    location=[end_lat, end_lon],
+                    radius=2,
+                    color=color,
+                    fillColor=color,
+                    fillOpacity=0.8,
+                    popup=f"Wind Speed: {row['wind_speed']:.1f} m/s<br>Direction: {row['wind_direction']:.0f}°"
+                ).add_to(m)
+    
+    # Add legend
+    legend_html = '''
+    <div style="position: fixed; 
+                bottom: 50px; left: 50px; width: 200px; height: 120px; 
+                background-color: white; border:2px solid grey; z-index:9999; 
+                font-size:14px; padding: 10px">
+    <h4>Wind Speed (m/s)</h4>
+    <p><span style="color:blue">●</span> 0-3 Light</p>
+    <p><span style="color:green">●</span> 3-7 Moderate</p>
+    <p><span style="color:orange">●</span> 7-12 Strong</p>
+    <p><span style="color:red">●</span> 12+ Very Strong</p>
+    </div>
+    '''
+    m.get_root().html.add_child(folium.Element(legend_html))
+    
+    # Save map to temporary file
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.html')
+    m.save(temp_file.name)
+    return temp_file.name
+
+def update_wind_map(resolution, show_vectors, show_heatmap):
+    """
+    Update the wind map based on user inputs
+    """
+    map_file = create_wind_map(resolution, show_vectors, show_heatmap)
+    return map_file
+
+# Create Gradio interface
+with gr.Blocks(title="Global Wind Map", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🌬️ Global Wind Map")
+    gr.Markdown("Explore global wind patterns with interactive visualization")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("## Controls")
+            resolution = gr.Slider(
+                minimum=5, 
+                maximum=20, 
+                value=10, 
+                step=5,
+                label="Data Resolution (degrees)",
+                info="Lower values = more detail (slower)"
+            )
+            show_vectors = gr.Checkbox(
+                value=True,
+                label="Show Wind Vectors",
+                info="Display wind direction arrows"
+            )
+            show_heatmap = gr.Checkbox(
+                value=True,
+                label="Show Wind Speed Heatmap",
+                info="Display wind speed as colored overlay"
+            )
+            
+            update_btn = gr.Button("🔄 Update Map", variant="primary")
+            
+            gr.Markdown("""
+            ### About the Data
+            This demo shows simulated wind data with realistic patterns:
+            - **Trade Winds**: Easterly winds near the equator
+            - **Westerlies**: Westerly winds in mid-latitudes
+            - **Polar Winds**: Variable winds in polar regions
+            
+            In a production version, this would connect to real weather APIs like:
+            - OpenWeather API
+            - NOAA Global Forecast System
+            - European Centre for Medium-Range Weather Forecasts
+            """)
+        
+        with gr.Column(scale=3):
+            map_html = gr.HTML(
+                value=create_wind_map(),
+                label="Wind Map"
+            )
+    
+    # Update map when controls change
+    update_btn.click(
+        fn=update_wind_map,
+        inputs=[resolution, show_vectors, show_heatmap],
+        outputs=[map_html]
+    )
+    
+    # Auto-update when sliders change
+    resolution.change(
+        fn=update_wind_map,
+        inputs=[resolution, show_vectors, show_heatmap],
+        outputs=[map_html]
+    )
+    show_vectors.change(
+        fn=update_wind_map,
+        inputs=[resolution, show_vectors, show_heatmap],
+        outputs=[map_html]
+    )
+    show_heatmap.change(
+        fn=update_wind_map,
+        inputs=[resolution, show_vectors, show_heatmap],
+        outputs=[map_html]
+    )
+
+if __name__ == "__main__":
+    demo.launch() 

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+folium>=0.14.0
+numpy>=1.24.0
+pandas>=2.0.0
+requests>=2.31.0 

run.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+# Activate virtual environment
+source venv/bin/activate
+
+# Run the Gradio app
+python app.py