Deploy from GitHub Actions

plots/map.py

@@ -8,6 +8,7 @@ import numpy as np
 import pandas as pd
 import streamlit as st
 from matplotlib.colors import LinearSegmentedColormap
+from matplotlib.figure import Figure
 from osgeo import gdal
 
 from utils.data_loading import timer
@@ -213,8 +214,320 @@ def plot_seasonal_salinity_for_bays(
 
 
 @timer(include_params=True)
-def generate_seasonal_plot(data, year, shapefile_path):
-    """Generate the seasonal trends plot"""
+def generate_seasonal_plot(
+    data: pd.DataFrame,
+    parameter: str,
+    year: str,
+    shapefile_path: str,
+    reporting_end_month: int = 10,
+    basemap_provider=ctx.providers.USGS.USTopo,  # type: ignore
+    alpha: float = 0.5,
+) -> tuple[Figure, pd.DataFrame, pd.DataFrame]:
+    """
+    Create seasonal plots of mean parameter values by WBID for specific bays.
+
+    Parameters
+    ----------
+    data : pd.DataFrame
+        DataFrame containing measurements with lat/long
+    parameter : str
+        Parameter to plot (e.g., "Salinity", "Dissolved Oxygen")
+    year : str
+        Reporting Year to filter data for
+    shapefile_path : str
+        Path to WBID shapefile
+    reporting_end_month : int
+        Last month of reporting year (1-12)
+    basemap_provider : ctx.providers
+        Contextily map provider
+    alpha : float
+        Transparency of basemap
+
+    Returns
+    -------
+    tuple[Figure, pd.DataFrame, pd.DataFrame]
+        - Figure: Matplotlib figure containing the plot
+        - DataFrame: Raw data used in plot
+        - DataFrame: Processed quarterly means
+    """
+    if st.session_state.get("DEBUG", False):
+        debugging_info(data, shapefile_path)
+
+    # Load WBIDs
+    wbids = gpd.read_file(shapefile_path)
+    if wbids.crs is None:
+        wbids.set_crs(epsg=6439, inplace=True)
+    wbids = wbids.to_crs(epsg=3857)
+
+    # Filter for specific bays
+    bay_wbids = [
+        "1061A",
+        "1061B",
+        "1061C",
+        "1061D",
+        "1061E",
+        "1061F",
+        "1061G",
+        "1061H",
+        "1055A",
+    ]
+    year_data = data[
+        (data["Reporting_Year"] == int(year)) & (data["WBID"].isin(bay_wbids))
+    ].copy()
+
+    # Calculate quarterly means
+    seasonal_means = calculate_quarterly_means(
+        year_data, parameter, reporting_end_month
+    )
+
+    # Create the plot
+    fig = create_quarterly_maps(
+        seasonal_means=seasonal_means,
+        wbids=wbids[wbids["WBID"].isin(bay_wbids)],
+        parameter=parameter,
+        year=year,
+        reporting_end_month=reporting_end_month,
+        basemap_provider=basemap_provider,
+        alpha=alpha,
+    )
+
+    return fig, year_data, seasonal_means
+
+
+def calculate_quarterly_means(
+    data: pd.DataFrame, parameter: str, reporting_end_month: int
+) -> pd.DataFrame:
+    """Calculate quarterly means for the parameter"""
+    # Add quarter information
+    data["quarter"] = data["Activity_Start_Date_Time"].apply(
+        lambda x: get_quarter(x, reporting_end_month)
+    )
+
+    # Calculate means
+    return (
+        data.groupby(["WBID", "quarter"], observed=True)["Org_Result_Value"]
+        .mean()
+        .reset_index()
+        .rename(columns={"Org_Result_Value": parameter})
+    )
+
+
+def get_quarter(date, reporting_end_month: int) -> str:
+    """Calculate quarter based on reporting year end month"""
+    month = date.month
+    month_offset = (12 - reporting_end_month) % 12
+    adjusted_month = ((month + month_offset) % 12) or 12
+    return f"Q{((adjusted_month - 1) // 3) + 1}"
+
+
+def create_quarterly_maps(
+    seasonal_means: pd.DataFrame,
+    wbids: gpd.GeoDataFrame,
+    parameter: str,
+    year: str,
+    reporting_end_month: int,
+    basemap_provider,
+    alpha: float = 0.5,
+) -> Figure:
+    """Create the quarterly map visualization"""
+    fig = plt.figure(figsize=(20, 14))
+
+    # Set up color scheme
+    colors = ["#08519c", "#73a9cf", "#fee090", "#fc8d59", "#d73027"]
+    cmap = LinearSegmentedColormap.from_list("custom", colors, N=100)
+
+    # Calculate plot bounds
+    bounds = wbids.total_bounds
+    extent = calculate_map_extent(bounds)
+
+    # Create grid layout with tight spacing
+    gs = fig.add_gridspec(
+        2,
+        2,
+        width_ratios=[1, 1],
+        wspace=0.05,
+        hspace=-0.15,
+        left=0.02,
+        right=0.98,
+        top=0.95,
+        bottom=0.05,
+    )
+
+    # Plot each quarter
+    for idx, quarter in enumerate(["Q1", "Q2", "Q3", "Q4"]):
+        ax = fig.add_subplot(gs[idx // 2, idx % 2])
+        plot_quarter(
+            ax=ax,
+            quarter=quarter,
+            seasonal_means=seasonal_means,
+            wbids=wbids,
+            parameter=parameter,
+            year=year,
+            reporting_end_month=reporting_end_month,
+            cmap=cmap,
+            extent=extent,
+            basemap_provider=basemap_provider,
+            alpha=alpha,
+        )
+
+    add_colorbar(fig, seasonal_means, parameter, cmap)
+
+    return fig
+
+
+def plot_quarter(
+    ax: plt.Axes,  # type: ignore
+    quarter: str,
+    seasonal_means: pd.DataFrame,
+    wbids: gpd.GeoDataFrame,
+    parameter: str,
+    year: str,
+    reporting_end_month: int,
+    cmap: LinearSegmentedColormap,
+    extent: list[float],
+    basemap_provider,
+    alpha: float = 0.5,
+) -> None:
+    """Plot a single quarter's map"""
+    # Get data for this quarter
+    quarter_data = seasonal_means[seasonal_means["quarter"] == quarter]
+    merged = wbids.merge(quarter_data, on="WBID", how="left")
+
+    # Get value range for consistent colormap
+    vmin = seasonal_means[parameter].min()
+    vmax = get_parameter_max_value(parameter, seasonal_means[parameter].max())
+
+    # Plot WBIDs
+    merged.plot(
+        column=parameter,
+        ax=ax,
+        cmap=cmap,
+        vmin=vmin,
+        vmax=vmax,
+        alpha=0.7,
+        missing_kwds={"color": "lightgrey", "alpha": 0.5},
+    )
+
+    # Add basemap
+    ctx.add_basemap(ax, source=basemap_provider, zoom=11, alpha=alpha)  # type: ignore
+
+    # Set map extent
+    ax.set_xlim(extent[0], extent[1])
+    ax.set_ylim(extent[2], extent[3])
+
+    # Get date range for this quarter
+    date_range = get_quarter_dates(quarter, int(year), reporting_end_month)
+
+    # Create title with appropriate padding based on position
+    title_pad = 15 if int(quarter[1]) <= 2 else 5  # Top row vs bottom row
+    ax.set_title(
+        f"Quarter {quarter[1]} Mean {parameter}\n{date_range}",
+        pad=title_pad,
+        fontsize=10,
+    )
+    ax.set_axis_off()
+
+
+def get_parameter_max_value(parameter: str, data_max: float) -> float:
+    """Get the maximum value for colormap scaling based on parameter"""
+    parameter_limits = {
+        "Salinity": 40,
+        "Dissolved Oxygen": 12,
+        "pH": 9,
+        "Temperature, Water": 35,
+        "Turbidity": None,  # Use data max
+        "Total Nitrogen": None,
+        "Total Phosphorus": None,
+        "Fecal Coliform (MPN)": None,
+    }
+    return parameter_limits.get(parameter, data_max)
+
+
+def calculate_map_extent(
+    bounds: np.ndarray, buffer_fraction: float = 0.05
+) -> list[float]:
+    """Calculate map extent with buffer"""
+    x_buffer = (bounds[2] - bounds[0]) * buffer_fraction
+    y_buffer = (bounds[3] - bounds[1]) * buffer_fraction
+    return [
+        bounds[0] - x_buffer,  # xmin
+        bounds[2] + x_buffer,  # xmax
+        bounds[1] - y_buffer,  # ymin
+        bounds[3] + y_buffer,  # ymax
+    ]
+
+
+def get_quarter_dates(quarter: str, year: int, reporting_end_month: int) -> str:
+    """Get date range string for a quarter"""
+    # Calculate first month of reporting year
+    first_month = (reporting_end_month % 12) + 1
+
+    # Calculate start month for each quarter
+    quarter_num = int(quarter[1])
+    start_month = ((first_month - 1 + ((quarter_num - 1) * 3)) % 12) + 1
+    end_month = ((start_month + 2) % 12) or 12
+
+    # Determine correct years for start and end dates
+    start_year = year - 1 if start_month > reporting_end_month else year
+    end_year = start_year if end_month >= start_month else start_year + 1
+
+    # Create date objects
+    start_date = pd.Timestamp(f"{start_year}-{start_month:02d}-01")
+    end_date = pd.Timestamp(
+        f"{end_year}-{end_month:02d}-{pd.Timestamp(f'{end_year}-{end_month:02d}').days_in_month}"
+    )
+
+    return f"{start_date.strftime('%b %d, %Y')} - {end_date.strftime('%b %d, %Y')}"
+
+
+def add_colorbar(
+    fig: Figure,
+    seasonal_means: pd.DataFrame,
+    parameter: str,
+    cmap: LinearSegmentedColormap,
+) -> None:
+    """Add colorbar to the figure"""
+    # Get value range
+    vmin = seasonal_means[parameter].min()
+    vmax = get_parameter_max_value(parameter, seasonal_means[parameter].max())
+
+    # Create colorbar
+    norm = plt.Normalize(vmin=vmin, vmax=vmax)  # type: ignore
+    sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+    sm.set_array([])
+
+    # Get parameter unit
+    unit = get_parameter_unit(parameter)
+    label = f"{parameter} ({unit})" if unit else parameter
+
+    # Add colorbar to figure
+    fig.colorbar(
+        sm,
+        ax=fig.axes,
+        orientation="vertical",
+        label=label,
+        pad=0.01,
+        fraction=0.015,
+        ticks=np.arange(0, vmax + 5, 5),  # Add ticks every 5 units
+    )
+
+
+def get_parameter_unit(parameter: str) -> str:
+    """Get the unit for a parameter"""
+    parameter_units = {
+        "Salinity": "ppt",
+        "Dissolved Oxygen": "mg/L",
+        "pH": "",
+        "Temperature, Water": "°C",
+        "Turbidity": "NTU",
+        "Total Nitrogen": "mg/L",
+        "Total Phosphorus": "mg/L",
+        "Fecal Coliform (MPN)": "MPN/100mL",
+    }
+    return parameter_units.get(parameter, "")
+
+
+def debugging_info(data: pd.DataFrame, shapefile_path: str) -> None:
     # Add debugging information
     wbids = gpd.read_file(shapefile_path)
 
@@ -231,28 +544,19 @@ def generate_seasonal_plot(data, year, shapefile_path):
     # Pre-transform to Web Mercator (EPSG:3857) here to avoid issues in plotting function
     wbids = wbids.to_crs(epsg=3857)
 
-    if st.session_state.get("DEBUG", False):
-        st.write("Debug Info:")
-        st.write(
-            {
-                "Shapefile CRS": wbids.crs,
-                "Input Data CRS": data.crs
-                if isinstance(data, gpd.GeoDataFrame)
-                else "Not a GeoDataFrame",
-                "GDAL Version": gdal.VersionInfo()
-                if "osgeo.gdal" in sys.modules
-                else "Not available",
-                "GeoPandas Version": gpd.__version__,
-                "Python Version": sys.version,
-                "File exists": Path(shapefile_path).exists(),
-                "Associated files": list(Path(shapefile_path).parent.glob("*.*")),
-            }
-        )
-
-    return plot_seasonal_salinity_for_bays(
-        data,
-        year,
-        shapefile_path=shapefile_path,
-        wbids=wbids,
-        reporting_end_month=st.session_state.reporting_month,
+    st.write("Debug Info:")
+    st.write(
+        {
+            "Shapefile CRS": wbids.crs,
+            "Input Data CRS": data.crs
+            if isinstance(data, gpd.GeoDataFrame)
+            else "Not a GeoDataFrame",
+            "GDAL Version": gdal.VersionInfo()
+            if "osgeo.gdal" in sys.modules
+            else "Not available",
+            "GeoPandas Version": gpd.__version__,
+            "Python Version": sys.version,
+            "File exists": Path(shapefile_path).exists(),
+            "Associated files": list(Path(shapefile_path).parent.glob("*.*")),
+        }
     )

ui/pages/home.py

@@ -1,6 +1,5 @@
 import io
 
-import pandas as pd
 import streamlit as st
 
 from components import render_stations_map

ui/pages/seasonal_maps.py

@@ -1,33 +1,90 @@
+import io
+
 import streamlit as st
 
+from components import render_filtered_data_preview
 from dashboard_analytics import log_visit
 from plots.map import generate_seasonal_plot
-from utils.data_loading import load_seasonal_data
+from utils.data_loading import add_lat_long, get_stations_data
 
 log_visit("Seasonal Maps")
 
-
 st.title("Seasonal Variations")
 raw_df = st.session_state.data["raw_df"]
-# Use Reporting_Year instead of calendar year
-years = sorted(raw_df["Reporting_Year"].unique())
 
 # Move filters to sidebar
 st.sidebar.markdown("### Filter Options")
-analyte = st.sidebar.selectbox(
-    "Select Parameter:", ["Salinity"], index=0, key="seasonal_analyte_select"
+
+# Allow selection of any parameter
+parameters = sorted(raw_df["Org_Analyte_Name"].unique())
+selected_parameter = st.sidebar.selectbox(
+    "Select Parameter:",
+    parameters,
+    index=parameters.index("Salinity") if "Salinity" in parameters else 0,
+    key="seasonal_parameter_select",
 )
+
+# Use Reporting_Year for consistency
+years = sorted(raw_df["Reporting_Year"].unique(), reverse=True)
 selected_year = st.sidebar.selectbox(
-    "Select Year:", sorted(years, reverse=True), index=0, key="seasonal_year_select"
+    "Select Year:", years, index=0, key="seasonal_year_select"
 )
 
 if not raw_df.empty:
-    seasonal_data = load_seasonal_data(raw_df, analyte)
-    fig = generate_seasonal_plot(
-        seasonal_data,
-        str(selected_year),
+    # Filter data for selected parameter
+    param_data = raw_df[raw_df["Org_Analyte_Name"] == selected_parameter].copy()
+
+    # Add lat/long information using existing function
+    param_data = add_lat_long(param_data, get_stations_data())
+
+    # Generate plot and get data
+    fig, raw_data, plot_data = generate_seasonal_plot(
+        data=param_data,
+        parameter=selected_parameter,
+        year=str(selected_year),
         shapefile_path="data/waterbody_ids/Waterbody_IDs_(WBIDs).shp",
+        reporting_end_month=st.session_state.reporting_month,
     )
     st.pyplot(fig)
+
+    # Add data viewers
+    with st.expander("Chart Data"):
+        render_filtered_data_preview(
+            plot_data, display_columns=plot_data.columns.tolist()
+        )
+
+        # Add CSV download button for chart data
+        csv_buffer = io.StringIO()
+        plot_data.to_csv(csv_buffer, index=False)
+        st.download_button(
+            label=f"Download Chart Data for {selected_parameter} (CSV)",
+            data=csv_buffer.getvalue(),
+            file_name=f"{selected_parameter}_seasonal_{selected_year}_chart_data.csv",
+            mime="text/csv",
+        )
+
+    with st.expander("Raw Data"):
+        render_filtered_data_preview(
+            raw_data,
+            [
+                "Activity_Start_Date_Time",
+                "Reporting_Year",
+                "WBID",
+                "Station_Number",
+                "Sample_Position",
+                "Org_Analyte_Name",
+                "Org_Result_Value",
+            ],
+        )
+
+        # Add CSV download button for raw data
+        csv_buffer = io.StringIO()
+        raw_data.to_csv(csv_buffer, index=False)
+        st.download_button(
+            label=f"Download Raw Data for {selected_parameter} (CSV)",
+            data=csv_buffer.getvalue(),
+            file_name=f"{selected_parameter}_seasonal_{selected_year}_raw_data.csv",
+            mime="text/csv",
+        )
 else:
     st.warning("No data available for seasonal analysis.")