def le_imgRefPath_ChangeAction(self):
if (self.ImgRefSelected == None):
self.ImgRefSelected = RasterFile(
file_full_path=str(self.ui.leImgRefPath.text()))
else:
self.ImgRefSelected.file_full_path = str(
self.ui.leImgRefPath.text())
def distribuir_kc(dia, semeadura_, colheita_, ano_inicio, dia_inicio,
periodo_kc, kc_vetorizado, path_img_referencia, path_out):
threading.currentThread().terminada = False
imagem_kc = RasterFile(file_full_path=path_img_referencia)
imagem_kc.getLoadJustMetaData()
imagem_kc.file_path = path_out
n_linhas = len(semeadura_)
n_colunas = len(semeadura_[0])
delta_c = (colheita_ - semeadura_) #.astype(np.float32)
tempo_em_campo = (dia + 1 - semeadura_) #.astype(np.float32)
i_FKc = np.zeros((n_linhas, n_colunas)).astype(np.float32)
for i in range(n_linhas):
mask = ((tempo_em_campo[i] > 0) & (tempo_em_campo[i] <= delta_c[i]))
i_FKc[i][mask] = (
(tempo_em_campo[i][mask] - 1) * periodo_kc) / delta_c[i][mask]
i_FKc[i][mask] = np.ceil(i_FKc[i][mask])
i_FKc[i][mask] = [kc_vetorizado[index] for index in i_FKc[i][mask]]
imagem_kc.file_name = str(
datetime.datetime(ano_inicio, 1, 1) +
datetime.timedelta(dia + dia_inicio - 1))[:10]
imagem_kc.metadata.update(nodata=0)
imagem_kc.metadata.update(dtype="float32")
imagem_kc.saveRasterData(band_matrix=i_FKc)
threading.currentThread().terminada = True
return
def loadListByRoot(self, rootDir=None, filtro=None):
'''
Abre uma lista de mapas localizados em uma determinada pasta
'''
if rootDir != None: self.root_path = rootDir
if filtro != None: self.root_filter = filtro
print("endereco das imagens: ", self.root_path)
caminhos = [
os.path.join(self.root_path, nome)
for nome in os.listdir(self.root_path)
]
arquivos = [arq for arq in caminhos if os.path.isfile(arq)]
for f in arquivos:
f = RasterFile(file_full_path=f)
if (self.root_filter == None):
self.append(f)
else:
if (f.file_ext in self.root_filter):
self.append(f)
return self
def distribuir_kc(dia, semeadura_, colheita_, ano_inicio, dia_inicio, periodo_kc, kc_vetorizado, path_img_referencia, path_out):
threading.currentThread().terminada = False
imagem_kc = RasterFile(file_full_path = path_img_referencia)
imagem_kc.getLoadJustMetaData()
imagem_kc.file_path = path_out
n_linhas = len(semeadura_)
n_colunas = len(semeadura_[0])
delta_c = (colheita_ - semeadura_)#.astype(np.float32)
tempo_em_campo = (dia+1 - semeadura_)#.astype(np.float32)
i_FKc = np.zeros((n_linhas, n_colunas)).astype(np.float32)
for i in range(n_linhas) :
mask = ((tempo_em_campo[i] > 0) & (tempo_em_campo[i] <= delta_c[i]))
i_FKc[i][mask] = ((tempo_em_campo[i][mask]-1) * periodo_kc)/delta_c[i][mask]
i_FKc[i][mask] = np.ceil(i_FKc[i][mask])
i_FKc[i][mask] = [kc_vetorizado[index] for index in i_FKc[i][mask]]
imagem_kc.file_name = str(datetime.datetime(ano_inicio, 1, 1) + datetime.timedelta(dia + dia_inicio - 1))[:10]
imagem_kc.metadata.update(nodata=0)
imagem_kc.metadata.update(dtype="float32")
imagem_kc.saveRasterData(band_matrix = i_FKc)
threading.currentThread().terminada = True
return
def __execOperation__(self):
prefix = self.paramentrosIN_carregados["prefixo"]
sufix = self.paramentrosIN_carregados["sufixo"]
mask = self.paramentrosIN_carregados["mask"]
images_super = self.paramentrosIN_carregados["images"]
avanco_semeadura = self.paramentrosIN_carregados["avanco_semeadura"]
avanco_semeadura = avanco_semeadura
avanco_colheita = self.paramentrosIN_carregados["avanco_colheita"]
avanco_colheita = avanco_colheita
intervalo_semeadura = self.paramentrosIN_carregados["intervalo_semeadura"]
intervalo_pico = self.paramentrosIN_carregados["intervalo_pico"]
intervalo_colheita = self.paramentrosIN_carregados["intervalo_colheita"]
#barra_progresso = self.paramentrosIN_carregados["progress_bar"]
intervalo_semeadura = intervalo_semeadura.split("-")
intervalo_pico = intervalo_pico.split("-")
intervalo_colheita = intervalo_colheita.split("-")
images = images_super.loadListRasterData()
if images==None:
raise Exception("A funcao necessita de uma serie de imagens para funcionar")
n_images = len(images)
n_linhas = len(images[0])
n_colunas = len(images[0][0])
#nullValue = float(self.paramentrosIN_carregados["null_value"])
#if(images[0][0][0] == nullValue) : print("null value igual")
#else : print("diferente")
sys.stdout.write( "Criando imagens de referencia: ")
self.print_text(u"Criando imagens de referência.")
imagem_referencia = np.zeros((n_linhas, n_colunas))
imagem_semeadura = array(imagem_referencia).astype(dtype="int32")
imagem_colheita = array(imagem_referencia).astype(dtype="int32")
imagem_pico = array(imagem_referencia).astype(dtype="int32")
sys.stdout.write( "Gerando estimativas: ")
self.print_text("Gerando estimativas.")
progress(0.0)
imagem_for_null_value = images[0]
nullValue = imagem_for_null_value[0][0]
#print(nullValue)
avanco_semeadura = timedelta(avanco_semeadura)
avanco_colheita = timedelta(avanco_colheita)
images_super[0].metadata.update(nodata=0)
#print images_super[0].metadata
for i_linhas in range(0, n_linhas):
progress(i_linhas/float(n_linhas))
self.progresso = (i_linhas/float(n_linhas)) * 100
for i_coluna in range(0, n_colunas):
line = list()
if threading.currentThread().stopped() : return
if nullValue != imagem_for_null_value[i_linhas][i_coluna] :
for img in images:
line.append(img[i_linhas][i_coluna])
cenaPico = self.findPeakHelper(line, int(intervalo_pico[0]), int(intervalo_pico[1])) # 3 - 23
data_txt_pico = images_super[cenaPico].file_name.replace(prefix, "").replace(sufix, "")
data_pico = dt.strptime(data_txt_pico, mask)
ano_pico = data_pico.year
dia_juliano = data_pico.timetuple().tm_yday
imagem_pico[i_linhas][i_coluna] = ((ano_pico * 1000) + dia_juliano)
cenaSemeadura = self.findLowPeakHelper(line, int(intervalo_semeadura[0]), int(intervalo_semeadura[1])) # 6 - 23
cenaColheita = self.findLowPeakHelper(line, int(intervalo_colheita[0]), int(intervalo_colheita[1])) # 11 - 34
data_txt_semeadura = images_super[cenaSemeadura].file_name.replace(prefix, "").replace(sufix, "")
data_semeadura = dt.strptime(data_txt_semeadura, mask)
data_txt_colheita = images_super[cenaColheita].file_name.replace(prefix, "").replace(sufix, "")
data_colheita = dt.strptime(data_txt_colheita, mask)
picoMenosSemeadura = data_pico - data_semeadura
ColheitaMenosPico = data_colheita - data_pico
data_semeadura += timedelta((picoMenosSemeadura.days * avanco_semeadura).days)
data_colheita += timedelta((ColheitaMenosPico.days * avanco_colheita).days)
dia_juliano_semeadura = data_semeadura.timetuple().tm_yday
imagem_semeadura[i_linhas][i_coluna] = ((data_semeadura.year * 1000) + dia_juliano_semeadura)
dia_juliano_colheita = data_colheita.timetuple().tm_yday
imagem_colheita[i_linhas][i_coluna] = ((data_colheita.year * 1000) + dia_juliano_colheita)
saida = TableData()
imagem_semeadura = RasterFile(data=imagem_semeadura)
imagem_semeadura.metadata = images_super[0].metadata
imagem_semeadura.data_name = "semeadura"
imagem_colheita = RasterFile(data=imagem_colheita)
imagem_colheita.metadata = images_super[0].metadata
imagem_colheita.data_name = "colheita"
imagem_pico = RasterFile(data=imagem_pico)
imagem_pico.metadata = images_super[0].metadata
imagem_pico.data_name = "cenaPico"
saida["imagem_semeadura"] = imagem_semeadura
saida["imagem_colheita"] = imagem_colheita
saida["imagem_pico"] = imagem_pico
return saida
class Controller(AbstractController.Controller):
'''
classdocs
'''
ShapeSelected = None
ImgRefSelected = None
def inicializar(self):
self.ui.leImgRefPath.setText(
"C:\\Gafanhoto WorkSpace\\DataTestes\\raster\\semeadura_soja_11-12.tif"
)
self.ui.leShapePath.setText(
"C:\\Gafanhoto WorkSpace\\DataTestes\\shape\\Contorno_Agassis_Pontos_2015.shp"
)
def btn_FindShp_ClickAction(self):
self.findPath(self.ui.leShapePath)
def btn_FindImgRef_ClickAction(self):
self.findPath(self.ui.leImgRefPath)
def le_shapePath_ChangeAction(self):
if (self.ShapeSelected == None):
text = str(self.ui.leShapePath.text())
self.ShapeSelected = VectorFile(file_full_path=text)
else:
self.ShapeSelected.file_full_path = self.ui.leShapePath.text()
itens = self.ShapeSelected.readVectorData()["properties"].keys()
self.ui.cbAtribute.addItems(itens)
self.ui.cbAtribute.setEnabled(True)
self.ui.cbAtribute.setCurrentIndex(0)
def le_imgRefPath_ChangeAction(self):
if (self.ImgRefSelected == None):
self.ImgRefSelected = RasterFile(
file_full_path=str(self.ui.leImgRefPath.text()))
else:
self.ImgRefSelected.file_full_path = str(
self.ui.leImgRefPath.text())
def cb_Atribute_ChangeAction(self):
itens = self.ShapeSelected.readVectorData()["properties"].keys()
itens.remove(self.ui.cbAtribute.currentText())
self.ui.lwGroupAtributes.clear()
for item in itens:
item = QtGui.QListWidgetItem(item)
item.setCheckState(QtCore.Qt.Unchecked)
self.ui.lwGroupAtributes.addItem(item)
self.ui.lwGroupAtributes.setEnabled(True)
__sortingEnabled = self.ui.lwGroupAtributes.isSortingEnabled()
self.ui.lwGroupAtributes.setSortingEnabled(__sortingEnabled)
def executa(self):
print "executando.."
self.function = Interpola.InterpolaTabela()
self.function.console = self.print_text
self.print_text("Executando..")
separador = SplitTable()
dados_separador = TableData()
atributos = list()
for index in xrange(self.ui.lwGroupAtributes.count()):
if self.ui.lwGroupAtributes.item(index).checkState() == 2:
atributos.append(
str(self.ui.lwGroupAtributes.item(index).text()))
vector_table = self.ShapeSelected.readVectorData()
dados_separador.data = {'table': vector_table, 'atributos': atributos}
dados_separador.data["data_path"] = self.ui.leShapePath.text()
dados_interpolador = TableData()
image_information = self.ImgRefSelected.getRasterInformation()
dados_interpolador['table_data'] = dados_separador
dados_interpolador['atributo'] = str(self.ui.cbAtribute.currentText())
dados_interpolador["format_image_data"] = image_information
self.print_text("Interpolando")
mensagem = self.function.executar(dados_interpolador)
self.finalizar()
def valida_form(self):
if self.ShapeSelected is None:
self.message(u"Shape para interpolação não encontrado.")
return False
if self.ImgRefSelected is None:
self.message(u"Imagem de referencia não encontrada.")
return False
return True
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
# -*- coding: utf-8 -*-
'''
Created on 08/01/2016
@author: Paloschi
'''
from Modelo.beans import RasterFile
import sys
root = "C:\\Users\\Paloschi\\Desktop\\Tudo_Necessario\\"
path = root + "ya_invertido_soma.tif"
import numpy as np
raster = RasterFile(file_full_path=path)
data_raster = raster.loadRasterData(True)
nodata = raster.metadata["nodata"]
print nodata
print ""
sys.stdout.write("media" + "\t")
sys.stdout.write("minimo" + "\t")
sys.stdout.write("maximo" + "\t")
sys.stdout.write("coeficiente de variação" + "\t")
print("")
for band in data_raster:
mean = list()
date = datetime.datetime(year, 1, 1) + datetime.timedelta(days - 1)
return date
if __name__ == '__main__':
from Modelo.beans import TableData
import ctypes
myappid = ("NTX.Gafanhoto.Distibuidorkc.0.1")
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
paramIN = dict()
paramIN["semeadura"] = RasterFile(
file_full_path=
"C:/CyMP//Gafanhoto//DADOS para Dr//Imagens Cascavel//TesteDatasCultura//semeadura.tif"
)
paramIN["colheita"] = RasterFile(
file_full_path=
"C:/CyMP//Gafanhoto//DADOS para Dr//Imagens Cascavel//TesteDatasCultura//colheita.tif"
)
paramIN[
"path_out"] = "C:/CyMP//Gafanhoto//DADOS para Dr//Imagens Cascavel//TesteDatasCultura//saida_teste"
paramIN["Kc"] = TableData()
#paramIN["Kc"]["0-10"]=40
#paramIN["Kc"]["10-50"]=80
#paramIN["Kc"]["50-85"]=115
#paramIN["Kc"]["85-125"]=80
#paramIN["Kc"]["125-140"]=50
paramIN["Kc"]["0-10"] = 0.10
paramIN["Kc"]["10-50"] = 0.25
#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.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
date = datetime.datetime(year, 1, 1) + datetime.timedelta(days - 1)
return date
if __name__ == '__main__':
from Modelo.beans import TableData
import ctypes
myappid = ("NTX.Gafanhoto.Distibuidorkc.0.1")
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
paramIN = dict()
paramIN["semeadura"] = RasterFile(
file_full_path=
"E:\\Gafanhoto WorkSpace\\Soja11_12\\Datas_DS-DC\\semeadura_soja_11-12.tif"
)
paramIN["colheita"] = RasterFile(
file_full_path=
"E:\\Gafanhoto WorkSpace\\Soja11_12\\Datas_DS-DC\\colheita_soja_11-12.tif"
)
paramIN[
"path_out"] = "E:\\Gafanhoto WorkSpace\\Soja11_12\\Indices_BH\\Kc_distribuido"
paramIN["Kc"] = TableData()
paramIN["Kc"]["0-10"] = 40
paramIN["Kc"]["10-50"] = 80
paramIN["Kc"]["50-85"] = 115
paramIN["Kc"]["85-125"] = 80
paramIN["Kc"]["125-140"] = 50
#paramIN["Kc"]["0-10"]=10
#paramIN["Kc"]["10-50"]=25
def __execOperation__(self):
global nullValue, imagem_media, imagem_sd, imagem_cv, imagem_soma, imagem_min, imagem_max
global imagem_mediana, imagem_amplitude, images, n_linhas, n_colunas, threads_ready, n_threadings
print("executando operação")
images_super = self.paramentrosIN_carregados["images"]
print("Numero de imagens para ler: " + str(len(images_super)))
nullValue = np.double(images_super[0].getRasterInformation()["NoData"])
statistics = self.paramentrosIN_carregados["statistics"]
print("Estatisticas a fazer: ", statistics)
do = dict()
do["Media"] = "media" in statistics
do["CV"] = "cv" in statistics
do["SD"] = "sd" in statistics
do["Soma"] = "soma" in statistics
do["Min"] = "min" in statistics
do["Max"] = "max" in statistics
do["Mediana"] = "mediana" in statistics
do["Amplitude"] = "amplitude" in statistics
images = images_super.loadListRasterData()
print("Numero de imagens lidas: " + str(len(images)))
n_linhas = len(images[0])
n_colunas = len(images[0][0])
for img in images:
if len(img) != n_linhas or len(img[0]) != n_colunas:
raise IndexError(
"Erro - As imagens precisam ter o mesmo número de linhas e colunas"
)
print("numero de colunas e linhas: " + str(n_linhas) + " : " +
str(n_colunas))
#imagem_referencia = [[0 for x in range(n_colunas)] for x in range(n_linhas)]
imagem_referencia = np.zeros((n_linhas, n_colunas))
imagem_out = dict
if do["Media"]:
imagem_out["media"] = array(
imagem_referencia) #.astype(dtype="int16")
if do["CV"]:
imagem_out["cv"] = array(
imagem_referencia) #.astype(dtype="int16")
if do["SD"]:
imagem_out["sd"] = array(
imagem_referencia) #.astype(dtype="int16")
if do["Soma"]:
imagem_out["soma"] = array(
imagem_referencia) #.astype(dtype="int16")
if do["Min"]:
imagem_out["min"] = array(
imagem_referencia) #.astype(dtype="int16")
if do["Max"]:
imagem_out["max"] = array(
imagem_referencia) #.astype(dtype="int16")
if do["Mediana"]:
imagem_out["mediana"] = array(
imagem_referencia) #.astype(dtype="int16")
if do["Amplitude"]:
imagem_out["amplitude"] = array(
imagem_referencia) #.astype(dtype="int16")
print("processando:")
numero_de_nucleos = GeneralTools.available_cpu_count()
n_threadings = int(numero_de_nucleos - 2)
print("Numero de threads", n_threadings)
threads_ready = 0
pool = Pool()
#pool = multiprocessing.Pool(processes=n_threadings)
for i in range(0, n_threadings):
#t = threading.Thread(target=thread_process, args=(n_linhas/n_threadings*i, n_linhas/n_threadings*(i+1)))
#t.start()
linha_inicial = n_linhas / n_threadings * i
linha_final = n_linhas / n_threadings * (i + 1)
p = Process(target=thread_process,
args=(linha_inicial, linha_final))
p.start()
#pool.map(thread_process(n_linhas/n_threadings*i, n_linhas/n_threadings*(i+1)))
#pool.close()
while (threads_ready < n_threadings):
pass
print("Arrumando imagens de saida")
saida = SerialFile()
saida.metadata = self.paramentrosIN_carregados["images"][0].metadata
if do["Media"]:
imagem_media = RasterFile(data=imagem_media)
imagem_media.metadata = saida.metadata
imagem_media.file_name = "imagem_media"
saida.append(imagem_media)
if do["CV"]:
imagem_cv = RasterFile(data=imagem_cv)
imagem_cv.metadata = saida.metadata
imagem_cv.file_name = "imagem_coeficiente_variacao"
saida.append(imagem_cv)
if do["SD"]:
imagem_sd = RasterFile(data=imagem_sd)
imagem_sd.metadata = saida.metadata
imagem_sd.file_name = "imagem_desvio_padrao"
saida.append(imagem_sd)
if do["Soma"]:
imagem_soma = RasterFile(data=imagem_soma)
imagem_soma.metadata = saida.metadata
imagem_soma.file_name = "imagem_soma"
saida.append(imagem_soma)
if do["Min"]:
imagem_min = RasterFile(data=imagem_min)
imagem_min.metadata = saida.metadata
imagem_min.file_name = "imagem_minimo"
saida.append(imagem_min)
if do["Max"]:
imagem_max = RasterFile(data=imagem_max)
imagem_max.metadata = saida.metadata
imagem_max.file_name = "imagem_maximo"
saida.append(imagem_max)
if do["Mediana"]:
imagem_mediana = RasterFile(data=imagem_mediana)
imagem_mediana.metadata = saida.metadata
imagem_mediana.file_name = "imagem_mediana"
saida.append(imagem_mediana)
if do["Amplitude"]:
imagem_amplitude = RasterFile(data=imagem_amplitude)
imagem_amplitude.metadata = saida.metadata
imagem_amplitude.file_name = "imagem_amplitude"
saida.append(imagem_amplitude)
print("imagens prontas para gravar, statistical stractor completo")
return saida
class Controller(AbstractController.Controller):
'''
classdocs
'''
ShapeSelected = None
ImgRefSelected = None
def inicializar(self):
self.ui.leImgRefPath.setText("C:\\Gafanhoto WorkSpace\\DataTestes\\raster\\semeadura_soja_11-12.tif")
self.ui.leShapePath.setText("C:\\Gafanhoto WorkSpace\\DataTestes\\shape\\Contorno_Agassis_Pontos_2015.shp")
def btn_FindShp_ClickAction(self):
self.findPath(self.ui.leShapePath)
def btn_FindImgRef_ClickAction(self):
self.findPath(self.ui.leImgRefPath)
def le_shapePath_ChangeAction(self):
if (self.ShapeSelected == None):
text = str(self.ui.leShapePath.text())
self.ShapeSelected = VectorFile(file_full_path = text)
else:
self.ShapeSelected.file_full_path = self.ui.leShapePath.text()
itens = self.ShapeSelected.readVectorData()["properties"].keys()
self.ui.cbAtribute.addItems(itens)
self.ui.cbAtribute.setEnabled(True)
self.ui.cbAtribute.setCurrentIndex(0)
def le_imgRefPath_ChangeAction(self):
if (self.ImgRefSelected == None):
self.ImgRefSelected = RasterFile(file_full_path = str(self.ui.leImgRefPath.text()))
else:
self.ImgRefSelected.file_full_path = str(self.ui.leImgRefPath.text())
def cb_Atribute_ChangeAction(self):
itens = self.ShapeSelected.readVectorData()["properties"].keys()
itens.remove(self.ui.cbAtribute.currentText())
self.ui.lwGroupAtributes.clear()
for item in itens:
item = QtGui.QListWidgetItem(item)
item.setCheckState(QtCore.Qt.Unchecked)
self.ui.lwGroupAtributes.addItem(item)
self.ui.lwGroupAtributes.setEnabled(True)
__sortingEnabled = self.ui.lwGroupAtributes.isSortingEnabled()
self.ui.lwGroupAtributes.setSortingEnabled(__sortingEnabled)
def executa(self):
print "executando.."
self.function = Interpola.InterpolaTabela()
self.function.console = self.print_text
self.print_text("Executando..")
separador = SplitTable()
dados_separador = TableData()
atributos = list()
for index in xrange(self.ui.lwGroupAtributes.count()):
if self.ui.lwGroupAtributes.item(index).checkState() == 2:
atributos.append(str(self.ui.lwGroupAtributes.item(index).text()))
vector_table = self.ShapeSelected.readVectorData()
dados_separador.data = {'table' : vector_table, 'atributos' : atributos}
dados_separador.data["data_path"] = self.ui.leShapePath.text()
dados_interpolador = TableData()
image_information = self.ImgRefSelected.getRasterInformation()
dados_interpolador['table_data'] = dados_separador
dados_interpolador['atributo'] = str(self.ui.cbAtribute.currentText())
dados_interpolador["format_image_data"] = image_information
self.print_text("Interpolando")
mensagem = self.function.executar(dados_interpolador)
self.finalizar()
def valida_form(self):
if self.ShapeSelected is None:
self.message(u"Shape para interpolação não encontrado.")
return False
if self.ImgRefSelected is None:
self.message(u"Imagem de referencia não encontrada.")
return False
return True
def le_imgRefPath_ChangeAction(self):
if (self.ImgRefSelected == None):
self.ImgRefSelected = RasterFile(file_full_path = str(self.ui.leImgRefPath.text()))
else:
self.ImgRefSelected.file_full_path = str(self.ui.leImgRefPath.text())
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
dia_colheita = colheita - ano_colheita * 1000
primeira_data = np.min(semeadura)
primeiro_ano = primeira_data/1000
primeiro_dia = primeira_data - primeiro_ano * 1000
semeadura_normalizada = (ano_semeadura - primeiro_ano - 1) * (primeiro_dia - dia_semeadura) + (ano_semeadura - primeiro_ano) * dia_semeadura + (ano_semeadura - primeiro_ano) * (365 - primeiro_dia)
colheita_normalizada = ((ano_colheita - primeiro_ano) - 1) * (primeiro_dia - dia_colheita) + (ano_colheita - primeiro_ano) * dia_colheita + (ano_colheita - primeiro_ano) * (365 - primeiro_dia)
#print colheita_normalizada
#print ((ano_colheita - primeiro_ano) - 1) * (primeiro_dia - dia_colheita) + (ano_colheita - primeiro_ano) * dia_colheita + (ano_colheita - primeiro_ano) * (365 - primeiro_dia)
return semeadura_normalizada, colheita_normalizada, primeiro_ano, primeiro_dia
raster = RasterFile(file_full_path="C:\\Users\\Paloschi\\Desktop\\2013-2014\\semeadura.tif")
imagem_semeadura = raster.loadRasterData()
raster = RasterFile(file_full_path="C:\\Users\\Paloschi\\Desktop\\2013-2014\\colheita.tif")
imagem_colheita = raster.loadRasterData()
semeadura_normalizado, colheita_normalizado, ano_inicio, dia_inicio = normalize_datas(imagem_semeadura, imagem_colheita)
print semeadura_normalizado
print colheita_normalizado
ultimo_dia = np.max(colheita_normalizado)
periodo_kc = 120
delta_c = colheita_normalizado - semeadura_normalizado
kc_vetorizado = range(100,221)
kc_vetorizado[0] = 0
#img_teste_path = "C:\\Users\\rennan.paloschi\\Desktop\\Dados_Gerais\\raster\\ECMWF\\Teste_raster_csv\\Imagens"
#img_teste = SerialFile(root_path=img_teste_path)
#img_teste.loadListByRoot()
#paramIN = dict()
#paramIN["images"] = img_teste
#paramIN["out_folder"] = "C:\\Users\\rennan.paloschi\\Desktop\\Dados_Gerais\\raster\\ECMWF\\Teste_raster_csv\\Saida\\"
#csv_vrt_files = RasterToCSVeVRT().executar(paramIN)
'''
Imagem de referencia
'''
from Modelo.beans import RasterFile
img_referencia_path = "C:\\Gafanhoto WorkSpace\\DataTestes\\raster\\Fazer\\20110101.tif"
img_referencia = RasterFile(file_full_path=img_referencia_path)
info_img_referencia = img_referencia.getRasterInformation()
'''
Conf algoritimo
'''
conf_alg = TableData()
#conf_alg["max_points"] = "12"
#conf_alg["radius"] = "0"
'''
Imagem de saida
'''
img_out = RasterFile(
file_full_path=
"C:\\Gafanhoto WorkSpace\\DataTestes\\out\\Primeira tentativa\\evpt_20110101.tif"
)
def __execOperation__(self):
self.print_text(u"Iniciando função")
images_super = self.paramentrosIN_carregados["images"]
self.console(u"Número de imagens para ler: " + str(len(images_super)))
#nullValue = self.paramentrosIN_carregados["null_value"]
statistics = self.paramentrosIN_carregados["statistics"]
#self.print_text("Estatisticas a fazer: ", statistics)
doMedia = "media" in statistics
doCV = "cv" in statistics
doSD = "sd" in statistics
doSoma = "soma" in statistics
doMin = "min" in statistics
doMax = "max" in statistics
doMediana = "mediana" in statistics
doAmplitude = "amplitude" in statistics
imagem_referencia = images_super[0].loadRasterData()
n_linhas = len(imagem_referencia)
n_colunas = len(imagem_referencia[0])
for img in images_super:
img = img.loadRasterData()
if len(img) != n_linhas or len(img[0]) != n_colunas:
raise IndexError(
"Erro - As imagens precisam ter o mesmo número de linhas e colunas"
)
imagem_referencia = np.zeros((n_linhas, n_colunas))
if doMedia:
imagem_media = array(imagem_referencia).astype(dtype="float32")
if doCV: imagem_cv = array(imagem_referencia).astype(dtype="float32")
if doSD: imagem_sd = array(imagem_referencia) #.astype(dtype="int16")
if doSoma:
imagem_soma = array(imagem_referencia).astype(dtype="float32")
if doMin: imagem_min = array(imagem_referencia).astype(dtype="float32")
if doMax: imagem_max = array(imagem_referencia).astype(dtype="float32")
if doMediana:
imagem_mediana = array(imagem_referencia) #.astype(dtype="int16")
if doAmplitude:
imagem_amplitude = array(imagem_referencia).astype(dtype="float32")
self.print_text(u"Processando:")
if doSoma:
n_imagens = len(images_super)
self.print_text(u"Somando Imagens:")
progress(0.0)
for i in range(n_imagens - 1):
imagem_soma += images_super[i + 1].loadRasterData()
self.setProgresso(i, n_imagens)
#progress( 0.0)
if doMedia or doCV or doSD or doMin or doMax or doMediana or doAmplitude:
images = images_super.loadListRasterData()
for i_linha in range(0, n_linhas):
#status = i_linha+1/float(n_linhas)
#progress(float(i_linha/float(n_linhas)))
self.progresso = (float(i_linha / float(n_linhas))) * 100
for i_coluna in range(0, n_colunas):
line = list()
if threading.currentThread().stopped(): return
for img in images:
line.append(img[i_linha][i_coluna])
mean = None
sd = None
if doCV:
mean = np.nanmean(line)
sd = np.nanstd(line)
divisor = mean * 100
if divisor != 0: cv = sd / mean * 100
else: cv = 0
imagem_cv[i_linha][i_coluna] = cv
if doMedia:
if mean == None:
mean = np.nanmean(line) # calcula a média
imagem_media[i_linha][i_coluna] = mean
if doSD:
if sd == None:
sd = np.nanstd(line) # calcula o desvio padrão
imagem_sd[i_linha][i_coluna] = sd
#if doSoma :
#soma = np.nansum(line)
#imagem_soma[i_linha][i_coluna] = soma
minimo = None
if doMin:
minimo = np.nanmin(line)
imagem_min[i_linha][i_coluna] = minimo
maximo = None
if doMax:
maximo = np.nanmax(line)
imagem_max[i_linha][i_coluna] = maximo
if doMediana:
mediana = np.nanmedian(line)
imagem_mediana[i_linha][i_coluna] = mediana
if doAmplitude:
if minimo == None: minimo = np.nanmin(line)
if maximo == None: maximo = np.nanmax(line)
amplitude = maximo - minimo
imagem_amplitude[i_linha][i_coluna] = amplitude
self.print_text(u"Arrumando imagens de saida")
saida = SerialFile()
saida.metadata = self.paramentrosIN_carregados["images"][0].metadata
if doMedia:
imagem_media = RasterFile(data=imagem_media)
imagem_media.metadata = saida.metadata
imagem_media.file_name = "imagem_media"
saida.append(imagem_media)
if doCV:
imagem_cv = RasterFile(data=imagem_cv)
imagem_cv.metadata = saida.metadata
imagem_cv.file_name = "imagem_coeficiente_variacao"
saida.append(imagem_cv)
if doSD:
imagem_sd = RasterFile(data=imagem_sd)
imagem_sd.metadata = saida.metadata
imagem_sd.file_name = "imagem_desvio_padrao"
saida.append(imagem_sd)
if doSoma:
imagem_soma = RasterFile(data=imagem_soma)
imagem_soma.metadata = saida.metadata
imagem_soma.file_name = "imagem_soma"
saida.append(imagem_soma)
if doMin:
imagem_min = RasterFile(data=imagem_min)
imagem_min.metadata = saida.metadata
imagem_min.file_name = "imagem_minimo"
saida.append(imagem_min)
if doMax:
imagem_max = RasterFile(data=imagem_max)
imagem_max.metadata = saida.metadata
imagem_max.file_name = "imagem_maximo"
saida.append(imagem_max)
if doMediana:
imagem_mediana = RasterFile(data=imagem_mediana)
imagem_mediana.metadata = saida.metadata
imagem_mediana.file_name = "imagem_mediana"
saida.append(imagem_mediana)
if doAmplitude:
imagem_amplitude = RasterFile(data=imagem_amplitude)
imagem_amplitude.metadata = saida.metadata
imagem_amplitude.file_name = "imagem_amplitude"
saida.append(imagem_amplitude)
self.print_text(
u"imagens prontas para gravar, statistical stractor completo")
return saida
#img_teste = SerialFile(root_path=img_teste_path)
#img_teste.loadListByRoot()
#paramIN = dict()
#paramIN["images"] = img_teste
#paramIN["out_folder"] = "C:\\Users\\rennan.paloschi\\Desktop\\Dados_Gerais\\raster\\ECMWF\\Teste_raster_csv\\Saida\\"
#csv_vrt_files = RasterToCSVeVRT().executar(paramIN)
'''
Imagem de referencia
'''
from Modelo.beans import RasterFile
img_referencia_path = "C:\\Gafanhoto WorkSpace\\DataTestes\\raster\\Fazer\\20110101.tif"
img_referencia = RasterFile(file_full_path = img_referencia_path)
info_img_referencia = img_referencia.getRasterInformation()
'''
Conf algoritimo
'''
conf_alg = TableData()
#conf_alg["max_points"] = "12"
#conf_alg["radius"] = "0"
'''
Imagem de saida
'''
img_out = RasterFile(file_full_path = "C:\\Gafanhoto WorkSpace\\DataTestes\\out\\Primeira tentativa\\evpt_20110101.tif")
'''
Created on 10/01/2016
@author: Paloschi
'''
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
semeadura_normalizada = (ano_semeadura - primeiro_ano - 1) * (
primeiro_dia -
dia_semeadura) + (ano_semeadura - primeiro_ano) * dia_semeadura + (
ano_semeadura - primeiro_ano) * (365 - primeiro_dia)
colheita_normalizada = (
(ano_colheita - primeiro_ano) - 1) * (primeiro_dia - dia_colheita) + (
ano_colheita - primeiro_ano) * dia_colheita + (
ano_colheita - primeiro_ano) * (365 - primeiro_dia)
#print colheita_normalizada
#print ((ano_colheita - primeiro_ano) - 1) * (primeiro_dia - dia_colheita) + (ano_colheita - primeiro_ano) * dia_colheita + (ano_colheita - primeiro_ano) * (365 - primeiro_dia)
return semeadura_normalizada, colheita_normalizada, primeiro_ano, primeiro_dia
raster = RasterFile(
file_full_path="C:\\Users\\Paloschi\\Desktop\\2013-2014\\semeadura.tif")
imagem_semeadura = raster.loadRasterData()
raster = RasterFile(
file_full_path="C:\\Users\\Paloschi\\Desktop\\2013-2014\\colheita.tif")
imagem_colheita = raster.loadRasterData()
semeadura_normalizado, colheita_normalizado, ano_inicio, dia_inicio = normalize_datas(
imagem_semeadura, imagem_colheita)
print semeadura_normalizado
print colheita_normalizado
ultimo_dia = np.max(colheita_normalizado)
periodo_kc = 120
delta_c = colheita_normalizado - semeadura_normalizado
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.")
def __execOperation__(self):
global nullValue, imagem_media, imagem_sd, imagem_cv, imagem_soma, imagem_min, imagem_max
global imagem_mediana, imagem_amplitude, images, n_linhas, n_colunas, threads_ready, n_threadings
print("executando operação")
images_super = self.paramentrosIN_carregados["images"]
print("Numero de imagens para ler: " + str(len(images_super)))
nullValue = np.double(images_super[0].getRasterInformation()["NoData"])
statistics = self.paramentrosIN_carregados["statistics"]
print("Estatisticas a fazer: ", statistics)
do = dict()
do["Media"] = "media" in statistics
do["CV"] = "cv" in statistics
do["SD"] = "sd" in statistics
do["Soma"] = "soma" in statistics
do["Min"] = "min" in statistics
do["Max"] = "max" in statistics
do["Mediana"] = "mediana" in statistics
do["Amplitude"] = "amplitude" in statistics
images = images_super.loadListRasterData()
print("Numero de imagens lidas: " + str(len(images)))
n_linhas = len(images[0])
n_colunas = len(images[0][0])
for img in images:
if len(img) != n_linhas or len(img[0]) != n_colunas:
raise IndexError("Erro - As imagens precisam ter o mesmo número de linhas e colunas")
print("numero de colunas e linhas: " + str(n_linhas) + " : " + str(n_colunas))
#imagem_referencia = [[0 for x in range(n_colunas)] for x in range(n_linhas)]
imagem_referencia = np.zeros((n_linhas, n_colunas))
imagem_out = dict
if do["Media"] : imagem_out["media"] = array(imagem_referencia)#.astype(dtype="int16")
if do["CV"] : imagem_out["cv"] = array(imagem_referencia)#.astype(dtype="int16")
if do["SD"] : imagem_out["sd"] = array(imagem_referencia)#.astype(dtype="int16")
if do["Soma"] : imagem_out["soma"] = array(imagem_referencia)#.astype(dtype="int16")
if do["Min"] : imagem_out["min"] = array(imagem_referencia)#.astype(dtype="int16")
if do["Max"] : imagem_out["max"] = array(imagem_referencia)#.astype(dtype="int16")
if do["Mediana"] : imagem_out["mediana"] = array(imagem_referencia)#.astype(dtype="int16")
if do["Amplitude"] : imagem_out["amplitude"] = array(imagem_referencia)#.astype(dtype="int16")
print("processando:")
numero_de_nucleos = GeneralTools.available_cpu_count()
n_threadings = int(numero_de_nucleos-2)
print ("Numero de threads", n_threadings)
threads_ready = 0
pool = Pool()
#pool = multiprocessing.Pool(processes=n_threadings)
for i in range(0, n_threadings):
#t = threading.Thread(target=thread_process, args=(n_linhas/n_threadings*i, n_linhas/n_threadings*(i+1)))
#t.start()
linha_inicial = n_linhas/n_threadings*i
linha_final = n_linhas/n_threadings*(i+1)
p = Process(target= thread_process, args=(linha_inicial, linha_final))
p.start()
#pool.map(thread_process(n_linhas/n_threadings*i, n_linhas/n_threadings*(i+1)))
#pool.close()
while (threads_ready < n_threadings):
pass
print("Arrumando imagens de saida")
saida = SerialFile ()
saida.metadata = self.paramentrosIN_carregados["images"][0].metadata
if do["Media"]:
imagem_media = RasterFile(data = imagem_media)
imagem_media.metadata = saida.metadata
imagem_media.file_name = "imagem_media"
saida.append(imagem_media)
if do["CV"]:
imagem_cv = RasterFile(data = imagem_cv)
imagem_cv.metadata = saida.metadata
imagem_cv.file_name = "imagem_coeficiente_variacao"
saida.append(imagem_cv)
if do["SD"] :
imagem_sd = RasterFile(data = imagem_sd)
imagem_sd.metadata = saida.metadata
imagem_sd.file_name = "imagem_desvio_padrao"
saida.append(imagem_sd)
if do["Soma"] :
imagem_soma = RasterFile(data = imagem_soma)
imagem_soma.metadata = saida.metadata
imagem_soma.file_name = "imagem_soma"
saida.append(imagem_soma)
if do["Min"] :
imagem_min = RasterFile(data = imagem_min)
imagem_min.metadata = saida.metadata
imagem_min.file_name = "imagem_minimo"
saida.append(imagem_min)
if do["Max"] :
imagem_max = RasterFile(data = imagem_max)
imagem_max.metadata = saida.metadata
imagem_max.file_name = "imagem_maximo"
saida.append(imagem_max)
if do["Mediana"] :
imagem_mediana = RasterFile(data = imagem_mediana)
imagem_mediana.metadata = saida.metadata
imagem_mediana.file_name = "imagem_mediana"
saida.append(imagem_mediana)
if do["Amplitude"] :
imagem_amplitude = RasterFile(data = imagem_amplitude)
imagem_amplitude.metadata = saida.metadata
imagem_amplitude.file_name = "imagem_amplitude"
saida.append(imagem_amplitude)
print("imagens prontas para gravar, statistical stractor completo")
return saida
def __execOperation__(self):
sys.stdout.write("Inicializando Parametros...")
self.print_text(u"Inicializando Parametros...")
prefix = self.paramentrosIN_carregados["prefixo"]
sufix = self.paramentrosIN_carregados["sufixo"]
mask = self.paramentrosIN_carregados["mask"]
images_super = self.paramentrosIN_carregados["images"]
avanco_semeadura = self.paramentrosIN_carregados["avanco_semeadura"]
avanco_semeadura = avanco_semeadura
avanco_colheita = self.paramentrosIN_carregados["avanco_colheita"]
avanco_colheita = avanco_colheita
intervalo_semeadura = self.paramentrosIN_carregados[
"intervalo_semeadura"]
intervalo_pico = self.paramentrosIN_carregados["intervalo_pico"]
intervalo_colheita = self.paramentrosIN_carregados[
"intervalo_colheita"]
#barra_progresso = self.paramentrosIN_carregados["progress_bar"]
intervalo_semeadura = intervalo_semeadura.split("-")
intervalo_pico = intervalo_pico.split("-")
intervalo_colheita = intervalo_colheita.split("-")
images = images_super.loadListRasterData()
if images == None:
raise Exception(
"A funcao necessita de uma serie de imagens para funcionar")
#n_images = len(images)
n_linhas = len(images[0])
n_colunas = len(images[0][0])
nullValue = float(self.paramentrosIN_carregados["null_value"])
if (images[0][0][0] == nullValue): print("null value igual")
#else : print("diferente")
imagem_referencia = np.zeros((n_linhas, n_colunas))
imagem_semeadura = array(imagem_referencia).astype(dtype="int32")
imagem_colheita = array(imagem_referencia).astype(dtype="int32")
imagem_pico = array(imagem_referencia).astype(dtype="int32")
sys.stdout.write("Gerando estimativas: ")
self.print_text("Gerando estimativas.")
progress(0.0)
imagem_for_null_value = images[0]
#nullValue = imagem_for_null_value[0][0]
avanco_semeadura = timedelta(avanco_semeadura)
avanco_colheita = timedelta(avanco_colheita)
images_super[0].metadata.update(nodata=0)
for i_linhas in range(0, n_linhas):
#progress(i_linhas/float(n_linhas))
self.setProgresso(i_linhas, n_linhas)
for i_coluna in range(0, n_colunas):
line = list()
if threading.currentThread().stopped(): return
if nullValue != imagem_for_null_value[i_linhas][i_coluna]:
for img in images:
line.append(img[i_linhas][i_coluna])
cenaPico = self.findPeakHelper(line, int(
intervalo_pico[0]), int(intervalo_pico[1])) # 3 - 23
data_txt_pico = images_super[cenaPico].file_name.replace(
prefix, "").replace(sufix, "")
data_pico = dt.strptime(data_txt_pico, mask)
ano_pico = data_pico.year
dia_juliano = data_pico.timetuple().tm_yday
imagem_pico[i_linhas][i_coluna] = ((ano_pico * 1000) +
dia_juliano)
cenaSemeadura = self.findLowPeakHelper(
line, int(intervalo_semeadura[0]),
int(intervalo_semeadura[1])) # 6 - 23
cenaColheita = self.findLowPeakHelper(
line, int(intervalo_colheita[0]),
int(intervalo_colheita[1])) # 11 - 34
data_txt_semeadura = images_super[
cenaSemeadura].file_name.replace(prefix, "").replace(
sufix, "")
data_semeadura = dt.strptime(data_txt_semeadura, mask)
data_txt_colheita = images_super[
cenaColheita].file_name.replace(prefix,
"").replace(sufix, "")
data_colheita = dt.strptime(data_txt_colheita, mask)
picoMenosSemeadura = data_pico - data_semeadura
ColheitaMenosPico = data_colheita - data_pico
data_semeadura += timedelta(
(picoMenosSemeadura.days * avanco_semeadura).days)
data_colheita += timedelta(
(ColheitaMenosPico.days * avanco_colheita).days)
dia_juliano_semeadura = data_semeadura.timetuple().tm_yday
imagem_semeadura[i_linhas][i_coluna] = (
(data_semeadura.year * 1000) + dia_juliano_semeadura)
dia_juliano_colheita = data_colheita.timetuple().tm_yday
imagem_colheita[i_linhas][i_coluna] = (
(data_colheita.year * 1000) + dia_juliano_colheita)
saida = TableData()
imagem_semeadura = RasterFile(data=imagem_semeadura)
imagem_semeadura.metadata = images_super[0].metadata
imagem_semeadura.data_name = "semeadura"
imagem_colheita = RasterFile(data=imagem_colheita)
imagem_colheita.metadata = images_super[0].metadata
imagem_colheita.data_name = "colheita"
imagem_pico = RasterFile(data=imagem_pico)
imagem_pico.metadata = images_super[0].metadata
imagem_pico.data_name = "cenaPico"
saida["imagem_semeadura"] = imagem_semeadura
saida["imagem_colheita"] = imagem_colheita
saida["imagem_pico"] = imagem_pico
return saida
def __execOperation__(self):
self.print_text(u"Iniciando função")
images_super = self.paramentrosIN_carregados["images"]
self.console(u"Número de imagens para ler: " + str(len(images_super)))
nullValue = self.paramentrosIN_carregados["null_value"]
statistics = self.paramentrosIN_carregados["statistics"]
#self.print_text("Estatisticas a fazer: ", statistics)
doMedia = "media" in statistics
doCV = "cv" in statistics
doSD = "sd" in statistics
doSoma = "soma" in statistics
doMin = "min" in statistics
doMax = "max" in statistics
doMediana = "mediana" in statistics
doAmplitude = "amplitude" in statistics
images = images_super.loadListRasterData()
#self.print_text("Numero de imagens lidas: " + str(len(images)))
n_linhas = len(images[0])
n_colunas = len(images[0][0])
for img in images:
if len(img) != n_linhas or len(img[0]) != n_colunas:
raise IndexError("Erro - As imagens precisam ter o mesmo número de linhas e colunas")
#self.print_text("numero de colunas e linhas: " + str(n_linhas) + " : " + str(n_colunas))
#imagem_referencia = [[0 for x in range(n_colunas)] for x in range(n_linhas)]
imagem_referencia = np.zeros((n_linhas, n_colunas))
if doMedia : imagem_media = array(imagem_referencia).astype(dtype="float32")
if doCV : imagem_cv = array(imagem_referencia).astype(dtype="float32")
if doSD : imagem_sd = array(imagem_referencia)#.astype(dtype="int16")
if doSoma : imagem_soma = array(imagem_referencia).astype(dtype="float32")
if doMin : imagem_min = array(imagem_referencia).astype(dtype="float32")
if doMax : imagem_max = array(imagem_referencia).astype(dtype="float32")
if doMediana : imagem_mediana = array(imagem_referencia)#.astype(dtype="int16")
if doAmplitude : imagem_amplitude = array(imagem_referencia).astype(dtype="float32")
self.print_text(u"Processando:")
#progress( 0.0)
for i_linha in range(0, n_linhas):
#status = i_linha+1/float(n_linhas)
#progress(float(i_linha/float(n_linhas)))
self.progresso = (float(i_linha/float(n_linhas)))*100
for i_coluna in range(0, n_colunas):
line = list()
if threading.currentThread().stopped() : return
#if nullValue != None and float(nullValue) == images[1][i_linha][i_coluna] :
#pass
#else:
for img in images:
line.append(img[i_linha][i_coluna])
mean = None
sd = None
if doCV :
mean = np.nanmean(line)
sd = np.nanstd(line)
divisor = mean * 100
if divisor != 0 : cv = sd / mean * 100
else : cv = 0
imagem_cv[i_linha][i_coluna] = cv
if doMedia :
if mean == None : mean = np.nanmean(line) # calcula a média
imagem_media[i_linha][i_coluna] = mean
if doSD :
if sd == None : sd = np.nanstd(line) # calcula o desvio padrão
imagem_sd[i_linha][i_coluna] = sd
if doSoma :
soma = np.nansum(line)
imagem_soma[i_linha][i_coluna] = soma
minimo = None
if doMin :
minimo = np.nanmin(line)
imagem_min[i_linha][i_coluna] = minimo
maximo = None
if doMax :
maximo = np.nanmax(line)
imagem_max[i_linha][i_coluna] = maximo
if doMediana :
mediana = np.nanmedian(line)
imagem_mediana[i_linha][i_coluna] = mediana
if doAmplitude :
if minimo == None : minimo = np.nanmin(line)
if maximo == None : maximo = np.nanmax(line)
amplitude = maximo - minimo
imagem_amplitude[i_linha][i_coluna] = amplitude
self.print_text(u"Arrumando imagens de saida")
saida = SerialFile ()
saida.metadata = self.paramentrosIN_carregados["images"][0].metadata
if doMedia:
imagem_media = RasterFile(data = imagem_media)
imagem_media.metadata = saida.metadata
imagem_media.file_name = "imagem_media"
saida.append(imagem_media)
if doCV:
imagem_cv = RasterFile(data = imagem_cv)
imagem_cv.metadata = saida.metadata
imagem_cv.file_name = "imagem_coeficiente_variacao"
saida.append(imagem_cv)
if doSD :
imagem_sd = RasterFile(data = imagem_sd)
imagem_sd.metadata = saida.metadata
imagem_sd.file_name = "imagem_desvio_padrao"
saida.append(imagem_sd)
if doSoma :
imagem_soma = RasterFile(data = imagem_soma)
imagem_soma.metadata = saida.metadata
imagem_soma.file_name = "imagem_soma"
saida.append(imagem_soma)
if doMin :
imagem_min = RasterFile(data = imagem_min)
imagem_min.metadata = saida.metadata
imagem_min.file_name = "imagem_minimo"
saida.append(imagem_min)
if doMax :
imagem_max = RasterFile(data = imagem_max)
imagem_max.metadata = saida.metadata
imagem_max.file_name = "imagem_maximo"
saida.append(imagem_max)
if doMediana :
imagem_mediana = RasterFile(data = imagem_mediana)
imagem_mediana.metadata = saida.metadata
imagem_mediana.file_name = "imagem_mediana"
saida.append(imagem_mediana)
if doAmplitude :
imagem_amplitude = RasterFile(data = imagem_amplitude)
imagem_amplitude.metadata = saida.metadata
imagem_amplitude.file_name = "imagem_amplitude"
saida.append(imagem_amplitude)
self.print_text(u"imagens prontas para gravar, statistical stractor completo")
return saida
