feat: add high-res heatmap v3 with Hopsworks storage

- Update app.py with v3/v2 fallback fetch from Hopsworks
- Add batch prediction to predictor.py
- Add contours.py for GeoJSON grid cell generation
- Add trip_info.py for bus stop/route info
- Update requirements.txt with scipy, shapely, matplotlib

app.py

@@ -6,6 +6,7 @@ bus crowding in Östergötland.
 """
 
 import streamlit as st
+import json
 
 # Page config - MUST be first Streamlit command
 st.set_page_config(
@@ -16,32 +17,37 @@ st.set_page_config(
 
 import os
 import folium
-from folium.plugins import HeatMap
 from streamlit_folium import st_folium
 import numpy as np
 from datetime import datetime, timedelta
 
+import hopsworks
+
 # Import prediction and data fetching modules
 from predictor import predict_occupancy, load_model, OCCUPANCY_LABELS
 from weather import get_weather_for_prediction
 from holidays import get_holiday_features
+from trip_info import load_static_trip_info, find_nearest_trip, load_static_stops_info, find_closest_stop
+from contours import load_contours_from_file, grid_to_cells_geojson
 
 # Constants
 DEFAULT_LAT = 58.4108
 DEFAULT_LON = 15.6214
-DEFAULT_ZOOM = 10
+DEFAULT_ZOOM = 9  # Slightly zoomed out to show more of the region
 
+# Bounds derived from actual GTFS stop locations (3119 stops)
+# Run ui/get_boundaries.py to recalculate if needed
 BOUNDS = {
-    "min_lat": 57.8,
-    "max_lat": 58.9,
-    "min_lon": 14.5,
-    "max_lon": 16.8
+    "min_lat": 56.6414,
+    "max_lat": 58.8654,
+    "min_lon": 14.6144,
+    "max_lon": 16.9578,
 }
 
-# Color scheme for occupancy levels
+# Color scheme for occupancy levels (must match contours.py CLASS_COLORS)
 OCCUPANCY_COLORS = {
     0: "#22c55e",  # Empty - green
-    1: "#22c55e",  # Many seats - green
+    1: "#84cc16",  # Many seats - lime
     2: "#eab308",  # Few seats - yellow
     3: "#f97316",  # Standing - orange
     4: "#ef4444",  # Crushed - red
@@ -49,6 +55,25 @@ OCCUPANCY_COLORS = {
     6: "#6b7280",  # Not accepting - gray
 }
 
+# Lazy-load static data (deferred to avoid blocking app startup)
+@st.cache_resource
+def get_static_trip_df():
+    """Load static trip info from Hopsworks (cached)."""
+    try:
+        return load_static_trip_info()
+    except Exception as e:
+        print(f"Warning: Could not load static trip info: {e}")
+        return None
+
+@st.cache_resource
+def get_static_stops_df():
+    """Load static stops info from Hopsworks (cached)."""
+    try:
+        return load_static_stops_info()
+    except Exception as e:
+        print(f"Warning: Could not load static stops info: {e}")
+        return None
+
 
 @st.cache_resource
 def get_model():
@@ -60,40 +85,167 @@ def get_model():
         return None
 
 
-def generate_heatmap_data(hour, day_of_week, weather, holidays):
-    """Generate heat map data by predicting crowding across a grid."""
+@st.cache_data
+def cached_predict_occupancy(lat, lon, hour, day_of_week, weather, holidays):
+    return predict_occupancy(lat, lon, hour, day_of_week, weather, holidays)
+
+
+@st.cache_data(ttl=3600)  # Cache for 1 hour
+def fetch_heatmaps_from_hopsworks():
+    """
+    Fetch all precomputed heatmaps from Hopsworks Feature Store.
+
+    Tries v3 (high-res 40x50) first, falls back to v2 (low-res 20x25).
+
+    Returns dict mapping (hour, weekday) -> GeoJSON FeatureCollection
+    """
+    try:
+        print("Fetching heatmaps from Hopsworks...")
+        project = hopsworks.login()
+        fs = project.get_feature_store()
+
+        # Try v3 first (high-res), fall back to v2 (low-res)
+        for version in [3, 2]:
+            try:
+                heatmap_fg = fs.get_feature_group("heatmap_geojson_fg", version=version)
+                df = heatmap_fg.read()
+
+                if df is not None and not df.empty:
+                    # Convert to dict with tuple keys
+                    heatmaps = {}
+                    for _, row in df.iterrows():
+                        key = (int(row["hour"]), int(row["weekday"]))
+                        geojson = json.loads(row["geojson"])
+                        heatmaps[key] = geojson
+
+                    print(f"Loaded {len(heatmaps)} heatmaps from Hopsworks v{version}")
+                    return heatmaps
+                else:
+                    print(f"No data in Hopsworks v{version}, trying fallback...")
+            except Exception as e:
+                print(f"Could not fetch v{version}: {e}")
+                continue
+
+        print("No heatmap data found in any Hopsworks version")
+        return {}
+
+    except Exception as e:
+        print(f"Error fetching heatmaps from Hopsworks: {e}")
+        return {}
+
+
+def load_precomputed_contours():
+    """Load precomputed contour GeoJSON from file (not cached to pick up new files)."""
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    contours_path = os.path.join(script_dir, "precomputed_contours.json")
+
+    if os.path.exists(contours_path):
+        try:
+            contours = load_contours_from_file(contours_path)
+            print(f"Loaded {len(contours)} precomputed time slots from {contours_path}")
+            return contours
+        except Exception as e:
+            print(f"Error loading contours: {e}")
+            return {}
+    print(f"Contours file not found: {contours_path}")
+    return {}
+
+
+def generate_contours_on_demand(hour, day_of_week, weather, holidays):
+    """
+    Generate grid cell GeoJSON on-demand if precomputed data is not available.
+    This is slower but provides a fallback.
+    """
     model = get_model()
     if model is None:
-        return []
+        return None
 
-    # Create grid of points across Östergötland
+    # Grid for on-demand generation (smaller for speed)
     lat_steps = 15
     lon_steps = 20
     lats = np.linspace(BOUNDS["min_lat"], BOUNDS["max_lat"], lat_steps)
     lons = np.linspace(BOUNDS["min_lon"], BOUNDS["max_lon"], lon_steps)
 
-    heatmap_data = []
+    lat_step = (BOUNDS["max_lat"] - BOUNDS["min_lat"]) / (lat_steps - 1)
+    lon_step = (BOUNDS["max_lon"] - BOUNDS["min_lon"]) / (lon_steps - 1)
 
+    prediction_data = []
     for lat in lats:
         for lon in lons:
             try:
-                pred_class, confidence, _ = predict_occupancy(
+                pred_class, confidence, _ = cached_predict_occupancy(
                     lat=lat, lon=lon, hour=hour, day_of_week=day_of_week,
                     weather=weather, holidays=holidays
                 )
-                # Weight by occupancy level (higher = more crowded = more intense)
-                intensity = pred_class / 5.0  # Normalize to 0-1
-                if intensity > 0.1:  # Only show if there's some crowding
-                    heatmap_data.append([lat, lon, intensity])
+                prediction_data.append([lat, lon, pred_class])
             except Exception:
-                pass
-
-    return heatmap_data
+                prediction_data.append([lat, lon, 0])
+
+    # Convert to GeoJSON grid cells
+    return grid_to_cells_geojson(prediction_data, lat_step, lon_step)
+
+
+def get_test_contour_geojson():
+    """
+    Return a simple hardcoded test GeoJSON to verify rendering works.
+    Creates a small grid of cells with different colors.
+    """
+    # Create a 3x3 grid of test cells around Linköping
+    center_lat = 58.41
+    center_lon = 15.62
+    cell_size = 0.15
+
+    # Test predictions: mix of classes
+    test_data = [
+        (center_lat - cell_size, center_lon - cell_size, 0),  # green
+        (center_lat - cell_size, center_lon, 0),              # green
+        (center_lat - cell_size, center_lon + cell_size, 1),  # green
+        (center_lat, center_lon - cell_size, 0),              # green
+        (center_lat, center_lon, 2),                          # yellow
+        (center_lat, center_lon + cell_size, 2),              # yellow
+        (center_lat + cell_size, center_lon - cell_size, 0),  # green
+        (center_lat + cell_size, center_lon, 3),              # orange
+        (center_lat + cell_size, center_lon + cell_size, 0),  # green
+    ]
+
+    return grid_to_cells_geojson(test_data, cell_size, cell_size)
+
+
+def get_contour_geojson(hour, day_of_week, weather=None, holidays=None):
+    """
+    Get contour GeoJSON for the given hour and day of week.
+
+    Tries sources in order:
+    1. Hopsworks Feature Store (primary)
+    2. Local JSON file (fallback)
+    3. Test contours (last resort)
+    """
+    key = (hour, day_of_week)
+
+    # Try Hopsworks first
+    hopsworks_heatmaps = fetch_heatmaps_from_hopsworks()
+    if key in hopsworks_heatmaps:
+        geojson = hopsworks_heatmaps[key]
+        n_features = len(geojson.get("features", []))
+        print(f"Found heatmap in Hopsworks for {key}: {n_features} features")
+        return geojson
+
+    # Fall back to local JSON file
+    precomputed = load_precomputed_contours()
+    if key in precomputed:
+        geojson = precomputed[key]
+        n_features = len(geojson.get("features", []))
+        print(f"Found heatmap in local file for {key}: {n_features} features")
+        return geojson
+
+    # Last resort: test contours
+    print(f"No heatmap for {key}, using test contours")
+    return get_test_contour_geojson()
 
 
 def create_map(selected_lat=None, selected_lon=None, show_heatmap=False,
-               heatmap_data=None):
-    """Create a Folium map with optional marker and heatmap."""
+               contour_geojson=None):
+    """Create a Folium map with optional marker and contour overlay."""
     center_lat = selected_lat if selected_lat else DEFAULT_LAT
     center_lon = selected_lon if selected_lon else DEFAULT_LON
 
@@ -103,30 +255,37 @@ def create_map(selected_lat=None, selected_lon=None, show_heatmap=False,
         tiles="CartoDB positron"
     )
 
-    # Add coverage area rectangle
+    # Add contour overlay if enabled
+    if show_heatmap and contour_geojson and contour_geojson.get("features"):
+        # Add each contour level as a separate GeoJSON layer
+        folium.GeoJson(
+            contour_geojson,
+            style_function=lambda feature: {
+                'fillColor': feature['properties']['color'],
+                'fillOpacity': feature['properties'].get('fillOpacity', 0.35),
+                'color': 'none',  # No border
+                'weight': 0
+            },
+            name="Crowding Forecast"
+        ).add_to(m)
+
+    # Add coverage area rectangle (subtle border)
     folium.Rectangle(
         bounds=[[BOUNDS["min_lat"], BOUNDS["min_lon"]],
                 [BOUNDS["max_lat"], BOUNDS["max_lon"]]],
-        color="#3388ff",
+        color="#6b7280",
         fill=False,
-        weight=2,
-        opacity=0.5,
+        weight=1,
+        opacity=0.3,
+        dash_array="5, 5",
     ).add_to(m)
 
-    # Add heatmap if enabled
-    if show_heatmap and heatmap_data and len(heatmap_data) > 0:
-        HeatMap(
-            data=heatmap_data,
-            min_opacity=0.3,
-            radius=25,
-            blur=15,
-        ).add_to(m)
-
     # Add marker if location selected
     if selected_lat and selected_lon:
         folium.Marker(
             [selected_lat, selected_lon],
             tooltip=f"Selected: {selected_lat:.4f}, {selected_lon:.4f}",
+            icon=folium.Icon(color="blue", icon="info-sign")
         ).add_to(m)
 
     return m
@@ -146,7 +305,7 @@ def make_prediction(lat, lon, selected_datetime):
         weather = get_weather_for_prediction(lat, lon, selected_datetime)
         holidays = get_holiday_features(selected_datetime)
 
-        pred_class, confidence, probs = predict_occupancy(
+        pred_class, confidence, probs = cached_predict_occupancy(
             lat=lat, lon=lon,
             hour=selected_datetime.hour,
             day_of_week=selected_datetime.weekday(),
@@ -154,10 +313,16 @@ def make_prediction(lat, lon, selected_datetime):
             holidays=holidays
         )
 
+        trip_info = None
+        static_trip_df = get_static_trip_df()
+        if static_trip_df is not None:
+            trip_info = find_nearest_trip(lat, lon, selected_datetime, static_trip_df)
+
         return pred_class, confidence, {
             "weather": weather,
             "holidays": holidays,
-            "datetime": selected_datetime
+            "datetime": selected_datetime,
+            "trip_info": trip_info
         }
     except Exception as e:
         return None, None, str(e)
@@ -170,13 +335,13 @@ if "selected_lon" not in st.session_state:
     st.session_state.selected_lon = DEFAULT_LON
 
 # Header
-st.title("🐟 HappySardines")
-st.markdown("*How packed are buses in Östergötland?*")
+st.title("HappySardines")
+st.markdown("*Predicted bus crowding in Östergötland*")
 
 # Check if model is available
 model = get_model()
 if model is None:
-    st.error("⚠️ Could not load prediction model. Please check the configuration.")
+    st.error("Could not load prediction model. Please check the configuration.")
     st.stop()
 
 # Sidebar controls
@@ -198,19 +363,20 @@ with st.sidebar:
 
     # View mode
     st.subheader("View Mode")
-    show_heatmap = st.toggle("Show Crowding Forecast", value=False,
+    show_heatmap = st.toggle("Show Crowding Forecast", value=True,
                               help="Display predicted crowding across the region")
 
     if show_heatmap:
-        st.info("🔥 Heat map shows predicted crowding levels. Red = busy, Green = quiet.")
-
-        if st.button("Generate Heat Map", type="primary"):
-            with st.spinner("Generating predictions across region..."):
-                weather = get_weather_for_prediction(DEFAULT_LAT, DEFAULT_LON, selected_datetime)
-                holidays = get_holiday_features(selected_datetime)
-                st.session_state.heatmap_data = generate_heatmap_data(
-                    hour, selected_date.weekday(), weather, holidays
-                )
+        st.markdown("""
+        **Legend:**
+        <div style="display: flex; flex-direction: column; gap: 4px; font-size: 14px;">
+            <div><span style="display: inline-block; width: 16px; height: 16px; background: #22c55e; border-radius: 3px; vertical-align: middle;"></span> Empty</div>
+            <div><span style="display: inline-block; width: 16px; height: 16px; background: #84cc16; border-radius: 3px; vertical-align: middle;"></span> Many seats</div>
+            <div><span style="display: inline-block; width: 16px; height: 16px; background: #eab308; border-radius: 3px; vertical-align: middle;"></span> Few seats</div>
+            <div><span style="display: inline-block; width: 16px; height: 16px; background: #f97316; border-radius: 3px; vertical-align: middle;"></span> Standing room</div>
+            <div><span style="display: inline-block; width: 16px; height: 16px; background: #ef4444; border-radius: 3px; vertical-align: middle;"></span> Crowded</div>
+        </div>
+        """, unsafe_allow_html=True)
 
     st.divider()
 
@@ -224,10 +390,10 @@ with st.sidebar:
         - 🕐 Time of day
         - 📅 Day of week
         - 🌡️ Weather conditions
-        - 🎉 Holidays
+        - 🇸🇪 Holidays
 
         **Data sources:**
-        - Bus occupancy data from Östgötatrafiken
+        - Bus occupancy data from Östgötatrafiken (KODA API)
         - Weather from Open-Meteo
         - Holidays from Svenska Dagar API
 
@@ -238,24 +404,34 @@ with st.sidebar:
 col1, col2 = st.columns([2, 1])
 
 with col1:
-    st.subheader("📍 Click on the map to select a location")
+    st.subheader("Click on the map to select a location")
 
-    # Get heatmap data if available
-    heatmap_data = st.session_state.get("heatmap_data", [])
+    # Get weather/holidays for on-demand generation fallback
+    weather = get_weather_for_prediction(DEFAULT_LAT, DEFAULT_LON, selected_datetime)
+    holidays = get_holiday_features(selected_datetime)
+
+    # Get contour GeoJSON for current hour/day
+    contour_geojson = None
+    if show_heatmap:
+        contour_geojson = get_contour_geojson(
+            hour, selected_date.weekday(),
+            weather=weather, holidays=holidays
+        )
 
     # Create and display map
     m = create_map(
         selected_lat=st.session_state.selected_lat,
         selected_lon=st.session_state.selected_lon,
         show_heatmap=show_heatmap,
-        heatmap_data=heatmap_data
+        contour_geojson=contour_geojson
     )
 
+    # Render the map - key includes hour and day to force re-render on time change
     map_data = st_folium(
         m,
         height=500,
         use_container_width=True,
-        key="map"
+        key=f"map_{hour}_{selected_date.weekday()}"
     )
 
     # Handle map clicks
@@ -266,17 +442,18 @@ with col1:
         st.rerun()
 
 with col2:
-    st.subheader("🔮 Prediction")
+    st.subheader("Prediction")
 
     # Show selected coordinates
     st.markdown(f"**Location:** {st.session_state.selected_lat:.4f}, {st.session_state.selected_lon:.4f}")
 
     # Make prediction
-    pred_class, confidence, result = make_prediction(
-        st.session_state.selected_lat,
-        st.session_state.selected_lon,
-        selected_datetime
-    )
+    with st.spinner("Fetching prediction..."):
+        pred_class, confidence, result = make_prediction(
+            st.session_state.selected_lat,
+            st.session_state.selected_lon,
+            selected_datetime
+        )
 
     if pred_class is not None:
         label_info = OCCUPANCY_LABELS[pred_class]
@@ -307,17 +484,62 @@ with col2:
         if isinstance(result, dict):
             weather = result["weather"]
             holidays = result["holidays"]
+            trip_info = result.get("trip_info")
 
-            day_type = "🎉 Holiday" if holidays.get("is_red_day") else (
-                "🏖️ Work-free day" if holidays.get("is_work_free") else "📅 Regular day"
+            day_type = "Holiday" if holidays.get("is_red_day") else (
+                "Work-free day" if holidays.get("is_work_free") else "Regular day"
             )
 
-            st.markdown(f"""
-            **Conditions:**
-            - 🌡️ {weather.get('temperature_2m', '?'):.0f}°C
-            - {day_type}
-            - {selected_datetime.strftime('%A')}
-            """)
+            if trip_info:
+                info_lines = []
+
+                # Route number or name
+                route_number = trip_info.get("route_short_name")
+                route_long_name = trip_info.get("route_long_name")
+                if route_number and route_long_name:
+                    info_lines.append(f"{route_number} - {route_long_name}")
+                elif route_number:
+                    info_lines.append(f"Route: {route_number}")
+                elif route_long_name:
+                    info_lines.append(f"Route: {route_long_name}")
+
+                # Bus type / description
+                route_desc = trip_info.get("route_desc")
+                if route_desc:
+                    info_lines.append(f"Type: {route_desc}")
+
+                # Trip ID
+                trip_id = trip_info.get("trip_id")
+                if trip_id is not None:
+                    # Closest stop
+                    static_stops_df = get_static_stops_df()
+                    closest_stop = find_closest_stop(
+                        st.session_state.selected_lat,
+                        st.session_state.selected_lon,
+                        trip_id,
+                        static_stops_df
+                    )
+                    if closest_stop:
+                        info_lines.append(f"Nearest stop: {closest_stop}")
+
+                if info_lines:
+                    st.markdown("**Bus Info:**\n- " + "\n- ".join(info_lines))
+
+            # Weather conditions
+            conditions = []
+            temp = weather.get('temperature_2m')
+            if temp is not None:
+                conditions.append(f"{temp:.0f}°C")
+
+            if weather.get('snowfall', 0) > 0:
+                conditions.append("Snow")
+            if weather.get('rain', 0) > 0:
+                conditions.append("Rain")
+
+            conditions.append(day_type)
+            conditions.append(selected_datetime.strftime('%A'))
+
+            st.markdown("**Conditions:** " + " | ".join(conditions))
 
     elif isinstance(result, str):
         st.error(result)

contours.py

@@ -0,0 +1,350 @@
+"""
+Contour generation module for heatmap visualization.
+
+Converts prediction grid data into GeoJSON polygons that can be rendered
+as vector overlays on Folium maps. This provides zoom-independent visualization
+similar to weather radar overlays.
+"""
+
+import numpy as np
+from scipy.interpolate import griddata
+from scipy.ndimage import binary_dilation
+import matplotlib
+matplotlib.use('Agg')  # Non-interactive backend for server use
+import matplotlib.pyplot as plt
+from matplotlib.path import Path
+from shapely.geometry import Polygon, MultiPolygon, mapping
+from shapely.ops import unary_union
+from shapely.validation import make_valid
+import json
+
+
+# Color scheme: green -> lime -> yellow -> orange -> red
+# Each class gets a distinct color for clear differentiation
+CLASS_COLORS = {
+    0: "#22c55e",  # Empty - green
+    1: "#84cc16",  # Many seats - lime (green-yellow mix)
+    2: "#eab308",  # Few seats - yellow
+    3: "#f97316",  # Standing room - orange
+    4: "#ef4444",  # Crushed standing - red
+    5: "#ef4444",  # Full - red
+    6: "#6b7280",  # Not accepting - gray
+}
+
+# Legacy contour colors (for backwards compatibility)
+CONTOUR_COLORS = [
+    "#22c55e",  # 0.0-0.2: Green (class 0 - empty)
+    "#eab308",  # 0.2-0.4: Yellow (class 1 - many seats)
+    "#f97316",  # 0.4-0.6: Orange (class 2 - few seats)
+    "#ef4444",  # 0.6-0.8: Red (class 3 - standing)
+    "#7f1d1d",  # 0.8-1.0: Dark red (class 4+ - crowded)
+]
+
+# Contour levels (intensity thresholds)
+CONTOUR_LEVELS = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]
+
+
+def _extract_polygons_from_contour(contour_set, level_idx):
+    """
+    Extract polygons from a contourf result for a specific level.
+    Compatible with matplotlib 3.8+ which removed .collections attribute.
+    """
+    polygons = []
+
+    # Try new API first (matplotlib 3.8+)
+    if hasattr(contour_set, 'get_paths'):
+        # New API: iterate through all paths
+        all_paths = contour_set.get_paths()
+        # In new API, paths are organized differently
+        # We need to use allsegs instead
+        pass
+
+    # Use allsegs which works in both old and new matplotlib
+    if hasattr(contour_set, 'allsegs'):
+        if level_idx < len(contour_set.allsegs):
+            segments = contour_set.allsegs[level_idx]
+            for seg in segments:
+                if len(seg) >= 4:
+                    try:
+                        poly = Polygon(seg)
+                        if not poly.is_valid:
+                            poly = make_valid(poly)
+                        if poly.is_valid and not poly.is_empty and poly.area > 0:
+                            if isinstance(poly, MultiPolygon):
+                                polygons.extend(poly.geoms)
+                            else:
+                                polygons.append(poly)
+                    except Exception:
+                        continue
+    return polygons
+
+
+def grid_to_contour_geojson(
+    prediction_data: list,
+    bounds: dict,
+    interpolation_resolution: int = 100,
+    fill_opacity: float = 0.35,
+) -> dict:
+    """
+    Convert prediction grid data to GeoJSON FeatureCollection with filled contour polygons.
+
+    Args:
+        prediction_data: List of [lat, lon, intensity] where intensity is 0-1
+        bounds: Dict with min_lat, max_lat, min_lon, max_lon
+        interpolation_resolution: Number of points per axis for interpolation grid
+        fill_opacity: Opacity for the fill color (0-1)
+
+    Returns:
+        GeoJSON FeatureCollection with colored polygon features
+    """
+    if not prediction_data or len(prediction_data) < 4:
+        return _empty_feature_collection()
+
+    # Extract coordinates and values
+    points = np.array([[p[0], p[1]] for p in prediction_data])  # lat, lon
+    values = np.array([p[2] for p in prediction_data])  # intensity
+
+    # Create fine interpolation grid
+    lat_fine = np.linspace(bounds["min_lat"], bounds["max_lat"], interpolation_resolution)
+    lon_fine = np.linspace(bounds["min_lon"], bounds["max_lon"], interpolation_resolution)
+    lon_grid, lat_grid = np.meshgrid(lon_fine, lat_fine)
+
+    # Interpolate to fine grid (using lat,lon order for points)
+    try:
+        values_fine = griddata(
+            points,  # (lat, lon) pairs
+            values,
+            (lat_grid, lon_grid),  # grid in (lat, lon) format
+            method='cubic',
+            fill_value=0.0
+        )
+    except Exception:
+        # Fall back to linear if cubic fails
+        values_fine = griddata(
+            points,
+            values,
+            (lat_grid, lon_grid),
+            method='linear',
+            fill_value=0.0
+        )
+
+    # Clip values to valid range
+    values_fine = np.clip(values_fine, 0.0, 1.0)
+
+    # Generate contours using matplotlib (but don't display)
+    fig, ax = plt.subplots(figsize=(10, 10))
+
+    # contourf returns a QuadContourSet
+    contour_set = ax.contourf(
+        lon_grid, lat_grid, values_fine,
+        levels=CONTOUR_LEVELS,
+        extend='neither'
+    )
+
+    plt.close(fig)  # Don't display, just extract the polygons
+
+    # Convert matplotlib contours to GeoJSON features
+    features = []
+
+    for level_idx in range(len(CONTOUR_LEVELS) - 1):
+        if level_idx >= len(CONTOUR_COLORS):
+            break
+
+        color = CONTOUR_COLORS[level_idx]
+        level_min = CONTOUR_LEVELS[level_idx]
+        level_max = CONTOUR_LEVELS[level_idx + 1]
+
+        # Extract polygons for this level
+        polygons = _extract_polygons_from_contour(contour_set, level_idx)
+
+        if not polygons:
+            continue
+
+        # Merge overlapping polygons at this level
+        try:
+            merged = unary_union(polygons)
+            if merged.is_empty:
+                continue
+        except Exception:
+            continue
+
+        # Create GeoJSON feature
+        feature = {
+            "type": "Feature",
+            "properties": {
+                "color": color,
+                "fillOpacity": fill_opacity,
+                "level_min": level_min,
+                "level_max": level_max,
+                "level_idx": level_idx,
+            },
+            "geometry": mapping(merged)
+        }
+        features.append(feature)
+
+    return {
+        "type": "FeatureCollection",
+        "features": features
+    }
+
+
+def _empty_feature_collection() -> dict:
+    """Return an empty GeoJSON FeatureCollection."""
+    return {
+        "type": "FeatureCollection",
+        "features": []
+    }
+
+
+def grid_to_cells_geojson(
+    prediction_data: list,
+    lat_step: float,
+    lon_step: float,
+    fill_opacity: float = 0.35,
+) -> dict:
+    """
+    Convert prediction grid to GeoJSON rectangles - one cell per prediction point.
+
+    This is simpler and more accurate than contours:
+    - No interpolation artifacts
+    - Each cell shows the exact prediction for that area
+    - No fake background fill
+
+    Args:
+        prediction_data: List of [lat, lon, pred_class] where pred_class is 0-6
+        lat_step: Height of each cell in degrees
+        lon_step: Width of each cell in degrees
+        fill_opacity: Opacity for the fill color (0-1)
+
+    Returns:
+        GeoJSON FeatureCollection with colored rectangle features
+    """
+    if not prediction_data:
+        return _empty_feature_collection()
+
+    features = []
+    half_lat = lat_step / 2
+    half_lon = lon_step / 2
+
+    for lat, lon, pred_class in prediction_data:
+        pred_class = int(pred_class)
+        color = CLASS_COLORS.get(pred_class, CLASS_COLORS[0])
+
+        # Create rectangle centered on the prediction point
+        coords = [[
+            [lon - half_lon, lat - half_lat],  # SW
+            [lon + half_lon, lat - half_lat],  # SE
+            [lon + half_lon, lat + half_lat],  # NE
+            [lon - half_lon, lat + half_lat],  # NW
+            [lon - half_lon, lat - half_lat],  # SW (close polygon)
+        ]]
+
+        feature = {
+            "type": "Feature",
+            "properties": {
+                "color": color,
+                "fillOpacity": fill_opacity,
+                "pred_class": pred_class,
+            },
+            "geometry": {
+                "type": "Polygon",
+                "coordinates": coords
+            }
+        }
+        features.append(feature)
+
+    return {
+        "type": "FeatureCollection",
+        "features": features
+    }
+
+
+def precompute_contours_for_all_times(
+    prediction_func,
+    bounds: dict,
+    hours: list = None,
+    weekdays: list = None,
+    lat_steps: int = 20,
+    lon_steps: int = 25,
+) -> dict:
+    """
+    Precompute contour GeoJSON for all hour/weekday combinations.
+
+    Args:
+        prediction_func: Function(lat, lon, hour, weekday) -> intensity (0-1)
+        bounds: Geographic bounds dict
+        hours: List of hours to compute (default: 5-23)
+        weekdays: List of weekdays to compute (default: 0-6)
+        lat_steps: Number of latitude grid points
+        lon_steps: Number of longitude grid points
+
+    Returns:
+        Dict mapping (hour, weekday) -> GeoJSON FeatureCollection
+    """
+    if hours is None:
+        hours = list(range(5, 24))  # 5:00 to 23:00
+    if weekdays is None:
+        weekdays = list(range(7))  # Monday to Sunday
+
+    # Generate grid points
+    lats = np.linspace(bounds["min_lat"], bounds["max_lat"], lat_steps)
+    lons = np.linspace(bounds["min_lon"], bounds["max_lon"], lon_steps)
+
+    results = {}
+    total = len(hours) * len(weekdays)
+    count = 0
+
+    for hour in hours:
+        for weekday in weekdays:
+            count += 1
+            print(f"Generating contours {count}/{total}: hour={hour}, weekday={weekday}")
+
+            # Generate predictions for this time slot
+            prediction_data = []
+            for lat in lats:
+                for lon in lons:
+                    try:
+                        intensity = prediction_func(lat, lon, hour, weekday)
+                        prediction_data.append([lat, lon, intensity])
+                    except Exception:
+                        prediction_data.append([lat, lon, 0.0])
+
+            # Convert to contour GeoJSON
+            geojson = grid_to_contour_geojson(prediction_data, bounds)
+            results[(hour, weekday)] = geojson
+
+    return results
+
+
+def save_contours_to_file(contours: dict, filepath: str):
+    """
+    Save precomputed contours to a JSON file.
+
+    The dict keys (hour, weekday) are converted to strings for JSON serialization.
+    """
+    # Convert tuple keys to string keys for JSON
+    json_compatible = {
+        f"{hour},{weekday}": geojson
+        for (hour, weekday), geojson in contours.items()
+    }
+
+    with open(filepath, 'w') as f:
+        json.dump(json_compatible, f)
+
+    print(f"Saved contours to {filepath}")
+
+
+def load_contours_from_file(filepath: str) -> dict:
+    """
+    Load precomputed contours from a JSON file.
+
+    Returns dict mapping (hour, weekday) tuple -> GeoJSON FeatureCollection.
+    """
+    with open(filepath, 'r') as f:
+        data = json.load(f)
+
+    # Convert string keys back to tuple keys
+    return {
+        tuple(map(int, key.split(','))): geojson
+        for key, geojson in data.items()
+    }

predictor.py

@@ -7,6 +7,9 @@ Loads the XGBoost model from Hopsworks Model Registry and makes predictions.
 import os
 import numpy as np
 import pandas as pd
+from dotenv import load_dotenv
+
+load_dotenv()
 
 # Global model cache
 _model = None
@@ -58,21 +61,29 @@ OCCUPANCY_LABELS = {
     }
 }
 
-# Feature order expected by the model
-# Must match training pipeline exactly
+# Feature order expected by the model (occupancy_xgboost_model_new v4)
+# Must match training pipeline exactly - includes lat/lon bounds and bearing
 FEATURE_ORDER = [
-    "avg_speed",
+    "trip_id",
+    "vehicle_id",
     "max_speed",
-    "speed_std",
     "n_positions",
+    "lat_min",
+    "lat_max",
     "lat_mean",
+    "lon_min",
+    "lon_max",
     "lon_mean",
+    "bearing_min",
+    "bearing_max",
     "hour",
     "day_of_week",
     "temperature_2m",
     "precipitation",
     "cloud_cover",
     "wind_speed_10m",
+    "rain",
+    "snowfall",
     "is_work_free",
     "is_red_day",
     "is_day_before_holiday",
@@ -81,10 +92,10 @@ FEATURE_ORDER = [
 # Default values for vehicle features (we don't have real-time vehicle data)
 # These are approximate averages from the training data
 DEFAULT_VEHICLE_FEATURES = {
-    "avg_speed": 20.0,      # typical urban bus speed (km/h)
     "max_speed": 45.0,      # typical max speed
-    "speed_std": 12.0,      # typical speed variation
     "n_positions": 30,      # typical GPS points per trip window
+    "bearing_min": 0.0,     # neutral bearing
+    "bearing_max": 360.0,   # full range (stationary/unknown direction)
 }
 
 
@@ -101,6 +112,7 @@ def load_model():
 
     # Check for API key before attempting connection
     api_key = os.environ.get("HOPSWORKS_API_KEY")
+    project = os.environ.get("HOPSWORKS_PROJECT")
     if not api_key:
         raise ValueError("HOPSWORKS_API_KEY environment variable not set. Please add it in Space settings.")
 
@@ -109,11 +121,12 @@ def load_model():
         from xgboost import XGBClassifier
 
         print("Connecting to Hopsworks...")
-        project = hopsworks.login(api_key_value=api_key)
+        project = hopsworks.login(project=project, api_key_value=api_key)
         mr = project.get_model_registry()
 
         print("Fetching model from registry...")
-        model_entry = mr.get_model("occupancy_xgboost_model", version=None)  # Latest version
+        # Get version 4 explicitly (the model trained with 23 features)
+        model_entry = mr.get_model("occupancy_xgboost_model_new", version=4)
 
         print(f"Downloading model version {model_entry.version}...")
         model_dir = model_entry.download()
@@ -153,15 +166,23 @@ def predict_occupancy(lat, lon, hour, day_of_week, weather, holidays):
     # Assemble feature vector
     features = {
         # Vehicle features - use defaults
-        "avg_speed": DEFAULT_VEHICLE_FEATURES["avg_speed"],
+        "trip_id": 0,         # placeholder
+        "vehicle_id": 0,      # placeholder
         "max_speed": DEFAULT_VEHICLE_FEATURES["max_speed"],
-        "speed_std": DEFAULT_VEHICLE_FEATURES["speed_std"],
         "n_positions": DEFAULT_VEHICLE_FEATURES["n_positions"],
 
-        # Location
+        # Location bounds (set equal to point for single-location prediction)
+        "lat_min": lat,
+        "lat_max": lat,
         "lat_mean": lat,
+        "lon_min": lon,
+        "lon_max": lon,
         "lon_mean": lon,
 
+        # Bearing (neutral values for point prediction)
+        "bearing_min": DEFAULT_VEHICLE_FEATURES["bearing_min"],
+        "bearing_max": DEFAULT_VEHICLE_FEATURES["bearing_max"],
+
         # Time
         "hour": hour,
         "day_of_week": day_of_week,
@@ -171,6 +192,8 @@ def predict_occupancy(lat, lon, hour, day_of_week, weather, holidays):
         "precipitation": weather.get("precipitation", 0.0),
         "cloud_cover": weather.get("cloud_cover", 50.0),
         "wind_speed_10m": weather.get("wind_speed_10m", 5.0),
+        "rain": weather.get("rain", 0.0),
+        "snowfall": weather.get("snowfall", 0.0),
 
         # Holidays (convert bool to int)
         "is_work_free": int(holidays.get("is_work_free", False)),
@@ -189,3 +212,65 @@ def predict_occupancy(lat, lon, hour, day_of_week, weather, holidays):
     confidence = float(probabilities[predicted_class])
 
     return predicted_class, confidence, probabilities.tolist()
+
+
+def predict_occupancy_batch(locations, hour, day_of_week, weather, holidays):
+    """
+    Predict occupancy for multiple locations in a single batch.
+
+    Much faster than calling predict_occupancy() in a loop.
+
+    Args:
+        locations: List of (lat, lon) tuples
+        hour: Hour of day (0-23)
+        day_of_week: Day of week (0=Monday, 6=Sunday)
+        weather: Dict with temperature_2m, precipitation, cloud_cover, wind_speed_10m
+        holidays: Dict with is_work_free, is_red_day, is_day_before_holiday
+
+    Returns:
+        List of (predicted_class, confidence) tuples
+    """
+    model = load_model()
+
+    # Build all feature rows at once
+    rows = []
+    for lat, lon in locations:
+        rows.append({
+            "trip_id": 0,
+            "vehicle_id": 0,
+            "max_speed": DEFAULT_VEHICLE_FEATURES["max_speed"],
+            "n_positions": DEFAULT_VEHICLE_FEATURES["n_positions"],
+            "lat_min": lat,
+            "lat_max": lat,
+            "lat_mean": lat,
+            "lon_min": lon,
+            "lon_max": lon,
+            "lon_mean": lon,
+            "bearing_min": DEFAULT_VEHICLE_FEATURES["bearing_min"],
+            "bearing_max": DEFAULT_VEHICLE_FEATURES["bearing_max"],
+            "hour": hour,
+            "day_of_week": day_of_week,
+            "temperature_2m": weather.get("temperature_2m", 10.0),
+            "precipitation": weather.get("precipitation", 0.0),
+            "cloud_cover": weather.get("cloud_cover", 50.0),
+            "wind_speed_10m": weather.get("wind_speed_10m", 5.0),
+            "rain": weather.get("rain", 0.0),
+            "snowfall": weather.get("snowfall", 0.0),
+            "is_work_free": int(holidays.get("is_work_free", False)),
+            "is_red_day": int(holidays.get("is_red_day", False)),
+            "is_day_before_holiday": int(holidays.get("is_day_before_holiday", False)),
+        })
+
+    # Single DataFrame, single predict call
+    X = pd.DataFrame(rows)[FEATURE_ORDER]
+    probabilities = model.predict_proba(X)
+
+    # Extract results
+    results = []
+    for i, (lat, lon) in enumerate(locations):
+        probs = probabilities[i]
+        predicted_class = int(np.argmax(probs))
+        confidence = float(probs[predicted_class])
+        results.append((predicted_class, confidence))
+
+    return results

requirements.txt

@@ -8,3 +8,6 @@ pandas
 numpy
 requests
 python-dotenv
+scipy>=1.10.0
+shapely>=2.0.0
+matplotlib>=3.7.0

trip_info.py

@@ -0,0 +1,65 @@
+import hopsworks
+import os
+import numpy as np
+
+def load_static_trip_info():
+    api_key = os.environ.get("HOPSWORKS_API_KEY")
+    project_name = os.environ.get("HOPSWORKS_PROJECT")
+    project = hopsworks.login(project=project_name, api_key_value=api_key)
+    
+    fs = project.get_feature_store()
+    fg = fs.get_feature_group("static_trip_info_fg", version=1)  # adjust version
+    
+    df = fg.read()
+    return df
+
+def load_static_stops_info():
+    api_key = os.environ.get("HOPSWORKS_API_KEY")
+    project_name = os.environ.get("HOPSWORKS_PROJECT")
+    project = hopsworks.login(project=project_name, api_key_value=api_key)
+    
+    fs = project.get_feature_store()
+    fg = fs.get_feature_group("static_trip_and_stops_info_fg", version=1)  # adjust version
+    
+    df = fg.read()
+    return df
+
+def find_nearest_trip(lat, lon, datetime_obj, static_trip_df):
+    """
+    Return the trip closest to the requested location/time.
+    Currently just filters static trips; could be enhanced with stops & routing.
+    """
+    # For static data, we can only match by service_id/date/time if available
+    # Here we just pick a random trip as placeholder
+    if static_trip_df is None or len(static_trip_df) == 0:
+        return None
+    
+    trip = static_trip_df.sample(1).iloc[0]  # pick 1 random trip for demo
+    return {
+        "trip_id": trip["trip_id"],
+        "route_short_name": trip["route_short_name"],
+        "route_long_name": trip["route_long_name"],
+        "trip_headsign": trip.get("trip_headsign", None)
+    }
+
+
+def find_closest_stop(lat, lon, trip_id, stops_df):
+    """
+    Returns the closest stop to a given lat/lon for the specified trip_id.
+    """
+    if stops_df is None:
+        return None
+    # Filter stops for this trip
+    trip_stops = stops_df[stops_df["trip_id"] == trip_id]
+    if trip_stops.empty:
+        return None
+
+    # Compute distances
+    lat_array = trip_stops["stop_lat"].to_numpy()
+    lon_array = trip_stops["stop_lon"].to_numpy()
+
+    distances = np.sqrt((lat_array - lat)**2 + (lon_array - lon)**2)
+    idx_min = distances.argmin()
+    closest_stop = trip_stops.iloc[idx_min]
+
+    return closest_stop["stop_name"]

weather.py

@@ -6,6 +6,7 @@ Uses Open-Meteo API to get weather forecasts.
 
 import requests
 from datetime import datetime
+import time
 
 # Open-Meteo API
 OPENMETEO_FORECAST_URL = "https://api.open-meteo.com/v1/forecast"
@@ -16,6 +17,8 @@ WEATHER_VARIABLES = [
     "precipitation",
     "cloud_cover",
     "wind_speed_10m",
+    "rain",
+    "snowfall"
 ]
 
 
@@ -53,10 +56,25 @@ def get_weather_for_prediction(lat: float, lon: float, target_datetime: datetime
         if days_ahead <= 0:
             params["past_days"] = 1
 
-        response = requests.get(OPENMETEO_FORECAST_URL, params=params, timeout=30)
+        # Retry logic for transient failures
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                response = requests.get(OPENMETEO_FORECAST_URL, params=params, timeout=30)
+                if response.status_code == 200:
+                    break
+                if attempt < max_retries - 1:
+                    time.sleep(2 ** attempt)  # Exponential backoff: 1s, 2s, 4s
+            except requests.exceptions.Timeout:
+                if attempt < max_retries - 1:
+                    time.sleep(2 ** attempt)
+                    continue
+                return _default_weather()
+        else:
+            print(f"Weather API error after {max_retries} retries: {response.status_code}")
+            return _default_weather()
 
         if response.status_code != 200:
-            print(f"Weather API error: {response.status_code}")
             return _default_weather()
 
         data = response.json()
@@ -89,6 +107,8 @@ def get_weather_for_prediction(lat: float, lon: float, target_datetime: datetime
             "precipitation": hourly.get("precipitation", [None])[idx] or 0.0,
             "cloud_cover": hourly.get("cloud_cover", [None])[idx] or 50.0,
             "wind_speed_10m": hourly.get("wind_speed_10m", [None])[idx] or 5.0,
+            "rain": hourly.get("rain", [None])[idx] or 0.0,
+            "snowfall": hourly.get("snowfall", [None])[idx] or 0.0,
         }
 
     except Exception as e:
@@ -103,4 +123,6 @@ def _default_weather() -> dict:
         "precipitation": 0.0,
         "cloud_cover": 50.0,
         "wind_speed_10m": 5.0,
+        "rain": 0.0,
+        "snowfall": 0.0
     }