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 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):
images = self.paramentrosIN_carregados["images"]
if self.paramentrosIN_carregados.has_key("conf_algoritimo"):
conf_algoritimo = self.paramentrosIN_carregados["conf_algoritimo"]
else:
conf_algoritimo = dict()
img_matrix = images.loadListRasterData()
if img_matrix == None:
print self.console("Erro no carregamento das imagens")
threading.currentThread().stop()
return
self.imagem_0 = img_matrix[
0] # imagem de referencia pra leitura de valores null
conf_algoritimo["NoData"] = self.imagem_0[0][0]
self.n_bandas = len(img_matrix)
self.n_linhas = len(img_matrix[0])
self.n_colunas = len(img_matrix[0][0])
sys.stdout.write("Numero de bandas: " + str(self.n_bandas))
sys.stdout.write(" Numero de linhas: " + str(self.n_linhas))
print(" Numero de colunas: " + str(self.n_colunas))
linhas_filtradas = self.filtrar(img_matrix, conf_algoritimo)
if threading.currentThread().stopped(): return
results = linhas_filtradas
imgs_saida = SerialFile()
imgs_saida.metadata = images.metadata
i_imagem = 0
for img in self.paramentrosIN_carregados["images"]:
img.data = results[i_imagem]
i_imagem += 1
imgs_saida.append(img)
return imgs_saida
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 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):
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):
'''
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()
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
if __name__ == '__main__':
ss = SpectreStatisticalStractor()
root_ = "C:\\Users\\Paloschi\\Desktop\\data\\Rasters\\TesteFiltro\\entrada\\"
images = SerialFile(root_path=root_)
images.loadListByRoot(filtro="tif")
parametrosIN = TableData()
parametrosIN["images"] = images
parametrosIN["null_value"] = 0
statistics = list()
statistics.append("media")
statistics.append("cv")
parametrosIN["statistics"] = statistics
ss.data = parametrosIN
resultados = ss.data
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):
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
def __execOperation__(self):
images = self.paramentrosIN_carregados["images"]
if self.paramentrosIN_carregados.has_key("conf_algoritimo") : conf_algoritimo = self.paramentrosIN_carregados["conf_algoritimo"]
else : conf_algoritimo = dict()
img_matrix = images.loadListRasterData()
if img_matrix == None:
print self.console("Erro no carregamento das imagens")
threading.currentThread().stop()
return
self.imagem_0 = img_matrix[0] # imagem de referencia pra leitura de valores null
conf_algoritimo["NoData"] = self.imagem_0[0][0]
#conf_algoritimo["NoData"] = double(images[0].getRasterInformation()["NoData"])
self.n_bandas = len(img_matrix)
self.n_linhas = len(img_matrix[0])
self.n_colunas = len(img_matrix[0][0])
sys.stdout.write("Numero de bandas: " + str(self.n_bandas))
sys.stdout.write(" Numero de linhas: " + str(self.n_linhas))
print(" Numero de colunas: " + str(self.n_colunas))
linhas_filtradas = self.filtrar(img_matrix, conf_algoritimo)
if threading.currentThread().stopped() : return
results = linhas_filtradas
#results = np.zeros((self.n_bandas, self.n_linhas, self.n_colunas,))
#results = array(results).astype(dtype="int16")
#i_imagem = 0
#i_linha = 0
#i_coluna = 0
#sys.stdout.write( "Criando nova série de imagens com valores filtrados: ")
#progress( 0.0 )
#print ("numero de colunas", self.n_colunas)
#for linha in linhas_filtradas:
#i_imagem=0
#progress( (i_linha+1) / float(self.n_linhas))
#while self.imagem_0[i_linha][i_coluna] == conf_algoritimo["NoData"]:
#i_coluna+=1
#if i_coluna>=self.n_colunas:
#i_coluna=0
#i_linha+=1
#for pixel in linha:
#results[i_imagem][i_linha][i_coluna] = pixel
#i_imagem+=1
#i_coluna+=1
#if i_coluna>=self.n_colunas:
#i_coluna=0
#i_linha+=1
imgs_saida = SerialFile()
imgs_saida.metadata = images.metadata
i_imagem = 0
for img in self.paramentrosIN_carregados["images"]:
img.data = results[i_imagem]
i_imagem+=1
imgs_saida.append(img)
#saida = TableData()
#saida["images"] = img_saida
return imgs_saida
# -*- coding: utf-8 -*-
'''
Created on Aug 17, 2015
@author: Paloschi
'''
from Modelo.beans import SerialFile
import rasterio
from numpy.core.numeric import array
import numpy
pathIn = "C:\\Users\\Paloschi\\Desktop\\New folder\\recortadas"
pathOut = "C:\Users\Paloschi\Desktop\New folder\EVI2"
imagens_rgb = SerialFile(root_path=pathIn)
imagens_rgb.loadListByRoot(filtro = "tif")
for img in imagens_rgb:
with rasterio.open(img.file_full_path) as raster:
r, g, b = raster.read()
metadata = raster.meta
'''EVI2= 2,5 [(N-R) / (N + 2,4R+1)] '''
N = r.astype(rasterio.float64)# vermelho é o infravermelho próximo
R = b.astype(rasterio.float64) # azul é o vermelho
#print r
#print b
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):
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
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
if __name__ == '__main__':
ss = SpectreStatisticalStractor()
root_ = "C:\\Users\\Paloschi\\Desktop\\data\\Rasters\\TesteFiltro\\entrada\\"
images = SerialFile(root_path = root_)
images.loadListByRoot(filtro = "tif")
parametrosIN = TableData()
parametrosIN["images"] = images
parametrosIN["null_value"] = 0
statistics = list()
statistics.append("media")
statistics.append("cv")
parametrosIN["statistics"] = statistics
ss.data = parametrosIN
resultados = ss.data
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
# -*- coding: utf-8 -*-
'''
Created on Aug 17, 2015
@author: Paloschi
'''
from Modelo.beans import SerialFile
import rasterio
from numpy.core.numeric import array
import numpy
pathIn = "C:\\Users\\Paloschi\\Desktop\\New folder\\recortadas"
pathOut = "C:\Users\Paloschi\Desktop\New folder\EVI2"
imagens_rgb = SerialFile(root_path=pathIn)
imagens_rgb.loadListByRoot(filtro="tif")
for img in imagens_rgb:
with rasterio.open(img.file_full_path) as raster:
r, g, b = raster.read()
metadata = raster.meta
'''EVI2= 2,5 [(N-R) / (N + 2,4R+1)] '''
N = r.astype(rasterio.float64) # vermelho é o infravermelho próximo
R = b.astype(rasterio.float64) # azul é o vermelho
#print r
#print b
#print N
for p in processes:
p.join()
results = [output.get() for p in processes]
print(results)
i_linhas += n_threadings
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")
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
if __name__ == '__main__':
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\\"
f = RasterToCSVeVRT()
f.executar(paramIN)
