def lambda_handler(event, context):
print(event)
print(context)
query = filters.and_filter(
filters.geom_filter(aoi),
filters.range_filter('cloud_cover', gt=0),
)
request = filters.build_search_request(
query, item_types=['PSScene3Band', 'PSScene4Band'])
result = client.quick_search(request)
stdout.write('id,cloud_cover,date\n')
for item in result.items_iter(limit=5):
props = item['properties']
stdout.write('{0},{cloud_cover},{acquired}\n'.format(
item['id'], **props))
response = {
"statusCode": 200,
"body": json.dumps({
"something": 5,
"somethingelse": 5
})
}
print(response)
return response
def build_request(aoi_geom, start_date, stop_date, cloud_cover=100):
"""build a data api search request for PS imagery.
Args:
aoi_geom (geojson):
start_date (datetime.datetime)
stop_date (datetime.datetime)
Returns:
Request
"""
query = filters.and_filter(
filters.geom_filter(aoi_geom),
filters.range_filter('cloud_cover', lte=cloud_cover),
filters.date_range('acquired', gt=start_date),
filters.date_range('acquired', lt=stop_date))
# Skipping REScene because is not orthorrectified and
# cannot be clipped.
return filters.build_search_request(query, [
'PSScene3Band',
'PSScene4Band',
'PSOrthoTile',
'REOrthoTile',
])
def get_a_filter_cli_api(polygon_json,start_date, end_date, could_cover_thr):
geo_filter = filters.geom_filter(polygon_json)
date_filter = filters.date_range('acquired', gte=start_date, lte = end_date)
cloud_filter = filters.range_filter('cloud_cover', lte=could_cover_thr)
combined_filters = filters.and_filter(geo_filter, date_filter, cloud_filter)
return combined_filters
def build_request(aoi_shape):
old = datetime.datetime(year=y1, month=m1, day=d1)
new = datetime.datetime(year=y2, month=m2, day=d2)
query = filters.and_filter(filters.geom_filter(sgeom.mapping(aoi_shape)),
filters.range_filter('cloud_cover', lt=cc),
filters.date_range('acquired', gt=old),
filters.date_range('acquired', lt=new))
item_types = ["PSScene4Band"]
return filters.build_search_request(query, item_types)
def convert(self, val, param, ctx):
val = read(val)
if not val:
return []
try:
geoj = json.loads(val)
except ValueError:
raise click.BadParameter('invalid GeoJSON')
geom = geometry_from_json(geoj)
if geom is None:
raise click.BadParameter('unable to find geometry in input')
return [filters.geom_filter(geom)]
def convert(self, val, param, ctx):
val = read(val)
if not val:
return []
try:
geoj = json.loads(val)
except ValueError:
raise click.BadParameter('invalid GeoJSON')
geom = geometry_from_json(geoj)
if geom is None:
raise click.BadParameter('unable to find geometry in input')
return [filters.geom_filter(geom)]
def search(self,
spatial,
temporal=None,
properties=None,
limit=10,
**kwargs):
stac_query = STACQuery(spatial, temporal)
# Start with spatial as its always required
planet_query = filters.geom_filter(stac_query.spatial)
if temporal:
temporal_query = filters.and_filter(
filters.date_range('acquired', gt=stac_query.temporal[0]),
filters.date_range('acquired', lt=stac_query.temporal[1]),
)
planet_query = filters.and_filter(planet_query, temporal_query)
if properties:
property_queries = []
for (field_name, v) in properties.items():
if field_name == 'eo:instrument':
continue
# Handle for searching on legacy extension
if field_name.startswith('legacy:'):
field_name = field_name.repace('legacy:', '')
equality = list(v)[0]
args = {equality: v[equality]}
planet_field = field_mappings[field_name]
field_type = field_types[field_name]
if field_type == str:
property_queries.append(
filters.string_filter(planet_field, *args))
elif field_type == float:
property_queries.append(
filters.range_filter(planet_field, **args))
planet_query = filters.and_filter(planet_query, *property_queries)
planet_request = api.filters.build_search_request(
planet_query, kwargs['subdatasets'])
planet_request.update({'limit': limit})
self.manifest.searches.append([self, planet_request])
def getPlanetPicture(fireDataSet):
distance = 45
for i in range(0, 100):
client = api.ClientV1(api_key="e262ca6835e64fa7b6975c558237e509")
geom = HF.getbox(i, distance, fireDataSet)
geom_AOI = {"type": "Polygon", "coordinates": [geom]}
pre_date = HF.getDatePre(fireDataSet, i)
post_date = HF.getDatePost(fireDataSet, i)
datePre_filter = filters.date_range('acquired',
gte=pre_date[0],
lte=pre_date[1])
datePost_filter = filters.date_range('acquired',
gte=post_date[0],
lte=post_date[1])
geom_filter = filters.geom_filter(geom_AOI)
cloud_filter = filters.range_filter('cloud_cover', lte=0.03)
andPre_filter = filters.and_filter(datePre_filter, cloud_filter,
geom_filter)
andPost_filter = filters.and_filter(datePost_filter, cloud_filter,
geom_filter)
item_types = ["PSOrthoTile"]
reqPre = filters.build_search_request(andPre_filter, item_types)
reqPost = filters.build_search_request(andPost_filter, item_types)
resPre = client.quick_search(reqPre)
resPost = client.quick_search(reqPost)
print("it should print something :")
for item in resPre.items_iter(1):
print(item['id'], item['properties']['item_type'])
for item in resPost.items_iter(1):
print(item['id'], item['properties']['item_type'])
imagePre = None
imagePost = None
return imagePre, imagePost
def filters(self):
filters = []
if self.leAOI.text():
try:
qgsgeom = qgsgeometry_from_geojson(self.leAOI.text())
if not qgsgeom.isEmpty():
geom_json = json.loads(qgsgeom.asJson())
filters.append(geom_filter(geom_json))
else:
self._show_message("AOI not valid GeoJSON polygon",
level=Qgis.Warning,
duration=10)
except Exception:
self._show_message("AOI not valid JSON",
level=Qgis.Warning,
duration=10)
finally:
return filters
def filters(self):
filters = []
if self.leAOI.text():
# TODO: Validate GeoJSON; try planet.api.utils.probably_geojson()
# noinspection PyBroadException
try:
if qgsgeometry_from_geojson(self.leAOI.text()):
aoi = json.loads(self.leAOI.text())
filters.append(geom_filter(aoi))
else:
self._show_message("AOI not valid GeoJSON polygon",
level=Qgis.Warning,
duration=10)
except Exception:
self._show_message("AOI not valid JSON",
level=Qgis.Warning,
duration=10)
finally:
return filters
def get_planet_items(api_key, aoi, start, end, cloud_cover):
"""
Request imagery items from the planet API for the requested dates.
Args:
api_key (str): the valid api key
aoi(geojson): the geometry of the alert
start(datetime.date): the start of the request
end (datetime.date): the end of the request
cloud_cover (int): the cloud coverage tolerated
Return:
(list): items from the Planet API
"""
query = filters.and_filter(
filters.geom_filter(aoi),
filters.range_filter("cloud_cover", lte=cloud_cover),
filters.date_range("acquired", gt=start),
filters.date_range("acquired", lt=end),
)
# Skipping REScene because is not orthorrectified and
# cannot be clipped.
asset_types = ["PSScene"]
# build the request
request = filters.build_search_request(query, asset_types)
result = client(api_key).quick_search(request)
# get all the results
items_pages = []
for page in result.iter(None):
items_pages.append(page.get())
items = [item for page in items_pages for item in page["features"]]
return items
def get_a_filter_cli_api(polygon_json, start_date, end_date, could_cover_thr):
'''
create a filter based on a geometry, date range, cloud cover
:param polygon_json: a polygon in json format
:param start_date: start date
:param end_date: end date
:param could_cover_thr: images with cloud cover less than this value
:return: a combined filter (and filter)
'''
# gt: Greater Than
# gte: Greater Than or Equal To
# lt: Less Than
# lte: Less Than or Equal To
geo_filter = filters.geom_filter(polygon_json)
date_filter = filters.date_range('acquired', gte=start_date, lte=end_date)
cloud_filter = filters.range_filter('cloud_cover', lte=could_cover_thr)
combined_filters = filters.and_filter(geo_filter, date_filter,
cloud_filter)
return combined_filters
[-122.41996765136719, 37.80184969073113],
[-122.45593070983887, 37.80184969073113],
[-122.45593070983887, 37.76060492968732]]]
}
# Get API key
api_key = api.ClientV1().login('*****@*****.**', 'gertan20')
# Create client
client = api.ClientV1(api_key=api_key['api_key'])
# Build a query using the AOI and a cloud_cover filter
# that get images with lower than 10% cloud cover
# and acquired on Nov 1st, 2017
query = filters.and_filter(
filters.geom_filter(aoi), filters.range_filter('cloud_cover', lt=0.1),
filters.date_range('acquired',
gte='2017-11-01T00:00:00.000Z',
lte='2017-11-01T23:59:00.000Z'))
# Build a request for only PlanetScope imagery
# Item types:
# https://www.planet.com/docs/reference/data-api/items-assets
request = filters.build_search_request(query, item_types=['PSScene4Band'])
# Get results
result = client.quick_search(request)
# Setup auth
session = requests.Session()
session.auth = (api_key['api_key'], '')
import datetime
os.chdir(orig_path)
print(AOIs[1])
if (geojson_exists):
myAOI = AOIs[1]
else:
myAOI = AOIs[1]["geometry"]
# build a query using the AOI and
# a cloud_cover filter that excludes 'cloud free' scenes
quakeDay = datetime.datetime(year, month, day)
old = datetime.datetime(year, month, day) - timedelta(weeks=26)
now = datetime.datetime(year, month, day) + timedelta(weeks=26)
query = filters.and_filter(
filters.geom_filter(myAOI),
filters.range_filter('cloud_cover', lt=50),
#filters.date_range('acquired', gt=old)
filters.date_range('acquired', gt=old, lt=now))
# build a request for only PlanetScope imagery
request = filters.build_search_request(query, item_types=[sat_use])
# if you don't have an API key configured, this will raise an exception
result = client.quick_search(request)
scenes = []
planet_map = {}
for item in result.items_iter(limit=3000):
planet_map[item['id']] = item
props = item['properties']
props["id"] = item['id']
def idl(**kwargs):
for key, value in kwargs.items():
if key == "infile" and value is not None:
infile = value
try:
if infile.endswith(".geojson"):
aoi_resp = multipoly(infile)
try:
for things in aoi_resp["features"]:
ovall.append(things["geometry"]["coordinates"])
except Exception:
for things in json.loads(aoi_resp)["features"]:
ovall.append(things["geometry"]["coordinates"])
# print(list_depth(ovall))
aoi_geom = ovall
if (list_depth(ovall) == 2 and json.loads(aoi_resp)
["features"][0]["geometry"]["type"] == "MultiPolygon"):
temp["coordinates"] = aoi_geom[0]
elif (list_depth(ovall) == 2
and json.loads(aoi_resp)["features"][0]["geometry"]
["type"] != "MultiPolygon"):
aoi_geom = ovall[0][0]
temp["type"] = "Polygon"
temp["coordinates"] = aoi_geom
elif list_depth(ovall) == 1:
aoi_geom = ovall[0]
temp["type"] = "Polygon"
temp["coordinates"] = aoi_geom
elif list_depth(ovall) == 0:
aoi_geom = ovall
temp["type"] = "Polygon"
temp["coordinates"] = aoi_geom
else:
print(
"Please check GeoJSON: Could not parse coordinates"
)
elif infile.endswith(".json"):
with open(infile) as aoi:
aoi_resp = json.load(aoi)
aoi_geom = aoi_resp["config"][0]["config"][
"coordinates"]
elif infile.endswith(".kml"):
getcoord = kml2coord(infile)
aoi_geom = getcoord["features"][0]["geometry"][
"coordinates"]
except Exception as e:
print("Could not parse geometry")
print(e)
if key == "item" and value is not None:
try:
item = value
except Exception as e:
sys.exit(e)
if key == "start" and value is not None:
try:
start = time2utc(value)
st = filters.date_range("acquired", gte=start)
except Exception as e:
sys.exit(e)
if key == "end" and value is not None:
try:
end = time2utc(value)
ed = filters.date_range("acquired", lte=end)
except Exception as e:
sys.exit(e)
if key == "asset" and value is not None:
try:
asset = value
except Exception as e:
sys.exit(e)
if key == "cmin":
if value == None:
try:
cmin = 0
except Exception as e:
print(e)
if value is not None:
try:
cmin = float(value)
except Exception as e:
print(e)
if key == "cmax":
if value == None:
try:
cmax = 1
except Exception as e:
print(e)
elif value is not None:
try:
cmax = float(value)
except Exception as e:
print(e)
if key == "num":
if value is not None:
num = value
elif value == None:
num = 1000000
if key == "outfile" and value is not None:
outfile = value
try:
open(outfile, "w")
except Exception as e:
sys.exit(e)
if key == "ovp":
if value is not None:
ovp = int(value)
elif value == None:
ovp = 0.01
if key == "filters" and value is not None:
for items in value:
ftype = items.split(":")[0]
if ftype == "string":
try:
fname = items.split(":")[1]
fval = items.split(":")[2]
# stbase={'config': [], 'field_name': [], 'type': 'StringInFilter'}
stbase["config"] = fval.split(",") # fval
stbase["field_name"] = fname
except Exception as e:
print(e)
elif ftype == "range":
fname = items.split(":")[1]
fgt = items.split(":")[2]
flt = items.split(":")[3]
# rbase={'config': {'gte': [], 'lte': []},'field_name': [], 'type': 'RangeFilter'}
rbase["config"]["gte"] = int(fgt)
rbase["config"]["lte"] = int(flt)
rbase["field_name"] = fname
print("Running search for a maximum of: " + str(num) + " assets")
l = 0
[head, tail] = os.path.split(outfile)
sgeom = filters.geom_filter(temp)
aoi_shape = shape(temp)
if not aoi_shape.is_valid:
aoi_shape = aoi_shape.buffer(0)
# print('Your Input Geometry is invalid & may have issues:A valid Polygon may not possess anyoverlapping exterior or interior rings.'+'\n')
date_filter = filters.date_range("acquired", gte=start, lte=end)
cloud_filter = filters.range_filter("cloud_cover", gte=cmin, lte=cmax)
asset_filter = filters.permission_filter("assets." +
str(asset.split(",")[0]) +
":download")
# print(rbase)
# print(stbase)
if len(rbase["field_name"]) != 0 and len(stbase["field_name"]) != 0:
and_filter = filters.and_filter(date_filter, cloud_filter,
asset_filter, sgeom, stbase, rbase)
elif len(rbase["field_name"]) == 0 and len(stbase["field_name"]) != 0:
and_filter = filters.and_filter(date_filter, cloud_filter,
asset_filter, sgeom, stbase)
elif len(rbase["field_name"]) != 0 and len(stbase["field_name"]) == 0:
and_filter = filters.and_filter(date_filter, cloud_filter,
asset_filter, sgeom, rbase)
elif len(rbase["field_name"]) == 0 and len(stbase["field_name"]) == 0:
and_filter = filters.and_filter(date_filter, cloud_filter,
asset_filter, sgeom)
item_types = [item]
req = filters.build_search_request(and_filter, item_types)
res = client.quick_search(req)
for things in res.items_iter(
1000000): # A large number as max number to check against
try:
all_assets = [
assets.split(":")[0].replace("assets.", "")
for assets in things["_permissions"]
]
if things["properties"]["quality_category"] == "standard" and all(
elem in all_assets for elem in asset.split(",")):
itemid = things["id"]
footprint = things["geometry"]
s = shape(footprint)
if item.startswith("SkySat"):
epsgcode = "3857"
else:
epsgcode = things["properties"]["epsg_code"]
if aoi_shape.area > s.area:
intersect = (s).intersection(aoi_shape)
elif s.area >= aoi_shape.area:
intersect = (aoi_shape).intersection(s)
proj_transform = pyproj.Transformer.from_proj(
pyproj.Proj(4326), pyproj.Proj(epsgcode), always_xy=True
).transform # always_xy determines correct coord order
print(
"Processing " + str(len(ar) + 1) +
" items with total area " +
str("{:,}".format(round(sum(far)))) + " sqkm",
end="\r",
)
if (transform(proj_transform, (aoi_shape)).area > transform(
proj_transform, s).area):
if (transform(proj_transform, intersect).area /
transform(proj_transform, s).area * 100) >= ovp:
ar.append(
transform(proj_transform, intersect).area /
1000000)
far.append(transform(proj_transform, s).area / 1000000)
with open(outfile, "a") as csvfile:
writer = csv.writer(csvfile,
delimiter=",",
lineterminator="\n")
writer.writerow([itemid])
elif (transform(proj_transform, s).area >= transform(
proj_transform, aoi_shape).area):
if (transform(proj_transform, intersect).area / transform(
proj_transform, aoi_shape).area * 100) >= ovp:
ar.append(
transform(proj_transform, intersect).area /
1000000)
far.append(transform(proj_transform, s).area / 1000000)
with open(outfile, "a") as csvfile:
writer = csv.writer(csvfile,
delimiter=",",
lineterminator="\n")
writer.writerow([itemid])
if int(len(ar)) == int(num):
break
except Exception as e:
pass
except (KeyboardInterrupt, SystemExit) as e:
print("\n" + "Program escaped by User")
sys.exit()
num_lines = sum(
1 for line in open(os.path.join(head,
tail.split(".")[0] + ".csv")))
print("Total number of item ids written to " + str(
os.path.join(head,
tail.split(".")[0] + ".csv") + " ===> " + str(num_lines)))
print("Total estimated cost to quota: " +
str("{:,}".format(round(sum(far)))) + " sqkm")
print("Total estimated cost to quota if clipped: " +
str("{:,}".format(round(sum(ar)))) + " sqkm")
# geojson AOI
aoi = {
"type":
"Polygon",
"coordinates": [[[-122.54, 37.81], [-122.38, 37.84], [-122.35, 37.71],
[-122.53, 37.70], [-122.54, 37.81]]]
}
# will pick up api_key via environment variable PL_API_KEY
# but can be specified using `api_key` named argument
client = api.ClientV1()
# build a query using the AOI and
# a cloud_cover filter that excludes 'cloud free' scenes
query = filters.and_filter(
filters.geom_filter(aoi),
filters.range_filter('cloud_cover', gt=0),
)
# build a request for only PlanetScope imagery
request = filters.build_search_request(
query, item_types=['PSScene3Band', 'PSScene4Band'])
# if you don't have an API key configured, this will raise an exception
result = client.quick_search(request)
stdout.write('id,cloud_cover,date\n')
# items_iter returns a limited iterator of all results. behind the scenes,
# the client is paging responses from the API
for item in result.items_iter(limit=None):
[-122.38, 37.84],
[-122.35, 37.71],
[-122.53, 37.70],
[-122.54, 37.81]
]
]
}
# will pick up api_key via environment variable PL_API_KEY
# but can be specified using `api_key` named argument
client = api.ClientV1()
# build a query using the AOI and
# a cloud_cover filter that excludes 'cloud free' scenes
query = filters.and_filter(
filters.geom_filter(aoi),
filters.range_filter('cloud_cover', gt=0),
)
# build a request for only PlanetScope imagery
request = filters.build_search_request(
query, item_types=['PSScene3Band', 'PSScene4Band']
)
# if you don't have an API key configured, this will raise an exception
result = client.quick_search(request)
stdout.write('id,cloud_cover,date\n')
# items_iter returns a limited iterator of all results. behind the scenes,
# the client is paging responses from the API
def idl(**kwargs):
for key, value in kwargs.items():
if key == 'infile' and value is not None:
infile = value
try:
if infile.endswith('.geojson'):
with open(infile) as aoi:
aoi_resp = json.load(aoi)
for things in aoi_resp['features']:
ovall.append(things['geometry']['coordinates'])
#print(list_depth(ovall))
if len(ovall) > 1:
aoi_geom = ovall
else:
if list_depth(ovall) == 0:
aoi_geom = ovall
elif list_depth(ovall) == 1:
aoi_geom = ovall[0]
elif list_depth(ovall) == 2:
aoi_geom = ovall[0][0]
else:
print(
'Please check GeoJSON: Could not parse coordinates'
)
aoi_geom == aoi_geom
#print(aoi_geom)
elif infile.endswith('.json'):
with open(infile) as aoi:
aoi_resp = json.load(aoi)
aoi_geom = aoi_resp['config'][0]['config'][
'coordinates']
elif infile.endswith('.kml'):
getcoord = kml2coord(infile)
aoi_geom = getcoord
except Exception as e:
print('Could not parse geometry')
print(e)
if key == 'item' and value is not None:
try:
item = value
except Exception as e:
sys.exit(e)
if key == 'start' and value is not None:
try:
start = value
st = filters.date_range('acquired', gte=start)
except Excpetion as e:
sys.exit(e)
if key == 'end' and value is not None:
end = value
ed = filters.date_range('acquired', lte=end)
if key == 'asset' and value is not None:
try:
asset = value
except Exception as e:
sys.exit(e)
if key == 'cmin':
if value == None:
try:
cmin = 0
except Exception as e:
print(e)
if value is not None:
try:
cmin = float(value)
except Exception as e:
print(e)
if key == 'cmax':
if value == None:
try:
cmax = 1
except Exception as e:
print(e)
elif value is not None:
try:
cmax = float(value)
except Exception as e:
print(e)
if key == 'num':
if value is not None:
num = value
elif value == None:
num = 1000000
if key == 'outfile' and value is not None:
outfile = value
try:
open(outfile, 'w')
except Exception as e:
sys.exit(e)
if key == 'ovp':
if value is not None:
ovp = int(value)
elif value == None:
ovp = 1
if key == 'filters' and value is not None:
for items in value:
ftype = items.split(':')[0]
if ftype == 'string':
try:
fname = items.split(':')[1]
fval = items.split(':')[2]
#stbase={'config': [], 'field_name': [], 'type': 'StringInFilter'}
stbase['config'] = fval.split(',') #fval
stbase['field_name'] = fname
except Exception as e:
print(e)
elif ftype == 'range':
fname = items.split(':')[1]
fgt = items.split(':')[2]
flt = items.split(':')[3]
#rbase={'config': {'gte': [], 'lte': []},'field_name': [], 'type': 'RangeFilter'}
rbase['config']['gte'] = int(fgt)
rbase['config']['lte'] = int(flt)
rbase['field_name'] = fname
print('Running search for a maximum of: ' + str(num) + ' assets')
l = 0
[head, tail] = os.path.split(outfile)
if len(ovall) > 1:
temp = {"coordinates": [], "type": "MultiPolygon"}
temp['coordinates'] = aoi_geom
else:
temp = tempsingle
temp['coordinates'] = aoi_geom
sgeom = filters.geom_filter(temp)
aoi_shape = shape(temp)
date_filter = filters.date_range('acquired', gte=start, lte=end)
cloud_filter = filters.range_filter('cloud_cover', gte=cmin, lte=cmax)
asset_filter = filters.permission_filter('assets.' + str(asset) +
':download')
# print(rbase)
# print(stbase)
if len(rbase['field_name']) != 0 and len(stbase['field_name']) != 0:
and_filter = filters.and_filter(date_filter, cloud_filter,
asset_filter, sgeom, stbase, rbase)
elif len(rbase['field_name']) == 0 and len(stbase['field_name']) != 0:
and_filter = filters.and_filter(date_filter, cloud_filter,
asset_filter, sgeom, stbase)
elif len(rbase['field_name']) != 0 and len(stbase['field_name']) == 0:
and_filter = filters.and_filter(date_filter, cloud_filter,
asset_filter, sgeom, rbase)
elif len(rbase['field_name']) == 0 and len(stbase['field_name']) == 0:
and_filter = filters.and_filter(date_filter, cloud_filter,
asset_filter, sgeom)
item_types = [item]
req = filters.build_search_request(and_filter, item_types)
res = client.quick_search(req)
for things in res.items_iter(
1000000): # A large number as max number to check against
itemid = things['id']
footprint = things["geometry"]
s = shape(footprint)
if item.startswith('SkySat'):
epsgcode = '3857'
else:
epsgcode = things['properties']['epsg_code']
if aoi_shape.area > s.area:
intersect = (s).intersection(aoi_shape)
elif s.area >= aoi_shape.area:
intersect = (aoi_shape).intersection(s)
proj = partial(pyproj.transform, pyproj.Proj(init='epsg:4326'),
pyproj.Proj(init='epsg:' + str(epsgcode)))
if transform(proj, aoi_shape).area > transform(proj, s).area:
if (transform(proj, intersect).area / transform(proj, s).area *
100) >= ovp:
ar.append(transform(proj, intersect).area / 1000000)
far.append(transform(proj, s).area / 1000000)
with open(outfile, 'a') as csvfile:
writer = csv.writer(csvfile,
delimiter=',',
lineterminator='\n')
writer.writerow([itemid])
elif transform(proj, s).area > transform(proj, aoi_shape).area:
if (transform(proj, intersect).area /
transform(proj, aoi_shape).area * 100) >= ovp:
ar.append(transform(proj, intersect).area / 1000000)
far.append(transform(proj, s).area / 1000000)
with open(outfile, 'a') as csvfile:
writer = csv.writer(csvfile,
delimiter=',',
lineterminator='\n')
writer.writerow([itemid])
if int(len(ar)) == int(num):
break
num_lines = sum(
1 for line in open(os.path.join(head,
tail.split('.')[0] + '.csv')))
print('Total number of assets written to ' + str(
os.path.join(head,
tail.split('.')[0] + '.csv') + ' ===> ' + str(num_lines)))
print('Total estimated cost to quota: ' +
str("{:,}".format(round(sum(far)))) + ' sqkm')
print('Total estimated cost to quota if clipped: ' +
str("{:,}".format(round(sum(ar)))) + ' sqkm')
def idc(idlist, item, asset, geometry):
try:
if geometry.endswith('.geojson'):
with open(geometry) as aoi:
aoi_resp = json.load(aoi)
if list_depth(aoi_resp['features'][0]['geometry']
['coordinates']) == 0:
aoi_geom = aoi_resp['features'][0]['geometry'][
'coordinates']
elif list_depth(aoi_resp['features'][0]['geometry']
['coordinates']) == 1:
aoi_geom = aoi_resp['features'][0]['geometry'][
'coordinates'][0]
else:
print('Please check GeoJSON: Could not parse coordinates')
elif geometry.endswith('.json'):
with open(geometry) as aoi:
aoi_resp = json.load(aoi)
aoi_geom = aoi_resp['config'][0]['config']['coordinates']
elif geometry.endswith('.kml'):
getcoord = kml2coord(geometry)
aoi_geom = getcoord
except Exception as e:
print('Could not parse geometry')
print(e)
l = []
stbase = {'config': [], 'field_name': 'id', 'type': 'StringInFilter'}
with open(idlist) as f:
try:
reader = csv.reader(f)
for row in reader:
item_id = row[0]
if str(item_id.isalpha()) == 'False':
l.append(item_id)
except Exception as e:
print(e)
stbase['config'] = l
temp['coordinates'] = aoi_geom
sgeom = filters.geom_filter(temp)
aoi_shape = shape(temp)
asset_filter = filters.permission_filter('assets.' + str(asset) +
':download')
and_filter = filters.and_filter(asset_filter, stbase)
item_types = [item]
req = filters.build_search_request(and_filter, item_types)
res = client.quick_search(req)
num_lines = sum(
1 for line in open(os.path.join(idlist.split('.')[0] + '.csv')))
n = 1
print('Checking permission for assets in idlist...')
for things in res.items_iter(
num_lines): # A large number as max number to check against
itemid = things['id']
#print('Processing '+str(n)+' of '+str(num_lines))
n = n + 1
footprint = things["geometry"]
s = shape(footprint)
if item.startswith('SkySat'):
epsgcode = '3857'
else:
epsgcode = things['properties']['epsg_code']
if aoi_shape.area > s.area:
intersect = (s).intersection(aoi_shape)
elif s.area >= aoi_shape.area:
intersect = (aoi_shape).intersection(s)
proj = partial(pyproj.transform, pyproj.Proj(init='epsg:4326'),
pyproj.Proj(init='epsg:' + str(epsgcode)))
if transform(proj, aoi_shape).area > transform(proj, s).area:
ar.append(transform(proj, intersect).area / 1000000)
far.append(transform(proj, s).area / 1000000)
elif transform(proj, s).area > transform(proj, aoi_shape).area:
ar.append(transform(proj, intersect).area / 1000000)
far.append(transform(proj, s).area / 1000000)
print('\n' + 'Total estimated cost to quota: ' +
str("{:,}".format(round(sum(far)))) + ' sqkm')
print('Total estimated cost to quota if clipped: ' +
str("{:,}".format(round(sum(ar)))) + ' sqkm')
