Uncomment the following line to install geemap if needed.
# !pip install -U geemap
Check package version.
import ee
import geemap
print(ee.__version__)
print(geemap.__version__)
geemap.api_docs()
geemap.open_youtube()
geemap.ee_search()
Map = geemap.Map(center=[40, -100], zoom=4)
Map.add_basemap("HYBRID")
Map
Use the Drawing tool to draw any rectangle on the map.
https://earthengine.google.com/timelapse/
https://geemap.readthedocs.io/en/latest/source/geemap.html#geemap.geemap.Map.add_landsat_ts_gif
Map.setCenter(-114.762293, 36.06462, 9)
label = "Surface water dynamics in Lake Mead"
Map.add_landsat_ts_gif(
label=label,
start_year=1985,
bands=["NIR", "Red", "Green"],
font_color="white",
frames_per_second=10,
progress_bar_color="blue",
)
Map.setCenter(-74.4557, -8.4289, 9)
label = "Surface Water Dynamics of Ucayali River, Peru"
Map.add_landsat_ts_gif(
label=label,
start_year=1985,
start_date="01-01",
end_date="12-31",
bands=["SWIR1", "NIR", "Red"],
font_color="white",
frames_per_second=10,
progress_bar_color="blue",
)
In this case study, we can going to use USGS Landsat 8 Surface Reflectance Tier 1.
ee.ImageCollection("LANDSAT/LC08/C01/T1_SR")
Map = geemap.Map()
Map.add_basemap("HYBRID")
Map.setCenter(-114.762293, 36.06462, 9)
Map
Pan and zoom the map to Lake Mead near Las Vegas, NV. Use the Drawing Tools to place a marker inside Lake Mead.
roi = Map.user_roi
print(roi.getInfo())
Alternatively, you can define an ee.Geometry() as an ROI.
roi = ee.Geometry.Point([-114.762293, 36.06462])
Let's filter the ImageCollection by roi and date, and then sort by cloud cover.
images = (
ee.ImageCollection("LANDSAT/LC08/C01/T1_SR")
.filterBounds(roi)
.filterDate("2015-01-01", "2019-12-31")
.sort("CLOUD_COVER")
)
How many Landsat 8 images (2015-2019) are available for the study area?
print(images.size().getInfo())
Since the returned images are already sorted by CLOUD_COVER in ascending order, the first image would be the best cloud-free image.
# best_image = images.toList(images.size()).get(0)
best_image = images.first().select(["B1", "B2", "B3", "B4", "B5", "B6", "B7"])
Let's add the best image to the Map.
vis_params = {
"bands": ["B5", "B4", "B3"],
"min": 0,
"max": 6000,
"gamma": 1.4,
}
Map.addLayer(best_image, vis_params, "Best image")
Use the Inspector and Plotting to check pixel values and spectral signature.
print(best_image.getInfo())
print(best_image.propertyNames().getInfo())
print(best_image.get("system:id").getInfo())
image = ee.Image("LANDSAT/LC08/C01/T1_SR/LC08_039035_20150724")
vis_params = {
"bands": ["B6", "B5", "B4"],
"min": 0,
"max": 6000,
"gamma": 1.4,
}
Map.addLayer(image, vis_params, "image")
Map
print(best_image.get("CLOUD_COVER").getInfo())
print(best_image.get("system:band_names").getInfo())
print(best_image.get("system:time_start").getInfo())
print(ee.Date(best_image.get("system:time_start")).format("YYYY-MM-dd").getInfo())
print(
"WRS_Path={}, WRS_ROW={}".format(
best_image.get("WRS_PATH").getInfo(), best_image.get("WRS_ROW").getInfo()
)
)
The Normalized Difference Water Index (NDWI) is used to monitor changes related to water content in water bodies, using green and NIR wavelengths, defined by McFeeters (1996):
Map = geemap.Map()
Map
image = ee.Image("LANDSAT/LC08/C01/T1_SR/LC08_039035_20150724")
vis_params = {
"bands": ["B5", "B4", "B3"],
"min": 0,
"max": 6000,
"gamma": 1.4,
}
Map.addLayer(image, vis_params, "image")
Map.centerObject(image, 8)
ndwi_image = image.normalizedDifference(["B3", "B5"])
vis_ndwi = {
"min": -1,
"max": 1,
"palette": [
"#ece7f2",
"#d0d1e6",
"#a6bddb",
"#74a9cf",
"#3690c0",
"#0570b0",
"#045a8d",
"#023858",
],
}
Map.addLayer(ndwi_image, vis_ndwi, "NDWI image")
ndwi_threshold = 0
water_image = ndwi_image.gt(ndwi_threshold).selfMask()
Map.addLayer(water_image, {"palette": "blue"}, "Water image")
Map.layers
water_layer = Map.layers[-1]
water_layer.interact(opacity=(0.0, 1.0, 0.1))
Map
water_vector = water_image.reduceToVectors(scale=30, maxPixels=60000000)
Map.addLayer(water_vector, {}, "Water vector")
roi = ee.Geometry.Point([-114.762293, 36.06462])
lake_mead = water_vector.filterBounds(roi)
Map.addLayer(lake_mead, {}, "Lake Mead")
Map.addLayer(
ee.Image().paint(lake_mead, 0, 2), {"palette": "blue"}, "Lake Mead Outline"
)
area = lake_mead.geometry().area(1).divide(1e6).round().getInfo()
print("Area = {} km2".format(area))
Map = geemap.Map()
Map
Define input parameters
roi = ee.Geometry.Point([-114.762293, 36.06462])
start_date = "2015-01-01"
end_date = "2019-12-31"
cloud_threshold = 0.05
ndwi_threshold = 0
images = (
ee.ImageCollection("LANDSAT/LC08/C01/T1_SR")
.filterBounds(roi)
.filterDate(start_date, end_date)
.filterMetadata("CLOUD_COVER", "less_than", cloud_threshold)
)
print(images.size().getInfo())
print(images.aggregate_array("system:id").getInfo())
dates = images.aggregate_array("system:time_start").map(
lambda d: ee.Date(d).format("YYYY-MM-dd")
)
print(dates.getInfo())
first_image = ee.Image(images.toList(images.size()).get(3))
vis_params = {
"bands": ["B5", "B4", "B3"],
"min": 0,
"max": 6000,
"gamma": 1.4,
}
Map.addLayer(first_image, vis_params, "First image")
Map.centerObject(roi, 8)
def extract_water(img):
ndwi_image = img.normalizedDifference(["B3", "B5"])
water_image = ndwi_image.gt(ndwi_threshold)
return water_image
ndwi_images = images.map(extract_water)
first_ndwi_image = ee.Image(ndwi_images.toList(ndwi_images.size()).get(0)).selfMask()
Map.addLayer(first_ndwi_image, {"palette": "blue"}, "First NDWI")
occurrence = ndwi_images.sum().selfMask()
Map.addLayer(occurrence.randomVisualizer(), {}, "Water occurrence")
def ras_to_vec(img):
vec = img.selfMask().reduceToVectors(scale=30, maxPixels=60000000)
vec = vec.filterBounds(roi)
return vec.set({"area": vec.geometry().area(1).divide(1e6).round()})
ndwi_vectors = ndwi_images.map(ras_to_vec)
areas = ndwi_vectors.aggregate_array("area")
print(areas.getInfo())
import matplotlib.pyplot as plt
%matplotlib inline
# %matplotlib qt
fig = plt.figure(figsize=(12, 6))
x = dates.getInfo()
y = areas.getInfo()
plt.plot(x, y, marker="o")
plt.xlabel("Date")
plt.ylabel("Lake Mead Area (km2)")
plt.show()
water_images = ndwi_images.map(lambda img: img.selfMask())
landsat_images = images
water_layer_names = ["Water " + str(date) for date in x]
landsat_layer_names = ["Landsat " + str(date) for date in x]
water_vis = {"palette": "blue"}
landsat_vis = {
"bands": ["B5", "B4", "B3"],
"min": 0,
"max": 6000,
"gamma": 1.4,
}
Map = geemap.Map()
Map.ts_inspector(
left_ts=water_images,
right_ts=landsat_images,
left_names=water_layer_names,
right_names=landsat_layer_names,
left_vis=water_vis,
right_vis=landsat_vis,
)
Map.centerObject(roi, zoom=8)
Map
layer_index = 9 # Change this index to your desired date
print("Image date: {}".format(x[layer_index]))
water_image = ee.Image(water_images.toList(water_images.size()).get(layer_index))
landsat_image = ee.Image(landsat_images.toList(landsat_images.size()).get(layer_index))
left_layer = geemap.ee_tile_layer(water_image, water_vis, "Water")
right_layer = geemap.ee_tile_layer(landsat_image, landsat_vis, "Landsat")
Map = geemap.Map()
Map.addLayer(landsat_image, landsat_vis, "Landsat")
Map.split_map(left_layer, right_layer)
Map.centerObject(roi, zoom=12)
Map
geemap.ee_export_image_collection_to_drive(water_images, folder="export", scale=90)
geemap.ee_export_image_to_drive(
occurrence.toInt(),
description="water_occurrence",
folder="export",
region=first_ndwi_image.geometry(),
scale=90,
)
import ee
import geemap
Map = geemap.Map()
Map
states_shp = geemap.shp_to_ee("../data/us_states.shp")
Map.addLayer(states_shp, {}, "US States SHP")
state_name = "Nevada"
roi = ee.FeatureCollection("TIGER/2018/States").filter(ee.Filter.eq("NAME", state_name))
# roi = states_shp.filterBounds(Map.user_roi)
Map.addLayer(ee.Image().paint(roi, 0, 2), {"palette": "red"}, state_name)
images = geemap.landsat_timeseries(
roi=roi, start_year=1984, end_year=2019, start_date="06-01", end_date="09-30"
)
first_image = ee.Image(images.toList(images.size()).get(0))
landsat_vis = {"bands": ["NIR", "Red", "Green"], "min": 0, "max": 3500}
Map.addLayer(first_image, landsat_vis, "First image")
layer_names = ["Landsat " + str(year) for year in range(1984, 2020)]
Map = geemap.Map()
Map.ts_inspector(
left_ts=images,
right_ts=images,
left_names=layer_names,
right_names=layer_names,
left_vis=landsat_vis,
right_vis=landsat_vis,
)
Map.centerObject(roi, zoom=8)
Map
ndwi_threshold = 0
def extract_water(img):
ndwi_image = img.normalizedDifference(["Green", "NIR"])
water_image = ndwi_image.gt(ndwi_threshold)
return water_image
water_images = images.map(extract_water)
Map = geemap.Map()
first_image = ee.Image(images.toList(images.size()).get(0))
landsat_vis = {"bands": ["NIR", "Red", "Green"], "min": 0, "max": 3500}
Map.addLayer(first_image, landsat_vis, "First image")
first_water_image = ee.Image(water_images.toList(water_images.size()).get(0)).selfMask()
Map.addLayer(first_water_image, {"palette": "blue"}, "First NDWI")
Map
layer_index = 0 # Change this index to your desired date
print(layer_names[layer_index])
water_image = ee.Image(
water_images.toList(water_images.size()).get(layer_index)
).selfMask()
landsat_image = ee.Image(images.toList(images.size()).get(layer_index))
water_vis = {"palette": "blue"}
landsat_vis = {
"bands": ["NIR", "Red", "Green"],
"min": 0,
"max": 4000,
"gamma": 1.4,
}
left_layer = geemap.ee_tile_layer(water_image, water_vis, "Water")
right_layer = geemap.ee_tile_layer(landsat_image, landsat_vis, "Landsat")
Map = geemap.Map()
Map.addLayer(landsat_image, landsat_vis, "Landsat")
Map.split_map(left_layer, right_layer)
Map.centerObject(roi, zoom=12)
Map
import ee
import geemap
Map = geemap.Map()
Map.add_basemap("HYBRID")
Map
gsw = ee.Image("JRC/GSW1_1/GlobalSurfaceWater")
print(gsw.bandNames().getInfo())
occurrence = gsw.select("occurrence")
vis_occurrence = {"min": 0, "max": 100, "palette": ["red", "blue"]}
Map.addLayer(occurrence, vis_occurrence, "Occurrence")
water_mask = occurrence.gt(90).selfMask()
vis_water_mask = {"palette": ["white", "blue"]}
Map.addLayer(water_mask, vis_water_mask, "Water Mask (>90%)")
Map.setCenter(-74.4557, -8.4289, 11)
Map
change = gsw.select("change_abs")
vis_change = {"min": -50, "max": 50, "palette": ["red", "black", "limegreen"]}
Map.addLayer(change, vis_change, "Occurrence change intensity")
transition = gsw.select("transition")
Map.addLayer(transition, {}, "Transition classes")
label = "Surface Water Dynamics"
Map.add_landsat_ts_gif(
label=label,
start_year=1985,
start_date="01-01",
end_date="12-31",
bands=["SWIR1", "NIR", "Red"],
font_color="white",
frames_per_second=10,
progress_bar_color="blue",
)