Initial commit

.github/workflows/sync-hf.yml

@@ -0,0 +1,20 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push --force https://giswqs:$HF_TOKEN@huggingface.co/spaces/giswqs/playa-wetlands main

.gitignore

@@ -0,0 +1,164 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+private/
+
+# C extensions
+*.so
+**/*.tif
+**/*.csv
+notebooks/
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

Dockerfile

@@ -0,0 +1,25 @@
+FROM jupyter/base-notebook:latest
+
+RUN mamba install -c conda-forge leafmap geopandas localtileserver -y && \
+    fix-permissions "${CONDA_DIR}" && \
+    fix-permissions "/home/${NB_USER}"
+
+USER root
+RUN apt-get update && apt-get install -y git
+RUN pip install -U git+https://github.com/gee-community/geemap.git
+
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+RUN mkdir ./pages
+COPY /pages ./pages
+
+ENV PROJ_LIB='/opt/conda/share/proj'
+
+USER root
+RUN chown -R ${NB_UID} ${HOME}
+USER ${NB_USER}
+
+EXPOSE 8765
+
+CMD ["solara", "run", "./pages", "--host=0.0.0.0"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Open Geospatial Solutions
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,2 +1,3 @@
 # playa-wetlands
+
 Mapping Playa Wetlands

pages/00_home.py

@@ -0,0 +1,19 @@
+import solara
+
+
+@solara.component
+def Page():
+    markdown = """
+    ## Solara for Geospatial Applications
+    
+    ### Introduction
+
+    An interactive web app for mapping Playa wetlands.
+
+    - Web App: <https://giswqs-playa-wetlands.hf.space>
+    - GitHub: <https://github.com/giswqs/playa-wetlands>
+    - Hugging Face: <https://huggingface.co/spaces/giswqs/playa-wetlands>
+
+    """
+
+    solara.Markdown(markdown)

pages/01_depressions.py

@@ -0,0 +1,272 @@
+import ee
+import geemap
+
+import solara
+import ipywidgets as widgets
+import ipyleaflet
+
+zoom = solara.reactive(4)
+center = solara.reactive([40, -100])
+
+
+class Map(geemap.Map):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.add_layer_manager(opened=False)
+        # self.add_layer_manager(opened=False)
+        self.add_data()
+        names = ["NED 10m", "Depressions", "NWI Vector"]
+        # self.add_buttons()
+        self.add_inspector(names=names, visible=False, opened=True)
+
+    def add_data(self):
+
+        url = "https://mt1.google.com/vt/lyrs=s&x={x}&y={y}&z={z}"
+        self.add_tile_layer(url, name="Google Satellite", attribution="Google")
+
+        n_layers = 9
+
+        self.setCenter(-99.00, 47.01, 8)
+
+        ned = ee.Image("USGS/3DEP/10m")
+        hillshade = ee.Terrain.hillshade(ned)
+        # Map.addLayer(hillshade, {}, "CONUS Hillshade", False)
+
+        conus = ee.Geometry.BBox(-127.18, 19.39, -62.75, 51.29)
+
+        huc8 = ee.FeatureCollection("USGS/WBD/2017/HUC08").filterBounds(conus)
+        pipestem_hu8 = ee.FeatureCollection("users/giswqs/Pipestem/Pipestem_HUC8")
+
+        style = {"color": "00000088", "fillColor": "00000000", "width": 1}
+
+        palette = ["006633", "E5FFCC", "662A00", "D8D8D8", "F5F5F5"]
+        self.addLayer(
+            ned, {"min": 0, "max": 4000, "palette": palette}, "NED 10m", False
+        )
+        self.addLayer(hillshade, {}, "NED Hillshade", False)
+
+        states = ee.FeatureCollection("TIGER/2018/States")
+        floodplain = ee.FeatureCollection("users/giswqs/floodplain/GFP250m")
+
+        gfplain250 = ee.Image("projects/sat-io/open-datasets/GFPLAIN250/NA")
+        states = ee.FeatureCollection("users/giswqs/public/us_states")
+        fp_image = gfplain250.clipToCollection(states)
+        self.addLayer(fp_image, {"palette": "#002B4D"}, "Floodplain raster", False)
+
+        fp_style = {"fillColor": "0000ff88"}
+        self.addLayer(floodplain.style(**fp_style), {}, "Floodplain vector", False)
+        self.addLayer(huc8, {}, "NHD-HU8 Vector", False)
+        self.addLayer(huc8.style(**style), {}, "NHD-HU8 Raster")
+        self.addLayer(
+            pipestem_hu8.style(
+                **{"color": "ffff00ff", "fillColor": "00000000", "width": 2}
+            ),
+            {},
+            "Pipestem HU8",
+        )
+
+        self.add_legend(
+            builtin_legend="NWI", position="bottomleft", title="NWI Wetland Type"
+        )
+
+        def add_buttons(self, opened=True):
+
+            widget_width = "250px"
+            padding = "0px 0px 0px 5px"  # upper, right, bottom, left
+            style = {"description_width": "initial"}
+
+            toolbar_button = widgets.ToggleButton(
+                value=False,
+                tooltip="Toolbar",
+                icon="hand-o-up",
+                layout=widgets.Layout(
+                    width="28px", height="28px", padding="0px 0px 0px 4px"
+                ),
+            )
+
+            close_button = widgets.ToggleButton(
+                value=False,
+                tooltip="Close the tool",
+                icon="times",
+                button_style="primary",
+                layout=widgets.Layout(
+                    height="28px", width="28px", padding="0px 0px 0px 4px"
+                ),
+            )
+
+            buttons = widgets.ToggleButtons(
+                value=None,
+                options=["Watershed", "Inspector", "Deactivate"],
+                tooltips=["Apply", "Reset", "Close"],
+                button_style="primary",
+            )
+            buttons.style.button_width = "87px"
+            # buttons.value = "Watershed"
+
+            label = widgets.Label(
+                "Click on the map to select a watershed",
+                padding="0px 0px 0px 4px",
+                style=style,
+            )
+
+            output = widgets.Output(
+                layout=widgets.Layout(width=widget_width, padding=padding)
+            )
+            toolbar_widget = widgets.VBox()
+            toolbar_widget.children = [toolbar_button]
+            toolbar_header = widgets.HBox()
+            toolbar_header.children = [close_button, toolbar_button]
+            toolbar_footer = widgets.VBox()
+            toolbar_footer.children = [
+                buttons,
+                label,
+                output,
+            ]
+
+            def toolbar_btn_click(change):
+                if change["new"]:
+                    close_button.value = False
+                    toolbar_widget.children = [toolbar_header, toolbar_footer]
+                else:
+                    if not close_button.value:
+                        toolbar_widget.children = [toolbar_button]
+
+            toolbar_button.observe(toolbar_btn_click, "value")
+
+            def close_btn_click(change):
+                if change["new"]:
+                    toolbar_button.value = False
+                    self.toolbar_reset()
+                    if (
+                        self.tool_control is not None
+                        and self.tool_control in self.controls
+                    ):
+                        self.remove_control(self.tool_control)
+                        self.tool_control = None
+                    toolbar_widget.close()
+
+            close_button.observe(close_btn_click, "value")
+
+            def button_clicked(change):
+                if change["new"] == "Watershed":
+                    label.value = "Click on the map to select a watershed"
+
+                    def handle_interaction(**kwargs):
+                        latlon = kwargs.get("coordinates")
+                        if (
+                            kwargs.get("type") == "click"
+                            and buttons.value == "Watershed"
+                        ):
+                            self.layers = self.layers[:n_layers]
+                            self.default_style = {"cursor": "wait"}
+                            clicked_point = ee.Geometry.Point(latlon[::-1])
+                            selected = huc8.filterBounds(clicked_point)
+                            watershed_bbox = selected.geometry().bounds()
+                            huc_id = selected.first().get("huc8").getInfo()
+                            self.addLayer(
+                                selected.style(
+                                    **{"color": "ff0000ff", "fillColor": "00000000"}
+                                ),
+                                {},
+                                "HU8-" + huc_id,
+                            )
+
+                            label.value = f"Watershed HU8: {huc_id}"
+
+                            hillshade_clip = hillshade.clipToCollection(selected)
+                            self.addLayer(hillshade_clip, {}, "Hillshade")
+                            depression_id = "users/giswqs/depressions/" + huc_id
+                            depressions = ee.FeatureCollection(depression_id)
+                            try:
+                                self.addLayer(depressions, {}, "Depressions")
+                            except Exception as e:
+                                print(e)
+                            nwi_id = "users/giswqs/NWI-HU8/HU8_" + huc_id + "_Wetlands"
+                            try:
+                                nwi = ee.FeatureCollection(nwi_id)
+                                self.addLayer(nwi, {}, "NWI Vector")
+                            except Exception as e:
+                                print(e)
+
+                            types = [
+                                "Freshwater Forested/Shrub Wetland",
+                                "Freshwater Emergent Wetland",
+                                "Freshwater Pond",
+                                "Estuarine and Marine Wetland",
+                                "Riverine",
+                                "Lake",
+                                "Estuarine and Marine Deepwater",
+                                "Other",
+                            ]
+
+                            colors = [
+                                "#008837",
+                                "#7FC31C",
+                                "#688CC0",
+                                "#66C2A5",
+                                "#0190BF",
+                                "#13007C",
+                                "#007C88",
+                                "#B28653",
+                            ]
+
+                            fillColor = [c + "A8" for c in colors]
+                            nwi_color = geemap.ee_vector_style(
+                                nwi,
+                                column="WETLAND_TY",
+                                labels=types,
+                                fillColor=fillColor,
+                                color="00000000",
+                            )
+
+                            self.addLayer(nwi_color, {}, "NWI Raster")
+                            # sel_state = states.filterBounds(clicked_point).first().get('STUSPS').getInfo()
+                            # asset = 'projects/sat-io/open-datasets/NHD/NHD_' + sel_state + '/'
+                            # nhd_water = ee.FeatureCollection(asset + 'NHDWaterbody')
+                            # nhd_area = ee.FeatureCollection(asset + 'NHDArea')
+                            # nhd_flowline = ee.FeatureCollection(asset + 'NHDFlowline')
+                            # nhd_line = ee.FeatureCollection(asset + 'NHDLine')
+
+                            self.default_style = {"cursor": "default"}
+
+                    self.on_interaction(handle_interaction)
+
+                    with output:
+                        output.clear_output()
+                        print("Running ...")
+                elif change["new"] == "Inspector":
+                    label.value = "Click on the map to inspect data"
+                    output.clear_output()
+                elif change["new"] == "Deactivate":
+                    buttons.value = None
+                    label.value = "Click on the map to select a watershed"
+
+                # buttons.value = None
+
+            buttons.observe(button_clicked, "value")
+            buttons.value = "Watershed"
+
+            toolbar_button.value = opened
+            buttons_control = ipyleaflet.WidgetControl(
+                widget=toolbar_widget, position="topright"
+            )
+
+            if buttons_control not in self.controls:
+                self.add_control(buttons_control)
+                self.tool_control = buttons_control
+
+        add_buttons(self, opened=True)
+
+
+@solara.component
+def Page():
+    with solara.Column(style={"min-width": "500px"}):
+        Map.element(  # type: ignore
+            zoom=zoom.value,
+            on_zoom=zoom.set,
+            center=center.value,
+            on_center=center.set,
+            height="750px",
+            # scroll_wheel_zoom=True,
+            # height="600px",
+        )

pages/02_lidar.py

@@ -0,0 +1,61 @@
+import geemap
+import solara
+import ee
+
+zoom = solara.reactive(4)
+center = solara.reactive((40, -100))
+
+
+class Map(geemap.Map):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # Add what you want below
+        self.add_data()
+        self.add_layer_manager(opened=False)
+
+    def add_data(self, **kwargs):
+        url = "https://mt1.google.com/vt/lyrs=s&x={x}&y={y}&z={z}"
+        self.add_tile_layer(url, name="Google Satellite", attribution="Google")
+
+        dem_wms = "https://elevation.nationalmap.gov/arcgis/services/3DEPElevation/ImageServer/WMSServer"
+        layer = "3DEPElevation:Hillshade Multidirectional"
+        self.add_wms_layer(
+            url=dem_wms, layers=layer, name="Hillshade", format="image/png", shown=True
+        )
+
+        huc12 = ee.FeatureCollection("USGS/WBD/2017/HUC12")
+        collection = ee.ImageCollection("USGS/3DEP/1m")
+        style = {"color": "0000ff88", "fillColor": "00000000", "width": 1}
+
+        self.add_layer(
+            collection, {"min": 0, "max": 4000, "palette": "terrain"}, "3DEP", True, 0.5
+        )
+
+        nwi_wms = "https://fwspublicservices.wiself.usgs.gov/wetlandsmapservice/services/Wetlands/MapServer/WMSServer"
+        self.add_wms_layer(url=nwi_wms, layers="1", name="NWI", format="image/png")
+
+        # self.add_layer(huc12, {}, "HU-12 Vector", False)
+        self.add_layer(
+            huc12.style(**style),
+            {},
+            "HU-12",
+        )
+
+
+@solara.component
+def Page():
+    with solara.Column(style={"min-width": "500px"}):
+        # solara components support reactive variables
+        # solara.SliderInt(label="Zoom level", value=zoom, min=1, max=20)
+        # using 3rd party widget library require wiring up the events manually
+        # using zoom.value and zoom.set
+        Map.element(  # type: ignore
+            zoom=zoom.value,
+            on_zoom=zoom.set,
+            center=center.value,
+            on_center=center.set,
+            scroll_wheel_zoom=True,
+            height="750px",
+        )
+        # solara.Text(f"Zoom: {zoom.value}")
+        # solara.Text(f"Center: {center.value}")

pages/03_timelapse.py

@@ -0,0 +1,25 @@
+import os
+import ee
+import geemap
+import ipywidgets as widgets
+from IPython.display import display
+import solara
+
+
+class Map(geemap.Map):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.add_basemap("Esri.WorldImagery")
+        self.add_gui("timelapse", basemap=None)
+
+
+@solara.component
+def Page():
+    with solara.Column(style={"min-width": "500px"}):
+        Map.element(
+            center=[20, -0],
+            zoom=2,
+            height="750px",
+            zoom_ctrl=False,
+            measure_ctrl=False,
+        )

pages/04_timeseries.py

@@ -0,0 +1,283 @@
+import os
+import ee
+import geemap
+import ipywidgets as widgets
+from IPython.display import display
+import solara
+from geemap import get_current_year, jslink_slider_label
+
+
+class Map(geemap.Map):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.add_basemap("Esri.WorldImagery")
+        self.add_ts_gui(position="topright")
+
+    def clean_up(self):
+        if hasattr(self, "slider_ctrl") and self.slider_ctrl is not None:
+            self.remove(self.slider_ctrl)
+            delattr(self, "slider_ctrl")
+
+        layer = self.find_layer("Time series")
+        if layer is not None:
+            self.remove(layer)
+        layer = self.find_layer("Image X")
+        if layer is not None:
+            self.remove(layer)
+
+        draw_layer = self.find_layer("Drawn Features")
+        if draw_layer is not None:
+            self.remove(draw_layer)
+
+    def add_ts_gui(self, position="topright", **kwargs):
+
+        widget_width = "350px"
+        padding = "0px 0px 0px 5px"  # upper, right, bottom, left
+        style = {"description_width": "initial"}
+        current_year = get_current_year()
+
+        collection = widgets.Dropdown(
+            options=[
+                "Landsat TM-ETM-OLI Surface Reflectance",
+            ],
+            value="Landsat TM-ETM-OLI Surface Reflectance",
+            description="Collection:",
+            layout=widgets.Layout(width=widget_width, padding=padding),
+            style=style,
+        )
+        bands = widgets.Dropdown(
+            description="Bands:",
+            options=[
+                "Red/Green/Blue",
+                "NIR/Red/Green",
+                "SWIR2/SWIR1/NIR",
+                "NIR/SWIR1/Red",
+                "SWIR2/NIR/Red",
+                "SWIR2/SWIR1/Red",
+                "SWIR1/NIR/Blue",
+                "NIR/SWIR1/Blue",
+                "SWIR2/NIR/Green",
+                "SWIR1/NIR/Red",
+            ],
+            value="SWIR1/NIR/Red",
+            style=style,
+            layout=widgets.Layout(width="195px", padding=padding),
+        )
+
+        frequency = widgets.Dropdown(
+            description="Frequency:",
+            options=["year", "quarter", "month"],
+            value="year",
+            style=style,
+            layout=widgets.Layout(width="150px", padding=padding),
+        )
+
+        start_year = widgets.IntSlider(
+            description="Start Year:",
+            value=1984,
+            min=1984,
+            max=current_year,
+            readout=False,
+            style=style,
+            layout=widgets.Layout(width="138px", padding=padding),
+        )
+
+        start_year_label = widgets.Label("1984")
+        jslink_slider_label(start_year, start_year_label)
+
+        end_year = widgets.IntSlider(
+            description="End Year:",
+            value=current_year,
+            min=1984,
+            max=current_year,
+            readout=False,
+            style=style,
+            layout=widgets.Layout(width="138px", padding=padding),
+        )
+        end_year_label = widgets.Label(str(current_year))
+        jslink_slider_label(end_year, end_year_label)
+
+        start_month = widgets.IntSlider(
+            description="Start Month:",
+            value=5,
+            min=1,
+            max=12,
+            readout=False,
+            style=style,
+            layout=widgets.Layout(width="145px", padding=padding),
+        )
+
+        start_month_label = widgets.Label(
+            "5",
+            layout=widgets.Layout(width="20px", padding=padding),
+        )
+        jslink_slider_label(start_month, start_month_label)
+
+        end_month = widgets.IntSlider(
+            description="End Month:",
+            value=10,
+            min=1,
+            max=12,
+            readout=False,
+            style=style,
+            layout=widgets.Layout(width="155px", padding=padding),
+        )
+
+        end_month_label = widgets.Label("10")
+        jslink_slider_label(end_month, end_month_label)
+
+        output = widgets.Output()
+
+        button_width = "113px"
+        apply_btn = widgets.Button(
+            description="Time slider",
+            button_style="primary",
+            tooltip="Click to create timeseries",
+            style=style,
+            layout=widgets.Layout(padding="0px", width=button_width),
+        )
+
+        split_btn = widgets.Button(
+            description="Split map",
+            button_style="primary",
+            tooltip="Click to create timeseries",
+            style=style,
+            layout=widgets.Layout(padding="0px", width=button_width),
+        )
+
+        reset_btn = widgets.Button(
+            description="Reset",
+            button_style="primary",
+            style=style,
+            layout=widgets.Layout(padding="0px", width=button_width),
+        )
+
+        vbox = widgets.VBox(
+            [
+                collection,
+                widgets.HBox([bands, frequency]),
+                widgets.HBox([start_year, start_year_label, end_year, end_year_label]),
+                widgets.HBox(
+                    [start_month, start_month_label, end_month, end_month_label]
+                ),
+                widgets.HBox([apply_btn, split_btn, reset_btn]),
+                output,
+            ]
+        )
+        self.add_widget(vbox, position=position, add_header=True)
+
+        def apply_btn_click(change):
+
+            if hasattr(self, "slider_ctrl") and self.slider_ctrl is not None:
+                self.remove(self.slider_ctrl)
+                delattr(self, "slider_ctrl")
+
+            with output:
+                output.clear_output()
+                if self.user_roi is None:
+                    output.append_stdout("Please draw a ROI first.")
+                else:
+                    output.append_stdout("Creating time series...")
+                    collection = geemap.landsat_timeseries(
+                        roi=self.user_roi,
+                        start_year=start_year.value,
+                        end_year=end_year.value,
+                        start_date=str(start_month.value).zfill(2) + "-01",
+                        end_date=str(end_month.value).zfill(2) + "-01",
+                        frequency=frequency.value,
+                    )
+                    vis_params = {
+                        "bands": bands.value.split("/"),
+                        "min": 0,
+                        "max": 0.4,
+                    }
+
+                    if frequency.value == "year":
+                        date_format = "YYYY"
+                    elif frequency.value == "quarter":
+                        date_format = "YYYY-MM"
+                    elif frequency.value == "month":
+                        date_format = "YYYY-MM"
+
+                    self.add_time_slider(
+                        collection,
+                        region=self.user_roi,
+                        vis_params=vis_params,
+                        date_format=date_format,
+                    )
+                    self._draw_control.clear()
+                    draw_layer = self.find_layer("Drawn Features")
+                    if draw_layer is not None:
+                        self.remove(draw_layer)
+                    output.clear_output()
+
+        apply_btn.on_click(apply_btn_click)
+
+        def split_btn_click(change):
+
+            if hasattr(self, "slider_ctrl") and self.slider_ctrl is not None:
+                self.remove(self.slider_ctrl)
+                delattr(self, "slider_ctrl")
+
+            with output:
+                output.clear_output()
+                if self.user_roi is None:
+                    output.append_stdout("Please draw a ROI first.")
+                else:
+                    output.append_stdout("Creating time series...")
+                    collection = geemap.landsat_timeseries(
+                        roi=self.user_roi,
+                        start_year=start_year.value,
+                        end_year=end_year.value,
+                        start_date=str(start_month.value).zfill(2) + "-01",
+                        end_date=str(end_month.value).zfill(2) + "-01",
+                        frequency=frequency.value,
+                    )
+                    vis_params = {
+                        "bands": bands.value.split("/"),
+                        "min": 0,
+                        "max": 0.4,
+                    }
+
+                    if frequency.value == "year":
+                        date_format = "YYYY"
+                        dates = geemap.image_dates(collection, date_format).getInfo()
+                    elif frequency.value == "quarter":
+                        date_format = "YYYY-MM"
+                        dates = geemap.image_dates(collection, date_format).getInfo()
+                    elif frequency.value == "month":
+                        date_format = "YYYY-MM"
+                        dates = geemap.image_dates(collection, date_format).getInfo()
+
+                    self.ts_inspector(
+                        collection,
+                        left_names=dates,
+                        left_vis=vis_params,
+                        add_close_button=True,
+                    )
+                    output.clear_output()
+
+                    self._draw_control.clear()
+                    draw_layer = self.find_layer("Drawn Features")
+                    if draw_layer is not None:
+                        self.remove(draw_layer)
+
+        split_btn.on_click(split_btn_click)
+
+        def reset_btn_click(change):
+            output.clear_output()
+            self.clean_up()
+
+        reset_btn.on_click(reset_btn_click)
+
+
+@solara.component
+def Page():
+    with solara.Column(style={"min-width": "500px"}):
+        Map.element(
+            center=[20, -0],
+            zoom=2,
+            height="750px",
+            zoom_ctrl=False,
+            measure_ctrl=False,
+        )

pages/05_jrc.py

@@ -0,0 +1,141 @@
+import os
+import ee
+import geemap
+import ipywidgets as widgets
+from IPython.display import display
+import solara
+
+
+class Map(geemap.Map):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.add_basemap("Esri.WorldImagery")
+        self.add_ee_data()
+        self.add_buttons(add_header=True)
+
+    def add_ee_data(self):
+
+        dataset = ee.Image("JRC/GSW1_4/GlobalSurfaceWater")
+        image = dataset.select(["occurrence"])
+        vis_params = {
+            "min": 0.0,
+            "max": 100.0,
+            "palette": ["ffffff", "ffbbbb", "0000ff"],
+        }
+        self.addLayer(image, vis_params, "Occurrence")
+        self.add_colorbar(
+            vis_params, label="Water occurrence (%)", layer_name="Occurrence"
+        )
+
+    def add_buttons(self, position="topright", **kwargs):
+        padding = "0px 5px 0px 5px"
+        widget = widgets.VBox(layout=widgets.Layout(padding=padding))
+        layout = widgets.Layout(width="auto")
+        style = {"description_width": "initial"}
+        hist_btn = widgets.Button(description="Occurrence", layout=layout)
+        bar_btn = widgets.Button(description="Monthly history", layout=layout)
+        reset_btn = widgets.Button(description="Reset", layout=layout)
+        scale = widgets.IntSlider(
+            min=30, max=1000, value=90, description="Scale", layout=layout, style=style
+        )
+        month_slider = widgets.IntRangeSlider(
+            description="Months",
+            value=[5, 10],
+            min=1,
+            max=12,
+            step=1,
+            layout=layout,
+            style=style,
+        )
+        widget.children = [
+            widgets.HBox([hist_btn, bar_btn, reset_btn]),
+            month_slider,
+            scale,
+        ]
+        self.add_widget(widget, position=position, **kwargs)
+        output = widgets.Output()
+        self.add_widget(output, position="bottomleft", add_header=False)
+
+        def hist_btn_click(b):
+            region = self.user_roi
+            if region is not None:
+                output.clear_output()
+                output.append_stdout("Computing histogram...")
+                image = ee.Image("JRC/GSW1_4/GlobalSurfaceWater").select(["occurrence"])
+                self.default_style = {"cursor": "wait"}
+                hist = geemap.image_histogram(
+                    image,
+                    region,
+                    scale=scale.value,
+                    height=350,
+                    width=550,
+                    x_label="Water Occurrence (%)",
+                    y_label="Pixel Count",
+                    layout_args={
+                        "title": dict(x=0.5),
+                        "margin": dict(l=0, r=0, t=10, b=0),
+                    },
+                    return_df=False,
+                )
+
+                with output:
+                    output.clear_output()
+                    display(hist)
+                self.default_style = {"cursor": "default"}
+            else:
+                output.clear_output()
+                with output:
+                    output.append_stdout("Please draw a region of interest first.")
+
+        hist_btn.on_click(hist_btn_click)
+
+        def bar_btn_click(b):
+            region = self.user_roi
+            if region is not None:
+                self.default_style = {"cursor": "wait"}
+                output.clear_output()
+                output.append_stdout("Computing monthly history...")
+                bar = geemap.jrc_hist_monthly_history(
+                    region=region,
+                    scale=scale.value,
+                    height=350,
+                    width=550,
+                    layout_args={
+                        "title": dict(x=0.5),
+                        "margin": dict(l=0, r=0, t=10, b=0),
+                    },
+                    frequency="month",
+                    start_month=month_slider.value[0],
+                    end_month=month_slider.value[1],
+                    denominator=1e4,
+                    y_label="Area (ha)",
+                )
+
+                with output:
+                    output.clear_output()
+                    display(bar)
+                self.default_style = {"cursor": "default"}
+            else:
+                output.clear_output()
+                with output:
+                    output.append_stdout("Please draw a region of interest first.")
+
+        bar_btn.on_click(bar_btn_click)
+
+        def reset_btn_click(b):
+            self._draw_control.clear()
+            output.clear_output()
+
+        reset_btn.on_click(reset_btn_click)
+
+
+@solara.component
+def Page():
+    with solara.Column(style={"min-width": "500px"}):
+        Map.element(
+            center=[20, -0],
+            zoom=2,
+            height="750px",
+            zoom_ctrl=False,
+            measure_ctrl=False,
+        )

pages/06_compare.py

@@ -0,0 +1,279 @@
+import os
+import ee
+import geemap
+import ipywidgets as widgets
+from IPython.display import display
+import solara
+from datetime import date
+
+
+class Map(geemap.Map):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.add_basemap("Esri.WorldImagery")
+        self.add_gui_widget(add_header=True)
+
+    def clean_up(self):
+
+        layers = [
+            "Pre-event Image",
+            "Post-event Image",
+            "Pre-event NDWI",
+            "Post-event NDWI",
+            "Pre-event Water",
+            "Post-event Water",
+            "Disappeared Water",
+            "New Water",
+        ]
+        for layer_name in layers:
+            layer = self.find_layer(layer_name)
+            if layer is not None:
+                self.remove(layer)
+
+    def add_gui_widget(self, position="topright", **kwargs):
+
+        widget = widgets.VBox(layout=widgets.Layout(padding="0px 5px 0px 5px"))
+        pre_widget = widgets.HBox()
+        post_widget = widgets.HBox()
+        layout = widgets.Layout(width="auto")
+        style = {"description_width": "initial"}
+        padding = "0px 5px 0px 5px"
+        pre_start_date = widgets.DatePicker(
+            description="Start",
+            value=date(2014, 1, 1),
+            style=style,
+            layout=widgets.Layout(padding=padding, width="160px"),
+        )
+        pre_end_date = widgets.DatePicker(
+            description="End",
+            value=date(2014, 12, 31),
+            style=style,
+            layout=widgets.Layout(padding=padding, width="160px"),
+        )
+        pre_cloud_cover = widgets.IntSlider(
+            description="Cloud",
+            min=0,
+            max=100,
+            value=25,
+            step=1,
+            readout=False,
+            style=style,
+            layout=widgets.Layout(padding=padding, width="130px"),
+        )
+        pre_cloud_label = widgets.Label(value=str(pre_cloud_cover.value))
+        geemap.jslink_slider_label(pre_cloud_cover, pre_cloud_label)
+        pre_widget.children = [
+            pre_start_date,
+            pre_end_date,
+            pre_cloud_cover,
+            pre_cloud_label,
+        ]
+        post_start_date = widgets.DatePicker(
+            description="Start",
+            value=date(2024, 1, 1),
+            style=style,
+            layout=widgets.Layout(padding=padding, width="160px"),
+        )
+        post_end_date = widgets.DatePicker(
+            description="End",
+            value=date(2024, 12, 31),
+            style=style,
+            layout=widgets.Layout(padding=padding, width="160px"),
+        )
+        post_cloud_cover = widgets.IntSlider(
+            description="Cloud",
+            min=0,
+            max=100,
+            value=30,
+            step=1,
+            readout=False,
+            style=style,
+            layout=widgets.Layout(padding=padding, width="130px"),
+        )
+        post_cloud_label = widgets.Label(value=str(post_cloud_cover.value))
+        geemap.jslink_slider_label(post_cloud_cover, post_cloud_label)
+        post_widget.children = [
+            post_start_date,
+            post_end_date,
+            post_cloud_cover,
+            post_cloud_label,
+        ]
+
+        apply_btn = widgets.Button(description="Apply", layout=layout)
+        reset_btn = widgets.Button(description="Reset", layout=layout)
+        buttons = widgets.HBox([apply_btn, reset_btn])
+        output = widgets.Output()
+
+        use_split = widgets.Checkbox(
+            value=False,
+            description="Split map",
+            style=style,
+            layout=widgets.Layout(padding=padding, width="100px"),
+        )
+
+        use_ndwi = widgets.Checkbox(
+            value=False,
+            description="Compute NDWI",
+            style=style,
+            layout=widgets.Layout(padding=padding, width="160px"),
+        )
+
+        ndwi_threhold = widgets.FloatSlider(
+            description="Threshold",
+            min=-1,
+            max=1,
+            value=0,
+            step=0.05,
+            readout=True,
+            style=style,
+            layout=widgets.Layout(padding=padding, width="230px"),
+        )
+
+        options = widgets.HBox(
+            [
+                use_split,
+                use_ndwi,
+                ndwi_threhold,
+            ]
+        )
+
+        widget.children = [pre_widget, post_widget, options, buttons, output]
+        self.add_widget(widget, position=position, **kwargs)
+
+        def apply_btn_click(b):
+
+            marker_layer = self.find_layer("Search location")
+            if marker_layer is not None:
+                self.remove(marker_layer)
+            self.clean_up()
+
+            if self.user_roi is None:
+                output.clear_output()
+                output.append_stdout("Please draw a ROI first.")
+            elif (
+                pre_start_date.value is None
+                or pre_end_date.value is None
+                or post_start_date.value is None
+                or post_end_date.value is None
+            ):
+                output.clear_output()
+                output.append_stdout("Please select start and end dates.")
+
+            elif self.user_roi is not None:
+                output.clear_output()
+                output.append_stdout("Computing... Please wait.")
+                roi = ee.FeatureCollection(self.user_roi)
+                vis_params = {"bands": ["B6", "B5", "B4"], "min": 0, "max": 0.4}
+                if pre_start_date.value.strftime("%Y-%m-%d") < "2013-04-11":
+                    pre_col = geemap.landsat_timeseries(
+                        roi,
+                        start_year=pre_start_date.value.year,
+                        end_year=pre_end_date.value.year,
+                    ).select(["SWIR1", "NIR", "Red", "Green"], ["B6", "B5", "B4", "B3"])
+                else:
+                    pre_col = (
+                        ee.ImageCollection("NASA/HLS/HLSL30/v002")
+                        .filterBounds(roi)
+                        .filterDate(
+                            pre_start_date.value.strftime("%Y-%m-%d"),
+                            pre_end_date.value.strftime("%Y-%m-%d"),
+                        )
+                        .filter(ee.Filter.lt("CLOUD_COVERAGE", pre_cloud_cover.value))
+                    )
+
+                if post_start_date.value.strftime("%Y-%m-%d") < "2013-04-11":
+                    post_col = geemap.landsat_timeseries(
+                        roi,
+                        start_year=post_start_date.value.year,
+                        end_year=post_end_date.value.year,
+                    ).select(["SWIR1", "NIR", "Red", "Green"], ["B6", "B5", "B4", "B3"])
+                else:
+                    post_col = (
+                        ee.ImageCollection("NASA/HLS/HLSL30/v002")
+                        .filterBounds(roi)
+                        .filterDate(
+                            post_start_date.value.strftime("%Y-%m-%d"),
+                            post_end_date.value.strftime("%Y-%m-%d"),
+                        )
+                        .filter(ee.Filter.lt("CLOUD_COVERAGE", post_cloud_cover.value))
+                    )
+
+                pre_img = pre_col.median().clip(roi)
+                post_img = post_col.median().clip(roi)
+
+                if use_split.value:
+                    left_layer = geemap.ee_tile_layer(
+                        pre_img, vis_params, "Pre-event Image"
+                    )
+                    right_layer = geemap.ee_tile_layer(
+                        post_img, vis_params, "Post-event Image"
+                    )
+                    self.split_map(
+                        left_layer,
+                        right_layer,
+                        add_close_button=True,
+                        left_label="Pre-event",
+                        right_label="Post-event",
+                    )
+                else:
+                    pre_img = pre_col.median().clip(roi)
+                    post_img = post_col.median().clip(roi)
+                    self.add_layer(pre_img, vis_params, "Pre-event Image")
+                    self.add_layer(post_img, vis_params, "Post-event Image")
+
+                if use_ndwi.value and (not use_split.value):
+                    pre_ndwi = pre_img.normalizedDifference(["B3", "B6"]).rename("NDWI")
+                    post_ndwi = post_img.normalizedDifference(["B3", "B6"]).rename(
+                        "NDWI"
+                    )
+                    ndwi_vis = {"min": -1, "max": 1, "palette": "ndwi"}
+                    self.add_layer(pre_ndwi, ndwi_vis, "Pre-event NDWI", False)
+                    self.add_layer(post_ndwi, ndwi_vis, "Post-event NDWI", False)
+
+                    pre_water = pre_ndwi.gt(ndwi_threhold.value)
+                    post_water = post_ndwi.gt(ndwi_threhold.value)
+                    self.add_layer(
+                        pre_water.selfMask(), {"palette": "blue"}, "Pre-event Water"
+                    )
+                    self.add_layer(
+                        post_water.selfMask(), {"palette": "red"}, "Post-event Water"
+                    )
+                    new_water = post_water.subtract(pre_water).gt(0)
+                    disappear_water = pre_water.subtract(post_water).gt(0)
+                    self.add_layer(
+                        disappear_water.selfMask(),
+                        {"palette": "brown"},
+                        "Disappeared Water",
+                    )
+                    self.add_layer(
+                        new_water.selfMask(), {"palette": "cyan"}, "New Water"
+                    )
+
+                    with output:
+                        output.clear_output()
+
+                output.clear_output()
+
+        apply_btn.on_click(apply_btn_click)
+
+        def reset_btn_click(b):
+            self.clean_up()
+            self._draw_control.clear()
+            draw_layer = self.find_layer("Drawn Features")
+            if draw_layer is not None:
+                self.remove(draw_layer)
+            output.clear_output()
+
+        reset_btn.on_click(reset_btn_click)
+
+
+@solara.component
+def Page():
+    with solara.Column(style={"min-width": "500px"}):
+        Map.element(
+            center=[20, -0],
+            zoom=2,
+            height="750px",
+            zoom_ctrl=False,
+            measure_ctrl=False,
+        )

requirements.txt

@@ -0,0 +1,4 @@
+git+https://github.com/gee-community/geemap.git
+git+https://github.com/opengeos/leafmap.git
+solara
+geopandas