fix: anchor all maps on AOI bbox to stop squashed hotspot images

The hotspot map was using the product raster's bounds for set_xlim/ylim,
while render_raster_map was using the true-color raster's bounds. When
CDSE returned a product raster with tile-boundary-cropped bounds (e.g. a
0.03° × 0.08° strip), the hotspot came out several times flatter than
the top product map.

Fix:
- new _figsize_for_extent() sizes the matplotlib figure to match the
data aspect (cos-lat corrected) so tight_layout + bbox_inches never
produce a stretched PNG
- render_raster_map, render_hotspot_map, and render_overview_map all
now anchor xlim/ylim on the AOI bbox instead of whichever raster
happened to be opened first
- imshow() calls no longer pass the aspect kwarg — set_aspect() on the
axes is the single source of truth

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

app/outputs/maps.py

@@ -243,49 +243,53 @@ def render_raster_map(
     """
     import rasterio
 
-    fig, ax = plt.subplots(figsize=(6, 5), dpi=200, facecolor=SHELL)
-    ax.set_facecolor(SHELL)
+    # Anchor the plot on the AOI bbox so every map in the report uses the
+    # same frame — prevents "pushed flat" artifacts caused by CDSE tile
+    # rasters coming back with bounds that don't match the AOI aspect.
+    min_lon, min_lat, max_lon, max_lat = aoi.bbox
+    plot_extent = [min_lon, max_lon, min_lat, max_lat]
+    geo_aspect = _geographic_aspect(plot_extent)
 
-    extent = None
+    fig, ax = plt.subplots(
+        figsize=_figsize_for_extent(plot_extent),
+        dpi=200,
+        facecolor=SHELL,
+    )
+    ax.set_facecolor(SHELL)
 
-    # Render true-color base layer
+    # Render true-color base layer at its own bounds; anything outside the
+    # AOI is clipped by set_xlim/ylim below.
     if true_color_path is not None:
         with rasterio.open(true_color_path) as src:
             rgb = src.read([1, 2, 3]).astype(np.float32)
-            extent = [src.bounds.left, src.bounds.right, src.bounds.bottom, src.bounds.top]
-        # Sentinel-2 reflectance scaling (values typically 0-10000)
+            tc_extent = [src.bounds.left, src.bounds.right, src.bounds.bottom, src.bounds.top]
         rgb_max = max(rgb.max(), 1.0)
         scale = 3000.0 if rgb_max > 255 else 255.0
         rgb_normalized = np.clip(rgb / scale, 0, 1).transpose(1, 2, 0)
-        geo_aspect = _geographic_aspect(extent)
-        ax.imshow(rgb_normalized, extent=extent, aspect=geo_aspect, zorder=0)
+        ax.imshow(rgb_normalized, extent=tc_extent, zorder=0)
 
-    # Render indicator raster overlay
+    # Render indicator raster overlay at its own bounds.
     if indicator_path is not None:
         with rasterio.open(indicator_path) as src:
             data = src.read(indicator_band).astype(np.float32)
             nodata = src.nodata
             ind_extent = [src.bounds.left, src.bounds.right, src.bounds.bottom, src.bounds.top]
-        if extent is None:
-            extent = ind_extent
-        geo_aspect = _geographic_aspect(extent)
         masked = np.ma.masked_where(
             (data == nodata) if nodata is not None else np.zeros_like(data, dtype=bool),
             data,
         )
         im = ax.imshow(
             masked, extent=ind_extent, cmap=cmap, alpha=alpha,
-            vmin=vmin, vmax=vmax, aspect=geo_aspect, zorder=1,
+            vmin=vmin, vmax=vmax, zorder=1,
         )
         cbar = fig.colorbar(im, ax=ax, fraction=0.03, pad=0.04, shrink=0.85)
         cbar.set_label(label, fontsize=7, color=INK_MUTED)
         cbar.ax.tick_params(labelsize=6, colors=INK_MUTED)
 
-    # AOI outline
-    if extent is not None:
-        ax.set_xlim(extent[0], extent[1])
-        ax.set_ylim(extent[2], extent[3])
-        ax.set_aspect(_geographic_aspect(extent))
+    # Anchor view + aspect on AOI bbox.
+    ax.set_xlim(plot_extent[0], plot_extent[1])
+    ax.set_ylim(plot_extent[2], plot_extent[3])
+    ax.set_aspect(geo_aspect)
     color = STATUS_COLORS[status]
     _draw_aoi_rect(ax, aoi, color)
 
@@ -319,6 +323,33 @@ def _geographic_aspect(extent: list[float]) -> float:
     return 1.0 / cos_lat
 
 
+def _figsize_for_extent(
+    extent: list[float],
+    *,
+    base_height_in: float = 5.0,
+    colorbar_allowance_in: float = 1.0,
+    min_width_in: float = 3.5,
+    max_width_in: float = 10.0,
+) -> tuple[float, float]:
+    """Return (width, height) in inches that match the data aspect ratio.
+
+    Without this, matplotlib's default figsize can force the axes into a
+    shape that doesn't match the data, and `bbox_inches="tight"` then
+    crops a distorted frame. By sizing the figure to the data first, the
+    rendered PNG matches the physical aspect of the AOI, and the image
+    no longer looks "pushed flat" (or stretched) in the PDF.
+    """
+    west, east, south, north = extent
+    data_w = max(east - west, 1e-9)
+    data_h = max(north - south, 1e-9)
+    geo_aspect = _geographic_aspect(extent)
+    # Display ratio (width / height) once cos-lat correction is applied.
+    display_ratio = data_w / (data_h * geo_aspect)
+    fig_w = base_height_in * display_ratio + colorbar_allowance_in
+    fig_w = min(max(fig_w, min_width_in), max_width_in)
+    return fig_w, base_height_in
+
+
 def render_hotspot_map(
     *,
     true_color_path: str | None,
@@ -335,17 +366,25 @@ def render_hotspot_map(
     Only pixels where |z-score| > threshold are shown; non-significant
     pixels are transparent, letting the true-color base show through.
 
-    Uses a geographic (cos-lat-corrected) axis aspect so the image is
-    never stretched when it's later placed into the PDF.
+    The plot is anchored on the AOI bbox (not the product raster bounds)
+    so that it matches the other maps in the report, and the figure is
+    sized to match the data aspect so the PNG never comes out "pushed
+    flat" after bbox_inches="tight" cropping.
     """
     import rasterio
 
-    fig, ax = plt.subplots(figsize=(6, 5), dpi=200, facecolor=SHELL)
-    ax.set_facecolor(SHELL)
+    min_lon, min_lat, max_lon, max_lat = aoi.bbox
+    plot_extent = [min_lon, max_lon, min_lat, max_lat]
+    geo_aspect = _geographic_aspect(plot_extent)
 
-    geo_aspect = _geographic_aspect(extent)
+    fig, ax = plt.subplots(
+        figsize=_figsize_for_extent(plot_extent),
+        dpi=200,
+        facecolor=SHELL,
+    )
+    ax.set_facecolor(SHELL)
 
-    # True-color base layer
+    # True-color base layer — drawn at its own extent but clipped to AOI.
     if true_color_path is not None:
         with rasterio.open(true_color_path) as src:
             rgb = src.read([1, 2, 3]).astype(np.float32)
@@ -353,22 +392,22 @@ def render_hotspot_map(
         rgb_max = max(rgb.max(), 1.0)
         scale = 3000.0 if rgb_max > 255 else 255.0
         rgb_normalized = np.clip(rgb / scale, 0, 1).transpose(1, 2, 0)
-        ax.imshow(rgb_normalized, extent=tc_extent, aspect=geo_aspect, zorder=0)
+        ax.imshow(rgb_normalized, extent=tc_extent, zorder=0)
 
-    # Hotspot overlay — only significant pixels, masked elsewhere
+    # Hotspot overlay — drawn at the product raster's extent.
     masked_z = np.ma.masked_where(~hotspot_mask, zscore_raster)
     vmax = min(float(np.nanmax(np.abs(zscore_raster))), 5.0)
     im = ax.imshow(
         masked_z, extent=extent, cmap="RdBu_r", alpha=0.8,
-        vmin=-vmax, vmax=vmax, aspect=geo_aspect, zorder=1,
+        vmin=-vmax, vmax=vmax, zorder=1,
     )
     cbar = fig.colorbar(im, ax=ax, fraction=0.03, pad=0.04, shrink=0.85)
     cbar.set_label(f"{label} (decline \u2190 \u2192 increase)", fontsize=7, color=INK_MUTED)
     cbar.ax.tick_params(labelsize=6, colors=INK_MUTED)
 
-    # AOI outline and axis limits
-    ax.set_xlim(extent[0], extent[1])
-    ax.set_ylim(extent[2], extent[3])
+    # Anchor view on AOI so this map lines up with the product map.
+    ax.set_xlim(plot_extent[0], plot_extent[1])
+    ax.set_ylim(plot_extent[2], plot_extent[3])
     ax.set_aspect(geo_aspect)
     color = STATUS_COLORS[status]
     _draw_aoi_rect(ax, aoi, color)
@@ -411,19 +450,30 @@ def render_overview_map(
     """
     import rasterio
 
-    fig, ax = plt.subplots(figsize=(8, 6), dpi=200, facecolor=SHELL)
+    # Anchor overview on the AOI bbox — same reasoning as the indicator
+    # and hotspot maps: keep geometry consistent across the report.
+    min_lon, min_lat, max_lon, max_lat = aoi.bbox
+    plot_extent = [min_lon, max_lon, min_lat, max_lat]
+    geo_aspect = _geographic_aspect(plot_extent)
+
+    fig, ax = plt.subplots(
+        figsize=_figsize_for_extent(
+            plot_extent, base_height_in=6.0, max_width_in=11.0,
+        ),
+        dpi=200,
+        facecolor=SHELL,
+    )
     ax.set_facecolor(SHELL)
 
     with rasterio.open(true_color_path) as src:
         rgb = src.read([1, 2, 3]).astype(np.float32)
-        extent = [src.bounds.left, src.bounds.right, src.bounds.bottom, src.bounds.top]
+        tc_extent = [src.bounds.left, src.bounds.right, src.bounds.bottom, src.bounds.top]
 
     # Sentinel-2 reflectance scaling
     rgb_max = max(rgb.max(), 1.0)
     scale = 3000.0 if rgb_max > 255 else 255.0
     rgb_normalized = np.clip(rgb / scale, 0, 1).transpose(1, 2, 0)
-    geo_aspect = _geographic_aspect(extent)
-    ax.imshow(rgb_normalized, extent=extent, aspect=geo_aspect)
+    ax.imshow(rgb_normalized, extent=tc_extent)
     ax.set_aspect(geo_aspect)
 
     # AOI outline
@@ -439,8 +489,8 @@ def render_overview_map(
     elif date_range:
         ax.set_title(date_range, fontsize=8, color=INK_MUTED, pad=6)
 
-    ax.set_xlim(extent[0], extent[1])
-    ax.set_ylim(extent[2], extent[3])
+    ax.set_xlim(plot_extent[0], plot_extent[1])
+    ax.set_ylim(plot_extent[2], plot_extent[3])
     ax.tick_params(labelsize=6, colors=INK_MUTED)
     ax.set_xlabel("Longitude", fontsize=7, color=INK_MUTED)
     ax.set_ylabel("Latitude", fontsize=7, color=INK_MUTED)