ticoi 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

ticoi/__about__.py

@@ -1 +1 @@
-__version__ = "0.0.1"
+__version__ = "0.1.0"

ticoi/cube_data_classxr.py

@@ -37,13 +37,20 @@ from ticoi.filtering_functions import dask_filt_warpper, dask_smooth_wrapper
 from ticoi.inversion_functions import construction_dates_range_np
 from ticoi.mjd2date import mjd2date
 
+
+from typing import Literal
+
+MethodInterp = Literal["linear", "nearest", "zero", "slinear", "quadratic", "cubic"]
+ReturnAs = Literal["dataframe", "cube"]
+
+
 # %% ======================================================================== #
 #                              CUBE DATA CLASS                                #
 # =========================================================================%% #
 
 
 class CubeDataClass:
-    def __init__(self, cube=None, ds=None):
+    def __init__(self, cube=None, ds: xr.Dataset = None):
         """
         Initialisation of the main attributes, or copy cube's attributes and ds dataset if given.
 
@@ -267,12 +274,6 @@ class CubeDataClass:
 
         self.update_dimension()  # Update self.nx,self.ny,self.nz
 
-        if conf:
-            minconfx = np.nanmin(self.ds["vx_error"].values[:])
-            maxconfx = np.nanmax(self.ds["vx_error"].values[:])
-            minconfy = np.nanmin(self.ds["vy_error"].values[:])
-            maxconfy = np.nanmax(self.ds["vy_error"].values[:])
-
         date1 = np.array([np.datetime64(date_str, "D") for date_str in self.ds["acquisition_date_img1"].values])
         date2 = np.array([np.datetime64(date_str, "D") for date_str in self.ds["acquisition_date_img2"].values])
 
@@ -295,6 +296,10 @@ class CubeDataClass:
         sensor[np.isin(sensor, ["S2A", "S2B"])] = "Sentinel-2"
 
         if conf:  # Normalize the error between 0 and 1, and convert error in confidence
+            minconfx = np.nanmin(self.ds["vx_error"].values[:])
+            maxconfx = np.nanmax(self.ds["vx_error"].values[:])
+            minconfy = np.nanmin(self.ds["vy_error"].values[:])
+            maxconfy = np.nanmax(self.ds["vy_error"].values[:])
             errorx = 1 - (self.ds["vx_error"].values - minconfx) / (maxconfx - minconfx)
             errory = 1 - (self.ds["vy_error"].values - minconfy) / (maxconfy - minconfy)
         else:
@@ -687,7 +692,7 @@ class CubeDataClass:
         filepath: list | str,
         chunks: dict | str | int = {},
         conf: bool = False,
-        subset: str | None = None,
+        subset: list[np.array] | None = None,
         buffer: str | None = None,
         pick_date: str | None = None,
         pick_sensor: str | None = None,
@@ -1044,7 +1049,7 @@ class CubeDataClass:
         :params i, j: [int | float] --- Coordinates to be converted
         :param unit: [int] [default is 365] --- 1 for m/d, 365 for m/y
         :param regu: [int | str] [default is '1accelnotnull'] --- Type of regularization
-        :param coef: [int] [default is 100] --- Coef of Tikhonov regularisation
+        :param coef: [int] [default is 100] --- Coef of Tikhonov regularization
         :param flag: [xr dataset | None] [default is None] --- If not None, the values of the coefficient used for stable areas, surge glacier and non surge glacier
         :param solver: [str] [default is 'LSMR_ini'] --- Solver of the inversion: 'LSMR', 'LSMR_ini', 'LS', 'LS_bounded', 'LSQR'
         :param interp: [str] [default is 'nearest'] --- Interpolation method used to load the pixel when it is not in the dataset ('nearest' or 'linear')
@@ -1056,8 +1061,8 @@ class CubeDataClass:
         :return data: [list | None] --- A list 2 elements : the first one is np.ndarray with the observed
         :return mean: [list | None] --- A list with average vx and vy if solver=LSMR_ini, but the regularization do not require an apriori on the acceleration
         :return dates_range: [list | None] --- Dates between which the displacements will be inverted
-        :return regu: [np array | Nothing] --- If flag is not None, regularisation method to be used for each pixel
-        :return coef: [np array | Nothing] --- If flag is not None, regularisation coefficient to be used for each pixel
+        :return regu: [np array | Nothing] --- If flag is not None, regularization method to be used for each pixel
+        :return coef: [np array | Nothing] --- If flag is not None, regularization coefficient to be used for each pixel
         """
 
         # Variables to keep
@@ -1148,7 +1153,7 @@ class CubeDataClass:
         Delete outliers according to a certain criterium.
 
         :param delete_outliers: [str | float] --- If float delete all velocities which a quality indicator higher than delete_outliers, if median_filter delete outliers that an angle 45° away from the average vector
-        :param flag: [xr dataset | None] [default is None] --- If not None, the values of the coefficient used for stable areas, surge glacier and non surge glacier
+        :param flag: [xr dataset | None] [default is None] --- If not None, the values of the coefficient used for static areas, surge glacier and non surge glacier
         """
 
         if isinstance(delete_outliers, int) or isinstance(delete_outliers, str):
@@ -1350,7 +1355,7 @@ class CubeDataClass:
             elif flag.split(".")[-1] in ["shp", "gpkg"]:  # If flag is a shape file
                 flag = geopandas.read_file(flag).to_crs(self.ds.proj4).clip(self.ds.rio.bounds())
 
-                # surge-type glacier: 2, other glacier: 1, stable area: 0
+                # surge-type glacier: 2, other glacier: 1, static area: 0
                 if field_name is None:
                     if "surge_type" in flag.columns:  # RGI inventory, surge-type glacier: 2, other glacier: 0
                         default_value = 0
@@ -1417,7 +1422,7 @@ class CubeDataClass:
         velo_or_disp: str = "velo",
         select_baseline: int | None = 180,
         verbose: bool = False,
-    ) -> xr.Dataset:
+    ) -> xr.Dataset | None:
         """
            Filter the original data before the inversion:
         -delete outliers according to the provided criterion
@@ -1432,7 +1437,7 @@ class CubeDataClass:
         :param order: [int] [default is 3] --- Order of the smoothing function
         :param unit: [int] [default is 365] --- 365 if the unit is m/y, 1 if the unit is m/d
         :param delete_outliers: [str | float | None] [default is None] --- If float delete all velocities which a quality indicator higher than delete_outliers
-        :param flag: [xr dataset | None] [default is None] --- If not None, the values of the coefficient used for stable areas, surge glacier and non surge glacier
+        :param flag: [xr dataset | None] [default is None] --- If not None, the values of the coefficient used for static areas, surge glacier and non surge glacier
         :param regu: [int | str] [default is "1accelnotnull"] --- Regularisation of the solver
         :param solver: [str] [default is 'LSMR_ini'] --- Solver used to invert the system
         :param proj: [str] [default is 'EPSG:4326'] --- EPSG of i,j projection
@@ -1443,7 +1448,9 @@ class CubeDataClass:
         :return obs_filt: [xr dataset | None] --- Filtered dataset
         """
 
-        def loop_rolling(da_arr: xr.Dataset, select_baseline: int | None = 180) -> (np.ndarray, np.ndarray):  # type: ignore
+        def loop_rolling(
+            da_arr: xr.Dataset | xr.DataArray, select_baseline: int | None = 180
+        ) -> (np.ndarray, np.ndarray):  # type: ignore
             """
             A function to calculate spatial mean, resample data, and calculate smoothed velocity.
 
@@ -1532,7 +1539,7 @@ class CubeDataClass:
             self.ds["vx"] = self.ds["vx"] / self.ds["temporal_baseline"] * unit
             self.ds["vy"] = self.ds["vy"] / self.ds["temporal_baseline"] * unit
 
-        if flag is not None:  # create a flag, to identify stable,areas, and eventually surges
+        if flag is not None:  # create a flag, to identify static,areas, and eventually surges
             flag = self.create_flag(flag)
             flag.load()
 
@@ -1927,7 +1934,7 @@ class CubeDataClass:
         self,
         points_heatmap: pd.DataFrame,
         variable: str = "vv",
-        method_interp: str = "linear",
+        method_interp: MethodInterp = "linear",
         verbose: bool = False,
         freq: str = "MS",
         method: str = "mean",
@@ -2049,56 +2056,36 @@ class CubeDataClass:
             )
         ).reshape(self.nx, self.ny)
 
-    def compute_med_stable_areas(
-        self, shapefile_path, return_as="dataframe", stat_name="med", var_list=["vx", "vy"], invert=True
+    def compute_med_static_areas(
+        self,
+        shapefile_path: str,
+        return_as: ReturnAs = "dataframe",
+        var_list: list[str] = ["vx", "vy"],
+        invert: bool = True,
     ):
         """
-        Compute MAD per time step using Dask and apply_ufunc over a shapefile-defined area.
-
-        Parameters:
+        Compute median values in static areas
 
-            shapefile_path (str): Path to shapefile.
-            return_as (str): 'dataframe' or 'cube'.
-            stat_name (str): Base variable name for new data.
-            invert (bool): Whether to invert the shapefile mask.
+        :param shapefile_path: Path to shapefile.
+        :param var_list: List of variable names.
+        :param invert: Whether to invert the shapefile mask.
 
-        Returns:
-            pd.DataFrame or xr.Dataset
+        :return: pd.DataFrame or xr.Dataset
         """
-        # Ensure data has Dask chunks
-        # self.ds = self.ds.chunk({'y': -1, 'x': -1, 'mid_date': 10})
-        print(var_list)
+
         # Clip with shapefile
         gdf = gpd.read_file(shapefile_path)
         gdf = gdf.to_crs(self.ds.rio.crs)
         masked = self.ds.rio.clip(gdf.geometry, gdf.crs, drop=False, all_touched=True, invert=invert)
 
-        print("Clipped")
+        mad_results = masked[var_list].median(dim=["x", "y"]).compute()
 
-        # Return as DataFrame
         if return_as == "dataframe":
-            df_vx = (
-                masked["vx"]
-                .median(dim=["x", "y"])
-                .compute()
-                .to_dataframe(name=f"{stat_name}_vx")
-                .reset_index()[["mid_date", f"{stat_name}_vx"]]
-            )
-            df_vy = (
-                masked["vy"]
-                .median(dim=["x", "y"])
-                .compute()
-                .to_dataframe(name=f"{stat_name}_vy")
-                .reset_index()[["mid_date", f"{stat_name}_vy"]]
-            )
-            if len(var_list) == 3:
-                df_v = (
-                    masked[var_list[2]]
-                    .median(dim=["x", "y"])
-                    .compute()
-                    .to_dataframe(name=f"{stat_name}_v")
-                    .reset_index()[["mid_date", f"{stat_name}_v"]]
-                )
+            # Return as DataFrame
+            df_vx = mad_results["vx"].to_dataframe(name="med_vx").reset_index()[["mid_date", "med_vx"]]
+            df_vy = mad_results["vy"].to_dataframe(name="med_vy").reset_index()[["mid_date", "med_vy"]]
+            if len(var_list) == 3:  # for vv
+                df_v = mad_results[var_list[2]].to_dataframe(name="med_v").reset_index()[["mid_date", "med_v"]]
 
             # Merge on time coordinate (e.g., 'mid_date')
             if len(var_list) == 3:
@@ -2110,81 +2097,57 @@ class CubeDataClass:
 
             return merged_df
 
-        # # Return as cube
-        # elif return_as == 'cube':
-        #     return self.assign({f'{stat_name}_vx': mad_results['vx'], f'{stat_name}_vy': mad_results['vy']})
+        # Return as cube
+        elif return_as == "cube":
+            return self.assign({"nmad_vx": mad_results["vx"], "nmad_vy": mad_results["vy"]})
 
         else:
             raise ValueError("return_as must be 'dataframe' or 'cube'")
 
-    def compute_mad(self, shapefile_path, return_as="dataframe", stat_name="mad", var_list=["vx", "vy"], invert=True):
+    def compute_nmad(
+        self,
+        shapefile_path: str,
+        return_as: ReturnAs = "dataframe",
+        var_list: list[str] = ["vx", "vy"],
+        invert: bool = True,
+    ):
         """
-        Compute MAD per time step using Dask and apply_ufunc over a shapefile-defined area.
-
-        Parameters:
 
-            shapefile_path (str): Path to shapefile.
-            return_as (str): 'dataframe' or 'cube'.
-            stat_name (str): Base variable name for new data.
-            invert (bool): Whether to invert the shapefile mask.
+        :param shapefile_path: Path to shapefile.
+        :param return_as: 'dataframe' or 'cube'.
+        :param var_list:
+        :param invert: Whether to invert the shapefile mask.
 
-        Returns:
-            pd.DataFrame or xr.Dataset
+        :return: pd.DataFrame or xr.Dataset
         """
-        # Ensure data has Dask chunks
-        self.ds = self.ds.chunk({"y": -1, "x": -1, "mid_date": 10})
-        print(var_list)
+
         # Clip with shapefile
         gdf = gpd.read_file(shapefile_path)
         gdf = gdf.to_crs(self.ds.rio.crs)
-        masked = self.ds.rio.clip(gdf.geometry, gdf.crs, drop=False, all_touched=True, invert=invert)
+        masked_gpd = self.ds.rio.clip(gdf.geometry, gdf.crs, drop=False, all_touched=True, invert=invert)
 
-        print("Clipped")
+        masked = masked_gpd.dropna(dim="x", how="all").dropna(dim="y", how="all").dropna(dim="mid_date", how="all")
 
         # Define MAD function
         def mad_2d(arr):
             median = np.nanmedian(arr)
             return 1.483 * np.nanmedian(np.abs(arr - median))
 
-        mad_results = {}  # Store MAD DataArrays
-
-        for var in var_list:
-            data = masked[var]
-
-            mad = xr.apply_ufunc(
-                mad_2d,
-                data,
-                input_core_dims=[["y", "x"]],
-                output_core_dims=[[]],
-                vectorize=True,
-                dask="parallelized",
-                output_dtypes=[data.dtype],
-            )
-
-            mad.name = f"{stat_name}_{var}"
-            mad_results[var] = mad
+        mad_results = xr.apply_ufunc(
+            mad_2d,
+            masked[var_list],
+            input_core_dims=[["y", "x"]],
+            output_core_dims=[[]],
+            vectorize=True,
+            dask="parallelized",
+        ).compute()
 
         # Return as DataFrame
         if return_as == "dataframe":
-            df_vx = (
-                mad_results["vx"]
-                .compute()
-                .to_dataframe(name=f"{stat_name}_vx")
-                .reset_index()[["mid_date", f"{stat_name}_vx"]]
-            )
-            df_vy = (
-                mad_results["vy"]
-                .compute()
-                .to_dataframe(name=f"{stat_name}_vy")
-                .reset_index()[["mid_date", f"{stat_name}_vy"]]
-            )
+            df_vx = mad_results["vx"].to_dataframe(name="nmad_vx").reset_index()[["mid_date", "nmad_vx"]]
+            df_vy = mad_results["vy"].to_dataframe(name="nmad_vy").reset_index()[["mid_date", "nmad_vy"]]
             if len(var_list) == 3:
-                df_v = (
-                    mad_results[var_list[2]]
-                    .compute()
-                    .to_dataframe(name=f"{stat_name}_v")
-                    .reset_index()[["mid_date", f"{stat_name}_v"]]
-                )
+                df_v = mad_results[var_list[2]].to_dataframe(name="nmad_v").reset_index()[["mid_date", "nmad_v"]]
 
             # Merge on time coordinate (e.g., 'mid_date')
             if len(var_list) == 3:
@@ -2198,7 +2161,7 @@ class CubeDataClass:
 
         # Return as cube
         elif return_as == "cube":
-            return self.assign({f"{stat_name}_vx": mad_results["vx"], f"{stat_name}_vy": mad_results["vy"]})
+            return self.assign({"nmad_vx": mad_results["vx"], "nmad_vy": mad_results["vy"]})
 
         else:
             raise ValueError("return_as must be 'dataframe' or 'cube'")

{ticoi-0.0.1.dist-info → ticoi-0.1.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: ticoi
-Version: 0.0.1
+Version: 0.1.0
 Summary: A package to run Temporal Inversion using linear Combinations of Observations, and Interpolation (TICOI)
 Project-URL: Homepage, https://github.com/ticoi/ticoi.git
-Project-URL: Issues, https://github.com/pypa/sampleproject/issues
+Project-URL: Issues, https://github.com/ticoi/ticoi/issues
 Author: Lei Guo
 Author-email: Laurane Charrier <laurane.charrier@outlook.com>
 License: GPL-3.0-only
@@ -81,18 +81,14 @@ Clone the git repo and create a `mamba` environment (see how to install `mamba`
 the [mamba documentation](https://mamba.readthedocs.io/en/latest/)):
 
 ```bash
-git clone git@github.com:ticoi/ticoi.git
-cd ticoi
 mamba env create -f environment.yml  # Add '-n custom_name' if you want.
-mamba activate environment  # Or any other name specified above
+mamba install -c conda-forge ticoi
 ```
 
 ### With `pip`
 
 ```bash
-python3.10 -m venv ticoi-env
-source ticoi-env/bin/activate
-pip install git+https://github.com/ticoi/ticoi.git
+pip install ticoi
 ```
 
 ## TUTORIALS
@@ -114,6 +110,7 @@ pip install git+https://github.com/ticoi/ticoi.git
 * [How to process one ITS_LIVE cube directly from the cloud](/examples/advanced/cube_ticoi_demo_its_live.py)
 * [How to format several geotiff files into a netCDF file](examples/advanced/cube_prep_from_geotiff.py)
 * [How to apply GLAFT on TICOI results](examples/advanced/glaft_for_ticoi_results.py)
+* [How to compute statistics in static areas](examples/advanced/stats_in_static_areas.py)
 
 ## TO USE YOUR OWN DATASET
 

{ticoi-0.0.1.dist-info → ticoi-0.1.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-ticoi/__about__.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
+ticoi/__about__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
 ticoi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ticoi/core.py,sha256=uW-t8g46sKEuJ2e_Xh--MXHRNwbyruOm84a3N6qRAT0,67652
-ticoi/cube_data_classxr.py,sha256=HSSVZmnfR3eDe_TnagmBHEPO1uAgqq_Jfgmy-sdZPik,103777
+ticoi/cube_data_classxr.py,sha256=noOkdbecfRY8iT-ZB6gHtD8mchxXFV5ScA7ConU6edo,102605
 ticoi/cube_writer.py,sha256=mGz79Drme9Ub983t_pS1-VIRHpSxRwU21GAoznkqYq4,32806
 ticoi/example.py,sha256=YqUPXH7YcW75O1w3VFkcgyOFChnn1OR0syxVop-lWM8,3300
 ticoi/filtering_functions.py,sha256=IYEZTllbrfmZ_EqtXFYyWaNFGaZ7akjmJ7HkYdcKIjU,26633
@@ -12,7 +12,7 @@ ticoi/optimize_coefficient_functions.py,sha256=IRoumcK_KAspz4qeYEEaYDLsO_nvY3lke
 ticoi/pixel_class.py,sha256=xv29Z3w7xTgdRQN7Qe6zeARwT-KdRMW8thIoJCj5Sw8,81771
 ticoi/seasonality_functions.py,sha256=4oMsHxgD1jlkJSsIDGFHmb311b48IkrT2xUx3Z4X-1g,9153
 ticoi/utils.py,sha256=tfmP2g5iF1MEq_Z1CBNCSz0KsMPRHI_lUgGEz_nGi3o,29403
-ticoi-0.0.1.dist-info/METADATA,sha256=fLQzemVjfHH9dJ9eYCt5wNrm9JIIdw055fejxdS84eM,6441
-ticoi-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ticoi-0.0.1.dist-info/licenses/LICENSE,sha256=2n6rt7r999OuXp8iOqW9we7ORaxWncIbOwN1ILRGR2g,7651
-ticoi-0.0.1.dist-info/RECORD,,
+ticoi-0.1.0.dist-info/METADATA,sha256=Wg1MZUYTbOxBZKNL5XukCQyoXVnXiqDg3Lm57TslsBg,6353
+ticoi-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ticoi-0.1.0.dist-info/licenses/LICENSE,sha256=2n6rt7r999OuXp8iOqW9we7ORaxWncIbOwN1ILRGR2g,7651
+ticoi-0.1.0.dist-info/RECORD,,