Example #1
0
    def __execOperation__(self):

        self.console("Carregando imagens.")
        
        serie_Zr = self.paramentrosIN_carregados["Zr"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
        serie_TAW = self.paramentrosIN_carregados["TAW"]
        CAD_ = self.paramentrosIN_carregados["CAD"].loadRasterData() # pucha lista
        
        Zr_factor = float(serie_Zr.mutiply_factor)
        TAW_factor = float(serie_TAW.mutiply_factor)
        
        n_zr = len(serie_Zr)
        
        self.console(str(n_zr) + " imagens de Zr encontradas.")
        self.console(u"Gerando série de imagens TAW..")

        '''
            O laço a seguir percorre todas as imagens de Zr presentes
            O calculo da TAW é Zr = CAD * Zr
        '''

        for i in range(n_zr):
            
            if threading.currentThread().stopped()  : return 
            self.setProgresso(i, n_zr)

            zr = serie_Zr[i]
            data_zr = serie_Zr.getDate_time(file=zr)
            zr_ = numpy.array(zr.loadRasterData()).astype(dtype="float32")
            zr_ = zr_ * Zr_factor
            
            taw_ = zr_ * CAD_       
            taw_ *= TAW_factor
            
            taw = RasterFile(file_path=serie_TAW.root_path, ext="tif")
            taw = serie_TAW.setDate_time(data_zr, file=taw)       
            taw.data = taw_
            taw.metadata = zr.metadata
            taw.saveRasterData()
            
            taw.data = None
            serie_TAW.append(taw)
        
        return serie_TAW
Example #2
0
File: DIF.py Project: Paloschi/CyMP
    def __execOperation__(self):
        '''
            Por padrão agora assumo que, quando uma variavel tiver como sufixo um underline "_"
            é porque esta variavel contem os valores carregados (matrizes brutas) dos dados
        '''

        serie_ET0 = self.paramentrosIN_carregados["ET0"].loadListByRoot(
        )  # pucha e já carrega a lista caso não tenha sido carregada
        serie_Kc = self.paramentrosIN_carregados["Kc"].loadListByRoot(
        )  # pucha e já carrega a lista caso não tenha sido carregada
        serie_ETc = self.paramentrosIN_carregados["ETc"]  # pucha lista

        Kc_factor = float(serie_Kc.mutiply_factor)
        ET0_factor = serie_ET0.mutiply_factor
        ETC_factor = serie_ETc.mutiply_factor

        for i_Kc in range(len(serie_Kc)):
            #gdal_calc.py [-A <filename>] [--A_band] [-B...-Z filename] [other_options]
            Kc = serie_Kc[i_Kc]
            data_kc = serie_Kc.getDate_time(file=Kc)

            ET0 = self.procurar_descende_correspondente(data_kc, serie_ET0)

            etc = RasterFile(file_path=serie_ETc.root_path,
                             ext="tif",
                             file_name=Kc.file_name)

            ET0_ = numpy.array(
                ET0.loadRasterData()).astype(dtype="float32") * ET0_factor
            Kc_ = numpy.array(
                Kc.loadRasterData()).astype(dtype="float32") * Kc_factor

            dias_decend = self.dias_decend

            ETc_ = Kc_ * (ET0_ / dias_decend) * ETC_factor

            #print ET0.file_full_path
            #print Kc.file_full_path

            etc.metadata = Kc.metadata
            etc.data = ETc_
            etc.saveRasterData()
Example #3
0
 def __execOperation__(self):
     '''
         Por padrão agora assumo que, quando uma variavel tiver como sufixo um underline "_"
         é porque esta variavel contem os valores carregados (matrizes brutas) dos dados
     '''
     
     serie_ET0 = self.paramentrosIN_carregados["ET0"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
     serie_Kc = self.paramentrosIN_carregados["Kc"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
     serie_ETc = self.paramentrosIN_carregados["ETc"] # pucha lista
     
     Kc_factor = float(serie_Kc.mutiply_factor)
     ET0_factor = serie_ET0.mutiply_factor
     ETC_factor = serie_ETc.mutiply_factor
     
     
     
     for i_Kc in range(len(serie_Kc)):
         #gdal_calc.py [-A <filename>] [--A_band] [-B...-Z filename] [other_options]
         Kc = serie_Kc[i_Kc]
         data_kc = serie_Kc.getDate_time(file=Kc)
         
         ET0 = self.procurar_descende_correspondente(data_kc, serie_ET0)
         
         etc = RasterFile(file_path=serie_ETc.root_path, ext="tif", file_name=Kc.file_name)
         
         ET0_ = numpy.array(ET0.loadRasterData()).astype(dtype="float32") * ET0_factor
         Kc_ = numpy.array(Kc.loadRasterData()).astype(dtype="float32") * Kc_factor
         
         dias_decend = self.dias_decend
         
         ETc_ = Kc_ * (ET0_  / dias_decend) * ETC_factor
         
         #print ET0.file_full_path
         #print Kc.file_full_path
         
         etc.metadata = Kc.metadata
         etc.data = ETc_
         etc.saveRasterData()
Example #4
0
    def __execOperation__(self):
        '''
            Por padrão agora assumo que, quando uma variavel tiver como sufixo um underline "_"
            é porque esta variavel contem os valores carregados (matrizes brutas) dos dados
        '''

        self.print_text("Carregando imagens.")

        serie_ET0 = self.paramentrosIN_carregados["ET0"].loadListByRoot(
        )  # pucha e já carrega a lista caso não tenha sido carregada
        serie_Kc = self.paramentrosIN_carregados["Kc"].loadListByRoot(
        )  # pucha e já carrega a lista caso não tenha sido carregada
        serie_ETc = self.paramentrosIN_carregados["ETc"]  # pucha lista

        #Kc_factor = float(serie_Kc.mutiply_factor)
        #ET0_factor = float(serie_ET0.mutiply_factor)
        #ETC_factor = float(serie_ETc.mutiply_factor)

        n_et0 = len(serie_ET0)

        #self.console(str(n_et0) + " imagens de ET0 encontradas.")
        #self.console(str(len(serie_Kc)) + " imagens de Kc encontradas.")

        self.console(u"Gerando imagens de saída...")
        '''
            O laço a seguir percorre todas as imagens de ET0 presentes
            ele verifica se há imagens de Kc correspondentes para realizar a multiplicação
            caso não haja ele simplesmente mantém a imagem de ET0 como imagem de ETc
            
            O calculo de Etc é Etc = Et0 * Kc
        '''

        for i_ET0 in range(n_et0):

            if threading.currentThread().stopped(): return
            self.setProgresso(i_ET0, n_et0)

            ET0 = serie_ET0[i_ET0]
            data_ET0 = serie_ET0.getDate_time(file=ET0)
            kc = None

            data = None

            for i_Kc in range(len(serie_Kc)):
                data = serie_Kc.getDate_time(file=serie_Kc[i_Kc])
                if data == data_ET0:
                    kc = serie_Kc[i_Kc]
                    break

            etc = RasterFile(file_path=serie_ETc.root_path, ext="tif")
            etc = serie_ETc.setDate_time(data_ET0, file=etc)

            ET0_ = numpy.array(ET0.loadRasterData()).astype(
                dtype="float32")  #* ET0_factor
            ET0_[ET0_ == ET0.metadata["nodata"]] = 0
            #ET0_ = ET0_ * ET0_factor # Problemas com o factor

            if kc == None:  # caso não encontre nenhum kc correspondente a mesma data
                #self.console(u"Kc para o dia" + str(data))
                ETc_ = ET0_
                #ETc_ *= ETC_factor # Problemas com o factor
                #ETc_ = self.compactar(ETc_)
                etc.data = ETc_

            else:

                Kc_ = numpy.array(kc.loadRasterData()).astype(dtype="float32")
                #Kc_ *= Kc_factor # Problemas com o factor
                ETc_ = Kc_ * ET0_
                #ETc_ *= ETC_factor # Problemas com o factor
                #ETc_ = self.compactar(ETc_) # Problemas com o factor
                etc.data = ETc_

            etc.metadata = ET0.metadata
            etc.metadata.update(nodata=0)
            etc.metadata.update(dtype=etc.data.dtype)
            etc.saveRasterData()

            serie_ETc.append(etc)

        self.console(u"Concluído")

        return serie_ETc
Example #5
0
    def __execOperation__(self):

        self.console("Carregando imagens.")
        
        serie_eta = self.paramentrosIN_carregados["ETa"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
        serie_etc = self.paramentrosIN_carregados["ETc"].loadListByRoot()
        serie_yx = self.paramentrosIN_carregados["Yx"].loadListByRoot() # pucha lista
        serie_Kc = self.paramentrosIN_carregados["Kc"].loadListByRoot() # pucha lista
        serie_ya = self.paramentrosIN_carregados["Ya"]
        
        ky = self.paramentrosIN_carregados["Ky"]
        
        #factor_eta = float(serie_eta.mutiply_factor)
        #factor_etc = float(serie_etc.mutiply_factor)
        #factor_yx = float(serie_yx.mutiply_factor)
        #factor_ya = float(serie_ya.mutiply_factor)
        
        n_img = len(serie_Kc)
        
        self.console("As imagens de Kc serão usadas como referencia")
        self.console(str(n_img) + " imagens de Kc encontradas.")
        
        self.console(u"Gerando série de imagens de Ya..")

        for i in range(n_img):
            
            if threading.currentThread().stopped()  : return 
            self.setProgresso(i, n_img)

            kc = serie_Kc[i]
            data_ref = serie_Kc.getDate_time(file=kc)
            kc_ = kc.loadRasterData()
            
            #eta_ = self.LoadImgByDate(serie_eta, data_ref, factor_eta)
            #etc_ = self.LoadImgByDate(serie_etc, data_ref, factor_etc)
            #yx_ = self.LoadImgByDate(serie_yx, data_ref, factor_yx)
            
            eta_ = self.LoadImgByDate(serie_eta, data_ref)
            etc_ = self.LoadImgByDate(serie_etc, data_ref)
            yx_ = self.LoadImgByDate(serie_yx, data_ref)
            
            p1= ky * (1-eta_/etc_)
            ya_ = (1-p1) * yx_
            
            for i in range(len(ya_)): 
                ya_[i][kc_[i]==0] = 0
                
            #ya_ = numpy.round(ya_, 3)   
            #ya_ *= factor_ya
            
            #ya_ = self.compactar(ya_)   
            
            ya = RasterFile(file_path=serie_ya.root_path, ext="tif")
            ya = serie_ya.setDate_time(data_ref, file=ya)       
            ya.data = ya_
            ya.metadata = kc.metadata
            ya.metadata.update(nodata=0)
            ya.saveRasterData()
            
            ya.data = ya_
            
            serie_ya.append(ya)
        
        return serie_ya
Example #6
0
    def __execOperation__(self):

        serie_raw = self.paramentrosIN_carregados["RAW"].loadListByRoot()
        serie_taw = self.paramentrosIN_carregados["TAW"].loadListByRoot()
        serie_dr = self.paramentrosIN_carregados["Dr"].loadListByRoot()

        serie_ks = self.paramentrosIN_carregados["Ks"]

        #factor_raw = float(serie_raw.mutiply_factor)
        #factor_taw = float(serie_taw.mutiply_factor)
        #factor_dr = float(serie_dr.mutiply_factor)
        #factor_ks = float(serie_ks.mutiply_factor)

        n_taw = len(serie_taw)

        taw_ = serie_taw[0].loadRasterData()

        n_linhas = len(taw_)
        n_colunas = len(taw_[0])

        for i in range(n_taw):

            if threading.currentThread().stopped(): return
            self.setProgresso(i, n_taw)

            taw = serie_taw[i]
            data_taw = serie_taw.getDate_time(file=taw)
            taw_ = numpy.array(taw.loadRasterData()).astype(dtype="float32")
            #taw_ *= factor_taw

            raw_ = self.LoadImgByDate(serie_raw, data_taw, 1)

            dr_ = self.LoadImgByDate(serie_dr, data_taw, 1)

            if dr_ is None:
                self.console(u"Aviso: Imagem de Dr para a data: " +
                             str(data_taw))

            if raw_ is None:
                self.console(u"Aviso: Imagem de RAW para a data: " +
                             str(data_taw))

            if dr_ is not None and raw_ is not None:
                ''' ----------------------------------------------- '''

                ks_ = numpy.zeros((n_linhas, n_colunas))
                #ks_ +=1
                ''' ----------------------------------------------- '''

                a = (taw_ - (-dr_))
                b = (taw_ - raw_)
                c = a / b

                for i in range(len(ks_)):

                    ks_[i][-dr_[i] >= raw_[i]] = c[i][-dr_[i] >= raw_[i]]
                    ks_[i][-dr_[i] < raw_[i]] = 1
                    ks_[i][ks_[i] == -float('Inf')] = -1
                    ks_[i][taw_[i] == float('NaN')] = -1

                    #ks_[i][taw_[i] == 127] = taw.metadata["nodata"]
                    #ks_[i][raw_[i] == 0] = taw.metadata["nodata"]
                ''' ------------------------------------------------ '''

                #ks_ = numpy.round(ks_, 2)
                #ks_ *= factor_ks
                #ks_ = self.compactar(ks_)

                #ks_ = numpy.ma.masked_array(ks_, 999)

                ks_ = 1 - ks_  # invertendo o Ks pra dar certo na formulas

                print("Valor de taw_:" + str(taw_[60][83]))
                print("Valor de raw_:" + str(raw_[60][83]))
                print("Valor de dr_:" + str(dr_[60][83]))
                print("Valor de Ks:" + str(ks_[60][83]))
                print("------------------------------")

                #print data_taw
                #for i in range(n_linhas):
                #for ii in range(n_colunas):
                #if taw_[i][ii] != 0.0 and taw_[i][ii] != 127.0 and ks_[i][ii] != 1 and ks_[i][ii] != 0:
                #print a[i][ii], b[i][ii], c[i][ii]
                #print taw_[i][ii], raw_[i][ii], dr_[i][ii], ks_[i][ii]
                #print "----------------------------------"

                ks = RasterFile(file_path=serie_ks.root_path, ext="tif")
                ks = serie_ks.setDate_time(data_taw, file=ks)
                ks.data = ks_.astype(dtype="float32")
                ks.metadata = taw.metadata
                ks.metadata.update(dtype=ks.data.dtype)
                ks.metadata.update(nodata=2)
                ks.saveRasterData()
                ks.data = None
                serie_ks.append(ks)

        return serie_ks
Example #7
0
File: TAW.py Project: Paloschi/CyMP
    def __execOperation__(self):

        self.console("Carregando imagens.")
        
        serie_Zr = self.paramentrosIN_carregados["Zr"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
        serie_TAW = self.paramentrosIN_carregados["TAW"]
        CAD_ = self.paramentrosIN_carregados["CAD"].loadRasterData() # pucha lista
        p_valor = self.paramentrosIN_carregados["p"]
        
        p_valor = float(p_valor)  
        
        #print self.paramentrosIN_carregados["CAD"].metadata
        
        #CAD_ = numpy.ma.masked_array(CAD_, self.paramentrosIN_carregados["CAD"].metadata["nodata"])
        
        #Zr_factor = float(serie_Zr.mutiply_factor)
        #TAW_factor = float(serie_TAW.mutiply_factor)
        
        n_zr = len(serie_Zr)
        
        self.console(str(n_zr) + " imagens de Zr encontradas.")
        self.console(u"Gerando série de imagens...")

        '''
            O laço a seguir percorre todas as imagens de Zr presentes
            O calculo da TAW é Zr = CAD * Zr
        '''

        
        for i in range(n_zr):
            
            if threading.currentThread().stopped()  : return 
            self.setProgresso(i, n_zr)

            zr = serie_Zr[i]
            data_zr = serie_Zr.getDate_time(file=zr)
            
            zr_ = numpy.array(zr.loadRasterData()).astype(dtype="float32")
            
            n_linhas = len(zr_)
            n_colunas = len(zr_[0])
            
            taw_ = numpy.zeros((n_linhas, n_colunas)).astype(dtype="float32")
            
            CAD_ = numpy.array(CAD_).astype(dtype = "float32")
            
            #zr_ = numpy.ma.array(zr_, mask=float(zr.metadata["nodata"]))
            
            #print ("Valor Zr: " + str(zr_[0][0]))
            #print ("Valor CAD: " + str(CAD_[0][0]))
            #print ("Valor p: " + str(p_valor))
            
            taw_ = zr_ * CAD_ * p_valor
            
            #print ("Valor TAW: " + str(taw_[0][0]))
            
            taw = RasterFile(file_path=serie_TAW.root_path, ext="tif")
            taw = serie_TAW.setDate_time(data_zr, file=taw)       
            taw.data = taw_
            taw.metadata = zr.metadata
            taw.metadata.update(dtype = taw.data.dtype)
            taw.metadata.update(nodata = -2147483647)
            taw.saveRasterData()
            
            taw.data = None
            serie_TAW.append(taw)
        
        return serie_TAW
Example #8
0
    def __execOperation__(self):

        self.console("Carregando imagens.")
        
        serie_Etc = self.paramentrosIN_carregados["Etc"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
        serie_PPP = self.paramentrosIN_carregados["PPP"].loadListByRoot() 
        serie_TAW = self.paramentrosIN_carregados["TAW"].loadListByRoot() 
        serie_Dr = self.paramentrosIN_carregados["Dr"]
        CAD_ = self.paramentrosIN_carregados["CAD"].loadRasterData()
        
        
        Etc_factor = float(serie_Etc.mutiply_factor)
        PPP_factor = float(serie_PPP.mutiply_factor)
        TAW_factor = float(serie_TAW.mutiply_factor)
        Dr_factor = float(serie_Dr.mutiply_factor)
        
        n_ppp = len(serie_PPP)
        
        self.console(str(n_ppp) + u" imagens de precipitação encontradas.")
        self.console(str(len(serie_Etc)) + u" imagens de Etc encontradas.")
        self.console(str(len(serie_TAW)) + u" imagens de TAW encontradas.")
        self.console(u"Gerando balanço...")

        '''
            O laço a seguir percorre todas as imagens de Zr presentes
            O calculo da TAW é Zr = CAD * Zr
        '''
        
        Dr_anterior = None

        for i in range(n_ppp):
            
            if threading.currentThread().stopped()  : return 
            self.setProgresso(i, n_ppp)

            ppp = serie_PPP[i]
            data_ppp = serie_PPP.getDate_time(file=ppp)
            ppp_ = numpy.array(ppp.loadRasterData()).astype(dtype="float32")
            ppp_ *= PPP_factor
            
            etc = self.procura_img_por_data(serie_Etc, data_ppp)
            etc_ = numpy.array(etc.loadRasterData()).astype(dtype="float32")
            etc_ *= Etc_factor
                
            taw = self.procura_img_por_data(serie_TAW, data_ppp)
            if taw is not None :
                taw_ = numpy.array(taw.loadRasterData()).astype(dtype="float32")   
                taw_ *= TAW_factor 
            else :
                taw_ = CAD_  
                
            
            if Dr_anterior != None:
                ppp_ -= Dr_anterior
            
            Dr_ = etc_ - ppp_

            for i in range(len(taw_)) :
                Dr_[i][-Dr_[i] > taw_[i]] = -taw_[i][-Dr_[i] > taw_[i]]
                "isso aqui em baixo é pro balanço idrico nao ser menor que 0 ou seja o Dr nao pode ser maior q 0"
                Dr_[i][Dr_[i] > 0] = 0 
                
            Dr_anterior = numpy.copy(Dr_)  
            Dr_ = numpy.round(Dr_, 2)   
            Dr_ *= Dr_factor
            
            Dr_ = self.compactar(Dr_)        
            
            dr = RasterFile(file_path=serie_Dr.root_path, ext="tif")
            dr = serie_Dr.setDate_time(data_ppp, file=dr)       
            dr.data = Dr_
            dr.metadata = ppp.metadata
            dr.saveRasterData()
            dr.data = None
            serie_Dr.append(dr)
  
        return serie_Dr
Example #9
0
    def __execOperation__(self):
        '''
            Por padrão agora assumo que, quando uma variavel tiver como sufixo um underline "_"
            é porque esta variavel contem os valores carregados (matrizes brutas) dos dados
        '''
        
        self.print_text("Carregando imagens.")
        
        serie_ET0 = self.paramentrosIN_carregados["ET0"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
        serie_Kc = self.paramentrosIN_carregados["Kc"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
        serie_ETc = self.paramentrosIN_carregados["ETc"] # pucha lista
        
        Kc_factor = float(serie_Kc.mutiply_factor)
        ET0_factor = float(serie_ET0.mutiply_factor)
        ETC_factor = float(serie_ETc.mutiply_factor)
        
        n_et0 = len(serie_ET0)
        
        #self.console(str(n_et0) + " imagens de ET0 encontradas.")
        #self.console(str(len(serie_Kc)) + " imagens de Kc encontradas.")
        
        self.console(u"Gerando imagens de saída...")

        '''
            O laço a seguir percorre todas as imagens de ET0 presentes
            ele verifica se há imagens de Kc correspondentes para realizar a multiplicação
            caso não haja ele simplesmente mantém a imagem de ET0 como imagem de ETc
            
            O calculo de Etc é Etc = Et0 * Kc
        '''

        for i_ET0 in range(n_et0):
            
            if threading.currentThread().stopped()  : return 
            self.setProgresso(i_ET0, n_et0)

            ET0 = serie_ET0[i_ET0]
            data_ET0 = serie_ET0.getDate_time(file=ET0)
            kc = None
            
            for i_Kc in range(len(serie_Kc)):
                data = serie_Kc.getDate_time(file=serie_Kc[i_Kc])
                if data == data_ET0:
                    kc = serie_Kc[i_Kc]
                    break
            
            etc = RasterFile(file_path=serie_ETc.root_path, ext="tif")
            #print data_ET0
            #print kc
            etc = serie_ETc.setDate_time(data_ET0, file=etc)
            
            ET0_ = numpy.array(ET0.loadRasterData()).astype(dtype="float32") #* ET0_factor
            ET0_[ET0_==ET0.metadata["nodata"]] = 0 
            ET0_ = ET0_ * ET0_factor
            
            if kc == None: # caso não encontre nenhum kc correspondente a mesma data
                ETc_ = ET0_
                ETc_ *= ETC_factor
                ETc_ = self.compactar(ETc_)
                etc.data = ETc_
                
            else: 
                    
                Kc_ = numpy.array(kc.loadRasterData()).astype(dtype="float32")
                Kc_ *= Kc_factor
                
                '''1 é o valor default pra quando o Kc for 0 isso tem que ser visto'''
                #Kc_[Kc_==0] = 1 
                
                #print ET0.metadata
                #print kc.metadata

                ETc_ = Kc_ * ET0_
                ETc_ = numpy.round(ETc_, 2)  
                
                print "Etc", Kc_[695][879]
                print "Ks", ET0_[695][879]
                print "ETs", ETc_[695][879]
                
                
                ETc_ *= ETC_factor
                ETc_ = self.compactar(ETc_)
                
                print "ETs", ETc_[695][879]
                    
                etc.data = ETc_
            
            
            etc.metadata = ET0.metadata
            etc.metadata.update(nodata=0)
            etc.saveRasterData()
            
            serie_ETc.append(etc)
            
        self.console(u"Concluído")
            
        return serie_ETc
Example #10
0
    def __execOperation__(self):

        self.console("Carregando imagens.")

        serie_Etc = self.paramentrosIN_carregados["Etc"].loadListByRoot(
        )  # pucha e já carrega a lista caso não tenha sido carregada
        serie_PPP = self.paramentrosIN_carregados["PPP"].loadListByRoot()
        serie_TAW = self.paramentrosIN_carregados["TAW"].loadListByRoot()
        serie_Dr = self.paramentrosIN_carregados["Dr"]
        CAD_ = self.paramentrosIN_carregados["CAD"].loadRasterData()

        #Etc_factor = float(serie_Etc.mutiply_factor)
        #PPP_factor = float(serie_PPP.mutiply_factor)
        #TAW_factor = float(serie_TAW.mutiply_factor)
        #Dr_factor = float(serie_Dr.mutiply_factor)

        n_ppp = len(serie_PPP)

        self.console(str(n_ppp) + u" imagens de precipitação encontradas.")
        self.console(str(len(serie_Etc)) + u" imagens de Etc encontradas.")
        self.console(str(len(serie_TAW)) + u" imagens de TAW encontradas.")
        self.console(u"Gerando balanço...")
        '''
            O laço a seguir percorre todas as imagens de Zr presentes
            O calculo da TAW é Zr = CAD * Zr
        '''

        Dr_anterior = None

        for i in range(n_ppp):

            if threading.currentThread().stopped(): return
            self.setProgresso(i, n_ppp)

            ppp = serie_PPP[i]
            data_ppp = serie_PPP.getDate_time(file=ppp)
            ppp_ = numpy.array(ppp.loadRasterData()).astype(dtype="float32")
            #ppp_ *= PPP_factor

            etc = self.procura_img_por_data(serie_Etc, data_ppp)
            if etc is None:
                self.console(
                    u"ERRO: não foi encontrado imagem de etc para a data: " +
                    data_ppp.strftime('%d/%m/%Y') + "!")
                self.console(u"Confira as datas e as máscaras de tempo.")
                threading.currentThread().stop()
                return
            etc_ = numpy.array(etc.loadRasterData()).astype(dtype="float32")
            #etc_ *= Etc_factor

            taw = self.procura_img_por_data(serie_TAW, data_ppp)
            if taw is not None:
                taw_ = numpy.array(
                    taw.loadRasterData()).astype(dtype="float32")
                #taw_ *= TAW_factor
            else:
                taw_ = CAD_

            if Dr_anterior != None:
                ppp_ -= Dr_anterior

            Dr_ = etc_ - ppp_

            for i in range(len(taw_)):
                Dr_[i][-Dr_[i] > taw_[i]] = -taw_[i][-Dr_[i] > taw_[i]]
                #"isso aqui em baixo é pro balanço idrico nao ser menor que 0 ou seja o Dr nao pode ser maior q 0"
                Dr_[i][Dr_[i] > 0] = 0

            Dr_anterior = numpy.copy(Dr_)
            #Dr_ = numpy.round(Dr_, 2)
            #Dr_ *= Dr_factor

            #Dr_ = self.compactar(Dr_)

            dr = RasterFile(file_path=serie_Dr.root_path, ext="tif")
            dr = serie_Dr.setDate_time(data_ppp, file=dr)
            dr.data = Dr_
            dr.metadata = ppp.metadata
            dr.metadata.update(dtype=dr.data.dtype)
            dr.saveRasterData()
            dr.data = None
            serie_Dr.append(dr)

        return serie_Dr
Example #11
0
    def __execOperation__(self):
        
        serie_raw = self.paramentrosIN_carregados["RAW"].loadListByRoot()
        serie_taw = self.paramentrosIN_carregados["TAW"].loadListByRoot()
        serie_dr = self.paramentrosIN_carregados["Dr"].loadListByRoot()
        
        serie_ks = self.paramentrosIN_carregados["Ks"]
        
        factor_raw = float(serie_raw.mutiply_factor)
        factor_taw = float(serie_taw.mutiply_factor)
        factor_dr = float(serie_dr.mutiply_factor)
        factor_ks = float(serie_ks.mutiply_factor)
        
        n_taw = len(serie_taw)
        
        taw_ = serie_taw[0].loadRasterData()
        n_linhas = len(taw_)
        n_colunas = len(taw_[0])
        
        for i in range(n_taw):
            
            if threading.currentThread().stopped()  : return 
            self.setProgresso(i, n_taw)
            
            taw = serie_taw[i]
            data_taw = serie_taw.getDate_time(file=taw)
            taw_ = numpy.array(taw.loadRasterData()).astype(dtype="float32")
            taw_ *= factor_taw
            
            raw_ = self.LoadImgByDate(serie_raw, data_taw, factor_raw)
            dr_ = self.LoadImgByDate(serie_dr, data_taw, factor_dr)
            
            ''' ----------------------------------------------- '''
            
            ks_ = numpy.zeros((n_linhas, n_colunas))
            #ks_ +=1
            
            ''' ----------------------------------------------- '''
            
            a = (taw_ - (- dr_)) 
            b = (taw_ - raw_)
            c = a / b
            
            for i in range(len(ks_)) :

                ks_[i][-dr_[i] >= raw_[i]] = c[i][-dr_[i] >= raw_[i]]
                ks_[i][-dr_[i] < raw_[i]] = 1
                ks_[i][ks_[i] == -float('Inf')] = 2
                ks_[i][taw_[i] == float('NaN')] = 2
                ks_[i][taw_[i] == 127] = 2
                ks_[i][raw_[i] == 0] = 2

                
            
            ''' ------------------------------------------------ '''
            
            ks_ = numpy.round(ks_, 2)  
            ks_ *= factor_ks
            ks_ = self.compactar(ks_)
            
            ks_ = 1 - ks_ # invertendo o Ks pra dar certo na formulas
            
            #print data_taw
            #for i in range(n_linhas):
                #for ii in range(n_colunas):
                    #if taw_[i][ii] != 0.0 and taw_[i][ii] != 127.0 and ks_[i][ii] != 1 and ks_[i][ii] != 0:
                        #print a[i][ii], b[i][ii], c[i][ii]
                        #print taw_[i][ii], raw_[i][ii], dr_[i][ii], ks_[i][ii]
                        #print "----------------------------------"
            
            
            ks = RasterFile(file_path=serie_ks.root_path, ext="tif")
            ks = serie_ks.setDate_time(data_taw, file=ks)       
            ks.data = ks_
            ks.metadata = taw.metadata
            ks.metadata.update(nodata=200)
            ks.saveRasterData()
            ks.data = None
            serie_ks.append(ks)
            
        return serie_ks
Example #12
0
    def __execOperation__(self):

        self.console("Carregando imagens.")
        
        serie_eta = self.paramentrosIN_carregados["ETa"].loadListByRoot() # pucha e já carrega a lista caso não tenha sido carregada
        serie_etc = self.paramentrosIN_carregados["ETc"].loadListByRoot()
        serie_yx = self.paramentrosIN_carregados["Yx"].loadListByRoot() # pucha lista
        serie_Kc = self.paramentrosIN_carregados["Kc"].loadListByRoot() # pucha lista
        serie_ya = self.paramentrosIN_carregados["Ya"]
        
        ky = self.paramentrosIN_carregados["Ky"]
        
        factor_eta = float(serie_eta.mutiply_factor)
        factor_etc = float(serie_etc.mutiply_factor)
        factor_yx = float(serie_yx.mutiply_factor)
        factor_ya = float(serie_ya.mutiply_factor)
        
        n_img = len(serie_Kc)
        
        self.console("As imagens de Kc serão usadas como referencia")
        self.console(str(n_img) + " imagens de Kc encontradas.")
        
        self.console(u"Gerando série de imagens de Ya..")

        for i in range(n_img):
            
            if threading.currentThread().stopped()  : return 
            self.setProgresso(i, n_img)

            kc = serie_Kc[i]
            data_ref = serie_Kc.getDate_time(file=kc)
            kc_ = kc.loadRasterData()
            
            eta_ = self.LoadImgByDate(serie_eta, data_ref, factor_eta)
            etc_ = self.LoadImgByDate(serie_etc, data_ref, factor_etc)
            yx_ = self.LoadImgByDate(serie_yx, data_ref, factor_yx)
            
            
            p1= ky * (1-eta_/etc_)
            ya_ = (1-p1) * yx_
            
            for i in range(len(ya_)): 
                ya_[i][kc_[i]==0] = 0
                
            ya_ = numpy.round(ya_, 3)   
            ya_ *= factor_ya
            
            #ya_ = self.compactar(ya_)   
            
            ya = RasterFile(file_path=serie_ya.root_path, ext="tif")
            ya = serie_ya.setDate_time(data_ref, file=ya)       
            ya.data = ya_
            ya.metadata = kc.metadata
            ya.metadata.update(nodata=0)
            ya.saveRasterData()
            
            ya.data = ya_
            
            serie_ya.append(ya)
        
        return serie_ya