def main():
response = {}
strLegend = ''
# read from input parameters
form = cgi.FieldStorage()
strCoverage = form.getfirst("coverage")
strDateCoverage = form.getfirst("dateCoverage")
# return dataset features
arrayFName = returnVariableFeature(strCoverage)
# return dataset values from GN
arrayVDataset = _returnDatasetAttributes(arrayFName["id"],
arrayFName["type"])
# retunr Legend image of getLegend using WMS
strLegend = _returnLegendString(arrayFName, arrayVDataset, strDateCoverage)
# response
response["description"] = arrayFName["description"]
response["legendLink"] = strLegend
# response["metadataLink"]=_returnMetadataLink(arrayFName["id"])
response["id"] = arrayFName["id"]
response['result'] = 1
response['error'] = ''
# print the output json array
print(json.JSONEncoder().encode(response))
def main():
response = {}
strTempCoverage = ''
#_returnUniqueFilename();
# read from input parameters
form = cgi.FieldStorage()
# coverage
strCoverage = form.getfirst("coverage")
blnSortable = form.getfirst("blnSortable")
responseData = {}
pos = strCoverage.find("REPLACESCENARIO")
response = {'result': 1, 'error': ''}
if (pos != -1):
arrayFName = returnVariableFeature(strCoverage)
strTemp = _returnIniValue("DATASET_SCENARIO", arrayFName["owner"])
arrayScenario = strTemp.split(',')
responseData["scenario"] = arrayScenario
response["data"] = responseData
else:
# return layer features
arrayFName = returnVariableFeature(strCoverage)
if (blnSortable == "1"):
if (arrayFName["scenario"] != ""):
strTempCoverage = arrayFName["scenario"]
# return all values for scenario dataset
arrayFName = returnVariableFeature(arrayFName["scenario"])
# translate with the scenario value
if (arrayFName["scenario"] != ""):
strTemp = _returnIniValue(
"DATASET_SCENARIO", arrayFName["scenario"])
arrayScenario = strTemp.split(',')
responseData["originalScenario"] = arrayScenario
# strFromDate=''
# strToDate=''
strtext = ''
strLegend = ''
# strUnit=''
strYearKey = ''
# return info from GN
arrayVDataset = _returnDatasetAttributes(
arrayFName["id"], arrayFName["type"])
if ((arrayFName["type"] != "s_d") and (arrayFName["type"] != "s_m")):
# RASTER: r_m or r_d
# date from and to
if (arrayVDataset["fromDate"] != ""):
strTempDate = str(arrayVDataset["fromDate"])[:10]
arrayTempDate = strTempDate.split('-')
fromY = int(arrayTempDate[0])
#fromM= int(arrayTempDate[1])
#fromD= int(arrayTempDate[2])
if (arrayVDataset["toDate"] != ""):
strTempDate = str(arrayVDataset["toDate"])[:10]
arrayTempDate = strTempDate.split('-')
toY = int(arrayTempDate[0])
#toM= int(arrayTempDate[1])
#toD= int(arrayTempDate[2])
# return day conditions for layer selected
dayconditions = _returnDayConditions(arrayFName["interval"], '')
if (int(toY) > int(fromY)):
startYear = int(fromY) + 1
else:
startYear = fromY
endYear = startYear + 1
# from year = to year
# it must returns only the first year to complete the month combo
# for one year
for lngYear in range(startYear, endYear):
# for all days into dayconditions
for lngDay in dayconditions:
# dt = datetime.datetime(lngYear,1,1)
# dtdelta = datetime.timedelta(days=lngDay-1)
#a=dt + dtdelta
# strTempDate=a.isoformat()
# verify if the file exists
strTempDate = returnIfLeapYear(lngDay, lngYear)
strTempDate = strTempDate.isoformat()
result = _verifyDatasetDate(
strTempDate, arrayVDataset["fromDate"], arrayVDataset["toDate"])
# if yes, add into a string
if (result == 1):
strtext = strtext + strTempDate + str('_')
# return REPLACEKEY for coverage
arrayDates = returnShapeFile_replacekey(strCoverage)
if (arrayDates[0] != ''):
strtext = ''
for strReplace in arrayDates:
strtext = strtext + strReplace + str('_')
strYearKey = "YEARDAY_SPECIAL"
else:
strtext = strtext[:-1]
strYearKey = "YEAR"
else:
# SHAPE MOSAIC: s+mk or s_d
# return dates for the layer
arrayDates = returnShapeFile_replacekey(strCoverage)
# for each date in arrayDates
for strReplace in arrayDates:
strtext = strtext + strReplace + str('_')
strYearKey = "YEAR_SPECIAL"
# return the output string
responseData["scenario"] = ''
responseData["strHttp"] = arrayVDataset["ows"]
responseData["strEPSG"] = arrayVDataset["crs"]
responseData["strServerType"] = arrayVDataset["serverType"]
responseData["strDataType"] = arrayFName["type"]
responseData["strDateFrom"] = str(arrayVDataset["fromDate"])
responseData["strDateTo"] = str(arrayVDataset["toDate"])
responseData["strDateList"] = strtext
responseData["strDateType"] = str(strYearKey)
responseData["strLegend"] = strLegend
responseData["strUnit"] = str(arrayVDataset["unit"])
responseData["strID"] = str(arrayFName["id"])
if (strTempCoverage != ""):
# if the temporary value is not blank
# change the label with the new one
responseData["strLabel"] = str(strTempCoverage)
# save the old one as strLabelTranslate
responseData["strLabelTranslate"] = str(strCoverage)
else:
responseData["strLabel"] = str(strCoverage)
responseData["dateFormat"] = str(arrayFName["dateFormat"])
responseData["strDateInterval"] = arrayFName["interval"]
responseData["strDescription"] = str(arrayFName["description"])
response["data"] = responseData
print(json.JSONEncoder().encode(response))
def main():
result = ''
# reads input parameters
form = cgi.FieldStorage()
# latitude and longitude values
arrayParams = {}
# latitude and longitude values
arrayParams["txtLLat"] = float(form.getfirst("lat"))
arrayParams["txtULat"] = float(form.getfirst("lat"))
arrayParams["txtLLon"] = float(form.getfirst("lon"))
arrayParams["txtRLon"] = float(form.getfirst("lon"))
# layer name
arrayParams["layerCrop"] = (form.getfirst("layerCrop"))
# date value
try:
arrayParams["strDate"] = (form.getfirst("strDate"))
except:
arrayParams["strDate"] = ''
strError = ''
response = {}
if (arrayParams["layerCrop"] == None):
response["id"] = ''
response["geometry"] = ''
response["label"] = ''
response["projection"] = ''
else:
# return dataset feature
arrayFName = returnVariableFeature(arrayParams["layerCrop"])
# return dataset attributes
arrayVDataset = _returnDatasetAttributes(arrayFName["id"],
arrayFName["type"])
# return geometry
#print arrayFName
#print arrayVDataset
result = queryFeature(arrayFName, arrayVDataset, arrayParams, '',
'the_geom', '')
resultGeom = ''
if (result["result"] == 1):
resultGeom = result["value"]
# query vector shapefile and retrieve the value
result = queryFeature(arrayFName, arrayVDataset, arrayParams, '',
arrayFName["returnid"], '')
resultID = ''
if (result["result"] == 1):
resultID = result["value"]
# output google projection
if (arrayVDataset["serverType"] == "MAPSERVER"):
strToProj = strGEPSGF900913Proj
else:
strToProj = strGEPSGF4326Proj
response["id"] = resultID
response["geometry"] = resultGeom
response["label"] = arrayFName["returnlabel"]
response["projection"] = strToProj
else:
strError = result["error"]
else:
strError = result["error"]
if (strError == ""):
response["error"] = ''
response["result"] = '1'
else:
response["error"] = strError
response["result"] = '0'
print(json.JSONEncoder().encode(response))
def main():
result=''
# reads input parameters
form = cgi.FieldStorage()
# latitude and longitude values
arrayParams = {}
# latitude and longitude values
arrayParams["txtLLat"]=float(form.getfirst("lat"))
arrayParams["txtULat"]=float(form.getfirst("lat"))
arrayParams["txtLLon"]= float(form.getfirst("lon"))
arrayParams["txtRLon"]= float(form.getfirst("lon"))
# layer name
arrayParams["layerCrop"]= (form.getfirst("layerCrop"))
# date value
try:
arrayParams["strDate"]= (form.getfirst("strDate"))
except:
arrayParams["strDate"]=''
strError=''
response={}
if (arrayParams["layerCrop"]==None):
response["id"]=''
response["geometry"]=''
response["label"]=''
response["projection"]=''
else:
# return dataset feature
arrayFName=returnVariableFeature(arrayParams["layerCrop"])
# return dataset attributes
arrayVDataset=_returnDatasetAttributes(arrayFName["id"],arrayFName["type"])
# return geometry
#print arrayFName
#print arrayVDataset
result=queryFeature(arrayFName,arrayVDataset,arrayParams,'','the_geom','')
resultGeom='';
if (result["result"] == 1):
resultGeom=result["value"]
# query vector shapefile and retrieve the value
result=queryFeature(arrayFName,arrayVDataset,arrayParams,'',arrayFName["returnid"],'')
resultID=''
if (result["result"] == 1):
resultID=result["value"]
# output google projection
if (arrayVDataset["serverType"]=="MAPSERVER"):
strToProj=strGEPSGF900913Proj;
else:
strToProj=strGEPSGF4326Proj;
response["id"]=resultID
response["geometry"]=resultGeom
response["label"]=arrayFName["returnlabel"]
response["projection"]=strToProj
else:
strError=result["error"]
else:
strError=result["error"]
if (strError == ""):
response["error"]=''
response["result"]='1'
else:
response["error"]=strError
response["result"]='0'
print(json.JSONEncoder().encode(response))
def main():
response = {}
strTempCoverage = ''
#_returnUniqueFilename();
# read from input parameters
form = cgi.FieldStorage()
# coverage
strCoverage = form.getfirst("coverage")
blnSortable = form.getfirst("blnSortable")
responseData = {}
pos = strCoverage.find("REPLACESCENARIO")
response = {'result': 1, 'error': ''}
if (pos != -1):
arrayFName = returnVariableFeature(strCoverage)
strTemp = _returnIniValue("DATASET_SCENARIO", arrayFName["owner"])
arrayScenario = strTemp.split(',')
responseData["scenario"] = arrayScenario
response["data"] = responseData
else:
# return layer features
arrayFName = returnVariableFeature(strCoverage)
if (blnSortable == "1"):
if (arrayFName["scenario"] != ""):
strTempCoverage = arrayFName["scenario"]
# return all values for scenario dataset
arrayFName = returnVariableFeature(arrayFName["scenario"])
# translate with the scenario value
if (arrayFName["scenario"] != ""):
strTemp = _returnIniValue("DATASET_SCENARIO",
arrayFName["scenario"])
arrayScenario = strTemp.split(',')
responseData["originalScenario"] = arrayScenario
# strFromDate=''
# strToDate=''
strtext = ''
strLegend = ''
# strUnit=''
strYearKey = ''
# return info from GN
arrayVDataset = _returnDatasetAttributes(arrayFName["id"],
arrayFName["type"])
if ((arrayFName["type"] != "s_d") and (arrayFName["type"] != "s_m")):
# RASTER: r_m or r_d
# date from and to
if (arrayVDataset["fromDate"] != ""):
strTempDate = str(arrayVDataset["fromDate"])[:10]
arrayTempDate = strTempDate.split('-')
fromY = int(arrayTempDate[0])
#fromM= int(arrayTempDate[1])
#fromD= int(arrayTempDate[2])
if (arrayVDataset["toDate"] != ""):
strTempDate = str(arrayVDataset["toDate"])[:10]
arrayTempDate = strTempDate.split('-')
toY = int(arrayTempDate[0])
#toM= int(arrayTempDate[1])
#toD= int(arrayTempDate[2])
# return day conditions for layer selected
dayconditions = _returnDayConditions(arrayFName["interval"], '')
if (int(toY) > int(fromY)):
startYear = int(fromY) + 1
else:
startYear = fromY
endYear = startYear + 1
# from year = to year
# it must returns only the first year to complete the month combo
# for one year
for lngYear in range(startYear, endYear):
# for all days into dayconditions
for lngDay in dayconditions:
# dt = datetime.datetime(lngYear,1,1)
# dtdelta = datetime.timedelta(days=lngDay-1)
#a=dt + dtdelta
# strTempDate=a.isoformat()
# verify if the file exists
strTempDate = returnIfLeapYear(lngDay, lngYear)
strTempDate = strTempDate.isoformat()
result = _verifyDatasetDate(strTempDate,
arrayVDataset["fromDate"],
arrayVDataset["toDate"])
# if yes, add into a string
if (result == 1):
strtext = strtext + strTempDate + str('_')
# return REPLACEKEY for coverage
arrayDates = returnShapeFile_replacekey(strCoverage)
if (arrayDates[0] != ''):
strtext = ''
for strReplace in arrayDates:
strtext = strtext + strReplace + str('_')
strYearKey = "YEARDAY_SPECIAL"
else:
strtext = strtext[:-1]
strYearKey = "YEAR"
else:
# SHAPE MOSAIC: s+mk or s_d
# return dates for the layer
arrayDates = returnShapeFile_replacekey(strCoverage)
# for each date in arrayDates
for strReplace in arrayDates:
strtext = strtext + strReplace + str('_')
strYearKey = "YEAR_SPECIAL"
# return the output string
responseData["scenario"] = ''
responseData["strHttp"] = arrayVDataset["ows"]
responseData["strEPSG"] = arrayVDataset["crs"]
responseData["strServerType"] = arrayVDataset["serverType"]
responseData["strDataType"] = arrayFName["type"]
responseData["strDateFrom"] = str(arrayVDataset["fromDate"])
responseData["strDateTo"] = str(arrayVDataset["toDate"])
responseData["strDateList"] = strtext
responseData["strDateType"] = str(strYearKey)
responseData["strLegend"] = strLegend
responseData["strUnit"] = str(arrayVDataset["unit"])
responseData["strID"] = str(arrayFName["id"])
if (strTempCoverage != ""):
# if the temporary value is not blank
# change the label with the new one
responseData["strLabel"] = str(strTempCoverage)
# save the old one as strLabelTranslate
responseData["strLabelTranslate"] = str(strCoverage)
else:
responseData["strLabel"] = str(strCoverage)
responseData["dateFormat"] = str(arrayFName["dateFormat"])
responseData["strDateInterval"] = arrayFName["interval"]
responseData["strDescription"] = str(arrayFName["description"])
response["data"] = responseData
print(json.JSONEncoder().encode(response))
def main():
form = cgi.FieldStorage()
strLayer = form.getfirst("strLayer")
strYear = str(form.getfirst("strYear"))
strMonth = str(form.getfirst("strMonth"))
# html parser
#h = HTMLParser.HTMLParser()
# return output filename
strName = _returnUniqueFilename()
# save png and pdf extensions
# strOutFilenamePNG=strName+'.png';
strOutFilenamePDF = strName + '.pdf'
# pdf istance
pdf = FPDF()
# add page
pdf.add_page()
pdf.add_font(
'DejaVu',
'',
r'/var/lib/opengeo/geoserver/styles/DejaVuSansCondensed.ttf',
uni=True)
pdf.set_font('Arial', 'B', 16)
cont = 30
# add title
strTitle = _returnIniValue('PDF_CONFIGURATION', 'PDF_TITLE')
pdf.cell(200, 10, txt=strTitle, ln=1, align="L")
pdf.set_font('Arial', '', 16)
strHttp = _returnHttpAddress()
# add link
pdf.cell(200, 10, strHttp, 0, 1, 'L')
pdf.ln(10)
cont = cont + 10
if (strLayer != ""):
# add layer
pdf.ln(5)
pdf.set_x(10)
cont = cont + 10
arrayFName = returnVariableFeature(strLayer)
if (strMonth != "None"):
strDate = strYear + '-' + strMonth
else:
strDate = strYear
strPrintDate = str(strDate)
arrayVDataset = _returnDatasetAttributes(
arrayFName["id"], arrayFName["type"])
strLink = _returnGetMapLink(
arrayFName, arrayVDataset, strYear, strMonth)
pdf.set_font('Arial', '', 12)
# layer title
pdf.cell(0, 0, 'Layer: ')
pdf.ln(5)
cont = cont + 10
pdf.set_x(15)
pdf.set_font('DejaVu', '', 12)
strText = arrayFName['description'] + ', ' + strPrintDate
if (arrayVDataset["unit"] != ""):
strText += ' (' + arrayVDataset["unit"] + ')'
pdf.cell(0, 0, strText.decode('UTF-8'))
pdf.ln(100)
# add image
pdf.image(strLink, 10, cont, 180, 100, 'PNG')
cont = cont + 110
# add legend
if (arrayFName["legend"] == ""):
# return http image
strLegend = _returnLegendString(arrayFName, arrayVDataset, strDate)
import urllib2
a = urllib2.urlopen(strLegend).read()
size = get_image_info(a)
else:
# return image info
strPath = _returnHTMLDir()
with open(strPath + arrayFName["legend"], 'rb') as f:
data = f.read()
size = get_image_info(data)
strLegend = strPath + arrayFName["legend"]
# calculate image size
lngW = size[0]
lngH = size[1]
lngWMax = 50
lngHMax = 30
if (lngW > lngH):
if (lngW > lngWMax):
lngH = (lngWMax * lngH) / lngW
lngW = lngWMax
else:
if (lngH > lngHMax):
lngW = (lngHMax * lngW) / lngH
lngH = lngHMax
# add image
pdf.image(strLegend, 10, cont, lngW, lngH)
pdf.ln(lngH + 30)
# add copyright
pdf.set_font('Arial', '', 12)
pdf.cell(0, 0, 'Use limitation: ')
strTextCopyright = _returnPdfCopyright(arrayFName["id"])
pdf.ln(5)
pdf.set_font('DejaVu', '', 10)
# multi cell (text)
pdf.multi_cell(180, 5, strTextCopyright.decode('UTF-8'))
strOutputDirectory = _returnTempDirectory(0)
strHTTPOutputDirectory = _returnTempDirectory(1)
pdf.output(strOutputDirectory + strOutFilenamePDF, 'F')
# print and return the output link
print strHTTPOutputDirectory + strOutFilenamePDF
def main():
arrayParams = json.load(sys.stdin)
response = {}
# return Y1 description
response["strY1Descr"] = ''
# return Y2 description
response["strY2Descr"] = ''
# return graph title
h = HTMLParser.HTMLParser()
# operation as input parameter
response["strOperation"] = arrayParams["operation"]
arrayUnits = {}
arrayLabels = {}
arrayColors = {}
arrayColorsGraph = []
arrayCopyright = {}
lngContSC = 0
lngContB = 1
lngContL = 1
lngContH = 1
lngColor = 0
strHeader = 'Date,'
blnBarChartY1 = 0
blnLogY1 = 0
# for each layer of Y1
for arrayTemp in arrayParams["vars1"]:
# save layer name
strLayer = arrayTemp["value"]
# return layer feature
arrayFName = returnVariableFeature(strLayer)
# return parameter from GN
arrayVDataset = _returnDatasetAttributes(
arrayFName["id"], arrayFName["type"])
# return Y1 description
if (response["strY1Descr"] == ""):
if (len(arrayParams["vars1"]) > 1):
# if there are more than 1 variable, the system return the owner description
# (all datasets must be of the save group)
response["strY1Descr"] = arrayFName['owner']
else:
# return layer description
response["strY1Descr"] = str(arrayFName["description"])
# add the unit
if (str(arrayVDataset["unit"]) != ""):
response[
"strY1Descr"] += '(' + str(arrayVDataset["unit"]) + ')'
arrayFormula = arrayFName["formula"].split('_')
# STEPCHART
if (arrayFormula[0] == "STEPCHART"):
# number of maximum fields
lngMax = int(arrayVDataset["maxValue"])
# return colors from ini files
arrayGColors_2y_stepchart = _returnColorsScale_SC(
str(arrayFName["colorsScale"]), "COLOR")
# and labels
arrayGLabels_2y_stepchart = _returnColorsScale_SC(
str(arrayFName["colorsScale"]), "LABEL")
# save the header line of CSV file
for ii in range(int(arrayVDataset["minValue"]), int(lngMax) + 1, 1):
strVar = str('SCY1' + str(lngContSC + 1))
strHeader += strVar + ','
# save the output label used from javascript to describe with
# the mouse over a specific value
arrayLabels[str(strVar)] = arrayGLabels_2y_stepchart[lngContSC]
# save the output unit
arrayUnits[strVar] = arrayVDataset["unit"]
# save the color used to design the graph
arrayColors[strVar] = arrayGColors_2y_stepchart[lngContSC]
arrayColorsGraph.append(arrayGColors_2y_stepchart[lngContSC])
lngContSC = lngContSC + 1
else:
# BARCHART
if ((arrayFormula[0] == "BAR0") or (arrayFormula[0] == "BAR")):
strVar = str('BY1' + str(lngContB))
lngContB = lngContB + 1
if (arrayFormula[0] == "BAR0"):
blnBarChartY1 = 1
else:
# LINEBAR
if (arrayFormula[0] == "LINEBAR"):
strVar = 'LY1' + str(lngContL)
lngContL = lngContL + 1
else:
# HISTOGRAM
if (arrayFormula[0] == "HISTOGRAM"):
strVar = 'HY1' + str(lngContH)
lngContH = lngContH + 1
strHeader += strVar
arrayLabels[str(strVar)] = str(arrayFName["description"])
# if deviation is enabled
# add a string to describe if the returned value is standard or
# spatial deviation
if (arrayParams["blnDeviation"] == 1):
if (arrayFName["sd"] != ""):
arrayLabels[str(strVar)] = arrayLabels[
str(strVar)] + ' (standard deviation)'
else:
if (arrayParams["operation"] != "POINT"):
arrayLabels[str(strVar)] = arrayLabels[
str(strVar)] + ' (spatial deviation)'
# return unit
arrayUnits[str(strVar)] = arrayVDataset["unit"]
# color
arrayGColors_2y_other = _returnColorsScale(
str(arrayFName["colorsScale"]))
arrayColors[strVar] = arrayGColors_2y_other[lngColor]
arrayColorsGraph.append(arrayGColors_2y_other[lngColor])
strHeader += ','
lngColor = lngColor + 1
arrayCopyright[str(strVar)] = h.unescape(
_returnPdfCopyright(arrayFName["id"]))
if (arrayFormula[1] == "LOG"):
blnLogY1 = 1
lngContSC = 0
lngContB = 1
lngContL = 1
blnBarChartY2 = 0
blnLogY2 = 0
# the same for all variables of Y2
for arrayTemp in arrayParams["vars2"]:
strLayer = arrayTemp["value"]
arrayFName = returnVariableFeature(strLayer)
arrayVDataset = _returnDatasetAttributes(
arrayFName["id"], arrayFName["type"])
if (response["strY2Descr"] == ""):
if (len(arrayParams["vars2"]) > 1):
response["strY2Descr"] = arrayFName['owner']
else:
response["strY2Descr"] = str(arrayFName["description"])
if (str(arrayVDataset["unit"]) != ""):
response[
"strY2Descr"] += '(' + str(arrayVDataset["unit"]) + ')'
arrayFormula = arrayFName["formula"].split('_')
if (arrayFormula[0] == "STEPCHART"):
lngMax = int(arrayVDataset["maxValue"])
arrayGColors_2y_stepchart = _returnColorsScale_SC(
str(arrayFName["colorsScale"]), "COLOR")
arrayGLabels_2y_stepchart = _returnColorsScale_SC(
str(arrayFName["colorsScale"]), "LABEL")
for ii in range(int(arrayVDataset["minValue"]), int(lngMax) + 1, 1):
strVar = str('SCY2' + str(lngContSC + 1))
strHeader += strVar + ','
arrayLabels[str(strVar)] = arrayGLabels_2y_stepchart[lngContSC]
arrayUnits[strVar] = arrayVDataset["unit"]
arrayColors[strVar] = arrayGColors_2y_stepchart[lngContSC]
arrayColorsGraph.append(arrayGColors_2y_stepchart[lngContSC])
lngContSC = lngContSC + 1
else:
if ((arrayFormula[0] == "BAR0") or (arrayFormula[0] == "BAR")):
strVar = str('BY2' + str(lngContB))
lngContB = lngContB + 1
if (arrayFormula[0] == "BAR"):
blnBarChartY2 = 1
else:
if (arrayFormula[0] == "LINEBAR"):
strVar = 'LY2' + str(lngContL)
lngContL = lngContL + 1
else:
if (arrayFormula[0] == "HISTOGRAM"):
strVar = 'HY2' + str(lngContH)
lngContH = lngContH + 1
strHeader += strVar
arrayLabels[str(strVar)] = str(arrayFName["description"])
if (arrayParams["blnDeviation"] == 1):
if (arrayFName["sd"] != ""):
arrayLabels[str(strVar)] = arrayLabels[
str(strVar)] + ' (standard deviation)'
else:
if (arrayParams["operation"] != "POINT"):
arrayLabels[str(strVar)] = arrayLabels[
str(strVar)] + ' (spatial deviation)'
arrayUnits[str(strVar)] = arrayVDataset["unit"]
arrayGColors_2y_other = _returnColorsScale(
str(arrayFName["colorsScale"]))
arrayColors[strVar] = arrayGColors_2y_other[lngColor]
arrayColorsGraph.append(arrayGColors_2y_other[lngColor])
strHeader += ','
lngColor = lngColor + 1
arrayCopyright[str(strVar)] = h.unescape(
_returnPdfCopyright(arrayFName["id"]))
if (arrayFormula[1] == "LOG"):
blnLogY2 = 1
# header to save into the CSV file
strHeader = strHeader[:-1] + '\n'
# CSV filename
strFilename = _returnFilename_csv()
# initialize the CSV file
_formatCsvFile(strHeader, strFilename)
# return the http file
strHttpFilename = _returnHttpFilename(strFilename)
# save all output values into a json array
response["units"] = arrayUnits
response["labels"] = arrayLabels
response["colors"] = arrayColors
response["colorsGraph"] = arrayColorsGraph
response["strGraphTitle"] = _returnGraphTitle(arrayParams)
response['strFilename'] = strFilename
response['strHttpFilename'] = strHttpFilename
response['blnBarChartY1'] = blnBarChartY1
response['blnBarChartY2'] = blnBarChartY2
response['blnLogaritmicY1'] = blnLogY1
response['blnLogaritmicY2'] = blnLogY2
strSource = _returnIniValue('PDF_CONFIGURATION', 'PDF_TITLE')
response['reference'] = str(strSource) + ', ' + str(_returnHttpAddress())
response['copyright'] = arrayCopyright
response['result'] = 1
response['error'] = ''
print(json.JSONEncoder().encode(response))
def main():
form = cgi.FieldStorage()
strLayer = form.getfirst("strLayer")
strYear = str(form.getfirst("strYear"))
strMonth = str(form.getfirst("strMonth"))
# html parser
#h = HTMLParser.HTMLParser()
# return output filename
strName = _returnUniqueFilename()
# save png and pdf extensions
# strOutFilenamePNG=strName+'.png';
strOutFilenamePDF = strName + '.pdf'
# pdf istance
pdf = FPDF()
# add page
pdf.add_page()
pdf.add_font('DejaVu',
'',
r'/var/lib/opengeo/geoserver/styles/DejaVuSansCondensed.ttf',
uni=True)
pdf.set_font('Arial', 'B', 16)
cont = 30
# add title
strTitle = _returnIniValue('PDF_CONFIGURATION', 'PDF_TITLE')
pdf.cell(200, 10, txt=strTitle, ln=1, align="L")
pdf.set_font('Arial', '', 16)
strHttp = _returnHttpAddress()
# add link
pdf.cell(200, 10, strHttp, 0, 1, 'L')
pdf.ln(10)
cont = cont + 10
if (strLayer != ""):
# add layer
pdf.ln(5)
pdf.set_x(10)
cont = cont + 10
arrayFName = returnVariableFeature(strLayer)
if (strMonth != "None"):
strDate = strYear + '-' + strMonth
else:
strDate = strYear
strPrintDate = str(strDate)
arrayVDataset = _returnDatasetAttributes(arrayFName["id"],
arrayFName["type"])
strLink = _returnGetMapLink(arrayFName, arrayVDataset, strYear,
strMonth)
pdf.set_font('Arial', '', 12)
# layer title
pdf.cell(0, 0, 'Layer: ')
pdf.ln(5)
cont = cont + 10
pdf.set_x(15)
pdf.set_font('DejaVu', '', 12)
strText = arrayFName['description'] + ', ' + strPrintDate
if (arrayVDataset["unit"] != ""):
strText += ' (' + arrayVDataset["unit"] + ')'
pdf.cell(0, 0, strText.decode('UTF-8'))
pdf.ln(100)
# add image
pdf.image(strLink, 10, cont, 180, 100, 'PNG')
cont = cont + 110
# add legend
if (arrayFName["legend"] == ""):
# return http image
strLegend = _returnLegendString(arrayFName, arrayVDataset, strDate)
import urllib2
a = urllib2.urlopen(strLegend).read()
size = get_image_info(a)
else:
# return image info
strPath = _returnHTMLDir()
with open(strPath + arrayFName["legend"], 'rb') as f:
data = f.read()
size = get_image_info(data)
strLegend = strPath + arrayFName["legend"]
# calculate image size
lngW = size[0]
lngH = size[1]
lngWMax = 50
lngHMax = 30
if (lngW > lngH):
if (lngW > lngWMax):
lngH = (lngWMax * lngH) / lngW
lngW = lngWMax
else:
if (lngH > lngHMax):
lngW = (lngHMax * lngW) / lngH
lngH = lngHMax
# add image
pdf.image(strLegend, 10, cont, lngW, lngH)
pdf.ln(lngH + 30)
# add copyright
pdf.set_font('Arial', '', 12)
pdf.cell(0, 0, 'Use limitation: ')
strTextCopyright = _returnPdfCopyright(arrayFName["id"])
pdf.ln(5)
pdf.set_font('DejaVu', '', 10)
# multi cell (text)
pdf.multi_cell(180, 5, strTextCopyright.decode('UTF-8'))
strOutputDirectory = _returnTempDirectory(0)
strHTTPOutputDirectory = _returnTempDirectory(1)
pdf.output(strOutputDirectory + strOutFilenamePDF, 'F')
# print and return the output link
print strHTTPOutputDirectory + strOutFilenamePDF
def main():
# reads input parameters
form = cgi.FieldStorage()
#h = HTMLParser.HTMLParser()
data = form.getfirst("data")
strParams = form.getfirst("strParams")
pos = data.find(",")
data = data[pos + 1:]
arrayParams = strParams.split('<%%>')
data = base64.b64decode(data)
# output directory
strOutputDirectory = _returnTempDirectory(0)
# return filename
strName = _returnUniqueFilename()
# png and pdf extensions
strOutFilenamePNG = strName + '.png'
strOutFilenamePDF = strName + '.pdf'
# open png file for writing
f = open(strOutputDirectory + strOutFilenamePNG, 'w')
f.write(data)
f.close()
# parameters
# print arrayParams[1]
# strText=arrayParams[1].encode("utf-8")
# print strText
# arrayParams[1]=h.unescape(arrayParams[1])
#arrayParams[1]=arrayParams[1].replace("<br>", ", ");
#arrayParams[1]=arrayParams[1].replace("Â", "");
# variables
arrayVars1 = arrayParams[2].split('#')
arrayVars2 = arrayParams[3].split('#')
# pdf istance
pdf = FPDF()
# add page
pdf.add_page()
#pdf.add_font('Arial', '', r'/var/lib/opengeo/geoserver/styles/ArialSansCondensed.ttf', uni=True)
#pdf.set_font('Arial', '', 14)
pdf.set_font('Arial', 'B', 16)
cont = 0
# add title
strTitle = _returnIniValue('PDF_CONFIGURATION', 'PDF_TITLE')
pdf.cell(200, 10, txt=strTitle, ln=1, align="L")
pdf.set_font('Arial', '', 16)
strHttp = _returnHttpAddress()
# add ce ll for address
pdf.cell(200, 10, strHttp, 0, 1, 'L')
pdf.ln(10)
cont = cont + 10
# add cell for operation
pdf.set_font('Arial', '', 12)
pdf.cell(0, 0, 'Operation: ')
pdf.ln(5)
cont = cont + 5
pdf.set_x(15)
# add cell for coordinates
# pdf.set_font('Arial','',12)
pdf.cell(0, 0, arrayParams[0].decode('UTF-8'))
pdf.ln(5)
cont = cont + 5
# add cell for coordinates
pdf.set_font('Arial', '', 12)
pdf.cell(0, 0, 'Coordinates: ')
pdf.ln(5)
cont = cont + 5
pdf.set_x(15)
# pdf.set_font('Arial','',12)
pdf.cell(0, 0, arrayParams[1].decode('UTF-8'))
#pdf.write(8, text)
pdf.ln(5)
cont = cont + 5
pdf.set_font('Arial', '', 12)
# variables list
pdf.cell(0, 0, 'Variables Y1: ')
pdf.ln(5)
cont = cont + 5
strAdditionalInfo = ''
strTextCopyright = ''
for value in arrayVars1:
if (value != ""):
arrayFName = returnVariableFeature(value)
arrayVDataset = _returnDatasetAttributes(
arrayFName["id"], arrayFName["type"])
pdf.set_font('Arial', '', 12)
strAdd = arrayFName["description"].decode('UTF-8')
if (arrayVDataset["unit"] != ""):
strAdd += ' (' + arrayVDataset["unit"].decode('UTF-8') + ')'
pdf.set_x(15)
pdf.cell(0, 0, strAdd)
# for each variable add a description
pdf.ln(5)
cont = cont + 5
# save the copyright for each variable in order to put the text
# after the graph
strTextCopyright += '\n\n' + strAdd + '\n' + \
_returnPdfCopyright(arrayFName["id"])
strAdditionalInfo += _returnMetadataAdditionalInfo(
arrayFName["id"])
strAdditionalInfo += '\n\nMetadata link: \n' + \
_returnMetadataLink(arrayFName["id"])
blnPrimaVolta = 1
for value in arrayVars2:
if (value != ""):
if (blnPrimaVolta == 1):
blnPrimaVolta = 0
pdf.cell(0, 0, 'Variables Y2: ')
pdf.ln(5)
pdf.set_x(15)
arrayFName = returnVariableFeature(value)
arrayVDataset = _returnDatasetAttributes(
arrayFName["id"], arrayFName["type"])
pdf.set_font('Arial', '', 12)
strAdd = arrayFName["description"].decode('UTF-8')
if (arrayVDataset["unit"] != ""):
strAdd += ' (' + arrayVDataset["unit"].decode('UTF-8') + ')'
pdf.cell(0, 0, strAdd)
# for each variable add a description
pdf.ln(5)
cont = cont + 5
# save the copyright for each variable in order to put the text
# after the graph
strTextCopyright += '\n\n' + strAdd + '\n' + \
_returnPdfCopyright(arrayFName["id"])
strAdditionalInfo += '\n\n' + \
_returnMetadataAdditionalInfo(arrayFName["id"])
strAdditionalInfo += '\n\nMetadata link: \n' + \
_returnMetadataLink(arrayFName["id"])
# add graph image
pdf.image(strOutputDirectory + strOutFilenamePNG,
10, cont + 40, 180, 120, 'PNG')
# add copyright
if (strTextCopyright != ""):
pdf.ln(130)
pdf.set_font('Arial', '', 12)
pdf.cell(0, 0, 'Use limitation: ')
pdf.ln(1)
pdf.set_font('Arial', '', 10)
pdf.multi_cell(180, 5, strTextCopyright.decode('UTF-8'))
strHTTPOutputDirectory = _returnTempDirectory(1)
pdf.ln(5)
if (strAdditionalInfo != ""):
pdf.set_font('Arial', '', 10)
pdf.multi_cell(180, 5, strAdditionalInfo.decode('UTF-8'))
strHTTPOutputDirectory = _returnTempDirectory(1)
pdf.ln(5)
pdf.output(strOutputDirectory + strOutFilenamePDF, 'F')
# print and return the output link
print strHTTPOutputDirectory + strOutFilenamePDF
def main():
global strError
blnDebug = 0
response = {'result': 0, 'error': ''}
arrayParams = json.load(sys.stdin)
# save process id in order to delete when stop the process
_savePid(arrayParams["strCSVFile"] + '.pid')
# arrayParams["txtRLon"]=10.444722
# arrayParams["txtLLon"]=10.444722
# arrayParams["txtULat"]=51.084722
# arrayParams["txtLLat"]=51.084722
# arrayParams["strCSVFile"]="/var/www/html/temp/20140610144944074620.csv"
# input parameters
arrayParams["append"] = int(arrayParams["append"])
# arrayParams["append"]=1;
arrayParams["txtRLon"] = float(arrayParams["txtRLon"])
arrayParams["txtLLon"] = float(arrayParams["txtLLon"])
arrayParams["txtULat"] = float(arrayParams["txtULat"])
arrayParams["txtLLat"] = float(arrayParams["txtLLat"])
arrayParams["originaltxtRLon"] = arrayParams["txtRLon"]
arrayParams["originaltxtLLon"] = arrayParams["txtLLon"]
arrayParams["originaltxtULat"] = arrayParams["txtULat"]
arrayParams["originaltxtLLat"] = arrayParams["txtLLat"]
arrayParams["fromMonth"] = int(arrayParams["fromMonth"])
arrayParams["toMonth"] = int(arrayParams["toMonth"])
arrayParams["fromYear"] = int(arrayParams["fromYear"])
arrayParams["toYear"] = int(arrayParams["toYear"])
strLayersDescr = ''
arrayLayers = []
# collects all input vars
for arrayTemp in arrayParams["vars1"]:
arrayLayers.append(arrayTemp['value'])
for arrayTemp in arrayParams["vars2"]:
arrayLayers.append(arrayTemp['value'])
if (blnDebug == 1):
print arrayParams
# arrayFinalDates=[]
#arrayValues = []
#arrayFinal1= []
#arrayFinal2= []
# lngFinal=0;
# lngCont=0;
blnContinueDate = 0
# lngIncr=1
# lngContSC=1;
# lngContB=1;
# lngContL=1;
# lngContH=1;
# strHeader='Date,'
arrayFName_total = []
arrayVDataset_total = []
arrayFNameSD_total = []
arrayVDatasetSD_total = []
arrayParams["crs"] = strGEPSGF4326Proj
blnFoundShapeFile = 0
strFoundShapeFile = ''
strFoundShapeFile_owner = ''
for arrayTemp in arrayParams["vars1"]:
strLayer = arrayTemp['value']
# return variable info
arrayFName = returnVariableFeature(strLayer)
# if the variable is a shape
if (arrayFName["type"] == "s_d" or arrayFName["type"] == "s_m"):
blnFoundShapeFile = 1
strFoundShapeFile_owner = arrayFName["owner"]
if (strFoundShapeFile == ""):
strFoundShapeFile = strLayer
arrayTemp = arrayFName["formula"].split('_')
# return dataset attributes from GN
arrayVDataset = _returnDatasetAttributes(
arrayFName["id"], arrayFName["type"])
if arrayVDataset:
arrayVDataset_total.append(arrayVDataset)
# return dates available reads from getCapabilities
arrayDatesAv = _returnGetCapabilities_dates(arrayVDataset["ows"], arrayFName["type"], arrayFName[
"store"], arrayFName["name"], arrayVDataset["ows_version"], arrayFName["dateFormat"], arrayFName["interval"])
arrayFName["dates_available"] = arrayDatesAv
if arrayFName:
arrayFName_total.append(arrayFName)
if (arrayTemp[0] == "STEPCHART"):
strEmptyString = ''
lngMax = arrayVDataset["maxValue"]
for ii in range(int(arrayVDataset["minValue"]), int(lngMax) + 1, 1):
strEmptyString += 'null,'
strEmptyString = strEmptyString[:-1]
# deviation
if (arrayParams["blnDeviation"] == 1):
# info about the deviation datates
arrayFNameSD = returnVariableFeature(arrayFName['sd'])
arrayVDatasetSD = []
if arrayFNameSD:
# return dataset attributes from GN
arrayVDatasetSD = _returnDatasetAttributes(
arrayFNameSD["id"], arrayFNameSD["type"])
# return dates available reads from getCapabilities
arrayDatesAvSD = _returnGetCapabilities_dates(arrayVDataset["ows"], arrayFNameSD["type"], arrayFNameSD[
"store"], arrayFNameSD["name"], arrayVDatasetSD["ows_version"], arrayFNameSD["dateFormat"], arrayFNameSD["interval"])
arrayFNameSD["dates_available"] = arrayDatesAvSD
arrayVDatasetSD_total.append(arrayVDatasetSD)
arrayFNameSD_total.append(arrayFNameSD)
# same process for VARS2
for arrayTemp in arrayParams["vars2"]:
strLayer = arrayTemp['value']
arrayFName = returnVariableFeature(strLayer)
if (arrayFName["type"] == "s_d" or arrayFName["type"] == "s_m"):
if (blnFoundShapeFile == 1):
# there is a shape on the VAR1
if (strFoundShapeFile_owner != ""):
if (arrayFName["owner"] != strFoundShapeFile_owner):
#strError="You cannot compare two shapefile at the same time: please, change it!"
# return an error if the user tries to compare 2
# shapefiles at the same time
exit(0)
else:
blnFoundShapeFile = 1
if (strFoundShapeFile == ""):
strFoundShapeFile = strLayer
arrayTemp = arrayFName["formula"].split('_')
arrayVDataset = _returnDatasetAttributes(
arrayFName["id"], arrayFName["type"])
if arrayVDataset:
arrayVDataset_total.append(arrayVDataset)
arrayDatesAv = _returnGetCapabilities_dates(arrayVDataset["ows"], arrayFName["type"], arrayFName[
"store"], arrayFName["name"], arrayVDataset["ows_version"], arrayFName["dateFormat"], arrayFName["interval"])
arrayFName["dates_available"] = arrayDatesAv
if arrayFName:
arrayFName_total.append(arrayFName)
if (arrayTemp[0] == "STEPCHART"):
strEmptyString = ''
lngMax = arrayVDataset["maxValue"]
for ii in range(int(arrayVDataset["minValue"]), int(lngMax) + 1, 1):
strEmptyString += 'null,'
strEmptyString = strEmptyString[:-1]
if (arrayParams["blnDeviation"] == 1):
arrayFNameSD = returnVariableFeature(arrayFName['sd'])
arrayVDatasetSD = []
if arrayFNameSD:
arrayVDatasetSD = _returnDatasetAttributes(
arrayFNameSD["id"], arrayFNameSD["type"])
arrayDatesAvSD = _returnGetCapabilities_dates(arrayVDataset["ows"], arrayFNameSD["type"], arrayFNameSD[
"store"], arrayFNameSD["name"], arrayVDatasetSD["ows_version"], arrayFNameSD["dateFormat"], arrayFNameSD["interval"])
arrayFNameSD["dates_available"] = arrayDatesAvSD
arrayVDatasetSD_total.append(arrayVDatasetSD)
arrayFNameSD_total.append(arrayFNameSD)
# I found a shapefile
if (blnFoundShapeFile == 1 or arrayParams["operation"] == "SHAPE"):
# original coordinates
lngLatToFind = arrayParams["originaltxtLLat"]
lngLonToFind = arrayParams["originaltxtLLon"]
if (arrayParams["operation"] == "SHAPE"):
if (strFoundShapeFile != ""):
strLayerToFind = strFoundShapeFile
else:
strLayerToFind = arrayParams["layerCrop"]
else:
strLayerToFind = strFoundShapeFile
strGeom = ""
if (strLayerToFind != ""):
arrayFNameFeature = returnVariableFeature(strLayerToFind)
# print arrayFNameFeature
arrayVDatasetFeature = _returnDatasetAttributes(
arrayFNameFeature["id"], arrayFNameFeature["type"])
# print arrayVDatasetFeature
arrayParamsFeature = arrayParams
arrayParamsFeature["strDate"] = ""
if (arrayFNameFeature["type"] == "s_m"):
pos = arrayFNameFeature["fixed"].find("_")
if (pos == 4):
arrayParamsFeature["strDate"] = str(
arrayVDatasetFeature["fromDate"])[:pos].replace("-", "")
else:
arrayParamsFeature["strDate"] = str(
arrayVDatasetFeature["fromDate"])[:10].replace("-", "")
if (arrayVDatasetFeature["serverType"] == "MAPSERVER"):
arrayParamsFeature["crs"] = "EPSG:900913"
else:
arrayParamsFeature["crs"] = arrayVDatasetFeature["crs"]
arrayParamsFeature["name"] = strLayerToFind
arrayParamsFeature["txtLLon"] = lngLonToFind
arrayParamsFeature["txtRLon"] = lngLonToFind
arrayParamsFeature["txtLLat"] = lngLatToFind
arrayParamsFeature["txtULat"] = lngLatToFind
if (blnDebug == 1):
print arrayFNameFeature
print arrayVDatasetFeature
print arrayParamsFeature
print arrayParamsFeature["crs"]
# return the geometry converted to right projection
result = queryFeature(arrayFNameFeature, arrayVDatasetFeature,
arrayParamsFeature, '', 'the_geom', arrayParamsFeature["crs"])
strGeom = ''
if (result["result"] == 1):
strGeom = result["value"]
# cwa:wei_rb_ecf_REPLACEKEY_ann
if (arrayVDatasetFeature["serverType"] == "MAPSERVER"):
inputEPSG = 3857
outputEPSG = 4326
else:
inputEPSG = 4326
outputEPSG = 4326
# converted polygon
arrayParams["convertedPolygon"] = convertPolygon(
strGeom, inputEPSG, outputEPSG)
arrayParams["convertedCrs"] = strGEPSGF4326Proj
latS = []
lonS = []
strGGeometry = ''
# save all points into two different arrays in order to extrapolate
# the min and max values for lat and long
for values in arrayParams["convertedPolygon"]:
latS.append(float(values[1]))
lonS.append(float(values[0]))
strGGeometry += str(values[0]) + ' ' + str(values[1]) + ','
# save the geometry into the correct format for WPS
strGGeometry = strGGeometry[0:-1]
# save min and max
strAreaToLon = np.max(lonS) + 1
strAreaFromLon = np.min(lonS) - 1
strAreaToLat = np.max(latS) + 1
strAreaFromLat = np.min(latS) - 1
# save values into the structure
arrayParams["strGGeometry"] = strGGeometry
arrayParams["strAreaToLon"] = strAreaToLon
arrayParams["strAreaFromLon"] = strAreaFromLon
arrayParams["strAreaFromLat"] = strAreaFromLat
arrayParams["strAreaToLat"] = strAreaToLat
arrayParams["geom"] = strGeom
if (blnFoundShapeFile == 1):
arrayParams["operation"] = "SHAPE"
# return common dates
arrayDates = _returnCommonDates(arrayFName_total)
# print arrayDates
# return common years
arrayYears = _returnCommonYears(
arrayFName_total, arrayParams["fromYear"], arrayParams["toYear"])
# print arrayYears
# print arrayYears
# print arrayDates
# print arrayLayers
# exit(0);
strPrevStepChart = ''
blnPrimaVoltaDebug = 1
# start the loop
if (arrayParams["append"] == 1):
# append to the csv file
#f = open(arrayParams["strCSVFile"],'ab')
import csv
with open(arrayParams["strCSVFile"], 'rb') as csvfile:
reader = csv.reader(csvfile, delimiter=' ', quotechar='|')
#lastline = reader.next()
rows = list(reader)
lngNum = int(len(rows))
if (lngNum > 1):
strTemp = rows[lngNum - 1]
arrayTemp = strTemp[0].split(',')
strDate = arrayTemp[0]
arrayTempDate = strDate.split('-')
arrayParams["fromYear"] = int(arrayTempDate[0])
arrayParams["fromMonth"] = int(arrayTempDate[1])
arrayNewYears = []
for lngYear in arrayYears:
if (lngYear >= arrayParams["fromYear"]):
arrayNewYears.append(int(lngYear))
arrayYears = arrayNewYears
for lngYear in arrayYears:
# loop over days
for lngDay in arrayDates:
# verify if the year if a leap year
strTempDate = _returnIfLeapYear(lngDay, lngYear)
strTempDateOr = strTempDate
# extrapolate month
lngMonth = int(strTempDate.month)
# date
strTempDate = strTempDate.isoformat()
# verify date with input parameters
blnContinueDate = 1
if (lngYear == arrayParams["fromYear"]):
if (lngMonth < arrayParams["fromMonth"]):
blnContinueDate = 0
if (lngYear == arrayParams["toYear"]):
if (lngMonth > arrayParams["toMonth"]):
blnContinueDate = 0
# date
if (blnContinueDate == 1):
strLine = str(strTempDate[:10]) + ','
# for each layer
for xx in range(0, len(arrayLayers), 1):
strLayer = arrayLayers[xx]
if (blnDebug == 1):
print strLayer
# lngCont=0;
# arrayValues=[]
# shape dataset or mosaic
arrayParams["strCoverage"] = strLayer
arrayFName = arrayFName_total[xx]
strLayersDescr += arrayFName["description"] + '#'
if arrayVDataset_total[xx]:
arrayVDataset = arrayVDataset_total[xx]
arrayFName_deviation = []
if (arrayParams["blnDeviation"] == 1):
if ((arrayFNameSD_total) and (len(arrayFNameSD_total) > xx)):
arrayFName_deviation = arrayFNameSD_total[xx]
if ((arrayVDatasetSD_total) and (len(arrayVDatasetSD_total) > xx)):
arrayVDataset_deviation = arrayVDatasetSD_total[xx]
# input parameters
# if is a point, the system retrieve 3 x 3 pixels and
# extrapolate the 1,1
if (arrayParams["operation"] == "POINT"):
# return cell 3 * 3
arrayParams["txtLLon"] = arrayParams[
"originaltxtLLon"] - (arrayVDataset["xsize"] * 1.6)
arrayParams["txtLLat"] = arrayParams[
"originaltxtLLat"] - (arrayVDataset["ysize"] * 1.6)
arrayParams["txtRLon"] = arrayParams[
"originaltxtRLon"] + (arrayVDataset["xsize"] * 1.6)
arrayParams["txtULat"] = arrayParams[
"originaltxtULat"] + (arrayVDataset["ysize"] * 1.6)
# calculare width and height
widthValue = int(
((arrayParams["txtRLon"] - arrayParams["txtLLon"]) / arrayVDataset["xsize"]))
heightValue = int(
((arrayParams["txtULat"] - arrayParams["txtLLat"]) / arrayVDataset["ysize"]))
# minimun value
if (widthValue < 1):
widthValue = 1
if (heightValue < 1):
heightValue = 1
arrayParams["widthValue"] = widthValue
arrayParams["heightValue"] = heightValue
lngValue = ''
blnContinueDateLayer = 0
# verify if the dateset exists for the specific date
if (blnDebug == 1):
if (blnPrimaVoltaDebug == 1):
print arrayFName["dates_available"]
blnPrimaVoltaDebug = 0
strTempDateOrUp = _replaceDateFormat(
strTempDateOr, arrayFName["dateFormat"])
# print strTempDateOrUp
# print strTempDateOrUp
blnContinueDateLayer = _verifyIfDateIsAvailable(strTempDateOrUp, strLayer, arrayFName[
"type"], arrayFName["dates_available"], arrayFName["fixed"], arrayFName["dateFormat"])
arrayTemp = arrayFName["formula"].split('_')
if (blnContinueDateLayer == 1):
if (blnDebug == 1):
print "date ok: "
print strTempDateOrUp
arrayParams["strCoverage"] = strLayer
#======================================================
# SHAPEFILE (mosaic or dataset)
#======================================================
if ((arrayFName["type"] == "s_m") or (arrayFName["type"] == "s_d")):
strResult_var = ""
if (arrayFName["type"] == "s_d"):
# no data to save if it is a dataset
arrayParams["strDate"] = ''
else:
# save info for date
pos = arrayFName["fixed"].find("_")
if (pos == 4):
strTestDate = str(strTempDate)[0:pos]
else:
strTestDate = str(
strTempDate[:10]).replace("-", "")
# strTempNameOriginal=arrayFName["name"]
arrayParams["strDate"] = strTestDate
#==================================================
# QUERY FEATURE (WFS)
#==================================================
result = queryFeature(
arrayFName, arrayVDataset, arrayParams, lngDay, arrayFName["returnid"], '')
strResult_var = ''
if (result["result"] == 1):
strResult_var = result["value"]
lngValue = ''
if (strResult_var != ""):
lngValue = float(strResult_var)
#======================================================
# SHAPEFILE (mosaic or dataset)
#======================================================
else:
#==================================================
# RASTER (mosaic or dataset)
#==================================================
if (arrayParams["operation"] == "POINT" or arrayParams["operation"] == "BOX"):
#==============================================
# COVERAGE (WCS)
#==============================================
data = returnCoverageMeanValue(
arrayParams["operation"], strTempDate, arrayParams, arrayFName, arrayVDataset, '', 0)
else:
#==============================================
# CROP COVERAGE (WPS)
#==============================================
data = returnCropCoverageMeanValue(
arrayParams["operation"], strTempDate, arrayParams, arrayFName, arrayVDataset, '', 0)
# print data
strResult_var = str(_returnMeanValue(arrayParams[
"operation"], data, arrayVDataset, arrayFName["formula"], '', 0, arrayFName["colorsScale"]))
# translate the value
lngValue = _returnTransformMean(
strResult_var, arrayFName, arrayVDataset, 0)
if (blnDebug == 1):
print data
print strResult_var
print lngValue
#======================================================
# RASTER (mosaic or dataset)
#======================================================
if (blnDebug == 1):
print strResult_var
print lngValue
lngValueDev = ''
strResult_dev = ''
if (arrayTemp[0] != "HISTOGRAM"):
# if the dataset is a bar, the SD doesn't work
# se e'un bar non funziona la standard deviation
# quindi inutile recuperare il valore
if (arrayParams["blnDeviation"] == 1):
if (blnDebug == 1):
print "calcolo deviation"
#==============================================
# RASTER (mosaic or dataset)
#==============================================
if ((arrayFName["type"] != "s_m") and (arrayFName["type"] != "s_d")):
# print arrayFName_deviation
if arrayFName_deviation:
if (blnDebug == 1):
print "STANDARD deviation"
#======================================
# STANDARD DEVIATION
#======================================
arrayParams[
"strCoverage"] = arrayFName['sd']
blnContinueDateLayer = _verifyIfDateIsAvailable(strTempDateOrUp, arrayParams["strCoverage"], arrayFName_deviation[
"type"], arrayFName_deviation["dates_available"], arrayFName_deviation["fixed"], arrayFName_deviation["dateFormat"])
# verify if the layername exists in
# getCapabilities
if (blnContinueDateLayer == 1):
if (arrayParams["operation"] == "POINT" or arrayParams["operation"] == "BOX"):
#==============================
# COVERAGE (WCS)
#==============================
data = returnCoverageMeanValue(arrayParams[
"operation"], strTempDate, arrayParams, arrayFName_deviation, arrayVDataset_deviation, strResult_var, 0)
else:
#==============================
# CROP COVERAGE (WPS)
#==============================
data = returnCropCoverageMeanValue(arrayParams[
"operation"], strTempDate, arrayParams, arrayFName_deviation, arrayVDataset_deviation, strResult_var, 0)
strResult_dev = str(_returnMeanValue(arrayParams["operation"], data, arrayVDataset_deviation, arrayFName_deviation[
"formula"], strResult_var, 0, arrayFName["colorsScale"]))
lngValueDev = _returnTransformMean(
strResult_dev, arrayFName_deviation, arrayVDataset_deviation, 1)
if (blnDebug == 1):
print data
print strResult_dev
print lngValueDev
# exit(0);
else:
if (blnDebug == 1):
print "SPATIAL deviation"
#======================================
# SPATIAL DEVIATION
#======================================
if (arrayTemp[0] != "STEPCHART"):
# if (arrayParams["operation"]=="BOX"):
# ========================================================================================
# COVERAGE (WCS)
# ========================================================================================
# data=returnCoverageMeanValue(arrayParams["operation"],strTempDate,arrayParams,arrayFName,arrayVDataset,strResult_var,1)
# else:
# if (arrayParams["operation"]=="SHAPE"):
# ========================================================================================
# CROP COVERAGE (WPS)
# ========================================================================================
# data=returnCropCoverageMeanValue(arrayParams["operation"],strTempDate,arrayParams,arrayFName,arrayVDataset,strResult_var,1)
if (arrayParams["operation"] == "SHAPE" or arrayParams["operation"] == "BOX"):
strResult_dev = str(_returnMeanValue(arrayParams["operation"], data, arrayVDataset, arrayFName[
"formula"], strResult_var, 1, arrayFName["colorsScale"]))
lngValueDev = _returnTransformMean(
strResult_dev, arrayFName, arrayVDataset, 1)
if (blnDebug == 1):
print data
print strResult_dev
print strResult_var
print lngValueDev
#==============================================
# RASTER (mosaic or dataset)
#==============================================
if (arrayTemp[0] == "STEPCHART"):
if (lngValueDev == ""):
if (lngValue == ""):
if (strPrevStepChart != ""):
lngValue = strPrevStepChart
else:
lngValue = strEmptyString
lngValue = str(lngValue).replace(",", ",,")
strPrevStepChart = str(lngValue)
# add the standard deviation to null values for
# each value
else:
lngValueDev = ''
lngValue = ''
if (arrayTemp[0] == "STEPCHART"):
'''
lngValue=strEmptyString;
if (arrayParams["blnDeviation"]==1):
lngValue=str(lngValue).replace(",", ",,");
lngValueDev=''
'''
lngValue = strPrevStepChart
if (strPrevStepChart == ""):
lngValue = strEmptyString
if (arrayParams["blnDeviation"] == 1):
lngValue = str(lngValue).replace(",", ",,")
lngValueDev = ''
strLine += str(lngValue) + ',' + str(lngValueDev) + ','
# save the line
strLine = strLine[:-1] + '\n'
if (blnDebug == 1):
print strLine
exit(0)
# save the data into the .csv
_formatCsvFile(strLine, arrayParams["strCSVFile"])
# exit(0);
# return the http filename
# strHttpFilename=_returnHttpFilename(arrayParams["strCSVFile"]);
response['result'] = 1
response['error'] = ''
# return
print(json.JSONEncoder().encode(response))
def main():
global strError
blnDebug = 0
response = {'result': 0, 'error': ''}
arrayParams = json.load(sys.stdin)
# save process id in order to delete when stop the process
_savePid(arrayParams["strCSVFile"] + '.pid')
# arrayParams["txtRLon"]=10.444722
# arrayParams["txtLLon"]=10.444722
# arrayParams["txtULat"]=51.084722
# arrayParams["txtLLat"]=51.084722
# arrayParams["strCSVFile"]="/var/www/html/temp/20140610144944074620.csv"
# input parameters
arrayParams["append"] = int(arrayParams["append"])
# arrayParams["append"]=1;
arrayParams["txtRLon"] = float(arrayParams["txtRLon"])
arrayParams["txtLLon"] = float(arrayParams["txtLLon"])
arrayParams["txtULat"] = float(arrayParams["txtULat"])
arrayParams["txtLLat"] = float(arrayParams["txtLLat"])
arrayParams["originaltxtRLon"] = arrayParams["txtRLon"]
arrayParams["originaltxtLLon"] = arrayParams["txtLLon"]
arrayParams["originaltxtULat"] = arrayParams["txtULat"]
arrayParams["originaltxtLLat"] = arrayParams["txtLLat"]
arrayParams["fromMonth"] = int(arrayParams["fromMonth"])
arrayParams["toMonth"] = int(arrayParams["toMonth"])
arrayParams["fromYear"] = int(arrayParams["fromYear"])
arrayParams["toYear"] = int(arrayParams["toYear"])
strLayersDescr = ''
arrayLayers = []
# collects all input vars
for arrayTemp in arrayParams["vars1"]:
arrayLayers.append(arrayTemp['value'])
for arrayTemp in arrayParams["vars2"]:
arrayLayers.append(arrayTemp['value'])
if (blnDebug == 1):
print arrayParams
# arrayFinalDates=[]
#arrayValues = []
#arrayFinal1= []
#arrayFinal2= []
# lngFinal=0;
# lngCont=0;
blnContinueDate = 0
# lngIncr=1
# lngContSC=1;
# lngContB=1;
# lngContL=1;
# lngContH=1;
# strHeader='Date,'
arrayFName_total = []
arrayVDataset_total = []
arrayFNameSD_total = []
arrayVDatasetSD_total = []
arrayParams["crs"] = strGEPSGF4326Proj
blnFoundShapeFile = 0
strFoundShapeFile = ''
strFoundShapeFile_owner = ''
for arrayTemp in arrayParams["vars1"]:
strLayer = arrayTemp['value']
# return variable info
arrayFName = returnVariableFeature(strLayer)
# if the variable is a shape
if (arrayFName["type"] == "s_d" or arrayFName["type"] == "s_m"):
blnFoundShapeFile = 1
strFoundShapeFile_owner = arrayFName["owner"]
if (strFoundShapeFile == ""):
strFoundShapeFile = strLayer
arrayTemp = arrayFName["formula"].split('_')
# return dataset attributes from GN
arrayVDataset = _returnDatasetAttributes(arrayFName["id"],
arrayFName["type"])
if arrayVDataset:
arrayVDataset_total.append(arrayVDataset)
# return dates available reads from getCapabilities
arrayDatesAv = _returnGetCapabilities_dates(
arrayVDataset["ows"], arrayFName["type"], arrayFName["store"],
arrayFName["name"], arrayVDataset["ows_version"],
arrayFName["dateFormat"], arrayFName["interval"])
arrayFName["dates_available"] = arrayDatesAv
if arrayFName:
arrayFName_total.append(arrayFName)
if (arrayTemp[0] == "STEPCHART"):
strEmptyString = ''
lngMax = arrayVDataset["maxValue"]
for ii in range(int(arrayVDataset["minValue"]),
int(lngMax) + 1, 1):
strEmptyString += 'null,'
strEmptyString = strEmptyString[:-1]
# deviation
if (arrayParams["blnDeviation"] == 1):
# info about the deviation datates
arrayFNameSD = returnVariableFeature(arrayFName['sd'])
arrayVDatasetSD = []
if arrayFNameSD:
# return dataset attributes from GN
arrayVDatasetSD = _returnDatasetAttributes(
arrayFNameSD["id"], arrayFNameSD["type"])
# return dates available reads from getCapabilities
arrayDatesAvSD = _returnGetCapabilities_dates(
arrayVDataset["ows"], arrayFNameSD["type"],
arrayFNameSD["store"], arrayFNameSD["name"],
arrayVDatasetSD["ows_version"], arrayFNameSD["dateFormat"],
arrayFNameSD["interval"])
arrayFNameSD["dates_available"] = arrayDatesAvSD
arrayVDatasetSD_total.append(arrayVDatasetSD)
arrayFNameSD_total.append(arrayFNameSD)
# same process for VARS2
for arrayTemp in arrayParams["vars2"]:
strLayer = arrayTemp['value']
arrayFName = returnVariableFeature(strLayer)
if (arrayFName["type"] == "s_d" or arrayFName["type"] == "s_m"):
if (blnFoundShapeFile == 1):
# there is a shape on the VAR1
if (strFoundShapeFile_owner != ""):
if (arrayFName["owner"] != strFoundShapeFile_owner):
#strError="You cannot compare two shapefile at the same time: please, change it!"
# return an error if the user tries to compare 2
# shapefiles at the same time
exit(0)
else:
blnFoundShapeFile = 1
if (strFoundShapeFile == ""):
strFoundShapeFile = strLayer
arrayTemp = arrayFName["formula"].split('_')
arrayVDataset = _returnDatasetAttributes(arrayFName["id"],
arrayFName["type"])
if arrayVDataset:
arrayVDataset_total.append(arrayVDataset)
arrayDatesAv = _returnGetCapabilities_dates(
arrayVDataset["ows"], arrayFName["type"], arrayFName["store"],
arrayFName["name"], arrayVDataset["ows_version"],
arrayFName["dateFormat"], arrayFName["interval"])
arrayFName["dates_available"] = arrayDatesAv
if arrayFName:
arrayFName_total.append(arrayFName)
if (arrayTemp[0] == "STEPCHART"):
strEmptyString = ''
lngMax = arrayVDataset["maxValue"]
for ii in range(int(arrayVDataset["minValue"]),
int(lngMax) + 1, 1):
strEmptyString += 'null,'
strEmptyString = strEmptyString[:-1]
if (arrayParams["blnDeviation"] == 1):
arrayFNameSD = returnVariableFeature(arrayFName['sd'])
arrayVDatasetSD = []
if arrayFNameSD:
arrayVDatasetSD = _returnDatasetAttributes(
arrayFNameSD["id"], arrayFNameSD["type"])
arrayDatesAvSD = _returnGetCapabilities_dates(
arrayVDataset["ows"], arrayFNameSD["type"],
arrayFNameSD["store"], arrayFNameSD["name"],
arrayVDatasetSD["ows_version"], arrayFNameSD["dateFormat"],
arrayFNameSD["interval"])
arrayFNameSD["dates_available"] = arrayDatesAvSD
arrayVDatasetSD_total.append(arrayVDatasetSD)
arrayFNameSD_total.append(arrayFNameSD)
# I found a shapefile
if (blnFoundShapeFile == 1 or arrayParams["operation"] == "SHAPE"):
# original coordinates
lngLatToFind = arrayParams["originaltxtLLat"]
lngLonToFind = arrayParams["originaltxtLLon"]
if (arrayParams["operation"] == "SHAPE"):
if (strFoundShapeFile != ""):
strLayerToFind = strFoundShapeFile
else:
strLayerToFind = arrayParams["layerCrop"]
else:
strLayerToFind = strFoundShapeFile
strGeom = ""
if (strLayerToFind != ""):
arrayFNameFeature = returnVariableFeature(strLayerToFind)
# print arrayFNameFeature
arrayVDatasetFeature = _returnDatasetAttributes(
arrayFNameFeature["id"], arrayFNameFeature["type"])
# print arrayVDatasetFeature
arrayParamsFeature = arrayParams
arrayParamsFeature["strDate"] = ""
if (arrayFNameFeature["type"] == "s_m"):
pos = arrayFNameFeature["fixed"].find("_")
if (pos == 4):
arrayParamsFeature["strDate"] = str(
arrayVDatasetFeature["fromDate"])[:pos].replace(
"-", "")
else:
arrayParamsFeature["strDate"] = str(
arrayVDatasetFeature["fromDate"])[:10].replace(
"-", "")
if (arrayVDatasetFeature["serverType"] == "MAPSERVER"):
arrayParamsFeature["crs"] = "EPSG:900913"
else:
arrayParamsFeature["crs"] = arrayVDatasetFeature["crs"]
arrayParamsFeature["name"] = strLayerToFind
arrayParamsFeature["txtLLon"] = lngLonToFind
arrayParamsFeature["txtRLon"] = lngLonToFind
arrayParamsFeature["txtLLat"] = lngLatToFind
arrayParamsFeature["txtULat"] = lngLatToFind
if (blnDebug == 1):
print arrayFNameFeature
print arrayVDatasetFeature
print arrayParamsFeature
print arrayParamsFeature["crs"]
# return the geometry converted to right projection
result = queryFeature(arrayFNameFeature, arrayVDatasetFeature,
arrayParamsFeature, '', 'the_geom',
arrayParamsFeature["crs"])
strGeom = ''
if (result["result"] == 1):
strGeom = result["value"]
# cwa:wei_rb_ecf_REPLACEKEY_ann
if (arrayVDatasetFeature["serverType"] == "MAPSERVER"):
inputEPSG = 3857
outputEPSG = 4326
else:
inputEPSG = 4326
outputEPSG = 4326
# converted polygon
arrayParams["convertedPolygon"] = convertPolygon(
strGeom, inputEPSG, outputEPSG)
arrayParams["convertedCrs"] = strGEPSGF4326Proj
latS = []
lonS = []
strGGeometry = ''
# save all points into two different arrays in order to extrapolate
# the min and max values for lat and long
for values in arrayParams["convertedPolygon"]:
latS.append(float(values[1]))
lonS.append(float(values[0]))
strGGeometry += str(values[0]) + ' ' + str(values[1]) + ','
# save the geometry into the correct format for WPS
strGGeometry = strGGeometry[0:-1]
# save min and max
strAreaToLon = np.max(lonS) + 1
strAreaFromLon = np.min(lonS) - 1
strAreaToLat = np.max(latS) + 1
strAreaFromLat = np.min(latS) - 1
# save values into the structure
arrayParams["strGGeometry"] = strGGeometry
arrayParams["strAreaToLon"] = strAreaToLon
arrayParams["strAreaFromLon"] = strAreaFromLon
arrayParams["strAreaFromLat"] = strAreaFromLat
arrayParams["strAreaToLat"] = strAreaToLat
arrayParams["geom"] = strGeom
if (blnFoundShapeFile == 1):
arrayParams["operation"] = "SHAPE"
# return common dates
arrayDates = _returnCommonDates(arrayFName_total)
# print arrayDates
# return common years
arrayYears = _returnCommonYears(arrayFName_total, arrayParams["fromYear"],
arrayParams["toYear"])
# print arrayYears
# print arrayYears
# print arrayDates
# print arrayLayers
# exit(0);
strPrevStepChart = ''
blnPrimaVoltaDebug = 1
# start the loop
if (arrayParams["append"] == 1):
# append to the csv file
#f = open(arrayParams["strCSVFile"],'ab')
import csv
with open(arrayParams["strCSVFile"], 'rb') as csvfile:
reader = csv.reader(csvfile, delimiter=' ', quotechar='|')
#lastline = reader.next()
rows = list(reader)
lngNum = int(len(rows))
if (lngNum > 1):
strTemp = rows[lngNum - 1]
arrayTemp = strTemp[0].split(',')
strDate = arrayTemp[0]
arrayTempDate = strDate.split('-')
arrayParams["fromYear"] = int(arrayTempDate[0])
arrayParams["fromMonth"] = int(arrayTempDate[1])
arrayNewYears = []
for lngYear in arrayYears:
if (lngYear >= arrayParams["fromYear"]):
arrayNewYears.append(int(lngYear))
arrayYears = arrayNewYears
for lngYear in arrayYears:
# loop over days
for lngDay in arrayDates:
# verify if the year if a leap year
strTempDate = _returnIfLeapYear(lngDay, lngYear)
strTempDateOr = strTempDate
# extrapolate month
lngMonth = int(strTempDate.month)
# date
strTempDate = strTempDate.isoformat()
# verify date with input parameters
blnContinueDate = 1
if (lngYear == arrayParams["fromYear"]):
if (lngMonth < arrayParams["fromMonth"]):
blnContinueDate = 0
if (lngYear == arrayParams["toYear"]):
if (lngMonth > arrayParams["toMonth"]):
blnContinueDate = 0
# date
if (blnContinueDate == 1):
strLine = str(strTempDate[:10]) + ','
# for each layer
for xx in range(0, len(arrayLayers), 1):
strLayer = arrayLayers[xx]
if (blnDebug == 1):
print strLayer
# lngCont=0;
# arrayValues=[]
# shape dataset or mosaic
arrayParams["strCoverage"] = strLayer
arrayFName = arrayFName_total[xx]
strLayersDescr += arrayFName["description"] + '#'
if arrayVDataset_total[xx]:
arrayVDataset = arrayVDataset_total[xx]
arrayFName_deviation = []
if (arrayParams["blnDeviation"] == 1):
if ((arrayFNameSD_total)
and (len(arrayFNameSD_total) > xx)):
arrayFName_deviation = arrayFNameSD_total[xx]
if ((arrayVDatasetSD_total)
and (len(arrayVDatasetSD_total) > xx)):
arrayVDataset_deviation = arrayVDatasetSD_total[xx]
# input parameters
# if is a point, the system retrieve 3 x 3 pixels and
# extrapolate the 1,1
if (arrayParams["operation"] == "POINT"):
# return cell 3 * 3
arrayParams["txtLLon"] = arrayParams[
"originaltxtLLon"] - (arrayVDataset["xsize"] * 1.6)
arrayParams["txtLLat"] = arrayParams[
"originaltxtLLat"] - (arrayVDataset["ysize"] * 1.6)
arrayParams["txtRLon"] = arrayParams[
"originaltxtRLon"] + (arrayVDataset["xsize"] * 1.6)
arrayParams["txtULat"] = arrayParams[
"originaltxtULat"] + (arrayVDataset["ysize"] * 1.6)
# calculare width and height
widthValue = int(
((arrayParams["txtRLon"] - arrayParams["txtLLon"]) /
arrayVDataset["xsize"]))
heightValue = int(
((arrayParams["txtULat"] - arrayParams["txtLLat"]) /
arrayVDataset["ysize"]))
# minimun value
if (widthValue < 1):
widthValue = 1
if (heightValue < 1):
heightValue = 1
arrayParams["widthValue"] = widthValue
arrayParams["heightValue"] = heightValue
lngValue = ''
blnContinueDateLayer = 0
# verify if the dateset exists for the specific date
if (blnDebug == 1):
if (blnPrimaVoltaDebug == 1):
print arrayFName["dates_available"]
blnPrimaVoltaDebug = 0
strTempDateOrUp = _replaceDateFormat(
strTempDateOr, arrayFName["dateFormat"])
# print strTempDateOrUp
# print strTempDateOrUp
blnContinueDateLayer = _verifyIfDateIsAvailable(
strTempDateOrUp, strLayer, arrayFName["type"],
arrayFName["dates_available"], arrayFName["fixed"],
arrayFName["dateFormat"])
arrayTemp = arrayFName["formula"].split('_')
if (blnContinueDateLayer == 1):
if (blnDebug == 1):
print "date ok: "
print strTempDateOrUp
arrayParams["strCoverage"] = strLayer
#======================================================
# SHAPEFILE (mosaic or dataset)
#======================================================
if ((arrayFName["type"] == "s_m")
or (arrayFName["type"] == "s_d")):
strResult_var = ""
if (arrayFName["type"] == "s_d"):
# no data to save if it is a dataset
arrayParams["strDate"] = ''
else:
# save info for date
pos = arrayFName["fixed"].find("_")
if (pos == 4):
strTestDate = str(strTempDate)[0:pos]
else:
strTestDate = str(
strTempDate[:10]).replace("-", "")
# strTempNameOriginal=arrayFName["name"]
arrayParams["strDate"] = strTestDate
#==================================================
# QUERY FEATURE (WFS)
#==================================================
result = queryFeature(arrayFName, arrayVDataset,
arrayParams, lngDay,
arrayFName["returnid"], '')
strResult_var = ''
if (result["result"] == 1):
strResult_var = result["value"]
lngValue = ''
if (strResult_var != ""):
lngValue = float(strResult_var)
#======================================================
# SHAPEFILE (mosaic or dataset)
#======================================================
else:
#==================================================
# RASTER (mosaic or dataset)
#==================================================
if (arrayParams["operation"] == "POINT"
or arrayParams["operation"] == "BOX"):
#==============================================
# COVERAGE (WCS)
#==============================================
data = returnCoverageMeanValue(
arrayParams["operation"], strTempDate,
arrayParams, arrayFName, arrayVDataset, '',
0)
else:
#==============================================
# CROP COVERAGE (WPS)
#==============================================
data = returnCropCoverageMeanValue(
arrayParams["operation"], strTempDate,
arrayParams, arrayFName, arrayVDataset, '',
0)
# print data
strResult_var = str(
_returnMeanValue(arrayParams["operation"],
data, arrayVDataset,
arrayFName["formula"], '', 0,
arrayFName["colorsScale"]))
# translate the value
lngValue = _returnTransformMean(
strResult_var, arrayFName, arrayVDataset, 0)
if (blnDebug == 1):
print data
print strResult_var
print lngValue
#======================================================
# RASTER (mosaic or dataset)
#======================================================
if (blnDebug == 1):
print strResult_var
print lngValue
lngValueDev = ''
strResult_dev = ''
if (arrayTemp[0] != "HISTOGRAM"):
# if the dataset is a bar, the SD doesn't work
# se e'un bar non funziona la standard deviation
# quindi inutile recuperare il valore
if (arrayParams["blnDeviation"] == 1):
if (blnDebug == 1):
print "calcolo deviation"
#==============================================
# RASTER (mosaic or dataset)
#==============================================
if ((arrayFName["type"] != "s_m")
and (arrayFName["type"] != "s_d")):
# print arrayFName_deviation
if arrayFName_deviation:
if (blnDebug == 1):
print "STANDARD deviation"
#======================================
# STANDARD DEVIATION
#======================================
arrayParams[
"strCoverage"] = arrayFName['sd']
blnContinueDateLayer = _verifyIfDateIsAvailable(
strTempDateOrUp,
arrayParams["strCoverage"],
arrayFName_deviation["type"],
arrayFName_deviation[
"dates_available"],
arrayFName_deviation["fixed"],
arrayFName_deviation["dateFormat"])
# verify if the layername exists in
# getCapabilities
if (blnContinueDateLayer == 1):
if (arrayParams["operation"]
== "POINT"
or arrayParams["operation"]
== "BOX"):
#==============================
# COVERAGE (WCS)
#==============================
data = returnCoverageMeanValue(
arrayParams["operation"],
strTempDate, arrayParams,
arrayFName_deviation,
arrayVDataset_deviation,
strResult_var, 0)
else:
#==============================
# CROP COVERAGE (WPS)
#==============================
data = returnCropCoverageMeanValue(
arrayParams["operation"],
strTempDate, arrayParams,
arrayFName_deviation,
arrayVDataset_deviation,
strResult_var, 0)
strResult_dev = str(
_returnMeanValue(
arrayParams["operation"],
data,
arrayVDataset_deviation,
arrayFName_deviation[
"formula"],
strResult_var, 0,
arrayFName["colorsScale"]))
lngValueDev = _returnTransformMean(
strResult_dev,
arrayFName_deviation,
arrayVDataset_deviation, 1)
if (blnDebug == 1):
print data
print strResult_dev
print lngValueDev
# exit(0);
else:
if (blnDebug == 1):
print "SPATIAL deviation"
#======================================
# SPATIAL DEVIATION
#======================================
if (arrayTemp[0] != "STEPCHART"):
# if (arrayParams["operation"]=="BOX"):
# ========================================================================================
# COVERAGE (WCS)
# ========================================================================================
# data=returnCoverageMeanValue(arrayParams["operation"],strTempDate,arrayParams,arrayFName,arrayVDataset,strResult_var,1)
# else:
# if (arrayParams["operation"]=="SHAPE"):
# ========================================================================================
# CROP COVERAGE (WPS)
# ========================================================================================
# data=returnCropCoverageMeanValue(arrayParams["operation"],strTempDate,arrayParams,arrayFName,arrayVDataset,strResult_var,1)
if (arrayParams["operation"]
== "SHAPE"
or arrayParams["operation"]
== "BOX"):
strResult_dev = str(
_returnMeanValue(
arrayParams[
"operation"], data,
arrayVDataset,
arrayFName["formula"],
strResult_var, 1,
arrayFName[
"colorsScale"]))
lngValueDev = _returnTransformMean(
strResult_dev, arrayFName,
arrayVDataset, 1)
if (blnDebug == 1):
print data
print strResult_dev
print strResult_var
print lngValueDev
#==============================================
# RASTER (mosaic or dataset)
#==============================================
if (arrayTemp[0] == "STEPCHART"):
if (lngValueDev == ""):
if (lngValue == ""):
if (strPrevStepChart != ""):
lngValue = strPrevStepChart
else:
lngValue = strEmptyString
lngValue = str(lngValue).replace(",", ",,")
strPrevStepChart = str(lngValue)
# add the standard deviation to null values for
# each value
else:
lngValueDev = ''
lngValue = ''
if (arrayTemp[0] == "STEPCHART"):
'''
lngValue=strEmptyString;
if (arrayParams["blnDeviation"]==1):
lngValue=str(lngValue).replace(",", ",,");
lngValueDev=''
'''
lngValue = strPrevStepChart
if (strPrevStepChart == ""):
lngValue = strEmptyString
if (arrayParams["blnDeviation"] == 1):
lngValue = str(lngValue).replace(",", ",,")
lngValueDev = ''
strLine += str(lngValue) + ',' + str(lngValueDev) + ','
# save the line
strLine = strLine[:-1] + '\n'
if (blnDebug == 1):
print strLine
exit(0)
# save the data into the .csv
_formatCsvFile(strLine, arrayParams["strCSVFile"])
# exit(0);
# return the http filename
# strHttpFilename=_returnHttpFilename(arrayParams["strCSVFile"]);
response['result'] = 1
response['error'] = ''
# return
print(json.JSONEncoder().encode(response))