def __execOperation__(self):
serie_T = self.paramentrosIN_carregados["T"].loadListByRoot()
serie_PPR = self.paramentrosIN_carregados["PPR"]
self.Cc = self.paramentrosIN_carregados["Cc"]
matriz = serie_T[0]
matriz_ = matriz.loadRasterData()
info = matriz.getRasterInformation()
nullValue = info["NoData"]
img_lat = self.img_lat_long(info, matriz_, nullValue)
lat_rad = np.radians(img_lat)
a = float(180)/np.pi
ii=1
for T in serie_T:
if threading.currentThread().stopped() : return
start = time.time()
T_ = np.array(T.loadRasterData()).astype(dtype="float32")
data_T = serie_T.getDate_time(file=T)
dj = data_T.timetuple().tm_yday # Dia Juliano
#print dj
declinacao_solar = 23.45 * np.sin(np.radians((float(360)/float(365)) * (float(dj)-float(80))))
declinacao_solar_r = np.radians(declinacao_solar)
angulo_solar = np.arccos(np.radians(-np.tan(lat_rad) * np.tan(declinacao_solar_r))) * a
"DR = Distancia relativa sol-terra"
agulo_solar_r = np.radians(angulo_solar)
if declinacao_solar != 0:
DR = 1 + 0.0033 * np.cos(np.radians(360/(365*declinacao_solar)))
else :
DR = 1
radiacao_topo_atmosfera = 37.6 * DR * ((np.pi/180) * angulo_solar * np.sin(declinacao_solar_r) * np.sin(lat_rad) + np.cos(declinacao_solar_r) * np.cos(lat_rad) * np.sin(agulo_solar_r))
#radiacao_topo_atmosfera = radiacao_topo_atmosfera * 23.92344
ctn = 0.583 + 0.014 * T_ + 0.0013 * (T_**2) - 0.000037 * (T_**3)
ctc = -0.0425 + 0.035 * T_ + 0.00325 * (T_**2) - 0.0000925 * (T_**3)
n_t = range(len(T_))
for i in n_t:
index = [(T_[i]<16.5) & (T_[i]>37)]
ctn[i][index] = -0.0425 + 0.035 * T_[i][index] + 0.00325 * (T_[i][index]**2) - 0.0000925 * (T_[i][index]**3)
ctc[i][index] = -1.085 + 0.07 * T_[i][index] + 0.0065 * (T_[i][index]**2) - 0.000185 * (T_[i][index]**3)
PPBn = (31.7+0.219*radiacao_topo_atmosfera) * ctn * 0.6
PPBc = (107.2+0.219*radiacao_topo_atmosfera) * ctc * 0.6
PPBp = PPBn + PPBc
PPR_ = 0.265455 * self.Cc * PPBp
PPR = RasterFile(file_path=serie_PPR.root_path, ext="tif")
PPR = serie_PPR.setDate_time(data_T, file=PPR)
PPR.metadata = T.metadata
PPR.data = PPR_
PPR.saveRasterData()
PPR.data = None
serie_PPR.append(PPR)
ii +=1
end = time.time()
self.console("tempo restante(m):" + str( np.round(((end - start) * (len(serie_T)-ii)) /60, 2)))
self.setProgresso(ii, len(serie_T))
return serie_PPR
#imagem_convertida[i][ii] = delta_tempo
#n = len(str(data_pixel))
#ano_pixel = int(str(data_pixel)[0:4])
#dia_pixel = int(str(data_pixel)[4:n])
#imagem_convertida[i][ii] = (dia_pixel - dia_inicial) + (ano_pixel - ano_inicial * 365)
#except :
#pass
ano_pixel = int(str(data_pixel)[0:4])
imagem_convertida[i] = imagem[i]
progress(i/float(n_linhas-1))
print "Conversão terminada, retornando imagem"
return imagem_convertida
if __name__ == '__main__':
imagem = RasterFile(file_full_path="C:\\Gafanhoto WorkSpace\\DataTestes\\raster\\semeadura_soja_11-12.tif")
imagem_ = imagem.loadRasterData()
data_minima = Ds_DC_to_date(np.min(imagem_))
imagem.data = converter(data_minima, imagem_)
imagem.file_name = imagem.file_name + "convertida"
imagem.saveRasterData()
def __execOperation__(self):
serie_imagem_in = self.paramentrosIN_carregados["In"].loadListByRoot()
serie_imagem_out = self.paramentrosIN_carregados["Out_config"]
imagem_in_factor = float(serie_imagem_in.mutiply_factor)
imagem_out_factor = float(serie_imagem_out.mutiply_factor)
n_imagens = len(serie_imagem_in)
if n_imagens is 0:
self.console(u"Erro: Nenhuma imagem encontrada na pasta especificada.")
self.console(u"Cancelando função.")
threading.currentThread().stop()
return
self.console(u"Construindo série temporal diária...")
for i in range(n_imagens):
self.progresso = (i / float(n_imagens)) * 100
"""Recupera a data correspondente a imagem atual do laço """
data = serie_imagem_in.getDate_time(i)
dia_mes = data.day
"""Calcula quantos dias tem no decend atual"""
if dia_mes <= 10:
duracao = 10
elif dia_mes <= 20:
duracao = 10
else:
duracao = int(calendar.monthrange(data.year, data.month)[1]) - 20
if threading.currentThread().stopped():
print "thread parada, retornando da função"
return
imagem_ = serie_imagem_in[i].loadRasterData()
imagem_ *= imagem_in_factor
if self.paramentrosIN_carregados["Operation"] == "dividir valores":
imagem_ = imagem_ / float(duracao)
imagem_ = numpy.round(imagem_, 4)
elif self.paramentrosIN_carregados["Operation"] == "manter valores":
pass
imagem_ *= imagem_out_factor
# imagem_ = self.compactar(imagem_)
for ii in range(0, duracao):
img = RasterFile()
img.file_path = serie_imagem_out.root_path
data_img = data + timedelta(ii)
img.file_name = (
serie_imagem_out.prefixo + data_img.strftime(serie_imagem_out.date_mask) + serie_imagem_out.sufixo
)
img.data = imagem_
img.file_ext = "tif"
metadata = serie_imagem_in[i].metadata
# metadata.update(nodata=0)
img.saveRasterData(metadata=metadata)
print metadata
self.console(u"Série temporal diária concluída.")
from Modelo.beans import RasterFile
root = "D:\\1 - Mestrado (segundo semestre)\\Dissertacao\\Estudo de caso\\Cubos\\"
path = root + "Cubo_Ya_invertido.tif"
import numpy as np
raster = RasterFile(file_full_path = path)
data_raster = raster.loadRasterData(True)
nodata = raster.metadata["nodata"]
metadata = raster.metadata
metadata["count"] = 1
print raster.metadata
soma = imagem_kc_ = np.zeros((len(data_raster[1]), len(data_raster[1][0]))).astype(dtype="float32")
for band in data_raster:
soma += band
saida = RasterFile(file_full_path= path)
saida.file_name = "ya_invertido_soma"
saida.metadata = raster.metadata
saida.data = soma
saida.saveRasterData()
def __execOperation__(self):
self.console(u"Iniciando parametros.")
serie_T = self.paramentrosIN_carregados["T"].loadListByRoot()
serie_PPR = self.paramentrosIN_carregados["PPR"]
self.Cc = self.paramentrosIN_carregados["Cc"]
matriz = serie_T[0]
matriz_ = matriz.loadRasterData()
info = matriz.getRasterInformation()
nullValue = info["NoData"]
img_lat = self.img_lat_long(info, matriz_, nullValue)
lat_rad = np.radians(img_lat)
a = float(180) / np.pi
ii = 1
n_imagens = len(serie_T)
self.console(u"Número de imagens de encontradas: " + str(n_imagens))
self.console(u"Processando...")
for T in serie_T:
if threading.currentThread().stopped(): return
#start = time.time()
T_ = np.array(T.loadRasterData()).astype(dtype="float32")
data_T = serie_T.getDate_time(file=T)
dj = data_T.timetuple().tm_yday # Dia Juliano
#print dj
declinacao_solar = 23.45 * np.sin(
np.radians(
(float(360) / float(365)) * (float(dj) - float(80))))
declinacao_solar_r = np.radians(declinacao_solar)
angulo_solar = np.arccos(
np.radians(-np.tan(lat_rad) * np.tan(declinacao_solar_r))) * a
"DR = Distancia relativa sol-terra"
agulo_solar_r = np.radians(angulo_solar)
if declinacao_solar != 0:
DR = 1 + 0.0033 * np.cos(
np.radians(360 / (365 * declinacao_solar)))
else:
DR = 1
radiacao_topo_atmosfera = 37.6 * DR * (
(np.pi / 180) * angulo_solar * np.sin(declinacao_solar_r) *
np.sin(lat_rad) + np.cos(declinacao_solar_r) *
np.cos(lat_rad) * np.sin(agulo_solar_r))
#radiacao_topo_atmosfera = radiacao_topo_atmosfera * 23.92344
ctn = 0.583 + 0.014 * T_ + 0.0013 * (T_**2) - 0.000037 * (T_**3)
ctc = -0.0425 + 0.035 * T_ + 0.00325 * (T_**2) - 0.0000925 * (T_**
3)
n_t = range(len(T_))
for i in n_t:
index = [(T_[i] < 16.5) & (T_[i] > 37)]
ctn[i][index] = -0.0425 + 0.035 * T_[i][index] + 0.00325 * (
T_[i][index]**2) - 0.0000925 * (T_[i][index]**3)
ctc[i][index] = -1.085 + 0.07 * T_[i][index] + 0.0065 * (
T_[i][index]**2) - 0.000185 * (T_[i][index]**3)
PPBn = (31.7 + 0.219 * radiacao_topo_atmosfera) * ctn * 0.6
PPBc = (107.2 + 0.219 * radiacao_topo_atmosfera) * ctc * 0.6
PPBp = PPBn + PPBc
PPR_ = 0.265455 * self.Cc * PPBp
PPR = RasterFile(file_path=serie_PPR.root_path, ext="tif")
PPR = serie_PPR.setDate_time(data_T, file=PPR)
PPR.metadata = T.metadata
#print (PPR.metadata)
PPR_[PPR_ == float('Inf')] = PPR.metadata["nodata"]
#ks_[i][taw_[i] == float('NaN')] = -1
PPR.data = PPR_
PPR.metadata.update(dtype=PPR.data.dtype)
PPR.saveRasterData()
PPR.data = None
serie_PPR.append(PPR)
ii += 1
#end = time.time()
#self.console("tempo restante(m):" + str( np.round(((end - start) * (len(serie_T)-ii)) /60, 2)))
self.setProgresso(ii, len(serie_T))
return serie_PPR
def __execOperation__(self):
serie_imagem_in = self.paramentrosIN_carregados["In"].loadListByRoot()
serie_imagem_out = self.paramentrosIN_carregados["Out_config"]
#imagem_in_factor = float(serie_imagem_in.mutiply_factor)
#imagem_out_factor = float(serie_imagem_out.mutiply_factor)
n_imagens = len(serie_imagem_in)
if n_imagens is 0 :
self.console(u"Erro: Nenhuma imagem encontrada na pasta especificada.")
self.console(u"Cancelando função.")
threading.currentThread().stop()
return
self.console(u"Construindo série temporal diária...")
for i in range(n_imagens):
self.setProgresso(i, n_imagens)
'''Recupera a data correspondente a imagem atual do laço '''
try:
data = serie_imagem_in.getDate_time(i)
dia_mes = data.day
'''Calcula quantos dias tem no decend atual'''
if dia_mes <= 10: duracao = 10
elif dia_mes <= 20: duracao = 10
else : duracao = int(calendar.monthrange(data.year, data.month)[1]) - 20
if threading.currentThread().stopped() :
print "thread parada, retornando da função"
return
imagem_ = serie_imagem_in[i].loadRasterData()
imagem_ = numpy.ma.masked_array(imagem_, mask=(imagem_ == serie_imagem_in[i].metadata["nodata"]))
if self.paramentrosIN_carregados["Operation"] == "dividir valores":
imagem_ = (imagem_ / float(duracao))
imagem_[numpy.isinf(imagem_)] = 0
elif self.paramentrosIN_carregados["Operation"] == "manter valores":
pass
for ii in range (0, duracao):
img = RasterFile()
img.file_path = serie_imagem_out.root_path
data_img = data + timedelta(ii)
img.file_name = serie_imagem_out.prefixo + data_img.strftime(serie_imagem_out.date_mask) + serie_imagem_out.sufixo
img.data = imagem_
img.file_ext = "tif"
metadata = serie_imagem_in[i].metadata
img.metadata = metadata
img.metadata.update(dtype = img.data.dtype)
img.saveRasterData(metadata=metadata)
except:
self.console(u"Erro na imagem: " + serie_imagem_in[i].file_name)
self.console(u"Série temporal diária concluída.")
#ano_pixel = int(str(data_pixel)[0:4])
#dia_pixel = int(str(data_pixel)[4:n])
#imagem_convertida[i][ii] = (dia_pixel - dia_inicial) + (ano_pixel - ano_inicial * 365)
#except :
#pass
ano_pixel = int(str(data_pixel)[0:4])
imagem_convertida[i] = imagem[i]
progress(i / float(n_linhas - 1))
print "Conversão terminada, retornando imagem"
return imagem_convertida
if __name__ == '__main__':
imagem = RasterFile(
file_full_path=
"C:\\Gafanhoto WorkSpace\\DataTestes\\raster\\semeadura_soja_11-12.tif"
)
imagem_ = imagem.loadRasterData()
data_minima = Ds_DC_to_date(np.min(imagem_))
imagem.data = converter(data_minima, imagem_)
imagem.file_name = imagem.file_name + "convertida"
imagem.saveRasterData()
def distribuir_kc(data_minima, data_maxima, semeadura_, colheita_, periodo_kc,
kc_vetorizado, path_img_referencia, i, path_out):
import ctypes
import ConfigParser
config = ConfigParser.RawConfigParser()
config.read('workspace.properties')
company = config.get('Version', 'company')
product = config.get('Version', 'product')
subproduct = config.get('Version', 'subproduct')
version = config.get('Version', 'Version')
myappid = (company + "." + product + "." + subproduct + "." + version)
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
threading.currentThread().terminada = False
imagem_kc = RasterFile(file_full_path=path_img_referencia)
imagem_kc.loadRasterData()
imagem_kc.file_path = path_out
#print imagem_kc.metadata
n_linhas = len(semeadura_)
n_colunas = len(colheita_[0])
delta_total = (data_maxima - data_minima).days + 1
for i_dia in range(0, delta_total):
imagem_kc_ = np.zeros((n_linhas, n_colunas))
imagem_kc_ = array(imagem_kc_).astype(dtype="uint8")
dia = data_minima + timedelta(i_dia)
imagem_kc.data = array(semeadura_)
imagem_kc.file_name = str(dia.date())
#if delta_total > 1 :
#progresso = (i_dia/float(delta_total))*100
for i_linha in range(0, n_linhas):
progress(i_linha / float(n_linhas - 1))
for i_coluna in range(0, n_colunas):
try:
Ds = Ds_DC_to_date(semeadura_[i_linha][i_coluna])
Dc = Ds_DC_to_date(colheita_[i_linha][i_coluna])
delta_c = (Dc - Ds).days + 1
if (dia >= Ds and dia <= Dc):
k = dia - Ds
i_FKc = int((k * periodo_kc).days / delta_c)
Kc = kc_vetorizado[i_FKc]
imagem_kc_[i_linha][i_coluna] = Kc
except:
pass
imagem_kc.metadata.update(nodata=0)
imagem_kc.saveRasterData(band_matrix=imagem_kc_)
print "retornando do processo", i
#threading.currentThread().stopped = True
threading.currentThread().terminada = True
return None