def findCorners(img):
footprint = ee.Geometry(img.get('system:footprint'))
bounds = ee.List(footprint.bounds().coordinates().get(0))
coords = footprint.coordinates()
def wrap_xs(item):
return x(item)
xs = coords.map(wrap_xs)
def wrap_ys(item):
return y(item)
ys = coords.map(wrap_ys)
def findCorner(targetValue, values):
def wrap_diff(value):
return ee.Number(value).subtract(targetValue).abs()
diff = values.map(wrap_diff)
minValue = diff.reduce(ee.Reducer.min())
idx = diff.indexOf(minValue)
return ee.Number(coords.get(idx))
lowerLeft = findCorner(x(bounds.get(0)), xs)
lowerRight = findCorner(y(bounds.get(1)), ys)
upperRight = findCorner(x(bounds.get(2)), xs)
upperLeft = findCorner(y(bounds.get(3)), ys)
return {
'upperLeft': upperLeft,
'upperRight': upperRight,
'lowerRight': lowerRight,
'lowerLeft': lowerLeft
}
def radcal(current,prev):
''' iterator function for orthogonal regression and interactive radiometric normalization '''
k = ee.Number(current)
prev = ee.Dictionary(prev)
# image is concatenation of reference and target
image = ee.Image(prev.get('image'))
ncmask = ee.Image(prev.get('ncmask'))
nbands = ee.Number(prev.get('nbands'))
rect = ee.Geometry(prev.get('rect'))
coeffs = ee.List(prev.get('coeffs'))
normalized = ee.Image(prev.get('normalized'))
scale = image.select(0).projection().nominalScale()
# orthoregress reference onto target
image1 = image.clip(rect).select(k.add(nbands),k).updateMask(ncmask).rename(['x','y'])
means = image1.reduceRegion(ee.Reducer.mean(), scale=scale, maxPixels=1e9) \
.toArray()\
.project([0])
Xm = means.get([0])
Ym = means.get([1])
S = ee.Array(image1.toArray() \
.reduceRegion(ee.Reducer.covariance(), geometry=rect, scale=scale, maxPixels=1e9) \
.get('array'))
# Pearson correlation
R = S.get([0,1]).divide(S.get([0,0]).multiply(S.get([1,1])).sqrt())
eivs = S.eigen()
e1 = eivs.get([0,1])
e2 = eivs.get([0,2])
# slope and intercept
b = e2.divide(e1)
a = Ym.subtract(b.multiply(Xm))
coeffs = coeffs.add(ee.List([b,a,R]))
# normalize kth band in target
normalized = normalized.addBands(image.select(k.add(nbands)).multiply(b).add(a))
return ee.Dictionary({'image':image,'ncmask':ncmask,'nbands':nbands,'rect':rect,'coeffs':coeffs,'normalized':normalized})
def api_get_rivers():
bounds = ee.Geometry(request.json['bounds'])
selection = basins.filterBounds(bounds)
# for every selection, get and merge upstream catchments
upstream_catchments = ee.FeatureCollection(selection.map(get_upstream_catchments)).flatten().distinct('HYBAS_ID')
# get ids
upstream_catchment_ids = ee.List(upstream_catchments.aggregate_array('HYBAS_ID')).map(number_to_string)
# query rivers
upstream_rivers = rivers \
.filter(ee.Filter.inList('HYBAS_ID', upstream_catchment_ids)) \
.select(['ARCID', 'UP_CELLS', 'HYBAS_ID'])
# filter upstream branches
if 'filter_upstream_gt' in request.json:
filter_upstream = int(request.json['filter_upstream_gt'])
print('Filtering upstream branches, limiting by {0} number of cells'.format(filter_upstream))
upstream_rivers = upstream_rivers.filter(ee.Filter.gte('UP_CELLS', filter_upstream))
# create response
url = upstream_rivers.getDownloadURL('json')
data = {'url': url}
return Response(json.dumps(data), status=200, mimetype='application/json')
def display_composite_ipyleaflet(self, zoom=10):
image = self.image.clip(ee.Geometry(self.polygon))
mapid = image.getMapId()
tiles_url = self.ee_tiles.format(**mapid)
tile_layer = ipyl.TileLayer(url=tiles_url,
layers='collection',
format='image/png',
name=self.collection,
opacity=1)
polygon = ipyl.Polygon(locations=self.locations,
color=self.color,
fill_opacity=0.,
name='AoI')
m = ipyl.Map(center=tuple(self.centroid), zoom=zoom)
m.add_layer(tile_layer)
m.add_layer(polygon)
control = ipyl.LayersControl(position='topright')
m.add_control(control)
m.add_control(ipyl.FullScreenControl())
return m
def sfg_as_ee_py(x, sfc_class, opt_proj, opt_geodesic, opt_evenOdd):
x = re.sub(r':null', ':None', x)
# sfg to ee
if sfc_class in ["sfc_MULTIPOLYGON", "sfc_POLYGON"]:
return ee.Geometry(geo_json=eval(x),
opt_proj=opt_proj,
opt_geodesic=opt_geodesic,
opt_evenOdd=opt_evenOdd)
elif sfc_class in ["sfc_MULTILINESTRING", "sfc_LINESTRING"]:
return ee.Geometry(geo_json=eval(x),
opt_proj=opt_proj,
opt_geodesic=opt_geodesic)
elif sfc_class in ["sfc_MULTIPOINT", "sfc_POINT"]:
return ee.Geometry(geo_json=eval(x), opt_proj=opt_proj)
else:
return False
def get_sea_surface_height_time_series():
"""generate bathymetry image for a certain timespan (begin_date, end_date) and a dataset {jetski | vaklodingen | kustlidar}"""
r = request.get_json()
# get info from the request
dataset = r['region']
scale = 1000.0
if 'scale' in r:
scale = float(r['scale'])
region = ee.Geometry(dataset)
images = ee.ImageCollection("users/fbaart/ssh_grids_v1609")
def get_time_value(i):
t = i.date().millis()
mean = i.reduceRegion(ee.Reducer.mean(), region, scale)
i = i.set('t', t).set('v', mean.get('b1'))
return i
images = images.map(get_time_value)
times = images.aggregate_array('t').getInfo()
values = images.aggregate_array('v').getInfo()
time_series = {"times": times, "values": values}
return Response(json.dumps(time_series), status=200,
mimetype='application/json')
def testValid_GeometryCollection(self):
"""Verifies GeometryCollection constructor behavior with valid arguments."""
geometry = ee.Geometry({
'type':
'GeometryCollection',
'geometries': [{
'type': 'Polygon',
'coordinates': [[[-1, -1], [0, 1], [1, -1]]],
'geodesic': True,
'evenOdd': True
}, {
'type': 'Point',
'coordinates': [0, 0]
}, {
'type':
'GeometryCollection',
'geometries': [{
'type': 'Point',
'coordinates': [1, 2]
}, {
'type': 'Point',
'coordinates': [2, 1]
}]
}],
'coordinates': []
})
self.assertTrue(isinstance(geometry, ee.Geometry))
def testPrepareForExport_withRegionDimensionsCrsAndTransform(self):
with apitestcase.UsingCloudApi():
polygon = ee.Geometry.Polygon(9, 8, 7, 6, 3, 2)
image, params = self.base_image.prepare_for_export({
'crs':
'ABCD',
'crs_transform':
'[1,2,3,4,5,6]',
'dimensions': [3, 2],
'region':
polygon.toGeoJSONString(),
'something':
'else'
})
expected_polygon = ee.Geometry(polygon.toGeoJSON(),
opt_geodesic=False)
projected = self.base_image.reproject(
crs='ABCD', crsTransform=[1, 2, 3, 4, 5, 6])
self.assertImageEqual(
projected.clipToBoundsAndScale(width=3,
height=2,
geometry=expected_polygon),
image)
self.assertEqual({'something': 'else'}, params)
def extract_fp(image, sent=0):
""" :param sent:
:returns an ee.Geometry
"""
fp = ee.Image(image).get("system:footprint")
coordo = ee.Geometry(fp).coordinates()
return ee.Geometry.Polygon(coordo)
def testThumb_withDimensionsRegionCrs(self):
"""Verifies Thumbnail ID and URL generation in the Cloud API."""
with apitestcase.UsingCloudApi(
cloud_api_resource=self.cloud_api_resource):
url = self.base_image.getThumbURL({
'dimensions': [13, 42],
'region': self.geo_json,
'crs': 'EPSG:4326',
})
self.assertEqual('/v1alpha/thumbName:getPixels', url)
_, kwargs = self.cloud_api_resource.projects().thumbnails(
).create.call_args
self.assertEqual(
kwargs['body']['expression'],
serializer.encode(self.base_image.setDefaultProjection(
crs='EPSG:4326',
crsTransform=[1, 0, 0, 0, -1, 0]).clipToBoundsAndScale(
geometry=ee.Geometry(self.geo_json,
opt_geodesic=False),
width=13,
height=42),
for_cloud_api=True))
self.assertEqual(kwargs['parent'], 'projects/earthengine-legacy')
def findCorners(self):
footprint = ee.Geometry(self.image.get('system:footprint'))
bounds = ee.List(footprint.bounds().coordinates().get(0))
coords = footprint.coordinates()
xs = coords.map(lambda item: self.x(item))
ys = coords.map(lambda item: self.y(item))
def findCorner(targetValue, values):
diff = values.map(
lambda value: ee.Number(value).subtract(targetValue).abs())
minValue = diff.reduce(ee.Reducer.min())
idx = diff.indexOf(minValue)
return coords.get(idx)
lowerLeft = findCorner(self.x(bounds.get(0)), xs)
lowerRight = findCorner(self.y(bounds.get(1)), ys)
upperRight = findCorner(self.x(bounds.get(2)), xs)
upperLeft = findCorner(self.y(bounds.get(3)), ys)
return {
'upperLeft': upperLeft,
'upperRight': upperRight,
'lowerRight': lowerRight,
'lowerLeft': lowerLeft
}
def apply_SCSccorr(band):
method = 'SCSc'
out = ee.Image(1).addBands(img_plus_ic_mask2.select('IC', band)).reduceRegion(reducer= ee.Reducer.linearRegression(2,1), \
geometry= ee.Geometry(img.geometry().buffer(-5000)), \
scale= self.env.terrainScale, \
bestEffort =True,
maxPixels=1e10)
#out_a = ee.Number(out.get('scale'));
#out_b = ee.Number(out.get('offset'));
#out_c = ee.Number(out.get('offset')).divide(ee.Number(out.get('scale')));
fit = out.combine({"coefficients": ee.Array([[1], [1]])},
False)
#Get the coefficients as a nested list,
#cast it to an array, and get just the selected column
out_a = (ee.Array(fit.get('coefficients')).get([0, 0]))
out_b = (ee.Array(fit.get('coefficients')).get([1, 0]))
out_c = out_a.divide(out_b)
# apply the SCSc correction
SCSc_output = img_plus_ic_mask2.expression(
"((image * (cosB * cosZ + cvalue)) / (ic + cvalue))", {
'image': img_plus_ic_mask2.select([band]),
'ic': img_plus_ic_mask2.select('IC'),
'cosB': img_plus_ic_mask2.select('cosS'),
'cosZ': img_plus_ic_mask2.select('cosZ'),
'cvalue': out_c
})
return ee.Image(SCSc_output)
def get_water_mask_raw():
"""
Extracts water mask from raw satellite data.
Code Editor URL:
https://code.earthengine.google.com/4dd0b18aa43bfabf4845753dc7c6ba5c
"""
j = request.json
use_url = j['use_url']
region = ee.Geometry(j['region'])
bands = ['B3', 'B8'] # green, nir
start = j['start']
stop = j['stop']
percentile = j['percentile'] if 'percentile' in j else 10
ndwi_threshold = j['ndwi_threshold'] if 'ndwi_threshold' in j else 0
scale = j['scale'] if 'scale' in j else 10
# filter Sentinel-2 images
images = ee.ImageCollection('COPERNICUS/S2') \
.select(bands) \
.filterBounds(region) \
.filterDate(start, stop) \
.map(lambda i: i.resample('bilinear'))
# remove noise (clouds, shadows) using percentile composite
image = images \
.reduce(ee.Reducer.percentile([percentile])) \
\
# computer water mask using NDWI
water_mask = image \
.normalizedDifference() \
.gt(ndwi_threshold)
# vectorize
water_mask_vector = water_mask \
.mask(water_mask) \
.reduceToVectors(**{
"geometry": region,
"scale": scale / 2
})
water_mask_vector = water_mask_vector.toList(10000) \
.map(lambda o: ee.Feature(o).simplify(scale))
water_mask_vector = ee.FeatureCollection(water_mask_vector)
# create response
if use_url:
url = water_mask_vector.getDownloadURL('json')
data = {'url': url}
else:
data = water_mask_vector.getInfo()
return Response(json.dumps(data), status=200, mimetype='application/json')
def radcalbatch(current, prev):
''' Batch radiometric normalization '''
prev = ee.Dictionary(prev)
target = ee.Image(current)
reference = ee.Image(prev.get('reference'))
normalizedimages = ee.List(prev.get('normalizedimages'))
niter = ee.Number(prev.get('niter'))
rect = ee.Geometry(prev.get('rect'))
log = ee.List(prev.get('log'))
nbands = reference.bandNames().length()
# clip the images to subset and run iMAD
inputlist = ee.List.sequence(1, niter)
image = reference.addBands(target)
first = ee.Dictionary({
'done': ee.Number(0),
'image': image.clip(rect),
'allrhos': [ee.List.sequence(1, nbands)],
'chi2': ee.Image.constant(0),
'MAD': ee.Image.constant(0)
})
result = ee.Dictionary(inputlist.iterate(imad, first))
chi2 = ee.Image(result.get('chi2')).rename(['chi2'])
allrhos = ee.List(result.get('allrhos'))
# run radcal
ncmask = chi2cdf(chi2, nbands).lt(ee.Image.constant(0.05))
inputlist1 = ee.List.sequence(0, nbands.subtract(1))
first = ee.Dictionary({
'image': image,
'ncmask': ncmask,
'nbands': nbands,
'rect': rect,
'coeffs': ee.List([]),
'normalized': ee.Image()
})
result = ee.Dictionary(inputlist1.iterate(radcal, first))
coeffs = ee.List(result.get('coeffs'))
# update log
ninvar = ee.String(
ncmask.reduceRegion(ee.Reducer.sum().unweighted(),
maxPixels=1e9).toArray().project([0]))
log = log.add(target.get('system:id'))
iters = allrhos.length().subtract(1)
log = log.add(
ee.Algorithms.If(iters.eq(niter),
['No convergence, iterations:', iters],
['Iterations:', iters]))
log = log.add(['Invariant pixels:', ninvar])
log = ee.List(coeffs.iterate(addcoeffs, log))
# first band in normalized result is empty
sel = ee.List.sequence(1, nbands)
normalized = ee.Image(result.get('normalized')).select(sel)
normalizedimages = normalizedimages.add(normalized)
return ee.Dictionary({
'reference': reference,
'rect': rect,
'niter': niter,
'log': log,
'normalizedimages': normalizedimages
})
def generate_points(ring):
distances = ring.get('distances')
segments = ring.geometry().cutLines(distances).geometries()
segment_points = \
segments.map(lambda g: ee.Feature(ee.Geometry(g).centroid(1)))
return ee.FeatureCollection(segment_points)
def calculate_clicked_bbox(geojson):
click_geom = ee.Geometry(geojson['geometry'])
# Asset with projection info per zone
all_zones = ee.FeatureCollection("users/parevalo_bu/measures/measures_zones_crs")
zone = all_zones.filterBounds(click_geom).first()
target_proj = zone.get("CRS")
bbox = click_geom.buffer(45, 0, target_proj).bounds(0.01, target_proj)
return bbox
def getGeometryImage(image):
""" Return the image geometry build from border
Arguments:
:param image: GEE Image
:return: ee.Geometry.Polygon
"""
return ee.Geometry.Polygon(
ee.Geometry(image.get('system:footprint')).coordinates())
def illuminationCorrection(self, img):
props = img.toDictionary()
st = img.get('system:time_start')
img_plus_ic = img
mask2 = img_plus_ic.select('slope').gte(5)\
.And (img_plus_ic.select('IC').gte(0))\
.And (img_plus_ic.select('nir').gt(-0.1))
img_plus_ic_mask2 = ee.Image(img_plus_ic.updateMask(mask2))
# Specify Bands to topographically correct var
bandList = ['blue', 'green', 'red', 'nir', 'swir1', 'swir2']
compositeBands = img.bandNames()
nonCorrectBands = img.select(compositeBands.removeAll(bandList))
geom = ee.Geometry(img.get('system:footprint')).bounds().buffer(10000)
def apply_SCSccorr(band):
method = 'SCSc'
out = img_plus_ic_mask2.select('IC', band).reduceRegion({
'reducer':
ee.Reducer.linearFit(),
'geometry':
geom,
'scale':
self.envs.terrainScale,
'maxPixels':
1e10
})
if (not out):
return img_plus_ic_mask2.select(band)
else:
out_a = ee.Number(out.get('scale'))
out_b = ee.Number(out.get('offset'))
out_c = out_b.divide(out_a)
# Apply the SCSc correction var
SCSc_output = img_plus_ic_mask2.expression(
"((image * (cosB * cosZ + cvalue)) / (ic + cvalue))", {
'image': img_plus_ic_mask2.select(band),
'ic': img_plus_ic_mask2.select('IC'),
'cosB': img_plus_ic_mask2.select('cosS'),
'cosZ': img_plus_ic_mask2.select('cosZ'),
'cvalue': out_c
})
return SCSc_output
img_SCSccorr = ee.Image(bandList.map(apply_SCSccorr)) \
.addBands(img_plus_ic.select('IC'))
bandList_IC = ee.List([bandList, 'IC']).flatten()
img_SCSccorr = img_SCSccorr.unmask(
img_plus_ic.select(bandList_IC)).select(bandList)
return img_SCSccorr.addBands(nonCorrectBands)\
.setMulti(props)\
.set('system:time_start', st)
def testConstructors(self):
"""Verifies that constructors understand valid parameters."""
point = ee.Geometry.Point(1, 2)
from_geometry = ee.Feature(point)
self.assertEquals(ee.ApiFunction('Feature'), from_geometry.func)
self.assertEquals({
'geometry': point,
'metadata': None
}, from_geometry.args)
from_null_geometry = ee.Feature(None, {'x': 2})
self.assertEquals(ee.ApiFunction('Feature'), from_null_geometry.func)
self.assertEquals({
'geometry': None,
'metadata': {
'x': 2
}
}, from_null_geometry.args)
computed_geometry = ee.Geometry(
ee.ComputedObject(ee.Function(), {'a': 1}))
computed_properties = ee.ComputedObject(ee.Function(), {'b': 2})
from_computed_one = ee.Feature(computed_geometry)
from_computed_both = ee.Feature(computed_geometry, computed_properties)
self.assertEquals(ee.ApiFunction('Feature'), from_computed_one.func)
self.assertEquals({
'geometry': computed_geometry,
'metadata': None
}, from_computed_one.args)
self.assertEquals(ee.ApiFunction('Feature'), from_computed_both.func)
self.assertEquals(
{
'geometry': computed_geometry,
'metadata': computed_properties
}, from_computed_both.args)
from_variable = ee.Feature(ee.CustomFunction.variable(None, 'foo'))
self.assertTrue(isinstance(from_variable, ee.Feature))
self.assertEquals({
'type': 'ArgumentRef',
'value': 'foo'
}, from_variable.encode(None))
from_geo_json_feature = ee.Feature({
'type': 'Feature',
'id': 'bar',
'geometry': point.toGeoJSON(),
'properties': {
'foo': 42
}
})
self.assertEquals(ee.ApiFunction('Feature'),
from_geo_json_feature.func)
self.assertEquals(point, from_geo_json_feature.args['geometry'])
self.assertEquals({
'foo': 42,
'system:index': 'bar'
}, from_geo_json_feature.args['metadata'])
def pixelArea(self, img):
geom = ee.Geometry(img.get('system:footprint')).bounds()
area = img.select(['B4']).gt(0).reduceRegion(reducer= ee.Reducer.sum(),\
geometry= geom,\
scale= 1000,\
maxPixels=10000000)
return img.set("pixelArea", area.get("B4"))
def cloud_score(i):
score = i.select(quality_band)
score = score.reduceRegion(reducer=ee.Reducer.percentile(
[score_percentile]),
geometry=ee.Geometry(g),
scale=scale,
tileScale=4).values().get(0)
return i.set('quality_score', score)
def greenness_trend(year_start, year_end, geojson, lang, gc_client, metadata):
start_date = dt.datetime(year_start, 1, 1)
end_date = dt.datetime(year_end, 12, 31)
point = ee.Geometry(geojson)
region = point.buffer(BOX_SIDE / 2).bounds()
ndvi = []
for y in range(year_start, year_end + 1):
ndvi.append(OLI_SR_COLL.filterDate('{}-01-1'.format(y), '{}-12-31'.format(y)) \
.map(maskL8sr) \
.map(calculate_ndvi) \
.mean() \
.addBands(ee.Image(y).float()) \
.rename(['ndvi','year']))
ndvi_coll = ee.ImageCollection(ndvi)
# Compute linear trend function to predict ndvi based on year (ndvi trend)
lf_trend = ndvi_coll.select(['year', 'ndvi']).reduce(ee.Reducer.linearFit())
ndvi_trnd = (lf_trend.select('scale').divide(ndvi[0].select("ndvi"))).multiply(100)
# Define visualization parameter for ndvi trend and apply them
p_ndvi_trnd = {'min': -10, 'max': 10, 'palette':['#9b2779','#ffffe0','#006500']}
map_trnd = ndvi_trnd.visualize(**p_ndvi_trnd)
map_trnd_mosaic = ee.ImageCollection.fromImages([map_trnd, ee.Image() \
.int() \
.paint(point.buffer(BOX_SIDE / 75), 1) \
.visualize(**{'palette': ['black'], 'opacity': 1})]) \
.mosaic()
# Reproject ndvi mean image so it can retrieve data from every latitude
# without deforming the aoi bounding box
map_trnd_mosaic = map_trnd_mosaic.reproject(scale=30, crs='EPSG:3857')
# create thumbnail and retrieve it by url
trnd_url = map_trnd_mosaic.getThumbUrl({'region': region.getInfo(), 'dimensions': 256})
trnd_name = 'ndvi_trnd.png'
request.urlretrieve(trnd_url, trnd_name)
# read image and pass it to a 2-d numpy array
trnd_frame = Image.open(trnd_name)
ndvi_arr_trnd = np.array(trnd_frame)
legend = Image.open(os.path.join(pathlib.Path(__file__).parent.absolute(),
'ndvi_trd_{}.png'.format(lang.lower())))
title = metadata['greenness_trend']['title'][lang] + ' ({} - {})'.format(year_start, year_end)
f = plot_image_to_file(ndvi_arr_trnd, title, legend)
h = get_hash(f)
url = Url(upload_to_google_cloud(gc_client, f), h)
about = metadata['greenness_trend']['about'][lang].format(YEAR_START=start_date.strftime('%Y/%m/%d'),
YEAR_END=end_date.strftime('%Y/%m/%d'))
out = ImageryPNG(name='greenness_trend',
lang=lang,
title=title,
date=[start_date, end_date],
about=about,
url=url)
schema = ImageryPNGSchema()
return {'greenness_trend' : schema.dump(out)}
def getTopo(self, image):
dem = ee.Image(self.envs.demID)
dem = dem.unmask(0)
geom = ee.Geometry(image.get('system:footprint')).bounds()
slp_rad = ee.Terrain.slope(dem).clip(geom)
slope = slp_rad.reduceRegion({'reducer': ee.Reducer.percentile([80]),\
'geometry': geom,\
'scale': 100})
return image.set('slope', slope.get('slope'))
def fromShapefile(filename, start=None, end=None):
""" Convert an ESRI file (.shp and .dbf must be present) to a
ee.FeatureCollection
At the moment only works for shapes with less than 1000 records and doesn't
handle complex shapes.
:param filename: the name of the filename. If the shape is not in the
same path than the script, specify a path instead.
:type filename: str
:param start:
:return: the FeatureCollection
:rtype: ee.FeatureCollection
"""
wgs84 = ee.Projection('EPSG:4326')
# read the filename
reader = shapefile.Reader(filename)
fields = reader.fields[1:]
field_names = [field[0] for field in fields]
field_types = [field[1] for field in fields]
types = dict(zip(field_names, field_types))
features = []
projection = get_projection(filename)
# filter records with start and end
start = start if start else 0
if not end:
records = reader.shapeRecords()
end = len(records)
else:
end = end + 1
if (end - start) > 1000:
msg = "Can't process more than 1000 records at a time. Found {}"
raise ValueError(msg.format(end - start))
for i in range(start, end):
# atr = dict(zip(field_names, sr.record))
sr = reader.shapeRecord(i)
atr = {}
for fld, rec in zip(field_names, sr.record):
fld_type = types[fld]
if fld_type == 'D':
value = ee.Date(rec.isoformat()).millis().getInfo()
elif fld_type in ['C', 'N', 'F']:
value = rec
else:
continue
atr[fld] = value
geom = sr.shape.__geo_interface__
geometry = ee.Geometry(geom, 'EPSG:' + projection) \
.transform(wgs84, 1)
feat = ee.Feature(geometry, atr)
features.append(feat)
return ee.FeatureCollection(features)
def on_review_button_clicked(b):
watermask = ee.Image('UMD/hansen/global_forest_change_2015').select('datamask').eq(1)
with w_out:
try:
asset = ee.Image(w_exportassetsname.value)
center = ee.Geometry.Polygon(ee.Geometry(asset.get('system:footprint')).coordinates()) \
.centroid().coordinates().getInfo()
center.reverse()
m.center = center
bnames = asset.bandNames().getInfo()[3:-2]
count = len(bnames)
jet = 'black,blue,cyan,yellow,red'
rcy = 'black,red,cyan,yellow'
smap = asset.select('smap').byte()
cmap = asset.select('cmap').byte()
fmap = asset.select('fmap').byte()
bmap = asset.select(list(range(3,count+3)),bnames).byte()
palette = jet
w_out.clear_output()
print('Series length: %i images, reviewing (please wait for raster overlay) ...'%(count+1))
if w_changemap.value=='First':
mp = smap
mx = count
print('Interval of first change:\n blue = early, red = late')
elif w_changemap.value=='Last':
mp = cmap
mx = count
print('Interval of last change:\n blue = early, red = late')
elif w_changemap.value=='Frequency':
mp = fmap
mx = count/2
print('Change frequency :\n blue = few, red = many')
else:
sel = int(w_bmap.value)-1
sel = min(sel,count-1)
sel = max(sel,0)
if sel>0:
print('Bitemporal: %s --> %s'%(bnames[sel-1],bnames[sel]))
else:
print('Bitemporal: image1 --> %s'%bnames[sel])
print('red = positive definite, cyan = negative definite, yellow = indefinite')
mp = bmap.select(sel)
palette = rcy
mx = 3
if len(m.layers)>3:
m.remove_layer(m.layers[3])
if w_maskwater.value==True:
mp = mp.updateMask(watermask)
if w_maskchange.value==True:
mp = mp.updateMask(mp.gt(0))
m.add_layer(TileLayer(url=GetTileLayerUrl(mp.visualize(min=0, max=mx, palette=palette,opacity = w_opacity.value))))
w_export_ass.disabled = False
w_export_drv.disabled = False
w_export_atsf.disabled = False
except Exception as e:
print('Error: %s'%e)
def sfg_as_ee_py(x, sfc_class, opt_proj, opt_geodesic, opt_evenOdd):
x = re.sub(r":null", ":None", x)
sfc_class = re.sub("sfc_", "", sfc_class)
# sfg to ee
if sfc_class in ["MULTIPOLYGON", "POLYGON"]:
return ee.Geometry(
geo_json=eval(x),
opt_proj=opt_proj,
opt_geodesic=opt_geodesic,
opt_evenOdd=opt_evenOdd,
)
elif sfc_class in ["MULTILINESTRING", "LINESTRING"]:
return ee.Geometry(
geo_json=eval(x), opt_proj=opt_proj, opt_geodesic=opt_geodesic
)
elif sfc_class in ["MULTIPOINT", "POINT"]:
return ee.Geometry(geo_json=eval(x), opt_proj="EPSG:4326")
else:
return False
def _GetFeatureBoundingBox(f):
"""Returns a bounding box for the geometry of the passed-in feature."""
bounds = ee.Geometry(f.bounds().geometry()).coordinates()
sw = ee.List(ee.List(bounds.get(0)).get(0))
ne = ee.List(ee.List(bounds.get(0)).get(2))
bbox = ee.Dictionary({
'sw': ee.List([sw.get(1), sw.get(0)]),
'ne': ee.List([ne.get(1), ne.get(0)])
})
return bbox
def getTopo(self, img):
''' funtion to filter for areas with terrain and areas without'''
dem = self.env.dem.unmask(0)
geom = ee.Geometry(img.get('system:footprint')).bounds()
slp_rad = ee.Terrain.slope(dem).clip(geom)
slope = slp_rad.reduceRegion(reducer= ee.Reducer.percentile([80]), \
geometry= geom,\
scale= 100 ,\
maxPixels=10000000)
return img.set('slope', slope.get('slope'))
def generate_line_middle_point(pair):
pair = ee.List(pair)
s = ee.Geometry(pair.get(0))
offset = ee.Number(pair.get(1))
centroid = ee.Geometry.Point(s.coordinates().get(0))
return ee.Feature(centroid) \
.set("lineId", line.id()) \
.set("offset", offset)
def calcCloudStats(img):
imgPoly = ee.Algorithms.GeometryConstructors.Polygon(
ee.Geometry(img.get('system:footprint')).coordinates()
)
roi = ee.Geometry(img.get('ROI'))
intersection = roi.intersection(imgPoly, ee.ErrorMargin(0.5))
cloudMask = img.select(['cloudScore']).gt(cloudThresh).clip(roi).rename('cloudMask')
cloudAreaImg = cloudMask.multiply(ee.Image.pixelArea())
stats = cloudAreaImg.reduceRegion(
reducer=ee.Reducer.sum(),
geometry=roi,
scale=10,
maxPixels= 1e12)
cloudPercent = ee.Number(stats.get('cloudMask')).divide(imgPoly.area(0.001)).multiply(100)
coveragePercent = ee.Number(intersection.area()).divide(roi.area(0.001)).multiply(100)
cloudPercentROI = ee.Number(stats.get('cloudMask')).divide(roi.area(0.001)).multiply(100)
img = img.set('CLOUDY_PERCENTAGE', cloudPercent)
img = img.set('ROI_COVERAGE_PERCENT', coveragePercent)
img = img.set('CLOUDY_PERCENTAGE_ROI', cloudPercentROI)
return img
