def interpolar_todas_as_imagens(self, paramIn):
self.print_text(u"Lendo imagens e criando arquivos para a interpolação")
resposta = self.function.executar(paramIn)
if self.funcao_cancelada() : return
CSVs = resposta["CSVs"]
VRTs = resposta["VRTs"]
self.print_text(u"Número de imagens identificadas para interpolar: " + str(len(CSVs)))
self.function.progresso = 0.0
conf_algoritimo = TableData()
conf_algoritimo["power"] = str(self.ui.txPower.value())
conf_algoritimo["radius"] = str(self.ui.txRadius.value())
conf_algoritimo["max_points"] = str(self.ui.txMaxPoint.value())
conf_algoritimo["min_points"] = str(self.ui.txMinPoint.value())
conf_img_out = RasterFile(file_full_path=str(self.ui.txImgReference.text())).getRasterInformation()
self.console(u"Interpolando imagens...")
for i in range(len(CSVs)):
img_out = RasterFile(file_full_path=VRTs[i].file_full_path)
img_out.file_ext = "tif"
paramIn = TableData()
paramIn["csv"] = CSVs[i]
paramIn["vrt"] = VRTs[i]
paramIn["img_out_config"] = conf_img_out
paramIn["conf_algoritimo"] = conf_algoritimo
paramIn["img_out"] = img_out
self.function = IDW()
self.function.setProgresso(i, len(CSVs))
self.function.data = paramIn
imagem_interpolada = self.function.data
self.print_text("Imagem interpolada: " + imagem_interpolada.file_name)
if self.funcao_cancelada(): return
return "tudo certo!"
def interpolar_todas_as_imagens(self, paramIn):
self.print_text(u"Lendo imagens e criando arquivos para a interpolação")
resposta = self.function.executar(paramIn)
if self.funcao_cancelada() : return
CSVs = resposta["CSVs"]
VRTs = resposta["VRTs"]
self.print_text(u"Número de imagens identificadas para interpolar: " + str(len(CSVs)))
self.function.progresso = 0.0
conf_algoritimo = TableData()
conf_algoritimo["power"] = str(self.ui.txPower.value())
conf_algoritimo["radius"] = str(self.ui.txRadius.value())
conf_algoritimo["max_points"] = str(self.ui.txMaxPoint.value())
conf_algoritimo["min_points"] = str(self.ui.txMinPoint.value())
conf_img_out = RasterFile(file_full_path=str(self.ui.txImgReference.text())).getRasterInformation()
self.console(u"Interpolando imagens...")
for i in range(len(CSVs)):
img_out = RasterFile(file_full_path=VRTs[i].file_full_path)
img_out.file_ext = "tif"
paramIn = TableData()
paramIn["csv"] = CSVs[i]
paramIn["vrt"] = VRTs[i]
paramIn["img_out_config"] = conf_img_out
paramIn["conf_algoritimo"] = conf_algoritimo
paramIn["img_out"] = img_out
self.function = IDW()
self.function.setProgresso(i, len(CSVs))
self.function.data = paramIn
imagem_interpolada = self.function.data
self.print_text("Imagem interpolada: " + imagem_interpolada.file_name)
if self.funcao_cancelada(): return
return "tudo certo!"
def __execOperation__(self):
'''
Por padrão agora assumo que, quando uma variavel tiver como sufixo um underline "_"
é porque esta variavel contem os valores carregados (matrizes brutas) dos dados
'''
serie_ET0 = self.paramentrosIN_carregados["ET0"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
serie_Kc = self.paramentrosIN_carregados["Kc"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
serie_ETc = self.paramentrosIN_carregados["ETc"] # pucha lista
Kc_factor = float(serie_Kc.mutiply_factor)
ET0_factor = serie_ET0.mutiply_factor
ETC_factor = serie_ETc.mutiply_factor
for i_Kc in range(len(serie_Kc)):
#gdal_calc.py [-A <filename>] [--A_band] [-B...-Z filename] [other_options]
Kc = serie_Kc[i_Kc]
data_kc = serie_Kc.getDate_time(file=Kc)
ET0 = self.procurar_descende_correspondente(data_kc, serie_ET0)
etc = RasterFile(file_path=serie_ETc.root_path, ext="tif", file_name=Kc.file_name)
ET0_ = numpy.array(ET0.loadRasterData()).astype(dtype="float32") * ET0_factor
Kc_ = numpy.array(Kc.loadRasterData()).astype(dtype="float32") * Kc_factor
dias_decend = self.dias_decend
ETc_ = Kc_ * (ET0_ / dias_decend) * ETC_factor
#print ET0.file_full_path
#print Kc.file_full_path
etc.metadata = Kc.metadata
etc.data = ETc_
etc.saveRasterData()
def __execOperation__(self):
self.console("Carregando imagens.")
serie_Zr = self.paramentrosIN_carregados["Zr"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
serie_TAW = self.paramentrosIN_carregados["TAW"]
CAD_ = self.paramentrosIN_carregados["CAD"].loadRasterData() # pucha lista
Zr_factor = float(serie_Zr.mutiply_factor)
TAW_factor = float(serie_TAW.mutiply_factor)
n_zr = len(serie_Zr)
self.console(str(n_zr) + " imagens de Zr encontradas.")
self.console(u"Gerando série de imagens TAW..")
'''
O laço a seguir percorre todas as imagens de Zr presentes
O calculo da TAW é Zr = CAD * Zr
'''
for i in range(n_zr):
if threading.currentThread().stopped() : return
self.setProgresso(i, n_zr)
zr = serie_Zr[i]
data_zr = serie_Zr.getDate_time(file=zr)
zr_ = numpy.array(zr.loadRasterData()).astype(dtype="float32")
zr_ = zr_ * Zr_factor
taw_ = zr_ * CAD_
taw_ *= TAW_factor
taw = RasterFile(file_path=serie_TAW.root_path, ext="tif")
taw = serie_TAW.setDate_time(data_zr, file=taw)
taw.data = taw_
taw.metadata = zr.metadata
taw.saveRasterData()
taw.data = None
serie_TAW.append(taw)
return serie_TAW
def __execOperation__(self):
'''
Por padrão agora assumo que, quando uma variavel tiver como sufixo um underline "_"
é porque esta variavel contem os valores carregados (matrizes brutas) dos dados
'''
serie_ET0 = self.paramentrosIN_carregados["ET0"].loadListByRoot(
) # pucha e já carrega a lista caso não tenha sido carregada
serie_Kc = self.paramentrosIN_carregados["Kc"].loadListByRoot(
) # pucha e já carrega a lista caso não tenha sido carregada
serie_ETc = self.paramentrosIN_carregados["ETc"] # pucha lista
Kc_factor = float(serie_Kc.mutiply_factor)
ET0_factor = serie_ET0.mutiply_factor
ETC_factor = serie_ETc.mutiply_factor
for i_Kc in range(len(serie_Kc)):
#gdal_calc.py [-A <filename>] [--A_band] [-B...-Z filename] [other_options]
Kc = serie_Kc[i_Kc]
data_kc = serie_Kc.getDate_time(file=Kc)
ET0 = self.procurar_descende_correspondente(data_kc, serie_ET0)
etc = RasterFile(file_path=serie_ETc.root_path,
ext="tif",
file_name=Kc.file_name)
ET0_ = numpy.array(
ET0.loadRasterData()).astype(dtype="float32") * ET0_factor
Kc_ = numpy.array(
Kc.loadRasterData()).astype(dtype="float32") * Kc_factor
dias_decend = self.dias_decend
ETc_ = Kc_ * (ET0_ / dias_decend) * ETC_factor
#print ET0.file_full_path
#print Kc.file_full_path
etc.metadata = Kc.metadata
etc.data = ETc_
etc.saveRasterData()
def __execOperation__(self):
'''
Por padrão agora assumo que, quando uma variavel tiver como sufixo um underline "_"
é porque esta variavel contem os valores carregados (matrizes brutas) dos dados
'''
self.print_text("Carregando imagens.")
serie_ET0 = self.paramentrosIN_carregados["ET0"].loadListByRoot(
) # pucha e já carrega a lista caso não tenha sido carregada
serie_Kc = self.paramentrosIN_carregados["Kc"].loadListByRoot(
) # pucha e já carrega a lista caso não tenha sido carregada
serie_ETc = self.paramentrosIN_carregados["ETc"] # pucha lista
#Kc_factor = float(serie_Kc.mutiply_factor)
#ET0_factor = float(serie_ET0.mutiply_factor)
#ETC_factor = float(serie_ETc.mutiply_factor)
n_et0 = len(serie_ET0)
#self.console(str(n_et0) + " imagens de ET0 encontradas.")
#self.console(str(len(serie_Kc)) + " imagens de Kc encontradas.")
self.console(u"Gerando imagens de saída...")
'''
O laço a seguir percorre todas as imagens de ET0 presentes
ele verifica se há imagens de Kc correspondentes para realizar a multiplicação
caso não haja ele simplesmente mantém a imagem de ET0 como imagem de ETc
O calculo de Etc é Etc = Et0 * Kc
'''
for i_ET0 in range(n_et0):
if threading.currentThread().stopped(): return
self.setProgresso(i_ET0, n_et0)
ET0 = serie_ET0[i_ET0]
data_ET0 = serie_ET0.getDate_time(file=ET0)
kc = None
data = None
for i_Kc in range(len(serie_Kc)):
data = serie_Kc.getDate_time(file=serie_Kc[i_Kc])
if data == data_ET0:
kc = serie_Kc[i_Kc]
break
etc = RasterFile(file_path=serie_ETc.root_path, ext="tif")
etc = serie_ETc.setDate_time(data_ET0, file=etc)
ET0_ = numpy.array(ET0.loadRasterData()).astype(
dtype="float32") #* ET0_factor
ET0_[ET0_ == ET0.metadata["nodata"]] = 0
#ET0_ = ET0_ * ET0_factor # Problemas com o factor
if kc == None: # caso não encontre nenhum kc correspondente a mesma data
#self.console(u"Kc para o dia" + str(data))
ETc_ = ET0_
#ETc_ *= ETC_factor # Problemas com o factor
#ETc_ = self.compactar(ETc_)
etc.data = ETc_
else:
Kc_ = numpy.array(kc.loadRasterData()).astype(dtype="float32")
#Kc_ *= Kc_factor # Problemas com o factor
ETc_ = Kc_ * ET0_
#ETc_ *= ETC_factor # Problemas com o factor
#ETc_ = self.compactar(ETc_) # Problemas com o factor
etc.data = ETc_
etc.metadata = ET0.metadata
etc.metadata.update(nodata=0)
etc.metadata.update(dtype=etc.data.dtype)
etc.saveRasterData()
serie_ETc.append(etc)
self.console(u"Concluído")
return serie_ETc
def __execOperation__(self):
self.console("Carregando imagens.")
serie_eta = self.paramentrosIN_carregados["ETa"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
serie_etc = self.paramentrosIN_carregados["ETc"].loadListByRoot()
serie_yx = self.paramentrosIN_carregados["Yx"].loadListByRoot() # pucha lista
serie_Kc = self.paramentrosIN_carregados["Kc"].loadListByRoot() # pucha lista
serie_ya = self.paramentrosIN_carregados["Ya"]
ky = self.paramentrosIN_carregados["Ky"]
#factor_eta = float(serie_eta.mutiply_factor)
#factor_etc = float(serie_etc.mutiply_factor)
#factor_yx = float(serie_yx.mutiply_factor)
#factor_ya = float(serie_ya.mutiply_factor)
n_img = len(serie_Kc)
self.console("As imagens de Kc serão usadas como referencia")
self.console(str(n_img) + " imagens de Kc encontradas.")
self.console(u"Gerando série de imagens de Ya..")
for i in range(n_img):
if threading.currentThread().stopped() : return
self.setProgresso(i, n_img)
kc = serie_Kc[i]
data_ref = serie_Kc.getDate_time(file=kc)
kc_ = kc.loadRasterData()
#eta_ = self.LoadImgByDate(serie_eta, data_ref, factor_eta)
#etc_ = self.LoadImgByDate(serie_etc, data_ref, factor_etc)
#yx_ = self.LoadImgByDate(serie_yx, data_ref, factor_yx)
eta_ = self.LoadImgByDate(serie_eta, data_ref)
etc_ = self.LoadImgByDate(serie_etc, data_ref)
yx_ = self.LoadImgByDate(serie_yx, data_ref)
p1= ky * (1-eta_/etc_)
ya_ = (1-p1) * yx_
for i in range(len(ya_)):
ya_[i][kc_[i]==0] = 0
#ya_ = numpy.round(ya_, 3)
#ya_ *= factor_ya
#ya_ = self.compactar(ya_)
ya = RasterFile(file_path=serie_ya.root_path, ext="tif")
ya = serie_ya.setDate_time(data_ref, file=ya)
ya.data = ya_
ya.metadata = kc.metadata
ya.metadata.update(nodata=0)
ya.saveRasterData()
ya.data = ya_
serie_ya.append(ya)
return serie_ya
def __execOperation__(self):
serie_raw = self.paramentrosIN_carregados["RAW"].loadListByRoot()
serie_taw = self.paramentrosIN_carregados["TAW"].loadListByRoot()
serie_dr = self.paramentrosIN_carregados["Dr"].loadListByRoot()
serie_ks = self.paramentrosIN_carregados["Ks"]
#factor_raw = float(serie_raw.mutiply_factor)
#factor_taw = float(serie_taw.mutiply_factor)
#factor_dr = float(serie_dr.mutiply_factor)
#factor_ks = float(serie_ks.mutiply_factor)
n_taw = len(serie_taw)
taw_ = serie_taw[0].loadRasterData()
n_linhas = len(taw_)
n_colunas = len(taw_[0])
for i in range(n_taw):
if threading.currentThread().stopped(): return
self.setProgresso(i, n_taw)
taw = serie_taw[i]
data_taw = serie_taw.getDate_time(file=taw)
taw_ = numpy.array(taw.loadRasterData()).astype(dtype="float32")
#taw_ *= factor_taw
raw_ = self.LoadImgByDate(serie_raw, data_taw, 1)
dr_ = self.LoadImgByDate(serie_dr, data_taw, 1)
if dr_ is None:
self.console(u"Aviso: Imagem de Dr para a data: " +
str(data_taw))
if raw_ is None:
self.console(u"Aviso: Imagem de RAW para a data: " +
str(data_taw))
if dr_ is not None and raw_ is not None:
''' ----------------------------------------------- '''
ks_ = numpy.zeros((n_linhas, n_colunas))
#ks_ +=1
''' ----------------------------------------------- '''
a = (taw_ - (-dr_))
b = (taw_ - raw_)
c = a / b
for i in range(len(ks_)):
ks_[i][-dr_[i] >= raw_[i]] = c[i][-dr_[i] >= raw_[i]]
ks_[i][-dr_[i] < raw_[i]] = 1
ks_[i][ks_[i] == -float('Inf')] = -1
ks_[i][taw_[i] == float('NaN')] = -1
#ks_[i][taw_[i] == 127] = taw.metadata["nodata"]
#ks_[i][raw_[i] == 0] = taw.metadata["nodata"]
''' ------------------------------------------------ '''
#ks_ = numpy.round(ks_, 2)
#ks_ *= factor_ks
#ks_ = self.compactar(ks_)
#ks_ = numpy.ma.masked_array(ks_, 999)
ks_ = 1 - ks_ # invertendo o Ks pra dar certo na formulas
print("Valor de taw_:" + str(taw_[60][83]))
print("Valor de raw_:" + str(raw_[60][83]))
print("Valor de dr_:" + str(dr_[60][83]))
print("Valor de Ks:" + str(ks_[60][83]))
print("------------------------------")
#print data_taw
#for i in range(n_linhas):
#for ii in range(n_colunas):
#if taw_[i][ii] != 0.0 and taw_[i][ii] != 127.0 and ks_[i][ii] != 1 and ks_[i][ii] != 0:
#print a[i][ii], b[i][ii], c[i][ii]
#print taw_[i][ii], raw_[i][ii], dr_[i][ii], ks_[i][ii]
#print "----------------------------------"
ks = RasterFile(file_path=serie_ks.root_path, ext="tif")
ks = serie_ks.setDate_time(data_taw, file=ks)
ks.data = ks_.astype(dtype="float32")
ks.metadata = taw.metadata
ks.metadata.update(dtype=ks.data.dtype)
ks.metadata.update(nodata=2)
ks.saveRasterData()
ks.data = None
serie_ks.append(ks)
return serie_ks
def __execOperation__(self):
self.console("Carregando imagens.")
serie_Zr = self.paramentrosIN_carregados["Zr"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
serie_TAW = self.paramentrosIN_carregados["TAW"]
CAD_ = self.paramentrosIN_carregados["CAD"].loadRasterData() # pucha lista
p_valor = self.paramentrosIN_carregados["p"]
p_valor = float(p_valor)
#print self.paramentrosIN_carregados["CAD"].metadata
#CAD_ = numpy.ma.masked_array(CAD_, self.paramentrosIN_carregados["CAD"].metadata["nodata"])
#Zr_factor = float(serie_Zr.mutiply_factor)
#TAW_factor = float(serie_TAW.mutiply_factor)
n_zr = len(serie_Zr)
self.console(str(n_zr) + " imagens de Zr encontradas.")
self.console(u"Gerando série de imagens...")
'''
O laço a seguir percorre todas as imagens de Zr presentes
O calculo da TAW é Zr = CAD * Zr
'''
for i in range(n_zr):
if threading.currentThread().stopped() : return
self.setProgresso(i, n_zr)
zr = serie_Zr[i]
data_zr = serie_Zr.getDate_time(file=zr)
zr_ = numpy.array(zr.loadRasterData()).astype(dtype="float32")
n_linhas = len(zr_)
n_colunas = len(zr_[0])
taw_ = numpy.zeros((n_linhas, n_colunas)).astype(dtype="float32")
CAD_ = numpy.array(CAD_).astype(dtype = "float32")
#zr_ = numpy.ma.array(zr_, mask=float(zr.metadata["nodata"]))
#print ("Valor Zr: " + str(zr_[0][0]))
#print ("Valor CAD: " + str(CAD_[0][0]))
#print ("Valor p: " + str(p_valor))
taw_ = zr_ * CAD_ * p_valor
#print ("Valor TAW: " + str(taw_[0][0]))
taw = RasterFile(file_path=serie_TAW.root_path, ext="tif")
taw = serie_TAW.setDate_time(data_zr, file=taw)
taw.data = taw_
taw.metadata = zr.metadata
taw.metadata.update(dtype = taw.data.dtype)
taw.metadata.update(nodata = -2147483647)
taw.saveRasterData()
taw.data = None
serie_TAW.append(taw)
return serie_TAW
from numpy import ma
import numpy
from Modelo.beans.RasterData import RasterFile
if __name__ == '__main__':
img = RasterFile(file_full_path="C:\\Gafanhoto WorkSpace\\Soja11_12\\Tratamento de dados\\Modis\\DATAS\\32bSigned\\semeadura.tif")
img_ = img.loadRasterData()
print numpy.min(img_)
def __execOperation__(self):
self.console("Carregando imagens.")
serie_Etc = self.paramentrosIN_carregados["Etc"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
serie_PPP = self.paramentrosIN_carregados["PPP"].loadListByRoot()
serie_TAW = self.paramentrosIN_carregados["TAW"].loadListByRoot()
serie_Dr = self.paramentrosIN_carregados["Dr"]
CAD_ = self.paramentrosIN_carregados["CAD"].loadRasterData()
Etc_factor = float(serie_Etc.mutiply_factor)
PPP_factor = float(serie_PPP.mutiply_factor)
TAW_factor = float(serie_TAW.mutiply_factor)
Dr_factor = float(serie_Dr.mutiply_factor)
n_ppp = len(serie_PPP)
self.console(str(n_ppp) + u" imagens de precipitação encontradas.")
self.console(str(len(serie_Etc)) + u" imagens de Etc encontradas.")
self.console(str(len(serie_TAW)) + u" imagens de TAW encontradas.")
self.console(u"Gerando balanço...")
'''
O laço a seguir percorre todas as imagens de Zr presentes
O calculo da TAW é Zr = CAD * Zr
'''
Dr_anterior = None
for i in range(n_ppp):
if threading.currentThread().stopped() : return
self.setProgresso(i, n_ppp)
ppp = serie_PPP[i]
data_ppp = serie_PPP.getDate_time(file=ppp)
ppp_ = numpy.array(ppp.loadRasterData()).astype(dtype="float32")
ppp_ *= PPP_factor
etc = self.procura_img_por_data(serie_Etc, data_ppp)
etc_ = numpy.array(etc.loadRasterData()).astype(dtype="float32")
etc_ *= Etc_factor
taw = self.procura_img_por_data(serie_TAW, data_ppp)
if taw is not None :
taw_ = numpy.array(taw.loadRasterData()).astype(dtype="float32")
taw_ *= TAW_factor
else :
taw_ = CAD_
if Dr_anterior != None:
ppp_ -= Dr_anterior
Dr_ = etc_ - ppp_
for i in range(len(taw_)) :
Dr_[i][-Dr_[i] > taw_[i]] = -taw_[i][-Dr_[i] > taw_[i]]
"isso aqui em baixo é pro balanço idrico nao ser menor que 0 ou seja o Dr nao pode ser maior q 0"
Dr_[i][Dr_[i] > 0] = 0
Dr_anterior = numpy.copy(Dr_)
Dr_ = numpy.round(Dr_, 2)
Dr_ *= Dr_factor
Dr_ = self.compactar(Dr_)
dr = RasterFile(file_path=serie_Dr.root_path, ext="tif")
dr = serie_Dr.setDate_time(data_ppp, file=dr)
dr.data = Dr_
dr.metadata = ppp.metadata
dr.saveRasterData()
dr.data = None
serie_Dr.append(dr)
return serie_Dr
def __execOperation__(self):
'''
Por padrão agora assumo que, quando uma variavel tiver como sufixo um underline "_"
é porque esta variavel contem os valores carregados (matrizes brutas) dos dados
'''
self.print_text("Carregando imagens.")
serie_ET0 = self.paramentrosIN_carregados["ET0"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
serie_Kc = self.paramentrosIN_carregados["Kc"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
serie_ETc = self.paramentrosIN_carregados["ETc"] # pucha lista
Kc_factor = float(serie_Kc.mutiply_factor)
ET0_factor = float(serie_ET0.mutiply_factor)
ETC_factor = float(serie_ETc.mutiply_factor)
n_et0 = len(serie_ET0)
#self.console(str(n_et0) + " imagens de ET0 encontradas.")
#self.console(str(len(serie_Kc)) + " imagens de Kc encontradas.")
self.console(u"Gerando imagens de saída...")
'''
O laço a seguir percorre todas as imagens de ET0 presentes
ele verifica se há imagens de Kc correspondentes para realizar a multiplicação
caso não haja ele simplesmente mantém a imagem de ET0 como imagem de ETc
O calculo de Etc é Etc = Et0 * Kc
'''
for i_ET0 in range(n_et0):
if threading.currentThread().stopped() : return
self.setProgresso(i_ET0, n_et0)
ET0 = serie_ET0[i_ET0]
data_ET0 = serie_ET0.getDate_time(file=ET0)
kc = None
for i_Kc in range(len(serie_Kc)):
data = serie_Kc.getDate_time(file=serie_Kc[i_Kc])
if data == data_ET0:
kc = serie_Kc[i_Kc]
break
etc = RasterFile(file_path=serie_ETc.root_path, ext="tif")
#print data_ET0
#print kc
etc = serie_ETc.setDate_time(data_ET0, file=etc)
ET0_ = numpy.array(ET0.loadRasterData()).astype(dtype="float32") #* ET0_factor
ET0_[ET0_==ET0.metadata["nodata"]] = 0
ET0_ = ET0_ * ET0_factor
if kc == None: # caso não encontre nenhum kc correspondente a mesma data
ETc_ = ET0_
ETc_ *= ETC_factor
ETc_ = self.compactar(ETc_)
etc.data = ETc_
else:
Kc_ = numpy.array(kc.loadRasterData()).astype(dtype="float32")
Kc_ *= Kc_factor
'''1 é o valor default pra quando o Kc for 0 isso tem que ser visto'''
#Kc_[Kc_==0] = 1
#print ET0.metadata
#print kc.metadata
ETc_ = Kc_ * ET0_
ETc_ = numpy.round(ETc_, 2)
print "Etc", Kc_[695][879]
print "Ks", ET0_[695][879]
print "ETs", ETc_[695][879]
ETc_ *= ETC_factor
ETc_ = self.compactar(ETc_)
print "ETs", ETc_[695][879]
etc.data = ETc_
etc.metadata = ET0.metadata
etc.metadata.update(nodata=0)
etc.saveRasterData()
serie_ETc.append(etc)
self.console(u"Concluído")
return serie_ETc
def __execOperation__(self):
self.console("Carregando imagens.")
serie_Etc = self.paramentrosIN_carregados["Etc"].loadListByRoot(
) # pucha e já carrega a lista caso não tenha sido carregada
serie_PPP = self.paramentrosIN_carregados["PPP"].loadListByRoot()
serie_TAW = self.paramentrosIN_carregados["TAW"].loadListByRoot()
serie_Dr = self.paramentrosIN_carregados["Dr"]
CAD_ = self.paramentrosIN_carregados["CAD"].loadRasterData()
#Etc_factor = float(serie_Etc.mutiply_factor)
#PPP_factor = float(serie_PPP.mutiply_factor)
#TAW_factor = float(serie_TAW.mutiply_factor)
#Dr_factor = float(serie_Dr.mutiply_factor)
n_ppp = len(serie_PPP)
self.console(str(n_ppp) + u" imagens de precipitação encontradas.")
self.console(str(len(serie_Etc)) + u" imagens de Etc encontradas.")
self.console(str(len(serie_TAW)) + u" imagens de TAW encontradas.")
self.console(u"Gerando balanço...")
'''
O laço a seguir percorre todas as imagens de Zr presentes
O calculo da TAW é Zr = CAD * Zr
'''
Dr_anterior = None
for i in range(n_ppp):
if threading.currentThread().stopped(): return
self.setProgresso(i, n_ppp)
ppp = serie_PPP[i]
data_ppp = serie_PPP.getDate_time(file=ppp)
ppp_ = numpy.array(ppp.loadRasterData()).astype(dtype="float32")
#ppp_ *= PPP_factor
etc = self.procura_img_por_data(serie_Etc, data_ppp)
if etc is None:
self.console(
u"ERRO: não foi encontrado imagem de etc para a data: " +
data_ppp.strftime('%d/%m/%Y') + "!")
self.console(u"Confira as datas e as máscaras de tempo.")
threading.currentThread().stop()
return
etc_ = numpy.array(etc.loadRasterData()).astype(dtype="float32")
#etc_ *= Etc_factor
taw = self.procura_img_por_data(serie_TAW, data_ppp)
if taw is not None:
taw_ = numpy.array(
taw.loadRasterData()).astype(dtype="float32")
#taw_ *= TAW_factor
else:
taw_ = CAD_
if Dr_anterior != None:
ppp_ -= Dr_anterior
Dr_ = etc_ - ppp_
for i in range(len(taw_)):
Dr_[i][-Dr_[i] > taw_[i]] = -taw_[i][-Dr_[i] > taw_[i]]
#"isso aqui em baixo é pro balanço idrico nao ser menor que 0 ou seja o Dr nao pode ser maior q 0"
Dr_[i][Dr_[i] > 0] = 0
Dr_anterior = numpy.copy(Dr_)
#Dr_ = numpy.round(Dr_, 2)
#Dr_ *= Dr_factor
#Dr_ = self.compactar(Dr_)
dr = RasterFile(file_path=serie_Dr.root_path, ext="tif")
dr = serie_Dr.setDate_time(data_ppp, file=dr)
dr.data = Dr_
dr.metadata = ppp.metadata
dr.metadata.update(dtype=dr.data.dtype)
dr.saveRasterData()
dr.data = None
serie_Dr.append(dr)
return serie_Dr
def __execOperation__(self):
serie_raw = self.paramentrosIN_carregados["RAW"].loadListByRoot()
serie_taw = self.paramentrosIN_carregados["TAW"].loadListByRoot()
serie_dr = self.paramentrosIN_carregados["Dr"].loadListByRoot()
serie_ks = self.paramentrosIN_carregados["Ks"]
factor_raw = float(serie_raw.mutiply_factor)
factor_taw = float(serie_taw.mutiply_factor)
factor_dr = float(serie_dr.mutiply_factor)
factor_ks = float(serie_ks.mutiply_factor)
n_taw = len(serie_taw)
taw_ = serie_taw[0].loadRasterData()
n_linhas = len(taw_)
n_colunas = len(taw_[0])
for i in range(n_taw):
if threading.currentThread().stopped() : return
self.setProgresso(i, n_taw)
taw = serie_taw[i]
data_taw = serie_taw.getDate_time(file=taw)
taw_ = numpy.array(taw.loadRasterData()).astype(dtype="float32")
taw_ *= factor_taw
raw_ = self.LoadImgByDate(serie_raw, data_taw, factor_raw)
dr_ = self.LoadImgByDate(serie_dr, data_taw, factor_dr)
''' ----------------------------------------------- '''
ks_ = numpy.zeros((n_linhas, n_colunas))
#ks_ +=1
''' ----------------------------------------------- '''
a = (taw_ - (- dr_))
b = (taw_ - raw_)
c = a / b
for i in range(len(ks_)) :
ks_[i][-dr_[i] >= raw_[i]] = c[i][-dr_[i] >= raw_[i]]
ks_[i][-dr_[i] < raw_[i]] = 1
ks_[i][ks_[i] == -float('Inf')] = 2
ks_[i][taw_[i] == float('NaN')] = 2
ks_[i][taw_[i] == 127] = 2
ks_[i][raw_[i] == 0] = 2
''' ------------------------------------------------ '''
ks_ = numpy.round(ks_, 2)
ks_ *= factor_ks
ks_ = self.compactar(ks_)
ks_ = 1 - ks_ # invertendo o Ks pra dar certo na formulas
#print data_taw
#for i in range(n_linhas):
#for ii in range(n_colunas):
#if taw_[i][ii] != 0.0 and taw_[i][ii] != 127.0 and ks_[i][ii] != 1 and ks_[i][ii] != 0:
#print a[i][ii], b[i][ii], c[i][ii]
#print taw_[i][ii], raw_[i][ii], dr_[i][ii], ks_[i][ii]
#print "----------------------------------"
ks = RasterFile(file_path=serie_ks.root_path, ext="tif")
ks = serie_ks.setDate_time(data_taw, file=ks)
ks.data = ks_
ks.metadata = taw.metadata
ks.metadata.update(nodata=200)
ks.saveRasterData()
ks.data = None
serie_ks.append(ks)
return serie_ks
def __execOperation__(self):
self.console("Carregando imagens.")
serie_eta = self.paramentrosIN_carregados["ETa"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
serie_etc = self.paramentrosIN_carregados["ETc"].loadListByRoot()
serie_yx = self.paramentrosIN_carregados["Yx"].loadListByRoot() # pucha lista
serie_Kc = self.paramentrosIN_carregados["Kc"].loadListByRoot() # pucha lista
serie_ya = self.paramentrosIN_carregados["Ya"]
ky = self.paramentrosIN_carregados["Ky"]
factor_eta = float(serie_eta.mutiply_factor)
factor_etc = float(serie_etc.mutiply_factor)
factor_yx = float(serie_yx.mutiply_factor)
factor_ya = float(serie_ya.mutiply_factor)
n_img = len(serie_Kc)
self.console("As imagens de Kc serão usadas como referencia")
self.console(str(n_img) + " imagens de Kc encontradas.")
self.console(u"Gerando série de imagens de Ya..")
for i in range(n_img):
if threading.currentThread().stopped() : return
self.setProgresso(i, n_img)
kc = serie_Kc[i]
data_ref = serie_Kc.getDate_time(file=kc)
kc_ = kc.loadRasterData()
eta_ = self.LoadImgByDate(serie_eta, data_ref, factor_eta)
etc_ = self.LoadImgByDate(serie_etc, data_ref, factor_etc)
yx_ = self.LoadImgByDate(serie_yx, data_ref, factor_yx)
p1= ky * (1-eta_/etc_)
ya_ = (1-p1) * yx_
for i in range(len(ya_)):
ya_[i][kc_[i]==0] = 0
ya_ = numpy.round(ya_, 3)
ya_ *= factor_ya
#ya_ = self.compactar(ya_)
ya = RasterFile(file_path=serie_ya.root_path, ext="tif")
ya = serie_ya.setDate_time(data_ref, file=ya)
ya.data = ya_
ya.metadata = kc.metadata
ya.metadata.update(nodata=0)
ya.saveRasterData()
ya.data = ya_
serie_ya.append(ya)
return serie_ya
