def open_in_explorer(self):
from .pe_explorer_dockwidget import show_explorer_and_search_daily_images
request = build_search_request(
string_filter("id", self.scene[ID]), [self.properties[ITEM_TYPE]]
)
show_explorer_and_search_daily_images(request)
def perform_search(self, clicked=True):
log.debug('Search initiated')
# Remove highlight on search button
self._toggle_search_highlight(False)
self._collect_sources_filters()
send_analytics_for_search(self._sources)
if not self._main_filters.leAOI.text():
id_filters = filters_from_request(self._filters, "id")
if len(id_filters) == 0:
self.lblWarning.setHidden(False)
return
self.lblWarning.setHidden(True)
if not self._sources:
self.parent.show_message('No item types selected',
level=Qgis.Warning,
duration=10)
return
# TODO: Also validate GeoJSON prior to performing search
search_request = build_search_request(self._filters, self._sources)
self._request = search_request
self.searchResultsWidget.update_request(search_request,
self.local_filters)
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 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 perform_search(self, clicked=True):
log.debug('Search initiated')
# Remove highlight on search button
self._toggle_search_highlight(False)
self._collect_sources_filters()
if not self._main_filters.leAOI.text():
id_filters = filters_from_request(self._filters, "id")
if len(id_filters) == 0:
self.lblWarning.setHidden(False)
return
self.lblWarning.setHidden(True)
# TODO: Also validate GeoJSON prior to performing search
search_request = build_search_request(self._filters, self._sources)
self._request = search_request
if is_segments_write_key_valid():
analytics.track(self.p_client.user()["email"],
"Daily images search executed",
{"query": search_request})
self.searchResultsWidget.update_request(search_request,
self.local_filters)
def perform_search(self, clicked=True):
log.debug("Search initiated")
# Remove highlight on search button
self._toggle_search_highlight(False)
if self.legacy_request is not None:
search_request = self.legacy_request
self.local_filters = []
self.searchResultsWidget.update_request(search_request, self.local_filters)
return
self._collect_sources_filters()
send_analytics_for_search(self._sources)
if not self._aoi_filter.leAOI.text():
id_filters = filters_from_request(self._filters, "id")
if len(id_filters) == 0:
self.lblWarning.setHidden(False)
return
self.lblWarning.setHidden(True)
if not self._sources:
self.parent.show_message(
"No item types selected", level=Qgis.Warning, duration=10
)
return
search_request = build_search_request(self._filters, self._sources)
self._request = search_request
self.searchResultsWidget.update_request(search_request, self.local_filters)
def search_req_from_opts(**kw):
# item_type will be list of lists - flatten
item_types = chain.from_iterable(kw.pop('item_type'))
name = kw.pop('name', '')
interval = kw.pop('interval', '')
filt = filter_from_opts(**kw)
return filters.build_search_request(
filt, item_types, name=name, interval=interval)
def search_req_from_opts(**kw):
# item_type will be list of lists - flatten
item_types = chain.from_iterable(kw.pop('item_type'))
name = kw.pop('name', '')
interval = kw.pop('interval', '')
filt = filter_from_opts(**kw)
return filters.build_search_request(
filt, item_types, name=name, interval=interval)
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_items_count(combined_filter, item_types):
req = filters.build_search_request(combined_filter, item_types, interval="year") #year or day
stats = client.stats(req).get()
# p(stats)
total_count = 0
for bucket in stats['buckets']:
total_count += bucket['count']
return total_count
def __init__(self, parent):
super(DailyImagesWidget, self).__init__()
self.parent = parent
self.setupUi(self)
self._setup_aoi_filter()
self._setup_daily_filters_widget()
self.btnFilterResults.clicked.connect(self.show_filters)
self.btnBackFromFilters.clicked.connect(self.hide_filters)
self.btnClearFilters.clicked.connect(self.clear_filters)
self.searchResultsWidget = DailyImagesSearchResultsWidget()
layout = QVBoxLayout()
layout.setMargin(0)
self.grpBoxResults.setLayout(layout)
self.grpBoxResults.layout().addWidget(self.searchResultsWidget)
self.searchResultsWidget.checkedCountChanged.connect(
self._update_orders_button)
self.searchResultsWidget.setAOIRequested.connect(
self.set_aoi_from_request)
layout = QVBoxLayout()
layout.setMargin(0)
self.legacyWarningWidget = LegacyWarningWidget()
self.legacyWarningWidget.updateLegacySearch.connect(
self.update_legacy_search)
layout.addWidget(self.legacyWarningWidget)
self.frameWarningLegacySearch.setLayout(layout)
self.frameWarningLegacySearch.setVisible(False)
self._toggle_search_highlight(True)
self.btnSearch.clicked.connect(self.perform_search)
self.labelSavedSearches.linkActivated.connect(self.open_saved_searches)
# Collected sources/filters, upon search request
self._sources = None
self._filters = None
self.local_filters = None
self._request = None
self.legacy_request = None
self.current_saved_search = None
self.btnOrder.clicked.connect(self.order_checked)
self._setup_actions_button()
self._checked_item_type_nodes = {}
self.lblWarning.setHidden(True)
self._collect_sources_filters()
self._default_filter_values = build_search_request(
self._filters, self._sources)
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 update_legacy_search(self):
if self.legacy_request is not None and self.current_saved_search is not None:
self.legacy_request = None
self._collect_sources_filters()
request = build_search_request(self._filters, self._sources)
request["name"] = self.current_saved_search["name"]
PlanetClient.getInstance().update_search(
request, self.current_saved_search["id"])
self.frameWarningLegacySearch.setVisible(False)
self._daily_filters_widget.hide_legacy_search_elements()
else:
self.legacy_request = None
self.frameWarningLegacySearch.setVisible(False)
self._daily_filters_widget.hide_legacy_search_elements()
self._daily_filters_widget.clear_id_filter()
def __init__(self, parent):
super(DailyImagesWidget, self).__init__()
self.parent = parent
self.p_client = PlanetClient.getInstance()
self.setupUi(self)
self._setup_main_filter()
self._setup_daily_filters_widget()
self.btnFilterResults.clicked.connect(self.show_filters)
self.btnBackFromFilters.clicked.connect(self.hide_filters)
self.btnClearFilters.clicked.connect(self.clear_filters)
self.searchResultsWidget = DailyImagesSearchResultsWidget()
layout = QVBoxLayout()
layout.setMargin(0)
self.grpBoxResults.setLayout(layout)
self.grpBoxResults.layout().addWidget(self.searchResultsWidget)
self.searchResultsWidget.checkedCountChanged.connect(
self._update_orders_button)
self.searchResultsWidget.setAOIRequested.connect(
self.set_aoi_from_request)
self.searchResultsWidget.searchSaved.connect(self._search_saved)
self._toggle_search_highlight(True)
self.btnSearch.clicked[bool].connect(self.perform_search)
# Collected sources/filters, upon search request
self._sources = None
self._filters = None
self.local_filters = None
self._request = None
self.btnOrder.clicked.connect(self.order_checked)
self._setup_actions_button()
self._checked_queue_set_count = 0
self._checked_queue_set = set()
self._checked_item_type_nodes = {}
self.lblWarning.setHidden(True)
self._collect_sources_filters()
self._default_filter_values = build_search_request(
self._filters, self._sources)
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 search_scenes_on_server(idx, geom, start_date, end_date, cloud_cover_thr,
item_types):
# search and donwload using Planet Client API
combined_filter = get_a_filter_cli_api(geom, start_date, end_date,
cloud_cover_thr)
# get the count number
item_count = get_items_count(combined_filter, item_types)
if item_count == 100000:
basic.outputlogMessage(
'error, failed to get images of %dth polygon currently, skip it' %
idx)
return False
basic.outputlogMessage('The total number of scenes is %d' % item_count)
req = filters.build_search_request(combined_filter, item_types)
# p(req)
res = client.quick_search(req)
return res, item_count
def get_items_count(combined_filter, item_types):
'''
based on the filter, and item types, the count of item
:param combined_filter: filter
:param item_types: item types
:return: the count of items
'''
try:
req = filters.build_search_request(combined_filter,
item_types,
interval="year") #year or day
stats = client.stats(req).get()
except APIException as e:
basic.outputlogMessage(str(e))
return 100000 # return a large number
# p(stats)
total_count = 0
for bucket in stats['buckets']:
total_count += bucket['count']
return total_count
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 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")
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 main(options, args):
# need to set the key first, and start API client
get_and_set_Planet_key('*****@*****.**')
# get_and_set_Planet_key('*****@*****.**')
# print(os.environ['PL_API_KEY'])
# list_ItemTypes()
polygons_shp = args[0]
save_folder = args[1] # folder for saving downloaded images
# check training polygons
assert io_function.is_file_exist(polygons_shp)
os.system('mkdir -p ' + save_folder)
polygons_json = read_polygons_json(polygons_shp)
item_type = 'PSScene4Band' # PSScene4Band , PSOrthoTile
start_date = datetime.datetime(year=2018, month=5, day=20)
end_date = datetime.datetime(year=2018, month=6, day=1)
could_cover_thr = 0.3
# ############################################################################################################
# # search and download images using http request
# # search_image_stats_for_a_polygon(polygons_json[0], item_type, start_date, end_date, could_cover_thr)
#
# images_ids = search_image_metadata_for_a_polygon(polygons_json[0], item_type, start_date, end_date, could_cover_thr)
# [print(item) for item in images_ids ]
#
# asset_type_list = get_asset_type(item_type, images_ids[1])
# [print(item) for item in asset_type_list]
#
# for asset_type in asset_type_list:
# download_url = activation_a_item(images_ids[0], item_type, asset_type)
#
# if download_url is None:
# basic.outputlogMessage('failed to get the location of %s'%asset_type )
# continue
#
# # download ehte activated item
# if 'xml' == asset_type.split('_')[-1]:
# output = images_ids[0] + '_' + asset_type + '.xml'
# elif 'rpc' == asset_type.split('_')[-1]:
# output = images_ids[0] + '_' + asset_type + '.txt'
# else:
# output = images_ids[0] + '_' + asset_type + '.tif'
# # images_ids[0]+'.tif'
# download_one_item(download_url,os.path.join(save_folder,output))
############################################################################################################
# search and donwload using Planet Client API
# p(polygons_json[0]) # print a polygon in JSON format
geom = polygons_json[0]
combined_filter = get_a_filter_cli_api(geom, start_date, end_date, could_cover_thr)
# p(combined_filter)
item_types = ["PSScene4Band"] #, "PSOrthoTile"
# get the count number
item_count = get_items_count(combined_filter, item_types)
basic.outputlogMessage('The total count number is %d'%item_count)
req = filters.build_search_request(combined_filter, item_types)
p(req)
res = client.quick_search(req)
if res.response.status_code == 200:
# print('good')
all_items = []
for item in res.items_iter(item_count):
# print(item['id'], item['properties']['item_type'])
all_items.append(item)
# sort the item based on cloud cover
all_items.sort(key=lambda x: float(x['properties']['cloud_cover']))
# [print(item['id'],item['properties']['cloud_cover']) for item in all_items]
# active and download them, only download the SR product
for item in all_items:
print(item['id'])
assets = client.get_assets(item).get()
for asset in sorted(assets.keys()):
print(asset)
# I want to download SR, level 3B, product
# test: download the first one, all
# not all the item has "analytic_sr"
item = all_items[0]
assets = client.get_assets(item).get()
for asset in sorted(assets.keys()):
print(asset)
if 'basic' in asset:
print('skip %s'% asset)
continue
if asset not in asset_types:
continue
# active and download
active_and_downlaod_asset(item, asset, save_folder)
# test
# active_and_downlaod_asset(item, 'analytic_sr', save_folder)
# active_and_downlaod_asset(item, 'basic_analytic_dn_nitf', save_folder)
# active_and_downlaod_asset(item, 'analytic_sr', save_folder)
else:
print('code {}, text, {}'.format(res.response.status_code, res.response.text))
test = 1
pass
def create_search_request(regional_filter, item_types):
return filters.build_search_request(regional_filter, item_types)
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 download_planet_images(polygons_json, start_date, end_date,
cloud_cover_thr, item_types, save_folder):
'''
download images from for all polygons, to save quota, each polygon only downlaod one image
:param polygons_json: a list of polygons in json format
:param start_date:
:param end_date:
:param cloud_cover_thr:
:param save_folder:
:return: True if successful, false otherwise
'''
for idx, geom in enumerate(polygons_json):
# for test
# if idx > 20: break
# if idx != 1: continue
# if idx != 344: continue
####################################
#check if any image already cover this polygon, if yes, skip downloading
if check_geom_polygon_overlap(downloaed_scene_geometry, geom) is True:
basic.outputlogMessage(
'%dth polygon already in the extent of download images, skip it'
% idx)
continue
# search and donwload using Planet Client API
combined_filter = get_a_filter_cli_api(geom, start_date, end_date,
cloud_cover_thr)
# get the count number
item_count = get_items_count(combined_filter, item_types)
if item_count == 100000:
basic.outputlogMessage(
'error, failed to get images of %dth polygon currently, skip it'
% idx)
continue
basic.outputlogMessage('The total count number is %d' % item_count)
req = filters.build_search_request(combined_filter, item_types)
# p(req)
res = client.quick_search(req)
if res.response.status_code == 200:
all_items = []
for item in res.items_iter(item_count):
# print(item['id'], item['properties']['item_type'])
all_items.append(item)
# I want to download SR, level 3B, product
select_items = select_items_to_download(idx, geom, all_items)
if select_items is False:
continue
for download_item in select_items:
download_item_id = download_item['id']
# p(item['geometry'])
save_dir = os.path.join(save_folder, download_item_id)
os.system('mkdir -p ' + save_dir)
assets = client.get_assets(download_item).get()
basic.outputlogMessage(
'download a scene (id: %s) that cover the %dth polygon' %
(download_item_id, idx))
for asset in sorted(assets.keys()):
if asset not in asset_types:
continue
if check_asset_exist(download_item, asset, save_dir):
continue
basic.outputlogMessage('download %s' % asset)
# activate and download
activate_and_download_asset(download_item, asset, save_dir)
# save the geometry of this item to disk
with open(
os.path.join(save_folder,
download_item_id + '.geojson'),
'w') as outfile:
json.dump(download_item['geometry'], outfile, indent=2)
# update the geometry of already downloaded geometry
downloaed_scene_geometry.append(download_item['geometry'])
else:
print('code {}, text, {}'.format(res.response.status_code,
res.response.text))
return True
def perform_search(self, clicked=True):
log.debug('Search initiated')
# Remove highlight on search button
self._toggle_search_highlight(False)
resource_type = self.cmbBoxItemGroupType.currentData()
if resource_type == RESOURCE_DAILY:
self._collect_sources_filters()
if not self._main_filters.leAOI.text():
self.show_message('No area of interest (AOI) defined',
level=Qgis.Warning,
duration=10)
return
# TODO: Also validate GeoJSON prior to performing search
# TODO: replace hardcoded item type with dynamic item types
search_request = build_search_request(self._filters, self._sources)
self._request = search_request
if is_segments_write_key_valid():
analytics.track(self.p_client.user()["email"],
"Daily images search executed",
{"query": search_request})
# self.msg_log.logMessage(
# f"Request:\n" \
# f"<pre>{json.dumps(self._request, indent=2)}</pre>",
# LOG_NAME)
# Create new results tab, in results tab viewer, passing in request
wdgt = PlanetSearchResultsWidget(
parent=self.tabWidgetResults,
iface=self._iface,
api_key=self.api_key,
request_type=resource_type,
request=search_request,
sort_order=self._sort_order,
)
wdgt.checkedCountChanged.connect(self._update_checked_queue_set)
wdgt.setAOIRequested.connect(self.set_aoi_from_request)
wdgt.setSearchParamsRequested.connect(
self.set_search_params_from_request)
wdgt.zoomToAOIRequested.connect(
self._prepare_for_zoom_to_search_aoi)
self.frameResults.setStyleSheet(RESULTS_BKGRD_WHITE)
self.tabWidgetResults.setUpdatesEnabled(False)
self.tabWidgetResults.addTab(wdgt, 'Daily')
self.tabWidgetResults.setUpdatesEnabled(True)
self.tabWidgetResults.setCurrentWidget(wdgt)
# search_results = self.p_client.quick_search(search_request)
if resource_type == RESOURCE_SINGLE_MOSAICS:
search_text = self.leMosaicName.text()
if is_segments_write_key_valid():
analytics.track(self.p_client.user()["email"],
"Mosaics search executed",
{"text": search_text})
self.listSingleMosaics.populate(search_text)
]
]
}
# 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']
stdout.write('{0},{cloud_cover},{acquired}\n'.format(item['id'], **props))
[-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 = '''{
"type": "Polygon",
"coordinates": [
[
[
-118.13630282878874,
34.13666853390047
],
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")
date_range_filter = {
"type": "DateRangeFilter",
"field_name": "acquired",
"config": {
"gte": "2016-05-31T00:00:00.000Z",
"lte": "2017-07-01T00:00:00.000Z"
}
}
query = filters.and_filter(
filters.geom_filter(aoi),
filters.range_filter('cloud_cover', gt=0),
date_range_filter,
)
request = filters.build_search_request(
query, item_types=['PSScene4Band', 'REOrthoTile'])
result = client.quick_search(request)
#Create foluim map
folium_map = folium.Map(location=[142, -9],
tiles='Mapbox Bright',
zoom_start=2)
folium.GeoJson(aoi, name='geojson').add_to(torres_strait)
##################################################################
################## PREPARE DATA: JSON TO FLAT DATA ###############
##################################################################
imgs = []
for item in result.items_iter(limit=None):
imgs.append(item)
# 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'], '')
# Set asset type to download
asset_type = 'analytic'
stdout.write('item_id,item_type,cloud_cover,date\n')
# items_iter returns a limited iterator of all results,
# behind the scenes, the client is paging responses from the API
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"]
props["thumbnail"] = item["_links"]["thumbnail"]
scenes.append(props)
scenes = pd.DataFrame(data=scenes)
display(scenes)
print(len(scenes))
# product type
item_types = ['PSScene4Band', 'REOrthoTile']
asset_type = 'analytic'
# coverage?
# create a filter that combines our geo and date filters
# could also use an "OrFilter"
query = {
"type": "AndFilter",
"config": [geometry_filter, date_range_filter, cloud_cover_filter]
}
# build a request for type of image: which one?
request = filters.build_search_request(query, item_types)
# %% Searching data, example on https://www.planet.com/docs/api-quickstart-examples/step-1-search/
# if you don't have an API key configured, this will raise an exception
dataset = 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 dataset.items_iter(limit=None):
props = item['properties']
stdout.write('{0},{cloud_cover},{acquired}\n'.format(item['id'], **props))
# %% download
