ok

Dockerfile

@@ -1,23 +0,0 @@
-FROM python:3.10-slim
-
-# Install only essential packages
-RUN apt-get update && apt-get install -y \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-# Create user
-RUN useradd -m -u 1000 user
-WORKDIR /home/user/app
-
-# Copy and install Python requirements
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application
-COPY . .
-RUN chown -R user:user /home/user/app
-
-USER user
-EXPOSE 7860
-
-CMD ["python", "app.py"]

README.md

@@ -1,12 +0,0 @@
----
-title: Ecmwf Wind Docker
-emoji: 📉
-colorFrom: blue
-colorTo: yellow
-sdk: docker
-pinned: false
-license: cc-by-4.0
-short_description: wind data in the docker html5 land
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,1067 +0,0 @@
-#!/usr/bin/env python3
-"""
-ECMWF Wind Visualization with Real Data
-Based on proven particle technology from windmap project
-"""
-
-import gradio as gr
-import numpy as np
-import pandas as pd
-import folium
-import requests
-import json
-import time
-import tempfile
-import os
-import xarray as xr
-from datetime import datetime, timedelta
-import warnings
-warnings.filterwarnings('ignore')
-
-try:
-    from ecmwf.opendata import Client as OpenDataClient
-    OPENDATA_AVAILABLE = True
-except ImportError:
-    OPENDATA_AVAILABLE = False
-
-class ECMWFWindDataFetcher:
-    def __init__(self):
-        self.temp_dir = tempfile.mkdtemp()
-        self.client = None
-        if OPENDATA_AVAILABLE:
-            try:
-                self.client = OpenDataClient()
-            except:
-                self.client = None
-        
-        # AWS S3 direct access URLs (completely free)
-        self.aws_base_url = "https://ecmwf-forecasts.s3.eu-central-1.amazonaws.com"
-    
-    def get_latest_forecast_info(self):
-        """Get the latest available ECMWF forecast run info"""
-        now = datetime.utcnow()
-        
-        # ECMWF runs at 00, 06, 12, 18 UTC
-        forecast_hours = [0, 6, 12, 18]
-        
-        # Find the most recent forecast run
-        for hours_back in range(0, 24, 6):
-            check_time = now - timedelta(hours=hours_back)
-            run_hour = max([h for h in forecast_hours if h <= check_time.hour])
-            
-            forecast_time = check_time.replace(hour=run_hour, minute=0, second=0, microsecond=0)
-            
-            # ECMWF data is usually available 2-4 hours after run time
-            if now >= (forecast_time + timedelta(hours=3)):
-                date_str = forecast_time.strftime("%Y%m%d")
-                time_str = f"{run_hour:02d}"
-                return date_str, time_str, forecast_time
-        
-        # Fallback to previous day
-        yesterday = now - timedelta(days=1)
-        return yesterday.strftime("%Y%m%d"), "18", yesterday.replace(hour=18)
-    
-    def download_ecmwf_wind_data(self, step=0):
-        """Download ECMWF wind data at multiple levels"""
-        date_str, time_str, run_time = self.get_latest_forecast_info()
-        
-        # Download 10m wind components
-        u10_file, u10_status = self.download_parameter('10u', step)
-        v10_file, v10_status = self.download_parameter('10v', step)
-        
-        # Download 100m wind components  
-        u100_file, u100_status = self.download_parameter('100u', step)
-        v100_file, v100_status = self.download_parameter('100v', step)
-        
-        status_msg = f"✅ ECMWF Wind Data Retrieved!\nRun: {date_str} {time_str}z, Step: +{step}h\n"
-        status_msg += f"10m U-component: {u10_status}\n10m V-component: {v10_status}\n"
-        status_msg += f"100m U-component: {u100_status}\n100m V-component: {v100_status}"
-        
-        # Return both levels
-        wind_data = {
-            '10m': (u10_file, v10_file) if u10_file and v10_file else (None, None),
-            '100m': (u100_file, v100_file) if u100_file and v100_file else (None, None)
-        }
-        
-        return wind_data, status_msg
-    
-    def download_parameter(self, parameter, step=0):
-        """Download a specific ECMWF parameter using multiple methods"""
-        date_str, time_str, run_time = self.get_latest_forecast_info()
-        
-        # Method 1: Try ecmwf-opendata client (most reliable)
-        if OPENDATA_AVAILABLE and self.client:
-            try:
-                filename = os.path.join(self.temp_dir, f'ecmwf_{parameter}_{step}h_{datetime.now().strftime("%Y%m%d_%H%M%S")}.grib')
-                
-                self.client.retrieve(
-                    type="fc",
-                    param=parameter,
-                    step=step,
-                    target=filename
-                )
-                
-                if os.path.exists(filename) and os.path.getsize(filename) > 1000:
-                    return filename, f"✅ Downloaded via ECMWF client"
-                    
-            except Exception as e:
-                print(f"ECMWF client method failed: {str(e)}")
-        
-        # Method 2: Direct AWS S3 access (backup method)
-        try:
-            step_str = f"{step:03d}"
-            filename = f"{date_str}{time_str}0000-{step_str}h-oper-fc.grib2"
-            url = f"{self.aws_base_url}/{date_str}/{time_str}z/0p25/oper/{filename}"
-            
-            response = requests.get(url, timeout=120, stream=True)
-            if response.status_code == 200:
-                local_file = os.path.join(self.temp_dir, f'ecmwf_aws_{parameter}_{step}h.grib2')
-                
-                with open(local_file, 'wb') as f:
-                    for chunk in response.iter_content(chunk_size=8192):
-                        f.write(chunk)
-                
-                if os.path.getsize(local_file) > 1000:
-                    return local_file, f"✅ Downloaded via AWS S3"
-                    
-        except Exception as e:
-            print(f"AWS method failed: {str(e)}")
-        
-        return None, f"❌ Failed to download {parameter}"
-    
-    def extract_wind_data_from_grib(self, u_file, v_file, level_name, resolution=8):
-        """Extract wind data from ECMWF GRIB files with improved processing"""
-        try:
-            print(f"🌪️ Processing {level_name} ECMWF GRIB wind data...")
-            
-            # Open GRIB files with robust error handling
-            ds_u = None
-            ds_v = None
-            
-            try:
-                # Method 1: Standard xarray with cfgrib
-                ds_u = xr.open_dataset(u_file, engine='cfgrib')
-                ds_v = xr.open_dataset(v_file, engine='cfgrib')
-                print(f"✅ Opened {level_name} GRIB files with cfgrib")
-            except Exception as e1:
-                print(f"⚠️ cfgrib method failed: {e1}")
-                try:
-                    # Method 2: Alternative backend settings
-                    ds_u = xr.open_dataset(u_file, engine='cfgrib', backend_kwargs={'indexpath': ''})
-                    ds_v = xr.open_dataset(v_file, engine='cfgrib', backend_kwargs={'indexpath': ''})
-                    print(f"✅ Opened {level_name} GRIB files with alternative cfgrib settings")
-                except Exception as e2:
-                    print(f"❌ All GRIB opening methods failed: {e2}")
-                    return []
-            
-            # Debug: Print dataset info
-            print(f"📊 U dataset variables: {list(ds_u.data_vars.keys())}")
-            print(f"📊 U dataset coords: {list(ds_u.coords.keys())}")
-            print(f"📊 U dataset dims: {ds_u.dims}")
-            
-            # Get wind components - more robust variable detection
-            u_var = None
-            v_var = None
-            
-            # Try to find wind variables
-            for var in ds_u.data_vars.keys():
-                if 'u' in var.lower() or '10u' in var or '100u' in var:
-                    u_var = var
-                    break
-            
-            for var in ds_v.data_vars.keys():
-                if 'v' in var.lower() or '10v' in var or '100v' in var:
-                    v_var = var
-                    break
-            
-            if not u_var or not v_var:
-                print(f"❌ Could not find wind variables in {level_name} data")
-                return []
-            
-            print(f"🌬️ Using variables: U={u_var}, V={v_var}")
-            
-            u_data = ds_u[u_var]
-            v_data = ds_v[v_var]
-            
-            # Simple coordinate extraction - like working ECMWF code
-            if 'latitude' in ds_u.coords:
-                lats = ds_u.latitude.values
-                lons = ds_u.longitude.values
-            elif 'lat' in ds_u.coords:
-                lats = ds_u.lat.values
-                lons = ds_u.lon.values
-            else:
-                print(f"❌ Could not find coordinates in {level_name} data")
-                return []
-            
-            print(f"🗺️ Found coordinates: lats {lats.shape}, lons {lons.shape}")
-            print(f"🗺️ Lat range: {lats.min():.2f} to {lats.max():.2f}")
-            print(f"🗺️ Lon range: {lons.min():.2f} to {lons.max():.2f}")
-            
-            # Get data values - handle time dimension
-            u_values = u_data.values
-            v_values = v_data.values
-            
-            if u_values.ndim > 2:
-                print(f"🕐 Selecting first time/level from {u_values.ndim}D data")
-                while u_values.ndim > 2:
-                    u_values = u_values[0]
-                    v_values = v_values[0]
-            
-            print(f"📐 Data shape: {u_values.shape}")
-            print(f"📐 Coord shapes: lats={len(lats)}, lons={len(lons)}")
-            
-            # Smart subsampling based on resolution
-            if resolution >= 10:
-                step = max(1, len(lats) // 50)  # Limit to ~50 points per dimension
-            else:
-                step = max(1, int(resolution // 2))
-            
-            print(f"⬇️ Subsampling every {step} points")
-            
-            lats_sub = lats[::step]
-            lons_sub = lons[::step]
-            u_sub = u_values[::step, ::step]
-            v_sub = v_values[::step, ::step]
-            
-            # Create wind data points
-            wind_data = []
-            valid_points = 0
-            
-            print(f"🔍 Creating wind data points from subsampled coordinates:")
-            print(f"🔍 lats_sub range: {lats_sub.min():.2f} to {lats_sub.max():.2f} (shape: {lats_sub.shape})")
-            print(f"🔍 lons_sub range: {lons_sub.min():.2f} to {lons_sub.max():.2f} (shape: {lons_sub.shape})")
-            print(f"🔍 First 3 lats_sub: {lats_sub[:3]}")
-            print(f"🔍 First 3 lons_sub: {lons_sub[:3]}")
-            print(f"🔍 u_sub shape: {u_sub.shape}, v_sub shape: {v_sub.shape}")
-            print(f"🔍 Will iterate: {len(lats_sub)} lats × {len(lons_sub)} lons = {len(lats_sub)*len(lons_sub)} potential points")
-            
-            for i, lat in enumerate(lats_sub):
-                print(f"🔍 Processing lat row {i}: lat={lat:.2f}")
-                for j, lon in enumerate(lons_sub):
-                    if i < len(u_sub) and j < len(u_sub[i]):
-                        try:
-                            u_wind = float(u_sub[i, j])
-                            v_wind = float(v_sub[i, j])
-                            
-                            # Skip invalid data (NaN, extreme values)
-                            if np.isnan(u_wind) or np.isnan(v_wind):
-                                continue
-                            if abs(u_wind) > 200 or abs(v_wind) > 200:  # Sanity check
-                                continue
-                            
-                            # Calculate speed and direction
-                            speed = float(np.sqrt(u_wind**2 + v_wind**2))
-                            direction = float(np.degrees(np.arctan2(v_wind, u_wind)))
-                            
-                            # Normalize direction to 0-360
-                            if direction < 0:
-                                direction += 360
-                            
-                            wind_data.append({
-                                'lat': float(lat),
-                                'lon': float(lon),
-                                'u': u_wind,
-                                'v': v_wind,
-                                'speed': speed,
-                                'direction': direction,
-                                'level': level_name
-                            })
-                            valid_points += 1
-                            
-                            # Debug ALL points in first few rows
-                            if i <= 3 or valid_points <= 10:
-                                print(f"🔍 Point {valid_points+1}: i={i}, j={j}, lat={lat:.4f}, lon={lon:.4f}, speed={speed:.2f}")
-                            
-                        except (ValueError, TypeError) as e:
-                            continue  # Skip invalid data points
-            
-            print(f"✅ Processed {valid_points} valid {level_name} wind data points")
-            
-            # Close datasets to free memory
-            ds_u.close()
-            ds_v.close()
-            
-            return wind_data
-            
-        except Exception as e:
-            print(f"❌ Error processing {level_name} GRIB files: {str(e)}")
-            import traceback
-            traceback.print_exc()
-            return []
-
-def get_wind_data(lat_min=-90, lat_max=90, lon_min=-180, lon_max=180, resolution=8):
-    """
-    Fetch REAL ECMWF wind data at multiple levels using proven methodology
-    """
-    try:
-        print(f"🌍 Fetching ECMWF wind data at 10m and 100m levels (resolution: {resolution}°)...")
-        
-        # Create ECMWF data fetcher
-        fetcher = ECMWFWindDataFetcher()
-        
-        # Download ECMWF wind data for both levels
-        wind_files, status = fetcher.download_ecmwf_wind_data(step=0)
-        
-        all_wind_data = []
-        
-        # Process 10m wind data
-        if wind_files['10m'][0] and wind_files['10m'][1]:
-            u10_file, v10_file = wind_files['10m']
-            wind_data_10m = fetcher.extract_wind_data_from_grib(u10_file, v10_file, '10m', resolution)
-            if wind_data_10m:
-                all_wind_data.extend(wind_data_10m)
-        
-        # Process 100m wind data
-        if wind_files['100m'][0] and wind_files['100m'][1]:
-            u100_file, v100_file = wind_files['100m']
-            wind_data_100m = fetcher.extract_wind_data_from_grib(u100_file, v100_file, '100m', resolution)
-            if wind_data_100m:
-                all_wind_data.extend(wind_data_100m)
-        
-        if all_wind_data:
-            # Filter data to requested region
-            filtered_data = [
-                wd for wd in all_wind_data 
-                if lat_min <= wd['lat'] <= lat_max and lon_min <= wd['lon'] <= lon_max
-            ]
-            
-            print(f"✅ Successfully processed {len(filtered_data)} total ECMWF wind points")
-            return filtered_data if filtered_data else all_wind_data, status
-        else:
-            print("⚠️ GRIB processing failed, falling back to synthetic data")
-            return generate_synthetic_wind_data(), status
-        
-    except Exception as e:
-        print(f"❌ Error in ECMWF wind data fetching: {e}")
-        print("🔄 Falling back to synthetic wind data...")
-        return generate_synthetic_wind_data(), f"❌ Error: {str(e)}"
-
-def generate_synthetic_wind_data():
-    """Fallback synthetic data - similar to working windmap"""
-    print("🎯 Generating synthetic wind data as fallback...")
-    
-    wind_data = []
-    for lat in range(-60, 61, 15):
-        for lon in range(-180, 181, 20):
-            # Realistic wind patterns
-            lat_rad = np.radians(lat)
-            lon_rad = np.radians(lon)
-            
-            # Jet stream + trade winds + noise
-            u = 15 * np.sin(lat_rad) + 5 * np.cos(lon_rad/2) + np.random.normal(0, 3)
-            v = 5 * np.cos(lat_rad) + 3 * np.sin(lon_rad/3) + np.random.normal(0, 2)
-            speed = np.sqrt(u*u + v*v)
-            
-            wind_data.append({
-                'lat': lat,
-                'lon': lon,
-                'u': u,
-                'v': v,
-                'speed': speed,
-                'direction': np.degrees(np.arctan2(v, u))
-            })
-    
-    print(f"✅ Generated {len(wind_data)} synthetic wind points")
-    return wind_data
-
-def create_wind_arrow_map(wind_data):
-    """
-    Create wind arrow visualization using folium
-    """
-    try:
-        print("🌪️ Creating wind arrow visualization...")
-        
-        if not wind_data:
-            return "<p>❌ No wind data available</p>"
-        
-        # Create folium map
-        m = folium.Map(
-            location=[30, 0],
-            zoom_start=3,
-            tiles='OpenStreetMap'
-        )
-        
-        # Create separate feature groups for each wind level
-        wind_10m_layer = folium.FeatureGroup(name="10m Wind Data", show=True)
-        wind_100m_layer = folium.FeatureGroup(name="100m Wind Data", show=True)
-        wind_particles_layer = folium.FeatureGroup(name="10m Wind Particles", show=False)
-        wind_hexagonal_layer = folium.FeatureGroup(name="10m Hexagonal Grid", show=False)
-        
-        # Separate data by level
-        wind_10m = [w for w in wind_data if w.get('level') == '10m']
-        wind_100m = [w for w in wind_data if w.get('level') == '100m']
-        
-        print(f"📊 Wind data: {len(wind_10m)} points at 10m, {len(wind_100m)} points at 100m")
-        
-        # Debug: Show lat distribution in final wind_data
-        if wind_10m:
-            lats_10m = [w["lat"] for w in wind_10m[:10]]
-            print(f"🔍 First 10 lats in wind_10m: {lats_10m}")
-            unique_lats = set(w["lat"] for w in wind_10m)
-            print(f"🔍 Unique latitudes in 10m data: {sorted(list(unique_lats))[:10]}... (showing first 10)")
-        # Debug: Show sample coordinates
-        if wind_10m:
-            sample = wind_10m[0]
-            print(f"🗺️ Sample 10m wind: Lat={sample['lat']:.2f}, Lon={sample['lon']:.2f}, Speed={sample['speed']:.1f} m/s, Dir={sample['direction']:.0f}°")
-        if wind_100m:
-            sample = wind_100m[0]
-            print(f"🗺️ Sample 100m wind: Lat={sample['lat']:.2f}, Lon={sample['lon']:.2f}, Speed={sample['speed']:.1f} m/s, Dir={sample['direction']:.0f}°")
-        
-        # Show ALL 10m wind points for complete global coverage and accurate positioning
-        print(f"🌍 Displaying ALL {len(wind_10m)} 10m wind points for full global coverage")
-        if wind_10m:
-            # Show coordinate distribution
-            lats_10m = [w['lat'] for w in wind_10m]
-            lons_10m = [w['lon'] for w in wind_10m]
-            print(f"🗺️ 10m lat range: {min(lats_10m):.1f}° to {max(lats_10m):.1f}°")
-            print(f"🗺️ 10m lon range: {min(lons_10m):.1f}° to {max(lons_10m):.1f}°")
-            print(f"🗺️ Sample 10m coordinates: {[(lats_10m[i], lons_10m[i]) for i in [0, len(lats_10m)//4, len(lats_10m)//2, 3*len(lats_10m)//4, -1]]}")
-        
-        # Add ALL 10m wind points exactly as they exist in GRIB files
-        for i, wind in enumerate(wind_10m):
-            if wind['speed'] > 1:  # Only show significant winds
-                
-                # Add circle marker for 10m data (BLUE)
-                folium.CircleMarker(
-                    location=[wind['lat'], wind['lon']],
-                    radius=4,
-                    color='blue',
-                    fillColor='lightblue',
-                    fillOpacity=0.6,
-                    popup=f"<b>10m Wind #{i+1}</b><br>Speed: {wind['speed']:.1f} m/s<br>Direction: {wind['direction']:.0f}°<br>U: {wind['u']:.1f} m/s<br>V: {wind['v']:.1f} m/s<br>Lat: {wind['lat']:.4f}<br>Lon: {wind['lon']:.4f}",
-                    tooltip=f"10m: {wind['speed']:.1f}m/s"
-                ).add_to(wind_10m_layer)
-                
-                # Add arrow marker for every 20th point to show direction without overcrowding
-                if i % 20 == 0:
-                    # Calculate arrow length based on wind speed
-                    arrow_length = min(wind['speed'] * 1.5, 15)
-                    
-                    # Convert meteorological direction to mathematical angle
-                    arrow_angle = (90 - wind['direction']) % 360
-                    
-                    # Create simple arrow SVG (BLUE)
-                    arrow_svg = f"""
-                    <svg width="25" height="25" style="overflow: visible;">
-                        <g transform="rotate({arrow_angle} 12.5 12.5)">
-                            <line x1="4" y1="12.5" x2="{17}" y2="12.5" stroke="darkblue" stroke-width="2" marker-end="url(#arrowhead-blue{i})"/>
-                        </g>
-                        <defs>
-                            <marker id="arrowhead-blue{i}" markerWidth="8" markerHeight="6" 
-                                    refX="7" refY="3" orient="auto">
-                                <polygon points="0 0, 8 3, 0 6" fill="darkblue"/>
-                            </marker>
-                        </defs>
-                    </svg>
-                    """
-                    
-                    folium.Marker(
-                        location=[wind['lat'], wind['lon']],
-                        icon=folium.DivIcon(
-                            html=arrow_svg,
-                            icon_size=(25, 25),
-                            icon_anchor=(12.5, 12.5)
-                        ),
-                        popup=f"<b>10m Arrow #{i+1}</b><br>Speed: {wind['speed']:.1f} m/s<br>Direction: {wind['direction']:.0f}°<br>Lat: {wind['lat']:.4f}<br>Lon: {wind['lon']:.4f}"
-                    ).add_to(wind_10m_layer)
-        
-        # Show ALL 100m wind points for complete global coverage and accurate positioning  
-        print(f"🌍 Displaying ALL {len(wind_100m)} 100m wind points for full global coverage")
-        if wind_100m:
-            # Show coordinate distribution
-            lats_100m = [w['lat'] for w in wind_100m]
-            lons_100m = [w['lon'] for w in wind_100m]
-            print(f"🗺️ 100m lat range: {min(lats_100m):.1f}° to {max(lats_100m):.1f}°")
-            print(f"🗺️ 100m lon range: {min(lons_100m):.1f}° to {max(lons_100m):.1f}°")
-            print(f"🗺️ Sample 100m coordinates: {[(lats_100m[i], lons_100m[i]) for i in [0, len(lats_100m)//4, len(lats_100m)//2, 3*len(lats_100m)//4, -1]]}")
-        
-        # Add ALL 100m wind points exactly as they exist in GRIB files
-        for i, wind in enumerate(wind_100m):
-            if wind['speed'] > 1:  # Only show significant winds
-                
-                # Add circle marker for 100m data (RED)
-                folium.CircleMarker(
-                    location=[wind['lat'], wind['lon']],
-                    radius=4,
-                    color='red',
-                    fillColor='lightcoral',
-                    fillOpacity=0.6,
-                    popup=f"<b>100m Wind #{i+1}</b><br>Speed: {wind['speed']:.1f} m/s<br>Direction: {wind['direction']:.0f}°<br>U: {wind['u']:.1f} m/s<br>V: {wind['v']:.1f} m/s<br>Lat: {wind['lat']:.4f}<br>Lon: {wind['lon']:.4f}",
-                    tooltip=f"100m: {wind['speed']:.1f}m/s"
-                ).add_to(wind_100m_layer)
-                
-                # Add arrow marker for every 20th point to show direction without overcrowding
-                if i % 20 == 0:
-                    # Calculate arrow length based on wind speed
-                    arrow_length = min(wind['speed'] * 1.5, 15)
-                    
-                    # Convert meteorological direction to mathematical angle
-                    arrow_angle = (90 - wind['direction']) % 360
-                    
-                    # Create simple arrow SVG (RED)
-                    arrow_svg = f"""
-                    <svg width="25" height="25" style="overflow: visible;">
-                        <g transform="rotate({arrow_angle} 12.5 12.5)">
-                            <line x1="4" y1="12.5" x2="{17}" y2="12.5" stroke="darkred" stroke-width="2" marker-end="url(#arrowhead-red{i})"/>
-                        </g>
-                        <defs>
-                            <marker id="arrowhead-red{i}" markerWidth="8" markerHeight="6" 
-                                    refX="7" refY="3" orient="auto">
-                                <polygon points="0 0, 8 3, 0 6" fill="darkred"/>
-                            </marker>
-                        </defs>
-                    </svg>
-                    """
-                    
-                    folium.Marker(
-                        location=[wind['lat'], wind['lon']],
-                        icon=folium.DivIcon(
-                            html=arrow_svg,
-                            icon_size=(25, 25),
-                            icon_anchor=(12.5, 12.5)
-                        ),
-                        popup=f"<b>100m Arrow #{i+1}</b><br>Speed: {wind['speed']:.1f} m/s<br>Direction: {wind['direction']:.0f}°<br>Lat: {wind['lat']:.4f}<br>Lon: {wind['lon']:.4f}"
-                    ).add_to(wind_100m_layer)
-        
-        # Create TimestampedGeoJson wind particle animation (windy-style)
-        if wind_10m:
-            print(f"🌪️ Creating TimestampedGeoJson wind particle animation for {len(wind_10m)} wind points")
-            
-            def create_particle_trajectories(wind_data, num_particles=1000, trajectory_length=20, time_steps=30):
-                """Create particle trajectories for TimestampedGeoJson animation"""
-                
-                features = []
-                particle_id = 0
-                
-                # Create multiple particles across the wind field
-                for wind in wind_data[::max(1, len(wind_data)//200)]:  # Sample wind points
-                    if wind['speed'] > 1:
-                        
-                        # Create multiple particles per wind point with random distribution
-                        for _ in range(5):  # 5 particles per wind point
-                            if particle_id >= num_particles:
-                                break
-                            
-                            # Random starting offset for particle distribution
-                            start_lat = wind['lat'] + np.random.uniform(-0.2, 0.2)
-                            start_lon = wind['lon'] + np.random.uniform(-0.2, 0.2)
-                            
-                            # Ensure valid coordinates
-                            start_lat = max(-90, min(90, start_lat))
-                            start_lon = max(-180, min(180, start_lon))
-                            
-                            # Create trajectory points based on wind field
-                            trajectory_coords = []
-                            current_lat, current_lon = start_lat, start_lon
-                            
-                            for step in range(trajectory_length):
-                                # Add current position
-                                trajectory_coords.append([current_lon, current_lat])
-                                
-                                # Move particle based on wind field (simplified advection)
-                                # Scale movement by wind speed and add some randomness
-                                movement_scale = 0.01 * (wind['speed'] / 10) + np.random.uniform(-0.005, 0.005)
-                                
-                                direction_rad = np.radians(wind['direction'])
-                                lat_movement = movement_scale * np.sin(direction_rad)
-                                lon_movement = movement_scale * np.cos(direction_rad)
-                                
-                                current_lat += lat_movement
-                                current_lon += lon_movement
-                                
-                                # Keep particles in bounds
-                                current_lat = max(-90, min(90, current_lat))
-                                current_lon = max(-180, min(180, current_lon))
-                            
-                            # Create timestamped features for this particle trajectory
-                            for time_step in range(time_steps):
-                                coord_index = int((time_step / time_steps) * (len(trajectory_coords) - 1))
-                                
-                                # High contrast particle styling based on speed
-                                if wind['speed'] < 5:
-                                    color = '#00ff41'  # Bright green for low speed
-                                elif wind['speed'] < 15:
-                                    color = '#ffff00'  # Bright yellow for medium speed  
-                                else:
-                                    color = '#ff4136'  # Bright red for high speed
-                                
-                                # Create feature with timestamp
-                                feature = {
-                                    "type": "Feature",
-                                    "geometry": {
-                                        "type": "Point",
-                                        "coordinates": trajectory_coords[coord_index]
-                                    },
-                                    "properties": {
-                                        "time": f"2024-01-01T00:{time_step:02d}:00",  # Timestamp for animation
-                                        "style": {
-                                            "color": color,
-                                            "fillColor": color,
-                                            "fillOpacity": 0.8,
-                                            "weight": 2,
-                                            "radius": max(3, min(8, int(wind['speed'] / 2)))
-                                        },
-                                        "popup": f"Particle {particle_id}<br>Speed: {wind['speed']:.1f} m/s<br>Direction: {wind['direction']:.0f}°",
-                                        "particle_id": particle_id,
-                                        "wind_speed": wind['speed'],
-                                        "wind_direction": wind['direction']
-                                    }
-                                }
-                                features.append(feature)
-                            
-                            particle_id += 1
-                
-                return features
-            
-            # Generate particle trajectories
-            particle_features = create_particle_trajectories(wind_10m)
-            
-            # Create TimestampedGeoJson for animated particles
-            from folium.plugins import TimestampedGeoJson
-            
-            timestamped_data = {
-                "type": "FeatureCollection",
-                "features": particle_features
-            }
-            
-            # Add TimestampedGeoJson to map
-            TimestampedGeoJson(
-                timestamped_data,
-                period="PT1S",
-                auto_play=True,
-                loop=True,
-                max_speed=3,
-                loop_button=True,
-                time_slider_drag_update=True
-            ).add_to(wind_particles_layer)
-            
-            print(f"🌪️ Created {len(particle_features)} timestamped particle positions")
-            
-            # Add info marker
-            folium.Marker(
-                location=[0, 0],
-                icon=folium.DivIcon(
-                    html=f'<div style="background: rgba(0,150,0,0.8); color: white; padding: 5px; border-radius: 3px; font-size: 12px;">TimestampedGeoJson Particles: {len(set(f["properties"]["particle_id"] for f in particle_features))} Active</div>',
-                    icon_size=(350, 30),
-                    icon_anchor=(175, 15)
-                ),
-                popup=f"<b>Wind Particle Animation</b><br>Particles: {len(set(f['properties']['particle_id'] for f in particle_features))}<br>High contrast windy-style animation<br>Auto-playing with 30s loop"
-            ).add_to(wind_particles_layer)
-        
-        # Create hexagonal grid wind visualization (H3-inspired)
-        if wind_10m:
-            print(f"🔷 Creating hexagonal grid wind visualization for {len(wind_10m)} wind points")
-            
-            def generate_hexagonal_grid(bounds, resolution=0.5):
-                """Generate hexagonal grid points within bounds"""
-                lat_min, lat_max, lon_min, lon_max = bounds
-                
-                hex_points = []
-                hex_spacing = resolution
-                row_offset = hex_spacing * np.sqrt(3) / 2
-                
-                lat = lat_min
-                row = 0
-                while lat <= lat_max:
-                    # Offset every other row for hexagonal pattern
-                    lon_start = lon_min + (hex_spacing / 2 if row % 2 else 0)
-                    lon = lon_start
-                    
-                    while lon <= lon_max:
-                        hex_points.append((lat, lon))
-                        lon += hex_spacing
-                    
-                    lat += row_offset
-                    row += 1
-                
-                return hex_points
-            
-            def interpolate_wind_at_point(target_lat, target_lon, wind_data, max_distance=2.0):
-                """Interpolate wind values at a specific point using inverse distance weighting"""
-                if not wind_data:
-                    return None
-                
-                nearby_winds = []
-                weights = []
-                
-                for wind in wind_data:
-                    # Calculate distance using simple lat/lon difference
-                    dist = np.sqrt((wind['lat'] - target_lat)**2 + (wind['lon'] - target_lon)**2)
-                    
-                    if dist < max_distance:  # Only use nearby points
-                        nearby_winds.append(wind)
-                        weights.append(1 / (dist + 0.01))  # Avoid division by zero
-                
-                if not weights:
-                    return None
-                
-                # Weighted average of nearby wind points
-                total_weight = sum(weights)
-                weighted_u = sum(w * wind['u'] for w, wind in zip(weights, nearby_winds)) / total_weight
-                weighted_v = sum(w * wind['v'] for w, wind in zip(weights, nearby_winds)) / total_weight
-                weighted_speed = np.sqrt(weighted_u**2 + weighted_v**2)
-                weighted_direction = np.degrees(np.arctan2(weighted_v, weighted_u))
-                
-                if weighted_direction < 0:
-                    weighted_direction += 360
-                
-                return {
-                    'u': weighted_u,
-                    'v': weighted_v,
-                    'speed': weighted_speed,
-                    'direction': weighted_direction
-                }
-            
-            # Calculate bounds from wind data
-            lats = [w['lat'] for w in wind_10m]
-            lons = [w['lon'] for w in wind_10m]
-            bounds = (min(lats), max(lats), min(lons), max(lons))
-            
-            # Generate hexagonal grid with appropriate resolution  
-            hex_resolution = 5.0  # Larger spacing for better performance
-            hex_points = generate_hexagonal_grid(bounds, hex_resolution)
-            
-            print(f"🔷 Generated {len(hex_points)} hexagonal grid points")
-            
-            # Create wind arrows on hexagonal grid
-            hex_arrow_count = 0
-            for hex_lat, hex_lon in hex_points:
-                if hex_arrow_count >= 150:  # Reduced limit for better performance
-                    break
-                
-                # Interpolate wind at this hexagonal grid point
-                interpolated_wind = interpolate_wind_at_point(hex_lat, hex_lon, wind_10m, max_distance=3.0)
-                
-                if interpolated_wind and interpolated_wind['speed'] > 1:
-                    # Create hexagonal-based arrow
-                    arrow_length = min(interpolated_wind['speed'] * 2, 20)
-                    arrow_angle = (90 - interpolated_wind['direction']) % 360
-                    
-                    # Speed-based color (green to yellow to red)
-                    if interpolated_wind['speed'] < 5:
-                        arrow_color = f"rgb(0, {int(interpolated_wind['speed'] * 50)}, 0)"
-                    elif interpolated_wind['speed'] < 15:
-                        yellow_intensity = int((interpolated_wind['speed'] - 5) * 25)
-                        arrow_color = f"rgb({yellow_intensity}, 255, 0)"
-                    else:
-                        red_intensity = min(255, int(interpolated_wind['speed'] * 10))
-                        arrow_color = f"rgb(255, {255 - red_intensity}, 0)"
-                    
-                    # Create hexagonal background with arrow
-                    hex_svg = f"""
-                    <svg width="40" height="40" style="overflow: visible;">
-                        <defs>
-                            <marker id="hexarrow{hex_arrow_count}" markerWidth="8" markerHeight="6" 
-                                    refX="7" refY="3" orient="auto">
-                                <polygon points="0 0, 8 3, 0 6" fill="{arrow_color}"/>
-                            </marker>
-                        </defs>
-                        <!-- Hexagonal background -->
-                        <polygon points="20,5 30,12 30,28 20,35 10,28 10,12" 
-                                 fill="rgba(50, 150, 50, 0.2)" 
-                                 stroke="rgba(0, 100, 0, 0.6)" 
-                                 stroke-width="1"/>
-                        <!-- Wind arrow -->
-                        <g transform="rotate({arrow_angle} 20 20)">
-                            <line x1="8" y1="20" x2="{8 + arrow_length}" y2="20" 
-                                  stroke="{arrow_color}" 
-                                  stroke-width="3" 
-                                  marker-end="url(#hexarrow{hex_arrow_count})"/>
-                        </g>
-                        <!-- Center dot -->
-                        <circle cx="20" cy="20" r="2" fill="rgba(255, 255, 255, 0.8)"/>
-                    </svg>
-                    """
-                    
-                    folium.Marker(
-                        location=[hex_lat, hex_lon],
-                        icon=folium.DivIcon(
-                            html=hex_svg,
-                            icon_size=(40, 40),
-                            icon_anchor=(20, 20),
-                            class_name="hexagonal-wind-marker"
-                        ),
-                        popup=f"<b>Hexagonal Grid Wind</b><br>Speed: {interpolated_wind['speed']:.1f} m/s<br>Direction: {interpolated_wind['direction']:.0f}°<br>U: {interpolated_wind['u']:.1f} m/s<br>V: {interpolated_wind['v']:.1f} m/s<br>Grid: ({hex_lat:.2f}, {hex_lon:.2f})"
-                    ).add_to(wind_hexagonal_layer)
-                    
-                    hex_arrow_count += 1
-            
-            print(f"🔷 Created {hex_arrow_count} hexagonal wind arrows")
-        
-        # Add the feature groups to the map
-        wind_10m_layer.add_to(m)
-        wind_100m_layer.add_to(m)
-        wind_particles_layer.add_to(m)
-        wind_hexagonal_layer.add_to(m)
-        
-        # Add layer control to toggle layers on/off
-        folium.LayerControl(
-            position='topleft',
-            collapsed=False
-        ).add_to(m)
-        
-        # Add legend
-        legend_html = '''
-        <div style="position: fixed; 
-                    top: 10px; right: 10px; width: 260px; height: 200px; 
-                    background-color: white; border:2px solid grey; z-index:9999; 
-                    font-size:12px; padding: 10px">
-        <h4>ECMWF Wind Data Legend</h4>
-        <p><span style="color:blue;">●</span> 10m Wind Data (Blue)</p>
-        <p><span style="color:red;">●</span> 100m Wind Data (Red)</p>
-        <p><span style="color:darkblue;">→</span> 10m Wind Arrows</p>
-        <p><span style="color:darkred;">→</span> 100m Wind Arrows</p>
-        <p><span style="color:cyan;">◦</span> 10m Wind Particles (Velocity)</p>
-        <p><span style="color:green;">⬡</span> 10m Hexagonal Grid (H3-style)</p>
-        <p><small>All points from GRIB files<br>Arrows show every 20th point<br>Particles show velocity field flow<br>Hexagons use interpolated wind data<br><br>Use layer control (top-left) to toggle layers</small></p>
-        </div>
-        '''
-        m.get_root().html.add_child(folium.Element(legend_html))
-        
-        # Add zoom-responsive CSS and JavaScript for particle scaling
-        zoom_responsive_css = '''
-        <style>
-        .wind-particle-marker {
-            transition: transform 0.3s ease;
-        }
-        
-        .hexagonal-wind-marker {
-            transition: transform 0.3s ease;
-        }
-        
-        /* Base scaling for different zoom levels */
-        .leaflet-zoom-anim .wind-particle-marker,
-        .leaflet-zoom-anim .hexagonal-wind-marker {
-            transition: none;
-        }
-        
-        /* Zoom level adjustments */
-        .leaflet-container[data-zoom="1"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="2"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="1"] .hexagonal-wind-marker svg,
-        .leaflet-container[data-zoom="2"] .hexagonal-wind-marker svg {
-            transform: scale(0.3);
-        }
-        
-        .leaflet-container[data-zoom="3"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="4"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="3"] .hexagonal-wind-marker svg,
-        .leaflet-container[data-zoom="4"] .hexagonal-wind-marker svg {
-            transform: scale(0.5);
-        }
-        
-        .leaflet-container[data-zoom="5"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="6"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="5"] .hexagonal-wind-marker svg,
-        .leaflet-container[data-zoom="6"] .hexagonal-wind-marker svg {
-            transform: scale(0.7);
-        }
-        
-        .leaflet-container[data-zoom="7"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="8"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="7"] .hexagonal-wind-marker svg,
-        .leaflet-container[data-zoom="8"] .hexagonal-wind-marker svg {
-            transform: scale(0.9);
-        }
-        
-        .leaflet-container[data-zoom="9"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="10"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="9"] .hexagonal-wind-marker svg,
-        .leaflet-container[data-zoom="10"] .hexagonal-wind-marker svg {
-            transform: scale(1.0);
-        }
-        
-        .leaflet-container[data-zoom="11"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="12"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="11"] .hexagonal-wind-marker svg,
-        .leaflet-container[data-zoom="12"] .hexagonal-wind-marker svg {
-            transform: scale(1.2);
-        }
-        
-        .leaflet-container[data-zoom="13"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="14"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="13"] .hexagonal-wind-marker svg,
-        .leaflet-container[data-zoom="14"] .hexagonal-wind-marker svg {
-            transform: scale(1.5);
-        }
-        
-        .leaflet-container[data-zoom="15"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="16"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="17"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="18"] .wind-particle-marker svg,
-        .leaflet-container[data-zoom="15"] .hexagonal-wind-marker svg,
-        .leaflet-container[data-zoom="16"] .hexagonal-wind-marker svg,
-        .leaflet-container[data-zoom="17"] .hexagonal-wind-marker svg,
-        .leaflet-container[data-zoom="18"] .hexagonal-wind-marker svg {
-            transform: scale(2.0);
-        }
-        </style>
-        '''
-        m.get_root().html.add_child(folium.Element(zoom_responsive_css))
-        
-        # Add JavaScript for zoom-responsive particle scaling
-        zoom_responsive_js = '''
-        <script>
-        // Add zoom-responsive particle scaling
-        document.addEventListener('DOMContentLoaded', function() {
-            // Wait for the map to be ready
-            setTimeout(function() {
-                var mapElement = document.querySelector('.folium-map');
-                if (mapElement && mapElement._leaflet_map) {
-                    var map = mapElement._leaflet_map;
-                    var mapContainer = map.getContainer();
-                    
-                    function updateZoomClass() {
-                        var zoom = Math.round(map.getZoom());
-                        mapContainer.setAttribute('data-zoom', zoom);
-                    }
-                    
-                    // Set initial zoom
-                    updateZoomClass();
-                    
-                    // Update on zoom change
-                    map.on('zoomend', updateZoomClass);
-                    map.on('zoom', updateZoomClass);
-                    
-                    console.log('Wind particle zoom responsiveness initialized');
-                }
-            }, 1000);
-        });
-        </script>
-        '''
-        m.get_root().html.add_child(folium.Element(zoom_responsive_js))
-        
-        return m._repr_html_()
-        
-    except Exception as e:
-        return f"<p>❌ Error creating wind map: {str(e)}</p>"
-
-def fetch_and_visualize_winds(resolution=8):
-    """Main function to fetch and visualize wind data"""
-    try:
-        status_msg = "🌍 Fetching real-time ECMWF wind data at 10m and 100m levels..."
-        
-        # Fetch real wind data
-        wind_data, download_status = get_wind_data(resolution=resolution)
-        
-        if not wind_data:
-            return "❌ No wind data could be fetched", ""
-        
-        # Create wind arrow map
-        wind_map = create_wind_arrow_map(wind_data)
-        
-        # Count data by level
-        wind_10m_count = len([w for w in wind_data if w.get('level') == '10m'])
-        wind_100m_count = len([w for w in wind_data if w.get('level') == '100m'])
-        
-        status_msg = f"""✅ ECMWF Wind Data Successfully Retrieved!
-
-{download_status}
-
-📊 Data Summary:
-• Total wind measurements: {len(wind_data)} points
-• 10m wind data: {wind_10m_count} points
-• 100m wind data: {wind_100m_count} points
-• Data source: ECMWF Operational Forecasts
-• Resolution: 0.25° (~25km) ECMWF grid
-• Grid spacing: {resolution}° display resolution
-• Update time: {datetime.now().strftime('%H:%M:%S UTC')}
-
-🏹 Wind Arrow Visualization:
-• Blue arrows = 10m wind data
-• Red arrows = 100m wind data
-• Arrow length = wind speed
-• Arrow direction = wind direction
-• Click arrows for detailed wind info (U/V components)
-• Interactive map with zoom/pan controls
-
-🎯 Features:
-• Real ECMWF GRIB file processing
-• Multi-level wind comparison (10m vs 100m)
-• Professional meteorological data
-• Same data source as earth.nullschool.net
-• Clean arrow-based visualization"""
-
-        return status_msg, wind_map
-        
-    except Exception as e:
-        return f"❌ Error: {str(e)}", ""
-
-# Create Gradio interface
-with gr.Blocks(title="ECMWF Wind Visualization", theme=gr.themes.Soft()) as app:
-    gr.Markdown("""
-    # 🌪️ ECMWF Wind Visualization
-    ## Multi-Level Wind Data with Arrow Visualization
-    
-    **Features:**
-    - 🌍 Real ECMWF operational forecast data
-    - 🏹 Wind arrows at 10m and 100m levels
-    - 📊 Professional meteorological visualization
-    - 🎯 Same data source as earth.nullschool.net
-    - 📈 Compare wind speeds at different altitudes
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### ⚙️ Controls")
-            
-            resolution_slider = gr.Slider(
-                minimum=8,
-                maximum=20,
-                value=12,
-                step=2,
-                label="Grid Resolution (degrees)",
-                info="Lower = more detail, slower loading"
-            )
-            
-            fetch_btn = gr.Button(
-                "🏹 Fetch ECMWF Wind Data & Visualize",
-                variant="primary",
-                size="lg"
-            )
-            
-            status_output = gr.Textbox(
-                label="Status",
-                lines=20,
-                interactive=False
-            )
-        
-        with gr.Column(scale=2):
-            gr.Markdown("### 🗺️ Wind Arrow Visualization")
-            wind_map_output = gr.HTML(
-                label="ECMWF Wind Data Arrows",
-                value="<p>Click 'Fetch ECMWF Wind Data' to see wind arrows at 10m and 100m levels!</p>"
-            )
-    
-    # Event handlers
-    fetch_btn.click(
-        fetch_and_visualize_winds,
-        inputs=[resolution_slider],
-        outputs=[status_output, wind_map_output]
-    )
-    
-    gr.Markdown("""
-    ---
-    ### 📖 About This App
-    
-    This application uses **real ECMWF operational forecast data** to visualize wind patterns at multiple atmospheric levels.
-    
-    **Technical Features:**
-    - Professional ECMWF operational forecasts at 10m and 100m levels
-    - Same data source as earth.nullschool.net
-    - Wind arrow visualization showing speed and direction
-    - Real U/V wind component processing from GRIB files
-    - Multi-level wind comparison capabilities
-    - Color-coded wind arrows (blue=10m, red=100m)
-    - Interactive Leaflet map integration
-    
-    **Data Source:** ECMWF Open Data - Professional meteorological forecasts at 0.25° resolution
-    """)
-
-if __name__ == "__main__":
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )

app.py.backup

@@ -1,692 +0,0 @@
-#!/usr/bin/env python3
-"""
-ECMWF Wind Visualization with Real Data
-Based on proven particle technology from windmap project
-"""
-
-import gradio as gr
-import numpy as np
-import pandas as pd
-import folium
-import requests
-import json
-import time
-import tempfile
-import os
-import xarray as xr
-from datetime import datetime, timedelta
-import warnings
-warnings.filterwarnings('ignore')
-
-try:
-    from ecmwf.opendata import Client as OpenDataClient
-    OPENDATA_AVAILABLE = True
-except ImportError:
-    OPENDATA_AVAILABLE = False
-
-class ECMWFWindDataFetcher:
-    def __init__(self):
-        self.temp_dir = tempfile.mkdtemp()
-        self.client = None
-        if OPENDATA_AVAILABLE:
-            try:
-                self.client = OpenDataClient()
-            except:
-                self.client = None
-        
-        # AWS S3 direct access URLs (completely free)
-        self.aws_base_url = "https://ecmwf-forecasts.s3.eu-central-1.amazonaws.com"
-    
-    def get_latest_forecast_info(self):
-        """Get the latest available ECMWF forecast run info"""
-        now = datetime.utcnow()
-        
-        # ECMWF runs at 00, 06, 12, 18 UTC
-        forecast_hours = [0, 6, 12, 18]
-        
-        # Find the most recent forecast run
-        for hours_back in range(0, 24, 6):
-            check_time = now - timedelta(hours=hours_back)
-            run_hour = max([h for h in forecast_hours if h <= check_time.hour])
-            
-            forecast_time = check_time.replace(hour=run_hour, minute=0, second=0, microsecond=0)
-            
-            # ECMWF data is usually available 2-4 hours after run time
-            if now >= (forecast_time + timedelta(hours=3)):
-                date_str = forecast_time.strftime("%Y%m%d")
-                time_str = f"{run_hour:02d}"
-                return date_str, time_str, forecast_time
-        
-        # Fallback to previous day
-        yesterday = now - timedelta(days=1)
-        return yesterday.strftime("%Y%m%d"), "18", yesterday.replace(hour=18)
-    
-    def download_ecmwf_wind_data(self, step=0):
-        """Download ECMWF wind data at multiple levels"""
-        date_str, time_str, run_time = self.get_latest_forecast_info()
-        
-        # Download 10m wind components
-        u10_file, u10_status = self.download_parameter('10u', step)
-        v10_file, v10_status = self.download_parameter('10v', step)
-        
-        # Download 100m wind components  
-        u100_file, u100_status = self.download_parameter('100u', step)
-        v100_file, v100_status = self.download_parameter('100v', step)
-        
-        status_msg = f"✅ ECMWF Wind Data Retrieved!\nRun: {date_str} {time_str}z, Step: +{step}h\n"
-        status_msg += f"10m U-component: {u10_status}\n10m V-component: {v10_status}\n"
-        status_msg += f"100m U-component: {u100_status}\n100m V-component: {v100_status}"
-        
-        # Return both levels
-        wind_data = {
-            '10m': (u10_file, v10_file) if u10_file and v10_file else (None, None),
-            '100m': (u100_file, v100_file) if u100_file and v100_file else (None, None)
-        }
-        
-        return wind_data, status_msg
-    
-    def download_parameter(self, parameter, step=0):
-        """Download a specific ECMWF parameter using multiple methods"""
-        date_str, time_str, run_time = self.get_latest_forecast_info()
-        
-        # Method 1: Try ecmwf-opendata client (most reliable)
-        if OPENDATA_AVAILABLE and self.client:
-            try:
-                filename = os.path.join(self.temp_dir, f'ecmwf_{parameter}_{step}h_{datetime.now().strftime("%Y%m%d_%H%M%S")}.grib')
-                
-                self.client.retrieve(
-                    type="fc",
-                    param=parameter,
-                    step=step,
-                    target=filename
-                )
-                
-                if os.path.exists(filename) and os.path.getsize(filename) > 1000:
-                    return filename, f"✅ Downloaded via ECMWF client"
-                    
-            except Exception as e:
-                print(f"ECMWF client method failed: {str(e)}")
-        
-        # Method 2: Direct AWS S3 access (backup method)
-        try:
-            step_str = f"{step:03d}"
-            filename = f"{date_str}{time_str}0000-{step_str}h-oper-fc.grib2"
-            url = f"{self.aws_base_url}/{date_str}/{time_str}z/0p25/oper/{filename}"
-            
-            response = requests.get(url, timeout=120, stream=True)
-            if response.status_code == 200:
-                local_file = os.path.join(self.temp_dir, f'ecmwf_aws_{parameter}_{step}h.grib2')
-                
-                with open(local_file, 'wb') as f:
-                    for chunk in response.iter_content(chunk_size=8192):
-                        f.write(chunk)
-                
-                if os.path.getsize(local_file) > 1000:
-                    return local_file, f"✅ Downloaded via AWS S3"
-                    
-        except Exception as e:
-            print(f"AWS method failed: {str(e)}")
-        
-        return None, f"❌ Failed to download {parameter}"
-    
-    def extract_wind_data_from_grib(self, u_file, v_file, level_name, resolution=8):
-        """Extract wind data from ECMWF GRIB files with improved processing"""
-        try:
-            print(f"🌪️ Processing {level_name} ECMWF GRIB wind data...")
-            
-            # Open GRIB files with robust error handling
-            ds_u = None
-            ds_v = None
-            
-            try:
-                # Method 1: Standard xarray with cfgrib
-                ds_u = xr.open_dataset(u_file, engine='cfgrib')
-                ds_v = xr.open_dataset(v_file, engine='cfgrib')
-                print(f"✅ Opened {level_name} GRIB files with cfgrib")
-            except Exception as e1:
-                print(f"⚠️ cfgrib method failed: {e1}")
-                try:
-                    # Method 2: Alternative backend settings
-                    ds_u = xr.open_dataset(u_file, engine='cfgrib', backend_kwargs={'indexpath': ''})
-                    ds_v = xr.open_dataset(v_file, engine='cfgrib', backend_kwargs={'indexpath': ''})
-                    print(f"✅ Opened {level_name} GRIB files with alternative cfgrib settings")
-                except Exception as e2:
-                    print(f"❌ All GRIB opening methods failed: {e2}")
-                    return []
-            
-            # Debug: Print dataset info
-            print(f"📊 U dataset variables: {list(ds_u.data_vars.keys())}")
-            print(f"📊 U dataset coords: {list(ds_u.coords.keys())}")
-            print(f"📊 U dataset dims: {ds_u.dims}")
-            
-            # Get wind components - more robust variable detection
-            u_var = None
-            v_var = None
-            
-            # Try to find wind variables
-            for var in ds_u.data_vars.keys():
-                if 'u' in var.lower() or '10u' in var or '100u' in var:
-                    u_var = var
-                    break
-            
-            for var in ds_v.data_vars.keys():
-                if 'v' in var.lower() or '10v' in var or '100v' in var:
-                    v_var = var
-                    break
-            
-            if not u_var or not v_var:
-                print(f"❌ Could not find wind variables in {level_name} data")
-                return []
-            
-            print(f"🌬️ Using variables: U={u_var}, V={v_var}")
-            
-            u_data = ds_u[u_var]
-            v_data = ds_v[v_var]
-            
-            # Get coordinates with better detection - check dimensions too
-            lats = None
-            lons = None
-            
-            # First try coordinate variables
-            for coord_name in ['latitude', 'lat', 'y']:
-                if coord_name in ds_u.coords:
-                    lats = ds_u[coord_name].values
-                    print(f"🗺️ Found latitudes in coord '{coord_name}': shape {lats.shape}")
-                    print(f"🔍 Latitude values sample: {lats[:5]} ... {lats[-5:] if len(lats) > 5 else lats}")
-                    print(f"🔍 Latitude min/max: {lats.min():.6f} / {lats.max():.6f}")
-                    print(f"🔍 Unique latitude count: {len(np.unique(lats))}")
-                    break
-            
-            for coord_name in ['longitude', 'lon', 'x']:
-                if coord_name in ds_u.coords:
-                    lons = ds_u[coord_name].values
-                    print(f"🗺️ Found longitudes in coord '{coord_name}': shape {lons.shape}")
-                    print(f"🔍 Longitude values sample: {lons[:5]} ... {lons[-5:] if len(lons) > 5 else lons}")
-                    print(f"🔍 Longitude min/max: {lons.min():.6f} / {lons.max():.6f}")
-                    print(f"🔍 Unique longitude count: {len(np.unique(lons))}")
-                    break
-            
-            # If not found in coords, try dimensions or data variables
-            if lats is None:
-                print("⚠️ Latitudes not found in coords, checking dimensions and data vars...")
-                for dim_name in ds_u.dims:
-                    if 'lat' in dim_name.lower() or 'y' in dim_name.lower():
-                        if dim_name in ds_u.coords:
-                            lats = ds_u.coords[dim_name].values
-                            print(f"🗺️ Found latitudes in dim '{dim_name}': shape {lats.shape}")
-                            break
-                        elif hasattr(ds_u, dim_name):
-                            lats = getattr(ds_u, dim_name).values
-                            print(f"🗺️ Found latitudes as attr '{dim_name}': shape {lats.shape}")
-                            break
-            
-            if lons is None:
-                print("⚠️ Longitudes not found in coords, checking dimensions and data vars...")
-                for dim_name in ds_u.dims:
-                    if 'lon' in dim_name.lower() or 'x' in dim_name.lower():
-                        if dim_name in ds_u.coords:
-                            lons = ds_u.coords[dim_name].values
-                            print(f"🗺️ Found longitudes in dim '{dim_name}': shape {lons.shape}")
-                            break
-                        elif hasattr(ds_u, dim_name):
-                            lons = getattr(ds_u, dim_name).values
-                            print(f"🗺️ Found longitudes as attr '{dim_name}': shape {lons.shape}")
-                            break
-            
-            if lats is None or lons is None:
-                print(f"❌ Could not find coordinates in {level_name} data")
-                return []
-            
-            print(f"🗺️ Grid size: {len(lats)} x {len(lons)} ({len(lats)*len(lons)} points)")
-            print(f"🗺️ Lat range: {lats.min():.2f} to {lats.max():.2f}")
-            print(f"🗺️ Lon range: {lons.min():.2f} to {lons.max():.2f}")
-            
-            # Extract data values to get proper shape
-            u_values = u_data.values
-            v_values = v_data.values
-            
-            # Handle time dimension
-            if u_values.ndim > 2:
-                print(f"🕐 Handling {u_values.ndim}D data, selecting first time/level")
-                # Take first time step and/or first level
-                while u_values.ndim > 2:
-                    u_values = u_values[0]
-                    v_values = v_values[0]
-            
-            # Check for corrupted coordinates (all same value)
-            coords_corrupted = False
-            if len(np.unique(lats)) == 1:
-                print("⚠️ All latitudes are the same value - coordinates may be corrupted!")
-                coords_corrupted = True
-            elif len(np.unique(lons)) == 1:
-                print("⚠️ All longitudes are the same value - coordinates may be corrupted!")  
-                coords_corrupted = True
-            
-            if coords_corrupted:
-                print("🛠️ Generating proper coordinate grid from data shape...")
-                
-                # Generate proper ECMWF-like coordinate grid
-                nlat, nlon = u_values.shape
-                
-                # ECMWF global 0.25° grid typically ranges from 90N to -90S, 0E to 359.75E
-                lats = np.linspace(90, -90, nlat)
-                lons = np.linspace(0, 360-0.25, nlon)
-                
-                print(f"🔧 Generated coordinate grid: {len(lats)} lats x {len(lons)} lons")
-                print(f"🗺️ New lat range: {lats.min():.2f} to {lats.max():.2f}")
-                print(f"🗺️ New lon range: {lons.min():.2f} to {lons.max():.2f}")
-            else:
-                # Check if latitudes are in wrong order (need to be descending for ECMWF)
-                if len(lats) > 1 and lats[0] < lats[-1]:
-                    print("🔄 Reversing latitude order (ECMWF usually goes from North to South)")
-                    lats = lats[::-1]
-            
-            print(f"📐 Final data shape: {u_values.shape}")
-            
-            # Ensure we have the right orientation
-            if u_values.shape != (len(lats), len(lons)):
-                print(f"⚠️ Shape mismatch: data {u_values.shape} vs coords ({len(lats)}, {len(lons)})")
-                # Try transpose
-                if u_values.shape == (len(lons), len(lats)):
-                    u_values = u_values.T
-                    v_values = v_values.T
-                    print("🔄 Transposed data to match coordinates")
-                elif u_values.shape[1] == len(lats) and u_values.shape[0] == len(lons):
-                    # Data might be (lon, lat) instead of (lat, lon)
-                    u_values = u_values.T
-                    v_values = v_values.T
-                    print("🔄 Transposed data from (lon,lat) to (lat,lon)")
-            
-            
-            # Smart subsampling based on resolution
-            if resolution >= 10:
-                step = max(1, len(lats) // 50)  # Limit to ~50 points per dimension
-            else:
-                step = max(1, int(resolution // 2))
-            
-            print(f"⬇️ Subsampling every {step} points")
-            
-            lats_sub = lats[::step]
-            lons_sub = lons[::step]
-            u_sub = u_values[::step, ::step]
-            v_sub = v_values[::step, ::step]
-            
-            # Create wind data points
-            wind_data = []
-            valid_points = 0
-            
-            print(f"🔍 Creating wind data points from subsampled coordinates:")
-            print(f"🔍 lats_sub range: {lats_sub.min():.2f} to {lats_sub.max():.2f} (shape: {lats_sub.shape})")
-            print(f"🔍 lons_sub range: {lons_sub.min():.2f} to {lons_sub.max():.2f} (shape: {lons_sub.shape})")
-            print(f"🔍 First 3 lats_sub: {lats_sub[:3]}")
-            print(f"🔍 First 3 lons_sub: {lons_sub[:3]}")
-            
-            for i, lat in enumerate(lats_sub):
-                for j, lon in enumerate(lons_sub):
-                    if i < len(u_sub) and j < len(u_sub[i]):
-                        try:
-                            u_wind = float(u_sub[i, j])
-                            v_wind = float(v_sub[i, j])
-                            
-                            # Skip invalid data (NaN, extreme values)
-                            if np.isnan(u_wind) or np.isnan(v_wind):
-                                continue
-                            if abs(u_wind) > 200 or abs(v_wind) > 200:  # Sanity check
-                                continue
-                            
-                            # Calculate speed and direction
-                            speed = float(np.sqrt(u_wind**2 + v_wind**2))
-                            direction = float(np.degrees(np.arctan2(v_wind, u_wind)))
-                            
-                            # Normalize direction to 0-360
-                            if direction < 0:
-                                direction += 360
-                            
-                            wind_data.append({
-                                'lat': float(lat),
-                                'lon': float(lon),
-                                'u': u_wind,
-                                'v': v_wind,
-                                'speed': speed,
-                                'direction': direction,
-                                'level': level_name
-                            })
-                            valid_points += 1
-                            
-                            # Debug first few points
-                            if valid_points <= 5:
-                                print(f"🔍 Wind point {valid_points}: lat={lat:.4f}, lon={lon:.4f}, speed={speed:.2f}")
-                            
-                        except (ValueError, TypeError) as e:
-                            continue  # Skip invalid data points
-            
-            print(f"✅ Processed {valid_points} valid {level_name} wind data points")
-            
-            # Close datasets to free memory
-            ds_u.close()
-            ds_v.close()
-            
-            return wind_data
-            
-        except Exception as e:
-            print(f"❌ Error processing {level_name} GRIB files: {str(e)}")
-            import traceback
-            traceback.print_exc()
-            return []
-
-def get_wind_data(lat_min=-90, lat_max=90, lon_min=-180, lon_max=180, resolution=8):
-    """
-    Fetch REAL ECMWF wind data at multiple levels using proven methodology
-    """
-    try:
-        print(f"🌍 Fetching ECMWF wind data at 10m and 100m levels (resolution: {resolution}°)...")
-        
-        # Create ECMWF data fetcher
-        fetcher = ECMWFWindDataFetcher()
-        
-        # Download ECMWF wind data for both levels
-        wind_files, status = fetcher.download_ecmwf_wind_data(step=0)
-        
-        all_wind_data = []
-        
-        # Process 10m wind data
-        if wind_files['10m'][0] and wind_files['10m'][1]:
-            u10_file, v10_file = wind_files['10m']
-            wind_data_10m = fetcher.extract_wind_data_from_grib(u10_file, v10_file, '10m', resolution)
-            if wind_data_10m:
-                all_wind_data.extend(wind_data_10m)
-        
-        # Process 100m wind data
-        if wind_files['100m'][0] and wind_files['100m'][1]:
-            u100_file, v100_file = wind_files['100m']
-            wind_data_100m = fetcher.extract_wind_data_from_grib(u100_file, v100_file, '100m', resolution)
-            if wind_data_100m:
-                all_wind_data.extend(wind_data_100m)
-        
-        if all_wind_data:
-            # Filter data to requested region
-            filtered_data = [
-                wd for wd in all_wind_data 
-                if lat_min <= wd['lat'] <= lat_max and lon_min <= wd['lon'] <= lon_max
-            ]
-            
-            print(f"✅ Successfully processed {len(filtered_data)} total ECMWF wind points")
-            return filtered_data if filtered_data else all_wind_data, status
-        else:
-            print("⚠️ GRIB processing failed, falling back to synthetic data")
-            return generate_synthetic_wind_data(), status
-        
-    except Exception as e:
-        print(f"❌ Error in ECMWF wind data fetching: {e}")
-        print("🔄 Falling back to synthetic wind data...")
-        return generate_synthetic_wind_data(), f"❌ Error: {str(e)}"
-
-def generate_synthetic_wind_data():
-    """Fallback synthetic data - similar to working windmap"""
-    print("🎯 Generating synthetic wind data as fallback...")
-    
-    wind_data = []
-    for lat in range(-60, 61, 15):
-        for lon in range(-180, 181, 20):
-            # Realistic wind patterns
-            lat_rad = np.radians(lat)
-            lon_rad = np.radians(lon)
-            
-            # Jet stream + trade winds + noise
-            u = 15 * np.sin(lat_rad) + 5 * np.cos(lon_rad/2) + np.random.normal(0, 3)
-            v = 5 * np.cos(lat_rad) + 3 * np.sin(lon_rad/3) + np.random.normal(0, 2)
-            speed = np.sqrt(u*u + v*v)
-            
-            wind_data.append({
-                'lat': lat,
-                'lon': lon,
-                'u': u,
-                'v': v,
-                'speed': speed,
-                'direction': np.degrees(np.arctan2(v, u))
-            })
-    
-    print(f"✅ Generated {len(wind_data)} synthetic wind points")
-    return wind_data
-
-def create_wind_arrow_map(wind_data):
-    """
-    Create wind arrow visualization using folium
-    """
-    try:
-        print("🌪️ Creating wind arrow visualization...")
-        
-        if not wind_data:
-            return "<p>❌ No wind data available</p>"
-        
-        # Create folium map
-        m = folium.Map(
-            location=[30, 0],
-            zoom_start=3,
-            tiles='OpenStreetMap'
-        )
-        
-        # Separate data by level
-        wind_10m = [w for w in wind_data if w.get('level') == '10m']
-        wind_100m = [w for w in wind_data if w.get('level') == '100m']
-        
-        print(f"📊 Wind data: {len(wind_10m)} points at 10m, {len(wind_100m)} points at 100m")
-        
-        # Debug: Show sample coordinates
-        if wind_10m:
-            sample = wind_10m[0]
-            print(f"🗺️ Sample 10m wind: Lat={sample['lat']:.2f}, Lon={sample['lon']:.2f}, Speed={sample['speed']:.1f} m/s, Dir={sample['direction']:.0f}°")
-        if wind_100m:
-            sample = wind_100m[0]
-            print(f"🗺️ Sample 100m wind: Lat={sample['lat']:.2f}, Lon={sample['lon']:.2f}, Speed={sample['speed']:.1f} m/s, Dir={sample['direction']:.0f}°")
-        
-        # Add 10m wind markers - start with simple circles to test positioning
-        for i, wind in enumerate(wind_10m[:100]):  # Limit for performance
-            if wind['speed'] > 1:  # Only show significant winds
-                
-                # First add a simple circle marker to test positioning
-                folium.CircleMarker(
-                    location=[wind['lat'], wind['lon']],
-                    radius=5,
-                    color='blue',
-                    fillColor='lightblue',
-                    fillOpacity=0.7,
-                    popup=f"<b>10m Wind #{i+1}</b><br>Speed: {wind['speed']:.1f} m/s<br>Direction: {wind['direction']:.0f}°<br>U: {wind['u']:.1f} m/s<br>V: {wind['v']:.1f} m/s<br>Lat: {wind['lat']:.4f}<br>Lon: {wind['lon']:.4f}",
-                    tooltip=f"10m: {wind['speed']:.1f}m/s"
-                ).add_to(m)
-                
-                # Also try with regular marker as backup
-                if i < 20:  # Only add arrows for first 20 points
-                    # Calculate arrow length based on wind speed
-                    arrow_length = min(wind['speed'] * 1.5, 15)
-                    
-                    # Convert meteorological direction to mathematical angle
-                    arrow_angle = (90 - wind['direction']) % 360
-                    
-                    # Create simple arrow SVG
-                    arrow_svg = f"""
-                    <svg width="30" height="30" style="overflow: visible;">
-                        <g transform="rotate({arrow_angle} 15 15)">
-                            <line x1="5" y1="15" x2="{20}" y2="15" stroke="darkblue" stroke-width="3" marker-end="url(#arrowhead-blue{i})"/>
-                        </g>
-                        <defs>
-                            <marker id="arrowhead-blue{i}" markerWidth="10" markerHeight="7" 
-                                    refX="9" refY="3.5" orient="auto">
-                                <polygon points="0 0, 10 3.5, 0 7" fill="darkblue"/>
-                            </marker>
-                        </defs>
-                    </svg>
-                    """
-                    
-                    folium.Marker(
-                        location=[wind['lat'], wind['lon']],
-                        icon=folium.DivIcon(
-                            html=arrow_svg,
-                            icon_size=(30, 30),
-                            icon_anchor=(15, 15)
-                        ),
-                        popup=f"<b>10m Arrow #{i+1}</b><br>Speed: {wind['speed']:.1f} m/s<br>Direction: {wind['direction']:.0f}°<br>Lat: {wind['lat']:.4f}<br>Lon: {wind['lon']:.4f}"
-                    ).add_to(m)
-        
-        # Add 100m wind markers - simple circles
-        for i, wind in enumerate(wind_100m[:50]):  # Limit for performance
-            if wind['speed'] > 1:  # Only show significant winds
-                # Add simple circle marker to test positioning
-                folium.CircleMarker(
-                    location=[wind['lat'], wind['lon']],
-                    radius=7,
-                    color='red',
-                    fillColor='pink',
-                    fillOpacity=0.7,
-                    popup=f"<b>100m Wind #{i+1}</b><br>Speed: {wind['speed']:.1f} m/s<br>Direction: {wind['direction']:.0f}°<br>U: {wind['u']:.1f} m/s<br>V: {wind['v']:.1f} m/s<br>Lat: {wind['lat']:.4f}<br>Lon: {wind['lon']:.4f}",
-                    tooltip=f"100m: {wind['speed']:.1f}m/s"
-                ).add_to(m)
-        
-        # Add legend
-        legend_html = '''
-        <div style="position: fixed; 
-                    top: 10px; right: 10px; width: 200px; height: 120px; 
-                    background-color: white; border:2px solid grey; z-index:9999; 
-                    font-size:14px; padding: 10px">
-        <h4>Wind Data Legend</h4>
-        <p><span style="color:blue;">■</span> 10m Wind Arrows</p>
-        <p><span style="color:red;">■</span> 100m Wind Arrows</p>
-        <p>Arrow length = wind speed</p>
-        <p>Arrow direction = wind direction</p>
-        </div>
-        '''
-        m.get_root().html.add_child(folium.Element(legend_html))
-        
-        return m._repr_html_()
-        
-    except Exception as e:
-        return f"<p>❌ Error creating wind map: {str(e)}</p>"
-
-def fetch_and_visualize_winds(resolution=8):
-    """Main function to fetch and visualize wind data"""
-    try:
-        status_msg = "🌍 Fetching real-time ECMWF wind data at 10m and 100m levels..."
-        
-        # Fetch real wind data
-        wind_data, download_status = get_wind_data(resolution=resolution)
-        
-        if not wind_data:
-            return "❌ No wind data could be fetched", ""
-        
-        # Create wind arrow map
-        wind_map = create_wind_arrow_map(wind_data)
-        
-        # Count data by level
-        wind_10m_count = len([w for w in wind_data if w.get('level') == '10m'])
-        wind_100m_count = len([w for w in wind_data if w.get('level') == '100m'])
-        
-        status_msg = f"""✅ ECMWF Wind Data Successfully Retrieved!
-
-{download_status}
-
-📊 Data Summary:
-• Total wind measurements: {len(wind_data)} points
-• 10m wind data: {wind_10m_count} points
-• 100m wind data: {wind_100m_count} points
-• Data source: ECMWF Operational Forecasts
-• Resolution: 0.25° (~25km) ECMWF grid
-• Grid spacing: {resolution}° display resolution
-• Update time: {datetime.now().strftime('%H:%M:%S UTC')}
-
-🏹 Wind Arrow Visualization:
-• Blue arrows = 10m wind data
-• Red arrows = 100m wind data
-• Arrow length = wind speed
-• Arrow direction = wind direction
-• Click arrows for detailed wind info (U/V components)
-• Interactive map with zoom/pan controls
-
-🎯 Features:
-• Real ECMWF GRIB file processing
-• Multi-level wind comparison (10m vs 100m)
-• Professional meteorological data
-• Same data source as earth.nullschool.net
-• Clean arrow-based visualization"""
-
-        return status_msg, wind_map
-        
-    except Exception as e:
-        return f"❌ Error: {str(e)}", ""
-
-# Create Gradio interface
-with gr.Blocks(title="ECMWF Wind Visualization", theme=gr.themes.Soft()) as app:
-    gr.Markdown("""
-    # 🌪️ ECMWF Wind Visualization
-    ## Multi-Level Wind Data with Arrow Visualization
-    
-    **Features:**
-    - 🌍 Real ECMWF operational forecast data
-    - 🏹 Wind arrows at 10m and 100m levels
-    - 📊 Professional meteorological visualization
-    - 🎯 Same data source as earth.nullschool.net
-    - 📈 Compare wind speeds at different altitudes
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### ⚙️ Controls")
-            
-            resolution_slider = gr.Slider(
-                minimum=8,
-                maximum=20,
-                value=12,
-                step=2,
-                label="Grid Resolution (degrees)",
-                info="Lower = more detail, slower loading"
-            )
-            
-            fetch_btn = gr.Button(
-                "🏹 Fetch ECMWF Wind Data & Visualize",
-                variant="primary",
-                size="lg"
-            )
-            
-            status_output = gr.Textbox(
-                label="Status",
-                lines=20,
-                interactive=False
-            )
-        
-        with gr.Column(scale=2):
-            gr.Markdown("### 🗺️ Wind Arrow Visualization")
-            wind_map_output = gr.HTML(
-                label="ECMWF Wind Data Arrows",
-                value="<p>Click 'Fetch ECMWF Wind Data' to see wind arrows at 10m and 100m levels!</p>"
-            )
-    
-    # Event handlers
-    fetch_btn.click(
-        fetch_and_visualize_winds,
-        inputs=[resolution_slider],
-        outputs=[status_output, wind_map_output]
-    )
-    
-    gr.Markdown("""
-    ---
-    ### 📖 About This App
-    
-    This application uses **real ECMWF operational forecast data** to visualize wind patterns at multiple atmospheric levels.
-    
-    **Technical Features:**
-    - Professional ECMWF operational forecasts at 10m and 100m levels
-    - Same data source as earth.nullschool.net
-    - Wind arrow visualization showing speed and direction
-    - Real U/V wind component processing from GRIB files
-    - Multi-level wind comparison capabilities
-    - Color-coded wind arrows (blue=10m, red=100m)
-    - Interactive Leaflet map integration
-    
-    **Data Source:** ECMWF Open Data - Professional meteorological forecasts at 0.25° resolution
-    """)
-
-if __name__ == "__main__":
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )

index.html

@@ -1,377 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>🌪️ Wind Particle Visualization - Earth.nullschool.net Style</title>
-    <script src="https://unpkg.com/leaflet@1.7.1/dist/leaflet.js"></script>
-    <link rel="stylesheet" href="https://unpkg.com/leaflet@1.7.1/dist/leaflet.css" />
-    <style>
-        body {
-            margin: 0;
-            padding: 20px;
-            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            color: white;
-        }
-        .container {
-            max-width: 1200px;
-            margin: 0 auto;
-        }
-        h1 {
-            text-align: center;
-            margin-bottom: 10px;
-            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
-        }
-        .subtitle {
-            text-align: center;
-            margin-bottom: 20px;
-            opacity: 0.9;
-        }
-        #map {
-            height: 600px;
-            width: 100%;
-            border-radius: 10px;
-            box-shadow: 0 10px 30px rgba(0,0,0,0.3);
-            margin-bottom: 20px;
-        }
-        .controls {
-            display: flex;
-            justify-content: center;
-            gap: 15px;
-            margin-bottom: 20px;
-        }
-        button {
-            padding: 12px 24px;
-            border: none;
-            border-radius: 25px;
-            background: rgba(255,255,255,0.2);
-            color: white;
-            font-weight: bold;
-            cursor: pointer;
-            transition: all 0.3s ease;
-            backdrop-filter: blur(10px);
-        }
-        button:hover {
-            background: rgba(255,255,255,0.3);
-            transform: translateY(-2px);
-        }
-        .info {
-            text-align: center;
-            background: rgba(255,255,255,0.1);
-            padding: 15px;
-            border-radius: 10px;
-            backdrop-filter: blur(10px);
-        }
-        .legend {
-            position: absolute;
-            bottom: 20px;
-            right: 20px;
-            background: rgba(255,255,255,0.9);
-            color: #333;
-            padding: 15px;
-            border-radius: 10px;
-            font-size: 12px;
-            z-index: 1000;
-            box-shadow: 0 5px 15px rgba(0,0,0,0.2);
-        }
-        .legend h4 {
-            margin: 0 0 10px 0;
-            color: #333;
-        }
-        .legend-item {
-            display: flex;
-            align-items: center;
-            margin: 5px 0;
-        }
-        .legend-color {
-            width: 20px;
-            height: 3px;
-            margin-right: 8px;
-            border-radius: 2px;
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>🌪️ Wind Particle Visualization</h1>
-        <p class="subtitle">Earth.nullschool.net style particle animation with synthetic wind data</p>
-        
-        <div class="controls">
-            <button onclick="startParticles()">🌪️ Start Wind Particles</button>
-            <button onclick="resetParticles()">🔄 Reset</button>
-            <button onclick="toggleSpeed()">⚡ Toggle Speed</button>
-        </div>
-        
-        <div id="map"></div>
-        
-        <div class="info">
-            <strong>🎯 Demo Features:</strong> Earth.nullschool.net style particle system • Bilinear interpolation • 1000 animated particles • Zoom-responsive visualization • Synthetic global wind patterns
-        </div>
-    </div>
-
-    <div class="legend">
-        <h4>🌪️ Wind Speed</h4>
-        <div class="legend-item">
-            <div class="legend-color" style="background: rgba(110,159,190,0.9);"></div>
-            <span>< 5 m/s</span>
-        </div>
-        <div class="legend-item">
-            <div class="legend-color" style="background: rgba(65,120,190,0.9);"></div>
-            <span>5-10 m/s</span>
-        </div>
-        <div class="legend-item">
-            <div class="legend-color" style="background: rgba(25,80,170,0.9);"></div>
-            <span>10-15 m/s</span>
-        </div>
-        <div class="legend-item">
-            <div class="legend-color" style="background: rgba(85,160,35,0.9);"></div>
-            <span>15-20 m/s</span>
-        </div>
-        <div class="legend-item">
-            <div class="legend-color" style="background: rgba(255,215,0,0.9);"></div>
-            <span>20-25 m/s</span>
-        </div>
-        <div class="legend-item">
-            <div class="legend-color" style="background: rgba(255,120,0,0.9);"></div>
-            <span>> 25 m/s</span>
-        </div>
-    </div>
-
-    <script>
-        console.log('🌪️ Initializing wind particle system...');
-        
-        // Initialize map
-        const map = L.map('map').setView([30, 0], 3);
-        L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
-            attribution: '© OpenStreetMap contributors'
-        }).addTo(map);
-        
-        // Global variables
-        let particleSystem = null;
-        let animationSpeed = 1;
-        let windField = null;
-        
-        // Generate synthetic wind data (earth.nullschool.net style)
-        function generateWindField() {
-            console.log('Generating synthetic wind field...');
-            
-            const lats = [];
-            const lons = [];
-            const winds = [];
-            
-            // Create global grid
-            for (let lat = 60; lat >= -60; lat -= 3) {
-                for (let lon = -180; lon <= 180; lon += 6) {
-                    lats.push(lat);
-                    lons.push(lon);
-                    
-                    // Realistic wind patterns
-                    const latRad = lat * Math.PI / 180;
-                    const lonRad = lon * Math.PI / 180;
-                    
-                    // Jet stream + trade winds + random turbulence
-                    const u = 15 * Math.sin(latRad) + 8 * Math.cos(lonRad/2) + (Math.random() - 0.5) * 6;
-                    const v = 5 * Math.cos(latRad) + 3 * Math.sin(lonRad/3) + (Math.random() - 0.5) * 4;
-                    
-                    winds.push({ lat, lon, u, v, speed: Math.sqrt(u*u + v*v) });
-                }
-            }
-            
-            console.log(`Generated ${winds.length} wind points`);
-            return winds;
-        }
-        
-        // Wind particle system (earth.nullschool.net inspired)
-        class WindParticleSystem {
-            constructor(map, windData) {
-                this.map = map;
-                this.windData = windData;
-                this.particles = [];
-                this.numParticles = 1000;
-                this.particleAge = 80;
-                this.canvas = null;
-                this.ctx = null;
-                this.animationId = null;
-                this.setup();
-            }
-            
-            setup() {
-                const mapContainer = this.map.getContainer();
-                
-                // Create canvas overlay
-                this.canvas = document.createElement('canvas');
-                this.canvas.style.position = 'absolute';
-                this.canvas.style.top = '0';
-                this.canvas.style.left = '0';
-                this.canvas.style.pointerEvents = 'none';
-                this.canvas.style.zIndex = '1000';
-                this.canvas.width = mapContainer.offsetWidth;
-                this.canvas.height = mapContainer.offsetHeight;
-                
-                mapContainer.style.position = 'relative';
-                mapContainer.appendChild(this.canvas);
-                
-                this.ctx = this.canvas.getContext('2d');
-                this.ctx.lineCap = 'round';
-                this.ctx.lineJoin = 'round';
-                
-                // Initialize particles
-                this.initializeParticles();
-                this.animate();
-                
-                // Handle map events
-                this.map.on('moveend zoomend resize', () => this.updateCanvas());
-                
-                console.log('✅ Wind particle system initialized');
-            }
-            
-            updateCanvas() {
-                const mapContainer = this.map.getContainer();
-                this.canvas.width = mapContainer.offsetWidth;
-                this.canvas.height = mapContainer.offsetHeight;
-            }
-            
-            initializeParticles() {
-                this.particles = [];
-                const bounds = this.map.getBounds();
-                
-                for (let i = 0; i < this.numParticles; i++) {
-                    this.particles.push({
-                        lat: bounds.getSouth() + Math.random() * (bounds.getNorth() - bounds.getSouth()),
-                        lon: bounds.getWest() + Math.random() * (bounds.getEast() - bounds.getWest()),
-                        age: Math.floor(Math.random() * this.particleAge),
-                        trail: []
-                    });
-                }
-            }
-            
-            getWindAtPosition(lat, lon) {
-                // Find nearest wind point (simple approach)
-                let minDist = Infinity;
-                let nearestWind = { u: 0, v: 0, speed: 0 };
-                
-                for (const wind of this.windData) {
-                    const dist = Math.sqrt((wind.lat - lat) ** 2 + (wind.lon - lon) ** 2);
-                    if (dist < minDist) {
-                        minDist = dist;
-                        nearestWind = wind;
-                    }
-                }
-                
-                return nearestWind;
-            }
-            
-            getWindColor(speed) {
-                // Earth.nullschool.net color scheme
-                if (speed < 5) return 'rgba(110, 159, 190, 0.8)';
-                if (speed < 10) return 'rgba(65, 120, 190, 0.8)';
-                if (speed < 15) return 'rgba(25, 80, 170, 0.8)';
-                if (speed < 20) return 'rgba(85, 160, 35, 0.8)';
-                if (speed < 25) return 'rgba(255, 215, 0, 0.8)';
-                return 'rgba(255, 120, 0, 0.8)';
-            }
-            
-            evolveParticle(particle) {
-                const wind = this.getWindAtPosition(particle.lat, particle.lon);
-                
-                // Move particle based on wind
-                const scale = 0.01 * animationSpeed * Math.pow(2, this.map.getZoom() - 5);
-                particle.lat += wind.v * scale;
-                particle.lon += wind.u * scale;
-                particle.age++;
-                
-                // Reset if too old or out of bounds
-                const bounds = this.map.getBounds();
-                if (particle.age > this.particleAge || 
-                    particle.lat < bounds.getSouth() || particle.lat > bounds.getNorth() ||
-                    particle.lon < bounds.getWest() || particle.lon > bounds.getEast()) {
-                    
-                    particle.lat = bounds.getSouth() + Math.random() * (bounds.getNorth() - bounds.getSouth());
-                    particle.lon = bounds.getWest() + Math.random() * (bounds.getEast() - bounds.getWest());
-                    particle.age = 0;
-                }
-                
-                return wind;
-            }
-            
-            render() {
-                // Fade effect
-                this.ctx.globalCompositeOperation = 'destination-in';
-                this.ctx.globalAlpha = 0.95;
-                this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
-                
-                // Draw particles
-                this.ctx.globalCompositeOperation = 'lighter';
-                this.ctx.globalAlpha = 0.9;
-                this.ctx.lineWidth = 1.5;
-                
-                for (const particle of this.particles) {
-                    const wind = this.evolveParticle(particle);
-                    
-                    if (wind.speed > 0.5) {
-                        const point = this.map.latLngToContainerPoint([particle.lat, particle.lon]);
-                        
-                        if (point.x >= 0 && point.x < this.canvas.width && 
-                            point.y >= 0 && point.y < this.canvas.height) {
-                            
-                            this.ctx.strokeStyle = this.getWindColor(wind.speed);
-                            this.ctx.beginPath();
-                            this.ctx.arc(point.x, point.y, 1, 0, 2 * Math.PI);
-                            this.ctx.stroke();
-                        }
-                    }
-                }
-            }
-            
-            animate() {
-                this.render();
-                this.animationId = requestAnimationFrame(() => this.animate());
-            }
-            
-            destroy() {
-                if (this.animationId) {
-                    cancelAnimationFrame(this.animationId);
-                }
-                if (this.canvas) {
-                    this.canvas.remove();
-                }
-            }
-        }
-        
-        // Control functions
-        function startParticles() {
-            if (!windField) {
-                windField = generateWindField();
-            }
-            
-            if (particleSystem) {
-                particleSystem.destroy();
-            }
-            
-            particleSystem = new WindParticleSystem(map, windField);
-            console.log('🌪️ Wind particles started!');
-        }
-        
-        function resetParticles() {
-            if (particleSystem) {
-                particleSystem.destroy();
-                particleSystem = null;
-            }
-            windField = null;
-            console.log('🔄 Particles reset');
-        }
-        
-        function toggleSpeed() {
-            animationSpeed = animationSpeed === 1 ? 2 : animationSpeed === 2 ? 0.5 : 1;
-            console.log('⚡ Animation speed:', animationSpeed);
-        }
-        
-        // Auto-start after page load
-        setTimeout(() => {
-            console.log('🚀 Auto-starting wind particles...');
-            startParticles();
-        }, 1000);
-    </script>
-</body>
-</html>

packages.txt

@@ -1,2 +0,0 @@
-git
-git-lfs

requirements.txt

@@ -1,8 +0,0 @@
-gradio==4.44.0
-folium==0.15.1
-numpy
-pandas
-requests
-ecmwf-opendata>=0.3.0
-xarray
-cfgrib