PyGeoFetch 1.9.6__tar.gz → 1.9.7__tar.gz

{pygeofetch-1.9.6 → pygeofetch-1.9.7}/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.6/).
+Format follows [Keep a Changelog](https://keepachangelog.com/en/1.9.7/).
 
-## [1.9.6] — 2026-07-29
+## [1.9.7] — 2026-07-29
 
 ### Added
 - Major SNAPHU unwrapping improvements for urban InSAR applications
@@ -51,7 +51,7 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.9.6/).
 
 ### Migration Guide
 ```python
-# Before (v1.9.6)
+# Before (v1.9.7)
 unwrapper = PhaseUnwrapper(cost_mode="defo", init_method="mcf")
 unwrapped = unwrapper.unwrap(phase, coherence, nlooks=2.0)
 
@@ -72,7 +72,7 @@ unwrapped = unwrapper.unwrap(
 
 ---
 
-## [1.9.6] — 2026-07-12
+## [1.9.7] — 2026-07-12
 
 ### Added
 - Federated search across 22+ satellite data providers
@@ -188,8 +188,8 @@ unwrapped = unwrapper.unwrap(
 
 | Version | Date | Key Changes |
 |---------|------------|-------------|
-| **1.9.6** | 2026-07-29 | SNAPHU unwrapping fixes, 87.1% reliable pixels |
-| **1.9.6** | 2026-07-12 | 22 providers, 17 indices, Sentinel-1C/D |
+| **1.9.7** | 2026-07-29 | SNAPHU unwrapping fixes, 87.1% reliable pixels |
+| **1.9.7** | 2026-07-12 | 22 providers, 17 indices, Sentinel-1C/D |
 | **1.9.2** | 2026-06-15 | Batch processing, parallel downloads |
 | **1.9.1** | 2026-05-20 | 3D terrain, SNAPHU integration, time series |
 | **1.9.0** | 2026-04-25 | Initial public release |

{pygeofetch-1.9.6/pygeofetch.egg-info → pygeofetch-1.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 1.9.6
+Version: 1.9.7
 Summary: Universal satellite data pipeline + geospatial processing platform
 Author-email: Samuel Appiah Kubi <appiahkubis14@gmail.com>
 License: MIT License

{pygeofetch-1.9.6 → pygeofetch-1.9.7}/pygeofetch/__init__.py

@@ -1,5 +1,5 @@
 """
-PyGeoFetch v1.9.6 — Universal Satellite Data Pipeline.
+PyGeoFetch v1.9.7 — Universal Satellite Data Pipeline.
 
 Unified access to 22+ satellite data providers with a consistent
 Python API and CLI. Supports authentication management, federated search,
@@ -30,7 +30,7 @@ CLI::
     pygeofetch doctor
 """
 
-__version__ = "1.9.6"
+__version__ = "1.9.7"
 __author__ = "PyGeoFetch Contributors"
 __license__ = "MIT"
 

{pygeofetch-1.9.6 → pygeofetch-1.9.7}/pygeofetch/cli/main.py

@@ -1,5 +1,5 @@
 """
-PyGeoFetch CLI v1.9.6 main entry point.
+PyGeoFetch CLI v1.9.7 main entry point.
 
 Full command reference:
   pygeofetch auth       — credential management
@@ -71,7 +71,7 @@ def cli(
 ) -> None:
     """
     \b
-    PyGeoFetch v1.9.6 — Universal Satellite Data Pipeline
+    PyGeoFetch v1.9.7 — Universal Satellite Data Pipeline
     ===========================================================
     Unified access to 22+ satellite data providers.
 

{pygeofetch-1.9.6 → pygeofetch-1.9.7}/pygeofetch/insar/esd.py

@@ -172,6 +172,20 @@ def estimate_esd_shift_per_burst_overlap(
     overlaps = compute_overlap_row_ranges(swath_timing, azimuth_time_interval_s)
     lines_per_burst = swath_timing.lines_per_burst
     per_overlap_shifts: List[Optional[float]] = []
+    # Real, confirmed diagnostic gap fixed here: the two real, genuinely
+    # different reasons an overlap gets skipped (it fell entirely outside
+    # the given, possibly-cropped arrays -- an AOI/cropping issue -- vs.
+    # it was inside the arrays but below coherence_threshold -- a real
+    # decorrelation issue, e.g. vegetated/mountainous terrain) were
+    # previously indistinguishable from the outside: individual reasons
+    # were only logged at DEBUG level, and the final summary warning
+    # collapsed both into one "outside the given arrays, or were below
+    # coherence_threshold" message. That ambiguity is exactly what made
+    # it impossible to tell, from a normal INFO-level log, whether a
+    # given real run's ESD failure was fixable by widening the AOI or
+    # was a genuine reflection of the terrain -- tracked explicitly here
+    # instead of guessed at after the fact.
+    skip_reasons: List[str] = []
 
     for i, ((bw_start, bw_end), (fw_start, fw_end)) in enumerate(overlaps):
         bw_full_scene_start = i * lines_per_burst - row_offset + bw_start
@@ -184,11 +198,13 @@ def estimate_esd_shift_per_burst_overlap(
 
         if bw_clip_start >= bw_clip_end or fw_clip_start >= fw_clip_end:
             per_overlap_shifts.append(None)
+            skip_reasons.append("outside_array_bounds")
             continue  # this overlap falls entirely outside the real, given (possibly cropped) arrays
 
         n_common = min(bw_clip_end - bw_clip_start, fw_clip_end - fw_clip_start)
         if n_common < 1:
             per_overlap_shifts.append(None)
+            skip_reasons.append("outside_array_bounds")
             continue
 
         ref_bw = ref_complex[bw_clip_start:bw_clip_start + n_common]
@@ -256,19 +272,45 @@ def estimate_esd_shift_per_burst_overlap(
                 i, i + 1, 100 * valid.mean(), coherence_threshold,
             )
             per_overlap_shifts.append(None)
+            skip_reasons.append(f"low_coherence({100 * valid.mean():.0f}%)")
             continue
 
         double_diff = igram_fw * np.conj(igram_bw)
         mean_phase = np.angle(np.mean(double_diff[valid]))
         shift_s = mean_phase / (2 * np.pi * delta_f_ovl_hz)
         per_overlap_shifts.append(float(shift_s))
+        skip_reasons.append("used")
 
     valid_shifts = [s for s in per_overlap_shifts if s is not None]
     if not valid_shifts:
+        # Real, surfaced breakdown, not the previous ambiguous message --
+        # tells the caller directly whether every real overlap failed
+        # because none existed within the (possibly cropped) arrays at
+        # all (an AOI/cropping problem, fixable by widening the crop) or
+        # because they existed but were genuinely below the coherence
+        # threshold (a real decorrelation problem in the data itself,
+        # not fixable by widening anything).
+        n_outside = skip_reasons.count("outside_array_bounds")
+        n_low_coh = sum(1 for r in skip_reasons if r.startswith("low_coherence"))
         logger.warning(
             "Real per-burst-overlap ESD found no usable burst overlaps "
-            "(all fell outside the given arrays, or were below "
-            "coherence_threshold) — no shift estimate available."
+            "out of %d total: %d fell outside the given (possibly "
+            "cropped) arrays, %d were below coherence_threshold=%.2f. "
+            "%s",
+            len(overlaps), n_outside, n_low_coh, coherence_threshold,
+            (
+                "Every overlap fell outside the array -- try widening the "
+                "AOI/crop, since none were even tested for coherence."
+                if n_outside == len(overlaps) and len(overlaps) > 0
+                else (
+                    "Every real, in-bounds overlap was tested and found "
+                    "genuinely below the coherence threshold -- this "
+                    "reflects real decorrelation in the data, not "
+                    "something a larger AOI would fix."
+                    if n_low_coh == len(overlaps) and len(overlaps) > 0
+                    else "A mix of both -- see the per-overlap detail at DEBUG level."
+                )
+            ),
         )
         return None, per_overlap_shifts
 
@@ -279,4 +321,4 @@ def estimate_esd_shift_per_burst_overlap(
         len(valid_shifts), len(overlaps), combined_shift_s * 1000,
         combined_shift_s / azimuth_time_interval_s,
     )
-    return combined_shift_s, per_overlap_shifts
+    return combined_shift_s, per_overlap_shifts

{pygeofetch-1.9.6 → pygeofetch-1.9.7}/pygeofetch/insar/flatearth.py

@@ -178,6 +178,39 @@ def compute_flat_earth_phase(
                 n_out_of_bounds += 1
                 continue
 
+            # Real, confirmed gap fixed here: t_ref/ref_row/ref_col were
+            # already validated against the reference scene's real
+            # bounds above, but t_sec was never checked against the
+            # SECONDARY scene's real bounds at all -- find_zero_doppler_time
+            # has no built-in guarantee of converging to the zero-Doppler
+            # crossing nearest the initial guess specifically (only that
+            # it converges to *some* zero crossing), so nothing here was
+            # catching a secondary-orbit convergence result that fell
+            # outside this ground point's real, valid azimuth/range window
+            # for the secondary acquisition. An undetected error here
+            # would silently corrupt R_sec and, through it, every sample
+            # point's flat_phase and the polynomial fit fit across all of
+            # them -- a real, plausible explanation for this project's
+            # own observed flat-earth phase anomaly (values in the tens
+            # of millions of radians, physically equivalent to tens of
+            # km of spurious range error, for specific real pairs).
+            sec_row = sec_geometry.row_for_azimuth_time(t_sec)
+            range_sec_time = 2 * R_sec / 299792458.0
+            sec_col = sec_geometry.col_for_range_time(range_sec_time)
+
+            if not (0 <= sec_row < sec_geometry.n_lines and 0 <= sec_col < sec_geometry.n_columns):
+                n_out_of_bounds += 1
+                logger.debug(
+                    "Flat-earth phase: sample (%.4f, %.4f) rejected -- "
+                    "t_sec converged to a secondary-scene row/col "
+                    "(%.1f, %.1f) outside the real secondary SLC extent "
+                    "(%d lines x %d columns). This is the real, specific "
+                    "case the reference-only bounds check upstream could "
+                    "not catch.",
+                    lon, lat, sec_row, sec_col, sec_geometry.n_lines, sec_geometry.n_columns,
+                )
+                continue
+
             # Real, verified sign convention: interferogram phase =
             # phase(ref) - phase(sec), and SAR phase for a point at
             # range R is -(4*pi/lambda)*R, so
@@ -240,4 +273,4 @@ def compute_flat_earth_phase(
         len(grid_rows), polynomial_degree, dense_phase.min(), dense_phase.max(),
     )
 
-    return dense_phase.astype(np.float32)
+    return dense_phase.astype(np.float32)

{pygeofetch-1.9.6 → pygeofetch-1.9.7}/pygeofetch/insar/interferogram.py

@@ -391,11 +391,32 @@ class InterferogramGenerator:
 
             # Step 2: real deburst, applied to both images using each
             # date's own real burst metadata.
+            #
+            # Real, confirmed bug fixed here: by this point sec_complex has
+            # already been resampled onto the REFERENCE's real grid, either
+            # by _orbit_based_coregister (which explicitly fits and applies
+            # an offset field using both ref_row_off AND sec_row_off
+            # together, see resample_with_offset_field above) or by the
+            # shape-based _resample_to_reference fallback -- either way,
+            # sec_complex's row 0 now corresponds to the same real
+            # full-scene row as ref_complex's row 0, i.e. ref_row_off, not
+            # its own original, pre-coregistration sec_row_off. Passing
+            # the stale sec_row_off here fed deburst_array a coordinate
+            # system that no longer matched the array it was actually
+            # operating on, silently shifting which rows got cropped as
+            # "burst edge/overlap" for the secondary relative to where the
+            # real burst boundaries actually fell in the now-coregistered
+            # array -- corrupting the debursted secondary image used for
+            # every downstream step (interferogram formation, coherence,
+            # unwrapping), independent of and in addition to the separate
+            # per-burst-overlap ESD issue investigated above, which runs
+            # earlier, on the pre-deburst array, and was already using
+            # ref_row_off correctly for both images at that stage.
             ref_debursted, ref_first_kept_row = deburst_array(
                 ref_complex, ref_burst_info, azimuth_time_interval_s, row_offset=int(ref_row_off)
             )
             sec_debursted, _ = deburst_array(
-                sec_complex, sec_burst_info, azimuth_time_interval_s, row_offset=int(sec_row_off)
+                sec_complex, sec_burst_info, azimuth_time_interval_s, row_offset=int(ref_row_off)
             )
 
             # Real correctness fix, not optional: deburst can remove
@@ -549,6 +570,63 @@ class InterferogramGenerator:
         DataValidator.validate_slc(ref_complex, name="reference SLC").raise_if_invalid()
         DataValidator.validate_slc(sec_complex, name="secondary SLC").raise_if_invalid()
 
+        # Real, confirmed-relevant check added here: mismatched satellite
+        # platform (S1A vs S1B) or sub-swath (IW1/IW2/IW3) between the two
+        # real dates is a genuine, documented risk factor for this exact
+        # kind of pair -- confirmed directly against ESA's own S1TBX TOPS
+        # interferometry tutorial: sub-swaths are processed independently
+        # and must be explicitly merged (S-1 TOPS Merge) before combining
+        # data from different ones, and combining S1A/S1B "be aware the
+        # extents... can be shifted along-track and different bursts must
+        # be selected for the same area." Real, satellite platform is read
+        # directly from the .SAFE product's own real filename (its first
+        # three characters, "S1A" or "S1B", by Sentinel-1's own naming
+        # convention), and real sub-swath from the tag SLCExtractor itself
+        # already records at extraction time -- not guessed. This does not
+        # raise: pygeofetch's own coregistration and burst-aware processing
+        # can still run and may still produce a usable result, but a
+        # mismatch here is a real, direct, and previously silent
+        # contributor to degraded coregistration and failed per-burst-
+        # overlap ESD, worth surfacing loudly rather than only showing up
+        # later as an unexplained low coherence value.
+        if reference_safe_zip is not None and secondary_safe_zip is not None:
+            ref_platform = Path(reference_safe_zip).name[:3]
+            sec_platform = Path(secondary_safe_zip).name[:3]
+            if ref_platform != sec_platform:
+                logger.warning(
+                    "Reference (%s) and secondary (%s) scenes are from "
+                    "different Sentinel-1 satellites -- burst boundaries "
+                    "for the same real ground area are not guaranteed to "
+                    "align between S1A and S1B. This pair can still be "
+                    "processed, but expect degraded coregistration and "
+                    "possible per-burst-overlap ESD failure as a direct "
+                    "consequence, not a separate, unrelated issue.",
+                    ref_platform, sec_platform,
+                )
+
+            try:
+                from pygeofetch.insar.coregister import read_matched_swath
+
+                ref_swath = read_matched_swath(reference) if reference is not None else None
+                sec_swath = read_matched_swath(secondary) if secondary is not None else None
+                if ref_swath and sec_swath and ref_swath != sec_swath:
+                    logger.warning(
+                        "Reference (%s) and secondary (%s) scenes were "
+                        "extracted from different real sub-swaths -- per "
+                        "ESA's own TOPS documentation, sub-swaths are "
+                        "processed independently and require an explicit "
+                        "merge step before combining; without it, ESD "
+                        "and coregistration between these two dates are "
+                        "not expected to find a usable, shared burst "
+                        "structure. This pair can still be processed, "
+                        "but this mismatch is a real, direct, and "
+                        "previously silent explanation if ESD reports no "
+                        "usable overlaps for it.",
+                        ref_swath, sec_swath,
+                    )
+            except Exception:
+                pass  # real, best-effort check -- never block processing over it
+
         # Step 1: coregistration.
         real_coreg_inputs = (
             dem, reference_safe_zip, secondary_safe_zip,
@@ -1079,16 +1157,72 @@ class InterferogramGenerator:
             return interferogram, {"correction_applied": False, "reason": "rasterio_missing"}
 
         try:
+            interferogram_crs = profile.get("crs")
+            interferogram_transform = profile.get("transform")
+
             with rasterio.open(dem_path) as dem_src:
-                dem = dem_src.read(1).astype(np.float32)
-            if dem.shape != interferogram.shape:
-                from scipy.ndimage import zoom
+                if interferogram_crs is not None and interferogram_transform is not None:
+                    # Real, confirmed bug fixed here: the previous fallback
+                    # reprojected the DEM onto the interferogram's grid
+                    # using ONLY a shape ratio (scipy.ndimage.zoom), never
+                    # referencing the real, georeferenced profile/transform
+                    # this method receives as its own `profile` argument --
+                    # that only produces a correctly-aligned DEM if the DEM
+                    # and interferogram happen to cover exactly the same
+                    # real geographic extent, which this project's own AOI-
+                    # cropped, orbit-coregistered pipeline does not
+                    # guarantee (confirmed directly against this project's
+                    # own logs: reference/secondary crop offsets of several
+                    # thousand rows relative to each other). A shape-only
+                    # resample under that mismatch compares elevation at
+                    # the wrong real pixels to phase at the wrong real
+                    # pixels, which would show up as exactly the near-zero
+                    # or negative R^2 this project's own real runs
+                    # reported for every pair tested -- not necessarily
+                    # because there was little true topographic phase to
+                    # find, but because the regression was never actually
+                    # comparing elevation and phase at the same ground
+                    # location to begin with. Reproject properly using the
+                    # real CRS/transform on both sides instead.
+                    from rasterio.warp import reproject, Resampling
+
+                    dem = np.empty(interferogram.shape, dtype=np.float32)
+                    reproject(
+                        source=rasterio.band(dem_src, 1),
+                        destination=dem,
+                        src_transform=dem_src.transform,
+                        src_crs=dem_src.crs,
+                        dst_transform=interferogram_transform,
+                        dst_crs=interferogram_crs,
+                        resampling=Resampling.bilinear,
+                        src_nodata=dem_src.nodata,
+                        dst_nodata=np.nan,
+                    )
+                else:
+                    # Honest fallback: no real georeferencing available on
+                    # either side to reproject against, so approximate
+                    # alignment via shape ratio is the best available --
+                    # but this is a real, meaningfully weaker guarantee
+                    # than the georeferenced path above, and worth logging
+                    # as such rather than silently treating it the same.
+                    logger.warning(
+                        "No real CRS/transform available on the "
+                        "interferogram profile -- falling back to a "
+                        "shape-ratio DEM resample, which only aligns "
+                        "correctly if the DEM and interferogram already "
+                        "cover the exact same real geographic extent. "
+                        "Topographic phase removal R^2 may be unreliable "
+                        "as a result."
+                    )
+                    dem = dem_src.read(1).astype(np.float32)
+                    if dem.shape != interferogram.shape:
+                        from scipy.ndimage import zoom
 
-                zf = (
-                    interferogram.shape[0] / dem.shape[0],
-                    interferogram.shape[1] / dem.shape[1],
-                )
-                dem = zoom(dem, zf, order=1)
+                        zf = (
+                            interferogram.shape[0] / dem.shape[0],
+                            interferogram.shape[1] / dem.shape[1],
+                        )
+                        dem = zoom(dem, zf, order=1)
 
             valid = np.isfinite(dem) & (dem > -500)
             phase = np.angle(interferogram)

{pygeofetch-1.9.6 → pygeofetch-1.9.7}/pygeofetch/meta.yaml

@@ -1,4 +1,4 @@
-{% set version = "1.9.6" %}
+{% set version = "1.9.7" %}
 
 package:
   name: pygeofetch

{pygeofetch-1.9.6 → pygeofetch-1.9.7/pygeofetch.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 1.9.6
+Version: 1.9.7
 Summary: Universal satellite data pipeline + geospatial processing platform
 Author-email: Samuel Appiah Kubi <appiahkubis14@gmail.com>
 License: MIT License

{pygeofetch-1.9.6 → pygeofetch-1.9.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pygeofetch"
-version = "1.9.6"
+version = "1.9.7"
 description = "Universal satellite data pipeline + geospatial processing platform"
 readme = "README.md"
 license = { file = "LICENSE" }

{pygeofetch-1.9.6 → pygeofetch-1.9.7}/tests/test_flat_earth_phase.py

@@ -19,13 +19,12 @@ from pathlib import Path
 import numpy as np
 import pytest
 
-sys.path.insert(0, str(Path(__file__).parent))
-from test_insar_verified_components import _build_geometry  # noqa: E402
-
-from pygeofetch.insar.annotation import SLCGeometry  # noqa: E402
-from pygeofetch.insar.flatearth import compute_flat_earth_phase  # noqa: E402
-from pygeofetch.insar.geolocation import (  # noqa: E402
+from pygeofetch.insar.annotation import SLCGeometry
+from pygeofetch.insar.flatearth import compute_flat_earth_phase
+from pygeofetch.insar.geolocation import (
     SPEED_OF_LIGHT,
+    WGS84_A,
+    WGS84_B,
     geodetic_to_ecef,
     find_zero_doppler_time,
     interpolate_orbit_state,
@@ -34,6 +33,62 @@ from pygeofetch.insar.geolocation import (  # noqa: E402
 WAVELENGTH_M = 0.05546576
 
 
+# Real, confirmed fix here: this file previously imported _build_geometry
+# from a sibling test module (test_insar_verified_components) via a
+# runtime sys.path.insert() hack. That only worked when both files sat
+# together in the same directory -- a real, brittle assumption that broke
+# in any environment where this file is used standalone (as reported: the
+# sibling file genuinely does not exist there). Inlined below, verbatim,
+# so this file is fully self-contained and has no dependency on any
+# other test file existing.
+def _build_geometry(lat_deg, lon_deg, dem_h=0.0, incl_deg=98.18, ascending=True):
+    """Build a fully self-consistent, realistic satellite+ground-point test
+    geometry — real orbital velocity direction, exact zero-Doppler
+    projection."""
+    lat, lon = math.radians(lat_deg), math.radians(lon_deg)
+    e2 = 1 - ((WGS84_B + dem_h) ** 2 / (WGS84_A + dem_h) ** 2)
+    N = (WGS84_A + dem_h) / math.sqrt(1 - e2 * math.sin(lat) ** 2)
+    P_true = (
+        N * math.cos(lat) * math.cos(lon),
+        N * math.cos(lat) * math.sin(lon),
+        N * (1 - e2) * math.sin(lat),
+    )
+    altitude = 693000.0
+    normal = (
+        P_true[0] / (WGS84_A + dem_h) ** 2,
+        P_true[1] / (WGS84_A + dem_h) ** 2,
+        P_true[2] / (WGS84_B + dem_h) ** 2,
+    )
+    nmag = math.sqrt(sum(c**2 for c in normal))
+    normal = tuple(c / nmag for c in normal)
+    sat_pos = tuple(P_true[i] + normal[i] * altitude for i in range(3))
+
+    incl = math.radians(incl_deg)
+    sign = 1 if ascending else -1
+    plane_normal = (
+        sign * math.sin(incl) * math.sin(lon),
+        -sign * math.sin(incl) * math.cos(lon),
+        math.cos(incl),
+    )
+    pn_mag = math.sqrt(sum(c**2 for c in plane_normal))
+    plane_normal = tuple(c / pn_mag for c in plane_normal)
+    tangent = (
+        plane_normal[1] * normal[2] - plane_normal[2] * normal[1],
+        plane_normal[2] * normal[0] - plane_normal[0] * normal[2],
+        plane_normal[0] * normal[1] - plane_normal[1] * normal[0],
+    )
+    tmag = math.sqrt(sum(c**2 for c in tangent))
+    tangent = tuple(c / tmag for c in tangent)
+    sat_vel = tuple(c * 7500.0 for c in tangent)
+
+    d = sum(sat_vel[i] * (P_true[i] - sat_pos[i]) for i in range(3)) / sum(v**2 for v in sat_vel)
+    P_exact = tuple(P_true[i] - d * sat_vel[i] for i in range(3))
+    los = tuple(sat_pos[i] - P_exact[i] for i in range(3))
+    range_m = math.sqrt(sum(c**2 for c in los))
+    range_time_s = 2 * range_m / SPEED_OF_LIGHT
+    return sat_pos, sat_vel, range_time_s, P_exact
+
+
 def _orbit_series(center_pos, center_vel, center_time):
     times, positions, velocities = [], [], []
     for i in range(-60, 61):
@@ -59,7 +114,22 @@ def _build_fixture(n=200, b_perp=80.0):
         near_range_time_s=range_time_center - (n / 2) * (1 / 6.4e7), range_sampling_rate_hz=6.4e7,
         n_lines=n, n_columns=n,
     )
-    return ref_geom, ref_orbit, sec_orbit, t0_ref, t0_sec, n
+    # Real, confirmed test-fixture gap fixed here: the fixture previously
+    # only built ONE SLCGeometry and every caller passed it as BOTH
+    # ref_geometry and sec_geometry -- which never exercised the real,
+    # production scenario (interferogram.py always parses a genuinely
+    # separate sec_geom_fe from the secondary's own SAFE zip, anchored to
+    # the secondary's own real first_line_time, not the reference's).
+    # Reusing ref_geom for both meant t_sec (anchored ~12 real days after
+    # ref_geom's own first_line_time) was silently being evaluated
+    # against the WRONG scene's timing reference whenever a real
+    # secondary-bounds check was added -- exactly what surfaced this gap.
+    sec_geom = SLCGeometry(
+        first_line_time=t0_sec - timedelta(seconds=n / 2 * 0.002), azimuth_time_interval_s=0.002,
+        near_range_time_s=range_time_center - (n / 2) * (1 / 6.4e7), range_sampling_rate_hz=6.4e7,
+        n_lines=n, n_columns=n,
+    )
+    return ref_geom, sec_geom, ref_orbit, sec_orbit, t0_ref, t0_sec, n
 
 
 def test_range_difference_matches_textbook_approximation():
@@ -98,11 +168,11 @@ def test_matches_independent_direct_computation_at_a_real_point():
     """The module's polynomial-fit output at a specific pixel must
     match a completely independent, direct geometric computation at
     that same real point."""
-    ref_geom, ref_orbit, sec_orbit, t0_ref, t0_sec, n = _build_fixture()
+    ref_geom, sec_geom, ref_orbit, sec_orbit, t0_ref, t0_sec, n = _build_fixture()
     lon0, lat0 = -99.11, 19.34
 
     flat_phase = compute_flat_earth_phase(
-        ref_geom, ref_orbit, ref_geom, sec_orbit, t0_ref, t0_sec, (n, n), WAVELENGTH_M,
+        ref_geom, ref_orbit, sec_geom, sec_orbit, t0_ref, t0_sec, (n, n), WAVELENGTH_M,
         sample_bounds=(lon0, lat0, lon0 + 0.04, lat0 + 0.04), grid_points=7, polynomial_degree=2,
     )
 
@@ -129,11 +199,11 @@ def test_closed_loop_removal_through_complex_wrapped_pathway():
     a real, complex, wrapped interferogram alongside a known
     deformation signal, remove it, and confirm exact recovery of the
     true signal -- the same pathway process_pair() actually uses."""
-    ref_geom, ref_orbit, sec_orbit, t0_ref, t0_sec, n = _build_fixture()
+    ref_geom, sec_geom, ref_orbit, sec_orbit, t0_ref, t0_sec, n = _build_fixture()
     lon0, lat0 = -99.11, 19.34
 
     flat_phase = compute_flat_earth_phase(
-        ref_geom, ref_orbit, ref_geom, sec_orbit, t0_ref, t0_sec, (n, n), WAVELENGTH_M,
+        ref_geom, ref_orbit, sec_geom, sec_orbit, t0_ref, t0_sec, (n, n), WAVELENGTH_M,
         sample_bounds=(lon0, lat0, lon0 + 0.04, lat0 + 0.04), grid_points=7, polynomial_degree=2,
     )
 
@@ -155,8 +225,8 @@ def test_closed_loop_removal_through_complex_wrapped_pathway():
 
 
 def test_raises_with_neither_dem_nor_sample_bounds():
-    ref_geom, ref_orbit, sec_orbit, t0_ref, t0_sec, n = _build_fixture()
+    ref_geom, sec_geom, ref_orbit, sec_orbit, t0_ref, t0_sec, n = _build_fixture()
     with pytest.raises(ValueError):
         compute_flat_earth_phase(
-            ref_geom, ref_orbit, ref_geom, sec_orbit, t0_ref, t0_sec, (n, n), WAVELENGTH_M,
-        )
+            ref_geom, ref_orbit, sec_geom, sec_orbit, t0_ref, t0_sec, (n, n), WAVELENGTH_M,
+        )