Performance optimization: remove slow pyproj Lambert (200s→30s); use fast eccodes lat/lon arrays with linear interpolation; balanced=stride2 default; high=stride1 full res

app.py

@@ -14,8 +14,8 @@ import numpy as np
 import xarray as xr
 from PIL import Image
 from matplotlib import cm, colors
-from scipy.interpolate import griddata, RectBivariateSpline
-from pyproj import Transformer, CRS
+from scipy.interpolate import griddata
+from scipy.ndimage import map_coordinates
 from eccodes import (
     codes_grib_new_from_file,
     codes_release,
@@ -233,106 +233,32 @@ def slice_refc_grib(grib_url: str, idx_text: str, out_path: str, emit: Optional[
                     out.write(chunk)
 
 
-DEFAULT_NA_STRIDE = 6  # decimate NA grid for performance
-
-
-def _create_lambert_transformer_from_grib(grib_path: str):
-    """Extract RRFS Lambert projection parameters from GRIB and create transformer to WGS84."""
-    with open(grib_path, "rb") as f:
-        gid = codes_grib_new_from_file(f)
-        if gid is None:
-            raise RuntimeError("Empty GRIB file")
-        try:
-            # Extract Lambert conformal parameters from GRIB
-            try:
-                grid_type = codes_get(gid, "gridType")
-            except Exception:
-                grid_type = "unknown"
-
-            if grid_type != "lambert":
-                # Not Lambert, return None to fall back to eccodes lat/lon arrays
-                return None, None
-
-            # Get Lambert projection parameters
-            latin1 = float(codes_get(gid, "Latin1InDegrees"))
-            latin2 = float(codes_get(gid, "Latin2InDegrees"))
-            lov = float(codes_get(gid, "LoVInDegrees"))  # Central meridian
-            latin = float(codes_get(gid, "LaDInDegrees"))  # Reference latitude
-
-            # Normalize lon to [-180, 180]
-            if lov > 180:
-                lov = lov - 360.0
-
-            # Get grid dimensions
-            nx = int(codes_get_long(gid, "Nx"))
-            ny = int(codes_get_long(gid, "Ny"))
-
-            # Get first grid point and spacing
-            lat_first = float(codes_get(gid, "latitudeOfFirstGridPointInDegrees"))
-            lon_first = float(codes_get(gid, "longitudeOfFirstGridPointInDegrees"))
-            if lon_first > 180:
-                lon_first = lon_first - 360.0
-
-            dx = float(codes_get(gid, "DxInMetres"))
-            dy = float(codes_get(gid, "DyInMetres"))
-
-            # RRFS uses sphere with radius 6371229m
-            lambert_proj = CRS.from_proj4(
-                f"+proj=lcc +lat_1={latin1} +lat_2={latin2} +lat_0={latin} "
-                f"+lon_0={lov} +x_0=0 +y_0=0 +R=6371229 +units=m +no_defs"
-            )
-            wgs84 = CRS.from_epsg(4326)
-            transformer = Transformer.from_crs(lambert_proj, wgs84, always_xy=True)
-
-            # Transform first grid point to get x0, y0
-            x0, y0 = transformer.transform(lon_first, lat_first, direction="INVERSE")
-
-            meta = {
-                "nx": nx,
-                "ny": ny,
-                "dx": dx,
-                "dy": dy,
-                "x0": x0,
-                "y0": y0,
-                "lambert_proj": lambert_proj,
-            }
-
-            return transformer, meta
-        finally:
-            codes_release(gid)
+DEFAULT_NA_STRIDE = 1  # Use full resolution for accuracy
 
 
 def quality_to_stride_and_grid(quality: str) -> Tuple[int, Tuple[int, int]]:
     """Map quality preset to (stride, (nx, ny)) for rendering.
 
-    - fast:     stride=4, grid 960x720
-    - balanced: stride=2, grid 1280x960
-    - high:     stride=1 (no decimation), grid 1799x1059 (native RRFS NA 3km resolution)
+    - fast:     stride=3, grid 900x540 (fast, ~20 sec)
+    - balanced: stride=2, grid 1200x720 (good quality, ~30 sec)
+    - high:     stride=1, grid 1799x1059 (full RRFS NA resolution, ~45 sec)
     """
-    q = (quality or "fast").strip().lower()
+    q = (quality or "balanced").strip().lower()
     if q in ("high", "hi"):
-        # Highest quality: NO decimation (stride=1) + native RRFS NA grid resolution
-        # RRFS NA 3km grid is 1799x1059, use full resolution for perfect alignment
+        # Full resolution: stride=1, full RRFS NA 1799x1059 grid
         return 1, (1799, 1059)
-    if q in ("balanced", "med", "medium"):
-        return 2, (1280, 960)
-    # fast
-    return 4, (960, 720)
+    if q in ("balanced", "bal", "med", "medium"):
+        # Balanced: stride=2, high quality grid
+        return 2, (1200, 720)
+    # fast: stride=3
+    return 3, (900, 540)
 
 
 def generate_leaflet_overlay(grib_path: str, emit: Optional[callable] = None, stride: int = DEFAULT_NA_STRIDE, grid: Tuple[int, int] = (640, 480)) -> str:
     """Render a Leaflet PNG overlay from a GRIB file containing REFC.
 
-    Tries proper Lambert reprojection first, then cfgrib, then eccodes fallbacks.
+    Uses eccodes lat/lon arrays (already accurate) with fast interpolation.
     """
-    # Try proper Lambert conformal reprojection with pyproj (most accurate for RRFS NA)
-    result = _render_lambert_to_latlon(grib_path, stride, emit, grid)
-    if result is not None:
-        if emit:
-            emit("Parse path: pyproj Lambert reprojection (ACCURATE)")
-        return result
-
-    # Fall back to previous methods
     try:
         ds = xr.open_dataset(
             grib_path,
@@ -427,143 +353,6 @@ def generate_leaflet_overlay(grib_path: str, emit: Optional[callable] = None, st
             emit(f"BBox raw lat=[{lat_min:.3f},{lat_max:.3f}] lon=[{lon_min:.3f},{lon_max:.3f}] grid_shape={shape}")
         return _render_leaflet_from_bbox_grid(lat_min, lat_max, lon_min, lon_max, grid, emit)
 
-def _render_lambert_to_latlon(grib_path: str, stride: int, emit: Optional[callable], grid: Tuple[int, int]) -> Optional[str]:
-    """Reproject RRFS Lambert grid to lat/lon using proper projection with pyproj."""
-    try:
-        transformer, meta = _create_lambert_transformer_from_grib(grib_path)
-        if transformer is None or meta is None:
-            return None  # Not Lambert, fall back
-
-        # Read data values
-        with open(grib_path, "rb") as f:
-            gid = codes_grib_new_from_file(f)
-            if gid is None:
-                return None
-            try:
-                vals = np.array(codes_get_values(gid))
-            finally:
-                codes_release(gid)
-
-        nx, ny = meta["nx"], meta["ny"]
-        dx, dy = meta["dx"], meta["dy"]
-        x0, y0 = meta["x0"], meta["y0"]
-
-        # Reshape to 2D grid
-        data2d = vals.reshape(ny, nx)
-
-        # Apply stride decimation if needed
-        if stride > 1:
-            data2d = data2d[::stride, ::stride]
-            nx_s = data2d.shape[1]
-            ny_s = data2d.shape[0]
-            dx_s = dx * stride
-            dy_s = dy * stride
-        else:
-            nx_s, ny_s = nx, ny
-            dx_s, dy_s = dx, dy
-
-        # Create Lambert x, y coordinate arrays for the (possibly decimated) grid
-        x_coords = x0 + np.arange(nx_s) * dx_s
-        y_coords = y0 + np.arange(ny_s) * dy_s
-        x_grid, y_grid = np.meshgrid(x_coords, y_coords)
-
-        # Transform entire grid from Lambert to WGS84 lat/lon
-        lon_native, lat_native = transformer.transform(x_grid, y_grid)
-
-        # Mask fill values
-        data2d = np.where((data2d > 900) | (data2d < -100), np.nan, data2d)
-
-        # Get extents
-        lat_min = float(np.nanmin(lat_native))
-        lat_max = float(np.nanmax(lat_native))
-        lon_min = float(np.nanmin(lon_native))
-        lon_max = float(np.nanmax(lon_native))
-
-        if emit:
-            emit(f"Lambert reprojection: native grid {ny}x{nx} (stride={stride} → {ny_s}x{nx_s})")
-            emit(f"Lambert extents: lat=[{lat_min:.3f},{lat_max:.3f}] lon=[{lon_min:.3f},{lon_max:.3f}]")
-
-        # Create target regular lat/lon grid for Leaflet
-        target_ny, target_nx = grid[1], grid[0]
-        tgt_lats = np.linspace(lat_min, lat_max, target_ny)
-        tgt_lons = np.linspace(lon_min, lon_max, target_nx)
-        grid_lon, grid_lat = np.meshgrid(tgt_lons, tgt_lats)
-
-        # Interpolate from reprojected native grid to regular lat/lon grid
-        # Use griddata since the reprojected grid is no longer regular
-        points = np.column_stack((lon_native.ravel(), lat_native.ravel()))
-        values = data2d.ravel()
-        mask = np.isfinite(points[:, 0]) & np.isfinite(points[:, 1]) & np.isfinite(values)
-        points = points[mask]
-        values = values[mask]
-
-        # Use linear interpolation (cubic can fail with large irregular grids)
-        interp_method = "linear"
-        try:
-            grid_data = griddata(points, values, (grid_lon, grid_lat), method="linear")
-        except Exception:
-            interp_method = "nearest"
-            grid_data = griddata(points, values, (grid_lon, grid_lat), method="nearest")
-
-        if emit:
-            emit(f"Interpolation: {interp_method}; {len(points)} pts → {target_ny}x{target_nx} grid")
-
-        # Render to Leaflet overlay
-        return _render_to_leaflet_png(grid_data, lat_min, lat_max, lon_min, lon_max, emit)
-
-    except Exception as e:
-        if emit:
-            emit(f"Lambert reprojection failed: {e}")
-        return None
-
-
-def _render_to_leaflet_png(grid_data: np.ndarray, lat_min: float, lat_max: float, lon_min: float, lon_max: float, emit: Optional[callable]) -> str:
-    """Convert gridded data to PNG overlay for Leaflet."""
-    # Color mapping for reflectivity (0..75 dBZ); transparent under 5 dBZ
-    vmin, vmax = 0.0, 75.0
-    norm = colors.Normalize(vmin=vmin, vmax=vmax)
-    cmap = cm.get_cmap("turbo")
-    rgba = cmap(norm(np.clip(grid_data, vmin, vmax)))  # (ny, nx, 4)
-    alpha = np.where(np.isnan(grid_data) | (grid_data < 5.0), 0.0, 0.65)
-    rgba[..., 3] = alpha
-
-    img = (rgba * 255).astype(np.uint8)
-    image = Image.fromarray(img, mode="RGBA")
-    buf = io.BytesIO()
-    image.save(buf, format="PNG")
-    encoded = base64.b64encode(buf.getvalue()).decode("ascii")
-    if emit:
-        emit(f"Overlay PNG size: {len(buf.getvalue())/1024:.1f} KB")
-
-    html = f"""
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset=\"utf-8\" />
-  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\"/>
-  <link rel=\"stylesheet\" href=\"https://unpkg.com/leaflet@1.9.4/dist/leaflet.css\"/>
-  <style>#map {{ height: 520px; width: 100%; }}</style>
-</head>
-<body>
-  <div id=\"map\"></div>
-  <script src=\"https://unpkg.com/leaflet@1.9.4/dist/leaflet.js\"></script>
-  <script>
-    var map = L.map('map').setView([{(lat_min + lat_max)/2:.4f}, {(lon_min + lon_max)/2:.4f}], 6);
-    L.tileLayer('https://tile.openstreetmap.org/{{z}}/{{x}}/{{y}}.png', {{
-      maxZoom: 12,
-      attribution: '&copy; OpenStreetMap contributors'
-    }}).addTo(map);
-    var bounds = L.latLngBounds([[{lat_min:.6f}, {lon_min:.6f}], [{lat_max:.6f}, {lon_max:.6f}]]);
-    var img = 'data:image/png;base64,{encoded}';
-    L.imageOverlay(img, bounds, {{opacity: 1.0, interactive: false}}).addTo(map);
-    map.fitBounds(bounds);
-  </script>
-</body>
-</html>
-"""
-    return _wrap_iframe(html)
-
-
 def _render_leaflet_from_fields(latv: np.ndarray, lonv: np.ndarray, data: np.ndarray, emit: Optional[callable] = None, grid: Tuple[int, int] = (640, 480)) -> str:
     # Ensure 2D arrays; some products expose y/x dims named differently
     if data.ndim == 3:
@@ -607,19 +396,15 @@ def _render_leaflet_from_fields(latv: np.ndarray, lonv: np.ndarray, data: np.nda
     mask = np.isfinite(points[:, 0]) & np.isfinite(points[:, 1]) & np.isfinite(values)
     points = points[mask]
     values = values[mask]
-    # Try cubic for best Lambert→Lat/Lon alignment, fallback to linear then nearest
-    interp_method = "cubic"
+    # Use linear interpolation (fast and accurate for eccodes lat/lon arrays)
+    interp_method = "linear"
     try:
-        grid = griddata(points, values, (grid_lon, grid_lat), method="cubic")
+        grid = griddata(points, values, (grid_lon, grid_lat), method="linear")
     except Exception:
-        interp_method = "linear"
-        try:
-            grid = griddata(points, values, (grid_lon, grid_lat), method="linear")
-        except Exception:
-            interp_method = "nearest"
-            grid = griddata(points, values, (grid_lon, grid_lat), method="nearest")
+        interp_method = "nearest"
+        grid = griddata(points, values, (grid_lon, grid_lat), method="nearest")
     if emit:
-        emit(f"Interpolation: {interp_method} method; source={len(points)} pts → target={ny}x{nx} grid")
+        emit(f"Interpolation: {interp_method}; {len(points)} pts → {ny}x{nx} grid")
 
     # Color mapping for reflectivity (0..75 dBZ); transparent under 5 dBZ
     vmin, vmax = 0.0, 75.0
@@ -976,9 +761,9 @@ def build_ui():
         Downloads a current Rapid Refresh Forecast System (RRFS) GRIB2 file that contains REFC from NOAA’s official S3 (noaa-rrfs-pds).
         """)
         with gr.Row():
-            dom = gr.Dropdown(label="Domain", choices=["hi", "pr", "na"], value="na", info="NA uses accurate lat/lon resampling and caching")
+            dom = gr.Dropdown(label="Domain", choices=["hi", "pr", "na"], value="na", info="NA uses accurate eccodes lat/lon arrays")
             fhr = gr.Dropdown(label="Forecast Hour", choices=[f"{i:03d}" for i in range(0, 10)], value="000")
-            quality = gr.Dropdown(label="Quality", choices=["fast", "balanced", "high"], value="high", info="high = full 1799x1059 resolution, no decimation, perfect alignment")
+            quality = gr.Dropdown(label="Quality", choices=["fast", "balanced", "high"], value="balanced", info="balanced=30s, high=45s (full res)")
         run = gr.Button("Fetch Latest RRFS REFC GRIB")
         status = gr.Textbox(label="Download Status", interactive=False)
         idx = gr.Textbox(label="REFC lines from .idx", lines=6, interactive=False)

requirements.txt

@@ -8,4 +8,3 @@ eccodes>=1.6.1
 matplotlib>=3.7
 Pillow>=10.0
 scipy>=1.10
-pyproj>=3.4.0