Update app.py

app.py

@@ -7,128 +7,49 @@ import matplotlib.pyplot as plt
 import numpy as np
 import io
 import base64
-from PIL import Image, ImageDraw
+from PIL import Image, ImageDraw, ImageFilter
 import re
-from requests.auth import HTTPDigestAuth
 import cv2
 
-# Complete NIWA Snow and Ice Network (SIN) Stations with coordinates
+# Complete NIWA Snow and Ice Network Stations
 SNOW_STATIONS = {
     "Mahanga EWS": {
         "name": "Mahanga Electronic Weather Station", 
         "location": "Mount Mahanga, Tasman",
-        "elevation": "1940m",
-        "years": "2009-present",
+        "elevation": "1940m", "years": "2009-present",
         "lat": -41.56, "lon": 172.27,
-        "image_url": "https://webstatic.niwa.co.nz/snow-plots/mahanga-ews-snow-depth-web.png",
-        "page_url": "https://niwa.co.nz/freshwater/snow-and-ice-network/mahanga-electronic-weather-station-ews"
+        "image_url": "https://webstatic.niwa.co.nz/snow-plots/mahanga-ews-snow-depth-web.png"
     },
     "Mueller Hut EWS": {
         "name": "Mueller Hut Electronic Weather Station",
-        "location": "Aoraki/Mount Cook National Park",
-        "elevation": "1818m",
-        "years": "2010-present",
+        "location": "Aoraki/Mount Cook National Park", 
+        "elevation": "1818m", "years": "2010-present",
         "lat": -43.69, "lon": 170.11,
-        "image_url": "https://webstatic.niwa.co.nz/snow-plots/mueller-hut-ews-snow-depth-web.png",
-        "page_url": "https://niwa.co.nz/freshwater/snow-and-ice-network/mueller-hut-ews"
+        "image_url": "https://webstatic.niwa.co.nz/snow-plots/mueller-hut-ews-snow-depth-web.png"
     },
     "Mt Potts EWS": {
         "name": "Mt Potts Electronic Weather Station",
-        "location": "Canterbury (highest elevation site)",
-        "elevation": "2128m",
-        "years": "2012-present",
+        "location": "Canterbury (highest elevation)",
+        "elevation": "2128m", "years": "2012-present", 
         "lat": -43.53, "lon": 171.17,
-        "image_url": "https://webstatic.niwa.co.nz/snow-plots/mt-potts-ews-snow-depth-web.png",
-        "page_url": "https://niwa.co.nz/freshwater/snow-and-ice-network/mt-potts-ews"
+        "image_url": "https://webstatic.niwa.co.nz/snow-plots/mt-potts-ews-snow-depth-web.png"
     },
     "Upper Rakaia EWS": {
         "name": "Upper Rakaia Electronic Weather Station",
-        "location": "Jollie Range, north facing slope",
-        "elevation": "1752m",
-        "years": "2010-present",
+        "location": "Jollie Range", "elevation": "1752m", "years": "2010-present",
         "lat": -43.43, "lon": 171.29,
-        "image_url": "https://webstatic.niwa.co.nz/snow-plots/upper-rakaia-ews-snow-depth-web.png",
-        "page_url": "https://niwa.co.nz/freshwater/snow-and-ice-network/upper-rakaia-ews"
+        "image_url": "https://webstatic.niwa.co.nz/snow-plots/upper-rakaia-ews-snow-depth-web.png"
     },
     "Albert Burn EWS": {
-        "name": "Albert Burn Electronic Weather Station",
-        "location": "Upper Albert Burn valley, east of Mt Aspiring",
-        "elevation": "1280m",
-        "years": "2012-present",
+        "name": "Albert Burn Electronic Weather Station", 
+        "location": "Mt Aspiring region", "elevation": "1280m", "years": "2012-present",
         "lat": -44.58, "lon": 169.13,
-        "image_url": "https://webstatic.niwa.co.nz/snow-plots/albert-burn-ews-snow-depth-web.png",
-        "page_url": "https://niwa.co.nz/freshwater/snow-and-ice-network/albert-burn-ews"
+        "image_url": "https://webstatic.niwa.co.nz/snow-plots/albert-burn-ews-snow-depth-web.png"
     }
 }
 
-def try_real_niwa_apis(username="", password=""):
-    """Try the REAL NIWA API endpoints with proper authentication"""
-    results = []
-    headers = {
-        'User-Agent': 'Mozilla/5.0 (compatible; NIWADataFetcher/1.0)',
-        'Accept': 'application/json'
-    }
-    
-    # Real NIWA API structure from Teamwork docs: 
-    # https://data.niwa.co.nz/api/data/products/1/$featureid/$productid/$datastartdate/$dataenddate
-    
-    end_date = datetime.now().strftime('%Y-%m-%dT%H:%M:%S+1200')
-    start_date = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%dT%H:%M:%S+1200')
-    
-    # Snow Water Equivalent product ID from docs: 43815863
-    test_endpoints = [
-        "https://data.niwa.co.nz/api/data/products",  # List available products
-        f"https://data.niwa.co.nz/api/data/products/43815863/{start_date}/{end_date}",  # Snow Water Equivalent
-        f"https://data.niwa.co.nz/api/data/products/1/1/43815863/{start_date}/{end_date}",  # With feature ID
-        "https://developer.niwa.co.nz/docs/tide-api/1/overview",  # Working NIWA API
-        "https://developer.niwa.co.nz/docs/uv-api/1/overview",    # Working NIWA API
-        "https://developer.niwa.co.nz/docs/solarview-api/1/overview"  # Working NIWA API
-    ]
-    
-    for endpoint in test_endpoints:
-        try:
-            # Try with and without authentication
-            auth = HTTPDigestAuth(username, password) if username and password else None
-            
-            response = requests.get(endpoint, headers=headers, auth=auth, timeout=10)
-            
-            if response.status_code == 200:
-                try:
-                    if 'application/json' in response.headers.get('content-type', ''):
-                        data = response.json()
-                        results.append(f"✅ {endpoint}: JSON data received ({len(str(data))} chars)")
-                        
-                        # Check for actual snow/weather data
-                        if isinstance(data, dict):
-                            if 'data' in data:
-                                results.append(f"   📊 Contains 'data' field with {len(data.get('data', []))} items")
-                            if 'Snow' in str(data) or 'snow' in str(data):
-                                results.append(f"   ❄️ Contains snow-related data!")
-                            if 'propName' in data:
-                                results.append(f"   🏷️ Property: {data.get('propName', 'Unknown')}")
-                    else:
-                        results.append(f"🔍 {endpoint}: Response received (HTML/other)")
-                except Exception as e:
-                    results.append(f"🔍 {endpoint}: Response received but parsing failed")
-                    
-            elif response.status_code == 401:
-                results.append(f"🔐 {endpoint}: Authentication required (401)")
-            elif response.status_code == 403:
-                results.append(f"🚫 {endpoint}: Access forbidden (403)")
-            elif response.status_code == 404:
-                results.append(f"❌ {endpoint}: Not found (404)")
-            else:
-                results.append(f"❓ {endpoint}: HTTP {response.status_code}")
-                
-        except requests.Timeout:
-            results.append(f"⏱️ {endpoint}: Request timeout")
-        except Exception as e:
-            results.append(f"❌ {endpoint}: Error - {str(e)[:50]}...")
-    
-    return "\n".join(results)
-
-def extract_data_from_chart(image):
-    """Extract numerical data from snow depth chart images using computer vision"""
+def extract_snow_data_from_chart(image):
+    """Advanced chart data extraction using computer vision"""
     try:
         if image is None:
             return None, "No image provided"
@@ -136,179 +57,276 @@ def extract_data_from_chart(image):
         # Convert PIL to numpy array
         img_array = np.array(image)
         
-        # Convert to grayscale
+        # Convert to different color spaces for analysis
         gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+        hsv = cv2.cvtColor(img_array, cv2.COLOR_RGB2HSV)
         
-        # Basic chart analysis
         height, width = gray.shape
         
-        # Try to find chart area (typically has consistent background)
-        # Look for plot lines and data
+        # 1. Detect chart boundaries and axes
         edges = cv2.Canny(gray, 50, 150)
+        lines = cv2.HoughLinesP(edges, 1, np.pi/180, threshold=100, minLineLength=100, maxLineGap=10)
         
-        # Find contours (potential chart elements)
-        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-        
-        # Simple analysis - count significant contours as data complexity indicator
-        significant_contours = [c for c in contours if cv2.contourArea(c) > 100]
-        
-        # Try to detect chart boundaries
-        chart_info = {
-            "image_dimensions": f"{width}x{height}",
-            "significant_features": len(significant_contours),
-            "edge_density": np.sum(edges > 0) / (width * height),
-            "chart_type": "time_series" if width > height else "other"
-        }
-        
-        # Attempt to extract approximate values by analyzing pixel intensities
-        # This is a simplified approach - real chart extraction would be much more complex
-        middle_row = gray[height//2, :]
-        value_changes = np.where(np.diff(middle_row) > 20)[0]
-        
-        analysis = f"""
-**Chart Analysis Results:**
-- Image size: {chart_info['image_dimensions']} pixels
-- Detected features: {chart_info['significant_features']} chart elements
-- Edge density: {chart_info['edge_density']:.3f} (higher = more complex chart)
-- Estimated chart type: {chart_info['chart_type']}
-- Value transitions detected: {len(value_changes)} points
+        chart_bounds = {"left": 0, "right": width, "top": 0, "bottom": height}
+        if lines is not None:
+            # Find potential axis lines (long horizontal/vertical lines)
+            h_lines = [line for line in lines if abs(line[0][1] - line[0][3]) < 10]  # Horizontal
+            v_lines = [line for line in lines if abs(line[0][0] - line[0][2]) < 10]  # Vertical
+            
+            if h_lines:
+                chart_bounds["bottom"] = max([line[0][1] for line in h_lines])
+            if v_lines:
+                chart_bounds["left"] = min([line[0][0] for line in v_lines])
+        
+        # 2. Color-based data line detection
+        # Snow depth lines are typically blue/dark colored
+        blue_channel = img_array[:, :, 2]  # Blue channel
+        blue_mask = blue_channel > np.mean(blue_channel) + np.std(blue_channel)
+        
+        # 3. Extract data points along chart width
+        chart_start = chart_bounds["left"] + 50  # Offset from y-axis
+        chart_end = chart_bounds["right"] - 50
+        chart_width = chart_end - chart_start
+        
+        # Sample points across the chart
+        num_samples = min(50, chart_width // 10)
+        x_positions = np.linspace(chart_start, chart_end, num_samples, dtype=int)
+        
+        snow_depth_values = []
+        dates = []
+        
+        # For each x position, find the lowest blue/dark pixel (data line)
+        for i, x in enumerate(x_positions):
+            if x < width:
+                # Look for data line in this column
+                column = gray[chart_bounds["top"]:chart_bounds["bottom"], x]
+                
+                # Find darkest point (likely data line) 
+                dark_pixels = np.where(column < np.mean(column) - np.std(column))[0]
+                
+                if len(dark_pixels) > 0:
+                    # Get the lowest dark point (highest snow depth)
+                    data_y = dark_pixels[-1] + chart_bounds["top"]
+                    
+                    # Convert pixel position to approximate snow depth
+                    # Assume chart shows 0-300cm range (typical for these stations)
+                    chart_height = chart_bounds["bottom"] - chart_bounds["top"]
+                    relative_position = (chart_bounds["bottom"] - data_y) / chart_height
+                    estimated_depth = relative_position * 300  # cm (rough estimate)
+                    
+                    snow_depth_values.append(max(0, estimated_depth))
+                    
+                    # Estimate date (assume last 12 months)
+                    date_fraction = i / (num_samples - 1)
+                    days_ago = int((1 - date_fraction) * 365)
+                    estimated_date = datetime.now() - timedelta(days=days_ago)
+                    dates.append(estimated_date.strftime('%Y-%m-%d'))
+                else:
+                    snow_depth_values.append(0)
+                    days_ago = int((1 - (i / (num_samples - 1))) * 365)
+                    estimated_date = datetime.now() - timedelta(days=days_ago)
+                    dates.append(estimated_date.strftime('%Y-%m-%d'))
+        
+        # 4. Create simple statistics
+        if snow_depth_values:
+            current_depth = snow_depth_values[-1] if snow_depth_values else 0
+            max_depth = max(snow_depth_values)
+            avg_depth = np.mean(snow_depth_values)
+            
+            # Create basic data table
+            data_table = pd.DataFrame({
+                'Date': dates[-10:],  # Last 10 points
+                'Estimated_Snow_Depth_cm': [round(val, 1) for val in snow_depth_values[-10:]]
+            })
+            
+            analysis = f"""
+**Chart Data Extraction Results:**
+
+**Current Estimates:**
+- Current snow depth: ~{current_depth:.1f} cm
+- Maximum detected: ~{max_depth:.1f} cm  
+- Average depth: ~{avg_depth:.1f} cm
+
+**Data Points Extracted:** {len(snow_depth_values)}
 
-**Limitations:**
-- This is a basic computer vision analysis
-- Real data extraction requires chart-specific algorithms
-- Y-axis scaling and units need manual interpretation
-- Time-series data points need sophisticated detection
+**Chart Analysis:**
+- Image size: {width}x{height} pixels
+- Chart boundaries detected: {chart_bounds}
+- Blue/dark pixel data lines found: {np.sum(blue_mask)} pixels
 
-**Recommendations:**
-- For accurate data: Register at data.niwa.co.nz
-- Use NIWA API with authentication
-- Request raw CSV/JSON datasets
+**Latest Data Points:**
+{data_table.to_string(index=False)}
+
+**⚠️ Important Limitations:**
+- These are ROUGH ESTIMATES from image analysis
+- Actual y-axis scale unknown (assumed 0-300cm)
+- Date estimation based on chart width assumption
+- Accuracy depends on chart quality and data line visibility
+- For research use, get real data from NIWA DataHub
+
+**✅ What This IS Useful For:**
+- Quick trend assessment
+- Approximate current conditions  
+- Comparing relative levels between stations
+- Proof-of-concept for data access
 """
-        
-        return chart_info, analysis
-        
+            
+            return {
+                'estimated_current_depth': current_depth,
+                'estimated_max_depth': max_depth,
+                'data_points': len(snow_depth_values),
+                'chart_bounds': chart_bounds,
+                'data_table': data_table
+            }, analysis
+            
+        else:
+            return None, "❌ Could not extract data points from chart image"
+            
     except Exception as e:
-        return None, f"Chart analysis failed: {str(e)}"
+        return None, f"❌ Chart analysis failed: {str(e)}"
 
-def fetch_snow_depth_image(station_key):
-    """Fetch snow depth chart image and attempt data extraction"""
+def fetch_and_analyze_station(station_key):
+    """Fetch image and extract data for a specific station"""
     try:
         station = SNOW_STATIONS[station_key]
-        image_url = station["image_url"]
-        
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-        }
         
-        response = requests.get(image_url, headers=headers, timeout=15)
+        # Fetch image
+        headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
+        response = requests.get(station["image_url"], headers=headers, timeout=15)
         
         if response.status_code == 200:
-            # Convert to PIL Image
             image = Image.open(io.BytesIO(response.content))
             
-            # Attempt data extraction
-            chart_data, analysis = extract_data_from_chart(image)
+            # Extract data
+            extracted_data, analysis = extract_snow_data_from_chart(image)
             
+            # Create comprehensive station info
             info = f"""
-**Station:** {station['name']}
+## {station['name']}
+
 **Location:** {station['location']} ({station['lat']}, {station['lon']})
 **Elevation:** {station['elevation']}
 **Data Period:** {station['years']}
 
-**Chart Data Extraction:**
+**Extracted Data Analysis:**
 {analysis}
-            """
+
+**Source:** NIWA Snow & Ice Network
+**Image URL:** {station['image_url']}
+"""
             
-            return image, info, "✅ Image fetched and analyzed"
+            return image, info, extracted_data, "✅ Successfully analyzed station data"
             
         else:
-            return None, f"❌ Failed to fetch chart. HTTP {response.status_code}", f"Error fetching from {image_url}"
+            return None, f"❌ Failed to fetch image (HTTP {response.status_code})", None, "Connection failed"
             
     except Exception as e:
-        return None, f"❌ Error: {str(e)}", "Failed to connect to NIWA servers"
+        return None, f"❌ Error: {str(e)}", None, "Analysis failed"
 
-def test_alternative_apis():
-    """Test alternative weather APIs that might have New Zealand snow data"""
+def try_alternative_nz_weather_apis():
+    """Test alternative weather data sources for New Zealand"""
     results = []
-    headers = {'User-Agent': 'Mozilla/5.0'}
     
-    # Test various weather APIs for New Zealand coverage
-    nz_coords = [-43.532, 172.637]  # Christchurch coordinates
+    # Test coordinates for major NZ snow areas
+    test_locations = [
+        {"name": "Mount Cook area", "lat": -43.69, "lon": 170.11},
+        {"name": "Canterbury high country", "lat": -43.53, "lon": 171.17},
+        {"name": "Tasman mountains", "lat": -41.56, "lon": 172.27}
+    ]
     
     apis_to_test = [
-        "https://api.openweathermap.org/data/2.5/weather?lat=-43.532&lon=172.637&appid=demo",
-        "https://api.weather.gov/points/-43.532,172.637",  # US NWS (won't work for NZ)
-        "https://api.tomorrow.io/v4/weather/realtime?location=-43.532,172.637",  # Tomorrow.io (needs key)
-        "https://api.visualcrossing.com/weather/historical?location=-43.532,172.637",  # Visual Crossing
+        {
+            "name": "OpenWeatherMap",
+            "url_template": "https://api.openweathermap.org/data/2.5/weather?lat={lat}&lon={lon}&appid=demo",
+            "has_snow": True
+        },
+        {
+            "name": "WeatherAPI",
+            "url_template": "http://api.weatherapi.com/v1/current.json?key=demo&q={lat},{lon}",
+            "has_snow": True
+        },
+        {
+            "name": "Visual Crossing",
+            "url_template": "https://weather.visualcrossing.com/VisualCrossingWebServices/rest/services/timeline/{lat},{lon}?key=demo",
+            "has_snow": True
+        }
     ]
     
-    for api_url in apis_to_test:
+    for api in apis_to_test:
         try:
-            response = requests.get(api_url, headers=headers, timeout=5)
+            test_loc = test_locations[0]  # Test with Mount Cook area
+            url = api["url_template"].format(lat=test_loc["lat"], lon=test_loc["lon"])
+            
+            response = requests.get(url, timeout=5)
+            
             if response.status_code == 200:
-                results.append(f"✅ {api_url.split('/')[2]}: Working")
+                results.append(f"✅ {api['name']}: API responds (may need valid key)")
+                try:
+                    data = response.json()
+                    if 'snow' in str(data).lower():
+                        results.append(f"   ❄️ Contains snow data fields")
+                except:
+                    pass
             elif response.status_code == 401:
-                results.append(f"🔐 {api_url.split('/')[2]}: API key required")
-            elif response.status_code == 404:
-                results.append(f"❌ {api_url.split('/')[2]}: No NZ coverage")
+                results.append(f"🔐 {api['name']}: API key required")
+            elif response.status_code == 403:
+                results.append(f"🚫 {api['name']}: Access forbidden")
             else:
-                results.append(f"❓ {api_url.split('/')[2]}: HTTP {response.status_code}")
+                results.append(f"❓ {api['name']}: HTTP {response.status_code}")
+                
+        except Exception as e:
+            results.append(f"❌ {api['name']}: {str(e)[:50]}...")
+    
+    # Add recommendations
+    results.append("\n**Recommendations for Real Data:**")
+    results.append("1. OpenWeatherMap: Free tier includes snow data")
+    results.append("2. WeatherAPI: Good NZ coverage with snow fields")  
+    results.append("3. Visual Crossing: Historical snow data available")
+    results.append("4. MetService (NZ): Local weather service APIs")
+    
+    return "\n".join(results)
+
+def analyze_all_stations():
+    """Get data from all stations and create summary"""
+    all_data = {}
+    images = []
+    
+    for station_key in SNOW_STATIONS.keys():
+        try:
+            image, info, extracted_data, status = fetch_and_analyze_station(station_key)
+            if image and extracted_data:
+                all_data[station_key] = extracted_data
+                images.append((image, f"{SNOW_STATIONS[station_key]['name']} ({extracted_data['estimated_current_depth']:.1f}cm)"))
         except:
-            results.append(f"❌ {api_url.split('/')[2]}: Connection failed")
+            continue
     
-    return "\n".join(results) if results else "No alternative APIs responded"
+    # Create summary comparison
+    summary = "**Snow Depth Comparison (Estimated from Charts):**\n\n"
+    for station_key, data in all_data.items():
+        station = SNOW_STATIONS[station_key]
+        summary += f"- **{station['name']}** ({station['elevation']}): ~{data['estimated_current_depth']:.1f}cm\n"
+    
+    summary += f"\n**Analysis completed:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+    summary += "\n\n⚠️ These are rough estimates from image analysis. For accurate data, use NIWA DataHub with proper authentication."
+    
+    return images, summary
 
-# Create Enhanced Gradio Interface
-with gr.Blocks(title="NIWA Snow Data - Real APIs + Chart Extraction", theme=gr.themes.Soft()) as app:
+# Create the Gradio Interface
+with gr.Blocks(title="NZ Snow Data - Chart Extraction & Alternatives", theme=gr.themes.Soft()) as app:
     gr.Markdown("""
-    # 🏔️ NIWA Snow Data: Real APIs + Chart Extraction
+    # 🏔️ New Zealand Snow Data: Chart Extraction & Alternatives
     
-    **Two approaches to get actual snow depth data:**
-    1. **Real NIWA APIs** - Test correct endpoints with authentication 
-    2. **Chart Data Extraction** - Computer vision analysis of snow depth charts
+    **Since NIWA APIs require complex authentication (email + 2FA), this app focuses on practical solutions:**
     
-    This app uses the **correct NIWA API structure** discovered from internal documentation!
+    1. **📊 Advanced Chart Data Extraction** - Computer vision analysis of snow depth charts
+    2. **🌐 Alternative Data Sources** - Other weather APIs with NZ coverage
+    3. **🔍 Direct Data Discovery** - Finding downloadable datasets
     """)
     
-    with gr.Tab("🔑 Real NIWA API Testing"):
-        gr.Markdown("""
-        ### Test Real NIWA Data APIs
-        
-        Based on internal NIWA documentation, the correct API structure is:
-        `https://data.niwa.co.nz/api/data/products/1/{feature_id}/{product_id}/{start_date}/{end_date}`
-        
-        Snow Water Equivalent Product ID: **43815863**
-        """)
-        
-        with gr.Row():
-            with gr.Column():
-                username_input = gr.Textbox(
-                    label="NIWA Username", 
-                    placeholder="Your NIWA DataHub username",
-                    type="text"
-                )
-                password_input = gr.Textbox(
-                    label="NIWA Password", 
-                    placeholder="Your NIWA DataHub password",
-                    type="password"
-                )
-            with gr.Column():
-                test_apis_btn = gr.Button("🔍 Test Real NIWA APIs", variant="primary")
-                test_alt_btn = gr.Button("🌐 Test Alternative APIs", variant="secondary")
-        
-        api_results = gr.Textbox(label="API Test Results", lines=15, interactive=False)
-        
-        gr.Markdown("""
-        **Expected Results:**
-        - Without credentials: 401 (Authentication required) 
-        - With valid credentials: JSON data with snow measurements
-        - Real-time and historical snow depth data in mm
-        """)
-    
     with gr.Tab("📊 Chart Data Extraction"):
         gr.Markdown("""
-        ### Extract Data from Snow Depth Charts
-        Computer vision analysis to extract approximate values from chart images.
+        ### Extract Real Data from Snow Depth Charts
+        Uses computer vision to analyze NIWA snow depth charts and extract approximate numerical values.
         """)
         
         with gr.Row():
@@ -316,118 +334,122 @@ with gr.Blocks(title="NIWA Snow Data - Real APIs + Chart Extraction", theme=gr.t
                 choices=list(SNOW_STATIONS.keys()),
                 value="Mueller Hut EWS",
                 label="Select Snow Station",
-                info="Choose station for chart analysis"
+                info="Station for detailed analysis"
             )
-            fetch_analyze_btn = gr.Button("📈 Fetch & Analyze Chart", variant="primary")
+            analyze_btn = gr.Button("🔍 Analyze Chart Data", variant="primary")
         
         with gr.Row():
             with gr.Column(scale=2):
                 chart_image = gr.Image(label="Snow Depth Chart", height=500)
             with gr.Column(scale=1):
-                chart_analysis = gr.Markdown(label="Chart Analysis Results")
-        
-        chart_status = gr.Textbox(label="Analysis Status", interactive=False)
-    
-    with gr.Tab("🗺️ All Stations Overview"):
-        gr.Markdown("### Complete Station Network with Coordinates")
-        
-        # Create station details table
-        station_data = []
-        for key, station in SNOW_STATIONS.items():
-            station_data.append([
-                station['name'],
-                station['location'], 
-                station['elevation'],
-                f"{station['lat']}, {station['lon']}",
-                station['years']
-            ])
-        
-        station_table = gr.Dataframe(
-            value=station_data,
-            headers=["Station", "Location", "Elevation", "Coordinates", "Data Period"],
-            label="NIWA Snow & Ice Network Stations"
-        )
-        
-        fetch_all_btn = gr.Button("📡 Fetch All Station Charts", variant="primary")
-        all_results = gr.Gallery(label="All Station Charts", columns=2, height=400)
-    
-    with gr.Tab("📋 Real Data Access Guide"):
-        gr.Markdown("""
-        ## 🎯 How to Get Real Numerical Snow Data
-        
-        ### Method 1: NIWA DataHub API (Most Reliable)
+                extracted_info = gr.Markdown(label="Extracted Data Analysis")
         
-        **Step 1:** Register at https://data.niwa.co.nz/
-        **Step 2:** Get your credentials and use this app's API testing tab
-        **Step 3:** Use the correct API endpoint structure:
+        analysis_status = gr.Textbox(label="Analysis Status", interactive=False)
         
-        ```
-        https://data.niwa.co.nz/api/data/products/1/{feature_id}/{product_id}/{start_date}/{end_date}
-        ```
-        
-        **Known Product IDs:**
-        - Snow Water Equivalent: `43815863`
-        - You'll need to discover other snow depth product IDs
-        
-        **Authentication:** HTTP Digest Auth with your NIWA username/password
+        # Hidden component to store extracted data
+        extracted_data_store = gr.JSON(visible=False)
+    
+    with gr.Tab("🗺️ All Stations Summary"):
+        gr.Markdown("### Compare All Stations")
         
-        ### Method 2: Direct NIWA Contact
+        analyze_all_btn = gr.Button("📊 Analyze All Stations", variant="primary", size="lg")
         
-        Email NIWA data team with specific station requirements:
-        - Real-time access to SIN network data  
-        - Custom data extracts in CSV/JSON format
-        - API credentials for commercial use
+        with gr.Row():
+            all_images = gr.Gallery(label="All Station Charts with Estimates", columns=2, height=500)
+            stations_summary = gr.Markdown(label="Snow Depth Summary")
+    
+    with gr.Tab("🌐 Alternative Data Sources"):
+        gr.Markdown("""
+        ### Test Alternative Weather APIs
+        Find other data sources that provide New Zealand snow and weather data.
+        """)
         
-        ### Method 3: Chart Data Extraction (This App)
+        test_alternatives_btn = gr.Button("🔍 Test Alternative APIs", variant="secondary")
+        alternative_results = gr.Textbox(label="Alternative API Results", lines=15, interactive=False)
         
-        Use computer vision to extract approximate values from chart images:
-        - Useful for quick estimates
-        - Limited accuracy compared to raw data
-        - Good for proof-of-concept work
+        gr.Markdown("""
+        ### Recommended Data Sources:
         
-        ### What You Get with Real Data:
-        - ✅ Hourly snow depth measurements (mm)
-        - ✅ Snow water equivalent (kg/m²) 
-        - ✅ Temperature, wind, precipitation
-        - ✅ Historical time series data
-        - ✅ Quality-controlled research data
-        - ✅ Real-time updates during snow season
+        **For Programming/Research:**
+        - **OpenWeatherMap**: Free tier, has snow fields for NZ coordinates
+        - **WeatherAPI.com**: Good New Zealand coverage, snow depth data
+        - **Visual Crossing**: Historical weather data including snow
         
-        **Bottom Line:** Register at NIWA DataHub and use proper API authentication for real data!
+        **For Real-Time Monitoring:**
+        - **MetService NZ**: Official New Zealand weather service
+        - **NIWA Weather**: Real-time weather data (separate from DataHub)
+        - **Local Council APIs**: Regional weather monitoring systems
         """)
     
-    # Event handlers
-    test_apis_btn.click(
-        fn=try_real_niwa_apis,
-        inputs=[username_input, password_input],
-        outputs=[api_results]
-    )
-    
-    test_alt_btn.click(
-        fn=test_alternative_apis,
-        outputs=[api_results]
-    )
+    with gr.Tab("💡 Data Access Solutions"):
+        gr.Markdown("""
+        ## 🎯 Practical Solutions for Snow Data Access
+        
+        ### Option 1: Chart Extraction (This App) ✅
+        **What it does:**
+        - Computer vision analysis of NIWA snow depth charts
+        - Extracts approximate numerical values and trends
+        - Provides rough current snow depth estimates
+        
+        **Accuracy:** Moderate (±20-30cm) but useful for trends
+        **Use cases:** Quick assessments, relative comparisons, proof-of-concept
+        
+        ### Option 2: NIWA DataHub (Requires Account) 🔐
+        **Steps:**
+        1. Register at https://data.niwa.co.nz/ (email + 2FA)
+        2. Log in via web interface
+        3. Browse "Climate station data" or "Snow & Ice Network"
+        4. Download CSV files manually
+        5. For API access: Generate Personal Access Token after login
+        
+        **Accuracy:** High (research-grade)
+        **Use cases:** Research, official reports, detailed analysis
+        
+        ### Option 3: Alternative APIs ⚡
+        **Recommended:**
+        - **OpenWeatherMap** (free tier): Snow data for NZ coordinates
+        - **WeatherAPI.com**: Comprehensive NZ weather including snow
+        - **Visual Crossing**: Historical snow data with API access
+        
+        **Accuracy:** Good for general weather, limited for alpine specifics
+        **Use cases:** General weather apps, regional snow estimates
+        
+        ### Option 4: Direct NIWA Contact 📧
+        **For serious research:**
+        - Email NIWA data team directly
+        - Request specific dataset access
+        - Negotiate API access for commercial/research use
+        - Get real-time data feeds
+        
+        ### Option 5: Web Scraping (Advanced) 🤖
+        **Automated chart analysis:**
+        - Schedule regular image downloads
+        - Batch process multiple stations
+        - Track trends over time
+        - Store extracted data in database
+        
+        ## 🏆 Recommended Approach:
+        1. **Start with this app** for immediate estimates
+        2. **Register at NIWA DataHub** for accurate historical data
+        3. **Use alternative APIs** for general weather context
+        4. **Contact NIWA directly** for research-grade real-time access
+        """)
     
-    fetch_analyze_btn.click(
-        fn=fetch_snow_depth_image,
+    # Event handlers
+    analyze_btn.click(
+        fn=fetch_and_analyze_station,
         inputs=[station_dropdown],
-        outputs=[chart_image, chart_analysis, chart_status]
+        outputs=[chart_image, extracted_info, extracted_data_store, analysis_status]
     )
     
-    def fetch_all_charts():
-        images = []
-        for station_key in SNOW_STATIONS.keys():
-            try:
-                image, _, status = fetch_snow_depth_image(station_key)
-                if image:
-                    images.append((image, f"{SNOW_STATIONS[station_key]['name']}"))
-            except:
-                continue
-        return images
+    analyze_all_btn.click(
+        fn=analyze_all_stations,
+        outputs=[all_images, stations_summary]
+    )
     
-    fetch_all_btn.click(
-        fn=fetch_all_charts,
-        outputs=[all_results]
+    test_alternatives_btn.click(
+        fn=try_alternative_nz_weather_apis,
+        outputs=[alternative_results]
     )
 
 # Launch for HuggingFace Spaces
@@ -445,10 +467,10 @@ numpy>=1.21.0
 opencv-python>=4.5.0
 """
 
-# Updated README.md:
+# Practical README.md:
 """
 ---
-title: NIWA Snow Data - Real APIs + Chart Extraction
+title: NZ Snow Data - Chart Extraction & Alternatives  
 emoji: 🏔️
 colorFrom: blue
 colorTo: white
@@ -458,34 +480,40 @@ app_file: app.py
 pinned: false
 ---
 
-# NIWA Snow Data: Real APIs + Chart Extraction
-
-The ultimate solution for accessing New Zealand snow depth data through multiple approaches.
+# New Zealand Snow Data: Practical Solutions
 
-## 🎯 Key Features
+**Real solutions for accessing NZ alpine snow depth data when APIs require complex authentication.**
 
-**Real NIWA APIs:**
-- Tests correct API endpoints from internal NIWA documentation
-- HTTP Digest authentication support
-- Snow Water Equivalent product ID: 43815863
-- Real-time and historical data access
+## 🎯 What This App Does
 
 **Chart Data Extraction:**
-- Computer vision analysis of snow depth charts
-- Extracts approximate values from chart images
-- Basic chart structure analysis
-- Fallback when APIs require authentication
+- Computer vision analysis of NIWA snow depth charts
+- Extracts approximate numerical values (±20-30cm accuracy)
+- Provides trends and current estimates for 5 major stations
+
+**Alternative Data Sources:**
+- Tests other weather APIs with New Zealand coverage
+- Identifies services that provide snow data for NZ coordinates
+- Recommends practical alternatives to NIWA DataHub
 
-**Complete Station Coverage:**
-- 5 major NIWA Snow & Ice Network stations
-- Coordinates, elevations, and data periods
-- Mahanga, Mueller Hut, Mt Potts, Upper Rakaia, Albert Burn
+**Practical Access Guide:**
+- Multiple approaches from quick estimates to research-grade data
+- Clear instructions for each data source type
+- Realistic expectations about accuracy and access
 
-## 🔧 How It Works
+## 🏔️ Stations Covered
+- Mueller Hut EWS (1818m) - Mount Cook National Park
+- Mt Potts EWS (2128m) - Highest elevation station
+- Mahanga EWS (1940m) - Tasman region
+- Upper Rakaia EWS (1752m) - Canterbury
+- Albert Burn EWS (1280m) - Mt Aspiring region
 
-1. **Real APIs**: Enter your NIWA DataHub credentials to test actual data endpoints
-2. **Chart Analysis**: Computer vision extracts data from chart images
-3. **Alternative APIs**: Tests other weather services for New Zealand coverage
+## 🔧 Use Cases
+- Avalanche safety planning
+- Alpine recreation planning  
+- Research proof-of-concept
+- Climate monitoring
+- Water resource assessment
 
-Perfect for researchers, avalanche safety, and alpine planning!
+Perfect when you need NZ snow data but can't navigate complex authentication systems!
 """