pygeofetch 2.0.0__tar.gz → 2.0.2__tar.gz

{pygeofetch-2.0.0 → pygeofetch-2.0.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/2.0.0/).
+Format follows [Keep a Changelog](https://keepachangelog.com/en/2.0.2/).
 
-## [2.0.0] — 2026-07-29
+## [2.0.2] — 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/2.0.0/).
 
 ### Migration Guide
 ```python
-# Before (v2.0.0)
+# Before (v2.0.2)
 unwrapper = PhaseUnwrapper(cost_mode="defo", init_method="mcf")
 unwrapped = unwrapper.unwrap(phase, coherence, nlooks=2.0)
 
@@ -72,7 +72,7 @@ unwrapped = unwrapper.unwrap(
 
 ---
 
-## [2.0.0] — 2026-07-12
+## [2.0.2] — 2026-07-12
 
 ### Added
 - Federated search across 22+ satellite data providers
@@ -188,8 +188,8 @@ unwrapped = unwrapper.unwrap(
 
 | Version | Date | Key Changes |
 |---------|------------|-------------|
-| **2.0.0** | 2026-07-29 | SNAPHU unwrapping fixes, 87.1% reliable pixels |
-| **2.0.0** | 2026-07-12 | 22 providers, 17 indices, Sentinel-1C/D |
+| **2.0.2** | 2026-07-29 | SNAPHU unwrapping fixes, 87.1% reliable pixels |
+| **2.0.2** | 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-2.0.0/pygeofetch.egg-info → pygeofetch-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 2.0.0
+Version: 2.0.2
 Summary: Universal satellite data pipeline + geospatial processing platform
 Author-email: Samuel Appiah Kubi <appiahkubis14@gmail.com>
 License: MIT License
@@ -85,7 +85,7 @@ Requires-Dist: localtileserver>=1.0.0; extra == "viz"
 Requires-Dist: ipysheet>=0.6.0; extra == "viz"
 Requires-Dist: ipyleaflet>=0.17.0; extra == "viz"
 Requires-Dist: ipywidgets>=8.0.0; extra == "viz"
-Requires-Dist: ipyevents>=2.0.0; extra == "viz"
+Requires-Dist: ipyevents>=2.0.2; extra == "viz"
 Requires-Dist: ipyfilechooser>=0.6.0; extra == "viz"
 Requires-Dist: sidecar>=0.6.0; extra == "viz"
 Requires-Dist: bokeh>=3.0.0; extra == "viz"

{pygeofetch-2.0.0 → pygeofetch-2.0.2}/pygeofetch/__init__.py

@@ -1,5 +1,5 @@
 """
-PyGeoFetch v2.0.0 — Universal Satellite Data Pipeline.
+PyGeoFetch v2.0.2 — 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__ = "2.0.0"
+__version__ = "2.0.2"
 __author__ = "PyGeoFetch Contributors"
 __license__ = "MIT"
 

{pygeofetch-2.0.0 → pygeofetch-2.0.2}/pygeofetch/cli/main.py

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

{pygeofetch-2.0.0 → pygeofetch-2.0.2}/pygeofetch/insar/__init__.py

@@ -158,4 +158,5 @@ __all__ = [
     "collocate_by_geocoding",
     "CoregistrationQuality",
     "select_consistent_geometry",
+    
 ]

{pygeofetch-2.0.0 → pygeofetch-2.0.2}/pygeofetch/insar/coregister.py

@@ -665,23 +665,67 @@ def _sample_complex_imagette(data, center_row: float, center_col: float, size: i
     return (real + 1j * imag).astype(np.complex64)
 
 
-def _imagette_coherence(ref_imagette, sec_imagette) -> float:
+# def _imagette_coherence(ref_imagette, sec_imagette) -> float:
+#     """
+#     Single scalar complex coherence between two same-shape imagettes —
+#     SNAP CrossCorrelationOp's "Method 1" (no internal sliding window;
+#     the whole imagette is treated as one coherence estimation window):
+#     https://step.esa.int/main/wp-content/help/versions/13.0.0/snap-toolboxes/eu.esa.microwavetbx.sar.op.insar.ui/operators/CrossCorrelationOp.html
+#     """
+#     import numpy as np
+
+#     num = abs(np.mean(ref_imagette * np.conj(sec_imagette)))
+#     denom = np.sqrt(
+#         np.mean(np.abs(ref_imagette) ** 2) * np.mean(np.abs(sec_imagette) ** 2)
+#     )
+#     if denom < 1e-12:
+#         return 0.0
+#     return float(np.clip(num / denom, 0.0, 1.0))
+
+
+# def _imagette_coherence(ref_imagette, sec_imagette) -> float:
+
+#     import numpy as np
+
+#     num = abs(np.mean(ref_imagette * np.conj(sec_imagette)))
+#     denom = np.sqrt(np.mean(np.abs(ref_imagette) ** 2) * np.mean(np.abs(sec_imagette) ** 2))
+#     if denom < 1e-12:
+#         return 0.0
+#     return float(np.clip(num / denom, 0.0, 1.0))
+
+def _imagette_coherence(ref_imagette, sec_imagette, window_size: int = 5) -> float:
     """
-    Single scalar complex coherence between two same-shape imagettes —
-    SNAP CrossCorrelationOp's "Method 1" (no internal sliding window;
-    the whole imagette is treated as one coherence estimation window):
-    https://step.esa.int/main/wp-content/help/versions/13.0.0/snap-toolboxes/eu.esa.microwavetbx.sar.op.insar.ui/operators/CrossCorrelationOp.html
+    Calculate coherence using windowed averaging (standard ESD approach).
+    
+    Args:
+        ref_imagette: Reference imagette (complex array)
+        sec_imagette: Secondary imagette (complex array)
+        window_size: Window size for coherence calculation (default: 5)
+    
+    Returns:
+        Average coherence value
     """
     import numpy as np
-
-    num = abs(np.mean(ref_imagette * np.conj(sec_imagette)))
-    denom = np.sqrt(
-        np.mean(np.abs(ref_imagette) ** 2) * np.mean(np.abs(sec_imagette) ** 2)
-    )
-    if denom < 1e-12:
-        return 0.0
-    return float(np.clip(num / denom, 0.0, 1.0))
-
+    from scipy.ndimage import uniform_filter
+    
+    # Calculate complex cross-correlation
+    cross_corr = ref_imagette * np.conj(sec_imagette)
+    
+    # Calculate windowed averages
+    num_real = uniform_filter(cross_corr.real, size=window_size)
+    num_imag = uniform_filter(cross_corr.imag, size=window_size)
+    num = np.sqrt(num_real**2 + num_imag**2)
+    
+    denom_ref = uniform_filter(np.abs(ref_imagette)**2, size=window_size)
+    denom_sec = uniform_filter(np.abs(sec_imagette)**2, size=window_size)
+    denom = np.sqrt(denom_ref * denom_sec)
+    
+    # Calculate coherence
+    coherence = np.where(denom > 1e-12, num / denom, 0.0)
+    coherence = np.clip(coherence, 0.0, 1.0)
+    
+    # Return average coherence
+    return float(np.mean(coherence))
 
 def refine_offsets_by_coherence(
     ref_complex,
@@ -1124,11 +1168,11 @@ def resample_with_offset_field(
     import numpy as np
     from scipy.ndimage import map_coordinates
 
-    h, w = data.shape
-    out_real = np.empty((h, w), dtype=np.float32)
-    out_imag = np.empty((h, w), dtype=np.float32)
-    data_real = data.real
-    data_imag = data.imag
+    # h, w = data.shape
+    # out_real = np.empty((h, w), dtype=np.float32)
+    # out_imag = np.empty((h, w), dtype=np.float32)
+    # data_real = data.real
+    # data_imag = data.imag
 
     # Process in row chunks rather than building ~10 full-resolution
     # float64 intermediate arrays (row_idx, col_idx, ref_global_row/col,
@@ -1142,41 +1186,85 @@ def resample_with_offset_field(
     # more than sufficient precision for sub-pixel offset resampling and
     # halves the footprint on its own; chunking bounds peak memory to
     # one row-block regardless of total crop size.
-    chunk_rows = max(1, min(h, 2000))
-    for row_start in range(0, h, chunk_rows):
-        row_end = min(row_start + chunk_rows, h)
-        row_idx, col_idx = np.mgrid[row_start:row_end, 0:w].astype(np.float32)
-
-        # 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
-
-        out_real[row_start:row_end] = map_coordinates(
-            data_real, [sample_rows, sample_cols], order=1, mode="constant", cval=0.0
-        )
-        out_imag[row_start:row_end] = map_coordinates(
-            data_imag, [sample_rows, sample_cols], order=1, mode="constant", cval=0.0
-        )
+
+        
+    h, w = data.shape
+    out_real = np.empty((h, w), dtype=np.float32)
+    out_imag = np.empty((h, w), dtype=np.float32)
+    data_real = data.real
+    data_imag = data.imag
+
+    # Process in 2D tiles for cache locality and strict memory bounding
+    tile_h, tile_w = 1024, 1024 
+    
+    for r_start in range(0, h, tile_h):
+        r_end = min(r_start + tile_h, h)
+        for c_start in range(0, w, tile_w):
+            c_end = min(c_start + tile_w, w)
+            
+            # Use ogrid to create broadcastable 1D arrays instead of full 2D mgrid matrices
+            row_idx = np.arange(r_start, r_end, dtype=np.float32)[:, None]
+            col_idx = np.arange(c_start, c_end, dtype=np.float32)[None, :]
+            
+            ref_global_row = row_idx + ref_row_offset
+            ref_global_col = col_idx + ref_col_offset
+            
+            # Evaluate polynomial (broadcasts automatically, minimal memory)
+            offset_row = row_offset_fn(ref_global_row, ref_global_col)
+            offset_col = col_offset_fn(ref_global_row, ref_global_col)
+            
+            sample_rows = ref_global_row + offset_row - sec_row_offset
+            sample_cols = ref_global_col + offset_col - sec_col_offset
+            
+            # Broadcast to 2D for map_coordinates
+            sample_rows_2d = np.broadcast_to(sample_rows, (r_end - r_start, c_end - c_start))
+            sample_cols_2d = np.broadcast_to(sample_cols, (r_end - r_start, c_end - c_start))
+            
+            out_real[r_start:r_end, c_start:c_end] = map_coordinates(
+                data_real, [sample_rows_2d, sample_cols_2d], order=1, mode="constant", cval=0.0
+            )
+            out_imag[r_start:r_end, c_start:c_end] = map_coordinates(
+                data_imag, [sample_rows_2d, sample_cols_2d], order=1, mode="constant", cval=0.0
+            )
+            
+            del sample_rows_2d, sample_cols_2d, offset_row, offset_col
 
     return (out_real + 1j * out_imag).astype(np.complex64)
+    # chunk_rows = max(1, min(h, 2000))
+    # for row_start in range(0, h, chunk_rows):
+    #     row_end = min(row_start + chunk_rows, h)
+    #     row_idx, col_idx = np.mgrid[row_start:row_end, 0:w].astype(np.float32)
+
+    #     # 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
+
+    #     out_real[row_start:row_end] = map_coordinates(
+    #         data_real, [sample_rows, sample_cols], order=1, mode="constant", cval=0.0
+    #     )
+    #     out_imag[row_start:row_end] = map_coordinates(
+    #         data_imag, [sample_rows, sample_cols], order=1, mode="constant", cval=0.0
+    #     )
+
+    # return (out_real + 1j * out_imag).astype(np.complex64)
 
 
 def _interpolate(orbit, t):

{pygeofetch-2.0.0 → pygeofetch-2.0.2}/pygeofetch/insar/deburst.py

@@ -3,32 +3,27 @@ TOPS deburst — remove real burst-boundary overlap/redundancy, matching
 SNAP's own S-1 TOPS Deburst operator.
 
 Algorithm confirmed directly against ESA's own STEP documentation for
-TOPSARDeburstOp (step.esa.int/main/wp-content/help/.../TOPSARDeburstOp.html),
-not inferred or guessed:
-
-    "In the azimuth direction, bursts are merged according to their
-    zero Doppler time... The merge time is determined by the average
-    of the last line of the first burst and the first line of the next
-    burst. For each range cell, the merging time is quantised to the
-    nearest output azimuth cell."
+TOPSARDeburstOp:
+"In the azimuth direction, bursts are merged according to their
+zero Doppler time... The merge time is determined by the average
+of the last line of the first burst and the first line of the next
+burst. For each range cell, the merging time is quantised to the
+nearest output azimuth cell."
 
 Why this matters: without deburst, adjacent bursts' real overlap
 regions both remain in the data, and the SAME ground area gets imaged
 twice by two different (radiometrically and phase-wise inconsistent)
-parts of the antenna beam pattern -- this is a real, confirmed source
-of visible striping and degraded coherence at burst boundaries, and it
-was never being corrected anywhere in this pipeline before this module
-(pygeofetch's own existing ESD refinement docstring already admits this
-directly: "has no effect on already-deburst/stripmap data" -- data
-passed through it was never actually deburst).
+parts of the antenna beam pattern — this is a real, confirmed source
+of visible striping and degraded coherence at burst boundaries.
 """
-
 from __future__ import annotations
 
 import logging
 from datetime import timedelta
 from typing import List, Tuple
 
+import numpy as np
+
 from pygeofetch.insar.annotation import SwathTiming
 
 logger = logging.getLogger("pygeofetch.insar.deburst")
@@ -41,23 +36,9 @@ def compute_burst_row_ranges(
     Compute each burst's real, kept (non-overlapping) row range, in
     that burst's own local 0-indexed row coordinates.
 
-    Verified before use: on a small, controlled synthetic case with
-    known burst timing, the computed ranges left no gaps and no
-    duplicate coverage, and their total length matched an
-    independently-computed expected total (span from the first burst's
-    start to the last burst's last line, at one line per
-    azimuth_time_interval_s) exactly.
-
     Args:
-        swath_timing:  Real burst metadata from
-                       annotation.parse_burst_info().
-        azimuth_time_interval_s: Real per-line time spacing, from the
-                       same annotation XML's SLCGeometry
-                       (imageAnnotation/imageInformation/azimuthTimeInterval)
-                       -- must be the SAME value used for both, since
-                       the cut-time calculation converts between the
-                       two bursts' local row coordinates via this
-                       shared spacing.
+        swath_timing: Real burst metadata from annotation.parse_burst_info().
+        azimuth_time_interval_s: Real per-line time spacing.
 
     Returns:
         List of (keep_start_row, keep_end_row) inclusive, local to
@@ -72,23 +53,26 @@ def compute_burst_row_ranges(
     if n == 1:
         return [(0, lines_per_burst - 1)]
 
-    # Real cut row, in each side's own local coordinates, for every
-    # adjacent burst pair
-    cut_in_prev = [None] * n  # cut row (local to burst i) ending burst i's kept range
-    cut_in_next = [None] * n  # cut row (local to burst i) starting burst i's kept range
+    # Real cut row, in each side's own local coordinates
+    cut_in_prev = [None] * n
+    cut_in_next = [None] * n
 
     for i in range(n - 1):
         burst_i_last_line_time = bursts[i].azimuth_time + timedelta(
             seconds=(lines_per_burst - 1) * azimuth_time_interval_s
         )
         burst_next_first_line_time = bursts[i + 1].azimuth_time
-        cut_time = burst_i_last_line_time + (burst_next_first_line_time - burst_i_last_line_time) / 2
+        cut_time = burst_i_last_line_time + (
+            burst_next_first_line_time - burst_i_last_line_time
+        ) / 2
 
         cut_row_in_i = round(
-            (cut_time - bursts[i].azimuth_time).total_seconds() / azimuth_time_interval_s
+            (cut_time - bursts[i].azimuth_time).total_seconds()
+            / azimuth_time_interval_s
         )
         cut_row_in_next = round(
-            (cut_time - bursts[i + 1].azimuth_time).total_seconds() / azimuth_time_interval_s
+            (cut_time - bursts[i + 1].azimuth_time).total_seconds()
+            / azimuth_time_interval_s
         )
 
         cut_in_prev[i] = cut_row_in_i
@@ -100,11 +84,10 @@ def compute_burst_row_ranges(
         keep_end = (lines_per_burst - 1) if i == n - 1 else cut_in_prev[i]
         keep_start = max(0, min(keep_start, lines_per_burst - 1))
         keep_end = max(0, min(keep_end, lines_per_burst - 1))
+
         if keep_start > keep_end:
             logger.warning(
-                "Burst %d: computed keep range is empty (start=%d > end=%d) "
-                "— unusually large real overlap or unusual burst timing; "
-                "this burst will contribute no rows to the debursted result.",
+                "Burst %d: computed keep range is empty (start=%d > end=%d)",
                 i, keep_start, keep_end,
             )
         ranges.append((keep_start, keep_end))
@@ -112,30 +95,27 @@ def compute_burst_row_ranges(
     return ranges
 
 
-def deburst_array(data, swath_timing: SwathTiming, azimuth_time_interval_s: float, row_offset: int = 0):
+def deburst_array(
+    data: np.ndarray,
+    swath_timing: SwathTiming,
+    azimuth_time_interval_s: float,
+    row_offset: int = 0,
+) -> Tuple[np.ndarray, int]:
     """
     Apply real deburst to an array: remove each burst's redundant
     overlap rows and concatenate the kept, non-overlapping portions
-    into one continuous array — matching SNAP's real behaviour (the
-    image genuinely shrinks; this is not a masking operation).
+    into one continuous array.
 
     Args:
-        data:          2D array (complex SLC, real-valued raster,
-                       whatever a caller needs debursted), full burst
-                       stack — n_bursts * lines_per_burst rows (or the
-                       real full-scene extent if row_offset is used).
-        swath_timing:  Real burst metadata from annotation.parse_burst_info().
+        data: 2D array (complex SLC, real-valued raster, etc.)
+        swath_timing: Real burst metadata from annotation.parse_burst_info().
         azimuth_time_interval_s: Real per-line time spacing.
-        row_offset:    If `data` is an already-cropped extract, the real
-                       row offset of `data`'s row 0 within the full-scene
-                       burst stack. Default 0 assumes `data` already starts
-                       at the full-scene burst stack's row 0.
+        row_offset: If `data` is an already-cropped extract, the real
+            row offset of `data`'s row 0 within the full-scene burst stack.
 
     Returns:
         (debursted_data, first_kept_full_scene_row)
     """
-    import numpy as np
-
     if not isinstance(swath_timing, SwathTiming):
         raise TypeError(
             f"deburst_array expects a SwathTiming object, got "
@@ -176,8 +156,10 @@ def deburst_array(data, swath_timing: SwathTiming, azimuth_time_interval_s: floa
         )
 
     debursted = np.concatenate(chunks, axis=0)
+
     logger.info(
         "Deburst: %d bursts -> %d output rows (input was %d rows)",
         len(swath_timing.bursts), debursted.shape[0], data.shape[0],
     )
-    return debursted, first_kept_full_scene_row
+
+    return debursted, first_kept_full_scene_row