HrrrVizCodex

Sleeping

App Files Files Community

nakas commited on Sep 16, 2025

Commit

2b1f0e8

1 Parent(s): 7490235

feat(compare): add non-animated Leaflet static overlay side-by-side with Plotly; feat(export): KMZ overlay export (gx:LatLonQuad) with transparent PNG

Browse files

Files changed (1) hide show

app.py +307 -5

app.py CHANGED Viewed

@@ -469,6 +469,198 @@ def add_radar_image_layer(fig: go.Figure, lat2d: np.ndarray, lon2d: np.ndarray,
         print(f"Image layer error: {e}")
         return False
 def _locate_or_download_grib(forecast_hour: int):
     """Return local GRIB2 path for HRRR REFC at fxx, downloading if needed."""
     if not HERBIE_AVAILABLE:
@@ -633,6 +825,85 @@ def export_radar_grib(forecast_hour: int, min_dbz: float):
     except Exception as e:
         return None, f"Export error: {e}"
 def download_raw_grib(forecast_hour: int):
     """Return a copy-path under ./exports for the raw HRRR GRIB2 file used for REFC at the given forecast hour."""
     try:
@@ -1276,6 +1547,7 @@ def update_display(location, forecast_hour, parameter, show_radar_overlay, detai
         # Optional animation and Leaflet overlay
         gif_path = None
         leaflet_html = ""
         if animate_forecast:
             try:
                 gif_path, _ = generate_radar_animation_gif(detail_level=int(detail_level), min_dbz=float(min_dbz))
@@ -1294,7 +1566,13 @@ def update_display(location, forecast_hour, parameter, show_radar_overlay, detai
             except Exception as e:
                 leaflet_html = f"<div style='padding:8px;color:#900'>Leaflet overlay build failed: {str(e)}</div>"
-        return status, weather_map, gif_path, leaflet_html
     except Exception as e:
         print(f"Update error: {e}")
@@ -1305,7 +1583,7 @@ def update_display(location, forecast_hour, parameter, show_radar_overlay, detai
         error_fig.add_annotation(text=f"Update failed: {str(e)}", x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False)
         error_fig.update_layout(height=300)
-        return f"## Error\n{str(e)}", error_fig, None, ""
 # Stable interface - single map only
 with gr.Blocks(title="HRRR Weather + Radar") as app:
@@ -1379,7 +1657,9 @@ with gr.Blocks(title="HRRR Weather + Radar") as app:
         with gr.Column():
             status_text = gr.Markdown("Click button to fetch HRRR weather + radar data")
-            weather_map = gr.Plot()
             animation_view = gr.Image(label="Radar Animation (0–18h)")
             leaflet_overlay = gr.HTML(label="Leaflet Overlay")
             export_file = gr.File(label="GRIB2 Export", visible=True)
@@ -1389,14 +1669,14 @@ with gr.Blocks(title="HRRR Weather + Radar") as app:
     update_btn.click(
         fn=update_display,
         inputs=[location, forecast_hour, parameter, show_radar_overlay, detail_level, min_dbz, animate_forecast],
-        outputs=[status_text, weather_map, animation_view, leaflet_overlay]
     )
     # Auto-update when toggling radar
     show_radar_overlay.change(
         fn=update_display,
         inputs=[location, forecast_hour, parameter, show_radar_overlay, detail_level, min_dbz, animate_forecast],
-        outputs=[status_text, weather_map, animation_view, leaflet_overlay]
     )
     # Export GRIB button
@@ -1419,6 +1699,28 @@ with gr.Blocks(title="HRRR Weather + Radar") as app:
         outputs=[export_file]
     )
     def _download_raw_handler(forecast_hour):
         path, msg = download_raw_grib(int(forecast_hour))
         if path:

         print(f"Image layer error: {e}")
         return False
+def render_radar_png_data_url(z2d: np.ndarray, detail_level: int = 5) -> Optional[str]:
+    """Render a single radar frame (z2d) to a transparent PNG data URL."""
+    try:
+        import io, base64
+        import matplotlib
+        matplotlib.use('Agg', force=True)
+        import matplotlib.pyplot as plt
+        zmask = np.ma.masked_invalid(z2d)
+        cmap = build_mpl_colormap(get_radar_colorscale())
+        if cmap is None:
+            return None
+        ny, nx = z2d.shape
+        scale_map = {1: 1.2, 2: 1.6, 3: 2.0, 4: 3.0, 5: 4.0}
+        scale = scale_map.get(int(detail_level) if detail_level is not None else 3, 2.0)
+        max_pixels = 2_400_000
+        width = int(nx * scale)
+        height = int(ny * scale)
+        if width * height > max_pixels:
+            ratio = math.sqrt(max_pixels / (width * height))
+            width = max(64, int(width * ratio))
+            height = max(64, int(height * ratio))
+        dpi = 100
+        fig_img = plt.figure(figsize=(width / dpi, height / dpi), dpi=dpi)
+        fig_img.patch.set_alpha(0.0)
+        ax = fig_img.add_axes([0, 0, 1, 1])
+        ax.patch.set_alpha(0.0)
+        ax.imshow(zmask, cmap=cmap, vmin=0, vmax=65, origin='upper', interpolation='bilinear')
+        ax.axis('off')
+        buf = io.BytesIO()
+        fig_img.savefig(buf, format='png', dpi=dpi, transparent=True)
+        plt.close(fig_img)
+        img_b64 = base64.b64encode(buf.getvalue()).decode('ascii')
+        return f"data:image/png;base64,{img_b64}"
+    except Exception as e:
+        print(f"render_radar_png_data_url error: {e}")
+        return None
+def build_leaflet_static_overlay_html(grid: Optional[Dict[str, Any]], detail_level: int = 5) -> str:
+    """Build a Leaflet HTML with a single transparent PNG overlaid using piecewise projective warping."""
+    try:
+        if not grid:
+            return "<div style='padding:8px;color:#666'>No radar grid available.</div>"
+        lat2d = grid['lat2d']
+        lon2d = grid['lon2d']
+        z2d = grid['z2d']
+        data_url = render_radar_png_data_url(z2d, detail_level)
+        if not data_url:
+            return "<div style='padding:8px;color:#900'>Failed to render radar image.</div>"
+        min_lat = float(np.nanmin(lat2d))
+        max_lat = float(np.nanmax(lat2d))
+        min_lon = float(np.nanmin(lon2d))
+        max_lon = float(np.nanmax(lon2d))
+        c_lat = float(np.nanmean(lat2d))
+        c_lon = float(np.nanmean(lon2d))
+        ny, nx = lat2d.shape
+        TY = max(6, min(18, ny // 10))
+        TX = max(8, min(24, nx // 10))
+        yi = np.linspace(0, ny - 1, TY + 1).astype(int)
+        xi = np.linspace(0, nx - 1, TX + 1).astype(int)
+        tiles = []
+        for i in range(TY):
+            for j in range(TX):
+                i0, i1 = yi[i], yi[i+1]
+                j0, j1 = xi[j], xi[j+1]
+                tiles.append({
+                    'tl': [float(lat2d[i0, j0]), float(lon2d[i0, j0])],
+                    'tr': [float(lat2d[i0, j1]), float(lon2d[i0, j1])],
+                    'br': [float(lat2d[i1, j1]), float(lon2d[i1, j1])],
+                    'bl': [float(lat2d[i1, j0]), float(lon2d[i1, j0])],
+                    'ti': int(i), 'tj': int(j)
+                })
+        tiles_json = json.dumps(tiles)
+        doc = f"""
+        <!doctype html>
+        <html>
+        <head>
+          <meta charset=\"utf-8\" />
+          <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />
+          <link rel=\"stylesheet\" href=\"https://unpkg.com/leaflet@1.9.4/dist/leaflet.css\"/>
+          <style>
+            html,body,#leaflet-map{{height:100%;margin:0;padding:0}}
+            .tile img{{pointer-events:none;}}
+          </style>
+        </head>
+        <body>
+          <div id=\"leaflet-map\"></div>
+          <script src=\"https://unpkg.com/leaflet@1.9.4/dist/leaflet.js\"></script>
+          <script>
+          (function() {{
+            var map = L.map('leaflet-map', {{center: [{c_lat:.5f}, {c_lon:.5f}], zoom: 5, zoomControl: true}});
+            L.tileLayer('https://{{s}}.tile.openstreetmap.org/{{z}}/{{x}}/{{y}}.png', {{
+                maxZoom: 18,
+                attribution: '&copy; OpenStreetMap contributors'
+            }}).addTo(map);
+            var bounds = [[{min_lat:.6f}, {min_lon:.6f}], [{max_lat:.6f}, {max_lon:.6f}]];
+            map.fitBounds(bounds);
+            var frame = '{data_url}';
+            var tiles = {tiles_json};
+            var TX = {TX};
+            var TY = {TY};
+            var overlayPane = map.getPanes().overlayPane;
+            var container = document.createElement('div');
+            container.style.position = 'absolute';
+            overlayPane.appendChild(container);
+            var baseImg = new Image();
+            baseImg.onload = function() {{
+              var w = baseImg.naturalWidth, h = baseImg.naturalHeight;
+              var tw = w / TX, th = h / TY;
+              var tilesEls = [];
+              for (var k=0; k<tiles.length; k++) {{
+                var t = tiles[k];
+                var tile = document.createElement('div');
+                tile.className = 'tile';
+                tile.style.position = 'absolute';
+                tile.style.width = tw + 'px';
+                tile.style.height = th + 'px';
+                tile.style.transformOrigin = '0 0';
+                var im = new Image();
+                im.src = frame;
+                im.style.position = 'absolute';
+                im.style.left = (-t.tj * tw) + 'px';
+                im.style.top = (-t.ti * th) + 'px';
+                im.style.width = w + 'px';
+                im.style.height = h + 'px';
+                tile.appendChild(im);
+                container.appendChild(tile);
+                tilesEls.push({{tile: tile, t: t}});
+              }}
+              function applyTransforms() {{
+                for (var kk=0; kk<tilesEls.length; kk++) {{
+                  var el = tilesEls[kk];
+                  var t = el.t;
+                  var p0 = map.latLngToLayerPoint([t.tl[0], t.tl[1]]);
+                  var p1 = map.latLngToLayerPoint([t.tr[0], t.tr[1]]);
+                  var p2 = map.latLngToLayerPoint([t.br[0], t.br[1]]);
+                  var p3 = map.latLngToLayerPoint([t.bl[0], t.bl[1]]);
+                  var x0=p0.x, y0=p0.y, x1=p1.x, y1=p1.y, x2=p2.x, y2=p2.y, x3=p3.x, y3=p3.y;
+                  var dx1 = x1 - x2, dy1 = y1 - y2;
+                  var dx2 = x3 - x2, dy2 = y3 - y2;
+                  var dx3 = x0 - x1 + x2 - x3, dy3 = y0 - y1 + y2 - y3;
+                  var a, b, c, d, e, f, g, h2;
+                  if (dx3 === 0 && dy3 === 0) {{
+                    g = 0; h2 = 0;
+                    a = x1 - x0; b = x3 - x0; c = x0;
+                    d = y1 - y0; e = y3 - y0; f = y0;
+                  }} else {{
+                    var denom = dx1*dy2 - dx2*dy1;
+                    g = (dx3*dy2 - dx2*dy3)/denom;
+                    h2 = (dx1*dy3 - dx3*dy1)/denom;
+                    a = x1 - x0 + g*x1;
+                    b = x3 - x0 + h2*x3;
+                    c = x0;
+                    d = y1 - y0 + g*y1;
+                    e = y3 - y0 + h2*y3;
+                    f = y0;
+                  }}
+                  a /= tw; b /= th; d /= tw; e /= th; g /= tw; h2 /= th;
+                  var css = 'matrix3d('+
+                    a + ',' + d + ',0,' + g + ','+
+                    b + ',' + e + ',0,' + h2 + ','+
+                    '0,0,1,0,'+
+                    c + ',' + f + ',0,1)';
+                  el.tile.style.transform = css;
+                }}
+              }}
+              applyTransforms();
+              map.on('zoom viewreset move', applyTransforms);
+            }};
+            baseImg.src = frame;
+          }})();
+          </script>
+        </body>
+        </html>
+        """
+        # Escape for srcdoc
+        doc_escaped = doc.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace("\"", "&quot;")
+        return f"<iframe srcdoc=\"{doc_escaped}\" style=\"width:100%;height:520px;border:none;border-radius:8px\"></iframe>"
+    except Exception as e:
+        return f"<div style='padding:8px;color:#900'>Leaflet static overlay error: {str(e)}</div>"
 def _locate_or_download_grib(forecast_hour: int):
     """Return local GRIB2 path for HRRR REFC at fxx, downloading if needed."""
     if not HERBIE_AVAILABLE:
     except Exception as e:
         return None, f"Export error: {e}"
+def export_kmz_radar(forecast_hour: int, detail_level: int = 5, min_dbz: float = 0.0):
+    """Export a KMZ (KML + PNG) GroundOverlay of HRRR radar reflectivity for the given forecast hour.
+    Uses gx:LatLonQuad for the four-corner overlay to preserve orientation.
+    Returns (kmz_path, message)."""
+    try:
+        if not HERBIE_AVAILABLE:
+            return None, "Herbie is not available"
+        ds = fetch_real_hrrr_data('REFC:entire atmosphere', int(forecast_hour))
+        if isinstance(ds, tuple):
+            ds = ds[0]
+        grid = process_hrrr_grid(ds, target_cells={1:20000,2:40000,3:60000,4:90000,5:120000}.get(int(detail_level), 120000), param_type='radar', min_threshold=float(min_dbz))
+        if not grid:
+            return None, "Radar grid not available"
+        lat2d = grid['lat2d']
+        lon2d = grid['lon2d']
+        z2d = grid['z2d']
+        # Render PNG bytes
+        try:
+            import io
+            import matplotlib
+            matplotlib.use('Agg', force=True)
+            import matplotlib.pyplot as plt
+            zmask = np.ma.masked_invalid(z2d)
+            cmap = build_mpl_colormap(get_radar_colorscale())
+            ny, nx = z2d.shape
+            scale_map = {1: 1.2, 2: 1.6, 3: 2.0, 4: 3.0, 5: 4.0}
+            scale = scale_map.get(int(detail_level), 2.0)
+            width = int(nx * scale)
+            height = int(ny * scale)
+            dpi = 100
+            fig_img = plt.figure(figsize=(width / dpi, height / dpi), dpi=dpi)
+            fig_img.patch.set_alpha(0.0)
+            ax = fig_img.add_axes([0, 0, 1, 1])
+            ax.patch.set_alpha(0.0)
+            ax.imshow(zmask, cmap=cmap, vmin=0, vmax=65, origin='upper', interpolation='bilinear')
+            ax.axis('off')
+            buf = io.BytesIO()
+            fig_img.savefig(buf, format='png', dpi=dpi, transparent=True)
+            plt.close(fig_img)
+            png_bytes = buf.getvalue()
+        except Exception as e:
+            return None, f"PNG render error: {e}"
+        # Corners TL, TR, BR, BL
+        lat_tl, lon_tl = float(lat2d[0, 0]), float(lon2d[0, 0])
+        lat_tr, lon_tr = float(lat2d[0, -1]), float(lon2d[0, -1])
+        lat_br, lon_br = float(lat2d[-1, -1]), float(lon2d[-1, -1])
+        lat_bl, lon_bl = float(lat2d[-1, 0]), float(lon2d[-1, 0])
+        kml = f"""
+<?xml version="1.0" encoding="UTF-8"?>
+<kml xmlns="http://www.opengis.net/kml/2.2" xmlns:gx="http://www.google.com/kml/ext/2.2">
+  <GroundOverlay>
+    <name>HRRR Radar Reflectivity f{int(forecast_hour):02d}</name>
+    <color>ffffffff</color>
+    <Icon><href>overlay.png</href></Icon>
+    <gx:LatLonQuad>
+      <coordinates>
+        {lon_tl:.6f},{lat_tl:.6f},0 {lon_tr:.6f},{lat_tr:.6f},0 {lon_br:.6f},{lat_br:.6f},0 {lon_bl:.6f},{lat_bl:.6f},0
+      </coordinates>
+    </gx:LatLonQuad>
+  </GroundOverlay>
+</kml>
+"""
+        import zipfile
+        os.makedirs('exports', exist_ok=True)
+        kmz_path = os.path.join('exports', f"hrrr_radar_f{int(forecast_hour):02d}.kmz")
+        with zipfile.ZipFile(kmz_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+            zf.writestr('doc.kml', kml)
+            zf.writestr('overlay.png', png_bytes)
+        return kmz_path, None
+    except Exception as e:
+        return None, f"KMZ export error: {e}"
 def download_raw_grib(forecast_hour: int):
     """Return a copy-path under ./exports for the raw HRRR GRIB2 file used for REFC at the given forecast hour."""
     try:
         # Optional animation and Leaflet overlay
         gif_path = None
         leaflet_html = ""
+        leaflet_static = ""
         if animate_forecast:
             try:
                 gif_path, _ = generate_radar_animation_gif(detail_level=int(detail_level), min_dbz=float(min_dbz))
             except Exception as e:
                 leaflet_html = f"<div style='padding:8px;color:#900'>Leaflet overlay build failed: {str(e)}</div>"
+        # Always build static overlay for side-by-side comparison
+        try:
+            leaflet_static = build_leaflet_static_overlay_html(LAST_RADAR_GRID, detail_level=int(detail_level))
+        except Exception as e:
+            leaflet_static = f"<div style='padding:8px;color:#900'>Leaflet static overlay failed: {str(e)}</div>"
+        return status, weather_map, gif_path, leaflet_html, leaflet_static
     except Exception as e:
         print(f"Update error: {e}")
         error_fig.add_annotation(text=f"Update failed: {str(e)}", x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False)
         error_fig.update_layout(height=300)
+        return f"## Error\n{str(e)}", error_fig, None, "", ""
 # Stable interface - single map only
 with gr.Blocks(title="HRRR Weather + Radar") as app:
         with gr.Column():
             status_text = gr.Markdown("Click button to fetch HRRR weather + radar data")
+            with gr.Row():
+                weather_map = gr.Plot()
+                leaflet_static = gr.HTML(label="Leaflet Static Overlay")
             animation_view = gr.Image(label="Radar Animation (0–18h)")
             leaflet_overlay = gr.HTML(label="Leaflet Overlay")
             export_file = gr.File(label="GRIB2 Export", visible=True)
     update_btn.click(
         fn=update_display,
         inputs=[location, forecast_hour, parameter, show_radar_overlay, detail_level, min_dbz, animate_forecast],
+        outputs=[status_text, weather_map, animation_view, leaflet_overlay, leaflet_static]
     )
     # Auto-update when toggling radar
     show_radar_overlay.change(
         fn=update_display,
         inputs=[location, forecast_hour, parameter, show_radar_overlay, detail_level, min_dbz, animate_forecast],
+        outputs=[status_text, weather_map, animation_view, leaflet_overlay, leaflet_static]
     )
     # Export GRIB button
         outputs=[export_file]
     )
+    # Export KMZ overlay
+    export_kmz_btn = gr.Button("Export KMZ Overlay")
+    kmz_file = gr.File(label="KMZ Overlay", visible=True)
+    def _export_kmz_handler(forecast_hour, detail_level, min_dbz):
+        path, msg = export_kmz_radar(int(forecast_hour), int(detail_level), float(min_dbz))
+        if path:
+            return path
+        else:
+            import os
+            os.makedirs('exports', exist_ok=True)
+            err_path = f"exports/kmz_error.txt"
+            with open(err_path, 'w') as f:
+                f.write(msg or 'KMZ export failed')
+            return err_path
+    export_kmz_btn.click(
+        fn=_export_kmz_handler,
+        inputs=[forecast_hour, detail_level, min_dbz],
+        outputs=[kmz_file]
+    )
     def _download_raw_handler(forecast_hour):
         path, msg = download_raw_grib(int(forecast_hour))
         if path: