def create_csv_merge(self, output_file, stats1, stats2):
# with open(output_file, 'wb') as csvfile:
csv_file = csv.writer(output_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
json_string1 = json.dumps(stats1)
json_string2 = json.dumps(stats2)
# log.info(json_string1)
# log.info(json_string2)
json_data1 = json.loads(json_string1)
json_data2 = json.loads(json_string2)
# log.info(json_data1)
# log.info(json_data2)
csv_file.writerow(["code", "label", "valueX", "valueY"])
for data1 in json_data1:
#log.info(data1)
for data2 in json_data2:
#log.info(data2)
try:
if data1["code"] == data2["code"]:
if "stats" in data1["data"]:
log.info(data2)
if not math.isnan(data1["data"]["stats"][0]["mean"]) and not math.isnan(data2["data"]["stats"][0]["mean"]):
csv_file.writerow([data1["code"], data1["label"], data1["data"]["stats"][0]["mean"], data2["data"]["stats"][0]["mean"]])
pass
except Exception, e:
print e
def start_manager(self):
exit_flags[self.tab_id] = 0
log.info('START | Layers Download Manager')
thread_list = ['Alpha', 'Bravo', 'Charlie', 'Delta', 'Echo', 'Foxtrot', 'Golf', 'Hotel', 'India', 'Juliet']
queue_lock = Lock()
work_queue = Queue.Queue(len(self.file_paths_and_sizes))
threads = []
for thread_name in thread_list:
key = str(uuid.uuid4())
thread = LayerDownloadThread(self.source, thread_name, work_queue, queue_lock, key, self.target_dir, self.tab_id)
thread.start()
if not threads_map_key in thread_manager_processes:
thread_manager_processes[threads_map_key] = {}
thread_manager_processes[threads_map_key][key] = thread
threads.append(thread)
queue_lock.acquire()
for word in self.file_paths_and_sizes:
work_queue.put(word)
queue_lock.release()
while not work_queue.empty():
pass
exit_flags[self.tab_id] = 1
for t in threads:
t.join()
log.info('DONE | Layers Download Manager')
def start_manager(self):
exit_flags[self.tab_id] = 0
log.info('START | Bulk Download Manager')
thread_list = ['Alpha']
queue_lock = Lock()
work_queue = Queue.Queue(len(self.bulk_download_objects))
threads = []
for thread_name in thread_list:
thread = BulkDownloadThread(self.source, thread_name, work_queue, queue_lock, self.tab_id, self.aggregation)
thread.start()
threads.append(thread)
queue_lock.acquire()
for obj in self.bulk_download_objects:
work_queue.put(obj)
queue_lock.release()
while not work_queue.empty():
pass
exit_flags[self.tab_id] = 1
for t in threads:
t.join()
log.info('END | Bulk Download Manager')
def _publish_coverage(self, file_path, metadata_def=None, geoserver_def=None, overwrite=False, publish_on_geoserver=True, publish_metadata=True):
"""
@param file_path:
@param layer_def:
@param overwrite:
@return:
"""
try:
log.info(geoserver_def)
# layer_def = layer_def["coverageStore"]
# sanitize the layer_name
#name = sanitize_name(filesystem.get_filename(file_path))
name = sanitize_name(metadata_def["title"]["EN"])
# getting the default workspace
workspace = self.geoserver.get_default_workspace()
if "workspace" in metadata_def["meSpatialRepresentation"]:
workspace = metadata_def["meSpatialRepresentation"]["workspace"]
# setting up the uid TODO: this will be changed i guess with Ivano's metadata structure
if "uid" not in metadata_def:
metadata_def["uid"] = workspace + ":" + name
else:
workspace = metadata_def["uid"].split(",")[0]
# publish coveragestore on geoserver
# TODO: merge the metadata with the default vector metadata
if "name" not in geoserver_def:
geoserver_def["name"] = name
if "title" not in geoserver_def:
geoserver_def["title"] = name
if "workspace" not in geoserver_def:
geoserver_def["workspace"] = workspace
# clean layer name
#geoserver_def["name"] = sanitize_name(geoserver_def["name"])
# publish on metadata
if publish_metadata is True:
self.metadata.db_metadata.insert_metadata(metadata_def)
# publish table on geoserver cluster
if publish_on_geoserver is True:
self.geoserver.publish_coveragestore(geoserver_def, True)
# remove files and folder of the shapefile
if file_path is not None:
filesystem.remove_folder(file_path)
except PGeoException, e:
log.error(e)
self.rollback_raster()
def __init__(self, datasource):
if DBConnection.con is None:
try:
log.info("---PostGIS connection initialization---")
self.datasource = datasource
if self.datasource["schema"]:
self.schema = self.datasource["schema"]
db_connect_string = self.get_connection_string(False)
self.con = psycopg2.connect(db_connect_string)
log.info("Database '%s' connection opened. " % datasource['dbname'] )
except psycopg2.DatabaseError as db_error:
log.warn("Error :\n{0}".format(db_error))
pass
def process(obj):
p = Process()
output_path = obj["output_path"]
output_file_name = obj["output_file_name"]
source_path = obj["source_path"]
band = obj["band"]
process = obj["process"]
# deal with pixel size
pixel_size = None
#pixel_size = "0.0020833325"
# defualt init is the source_path
output_processed_files = source_path
# looping throught processes
for process_values in process:
for key in process_values:
print output_processed_files
# print key_function
# for key, value in my_dict.iteritems():
if key in key_function:
# explicit functions
if "extract_bands" in key:
output_processed_files = p.extract_bands(
output_processed_files, band, output_path)
# get the pixel size
elif "get_pixel_size" in key:
print "get_pixel_size"
pixel_size = p.get_pixel_size(output_processed_files[0],
process_values[key])
log.info(pixel_size)
else:
# STANDARD GDAL FUNCTIONS
print "not function"
print "parameters"
print key
print process_values[key]
process_values[key] = change_values(process_values[key],
pixel_size)
# reflection calls
output_processed_files = getattr(p,
key)(process_values[key],
output_processed_files,
output_path)
return output_processed_files
def extract_band_files(self, input_files, output_path, ext=None):
output_files = []
i = 0;
for f in input_files:
output_file_path = os.path.join(output_path, str(i) + ext)
cmd = "gdal_translate '" + f + "' " + output_file_path
log.info(cmd)
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
output, error = process.communicate()
#TODO catch the error
log.info(output)
log.warn(error)
output_files.append(output_file_path)
i += 1
return output_files
def unzip(filezip, path=create_tmp_folder(), folder_tmp=folder_tmp_default):
"""
Unzip a file in the tmp folder
@type filezip: string
@param filezip: path to the zip file
@type path: string
@param path: path from the tmp folder
@return: path to the unzipped folder
"""
path = os.path.join(folder_tmp, path)
log.info(path)
with zipfile.ZipFile(filezip, "r") as z:
z.extractall(path)
return path
def zip_files(name, files, path=folder_tmp_default):
extension = ".zip"
if ".zip" in name:
extension = ""
zip_path = os.path.join(path, name + extension)
log.info("Zip: '%s' from zip_files %s - %s" % (zip_path, name, files))
zf = zipfile.ZipFile(zip_path, "w")
zip_subdir = path
for fpath in files:
fdir, fname = os.path.split(fpath)
#Add file, at correct path
log.info(fname)
zf.write(fpath, fname)
zf.close()
return zip_path
def reload_configuration_geoserver_slaves(self, force_master_reload=False):
geoserver_cluster = self.config["geoserver_slaves"]
if force_master_reload is True:
geoserver_cluster.append(self.config["geoserver_master"])
for geoserver in geoserver_cluster:
cs_url = url(geoserver, ["reload?recurse=true"])
headers, response = self.http.request(cs_url, "POST")
log.info(headers)
if headers.status == 200:
log.info("Geoserver updated %s" % cs_url)
else:
log.warn("Raise error?")
return False
return True
def process(obj):
p = Process()
output_path = obj["output_path"]
output_file_name = obj["output_file_name"]
source_path = obj["source_path"]
band = obj["band"]
process = obj["process"]
# deal with pixel size
pixel_size = None
#pixel_size = "0.0020833325"
# defualt init is the source_path
output_processed_files = source_path
# looping throught processes
for process_values in process:
for key in process_values:
print output_processed_files
# print key_function
# for key, value in my_dict.iteritems():
if key in key_function:
# explicit functions
if "extract_bands" in key:
output_processed_files = p.extract_bands(output_processed_files, band, output_path)
# get the pixel size
elif "get_pixel_size" in key:
print "get_pixel_size"
pixel_size = p.get_pixel_size(output_processed_files[0], process_values[key])
log.info(pixel_size)
else:
# STANDARD GDAL FUNCTIONS
print "not function"
print "parameters"
print key
print process_values[key]
process_values[key] = change_values(process_values[key], pixel_size)
# reflection calls
output_processed_files = getattr(p, key)(process_values[key], output_processed_files, output_path)
return output_processed_files
def gdaladdo(self, parameters, input_files, output_path=None):
output_files = []
cmd = "gdaladdo "
for key in parameters["parameters"].keys():
cmd += " " + key + " " + str(parameters["parameters"][key])
for input_file in input_files:
cmd += " " + input_file
output_files.append(input_file)
cmd += " " + parameters["overviews_levels"]
log.info(cmd)
try:
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
output, error = process.communicate()
log.info(output)
return output_files
except Exception, e:
log.error(e)
raise PGeoException(e.message, 500)
def extract_band_files(self, input_files, output_path, ext=None):
output_files = []
i = 0
for f in input_files:
output_file_path = os.path.join(output_path, str(i) + ext)
cmd = "gdal_translate '" + f + "' " + output_file_path
log.info(cmd)
process = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
output, error = process.communicate()
#TODO catch the error
log.info(output)
log.warn(error)
output_files.append(output_file_path)
i += 1
return output_files
def extract_band_files(self, input_files, output_path, ext=None):
output_files = []
i = 0
try:
for f in input_files:
print get_filename(f, True)
output_file_path = os.path.join(output_path, str(i) + ext)
cmd = "gdal_translate '" + f + "' " + output_file_path
log.info(cmd)
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
output, error = process.communicate()
log.info(output)
output_files.append(output_file_path)
i += 1
return output_files
except Exception, e:
log.error(e)
raise PGeoException(e.message, 500)
def update_layer_metadata(self, name, data, c_type="json"):
"""
Update the layer by json or xml
@param name: name of the layer
@type name: string
@param data: json
@type name: string cointaining the data to update i.e. json '{"layer":{"title":"title of the layer"}}' or xml <layer><title>title of the layer</title></layer>
@param type: string that can be "json" or "xml"
@type name: string
@return: True if updated
"""
try:
headers = get_headers(c_type)
cs_url = url(self.service_url, ["layers", name + "." + c_type])
log.info(cs_url)
self._publish_layer(cs_url, "PUT", data, headers, 200)
except Exception, e:
log.error(e)
raise PGeoException(e)
def gdal_translate(self, parameters, input_files, output_path):
output_files = []
output_file = os.path.join(output_path, self.output_file_name)
output_files.append(output_file)
cmd = "gdal_translate "
if "opt" in parameters:
for key in parameters["opt"].keys():
cmd += " " + key + " " + str(parameters["opt"][key])
for input_file in input_files:
cmd += " " + input_file
cmd += " " + output_file
log.info(cmd)
try:
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
output, error = process.communicate()
log.info(output)
return output_files
except Exception, e:
log.error(e)
raise PGeoException(e.message, 500)
def set_default_style(self, name, stylename, enabled=True):
"""
Method used to change the default style of a layer
:param stylename: the name of the style to set ad default one
:param layername: the name of the layer
:param enabled: enable/disable the style
:return:
"""
# curl -v -u $GEOSERVER_PASSWORD -XPUT -H "Content-type: text/xml" -d "<layer><defaultStyle><name>$DEFAULT_STYLE</name></defaultStyle><enabled>$ENABLED</enabled></layer>" $GEOSERVER_URL/rest/layers/$GEOSERVER_WORKSPACE:$NAME
headers = get_headers("xml")
xml = "<layer><defaultStyle><name>{0}</name></defaultStyle><enabled>{1}</enabled></layer>".format(unicode(stylename).lower(), unicode(str(enabled).upper()))
cs_url = url(self.service_url, ["layers", name])
log.info("Change Layer: %s default style in %s" % (name, stylename))
headers, response = self.http.request(cs_url, "PUT", xml, headers)
log.info(cs_url)
if headers.status == 200:
# reload geoserver cluster
self.reload_configuration_geoserver_slaves()
else:
raise PGeoException(response, headers.status)
return True
def change_values(obj, pixel_size):
s = json.dumps(obj)
log.info(pixel_size)
log.info(s)
s = s.replace("{{PIXEL_SIZE}}", str(pixel_size))
log.info(s)
return json.loads(s)
def gdalwarp(self, parameters, input_files, output_path):
print "gdalwarp input_files"
print input_files
output_files = []
output_file = os.path.join(output_path, "warp")
output_files.append(output_file)
cmd = "gdalwarp "
for key in parameters["opt"].keys():
cmd += " " + key + " " + str(parameters["opt"][key])
for input_file in input_files:
cmd += " " + input_file
cmd += " " + output_file
log.info(cmd)
process = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
output, error = process.communicate()
log.info(output)
log.warn(error)
log.info(output_files)
return output_files
def gdal_merge(self, parameters, input_files, output_path):
print "gdal_merge"
output_files = []
output_file = os.path.join(output_path, "gdal_merge.hdf")
output_files.append(output_file)
# creating the cmd
cmd = "gdal_merge.py "
for key in parameters.keys():
cmd += " " + key + " " + str(parameters[key])
for input_file in input_files:
cmd += " " + input_file
cmd += " -o " + output_file
log.info(cmd)
process = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
output, error = process.communicate()
log.info(output)
log.warn(error)
log.info(output_files)
return output_files
def _publish_layer(self, cs_url, c_type, message, headers, expected_code=201):
try:
log.info("%s %s" % (cs_url, headers))
headers, response = self.http.request(cs_url, c_type, message, headers)
self._cache.clear()
log.info("%s %s %s" % (message, headers, response))
if headers.status != expected_code:
#raise UploadError(response)
log.info(headers)
log.info(response)
raise PGeoException(response, headers.status)
except PGeoException, e:
log.error(e)
raise PGeoException(e.get_message(), e.get_status_code())
def __init__(self, settings):
self.settings = settings
print settings
self.db_metadata = DBMetadata(settings["db"]["metadata"])
self.search = MongoSearch(settings["db"]["metadata"]['connection'], settings["db"]["metadata"]["database"], settings["db"]["metadata"]['document']['layer'])
log.info("---Metadata initialization---")
log.info(self.db_metadata)
log.info(self.search)
def change_values(obj, pixel_size):
s = json.dumps(obj)
log.info(pixel_size)
log.info(s)
s = s.replace("{{PIXEL_SIZE}}", str(pixel_size))
log.info(s)
return json.loads(s)
def get_scatter_analysis():
try:
# Module to process statistics
stats = Stats(settings)
user_json = request.get_json()
log.info(user_json)
response = []
for uid in user_json["raster"]["uids"]:
log.info(user_json)
json_stat = copy.deepcopy(user_json)
json_stat["raster"]["uid"] = uid
response.append(stats.zonal_stats(json_stat))
log.info(response[0])
log.info(response[1])
# io.BytesIO()
si = StringIO.StringIO()
result = stats.create_csv_merge(si, response[0], response[1])
log.info(result.getvalue())
return Response(result.getvalue())
except PGeoException, e:
raise PGeoException(e.get_message(), e.get_status_code())
def publish_postgis_table(self, data, overwrite=False):
"""
:param datasource: datasource stored in geoserver
:param name: name of the table in postgis
:return:
"""
#curl -v -u admin:geoserver -XPOST -H "Content-type: text/xml" -d "<featureType><name>buildings</name></featureType>"
#http://localhost:8080/geoserver/rest/workspaces/acme/datasources/nyc/featuretypes
#data = data["featureType"]
name = data["name"]
log.info(name)
workspace = self.get_default_workspace() if "workspace" not in data else data["workspace"]
datastore = self.get_default_datastore() if "datastore" not in data else data["datastore"]
if not overwrite:
log.warn("TODO: shapefile")
#if self.check_if_layer_exist(name, workspace):
# raise PGeoException(errors[520]+": %s" % name)
try:
# TODO this can be done with just one request
# Add layer to coveragestore
headers = get_headers("xml")
xml = "<featureType><name>{0}</name></featureType>".format(unicode(name).lower())
cs_url = url(self.service_url, ["workspaces", workspace, "datastores", datastore, 'featuretypes'])
self._publish_layer(cs_url, "POST", xml, headers)
# Update metadata of the layer
headers = get_headers("json")
json_data = deepcopy(data)
del json_data['name']
# set has default enabled the layer
if "enabled" not in json_data:
json_data["enabled"] = True
# json to send to geoserver
update_layer = {
"featureType" : json_data
}
cs_url = url(self.service_url, ["workspaces", workspace, "datastores", datastore, "featuretypes", name + ".json"] )
log.info(cs_url)
self._publish_layer(cs_url, "PUT", json.dumps(update_layer), headers, 200)
# TODO: check why doesn't update the default style
if 'defaultStyle' in json_data:
if 'name' in json_data['defaultStyle']:
log.info("change default style style")
self.set_default_style(name, json_data['defaultStyle']['name'])
except PGeoException, e:
log.error(e.get_message())
raise PGeoException(e.get_message(), e.get_status_code())
def get_pixel_size(self, input_file, formula=None):
# TODO: get pixel value with rasterio library?
cmd = "gdalinfo "
cmd += input_file
cmd += " | grep Pixel"
log.info(cmd)
try:
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
output, error = process.communicate()
log.info(output)
if "Pixel Size" in output:
pixel_size = output[output.find("(")+1:output.find(",")]
log.info(pixel_size)
formula = formula.replace("{{PIXEL_SIZE}}", str(pixel_size))
log.info(formula)
return eval(formula)
return None
except Exception, e:
log.error(e)
raise PGeoException(e.message, 500)
def gdaladdo(self, parameters, input_files, output_path=None):
log.info(parameters)
log.info(input_files)
output_files = []
cmd = "gdaladdo "
for key in parameters["parameters"].keys():
cmd += " " + key + " " + str(parameters["parameters"][key])
for input_file in input_files:
cmd += " " + input_file
output_files.append(input_file)
cmd += " " + parameters["overviews_levels"]
log.info(cmd)
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
output, error = process.communicate()
log.info(output)
log.warn(error)
return output_files
def check_if_layer_exist(self, name, workspace=None):
if workspace is None:
workspace = self.get_default_workspace()
layername = workspace +":" + name
cs_url = url(self.service_url, ["layers", layername + ".json"])
log.info("checking coverage exists: %s (%s)" % (name, cs_url))
response, content = self.http.request(cs_url, "GET")
log.info(response)
log.info(content)
if response.status == 200:
return True
elif response.status == 404:
return False
return False
def overviews_tif_file(output_file, parameters=None, overviews_levels=None):
log.info("Create overviews")
cmd = "gdaladdo "
for key in parameters.keys():
cmd += " " + key + " " + str(parameters[key])
cmd += " " + output_file
cmd += " " + overviews_levels
log.info(cmd)
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
output, error = process.communicate()
log.info(output)
log.warn(error)
return output_file
def gdaladdo(self, parameters, input_files, output_path=None):
log.info(parameters)
log.info(input_files)
output_files = []
cmd = "gdaladdo "
for key in parameters["parameters"].keys():
cmd += " " + key + " " + str(parameters["parameters"][key])
for input_file in input_files:
cmd += " " + input_file
output_files.append(input_file)
cmd += " " + parameters["overviews_levels"]
log.info(cmd)
process = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
output, error = process.communicate()
log.info(output)
log.warn(error)
return output_files
def extract_bands(self, input_files, band, output_path):
log.info("extract_files_and_band_names")
log.info(input_files)
log.info("band: " + str(band))
bands = []
ext = None
try:
files = glob.glob(input_files[0])
for f in files:
gtif = gdal.Open(f)
sds = gtif.GetSubDatasets()
bands.append(sds[int(band) - 1][0])
if ext is None:
filename, ext = os.path.splitext(f)
return self.extract_band_files(bands, output_path, ext)
except Exception, e:
log.error(e)
raise PGeoException(e.message, 500)
def overviews_tif_file(output_file, parameters=None, overviews_levels=None):
log.info("Create overviews")
cmd = "gdaladdo "
for key in parameters.keys():
cmd += " " + key + " " + str(parameters[key])
cmd += " " + output_file
cmd += " " + overviews_levels
log.info(cmd)
process = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
output, error = process.communicate()
log.info(output)
log.warn(error)
return output_file
def gdalwarp(self, parameters, input_files, output_path):
print "gdalwarp input_files"
print input_files
output_files = []
output_file = os.path.join(output_path, "warp")
output_files.append(output_file)
cmd = "gdalwarp "
for key in parameters["opt"].keys():
cmd += " " + key + " " + str(parameters["opt"][key])
for input_file in input_files:
cmd += " " + input_file
cmd += " " + output_file
log.info(cmd)
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
output, error = process.communicate()
log.info(output)
log.warn(error)
log.info(output_files)
return output_files
def gdal_merge(self, parameters, input_files, output_path):
print "gdal_merge"
output_files = []
output_file = os.path.join(output_path, "gdal_merge.hdf")
output_files.append(output_file)
# creating the cmd
cmd = "gdal_merge.py "
for key in parameters.keys():
cmd += " " + key + " " + str(parameters[key])
for input_file in input_files:
cmd += " " + input_file
cmd += " -o " + output_file
log.info(cmd)
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
output, error = process.communicate()
log.info(output)
log.warn(error)
log.info(output_files)
return output_files
def run(self):
while not exit_flags[self.tab_id]:
self.queue_lock.acquire()
if not self.queue.empty():
self.bulk_download_object = self.queue.get()
self.total_files = len(self.bulk_download_object['file_list'])
progress_map[self.tab_id]['total_files'] = self.total_files
progress_map[self.tab_id]['downloaded_files'] = 0
progress_map[self.tab_id]['status'] = 'START'
progress_map[self.tab_id]['progress'] = 0
self.queue_lock.release()
self.target_folder = create_filesystem(self.source, self.bulk_download_object['filesystem_structure'])
ftp = FTP(self.bulk_download_object['ftp_base_url'])
try:
ftp.login()
except Exception, e:
progress_map[self.tab_id]['status'] = 'ERROR'
exit_flags[self.tab_id] = 1
log.error(e)
continue
ftp.cwd(self.bulk_download_object['ftp_data_dir'])
remote_files = ftp.nlst()
for file_name in self.bulk_download_object['file_list']:
log.info('Downloading: ' + file_name)
if file_name in remote_files:
ftp.sendcmd('TYPE i')
file_obj = file_name
local_file = os.path.join(self.target_folder, file_obj)
progress_map[self.tab_id]['status'] = 'ONGOING'
if not os.path.isfile(local_file):
with open(local_file, 'w') as f:
def callback(chunk):
f.write(chunk)
ftp.retrbinary('RETR %s' % file_obj, callback)
self.downloaded_files += 1
progress_map[self.tab_id]['status'] = 'COMPLETE'
progress_map[self.tab_id]['progress'] = self.percent_done()
else:
self.downloaded_files += 1
progress_map[self.tab_id]['status'] = 'COMPLETE'
progress_map[self.tab_id]['progress'] = self.percent_done()
ftp.quit()
log.info('Download Complete. Start aggregation.')
self.aggregate_layers()
else:
self.queue_lock.release()
time.sleep(1)
def process_data(obj):
output_path = obj["output_path"]
output_file_name = None
output_file_extension = None
try:
output_file_name = obj["output_file_name"]
except:
pass
source_path = obj["source_path"]
band = obj["band"]
p = Process(output_file_name)
process = obj["process"]
# deal with pixel size
pixel_size = None
#pixel_size = "0.0020833325"
# defualt init is the source_path
output_processed_files = source_path
# looping throught processes
for process_values in process:
for key in process_values:
log.info(output_processed_files)
if key in key_function:
# explicit functions
if "extract_bands" in key:
output_processed_files = p.extract_bands(output_processed_files, band, output_path)
# get the pixel size
elif "get_pixel_size" in key:
log.info("get_pixel_size")
pixel_size = p.get_pixel_size(output_processed_files[0], process_values[key])
log.info(pixel_size)
else:
# STANDARD GDAL FUNCTIONS
log.info("not function")
log.info("parameters")
log.info(key)
log.info(process_values[key])
process_values[key] = change_values(process_values[key], pixel_size)
# reflection calls
output_processed_files = getattr(p, key)(process_values[key], output_processed_files, output_path)
return output_processed_files
def close_connection(self):
if self.con is not None:
self.con.close()
log.info("Database '%s' connection closed. " % self.datasource['dbname'] )
def get_pixel_size(self, input_file, formula=None):
log.info("get_pixel_size")
log.info(input_file)
log.info(formula)
pixel_size = None
# creating the cmd
cmd = "gdalinfo "
cmd += input_file
# gdalinfo 'HDF4_EOS:EOS_GRID:"/home/vortex/Desktop/LAYERS/MODIS/033/MOD13Q1.A2014033.h23v09.005.2014050114129.hdf":MODIS_Grid_16DAY_250m_500m_VI:250m 16 days NDVI' | grep size
cmd += " | grep Pixel"
log.info(cmd)
process = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
output, error = process.communicate()
log.info(output)
log.warn(error)
if "Pixel Size" in output:
pixel_size = output[output.find("(") + 1:output.find(",")]
log.info(pixel_size)
formula = formula.replace("{{PIXEL_SIZE}}", str(pixel_size))
log.info(formula)
return eval(formula)
return None
