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 __execOperation__(self):
self.console(u"iniciando operação de interpolação")
tabela_data = self.paramentrosIN_carregados['table_data']
atributo_interpolacao = self.paramentrosIN_carregados['atributo']
format_image_data = self.paramentrosIN_carregados['format_image_data']
self.console(u"Preparando interpolacao:")
self.WriteVRTfiles(tabela_data.data, atributo_interpolacao)
self.WriteCSVfiles(tabela_data.data, atributo_interpolacao)
path = tabela_data.data['data_path']
keys = tabela_data.keys()
self.console(u"Preparacao completa, interpolando:")
print(keys)
if len(keys) > 0:
for key in keys:
if (key!="data_path"):
self.console(u"criando tabela de interpolação, key: " + key)
informacao = self.CreateInterpolationTable(path, key, atributo_interpolacao, format_image_data)
interpolation_table = TableData("iformacao de interpolacao")
interpolation_table.data = informacao
interpolador = InterpoladorIvD("interpolando ECMWF")
interpolador.data = interpolation_table
self.console (interpolador.data)
else:
informacao = self.CreateInterpolationTable(path, None, atributo_interpolacao, format_image_data)
interpolation_table = TableData("iformacao de interpolacao")
interpolation_table.data = informacao
interpolador = InterpoladorIvD("interpolando ECMWF")
interpolador.data = interpolation_table
self.console (interpolador.data)
self.console (u"Interpolacao completa")
return (u"Interpolacao completa")
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 carregarParamIN(self):
images = SerialFile()
parametrosIN = TableData()
root_in = self.ui.leInFolder.text()
root_in = _fromUtf8(str(root_in) + "\\")
root_in = str(root_in).replace("\\", "/")
images.loadListByRoot(root_in)
self.print_text(u"Numero de imagens encontradas:" + str(len(images)))
parametrosIN["images"] = images
conf_algoritimo = TableData()
conf_algoritimo["window_size"] = self.ui.leWindowSize.text()
conf_algoritimo["order"] = self.ui.leOrdem.text()
#if self.ui.checkBox.isChecked() : conf_algoritimo["null_value"] = double(self.ui.leNullValue.text())
#else : conf_algoritimo["null_value"] = FileData(data= None)
parametrosIN["conf_algoritimo "] = conf_algoritimo
return parametrosIN
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 executa(self):
self.function = ExtratorSemeaduraColheita()
self.function.print_text = self.print_text
root_out = str(self.ui.leOutFolder.text())
root_in = str(self.ui.leInFolder.text())
parametrosIN = TableData()
images = SerialFile(root_path=root_in)
parametrosIN["images"] = images
parametrosIN["avanco_semeadura"] = double(
self.ui.dspASemeadura.value())
parametrosIN["avanco_colheita"] = double(self.ui.dsbAColheita.value())
parametrosIN["intervalo_pico"] = str(self.ui.lePPico.text())
parametrosIN["intervalo_semeadura"] = str(self.ui.lePSemeadura.text())
parametrosIN["intervalo_colheita"] = str(self.ui.lePColheita.text())
parametrosIN["null_value"] = double(self.ui.leNullValue.text())
parametrosIN["prefixo"] = str(self.ui.lePrefixo.text())
parametrosIN["sufixo"] = str(self.ui.leSufixo.text())
parametrosIN["mask"] = str(self.ui.leMascara.text())
images = self.function.executar(parametrosIN)
if self.funcao_cancelada(): return
self.print_text(u"Salvando imagens.")
semeadura = images["imagem_semeadura"]
semeadura.file_name = self.ui.leImgSemeadura.text()
semeadura.file_path = str(self.ui.leOutFolder.text())
semeadura.file_ext = "tif"
semeadura.saveRasterData()
colheita = images["imagem_colheita"]
colheita.file_name = self.ui.leImgColheita.text()
colheita.file_path = str(self.ui.leOutFolder.text())
colheita.file_ext = "tif"
colheita.saveRasterData()
pico = images["imagem_pico"]
pico.file_name = self.ui.leImgPico.text()
pico.file_path = str(self.ui.leOutFolder.text())
pico.file_ext = "tif"
pico.saveRasterData()
self.print_text("Terminado.")
self.finalizar()
def executa(self):
self.function = SpectreStatisticalStractor()
self.print_text(u"Organizando dados necessários")
root_in = str(self.ui.leInFolder.text())
root_in = path.normpath(root_in)
imagens_entrada = SerialFile()
imagens_entrada = imagens_entrada.loadListByRoot(root_in, "tif, img")
if (len(imagens_entrada) == 0):
self.console(u"Nenhuma imagem encontrada, abortando função")
self.finalizar()
self.console(u"Função finalizada")
return
root_out = str(self.ui.leOutFolder.text())
root_out = path.normpath(root_out)
paramsIN = TableData()
paramsIN["images"] = imagens_entrada
paramsIN["statistics"] = self.statistical_list
images_saida = self.function.executar(paramsIN)
self.print_text("Salvando imagens")
if self.funcao_cancelada():
return None
for imagem in images_saida:
try:
imagem.saveRasterData(file_path=root_out, ext="tif")
self.console("Imagem " + imagem.file_name + " salva.")
except:
self.console(
u"Não foi possivel salvar a imagem: " + imagem.file_name +
u". Verifique se o arquivo está sendo usado por outro aplicativo."
)
self.print_text(u"Conluído.")
self.finalizar()
def __execOperation__(self):
self.console(u"iniciando operação de interpolação")
tabela_data = self.paramentrosIN_carregados['table_data']
atributo_interpolacao = self.paramentrosIN_carregados['atributo']
format_image_data = self.paramentrosIN_carregados['format_image_data']
self.console(u"Preparando interpolacao:")
self.WriteVRTfiles(tabela_data.data, atributo_interpolacao)
self.WriteCSVfiles(tabela_data.data, atributo_interpolacao)
path = tabela_data.data['data_path']
keys = tabela_data.keys()
self.console(u"Preparacao completa, interpolando:")
print(keys)
if len(keys) > 0:
for key in keys:
if (key != "data_path"):
self.console(u"criando tabela de interpolação, key: " +
key)
informacao = self.CreateInterpolationTable(
path, key, atributo_interpolacao, format_image_data)
interpolation_table = TableData(
"iformacao de interpolacao")
interpolation_table.data = informacao
interpolador = InterpoladorIvD("interpolando ECMWF")
interpolador.data = interpolation_table
self.console(interpolador.data)
else:
informacao = self.CreateInterpolationTable(path, None,
atributo_interpolacao,
format_image_data)
interpolation_table = TableData("iformacao de interpolacao")
interpolation_table.data = informacao
interpolador = InterpoladorIvD("interpolando ECMWF")
interpolador.data = interpolation_table
self.console(interpolador.data)
self.console(u"Interpolacao completa")
return (u"Interpolacao completa")
def executa(self):
'''
Criando arquivos CSVs e VRTs para submeter a interpolação
'''
self.console(u"Recolhendo informações")
self.function = RasterToCSVeVRT()
paramIn = TableData()
paramIn["images"] = SerialFile(root_path=str(self.ui.txInFolder.text()))
paramIn["out_folder"] = str(self.ui.txOutFolder.text())
self.print_text(u'Interpolando imagens...')
resultado = self.interpolar_todas_as_imagens(paramIn)
if self.funcao_cancelada():
#self.console(u"Função interrompida")
self.finalizar()
elif resultado is not None:
self.console(u"Função concluída")
self.finalizar()
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
if __name__ == '__main__':
ss = SpectreStatisticalStractor_MT()
root_ = "C:\\Users\\rennan.paloschi\\Desktop\\Dados_Gerais\\raster\\pesada"
images = SerialFile(root_path=root_)
images.loadListByRoot(filtro="tif")
linha = list()
for img in images:
linha.append(img.loadRasterData()[0][:])
print(len(linha), "----------------------------------")
print(len(linha[0]), "----------------------------------")
parametrosIN = TableData()
parametrosIN["images"] = images
statistics = list()
statistics.append("media")
statistics.append("cv")
parametrosIN["statistics"] = statistics
ss.data = parametrosIN
resultados = ss.data
imagens = resultados
print imagens
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
paramIN["Kc"]["50-140"] = 0.60
#print "chamando funcao"
funcao = DistribuidorKC_()
#funcao.console = console
def __execOperation__(self):
imagensIN = self.paramentrosIN_carregados["images"]
outFolder = self.paramentrosIN_carregados["out_folder"]
imagensIN.loadListByRoot()
listaCSV = SerialFile()
listaVRT = SerialFile()
n_imagens = len(imagensIN)
i_imagem = 0
self.setProgresso(i_imagem, n_imagens)
for img in imagensIN :
matriz = img.loadRasterData()
nome_img = img.file_name
info = img.getRasterInformation()
xmin = float(info["xmin"])
xmax = float(info["xmax"])
nx = float(info["nx"])
x_pixelSize = (xmax - xmin) / nx
ymin = float(info["ymin"])
ymax = float(info["ymax"])
ny = float(info["ny"])
y_pixelSize = (ymax - ymin) / ny
n_linhas = len(matriz)
n_colunas = len(matriz[0])
csv_file = FileData(file_path=outFolder, file_name = nome_img, ext = "csv")
file_csv_path = csv_file.file_full_path
init_y_position = ymin + (y_pixelSize/2)
init_x_position = xmin + (x_pixelSize/2)
with open(file_csv_path,'w') as csv:
csv.write("Easting,Northing,Value\n")
for i_linha in range(0, n_linhas):
progress(i_linha/float(n_linhas-1))
cy = init_y_position + (y_pixelSize * i_linha)
cy = str(cy)
for i_coluna in range(0, n_colunas):
value = matriz[i_linha][i_coluna]
if threading.current_thread().stopped() : return None
cx = init_x_position + (x_pixelSize * i_coluna)
line = str(cx) + ',' + cy + ',' + str(value) + '\n'
csv.write(line)
listaCSV.append(csv_file)
vrt_file = csv_file
vrt_file.file_ext = "vrt"
root = etree.Element("OGRVRTDataSource")
csv_node = etree.Element("OGRVRTLayer", name=csv_file.file_name)
root.append(csv_node)
csv_node.append(etree.XML("<SrcDataSource>" +file_csv_path+"</SrcDataSource>"))
csv_node.append(etree.XML("<GeometryType>wkbPoint</GeometryType>"))
csv_node.append(etree.XML('<GeometryField encoding="PointFromColumns" x="Easting" y="Northing" z="Value"/>'))
tree = etree.ElementTree(root)
tree.write(vrt_file.file_full_path, pretty_print=True)
listaVRT.append(vrt_file)
i_imagem = i_imagem + 1.0
self.setProgresso(i_imagem, n_imagens)
saida = TableData()
saida["CSVs"] = listaCSV
saida["VRTs"] = listaVRT
return saida
