Add timelapse app

.gitignore

@@ -0,0 +1,132 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+# *.html
+private/
+.vscode/
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+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/
+
+# 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
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.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
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__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/

Home.py

@@ -0,0 +1,59 @@
+import streamlit as st
+import leafmap.foliumap as leafmap
+
+st.set_page_config(layout="wide")
+
+st.sidebar.title("About")
+st.sidebar.info(
+    """
+    Web App URL: <https://geospatial.streamlitapp.com>
+    GitHub repository: <https://github.com/giswqs/streamlit-geospatial>
+    """
+)
+
+st.sidebar.title("Contact")
+st.sidebar.info(
+    """
+    Qiusheng Wu: <https://wetlands.io>
+    [GitHub](https://github.com/giswqs) | [Twitter](https://twitter.com/giswqs) | [YouTube](https://www.youtube.com/c/QiushengWu) | [LinkedIn](https://www.linkedin.com/in/qiushengwu)
+    """
+)
+
+st.sidebar.title("Support")
+st.sidebar.info(
+    """
+    If you want to reward my work, I'd love a cup of coffee from you. Thanks!
+    [buymeacoffee.com/giswqs](http://buymeacoffee.com/giswqs)
+    """
+)
+
+
+st.title("Streamlit for Geospatial Applications")
+
+st.markdown(
+    """
+    This multi-page web app demonstrates various interactive web apps created using [streamlit](https://streamlit.io) and open-source mapping libraries, 
+    such as [leafmap](https://leafmap.org), [geemap](https://geemap.org), [pydeck](https://deckgl.readthedocs.io), and [kepler.gl](https://docs.kepler.gl/docs/keplergl-jupyter).
+    This is an open-source project and you are very welcome to contribute your comments, questions, resources, and apps as [issues](https://github.com/giswqs/streamlit-geospatial/issues) or 
+    [pull requests](https://github.com/giswqs/streamlit-geospatial/pulls) to the [GitHub repository](https://github.com/giswqs/streamlit-geospatial).
+
+    """
+)
+
+st.info("Click on the left sidebar menu to navigate to the different apps.")
+
+st.subheader("Timelapse of Satellite Imagery")
+st.markdown(
+    """
+    The following timelapse animations were created using the Timelapse web app. Click `Timelapse` on the left sidebar menu to create your own timelapse for any location around the globe.
+"""
+)
+
+row1_col1, row1_col2 = st.columns(2)
+with row1_col1:
+    st.image("https://github.com/giswqs/data/raw/main/timelapse/spain.gif")
+    st.image("https://github.com/giswqs/data/raw/main/timelapse/las_vegas.gif")
+
+with row1_col2:
+    st.image("https://github.com/giswqs/data/raw/main/timelapse/goes.gif")
+    st.image("https://github.com/giswqs/data/raw/main/timelapse/fire.gif")

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Qiusheng Wu
+
+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.

Procfile

@@ -0,0 +1 @@
+web: sh setup.sh && streamlit run Home.py

app-bk.py

@@ -0,0 +1,49 @@
+import streamlit as st
+from multiapp import MultiApp
+from apps import (
+    basemaps,
+    census,
+    cesium,
+    deck,
+    device_loc,
+    gee,
+    gee_datasets,
+    heatmap,
+    home,
+    housing,
+    # hurricane,
+    plotly_maps,
+    raster,
+    timelapse,
+    vector,
+    wms,
+    xy,
+)
+
+st.set_page_config(layout="wide")
+
+
+apps = MultiApp()
+
+# Add all your application here
+
+apps.add_app("Home", home.app)
+apps.add_app("Create Timelapse", timelapse.app)
+# apps.add_app("Hurricane Mapping", hurricane.app)
+apps.add_app("U.S. Real Estate Data", housing.app)
+apps.add_app("U.S. Census Data", census.app)
+apps.add_app("Visualize Raster Data", raster.app)
+apps.add_app("Visualize Vector Data", vector.app)
+apps.add_app("Search Basemaps", basemaps.app)
+apps.add_app("Pydeck Gallery", deck.app)
+apps.add_app("Heatmaps", heatmap.app)
+apps.add_app("Add Points from XY", xy.app)
+apps.add_app("Add Web Map Service (WMS)", wms.app)
+apps.add_app("Google Earth Engine (GEE)", gee.app)
+apps.add_app("Awesome GEE Community Datasets", gee_datasets.app)
+apps.add_app("Geolocation", device_loc.app)
+apps.add_app("Cesium 3D Map", cesium.app)
+apps.add_app("Plotly", plotly_maps.app)
+
+# The main app
+apps.run()

app.py

@@ -1,4 +1,50 @@
 import streamlit as st
+import leafmap.foliumap as leafmap
 
-x = st.slider('Select a value')
-st.write(x, 'squared is', x * x)
+st.set_page_config(layout="wide")
+
+st.sidebar.title("About")
+st.sidebar.info(
+    """
+    Web App URL: <https://geospatial.streamlitapp.com>
+    GitHub repository: <https://github.com/giswqs/streamlit-geospatial>
+    """
+)
+
+st.sidebar.title("Contact")
+st.sidebar.info(
+    """
+    Qiusheng Wu: <https://wetlands.io>
+    [GitHub](https://github.com/giswqs) | [Twitter](https://twitter.com/giswqs) | [YouTube](https://www.youtube.com/c/QiushengWu) | [LinkedIn](https://www.linkedin.com/in/qiushengwu)
+    """
+)
+
+st.title("Streamlit for Geospatial Applications")
+
+st.markdown(
+    """
+    This multi-page web app demonstrates various interactive web apps created using [streamlit](https://streamlit.io) and open-source mapping libraries, 
+    such as [leafmap](https://leafmap.org), [geemap](https://geemap.org), [pydeck](https://deckgl.readthedocs.io), and [kepler.gl](https://docs.kepler.gl/docs/keplergl-jupyter).
+    This is an open-source project and you are very welcome to contribute your comments, questions, resources, and apps as [issues](https://github.com/giswqs/streamlit-geospatial/issues) or 
+    [pull requests](https://github.com/giswqs/streamlit-geospatial/pulls) to the [GitHub repository](https://github.com/giswqs/streamlit-geospatial).
+
+    """
+)
+
+st.info("Click on the left sidebar menu to navigate to the different apps.")
+
+st.subheader("Timelapse of Satellite Imagery")
+st.markdown(
+    """
+    The following timelapse animations were created using the Timelapse web app. Click `Timelapse` on the left sidebar menu to create your own timelapse for any location around the globe.
+"""
+)
+
+row1_col1, row1_col2 = st.columns(2)
+with row1_col1:
+    st.image("https://github.com/giswqs/data/raw/main/timelapse/spain.gif")
+    st.image("https://github.com/giswqs/data/raw/main/timelapse/las_vegas.gif")
+
+with row1_col2:
+    st.image("https://github.com/giswqs/data/raw/main/timelapse/goes.gif")
+    st.image("https://github.com/giswqs/data/raw/main/timelapse/fire.gif")

apps/basemaps.py

@@ -0,0 +1,44 @@
+import streamlit as st
+import leafmap.foliumap as leafmap
+
+
+def app():
+    st.title("Searching Basemaps")
+    st.markdown(
+        """
+    This app is a demonstration of searching and loading basemaps from [xyzservices](https://github.com/geopandas/xyzservices) and [Quick Map Services (QMS)](https://github.com/nextgis/quickmapservices). Selecting from 1000+ basemaps with a few clicks.  
+    """
+    )
+
+    with st.expander("See demo"):
+        st.image("https://i.imgur.com/0SkUhZh.gif")
+
+    row1_col1, row1_col2 = st.columns([3, 1])
+    width = 800
+    height = 600
+    tiles = None
+
+    with row1_col2:
+
+        checkbox = st.checkbox("Search Quick Map Services (QMS)")
+        keyword = st.text_input("Enter a keyword to search and press Enter:")
+        empty = st.empty()
+
+        if keyword:
+            options = leafmap.search_xyz_services(keyword=keyword)
+            if checkbox:
+                qms = leafmap.search_qms(keyword=keyword)
+                if qms is not None:
+                    options = options + qms
+
+            tiles = empty.multiselect(
+                "Select XYZ tiles to add to the map:", options)
+
+        with row1_col1:
+            m = leafmap.Map()
+
+            if tiles is not None:
+                for tile in tiles:
+                    m.add_xyz_service(tile)
+
+            m.to_streamlit(width, height)

apps/census.py

@@ -0,0 +1,35 @@
+import streamlit as st
+import leafmap.foliumap as leafmap
+
+
+def app():
+    st.title("Using U.S. Census Data")
+    st.markdown(
+        """
+    This app is a demonstration of using the [U.S. Census Bureau](https://www.census.gov/) TIGERweb Web Map Service (WMS). A complete list of WMS layers can be found [here](https://tigerweb.geo.census.gov/tigerwebmain/TIGERweb_wms.html). 
+    """
+    )
+
+    if "first_index" not in st.session_state:
+        st.session_state["first_index"] = 60
+    else:
+        st.session_state["first_index"] = 0
+
+    row1_col1, row1_col2 = st.columns([3, 1])
+    width = 800
+    height = 600
+
+    census_dict = leafmap.get_census_dict()
+    with row1_col2:
+
+        wms = st.selectbox("Select a WMS", list(census_dict.keys()), index=11)
+        layer = st.selectbox(
+            "Select a layer",
+            census_dict[wms]["layers"],
+            index=st.session_state["first_index"],
+        )
+
+        with row1_col1:
+            m = leafmap.Map()
+            m.add_census_data(wms, layer)
+            m.to_streamlit(width, height)

apps/cesium.py

@@ -0,0 +1,8 @@
+import leafmap
+import streamlit as st
+
+
+def app():
+    st.title("Cesium 3D Map")
+    html = "data/html/sfo_buildings.html"
+    leafmap.cesium_to_streamlit(html, height=800)

apps/deck.py

@@ -0,0 +1,178 @@
+import os
+import streamlit as st
+import pydeck as pdk
+import pandas as pd
+
+
+def globe_view():
+
+    """
+    GlobeView
+    =========
+
+    Over 33,000 power plants of the world plotted by their production capacity (given by height)
+    and fuel type (green if renewable) on an experimental deck.gl GlobeView.
+    """
+
+    COUNTRIES = "https://d2ad6b4ur7yvpq.cloudfront.net/naturalearth-3.3.0/ne_50m_admin_0_scale_rank.geojson"
+    POWER_PLANTS = "https://raw.githubusercontent.com/ajduberstein/geo_datasets/master/global_power_plant_database.csv"
+
+    df = pd.read_csv(POWER_PLANTS)
+
+    def is_green(fuel_type):
+        """Return a green RGB value if a facility uses a renewable fuel type"""
+        if fuel_type.lower() in (
+            "nuclear",
+            "water",
+            "wind",
+            "hydro",
+            "biomass",
+            "solar",
+            "geothermal",
+        ):
+            return [10, 230, 120]
+        return [230, 158, 10]
+
+    df["color"] = df["primary_fuel"].apply(is_green)
+
+    view_state = pdk.ViewState(latitude=51.47, longitude=0.45, zoom=2, min_zoom=2)
+
+    # Set height and width variables
+    view = pdk.View(type="_GlobeView", controller=True, width=1000, height=700)
+
+    layers = [
+        pdk.Layer(
+            "GeoJsonLayer",
+            id="base-map",
+            data=COUNTRIES,
+            stroked=False,
+            filled=True,
+            get_fill_color=[200, 200, 200],
+        ),
+        pdk.Layer(
+            "ColumnLayer",
+            id="power-plant",
+            data=df,
+            get_elevation="capacity_mw",
+            get_position=["longitude", "latitude"],
+            elevation_scale=100,
+            pickable=True,
+            auto_highlight=True,
+            radius=20000,
+            get_fill_color="color",
+        ),
+    ]
+
+    r = pdk.Deck(
+        views=[view],
+        initial_view_state=view_state,
+        tooltip={"text": "{name}, {primary_fuel} plant, {country}"},
+        layers=layers,
+        # Note that this must be set for the globe to be opaque
+        parameters={"cull": True},
+    )
+
+    return r
+
+
+def geojson_layer():
+
+    """
+    GeoJsonLayer
+    ===========
+
+    Property values in Vancouver, Canada, adapted from the deck.gl example pages. Input data is in a GeoJSON format.
+    """
+
+    DATA_URL = "https://raw.githubusercontent.com/visgl/deck.gl-data/master/examples/geojson/vancouver-blocks.json"
+    LAND_COVER = [
+        [[-123.0, 49.196], [-123.0, 49.324], [-123.306, 49.324], [-123.306, 49.196]]
+    ]
+
+    INITIAL_VIEW_STATE = pdk.ViewState(
+        latitude=49.254, longitude=-123.13, zoom=11, max_zoom=16, pitch=45, bearing=0
+    )
+
+    polygon = pdk.Layer(
+        "PolygonLayer",
+        LAND_COVER,
+        stroked=False,
+        # processes the data as a flat longitude-latitude pair
+        get_polygon="-",
+        get_fill_color=[0, 0, 0, 20],
+    )
+
+    geojson = pdk.Layer(
+        "GeoJsonLayer",
+        DATA_URL,
+        opacity=0.8,
+        stroked=False,
+        filled=True,
+        extruded=True,
+        wireframe=True,
+        get_elevation="properties.valuePerSqm / 20",
+        get_fill_color="[255, 255, properties.growth * 255]",
+        get_line_color=[255, 255, 255],
+    )
+
+    r = pdk.Deck(layers=[polygon, geojson], initial_view_state=INITIAL_VIEW_STATE)
+    return r
+
+
+def terrain():
+
+    """
+    TerrainLayer
+    ===========
+
+    Extruded terrain using AWS Open Data Terrain Tiles and Mapbox Satellite imagery
+    """
+
+    # Import Mapbox API Key from environment
+    MAPBOX_API_KEY = os.environ["MAPBOX_API_KEY"]
+
+    # AWS Open Data Terrain Tiles
+    TERRAIN_IMAGE = (
+        "https://s3.amazonaws.com/elevation-tiles-prod/terrarium/{z}/{x}/{y}.png"
+    )
+
+    # Define how to parse elevation tiles
+    ELEVATION_DECODER = {
+        "rScaler": 256,
+        "gScaler": 1,
+        "bScaler": 1 / 256,
+        "offset": -32768,
+    }
+
+    SURFACE_IMAGE = f"https://api.mapbox.com/v4/mapbox.satellite/{{z}}/{{x}}/{{y}}@2x.png?access_token={MAPBOX_API_KEY}"
+
+    terrain_layer = pdk.Layer(
+        "TerrainLayer",
+        elevation_decoder=ELEVATION_DECODER,
+        texture=SURFACE_IMAGE,
+        elevation_data=TERRAIN_IMAGE,
+    )
+
+    view_state = pdk.ViewState(
+        latitude=46.24, longitude=-122.18, zoom=11.5, bearing=140, pitch=60
+    )
+
+    r = pdk.Deck(terrain_layer, initial_view_state=view_state)
+    return r
+
+
+def app():
+
+    st.title("Pydeck Gallery")
+
+    options = ["GeoJsonLayer", "GlobeView", "TerrainLayer"]
+
+    option = st.selectbox("Select a pydeck layer type", options)
+
+    if option == "GeoJsonLayer":
+        st.header("Property values in Vancouver, Canada")
+        st.pydeck_chart(geojson_layer())
+    # elif option == "GlobeView":
+    #     st.pydeck_chart(globe_view())
+    elif option == "TerrainLayer":
+        st.pydeck_chart(terrain())

apps/device_loc.py

@@ -0,0 +1,43 @@
+import streamlit as st
+from bokeh.models.widgets import Button
+from bokeh.models import CustomJS
+from streamlit_bokeh_events import streamlit_bokeh_events
+import leafmap.foliumap as leafmap
+
+
+def app():
+
+    loc_button = Button(label="Get Device Location", max_width=150)
+    loc_button.js_on_event(
+        "button_click",
+        CustomJS(
+            code="""
+        navigator.geolocation.getCurrentPosition(
+            (loc) => {
+                document.dispatchEvent(new CustomEvent("GET_LOCATION", {detail: {lat: loc.coords.latitude, lon: loc.coords.longitude}}))
+            }
+        )
+        """
+        ),
+    )
+    result = streamlit_bokeh_events(
+        loc_button,
+        events="GET_LOCATION",
+        key="get_location",
+        refresh_on_update=False,
+        override_height=75,
+        debounce_time=0,
+    )
+
+    if result:
+        if "GET_LOCATION" in result:
+            loc = result.get("GET_LOCATION")
+            lat = loc.get("lat")
+            lon = loc.get("lon")
+            st.write(f"Lat, Lon: {lat}, {lon}")
+
+            m = leafmap.Map(center=(lat, lon), zoom=16)
+            m.add_basemap("ROADMAP")
+            popup = f"lat, lon: {lat}, {lon}"
+            m.add_marker(location=(lat, lon), popup=popup)
+            m.to_streamlit()

apps/gee.py

@@ -0,0 +1,123 @@
+import ee
+import streamlit as st
+import geemap.foliumap as geemap
+
+
+def nlcd():
+
+    st.header("National Land Cover Database (NLCD)")
+
+    row1_col1, row1_col2 = st.columns([3, 1])
+    width = 950
+    height = 600
+
+    Map = geemap.Map()
+
+    # Select the seven NLCD epoches after 2000.
+    years = ["2001", "2004", "2006", "2008", "2011", "2013", "2016"]
+
+    # Get an NLCD image by year.
+    def getNLCD(year):
+        # Import the NLCD collection.
+        dataset = ee.ImageCollection("USGS/NLCD_RELEASES/2016_REL")
+
+        # Filter the collection by year.
+        nlcd = dataset.filter(ee.Filter.eq("system:index", year)).first()
+
+        # Select the land cover band.
+        landcover = nlcd.select("landcover")
+        return landcover
+
+    with row1_col2:
+        selected_year = st.multiselect("Select a year", years)
+        add_legend = st.checkbox("Show legend")
+
+    if selected_year:
+        for year in selected_year:
+            Map.addLayer(getNLCD(year), {}, "NLCD " + year)
+
+        if add_legend:
+            Map.add_legend(
+                legend_title="NLCD Land Cover Classification", builtin_legend="NLCD"
+            )
+        with row1_col1:
+            Map.to_streamlit(width=width, height=height)
+
+    else:
+        with row1_col1:
+            Map.to_streamlit(width=width, height=height)
+
+
+def search_data():
+
+    st.header("Search Earth Engine Data Catalog")
+
+    Map = geemap.Map()
+
+    if "ee_assets" not in st.session_state:
+        st.session_state["ee_assets"] = None
+    if "asset_titles" not in st.session_state:
+        st.session_state["asset_titles"] = None
+
+    col1, col2 = st.columns([2, 1])
+
+    dataset = None
+    with col2:
+        keyword = st.text_input("Enter a keyword to search (e.g., elevation)", "")
+        if keyword:
+            ee_assets = geemap.search_ee_data(keyword)
+            asset_titles = [x["title"] for x in ee_assets]
+            dataset = st.selectbox("Select a dataset", asset_titles)
+            if len(ee_assets) > 0:
+                st.session_state["ee_assets"] = ee_assets
+                st.session_state["asset_titles"] = asset_titles
+
+            if dataset is not None:
+                with st.expander("Show dataset details", True):
+                    index = asset_titles.index(dataset)
+                    html = geemap.ee_data_html(st.session_state["ee_assets"][index])
+                    st.markdown(html, True)
+
+                ee_id = ee_assets[index]["ee_id_snippet"]
+                uid = ee_assets[index]["uid"]
+                st.markdown(f"""**Earth Engine Snippet:** `{ee_id}`""")
+
+                vis_params = st.text_input(
+                    "Enter visualization parameters as a dictionary", {}
+                )
+                layer_name = st.text_input("Enter a layer name", uid)
+                button = st.button("Add dataset to map")
+                if button:
+                    vis = {}
+                    try:
+                        if vis_params.strip() == "":
+                            # st.error("Please enter visualization parameters")
+                            vis_params = "{}"
+                        vis = eval(vis_params)
+                        if not isinstance(vis, dict):
+                            st.error("Visualization parameters must be a dictionary")
+                        try:
+                            Map.addLayer(eval(ee_id), vis, layer_name)
+                        except Exception as e:
+                            st.error(f"Error adding layer: {e}")
+                    except Exception as e:
+                        st.error(f"Invalid visualization parameters: {e}")
+
+            with col1:
+                Map.to_streamlit()
+        else:
+            with col1:
+                Map.to_streamlit()
+
+
+def app():
+    st.title("Google Earth Engine Applications")
+
+    apps = ["National Land Cover Database (NLCD)", "Search Earth Engine Data Catalog"]
+
+    selected_app = st.selectbox("Select an app", apps)
+
+    if selected_app == "National Land Cover Database (NLCD)":
+        nlcd()
+    elif selected_app == "Search Earth Engine Data Catalog":
+        search_data()

apps/gee_datasets.py

@@ -0,0 +1,186 @@
+import ee
+import streamlit as st
+import geemap.foliumap as geemap
+
+WIDTH = 1060
+HEIGHT = 600
+
+
+def function():
+    st.write("Not implemented yet.")
+    Map = geemap.Map()
+    Map.to_streamlit(WIDTH, HEIGHT)
+
+
+def lulc_mrb_floodplain():
+
+    Map = geemap.Map()
+
+    State_boundaries = ee.FeatureCollection('users/giswqs/MRB/State_Boundaries')
+    State_style = State_boundaries.style(
+        **{'color': '808080', 'width': 1, 'fillColor': '00000000'}
+    )
+
+    MRB_boundary = ee.FeatureCollection('users/giswqs/MRB/MRB_Boundary')
+    MRB_style = MRB_boundary.style(
+        **{'color': '000000', 'width': 2, 'fillColor': '00000000'}
+    )
+
+    floodplain = ee.Image('users/giswqs/MRB/USGS_Floodplain')
+
+    class_values = [34, 38, 46, 50, 62]
+    class_palette = ['c500ff', '00ffc5', '00a9e6', '73004d', '004d73']
+
+    img_1950 = ee.Image('users/giswqs/MRB/Major_Transitions_1941_1950')
+    img_1950 = img_1950.set('b1_class_values', class_values)
+    img_1950 = img_1950.set('b1_class_palette', class_palette)
+
+    img_1960 = ee.Image('users/giswqs/MRB/Major_Transitions_1941_1960')
+    img_1960 = img_1960.set('b1_class_values', class_values)
+    img_1960 = img_1960.set('b1_class_palette', class_palette)
+
+    img_1970 = ee.Image('users/giswqs/MRB/Major_Transitions_1941_1970')
+    img_1970 = img_1970.set('b1_class_values', class_values)
+    img_1970 = img_1970.set('b1_class_palette', class_palette)
+
+    img_1980 = ee.Image('users/giswqs/MRB/Major_Transitions_1941_1980')
+    img_1980 = img_1980.set('b1_class_values', class_values)
+    img_1980 = img_1980.set('b1_class_palette', class_palette)
+
+    img_1990 = ee.Image('users/giswqs/MRB/Major_Transitions_1941_1990')
+    img_1990 = img_1990.set('b1_class_values', class_values)
+    img_1990 = img_1990.set('b1_class_palette', class_palette)
+
+    img_2000 = ee.Image('users/giswqs/MRB/Major_Transitions_1941_2000')
+    img_2000 = img_2000.set('b1_class_values', class_values)
+    img_2000 = img_2000.set('b1_class_palette', class_palette)
+
+    Map.addLayer(floodplain, {'palette': ['cccccc']}, 'Floodplain', True, 0.5)
+    Map.addLayer(img_2000, {}, 'Major Transitions 1941-2000')
+    Map.addLayer(img_1990, {}, 'Major Transitions 1941-1990')
+    Map.addLayer(img_1980, {}, 'Major Transitions 1941-1980')
+    Map.addLayer(img_1970, {}, 'Major Transitions 1941-1970')
+    Map.addLayer(img_1960, {}, 'Major Transitions 1941-1960')
+    Map.addLayer(img_1950, {}, 'Major Transitions 1941-1950')
+
+    Map.addLayer(State_style, {}, 'State Boundaries')
+    Map.addLayer(MRB_style, {}, 'MRB Boundary')
+
+    Map.to_streamlit(WIDTH, HEIGHT)
+
+
+def global_mangrove_watch():
+    """https://samapriya.github.io/awesome-gee-community-datasets/projects/mangrove/"""
+    Map = geemap.Map()
+    gmw2007 = ee.FeatureCollection("projects/sat-io/open-datasets/GMW/GMW_2007_v2")
+    gmw2008 = ee.FeatureCollection("projects/sat-io/open-datasets/GMW/GMW_2008_v2")
+    gmw2009 = ee.FeatureCollection("projects/sat-io/open-datasets/GMW/GMW_2009_v2")
+    gmw2010 = ee.FeatureCollection("projects/sat-io/open-datasets/GMW/GMW_2010_v2")
+    gmw2015 = ee.FeatureCollection("projects/sat-io/open-datasets/GMW/GMW_2015_v2")
+    gmw2016 = ee.FeatureCollection("projects/sat-io/open-datasets/GMW/GMW_2016_v2")
+    gmw1996 = ee.FeatureCollection("projects/sat-io/open-datasets/GMW/GMW_1996_v2")
+
+    Map.addLayer(
+        ee.Image().paint(gmw1996, 0, 3),
+        {"palette": ["228B22"]},
+        'Global Mangrove Watch 1996',
+    )
+    Map.addLayer(
+        ee.Image().paint(gmw2007, 0, 3),
+        {"palette": ["228B22"]},
+        'Global Mangrove Watch 2007',
+    )
+    Map.addLayer(
+        ee.Image().paint(gmw2008, 0, 3),
+        {"palette": ["228B22"]},
+        'Global Mangrove Watch 2008',
+    )
+    Map.addLayer(
+        ee.Image().paint(gmw2009, 0, 3),
+        {"palette": ["228B22"]},
+        'Global Mangrove Watch 2009',
+    )
+    Map.addLayer(
+        ee.Image().paint(gmw2010, 0, 3),
+        {"palette": ["228B22"]},
+        'Global Mangrove Watch 2010',
+    )
+    Map.addLayer(
+        ee.Image().paint(gmw2015, 0, 3),
+        {"palette": ["228B22"]},
+        'Global Mangrove Watch 2015',
+    )
+    Map.addLayer(
+        ee.Image().paint(gmw2016, 0, 3),
+        {"palette": ["228B22"]},
+        'Global Mangrove Watch 2015',
+    )
+
+    Map.to_streamlit(WIDTH, HEIGHT)
+
+
+def app():
+
+    st.title("Awesome GEE Community Datasets")
+
+    st.markdown(
+        """
+    
+    This app is for exploring the [Awesome GEE Community Datasets](https://samapriya.github.io/awesome-gee-community-datasets). Work in progress.
+    
+    """
+    )
+
+    datasets = {
+        "Population & Socioeconomic": {
+            "High Resolution Settlement Layer": "function()",
+            "World Settlement Footprint (2015)": "function()",
+            "Gridded Population of the World": "function()",
+            "geoBoundaries Global Database": "function()",
+            "West Africa Coastal Vulnerability Mapping": "function()",
+            "Relative Wealth Index (RWI)": "function()",
+            "Social Connectedness Index (SCI)": "function()",
+            "Native Land (Indigenous Land Maps)": "function()",
+        },
+        "Geophysical, Biological & Biogeochemical": {
+            "Geomorpho90m Geomorphometric Layers": "function()",
+        },
+        "Land Use and Land Cover": {
+            "Global Mangrove Watch": "global_mangrove_watch()",
+            "Mississippi River Basin Floodplain Land Use Change (1941-2000)": "lulc_mrb_floodplain()",
+        },
+        "Hydrology": {
+            "Global Shoreline Dataset": "function()",
+        },
+        "Agriculture, Vegetation and Forestry": {
+            "Landfire Mosaics LF v2.0.0": "function()",
+        },
+        "Global Utilities, Assets and Amenities Layers": {
+            "Global Power": "function()",
+        },
+        "EarthEnv Biodiversity ecosystems & climate Layers": {
+            "Global Consensus Landcover": "function()",
+        },
+        "Weather and Climate Layers": {
+            "Global Reference Evapotranspiration Layers": "function()",
+        },
+        "Global Events Layers": {
+            "Global Fire Atlas (2003-2016)": "function()",
+        },
+    }
+
+    row1_col1, row1_col2, _ = st.columns([1.2, 1.8, 1])
+
+    with row1_col1:
+        category = st.selectbox("Select a category", datasets.keys(), index=2)
+    with row1_col2:
+        dataset = st.selectbox("Select a dataset", datasets[category].keys())
+
+    Map = geemap.Map()
+
+    if dataset:
+        eval(datasets[category][dataset])
+
+    else:
+        Map = geemap.Map()
+        Map.to_streamlit(WIDTH, HEIGHT)

apps/heatmap.py

@@ -0,0 +1,19 @@
+import streamlit as st
+import leafmap.foliumap as leafmap
+
+
+def app():
+
+    st.title('Heatmaps')
+
+    filepath = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/us_cities.csv"
+    m = leafmap.Map(tiles="stamentoner")
+    m.add_heatmap(
+        filepath,
+        latitude="latitude",
+        longitude="longitude",
+        value="pop_max",
+        name="Heat map",
+        radius=20,
+    )
+    m.to_streamlit(width=700, height=500)

apps/home.py

@@ -0,0 +1,34 @@
+import streamlit as st
+import leafmap.foliumap as leafmap
+
+
+def app():
+    st.title("Streamlit for Geospatial Applications")
+
+    st.markdown(
+        """
+        This multi-page web app demonstrates various interactive web apps created using [streamlit](https://streamlit.io) and open-source mapping libraries, 
+        such as [leafmap](https://leafmap.org), [geemap](https://geemap.org), [pydeck](https://deckgl.readthedocs.io), and [kepler.gl](https://docs.kepler.gl/docs/keplergl-jupyter).
+        This is an open-source project and you are very welcome to contribute your comments, questions, resources, and apps as [issues](https://github.com/giswqs/streamlit-geospatial/issues) or 
+        [pull requests](https://github.com/giswqs/streamlit-geospatial/pulls) to the [GitHub repository](https://github.com/giswqs/streamlit-geospatial).
+
+        """
+    )
+
+    st.info("Click on the left sidebar menu to navigate to the different apps.")
+
+    st.subheader("Timelapse of Satellite Imagery")
+    st.markdown(
+        """
+        The following timelapse animations were created using the Timelapse web app. Click `Create Timelapse` on the left sidebar menu to create your own timelapse for any location around the globe.
+    """
+    )
+
+    row1_col1, row1_col2 = st.columns(2)
+    with row1_col1:
+        st.image("https://github.com/giswqs/data/raw/main/timelapse/spain.gif")
+        st.image("https://github.com/giswqs/data/raw/main/timelapse/las_vegas.gif")
+
+    with row1_col2:
+        st.image("https://github.com/giswqs/data/raw/main/timelapse/goes.gif")
+        st.image("https://github.com/giswqs/data/raw/main/timelapse/fire.gif")

apps/housing.py

@@ -0,0 +1,457 @@
+import datetime
+import os
+import pathlib
+import requests
+import zipfile
+import pandas as pd
+import pydeck as pdk
+import geopandas as gpd
+import streamlit as st
+import leafmap.colormaps as cm
+from leafmap.common import hex_to_rgb
+
+
+STREAMLIT_STATIC_PATH = pathlib.Path(st.__path__[0]) / "static"
+# We create a downloads directory within the streamlit static asset directory
+# and we write output files to it
+DOWNLOADS_PATH = STREAMLIT_STATIC_PATH / "downloads"
+if not DOWNLOADS_PATH.is_dir():
+    DOWNLOADS_PATH.mkdir()
+
+# Data source: https://www.realtor.com/research/data/
+# link_prefix = "https://econdata.s3-us-west-2.amazonaws.com/Reports/"
+link_prefix = "https://raw.githubusercontent.com/giswqs/data/main/housing/"
+
+data_links = {
+    "weekly": {
+        "national": link_prefix + "Core/listing_weekly_core_aggregate_by_country.csv",
+        "metro": link_prefix + "Core/listing_weekly_core_aggregate_by_metro.csv",
+    },
+    "monthly_current": {
+        "national": link_prefix + "Core/RDC_Inventory_Core_Metrics_Country.csv",
+        "state": link_prefix + "Core/RDC_Inventory_Core_Metrics_State.csv",
+        "metro": link_prefix + "Core/RDC_Inventory_Core_Metrics_Metro.csv",
+        "county": link_prefix + "Core/RDC_Inventory_Core_Metrics_County.csv",
+        "zip": link_prefix + "Core/RDC_Inventory_Core_Metrics_Zip.csv",
+    },
+    "monthly_historical": {
+        "national": link_prefix + "Core/RDC_Inventory_Core_Metrics_Country_History.csv",
+        "state": link_prefix + "Core/RDC_Inventory_Core_Metrics_State_History.csv",
+        "metro": link_prefix + "Core/RDC_Inventory_Core_Metrics_Metro_History.csv",
+        "county": link_prefix + "Core/RDC_Inventory_Core_Metrics_County_History.csv",
+        "zip": link_prefix + "Core/RDC_Inventory_Core_Metrics_Zip_History.csv",
+    },
+    "hotness": {
+        "metro": link_prefix
+        + "Hotness/RDC_Inventory_Hotness_Metrics_Metro_History.csv",
+        "county": link_prefix
+        + "Hotness/RDC_Inventory_Hotness_Metrics_County_History.csv",
+        "zip": link_prefix + "Hotness/RDC_Inventory_Hotness_Metrics_Zip_History.csv",
+    },
+}
+
+
+def get_data_columns(df, category, frequency="monthly"):
+    if frequency == "monthly":
+        if category.lower() == "county":
+            del_cols = ["month_date_yyyymm", "county_fips", "county_name"]
+        elif category.lower() == "state":
+            del_cols = ["month_date_yyyymm", "state", "state_id"]
+        elif category.lower() == "national":
+            del_cols = ["month_date_yyyymm", "country"]
+        elif category.lower() == "metro":
+            del_cols = ["month_date_yyyymm", "cbsa_code", "cbsa_title", "HouseholdRank"]
+        elif category.lower() == "zip":
+            del_cols = ["month_date_yyyymm", "postal_code", "zip_name", "flag"]
+    elif frequency == "weekly":
+        if category.lower() == "national":
+            del_cols = ["week_end_date", "geo_country"]
+        elif category.lower() == "metro":
+            del_cols = ["week_end_date", "cbsa_code", "cbsa_title", "hh_rank"]
+
+    cols = df.columns.values.tolist()
+
+    for col in cols:
+        if col.strip() in del_cols:
+            cols.remove(col)
+    if category.lower() == "metro":
+        return cols[2:]
+    else:
+        return cols[1:]
+
+
+@st.cache
+def get_inventory_data(url):
+    df = pd.read_csv(url)
+    url = url.lower()
+    if "county" in url:
+        df["county_fips"] = df["county_fips"].map(str)
+        df["county_fips"] = df["county_fips"].str.zfill(5)
+    elif "state" in url:
+        df["STUSPS"] = df["state_id"].str.upper()
+    elif "metro" in url:
+        df["cbsa_code"] = df["cbsa_code"].map(str)
+    elif "zip" in url:
+        df["postal_code"] = df["postal_code"].map(str)
+        df["postal_code"] = df["postal_code"].str.zfill(5)
+
+    if "listing_weekly_core_aggregate_by_country" in url:
+        columns = get_data_columns(df, "national", "weekly")
+        for column in columns:
+            if column != "median_days_on_market_by_day_yy":
+                df[column] = df[column].str.rstrip("%").astype(float) / 100
+    if "listing_weekly_core_aggregate_by_metro" in url:
+        columns = get_data_columns(df, "metro", "weekly")
+        for column in columns:
+            if column != "median_days_on_market_by_day_yy":
+                df[column] = df[column].str.rstrip("%").astype(float) / 100
+        df["cbsa_code"] = df["cbsa_code"].str[:5]
+    return df
+
+
+def filter_weekly_inventory(df, week):
+    df = df[df["week_end_date"] == week]
+    return df
+
+
+def get_start_end_year(df):
+    start_year = int(str(df["month_date_yyyymm"].min())[:4])
+    end_year = int(str(df["month_date_yyyymm"].max())[:4])
+    return start_year, end_year
+
+
+def get_periods(df):
+    return [str(d) for d in list(set(df["month_date_yyyymm"].tolist()))]
+
+
+@st.cache
+def get_geom_data(category):
+
+    prefix = (
+        "https://raw.githubusercontent.com/giswqs/streamlit-geospatial/master/data/"
+    )
+    links = {
+        "national": prefix + "us_nation.geojson",
+        "state": prefix + "us_states.geojson",
+        "county": prefix + "us_counties.geojson",
+        "metro": prefix + "us_metro_areas.geojson",
+        "zip": "https://www2.census.gov/geo/tiger/GENZ2018/shp/cb_2018_us_zcta510_500k.zip",
+    }
+
+    if category.lower() == "zip":
+        r = requests.get(links[category])
+        out_zip = os.path.join(DOWNLOADS_PATH, "cb_2018_us_zcta510_500k.zip")
+        with open(out_zip, "wb") as code:
+            code.write(r.content)
+        zip_ref = zipfile.ZipFile(out_zip, "r")
+        zip_ref.extractall(DOWNLOADS_PATH)
+        gdf = gpd.read_file(out_zip.replace("zip", "shp"))
+    else:
+        gdf = gpd.read_file(links[category])
+    return gdf
+
+
+def join_attributes(gdf, df, category):
+
+    new_gdf = None
+    if category == "county":
+        new_gdf = gdf.merge(df, left_on="GEOID", right_on="county_fips", how="outer")
+    elif category == "state":
+        new_gdf = gdf.merge(df, left_on="STUSPS", right_on="STUSPS", how="outer")
+    elif category == "national":
+        if "geo_country" in df.columns.values.tolist():
+            df["country"] = None
+            df.loc[0, "country"] = "United States"
+        new_gdf = gdf.merge(df, left_on="NAME", right_on="country", how="outer")
+    elif category == "metro":
+        new_gdf = gdf.merge(df, left_on="CBSAFP", right_on="cbsa_code", how="outer")
+    elif category == "zip":
+        new_gdf = gdf.merge(df, left_on="GEOID10", right_on="postal_code", how="outer")
+    return new_gdf
+
+
+def select_non_null(gdf, col_name):
+    new_gdf = gdf[~gdf[col_name].isna()]
+    return new_gdf
+
+
+def select_null(gdf, col_name):
+    new_gdf = gdf[gdf[col_name].isna()]
+    return new_gdf
+
+
+def get_data_dict(name):
+    in_csv = os.path.join(os.getcwd(), "data/realtor_data_dict.csv")
+    df = pd.read_csv(in_csv)
+    label = list(df[df["Name"] == name]["Label"])[0]
+    desc = list(df[df["Name"] == name]["Description"])[0]
+    return label, desc
+
+
+def get_weeks(df):
+    seq = list(set(df[~df["week_end_date"].isnull()]["week_end_date"].tolist()))
+    weeks = [
+        datetime.date(int(d.split("/")[2]), int(d.split("/")[0]), int(d.split("/")[1]))
+        for d in seq
+    ]
+    weeks.sort()
+    return weeks
+
+
+def get_saturday(in_date):
+    idx = (in_date.weekday() + 1) % 7
+    sat = in_date + datetime.timedelta(6 - idx)
+    return sat
+
+
+def app():
+
+    st.title("U.S. Real Estate Data and Market Trends")
+    st.markdown(
+        """**Introduction:** This interactive dashboard is designed for visualizing U.S. real estate data and market trends at multiple levels (i.e., national,
+         state, county, and metro). The data sources include [Real Estate Data](https://www.realtor.com/research/data) from realtor.com and 
+         [Cartographic Boundary Files](https://www.census.gov/geographies/mapping-files/time-series/geo/carto-boundary-file.html) from U.S. Census Bureau.
+         Several open-source packages are used to process the data and generate the visualizations, e.g., [streamlit](https://streamlit.io),
+          [geopandas](https://geopandas.org), [leafmap](https://leafmap.org), and [pydeck](https://deckgl.readthedocs.io).
+    """
+    )
+
+    with st.expander("See a demo"):
+        st.image("https://i.imgur.com/Z3dk6Tr.gif")
+
+    row1_col1, row1_col2, row1_col3, row1_col4, row1_col5 = st.columns(
+        [0.6, 0.8, 0.6, 1.4, 2]
+    )
+    with row1_col1:
+        frequency = st.selectbox("Monthly/weekly data", ["Monthly", "Weekly"])
+    with row1_col2:
+        types = ["Current month data", "Historical data"]
+        if frequency == "Weekly":
+            types.remove("Current month data")
+        cur_hist = st.selectbox(
+            "Current/historical data",
+            types,
+        )
+    with row1_col3:
+        if frequency == "Monthly":
+            scale = st.selectbox(
+                "Scale", ["National", "State", "Metro", "County"], index=3
+            )
+        else:
+            scale = st.selectbox("Scale", ["National", "Metro"], index=1)
+
+    gdf = get_geom_data(scale.lower())
+
+    if frequency == "Weekly":
+        inventory_df = get_inventory_data(data_links["weekly"][scale.lower()])
+        weeks = get_weeks(inventory_df)
+        with row1_col1:
+            selected_date = st.date_input("Select a date", value=weeks[-1])
+            saturday = get_saturday(selected_date)
+            selected_period = saturday.strftime("%-m/%-d/%Y")
+            if saturday not in weeks:
+                st.error(
+                    "The selected date is not available in the data. Please select a date between {} and {}".format(
+                        weeks[0], weeks[-1]
+                    )
+                )
+                selected_period = weeks[-1].strftime("%-m/%-d/%Y")
+        inventory_df = get_inventory_data(data_links["weekly"][scale.lower()])
+        inventory_df = filter_weekly_inventory(inventory_df, selected_period)
+
+    if frequency == "Monthly":
+        if cur_hist == "Current month data":
+            inventory_df = get_inventory_data(
+                data_links["monthly_current"][scale.lower()]
+            )