def convert(feature):
res = ee.Feature(None,feature.toDictionary())
return(res)
def getWRS(feature):
return ee.Feature(feature).get('PR')
#!/usr/bin/env python
"""Create and render a feature collection from polygons."""
import ee
from ee_plugin import Map
Map.setCenter(-107, 41, 6)
fc = ee.FeatureCollection([
ee.Feature(
ee.Geometry.Polygon([[-109.05, 41], [-109.05, 37], [-102.05, 37],
[-102.05, 41]]), {
'name': 'Colorado',
'fill': 1
}),
ee.Feature(
ee.Geometry.Polygon([[-114.05, 37.0], [-109.05, 37.0], [-109.05, 41.0],
[-111.05, 41.0], [-111.05, 42.0],
[-114.05, 42.0]]), {
'name': 'Utah',
'fill': 2
})
])
# Fill, then outline the polygons into a blank image.
image1 = ee.Image(0).mask(0).toByte()
image2 = image1.paint(fc, 'fill') # Get color from property named 'fill'
image3 = image2.paint(fc, 3, 5) # Outline using color 3, width 5.
Map.addLayer(image3, {
'palette': ['000000', 'FF0000', '00FF00', '0000FF'],
def shapelyToEEFeature(row):
properties = row.drop(["geometry"]).to_dict()
geoJSONfeature = geojson.Feature(geometry=row["geometry"],
properties=properties)
return ee.Feature(geoJSONfeature)
def _reduce_region(image):
stat_dict = image.reduceRegion(ee.Reducer.mean(), region, scale);
return ee.Feature(None, stat_dict)
def makefeature(data):
''' for exporting as CSV to Drive '''
return ee.Feature(None, {'data': data})
def _BuildDataSet(self, sampling_factor, normalize):
estimation_set = self.img_est.sample(region=self.region,
factor=sampling_factor,
seed=self.seed)
prediction_set = self.img_pred.sample(region=self.region,
factor=sampling_factor,
seed=self.seed)
# Add weights
estimation_set_size = ee.Number(estimation_set.size())
prediction_set_size = ee.Number(prediction_set.size())
peso_estimacion = ee.Number(self.beta).divide(estimation_set_size)
peso_prediccion = ee.Number(1 - self.beta).divide(prediction_set_size)
bands_modeling_estimation_input_weight = list(
self.bands_modeling_estimation_input)
bmp = list(self.bands_modeling_prediction)
bmp.append("weight")
bme = list(self.bands_modeling_estimation)
bme.append("weight")
estimation_set = estimation_set.map(
lambda ft: ee.Feature(ft).set("weight", peso_estimacion))
prediction_set = prediction_set.map(
lambda ft: ee.Feature(ft).set("weight", peso_prediccion))
bands_modeling_estimation_input_weight.append("weight")
self.estimation_set = estimation_set
self.prediction_set = prediction_set
if (self.beta > 0) and (self.cc_image < CC_IMAGE_TOP):
self.datos = estimation_set.merge(prediction_set.select(bmp, bme))
else:
logger.info("Using only prediction")
self.datos = prediction_set.select(bmp, bme)
if normalize:
self.datos, self.inputs_mean, self.inputs_std = normalization.ComputeNormalizationFeatureCollection(
self.datos,
self.bands_modeling_estimation_input,
only_center_data=False,
weight="weight")
self.datos, self.outputs_mean, self.outputs_std = normalization.ComputeNormalizationFeatureCollection(
self.datos,
self.bands_modeling_estimation_output,
only_center_data=True,
weight="weight")
self.inputs_mean = self.inputs_mean.toArray(
self.bands_modeling_estimation_input)
self.inputs_std = self.inputs_std.toArray(
self.bands_modeling_estimation_input)
self.outputs_mean = self.outputs_mean.toArray(
self.bands_modeling_estimation_output)
#if "B10" in self.bands_modeling_estimation_output:
# self.datos.select("B10").divide(100)
#if "B11" in self.bands_modeling_estimation_output:
# output_dataset["B11"] /= 100
self.inputs = self.datos.select(bands_modeling_estimation_input_weight)
self.outputs = self.datos.select(self.bands_modeling_estimation_output)
return
def getGeom(image):
return ee.Feature(image.geometry().centroid(), {'foo': 1})
def getMinMaxCoord(feature):
listCoords = ee.Array.cat(feature.geometry().coordinates(), 1)
xCoords = listCoords.slice(1, 0, 1)
yCoords = listCoords.slice(1, 1, 2)
return feature.set({'xMin':xCoords.reduce('min', [0]).get([0,0]),\
'yMin':yCoords.reduce('min', [0]).get([0,0])})
#Map the area getting function over the FeatureCollection.
chunks = chunks.map(getMinMaxCoord)
## for loop over each chunk
chunklist = chunks.toList(chunks.size())
start = time.time()
for ic in range(chunks.size().getInfo()):
ROI = ee.Feature(chunklist.get(ic))
print('\nProcessing SSC_ann_' + write_day + '_chunk' + str(ic + 1) +
'.asc')
#Print the first feature from the collection with the added property.
xMin = ROI.get('xMin').getInfo()
#~ #print('xmin:',xMin)
yMin = ROI.get('yMin').getInfo()
#~ #print('ymin:',yMin)
# write to ascii
xllcorner = xMin
yllcorner = yMin
cellsize = 0.00179 #for 200m (0.00091 for 100m,for 30m use 0.000277778)
nodata = -9999.0
bands = [k[1:] for k in config.desired_bands[sat]]
bands = ''.join(bands)
# name = '_'.join([spacecraft, date, tile, bands, cc])
name = '_'.join([spacecraft, date, tile, cc])
return name
basic.cwa(ee.Initialize)
crs_descriptor = basic.CRS(crs=config.crs, scale=config.scale)
if config.geometry is not None:
fc = ee.FeatureCollection(config.geometry)
config.geometry = ee.Feature(fc.iterate(uni, ee.Feature(fc.first())))
config.geometry = config.geometry.geometry()
if config.geometry_buff is not None:
config.geometry = config.geometry.buffer(config.geometry_buff)
if config.qa:
print 'Exporting QA as band 4'
config.desired_bands = {
i: config.desired_bands[i] + ['BQA']
for i in config.desired_bands
}
tasks = {}
collections = {
'8': 'LANDSAT/LC08/C01/T1_SR',
def sampling(sample):
lat = sample.get('latitude')
lon = sample.get('longitude')
ch4 = sample.get('ch4')
return ee.Feature(ee.Geometry.Point([lon, lat]), {'ch4': ch4})
def export_oneimage(img,location,name,scale,crs):
task = ee.batch.Export.image(img, name, {
'driveFolder':location,
'driveFileNamePrefix':name,
'outputBucket': location,
'outputPrefix': name,
'scale':scale,
'crs':crs
})
task.start()
while task.status()['state'] == 'RUNNING':
print 'Running...'
# Perhaps task.cancel() at some point.
time.sleep(10)
print 'Done.', task.status()
def appendBand(current, previous):
# Rename the band
previous=ee.Image(previous)
current = current.select([0,1,2,3,4,5,6])
# Append it to the result (Note: only return current item on first element/iteration)
accum = ee.Algorithms.If(ee.Algorithms.IsEqual(previous,None), current, previous.addBands(ee.Image(current)))
# Return the accumulation
return accum
fusion_table_dict = {
# 'ET_admin2': ("users/tkenned97/ET_Admin2_simp_2k",'2001-1-1','2016','ADMIN2'),
# 'TZ_admin1': ("users/tkenned97/TZ_Admin1_simp_2k", '2000-2-18','2015','ADMIN1'),
# 'ZM_admin2': ("users/tkenned97/ZM_Admin2_simp_2k",'2000-2-18','2017','ADMIN2'),
# 'NG_admin1': ("users/tkenned97/NG_Admin1_simp_2k",'2000-2-18','2017','ADMIN1'),
# 'MW_admin2': ("users/tkenned97/MW_Admin2_simp_2k",'2000-2-18','2017','ADMIN2'),
# 'KE_admin2': ("users/tkenned97/KE_Admin2_simp_2k",'2000-2-18','2016','ADMIN2')
'SU_admin2': ('users/akkstuff/sudan_admin2', '2013-1-1', '2018', 'ADM2_EN')
}
for country_key,val in fusion_table_dict.items():
fid, start_date, end_date, admin_type = val
region = ee.FeatureCollection(fid)
imgcoll = ee.ImageCollection('MODIS/006/MOD09A1').filterDate(start_date, end_date + '-12-31').sort('system:time_start').filterBounds(ee.Geometry.Rectangle(-22, 38, 60, -38))
img=imgcoll.iterate(appendBand)
img=ee.Image(img)
img_0=ee.Image(ee.Number(0))
img_5000=ee.Image(ee.Number(5000))
img=img.min(img_5000)
img=img.max(img_0)
scale = 500
crs='EPSG:4326'
raw_feature_data = list(region.toList(9999999).getInfo())
feature_names = []
for x in raw_feature_data:
feature_names.append(x['properties'][admin_type])
for name in feature_names:
feature = region.filterMetadata(admin_type, 'equals', name)
if "'" in name:
name = name.replace("'","")
if "/" in name:
name = name.replace("/","")
feature = ee.Feature(feature.first())
export_oneimage(img.clip(feature), 'africa-yield', country_key + "_" + name, scale, crs)
def export(self,
folder_name,
data_type,
coordinate_system='EPSG:4326',
scale=500,
export_limit=None,
min_img_val=None,
max_img_val=None,
major_states_only=True,
check_if_done=False,
download_folder=None):
"""Export an Image Collection from Earth Engine to Google Drive
Parameters
----------
folder_name: str
The name of the folder to export the images to in
Google Drive. If the folder is not there, this process
creates it
data_type: str {'image', 'mask', 'temperature'}
The type of data we are collecting. This tells us which bands to collect.
coordinate_system: str, default='EPSG:4326'
The coordinate system in which to export the data
scale: int, default=500
The pixel resolution, as determined by the output.
https://developers.google.com/earth-engine/scale
export_limit: int or None, default=None
If not none, limits the number of files exported to the value
passed.
min_img_val = int or None:
A minimum value to clip the band values to
max_img_val: int or None
A maximum value to clip the band values to
major_states_only: boolean, default=True
Whether to only use the 11 states responsible for 75 % of national soybean
production, as is done in the paper
check_if_done: boolean, default=False
If true, will check download_folder for any .tif files which have already been
downloaded, and won't export them again. This effectively allows for
checkpointing, and prevents all files from having to be downloaded at once.
download_folder: None or pathlib Path, default=None
Which folder to check for downloaded files, if check_if_done=True. If None, looks
in data/folder_name
"""
if check_if_done:
if download_folder is None:
download_folder = Path('data') / folder_name
already_downloaded = get_tif_files(download_folder)
imgcoll = ee.ImageCollection(self.collection_id) \
.filterBounds(ee.Geometry.Rectangle(-106.5, 50, -64, 23)) \
.filterDate('2002-12-31', '2016-8-4')
datatype_to_func = {
'image': _append_im_band,
'mask': _append_mask_band,
'temperature': _append_temp_band,
}
img = imgcoll.iterate(datatype_to_func[data_type])
img = ee.Image(img)
# "clip" the values of the bands
if min_img_val is not None:
# passing en ee.Number creates a constant image
img_min = ee.Image(ee.Number(min_img_val))
img = img.min(img_min)
if max_img_val is not None:
img_max = ee.Image(ee.Number(max_img_val))
img = img.max(img_max)
# note that the county regions are pulled from Google's Fusion tables. This calls a merge
# of county geometry and census data:
# https://fusiontables.google.com/data?docid=1S4EB6319wWW2sWQDPhDvmSBIVrD3iEmCLYB7nMM#rows:id=1
region = ee.FeatureCollection('TIGER/2018/Counties')
# turn the strings into numbers, see
# https://developers.google.com/earth-engine/datasets/catalog/TIGER_2018_Counties
def state_to_int(feature):
return feature.set('COUNTYFP',
ee.Number.parse(feature.get('COUNTYFP')))
region = region.map(state_to_int)
count = 0
for state_id, county_id in np.unique(
self.locations[['State ANSI', 'County ANSI']].values, axis=0):
if major_states_only:
if int(state_id) not in MAJOR_STATES:
print(f'Skipping state id {int(state_id)}')
continue
fname = '{}_{}'.format(int(state_id), int(county_id))
if check_if_done:
if f'{fname}.tif' in already_downloaded:
print(f'{fname}.tif already downloaded! Skipping')
continue
file_region = region.filterMetadata('COUNTYFP', 'equals',
int(county_id))
file_region = ee.Feature(file_region.first())
processed_img = img.clip(file_region)
file_region = None
while True:
try:
self._export_one_image(processed_img, folder_name, fname,
file_region, scale,
coordinate_system)
except (ee.ee_exception.EEException, ssl.SSLEOFError):
print(
f'Retrying State {int(state_id)}, County {int(county_id)}'
)
time.sleep(10)
continue
break
count += 1
if export_limit:
if count >= export_limit:
print('Reached export limit! Stopping')
break
print(f'Finished Exporting {count} files!')
'collection': l8.filterDate('2018-01-01', '2018-12-31'),
'asFloat': True
})
# Use these bands for prediction.
bands = ['B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B10', 'B11']
# Manually created polygons.
forest1 = ee.Geometry.Rectangle(-63.0187, -9.3958, -62.9793, -9.3443)
forest2 = ee.Geometry.Rectangle(-62.8145, -9.206, -62.7688, -9.1735)
nonForest1 = ee.Geometry.Rectangle(-62.8161, -9.5001, -62.7921, -9.4486)
nonForest2 = ee.Geometry.Rectangle(-62.6788, -9.044, -62.6459, -8.9986)
# Make a FeatureCollection from the hand-made geometries.
polygons = ee.FeatureCollection([
ee.Feature(nonForest1, {'class': 0}),
ee.Feature(nonForest2, {'class': 0}),
ee.Feature(forest1, {'class': 1}),
ee.Feature(forest2, {'class': 1}),
])
# Get the values for all pixels in each polygon in the training.
training = image.sampleRegions(
**{
# Get the sample from the polygons FeatureCollection.
'collection': polygons,
# Keep this list of properties from the polygons.
'properties': ['class'],
# Set the scale to get Landsat pixels in the polygons.
'scale': 30
})
Map
# %%
"""
## Add Earth Engine Python script
"""
# %%
# Add Earth Engine dataset
# Feature buffer example.
# Display the area within 2 kilometers of San Francisco BART stations.
# Instantiate a FeatureCollection of BART locations in Downtown San Francisco
# (points).
stations = [
ee.Feature(ee.Geometry.Point(-122.42, 37.77),
{'name': '16th St. Mission (16TH)'}),
ee.Feature(ee.Geometry.Point(-122.42, 37.75),
{'name': '24th St. Mission (24TH)'}),
ee.Feature(ee.Geometry.Point(-122.41, 37.78),
{'name': 'Civic Center/UN Plaza (CIVC)'})
]
bartStations = ee.FeatureCollection(stations)
# Map a function over the collection to buffer each feature.
def func_dky(f):
return f.buffer(2000, 100)
# Note that the errorMargin is set to 100.
bio = ee.Image('WORLDCLIM/V1/BIO')
srtm = ee.Image('CGIAR/SRTM90_V4')
bio01 = bio.select('bio01')
bio12 = bio.select('bio12')
# downscale env data
bio01 = downscale(bio01).unmask(0)
bio12 = downscale(bio12).unmask(0)
srtm = downscale(srtm).unmask(0)
## merge env data
envdata = adddata(srtm)
#get centroid polygon
tile_point = ee.Feature(ee.Geometry.Point(geom.centroid().coordinates()))
##create kernel
size = args.kernelsize
weights = ee.List.repeat(ee.List.repeat(1, size), size)
kernel = ee.Kernel.fixed(size, size, weights)
##Sample pixels in the ImageCollection at these random points
values = kernelnb(envdata)
task = ee.batch.Export.table.toCloudStorage(
collection=values,
description=name,
folder=None,
fileNamePrefix=args.folder + '/raw/' + str(size) + '/env_data/' + name,
fileFormat='TFRecord',
def _reduce_region(image):
"""Spatial aggregation function for a single image and a polygon feature"""
stat_dict = image.reduceRegion(fun, geometry, 30);
# FEature needs to be rebuilt because the backend doesn't accept to map
# functions that return dictionaries
return ee.Feature(None, stat_dict)
def contructXGrid(j):
j = ee.Number(j)
box = ee.Feature(ee.Geometry.Rectangle(j,i,j.add(gridSize),i.add(gridSize)))
out = ee.Algorithms.If(geom.contains(box.geometry()),box,null)
return ee.Feature(out)
def MultiPointFromQuery(query, geocoder="nominatim", **kwargs):
"""Constructs an ee.Feature describing a point from a query submitted to a geodocer using the geopy package. This returns all pairs of coordinates retrieved by the query.
The properties of the feature collection correspond to the raw properties retrieved by the locations of the query.
Tip
----------
Check more info about constructors in the :ref:`User Guide<Constructors>`.
Parameters
----------
query : str
Address, query or structured query to geocode.
geocoder : str, default = 'nominatim'
Geocoder to use. Please visit https://geopy.readthedocs.io/ for more info.
**kwargs :
Keywords arguments for geolocator.geocode(). The user_agent argument is mandatory (this argument can be set as user_agent = 'my-gee-username' or
user_agent = 'my-gee-app-name'). Please visit https://geopy.readthedocs.io/ for more info.
Returns
-------
ee.FeatureCollection
Feature Collection with point geometries from the specified query.
Examples
--------
>>> import ee, eemont
>>> ee.Authenticate()
>>> ee.Initialize()
>>> ee.FeatureCollection.MultiPointFromQuery('Río Amazonas',user_agent = 'my-gee-eemont-query').getInfo()
{'type': 'FeatureCollection',
'columns': {'boundingbox': 'List<String>',
'class': 'String',
'display_name': 'String',
'importance': 'Float',
'lat': 'String',
'licence': 'String',
'lon': 'String',
'osm_id': 'Integer',
'osm_type': 'String',
'place_id': 'Integer',
'system:index': 'String',
'type': 'String'},
'features': [{'type': 'Feature',
'geometry': {'type': 'Point', 'coordinates': [-57.4801276, -2.3740229]},
'id': '0',
'properties': {'boundingbox': ['-4.4421898',
'0.7065296',
'-73.4501259',
'-49.2759133'],
'class': 'waterway',
'display_name': 'Rio Amazonas, Região Norte, 69100-143, Brasil',
'importance': 0.4,
'lat': '-2.3740229',
'licence': 'Data © OpenStreetMap contributors, ODbL 1.0. https://osm.org/copyright',
'lon': '-57.4801276',
'osm_id': 2295651,
'osm_type': 'relation',
'place_id': 258650987,
'type': 'river'}},
{'type': 'Feature',
'geometry': {'type': 'Point',
'coordinates': [-70.04978704421745, -4.10958645]},
'id': '1',
'properties': {'boundingbox': ['-4.2647706',
'-3.9548576',
'-70.1817875',
'-69.9440055'],
'class': 'natural',
'display_name': 'Río Amazonas, Ramón Castilla, Mariscal Ramón Castilla, Loreto, Perú',
'importance': 0.39999999999999997,
'lat': '-4.10958645',
'licence': 'Data © OpenStreetMap contributors, ODbL 1.0. https://osm.org/copyright',
'lon': '-70.04978704421745',
'osm_id': 8495385,
'osm_type': 'relation',
'place_id': 297654614,
'type': 'water'}},
...]}
"""
locations = _retrieve_location(query, geocoder, False, **kwargs)
features = []
for location in locations:
geometry = ee.Geometry.Point([location.longitude, location.latitude])
feature = ee.Feature(geometry, location.raw)
features.append(feature)
return ee.FeatureCollection(features)
def bmaxOtsu(collection,target_data,region,
smoothing=100,
qualityBand=None,
reductionScale=90,
initThresh=0,
reverse=False,
gridSize=0.1,
bmaxThresh=0.75,
maxBoxes=100,
seed=7):
def constuctGrid(i):
def contructXGrid(j):
j = ee.Number(j)
box = ee.Feature(ee.Geometry.Rectangle(j,i,j.add(gridSize),i.add(gridSize)))
out = ee.Algorithms.If(geom.contains(box.geometry()),box,null)
return ee.Feature(out)
i = ee.Number(i)
out = ee.List.sequence(west,east.subtract(gridSize),gridSize).map(constuctXGrid)
return out
def calcBmax(feature):
segment = target.clip(feature)
initial = segment.lt(initThresh)
p1 = ee.Number(initial.reduceRegion(
reducer= ee.Reducer.mean(),
geometry= feature.geometry(),
bestEffort= True,
scale= reductionScale,
).get(histBand))
p2 = ee.Number(1).subtract(p1)
m = segment.updateMask(initial).rename('m1').addBands(
segment.updateMask(initial.not()).rename('m2')
)
mReduced = m.reduceRegion(
reducer= ee.Reducer.mean(),
geometry= feature.geometry(),
bestEffort= True,
scale= reductionScale,
)
m1 = ee.Number(mReduced.get('m1'))
m2 = ee.Number(mReduced.get('m2'))
m1 = ee.Number(ee.Algorithms.If(m1,m1,globalLow))
m2 = ee.Number(ee.Algorithms.If(m2,m2,globalHigh))
sigmab = p1.multiply(p2.multiply(m1.subtract(m2).pow(2)))
sigmat = ee.Number(segment.reduceRegion(
reducer= ee.Reducer.variance(),
geometry= feature.geometry(),
bestEffort= True,
scale= reductionScale,
).get(histBand))
bmax = sigmab.divide(sigmat)
return feature.set({'bmax':bmax})
tDate = ee.Date(target_date)
targetColl = collection.filterDate(tDate,tDate.advance(1,'day'))
if qualityBand == None:
histBand = ee.String(target.bandNames().get(0))
target = targetColl.mosaic()\
.select(histBand)
else:
histBand = ee.String(qualityBand)
target = targetColl.qualityMosaic(qualityBand)\
.select(histBand)
searchRegion = ee.Feature(ee.List(targeColl.map(geeutilsgetGeom).toList(1)).get(0))
theoretical = target.reduceRegion(
reducer= ee.Reducer.percentile([10,90]),
geometry= searchRegion.geometry(),
bestEffort= True,
scale: 5000
)
globalLow = theoretical.get(histBand.cat('_p10'))
globalHigh = theoretical.get(histBand.cat('_p90'))
geom = searchRegion.geometry()
bounds = geom.bounds()
coords = ee.List(bounds.coordinates().get(0))
gridSize = ee.Number(gridSize)
west = ee.Number(ee.List(coords.get(0)).get(0))
south = ee.Number(ee.List(coords.get(0)).get(1))
east = ee.Number(ee.List(coords.get(2)).get(0))
north = ee.Number(ee.List(coords.get(2)).get(1))
west = west.subtract(west.mod(gridSize))
south = south.subtract(south.mod(gridSize))
east = east.add(gridSize.subtract(east.mod(gridSize)))
north = north.add(gridSize.subtract(north.mod(gridSize)))
grid = ee.FeatureCollection(
ee.List.sequence(south,north.subtract(gridSize),gridSize).map(constuctGrid).flatten()
)
bmaxes = grid.map(calcBmax).filter(ee.Filter.gt('bmax',bmaxThresh)).randomColumn('random',seed)
nBoxes = ee.Number(bmax.size())
randomThresh = maxBoxes.divide(nBoxes)
selection = bmaxes.filter(ee.Filter.lt('random',randomThresh))
histogram = histogram_image.reduceRegion(ee.Reducer.histogram(255, 2)\
.combine('mean', None, True)\
.combine('variance', None,True),selection,reductionScale,bestEffort=True,
tileScale=16)
threshold = geeutils.otsu_function(histogram.get(histBand.cat('_histogram')))
water = target.gt(threshold).clip(geeutils.LAND.geometry())
return water.rename('water')
[180, 90], [-180, 90]],
proj=ee.Projection('EPSG:4326'),
geodesic=True)
# In[ ]:
# In[22]:
geometry3 = ee.Geometry.Polygon(coords=[[-170.0, -80.0], [170, -80.0],
[170, 80], [-170, 80]],
proj=ee.Projection('EPSG:4326'),
geodesic=True)
# In[23]:
feature = ee.Feature(geometry3, {})
# In[24]:
geoJSON = feature.geometry().getInfo()
# In[25]:
print(geoJSON)
# In[18]:
geoJSON["geodesic"] = False
# In[19]:
def spatialSelect(feature):
test = ee.Algorithms.If(geom.contains(feature.geometry()), feature,
None)
return ee.Feature(test)
def noGeometryEEFeature(row):
properties = row.to_dict()
return ee.Feature(None, properties)
def get_region(feature):
coll = LS_COLL.filterBounds(ee.Feature(feature).geometry())
ncoll = coll.size().getInfo()
# feature to be extracted
feat = ee.Algorithms.If(
ee.Number(BUFFER_DIST).gt(0),
ee.Feature(feature).buffer(BUFFER_DIST).bounds(), ee.Feature(feature))
feat_dict = feat.getInfo()
feat_props = feat_dict['properties']
pt_list = list()
if ncoll > 0:
# list of properties of each image in the collection as dictionary
coll_dicts = get_coll_dict(coll).getInfo()
# extract pixel values from the collection
# the output is a list or lists with the first row as column names
temp_list = coll.getRegion(ee.Feature(feat).geometry(),
SCALE).getInfo()
n = len(temp_list)
elem_names = temp_list[0]
id_column = elem_names.index('id')
for j in range(1, n):
pt_dict = dict()
for k in range(0, len(elem_names)):
pt_dict[elem_names[k]] = temp_list[j][k]
id = temp_list[j][id_column]
scene_prop_list = list(coll_dict for coll_dict in coll_dicts
if coll_dict['id'] == id)
scene_prop = scene_prop_list[0]
for prop in scene_properties:
pt_dict[prop] = scene_prop[prop]
for prop in feat_properties:
pt_dict[prop] = feat_props[prop]
pt_list.append(pt_dict)
else:
pt_dict = dict()
pt_dict['id'] = NULL_VALUE
pt_dict['time'] = NULL_VALUE
for prop in feat_properties:
pt_dict[prop] = feat_props[prop]
for prop in scene_properties:
pt_dict[prop] = NULL_VALUE
for band in bands:
pt_dict[band] = NULL_VALUE
pt_list.append(pt_dict)
return pt_list
import ee
import geemap
# Create a map centered at (lat, lon).
Map = geemap.Map(center=[40, -100], zoom=4)
# Make a list of Features.
features = [
ee.Feature(ee.Geometry.Rectangle(30.01, 59.80, 30.59, 60.15), {'name': 'Voronoi'}),
ee.Feature(ee.Geometry.Point(-73.96, 40.781), {'name': 'Thiessen'}),
ee.Feature(ee.Geometry.Point(6.4806, 50.8012), {'name': 'Dirichlet'})
]
# Create a FeatureCollection from the list and print it.
fromList = ee.FeatureCollection(features)
print(fromList.getInfo())
# Create a FeatureCollection from a single geometry and print it.
fromGeom = ee.FeatureCollection(ee.Geometry.Point(16.37, 48.225))
print(fromGeom.getInfo())
# Display the map.
Map
def reclass_list_to_fc(dictionary):
return ee.Feature(None, dictionary)
def over_list(p):
p = ee.List(p)
point = ee.Geometry.Point(p).buffer(buffer).bounds()
return ee.Feature(point)
def dict_to_feature(dictje):
return ee.Feature(None,dictje)
## Add Earth Engine Python script
"""
# %%
# Add Earth Engine dataset
# This function creates a new property that is the sum of two existing properties.
def addField(feature):
sum = ee.Number(feature.get('property1')).add(feature.get('property2'))
return feature.set({'sum': sum})
# Create a FeatureCollection from a list of Features.
features = ee.FeatureCollection([
ee.Feature(ee.Geometry.Point(-122.4536, 37.7403), {
'property1': 100,
'property2': 100
}),
ee.Feature(ee.Geometry.Point(-118.2294, 34.039), {
'property1': 200,
'property2': 300
}),
])
# Map the function over the collection.
featureCollection = features.map(addField)
# Print the entire FeatureCollection.
print(featureCollection.getInfo())
# Print a selected property of one Feature.
print(featureCollection.first().get('sum').getInfo())
def ee_get_s2_data(AOIs, req_params, qi_threshold=0, qi_filter=s2_filter1):
"""Get S2 data (level L2A, bottom of atmosphere data) from GEE.
Parameters
----------
AOIs : list or AOI instance
List of AOI instances or single AOI instance. If multiple AOIs
proviveded the computation in GEE server is parallellized.
If too many areas with long time range is provided, user might
hit GEE memory limits. Then you should call this function
sequentally to all AOIs. AOIs should have qi attribute computed first.
req_params : S2RequestParams instance
S2RequestParams instance with request details.
qi_threshold : float
Threshold value to filter images based on used qi filter.
qi filter holds labels of classes whose percentages within the AOI
is summed. If the sum is larger then the qi_threhold, data will not be
retrieved for that date/image. The default is 1, meaning all data is
retrieved.
qi_filter : list
List of strings with class labels (of unwanted classes) used to compute qi value,
see qi_threhold. The default is s2_filter1 = ['NODATA',
'SATURATED_DEFECTIVE',
'CLOUD_SHADOW',
'UNCLASSIFIED',
'CLOUD_MEDIUM_PROBA',
'CLOUD_HIGH_PROBA',
'THIN_CIRRUS',
'SNOW_ICE'].
Returns
-------
Nothing:
Computes data attribute for the given AOI instances.
"""
datestart = req_params.datestart
dateend = req_params.dateend
bands = req_params.bands
# if single AOI instance, make a list
if isinstance(AOIs, AOI):
AOIs = list([AOIs])
features = []
for a in AOIs:
filtered_qi = filter_s2_qi_dataframe(a.qi, qi_threshold, qi_filter)
if len(filtered_qi) == 0:
print("No observations to retrieve for area %s" % a.name)
continue
if a.tile is None:
min_tile = min(filtered_qi["tileid"].values)
filtered_qi = filtered_qi[filtered_qi["tileid"] == min_tile]
a.tile = min_tile
else:
filtered_qi = filtered_qi[filtered_qi["tileid"] == a.tile]
full_assetids = "COPERNICUS/S2_SR/" + filtered_qi["assetid"]
image_list = [ee.Image(asset_id) for asset_id in full_assetids]
crs = filtered_qi["projection"].values[0]["crs"]
if a.geometry_type == "Polygon":
feature = ee.Feature(
ee.Geometry.Polygon(a.coordinate_list),
{
"name": a.name,
"image_list": image_list
},
)
else:
feature = ee.Feature(
ee.Geometry.Point(a.coordinate_list[0][0],
a.coordinate_list[0][1]),
{
"name": a.name,
"image_list": image_list
},
)
features.append(feature)
if len(features) == 0:
print("No data to be retrieved!")
return None
feature_collection = ee.FeatureCollection(features)
def ee_get_s2_data_feature(feature):
geom = feature.geometry(0.01, crs)
image_collection = (
ee.ImageCollection.fromImages(
feature.get("image_list")).filterBounds(geom).filterDate(
datestart, dateend)
# .select(bands + ["SCL"])
)
image_collection = image_collection.map(calc_ndvi(
nir="B8A", red="B4")).select(bands + ["SCL", "NDVI"])
def ee_get_s2_data_image(img):
# img = img.clip(geom)
productid = img.get("PRODUCT_ID")
assetid = img.id()
tileid = img.get("MGRS_TILE")
system_index = img.get("system:index")
proj = img.select(bands[0]).projection()
sun_azimuth = img.get("MEAN_SOLAR_AZIMUTH_ANGLE")
sun_zenith = img.get("MEAN_SOLAR_ZENITH_ANGLE")
view_azimuth = (ee.Array([
img.get("MEAN_INCIDENCE_AZIMUTH_ANGLE_%s" % b) for b in bands
]).reduce(ee.Reducer.mean(), [0]).get([0]))
view_zenith = (ee.Array([
img.get("MEAN_INCIDENCE_ZENITH_ANGLE_%s" % b) for b in bands
]).reduce(ee.Reducer.mean(), [0]).get([0]))
img = img.resample("bilinear").reproject(crs=crs,
scale=req_params.scale)
# get the lat lon and add the ndvi
image_grid = ee.Image.pixelCoordinates(
ee.Projection(crs)).addBands(
[img.select(b) for b in bands + ["SCL", "NDVI"]])
# apply reducer to list
image_grid = image_grid.reduceRegion(
reducer=ee.Reducer.toList(),
geometry=geom,
maxPixels=1e8,
scale=req_params.scale,
)
# get data into arrays
x_coords = ee.Array(image_grid.get("x"))
y_coords = ee.Array(image_grid.get("y"))
band_data = {b: ee.Array(image_grid.get("%s" % b)) for b in bands}
scl_data = ee.Array(image_grid.get("SCL"))
ndvi_data = ee.Array(image_grid.get("NDVI"))
# perform LAI et al. computation possibly here!
tmpfeature = (ee.Feature(ee.Geometry.Point([0, 0])).set(
"productid", productid).set("system_index", system_index).set(
"assetid",
assetid).set("tileid", tileid).set("projection", proj).set(
"sun_zenith",
sun_zenith).set("sun_azimuth", sun_azimuth).set(
"view_zenith",
view_zenith).set("view_azimuth", view_azimuth).set(
"x_coords",
x_coords).set("y_coords", y_coords).set(
"SCL",
scl_data).set("NDVI",
ndvi_data).set(band_data))
return tmpfeature
s2_data_feature = image_collection.map(ee_get_s2_data_image)
return (feature.set(
"productid", s2_data_feature.aggregate_array("productid")).set(
"system_index",
s2_data_feature.aggregate_array("system_index")).set(
"assetid", s2_data_feature.aggregate_array("assetid")).set(
"tileid",
s2_data_feature.aggregate_array("tileid")).set(
"projection",
s2_data_feature.aggregate_array("projection")).set(
"sun_zenith",
s2_data_feature.aggregate_array("sun_zenith")).
set("sun_azimuth",
s2_data_feature.aggregate_array("sun_azimuth")).set(
"view_zenith",
s2_data_feature.aggregate_array("view_zenith")).set(
"view_azimuth",
s2_data_feature.aggregate_array("view_azimuth")).
set("x_coords",
s2_data_feature.aggregate_array("x_coords")).set(
"y_coords",
s2_data_feature.aggregate_array("y_coords")).set(
"SCL", s2_data_feature.aggregate_array("SCL")).set(
"NDVI",
s2_data_feature.aggregate_array("NDVI")).set({
b: s2_data_feature.aggregate_array(b)
for b in bands
}))
s2_data_feature_collection = feature_collection.map(
ee_get_s2_data_feature).getInfo()
s2_data = s2_feature_collection_to_dataframes(s2_data_feature_collection)
for a in AOIs:
name = a.name
a.data = s2_data[name]
