Merge pull request #3 from cchdo/visualize

Add Map Maker

Author: DocOtak

CHANGELOG.md

@@ -5,6 +5,7 @@
   Right now the timeout is 5 minutes and fixed.
 * fixed a bug where the wine retry decorator would retry forever
 * Increase the cnv generation attempts from 3 to 5
+* Add HTML/leaflet based map output
 
 ## v2025.08.0 (2025-08-11)
 * Initial release.

pyproject.toml

@@ -15,6 +15,7 @@ dependencies = [
     "lxml>=5.4.0",
     "odf-sbe>=0.2.1",
     "rich>=14.0.0",
+    "folium>=0.20.0",
 ]
 
 [project.scripts]

src/r2r_ctd/__main__.py

@@ -21,6 +21,7 @@
 
 from r2r_ctd.breakout import Breakout
 from r2r_ctd.docker_ctl import test_docker as _test_docker
+from r2r_ctd.maps import make_map
 from r2r_ctd.reporting import (
     ResultAggregator,
     write_xml_qa_report,
@@ -71,6 +72,7 @@ def qa(gen_cnvs: bool, paths: tuple[Path, ...]):
             station.r2r.write_con_report(breakout)
 
         write_xml_qa_report(breakout, ra.certificate)
+        make_map(ra)
 
         # write the cnv files if asked
         if gen_cnvs:

src/r2r_ctd/accessors.py

@@ -59,6 +59,18 @@ class R2RAccessor:
     def __init__(self, xarray_obj: xr.Dataset):
         self._obj = xarray_obj
 
+    @property
+    def __geo_interface__(self):
+        return {
+            "type": "Point",
+            "coordinates": (self.longitude, self.latitude),
+        }
+
+    @property
+    def name(self):
+        """Get the "name" of this station, basically the hex file name with the .hex removed"""
+        return get_filename(self._obj.hex).removesuffix(".hex")
+
     @cached_property
     def latitude(self) -> float | None:
         """Simple wrapper around :py:func:`~r2r_ctd.derived.get_latitude`"""

src/r2r_ctd/breakout.py

@@ -35,6 +35,46 @@ class BBox(NamedTuple):
     e: float
     n: float
 
+    @property
+    def __geo_interface__(self):
+        if self.w > self.e:
+            return {
+                "type": "MultiPolygon",
+                "coordinates": (
+                    (
+                        (
+                            (self.w, self.s),
+                            (180, self.s),
+                            (180, self.n),
+                            (self.w, self.n),
+                            (self.w, self.s),
+                        ),
+                    ),
+                    (
+                        (
+                            (-180, self.s),
+                            (self.e, self.s),
+                            (self.e, self.n),
+                            (-180, self.n),
+                            (-180, self.s),
+                        ),
+                    ),
+                ),
+            }
+
+        return {
+            "type": "Polygon",
+            "coordinates": (
+                (
+                    (self.w, self.s),
+                    (self.e, self.s),
+                    (self.e, self.n),
+                    (self.w, self.n),
+                    (self.w, self.s),
+                ),
+            ),
+        }
+
     def contains(self, lon: float, lat: float) -> bool:
         """given a lon/lat pair, determine if it is inside the bounding box represented by this instance"""
         if lat < self.s:

src/r2r_ctd/maps.py

@@ -0,0 +1,75 @@
+"""Functions for making maps to help QA work"""
+
+from logging import getLogger
+
+import folium
+
+from r2r_ctd.reporting import ResultAggregator
+from r2r_ctd.state import get_map_path
+
+logger = getLogger(__name__)
+
+
+def make_map(results: ResultAggregator):
+    """Write the results to a map using folium.
+
+    Useful for seeing what stations failed and what the tested bounding box was"""
+    m = folium.Map()
+
+    breakout_fields = [
+        "cruise_id",
+        "fileset_id",
+        "rating",
+        "manifest_ok",
+        "start_date",
+        "end_date",
+        "stations_not_on_map",
+    ]
+    breakout_popup = folium.GeoJsonPopup(
+        fields=breakout_fields,
+    )
+    breakout_tooltip = folium.GeoJsonTooltip(
+        fields=breakout_fields,
+    )
+
+    breakout_feature = results.geo_breakout_feature()
+
+    station_features = results.geo_station_feature()
+
+    if breakout_feature:
+        folium.GeoJson(
+            breakout_feature,
+            popup=breakout_popup,
+            tooltip=breakout_tooltip,
+            style_function=lambda feature: {
+                "fillColor": feature["properties"]["rating"],
+                "weight": 0,
+            },
+        ).add_to(m)
+
+    station_fields = [
+        "name",
+        "time",
+        "all_three_files",
+        "lon_lat_valid",
+        "time_valid",
+        "time_in",
+        "lon_lat_in",
+        "bottles_fired",
+    ]
+
+    if len(station_features["features"]) > 0:
+        folium.GeoJson(
+            station_features,
+            marker=folium.Marker(icon=folium.Icon()),
+            tooltip=folium.GeoJsonTooltip(fields=station_fields),
+            popup=folium.GeoJsonPopup(fields=station_fields),
+            style_function=lambda feature: {
+                "markerColor": feature["properties"]["marker_color"]
+            },
+        ).add_to(m)
+    folium.FitOverlays().add_to(m)
+
+    map_path = get_map_path(results.breakout)
+    m.save(map_path)
+    logger.info(f"Wrote QA map to: {map_path}")

src/r2r_ctd/reporting.py

@@ -141,6 +141,21 @@ def date_range(
     )
 
 
+def boolean_span_formatter(tf: bool) -> str:
+    """Format a boolean with html span element that colors green/red for true/false"""
+    return f"<span style='color: {'green' if tf else 'red'}'>{tf}</span>"
+
+
+RATING_CSS_MAP = {
+    "G": "green",
+    "Y": "yellow",
+    "R": "red",
+    "X": "black",
+    "N": "grey",
+}
+"""Mapping between the QA letter codes and css color name"""
+
+
 @dataclass
 class ResultAggregator:
     """Dataclass which iterates though all the stations their tests and aggregates their results and generates the "info blocks".
@@ -151,6 +166,100 @@ class ResultAggregator:
 
     breakout: Breakout
 
+    def geo_breakout_feature(self):
+        """If the breakout has a valid bounding box, generate the GeoJSON feature to plot on a map"""
+        if self.breakout.bbox is None:
+            return None
+
+        breakout_geometry = self.breakout.bbox.__geo_interface__
+        date_start = (
+            f"{self.breakout.temporal_bounds.dtstart:%Y-%m-%d}"
+            if self.breakout.temporal_bounds is not None
+            else ""
+        )
+        date_end = (
+            f"{self.breakout.temporal_bounds.dtend:%Y-%m-%d}"
+            if self.breakout.temporal_bounds is not None
+            else ""
+        )
+        not_on_map = (
+            f"<li>{station.r2r.name}</li>"
+            for station in self.breakout
+            if None in (station.r2r.longitude, station.r2r.latitude)
+        )
+        return {
+            "type": "FeatureCollection",
+            "features": [
+                {
+                    "type": "Feature",
+                    "geometry": breakout_geometry,
+                    "properties": {
+                        "cruise_id": self.breakout.cruise_id,
+                        "fileset_id": self.breakout.fileset_id,
+                        "rating": RATING_CSS_MAP[self.rating],
+                        "manifest_ok": boolean_span_formatter(
+                            self.breakout.manifest_ok
+                        ),
+                        "start_date": date_start,
+                        "end_date": date_end,
+                        "stations_not_on_map": f"<ul>{''.join(not_on_map) or '<li>All QAed stations on map</li>'}</ul>",
+                    },
+                }
+            ],
+        }
+
+    def geo_station_feature(self):
+        """Generate the GeoJSON feature collection with a feature for each station that has lon/lat coordinates to plot on a map"""
+        features = []
+        for station in self.breakout:
+            if None in (station.r2r.longitude, station.r2r.latitude):
+                continue
+            station_geometry = station.r2r.__geo_interface__
+            station_time = (
+                f"{station.r2r.time:%Y-%m-%d %H:%M:%S}" if station.r2r.time else "None"
+            )
+
+            marker_color = (
+                "green"
+                if (
+                    station.r2r.all_three_files
+                    and station.r2r.lon_lat_valid
+                    and station.r2r.time_valid
+                    and station.r2r.lon_lat_in(self.breakout.bbox)
+                    and station.r2r.time_in(self.breakout.temporal_bounds)
+                )
+                else "red"
+            )
+
+            features.append(
+                {
+                    "type": "Feature",
+                    "geometry": station_geometry,
+                    "properties": {
+                        "name": station.r2r.name,
+                        "time": station_time,
+                        "all_three_files": boolean_span_formatter(
+                            station.r2r.all_three_files
+                        ),
+                        "lon_lat_valid": boolean_span_formatter(
+                            station.r2r.lon_lat_valid
+                        ),
+                        "time_valid": boolean_span_formatter(station.r2r.time_valid),
+                        "lon_lat_in": boolean_span_formatter(
+                            station.r2r.lon_lat_in(self.breakout.bbox)
+                        ),
+                        "time_in": boolean_span_formatter(
+                            station.r2r.time_in(self.breakout.temporal_bounds)
+                        ),
+                        "bottles_fired": boolean_span_formatter(
+                            station.r2r.bottles_fired
+                        ),
+                        "marker_color": marker_color,
+                    },
+                }
+            )
+        return {"type": "FeatureCollection", "features": features}
+
     @cached_property
     def presence_of_all_files(self) -> int:
         """Iterate though the stations and count how many have :py:meth:`~r2r_ctd.accessors.R2RAccessor.all_three_files`"""

src/r2r_ctd/state.py

@@ -120,6 +120,18 @@ def get_product_path(breakout: "Breakout") -> Path:
     return product_dir
 
 
+def get_map_path(breakout: "Breakout") -> Path:
+    """Get the path to write the map file to, creating parent directories if necessary."""
+    map_name = breakout.qa_template_path.name.replace(
+        "_qa.2.0.xmlt",
+        "_qa_map.html",
+    )
+    map_html = breakout.path / "proc" / map_name
+    map_html.parent.mkdir(exist_ok=True, parents=True)
+
+    return map_html
+
+
 def get_filename(da: xr.DataArray) -> str:
     """Gets the ``filename`` attribute of a DataArray object that represents a file.