11 leafmap

Using Leafmap for Geospatial Analysis and Data Visualization

This notebook was developed for GEOG-312 - First Steps in GIS Programming.

Launch this notebook to execute code interactively using:

Google Colab: https://gishub.org/leafmap-312-colab
Pangeo Binder JupyterLab: https://gishub.org/leafmap-312-binder
Pangeo Binder Jupyter Notebook: https://gishub.org/leafmap-312-binder-nb
Streamlit app: https://streamlit.gishub.org

Introduction¶

Description¶

Leafmap is a Python package for interactive mapping and geospatial analysis with minimal coding in a Jupyter environment. It is built upon a number of open-source packages, such as folium and ipyleaflet (for creating interactive maps), WhiteboxTools and whiteboxgui (for analyzing geospatial data), and ipywidgets (for designing interactive graphical user interface). The WhiteboxTools library currently contains 480+ tools for advanced geospatial analysis. Leafmap provides many convenient functions for loading and visualizing geospatial data with only one line of code. Users can also use the interactive user interface to load geospatial data without coding. Anyone with a web browser and Internet connection can use leafmap to perform geospatial analysis and data visualization in the cloud with minimal coding. The topics that will be covered in this notebook include:

Creating interactive maps
Changing basemaps
Loading and visualizing vector/raster data
Using Cloud Optimized GeoTIFF (COG) and SpatialTemporal Asset Catalog (STAC)
Downloading OpenStreetMap data
Loading data from a PostGIS database
Creating custom legends and colorbars
Creating split-panel maps and linked maps
Visualizing Planet global monthly/quarterly mosaic
Designing and publishing interactive web apps
Performing geospatial analysis (e.g., hydrological analysis and LiDAR data analysis) using whiteboxgui.

Jupyter keyboard shortcuts¶

Shift+Enter: run cell, select below
Ctrl+Enter: : run selected cells
Alt+Enter: run cell and insert below
Tab: code completion or indent
Shift+Tab: tooltip
Ctrl+/: comment out code

Set up environment¶

Required Python packages:¶

leafmap - A Python package for interactive mapping and geospatial analysis with minimal coding in a Jupyter environment
geopandas - An open source project to make working with geospatial data in python easier.
keplergl - A high-performance web-based application for visual exploration of large-scale geolocation data sets
datapane - A Python library for building interactive reports in seconds
xarray-leaflet - An xarray extension for tiled map plotting

Required API keys¶

HERE Map API key
datapane API key
Planet API key

Use Google Colab¶

Click the button below to open this notebook in Google Colab and execute code interactively.

In [ ]:

import os
import subprocess
import sys
import os
import subprocess
import sys

In [ ]:

import warnings
warnings.filterwarnings("ignore")
import warnings
warnings.filterwarnings("ignore")

A function for installing Python packages.

In [ ]:

def install(package):
    subprocess.check_call([sys.executable, "-m", "pip", "install", package])
def install(package):
    subprocess.check_call([sys.executable, "-m", "pip", "install", package])

Install required Python packages in Google Colab.

In [ ]:

pkgs = ['leafmap', 'geopandas', 'keplergl', 'datapane', 'xarray_leaflet', 'osmnx', 'pygeos', 'imageio', 'tifffile']
if "google.colab" in sys.modules:
    for pkg in pkgs:
        install(pkg)
pkgs = ['leafmap', 'geopandas', 'keplergl', 'datapane', 'xarray_leaflet', 'osmnx', 'pygeos', 'imageio', 'tifffile']
if "google.colab" in sys.modules:
    for pkg in pkgs:
        install(pkg)

Use Pangeo Binder¶

Click the buttons below to open this notebook in JupyterLab (first button) or Jupyter Notebook (second button) and execute code interactively.

JupyterLab: https://gishub.org/leafmap-312-binder
Jupyter Notebook: https://gishub.org/leafmap-312-binder-nb

Use Miniconda/Anaconda¶

If you have Anaconda or Miniconda installed on your computer, you can install leafmap using the following commands. Leafmap has an optional dependency - geopandas, which can be challenging to install on some computers, especially Windows. It is highly recommended that you create a fresh conda environment to install geopandas and leafmap. Follow the commands below to set up a conda env and isntall geopandas, leafmap, datapane, keplergl, and xarray_leaflet.

conda create -n geo python=3.8
conda activate geo
conda install geopandas
conda install mamba -c conda-forge
mamba install leafmap datapane keplergl xarray_leaflet -c conda-forge
mamba install osmnx pygeos imageio tifffile -c conda-forge
pip install -U folium
jupyter lab

In [ ]:

try:
    import leafmap
except ImportError:
    install('leafmap')
try:
    import leafmap
except ImportError:
    install('leafmap')

Create an interactive map¶

leafmap has four plotting backends: folium, ipyleaflet, here-map, and kepler.gl. Note that the backends do not offer equal functionality. Some interactive functionality in ipyleaflet might not be available in other plotting backends. To use a specific plotting backend, use one of the following:

import leafmap.leafmap as leafmap
import leafmap.foliumap as leafmap
import leafmap.heremap as leafmap
import leafmap.kepler as leafmap

Use ipyleaflet¶

In [ ]:

import leafmap

m = leafmap.Map()
m
import leafmap

m = leafmap.Map()
m

Use folium¶

In [ ]:

import leafmap.foliumap as leafmap

m = leafmap.Map()
m
import leafmap.foliumap as leafmap

m = leafmap.Map()
m

Use kepler.gl¶

In [ ]:

import leafmap.kepler as leafmap

m = leafmap.Map()
m
import leafmap.kepler as leafmap

m = leafmap.Map()
m

If you encounter an error saying Error displaying widget: model not found when trying to display the map, you can use m.static_map() as a workaround until this kepler.gl bug has been resolved.

In [ ]:

m.static_map(width=1280, height=600)
m.static_map(width=1280, height=600)

Use here-map¶

Before you run the below cells make sure you have:

A HERE developer account, free and available under HERE Developer Portal
An API key from the HERE Developer Portal

In [ ]:

import os
import leafmap.heremap as leafmap
import os
import leafmap.heremap as leafmap

In [ ]:

if os.environ.get("HEREMAPS_API_KEY") is None:
    os.environ["HEREMAPS_API_KEY"] = 'your-api-key'

m = leafmap.Map()
m
if os.environ.get("HEREMAPS_API_KEY") is None:
    os.environ["HEREMAPS_API_KEY"] = 'your-api-key'

m = leafmap.Map()
m

Customize the default map¶

Specify map center and zoom level¶

In [ ]:

import leafmap
import leafmap

In [ ]:

m = leafmap.Map(center=(40, -100), zoom=4) #center=[lat, lon]
m
m = leafmap.Map(center=(40, -100), zoom=4) #center=[lat, lon]
m

In [ ]:

m = leafmap.Map(center=(51.5, -0.15), zoom=17)
m
m = leafmap.Map(center=(51.5, -0.15), zoom=17)
m

Change map size¶

In [ ]:

m = leafmap.Map(height="400px", width="800px")
m
m = leafmap.Map(height="400px", width="800px")
m

Set control visibility¶

When creating a map, set the following controls to either True or False as appropriate.

attribution_control
draw_control
fullscreen_control
layers_control
measure_control
scale_control
toolbar_control

In [ ]:

m = leafmap.Map(draw_control=False, measure_control=False, fullscreen_control=False, attribution_control=False)
m
m = leafmap.Map(draw_control=False, measure_control=False, fullscreen_control=False, attribution_control=False)
m

Remove all controls from the map.

In [ ]:

m = leafmap.Map()
m.clear_controls()
m
m = leafmap.Map()
m.clear_controls()
m

Change basemaps¶

Specify a Google basemap to use, can be one of ["ROADMAP", "TERRAIN", "SATELLITE", "HYBRID"].

In [ ]:

import leafmap
import leafmap

In [ ]:

m = leafmap.Map(google_map="TERRAIN")  # HYBIRD, ROADMAP, SATELLITE, TERRAIN
m
m = leafmap.Map(google_map="TERRAIN")  # HYBIRD, ROADMAP, SATELLITE, TERRAIN
m

Add a basemap using the add_basemap() function.

In [ ]:

m = leafmap.Map()
m.add_basemap("Esri.NatGeoWorldMap")
m
m = leafmap.Map()
m.add_basemap("Esri.NatGeoWorldMap")
m

Print out the list of available basemaps.

In [ ]:

for basemap in leafmap.leafmap_basemaps:
    print(basemap)
for basemap in leafmap.leafmap_basemaps:
    print(basemap)

Add tile layers¶

Add XYZ tile layer¶

In [ ]:

import leafmap
import leafmap

In [ ]:

m = leafmap.Map()
m.add_tile_layer(url="https://mt1.google.com/vt/lyrs=y&x={x}&y={y}&z={z}", name="Google Satellite", attribution="Google")
m
m = leafmap.Map()
m.add_tile_layer(url="https://mt1.google.com/vt/lyrs=y&x={x}&y={y}&z={z}", name="Google Satellite", attribution="Google")
m

Add WMS tile layer¶

More WMS basemaps can be found at the following websites:

USGS National Map: https://viewer.nationalmap.gov/services
MRLC NLCD Land Cover data: https://www.mrlc.gov/data-services-page
FWS NWI Wetlands data: https://www.fws.gov/wetlands/Data/Web-Map-Services.html

In [ ]:

m = leafmap.Map()
naip_url = 'https://services.nationalmap.gov/arcgis/services/USGSNAIPImagery/ImageServer/WMSServer?'
m.add_wms_layer(url=naip_url, layers='0', name='NAIP Imagery', format='image/png', shown=True)
m
m = leafmap.Map()
naip_url = 'https://services.nationalmap.gov/arcgis/services/USGSNAIPImagery/ImageServer/WMSServer?'
m.add_wms_layer(url=naip_url, layers='0', name='NAIP Imagery', format='image/png', shown=True)
m

Add xyzservices provider¶

Add a layer from xyzservices provider object.

In [ ]:

import os
import xyzservices.providers as xyz
import os
import xyzservices.providers as xyz

In [ ]:

basemap = xyz.HEREv3.basicMap
basemap
basemap = xyz.HEREv3.basicMap
basemap

In [ ]:

basemap['apiKey'] = os.environ["HEREMAPS_API_KEY"]
basemap['apiKey'] = os.environ["HEREMAPS_API_KEY"]

In [ ]:

m = leafmap.Map()
m.add_basemap(basemap)
m
m = leafmap.Map()
m.add_basemap(basemap)
m

Add vector tile layer¶

In [ ]:

import leafmap
import leafmap

In [ ]:

m = leafmap.Map()
m = leafmap.Map()

The URL to the vector tile.

In [ ]:

url='https://tile.nextzen.org/tilezen/vector/v1/512/all/{z}/{x}/{y}.mvt?api_key=gCZXZglvRQa6sB2z7JzL1w'
url='https://tile.nextzen.org/tilezen/vector/v1/512/all/{z}/{x}/{y}.mvt?api_key=gCZXZglvRQa6sB2z7JzL1w'

Attribution of the vector tile.

In [ ]:

attribution = "Nextzen"
attribution = "Nextzen"

One can customize the vector tile layer style if needed. More info can be found at https://ipyleaflet.readthedocs.io/en/latest/api_reference/vector_tile.html

In [ ]:

vector_tile_layer_styles={}
vector_tile_layer_styles={}

Add the vector tile layer to the map.

In [ ]:

m.add_vector_tile_layer(url, attribution, vector_tile_layer_styles)
m
m.add_vector_tile_layer(url, attribution, vector_tile_layer_styles)
m

Add COG/STAC layers¶

A Cloud Optimized GeoTIFF (COG) is a regular GeoTIFF file, aimed at being hosted on a HTTP file server, with an internal organization that enables more efficient workflows on the cloud. It does this by leveraging the ability of clients issuing HTTP GET range requests to ask for just the parts of a file they need.

More information about COG can be found at https://www.cogeo.org/in-depth.html

Some publicly available Cloud Optimized GeoTIFFs:

For this demo, we will use data from https://www.maxar.com/open-data/california-colorado-fires for mapping California and Colorado fires. A list of COGs can be found here.

Add COG layer¶

In [ ]:

import leafmap
import leafmap

In [ ]:

m = leafmap.Map()
url = 'https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2018-02-16/pine-gulch-fire20/1030010076004E00.tif'
url2 = 'https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-14/pine-gulch-fire20/10300100AAC8DD00.tif'

m.add_cog_layer(url, name="Fire (pre-event)")
m.add_cog_layer(url2, name="Fire (post-event)")
m
m = leafmap.Map()
url = 'https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2018-02-16/pine-gulch-fire20/1030010076004E00.tif'
url2 = 'https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-14/pine-gulch-fire20/10300100AAC8DD00.tif'

m.add_cog_layer(url, name="Fire (pre-event)")
m.add_cog_layer(url2, name="Fire (post-event)")
m

Retrieve the bounding box coordinates of the COG file.

In [ ]:

leafmap.cog_bounds(url)
leafmap.cog_bounds(url)

Retrieve the centroid coordinates of the COG file.

In [ ]:

leafmap.cog_center(url)
leafmap.cog_center(url)

Retrieves the tile layer URL of the COG file.

In [ ]:

leafmap.cog_tile(url)
leafmap.cog_tile(url)

Add STAC layer¶

The SpatioTemporal Asset Catalog (STAC) specification provides a common language to describe a range of geospatial information, so it can more easily be indexed and discovered. A 'spatiotemporal asset' is any file that represents information about the earth captured in a certain space and time. The initial focus is primarily remotely-sensed imagery (from satellites, but also planes, drones, balloons, etc), but the core is designed to be extensible to SAR, full motion video, point clouds, hyperspectral, LiDAR and derived data like NDVI, Digital Elevation Models, mosaics, etc. More information about STAC can be found at https://stacspec.org/

Some publicly available SpatioTemporal Asset Catalog (STAC):

https://stacindex.org

For this demo, we will use STAC assets from https://stacindex.org/catalogs/spot-orthoimages-canada-2005#/?t=catalogs

In [ ]:

m = leafmap.Map()
url = 'https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json'
m.add_stac_layer(url, bands=['B3', 'B2', 'B1'], name='False color')
m
m = leafmap.Map()
url = 'https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json'
m.add_stac_layer(url, bands=['B3', 'B2', 'B1'], name='False color')
m

Retrieve the bounding box coordinates of the STAC file.

In [ ]:

leafmap.stac_bounds(url)
leafmap.stac_bounds(url)

Retrieve the centroid coordinates of the STAC file.

In [ ]:

leafmap.stac_center(url)
leafmap.stac_center(url)

Retrieve the band names of the STAC file.

In [ ]:

leafmap.stac_bands(url)
leafmap.stac_bands(url)

Retrieve the tile layer URL of the STAC file.

In [ ]:

leafmap.stac_tile(url, bands=['B3', 'B2', 'B1'])
leafmap.stac_tile(url, bands=['B3', 'B2', 'B1'])

Add local raster datasets¶

The add_raster function relies on the xarray_leaflet package and is only available for the ipyleaflet plotting backend. Therefore, Google Colab is not supported. Note that xarray_leaflet does not work properly on Windows (source).

In [ ]:

import os
import leafmap
import os
import leafmap

Download samples raster datasets

More datasets can be downloaded from https://viewer.nationalmap.gov/basic/

In [ ]:

out_dir = os.getcwd()

landsat = os.path.join(out_dir, 'landsat.tif')
dem = os.path.join(out_dir, 'dem.tif')
out_dir = os.getcwd()

landsat = os.path.join(out_dir, 'landsat.tif')
dem = os.path.join(out_dir, 'dem.tif')

Download a small Landsat imagery.

In [ ]:

if not os.path.exists(landsat):
    landsat_url = 'https://drive.google.com/file/d/1EV38RjNxdwEozjc9m0FcO3LFgAoAX1Uw/view?usp=sharing'
    leafmap.download_from_gdrive(landsat_url, 'landsat.tif', out_dir, unzip=False)
if not os.path.exists(landsat):
    landsat_url = 'https://drive.google.com/file/d/1EV38RjNxdwEozjc9m0FcO3LFgAoAX1Uw/view?usp=sharing'
    leafmap.download_from_gdrive(landsat_url, 'landsat.tif', out_dir, unzip=False)

Download a small DEM dataset.

In [ ]:

if not os.path.exists(dem):
    dem_url = 'https://drive.google.com/file/d/1vRkAWQYsLWCi6vcTMk8vLxoXMFbdMFn8/view?usp=sharing'
    leafmap.download_from_gdrive(dem_url, 'dem.tif', out_dir, unzip=False)
if not os.path.exists(dem):
    dem_url = 'https://drive.google.com/file/d/1vRkAWQYsLWCi6vcTMk8vLxoXMFbdMFn8/view?usp=sharing'
    leafmap.download_from_gdrive(dem_url, 'dem.tif', out_dir, unzip=False)

In [ ]:

m = leafmap.Map()
m = leafmap.Map()

Add local raster datasets to the map

More colormap can be found at https://matplotlib.org/3.1.0/tutorials/colors/colormaps.html

In [ ]:

m.add_raster(dem, colormap='terrain', layer_name='DEM')
m.add_raster(dem, colormap='terrain', layer_name='DEM')

In [ ]:

m.add_raster(landsat, bands=[5, 4, 3], layer_name='Landsat')
m.add_raster(landsat, bands=[5, 4, 3], layer_name='Landsat')

In [ ]:

m
m

Add legend¶

Add built-in legend¶

In [ ]:

import leafmap
import leafmap

List all available built-in legends.

In [ ]:

legends = leafmap.builtin_legends
for legend in legends:
    print(legend)
legends = leafmap.builtin_legends
for legend in legends:
    print(legend)

Add a WMS layer and built-in legend to the map.

In [ ]:

m = leafmap.Map()
url = "https://www.mrlc.gov/geoserver/mrlc_display/NLCD_2019_Land_Cover_L48/wms?"
m.add_wms_layer(url, layers="NLCD_2019_Land_Cover_L48", name="NLCD 2019 CONUS Land Cover",format="image/png", transparent=True)
m.add_legend(builtin_legend='NLCD')
m
m = leafmap.Map()
url = "https://www.mrlc.gov/geoserver/mrlc_display/NLCD_2019_Land_Cover_L48/wms?"
m.add_wms_layer(url, layers="NLCD_2019_Land_Cover_L48", name="NLCD 2019 CONUS Land Cover",format="image/png", transparent=True)
m.add_legend(builtin_legend='NLCD')
m

Add U.S. National Wetlands Inventory (NWI). More info at https://www.fws.gov/wetlands.

In [ ]:

m = leafmap.Map(google_map="HYBRID")

url1 = "https://www.fws.gov/wetlands/arcgis/services/Wetlands/MapServer/WMSServer?"
m.add_wms_layer(url1, layers="1",format='image/png', transparent=True, name="NWI Wetlands Vector")

url2 = "https://www.fws.gov/wetlands/arcgis/services/Wetlands_Raster/ImageServer/WMSServer?"
m.add_wms_layer(url2, layers="0",format='image/png', transparent=True, name="NWI Wetlands Raster")

m.add_legend(builtin_legend="NWI")
m
m = leafmap.Map(google_map="HYBRID")

url1 = "https://www.fws.gov/wetlands/arcgis/services/Wetlands/MapServer/WMSServer?"
m.add_wms_layer(url1, layers="1",format='image/png', transparent=True, name="NWI Wetlands Vector")

url2 = "https://www.fws.gov/wetlands/arcgis/services/Wetlands_Raster/ImageServer/WMSServer?"
m.add_wms_layer(url2, layers="0",format='image/png', transparent=True, name="NWI Wetlands Raster")

m.add_legend(builtin_legend="NWI")
m

Add custom legend¶

There are two ways you can add custom legends:

Define legend labels and colors
Define legend dictionary

Define legend keys and colors

In [ ]:

m = leafmap.Map()

labels = ['One', 'Two', 'Three', 'Four', 'ect']
 #color can be defined using either hex code or RGB (0-255, 0-255, 0-255)
colors = ['#8DD3C7', '#FFFFB3', '#BEBADA', '#FB8072', '#80B1D3']
# colors = [(255, 0, 0), (127, 255, 0), (127, 18, 25), (36, 70, 180), (96, 68, 123)]

m.add_legend(title='Legend', labels=labels, colors=colors)
m
m = leafmap.Map()

labels = ['One', 'Two', 'Three', 'Four', 'ect']
 #color can be defined using either hex code or RGB (0-255, 0-255, 0-255)
colors = ['#8DD3C7', '#FFFFB3', '#BEBADA', '#FB8072', '#80B1D3']
# colors = [(255, 0, 0), (127, 255, 0), (127, 18, 25), (36, 70, 180), (96, 68, 123)]

m.add_legend(title='Legend', labels=labels, colors=colors)
m

Define a legend dictionary.

In [ ]:

m = leafmap.Map()

url = "https://www.mrlc.gov/geoserver/mrlc_display/NLCD_2019_Land_Cover_L48/wms?"
m.add_wms_layer(url, layers="NLCD_2019_Land_Cover_L48", name="NLCD 2019 CONUS Land Cover", format="image/png", transparent=True)

legend_dict = {
    '11 Open Water': '466b9f',
    '12 Perennial Ice/Snow': 'd1def8',
    '21 Developed, Open Space': 'dec5c5',
    '22 Developed, Low Intensity': 'd99282',
    '23 Developed, Medium Intensity': 'eb0000',
    '24 Developed High Intensity': 'ab0000',
    '31 Barren Land (Rock/Sand/Clay)': 'b3ac9f',
    '41 Deciduous Forest': '68ab5f',
    '42 Evergreen Forest': '1c5f2c',
    '43 Mixed Forest': 'b5c58f',
    '51 Dwarf Scrub': 'af963c',
    '52 Shrub/Scrub': 'ccb879',
    '71 Grassland/Herbaceous': 'dfdfc2',
    '72 Sedge/Herbaceous': 'd1d182',
    '73 Lichens': 'a3cc51',
    '74 Moss': '82ba9e',
    '81 Pasture/Hay': 'dcd939',
    '82 Cultivated Crops': 'ab6c28',
    '90 Woody Wetlands': 'b8d9eb',
    '95 Emergent Herbaceous Wetlands': '6c9fb8'
}

m.add_legend(legend_title="NLCD Land Cover Classification", legend_dict=legend_dict)
m
m = leafmap.Map()

url = "https://www.mrlc.gov/geoserver/mrlc_display/NLCD_2019_Land_Cover_L48/wms?"
m.add_wms_layer(url, layers="NLCD_2019_Land_Cover_L48", name="NLCD 2019 CONUS Land Cover", format="image/png", transparent=True)

legend_dict = {
    '11 Open Water': '466b9f',
    '12 Perennial Ice/Snow': 'd1def8',
    '21 Developed, Open Space': 'dec5c5',
    '22 Developed, Low Intensity': 'd99282',
    '23 Developed, Medium Intensity': 'eb0000',
    '24 Developed High Intensity': 'ab0000',
    '31 Barren Land (Rock/Sand/Clay)': 'b3ac9f',
    '41 Deciduous Forest': '68ab5f',
    '42 Evergreen Forest': '1c5f2c',
    '43 Mixed Forest': 'b5c58f',
    '51 Dwarf Scrub': 'af963c',
    '52 Shrub/Scrub': 'ccb879',
    '71 Grassland/Herbaceous': 'dfdfc2',
    '72 Sedge/Herbaceous': 'd1d182',
    '73 Lichens': 'a3cc51',
    '74 Moss': '82ba9e',
    '81 Pasture/Hay': 'dcd939',
    '82 Cultivated Crops': 'ab6c28',
    '90 Woody Wetlands': 'b8d9eb',
    '95 Emergent Herbaceous Wetlands': '6c9fb8'
}

m.add_legend(legend_title="NLCD Land Cover Classification", legend_dict=legend_dict)
m

Add colorbar¶

Continuous color¶

Add a continuous colorbar with a custom palette to the map.

In [ ]:

import leafmap
import leafmap

In [ ]:

m = leafmap.Map()
m.add_basemap('USGS 3DEP Elevation')
colors = ['006633', 'E5FFCC', '662A00', 'D8D8D8', 'F5F5F5']
m.add_colorbar(colors=colors, vmin=0, vmax=4000)
m
m = leafmap.Map()
m.add_basemap('USGS 3DEP Elevation')
colors = ['006633', 'E5FFCC', '662A00', 'D8D8D8', 'F5F5F5']
m.add_colorbar(colors=colors, vmin=0, vmax=4000)
m

Categorical colorbar¶

In [ ]:

m = leafmap.Map()

url = "https://elevation.nationalmap.gov/arcgis/services/3DEPElevation/ImageServer/WMSServer?"
m.add_wms_layer(url, layers="3DEPElevation:Hillshade Elevation Tinted", name="USGS 3DEP Elevation", format="image/png", transparent=True)

colors = ['006633', 'E5FFCC', '662A00', 'D8D8D8', 'F5F5F5']
m.add_colorbar(colors=colors, vmin=0, vmax=4000, categorical=True, step=4)
m
m = leafmap.Map()

url = "https://elevation.nationalmap.gov/arcgis/services/3DEPElevation/ImageServer/WMSServer?"
m.add_wms_layer(url, layers="3DEPElevation:Hillshade Elevation Tinted", name="USGS 3DEP Elevation", format="image/png", transparent=True)

colors = ['006633', 'E5FFCC', '662A00', 'D8D8D8', 'F5F5F5']
m.add_colorbar(colors=colors, vmin=0, vmax=4000, categorical=True, step=4)
m

Add colormap¶

The colormap functionality requires the ipyleaflet plotting backend. Folium is not supported.

In [ ]:

import leafmap
import leafmap.colormaps as cm
import leafmap
import leafmap.colormaps as cm

Common colormaps¶

Color palette for DEM data.

In [ ]:

cm.palettes.dem
cm.palettes.dem

Show the DEM palette.

In [ ]:

cm.plot_colormap(colors=cm.palettes.dem, axis_off=True)
cm.plot_colormap(colors=cm.palettes.dem, axis_off=True)

Color palette for NDVI data.

In [ ]:

cm.palettes.ndvi
cm.palettes.ndvi

Show the NDVI palette.

In [ ]:

cm.plot_colormap(colors=cm.palettes.ndvi)
cm.plot_colormap(colors=cm.palettes.ndvi)

Custom colormaps¶

Specify the number of classes for a palette.

In [ ]:

cm.get_palette('terrain', n_class=8)
cm.get_palette('terrain', n_class=8)

Show the terrain palette with 8 classes.

In [ ]:

cm.plot_colormap(colors=cm.get_palette('terrain', n_class=8))
cm.plot_colormap(colors=cm.get_palette('terrain', n_class=8))

Create a palette with custom colors, label, and font size.

In [ ]:

cm.plot_colormap(colors=["red", "green", "blue"], label="Temperature", font_size=12)
cm.plot_colormap(colors=["red", "green", "blue"], label="Temperature", font_size=12)

Create a discrete color palette.

In [ ]:

cm.plot_colormap(colors=["red", "green", "blue"], discrete=True, label="Temperature", font_size=12)
cm.plot_colormap(colors=["red", "green", "blue"], discrete=True, label="Temperature", font_size=12)

Specify the width and height for the palette.

In [ ]:

cm.plot_colormap('terrain', label="Elevation", width=8.0, height=0.4, orientation='horizontal',vmin=0, vmax=1000)
cm.plot_colormap('terrain', label="Elevation", width=8.0, height=0.4, orientation='horizontal',vmin=0, vmax=1000)

Change the orentation of the colormap to be vertical.

In [ ]:

cm.plot_colormap('terrain', label="Elevation", width=0.4, height=4, orientation='vertical',vmin=0, vmax=1000)
cm.plot_colormap('terrain', label="Elevation", width=0.4, height=4, orientation='vertical',vmin=0, vmax=1000)

Horizontal colormap¶

Add a horizontal colorbar to an interactive map.

In [ ]:

m = leafmap.Map()
m.add_basemap("OpenTopoMap")
m.add_colormap('terrain', label="Elevation", width=8.0, height=0.4, orientation='horizontal',vmin=0, vmax=4000)
m
m = leafmap.Map()
m.add_basemap("OpenTopoMap")
m.add_colormap('terrain', label="Elevation", width=8.0, height=0.4, orientation='horizontal',vmin=0, vmax=4000)
m

Vertical colormap¶

Add a vertical colorbar to an interactive map.

In [ ]:

m = leafmap.Map()
m.add_basemap("OpenTopoMap")
m.add_colormap('terrain', label="Elevation", width=0.4, height=4, orientation='vertical',vmin=0, vmax=4000)
m
m = leafmap.Map()
m.add_basemap("OpenTopoMap")
m.add_colormap('terrain', label="Elevation", width=0.4, height=4, orientation='vertical',vmin=0, vmax=4000)
m

List of available colormaps¶

In [ ]:

cm.plot_colormaps(width=12, height=0.4)
cm.plot_colormaps(width=12, height=0.4)

Add vector datasets¶

Add CSV¶

Read a CSV as a Pandas DataFrame.

In [ ]:

import os
import leafmap
import os
import leafmap

In [ ]:

in_csv = 'https://raw.githubusercontent.com/giswqs/data/main/world/world_cities.csv'
df = leafmap.csv_to_pandas(in_csv)
df
in_csv = 'https://raw.githubusercontent.com/giswqs/data/main/world/world_cities.csv'
df = leafmap.csv_to_pandas(in_csv)
df

Create a point layer from a CSV file containing lat/long information.

In [ ]:

m = leafmap.Map()
m.add_xy_data(in_csv, x="longitude", y="latitude", layer_name="World Cities")
m
m = leafmap.Map()
m.add_xy_data(in_csv, x="longitude", y="latitude", layer_name="World Cities")
m

Set the output directory.

In [ ]:

out_dir = os.getcwd()
out_shp = os.path.join(out_dir, 'world_cities.shp')
out_dir = os.getcwd()
out_shp = os.path.join(out_dir, 'world_cities.shp')

Convert a CSV file containing lat/long information to a shapefile.

In [ ]:

leafmap.csv_to_shp(in_csv, out_shp)
leafmap.csv_to_shp(in_csv, out_shp)

Convert a CSV file containing lat/long information to a GeoJSON.

In [ ]:

out_geojson = os.path.join(out_dir, 'world_cities.geojson')
leafmap.csv_to_geojson(in_csv, out_geojson)
out_geojson = os.path.join(out_dir, 'world_cities.geojson')
leafmap.csv_to_geojson(in_csv, out_geojson)

Convert a CSV file containing lat/long information to a GeoPandas GeoDataFrame.

In [ ]:

gdf = leafmap.csv_to_gdf(in_csv)
gdf
gdf = leafmap.csv_to_gdf(in_csv)
gdf

Add GeoJSON¶

Add a GeoJSON to the map.

In [ ]:

m = leafmap.Map(center=[0, 0], zoom=2)
in_geojson = 'https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/cable-geo.geojson'
m.add_geojson(in_geojson, layer_name="Cable lines", info_mode='on_hover')
m
m = leafmap.Map(center=[0, 0], zoom=2)
in_geojson = 'https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/cable-geo.geojson'
m.add_geojson(in_geojson, layer_name="Cable lines", info_mode='on_hover')
m

Add a GeoJSON with random filled color to the map.

In [ ]:

m = leafmap.Map(center=[0, 0], zoom=2)
url = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/countries.geojson"
m.add_geojson(url, layer_name="Countries", fill_colors=['red', 'yellow', 'green', 'orange'])
m
m = leafmap.Map(center=[0, 0], zoom=2)
url = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/countries.geojson"
m.add_geojson(url, layer_name="Countries", fill_colors=['red', 'yellow', 'green', 'orange'])
m

Use the style_callback function for assigning a random color to each polygon.

In [ ]:

import random

m = leafmap.Map(center=[0, 0], zoom=2)

url = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/countries.geojson"

def random_color(feature):
    return {
        'color': 'black',
        'fillColor': random.choice(['red', 'yellow', 'green', 'orange']),
    }

m.add_geojson(url, layer_name="Countries", style_callback=random_color)
m
import random

m = leafmap.Map(center=[0, 0], zoom=2)

url = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/countries.geojson"

def random_color(feature):
    return {
        'color': 'black',
        'fillColor': random.choice(['red', 'yellow', 'green', 'orange']),
    }

m.add_geojson(url, layer_name="Countries", style_callback=random_color)
m

Use custom style and hover_style functions.

In [ ]:

m = leafmap.Map(center=[0, 0], zoom=2)
url = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/countries.geojson"
style = {
    "stroke": True,
    "color": "#0000ff",
    "weight": 2,
    "opacity": 1,
    "fill": True,
    "fillColor": "#0000ff",
    "fillOpacity": 0.1,
}
hover_style = {"fillOpacity": 0.7}
m.add_geojson(url, layer_name="Countries", style=style, hover_style=hover_style)
m
m = leafmap.Map(center=[0, 0], zoom=2)
url = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/countries.geojson"
style = {
    "stroke": True,
    "color": "#0000ff",
    "weight": 2,
    "opacity": 1,
    "fill": True,
    "fillColor": "#0000ff",
    "fillOpacity": 0.1,
}
hover_style = {"fillOpacity": 0.7}
m.add_geojson(url, layer_name="Countries", style=style, hover_style=hover_style)
m

Add shapefile¶

In [ ]:

m = leafmap.Map(center=[0, 0], zoom=2)
in_shp = 'https://github.com/giswqs/leafmap/raw/master/examples/data/countries.zip'
m.add_shp(in_shp, layer_name="Countries")
m
m = leafmap.Map(center=[0, 0], zoom=2)
in_shp = 'https://github.com/giswqs/leafmap/raw/master/examples/data/countries.zip'
m.add_shp(in_shp, layer_name="Countries")
m

Add KML¶

In [ ]:

import leafmap
import leafmap

In [ ]:

m = leafmap.Map()
in_kml = 'https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/us-states.kml'
m.add_kml(in_kml,layer_name="US States KML")
m
m = leafmap.Map()
in_kml = 'https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/us-states.kml'
m.add_kml(in_kml,layer_name="US States KML")
m

Add GeoDataFrame¶

In [ ]:

import geopandas as gpd
import geopandas as gpd

In [ ]:

m = leafmap.Map()
gdf = gpd.read_file("https://github.com/giswqs/leafmap/raw/master/examples/data/cable-geo.geojson")
m.add_gdf(gdf, layer_name="Cable lines")
m
m = leafmap.Map()
gdf = gpd.read_file("https://github.com/giswqs/leafmap/raw/master/examples/data/cable-geo.geojson")
m.add_gdf(gdf, layer_name="Cable lines")
m

Read the GeoPandas sample dataset as a GeoDataFrame.

In [ ]:

path_to_data = gpd.datasets.get_path("nybb")
gdf = gpd.read_file(path_to_data)
gdf
path_to_data = gpd.datasets.get_path("nybb")
gdf = gpd.read_file(path_to_data)
gdf

In [ ]:

m = leafmap.Map()
m.add_gdf(gdf, layer_name="New York boroughs", fill_colors=["red", "green", "blue"])
m
m = leafmap.Map()
m.add_gdf(gdf, layer_name="New York boroughs", fill_colors=["red", "green", "blue"])
m

Add point layer¶

Add a point layer using the interactive GUI.

In [ ]:

m = leafmap.Map()
m
m = leafmap.Map()
m

Add a point layer programmatically.

In [ ]:

m = leafmap.Map()
url= "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/us_cities.geojson"
m.add_point_layer(url, popup=["name", "pop_max"], layer_name="US Cities")
m
m = leafmap.Map()
url= "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/us_cities.geojson"
m.add_point_layer(url, popup=["name", "pop_max"], layer_name="US Cities")
m

Add vector¶

The add_vector function supports any vector data format supported by GeoPandas.

In [ ]:

m = leafmap.Map(center=[0, 0], zoom=2)
url = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/countries.geojson"
m.add_vector(url, layer_name="Countries", fill_colors=['red', 'yellow', 'green', 'orange'])
m
m = leafmap.Map(center=[0, 0], zoom=2)
url = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/countries.geojson"
m.add_vector(url, layer_name="Countries", fill_colors=['red', 'yellow', 'green', 'orange'])
m

Download OSM data¶

OSM from geocode¶

Add OSM data of place(s) by name or ID to the map. Note that the leafmap custom layer control does not support GeoJSON, we need to use the ipyleaflet built-in layer control.

In [ ]:

import leafmap
import leafmap

In [ ]:

m = leafmap.Map(toolbar_control=False, layers_control=True)
m.add_osm_from_geocode("New York City", layer_name='NYC')
m
m = leafmap.Map(toolbar_control=False, layers_control=True)
m.add_osm_from_geocode("New York City", layer_name='NYC')
m

In [ ]:

m = leafmap.Map(toolbar_control=False, layers_control=True)
m.add_osm_from_geocode("Chicago, Illinois", layer_name='Chicago, IL')
m
m = leafmap.Map(toolbar_control=False, layers_control=True)
m.add_osm_from_geocode("Chicago, Illinois", layer_name='Chicago, IL')
m

OSM from place¶

Add OSM entities within boundaries of geocodable place(s) to the map.

In [ ]:

m = leafmap.Map(toolbar_control=False, layers_control=True)
place = "Bunker Hill, Los Angeles, California"
tags = {"building": True}
m.add_osm_from_place(place, tags, layer_name="Los Angeles, CA")
m
m = leafmap.Map(toolbar_control=False, layers_control=True)
place = "Bunker Hill, Los Angeles, California"
tags = {"building": True}
m.add_osm_from_place(place, tags, layer_name="Los Angeles, CA")
m

Show OSM feature tags. https://wiki.openstreetmap.org/wiki/Map_features

In [ ]:

# leafmap.osm_tags_list()
# leafmap.osm_tags_list()

OSM from address¶

In [ ]:

m = leafmap.Map(toolbar_control=False, layers_control=True)
m.add_osm_from_address(
    address="New York City", 
    tags={"amenity": "bar"}, 
    dist=1500,
    layer_name="NYC bars")
m
m = leafmap.Map(toolbar_control=False, layers_control=True)
m.add_osm_from_address(
    address="New York City", 
    tags={"amenity": "bar"}, 
    dist=1500,
    layer_name="NYC bars")
m

In [ ]:

m = leafmap.Map(toolbar_control=False, layers_control=True)
m.add_osm_from_address(
    address="New York City", 
    tags={
        "landuse": ["retail", "commercial"],
        "building": True
    },
    dist=1000, layer_name="NYC buildings")
m
m = leafmap.Map(toolbar_control=False, layers_control=True)
m.add_osm_from_address(
    address="New York City", 
    tags={
        "landuse": ["retail", "commercial"],
        "building": True
    },
    dist=1000, layer_name="NYC buildings")
m

OSM from bbox¶

In [ ]:

m = leafmap.Map(toolbar_control=False, layers_control=True)
north, south, east, west = 40.7551, 40.7454, -73.9738, -73.9965
m.add_osm_from_bbox(north, south, east, west, tags={"amenity": "bar"}, layer_name="NYC bars")
m
m = leafmap.Map(toolbar_control=False, layers_control=True)
north, south, east, west = 40.7551, 40.7454, -73.9738, -73.9965
m.add_osm_from_bbox(north, south, east, west, tags={"amenity": "bar"}, layer_name="NYC bars")
m

OSM from point¶

Add OSM entities within some distance N, S, E, W of a point to the map.

In [ ]:

m = leafmap.Map(center=[46.7808, -96.0156], zoom=12, toolbar_control=False, layers_control=True)
m.add_osm_from_point(center_point=(46.7808, -96.0156), tags={"natural": "water"}, dist=10000, layer_name="Lakes")
m
m = leafmap.Map(center=[46.7808, -96.0156], zoom=12, toolbar_control=False, layers_control=True)
m.add_osm_from_point(center_point=(46.7808, -96.0156), tags={"natural": "water"}, dist=10000, layer_name="Lakes")
m

In [ ]:

m = leafmap.Map(center=[39.9170, 116.3908], zoom=15, toolbar_control=False, layers_control=True)
m.add_osm_from_point(center_point=(39.9170, 116.3908), tags={"building": True, "natural": "water"}, dist=1000, layer_name="Beijing")
m
m = leafmap.Map(center=[39.9170, 116.3908], zoom=15, toolbar_control=False, layers_control=True)
m.add_osm_from_point(center_point=(39.9170, 116.3908), tags={"building": True, "natural": "water"}, dist=1000, layer_name="Beijing")
m

OSM from view¶

Add OSM entities within the current map view to the map.

In [ ]:

m = leafmap.Map(toolbar_control=False, layers_control=True)
m.set_center(-73.9854, 40.7500, 16)
m
m = leafmap.Map(toolbar_control=False, layers_control=True)
m.set_center(-73.9854, 40.7500, 16)
m

In [ ]:

m.add_osm_from_view(tags={"amenity": "bar", "building": True}, layer_name="New York")
m.add_osm_from_view(tags={"amenity": "bar", "building": True}, layer_name="New York")

Create a GeoPandas GeoDataFrame from place.

In [ ]:

gdf = leafmap.osm_gdf_from_place("New York City", tags={"amenity": "bar"})
gdf
gdf = leafmap.osm_gdf_from_place("New York City", tags={"amenity": "bar"})
gdf

Use WhiteboxTools¶

Use the built-in toolbox to perform geospatial analysis. For example, you can perform depression filling using the sample DEM dataset downloaded in the above step.

In [ ]:

import os
import leafmap
import urllib.request
import os
import leafmap
import urllib.request

Download a sample DEM dataset.

In [ ]:

url = 'https://github.com/giswqs/whitebox-python/raw/master/whitebox/testdata/DEM.tif'
url = 'https://github.com/giswqs/whitebox-python/raw/master/whitebox/testdata/DEM.tif'

In [ ]:

urllib.request.urlretrieve(url, "dem.tif")
urllib.request.urlretrieve(url, "dem.tif")

In [ ]:

m = leafmap.Map()
m
m = leafmap.Map()
m

Display the toolbox using the default mode.

In [ ]:

leafmap.whiteboxgui()
leafmap.whiteboxgui()

Display the toolbox using the collapsible tree mode. Note that the tree mode does not support Google Colab.

In [ ]:

leafmap.whiteboxgui(tree=True)
leafmap.whiteboxgui(tree=True)

Perform geospatial analysis using the whitebox package.

In [ ]:

import os
import whitebox
import os
import whitebox

In [ ]:

wbt = whitebox.WhiteboxTools()
wbt.verbose = True
wbt = whitebox.WhiteboxTools()
wbt.verbose = True

In [ ]:

wbt.version()
wbt.version()

In [ ]:

data_dir = os.getcwd()
wbt.set_working_dir(data_dir)
data_dir = os.getcwd()
wbt.set_working_dir(data_dir)

In [ ]:

wbt.feature_preserving_smoothing("dem.tif", "smoothed.tif", filter=9)
wbt.breach_depressions("smoothed.tif", "breached.tif")
wbt.d_inf_flow_accumulation("breached.tif", "flow_accum.tif")
wbt.feature_preserving_smoothing("dem.tif", "smoothed.tif", filter=9)
wbt.breach_depressions("smoothed.tif", "breached.tif")
wbt.d_inf_flow_accumulation("breached.tif", "flow_accum.tif")

In [ ]:

import matplotlib.pyplot as plt
import imageio
%matplotlib inline
import matplotlib.pyplot as plt
import imageio
%matplotlib inline  

In [ ]:

original = imageio.imread(os.path.join(data_dir, 'dem.tif'))
smoothed = imageio.imread(os.path.join(data_dir, 'smoothed.tif'))
breached = imageio.imread(os.path.join(data_dir, 'breached.tif'))
flow_accum = imageio.imread(os.path.join(data_dir, 'flow_accum.tif'))
original = imageio.imread(os.path.join(data_dir, 'dem.tif'))
smoothed = imageio.imread(os.path.join(data_dir, 'smoothed.tif'))
breached = imageio.imread(os.path.join(data_dir, 'breached.tif'))
flow_accum = imageio.imread(os.path.join(data_dir, 'flow_accum.tif'))

In [ ]:

fig=plt.figure(figsize=(16,11))

ax1 = fig.add_subplot(2, 2, 1)
ax1.set_title('Original DEM')
plt.imshow(original)

ax2 = fig.add_subplot(2, 2, 2)
ax2.set_title('Smoothed DEM')
plt.imshow(smoothed)

ax3 = fig.add_subplot(2, 2, 3)
ax3.set_title('Breached DEM')
plt.imshow(breached)

ax4 = fig.add_subplot(2, 2, 4)
ax4.set_title('Flow Accumulation')
plt.imshow(flow_accum)

plt.show()
fig=plt.figure(figsize=(16,11))

ax1 = fig.add_subplot(2, 2, 1)
ax1.set_title('Original DEM')
plt.imshow(original)

ax2 = fig.add_subplot(2, 2, 2)
ax2.set_title('Smoothed DEM')
plt.imshow(smoothed)

ax3 = fig.add_subplot(2, 2, 3)
ax3.set_title('Breached DEM')
plt.imshow(breached)

ax4 = fig.add_subplot(2, 2, 4)
ax4.set_title('Flow Accumulation')
plt.imshow(flow_accum)

plt.show()

Create basemap gallery¶

In [ ]:

import leafmap
import leafmap

In [ ]:

for basemap in leafmap.leafmap_basemaps:
    print(basemap)
for basemap in leafmap.leafmap_basemaps:
    print(basemap)

In [ ]:

layers = list(leafmap.leafmap_basemaps.keys())[17:117]
layers = list(leafmap.leafmap_basemaps.keys())[17:117]

In [ ]:

leafmap.linked_maps(rows=20, cols=5, height="200px", layers=layers, labels=layers)
leafmap.linked_maps(rows=20, cols=5, height="200px", layers=layers, labels=layers)

Create linked map¶

In [ ]:

import leafmap
import leafmap

In [ ]:

leafmap.leafmap_basemaps.keys()
leafmap.leafmap_basemaps.keys()

In [ ]:

layers = ['ROADMAP', 'HYBRID']
leafmap.linked_maps(rows=1, cols=2, height='400px', layers=layers)
layers = ['ROADMAP', 'HYBRID']
leafmap.linked_maps(rows=1, cols=2, height='400px', layers=layers)

In [ ]:

layers = ['Stamen.Terrain', 'OpenTopoMap']
leafmap.linked_maps(rows=1, cols=2, height='400px', layers=layers)
layers = ['Stamen.Terrain', 'OpenTopoMap']
leafmap.linked_maps(rows=1, cols=2, height='400px', layers=layers)

Create a 2 * 2 linked map to visualize land cover change. Specify the center and zoom parameters to change the default map center and zoom level.

In [ ]:

layers = [str(f"NLCD {year} CONUS Land Cover") for year in [2001, 2006, 2011, 2016]]
labels =  [str(f"NLCD {year}") for year in [2001, 2006, 2011, 2016]]
leafmap.linked_maps(rows=2, cols=2, height='300px', layers=layers, labels=labels, center=[36.1, -115.2], zoom=9)
layers = [str(f"NLCD {year} CONUS Land Cover") for year in [2001, 2006, 2011, 2016]]
labels =  [str(f"NLCD {year}") for year in [2001, 2006, 2011, 2016]]
leafmap.linked_maps(rows=2, cols=2, height='300px', layers=layers, labels=labels, center=[36.1, -115.2], zoom=9)

Create split-panel map¶

Create a split-panel map by specifying the left_layer and right_layer, which can be chosen from the basemap names, or any custom XYZ tile layer.

In [ ]:

import leafmap
import leafmap

In [ ]:

leafmap.split_map(left_layer="ROADMAP", right_layer="HYBRID")
leafmap.split_map(left_layer="ROADMAP", right_layer="HYBRID")

Hide the zoom control from the map.

In [ ]:

leafmap.split_map(left_layer="Esri.WorldTopoMap", right_layer="OpenTopoMap", zoom_control=False)
leafmap.split_map(left_layer="Esri.WorldTopoMap", right_layer="OpenTopoMap", zoom_control=False)

Add labels to the map and change the default map center and zoom level.

In [ ]:

leafmap.split_map(left_layer="NLCD 2001 CONUS Land Cover", right_layer="NLCD 2019 CONUS Land Cover", 
                  left_label = "2001", right_label="2019", label_position="bottom", center=[36.1, -114.9], zoom=10)
leafmap.split_map(left_layer="NLCD 2001 CONUS Land Cover", right_layer="NLCD 2019 CONUS Land Cover", 
                  left_label = "2001", right_label="2019", label_position="bottom", center=[36.1, -114.9], zoom=10)

Create heat map¶

Specify the file path to the CSV. It can either be a file locally or on the Internet.

In [ ]:

import leafmap
import leafmap

In [ ]:

m = leafmap.Map(layers_control=True)
in_csv = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/world_cities.csv"
m.add_heatmap(in_csv, latitude="latitude", longitude='longitude', value="pop_max", name="Heat map", radius=20)
m
m = leafmap.Map(layers_control=True)
in_csv = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/world_cities.csv"
m.add_heatmap(in_csv, latitude="latitude", longitude='longitude', value="pop_max", name="Heat map", radius=20)
m

Use the folium plotting backend.

In [ ]:

from leafmap import foliumap
from leafmap import foliumap

In [ ]:

m = foliumap.Map()
in_csv = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/world_cities.csv"
m.add_heatmap(in_csv, latitude="latitude", longitude='longitude', value="pop_max", name="Heat map", radius=20)
m = foliumap.Map()
in_csv = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/world_cities.csv"
m.add_heatmap(in_csv, latitude="latitude", longitude='longitude', value="pop_max", name="Heat map", radius=20)

In [ ]:

colors = ['blue', 'lime', 'red']
m.add_colorbar(colors=colors, vmin=0, vmax=10000)
m.add_title("World Population Heat Map", font_size="20px", align="center")
m
colors = ['blue', 'lime', 'red']
m.add_colorbar(colors=colors, vmin=0, vmax=10000)
m.add_title("World Population Heat Map", font_size="20px", align="center")
m

Save map to HTML¶

In [ ]:

import leafmap
import leafmap

In [ ]:

m = leafmap.Map()
m.add_basemap("Esri.NatGeoWorldMap")
m
m = leafmap.Map()
m.add_basemap("Esri.NatGeoWorldMap")
m

Specify the output HTML file name to save the map as a web page.

In [ ]:

m.to_html("mymap.html")
m.to_html("mymap.html")

If the output HTML file name is not provided, the function will return a string containing contain the source code of the HTML file.

In [ ]:

html = m.to_html()
html = m.to_html()

In [ ]:

# print(html)
# print(html)

Use kepler plotting backend¶

In [ ]:

import leafmap.kepler as leafmap
import leafmap.kepler as leafmap

Create an interactive map¶

Create an interactive map. You can specify various parameters to initialize the map, such as center, zoom, height, and widescreen.

In [ ]:

m = leafmap.Map(center=[40, -100], zoom=2, height=600, widescreen=False)
m
m = leafmap.Map(center=[40, -100], zoom=2, height=600, widescreen=False)
m

If you encounter an error saying Error displaying widget: model not found when trying to display the map, you can use m.static_map() as a workaround until this kepler.gl bug has been resolved.

In [ ]:

m.static_map(width=1280, height=600)
m.static_map(width=1280, height=600)

Add CSV¶

Add a CSV to the map. If you have a map config file, you can directly apply config to the map.

In [ ]:

m = leafmap.Map(center=[37.7621, -122.4143], zoom=12)
in_csv = 'https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/hex_data.csv'
config = 'https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/hex_config.json'
m.add_csv(in_csv, layer_name="hex_data", config=config)
m
m = leafmap.Map(center=[37.7621, -122.4143], zoom=12)
in_csv = 'https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/hex_data.csv'
config = 'https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/hex_config.json'
m.add_csv(in_csv, layer_name="hex_data", config=config)
m

In [ ]:

m.static_map(width=1280, height=600)
m.static_map(width=1280, height=600)

Save map config¶

Save the map configuration as a JSON file.

In [ ]:

m.save_config("cache/config.json")
m.save_config("cache/config.json")

Save map as html¶

Save the map to an interactive html.

In [ ]:

m.to_html(outfile="cache/kepler_hex.html")
m.to_html(outfile="cache/kepler_hex.html")

Add GeoJONS¶

Add a GeoJSON with US state boundaries to the map.

In [ ]:

m = leafmap.Map(center=[50, -110], zoom=2)
polygons = 'https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/us-states.json'
m.add_geojson(polygons, layer_name="Countries")
m
m = leafmap.Map(center=[50, -110], zoom=2)
polygons = 'https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/us-states.json'
m.add_geojson(polygons, layer_name="Countries")
m

In [ ]:

m.static_map(width=1280, height=600)
m.static_map(width=1280, height=600)

Add shapefile¶

Add a shapefile to the map.

In [ ]:

m = leafmap.Map(center=[20, 0], zoom=1)
in_shp = "https://github.com/giswqs/leafmap/raw/master/examples/data/countries.zip"
m.add_shp(in_shp, "Countries")
m
m = leafmap.Map(center=[20, 0], zoom=1)
in_shp = "https://github.com/giswqs/leafmap/raw/master/examples/data/countries.zip"
m.add_shp(in_shp, "Countries")
m

In [ ]:

m.static_map(width=1280, height=600)
m.static_map(width=1280, height=600)

Add GeoDataFrame¶

Add a GeoPandas GeoDataFrame to the map.

In [ ]:

import geopandas as gpd
import geopandas as gpd

In [ ]:

gdf = gpd.read_file("https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/world_cities.geojson")
gdf
gdf = gpd.read_file("https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/world_cities.geojson")
gdf

In [ ]:

m = leafmap.Map(center=[20, 0], zoom=1)
m.add_gdf(gdf, "World cities")
m
m = leafmap.Map(center=[20, 0], zoom=1)
m.add_gdf(gdf, "World cities")
m

In [ ]:

m.static_map(width=1280, height=600)
m.static_map(width=1280, height=600)

Publish maps¶

To follow this tutorial, you will need to sign up for an account with https://datapane.com, then install and authenticate the datapane Python package. More information can be found here.

pip install datapane
datapane login
datapane ping

If you encounter folium version errors, please uncomment the following line to update folium and restart the kernel.

In [ ]:

# !pip install -U folium
# !pip install -U folium

In [ ]:

import os
import datapane as dp
import leafmap.foliumap as leafmap
import os
import datapane as dp
import leafmap.foliumap as leafmap

In [ ]:

if os.environ.get("DP_TOKEN") is None:
    os.environ["DP_TOKEN"] = 'your-api-key'
if os.environ.get("DP_TOKEN") is None:
    os.environ["DP_TOKEN"] = 'your-api-key'

In [ ]:

dp.login(token=os.environ['DP_TOKEN'])
dp.login(token=os.environ['DP_TOKEN'])

Elevation map¶

In [ ]:

m = leafmap.Map()
m.add_basemap('USGS 3DEP Elevation')
colors = ['006633', 'E5FFCC', '662A00', 'D8D8D8', 'F5F5F5']
vmin = 0
vmax = 4000
m.add_colorbar(colors=colors, vmin=vmin, vmax=vmax)
m
m = leafmap.Map()
m.add_basemap('USGS 3DEP Elevation')
colors = ['006633', 'E5FFCC', '662A00', 'D8D8D8', 'F5F5F5']
vmin = 0
vmax = 4000
m.add_colorbar(colors=colors, vmin=vmin, vmax=vmax)
m

In [ ]:

m.publish(name="Elevation Map of North America")
m.publish(name="Elevation Map of North America")

Land cover map¶

In [ ]:

m = leafmap.Map()
m.add_basemap("NLCD 2019 CONUS Land Cover")
m.add_legend(builtin_legend='NLCD')
m
m = leafmap.Map()
m.add_basemap("NLCD 2019 CONUS Land Cover")
m.add_legend(builtin_legend='NLCD')
m

In [ ]:

m.publish(name="National Land Cover Database (NLCD) 2019")
m.publish(name="National Land Cover Database (NLCD) 2019")

Population heat map¶

In [ ]:

m = leafmap.Map()
in_csv = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/world_cities.csv"
m.add_heatmap(in_csv, latitude="latitude", longitude='longitude', value="pop_max", name="Heat map", radius=20)
m = leafmap.Map()
in_csv = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/world_cities.csv"
m.add_heatmap(in_csv, latitude="latitude", longitude='longitude', value="pop_max", name="Heat map", radius=20)

In [ ]:

colors = ['blue', 'lime', 'red']
vmin = 0
vmax = 10000
m.add_colorbar(colors=colors, vmin=vmin, vmax=vmax)
m
colors = ['blue', 'lime', 'red']
vmin = 0
vmax = 10000
m.add_colorbar(colors=colors, vmin=vmin, vmax=vmax)
m

In [ ]:

m.publish(name="World Population Heat Map")
m.publish(name="World Population Heat Map")

Use planet imagery¶

First, you need to sign up a Planet account and get an API key. See https://www.planet.com/nicfi & https://developers.planet.com/quickstart/apis. Uncomment the following line to pass in your API key.

In [ ]:

import os
import leafmap
import os
import leafmap

In [ ]:

if os.environ.get("PLANET_API_KEY") is None:
    os.environ["PLANET_API_KEY"] = 'your-api-key'
if os.environ.get("PLANET_API_KEY") is None:
    os.environ["PLANET_API_KEY"] = 'your-api-key'

In [ ]:

quarterly_tiles = leafmap.planet_quarterly_tiles()
quarterly_tiles = leafmap.planet_quarterly_tiles()

In [ ]:

for tile in quarterly_tiles:
    print(tile)
for tile in quarterly_tiles:
    print(tile)

In [ ]:

monthly_tiles = leafmap.planet_monthly_tiles()
monthly_tiles = leafmap.planet_monthly_tiles()

In [ ]:

for tile in monthly_tiles:
    print(tile)
for tile in monthly_tiles:
    print(tile)

Add a Planet monthly mosaic by specifying year and month.

In [ ]:

m = leafmap.Map()
m.add_planet_by_month(year=2020, month=8)
m
m = leafmap.Map()
m.add_planet_by_month(year=2020, month=8)
m

In [ ]:

m = leafmap.Map()
m.add_planet_by_quarter(year=2019, quarter=2)
m
m = leafmap.Map()
m.add_planet_by_quarter(year=2019, quarter=2)
m

Use timeseries inspector¶

In [ ]:

import os
import leafmap
import os
import leafmap

In [ ]:

if os.environ.get("PLANET_API_KEY") is None:
    os.environ["PLANET_API_KEY"] = 'your-api-key'
if os.environ.get("PLANET_API_KEY") is None:
    os.environ["PLANET_API_KEY"] = 'your-api-key'

In [ ]:

tiles = leafmap.planet_tiles()
tiles = leafmap.planet_tiles()

In [ ]:

leafmap.ts_inspector(tiles, center=[40, -100], zoom=4)
leafmap.ts_inspector(tiles, center=[40, -100], zoom=4)

Use time slider¶

Use the time slider to visualize Planet quarterly mosaic.

In [ ]:

import os
import leafmap
import os
import leafmap

In [ ]:

if os.environ.get("PLANET_API_KEY") is None:
    os.environ["PLANET_API_KEY"] = 'your-api-key'
if os.environ.get("PLANET_API_KEY") is None:
    os.environ["PLANET_API_KEY"] = 'your-api-key'

In [ ]:

m = leafmap.Map(center=[38.2659, -103.2447], zoom=13)
m
m = leafmap.Map(center=[38.2659, -103.2447], zoom=13)
m

In [ ]:

m = leafmap.Map()
layers_dict = leafmap.planet_quarterly_tiles()
m.add_time_slider(layers_dict, time_interval=1)
m
m = leafmap.Map()
layers_dict = leafmap.planet_quarterly_tiles()
m.add_time_slider(layers_dict, time_interval=1)
m

Use the time slider to visualize basemaps.

In [ ]:

m = leafmap.Map()
m.clear_layers()
layers_dict = leafmap.basemap_xyz_tiles()
m.add_time_slider(layers_dict, time_interval=1)
m
m = leafmap.Map()
m.clear_layers()
layers_dict = leafmap.basemap_xyz_tiles()
m.add_time_slider(layers_dict, time_interval=1)
m

Use PostGIS¶

Setting up the conda env:

conda create -n geo python=3.8
conda activate geo
conda install geopandas
conda install mamba -c conda-forge
mamba install leafmap sqlalchemy psycopg2 -c conda-forge

Sample dataset:

nyc_data.zip (Watch this video to load data into PostGIS)

Connect to the database¶

You can directly pass in the user name and password to access the database. Alternative, you can define environment variables. The default environment variables for user and password are SQL_USER and SQL_PASSWORD, respectively.

The try...except... statements are only used for building the documentation website (https://leafmap.org) because the PostGIS database is not available on GitHub. If you are running the notebook with Jupyter installed locally and PostGIS set up properly, you don't need these try...except... statements.

In [ ]:

try:
    con = leafmap.connect_postgis(database="nyc", host="localhost", user=None, password=None, use_env_var=True)
except:
    pass
try:
    con = leafmap.connect_postgis(database="nyc", host="localhost", user=None, password=None, use_env_var=True)
except:
    pass

Perform SQL queries¶

Create a GeoDataFrame from a sql query.

In [ ]:

sql = 'SELECT * FROM nyc_neighborhoods'
sql = 'SELECT * FROM nyc_neighborhoods'

In [ ]:

try:
    gdf = leafmap.read_postgis(sql, con)
    display(gdf)
except:
    pass
try:
    gdf = leafmap.read_postgis(sql, con)
    display(gdf)
except:
    pass

Display data on the map¶

In [ ]:

try:
    m = leafmap.Map()
    m.add_gdf_from_postgis(sql, con, layer_name="NYC Neighborhoods", fill_colors=["red", "green", "blue"])
    display(m)
except:
    pass
try:
    m = leafmap.Map()
    m.add_gdf_from_postgis(sql, con, layer_name="NYC Neighborhoods", fill_colors=["red", "green", "blue"])
    display(m)
except:
    pass    

In [ ]:

import leafmap
import numpy as np
import matplotlib.pyplot as plt
from ipywidgets import Output
from ipyleaflet import WidgetControl
import leafmap
import numpy as np
import matplotlib.pyplot as plt
from ipywidgets import Output
from ipyleaflet import WidgetControl

In [ ]:

m = leafmap.Map()

# Data for plotting
t = np.arange(0.0, 2.0, 0.01)
s = 1 + np.sin(2 * np.pi * t)

fig, ax = plt.subplots()
ax.plot(t, s)

ax.set(xlabel='time (s)', ylabel='voltage (mV)',
       title='About as simple as it gets, folks')
ax.grid()

# Create an output widget to host the plot
output_widget = Output()

# Show the plot on the widget
with output_widget:
    output_widget.clear_output()
    plt.show()

# Add the widget as a control to the map
output_control = WidgetControl(widget=output_widget, position="bottomright")
m.add_control(output_control)
m = leafmap.Map()

# Data for plotting
t = np.arange(0.0, 2.0, 0.01)
s = 1 + np.sin(2 * np.pi * t)

fig, ax = plt.subplots()
ax.plot(t, s)

ax.set(xlabel='time (s)', ylabel='voltage (mV)',
       title='About as simple as it gets, folks')
ax.grid()

# Create an output widget to host the plot
output_widget = Output()

# Show the plot on the widget
with output_widget:
    output_widget.clear_output()
    plt.show()

# Add the widget as a control to the map
output_control = WidgetControl(widget=output_widget, position="bottomright")
m.add_control(output_control)

In [ ]:

m
m

Develop custom widgets¶

In [ ]:

import leafmap
import ipywidgets as widgets
from ipyleaflet import WidgetControl
import leafmap
import ipywidgets as widgets
from ipyleaflet import WidgetControl

In [ ]:

widget_width = "250px"
padding = "0px 0px 0px 5px"  # upper, right, bottom, left

toolbar_button = widgets.ToggleButton(
    value=False,
    tooltip="Toolbar",
    icon="gears",
    layout=widgets.Layout(width="28px", height="28px", padding=padding),
)

close_button = widgets.ToggleButton(
    value=False,
    tooltip="Close the tool",
    icon="times",
    button_style="primary",
    layout=widgets.Layout(height="28px", width="28px", padding=padding),
)
widget_width = "250px"
padding = "0px 0px 0px 5px"  # upper, right, bottom, left

toolbar_button = widgets.ToggleButton(
    value=False,
    tooltip="Toolbar",
    icon="gears",
    layout=widgets.Layout(width="28px", height="28px", padding=padding),
)

close_button = widgets.ToggleButton(
    value=False,
    tooltip="Close the tool",
    icon="times",
    button_style="primary",
    layout=widgets.Layout(height="28px", width="28px", padding=padding),
)

In [ ]:

toolbar = widgets.HBox([toolbar_button])
toolbar
toolbar = widgets.HBox([toolbar_button])
toolbar

In [ ]:

def toolbar_click(change):
    if change["new"]:
        toolbar.children = [toolbar_button, close_button]
    else:
        toolbar.children = [toolbar_button]
        
toolbar_button.observe(toolbar_click, "value")
def toolbar_click(change):
    if change["new"]:
        toolbar.children = [toolbar_button, close_button]
    else:
        toolbar.children = [toolbar_button]
        
toolbar_button.observe(toolbar_click, "value")

In [ ]:

def close_click(change):
    if change["new"]:
        toolbar_button.close()
        close_button.close()
        toolbar.close()
        
close_button.observe(close_click, "value")
toolbar
def close_click(change):
    if change["new"]:
        toolbar_button.close()
        close_button.close()
        toolbar.close()
        
close_button.observe(close_click, "value")
toolbar

In [ ]:

rows = 2
cols = 2
grid = widgets.GridspecLayout(rows, cols, grid_gap="0px", layout=widgets.Layout(width="65px"))
rows = 2
cols = 2
grid = widgets.GridspecLayout(rows, cols, grid_gap="0px", layout=widgets.Layout(width="65px"))

icons: https://fontawesome.com/v4.7.0/icons/

In [ ]:

icons = ["folder-open", "map", "info", "question"]

for i in range(rows):
    for j in range(cols):
        grid[i, j] = widgets.Button(description="", button_style="primary", icon=icons[i*rows+j], 
                                    layout=widgets.Layout(width="28px", padding="0px"))
grid
icons = ["folder-open", "map", "info", "question"]

for i in range(rows):
    for j in range(cols):
        grid[i, j] = widgets.Button(description="", button_style="primary", icon=icons[i*rows+j], 
                                    layout=widgets.Layout(width="28px", padding="0px"))
grid

In [ ]:

toolbar = widgets.VBox([toolbar_button])
toolbar = widgets.VBox([toolbar_button])

In [ ]:

def toolbar_click(change):
    if change["new"]:
        toolbar.children = [widgets.HBox([close_button, toolbar_button]), grid]
    else:
        toolbar.children = [toolbar_button]
        
toolbar_button.observe(toolbar_click, "value")
toolbar
def toolbar_click(change):
    if change["new"]:
        toolbar.children = [widgets.HBox([close_button, toolbar_button]), grid]
    else:
        toolbar.children = [toolbar_button]
        
toolbar_button.observe(toolbar_click, "value")
toolbar

In [ ]:

toolbar_ctrl = WidgetControl(widget=toolbar, position="topright")
toolbar_ctrl = WidgetControl(widget=toolbar, position="topright")

In [ ]:

m = leafmap.Map()
m.add_control(toolbar_ctrl)
m
m = leafmap.Map()
m.add_control(toolbar_ctrl)
m

In [ ]:

output = widgets.Output()
output_ctrl = WidgetControl(widget=output, position="bottomright")
m.add_control(output_ctrl)
output = widgets.Output()
output_ctrl = WidgetControl(widget=output, position="bottomright")
m.add_control(output_ctrl)

In [ ]:

def tool_click(b):    
    with output:
        output.clear_output()
        print(f"You clicked the {b.icon} button")
def tool_click(b):    
    with output:
        output.clear_output()
        print(f"You clicked the {b.icon} button")

In [ ]:

for i in range(rows):
    for j in range(cols):
        tool = grid[i, j]
        tool.on_click(tool_click)
for i in range(rows):
    for j in range(cols):
        tool = grid[i, j]
        tool.on_click(tool_click)

Last update: 2021-12-03