dea-tools 0.3.5.dev20__tar.gz → 0.3.5.dev23__tar.gz

{dea_tools-0.3.5.dev20/dea_tools.egg-info → dea_tools-0.3.5.dev23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dea-tools
-Version: 0.3.5.dev20
+Version: 0.3.5.dev23
 Summary: Functions and algorithms for analysing Digital Earth Australia data.
 Home-page: https://github.com/GeoscienceAustralia/dea-notebooks
 Author: Geoscience Australia
@@ -44,7 +44,7 @@ Requires-Dist: pyproj
 Requires-Dist: pystac-client
 Requires-Dist: planetary-computer
 Requires-Dist: python-dateutil
-Requires-Dist: pyTMD<2.1.5,>=2.0.0
+Requires-Dist: pyTMD<=2.1.6
 Requires-Dist: pytz
 Requires-Dist: rasterio
 Requires-Dist: rasterstats

{dea_tools-0.3.5.dev20 → dea_tools-0.3.5.dev23}/dea_tools/classification.py

@@ -226,6 +226,7 @@ def predict_xr(
     chunk_size=None,
     persist=False,
     proba=False,
+    max_proba=True,
     clean=False,
     return_input=False,
 ):
@@ -255,6 +256,11 @@ def predict_xr(
         distributed RAM.
     proba : bool
         If True, predict probabilities
+    max_proba : bool
+        If True, the probabilities array will be flattened to contain
+        only the probabiltiy for the "Predictions" class. If False, 
+        the "Probabilities" object will be an array of prediction
+        probaiblities for each classes
     clean : bool
         If True, remove Infs and NaNs from input and output arrays
     return_input : bool
@@ -282,7 +288,7 @@ def predict_xr(
             input_xr.chunks["y"][0]
         )
 
-    def _predict_func(model, input_xr, persist, proba, clean, return_input):
+    def _predict_func(model, input_xr, persist, proba, max_proba, clean, return_input):
         x, y, crs = input_xr.x, input_xr.y, input_xr.geobox.crs
 
         input_data = []
@@ -330,18 +336,35 @@ def predict_xr(
             print("   probabilities...")
             out_proba = model.predict_proba(input_data_flattened)
 
-            # convert to %
-            out_proba = da.max(out_proba, axis=1) * 100.0
+            # return either one band with the max probability, or the whole probability array
+            if max_proba == True:
+                print("  returning single probability band.")
+                out_proba = da.max(out_proba, axis=1) * 100.0
+                out_proba = out_proba.reshape(len(y), len(x))
+                out_proba = xr.DataArray(
+                    out_proba, coords={"x": x, "y": y}, dims=["y", "x"]
+                )
+                output_xr["Probabilities"] = out_proba
+            else:
+                print("  returning class probability array.")
+                out_proba = out_proba * 100.0
+                class_names = model.classes_  # Get the unique class names from the fitted classifier
+
+                # Loop through each class (band)
+                probabilities_dataset = xr.Dataset()
+                for i, class_name in enumerate(class_names):
+                    reshaped_band = out_proba[:, i].reshape(len(y), len(x))
+                    reshaped_da = xr.DataArray(
+                        reshaped_band, coords={"x": x, "y": y}, dims=["y", "x"]
+                    )
+                    probabilities_dataset[f"prob_{class_name}"] = reshaped_da
 
+                # merge in the probabilities
+                output_xr = xr.merge([output_xr, probabilities_dataset])
+            
             if clean == True:
                 out_proba = da.where(da.isfinite(out_proba), out_proba, 0)
-
-            out_proba = out_proba.reshape(len(y), len(x))
-
-            out_proba = xr.DataArray(
-                out_proba, coords={"x": x, "y": y}, dims=["y", "x"]
-            )
-            output_xr["Probabilities"] = out_proba
+            
 
         if return_input == True:
             print("   input features...")
@@ -391,12 +414,12 @@ def predict_xr(
         model = ParallelPostFit(model)
         with joblib.parallel_backend("dask"):
             output_xr = _predict_func(
-                model, input_xr, persist, proba, clean, return_input
+                model, input_xr, persist, proba, max_proba, clean, return_input
             )
 
     else:
         output_xr = _predict_func(
-            model, input_xr, persist, proba, clean, return_input
+            model, input_xr, persist, proba, max_proba, clean, return_input
         ).compute()
 
     return output_xr

{dea_tools-0.3.5.dev20 → dea_tools-0.3.5.dev23}/dea_tools/coastal.py

@@ -288,120 +288,243 @@ def _model_tides(
         lat.max() + buffer,
     ]
 
-    # Read tidal constants and interpolate to grid points
-    if pytmd_model.format in ("OTIS", "ATLAS", "TMD3"):
-        amp, ph, D, c = pyTMD.io.OTIS.extract_constants(
-            lon,
-            lat,
-            pytmd_model.grid_file,
-            pytmd_model.model_file,
-            pytmd_model.projection,
-            type=pytmd_model.type,
-            crop=crop,
-            bounds=bounds,
-            method=method,
-            extrapolate=extrapolate,
-            cutoff=cutoff,
-            grid=pytmd_model.format,
+    # TEMPORARY HACK to work on both old and new pyTMD
+    try:
+            
+        # Read tidal constants and interpolate to grid points
+        if pytmd_model.format in ("OTIS", "ATLAS", "TMD3"):
+            amp, ph, D, c = pyTMD.io.OTIS.extract_constants(
+                lon,
+                lat,
+                pytmd_model.grid_file,
+                pytmd_model.model_file,
+                pytmd_model.projection,
+                type=pytmd_model.type,
+                crop=crop,
+                bounds=bounds,
+                method=method,
+                extrapolate=extrapolate,
+                cutoff=cutoff,
+                grid=pytmd_model.format,
+            )
+    
+            # Use delta time at 2000.0 to match TMD outputs
+            deltat = np.zeros((len(timescale)), dtype=np.float64)
+    
+        elif pytmd_model.format == "netcdf":
+            amp, ph, D, c = pyTMD.io.ATLAS.extract_constants(
+                lon,
+                lat,
+                pytmd_model.grid_file,
+                pytmd_model.model_file,
+                type=pytmd_model.type,
+                crop=crop,
+                bounds=bounds,
+                method=method,
+                extrapolate=extrapolate,
+                cutoff=cutoff,
+                scale=pytmd_model.scale,
+                compressed=pytmd_model.compressed,
+            )
+    
+            # Use delta time at 2000.0 to match TMD outputs
+            deltat = np.zeros((len(timescale)), dtype=np.float64)
+    
+        elif pytmd_model.format == "GOT":
+            amp, ph, c = pyTMD.io.GOT.extract_constants(
+                lon,
+                lat,
+                pytmd_model.model_file,
+                crop=crop,
+                bounds=bounds,
+                method=method,
+                extrapolate=extrapolate,
+                cutoff=cutoff,
+                scale=pytmd_model.scale,
+                compressed=pytmd_model.compressed,
+            )
+    
+            # Delta time (TT - UT1)
+            deltat = timescale.tt_ut1
+    
+        elif pytmd_model.format == "FES":
+            amp, ph = pyTMD.io.FES.extract_constants(
+                lon,
+                lat,
+                pytmd_model.model_file,
+                type=pytmd_model.type,
+                version=pytmd_model.version,
+                crop=crop,
+                bounds=bounds,
+                method=method,
+                extrapolate=extrapolate,
+                cutoff=cutoff,
+                scale=pytmd_model.scale,
+                compressed=pytmd_model.compressed,
+            )
+    
+            # Available model constituents
+            c = pytmd_model.constituents
+    
+            # Delta time (TT - UT1)
+            deltat = timescale.tt_ut1
+    
+        # Calculate complex phase in radians for Euler's
+        cph = -1j * ph * np.pi / 180.0
+    
+        # Calculate constituent oscillation
+        hc = amp * np.exp(cph)
+    
+        # Determine the number of points and times to process. If in
+        # "one-to-many" mode, these counts are used to repeat our extracted
+        # constituents and timesteps so we can extract tides for all
+        # combinations of our input times and tide modelling points.
+        # If in "one-to-one" mode, we avoid this step by setting counts to 1
+        # (e.g. "repeat 1 times")
+        points_repeat = len(x) if mode == "one-to-many" else 1
+        time_repeat = len(time) if mode == "one-to-many" else 1
+    
+        # If in "one-to-many" mode, repeat constituents to length of time
+        # and number of input coords before passing to `predict_tide_drift`
+        t, hc, deltat = (
+            np.tile(timescale.tide, points_repeat),
+            hc.repeat(time_repeat, axis=0),
+            np.tile(deltat, points_repeat),
         )
-
-        # Use delta time at 2000.0 to match TMD outputs
-        deltat = np.zeros((len(timescale)), dtype=np.float64)
-
-    elif pytmd_model.format == "netcdf":
-        amp, ph, D, c = pyTMD.io.ATLAS.extract_constants(
-            lon,
-            lat,
-            pytmd_model.grid_file,
-            pytmd_model.model_file,
-            type=pytmd_model.type,
-            crop=crop,
-            bounds=bounds,
-            method=method,
-            extrapolate=extrapolate,
-            cutoff=cutoff,
-            scale=pytmd_model.scale,
-            compressed=pytmd_model.compressed,
+    
+        # Predict tidal elevations at time and infer minor corrections
+        npts = len(t)
+        tide = np.ma.zeros((npts), fill_value=np.nan)
+        tide.mask = np.any(hc.mask, axis=1)
+    
+        # Predict tides
+        tide.data[:] = pyTMD.predict.drift(
+            t, hc, c, deltat=deltat, corrections=pytmd_model.format
         )
-
-        # Use delta time at 2000.0 to match TMD outputs
-        deltat = np.zeros((len(timescale)), dtype=np.float64)
-
-    elif pytmd_model.format == "GOT":
-        amp, ph, c = pyTMD.io.GOT.extract_constants(
-            lon,
-            lat,
-            pytmd_model.model_file,
-            crop=crop,
-            bounds=bounds,
-            method=method,
-            extrapolate=extrapolate,
-            cutoff=cutoff,
-            scale=pytmd_model.scale,
-            compressed=pytmd_model.compressed,
+        minor = pyTMD.predict.infer_minor(
+            t, hc, c, deltat=deltat, corrections=pytmd_model.format
         )
+        tide.data[:] += minor.data[:]
 
-        # Delta time (TT - UT1)
-        deltat = timescale.tt_ut1
-
-    elif pytmd_model.format == "FES":
-        amp, ph = pyTMD.io.FES.extract_constants(
-            lon,
-            lat,
-            pytmd_model.model_file,
-            type=pytmd_model.type,
-            version=pytmd_model.version,
-            crop=crop,
-            bounds=bounds,
-            method=method,
-            extrapolate=extrapolate,
-            cutoff=cutoff,
-            scale=pytmd_model.scale,
-            compressed=pytmd_model.compressed,
+    except:
+        # Read tidal constants and interpolate to grid points
+        if pytmd_model.format in ("OTIS", "ATLAS-compact", "TMD3"):
+            amp, ph, D, c = pyTMD.io.OTIS.extract_constants(
+                lon,
+                lat,
+                pytmd_model.grid_file,
+                pytmd_model.model_file,
+                pytmd_model.projection,
+                type=pytmd_model.type,
+                grid=pytmd_model.file_format,
+                crop=crop,
+                bounds=bounds,
+                method=method,
+                extrapolate=extrapolate,
+                cutoff=cutoff,
+            )
+    
+            # Use delta time at 2000.0 to match TMD outputs
+            deltat = np.zeros((len(timescale)), dtype=np.float64)
+    
+        elif pytmd_model.format in ("ATLAS-netcdf",):
+            amp, ph, D, c = pyTMD.io.ATLAS.extract_constants(
+                lon,
+                lat,
+                pytmd_model.grid_file,
+                pytmd_model.model_file,
+                type=pytmd_model.type,
+                crop=crop,
+                bounds=bounds,
+                method=method,
+                extrapolate=extrapolate,
+                cutoff=cutoff,
+                scale=pytmd_model.scale,
+                compressed=pytmd_model.compressed,
+            )
+    
+            # Use delta time at 2000.0 to match TMD outputs
+            deltat = np.zeros((len(timescale)), dtype=np.float64)
+    
+        elif pytmd_model.format in ("GOT-ascii", "GOT-netcdf"):
+            amp, ph, c = pyTMD.io.GOT.extract_constants(
+                lon,
+                lat,
+                pytmd_model.model_file,
+                grid=pytmd_model.type,
+                crop=crop,
+                bounds=bounds,
+                method=method,
+                extrapolate=extrapolate,
+                cutoff=cutoff,
+                scale=pytmd_model.scale,
+                compressed=pytmd_model.compressed,
+            )
+    
+            # Delta time (TT - UT1)
+            deltat = timescale.tt_ut1
+    
+        elif pytmd_model.format in ("FES-ascii", "FES-netcdf"):
+            amp, ph = pyTMD.io.FES.extract_constants(
+                lon,
+                lat,
+                pytmd_model.model_file,
+                type=pytmd_model.type,
+                version=pytmd_model.version,
+                crop=crop,
+                bounds=bounds,
+                method=method,
+                extrapolate=extrapolate,
+                cutoff=cutoff,
+                scale=pytmd_model.scale,
+                compressed=pytmd_model.compressed,
+            )
+    
+            # Available model constituents
+            c = pytmd_model.constituents
+    
+            # Delta time (TT - UT1)
+            deltat = timescale.tt_ut1
+    
+        # Calculate complex phase in radians for Euler's
+        cph = -1j * ph * np.pi / 180.0
+    
+        # Calculate constituent oscillation
+        hc = amp * np.exp(cph)
+    
+        # Determine the number of points and times to process. If in
+        # "one-to-many" mode, these counts are used to repeat our extracted
+        # constituents and timesteps so we can extract tides for all
+        # combinations of our input times and tide modelling points.
+        # If in "one-to-one" mode, we avoid this step by setting counts to 1
+        # (e.g. "repeat 1 times")
+        points_repeat = len(x) if mode == "one-to-many" else 1
+        time_repeat = len(time) if mode == "one-to-many" else 1
+    
+        # If in "one-to-many" mode, repeat constituents to length of time
+        # and number of input coords before passing to `predict_tide_drift`
+        t, hc, deltat = (
+            np.tile(timescale.tide, points_repeat),
+            hc.repeat(time_repeat, axis=0),
+            np.tile(deltat, points_repeat),
         )
-
-        # Available model constituents
-        c = pytmd_model.constituents
-
-        # Delta time (TT - UT1)
-        deltat = timescale.tt_ut1
-
-    # Calculate complex phase in radians for Euler's
-    cph = -1j * ph * np.pi / 180.0
-
-    # Calculate constituent oscillation
-    hc = amp * np.exp(cph)
-
-    # Determine the number of points and times to process. If in
-    # "one-to-many" mode, these counts are used to repeat our extracted
-    # constituents and timesteps so we can extract tides for all
-    # combinations of our input times and tide modelling points.
-    # If in "one-to-one" mode, we avoid this step by setting counts to 1
-    # (e.g. "repeat 1 times")
-    points_repeat = len(x) if mode == "one-to-many" else 1
-    time_repeat = len(time) if mode == "one-to-many" else 1
-
-    # If in "one-to-many" mode, repeat constituents to length of time
-    # and number of input coords before passing to `predict_tide_drift`
-    t, hc, deltat = (
-        np.tile(timescale.tide, points_repeat),
-        hc.repeat(time_repeat, axis=0),
-        np.tile(deltat, points_repeat),
-    )
-
-    # Predict tidal elevations at time and infer minor corrections
-    npts = len(t)
-    tide = np.ma.zeros((npts), fill_value=np.nan)
-    tide.mask = np.any(hc.mask, axis=1)
-
-    # Predict tides
-    tide.data[:] = pyTMD.predict.drift(
-        t, hc, c, deltat=deltat, corrections=pytmd_model.format
-    )
-    minor = pyTMD.predict.infer_minor(
-        t, hc, c, deltat=deltat, corrections=pytmd_model.format
-    )
-    tide.data[:] += minor.data[:]
+    
+        # Predict tidal elevations at time and infer minor corrections
+        npts = len(t)
+        tide = np.ma.zeros((npts), fill_value=np.nan)
+        tide.mask = np.any(hc.mask, axis=1)
+    
+        # Predict tides
+        tide.data[:] = pyTMD.predict.drift(t, hc, c, deltat=deltat, corrections=pytmd_model.corrections)
+        minor = pyTMD.predict.infer_minor(
+            t,
+            hc,
+            c,
+            deltat=deltat,
+            corrections=pytmd_model.corrections,
+            minor=pytmd_model.minor,
+        )
+        tide.data[:] += minor.data[:]
 
     # Replace invalid values with fill value
     tide.data[tide.mask] = tide.fill_value

{dea_tools-0.3.5.dev20 → dea_tools-0.3.5.dev23}/dea_tools/datahandling.py

@@ -1090,7 +1090,6 @@ def _esri_pansharpen(ds, pan_band, band_weights=None):
     ds_pansharpened : xarray.Dataset
         Pansharpened dataset with the same dimensions as the input dataset.
     """
-
     # Create new dataarrays with and without pan band
     da_nopan = ds.drop(pan_band).to_array()
     da_pan = ds[pan_band]
@@ -1157,6 +1156,8 @@ def _hsv_timestep_pansharpen(ds_i, pan_band):
     ds_pansharpened : xarray.Dataset
         Pansharpened dataset with the same dimensions as the input dataset.
     """
+    # Squeeze out any single dimensions
+    ds_i = ds_i.squeeze()
 
     # Convert to an xr.DataArray and move "variable" to end
     da_i = ds_i.to_array().transpose(..., "variable")
@@ -1209,6 +1210,8 @@ def _pca_timestep_pansharpen(ds_i, pan_band, pca_rescaling="histogram"):
     ds_pansharpened : xarray.Dataset
         Pansharpened dataset with the same dimensions as the input dataset.
     """
+    # Squeeze out any single dimensions
+    ds_i = ds_i.squeeze()
 
     # Reshape to 2D by stacking x and y dimensions to prepare it
     # as an input to PCA. Drop NA rows as these are not supported

{dea_tools-0.3.5.dev20 → dea_tools-0.3.5.dev23}/dea_tools/spatial.py

@@ -535,7 +535,7 @@ def subpixel_contours(
 
         contour_arrays = {
             _time_format(i, time_format): _contours_to_multiline(
-                da_i, z_values[0], min_vertices
+                da_i.squeeze(), z_values[0], min_vertices
             )
             for i, da_i in da.groupby(dim)
         }

{dea_tools-0.3.5.dev20 → dea_tools-0.3.5.dev23/dea_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dea-tools
-Version: 0.3.5.dev20
+Version: 0.3.5.dev23
 Summary: Functions and algorithms for analysing Digital Earth Australia data.
 Home-page: https://github.com/GeoscienceAustralia/dea-notebooks
 Author: Geoscience Australia
@@ -44,7 +44,7 @@ Requires-Dist: pyproj
 Requires-Dist: pystac-client
 Requires-Dist: planetary-computer
 Requires-Dist: python-dateutil
-Requires-Dist: pyTMD<2.1.5,>=2.0.0
+Requires-Dist: pyTMD<=2.1.6
 Requires-Dist: pytz
 Requires-Dist: rasterio
 Requires-Dist: rasterstats

{dea_tools-0.3.5.dev20 → dea_tools-0.3.5.dev23}/dea_tools.egg-info/requires.txt

@@ -26,7 +26,7 @@ pyproj
 pystac-client
 planetary-computer
 python-dateutil
-pyTMD<2.1.5,>=2.0.0
+pyTMD<=2.1.6
 pytz
 rasterio
 rasterstats

{dea_tools-0.3.5.dev20 → dea_tools-0.3.5.dev23}/setup.py

@@ -56,7 +56,7 @@ REQUIRED = [
     'pystac-client',
     'planetary-computer',
     'python-dateutil',
-    'pyTMD>=2.0.0,<2.1.5',    
+    'pyTMD<=2.1.6',    
     'pytz',
     'rasterio',
     'rasterstats',