def and_filter_from_opts(opts):
'''build an AND filter from the provided opts dict as passed to a command
from the filter_options decorator. Assumes all dict values are lists of
filter dict constructs.'''
return filters.and_filter(*list(chain.from_iterable([
o for o in opts.values() if o]
)))
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 and_filter_from_opts(opts):
'''build an AND filter from the provided opts dict as passed to a command
from the filter_options decorator. Assumes all dict values are lists of
filter dict constructs.'''
return filters.and_filter(*list(chain.from_iterable([
o for o in opts.values() if o]
)))
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 create_regional_filter(geo_json_path, start_date, percent_cloud):
'''
Creates the regional filter needed for analysis
:param geo_json_path: Geographic Coordinates
:paramtype geo_json_path: json file path
:param date_1: Starting Date for analysis
:paramtype date_1: datetime
:param percent_cloud: will allow you to filter images that are more than x% clouds
:paramtype percent_cloud: float [0,1]
:returns: The aggregated filter for the region of interest
:rtype: dict
..note: Assumes AND Logic Filter
'''
geometry_filter = Filters.create_geometry_filter(geo_json_path)
date_filter = filters.date_range('acquired', gte=start_date)
cloud_filter = filters.range_filter('cloud_cover', lte=percent_cloud)
regional_filter = filters.and_filter(geometry_filter, date_filter,
cloud_filter)
return regional_filter
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 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 _collect_sources_filters(self):
main_filters = self._aoi_filter.filters()
if not main_filters:
main_filters = []
sources = self._daily_filters_widget.sources()
item_filters, self.local_filters = self._daily_filters_widget.filters()
if not item_filters:
item_filters = []
all_filters = main_filters + item_filters
id_filters = [
f for f in all_filters
if "field_name" in f and f["field_name"] == "id"
]
item_type_filters = []
for item_type, options in sources.items():
# check for PSScene
if options in [4, 8] and PlanetClient.getInstance().has_api_key():
assets = PlanetClient.getInstance(
).psscene_asset_types_for_nbands(options)
item_type_filter = {
"config": [
{
"config": assets,
"type": "AssetFilter"
},
{
"config": ["PSScene"],
"type": "StringInFilter",
"field_name": "item_type",
},
],
"type":
"AndFilter",
}
else:
item_type_filter = {
"config": [item_type],
"type": "StringInFilter",
"field_name": "item_type",
}
item_type_filters.append(item_type_filter)
all_filters.append(or_filter(*item_type_filters))
if id_filters:
all_filters = [id_filters[0]]
self._filters = and_filter(*all_filters)
self._sources = list(sources.keys())
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 filter_from_opts(**kw):
'''Build a AND filter from the provided filter_in OR kwargs defaulting to an
empty 'and' filter (@todo: API workaround).
All kw values should be tuple or list
'''
filter_in = kw.pop('filter_json', None)
active = and_filter_from_opts(kw)
no_filters = len(active['config']) == 0
if no_filters and not filter_in:
return filters.and_filter()
if not no_filters and filter_in:
raise click.ClickException(
'Specify filter options or provide using --filter-json, not both')
if filter_in:
active = filter_in
return active
def _collect_sources_filters(self):
main_filters = self._aoi_filter.filters()
if not main_filters:
main_filters = []
sources = self._daily_filters_widget.sources()
item_filters, self.local_filters = self._daily_filters_widget.filters()
if not item_filters:
item_filters = []
all_filters = main_filters + item_filters
id_filters = [
f for f in all_filters if "field_name" in f and f["field_name"] == "id"
]
item_type_filters = []
for item_type, assets in sources.items():
if assets is not None:
item_type_filter = {
"config": [
{"config": assets, "type": "AssetFilter"},
{
"config": [item_type],
"type": "StringInFilter",
"field_name": "item_type",
},
],
"type": "AndFilter",
}
else:
item_type_filter = {
"config": [item_type],
"type": "StringInFilter",
"field_name": "item_type",
}
item_type_filters.append(item_type_filter)
all_filters.append(or_filter(*item_type_filters))
if id_filters:
all_filters = [id_filters[0]]
self._filters = and_filter(*all_filters)
self._sources = list(sources.keys())
def quick_search_client(shapesList):
items = []
for shape in shapesList:
geo_filter = {
"type": "GeometryFilter",
"field_name": "geometry",
"config": shape
}
# Setup an "AND" logical filter
and_filter = filters.and_filter(date_filter_cl, cloud_filter_cl, geo_filter)
# Construct the request.
req = filters.build_search_request(and_filter, pa.item_types)
res = client.quick_search(req)
items.append(res)
return items
def filter_from_opts(**kw):
'''Build a AND filter from the provided kwargs defaulting to an
empty 'and' filter (@todo: API workaround) if nothing is provided.
If the 'filter_json' argument is provided, this will be assumed to contain
a filter specification and will be anded with other filters. If the
'filter_json' is a search, the search filter value will be used.
All kw values should be tuple or list
'''
filter_in = kw.pop('filter_json', None)
active = and_filter_from_opts(kw)
if filter_in:
filter_in = filter_in.get('filter', filter_in)
if len(active['config']) > 0:
active = filters.and_filter(active, filter_in)
else:
active = filter_in
return active
def filter_from_opts(**kw):
'''Build a AND filter from the provided kwargs defaulting to an
empty 'and' filter (@todo: API workaround) if nothing is provided.
If the 'filter_json' argument is provided, this will be assumed to contain
a filter specification and will be anded with other filters. If the
'filter_json' is a search, the search filter value will be used.
All kw values should be tuple or list
'''
filter_in = kw.pop('filter_json', None)
active = and_filter_from_opts(kw)
if filter_in:
filter_in = filter_in.get('filter', filter_in)
if len(active['config']) > 0:
active = filters.and_filter(active, filter_in)
else:
active = filter_in
return active
def _collect_sources_filters(self):
main_filters = self._main_filters.filters()
if not main_filters:
main_filters = []
self._sources = self._daily_filters_widget.sources()
item_filters, self.local_filters = self._daily_filters_widget.filters()
if not item_filters:
item_filters = []
all_filters = main_filters + item_filters
id_filters = [
f for f in all_filters
if "field_name" in f and f["field_name"] == "id"
]
if id_filters:
self._filters = id_filters[0]
else:
self._filters = and_filter(*all_filters)
def _collect_sources_filters(self):
main_filters = self._main_filters.filters()
if not main_filters:
main_filters = []
# main_filters_json = self._main_filters.filters_as_json()
group_filters: PlanetFilterMixin = \
self._filter_widget(self.cmbBoxItemGroupType.currentIndex())
self._sources = group_filters.sources()
self._sort_order = group_filters.sort_order()
item_filters = group_filters.filters()
if not item_filters:
item_filters = []
# item_filters_json = item_filters.filters_as_json()
all_filters = main_filters + item_filters
# Merge main and item filters
self._filters = and_filter(*all_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
def idc(idlist, item, asset, geometry):
if geometry is not None:
try:
if geometry.endswith(".geojson"):
aoi_resp = multipoly(geometry)
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")
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 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 = pyproj.Transformer.from_proj(pyproj.Proj(4326),
pyproj.Proj(epsgcode),
always_xy=True).transform
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)
elif geometry is None:
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
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 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"]
proj = pyproj.Transformer.from_proj(pyproj.Proj(4326),
pyproj.Proj(epsgcode),
always_xy=True).transform
far.append(transform(proj, s).area / 1000000)
print("\n" + "Total estimated cost to quota: " +
str("{:,}".format(round(sum(far)))) + " sqkm")
if not len(ar) == 0:
print("Total estimated cost to quota if clipped: " +
str("{:,}".format(round(sum(ar)))) + " sqkm")
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']
props["geometry"] = item["geometry"]
[-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'], '')
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):
props = item['properties']
[-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):
}),
(filters.string_filter('ground_control', 'false'), {
'type': 'NotFilter',
'config': {
'type': 'StringInFilter',
'field_name': 'ground_control',
'config': ('false', )
}
})])
def test_not_filter(predicate, expected):
assert expected == filters.not_filter(predicate)
@pytest.mark.parametrize('filt, expected', [(filters.and_filter(
filters.date_range('published', lt='2019-08-29T13:20:37.776031Z'),
filters.not_filter(
filters.string_filter(
'id', '20190625_070754_20_105c', '20190324_150924_104b'))), {
'type':
'AndFilter',
'config': ({
'field_name': 'published',
'type': 'DateRangeFilter',
'config': {
'lt': '2019-08-29T13:20:37.776031Z'
}
}, {
'type': 'NotFilter',
'config': {
'field_name':
'id',
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')
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')
point.Transform(transform)
poly.Transform(transform)
print("\t"+point.ExportToWkt())
#print(poly.ExportToJson())
#print(poly.ExportToWkt())
polyJSON = json.loads(poly.ExportToJson())
aoi = polyJSON
#pprint(aoi)
# build a filter for the AOI
query = filters.and_filter(
filters.geom_filter(aoi),
filters.range_filter('cloud_cover', lt=CLOUDCOVERLT),
)
# we are requesting PlanetScope 4 Band imagery
item_types = BANDS
request = api.filters.build_search_request(query, item_types)
# this will cause an exception if there are any API related errors
results = client.quick_search(request)
# items_iter returns an iterator over API response pages
dl = downloader.create(client)
dl.on_complete = lambda *a: completed.append(a)
for item in results.items_iter(limit=ITEMLIMIT):
perms = item['_permissions']
if DEBUG:
geometry_filter = {
"type": "GeometryFilter",
"field_name": "geometry",
"config": {
"type":
"Polygon",
"coordinates": [[[-118.13630282878874, 34.13666853390047],
[-118.13481152057646, 34.13666853390047],
[-118.13481152057646, 34.13785404192857],
[-118.13630282878874, 34.13785404192857],
[-118.13630282878874, 34.13666853390047]]]
}
}
# choose and_filter (also there can be not_filter, or_filter)
and_filter = filters.and_filter(date_filter, cloud_filter, geometry_filter)
#Step3:
#set requests
#item_types = ["REOrthoTile", "PSOrthoTile"]
#item_types = ["PSOrthoTile"]
item_types = ["PSScene4Band"] ##################################
req = filters.build_search_request(and_filter, item_types)
print('====result=======')
#get results
res = client.quick_search(req)
#Step4:
# Area Of Interest (clip geometry) in GeoJSON format
aoi_json = '''{
