PyGeoFetch 1.9.0__tar.gz → 1.9.2__tar.gz

{pygeofetch-1.9.0 → pygeofetch-1.9.2}/CHANGELOG.md

@@ -1,9 +1,9 @@
 # Changelog
 
 All notable changes to PyGeoFetch are documented here.
-Format follows [Keep a Changelog](https://keepachangelog.com/en/1.9.0/).
+Format follows [Keep a Changelog](https://keepachangelog.com/en/1.9.2/).
 
-## [1.9.0] — 2026-07-12
+## [1.9.2] — 2026-07-12
 
 ### Added
 - Federated search across 22+ satellite data providers

{pygeofetch-1.9.0/pygeofetch.egg-info → pygeofetch-1.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 1.9.0
+Version: 1.9.2
 Summary: Universal satellite data pipeline + geospatial processing platform
 Author-email: Samuel Appiah Kubi <appiahkubis14@gmail.com>
 License: MIT License
@@ -94,8 +94,8 @@ Requires-Dist: plotly>=5.14.0; extra == "viz"
 Requires-Dist: whitebox>=2.3.0; extra == "viz"
 Requires-Dist: whiteboxgui>=2.3.0; extra == "viz"
 Requires-Dist: geemap>=0.28.0; extra == "viz"
-Requires-Dist: osmnx>=1.9.0; extra == "viz"
-Requires-Dist: contextily>=1.9.0; extra == "viz"
+Requires-Dist: osmnx>=1.9.2; extra == "viz"
+Requires-Dist: contextily>=1.9.2; extra == "viz"
 Requires-Dist: xyzservices>=2023.10.0; extra == "viz"
 Requires-Dist: mapclassify>=2.5.0; extra == "viz"
 Requires-Dist: geoplot>=0.5.0; extra == "viz"

{pygeofetch-1.9.0 → pygeofetch-1.9.2}/pygeofetch/__init__.py

@@ -30,7 +30,7 @@ CLI::
     pygeofetch doctor
 """
 
-__version__ = "1.9.0"
+__version__ = "1.9.2"
 __author__ = "PyGeoFetch Contributors"
 __license__ = "MIT"
 

{pygeofetch-1.9.0 → pygeofetch-1.9.2}/pygeofetch/core/engine.py

@@ -176,7 +176,7 @@ class PyGeoFetch:
         if _product.upper() == "SLC" and _effective:
             _effective = self._route_slc_providers(_effective)
         results = self.searcher.search(query, providers=_effective, use_cache=use_cache)
-        self._warn_if_outdated_constellation(results)
+        self._warn_if_outdated_constellation(results, query)
         return results
 
     def search_and_save(
@@ -217,19 +217,43 @@ class PyGeoFetch:
     }
     _GRD_ONLY = {"planetary_computer", "aws_earth", "element84"}
 
-    def _warn_if_outdated_constellation(self, results: list) -> None:
-        """Log a warning if results contain only decommissioned satellites after S1A decomm."""
-        from datetime import date
+    def _warn_if_outdated_constellation(self, results: list, query) -> None:
+        """Log a warning if results contain only decommissioned satellites
+        for a search whose OWN requested date range extends past S1A's
+        real decommissioning date — not just because today happens to be
+        past it. A search for genuine historical data (e.g. November
+        2024, well before S1A's actual 1 July 2026 end of mission) must
+        never trigger this, regardless of what today's date is; S1A
+        results from before decommissioning are completely legitimate."""
+        from datetime import date, datetime
 
         S1A_DECOM = date(2026, 7, 1)
-        if date.today() >= S1A_DECOM:
+
+        query_end = getattr(query, "end_date", None)
+        if query_end is None:
+            # No end date specified -- fall back to whether the search
+            # was actually run after decommissioning (the old behaviour,
+            # but only as a last resort when there's no query date to
+            # check against).
+            query_end_date = date.today()
+        elif isinstance(query_end, str):
+            query_end_date = datetime.fromisoformat(query_end.replace("Z", "")).date()
+        elif isinstance(query_end, datetime):
+            query_end_date = query_end.date()
+        elif isinstance(query_end, date):
+            query_end_date = query_end
+        else:
+            query_end_date = date.today()
+
+        if query_end_date >= S1A_DECOM:
             platforms = {getattr(r, "satellite", "") or "" for r in results}
             normalised = {_normalise_satellite_name(p) for p in platforms}
             if any("S1" in p for p in normalised):  # only check if S1 results
                 if not any(p in {"S1C", "S1D"} for p in normalised):
                     logger.warning(
-                        "Search returned only S1A/S1B results after Sentinel-1A "
-                        "decommissioning date. This may indicate a provider collection "
+                        "Search returned only S1A/S1B results for a date range "
+                        "extending past Sentinel-1A's real decommissioning date "
+                        "(1 July 2026). This may indicate a provider collection "
                         "routing issue. Check platform filter settings."
                     )
 
@@ -460,4 +484,4 @@ class PyGeoFetch:
 
     def __repr__(self) -> str:
         authed = [item["provider"] for item in self.auth.list()]
-        return f"PyGeoFetch(authenticated={authed}, cache_entries={len(self.searcher.cache._cache)})"
+        return f"PyGeoFetch(authenticated={authed}, cache_entries={len(self.searcher.cache._cache)})"

{pygeofetch-1.9.0 → pygeofetch-1.9.2}/pygeofetch/insar/__init__.py

@@ -55,7 +55,7 @@ from pygeofetch.insar.extraction import SLCExtractor
 from pygeofetch.insar.gpu import gpu_available
 from pygeofetch.insar.interferogram import InterferogramGenerator, InterferogramResult
 from pygeofetch.insar.timeseries import SBASTimeSeries
-from pygeofetch.insar.unwrap import PhaseUnwrapper
+from pygeofetch.insar.unwrap import PhaseUnwrapper, multilook
 from pygeofetch.insar.validate import DataValidator, ValidationResult
 from pygeofetch.insar.visualize import (
     visualize_interferogram,
@@ -79,6 +79,7 @@ from pygeofetch.insar.geolocation import (
     find_zero_doppler_time,
     parse_orbit_file,
     interpolate_orbit_state,
+    los_to_vertical_displacement,
 )
 from pygeofetch.insar.coregister import (
     compute_offset_field_from_dem,
@@ -90,6 +91,7 @@ __all__ = [
     "InterferogramGenerator",
     "InterferogramResult",
     "PhaseUnwrapper",
+    "multilook",
     "SBASTimeSeries",
     "AtmosphericCorrector",
     "SLCExtractor",
@@ -105,6 +107,7 @@ __all__ = [
     "find_zero_doppler_time",
     "parse_orbit_file",
     "interpolate_orbit_state",
+    "los_to_vertical_displacement",
     "compute_offset_field_from_dem",
     "fit_offset_polynomial",
     "resample_with_offset_field",

{pygeofetch-1.9.0 → pygeofetch-1.9.2}/pygeofetch/insar/annotation.py

@@ -15,6 +15,19 @@ MPC-0392):
     /product/imageAnnotation/imageInformation/azimuthTimeInterval
     /product/imageAnnotation/imageInformation/slantRangeTime
     /product/generalAnnotation/productInformation/rangeSamplingRate
+
+Dimension field paths confirmed separately, against ESA's Sentinel-1
+Product Specification (MPC-0240), which documents renaming
+numberOfAzimuthLines -> numberOfLines and numberOfRangeSamples ->
+numberOfSamples:
+
+    /product/imageAnnotation/imageInformation/numberOfLines
+    /product/imageAnnotation/imageInformation/numberOfSamples
+
+("numberOfColumns" is not a real field in this schema at all -- an
+earlier, unverified assumption here that only surfaced against real
+Sentinel-1 data, since synthetic tests built on the same assumption
+couldn't have caught their own premise being wrong.)
 """
 
 from __future__ import annotations
@@ -103,6 +116,17 @@ def parse_slc_geometry(
             n for n in zf.namelist()
             if "/annotation/" in n and n.lower().endswith(".xml")
             and "/calibration/" not in n.lower()
+            # Exclude RFI (radio frequency interference) report files --
+            # confirmed real, present in Sentinel-1 products since IPF
+            # 3.40, living in this same annotation tree. Their filenames
+            # are prefixed "rfi-" (not the satellite-platform prefix
+            # "s1a-"/"s1b-" real per-swath annotation files use), and
+            # critically can ALSO contain "-slc-" for SLC products
+            # (confirmed by testing: an earlier "-slc-" based filter was
+            # insufficient for exactly this reason), so the prefix is
+            # the only reliable differentiator, not substring content.
+            and not Path(n).name.lower().startswith("rfi-")
+            and "/rfi/" not in n.lower()
         ]
         if member_hint:
             filtered = [n for n in candidates if member_hint.lower() in n.lower()]
@@ -142,7 +166,14 @@ def parse_slc_geometry(
             get_text(".//generalAnnotation/productInformation/rangeSamplingRate")
         ),
         n_lines=int(get_text(".//imageAnnotation/imageInformation/numberOfLines")),
-        n_columns=int(get_text(".//imageAnnotation/imageInformation/numberOfColumns")),
+        # Real field name confirmed against ESA's own Product
+        # Specification (MPC-0240): "Renamed numberOfRangeSamples to
+        # numberOfSamples". "numberOfColumns" was never a real field in
+        # this schema at all -- an incorrect assumption in earlier
+        # research here, caught only against real Sentinel-1 data,
+        # since the synthetic tests built on that same assumption
+        # couldn't have caught their own premise being wrong.
+        n_columns=int(get_text(".//imageAnnotation/imageInformation/numberOfSamples")),
     )
 
     logger.info(
@@ -150,4 +181,4 @@ def parse_slc_geometry(
         Path(safe_zip_path).name, geometry.n_lines, geometry.n_columns,
         geometry.first_line_time,
     )
-    return geometry
+    return geometry

{pygeofetch-1.9.0 → pygeofetch-1.9.2}/pygeofetch/insar/atmosphere.py

@@ -74,6 +74,7 @@ class AtmosphericCorrector:
         dem: Union[str, Path],
         acquisition_datetime: Optional[str] = None,
         incidence_angle_deg: float = 38.0,
+        return_metadata: bool = False,
     ) -> Any:
         """
         Remove the tropospheric delay component from wrapped or unwrapped phase.
@@ -88,15 +89,33 @@ class AtmosphericCorrector:
             incidence_angle_deg:   Radar incidence angle for LOS projection
                                   of zenith delay (Sentinel-1 IW ≈ 30-46°,
                                   default 38° is the mid-swath average).
+            return_metadata:       If True, returns (phase, metadata) instead
+                                  of just phase. metadata includes
+                                  "correction_applied" (bool) and, for the
+                                  elevation method, "r_squared" (float) --
+                                  this is the only reliable way to know
+                                  whether a correction actually happened,
+                                  since the elevation method's internal R²
+                                  gate can legitimately skip correction
+                                  (returning the input unchanged) without
+                                  raising or otherwise signalling that in
+                                  the plain return value. Default False
+                                  preserves the original return type for
+                                  existing callers.
 
         Returns:
-            Corrected phase array, same shape and units as input.
+            Corrected phase array, same shape and units as input (or a
+            (phase, metadata) tuple if return_metadata=True).
         """
         if self._method == "era5":
-            return self._correct_era5(
+            result = self._correct_era5(
                 phase, dem, acquisition_datetime, incidence_angle_deg
             )
-        return self._correct_elevation(phase, dem)
+            metadata = {"correction_applied": True}
+        else:
+            result, metadata = self._correct_elevation(phase, dem)
+
+        return (result, metadata) if return_metadata else result
 
     # ── native elevation-correlated correction ────────────────────────────────
 
@@ -121,6 +140,12 @@ class AtmosphericCorrector:
         the phase variance (R² > 0.5); otherwise it is skipped and logged,
         since removing a low-confidence trend risks deleting real
         deformation signal rather than atmospheric noise.
+
+        Returns:
+            (phase_or_corrected, metadata) -- metadata always includes
+            "correction_applied" (bool) and, whenever the R² gate was
+            actually evaluated, "r_squared" (float), so callers can tell
+            a genuine correction apart from a same-shaped pass-through.
         """
         np = self._np()
         try:
@@ -145,7 +170,7 @@ class AtmosphericCorrector:
             logger.warning(
                 "Insufficient valid pixels for elevation correction — returning uncorrected"
             )
-            return phase
+            return phase, {"correction_applied": False, "reason": "insufficient_valid_pixels"}
 
         dem_v = dem_data[valid]
         phase_v = phase[valid]
@@ -164,7 +189,7 @@ class AtmosphericCorrector:
                 "correction to avoid absorbing real deformation signal.",
                 r_squared,
             )
-            return phase
+            return phase, {"correction_applied": False, "r_squared": float(r_squared)}
 
         tropo_phase = slope_rad_per_m * dem_data
         corrected = phase - tropo_phase
@@ -174,7 +199,7 @@ class AtmosphericCorrector:
             slope_rad_per_m,
             int(valid.sum()),
         )
-        return corrected.astype(np.float32)
+        return corrected.astype(np.float32), {"correction_applied": True, "r_squared": float(r_squared)}
 
     # ── ERA5/PyAPS-based correction ───────────────────────────────────────────
 
@@ -280,4 +305,4 @@ class AtmosphericCorrector:
     def _np(self):
         import numpy as np
 
-        return np
+        return np

{pygeofetch-1.9.0 → pygeofetch-1.9.2}/pygeofetch/insar/coregister.py

@@ -21,11 +21,49 @@ from __future__ import annotations
 
 import logging
 from pathlib import Path
-from typing import Tuple, Union
+from typing import Optional, Tuple, Union
 
 logger = logging.getLogger("pygeofetch.insar.coregister")
 
 
+def read_matched_swath(path: Union[str, Path]) -> Optional[str]:
+    """
+    Read back the matched sub-swath label (e.g. "iw3") recorded by
+    SLCExtractor.extract_scene(). Returns None if not present, so
+    callers can fall back to parse_slc_geometry()'s default (arbitrary
+    first-match) behaviour rather than fail outright.
+    """
+    import rasterio
+
+    try:
+        with rasterio.open(path) as src:
+            return src.tags().get("matched_swath") or None
+    except Exception:
+        return None
+
+
+def read_crop_offset(path: Union[str, Path]) -> Tuple[float, float]:
+    """
+    Read back the crop offset recorded by SLCExtractor._crop_to_aoi() -
+    the local array's origin in the original, uncropped scene's pixel
+    coordinates. Returns (0.0, 0.0) if the file wasn't cropped (either
+    it's the raw fallback extraction, or a file this metadata predates),
+    which is the correct default: no crop means local and full-scene
+    coordinates are already the same thing.
+    """
+    import rasterio
+
+    try:
+        with rasterio.open(path) as src:
+            tags = src.tags()
+            return (
+                float(tags.get("crop_row_off", 0.0)),
+                float(tags.get("crop_col_off", 0.0)),
+            )
+    except Exception:
+        return (0.0, 0.0)
+
+
 def compute_offset_field_from_dem(
     ref_geometry,
     ref_orbit,
@@ -294,7 +332,11 @@ def fit_offset_polynomial(grid_rows, grid_cols, offsets, degree: int = 1):
     return evaluate
 
 
-def resample_with_offset_field(data, row_offset_fn, col_offset_fn):
+def resample_with_offset_field(
+    data, row_offset_fn, col_offset_fn,
+    ref_row_offset: float = 0.0, ref_col_offset: float = 0.0,
+    sec_row_offset: float = 0.0, sec_col_offset: float = 0.0,
+):
     """
     Resample a complex array using a real, per-pixel offset field
     (from fit_offset_polynomial), rather than a naive shape-only zoom.
@@ -303,7 +345,24 @@ def resample_with_offset_field(data, row_offset_fn, col_offset_fn):
         data:           Complex array to resample (the secondary SLC).
         row_offset_fn, col_offset_fn: Callables from fit_offset_polynomial(),
                        giving the real (secondary - reference) offset
-                       at any (row, col) in the reference grid.
+                       at any (row, col) expressed in REFERENCE
+                       full-scene coordinates (that's what
+                       compute_offset_field_from_dem() fits them on).
+        ref_row_offset, ref_col_offset: The reference array's origin in
+                       full-scene coordinates (from read_crop_offset()
+                       on the reference file, if cropped) -- needed to
+                       correctly evaluate the offset functions, since
+                       they were fit on full-scene coordinates, not the
+                       reference crop's local 0-based ones.
+        sec_row_offset, sec_col_offset: The secondary array's (this
+                       function's `data`) origin in full-scene
+                       coordinates -- needed to convert the computed
+                       full-scene secondary sample position back into
+                       `data`'s own local coordinates for indexing,
+                       since the secondary crop can have a different
+                       offset than the reference crop.
+                       All four default to 0 for already-full-scene
+                       (uncropped) data.
 
     Returns:
         The resampled complex array, on the reference image's grid.
@@ -314,8 +373,26 @@ def resample_with_offset_field(data, row_offset_fn, col_offset_fn):
     h, w = data.shape
     row_idx, col_idx = np.mgrid[0:h, 0:w].astype(np.float64)
 
-    sample_rows = row_idx + row_offset_fn(row_idx, col_idx)
-    sample_cols = col_idx + col_offset_fn(row_idx, col_idx)
+    # row_idx/col_idx are the reference grid's local (0-based) coordinates.
+    # Convert to full-scene coordinates to correctly evaluate the fitted
+    # offset functions, which were built on real annotation-derived
+    # full-scene coordinates, not any particular crop's local ones.
+    ref_global_row = row_idx + ref_row_offset
+    ref_global_col = col_idx + ref_col_offset
+
+    offset_row = row_offset_fn(ref_global_row, ref_global_col)
+    offset_col = col_offset_fn(ref_global_row, ref_global_col)
+
+    # Where this pixel's secondary counterpart is, in full-scene coordinates
+    sec_global_row = ref_global_row + offset_row
+    sec_global_col = ref_global_col + offset_col
+
+    # Convert to the SECONDARY array's own local coordinates for actually
+    # indexing into `data` -- the secondary crop can have a different
+    # offset than the reference crop, so this is not the same subtraction
+    # as ref_row_offset/ref_col_offset above.
+    sample_rows = sec_global_row - sec_row_offset
+    sample_cols = sec_global_col - sec_col_offset
 
     real = map_coordinates(data.real, [sample_rows, sample_cols], order=1, mode="constant", cval=0.0)
     imag = map_coordinates(data.imag, [sample_rows, sample_cols], order=1, mode="constant", cval=0.0)
@@ -336,4 +413,4 @@ def _linspace(start, stop, n):
     if n == 1:
         return [start]
     step = (stop - start) / (n - 1)
-    return [start + i * step for i in range(n)]
+    return [start + i * step for i in range(n)]

{pygeofetch-1.9.0 → pygeofetch-1.9.2}/pygeofetch/insar/extraction.py

@@ -189,15 +189,193 @@ class SLCExtractor:
             else output_dir / f"{zip_path.stem}_{self._pol}.tif"
         )
 
-        with zipfile.ZipFile(zip_path) as zf:
-            with zf.open(matched_member) as src_f, open(out_path, "wb") as dst_f:
-                dst_f.write(src_f.read())
+        cropped = self._crop_to_aoi(zip_path, matched_member, aoi_tuple, out_path)
+        if cropped is None:
+            logger.warning(
+                "Cropping %s to AOI failed — falling back to extracting the "
+                "full, uncropped sub-swath (this will be much larger and "
+                "slower for everything downstream).",
+                self._swath_label(matched_member),
+            )
+            with zipfile.ZipFile(zip_path) as zf:
+                with zf.open(matched_member) as src_f, open(out_path, "wb") as dst_f:
+                    dst_f.write(src_f.read())
+            self._tag_matched_swath(out_path, matched_member)
 
         logger.info(
             "Extracted %s -> %s", self._swath_label(matched_member), out_path.name
         )
         return out_path
 
+    def _tag_matched_swath(self, out_path: Path, member_name: str) -> None:
+        """Tag an already-written GeoTIFF with its matched sub-swath label,
+        for the fallback (raw-copy) extraction path, which doesn't go
+        through rasterio for its initial write the way _crop_to_aoi()
+        does. Failure here is non-fatal -- the file itself is still
+        correct, just missing this one piece of discoverable metadata,
+        so downstream code falls back to arbitrary-first-match behaviour
+        rather than losing the extraction entirely."""
+        try:
+            import rasterio
+
+            with rasterio.open(out_path, "r+") as dst:
+                dst.update_tags(matched_swath=self._swath_label(member_name).lower())
+        except Exception as exc:
+            logger.warning(
+                "Could not tag %s with its matched sub-swath: %s", out_path.name, exc
+            )
+
+    def _crop_to_aoi(
+        self,
+        zip_path: Path,
+        member_name: str,
+        aoi_tuple: Tuple[float, float, float, float],
+        out_path: Path,
+        margin_frac: float = 0.15,
+    ) -> Optional[Path]:
+        """
+        Crop a zipped Sentinel-1 measurement TIFF to the AOI, reading
+        directly from inside the zip (no full-file extraction) and
+        writing only the windowed AOI region.
+
+        Sentinel-1 SLC TIFFs are GCP-georeferenced, not a simple affine
+        transform, so an exact pixel window can't be computed directly.
+        This fits an approximate affine transform from the real embedded
+        GCPs (rasterio.transform.from_gcps — the standard technique for
+        this), then adds a safety margin around the computed window to
+        protect against that approximation's error rather than risk
+        cutting off the real AOI.
+
+        Args:
+            margin_frac: Fractional padding added to the computed window
+                       on each side (0.15 = 15%) — generous on purpose,
+                       since padding too much only costs a little extra
+                       size, while padding too little risks silently
+                       losing part of the real area of interest.
+
+        Returns:
+            out_path on success, None if cropping wasn't possible for
+            any reason (missing GCPs, unreadable TIFF, degenerate
+            transform) — callers should fall back to full extraction
+            rather than fail outright.
+        """
+        import rasterio
+        from rasterio.transform import from_gcps
+        from rasterio.windows import Window
+        from rasterio.crs import CRS
+
+        vsi_path = f"/vsizip/{zip_path}/{member_name}"
+        try:
+            with rasterio.open(vsi_path) as src:
+                gcps, _gcp_crs = src.gcps
+                if not gcps or len(gcps) < 4:
+                    logger.warning(
+                        "%s: too few GCPs (%d) to fit a reliable crop transform",
+                        member_name, len(gcps) if gcps else 0,
+                    )
+                    return None
+
+                approx_transform = from_gcps(gcps)
+
+                min_lon, min_lat, max_lon, max_lat = aoi_tuple
+                # Inverse-transform all 4 AOI corners and take the bounding
+                # box of the results, rather than rasterio.windows.from_bounds()
+                # -- that function assumes a standard north-up transform
+                # (row increases as latitude decreases) and raises "Bounds
+                # and transform are inconsistent" when it doesn't, which is
+                # exactly the orientation real ascending-pass Sentinel-1
+                # data has (confirmed directly against real product
+                # footprints). This corner-based approach makes no
+                # assumption about orientation at all.
+                inv_transform = ~approx_transform
+                corners = [
+                    (min_lon, min_lat), (min_lon, max_lat),
+                    (max_lon, min_lat), (max_lon, max_lat),
+                ]
+                cols, rows = [], []
+                for lon, lat in corners:
+                    col, row = inv_transform * (lon, lat)
+                    cols.append(col)
+                    rows.append(row)
+                window = Window(
+                    col_off=min(cols), row_off=min(rows),
+                    width=max(cols) - min(cols), height=max(rows) - min(rows),
+                )
+
+                # Safety margin: the GCP-fitted transform is only an
+                # approximation, so pad the window generously rather than
+                # risk cropping out part of the real AOI.
+                pad_w = max(window.width * margin_frac, 50)
+                pad_h = max(window.height * margin_frac, 50)
+                col_off = window.col_off - pad_w
+                row_off = window.row_off - pad_h
+                width = window.width + 2 * pad_w
+                height = window.height + 2 * pad_h
+
+                # Clamp to the actual raster extent -- the padded window
+                # can legitimately extend past the real data bounds.
+                col_off_clamped = max(0, col_off)
+                row_off_clamped = max(0, row_off)
+                width_clamped = min(width - (col_off_clamped - col_off), src.width - col_off_clamped)
+                height_clamped = min(height - (row_off_clamped - row_off), src.height - row_off_clamped)
+
+                if width_clamped <= 0 or height_clamped <= 0:
+                    logger.warning(
+                        "%s: computed crop window falls entirely outside the "
+                        "raster bounds -- GCP transform may be unreliable",
+                        member_name,
+                    )
+                    return None
+
+                read_window = Window(
+                    col_off_clamped, row_off_clamped, width_clamped, height_clamped
+                )
+                data = src.read(1, window=read_window)
+
+                if data.size == 0:
+                    return None
+
+                # Real, locally-accurate transform for the cropped region,
+                # derived from the same GCP-fit transform used to locate it.
+                crop_transform = rasterio.windows.transform(read_window, approx_transform)
+
+                out_path.parent.mkdir(parents=True, exist_ok=True)
+                with rasterio.open(
+                    out_path, "w", driver="GTiff",
+                    dtype=data.dtype, count=1,
+                    width=data.shape[1], height=data.shape[0],
+                    crs=CRS.from_epsg(4326), transform=crop_transform,
+                    compress="deflate",
+                ) as dst:
+                    dst.write(data, 1)
+                    # Record the crop's origin in the FULL, UNCROPPED
+                    # scene's pixel coordinates. Real orbit-based
+                    # coregistration computes offset fields using
+                    # annotation.py's real acquisition timing, which
+                    # describes the full, uncropped sub-swath -- without
+                    # this offset recorded, downstream code has no way to
+                    # know that local row/col 0,0 in this cropped file is
+                    # actually row/col crop_row_off,crop_col_off in the
+                    # scene the orbit math is expressed in, and would
+                    # silently evaluate the fitted offset polynomial at
+                    # the wrong coordinates.
+                    dst.update_tags(
+                        crop_row_off=str(row_off_clamped),
+                        crop_col_off=str(col_off_clamped),
+                        matched_swath=self._swath_label(member_name).lower(),
+                    )
+
+                logger.info(
+                    "Cropped %s: %dx%d -> %dx%d (%.1fx smaller)",
+                    self._swath_label(member_name), src.width, src.height,
+                    data.shape[1], data.shape[0],
+                    (src.width * src.height) / max(data.size, 1),
+                )
+                return out_path
+        except Exception as exc:
+            logger.warning("Could not crop %s to AOI: %s", member_name, exc)
+            return None
+
     def list_subswaths(self, zip_path: Union[str, Path]) -> List[str]:
         """
         List the measurement TIFF entries for the configured polarisation
@@ -295,4 +473,4 @@ class SLCExtractor:
         for swath in ("iw1", "iw2", "iw3", "ew1", "ew2", "ew3", "ew4", "ew5"):
             if swath in lower:
                 return swath.upper()
-        return "?"
+        return "?"