satcube 0.1.17__py3-none-any.whl → 0.1.18__py3-none-any.whl

satcube/objects.py

@@ -1,26 +1,33 @@
-# satcube/objects.py
 from __future__ import annotations
 from dataclasses import dataclass, field
 import pathlib
 import pandas as pd
+from typing import Tuple
+from datetime import datetime
+import numpy as np
+import xarray as xr
+import rasterio as rio
+import torch
 
-from satcube.align  import align as _align_fn
-from satcube.cloud_detection  import cloud_masking as _cloud_fn
+from satcube.align  import align_fn
+from satcube.cloud  import cloud_fn
+from satcube.gapfill import gapfill_fn 
+from satcube.composite import monthly_composites_s2
+from satcube.smooth import gaussian_smooth
 
 @dataclass
 class SatCubeMetadata:
-    df: pd.DataFrame = field(repr=False)
-    raw_dir: pathlib.Path = field(repr=False)
+    df: pd.DataFrame
+    raw_dir: pathlib.Path
+    _current_dir: pathlib.Path | None = None
 
-    def __repr__(self) -> str: 
-        return self.df.__repr__()
-    
-    __str__ = __repr__
-    
-    def _repr_html_(self) -> str:
-        html = getattr(self.df, "_repr_html_", None)
-        return html() if callable(html) else self.df.__repr__()
 
+    def _dir(self) -> pathlib.Path:
+        return self._current_dir or self.raw_dir
+    
+    def _spawn(self, *, df: pd.DataFrame, current_dir: pathlib.Path) -> "SatCubeMetadata":
+        return SatCubeMetadata(df=df, raw_dir=self.raw_dir, _current_dir=current_dir)
+        
     def align(
         self,
         input_dir: str | pathlib.Path | None = None,
@@ -28,44 +35,209 @@ class SatCubeMetadata:
         nworks: int = 4,
         cache: bool = False
     ) -> "SatCubeMetadata":
-        
-        if input_dir is None:
-            input_dir = self.raw_dir
-        else:
-            input_dir = pathlib.Path(input_dir).expanduser().resolve()
 
-        _align_fn(
+        self.aligned_dir = pathlib.Path(output_dir).resolve()
+        
+        input_dir = pathlib.Path(input_dir).expanduser().resolve() if input_dir else self._dir()
+        output_dir = pathlib.Path(output_dir).resolve()
+        
+        new_df = align_fn(
+            metadata=self.df,
             input_dir=input_dir, 
-            output_dir=output_dir, 
+            output_dir=self.aligned_dir, 
             nworks=nworks, 
             cache=cache
         )
-        self.aligned_dir = pathlib.Path(output_dir).resolve()
-        return self
+                
+        return self._spawn(df=new_df, current_dir=output_dir)
 
     def cloud_masking(
         self,
+        input_dir: str | pathlib.Path | None = None,
         output_dir: str | pathlib.Path = "masked",
-        model_path: str | pathlib.Path = "SEN2CloudEnsemble",
-        device: str = "cpu"
+        device: str = "cpu",
+        cache: bool = False,
+        nworks: int = 4,
+    ) -> "SatCubeMetadata":
+        
+        input_dir = pathlib.Path(input_dir).expanduser().resolve() if input_dir else self._dir()
+        output_dir = pathlib.Path(output_dir).resolve()
+
+            
+        new_df = cloud_fn(
+            metadata=self.df,
+            input_dir=input_dir,
+            output_dir=output_dir,
+            device=device,
+            nworks=nworks,
+            cache=cache
+        )
+        
+        return self._spawn(df=new_df, current_dir=output_dir)
+
+    def gap_fill(
+        self,
+        *,
+        input_dir: str | pathlib.Path | None = None,
+        output_dir: str | pathlib.Path = "gapfilled",
+        method: str = "histogram_matching",
+        quiet: bool = False
+    ) -> "SatCubeMetadata":
+        """Fill small cloud/shadow gaps on top of current stack."""
+        in_dir  = pathlib.Path(input_dir).expanduser().resolve() if input_dir else self._dir()
+        out_dir = pathlib.Path(output_dir).resolve()
+
+        new_df = gapfill_fn(
+            metadata=self.df,
+            input_dir=in_dir,
+            output_dir=out_dir,
+            method=method,
+            quiet=quiet,
+        )
+        
+        return self._spawn(df=new_df, current_dir=out_dir)
+    
+    def monthly_composites(
+        self,
+        input_dir: str | pathlib.Path | None = None,
+        output_dir: str | pathlib.Path = "monthly_composites",
+        agg_method: str = "median"
+    ) -> "SatCubeMetadata":
+        
+        input_dir = pathlib.Path(input_dir).expanduser().resolve() if input_dir else self._dir()
+        output_dir = pathlib.Path(output_dir).resolve()
+        
+        date_range = (self.df["date"].min(), self.df["date"].max())
+
+        out_table = monthly_composites_s2(
+            metadata=self.df,
+            input_dir=input_dir,
+            output_dir=output_dir,
+            date_range=date_range,
+            agg_method=agg_method
+        )
+
+        return self._spawn(df=out_table, current_dir=output_dir)
+    
+    def interpolate(
+        self, 
+        input_dir: str | pathlib.Path | None = None,
+        output_dir: str | pathlib.Path = "interpolated",
     ) -> "SatCubeMetadata":
-        if not hasattr(self, "aligned_dir"):
-            raise RuntimeError("You must run .align() first")
-        _cloud_fn(
-            input=self.aligned_dir,
-            output=output_dir,
-            model_path=model_path,
-            device=device
+
+
+        input_dir = pathlib.Path(input_dir).expanduser().resolve() if input_dir else self._dir()
+        output_dir = pathlib.Path(output_dir).resolve()
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        all_raw_files = [input_dir / f for f in input_dir.glob("*.tif") if f.is_file()]
+
+        all_raw_files.sort()
+        all_raw_dates = pd.to_datetime(self.df["date"])
+
+        # Create a data cube with xarray
+        profile = rio.open(all_raw_files[0]).profile
+        data_np = np.array([rio.open(file).read() for file in all_raw_files]) / 10000  # Normalize
+        data_np[data_np == 6.5535] = np.nan  # Set NoData values to NaN
+        data_np = xr.DataArray(
+            data=data_np,
+            dims=("time", "band", "y", "x"),
+            coords={"time": all_raw_dates, "band": range(13)},
+        )
+
+        data_np = data_np.interpolate_na(dim="time", method="linear")
+
+        # Save the interpolated images
+        for idx, file in enumerate(all_raw_files):
+            current_data = data_np[idx].values
+            date = pd.to_datetime(self.df["date"].iloc[idx]).strftime("%Y-%m-%d")
+            with rio.open(output_dir / f"{date}.tif", "w", **profile) as dst:
+                dst.write((current_data * 10000).astype(np.uint16))  # Save the interpolated image
+
+        return self._spawn(df=self.df, current_dir=output_dir)
+
+    def smooth(
+        self,
+        input_dir: str | pathlib.Path | None = None,
+        output_dir: str | pathlib.Path = "smoothed",
+        smooth_w: int = 7,
+        smooth_p: int = 2,
+        device: str | torch.device = "cpu",
+    ) -> "SatCubeMetadata":
+
+        input_dir = pathlib.Path(input_dir).expanduser().resolve() if input_dir else self._dir()
+        output_dir = pathlib.Path(output_dir).resolve()
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        all_raw_files = list(input_dir / self.df["outname"])
+        out_files = [output_dir / file.name for file in all_raw_files]
+    
+        profile = rio.open(all_raw_files[0]).profile
+        data_np = (np.array([rio.open(file).read() for file in all_raw_files]) / 10000).astype(np.float32)
+
+        data_month = pd.to_datetime(self.df["date"]).dt.month
+        data_clim = []
+        for month in range(1, 13):
+            data_clim.append(data_np[data_month == month].mean(axis=0) / 10000)
+        data_clim = np.array(data_clim)
+
+        for idx, month in enumerate(data_month):
+            data_np[idx] = data_np[idx] - data_clim[month - 1]
+
+        # Smooth the residuals using Gaussian smoothing
+        data_np = torch.from_numpy(data_np).float().to(device)
+        try:
+            data_np = (
+                gaussian_smooth(
+                    data_np, kernel_size=smooth_w, sigma=smooth_p
+                ).cpu().numpy()
+            )
+        except Exception as e:
+            print(e)
+            data_np = data_np.cpu().numpy()
+
+        # Add the residuals back to the climatology
+        for idx, month in enumerate(data_month):
+            data_np[idx] = data_np[idx] + data_clim[month - 1]
+
+        # Save the smoothed images
+        for idx, file in enumerate(out_files):
+            with rio.open(file, "w", **profile) as dst:
+                    dst.write((data_np[idx] * 10000).astype(np.uint16))
+
+        # Prepare the new table
+        new_table = pd.DataFrame(
+            {
+                "date": self.df["date"],
+                "outname": self.df["outname"],
+            }
         )
-        self.masked_dir = pathlib.Path(output_dir).resolve()
-        return self
+
+        return self._spawn(df=new_table, current_dir=output_dir)    
+
+    def filter_metadata(self, condition) -> "SatCubeMetadata":
+        filtered_df = self.df[condition(self.df)]
+        return self._spawn(df=filtered_df, current_dir=self._current_dir)
+    
+    def __repr__(self) -> str: 
+        return self.df.__repr__()
+    
+    __str__ = __repr__
+    
+    def _repr_html_(self) -> str:
+        html = getattr(self.df, "_repr_html_", None)
+        return html() if callable(html) else self.df.__repr__()
     
     def __getattr__(self, item):
         return getattr(self.df, item)
 
     def __getitem__(self, key):
-        return self.df.__getitem__(key)
-    
+        if isinstance(key, pd.Series) or isinstance(key, pd.DataFrame): 
+            filtered_df = self.df[key]
+            return self._spawn(df=filtered_df, current_dir=self._current_dir)
+        return self.df[key]
     def __len__(self):
         return len(self.df)
-    
+    
+    def update_metadata(self, new_df: pd.DataFrame) -> None:
+        self.df = new_df

satcube/smooth.py

@@ -0,0 +1,46 @@
+import torch.nn.functional as F
+import torch
+import numpy as np  
+
+def gaussian_kernel1d(kernel_size: int, sigma: float):
+    """
+    Returns a 1D Gaussian kernel.
+    """
+    # Create a tensor with evenly spaced values centered at 0
+    x = torch.linspace(-(kernel_size // 2), kernel_size // 2, kernel_size)
+    # Calculate the Gaussian function
+    kernel = torch.exp(-(x**2) / (2 * sigma**2))
+    # Normalize the kernel to ensure the sum of all elements is 1
+    kernel = kernel / kernel.sum()
+    return kernel
+
+
+def gaussian_smooth(tensor, kernel_size: int, sigma: float):
+    """
+    Apply Gaussian smoothing on the time dimension (first dimension) of the input tensor.
+
+    Args:
+    - tensor (torch.Tensor): Input tensor of shape (T, C, H, W) where T is the time dimension.
+    - kernel_size (int): Size of the Gaussian kernel.
+    - sigma (float): Standard deviation of the Gaussian kernel.
+
+    Returns:
+    - smoothed_tensor (torch.Tensor): Smoothed tensor.
+    """
+    if isinstance(tensor, np.ndarray):
+        tensor = torch.from_numpy(tensor) 
+    # Get the Gaussian kernel
+    kernel = gaussian_kernel1d(kernel_size, sigma).to(tensor.device).view(1, 1, -1)
+
+    # Prepare the tensor for convolution: (B, C, T) where B = C*H*W, C=1, T=102
+    T, C, H, W = tensor.shape
+    tensor = tensor.view(T, -1).permute(1, 0).unsqueeze(1)  # Shape: (C*H*W, 1, T)
+
+    # Apply convolution
+    padding = kernel_size // 2
+    smoothed = F.conv1d(tensor, kernel, padding=padding, groups=1)
+
+    # Reshape back to original shape
+    smoothed = smoothed.squeeze(1).permute(1, 0).view(T, C, H, W)
+
+    return smoothed

{satcube-0.1.17.dist-info → satcube-0.1.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satcube
-Version: 0.1.17
+Version: 0.1.18
 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

satcube-0.1.18.dist-info/RECORD

@@ -0,0 +1,17 @@
+satcube/__init__.py,sha256=LtMqWBMAhz_QJQAQweBmKKJJoSqCFZ0ptCuxZ0WUPRs,209
+satcube/align.py,sha256=Ej5v2lLMtbAFQnme6GCOiTHVNCni2WDVGLK5BEvTYO8,3674
+satcube/archive_cloud_detection.py,sha256=HK8hTmxHziFGux6S91Rvob5FA0tuaKyES6FdG7Wiupo,749
+satcube/archive_dataclass.py,sha256=v_ReYzzwAK7bQVBXLhdcCHZZJ1-Vbibx5vtZ11SYDK0,933
+satcube/archive_main.py,sha256=QfdVyJcwCXMMtIFCOlVU7FoilDpkx9Oa6jN2MamFPhI,14852
+satcube/archive_utils.py,sha256=hnmUF5052PK4NJxUZCHSIWvekU6AllvHc2bxpF2TaXI,35064
+satcube/cloud.py,sha256=PL_wFH2HkfYXOELbxLcY-L5KCwBq0qX0BKS9X4w4t5s,7910
+satcube/composite.py,sha256=H0cZyEgiAGqB2KjHYrkW8HFSyaxieDGCd8h0tS-D36E,2773
+satcube/download.py,sha256=zWnsmxwDhg8TtLiRpPVPmc8vcceLH1sVMemx3aLQuwE,1453
+satcube/gapfill.py,sha256=Wpdx7JejxFgE3pdyV53-hqsT05-5IOPfEEuDhBhG8Dc,6763
+satcube/objects.py,sha256=B9v0LXzdd6Hg35Gxugd7Gv8pPH3gMYbwrv9fVPydV28,8385
+satcube/smooth.py,sha256=B7laeb3Z3QQLzGx22wIsCEt_F6PZevOXG59ZzzYgUg8,1614
+satcube/utils.py,sha256=QBdmSg6_4Vy-4mXH1Z3Z2AvbIKAXBYi5g3-IgWSE1MY,3660
+satcube-0.1.18.dist-info/LICENSE,sha256=YdB4BQMkMzWuKvXRIpQR4g91IQ_pwA5PSH2lNM97zFI,1070
+satcube-0.1.18.dist-info/METADATA,sha256=5dI7dilinMGbBhWCJ2R65yRKrJGofng6yBzMMvD03eU,6559
+satcube-0.1.18.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+satcube-0.1.18.dist-info/RECORD,,

satcube-0.1.17.dist-info/RECORD

@@ -1,10 +0,0 @@
-satcube/__init__.py,sha256=1q5c8Kx1dePuPBo29O7-1MA0L_GdBhi56gbxjQAa1_o,317
-satcube/align.py,sha256=_WCNgI0KhrI8b_aEnR-ecnqaILBV_eCdTuR0V18FwPA,3007
-satcube/cloud_detection.py,sha256=05OifUtWjE5jco8Q1jf_7qoQ45qrnJQgRc6LrPlMkLI,7898
-satcube/download.py,sha256=o8kwPzipU1f_pV0KNPLmLmjUEsoWb6yhkCt7kerDViU,1545
-satcube/objects.py,sha256=zhiYu-rUTm65TuEl2qIo7kLfpdam17_6CZl2KBCT9Jw,1988
-satcube/utils.py,sha256=QBdmSg6_4Vy-4mXH1Z3Z2AvbIKAXBYi5g3-IgWSE1MY,3660
-satcube-0.1.17.dist-info/LICENSE,sha256=YdB4BQMkMzWuKvXRIpQR4g91IQ_pwA5PSH2lNM97zFI,1070
-satcube-0.1.17.dist-info/METADATA,sha256=JH4s1yC_43FND-i42X5kXA5W-3UdGa62htVk-Hq-_l8,6559
-satcube-0.1.17.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-satcube-0.1.17.dist-info/RECORD,,