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',
)