satcube 0.1.13__tar.gz → 0.1.14__tar.gz

{satcube-0.1.13 → satcube-0.1.14}/PKG-INFO

@@ -1,29 +1,24 @@
 Metadata-Version: 2.1
 Name: satcube
-Version: 0.1.13
+Version: 0.1.14
 Summary: A Python package to create cloud-free monthly composites by fusing Landsat and Sentinel-2 data.
 Home-page: https://github.com/IPL-UV/satcube
 Author: Cesar Aybar
 Author-email: fcesar.aybar@uv.es
-Requires-Python: >=3.10,<4.0
+Requires-Python: >=3.9
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: full
-Requires-Dist: cubexpress (>=0.1.7)
-Requires-Dist: earthengine-api (>=1.5.12)
+Requires-Dist: cubexpress (>=0.1.10)
 Requires-Dist: mlstac (>=0.4.0)
-Requires-Dist: numpy (>=1.25.0)
-Requires-Dist: pandas (>=2.0.0)
 Requires-Dist: phicloudmask (>=0.0.2)
-Requires-Dist: pydantic (>=2.8.0)
-Requires-Dist: rasterio (>=1.3.9)
 Requires-Dist: requests (>=2.26.0)
-Requires-Dist: satalign (>=0.1.11)
+Requires-Dist: satalign (>=0.1.12)
 Requires-Dist: scikit-learn (>=1.2.0)
 Requires-Dist: segmentation-models-pytorch (>=0.3.0)
-Requires-Dist: utm (>=0.7.0)
 Requires-Dist: xarray (>=2023.7.0)
 Project-URL: Documentation, https://ipl-uv.github.io/satcube/
 Project-URL: Repository, https://github.com/IPL-UV/satcube

{satcube-0.1.13 → satcube-0.1.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name    = "satcube"
-version = "0.1.13"
+version = "0.1.14"
 description = "A Python package to create cloud-free monthly composites by fusing Landsat and Sentinel-2 data."
 authors = ["Cesar Aybar <fcesar.aybar@uv.es>"]
 repository     = "https://github.com/IPL-UV/satcube"
@@ -9,21 +9,15 @@ readme         = "README.md"
 packages       = [{ include = "satcube" }]
 
 [tool.poetry.dependencies]
-python          = ">=3.10,<4.0"
-cubexpress      = ">=0.1.7"
+python            = ">=3.9"
+cubexpress      = ">=0.1.10"
 mlstac          = ">=0.4.0"
-satalign        = ">=0.1.11"         
+satalign        = ">=0.1.12"         
 segmentation-models-pytorch = ">=0.3.0"
+phicloudmask    = ">=0.0.2" 
 scikit-learn    = ">=1.2.0"
-pandas          = ">=2.0.0"
-pydantic        = ">=2.8.0"
-rasterio          = ">=1.3.9"  
-earthengine-api   = ">=1.5.12"  
-numpy           = ">=1.25.0"
 requests        = ">=2.26.0"
-xarray          = ">=2023.7.0"
-utm             = ">=0.7.0"   
-phicloudmask    = ">=0.0.2" 
+xarray          = ">=2023.7.0"  
 
 [tool.poetry.extras]
 full = ["torch"]

{satcube-0.1.13 → satcube-0.1.14}/satcube/__init__.py

@@ -1,9 +1,9 @@
 from satcube.cloud_detection import cloud_masking
-from satcube.download import download_data
+from satcube.download import download
+from satcube.align import align
 
 
-
-__all__ = ["cloud_masking", "download_data"]
+__all__ = ["cloud_masking", "download", "align"]
 
 import importlib.metadata
 __version__ = importlib.metadata.version("satcube")

satcube-0.1.14/satcube/align.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import pathlib
+from typing import List, Tuple
+import pickle
+
+import numpy as np
+import rasterio
+import xarray as xr
+from affine import Affine
+
+import satalign as sat
+
+
+def align(
+    input_dir: str | pathlib.Path,
+    output_dir: str | pathlib.Path,
+    *,
+    channel: str = "mean",
+    crop_center: int = 128,
+    num_threads: int = 2,
+    save_tiffs: bool = True,
+) -> Tuple[xr.DataArray, List[np.ndarray]]:
+    """Align all masked Sentinel‑2 tiles found in *input_dir*.
+
+    Parameters
+    ----------
+    input_dir
+        Directory containing masked Sentinel‑2 *TIFF* tiles produced by the
+        previous preprocessing stage.
+    output_dir
+        Directory where the alignment artefacts (``datacube.pickle``) and, if
+        requested, one aligned *GeoTIFF* per date will be written.
+    channel
+        Datacube band used by the *PCC* model for correlation.  ``"mean"`` is
+        recommended because it carries fewer noise artefacts.
+    crop_center
+        Half‑size (in pixels) of the square window extracted around the scene
+        centre that is fed to the correlation engine.
+    num_threads
+        Number of CPU threads for the multi‑core phase‑correlation run.
+    save_tiffs
+        If *True* (default) the aligned datacube is exported to tiled *COGs* via
+        :func:`save_aligned_cube_to_tiffs`.
+    pickle_datacube
+        If *True* (default) the raw (unaligned) datacube is pickled to
+        ``datacube.pickle`` inside *output_dir* for reproducibility/debugging.
+
+    Returns
+    -------
+    aligned_cube, warp_matrices
+        *aligned_cube* is the spatially aligned datacube as an
+        :class:`xarray.DataArray`; *warp_matrices* is the list of 3 × 3 affine
+        homography matrices (one per time step) returned by the
+        :pyclass:`~satalign.PCC` engine.
+    """
+    input_path = pathlib.Path(input_dir).expanduser().resolve()
+    output_path = pathlib.Path(output_dir).expanduser().resolve()
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    # ── 1. Build datacube ────────────────────────────────────────────
+    da =  sat.utils.create_array(input_path)
+
+    # ── 2. Select reference slice (highest cloud‑score CDF) ───────────
+    da_sorted = da.sortby("cs_cdf", ascending=False)
+    ref_slice = da_sorted.isel(time=0)
+    reference = ref_slice.where((ref_slice != 0) & (ref_slice != 65535))
+
+    # ── 3. Instantiate and run PCC model ─────────────────────────────
+    pcc_model = sat.PCC(
+        datacube=da,
+        reference=reference,
+        channel=channel,
+        crop_center=crop_center,
+        num_threads=num_threads,
+    )
+    aligned_cube, warp_matrices = pcc_model.run_multicore()
+
+    # ── 4. Optionally export as Cloud‑Optimised GeoTIFFs ────────────
+    if save_tiffs:
+        save_aligned_cube_to_tiffs(aligned_cube, output_path)
+
+    return aligned_cube, warp_matrices
+
+
+def save_aligned_cube_to_tiffs(
+    aligned_cube: xr.DataArray,
+    out_dir: str | pathlib.Path,
+    *,
+    block_size: int = 128,
+) -> None:
+    """Write each time slice of *aligned_cube* to an individual tiled COG.
+
+    The filenames follow the pattern ``YYYY‑MM‑DD.tif``.
+
+    Parameters
+    ----------
+    aligned_cube
+        Datacube returned by :func:`align_datacube`.
+    out_dir
+        Target directory; it will be created if it does not exist.
+    block_size
+        Internal tile size (*rasterio* ``blockxsize`` and ``blockysize``).
+    """
+    out_dir_path = pathlib.Path(out_dir).expanduser().resolve()
+    out_dir_path.mkdir(parents=True, exist_ok=True)
+
+    # ── 1. Build affine transform from x/y coordinate vectors ────────
+    x_vals = aligned_cube.x.values
+    y_vals = aligned_cube.y.values
+    x_res = float(x_vals[1] - x_vals[0])  # positive (east)
+    y_res = float(y_vals[1] - y_vals[0])  # negative (north‑up)
+    transform = (
+        Affine.translation(x_vals[0] - x_res / 2.0, y_vals[0] - y_res / 2.0)
+        * Affine.scale(x_res, y_res)
+    )
+
+    # ── 2. Retrieve CRS from datacube attributes ────────────────────
+    attrs = aligned_cube.attrs
+    crs: str | None = attrs.get("crs_wkt")
+    if crs is None and "crs_epsg" in attrs:
+        crs = f"EPSG:{int(attrs['crs_epsg'])}"
+
+    # ── 3. Loop over acquisition dates and write GeoTIFFs ────────────
+    for t in aligned_cube.time.values:
+        date_str = str(t)[:10]  # YYYY‑MM‑DD
+        da_t = aligned_cube.sel(time=t)
+
+        # Ensure (band, y, x) memory layout for rasterio
+        data = da_t.transpose("band", "y", "x").values
+
+        profile = {
+            "driver": da_t.attrs.get("driver", "GTiff"),
+            "height": da_t.sizes["y"],
+            "width": da_t.sizes["x"],
+            "count": da_t.sizes["band"],
+            "dtype": str(da_t.dtype),
+            "transform": transform,
+            "crs": crs,
+            "nodata": int(getattr(da_t, "nodata", 0)),
+            "tiled": True,
+            "blockxsize": block_size,
+            "blockysize": block_size,
+            "interleave": "band",
+        }
+
+        outfile = out_dir_path / f"{date_str}.tif"
+        with rasterio.open(outfile, "w", **profile) as dst:
+            dst.write(data)

satcube-0.1.14/satcube/cloud_detection.py

@@ -0,0 +1,242 @@
+"""Predict cloud masks for Sentinel-2 GeoTIFFs with the SEN2CloudEnsemble model.
+
+The callable :pyfunc:`cloud_masking` accepts **either** a single ``.tif`` file  
+or a directory tree; in both cases it writes a masked copy of every image (and,
+optionally, the binary mask) to *output*.
+
+Example
+-------
+>>> from satcube.cloud_detection import cloud_masking
+>>> cloud_masking("~/s2/input", "~/s2/output", device="cuda")
+"""
+
+from __future__ import annotations
+
+import pathlib
+
+import mlstac
+import numpy as np
+import rasterio as rio
+from rasterio.windows import Window
+import torch
+import pandas as pd
+from tqdm import tqdm
+import rasterio as rio
+from rasterio.merge import merge
+
+from satcube.utils import define_iteration, DeviceManager
+import warnings
+warnings.filterwarnings(
+    "ignore",
+    message="The secret HF_TOKEN does not exist in your Colab secrets.",
+    category=UserWarning,
+    module=r"huggingface_hub\.utils\._.*",
+)
+
+
+
+
+def infer_cloudmask(
+    input_path: str | pathlib.Path,
+    output_path: str | pathlib.Path,
+    cloud_model: torch.nn.Module,
+    *,
+    chunk_size: int = 512,
+    overlap: int = 32,
+    device: str = "cpu",
+    save_mask: bool = False,
+    prefix: str = ""          
+) -> pathlib.Path:
+    """
+    Predict 'image_path' in overlapping patches of 'chunk_size' x 'chunk_size',
+    but only write the valid (inner) region to avoid seam artifacts.
+
+    This uses partial overlap logic:
+      - For interior tiles, skip overlap//2 on each side.
+      - For boundary tiles, we skip only the interior side to avoid losing data at the edges.
+
+    Parameters
+    ----------
+    image_path : Path to input image.
+    output_path : Path to output single-band mask.
+    cloud_model : PyTorch model (already loaded with weights).
+    chunk_size : Size of each tile to read from the source image (default 512).
+    overlap : Overlap in pixels between adjacent tiles (default 32).
+    device : "cpu" or "cuda:0".
+
+    Returns
+    -------
+    pathlib.Path : The path to the created output image.
+    """
+    # image_path = "/home/contreras/Documents/GitHub/satcube2/raw/2018-07-15_6q49m.tif"
+    # output_path = "/home/contreras/Documents/GitHub/satcube2/masked/2018-07-15_6q49m.tif"
+    
+    input_path = pathlib.Path(input_path)
+    output_path = pathlib.Path(output_path)
+
+    # 1) Validate metadata
+    with rio.open(input_path) as src:
+        meta = src.profile
+        if not meta.get("tiled", False):
+            raise ValueError("The input image is not marked as tiled in its metadata.")
+        # Ensure the internal blocksize matches chunk_size
+        if chunk_size % meta["blockxsize"] != 0 and meta["blockxsize"] <= chunk_size:
+            raise ValueError(f"Image blocks must be {chunk_size}x{chunk_size}, "
+                            f"got {meta['blockxsize']}x{meta['blockysize']}")
+        height, width = meta["height"], meta["width"]
+
+
+    # 2) Crear un buffer en RAM (float32)
+    full_mask = np.zeros((height, width), dtype=np.float32)
+
+    # 3) Iterar por ventanas
+
+    coords = define_iteration((height, width), chunk_size, overlap)
+
+    with rio.open(input_path) as src:
+
+        for (row_off, col_off) in tqdm(
+            coords, 
+            desc=f"{prefix} Inference on {input_path.name}",
+            position=1,
+            leave=False):
+
+            window = Window(col_off, row_off, chunk_size, chunk_size)
+            patch = src.read(window=window) / 1e4
+            patch_tensor = torch.from_numpy(patch).float().unsqueeze(0).to(device)
+            result = cloud_model(patch_tensor).cpu().numpy().astype(np.uint8)
+      
+            if col_off == 0:
+                offset_x = 0
+            else:
+                offset_x = col_off + overlap // 2
+            if row_off == 0:
+                offset_y = 0
+            else:
+                offset_y = row_off + overlap // 2
+            if (offset_x + chunk_size) == width:
+                length_x = chunk_size
+                sub_x_start = 0
+            else:
+                length_x = chunk_size - (overlap // 2)
+                sub_x_start = overlap // 2 if col_off != 0 else 0
+
+            if (offset_y + chunk_size) == height:
+                length_y = chunk_size
+                sub_y_start = 0
+            else:
+                length_y = chunk_size - (overlap // 2)
+                sub_y_start = overlap // 2 if row_off != 0 else 0
+
+            full_mask[
+                offset_y : offset_y + length_y,
+                offset_x : offset_x + length_x
+            ] = result[
+                sub_y_start : sub_y_start + length_y,
+                sub_x_start : sub_x_start + length_x
+            ]
+
+        if save_mask:
+            out_meta = meta.copy()
+            out_meta.update(count=1, dtype="uint8", nodata=255)
+            output_mask = output_path.parent / (output_path.stem + "_mask.tif")
+            with rio.open(output_mask, "w", **out_meta) as dst:
+                dst.write(full_mask, 1)
+            
+        with rio.open(input_path) as src_img:
+            data = src_img.read()
+            img_prof = src_img.profile.copy()
+
+        masked = data.copy()
+        masked[:, full_mask != 0] = 65535
+        img_prof.update(dtype="uint16", nodata=65535)
+
+        with rio.open(output_path, "w", **img_prof) as dst:
+            dst.write(masked)
+
+    return output_path
+
+def cloud_masking( 
+    input: str | pathlib.Path = "raw",
+    output: str | pathlib.Path = "masked",
+    model_path: str | pathlib.Path = "SEN2CloudEnsemble",
+    save_mask: bool = False,
+    device: str = "cpu",
+    cache: bool = True
+) -> list[pathlib.Path]:
+    """Write cloud-masked Sentinel-2 images.
+
+    Parameters
+    ----------
+    input
+        Path to a single ``.tif`` file **or** a directory containing them.
+    output
+        Destination directory (created i
+        f missing).
+    tile, pad
+        Tile size and padding (pixels) when tiling is required.
+    save_mask
+        If *True*, store the binary mask alongside the masked image.
+    device
+        Torch device for inference, e.g. ``"cpu"`` or ``"cuda:0"``.
+    max_pix_cpu
+        Tile images larger than this when running on CPU.
+
+    Returns
+    ------
+    list[pathlib.Path]
+        Paths to the generated masked images.
+    """
+    src = pathlib.Path(input).expanduser().resolve()
+    dst_dir = pathlib.Path(output).expanduser().resolve()
+    dst_dir.mkdir(parents=True, exist_ok=True)
+
+    # Collect files to process -------------------------------------------------
+    tif_paths = []
+    if src.is_dir():
+        tif_paths = [p for p in src.rglob("*.tif")]
+    elif src.is_file() and src.suffix.lower() == ".tif":
+        tif_paths = [src]
+        src = src.parent  # for relative-path bookkeeping below
+    else:
+        raise ValueError(f"Input must be a .tif or directory, got: {src}")
+
+    if not tif_paths:
+        print(f"[cloud_masking] No .tif files found in {src}")
+        return []
+    
+    if not pathlib.Path(model_path).exists():
+        mlstac.download(
+            file = "https://huggingface.co/tacofoundation/CloudSEN12-models/resolve/main/SEN2CloudEnsemble/mlm.json",
+            output_dir = model_path
+        )
+
+    model = mlstac.load(model_path)
+    cloud_model = DeviceManager(model, init_device=device).model
+    cloud_model.eval()
+
+    outs = [
+        infer_cloudmask(
+            input_path=p,
+            output_path=dst_dir / p.name,
+            cloud_model=cloud_model,
+            device=device,
+            save_mask=save_mask,
+            prefix=f"[{i+1}/{len(tif_paths)}] "
+        )
+        for i, p in enumerate(tif_paths)
+    ]
+
+    df_out = (
+        pd.Series(outs, name="path")
+        .to_frame()
+        .assign(path_str=lambda df: df["path"].astype(str))
+        .assign(
+            date  = lambda df: df["path_str"].str.extract(r"(\d{4}-\d{2}-\d{2})", expand=False),
+            score = lambda df: df["path_str"].str.extract(r"_(\d+)\.tif$", expand=False).astype(int) / 100
+        )
+        .drop(columns="path_str")                                    # ya no la necesitamos
+        .sort_values("score", ascending=False, ignore_index=True)
+    )
+
+    return df_out

satcube-0.1.14/satcube/download.py

@@ -0,0 +1,65 @@
+import sys, time, threading, itertools
+import cubexpress as ce
+import pandas as pd
+
+def download(
+    lon: float,
+    lat: float,
+    edge_size: int,
+    start: str,
+    end: str,
+    *,
+    max_cscore: float = 1,
+    min_cscore: float = 0,
+    outfolder: str = "raw",
+    nworks: int = 4,
+    cache: bool = True,
+    show_spinner: bool = True,
+    verbose: bool = False
+) -> pd.DataFrame:
+    """
+    """
+    stop_flag = {"v": False}
+
+    if show_spinner and not verbose:
+        def _spin():
+            for ch in itertools.cycle("|/-\\"):
+                if stop_flag["v"]:
+                    break
+                sys.stdout.write(f"\rDownloading Sentinel-2 imagery & metadata… {ch}")
+                sys.stdout.flush()
+                time.sleep(0.1)
+            sys.stdout.write("\rDownloading Sentinel-2 imagery & metadata ✅\n")
+            sys.stdout.flush()
+
+        th = threading.Thread(target=_spin, daemon=True)
+        th.start()
+    else:
+        th = None
+
+    try:
+        table = ce.s2_cloud_table(
+            lon=lon,
+            lat=lat,
+            edge_size=edge_size,
+            start=start,
+            end=end,
+            max_cscore=max_cscore,
+            min_cscore=min_cscore,
+            cache=cache,
+            verbose=verbose
+        )
+
+        ce.get_cube(
+            table=table,
+            outfolder=outfolder,
+            nworks=nworks,
+            verbose=verbose,
+            cache=cache
+        )
+    finally:
+        stop_flag["v"] = True
+        if th is not None:
+            th.join()
+
+    return table

{satcube-0.1.13 → satcube-0.1.14}/satcube/utils.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
 import gc
+import itertools
 from typing import Any, Optional
-
 import torch
 
-
 def _reset_gpu() -> None:
     """Release CUDA memory and reset allocation statistics.
 
@@ -15,6 +14,65 @@ def _reset_gpu() -> None:
     torch.cuda.reset_peak_memory_stats()
 
 
+def define_iteration(dimension: tuple, chunk_size: int, overlap: int = 0):
+    """
+    Define the iteration strategy to walk through the image with an overlap.
+
+    Args:
+        dimension (tuple): Dimension of the S2 image.
+        chunk_size (int): Size of the chunks.
+        overlap (int): Size of the overlap between chunks.
+
+    Returns:
+        list: List of chunk coordinates.
+    """
+    dimy, dimx = dimension
+
+    if chunk_size > max(dimx, dimy):
+        return [(0, 0)]
+
+    # Adjust step to create overlap
+    y_step = chunk_size - overlap
+    x_step = chunk_size - overlap
+
+    # Generate initial chunk positions
+    iterchunks = list(itertools.product(range(0, dimy, y_step), range(0, dimx, x_step)))
+
+    # Fix chunks at the edges to stay within bounds
+    iterchunks_fixed = fix_lastchunk(
+        iterchunks=iterchunks, s2dim=dimension, chunk_size=chunk_size
+    )
+
+    return iterchunks_fixed
+
+
+def fix_lastchunk(iterchunks, s2dim, chunk_size):
+    """
+    Fix the last chunk of the overlay to ensure it aligns with image boundaries.
+
+    Args:
+        iterchunks (list): List of chunks created by itertools.product.
+        s2dim (tuple): Dimension of the S2 images.
+        chunk_size (int): Size of the chunks.
+
+    Returns:
+        list: List of adjusted chunk coordinates.
+    """
+    itercontainer = []
+
+    for index_i, index_j in iterchunks:
+        # Adjust if the chunk extends beyond bounds
+        if index_i + chunk_size > s2dim[0]:
+            index_i = max(s2dim[0] - chunk_size, 0)
+        if index_j + chunk_size > s2dim[1]:
+            index_j = max(s2dim[1] - chunk_size, 0)
+
+        itercontainer.append((index_i, index_j))
+
+    return itercontainer
+
+
+
 class DeviceManager:
     """Hold a compiled mlstac model and move it between devices on demand."""
 
@@ -68,3 +126,4 @@ class DeviceManager:
         self.model = self._experiment.compiled_model(device=new_device, mode="max")
         self.device = new_device
         return self.model
+

satcube-0.1.13/satcube/cloud_detection.py

@@ -1,178 +0,0 @@
-"""Predict cloud masks for Sentinel-2 GeoTIFFs with the SEN2CloudEnsemble model.
-
-The callable :pyfunc:`cloud_masking` accepts **either** a single ``.tif`` file  
-or a directory tree; in both cases it writes a masked copy of every image (and,
-optionally, the binary mask) to *output*.
-
-Example
--------
->>> from satcube.cloud_detection import cloud_masking
->>> cloud_masking("~/s2/input", "~/s2/output", device="cuda")
-"""
-
-from __future__ import annotations
-
-import time
-from pathlib import Path
-from typing import List
-
-import mlstac
-import numpy as np
-import rasterio as rio
-import torch
-
-from satcube.utils import DeviceManager, _reset_gpu
-import warnings, re
-
-
-warnings.filterwarnings(
-    "ignore",
-    message=re.escape("The secret `HF_TOKEN` does not exist in your Colab secrets."),
-    category=UserWarning,
-    module="huggingface_hub.utils._auth",
-)
-
-def cloud_masking(
-    input: str | Path,              # noqa: A002 (shadowing built-in is OK here)
-    output: str | Path,
-    *,
-    tile: int = 512,
-    pad: int = 64,
-    save_mask: bool = False,
-    device: str = "cpu",
-    max_pix_cpu: float = 7.0e7
-) -> List[Path]:
-    """Write cloud-masked Sentinel-2 images.
-
-    Parameters
-    ----------
-    input
-        Path to a single ``.tif`` file **or** a directory containing them.
-    output
-        Destination directory (created if missing).
-    tile, pad
-        Tile size and padding (pixels) when tiling is required.
-    save_mask
-        If *True*, store the binary mask alongside the masked image.
-    device
-        Torch device for inference, e.g. ``"cpu"`` or ``"cuda:0"``.
-    max_pix_cpu
-        Tile images larger than this when running on CPU.
-
-    Returns
-    ------
-    list[pathlib.Path]
-        Paths to the generated masked images.
-    """
-    t_start = time.perf_counter()
-
-    src = Path(input).expanduser().resolve()
-    dst_dir = Path(output).expanduser().resolve()
-    dst_dir.mkdir(parents=True, exist_ok=True)
-
-    # Collect files to process -------------------------------------------------
-    tif_paths: list[Path]
-    if src.is_dir():
-        tif_paths = [p for p in src.rglob("*.tif")]
-    elif src.is_file() and src.suffix.lower() == ".tif":
-        tif_paths = [src]
-        src = src.parent  # for relative-path bookkeeping below
-    else:
-        raise ValueError(f"Input must be a .tif or directory, got: {src}")
-
-    if not tif_paths:
-        print(f"[cloud_masking] No .tif files found in {src}")
-        return []
-    
-    dir = Path("SEN2CloudEnsemble")
-
-    if not dir.exists():
-
-        mlstac.download(
-            file = "https://huggingface.co/tacofoundation/CloudSEN12-models/resolve/main/SEN2CloudEnsemble/mlm.json",
-            output_dir = "SEN2CloudEnsemble",
-        )
-
-    experiment = mlstac.load(dir.as_posix())
-
-    dm = DeviceManager(experiment, init_device=device)
-
-    masked_paths: list[Path] = []
-
-    # -------------------------------------------------------------------------
-    for idx, tif_path in enumerate(tif_paths, 1):
-        rel = tif_path.relative_to(src)
-        out_dir = dst_dir / rel.parent
-        out_dir.mkdir(parents=True, exist_ok=True)
-
-        mask_path = out_dir / f"{tif_path.stem}_cloudmask.tif"
-        masked_path = out_dir / f"{tif_path.stem}_masked.tif"
-
-        with rio.open(tif_path) as src_img:
-            profile = src_img.profile
-            h, w = src_img.height, src_img.width
-
-        mask_prof = profile.copy()
-        mask_prof.update(driver="GTiff", count=1, dtype="uint8", nodata=255)
-
-        do_tiling = (dm.device == "cuda") or (h * w > max_pix_cpu)
-        full_mask = np.full((h, w), 255, np.uint8)
-
-        t0 = time.perf_counter()
-
-        # ----------------------- inference -----------------------------------
-        if not do_tiling:  # full frame
-            with rio.open(tif_path) as src_img, torch.inference_mode():
-                img = src_img.read().astype(np.float32) / 1e4
-                h32, w32 = (h + 31) // 32 * 32, (w + 31) // 32 * 32
-                pad_b, pad_r = h32 - h, w32 - w
-                tensor = torch.from_numpy(img).unsqueeze(0)
-                if pad_b or pad_r:
-                    tensor = torch.nn.functional.pad(tensor, (0, pad_r, 0, pad_b))
-                mask = dm.model(tensor.to(dm.device)).squeeze(0)
-                full_mask[:] = mask[..., :h, :w].cpu().numpy().astype(np.uint8)
-        else:  # tiled
-            with rio.open(tif_path) as src_img, torch.inference_mode():
-                for y0 in range(0, h, tile):
-                    for x0 in range(0, w, tile):
-                        y0r, x0r = max(0, y0 - pad), max(0, x0 - pad)
-                        y1r, x1r = min(h, y0 + tile + pad), min(w, x0 + tile + pad)
-                        win = rio.windows.Window(x0r, y0r, x1r - x0r, y1r - y0r)
-
-                        patch = src_img.read(window=win).astype(np.float32) / 1e4
-                        tensor = torch.from_numpy(patch).unsqueeze(0).to(dm.device)
-                        mask = dm.model(tensor).squeeze(0).cpu().numpy().astype(np.uint8)
-
-                        y_in0 = pad if y0r else 0
-                        x_in0 = pad if x0r else 0
-                        y_in1 = mask.shape[0] - (pad if y1r < h else 0)
-                        x_in1 = mask.shape[1] - (pad if x1r < w else 0)
-                        core = mask[y_in0:y_in1, x_in0:x_in1]
-                        full_mask[y0 : y0 + core.shape[0], x0 : x0 + core.shape[1]] = core
-
-        # ----------------------- output --------------------------------------
-        if save_mask:
-            with rio.open(mask_path, "w", **mask_prof) as dst:
-                dst.write(full_mask, 1)
-
-        with rio.open(tif_path) as src_img:
-            data = src_img.read()
-            img_prof = src_img.profile.copy()
-
-        masked = data.copy()
-        masked[:, full_mask != 0] = 65535
-        img_prof.update(dtype="uint16", nodata=65535)
-
-        with rio.open(masked_path, "w", **img_prof) as dst:
-            dst.write(masked)
-
-        masked_paths.append(masked_path)
-        dt = time.perf_counter() - t0
-        print(f"[{idx}/{len(tif_paths)}] {rel} → done in {dt:.1f}s")
-
-    if dm.device == "cuda":
-        _reset_gpu()
-
-    total_time = time.perf_counter() - t_start
-    print(f"Processed {len(masked_paths)} image(s) in {total_time:.1f}s.")
-    return masked_paths

satcube-0.1.13/satcube/download.py

@@ -1,57 +0,0 @@
-import pathlib
-import ee
-import cubexpress
-import pandas as pd
-
-
-def download_data(
-    *,                     # keyword-only
-    lon: float,
-    lat: float,
-    cloud_max: int = 40,
-    edge_size: int = 2_048,
-    start: str,
-    end: str,
-    output: str = "raw",
-    scale: int = 10,
-    nworks: int = 4,
-    mosaic: bool = True
-) -> pd.DataFrame:
-    """
-    Download a Sentinel cube for (lon, lat) and return its metadata.
-
-    Parameters
-    ----------
-    lon, lat        Center point in degrees.
-    cloud_max       Max cloud cover (%).
-    edge_size       Square side length (m).
-    start, end      YYYY-MM-DD date range.
-    output          Folder for GeoTIFFs.
-    scale           Pixel size (m).
-    nworks          Parallel workers.
-    mosaic          Merge scenes per date.
-    auto_init_gee   Call ee.Initialize() if needed.
-
-    Returns
-    -------
-    pandas.DataFrame
-        Scene catalogue used for the request.
-    """
-    # Filter scenes
-    df = cubexpress.cloud_table(
-        lon=lon,
-        lat=lat,
-        edge_size=edge_size,
-        scale=scale,
-        cloud_max=cloud_max,
-        start=start,
-        end=end,
-    )
-
-    # Build requests + ensure dir
-    requests = cubexpress.table_to_requestset(df, mosaic=mosaic)
-    pathlib.Path(output).mkdir(parents=True, exist_ok=True)
-
-    # Download cube
-    cubexpress.get_cube(requests, output, nworks)
-    return df