ok

README.md

@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 ---
 title: Pydar Draw
 emoji: 🏆
@@ -12,3 +13,67 @@ short_description: recolor radar feeds
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+=======
+PydarDraw: Radar dBZ Quantization and Recoloring
+
+Overview
+- Fetch radar composite imagery from government WMS (e.g., MSC GeoMet).
+- Quantize pixel colors to source-layer dBZ using a configurable color table, with optional fractional dBZ (xx.xx) estimates from anti-aliased pixels.
+- Identify contiguous colored blocks (connected components) per dBZ.
+- Recolor the image into another dBZ color table (e.g., US NWS).
+
+Status
+- Default color tables for US NWS reflectivity and a pragmatic Canadian MSC reflectivity table are included. You may override with your own JSON or derive from a provided legend image.
+- No external services are required to run quantization/recoloring on a local image. Fetching from WMS requires network.
+
+Quick Start
+1) Recolor a local PNG using defaults (fractional dBZ optional):
+   ```python
+   from PIL import Image
+   import numpy as np
+   from pydardraw.processing.convert import image_to_dbz, dbz_to_image
+   from pydardraw.colormaps.canada_msc import CANADA_MSC_REF
+   from pydardraw.colormaps.nws_us import NWS_REF
+
+   img = Image.open("input_radar.png").convert("RGBA")
+   dbz, alpha = image_to_dbz(img, CANADA_MSC_REF, fractional=True)  # set False for discrete
+   recolored = dbz_to_image(dbz, alpha, NWS_REF)
+   recolored.save("recolored_nws.png")
+   ```
+
+2) Connected components and pixel resolution:
+   ```python
+   from pydardraw.processing.components import label_components
+   labels, stats = label_components(dbz, min_dbz=20)
+   # stats contains component sizes in pixels and km^2 if you supply bbox
+   ```
+
+3) Fetch a Canada composite via MSC GeoMet WMS and recolor (exact legend-derived palette):
+   ```python
+   from pydardraw.sources.msc_geomet import fetch_wms_png
+   from pydardraw.sources.msc_colormap import get_msc_reflectivity_colormap
+   from pydardraw.colormaps.nws_us import NWS_REF
+   from pydardraw.processing.convert import image_to_dbz, dbz_to_image
+
+   img = fetch_wms_png(
+       layer="RADAR_1KM_RDBR",
+       bbox=(-141, 41.6751, -52.6194, 83.1139),  # lon_min, lat_min, lon_max, lat_max
+       size=(1024, 768),
+   )
+   src_map = get_msc_reflectivity_colormap("RADAR_1KM_RDBR", derive_from_legend=True)
+   dbz, alpha = image_to_dbz(img, src_map, fractional=True)
+   recolored = dbz_to_image(dbz, alpha, NWS_REF)
+   recolored.save("canada_recolored.png")
+   ```
+
+Color Tables
+- US NWS reflectivity colors follow a commonly used palette for dBZ steps.
+- Canadian MSC reflectivity colors are provided as a practical approximation; you can replace with your authoritative mapping (see `pydardraw/colormaps/canada_msc.py`).
+
+Folium Overlay
+- Create a Folium map with a recolored overlay and the original WMS layer for comparison using `pydardraw.viz.folium_overlay.make_map_with_overlay`.
+
+Notes
+- Transparent pixels are treated as no-data (NaN) in the dBZ array and preserved in alpha.
+- Distance/resolution: Use the known WMS bbox and image size to compute km per pixel with a spherical earth approximation.
+>>>>>>> eaf9109 (Add Gradio app for MSC→NWS recolor)

app.py

@@ -0,0 +1,32 @@
+"""
+Gradio entrypoint for Hugging Face Spaces.
+
+This wraps the existing demo in apps/canada_radar_gradio.py so Spaces can
+discover `app.py` at the repo root.
+"""
+
+from __future__ import annotations
+
+import os
+
+from apps.canada_radar_gradio import demo as _demo
+
+# Expose as `demo` for Spaces discovery
+demo = _demo
+
+
+if __name__ == "__main__":
+    # Allow local run: `python app.py`
+    launch_kwargs = dict(server_name="0.0.0.0", debug=True)
+    port = os.getenv("GRADIO_SERVER_PORT")
+    if port:
+        try:
+            p = int(port)
+            if p > 0:
+                launch_kwargs["server_port"] = p
+        except Exception:
+            pass
+    share = os.getenv("GRADIO_SHARE", "0").lower() in {"1", "true", "yes"}
+    launch_kwargs["share"] = share
+    demo.launch(**launch_kwargs)
+

apps/__init__.py

@@ -0,0 +1 @@
+# Mark apps as a package for imports

apps/canada_radar_gradio.py

@@ -0,0 +1,166 @@
+import gradio as gr
+from PIL import Image
+import numpy as np
+
+from pydardraw.sources.msc_geomet import fetch_wms_png
+from pydardraw.sources.msc_colormap import get_msc_reflectivity_colormap, get_msc_reflectivity_gradient_map
+from pydardraw.colormaps.canada_msc import CANADA_MSC_REF
+from pydardraw.colormaps.nws_us import NWS_REF
+from pydardraw.processing.convert import image_to_dbz, dbz_to_image
+from pydardraw.processing.components import estimate_pixel_resolution, label_components, component_areas_km2
+from pydardraw.viz.folium_overlay import make_map_with_overlay
+
+
+CANADA_BBOX = (-141.0, 41.6751, -52.6194, 83.1139)  # lon_min, lat_min, lon_max, lat_max
+
+
+def fetch_and_recolor(
+    size_w: int,
+    size_h: int,
+    layer: str,
+    min_dbz: float = 20.0,
+    derive_palette: bool = True,
+    overlay_opacity: float = 0.8,
+    fractional_dbz: bool = True,
+    use_gradient_mapping: bool = True,
+    grad_min: float = 5.0,
+    grad_max: float = 75.0,
+    grad_orientation: str = "vertical",
+    grad_low_at_bottom: bool = True,
+    grad_stride: int = 1,
+    grad_manual_crop: bool = False,
+    crop_x0: int = 0,
+    crop_y0: int = 0,
+    crop_x1: int = 0,
+    crop_y1: int = 0,
+):
+    try:
+        img = fetch_wms_png(layer=layer, bbox=CANADA_BBOX, size=(size_w, size_h))
+    except Exception as e:
+        return None, None, f"Fetch error: {e}", ""
+
+    # Choose mapping: gradient (pixel-by-pixel) or discrete stops
+    if use_gradient_mapping:
+        manual_bbox = (int(crop_x0), int(crop_y0), int(crop_x1), int(crop_y1)) if grad_manual_crop else None
+        grad_map = get_msc_reflectivity_gradient_map(
+            layer=layer,
+            min_dbz=grad_min,
+            max_dbz=grad_max,
+            orientation=grad_orientation,
+            low_at_bottom=grad_low_at_bottom,
+            sample_stride=int(grad_stride),
+            manual_bbox=manual_bbox,
+        )
+        # Use gradient map's fractional evaluator for precise decimals
+        dbz, alpha = image_to_dbz(img, grad_map, fractional=True)
+    else:
+        # Build exact palette (derived) if requested; fallback to built-in
+        src_map = get_msc_reflectivity_colormap(layer, derive_from_legend=derive_palette)
+        dbz, alpha = image_to_dbz(img, src_map, fractional=fractional_dbz)
+    recolored = dbz_to_image(dbz, alpha, NWS_REF)
+
+    res = estimate_pixel_resolution(CANADA_BBOX, (size_w, size_h))
+    labels, stats = label_components(dbz, min_dbz=float(min_dbz))
+    areas = component_areas_km2(labels, res)
+
+    # Summary text
+    comp_count = len(stats)
+    total_km2 = sum(areas.values())
+    # Compute basic stats (mean/median dBZ over valid)
+    valid = ~np.isnan(dbz)
+    mean_dbz = float(np.nanmean(dbz)) if np.any(valid) else float("nan")
+    median_dbz = float(np.nanmedian(dbz)) if np.any(valid) else float("nan")
+    summary = (
+        f"Resolution: {res.km_per_px_x:.2f} km/px (x), {res.km_per_px_y:.2f} km/px (y)\n"
+        f"Components (>= {min_dbz:.2f} dBZ): {comp_count}\n"
+        f"Total masked area: {total_km2:.0f} km^2\n"
+        f"Mean dBZ: {mean_dbz:.2f}  Median dBZ: {median_dbz:.2f}"
+    )
+    # Also produce a Folium overlay for the recolored image
+    sw = (CANADA_BBOX[1], CANADA_BBOX[0])
+    ne = (CANADA_BBOX[3], CANADA_BBOX[2])
+    fmap = make_map_with_overlay(recolored, bounds=(sw, ne), opacity=overlay_opacity)
+    fmap_html = fmap._repr_html_()
+
+    return img, recolored, fmap_html, summary
+
+
+with gr.Blocks(title="Canada Radar Recolor → US NWS") as demo:
+    gr.Markdown("# 🇨🇦→🇺🇸 Radar Recolor (MSC → NWS)")
+    gr.Markdown("Fetch MSC composite, quantize to dBZ, and recolor to NWS scale.")
+    with gr.Row():
+        with gr.Column(scale=1):
+            layer = gr.Dropdown(
+                choices=["RADAR_1KM_RDBR", "RADAR_1KM_RRAI", "RADAR_1KM_RSNO"],
+                value="RADAR_1KM_RDBR",
+                label="WMS Layer",
+            )
+            size_w = gr.Slider(256, 2048, value=1024, step=64, label="Width (px)")
+            size_h = gr.Slider(256, 2048, value=768, step=64, label="Height (px)")
+            min_dbz = gr.Slider(0, 75, value=20.0, step=0.25, label="Min dBZ for components")
+            derive_palette = gr.Checkbox(value=True, label="Derive MSC palette from legend (exact)")
+            overlay_opacity = gr.Slider(0.1, 1.0, value=0.8, step=0.05, label="Overlay opacity")
+            fractional_dbz = gr.Checkbox(value=True, label="Estimate fractional dBZ (xx.xx)")
+            use_gradient_mapping = gr.Checkbox(value=True, label="Use legend gradient mapping (pixel-by-pixel)")
+            grad_min = gr.Number(value=5.0, label="Legend min dBZ")
+            grad_max = gr.Number(value=75.0, label="Legend max dBZ")
+            grad_orientation = gr.Dropdown(["vertical", "horizontal"], value="vertical", label="Legend orientation")
+            grad_low_at_bottom = gr.Checkbox(value=True, label="Low at bottom / left")
+            grad_stride = gr.Slider(1, 10, value=1, step=1, label="Legend sample stride (px)")
+            grad_manual_crop = gr.Checkbox(value=False, label="Manual legend crop (px)")
+            with gr.Row():
+                crop_x0 = gr.Number(value=0, label="crop_x0 (left)")
+                crop_y0 = gr.Number(value=0, label="crop_y0 (top)")
+                crop_x1 = gr.Number(value=0, label="crop_x1 (right)")
+                crop_y1 = gr.Number(value=0, label="crop_y1 (bottom)")
+            btn = gr.Button("Fetch + Recolor", variant="primary")
+
+            summary = gr.Textbox(label="Summary", interactive=False)
+
+        with gr.Column(scale=2):
+            orig = gr.Image(label="Original (MSC)", interactive=False)
+            out = gr.Image(label="Recolored (NWS)", interactive=False)
+            fmap = gr.HTML(label="Folium Map with Recolored Overlay")
+
+    btn.click(
+        fetch_and_recolor,
+        inputs=[
+            size_w,
+            size_h,
+            layer,
+            min_dbz,
+            derive_palette,
+            overlay_opacity,
+            fractional_dbz,
+            use_gradient_mapping,
+            grad_min,
+            grad_max,
+            grad_orientation,
+            grad_low_at_bottom,
+            grad_stride,
+            grad_manual_crop,
+            crop_x0,
+            crop_y0,
+            crop_x1,
+            crop_y1,
+        ],
+        outputs=[orig, out, fmap, summary],
+    )
+
+
+if __name__ == "__main__":
+    import os
+    launch_kwargs = dict(server_name="0.0.0.0", debug=True)
+    # Optional port override
+    port = os.getenv("GRADIO_SERVER_PORT")
+    if port:
+        try:
+            p = int(port)
+            if p > 0:
+                launch_kwargs["server_port"] = p
+        except Exception:
+            pass
+    # Optional share flag
+    share = os.getenv("GRADIO_SHARE", "0").lower() in {"1", "true", "yes"}
+    launch_kwargs["share"] = share
+    demo.launch(**launch_kwargs)

pydardraw.egg-info/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: pydardraw
+Version: 0.1.0
+Summary: Radar image processing: fetch, dBZ quantization, recoloring
+Author: Your Name
+Project-URL: Homepage, https://example.com
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.23
+Requires-Dist: Pillow>=9.0
+Requires-Dist: requests>=2.31
+Requires-Dist: gradio>=4.0
+Requires-Dist: folium>=0.14
+Provides-Extra: opencv
+Requires-Dist: opencv-python>=4.7; extra == "opencv"
+
+PydarDraw: Radar dBZ Quantization and Recoloring
+
+Overview
+- Fetch radar composite imagery from government WMS (e.g., MSC GeoMet).
+- Quantize pixel colors to source-layer dBZ using a configurable color table, with optional fractional dBZ (xx.xx) estimates from anti-aliased pixels.
+- Identify contiguous colored blocks (connected components) per dBZ.
+- Recolor the image into another dBZ color table (e.g., US NWS).
+
+Status
+- Default color tables for US NWS reflectivity and a pragmatic Canadian MSC reflectivity table are included. You may override with your own JSON or derive from a provided legend image.
+- No external services are required to run quantization/recoloring on a local image. Fetching from WMS requires network.
+
+Quick Start
+1) Recolor a local PNG using defaults (fractional dBZ optional):
+   ```python
+   from PIL import Image
+   import numpy as np
+   from pydardraw.processing.convert import image_to_dbz, dbz_to_image
+   from pydardraw.colormaps.canada_msc import CANADA_MSC_REF
+   from pydardraw.colormaps.nws_us import NWS_REF
+
+   img = Image.open("input_radar.png").convert("RGBA")
+   dbz, alpha = image_to_dbz(img, CANADA_MSC_REF, fractional=True)  # set False for discrete
+   recolored = dbz_to_image(dbz, alpha, NWS_REF)
+   recolored.save("recolored_nws.png")
+   ```
+
+2) Connected components and pixel resolution:
+   ```python
+   from pydardraw.processing.components import label_components
+   labels, stats = label_components(dbz, min_dbz=20)
+   # stats contains component sizes in pixels and km^2 if you supply bbox
+   ```
+
+3) Fetch a Canada composite via MSC GeoMet WMS and recolor (exact legend-derived palette):
+   ```python
+   from pydardraw.sources.msc_geomet import fetch_wms_png
+   from pydardraw.sources.msc_colormap import get_msc_reflectivity_colormap
+   from pydardraw.colormaps.nws_us import NWS_REF
+   from pydardraw.processing.convert import image_to_dbz, dbz_to_image
+
+   img = fetch_wms_png(
+       layer="RADAR_1KM_RDBR",
+       bbox=(-141, 41.6751, -52.6194, 83.1139),  # lon_min, lat_min, lon_max, lat_max
+       size=(1024, 768),
+   )
+   src_map = get_msc_reflectivity_colormap("RADAR_1KM_RDBR", derive_from_legend=True)
+   dbz, alpha = image_to_dbz(img, src_map, fractional=True)
+   recolored = dbz_to_image(dbz, alpha, NWS_REF)
+   recolored.save("canada_recolored.png")
+   ```
+
+Color Tables
+- US NWS reflectivity colors follow a commonly used palette for dBZ steps.
+- Canadian MSC reflectivity colors are provided as a practical approximation; you can replace with your authoritative mapping (see `pydardraw/colormaps/canada_msc.py`).
+
+Folium Overlay
+- Create a Folium map with a recolored overlay and the original WMS layer for comparison using `pydardraw.viz.folium_overlay.make_map_with_overlay`.
+
+Notes
+- Transparent pixels are treated as no-data (NaN) in the dBZ array and preserved in alpha.
+- Distance/resolution: Use the known WMS bbox and image size to compute km per pixel with a spherical earth approximation.

pydardraw.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+README.md
+pyproject.toml
+pydardraw/__init__.py
+pydardraw.egg-info/PKG-INFO
+pydardraw.egg-info/SOURCES.txt
+pydardraw.egg-info/dependency_links.txt
+pydardraw.egg-info/not-zip-safe
+pydardraw.egg-info/requires.txt
+pydardraw.egg-info/top_level.txt
+pydardraw/colormaps/base.py
+pydardraw/colormaps/canada_msc.py
+pydardraw/colormaps/derive.py
+pydardraw/colormaps/gradient.py
+pydardraw/colormaps/io.py
+pydardraw/colormaps/nws_us.py
+pydardraw/processing/components.py
+pydardraw/processing/convert.py
+pydardraw/sources/msc_colormap.py
+pydardraw/sources/msc_geomet.py
+pydardraw/viz/folium_overlay.py

pydardraw.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pydardraw.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

pydardraw.egg-info/requires.txt

@@ -0,0 +1,8 @@
+numpy>=1.23
+Pillow>=9.0
+requests>=2.31
+gradio>=4.0
+folium>=0.14
+
+[opencv]
+opencv-python>=4.7

pydardraw.egg-info/top_level.txt

@@ -0,0 +1 @@
+pydardraw

pydardraw/__init__.py

@@ -0,0 +1,8 @@
+__all__ = [
+    "colormaps",
+    "processing",
+    "sources",
+]
+
+__version__ = "0.1.0"
+

pydardraw/colormaps/base.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Tuple
+
+import numpy as np
+
+try:
+    import cv2  # type: ignore
+except Exception:  # pragma: no cover - cv2 optional for LAB distances
+    cv2 = None
+
+
+RGB = Tuple[int, int, int]
+
+
+@dataclass(frozen=True)
+class ColorStop:
+    value: float  # typically dBZ
+    color: RGB    # (R, G, B)
+
+
+class ColorMap:
+    def __init__(self, stops: List[ColorStop], name: str = "") -> None:
+        # Ensure sorted by value
+        self._stops = sorted(stops, key=lambda s: s.value)
+        self.name = name or ""
+
+        self._values = np.array([s.value for s in self._stops], dtype=np.float32)
+        self._rgb = np.array([s.color for s in self._stops], dtype=np.uint8)
+        # Precompute LAB if possible for better perceptual distances
+        if cv2 is not None:
+            rgb_reshaped = self._rgb.reshape((-1, 1, 3))
+            self._lab = cv2.cvtColor(rgb_reshaped, cv2.COLOR_RGB2LAB).reshape((-1, 3)).astype(np.float32)
+        else:
+            self._lab = None
+
+    @property
+    def values(self) -> np.ndarray:
+        return self._values
+
+    @property
+    def rgb(self) -> np.ndarray:
+        return self._rgb
+
+    def nearest_value_for_color(self, color: RGB) -> float:
+        """Return the dBZ (value) for the nearest palette color.
+
+        Uses CIE-LAB space if OpenCV available, otherwise RGB distance.
+        """
+        c = np.array(color, dtype=np.uint8).reshape((1, 1, 3))
+        if self._lab is not None and cv2 is not None:
+            c_lab = cv2.cvtColor(c, cv2.COLOR_RGB2LAB).reshape((1, 3)).astype(np.float32)
+            dists = np.linalg.norm(self._lab - c_lab, axis=1)
+        else:
+            c_rgb = c.reshape((1, 3)).astype(np.float32)
+            dists = np.linalg.norm(self._rgb.astype(np.float32) - c_rgb, axis=1)
+        idx = int(np.argmin(dists))
+        return float(self._values[idx])
+
+    def color_for_value(self, value: float) -> RGB:
+        """Return RGB for the nearest value stop."""
+        idx = int(np.argmin(np.abs(self._values - value)))
+        return tuple(int(x) for x in self._rgb[idx])  # type: ignore[return-value]
+
+    def fractional_value_for_color(self, color: RGB) -> float:
+        """Estimate a fractional value (e.g., dBZ with decimals) by projecting
+        the color onto the nearest adjacent stop pair in LAB (preferred) or RGB.
+
+        If the color matches a stop exactly, returns the exact stop value.
+        """
+        c = np.array(color, dtype=np.uint8).reshape((1, 1, 3))
+        if self._lab is not None and cv2 is not None:
+            c_lab = cv2.cvtColor(c, cv2.COLOR_RGB2LAB).reshape((3,)).astype(np.float32)
+            palette = self._lab
+        else:
+            c_lab = c.reshape((3,)).astype(np.float32)
+            palette = self._rgb.astype(np.float32)
+
+        # Exact match fast-path
+        if self._lab is not None and cv2 is not None:
+            dists = np.linalg.norm(palette - c_lab, axis=1)
+        else:
+            dists = np.linalg.norm(palette - c_lab, axis=1)
+        idx = int(np.argmin(dists))
+        if dists[idx] < 1e-3:
+            return float(self._values[idx])
+
+        # Choose adjacent neighbor to the nearest index
+        if idx == 0:
+            i, j = 0, 1
+        elif idx == len(self._values) - 1:
+            i, j = idx - 1, idx
+        else:
+            # Compare neighbors around idx
+            left = idx - 1
+            right = idx + 1
+            # Pick the adjacent whose projection distance is shortest
+            def proj_params(a, b):
+                va = palette[a]
+                vb = palette[b]
+                v = vb - va
+                t = float(np.dot(c_lab - va, v) / (np.dot(v, v) + 1e-12))
+                t = max(0.0, min(1.0, t))
+                p = va + t * v
+                err = float(np.linalg.norm(c_lab - p))
+                return t, err
+
+            t_l, err_l = proj_params(left, idx)
+            t_r, err_r = proj_params(idx, right)
+            if err_l <= err_r:
+                i, j, t = left, idx, t_l
+            else:
+                i, j, t = idx, right, t_r
+            return float(self._values[i] + t * (self._values[j] - self._values[i]))
+
+        # Fallback for edges using i, j chosen above
+        va = palette[i]
+        vb = palette[j]
+        v = vb - va
+        t = float(np.dot(c_lab - va, v) / (np.dot(v, v) + 1e-12))
+        t = max(0.0, min(1.0, t))
+        return float(self._values[i] + t * (self._values[j] - self._values[i]))

pydardraw/colormaps/canada_msc.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from .base import ColorMap, ColorStop
+
+
+# Pragmatic approximation of Canadian MSC composite base reflectivity palette.
+# Replace with authoritative mapping if available.
+_MSC_STOPS = [
+    ColorStop(5,  (0xB3, 0xFF, 0xFF)),  # very light cyan
+    ColorStop(10, (0x80, 0xCC, 0xFF)),  # light blue
+    ColorStop(15, (0x33, 0x99, 0xFF)),  # blue
+    ColorStop(20, (0x33, 0xFF, 0x33)),  # green
+    ColorStop(25, (0x00, 0xCC, 0x00)),  # dark green
+    ColorStop(30, (0x00, 0x99, 0x00)),  # darker green
+    ColorStop(35, (0xFF, 0xFF, 0x00)),  # yellow
+    ColorStop(40, (0xFF, 0xCC, 0x00)),  # amber
+    ColorStop(45, (0xFF, 0x99, 0x00)),  # orange
+    ColorStop(50, (0xFF, 0x00, 0x00)),  # red
+    ColorStop(55, (0xCC, 0x00, 0x00)),  # dark red
+    ColorStop(60, (0x99, 0x00, 0x00)),  # maroon
+    ColorStop(65, (0xFF, 0x00, 0xFF)),  # magenta
+    ColorStop(70, (0x66, 0x00, 0xCC)),  # purple
+    ColorStop(75, (0xFF, 0xFF, 0xFF)),  # white
+]
+
+CANADA_MSC_REF = ColorMap(_MSC_STOPS, name="MSC Composite Reflectivity (dBZ)")
+

pydardraw/colormaps/derive.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable, List, Tuple
+
+import numpy as np
+from PIL import Image
+
+try:
+    import cv2  # type: ignore
+except Exception:  # pragma: no cover - optional
+    cv2 = None
+
+from .base import ColorMap, ColorStop
+
+
+@dataclass
+class LegendDeriveConfig:
+    values: List[float]
+    low_at_bottom: bool = True
+    kmeans_attempts: int = 3
+    text_suppress_gray_thresh: int = 24  # exclude near-gray text if desired
+
+
+def derive_colormap_from_legend(img: Image.Image, cfg: LegendDeriveConfig) -> ColorMap:
+    """Derive a ColorMap from a legend image and provided dBZ values.
+
+    Assumes legend consists of K colored swatches (K=len(values)) arranged vertically,
+    optionally with text labels that are gray-ish and excluded by simple thresholding.
+    """
+    if cv2 is None:
+        raise RuntimeError("OpenCV is required for legend derivation (k-means).")
+
+    if img.mode != "RGBA":
+        img = img.convert("RGBA")
+    arr = np.asarray(img, dtype=np.uint8)
+    h, w, _ = arr.shape
+    rgb = arr[:, :, :3]
+    alpha = arr[:, :, 3]
+
+    # Focus on non-transparent pixels
+    mask = alpha > 0
+    data = rgb[mask].reshape(-1, 3).astype(np.float32)
+    if data.size == 0:
+        raise ValueError("Legend image appears empty.")
+
+    # Suppress gray pixels (likely text/lines) by removing low chroma pixels
+    lab = cv2.cvtColor(data.reshape(-1, 1, 3).astype(np.uint8), cv2.COLOR_RGB2LAB).reshape(-1, 3)
+    chroma = np.linalg.norm(lab[:, 1:], axis=1)
+    keep = chroma > cfg.text_suppress_gray_thresh
+    data = data[keep]
+
+    K = len(cfg.values)
+    if data.shape[0] < K:
+        raise ValueError("Not enough legend pixels for k-means clustering.")
+
+    # KMeans clustering to find swatch colors
+    criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 0.5)
+    _compactness, labels, centers = cv2.kmeans(
+        data,
+        K,
+        None,
+        criteria,
+        cfg.kmeans_attempts,
+        cv2.KMEANS_PP_CENTERS,
+    )
+    centers = centers.astype(np.uint8)
+
+    # Map cluster centers back to approximate y-position by matching center colors
+    # to pixels in the original mask and averaging their y.
+    # Build a simple nearest-color LUT for masked pixels
+    masked_coords = np.column_stack(np.nonzero(mask))  # (y, x)
+    masked_rgb = rgb[mask].reshape(-1, 3)
+
+    # Assign each pixel to nearest center
+    d2 = ((masked_rgb[:, None, :].astype(np.int32) - centers[None, :, :].astype(np.int32)) ** 2).sum(axis=2)
+    nearest = d2.argmin(axis=1)
+
+    avg_y = []
+    for k in range(K):
+        ys = masked_coords[nearest == k, 0]
+        if ys.size == 0:
+            avg_y.append(float('inf'))
+        else:
+            avg_y.append(float(ys.mean()))
+
+    # Order clusters by vertical position
+    order = np.argsort(avg_y)
+    if not cfg.low_at_bottom:
+        order = order[::-1]
+
+    ordered_centers = centers[order]
+    ordered_values = list(sorted(cfg.values))
+    stops = [ColorStop(val, tuple(map(int, c))) for val, c in zip(ordered_values, ordered_centers)]
+    return ColorMap(stops, name="Derived Legend")
+

pydardraw/colormaps/gradient.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable, Optional, Tuple
+
+import numpy as np
+from PIL import Image
+
+try:
+    import cv2  # type: ignore
+except Exception:  # pragma: no cover - optional
+    cv2 = None
+
+
+RGB = Tuple[int, int, int]
+
+
+@dataclass
+class GradientConfig:
+    orientation: str = "vertical"  # or "horizontal"
+    low_at_bottom: bool = True
+    sample_stride: int = 1  # sample every N rows/cols along the bar
+    saturation_thresh: int = 25  # HSV S threshold to ignore grayscale text
+    min_value: float = 5.0
+    max_value: float = 75.0
+
+
+class ColorGradientMap:
+    """Dense color→value mapping sampled from a legend gradient.
+
+    Provides fractional_value_for_color by k-NN interpolation in LAB (preferred) or RGB.
+    """
+
+    def __init__(self, colors_rgb: np.ndarray, values: np.ndarray, name: str = "LegendGradient") -> None:
+        assert colors_rgb.ndim == 2 and colors_rgb.shape[1] == 3
+        assert values.ndim == 1 and colors_rgb.shape[0] == values.shape[0]
+        self.name = name
+        self._rgb = colors_rgb.astype(np.uint8)
+        self._values = values.astype(np.float32)
+        if cv2 is not None:
+            self._lab = cv2.cvtColor(self._rgb.reshape(-1, 1, 3), cv2.COLOR_RGB2LAB).reshape(-1, 3).astype(np.float32)
+        else:
+            self._lab = None
+
+    def fractional_value_for_color(self, color: RGB, k: int = 3) -> float:
+        c = np.array(color, dtype=np.uint8).reshape(1, 1, 3)
+        if self._lab is not None and cv2 is not None:
+            c_lab = cv2.cvtColor(c, cv2.COLOR_RGB2LAB).reshape(1, 3).astype(np.float32)
+            d = np.linalg.norm(self._lab - c_lab, axis=1)
+        else:
+            c_rgb = c.reshape(1, 3).astype(np.float32)
+            d = np.linalg.norm(self._rgb.astype(np.float32) - c_rgb, axis=1)
+        # Exact match short-circuit
+        idx = int(np.argmin(d))
+        if float(d[idx]) < 1e-6:
+            return float(self._values[idx])
+        k = int(max(1, min(k, self._values.shape[0])))
+        nn = np.argpartition(d, kth=k - 1)[:k]
+        sel_d = d[nn]
+        sel_v = self._values[nn]
+        # Inverse-distance weighting
+        w = 1.0 / (sel_d.astype(np.float32) + 1e-6)
+        w /= w.sum()
+        return float((w * sel_v).sum())
+
+    @staticmethod
+    def _auto_detect_bar_mask(arr_rgba: np.ndarray, cfg: GradientConfig) -> np.ndarray:
+        # Heuristic: choose pixels with alpha>0 and saturation above threshold
+        alpha = arr_rgba[:, :, 3]
+        rgb = arr_rgba[:, :, :3]
+        if cv2 is not None:
+            hsv = cv2.cvtColor(rgb, cv2.COLOR_RGB2HSV)
+            sat = hsv[:, :, 1]
+        else:
+            # Simple saturation proxy: max-min across RGB channels
+            sat = rgb.max(axis=2) - rgb.min(axis=2)
+        mask = (alpha > 0) & (sat >= cfg.saturation_thresh)
+        return mask
+
+    @staticmethod
+    def _largest_component_bbox(mask: np.ndarray) -> Optional[Tuple[int, int, int, int]]:
+        if cv2 is None:
+            ys, xs = np.nonzero(mask)
+            if ys.size == 0:
+                return None
+            return int(xs.min()), int(ys.min()), int(xs.max()), int(ys.max())
+        num, labels = cv2.connectedComponents(mask.astype(np.uint8))
+        if num <= 1:
+            return None
+        best_area = 0
+        best_bbox = None
+        for lab in range(1, num):
+            ys, xs = np.where(labels == lab)
+            if ys.size == 0:
+                continue
+            x0, y0, x1, y1 = xs.min(), ys.min(), xs.max(), ys.max()
+            area = (x1 - x0 + 1) * (y1 - y0 + 1)
+            if area > best_area:
+                best_area = area
+                best_bbox = (x0, y0, x1, y1)
+        return best_bbox
+
+    @classmethod
+    def from_legend_image(
+        cls,
+        img: Image.Image,
+        cfg: GradientConfig,
+        manual_bbox: Optional[Tuple[int, int, int, int]] = None,
+    ) -> "ColorGradientMap":
+        if img.mode != "RGBA":
+            img = img.convert("RGBA")
+        arr = np.asarray(img, dtype=np.uint8)
+        h, w, _ = arr.shape
+        if manual_bbox is not None:
+            x0, y0, x1, y1 = manual_bbox
+            # clamp
+            x0 = max(0, min(x0, w - 1))
+            x1 = max(0, min(x1, w - 1))
+            y0 = max(0, min(y0, h - 1))
+            y1 = max(0, min(y1, h - 1))
+            if x0 > x1:
+                x0, x1 = x1, x0
+            if y0 > y1:
+                y0, y1 = y1, y0
+        else:
+            mask = cls._auto_detect_bar_mask(arr, cfg)
+            bbox = cls._largest_component_bbox(mask)
+            if bbox is None:
+                # Fallback: rightmost quarter for vertical, bottom quarter for horizontal
+                if cfg.orientation == "vertical":
+                    x0 = int(0.7 * w)
+                    x1 = w - 1
+                    y0, y1 = 0, h - 1
+                else:
+                    y0 = int(0.7 * h)
+                    y1 = h - 1
+                    x0, x1 = 0, w - 1
+            else:
+                x0, y0, x1, y1 = bbox
+        # x0,y0,x1,y1 are now defined
+
+        rgb = arr[:, :, :3]
+        colors: list[RGB] = []
+        values: list[float] = []
+
+        if cfg.orientation == "vertical":
+            xs = slice(x0, x1 + 1)
+            for y in range(y0, y1 + 1, max(1, cfg.sample_stride)):
+                row = rgb[y, xs, :]
+                # Robust color for the row: median across width
+                med = np.median(row, axis=0).astype(np.uint8)
+                frac = (y - y0) / max(1, (y1 - y0))
+                if cfg.low_at_bottom:
+                    val = cfg.max_value - frac * (cfg.max_value - cfg.min_value)
+                else:
+                    val = cfg.min_value + frac * (cfg.max_value - cfg.min_value)
+                colors.append((int(med[0]), int(med[1]), int(med[2])))
+                values.append(float(val))
+        else:
+            ys = slice(y0, y1 + 1)
+            for x in range(x0, x1 + 1, max(1, cfg.sample_stride)):
+                col = rgb[ys, x, :]
+                med = np.median(col, axis=0).astype(np.uint8)
+                frac = (x - x0) / max(1, (x1 - x0))
+                if cfg.low_at_bottom:
+                    val = cfg.min_value + frac * (cfg.max_value - cfg.min_value)
+                else:
+                    val = cfg.max_value - frac * (cfg.max_value - cfg.min_value)
+                colors.append((int(med[0]), int(med[1]), int(med[2])))
+                values.append(float(val))
+
+        # Deduplicate colors to keep mapping tight
+        arr_colors = np.array(colors, dtype=np.uint8)
+        arr_values = np.array(values, dtype=np.float32)
+        uniq, idx = np.unique(arr_colors, axis=0, return_index=True)
+        uniq_values = arr_values[idx]
+        return cls(uniq, uniq_values, name="LegendGradient")

pydardraw/colormaps/io.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Iterable, List, Tuple
+
+from .base import ColorMap, ColorStop
+
+
+def _parse_hex_rgb(hex_str: str) -> Tuple[int, int, int]:
+    s = hex_str.strip().lstrip('#')
+    if len(s) == 6:
+        r = int(s[0:2], 16)
+        g = int(s[2:4], 16)
+        b = int(s[4:6], 16)
+        return (r, g, b)
+    raise ValueError(f"Invalid hex RGB: {hex_str}")
+
+
+def load_colormap_from_json(path: Path | str, name: str | None = None) -> ColorMap:
+    """Load a colormap JSON of the form [{"value": 5, "color": "#RRGGBB"}, ...]."""
+    p = Path(path)
+    data = json.loads(p.read_text())
+    stops: List[ColorStop] = []
+    for item in data:
+        val = float(item["value"])  # type: ignore[index]
+        col = item["color"]  # type: ignore[index]
+        stops.append(ColorStop(val, _parse_hex_rgb(str(col))))
+    return ColorMap(stops, name=name or p.stem)
+

pydardraw/colormaps/nws_us.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from .base import ColorMap, ColorStop
+
+
+# A commonly used US NWS reflectivity color table (approximate hex -> RGB)
+# Steps at 5 dBZ from 5 to 75. You may customize as needed.
+_NWS_STOPS = [
+    ColorStop(5,  (0x04, 0xE9, 0xE7)),  # cyan
+    ColorStop(10, (0x01, 0x9F, 0xF4)),  # blue
+    ColorStop(15, (0x03, 0x00, 0xF4)),  # deep blue
+    ColorStop(20, (0x02, 0xFD, 0x02)),  # green
+    ColorStop(25, (0x01, 0xC5, 0x01)),  # dark green
+    ColorStop(30, (0x00, 0x8E, 0x00)),  # darker green
+    ColorStop(35, (0xFD, 0xF8, 0x02)),  # yellow
+    ColorStop(40, (0xE5, 0xBC, 0x00)),  # mustard
+    ColorStop(45, (0xFD, 0x95, 0x00)),  # orange
+    ColorStop(50, (0xFD, 0x00, 0x00)),  # red
+    ColorStop(55, (0xD4, 0x00, 0x00)),  # dark red
+    ColorStop(60, (0xBC, 0x00, 0x00)),  # darker red
+    ColorStop(65, (0xF8, 0x00, 0xFD)),  # magenta
+    ColorStop(70, (0x98, 0x54, 0xC6)),  # purple
+    ColorStop(75, (0xFD, 0xFD, 0xFD)),  # white
+]
+
+NWS_REF = ColorMap(_NWS_STOPS, name="NWS Reflectivity (dBZ)")
+

pydardraw/processing/components.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Optional, Tuple
+
+import numpy as np
+
+try:
+    import cv2  # type: ignore
+except Exception:  # pragma: no cover - optional
+    cv2 = None
+
+
+EARTH_RADIUS_KM = 6371.0088
+
+
+def _haversine_km(lat1, lon1, lat2, lon2) -> float:
+    import math
+
+    phi1, phi2 = math.radians(lat1), math.radians(lat2)
+    dphi = phi2 - phi1
+    dlambda = math.radians(lon2 - lon1)
+    a = math.sin(dphi / 2) ** 2 + math.cos(phi1) * math.cos(phi2) * math.sin(dlambda / 2) ** 2
+    return 2 * EARTH_RADIUS_KM * math.asin(math.sqrt(a))
+
+
+@dataclass
+class PixelResolution:
+    km_per_px_x: float
+    km_per_px_y: float
+
+
+def estimate_pixel_resolution(
+    bbox: Tuple[float, float, float, float],
+    size: Tuple[int, int],
+) -> PixelResolution:
+    """Approximate km per pixel using bbox=(lon_min, lat_min, lon_max, lat_max) and image size=(w,h)."""
+    lon_min, lat_min, lon_max, lat_max = bbox
+    w, h = size
+    # Horizontal distance along center latitude
+    lat_c = (lat_min + lat_max) / 2.0
+    km_x = _haversine_km(lat_c, lon_min, lat_c, lon_max)
+    km_y = _haversine_km(lat_min, lon_min, lat_max, lon_min)
+    return PixelResolution(km_per_px_x=km_x / max(1, w), km_per_px_y=km_y / max(1, h))
+
+
+def label_components(dbz: np.ndarray, min_dbz: Optional[float] = None) -> Tuple[np.ndarray, Dict[int, Dict[str, float]]]:
+    """Label connected components of non-NaN (and optionally >= min_dbz) pixels.
+
+    Returns (labels, stats) where labels is an int32 array with 0 as background,
+    and stats is {label: {"pixel_count": int}}.
+    """
+    mask = ~np.isnan(dbz)
+    if min_dbz is not None:
+        mask &= dbz >= float(min_dbz)
+
+    if cv2 is None:
+        # Fallback: 4-neighbor connected components via scipy-like approach (slow)
+        # Simple two-pass algorithm
+        h, w = dbz.shape
+        labels = np.zeros((h, w), dtype=np.int32)
+        current = 0
+        label_equiv = {}
+        for y in range(h):
+            for x in range(w):
+                if not mask[y, x]:
+                    continue
+                neighbors = []
+                if x > 0 and labels[y, x - 1] > 0:
+                    neighbors.append(labels[y, x - 1])
+                if y > 0 and labels[y - 1, x] > 0:
+                    neighbors.append(labels[y - 1, x])
+                if not neighbors:
+                    current += 1
+                    labels[y, x] = current
+                else:
+                    m = min(neighbors)
+                    labels[y, x] = m
+                    for n in neighbors:
+                        if n != m:
+                            label_equiv[n] = m
+        # Resolve equivalences
+        for y in range(h):
+            for x in range(w):
+                l = labels[y, x]
+                while l in label_equiv:
+                    l = label_equiv[l]
+                labels[y, x] = l
+    else:
+        mask_u8 = (mask.astype(np.uint8) * 255)
+        num, labels = cv2.connectedComponents(mask_u8, connectivity=4)
+        # OpenCV labels background = 0, components 1..num-1
+        # Already good.
+
+    # Stats
+    stats: Dict[int, Dict[str, float]] = {}
+    unique, counts = np.unique(labels[labels > 0], return_counts=True)
+    for lab, cnt in zip(unique.tolist(), counts.tolist()):
+        stats[int(lab)] = {"pixel_count": float(cnt)}
+    return labels, stats
+
+
+def component_areas_km2(
+    labels: np.ndarray,
+    resolution: PixelResolution,
+) -> Dict[int, float]:
+    """Compute area in km^2 for each labeled component."""
+    areas: Dict[int, float] = {}
+    unique, counts = np.unique(labels[labels > 0], return_counts=True)
+    px_area = resolution.km_per_px_x * resolution.km_per_px_y
+    for lab, cnt in zip(unique.tolist(), counts.tolist()):
+        areas[int(lab)] = cnt * px_area
+    return areas
+

pydardraw/processing/convert.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from typing import Tuple
+
+import numpy as np
+from PIL import Image
+
+from ..colormaps.base import ColorMap
+
+
+def _to_numpy_rgba(img: Image.Image) -> Tuple[np.ndarray, np.ndarray]:
+    if img.mode != "RGBA":
+        img = img.convert("RGBA")
+    arr = np.asarray(img, dtype=np.uint8)
+    rgb = arr[:, :, :3]
+    alpha = arr[:, :, 3]
+    return rgb, alpha
+
+
+def _unique_color_map(values_rgb: np.ndarray, func) -> dict:
+    """Map unique RGB colors to numeric values using the provided func(color)->float."""
+    lut: dict[tuple, float] = {}
+    for rgb in values_rgb:
+        key = (int(rgb[0]), int(rgb[1]), int(rgb[2]))
+        if key not in lut:
+            lut[key] = float(func(key))
+    return lut
+
+
+def _apply_lut_to_pixels(rgb: np.ndarray, alpha: np.ndarray, lut: dict) -> np.ndarray:
+    h, w, _ = rgb.shape
+    out = np.full((h, w), np.nan, dtype=np.float32)
+    flat_rgb = rgb.reshape(-1, 3)
+    flat_alpha = alpha.reshape(-1)
+    flat_out = out.reshape(-1)
+    for i in range(flat_rgb.shape[0]):
+        if flat_alpha[i] == 0:
+            continue
+        key = (int(flat_rgb[i, 0]), int(flat_rgb[i, 1]), int(flat_rgb[i, 2]))
+        val = lut.get(key)
+        if val is not None:
+            flat_out[i] = float(val)
+    return out
+
+
+def image_to_dbz(
+    img: Image.Image,
+    src_map: ColorMap,
+    fractional: bool = False,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Convert a colored radar image to a dBZ array using a source ColorMap.
+
+    - If fractional is False, snaps to nearest stop value exactly.
+    - If fractional is True, estimates a decimal value via LAB/RGB projection.
+
+    Returns (dbz_array, alpha_mask). Transparent pixels are NaN in dBZ.
+    """
+    rgb, alpha = _to_numpy_rgba(img)
+    # Collect unique RGB colors present (non-transparent)
+    mask = alpha > 0
+    unique_rgb = np.unique(rgb[mask].reshape(-1, 3), axis=0) if np.any(mask) else np.zeros((0, 3), dtype=np.uint8)
+
+    # Build LUT
+    if fractional:
+        lut = _unique_color_map(unique_rgb, src_map.fractional_value_for_color)
+    else:
+        lut = _unique_color_map(unique_rgb, src_map.nearest_value_for_color)
+
+    # Apply LUT
+    dbz = _apply_lut_to_pixels(rgb, alpha, lut)
+    return dbz, alpha
+
+
+def dbz_to_image(dbz: np.ndarray, alpha: np.ndarray, dst_map: ColorMap) -> Image.Image:
+    """Render a dBZ array (and alpha mask) into a colored RGBA image using dst_map."""
+    h, w = dbz.shape
+    rgb = np.zeros((h, w, 3), dtype=np.uint8)
+
+    # Map NaN to transparent
+    valid = ~np.isnan(dbz)
+    if np.any(valid):
+        # Vectorized nearest value mapping via LUT
+        vals = dbz[valid]
+        # Quantize to nearest stops
+        stops = dst_map.values
+        idx = np.abs(vals.reshape(-1, 1) - stops.reshape(1, -1)).argmin(axis=1)
+        colors = dst_map.rgb[idx]
+        rgb[valid] = colors
+
+    rgba = np.dstack([rgb, alpha.astype(np.uint8)])
+    return Image.fromarray(rgba, mode="RGBA")

pydardraw/sources/msc_colormap.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import Optional, List
+
+from PIL import Image
+
+from ..colormaps.base import ColorMap
+from ..colormaps.derive import LegendDeriveConfig, derive_colormap_from_legend
+from ..colormaps.canada_msc import CANADA_MSC_REF
+from ..colormaps.gradient import ColorGradientMap, GradientConfig
+from .msc_geomet import fetch_legend_png
+
+
+def get_msc_reflectivity_colormap(
+    layer: str = "RADAR_1KM_RDBR",
+    derive_from_legend: bool = True,
+    assumed_values: Optional[List[float]] = None,
+) -> ColorMap:
+    """Return a ColorMap for MSC reflectivity layers.
+
+    If derive_from_legend is True, fetches GetLegendGraphic and derives palette colors.
+    If no explicit values provided, assumes 5 dBZ steps [5..75] for K swatches.
+    Falls back to a built-in approximation if derivation fails.
+    """
+    if not derive_from_legend:
+        return CANADA_MSC_REF
+
+    try:
+        legend: Image.Image = fetch_legend_png(layer)
+        # If values are not supplied, guess K from legend clusters and use 5 dBZ steps
+        if assumed_values is None:
+            # Probe K by running k-means on legend and trying a few candidates.
+            # We do a two-pass: first use a typical K=15 (5..75), else try 14 or 16.
+            for K in (15, 14, 16):
+                vals = [5 + 5 * i for i in range(K)]
+                try:
+                    cmap = derive_colormap_from_legend(legend, LegendDeriveConfig(values=vals))
+                    return cmap
+                except Exception:
+                    continue
+            # Final attempt with built-in fallback
+            return CANADA_MSC_REF
+        else:
+            cmap = derive_colormap_from_legend(legend, LegendDeriveConfig(values=assumed_values))
+            return cmap
+    except Exception:
+        return CANADA_MSC_REF
+
+
+def get_msc_reflectivity_gradient_map(
+    layer: str = "RADAR_1KM_RDBR",
+    min_dbz: float = 5.0,
+    max_dbz: float = 75.0,
+    orientation: str = "vertical",
+    low_at_bottom: bool = True,
+    sample_stride: int = 1,
+    manual_bbox: Optional[tuple[int, int, int, int]] = None,
+) -> ColorGradientMap:
+    """Fetch the legend and build a dense pixel-by-pixel color→dBZ map.
+
+    This enables highly accurate fractional dBZ estimation by nearest colors.
+    """
+    legend: Image.Image = fetch_legend_png(layer)
+    cfg = GradientConfig(
+        orientation=orientation,
+        low_at_bottom=low_at_bottom,
+        sample_stride=sample_stride,
+        min_value=min_dbz,
+        max_value=max_dbz,
+    )
+    return ColorGradientMap.from_legend_image(legend, cfg, manual_bbox=manual_bbox)

pydardraw/sources/msc_geomet.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from io import BytesIO
+from typing import Optional, Tuple
+
+import requests
+from PIL import Image
+
+
+WMS_URL = "https://geo.weather.gc.ca/geomet"
+
+
+def fetch_wms_png(
+    layer: str,
+    bbox: Tuple[float, float, float, float],  # (lon_min, lat_min, lon_max, lat_max) in EPSG:4326
+    size: Tuple[int, int],  # (width, height)
+    time: Optional[str] = None,  # ISO8601 or latest if None
+    transparent: bool = True,
+    fmt: str = "image/png",
+    wms_url: str = WMS_URL,
+) -> Image.Image:
+    """Fetch a single WMS GetMap image for the given bbox and size.
+
+    Note: Network must be available. Returns a Pillow Image in RGBA if PNG.
+    """
+    params = {
+        "service": "WMS",
+        "request": "GetMap",
+        "version": "1.3.0",
+        "layers": layer,
+        "styles": "",
+        "format": fmt,
+        "transparent": str(transparent).lower(),
+        "crs": "EPSG:4326",
+        "bbox": f"{bbox[1]},{bbox[0]},{bbox[3]},{bbox[2]}",  # lat_min,lon_min,lat_max,lon_max for 1.3.0 EPSG:4326
+        "width": str(size[0]),
+        "height": str(size[1]),
+    }
+    if time:
+        params["time"] = time
+    r = requests.get(wms_url, params=params, timeout=30)
+    r.raise_for_status()
+    img = Image.open(BytesIO(r.content))
+    if img.mode != "RGBA":
+        img = img.convert("RGBA")
+    return img
+
+
+def fetch_legend_png(
+    layer: str,
+    wms_url: str = WMS_URL,
+    scale: int = 1,
+) -> Image.Image:
+    """Fetch WMS GetLegendGraphic image if available (for custom color-table derivation)."""
+    params = {
+        "service": "WMS",
+        "request": "GetLegendGraphic",
+        "version": "1.3.0",
+        "layer": layer,
+        "format": "image/png",
+        "scale": str(scale),
+    }
+    r = requests.get(wms_url, params=params, timeout=30)
+    r.raise_for_status()
+    img = Image.open(BytesIO(r.content))
+    if img.mode != "RGBA":
+        img = img.convert("RGBA")
+    return img
+

pydardraw/viz/folium_overlay.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import base64
+from io import BytesIO
+from typing import Tuple
+
+import folium
+from PIL import Image
+from folium.raster_layers import WmsTileLayer
+
+
+def image_to_data_url(img: Image.Image, fmt: str = "PNG") -> str:
+    buf = BytesIO()
+    img.save(buf, format=fmt)
+    b64 = base64.b64encode(buf.getvalue()).decode("ascii")
+    return f"data:image/{fmt.lower()};base64,{b64}"
+
+
+def make_map_with_overlay(
+    overlay: Image.Image,
+    bounds: Tuple[Tuple[float, float], Tuple[float, float]],  # (southwest(lat,lon), northeast(lat,lon))
+    opacity: float = 0.8,
+    center: Tuple[float, float] | None = None,
+    zoom_start: int = 4,
+    add_raw_wms: bool = True,
+    wms_url: str = "https://geo.weather.gc.ca/geomet",
+    wms_layer: str = "RADAR_1KM_RDBR",
+) -> folium.Map:
+    """Return a Folium map with the given image overlay and bounds."""
+    if center is None:
+        lat = (bounds[0][0] + bounds[1][0]) / 2.0
+        lon = (bounds[0][1] + bounds[1][1]) / 2.0
+        center = (lat, lon)
+
+    m = folium.Map(location=center, zoom_start=zoom_start, tiles="OpenStreetMap")
+    data_url = image_to_data_url(overlay)
+    folium.raster_layers.ImageOverlay(
+        image=data_url,
+        bounds=[bounds[0], bounds[1]],
+        opacity=opacity,
+        name="Recolored (NWS)",
+        interactive=False,
+        cross_origin=False,
+    ).add_to(m)
+    if add_raw_wms:
+        # Add the original MSC WMS layer for comparison
+        WmsTileLayer(
+            url=wms_url,
+            layers=wms_layer,
+            version="1.3.0",
+            transparent=True,
+            format="image/png",
+            name="Raw MSC WMS",
+            overlay=True,
+            control=True,
+            opacity=opacity,
+            attr='<a href="https://eccc-msc.github.io/open-data/licence/readme_en/">ECCC</a>',
+        ).add_to(m)
+    folium.LayerControl().add_to(m)
+    return m

pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pydardraw"
+version = "0.1.0"
+description = "Radar image processing: fetch, dBZ quantization, recoloring"
+authors = [{ name = "Your Name" }]
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "numpy>=1.23",
+    "Pillow>=9.0",
+    "requests>=2.31",
+    "gradio>=4.0",
+    "folium>=0.14",
+]
+
+[project.optional-dependencies]
+opencv = [
+    "opencv-python>=4.7",
+]
+
+[project.urls]
+Homepage = "https://example.com"
+
+[tool.setuptools]
+zip-safe = false
+
+[tool.setuptools.packages.find]
+include = ["pydardraw*"]
+exclude = ["apps*", "scripts*"]

requirements.txt

@@ -0,0 +1,9 @@
+gradio>=4.0
+numpy>=1.23
+Pillow>=9.0
+requests>=2.31
+folium>=0.14
+
+# Optional (perceptual color distances). Commented to keep build light.
+# opencv-python>=4.7
+

runtime.txt

@@ -0,0 +1 @@
+python-3.10

scripts/recolor_cli.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+import argparse
+from pathlib import Path
+
+from PIL import Image
+
+from pydardraw.colormaps.io import load_colormap_from_json
+from pydardraw.colormaps.canada_msc import CANADA_MSC_REF
+from pydardraw.colormaps.nws_us import NWS_REF
+from pydardraw.processing.convert import image_to_dbz, dbz_to_image
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Recolor a radar image to a target dBZ colormap")
+    ap.add_argument("input", type=Path, help="Input image (PNG)")
+    ap.add_argument("output", type=Path, help="Output image (PNG)")
+    ap.add_argument("--src-colormap", type=Path, help="JSON colormap for source (value, #RRGGBB)")
+    ap.add_argument("--dst-colormap", type=Path, help="JSON colormap for destination (value, #RRGGBB)")
+    ap.add_argument("--fractional", action="store_true", help="Estimate fractional dBZ (xx.xx) using LAB projection")
+    args = ap.parse_args()
+
+    src_map = load_colormap_from_json(args.src_colormap) if args.src_colormap else CANADA_MSC_REF
+    dst_map = load_colormap_from_json(args.dst_colormap) if args.dst_colormap else NWS_REF
+
+    img = Image.open(args.input).convert("RGBA")
+    dbz, alpha = image_to_dbz(img, src_map, fractional=args.fractional)
+    out = dbz_to_image(dbz, alpha, dst_map)
+    out.save(args.output)
+    print(f"Saved: {args.output}")
+
+
+if __name__ == "__main__":
+    main()

scripts/run_demo.sh

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Run the Canada → US NWS recolor Gradio demo with minimal fuss.
+#
+# Usage:
+#   bash scripts/run_demo.sh [--share] [--port <PORT|auto>] [--opencv]
+#
+# Examples:
+#   bash scripts/run_demo.sh --port 7861
+#   bash scripts/run_demo.sh --share --port 7861
+#   bash scripts/run_demo.sh --opencv --port auto
+
+PORT="7861"
+SHARE="0"
+WITH_OPENCV="0"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --share)
+      SHARE="1"; shift ;;
+    --opencv)
+      WITH_OPENCV="1"; shift ;;
+    --port)
+      PORT="${2:-7861}"; shift 2 ;;
+    -h|--help)
+      echo "Usage: $0 [--share] [--port <PORT|auto>] [--opencv]"; exit 0 ;;
+    *)
+      echo "Unknown arg: $1"; exit 1 ;;
+  esac
+done
+
+# Resolve repo root (this script lives in scripts/)
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="${SCRIPT_DIR%/scripts}"
+cd "$REPO_ROOT"
+
+# Pick Python
+if command -v python3 >/dev/null 2>&1; then
+  PY=python3
+else
+  PY=python
+fi
+
+# Create venv if missing
+if [[ ! -d .venv ]]; then
+  echo "[+] Creating virtualenv .venv"
+  "$PY" -m venv .venv
+fi
+
+echo "[+] Activating venv"
+source .venv/bin/activate
+
+echo "[+] Upgrading pip"
+python -m pip install -U pip wheel setuptools >/dev/null
+
+if [[ "$WITH_OPENCV" == "1" ]]; then
+  echo "[+] Installing package with OpenCV extras (for LAB precision)"
+  pip install -e '.[opencv]'
+else
+  echo "[+] Installing package"
+  pip install -e .
+fi
+
+# Configure Gradio env
+if [[ "$PORT" != "auto" ]]; then
+  export GRADIO_SERVER_PORT="$PORT"
+else
+  # Let Gradio auto-pick a free port by not setting the env var
+  unset GRADIO_SERVER_PORT 2>/dev/null || true
+fi
+export GRADIO_SHARE="$SHARE"
+
+echo "[+] Launching Gradio demo (share=$SHARE, port=${PORT})"
+echo "    Press Ctrl+C to stop."
+
+# Try to open the local URL automatically if a fixed port is chosen
+if [[ "$SHARE" != "1" && "$PORT" != "auto" ]]; then
+  LOCAL_URL="http://127.0.0.1:${PORT}"
+  if command -v open >/dev/null 2>&1; then
+    (sleep 2; open "$LOCAL_URL") &
+  elif command -v xdg-open >/dev/null 2>&1; then
+    (sleep 2; xdg-open "$LOCAL_URL") &
+  fi
+  echo "    When ready, your browser should open ${LOCAL_URL}"
+fi
+
+python apps/canada_radar_gradio.py
+