dea-tools 0.3.6.dev41__tar.gz → 0.3.6.dev42__tar.gz

{dea_tools-0.3.6.dev41/dea_tools.egg-info → dea_tools-0.3.6.dev42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dea-tools
-Version: 0.3.6.dev41
+Version: 0.3.6.dev42
 Summary: Functions and algorithms for analysing Digital Earth Australia data.
 Home-page: https://github.com/GeoscienceAustralia/dea-notebooks
 Author: Geoscience Australia

dea_tools-0.3.6.dev42/dea_tools/app/wetlandsinsighttool.py

@@ -0,0 +1,635 @@
+"""
+Digital Earth Australia Wetlands Insight Tool widget, which can be used to interactively 
+extract a stacked line plot using the wetlands insight tool on a wetland polygon.
+"""
+
+# Import required packages
+import fiona
+import sys
+import datacube
+import warnings
+import matplotlib.pyplot as plt
+from datacube.utils.geometry import CRS
+from ipyleaflet import (
+    WMSLayer,
+    basemaps,
+    basemap_to_tiles,
+    Map,
+    DrawControl,
+    WidgetControl,
+    SearchControl,
+    Marker,
+    LayerGroup,
+    LayersControl,
+    GeoData,
+)
+from traitlets import Unicode
+from ipywidgets import (
+    GridspecLayout,
+    Button,
+    Layout,
+    HBox,
+    VBox,
+    HTML,
+    Output,
+)
+import json
+import geopandas as gpd
+from io import BytesIO
+import ipywidgets as widgets
+import datetime
+import seaborn as sns
+
+# from shapely.geometry import box, shape
+import matplotlib.dates as mdates
+
+sys.path.insert(1, "../Tools/")
+import dea_tools.app.widgetconstructors as deawidgets
+from dea_tools.dask import create_local_dask_cluster
+from dea_tools.wetlands import generate_low_quality_data_periods
+from dea_tools.wit_app import WIT_drill, spatial_wit
+
+
+def make_box_layout():
+    return Layout(
+        #          border='solid 1px black',
+        margin="0px 10px 10px 0px",
+        padding="5px 5px 5px 5px",
+        width="100%",
+        height="100%",
+    )
+
+
+def create_expanded_button(description, button_style):
+    return Button(
+        description=description,
+        button_style=button_style,
+        layout=Layout(width="auto", height="auto"),
+    )
+
+
+class wit_app(HBox):
+
+    def __init__(self):
+        super().__init__()
+
+        ######################
+        # INITIAL ATTRIBUTES #
+        ######################
+
+        enddate = datetime.datetime.today()
+        startdate = datetime.datetime(
+            year=enddate.year - 1, month=enddate.month, day=enddate.day
+        )
+        self.startdate = startdate.strftime("%Y-%m-%d")
+        self.enddate = enddate.strftime("%Y-%m-%d")
+        self.wetland_name = "example WIT"
+        # self.out_csv = "example_WIT.csv"
+        self.out_plot = False
+        self.product_list = [
+            ("ESRI World Imagery", "none"),
+            ("Open Street Map", "open_street_map"),
+        ]
+        self.product = self.product_list[0][1]
+        self.target = None
+        self.action = None
+        self.gdf_drawn = None
+        self.gdf_uploaded = None
+        self.max_size = False
+        self.spatial_wit = False
+
+        ##################
+        # HEADER FOR APP #
+        ##################
+
+        # Create the Header widget
+        header_title_text = "<h3>Digital Earth Australia Wetlands Insight Tool </h3>"
+        instruction_text = "Select parameters and draw a polygon on the map to extract a stacked line plot for a given area. Alternatively, <b>upload a shapefile or a GeoJSON</b> to extract a stacked line plot for your wetland of interest polygon."
+        self.header = deawidgets.create_html(
+            f"{header_title_text}<p>{instruction_text}</p>"
+        )
+        self.header.layout = make_box_layout()
+
+        #####################################
+        # HANDLER FUNCTION FOR DRAW CONTROL #
+        #####################################
+
+        # Define the action to take once something is drawn on the map
+        def update_geojson(target, action, geo_json):
+
+            # Remove previously uploaded data if present
+            self.gdf_uploaded = None
+            fileupload_wetlands._counter = 0
+
+            # Get data from action
+            self.action = action
+
+            # Convert data to geopandas
+            json_data = json.dumps(geo_json)
+            binary_data = json_data.encode()
+            io = BytesIO(binary_data)
+            io.seek(0)
+            gdf = gpd.read_file(io)
+            gdf.crs = "EPSG:4326"
+
+            # Convert to Albers and compute area
+            gdf_drawn_albers = gdf.copy().to_crs("EPSG:3577")
+            m2_per_km2 = 10**6
+            area = gdf_drawn_albers.area.values[0] / m2_per_km2
+            polyarea_label = "Total polygon area"
+            polyarea_text = f"<b>{polyarea_label}</b>: {area:.2f} km<sup>2</sup>"
+
+            # Test area size
+            if self.max_size:
+                confirmation_text = '<span style="color: #33cc33"> <b>(Overriding maximum size limit; use with caution as may lead to memory issues)</b></span>'
+                self.header.value = (
+                    header_title_text + polyarea_text + confirmation_text
+                )
+                self.gdf_drawn = gdf
+            elif area <= 2000:
+                confirmation_text = '<span style="color: #33cc33"> <b>(Area to extract falls within recommended limit)</b></span>'
+                self.header.value = (
+                    header_title_text + polyarea_text + confirmation_text
+                )
+                self.gdf_drawn = gdf
+            else:
+                warning_text = '<span style="color: #ff5050"> <b>(Area to extract is too large, please update your polygon)</b></span>'
+                self.header.value = header_title_text + polyarea_text + warning_text
+                self.gdf_drawn = None
+
+        ###########################
+        # WIDGETS FOR APP OUTPUTS #
+        ###########################
+
+        self.dask_client = Output(layout=make_box_layout())
+        self.progress_bar = Output(layout=make_box_layout())
+        self.wit_plot = Output(layout=make_box_layout())
+        self.progress_header = deawidgets.create_html("")
+
+        #########################################
+        # MAP WIDGET, DRAWING TOOLS, WMS LAYERS #
+        #########################################
+
+        # Create drawing tools
+        desired_drawtools = ["rectangle", "polygon"]
+        draw_control = deawidgets.create_drawcontrol(desired_drawtools)
+
+        # Begin by displaying an empty layer group, and update the group with desired WMS on interaction.
+        self.map_layers = LayerGroup(layers=())
+        self.map_layers.name = "Map Overlays"
+
+        # Create map widget
+        self.m = deawidgets.create_map(
+            map_center=(-28, 135), zoom_level=4, basemap=basemaps.Esri.WorldImagery
+        )
+        self.m.layout = make_box_layout()
+
+        # Add tools to map widget
+        self.m.add_control(draw_control)
+        self.m.add_control(
+            SearchControl(
+                position="topleft",
+                url="https://nominatim.openstreetmap.org/search?format=json&q={s}",
+                zoom=13,  # 'Village / Suburb' level zoom
+                marker=Marker(draggable=False),
+            )
+        )
+        self.m.add_layer(self.map_layers)
+
+        # Store current basemap for future use
+        self.basemap = self.m.basemap
+
+        ############################
+        # WIDGETS FOR APP CONTROLS #
+        ############################
+
+        # Create parameter widgets
+        startdate_picker = deawidgets.create_datepicker(
+            value=startdate,
+        )
+        enddate_picker = deawidgets.create_datepicker(
+            value=enddate,
+        )
+        wetland_name = deawidgets.create_inputtext(self.wetland_name, self.wetland_name)
+        # output_csv = deawidgets.create_inputtext(self.out_csv, self.out_csv)
+        output_plot = deawidgets.create_checkbox(self.out_plot, "Figure (.png)")
+        deaoverlay_dropdown = deawidgets.create_dropdown(
+            self.product_list, self.product_list[0][1]
+        )
+        run_button = create_expanded_button("Run", "info")
+        fileupload_wetlands = widgets.FileUpload(accept="", multiple=True)
+
+        # Expandable advanced section
+        max_size = deawidgets.create_checkbox(
+            self.max_size, "Enable", layout={"width": "95%"}
+        )
+        output_spatial_wit = deawidgets.create_checkbox(
+            self.spatial_wit, "Animation (.gif)"
+        )
+
+        ####################################
+        # UPDATE FUNCTIONS FOR EACH WIDGET #
+        ####################################
+
+        # Run update functions whenever various widgets are changed.
+        startdate_picker.observe(self.update_startdate, "value")
+        enddate_picker.observe(self.update_enddate, "value")
+        wetland_name.observe(self.update_wetlandname, "value")
+        # output_csv.observe(self.update_outputcsv, "value")
+        output_plot.observe(self.update_outputplot, "value")
+        deaoverlay_dropdown.observe(self.update_deaoverlay, "value")
+        run_button.on_click(self.run_app)
+        draw_control.on_draw(update_geojson)
+        fileupload_wetlands.observe(self.update_fileupload_wetlands, "value")
+        max_size.observe(self.update_maxsize, "value")
+        output_spatial_wit.observe(self.update_outputspatialwit, "value")
+
+        ##################################
+        # COLLECTION OF ALL APP CONTROLS #
+        ##################################
+        expand_box = VBox(
+            [
+                HTML(
+                    "<b>Override maximum size limit:</b></br> (use with caution; may cause memory issues/crashes)"
+                ),
+                max_size,
+                HTML("<b>Spatial WIT animation:<b/>"),
+                output_spatial_wit,
+            ]
+        )
+
+        expand = widgets.Accordion(
+            children=[expand_box],
+            selected_index=None,
+        )
+        expand.set_title(0, "Advanced")
+
+        parameter_selection = VBox(
+            [
+                HTML("<b>Start Date:</b>"),
+                startdate_picker,
+                HTML("<b>End Date:</b>"),
+                enddate_picker,
+                HTML("<b>Wetland Name:</b>"),
+                wetland_name,
+                # HTML("<b>Output CSV:</b>"),
+                # output_csv,
+                HTML("<b>Output Plot:</b>"),
+                output_plot,
+                HTML(
+                    "</br><i><b>Upload Polygon:</b></br>Upload a GeoJSON or"
+                    " Shapefile (<5 mb) containing a wetland polygon.</i>"
+                ),
+                fileupload_wetlands,
+                HTML("</br>"),
+                expand,
+            ]
+        )
+        map_selection = VBox(
+            [
+                HTML("</br><b>Map overlay:</b>"),
+                deaoverlay_dropdown,
+            ]
+        )
+        parameter_selection.layout = make_box_layout()
+        map_selection.layout = make_box_layout()
+
+        ###############################
+        # SPECIFICATION OF APP LAYOUT #
+        ###############################
+
+        #       0   1    2   3   4   5   6   7    8   9
+        #     ---------------------------------------------
+        # 0   | Header                         | Map sel. |
+        #     ---------------------------------------------
+        # 1   | Params |                                  |
+        # 2   |        |                                  |
+        # 3   |        |                                  |
+        # 4   |        |               Map                |
+        # 5   |        |                                  |
+        # 6   |        |                                  |
+        #     ----------                                  |
+        # 7   |  Run   |                                  |
+        #     ---------------------------------------------
+        # 8   |               Status info                 |
+        #     ---------------------------------------------
+        # 9   |                                           |
+        # 10   |               Output/figure               |
+        # 11  |                                           |
+        # 12  | ------------------------------------------|
+
+        # Create the layout #[rowspan, colspan]
+        grid = GridspecLayout(13, 10, height="1350px", width="auto")
+
+        # Header and controls
+        grid[0, :8] = self.header
+        grid[0, 8:] = map_selection
+        grid[1:7, 0:2] = parameter_selection
+        grid[7, 0:2] = run_button
+
+        # Status info, map and plot
+        grid[1:8, 2:] = self.m  # map
+        grid[8:9, :] = self.progress_bar
+        # grid[7:8, :] = self.dask_client
+
+        # Plot
+        grid[9:, :] = self.wit_plot
+
+        # Display using HBox children attribute
+        self.children = [grid]
+
+    ######################################
+    # DEFINITION OF ALL UPDATE FUNCTIONS #
+    ######################################
+
+    # Set the output csv
+    def update_fileupload_wetlands(self, change):
+
+        # Clear any drawn data if present
+        self.gdf_drawn = None
+
+        # Temporary compatibility fix for ipywidget > 8.0
+        # TODO: Update code to use new fileupload API documented here:
+        # https://ipywidgets.readthedocs.io/en/latest/user_migration_guides.html#fileupload
+        uploaded_data = {
+            f["name"]: {"content": f.content.tobytes()} for f in change.new
+        }
+
+        # Save to file
+        for uploaded_filename in uploaded_data.keys():
+            with open(uploaded_filename, "wb") as output_file:
+                content = uploaded_data[uploaded_filename]["content"]
+                output_file.write(content)
+
+        with self.progress_bar:
+
+            try:
+
+                print("Loading vector data...", end="\r")
+                valid_files = [
+                    file
+                    for file in uploaded_data.keys()
+                    if file.lower().endswith((".shp", ".geojson"))
+                ]
+                valid_file = valid_files[0]
+                wetlands_gdf = (
+                    gpd.read_file(valid_file)
+                    .to_crs("EPSG:4326")
+                    .explode(index_parts=True)
+                    .reset_index(drop=True)
+                )
+
+                # Use ID column if it exists
+                if "id" in wetlands_gdf:
+                    wetlands_gdf = wetlands_gdf.set_index("id")
+                    print(f"Uploaded '{valid_file}'; automatically labelling ")
+                else:
+                    print(f"Uploaded '{valid_file}'; no 'id' column detected.")
+
+                # Create a geodata
+                geodata = GeoData(
+                    geo_dataframe=wetlands_gdf, style={"color": "black", "weight": 3}
+                )
+
+                # Add to map
+                xmin, ymin, xmax, ymax = wetlands_gdf.total_bounds
+                self.m.fit_bounds([[ymin, xmin], [ymax, xmax]])
+                self.m.add_layer(geodata)
+
+                # If completed, add to attribute
+                self.gdf_uploaded = wetlands_gdf
+
+            except IndexError:
+                print(
+                    "Cannot read uploaded files. Please ensure that data is "
+                    "in either GeoJSON or Shapefile format.",
+                    end="\r",
+                )
+                self.gdf_uploaded = None
+
+            except fiona.errors.DriverError:
+                print(
+                    "Shapefile is invalid. Please ensure that all shapefile "
+                    "components (e.g. .shp, .shx, .dbf, .prj) are uploaded.",
+                    end="\r",
+                )
+                self.gdf_uploaded = None
+
+    # Set the start date to the new edited date
+    def update_startdate(self, change):
+        self.startdate = change.new
+
+    # Set the end date to the new edited date
+    def update_enddate(self, change):
+        self.enddate = change.new
+
+    # Set the wetland name
+    def update_wetlandname(self, change):
+        self.wetland_name = change.new
+
+    # Set the output csv
+    # def update_outputcsv(self, change):
+    # self.out_csv = change.new
+
+    # Set the output plot
+    def update_outputplot(self, change):
+        self.out_plot = change.new
+
+    # Override max size limit
+    def update_maxsize(self, change):
+        self.max_size = change.new
+
+    # Select to output spatial WIT
+    def update_outputspatialwit(self, change):
+        self.spatial_wit = change.new
+
+    # Update product
+    def update_deaoverlay(self, change):
+
+        self.product = change.new
+
+        if self.product == "none":
+            self.map_layers.clear_layers()
+
+        elif self.product == "open_street_map":
+            self.map_layers.clear_layers()
+            layer = basemap_to_tiles(basemaps.OpenStreetMap.Mapnik)
+            self.map_layers.add_layer(layer)
+
+    def run_app(self, change):
+
+        # Clear progress bar and output areas before running
+        self.progress_bar.clear_output()
+        self.wit_plot.clear_output()
+        self.dask_client.clear_output()
+
+        # Configure local dask cluster
+        with self.dask_client:
+            client = create_local_dask_cluster(return_client=True, display_client=True)
+
+        # Set any defaults
+        dask_chunks = dict(x=1000, y=1000, time=1)
+
+        self.progress_header.value = "<h3>" + ("Progress") + "</h3>"
+
+        # Run DEA WIT analysis
+        with self.progress_bar:
+            warnings.filterwarnings("ignore")
+
+            # Load polygons from either map or uploaded files
+            if self.gdf_uploaded is not None:
+                wetlands_gdf = self.gdf_uploaded
+                run_text = "uploaded file"
+            elif self.gdf_drawn is not None:
+                wetlands_gdf = self.gdf_drawn
+
+                # save the drawn polygon as a geojson in the current directory
+                try:
+                    output_geojson_path = f"{self.wetland_name}_drawn_polygon.geojson"
+                    wetlands_gdf.to_file(output_geojson_path, driver="GeoJSON")
+                    print(f"Drawn polygon saved to: {output_geojson_path}")
+                except Exception as e:
+                    print(f"Error saving drawn polygon: {e}")
+                run_text = "selected polygon"
+            else:
+                print(
+                    f"No polygon drawn or uploaded. Please select a polygon on the map, or upload a GeoJSON or Shapefile.",
+                    end="\r",
+                )
+                wetlands_gdf = None
+
+            # Run wetlands polygon drill
+            df = None
+
+            if not self.wetland_name.endswith(".csv"):
+                output_csv = self.wetland_name + ".csv"
+            else:
+                output_csv = self.wetland_name
+
+            if wetlands_gdf is not None:
+                try:
+                    ds_wit, df = WIT_drill(
+                        gdf=wetlands_gdf,
+                        time=(self.startdate, self.enddate),
+                        export_csv=output_csv,
+                        dask_chunks=dask_chunks,
+                        verbose=False,
+                        verbose_progress=True,
+                    )
+                    print("WIT complete")
+                except AttributeError:
+                    print("No polygon selected")
+
+            else:
+                print(
+                    "No valid polygon to process. Please select or draw a new polygon."
+                )
+
+        # close down the dask client
+        client.shutdown()
+
+        # save the csv
+        if df is not None and self.wetland_name:
+            df.to_csv(output_csv, index=False)
+
+        else:
+            print("No valid polygon to process. Please select or draw a new polygon.")
+            df = None
+
+        # ---Plotting------------------------------
+        if df is not None:
+            with self.wit_plot:
+
+                fontsize = 17
+                plt.rcParams.update({"font.size": fontsize})
+                # set up color palette
+                pal = [
+                    sns.xkcd_rgb["cobalt blue"],
+                    sns.xkcd_rgb["neon blue"],
+                    sns.xkcd_rgb["grass"],
+                    sns.xkcd_rgb["beige"],
+                    sns.xkcd_rgb["brown"],
+                ]
+
+                # make a stacked area plot
+                plt.close("all")
+
+                fig, ax = plt.subplots(constrained_layout=True, figsize=(20, 6))
+
+                ax.stackplot(
+                    df["date"],
+                    df["water"] * 100,
+                    df["wet"] * 100,
+                    df["norm_pv"] * 100,
+                    df["norm_npv"] * 100,
+                    df["norm_bs"] * 100,
+                    colors=pal,
+                    alpha=0.7,
+                )
+
+                # manually change the legend display order
+                legend = ax.legend(
+                    ["open water", "wet", "green veg", "dry veg", "bare soil"][::-1],
+                    loc="lower left",
+                )
+                handles = legend.legend_handles
+
+                for i, handle in enumerate(handles):
+                    handle.set_facecolor(pal[::-1][i])
+                    handle.set_alpha(0.7)
+
+                # setup the display ranges
+                ax.set_ylim(0, 100)
+                ax.set_xlim(df["date"].min(), df["date"].max())
+
+                # add a new column: 'off_value' based on low quality data setting
+                df = generate_low_quality_data_periods(df)
+
+                ax.fill_between(
+                    df["date"],
+                    0,
+                    100,
+                    where=df["off_value"] == 100,
+                    color="white",
+                    alpha=0.5,
+                    hatch="//",
+                )
+
+                ax.xaxis.set_major_locator(mdates.MonthLocator())
+                ax.xaxis.set_major_formatter(mdates.DateFormatter("%b-%Y"))
+
+                # Rotates and right-aligns the x labels so they don't crowd each other.
+                for label in ax.get_xticklabels(which="major"):
+                    label.set(rotation=30, horizontalalignment="right")
+
+                x_label_text = "The Fractional Cover algorithm developed by the Joint Remote Sensing Research Program and\n the Water Observations from Space algorithm developed by Geoscience Australia are used in the production of this data"
+
+                ax.set_xlabel(x_label_text, style="italic")
+
+                ax.set_ylabel("Percentage of wetland (%)")
+
+                # add a title
+                plt.title(
+                    f"Percentage of area dominated by WOs, Wetness, Fractional Cover for\n {self.wetland_name}",
+                    fontsize=16,
+                )
+                plt.show()
+
+                if self.out_plot:
+                    # save the figure
+                    fig.savefig(f"{self.wetland_name}")
+
+        else:
+            print("No valid polygon to process. Please select or draw a new polygon.")
+
+        # Export spatial WIT animation if checkbox is selected
+        if self.spatial_wit and ds_wit is not None:
+
+            try:
+                ds = spatial_wit(ds=ds_wit, wetland_name=self.wetland_name)
+                print("Animation complete")
+            except AttributeError:
+                print("No polygon selected")
+
+        else:
+            print("No valid polygon to process. Please select or draw a new polygon.")

dea_tools-0.3.6.dev42/dea_tools/wit_app.py

@@ -0,0 +1,502 @@
+# wit_app.py
+"""
+This module is for processing DEA wetlands data, including Spatial WIT.
+
+License: The code in this notebook is licensed under the Apache 
+License, Version 2.0 (https://www.apache.org/licenses/LICENSE-2.0). 
+Digital Earth Australia data is licensed under the Creative Commons 
+by Attribution 4.0 license 
+(https://creativecommons.org/licenses/by/4.0/).
+
+Contact: If you need assistance, please post a question on the Open 
+Data Cube Discord chat (https://discord.com/invite/4hhBQVas5U) or on the 
+GIS Stack Exchange 
+(https://gis.stackexchange.com/questions/ask?tags=open-data-cube)using
+the `open-data-cube` tag (you can view previously asked questions
+here: https://gis.stackexchange.com/questions/tagged/open-data-cube). 
+
+If you would like to report an issue with this script, file one on 
+GitHub: https://github.com/GeoscienceAustralia/dea-notebooks/issues/new
+
+Last modified: March 2025
+
+"""
+
+# Import required packages
+
+import datetime
+import geopandas as gpd
+import imageio
+import itertools
+import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
+import numpy as np
+import os
+import pandas as pd
+import shutil
+import warnings
+import xarray as xr
+
+import datacube
+import sys
+
+sys.path.insert(1, "../Tools/")
+import dea_tools.bandindices
+import dea_tools.datahandling
+from dea_tools.spatial import xr_rasterize
+from dea_tools.dask import create_local_dask_cluster
+import dea_tools.wetlands
+
+# Create local dask cluster to improve data load time
+client = create_local_dask_cluster(return_client=True)
+
+
+def WIT_drill(
+    gdf,
+    time,
+    export_csv=None,
+    dask_chunks=None,
+    verbose=False,
+    verbose_progress=False,
+):
+    """
+    Runs the Wetlands Insight Tool over a polygon. The code is based on the DEA Wetlands
+    Insight Tool notebook.
+    This function loads FC, WOs, and Landsat Data, and calculates Tasseled Cap Wetness, in
+    order to summarise how the different classes have changed over time.
+
+    The output is an Xarray dataset and a pandas dataframe containing a timeseries of the
+    normalised relative fractions of each class at each time-step. This forms the input to
+    produce a stacked line plot.
+
+    Last modified March 2025
+
+    Parameters
+    ----------
+    gdf : geopandas.GeoDataFrame
+        The dataframe must only contain a single row containing the polygon you wish to
+        interrogate
+    time : tuple
+        A tuple containing the time range over which to run the WIT.
+        e.g. ("2014-01-01", "2015-01-01")
+    export_csv : string, optional
+        To save the returned pandas dataframe as a .csv file, pass a location string (e.g.
+        'output/results.csv')
+    dask_chunks : dict, optional
+        To lazily load the datasets using dask, pass a dictionary containing the dimensions
+        over which to chunk e.g. {'time':1, 'x':2048, 'y':2048}.
+    verbose : bool, optional
+        If true, print statements are outputted detailing the progress of the tool.
+    verbose_progress : bool, optional
+        For use with Dask progress bar.
+
+    Returns
+    -------
+    ds_wit : xarray.Dataset
+        An xarray dataset containing values for each cover class (open water, wet, pv, npv, bs).
+    polygon_base_df : pandas.DataFrame
+        A DataFrame containing the normalised timeseries of relative fractions of each cover
+        class (open water, wet, pv, npv, bs).
+
+    """
+
+    # Connect to the datacube
+    dc = datacube.Datacube(app="WIT_drill")
+
+    # load landsat 5,7,8 data
+    warnings.filterwarnings("ignore")
+
+    # load wetland polygon and specify the coordinate reference system of the polygon
+    if isinstance(gdf, datacube.utils.geometry._base.Geometry):
+        gdf = gpd.GeoDataFrame({"col1": ["name"], "geometry": gdf.geom}, crs=gdf.crs)
+    gpgon = datacube.utils.geometry.Geometry(gdf.geometry[0], crs=gdf.crs)
+
+    # Define which spectral bands are being used in the analysis
+    bands = [
+        f"nbart_{band}" for band in ("blue", "green", "red", "nir", "swir_1", "swir_2")
+    ]
+
+    if verbose_progress:
+        print("Loading Landsat data")
+
+    # Load Landsat 5, 7 and 8 data. Not including Landsat 7 SLC off period (31-05-2003 to 06-04-2022)
+    ds_ls = dea_tools.datahandling.load_ard(
+        dc,
+        products=["ga_ls8c_ard_3", "ga_ls7e_ard_3", "ga_ls5t_ard_3"],
+        ls7_slc_off=False,
+        measurements=bands,
+        geopolygon=gpgon,
+        output_crs="EPSG:3577",
+        resolution=(-30, 30),
+        resampling={"fmask": "nearest", "*": "bilinear"},
+        time=time,
+        group_by="solar_day",
+        dask_chunks={"time": 1, "x": 2048, "y": 2048},
+    )
+
+    # Load into memory using Dask
+    ds_ls.load()
+
+    # Load Water Observations dataset into the same spatial grid and resolution of the loaded Landsat dataset
+    ds_wo = dc.load(
+        "ga_ls_wo_3",
+        resampling="nearest",
+        group_by="solar_day",
+        like=ds_ls,
+        dask_chunks={"time": 1, "x": 2048, "y": 2048},
+    )
+
+    # Load Fractional Cover dataset into the same spatial grid and resolution of the loaded Landsat dataset
+    ds_fc = dc.load(
+        "ga_ls_fc_3",
+        resampling="nearest",
+        group_by="solar_day",
+        like=ds_ls,
+        dask_chunks={"time": 1, "x": 2048, "y": 2048},
+    )
+
+    # Load data into memory
+    ds_wo.load()
+    ds_fc.load()
+
+    # Locate and remove any observations which aren't in all three datasets
+    missing = set()
+    for t1, t2 in itertools.product(
+        [ds_fc.time.values, ds_wo.time.values, ds_ls.time.values], repeat=2
+    ):
+        missing_ = set(t1) - set(t2)
+        missing |= missing_
+
+    ds_fc = ds_fc.sel(time=[t for t in ds_fc.time.values if t not in missing])
+    ds_ls = ds_ls.sel(time=[t for t in ds_ls.time.values if t not in missing])
+    ds_wo = ds_wo.sel(time=[t for t in ds_wo.time.values if t not in missing])
+
+    # Calculate Tasseled Cap Wetness from the Landsat data
+    tcw = dea_tools.bandindices.calculate_indices(
+        ds_ls,
+        index="TCW",
+        collection="ga_ls_3",
+        normalise=False,
+        drop=True,
+        inplace=False,
+    )
+
+    # Divide Fractional Cover by 100 to keep them in [0,1]. Keeps data types the same in
+    # the output raster
+    bs = ds_fc.bs / 100
+    pv = ds_fc.pv / 100
+    npv = ds_fc.npv / 100
+
+    # Generate the WIT raster bands by creating an empty dataset called `output_rast` and
+    # populate with values from input datasets
+    rast_names = ["pv", "npv", "bs", "wet", "water"]
+    output_rast = {n: xr.zeros_like(bs) for n in rast_names}
+
+    output_rast["bs"].values[:] = bs
+    output_rast["pv"].values[:] = pv
+    output_rast["npv"].values[:] = npv
+
+    # Masking
+
+    # Rasterise the shapefile where gdf is the vector data and pv is the xarray template
+    poly_raster = xr_rasterize(gdf, pv) > 0
+
+    # Mask includes No data, Non contiguous data, Cloud shadow, Cloud, and water.
+    # See https://knowledge.dea.ga.gov.au/notebooks/DEA_products/DEA_Water_Observations/#Understanding-WOs-bit-flags
+    # for more detail.
+    mask = (ds_wo.water & 0b01100011) == 0
+    mask &= poly_raster
+
+    # Set open water to water present and classified as water as per Water Observations and bit flags
+    open_water = ds_wo.water & (1 << 7) > 0
+
+    # Thresholding
+
+    # Set wet pixels where not masked and above threshold of -350
+    wet = tcw.where(mask).TCW > -350
+
+    # Adding wet and water values to output raster
+
+    # TCW
+    output_rast["wet"].values[:] = wet.values.astype(float)
+    for name in rast_names[:3]:
+        output_rast[name].values[wet.values] = 0
+
+    # WO
+    output_rast["water"].values[:] = open_water.values.astype(float)
+    for name in rast_names[:4]:
+        output_rast[name].values[open_water.values] = 0
+
+    # Masking again
+    ds_wit = xr.Dataset(output_rast).where(mask)
+
+    # Calculate percentage missing
+    pc_missing = (~mask).where(poly_raster).mean(dim=["x", "y"])
+
+    # Mask entire observations where the polygon is more than 10% masked
+    ds_wit = ds_wit.where(pc_missing < 0.1)
+
+    # Normalise Fractional Cover Values in WIT result
+
+    # Convert ds_wit: xarray.Dataset to polygon_base_df: pandas.DataFrame
+    polygon_base_df = pd.DataFrame()
+    polygon_base_df["date"] = ds_wit.time.values
+
+    for band in rast_names:
+        polygon_base_df[band] = ds_wit[band].mean(dim=["x", "y"])
+
+    polygon_base_df = dea_tools.wetlands.normalise_wit(polygon_base_df)
+
+    # Create WIT comma-separated values (CSV) output file
+    if export_csv:
+        polygon_base_df = polygon_base_df.drop("index", axis=1)
+        polygon_base_df.to_csv(export_csv, index_label="date")
+
+    return ds_wit, polygon_base_df
+
+
+def classify_pixel(pv, npv, bs):
+    """
+    This function sorts the fractional cover values into their classes to be used in Spatial WIT.
+
+    Last modified March 2025
+
+    Parameters
+    ----------
+    pv : array
+        Array containing values for the photosynthetic (green) vegetation class.
+    npv : array
+        Array containing values for the non-photosynthetic (dry) vegetation class.
+    bs : array
+        Array containing values for the base soil class.
+
+    Returns
+    -------
+    integer
+        Integer values to assign each of the fractional cover classes (https://knowledge.dea.ga.gov.au/data/product/dea-fractional-cover-landsat/).
+
+    """
+    if pv > 2 / 3:
+        return 8  # pv
+    elif npv > 2 / 3:
+        return 0  # ng
+    elif bs > 2 / 3:
+        return 4  # bs
+    elif npv > 1 / 3 and bs > 1 / 3 and pv < 1 / 3:
+        return 1  # ng_bs
+    elif npv > 1 / 3 and pv > 1 / 3 and bs < 1 / 3:
+        return 3  # ng_pv
+    elif npv > 1 / 3 and pv < 1 / 3 and bs < 1 / 3:
+        return 2  # ng_mix
+    elif bs > 1 / 3 and pv > 1 / 3 and npv < 1 / 3:
+        return 6  # bs_pv
+    elif bs > 1 / 3 and pv < 1 / 3 and npv < 1 / 3:
+        return 5  # bs_mix
+    elif pv > 1 / 3 and npv < 1 / 3 and bs < 1 / 3:
+        return 7  # pv_mix
+    return -1
+
+
+def spatial_wit(ds, wetland_name):
+    """
+    Takes Wetlands Insight Tool classifications and represents them in a spatial way. The
+    same caveats for those classifications apply (see Dunn et al., 2023 and DEA
+    Wetlands Insight Tool notebook). The water and wet classes are binary and the
+    vegetation fractional cover classes are percentages per pixel, with the spatial
+    representation scaled accordingly.
+
+    Last modified: March 2025
+
+    Parameters
+    ----------
+    ds : xarray.Dataset
+        An xarray dataset containing values for each cover class (open water, wet, pv, npv, bs).
+
+    wetland_name : string
+        Value to be used when naming the output files.
+
+    Returns
+    -------
+    output_path :
+        File path where the GIF animation will be saved.
+
+
+    """
+    # Remove time steps where all values are missing (i.e. NaNs)
+    ds = ds.dropna(dim="time", how="all")
+
+    # Calculate the sum of the fractional cover values for pv, npv and bs then normalise
+    # the values for each class
+    fraction_sum = ds["pv"] + ds["npv"] + ds["bs"]
+    ds["pv"] = ds["pv"] / fraction_sum
+    ds["npv"] = ds["npv"] / fraction_sum
+    ds["bs"] = ds["bs"] / fraction_sum
+
+    # Apply the classification function to the dataset across all time, y, x
+    fc_class = xr.apply_ufunc(
+        classify_pixel,
+        ds["pv"],
+        ds["npv"],
+        ds["bs"],
+        vectorize=True,
+    )
+
+    fc_class = fc_class.where(fc_class != -1, np.nan)
+
+    # Add the new classification band to the dataset
+    ds["fc_class"] = fc_class
+
+    # Make a new band called wetland that combines all the fractional cover classes
+    # with the water and wet classes
+    # i.e. water == 10, wet == 9, all other areas retain original FC class
+    wetland = ds["fc_class"].where((ds["water"] == 0) | ds["water"].isnull(), 10)
+    ds["wetland"] = wetland
+    wetland = ds["wetland"].where((ds["wet"] == 0) | ds["wet"].isnull(), 9)
+    ds["wetland"] = wetland
+
+    # Define labels for each class
+    class_labels = [
+        "dry veg",  # ng
+        "dry veg and bare mix",  # ng_bs
+        "dry mix",  # ng_mix
+        "dry veg and green veg",  # ng_pv
+        "bare soil",  # bs
+        "bare soil mix",  # bs_mix
+        "bare soil and green veg",  # bs_pv
+        "green veg mix",  # pv_mix
+        "green veg",  # pv
+        "wet",
+        "water",
+    ]
+
+    # Define the colormap with your custom colors
+    cmap = mcolors.ListedColormap(
+        [
+            "#F1E8C9",  # ng
+            "#C0AB86",  # ng_bs
+            "#D6D2A7",  # ng_mix
+            "#BCD495",  # ng_pv
+            "#93724C",  # bs
+            "#9C895D",  # bs_mix
+            "#8F9C5C",  # bs_pv
+            "#9DBD74",  # pv_mix
+            "#8CC46B",  # pv
+            "#6ce6f8",  # wet
+            "#676dca",  # water
+        ]
+    )
+
+    # Create a BoundedNorm to ensure correct mapping of data to the colormap
+    norm = mcolors.Normalize(vmin=0, vmax=10)
+
+    # Create a directory to save the frames
+    os.makedirs("deawetlands_outputs", exist_ok=True)
+
+    # Clean the input name to remove spaces
+    wetland_name = wetland_name.replace(" ", "_")
+
+    # Save all the time steps
+
+    for t in ds.time:
+        wetland_time_step = ds["wetland"].sel(time=t)
+        date_str = str(t.values)[:10]  # Extract date as string
+        wetland_time_step.rio.to_raster(
+            f"deawetlands_outputs/{wetland_name}_{date_str}.tif"
+        )
+
+    # Make one big plot
+
+    num_time_steps = ds.sizes["time"]
+
+    # Set the number of columns as the number of time steps if less than 10
+    num_columns = min(num_time_steps, 10)
+
+    # Calculate the number of rows
+    num_rows = (num_time_steps + num_columns - 1) // num_columns
+
+    time_step = ds["wetland"].isel(time=0)
+    height, width = time_step.shape
+    fig, axes = plt.subplots(
+        num_rows, num_columns, figsize=(8 * num_columns * width / height, 8 * num_rows)
+    )
+
+    if num_rows == 1:
+        axes = axes.reshape(1, num_columns)
+    elif num_columns == 1:
+        axes = axes.reshape(num_rows, 1)
+
+    # Hide any unused axes
+    for i in range(num_rows * num_columns):
+        if i >= num_time_steps:
+            fig.delaxes(axes.flatten()[i])
+
+    # Plot time steps
+    for t in range(num_time_steps):
+        time_step = ds["wetland"].isel(time=t)
+        time_ns = ds["time"].isel(time=t).values.item()
+        time_date = pd.to_datetime(time_ns, unit="ns")
+        time_date_str = time_date.strftime("%d-%m-%Y")
+        row_idx = t // num_columns
+        col_idx = t % num_columns
+        time_step.plot.imshow(
+            cmap=cmap,
+            norm=norm,
+            ax=axes[row_idx, col_idx],  # Assign subplot
+            add_colorbar=False,  # Avoid multiple colorbars
+        )
+        axes[row_idx, col_idx].set_aspect("auto")  # keep aspect
+        axes[row_idx, col_idx].set_title(f"{time_date_str}")
+
+    plt.tight_layout()
+    plt.savefig(f"{wetland_name}_time_steps.png", dpi=72)
+
+    # Make a gif
+
+    # loop through each time step, creating and saving a frame
+    num_time_steps = ds.sizes["time"]
+    frames = []
+
+    for t in range(num_time_steps):
+        time_step = ds["wetland"].isel(time=t)
+        height, width = time_step.shape
+        fig, ax = plt.subplots(figsize=(8, 8 * height / width))  # dynamic aspect ratio
+
+        time_ns = ds["time"].isel(time=t).values.item()
+        time_date = pd.to_datetime(time_ns, unit="ns")
+        time_date_str = time_date.strftime("%d-%m-%Y")
+
+        time_step.plot.imshow(
+            cmap=cmap,
+            norm=norm,
+            ax=ax,
+            add_colorbar=False,  # Avoid multiple colorbars
+            # interpolation='none'
+        )
+        ax.set_aspect("auto")  # keep aspect
+        plt.title(f"Time:{time_date_str}")
+
+        # Rotates and right-aligns the x labels so they don't crowd each other.
+        for label in ax.get_xticklabels(which="major"):
+            label.set(rotation=30, horizontalalignment="right")
+
+        # Save the frame
+        frame_path = f"deawetlands_outputs/{wetland_name}_{time_date_str}.png"
+        plt.savefig(frame_path, bbox_inches="tight")
+        frames.append(frame_path)
+        plt.close(fig)
+
+    # make the gif
+    output_path = f"{wetland_name}_animation.gif"
+    with imageio.get_writer(output_path, mode="I", duration=0.7, loop=0) as writer:
+        for frame_path in frames:
+            image = imageio.imread(frame_path)
+            writer.append_data(image)
+
+    # print("GIF saved as 'wetland_animation.gif'")
+
+    # clean up
+    # for frame_path in frames:
+    #    os.remove(frame_path)
+    # shutil.rmtree("frames")
+
+    return output_path

{dea_tools-0.3.6.dev41 → dea_tools-0.3.6.dev42/dea_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dea-tools
-Version: 0.3.6.dev41
+Version: 0.3.6.dev42
 Summary: Functions and algorithms for analysing Digital Earth Australia data.
 Home-page: https://github.com/GeoscienceAustralia/dea-notebooks
 Author: Geoscience Australia

{dea_tools-0.3.6.dev41 → dea_tools-0.3.6.dev42}/dea_tools.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ dea_tools/temporal.py
 dea_tools/validation.py
 dea_tools/waterbodies.py
 dea_tools/wetlands.py
+dea_tools/wit_app.py
 dea_tools.egg-info/PKG-INFO
 dea_tools.egg-info/SOURCES.txt
 dea_tools.egg-info/dependency_links.txt
@@ -37,4 +38,5 @@ dea_tools/app/deacoastlines.py
 dea_tools/app/geomedian.py
 dea_tools/app/imageexport.py
 dea_tools/app/miningrehab.py
+dea_tools/app/wetlandsinsighttool.py
 dea_tools/app/widgetconstructors.py