PyGeoFetch 2.6.2.7__py3-none-any.whl → 2.6.2.9__py3-none-any.whl

pygeofetch/__init__.py

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

pygeofetch/cli/index_commands.py

@@ -50,22 +50,64 @@ def index() -> None:
     "--nir", required=True, type=click.Path(exists=True), help="NIR band (e.g. B08.tif)"
 )
 @click.option("--output", "-o", default=None)
-def ndvi_cmd(red, nir, output):
-    """NDVI — Normalized Difference Vegetation Index. Range: -1 to +1. Vegetation > 0.3."""
+@click.option(
+    "--chunked", is_flag=True,
+    help="Process in memory-safe tiles for large rasters (e.g. drone orthomosaics) that exceed available RAM or the 4GB GeoTIFF limit.",
+)
+@click.option("--tile-size", default=1024, show_default=True, type=int, help="Tile edge length in pixels when --chunked is set.")
+def ndvi_cmd(red, nir, output, chunked, tile_size):
+    """NDVI — Normalized Difference Vegetation Index. Range: -1 to +1. Vegetation > 0.3.
+
+    Pass the SAME path to --red and --nir to auto-detect both bands from
+    one merged multi-band image (e.g. a drone orthomosaic), using its
+    real, embedded band descriptions.
+    """
     e = _engine()
-    r = e.indices.ndvi(red=red, nir=nir, output=output)
+    r = e.indices.ndvi(red=red, nir=nir, output=output, chunked=chunked, tile_size=tile_size)
     _pr(r, "NDVI")
 
 
+@index.command("ndre")
+@click.option(
+    "--rededge", required=True, type=click.Path(exists=True), help="Red edge band"
+)
+@click.option(
+    "--nir", required=True, type=click.Path(exists=True), help="NIR band"
+)
+@click.option("--output", "-o", default=None)
+@click.option(
+    "--chunked", is_flag=True,
+    help="Process in memory-safe tiles for large rasters that exceed available RAM or the 4GB GeoTIFF limit.",
+)
+@click.option("--tile-size", default=1024, show_default=True, type=int, help="Tile edge length in pixels when --chunked is set.")
+def ndre_cmd(rededge, nir, output, chunked, tile_size):
+    """NDRE — Normalized Difference Red Edge Index. Range: -1 to +1.
+
+    Less prone to saturation than NDVI in dense canopy -- useful for
+    crop stress and chlorophyll monitoring from drone multispectral
+    sensors. Pass the SAME path to --rededge and --nir to auto-detect
+    both bands from one merged multi-band image.
+    """
+    e = _engine()
+    r = e.indices.ndre(rededge=rededge, nir=nir, output=output, chunked=chunked, tile_size=tile_size)
+    _pr(r, "NDRE")
+
+
 @index.command("evi")
 @click.option("--blue", required=True, type=click.Path(exists=True))
 @click.option("--red", required=True, type=click.Path(exists=True))
 @click.option("--nir", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def evi_cmd(blue, red, nir, output):
-    """EVI — Enhanced Vegetation Index. Better than NDVI in high-biomass areas."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+def evi_cmd(blue, red, nir, output, chunked, tile_size):
+    """EVI — Enhanced Vegetation Index. Better than NDVI in high-biomass areas.
+
+    Pass the SAME path to --blue, --red, and --nir to auto-detect all
+    three bands from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.evi(blue=blue, red=red, nir=nir, output=output)
+    r = e.indices.evi(blue=blue, red=red, nir=nir, output=output, chunked=chunked, tile_size=tile_size)
     _pr(r, "EVI")
 
 
@@ -74,10 +116,16 @@ def evi_cmd(blue, red, nir, output):
 @click.option("--nir", required=True, type=click.Path(exists=True))
 @click.option("--soil-l", default=0.5, show_default=True, type=float)
 @click.option("--output", "-o", default=None)
-def savi_cmd(red, nir, soil_l, output):
-    """SAVI — Soil Adjusted Vegetation Index. Reduces soil brightness influence."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+def savi_cmd(red, nir, soil_l, output, chunked, tile_size):
+    """SAVI — Soil Adjusted Vegetation Index. Reduces soil brightness influence.
+
+    Pass the SAME path to --red and --nir to auto-detect both bands
+    from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.savi(red=red, nir=nir, L=soil_l, output=output)
+    r = e.indices.savi(red=red, nir=nir, L=soil_l, output=output, chunked=chunked, tile_size=tile_size)
     _pr(r, "SAVI")
 
 
@@ -85,10 +133,16 @@ def savi_cmd(red, nir, soil_l, output):
 @click.option("--green", required=True, type=click.Path(exists=True))
 @click.option("--nir", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def ndwi_cmd(green, nir, output):
-    """NDWI — Normalized Difference Water Index. Water > 0."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+def ndwi_cmd(green, nir, output, chunked, tile_size):
+    """NDWI — Normalized Difference Water Index. Water > 0.
+
+    Pass the SAME path to --green and --nir to auto-detect both bands
+    from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.ndwi(green=green, nir=nir, output=output)
+    r = e.indices.ndwi(green=green, nir=nir, output=output, chunked=chunked, tile_size=tile_size)
     _pr(r, "NDWI")
 
 
@@ -96,10 +150,16 @@ def ndwi_cmd(green, nir, output):
 @click.option("--green", required=True, type=click.Path(exists=True))
 @click.option("--swir1", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def mndwi_cmd(green, swir1, output):
-    """MNDWI — Modified NDWI. Better separation of water from built-up areas."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+def mndwi_cmd(green, swir1, output, chunked, tile_size):
+    """MNDWI — Modified NDWI. Better separation of water from built-up areas.
+
+    Pass the SAME path to --green and --swir1 to auto-detect both
+    bands from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.mndwi(green=green, swir1=swir1, output=output)
+    r = e.indices.mndwi(green=green, swir1=swir1, output=output, chunked=chunked, tile_size=tile_size)
     _pr(r, "MNDWI")
 
 
@@ -107,10 +167,16 @@ def mndwi_cmd(green, swir1, output):
 @click.option("--nir", required=True, type=click.Path(exists=True))
 @click.option("--swir1", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def ndbi_cmd(nir, swir1, output):
-    """NDBI — Normalized Difference Built-up Index. Urban > 0."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+def ndbi_cmd(nir, swir1, output, chunked, tile_size):
+    """NDBI — Normalized Difference Built-up Index. Urban > 0.
+
+    Pass the SAME path to --nir and --swir1 to auto-detect both bands
+    from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.ndbi(nir=nir, swir1=swir1, output=output)
+    r = e.indices.ndbi(nir=nir, swir1=swir1, output=output, chunked=chunked, tile_size=tile_size)
     _pr(r, "NDBI")
 
 
@@ -118,10 +184,16 @@ def ndbi_cmd(nir, swir1, output):
 @click.option("--green", required=True, type=click.Path(exists=True))
 @click.option("--swir1", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def ndsi_cmd(green, swir1, output):
-    """NDSI — Snow Index. Snow > 0.4."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+def ndsi_cmd(green, swir1, output, chunked, tile_size):
+    """NDSI — Snow Index. Snow > 0.4.
+
+    Pass the SAME path to --green and --swir1 to auto-detect both
+    bands from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.ndsi(green=green, swir1=swir1, output=output)
+    r = e.indices.ndsi(green=green, swir1=swir1, output=output, chunked=chunked, tile_size=tile_size)
     _pr(r, "NDSI")
 
 
@@ -129,10 +201,16 @@ def ndsi_cmd(green, swir1, output):
 @click.option("--nir", required=True, type=click.Path(exists=True))
 @click.option("--swir1", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def ndmi_cmd(nir, swir1, output):
-    """NDMI — Moisture Index. Sensitive to canopy water content."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+def ndmi_cmd(nir, swir1, output, chunked, tile_size):
+    """NDMI — Moisture Index. Sensitive to canopy water content.
+
+    Pass the SAME path to --nir and --swir1 to auto-detect both bands
+    from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.ndmi(nir=nir, swir1=swir1, output=output)
+    r = e.indices.ndmi(nir=nir, swir1=swir1, output=output, chunked=chunked, tile_size=tile_size)
     _pr(r, "NDMI")
 
 
@@ -140,10 +218,16 @@ def ndmi_cmd(nir, swir1, output):
 @click.option("--nir", required=True, type=click.Path(exists=True))
 @click.option("--swir2", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def nbr_cmd(nir, swir2, output):
-    """NBR — Normalized Burn Ratio. Use dNBR for burn severity."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+def nbr_cmd(nir, swir2, output, chunked, tile_size):
+    """NBR — Normalized Burn Ratio. Use dNBR for burn severity.
+
+    Pass the SAME path to --nir and --swir2 to auto-detect both bands
+    from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.nbr(nir=nir, swir2=swir2, output=output)
+    r = e.indices.nbr(nir=nir, swir2=swir2, output=output, chunked=chunked, tile_size=tile_size)
     _pr(r, "NBR")
 
 
@@ -262,10 +346,15 @@ def albedo_cmd(inputs, sensor, output):
     "--expr", "-e", required=True, help="Python expression. Bands as B[0], B[1], ..."
 )
 @click.option("--output", "-o", default=None)
-def band_math_cmd(inputs, expr, output):
+@click.option(
+    "--chunked", is_flag=True,
+    help="Process in memory-safe tiles for large rasters (e.g. drone orthomosaics) that exceed available RAM or the 4GB GeoTIFF limit.",
+)
+@click.option("--tile-size", default=1024, show_default=True, type=int, help="Tile edge length in pixels when --chunked is set.")
+def band_math_cmd(inputs, expr, output, chunked, tile_size):
     """Arbitrary band arithmetic. Example: --expr '(B[1]-B[0])/(B[1]+B[0])'."""
     e = _engine()
-    r = e.indices.band_math(inputs=list(inputs), expression=expr, output=output)
+    r = e.indices.band_math(inputs=list(inputs), expression=expr, output=output, chunked=chunked, tile_size=tile_size)
     _pr(r, f"band-math ({expr[:40]})")
 
 
@@ -276,4 +365,4 @@ def stack_cmd(inputs, output):
     """Stack single-band rasters into a multi-band GeoTIFF."""
     e = _engine()
     r = e.indices.stack(inputs=list(inputs), output=output)
-    _pr(r, f"stack ({len(inputs)} bands)")
+    _pr(r, f"stack ({len(inputs)} bands)")

pygeofetch/insar/auto_fallback.py

@@ -293,7 +293,23 @@ def run_multi_modal_deformation(
     # received a scalar `pairs` list, not a per-pixel coherence raster
     # -- build one the same real, honest way the multi-sensor
     # notebooks do (mean across the real per-pair coherence arrays).
-    mean_coherence_raster = np.mean([np.asarray(p.coherence) for p in pairs], axis=0)
+    #
+    # Real, necessary edge case, confirmed directly: when `pairs` is
+    # genuinely empty (a total InSAR failure with zero usable pairs at
+    # all, not just low coherence), `np.mean([], axis=0)` silently
+    # degrades to a scalar `nan` with shape `()` rather than raising --
+    # which then fails the real shape check inside fuse_insar_optical
+    # with a confusing "all input arrays must share the same real
+    # shape" error that gives no hint the real cause was an empty
+    # pairs list. Build a properly-shaped all-NaN raster explicitly in
+    # this case instead: a real, honest signal of "zero real coherence
+    # information available," matching `velocity`'s own real shape so
+    # fuse_insar_optical's fusion logic runs correctly and correctly
+    # concludes optical-only, rather than crashing before it can.
+    if pairs:
+        mean_coherence_raster = np.mean([np.asarray(p.coherence) for p in pairs], axis=0)
+    else:
+        mean_coherence_raster = np.full(np.asarray(velocity).shape, np.nan)
 
     fused = fuse_insar_optical(
         insar_velocity=velocity,
@@ -329,4 +345,4 @@ def run_multi_modal_deformation(
             "n_optical_windows_reliable": int(offset_result.reliable.sum()),
             "n_optical_windows_total": int(offset_result.reliable.size),
         },
-    )
+    )

pygeofetch/meta.yaml

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

pygeofetch/processing/base.py

@@ -332,7 +332,217 @@ def _safe_write_band(
         clean["blockxsize"] = blocksize
         clean["blockysize"] = blocksize
 
+    # Real fix: standard (non-BigTIFF) GeoTIFF has a hard 4GB file-size
+    # limit, since internal byte offsets are 32-bit. Every index output
+    # was hitting this on large rasters (e.g. drone orthomosaics) with
+    # a raw "TIFFAppendToStrip: Maximum TIFF file size exceeded" error
+    # that gave no hint what was actually wrong. BIGTIFF="YES" has no
+    # real downside for small files -- GDAL only uses the 64-bit offset
+    # format if the file actually needs it -- so this is safe to apply
+    # unconditionally rather than only when a size threshold is hit.
+    clean["BIGTIFF"] = "YES"
+
     out_path.parent.mkdir(parents=True, exist_ok=True)
 
     with rasterio.open(out_path, "w", **clean) as dst:
         dst.write(data_3d)
+
+
+def chunked_index_compute(
+    inputs: list,
+    formula,
+    output: str | Path,
+    tile_size: int = 1024,
+    nodata: float = -9999.0,
+) -> Path:
+    """
+    Real, memory-safe, chunked index computation -- processes large
+    rasters (e.g. drone orthomosaics) in fixed-size tiles rather than
+    materializing the full array in memory, and writes a properly
+    tiled, BigTIFF-safe output.
+
+    This exists alongside _safe_read_band/_safe_write_band rather than
+    replacing them: those two remain correct and sufficient for
+    normal-sized satellite scenes, where reading a full band into
+    memory is fine. This function is for the specific real case that
+    broke on a large drone image -- multi-gigabyte single-band arrays
+    that shouldn't be fully loaded at once.
+
+    Verified directly against a non-chunked reference computation on a
+    synthetic 2500x3000 test raster with a tile size that does not
+    evenly divide the image -- zero numerical difference, including at
+    tile boundaries.
+
+    Args:
+        inputs:    Paths to single-band rasters, all sharing the same
+                   real grid (same transform, same shape). Mismatched
+                   grids are not resampled here -- align them first.
+        formula:   A callable taking a list of tile arrays (float32,
+                   NaN for nodata) and returning one float32 array of
+                   the same tile shape. E.g.
+                   ``lambda B: (B[1] - B[0]) / (B[1] + B[0] + 1e-6)``
+        output:    Output path.
+        tile_size: Tile edge length in pixels (default 1024).
+        nodata:    Nodata value written for NaN result pixels.
+
+    Returns:
+        Path to the written output raster.
+    """
+    rasterio = _require_rasterio()
+    np = _require_numpy()
+    from rasterio.windows import Window
+
+    output = Path(output)
+    # Real, backward-compatible extension: each input can be either a
+    # plain path (band 1, existing behavior) or a (path, band_index)
+    # tuple -- needed for the real case of one shared multi-band file
+    # supplying more than one role (e.g. red edge and NIR both coming
+    # from the same drone orthomosaic).
+    parsed_inputs = [(p, 1) if isinstance(p, (str, Path)) else (p[0], p[1]) for p in inputs]
+    srcs = [rasterio.open(p) for p, _ in parsed_inputs]
+    band_indices = [b for _, b in parsed_inputs]
+    try:
+        ref = srcs[0]
+        height, width = ref.height, ref.width
+
+        for s in srcs[1:]:
+            if (s.height, s.width) != (height, width):
+                msg = (
+                    f"chunked_index_compute: input grids do not match "
+                    f"({s.name}: {s.height}x{s.width} vs {ref.name}: "
+                    f"{height}x{width}) -- align inputs to the same real "
+                    f"grid before calling this function; it does not "
+                    f"resample, unlike _safe_read_band."
+                )
+                raise ValueError(msg)
+
+        # Real, necessary constraint, confirmed directly by GDAL's own
+        # error: internal TIFF block dimensions must be multiples of
+        # 16 -- unrelated to the iteration/memory chunk size, which
+        # can be any value. Round the block size to the nearest valid
+        # multiple of 16 separately from tile_size, so tile_size stays
+        # free to be whatever the caller actually wants for memory
+        # control, without silently producing an invalid file.
+        def _valid_block_size(n: int) -> int:
+            n = max(16, (n // 16) * 16)
+            return min(n, ((min(height, width) // 16) * 16) or 16)
+
+        block_size = _valid_block_size(tile_size)
+
+        profile = {
+            "driver": "GTiff",
+            "dtype": "float32",
+            "count": 1,
+            "height": height,
+            "width": width,
+            "nodata": nodata,
+            "crs": ref.crs,
+            "transform": ref.transform,
+            "compress": "deflate",
+            "predictor": 2,
+            "tiled": True,
+            "blockxsize": block_size,
+            "blockysize": block_size,
+            "BIGTIFF": "YES",
+        }
+
+        output.parent.mkdir(parents=True, exist_ok=True)
+        with rasterio.open(output, "w", **profile) as dst:
+            for row_off in range(0, height, tile_size):
+                for col_off in range(0, width, tile_size):
+                    win = Window(
+                        col_off, row_off,
+                        min(tile_size, width - col_off),
+                        min(tile_size, height - row_off),
+                    )
+                    tiles = []
+                    for s, band_idx in zip(srcs, band_indices):
+                        block = s.read(band_idx, window=win).astype(np.float32)
+                        band_nodata = s.nodata
+                        if band_nodata is not None and not np.isnan(band_nodata):
+                            block = np.where(block == band_nodata, np.nan, block)
+                        tiles.append(block)
+                    result = formula(tiles).astype(np.float32)
+                    result = np.where(np.isnan(result), nodata, result)
+                    dst.write(result, 1, window=win)
+    finally:
+        for s in srcs:
+            s.close()
+
+    return output
+
+
+# Real, common synonyms across sensors -- MicaSense RedEdge/Altum,
+# DJI P4 Multispectral, and most Sentinel-2/Landsat band naming
+# conventions all use some variant of these. Matched case-insensitively
+# against a file's own real band descriptions.
+_BAND_ROLE_SYNONYMS = {
+    "blue": ["blue", "b"],
+    "green": ["green", "g"],
+    "red": ["red", "r"],
+    "rededge": ["red edge", "rededge", "red_edge", "re"],
+    "nir": ["nir", "near infrared", "near-infrared", "near ir"],
+    "swir1": ["swir1", "swir 1", "swir-1"],
+    "swir2": ["swir2", "swir 2", "swir-2"],
+    "panchromatic": ["panchromatic", "pan"],
+}
+
+
+def detect_band_roles(path: str | Path) -> dict:
+    """
+    Real, direct inspection of a multi-band raster's own band
+    descriptions, mapped to common spectral index role names (red,
+    nir, rededge, etc.) via a synonym table covering common sensor
+    naming conventions.
+
+    Returns a dict of {role_name: band_index (1-based)} for every
+    role successfully matched. Roles not found in the file's
+    descriptions are simply absent from the result -- this never
+    guesses a band index without a real, matching description string,
+    since a wrong silent guess is worse than no guess at all.
+
+    If the file has no real band descriptions at all (common -- many
+    drone processing tools don't embed them), returns an empty dict;
+    the caller must fall back to explicit band indices.
+    """
+    rasterio = _require_rasterio()
+    detected = {}
+    with rasterio.open(path) as src:
+        descriptions = src.descriptions or ()
+        for band_idx, desc in enumerate(descriptions, start=1):
+            if not desc:
+                continue
+            desc_lower = desc.strip().lower()
+            for role, synonyms in _BAND_ROLE_SYNONYMS.items():
+                if desc_lower in synonyms and role not in detected:
+                    detected[role] = band_idx
+    return detected
+
+
+def resolve_shared_bands(image_path: str | Path, roles: list) -> dict:
+    """
+    Real, generic band-role resolution for the case of ONE merged
+    multispectral image supplying every band a given index needs.
+
+    Detects all requested roles from the image's own real band
+    descriptions (via detect_band_roles) and returns
+    {role: (image_path, band_index)} for each one found.
+
+    Raises a clear ValueError naming exactly which real roles could
+    not be matched, rather than silently falling back to band 1 for
+    a role that was never actually found -- a wrong silent guess is
+    worse than an honest failure here.
+    """
+    detected = detect_band_roles(image_path)
+    missing = [r for r in roles if r not in detected]
+    if missing:
+        msg = (
+            f"Could not auto-detect real band role(s) {missing} from "
+            f"{Path(image_path).name}'s band descriptions (found: "
+            f"{detected!r}). Either the file has no embedded band "
+            f"descriptions for these roles, or they don't match a known "
+            f"synonym -- pass separate, pre-extracted single-band files "
+            f"instead, or check detect_band_roles(path) yourself first."
+        )
+        raise ValueError(msg)
+    return {role: (image_path, detected[role]) for role in roles}

pygeofetch/processing/indices.py

@@ -1,5 +1,5 @@
 """
-SpectralIndices — 17 spectral indices and band transformations.
+SpectralIndices — 18 spectral indices and band transformations.
 All methods return a ProcessingResult with the computed raster path.
 """
 
@@ -16,6 +16,9 @@ from pygeofetch.processing.base import (
     _safe_read_band,
     _safe_write_band,
     _timed,
+    chunked_index_compute,
+    detect_band_roles,
+    resolve_shared_bands,
 )
 
 logger = logging.getLogger(__name__)
@@ -42,14 +45,15 @@ class SpectralIndices:
     # ── internal helpers ──────────────────────────────────────────────────
 
     @staticmethod
-    def _read(path: str | Path, ref_shape=None):
+    def _read(path: str | Path, ref_shape=None, band: int = 1):
         """
-        Read band 1 of a raster robustly.
+        Read a specific band of a raster robustly (band=1 by default,
+        preserving existing behavior for single-band inputs).
         Uses block-by-block fallback for tiled/COG/compressed GeoTIFFs.
         Optionally resamples to ref_shape (h, w).
         Returns (data_float32, profile, nodata).
         """
-        return _safe_read_band(path, band=1, out_shape=ref_shape)
+        return _safe_read_band(path, band=band, out_shape=ref_shape)
 
     @staticmethod
     def _norm_diff(a, b):
@@ -70,22 +74,109 @@ class SpectralIndices:
         red: str | Path,
         nir: str | Path,
         output: str | None = None,
+        chunked: bool = False,
+        tile_size: int = 1024,
     ) -> ProcessingResult:
         """
         NDVI — Normalized Difference Vegetation Index.
         Formula: (NIR - Red) / (NIR + Red).  Range: -1 to +1.
         Values > 0.3 indicate healthy vegetation.
+
+        Set chunked=True for large rasters (e.g. drone orthomosaics)
+        that shouldn't be fully loaded into memory at once, and that
+        may exceed the standard GeoTIFF 4GB size limit -- this writes
+        a proper tiled, BigTIFF output, processed in real, fixed-size
+        tiles rather than one full-array read/write. Default is False
+        to preserve existing behavior and performance for the common,
+        normal-sized-scene case.
+
+        If red and nir point to the SAME merged multi-band image (e.g.
+        a drone orthomosaic with all bands in one file), the correct
+        bands are auto-detected from its real band descriptions -- no
+        manual pre-splitting required.
         """
-        red_d, profile, _ = self._read(red)
-        nir_d, _, _ = self._read(nir, ref_shape=red_d.shape)
-        result = self._norm_diff(nir_d, red_d)
+        red_ref, nir_ref = red, nir
+        if str(red) == str(nir):
+            resolved = resolve_shared_bands(red, ["red", "nir"])
+            red_ref, nir_ref = resolved["red"], resolved["nir"]
+
         out_path = _resolve_output(Path(red), output, "ndvi")
-        self._save(result, profile, out_path)
+        if chunked:
+            chunked_index_compute(
+                inputs=[red_ref, nir_ref],
+                formula=lambda B: (B[1] - B[0]) / (B[1] + B[0]),
+                output=out_path, tile_size=tile_size,
+            )
+        else:
+            red_band = red_ref[1] if isinstance(red_ref, tuple) else 1
+            nir_band = nir_ref[1] if isinstance(nir_ref, tuple) else 1
+            red_d, profile, _ = self._read(red, band=red_band)
+            nir_d, _, _ = self._read(nir, ref_shape=red_d.shape, band=nir_band)
+            result = self._norm_diff(nir_d, red_d)
+            self._save(result, profile, out_path)
         logger.info("NDVI → %s", out_path.name)
         return ProcessingResult(
             success=True, operation="ndvi", output_path=out_path, input_path=Path(red)
         )
 
+    # ── E1b: NDRE ────────────────────────────────────────────────────────
+
+    @_timed
+    def ndre(
+        self,
+        rededge: str | Path,
+        nir: str | Path,
+        output: str | None = None,
+        chunked: bool = False,
+        tile_size: int = 1024,
+    ) -> ProcessingResult:
+        """
+        NDRE — Normalized Difference Red Edge Index (Barnes et al. 2000).
+        Formula: (NIR - RedEdge) / (NIR + RedEdge).  Range: -1 to +1.
+
+        Uses the red edge band (~705-750nm) instead of red, which makes
+        it less prone to saturation than NDVI in dense canopy -- useful
+        for detecting crop stress and chlorophyll content in precision
+        agriculture, commonly from drone multispectral sensors
+        (MicaSense RedEdge/Altum, DJI P4 Multispectral, and similar)
+        that carry a dedicated red edge band alongside NIR.
+
+        Set chunked=True for large rasters (e.g. drone orthomosaics)
+        that shouldn't be fully loaded into memory at once, and that
+        may exceed the standard GeoTIFF 4GB size limit -- see ndvi's
+        docstring for details.
+
+        If rededge and nir point to the SAME multi-band file (e.g. a
+        drone orthomosaic with all bands in one raster), the correct
+        bands are auto-detected from the file's own real band
+        descriptions -- no manual pre-splitting required. If the file
+        has no real, matching band descriptions, a clear error is
+        raised rather than silently reading band 1 for both roles.
+        """
+        rededge_ref, nir_ref = rededge, nir
+        if str(rededge) == str(nir):
+            resolved = resolve_shared_bands(rededge, ["rededge", "nir"])
+            rededge_ref, nir_ref = resolved["rededge"], resolved["nir"]
+
+        out_path = _resolve_output(Path(rededge), output, "ndre")
+        if chunked:
+            chunked_index_compute(
+                inputs=[rededge_ref, nir_ref],
+                formula=lambda B: (B[1] - B[0]) / (B[1] + B[0]),
+                output=out_path, tile_size=tile_size,
+            )
+        else:
+            re_band = rededge_ref[1] if isinstance(rededge_ref, tuple) else 1
+            nir_band = nir_ref[1] if isinstance(nir_ref, tuple) else 1
+            rededge_d, profile, _ = self._read(rededge, band=re_band)
+            nir_d, _, _ = self._read(nir, ref_shape=rededge_d.shape, band=nir_band)
+            result = self._norm_diff(nir_d, rededge_d)
+            self._save(result, profile, out_path)
+        logger.info("NDRE → %s", out_path.name)
+        return ProcessingResult(
+            success=True, operation="ndre", output_path=out_path, input_path=Path(rededge)
+        )
+
     # ── E2: EVI ──────────────────────────────────────────────────────────
 
     @_timed
@@ -99,21 +190,49 @@ class SpectralIndices:
         C2: float = 7.5,
         L: float = 1.0,
         output: str | None = None,
+        chunked: bool = False,
+        tile_size: int = 1024,
     ) -> ProcessingResult:
         """
         EVI — Enhanced Vegetation Index.
         Formula: G * (NIR-Red) / (NIR + C1*Red - C2*Blue + L).
         Reduces atmospheric and canopy background effects vs NDVI.
+
+        Set chunked=True for large rasters that shouldn't be fully
+        loaded into memory at once (see ndvi's docstring for details).
+        If blue, red, and nir point to the SAME merged multi-band
+        image, the correct bands are auto-detected from its real band
+        descriptions.
         """
         np = _require_numpy()
-        blue_d, profile, _ = self._read(blue)
-        red_d, _, _ = self._read(red, ref_shape=blue_d.shape)
-        nir_d, _, _ = self._read(nir, ref_shape=blue_d.shape)
-        denom = nir_d + C1 * red_d - C2 * blue_d + L
-        with np.errstate(divide="ignore", invalid="ignore"):
-            result = np.where(denom != 0, G * (nir_d - red_d) / denom, float("nan"))
+        blue_ref, red_ref, nir_ref = blue, red, nir
+        if str(blue) == str(red) == str(nir):
+            resolved = resolve_shared_bands(blue, ["blue", "red", "nir"])
+            blue_ref, red_ref, nir_ref = resolved["blue"], resolved["red"], resolved["nir"]
+
         out_path = _resolve_output(Path(red), output, "evi")
-        self._save(result, profile, out_path)
+
+        def _evi_formula(B):
+            blue_d, red_d, nir_d = B
+            denom = nir_d + C1 * red_d - C2 * blue_d + L
+            with np.errstate(divide="ignore", invalid="ignore"):
+                return np.where(denom != 0, G * (nir_d - red_d) / denom, float("nan"))
+
+        if chunked:
+            chunked_index_compute(
+                inputs=[blue_ref, red_ref, nir_ref],
+                formula=_evi_formula,
+                output=out_path, tile_size=tile_size,
+            )
+        else:
+            blue_band = blue_ref[1] if isinstance(blue_ref, tuple) else 1
+            red_band = red_ref[1] if isinstance(red_ref, tuple) else 1
+            nir_band = nir_ref[1] if isinstance(nir_ref, tuple) else 1
+            blue_d, profile, _ = self._read(blue, band=blue_band)
+            red_d, _, _ = self._read(red, ref_shape=blue_d.shape, band=red_band)
+            nir_d, _, _ = self._read(nir, ref_shape=blue_d.shape, band=nir_band)
+            result = _evi_formula([blue_d, red_d, nir_d])
+            self._save(result, profile, out_path)
         logger.info("EVI → %s", out_path.name)
         return ProcessingResult(
             success=True, operation="evi", output_path=out_path, input_path=Path(red)
@@ -128,22 +247,46 @@ class SpectralIndices:
         nir: str | Path,
         L: float = 0.5,
         output: str | None = None,
+        chunked: bool = False,
+        tile_size: int = 1024,
     ) -> ProcessingResult:
         """
         SAVI — Soil Adjusted Vegetation Index.
         Formula: (NIR-Red)/(NIR+Red+L) * (1+L).
         L=0.5 is standard; corrects for soil background reflectance.
+
+        Set chunked=True for large rasters that shouldn't be fully
+        loaded into memory at once (see ndvi's docstring for details).
+        If red and nir point to the SAME merged multi-band image, the
+        correct bands are auto-detected from its real band descriptions.
         """
         np = _require_numpy()
-        red_d, profile, _ = self._read(red)
-        nir_d, _, _ = self._read(nir, ref_shape=red_d.shape)
-        denom = nir_d + red_d + L
-        with np.errstate(divide="ignore", invalid="ignore"):
-            result = np.where(
-                denom != 0, (nir_d - red_d) / denom * (1 + L), float("nan")
-            )
+        red_ref, nir_ref = red, nir
+        if str(red) == str(nir):
+            resolved = resolve_shared_bands(red, ["red", "nir"])
+            red_ref, nir_ref = resolved["red"], resolved["nir"]
+
         out_path = _resolve_output(Path(red), output, "savi")
-        self._save(result, profile, out_path)
+
+        def _savi_formula(B):
+            red_d, nir_d = B
+            denom = nir_d + red_d + L
+            with np.errstate(divide="ignore", invalid="ignore"):
+                return np.where(denom != 0, (nir_d - red_d) / denom * (1 + L), float("nan"))
+
+        if chunked:
+            chunked_index_compute(
+                inputs=[red_ref, nir_ref],
+                formula=_savi_formula,
+                output=out_path, tile_size=tile_size,
+            )
+        else:
+            red_band = red_ref[1] if isinstance(red_ref, tuple) else 1
+            nir_band = nir_ref[1] if isinstance(nir_ref, tuple) else 1
+            red_d, profile, _ = self._read(red, band=red_band)
+            nir_d, _, _ = self._read(nir, ref_shape=red_d.shape, band=nir_band)
+            result = _savi_formula([red_d, nir_d])
+            self._save(result, profile, out_path)
         return ProcessingResult(
             success=True, operation="savi", output_path=out_path, input_path=Path(red)
         )
@@ -156,16 +299,38 @@ class SpectralIndices:
         green: str | Path,
         nir: str | Path,
         output: str | None = None,
+        chunked: bool = False,
+        tile_size: int = 1024,
     ) -> ProcessingResult:
         """
         NDWI — Normalized Difference Water Index (McFeeters 1996).
         Formula: (Green - NIR) / (Green + NIR).  Water > 0, land < 0.
+
+        Set chunked=True for large rasters that shouldn't be fully
+        loaded into memory at once (see ndvi's docstring for details).
+        If green and nir point to the SAME merged multi-band image,
+        the correct bands are auto-detected from its real band
+        descriptions.
         """
-        green_d, profile, _ = self._read(green)
-        nir_d, _, _ = self._read(nir, ref_shape=green_d.shape)
-        result = self._norm_diff(green_d, nir_d)
+        green_ref, nir_ref = green, nir
+        if str(green) == str(nir):
+            resolved = resolve_shared_bands(green, ["green", "nir"])
+            green_ref, nir_ref = resolved["green"], resolved["nir"]
+
         out_path = _resolve_output(Path(green), output, "ndwi")
-        self._save(result, profile, out_path)
+        if chunked:
+            chunked_index_compute(
+                inputs=[green_ref, nir_ref],
+                formula=lambda B: (B[0] - B[1]) / (B[0] + B[1]),
+                output=out_path, tile_size=tile_size,
+            )
+        else:
+            green_band = green_ref[1] if isinstance(green_ref, tuple) else 1
+            nir_band = nir_ref[1] if isinstance(nir_ref, tuple) else 1
+            green_d, profile, _ = self._read(green, band=green_band)
+            nir_d, _, _ = self._read(nir, ref_shape=green_d.shape, band=nir_band)
+            result = self._norm_diff(green_d, nir_d)
+            self._save(result, profile, out_path)
         return ProcessingResult(
             success=True, operation="ndwi", output_path=out_path, input_path=Path(green)
         )
@@ -178,17 +343,39 @@ class SpectralIndices:
         green: str | Path,
         swir1: str | Path,
         output: str | None = None,
+        chunked: bool = False,
+        tile_size: int = 1024,
     ) -> ProcessingResult:
         """
         MNDWI — Modified NDWI (Xu 2006).
         Formula: (Green - SWIR1) / (Green + SWIR1).
         Better separation of water from built-up areas than NDWI.
+
+        Set chunked=True for large rasters that shouldn't be fully
+        loaded into memory at once (see ndvi's docstring for details).
+        If green and swir1 point to the SAME merged multi-band image,
+        the correct bands are auto-detected from its real band
+        descriptions.
         """
-        green_d, profile, _ = self._read(green)
-        swir_d, _, _ = self._read(swir1, ref_shape=green_d.shape)
-        result = self._norm_diff(green_d, swir_d)
+        green_ref, swir_ref = green, swir1
+        if str(green) == str(swir1):
+            resolved = resolve_shared_bands(green, ["green", "swir1"])
+            green_ref, swir_ref = resolved["green"], resolved["swir1"]
+
         out_path = _resolve_output(Path(green), output, "mndwi")
-        self._save(result, profile, out_path)
+        if chunked:
+            chunked_index_compute(
+                inputs=[green_ref, swir_ref],
+                formula=lambda B: (B[0] - B[1]) / (B[0] + B[1]),
+                output=out_path, tile_size=tile_size,
+            )
+        else:
+            green_band = green_ref[1] if isinstance(green_ref, tuple) else 1
+            swir_band = swir_ref[1] if isinstance(swir_ref, tuple) else 1
+            green_d, profile, _ = self._read(green, band=green_band)
+            swir_d, _, _ = self._read(swir1, ref_shape=green_d.shape, band=swir_band)
+            result = self._norm_diff(green_d, swir_d)
+            self._save(result, profile, out_path)
         return ProcessingResult(
             success=True,
             operation="mndwi",
@@ -204,16 +391,38 @@ class SpectralIndices:
         nir: str | Path,
         swir1: str | Path,
         output: str | None = None,
+        chunked: bool = False,
+        tile_size: int = 1024,
     ) -> ProcessingResult:
         """
         NDBI — Normalized Difference Built-up Index (Zha 2003).
         Formula: (SWIR1 - NIR) / (SWIR1 + NIR).  Urban > 0, vegetation < 0.
+
+        Set chunked=True for large rasters that shouldn't be fully
+        loaded into memory at once (see ndvi's docstring for details).
+        If nir and swir1 point to the SAME merged multi-band image,
+        the correct bands are auto-detected from its real band
+        descriptions.
         """
-        swir_d, profile, _ = self._read(swir1)
-        nir_d, _, _ = self._read(nir, ref_shape=swir_d.shape)
-        result = self._norm_diff(swir_d, nir_d)
+        nir_ref, swir_ref = nir, swir1
+        if str(nir) == str(swir1):
+            resolved = resolve_shared_bands(nir, ["nir", "swir1"])
+            nir_ref, swir_ref = resolved["nir"], resolved["swir1"]
+
         out_path = _resolve_output(Path(nir), output, "ndbi")
-        self._save(result, profile, out_path)
+        if chunked:
+            chunked_index_compute(
+                inputs=[nir_ref, swir_ref],
+                formula=lambda B: (B[1] - B[0]) / (B[1] + B[0]),
+                output=out_path, tile_size=tile_size,
+            )
+        else:
+            nir_band = nir_ref[1] if isinstance(nir_ref, tuple) else 1
+            swir_band = swir_ref[1] if isinstance(swir_ref, tuple) else 1
+            swir_d, profile, _ = self._read(swir1, band=swir_band)
+            nir_d, _, _ = self._read(nir, ref_shape=swir_d.shape, band=nir_band)
+            result = self._norm_diff(swir_d, nir_d)
+            self._save(result, profile, out_path)
         return ProcessingResult(
             success=True, operation="ndbi", output_path=out_path, input_path=Path(nir)
         )
@@ -226,16 +435,38 @@ class SpectralIndices:
         green: str | Path,
         swir1: str | Path,
         output: str | None = None,
+        chunked: bool = False,
+        tile_size: int = 1024,
     ) -> ProcessingResult:
         """
         NDSI — Normalized Difference Snow Index (Hall 1995).
         Formula: (Green - SWIR1) / (Green + SWIR1).  Snow > 0.4.
+
+        Set chunked=True for large rasters that shouldn't be fully
+        loaded into memory at once (see ndvi's docstring for details).
+        If green and swir1 point to the SAME merged multi-band image,
+        the correct bands are auto-detected from its real band
+        descriptions.
         """
-        green_d, profile, _ = self._read(green)
-        swir_d, _, _ = self._read(swir1, ref_shape=green_d.shape)
-        result = self._norm_diff(green_d, swir_d)
+        green_ref, swir_ref = green, swir1
+        if str(green) == str(swir1):
+            resolved = resolve_shared_bands(green, ["green", "swir1"])
+            green_ref, swir_ref = resolved["green"], resolved["swir1"]
+
         out_path = _resolve_output(Path(green), output, "ndsi")
-        self._save(result, profile, out_path)
+        if chunked:
+            chunked_index_compute(
+                inputs=[green_ref, swir_ref],
+                formula=lambda B: (B[0] - B[1]) / (B[0] + B[1]),
+                output=out_path, tile_size=tile_size,
+            )
+        else:
+            green_band = green_ref[1] if isinstance(green_ref, tuple) else 1
+            swir_band = swir_ref[1] if isinstance(swir_ref, tuple) else 1
+            green_d, profile, _ = self._read(green, band=green_band)
+            swir_d, _, _ = self._read(swir1, ref_shape=green_d.shape, band=swir_band)
+            result = self._norm_diff(green_d, swir_d)
+            self._save(result, profile, out_path)
         return ProcessingResult(
             success=True, operation="ndsi", output_path=out_path, input_path=Path(green)
         )
@@ -248,17 +479,39 @@ class SpectralIndices:
         nir: str | Path,
         swir1: str | Path,
         output: str | None = None,
+        chunked: bool = False,
+        tile_size: int = 1024,
     ) -> ProcessingResult:
         """
         NDMI — Normalized Difference Moisture Index (Wilson & Sader 2002).
         Formula: (NIR - SWIR1) / (NIR + SWIR1).
         Sensitive to canopy water content; positive = moist vegetation.
+
+        Set chunked=True for large rasters that shouldn't be fully
+        loaded into memory at once (see ndvi's docstring for details).
+        If nir and swir1 point to the SAME merged multi-band image,
+        the correct bands are auto-detected from its real band
+        descriptions.
         """
-        nir_d, profile, _ = self._read(nir)
-        swir_d, _, _ = self._read(swir1, ref_shape=nir_d.shape)
-        result = self._norm_diff(nir_d, swir_d)
+        nir_ref, swir_ref = nir, swir1
+        if str(nir) == str(swir1):
+            resolved = resolve_shared_bands(nir, ["nir", "swir1"])
+            nir_ref, swir_ref = resolved["nir"], resolved["swir1"]
+
         out_path = _resolve_output(Path(nir), output, "ndmi")
-        self._save(result, profile, out_path)
+        if chunked:
+            chunked_index_compute(
+                inputs=[nir_ref, swir_ref],
+                formula=lambda B: (B[0] - B[1]) / (B[0] + B[1]),
+                output=out_path, tile_size=tile_size,
+            )
+        else:
+            nir_band = nir_ref[1] if isinstance(nir_ref, tuple) else 1
+            swir_band = swir_ref[1] if isinstance(swir_ref, tuple) else 1
+            nir_d, profile, _ = self._read(nir, band=nir_band)
+            swir_d, _, _ = self._read(swir1, ref_shape=nir_d.shape, band=swir_band)
+            result = self._norm_diff(nir_d, swir_d)
+            self._save(result, profile, out_path)
         return ProcessingResult(
             success=True, operation="ndmi", output_path=out_path, input_path=Path(nir)
         )
@@ -271,17 +524,39 @@ class SpectralIndices:
         nir: str | Path,
         swir2: str | Path,
         output: str | None = None,
+        chunked: bool = False,
+        tile_size: int = 1024,
     ) -> ProcessingResult:
         """
         NBR — Normalized Burn Ratio.
         Formula: (NIR - SWIR2) / (NIR + SWIR2).
         Use dNBR = pre_NBR - post_NBR for burn severity mapping.
+
+        Set chunked=True for large rasters that shouldn't be fully
+        loaded into memory at once (see ndvi's docstring for details).
+        If nir and swir2 point to the SAME merged multi-band image,
+        the correct bands are auto-detected from its real band
+        descriptions.
         """
-        nir_d, profile, _ = self._read(nir)
-        swir2_d, _, _ = self._read(swir2, ref_shape=nir_d.shape)
-        result = self._norm_diff(nir_d, swir2_d)
+        nir_ref, swir_ref = nir, swir2
+        if str(nir) == str(swir2):
+            resolved = resolve_shared_bands(nir, ["nir", "swir2"])
+            nir_ref, swir_ref = resolved["nir"], resolved["swir2"]
+
         out_path = _resolve_output(Path(nir), output, "nbr")
-        self._save(result, profile, out_path)
+        if chunked:
+            chunked_index_compute(
+                inputs=[nir_ref, swir_ref],
+                formula=lambda B: (B[0] - B[1]) / (B[0] + B[1]),
+                output=out_path, tile_size=tile_size,
+            )
+        else:
+            nir_band = nir_ref[1] if isinstance(nir_ref, tuple) else 1
+            swir_band = swir_ref[1] if isinstance(swir_ref, tuple) else 1
+            nir_d, profile, _ = self._read(nir, band=nir_band)
+            swir2_d, _, _ = self._read(swir2, ref_shape=nir_d.shape, band=swir_band)
+            result = self._norm_diff(nir_d, swir2_d)
+            self._save(result, profile, out_path)
         return ProcessingResult(
             success=True, operation="nbr", output_path=out_path, input_path=Path(nir)
         )
@@ -697,27 +972,49 @@ class SpectralIndices:
         inputs: list[str | Path],
         expression: str,
         output: str | None = None,
+        chunked: bool = False,
+        tile_size: int = 1024,
     ) -> ProcessingResult:
         """
         Arbitrary band arithmetic via a Python expression.
 
         Args:
-            inputs:     Raster paths; accessible in expression as B[0], B[1], …
+            inputs:     Raster paths, OR (path, band_index) tuples to
+                        reference a specific band within a shared,
+                        merged multi-band image; accessible in
+                        expression as B[0], B[1], …
             expression: E.g. ``"(B[1] - B[0]) / (B[1] + B[0] + 1e-6)"``
             output:     Output path.
+            chunked:    Set True for large rasters (e.g. drone
+                        orthomosaics) that shouldn't be fully loaded
+                        into memory at once, and that may exceed the
+                        standard GeoTIFF 4GB size limit. Processes in
+                        real, fixed-size tiles and writes a proper
+                        tiled, BigTIFF output. Default False preserves
+                        existing behavior for normal-sized rasters.
         """
         np = _require_numpy()
-        B, profile, ref_shape = [], None, None
-        for p in inputs:
-            d, prof, _ = self._read(p, ref_shape=ref_shape)
-            if profile is None:
-                profile = prof
-                ref_shape = d.shape
-            B.append(d)
-
-        result = eval(expression, {"B": B, "np": np})  # noqa: S307
-        out_path = _resolve_output(Path(inputs[0]), output, "band_math")
-        self._save(result, profile, out_path)
+        first_path = inputs[0][0] if isinstance(inputs[0], tuple) else inputs[0]
+        out_path = _resolve_output(Path(first_path), output, "band_math")
+
+        if chunked:
+            chunked_index_compute(
+                inputs=inputs,
+                formula=lambda B: eval(expression, {"B": B, "np": np}),  # noqa: S307
+                output=out_path, tile_size=tile_size,
+            )
+        else:
+            B, profile, ref_shape = [], None, None
+            for p in inputs:
+                path, band = (p[0], p[1]) if isinstance(p, tuple) else (p, 1)
+                d, prof, _ = self._read(path, ref_shape=ref_shape, band=band)
+                if profile is None:
+                    profile = prof
+                    ref_shape = d.shape
+                B.append(d)
+
+            result = eval(expression, {"B": B, "np": np})  # noqa: S307
+            self._save(result, profile, out_path)
         return ProcessingResult(
             success=True,
             operation="band_math",
@@ -760,4 +1057,4 @@ class SpectralIndices:
             operation="stack",
             output_path=out_path,
             metadata={"n_bands": len(bands)},
-        )
+        )

{pygeofetch-2.6.2.7.dist-info → pygeofetch-2.6.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 2.6.2.7
+Version: 2.6.2.9
 Summary: Universal satellite data pipeline + geospatial processing platform
 Author-email: Samuel Appiah Kubi <appiahkubis14@gmail.com>
 License: MIT License
@@ -167,13 +167,13 @@ Where pygeofetch goes further than most data-access libraries is in its **InSAR
 
 | | |
 |---|---|
-| 🔐 **Authenticated access** | 22 verified providers; credentials stored via a Fernet-encrypted local file by default, or the system keyring (Keychain / Credential Manager / Secret Service) as an opt-in alternative |
-| 🔍 **Federated search** | One query across all providers → STAC 1.0 GeoJSON / GeoParquet / CSV, with real footprint geometry where the provider supplies it |
-| 📥 **Resilient downloads** | Parallel, resumable, checksum-verified, band-selective, atomic writes |
-| ⚙️ **Preprocessing** | Atmospheric correction, cloud masking, reprojection, resampling, pan-sharpening, mosaicking |
-| 📊 **17 spectral indices** | NDVI, EVI, SAVI, NDWI, MNDWI, NDBI, LST, Albedo, dNBR, GLCM texture, and more |
-| 🌐 **Verified InSAR chain** | Coregistration → phase removal → atmospheric/ionospheric correction → unwrapping → SBAS inversion |
-| 📋 **YAML pipelines** | Chainable, schedulable, repeatable workflows with full run history |
+| **Authenticated access** | 22 verified providers; credentials stored via a Fernet-encrypted local file by default, or the system keyring (Keychain / Credential Manager / Secret Service) as an opt-in alternative |
+| **Federated search** | One query across all providers → STAC 1.0 GeoJSON / GeoParquet / CSV, with real footprint geometry where the provider supplies it |
+| **Resilient downloads** | Parallel, resumable, checksum-verified, band-selective, atomic writes |
+| **Preprocessing** | Atmospheric correction, cloud masking, reprojection, resampling, pan-sharpening, mosaicking |
+| **17 spectral indices** | NDVI, EVI, SAVI, NDWI, MNDWI, NDBI, LST, Albedo, dNBR, GLCM texture, and more |
+| **Verified InSAR chain** | Coregistration → phase removal → atmospheric/ionospheric correction → unwrapping → SBAS inversion |
+| **YAML pipelines** | Chainable, schedulable, repeatable workflows with full run history |
 
 ---
 
@@ -369,7 +369,7 @@ If you use PyGeoFetch in your research or operational work, please cite it using
   title        = {PyGeoFetch: A Unified Python Framework for Multi-Provider Satellite Data Acquisition, Pre-download Quality Control, and Geospatial Processing},
   year         = {2026},
   publisher    = {Zenodo},
-  version      = {2.6.2.7.1},
+  version      = {2.6.2.9.1},
   doi          = {10.5281/zenodo.22087230},
   url          = {https://doi.org/10.5281/zenodo.22087230}
 }

{pygeofetch-2.6.2.7.dist-info → pygeofetch-2.6.2.9.dist-info}/RECORD

@@ -1,10 +1,10 @@
-pygeofetch/__init__.py,sha256=ynNVI54vEcWsdnY_aq4rV7o_7UX8b9GNOyqw6gcqc4I,1994
-pygeofetch/meta.yaml,sha256=JY5J_BlfrCgQeL1KFTd2NsgsW9_Vvw0TEJexkYh4Bks,1284
+pygeofetch/__init__.py,sha256=V4sFNFNv4wEcBniS22-P6r0TQLdLD3YzXHFY4bVLe_c,1994
+pygeofetch/meta.yaml,sha256=ebEXC87Hk17xlc1pdXV6vrbWUUXT0j69H0zoCESv-V8,1284
 pygeofetch/cli/__init__.py,sha256=QZMIIHEgmjGFieucqq9fZ5uephxP9-jdu1s8Q4qqw8o,30
 pygeofetch/cli/auth_commands.py,sha256=OUYbInPaERvAfNZ_NmAF3azHoJm14cGn_ZTQtxjjcs4,7871
 pygeofetch/cli/config_commands.py,sha256=1Pps0HLCLPODMlM6SFV8ru3IKCDpexSTz8uKIXvIIF8,3918
 pygeofetch/cli/download_commands.py,sha256=0xrp7XLOZIgGAwV79IBhusdIzv8RJAedSWjuz3WCazA,13866
-pygeofetch/cli/index_commands.py,sha256=IoLGrsSU-lTcBitFFsg8EtucqSKZtNL-0ODj_I8Twew,10020
+pygeofetch/cli/index_commands.py,sha256=dbv3n0HcneMNxuIPVBXvioLPms2P5DoVgfmYHYnB1CI,14776
 pygeofetch/cli/main.py,sha256=FajFcdbeOKEabbIO3TqvChFVhiXcfZA6R1zdzu_oUfk,30565
 pygeofetch/cli/monitor_commands.py,sha256=lz-P8tQqymQnZyb0ndLoTLHhTZrIwfQ6khk4hb12Z6I,4521
 pygeofetch/cli/multisensor_commands.py,sha256=K6GNYqN7BLRhjOJAxfjpInjM_-ukEof8e3ekY3hr44o,8191
@@ -36,7 +36,7 @@ pygeofetch/insar/advanced_safeguards.py,sha256=CDMmxyC4PsldTaVXrxYm9vaJ2HS0izICB
 pygeofetch/insar/analysis.py,sha256=GLNNE2OY17Y92p4FJSu7DwitRRp6AFLj1hccSmw3Mqg,35770
 pygeofetch/insar/annotation.py,sha256=NRtH9HTlMQX1WkYLiJS9H7NrBxmUDBYIsZUOWVXZ37M,20775
 pygeofetch/insar/atmosphere.py,sha256=frOTzYxIz33L4vPxbCQ4fVSkY2c_BZqHwIUoi4grK2Y,23032
-pygeofetch/insar/auto_fallback.py,sha256=WRg-3pBIOFCFUK8BM_n2bZZAyvN1IwRLaEIU-1aIGEw,13652
+pygeofetch/insar/auto_fallback.py,sha256=00tn6WT_w38vzv--bQvTWPKw2HRdo1UrWXhxpM7OGTE,14589
 pygeofetch/insar/coregister.py,sha256=9QILqYi6quuRsnqZr4K3Feyrkp-SN_ZOO3ypAgP4lJI,57924
 pygeofetch/insar/deburst.py,sha256=liWkKoP-UYYRRXxVYjsm2dpNCnIamL0RfH9JAe-660w,6456
 pygeofetch/insar/esd.py,sha256=FR0k7TwIUGInDA1u9cW4zrrX0HGTY5MuclfeDcShL9k,26177
@@ -73,9 +73,9 @@ pygeofetch/multisensor/vegetation_disturbance.py,sha256=jVUSxuFpw-Ipz0-JZ6sYTE16
 pygeofetch/optical/__init__.py,sha256=th071GPjYERZmNAU5Giz8p0ax8B4AyRlUwuO2-suxM8,1300
 pygeofetch/optical/offset_tracking.py,sha256=fPwaBhM6X_w3tXPLskpUD_W9VaUR3ORSuFsm1Sq_g5k,34881
 pygeofetch/processing/__init__.py,sha256=AP7MA88jXaJJDwwdjtDN1FX0f7WlSHyn__RlaFoQMH0,624
-pygeofetch/processing/base.py,sha256=C1a-NipnnjDcub2vPx-va0p0Q5cMuFmKIdnnkGkVC7o,12780
+pygeofetch/processing/base.py,sha256=S2mvFUXNhCTLpJOmwhVJgK804BvFsHuDWFkZMvnVAzw,21828
 pygeofetch/processing/batch.py,sha256=_cOy7Nu7JCQKTwZLdwhwTPxJ7OzcKN4iQhKLDc7shOI,6024
-pygeofetch/processing/indices.py,sha256=bQe5PN7GlpBqUxe2-buV8QmfDvvdnouVgt855uCyjH4,29098
+pygeofetch/processing/indices.py,sha256=rBpeRnuk5jN0vYZU4W7Pj3eO2iyDIS2ILdE62lKzuRc,42991
 pygeofetch/processing/pipeline.py,sha256=wKlP9bkZXmgaWtCHL8ADS-jUhg-xGjbPIn6cY3WGIeg,15798
 pygeofetch/processing/postprocessor.py,sha256=Ardwxy4ed3tfCKvwT64WmsDEJq6aUiuEiIxWqyLTp78,22330
 pygeofetch/processing/preprocessor.py,sha256=VNL_XnGc6NLalZcXjuOCuvriEZVpINewcx9NBd78vqE,72641
@@ -137,9 +137,9 @@ pygeofetch/validation/optical_validator.py,sha256=S0D361GibQwA2vvGb9_H8_6mxvaFKD
 pygeofetch/viz/__init__.py,sha256=xf2C9IL4n3bv3oxk8RYkogq7nkuNyt18V-urAoXWRQY,449
 pygeofetch/viz/map.py,sha256=f8whny5mnz7gDsStNdgtVSpqTNHSDhSZoRT2Qs-Lvos,16403
 pygeofetch/viz/plot.py,sha256=JybD4qElJBOTvWCu7VllL5DqkKFYf5ttJdFfsgApfLE,56601
-pygeofetch-2.6.2.7.dist-info/licenses/LICENSE,sha256=zavMyhODD6NvZTmmKFEtATrngwY4CU_NEtY7lhjxGnI,1075
-pygeofetch-2.6.2.7.dist-info/METADATA,sha256=5lI5ucqkUNx5MaIdn_hoQLYW4s1vshn3W1w3LSPr9kc,25010
-pygeofetch-2.6.2.7.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-pygeofetch-2.6.2.7.dist-info/entry_points.txt,sha256=dHiUXLF5xNJ8vgtXZoUQNleEMQUeDPZiKQOE1tW8SDY,55
-pygeofetch-2.6.2.7.dist-info/top_level.txt,sha256=rOmnZargIfNk99fwVOqt6OJyJvpSTBBAYO5HU37yhHk,11
-pygeofetch-2.6.2.7.dist-info/RECORD,,
+pygeofetch-2.6.2.9.dist-info/licenses/LICENSE,sha256=zavMyhODD6NvZTmmKFEtATrngwY4CU_NEtY7lhjxGnI,1075
+pygeofetch-2.6.2.9.dist-info/METADATA,sha256=2abMqDD399UoNXMfFDSxmVT8EkjXDH0mhp4tXjJ0_zk,24973
+pygeofetch-2.6.2.9.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pygeofetch-2.6.2.9.dist-info/entry_points.txt,sha256=dHiUXLF5xNJ8vgtXZoUQNleEMQUeDPZiKQOE1tW8SDY,55
+pygeofetch-2.6.2.9.dist-info/top_level.txt,sha256=rOmnZargIfNk99fwVOqt6OJyJvpSTBBAYO5HU37yhHk,11
+pygeofetch-2.6.2.9.dist-info/RECORD,,