def calc_arvi(self): r = QgsRasterCalculatorEntry() r.ref = self.red.name() + '@1' r.raster = self.red r.bandNumber = 1 ir = QgsRasterCalculatorEntry() ir.ref = self.nir.name() + '@2' ir.raster = self.nir ir.bandNumber = 1 b = QgsRasterCalculatorEntry() b.ref = self.blue.name() + '@3' b.raster = self.blue b.bandNumber = 1 entries = list() entries.append(r) entries.append(ir) entries.append(b) expression = '({0} - ({1} - {3} * ({1} - {2}))) / ({0} + ({1} - {3} * ({1} - {2})))'.format( ir.ref, r.ref, b.ref, str(self.a) ) calc = QgsRasterCalculator( expression, self.output, "GTiff", self.red.extent(), self.red.width(), self.red.height(), entries ) calc.processCalculation()
def lulc_study_area(self): tempdir = self.gettempdir() lulc_layer = self.lulc_layer() study_area = self.study_layer() # Get Study area layer info. studylyrName = study_area.name() entries = [] studyras = QgsRasterCalculatorEntry() studyras.ref = studylyrName + '@1' studyras.raster = study_area studyras.bandNumber = 1 entries.append(studyras) # Get lulc layer info. lulcName = lulc_layer.name() lulcras = QgsRasterCalculatorEntry() lulcras.ref = lulcName + '@1' lulcras.raster = lulc_layer lulcras.bandNumber = 1 entries.append(lulcras) formula = "\"" + studyras.ref + "\"" + ' * ' + "\"" + lulcras.ref + "\"" output_lulc_study = tempdir + "/%s_study.tif" % str(lulcName) calc = QgsRasterCalculator(formula, output_lulc_study, 'GTiff', study_area.extent(), study_area.width(), study_area.height(), entries) calc.processCalculation() del entries return output_lulc_study
def run(self): """ Start of calculation. A GTiff-file is created in the process. """ self.LOGGER.debug("start NDVI calculation") r = QgsRasterCalculatorEntry() ir = QgsRasterCalculatorEntry() r.raster = self.red_raster_layer ir.raster = self.infrared_raster_layer r.bandNumber = self.red_band_number ir.bandNumber = self.infrared_band_number r.ref = self.red_raster_layer.name() + "@" + str(self.red_band_number) ir.ref = self.infrared_raster_layer.name() + "@" + str( self.infrared_band_number) references = (ir.ref, r.ref, ir.ref, r.ref) formula_string = '("%s" - "%s") / ("%s" + "%s")' % references output_format = "GTiff" output_extent = self.red_raster_layer.extent() n_output_columns = self.red_raster_layer.width() n_output_rows = self.red_raster_layer.height() raster_entries = [ir, r] ndvi_raster_calculator = QgsRasterCalculator( formula_string, self.output_file_name, output_format, output_extent, n_output_columns, n_output_rows, raster_entries) ndvi_raster_calculator.processCalculation() self.finished.emit(self.output_file_name)
def processing_ndvi_calc(rLayer1, rLayer2, path): """ Older deprecated NDVI handler, This is simply the template for the monstrosity that the current one has become :param rLayer1: rLayer 1 Object :param rLayer2: rLayer 2 Object :param path: Path to Output too :return: None """ path = path r1 = QgsRasterCalculatorEntry() r2 = QgsRasterCalculatorEntry() r1.ref = "rLayer@1" r2.ref = "rLayer@2" r1.raster = rLayer1 r2.raster = rLayer2 r1.bandNumber = 1 r2.bandNumber = 1 entries = [r1, r2] expression = "(\"{0}\"-\"{1}\")/(\"{2}\"+\"{3}\")".format( r1.ref, r2.ref, r1.ref, r2.ref) a = QgsRasterCalculator(expression, path, 'GTiff', rLayer1.extent(), rLayer1.width(), rLayer1.height(), entries) a.processCalculation()
def RasterAddition(luccraster, nppraster, outputfilename): luccraster = OpenRaster(luccfilename) # print("Lucc : " + str(luccraster.isValid())) nppraster = OpenRaster(nppfilename) # print("NPP : " + str(nppraster.isValid())) entries = [] boh1 = QgsRasterCalculatorEntry() boh1.ref = 'lucc@1' boh1.raster = luccraster boh1.bandNumber = 1 entries.append(boh1) boh2 = QgsRasterCalculatorEntry() boh2.ref = 'npp@1' boh2.raster = nppraster boh2.bandNumber = 1 entries.append(boh2) # Process calculation with input extent and resolution calc = QgsRasterCalculator('lucc@1 + npp@1', outputfilename, 'GTiff', luccraster.extent(), luccraster.width(), luccraster.height(), entries) calc.processCalculation()
def calc_sipi(self): lyr1 = self.getRed() lyr2 = self.getNir() lyr3 = self.getBlue() output = os.path.join(self.dlg.le_output.text(),"sipi.tif") entries = [] #red band ras1 = QgsRasterCalculatorEntry() ras1.ref = 'red' ras1.raster = lyr1 ras1.bandNumber = 1 entries.append(ras1) #nir band ras2 = QgsRasterCalculatorEntry() ras2.ref = 'nir' ras2.raster = lyr2 ras2.bandNumber = 1 entries.append( ras2 ) #blue band ras3 = QgsRasterCalculatorEntry() ras3.ref = 'blue' ras3.raster = lyr3 ras3.bandNumber = 1 entries.append( ras3 ) calc = QgsRasterCalculator( '("nir" - "blue") / ("nir" - "red")', \ output, 'GTiff', lyr1.extent(), lyr1.width(), lyr1.height(), entries ) calc.processCalculation() self.iface.messageBar().pushMessage("SIPI Output Created Successfully", level=Qgis.Success, duration=3)
def processAlgorithm(self, parameters, context, progress): output = self.parameterAsOutputLayer(parameters, self.OUTPUT_SURFACE, context) bottomRaster = self.parameterAsRasterLayer(parameters, self.BOTTOM_SURFACE, context) topRaster = self.parameterAsRasterLayer(parameters, self.TOP_SURFACE, context) entries = [] ras = QgsRasterCalculatorEntry() ras.ref = 'ras@1' ras.raster = topRaster ras.bandNumber = 1 entries.append(ras) ras1 = QgsRasterCalculatorEntry() ras1.ref = 'ras1@1' ras1.raster = bottomRaster ras1.bandNumber = 1 entries.append(ras1) calc = QgsRasterCalculator( 'ras@1 + (ras1@1 - ras@1) * ((ras1@1 - ras@1) >= 0)', output, 'GTiff', bottomRaster.extent(), bottomRaster.width(), bottomRaster.height(), entries) calc.processCalculation() return {self.OUTPUT_SURFACE: output}
def WeightedOverlay(bohLayer, bohLayer1): tf = tempfile.TemporaryDirectory() tfile = tf.name + "\\OUTPUT.tif" entries = [] #define band 1 boh1 = QgsRasterCalculatorEntry() boh1.ref = 'boh@1' boh1.raster = bohLayer boh1.bandNumber = 1 entries.append(boh1) #define band 2 boh2 = QgsRasterCalculatorEntry() boh2.ref = 'boh1@1' boh2.raster = bohLayer1 boh2.bandNumber = 1 entries.append(boh2) # Process calculation with input extent and resolution calc = QgsRasterCalculator('Float(boh1@1 - boh@1)/Float(boh1@1 + boh@1)', 'outputfile', 'GTiff', bohLayer.extent(), bohLayer.width(), bohLayer.height(), entries) calc.processCalculation() '''
def processAlgorithm(self, parameters, context, progress): output = self.parameterAsOutputLayer(parameters, self.OUTPUT_SURFACE, context) topRaster = self.parameterAsRasterLayer(parameters, self.TOP_SURFACE, context) bottomRaster = self.parameterAsRasterLayer(parameters, self.BOTTOM_SURFACE, context) ntgRaster = self.parameterAsRasterLayer(parameters, self.NTG_SURFACE, context) poroRaster = self.parameterAsRasterLayer(parameters, self.PORO_SURFACE, context) vnkValue = self.parameterAsDouble(parameters, self.VNK_VALUE, context) formula = '( base@1 - top@1 ) * ( base@1 <= {0} ) + ( {0} - top@1 ) * ( base@1 > {0} ) * ' \ '( ( base@1 - top@1 ) * ( base@1 <= {0}) + ( {0} - top@1 ) * ( base@1 > {0} ) > 0)'.format(vnkValue) entries = [] ras = QgsRasterCalculatorEntry() ras.ref = 'top@1' ras.raster = topRaster ras.bandNumber = 1 entries.append(ras) ras1 = QgsRasterCalculatorEntry() ras1.ref = 'base@1' ras1.raster = bottomRaster ras1.bandNumber = 1 entries.append(ras1) calc = QgsRasterCalculator(formula, output, 'GTiff', bottomRaster.extent(), bottomRaster.width(), bottomRaster.height(), entries) calc.processCalculation(progress) return {self.OUTPUT_SURFACE: output}
def calc_cvi(self): lyr1 = self.getRed() lyr2 = self.getNir() lyr3 = self.getGreen() output = os.path.join(self.dlg.le_output.text(),"cvi.tif") entries = [] #red band ras1 = QgsRasterCalculatorEntry() ras1.ref = 'red' ras1.raster = lyr1 ras1.bandNumber = 1 entries.append(ras1) #nir band ras2 = QgsRasterCalculatorEntry() ras2.ref = 'nir' ras2.raster = lyr2 ras2.bandNumber = 1 entries.append( ras2 ) #green band ras3 = QgsRasterCalculatorEntry() ras3.ref = 'green' ras3.raster = lyr3 ras3.bandNumber = 1 entries.append( ras3 ) calc = QgsRasterCalculator( '"nir" * ("red" / ("green" * "green"))', \ output, 'GTiff', lyr1.extent(), lyr1.width(), lyr1.height(), entries ) calc.processCalculation() self.iface.messageBar().pushMessage("CVI Output Created Successfully", level=Qgis.Success, duration=3)
def calc_savi(self): r = QgsRasterCalculatorEntry() r.ref = self.red.name() + '@1' r.raster = self.red r.bandNumber = 1 ir = QgsRasterCalculatorEntry() ir.ref = self.nir.name() + '@2' ir.raster = self.nir ir.bandNumber = 1 entries = list() entries.append(r) entries.append(ir) expression = '(({0} - {1}) / ({0} + {1} + {2})) * (1 + {2})'.format( ir.ref, r.ref, self.L ) calc = QgsRasterCalculator( expression, self.output, "GTiff", self.red.extent(), self.red.width(), self.red.height(), entries ) calc.processCalculation()
def pop_boundary(self): tempdir = self.gettempdir() study_area = self.study_layer() pop_layer = self.pop_layer() entries = [] # Get Study area layer info. studylyrName = study_area.name() studyras = QgsRasterCalculatorEntry() studyras.ref = studylyrName + '@1' studyras.raster = study_area studyras.bandNumber = 1 entries.append(studyras) # Get Population area layer info. poplyrName = pop_layer.name() popras = QgsRasterCalculatorEntry() popras.ref = poplyrName + '@1' popras.raster = pop_layer popras.bandNumber = 1 entries.append(popras) formula = "\"" + studyras.ref + "\"" + ' * ' + "\"" + popras.ref + "\"" #print formula pop_output = tempdir + "/%s_study.tif" % str(poplyrName) #print pop_output calc = QgsRasterCalculator(formula, pop_output, 'GTiff', study_area.extent(), study_area.width(), study_area.height(), entries) calc.processCalculation() del entries return pop_output
def calcular(self): RED = QgsRasterLayer( self.carga_RED.filePath()) #Se guarda en la variable RED NIR = QgsRasterLayer( self.carga_NIR.filePath()) #Se guarda en la variable NIR # SE COMPRUEBA QUE LAS IMAGENES DE ENTRADA TENGAN LAS MISMAS DIMENSIONES if RED.width() == NIR.width() and RED.height() == NIR.height(): continuar = True else: ctypes.windll.user32.MessageBoxW( 0, "¡Las imágenes no tienen las mismas dimensiones!. Carguelas de nuevo", "Error!!", 1) continuar = False # SI LAS IMAGENES DE ENTRADA TIENEN LAS MISMAS DIMENSIONES SE EJECUTA if continuar == True: iface.addRasterLayer(str(self.carga_RED.filePath()) ) # Se carga en QGIS, en el espaio de trabajo iface.addRasterLayer(str(self.carga_NIR.filePath()) ) # Se carga en QGIS, en el espaio de trabajo # Definicion de los paramentros necesarios para la aplicacion de QgsRasterCalculator output = self.txt_ruta.text() entries = [] #BANDA RED ras = QgsRasterCalculatorEntry() ras.ref = 'ras@1' ras.raster = RED ras.bandNumber = 1 entries.append(ras) #BANDA NIR ras = QgsRasterCalculatorEntry() ras.ref = 'ras@2' ras.raster = NIR ras.bandNumber = 1 entries.append(ras) #DEPENDIENDO DEL ÍNDICE DE VEGETACIÓN SELECCIONADO EJECUTA UN CÁLCULO U OTRO if self.rb_AVI.isChecked() == True: calc = QgsRasterCalculator( '("ras@2"*(1-"ras@1")*("ras@2"-"ras@1"))^(1/3)', output, 'GTiff', RED.extent(), RED.width(), RED.height(), entries) calc.processCalculation() if self.rb_NDVI.isChecked() == True: calc = QgsRasterCalculator( '("ras@2"-"ras@1")/("ras@2"+"ras@1")', output, 'GTiff', RED.extent(), RED.width(), RED.height(), entries) calc.processCalculation() if self.rb_SAVI.isChecked() == True: calc = QgsRasterCalculator( '(("ras@2"-"ras@1")/("ras@2"+"ras@1"+0.5))*1.5', output, 'GTiff', RED.extent(), RED.width(), RED.height(), entries) calc.processCalculation() iface.addRasterLayer( output) # Se carga en QGIS el Output, en el espaio de trabajo
def calc_e1(self, dir_output, dir_D_11, dir_C_besar_10, dir_D_10, dir_E0, temp_folder): self.dir_output = dir_output self.path = os.path.join(str(Path(dir_output).parent), 'temp_folder', '') self.temp_folder = temp_folder self.dir_D_11 = dir_D_11 self.dir_C_besar_10 = dir_C_besar_10 self.dir_D_10 = dir_D_10 self.dir_E0 = dir_E0 self.dir_output_temp = self.path + 'E1.tif' entries = [] D_11 = QgsRasterLayer(self.dir_D_11) ras = QgsRasterCalculatorEntry() ras.ref = '11 - D@1' ras.raster = D_11 ras.bandNumber = 1 entries.append(ras) C_besar_10 = QgsRasterLayer(self.dir_C_besar_10) ras = QgsRasterCalculatorEntry() ras.ref = '10 - C besar@1' ras.raster = C_besar_10 ras.bandNumber = 1 entries.append(ras) D_10 = QgsRasterLayer(self.dir_D_10) ras = QgsRasterCalculatorEntry() ras.ref = '10 - D@1' ras.raster = D_10 ras.bandNumber = 1 entries.append(ras) E0 = QgsRasterLayer(self.dir_E0) ras = QgsRasterCalculatorEntry() ras.ref = 'E0@1' ras.raster = E0 ras.bandNumber = 1 entries.append(ras) if self.temp_folder == 'yes': calc = QgsRasterCalculator( '"11 - D@1" * ( 1 - "10 - C besar@1" - "10 - D@1" ) / "E0@1"', self.dir_output_temp, 'GTiff', E0.extent(), E0.width(), E0.height(), entries) calc.processCalculation() elif self.temp_folder == 'no': calc = QgsRasterCalculator( '"11 - D@1" * ( 1 - "10 - C besar@1" - "10 - D@1" ) / "E0@1"', self.dir_output, 'GTiff', E0.extent(), E0.width(), E0.height(), entries) calc.processCalculation() iface.addRasterLayer(str(self.dir_output))
def processAlgorithm(self, parameters, context, feedback): """ Here is where the processing itself takes place. """ # Retrieve the feature source and sink. The 'dest_id' variable is used # to uniquely identify the feature sink, and must be included in the # dictionary returned by the processAlgorithm function. rasterInput1 = self.parameterAsRasterLayer(parameters, self.INPUT_1, context) rasterInput2 = self.parameterAsRasterLayer(parameters, self.INPUT_2, context) FOperation = self.parameterAsEnum(parameters, self.CHOICE_FOPERATION, context) feedback.pushInfo('Fuzzy Operation: ' + str(FOperation)) outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) feedback.pushInfo('Output File: ' + outputFile) rCalcEntry1 = QgsRasterCalculatorEntry() rCalcEntry1.ref = 'r1@1' rCalcEntry1.raster = rasterInput1 rCalcEntry2 = QgsRasterCalculatorEntry() rCalcEntry2.ref = 'r2@1' rCalcEntry2.raster = rasterInput2 fsum = '1 - (( 1 - r1@1) * (1 - r2@1))' fAnd = '((r1@1 < r2@1) * r1@1 ) + ((r2@1 < r1@1) * r2@1 ) + ((r2@1 = r1@1) * r2@1 ) ' fOr = '((r1@1 > r2@1) * r1@1 ) + ((r2@1 > r1@1) * r2@1 ) + ((r2@1 = r1@1) * r2@1 )' fMultiply = 'r1@1 * r2@1' if FOperation == 0: formula = fsum elif FOperation == 1: formula = fAnd elif FOperation == 2: formula = fOr elif FOperation == 3: formula = fMultiply feedback.pushInfo('Operator: ' + str(FOperation)) feedback.pushInfo('Formula: ' + str(formula)) calc = QgsRasterCalculator(formula, outputFile, 'GTiff', rasterInput1.extent(), rasterInput1.width(), rasterInput1.height(), [rCalcEntry1, rCalcEntry2]) feedback.pushInfo("p calc1") calc.processCalculation() feedback.pushInfo("p calc1") return {self.OUTPUT: outputFile}
def calculate_PCD(red,nir,pcdPath): # Obtain file information and create the layers redInfo=QFileInfo(red) nirInfo=QFileInfo(nir) redBaseName=redInfo.baseName() nirBaseName=nirInfo.baseName() folderPath = redInfo.absolutePath() redReflectancePath = folderPath + "/red_reflectance.tif" nirReflectancePath = folderPath + "/nir_reflectance.tif" redLayer = QgsRasterLayer(red,redBaseName) if not redLayer.isValid(): print "Error importing red band to calculate reflectances" nirLayer = QgsRasterLayer(nir,nirBaseName) if not nirLayer.isValid(): print "Error importing NIR band to calculate reflectances" # The images are transformed into reflectances by dividing by 32768 entries=[] redReflectance = QgsRasterCalculatorEntry() redReflectance.ref = "red_band@1" redReflectance.raster=redLayer redReflectance.bandNumber = 1 entries.append(redReflectance) # Converts the DN raster into a reflectance raster calc=QgsRasterCalculator('float(' + redReflectance.ref + ')/32768', redReflectancePath,"GTiff",redLayer.extent(),redLayer.width(),redLayer.height(), entries) calc.processCalculation() nirReflectance = QgsRasterCalculatorEntry() nirReflectance.ref = "nir_band@1" nirReflectance.raster=nirLayer nirReflectance.bandNumber = 1 entries.append(nirReflectance) # Converts the DN raster into a reflectance raster calc=QgsRasterCalculator('float(' + nirReflectance.ref + ')/32768', nirReflectancePath,"GTiff",nirLayer.extent(),nirLayer.width(),nirLayer.height(), entries) calc.processCalculation() # Calculate the PCD index calc=QgsRasterCalculator("float(" + nirReflectance.ref + ")/float(" + redReflectance.ref + ")", pcdPath,"GTiff",nirLayer.extent(),nirLayer.width(),nirLayer.height(), entries) calc.processCalculation() print "PCD calculated"
def main(): # Read the options and arguments from the command line (w/ some default settings). options = Options() opts = options.parse(sys.argv[1:]) # Configure logging. FORMAT = '%(asctime)s - %(levelname)s - %(message)s' logging.basicConfig(filename=opts.logfile, filemode="w", format=FORMAT, level=logging.DEBUG) logging.getLogger().addHandler(logging.StreamHandler()) # Init QGIS app = QApplication(sys.argv) QgsApplication.setPrefixPath("/usr/local/qgis_master", True) QgsApplication.initQgis() #Load CIR orthofoto fileName = "/home/stefan/Downloads/1091-231.tif" fileInfo = QFileInfo(fileName) baseName = fileInfo.baseName() rlayer = QgsRasterLayer(fileName, baseName) if not rlayer.isValid(): print "Layer failed to load!" print "************" print rlayer.width() print rlayer.bandCount() #print rlayer.metadata() #print rlayer.rasterType() #print rlayer.dataProvider().colorTable(1) print "************" # Define an alias for each band in form of a QgsRasterCalculatorEntry. entries = [] band1 = QgsRasterCalculatorEntry() band1.ref = 'cir@1' band1.raster = rlayer band1.bandNumber = 1 entries.append(band1) band2 = QgsRasterCalculatorEntry() band2.ref = 'cir@2' band2.raster = rlayer band2.bandNumber = 2 entries.append(band2) # Process calculation with input extent and resolution calc = QgsRasterCalculator('(cir@1 - cir@2) / (cir@1 + cir@2)', '/home/stefan/Downloads/1091-231_ndvi.tif', 'GTiff', rlayer.extent(), rlayer.width(), rlayer.height(), entries) calc.processCalculation()
def run(self): """Run method that performs all the real work""" # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False self.dlg = NDVIDialog() self.dlg.pushButton.clicked.connect(self.select_output_file) # Fetch the currently loaded layers layers = QgsProject.instance().layerTreeRoot().children() # Clear the contents of the comboBox from previous runs self.dlg.comboBox.clear() # Populate the comboBox with names of all the loaded layers self.dlg.comboBox.addItems([layer.name() for layer in layers]) self.dlg.comboBox_2.clear() # Populate the comboBox with names of all the loaded layers self.dlg.comboBox_2.addItems([layer.name() for layer in layers]) # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: # Do something useful here - delete the line containing pass and # substitute with your code. l7_b4 = self.dlg.comboBox.currentIndex() l7_b4 = layers[l7_b4].layer() l7_b3 = self.dlg.comboBox_2.currentIndex() l7_b3 = layers[l7_b3].layer() entries = [] output = self.dlg.lineEdit.text() raster4 = l7_b4 b4 = QgsRasterCalculatorEntry() b4.ref = "b4@1" b4.raster = raster4 b4.bandNumber = 1 raster3 = l7_b3 b3 = QgsRasterCalculatorEntry() b3.ref = "b3@1" b3.raster = raster3 b3.bandNumber = 1 entries.append(b4) entries.append(b3) calc = QgsRasterCalculator('("b4@1"-"b3@1")/("b4@1"+"b3@1")',output,"GTiff",\ raster4.extent(),raster4.width(),raster4.height(),entries) calc.processCalculation() self.iface.messageBar().pushMessage( "Success", "Output file written at " , level=Qgis.Success, duration=3)
def AjusteComETP (chuva, etp, output): entries = [] raster1 = QgsRasterCalculatorEntry() raster1.ref = 'chuva@1' raster1.raster = chuva raster1.bandNumber = 1 entries.append(raster1) raster2 = QgsRasterCalculatorEntry() raster2.ref = 'etp@1' raster2.raster = etp raster2.bandNumber = 1 entries.append(raster2) calc = QgsRasterCalculator ('(etp@1 > 0) * chuva@1', output, 'GTiff', chuva.extent(), chuva.width(), chuva.height(), entries) calc.processCalculation()
def raster_subtract(self): # if the layer does not exist it has to be created rlayer1 = QgsMapLayerRegistry.instance().mapLayersByName( self.cb_input1.currentText() )[0] rlayer2 = QgsMapLayerRegistry.instance().mapLayersByName( self.cb_input2.currentText() )[0] fileName = self.lineEdit.text() entries = [] # Define band1 boh1 = QgsRasterCalculatorEntry() boh1.ref = 'boh@1' boh1.raster = rlayer1 boh1.bandNumber = 1 entries.append( boh1 ) # Define band2 boh2 = QgsRasterCalculatorEntry() boh2.ref = 'boh@2' boh2.raster = rlayer2 boh2.bandNumber = 1 entries.append( boh2 ) # Process calculation with input extent and resolution calc = QgsRasterCalculator( 'boh@1 - boh@2', fileName, \ 'GTiff', rlayer1.extent(), \ rlayer1.width(), rlayer1.height(), entries ) calc.processCalculation() # Load the file into the map fileInfo = QFileInfo(fileName) baseName = fileInfo.baseName() root = QgsProject.instance().layerTreeRoot() node_group1 = root.insertGroup(0, "Group 1") node_subgroup1 = node_group1.addGroup("Sub-group 1") # Check out signals from nodes section # http://www.lutraconsulting.co.uk/blog/2014/07/25/qgis-layer-tree-api-part-2/ # if the layer does not exist it has to be created if not QgsMapLayerRegistry.instance().mapLayersByName(baseName): rOutput = QgsRasterLayer(fileName, baseName) QgsMapLayerRegistry.instance().addMapLayer(rOutput, False) setRamp(rOutput, self.iface) node_layer1 = node_subgroup1.addLayer(rOutput) # if the layer already exists trigger a refresh else: rOutput = QgsMapLayerRegistry.instance().mapLayersByName(baseName)[0] rOutput.triggerRepaint()
def sum_quantiles(self): tempdir = self.gettempdir() lst_quantile = self.quantile() # List layers for calculate. entries = [] for lyrPath in lst_quantile[0:1]: lyrName = os.path.basename(lyrPath) lyr1 = QgsRasterLayer(lyrPath, lyrName) # Get raster info. ras1 = QgsRasterCalculatorEntry() ras1.ref = lyrName + '@1' ras1.raster = lyr1 ras1.bandNumber = 1 entries.append(ras1) for lyrPath in lst_quantile[1:2]: lyrName = os.path.basename(lyrPath) lyr2 = QgsRasterLayer(lyrPath, lyrName) # Get raster info. ras2 = QgsRasterCalculatorEntry() ras2.ref = lyrName + '@1' ras2.raster = lyr2 ras2.bandNumber = 1 entries.append(ras2) for lyrPath in lst_quantile[2:3]: lyrName = os.path.basename(lyrPath) lyr3 = QgsRasterLayer(lyrPath, lyrName) # Get raster info. ras3 = QgsRasterCalculatorEntry() ras3.ref = lyrName + '@1' ras3.raster = lyr3 ras3.bandNumber = 1 entries.append(ras3) formula_sum = "((" + "\"" + ras1.ref + "\"" + '*' + '100' + ')' + ' + ' + '(' + "\"" + ras2.ref + "\"" + '*' + '10' + ")" + ' + ' + "(" + "\"" + ras3.ref + "\"" + '))' output = tempdir + "/VIF.tif" calc_sum = QgsRasterCalculator(formula_sum, output, 'GTiff', lyr1.extent(), lyr1.width(), lyr1.height(), entries) calc_sum.processCalculation() del entries return output
def capacity(self): lstStnd_Capa = self.lst_capa() tempdir = self.gettempdir() entries = [] try: for i in range(0, len(lstStnd_Capa)): raster = lstStnd_Capa[i] readRst = processing.getObject(raster) ras1 = QgsRasterCalculatorEntry() ras1.raster = readRst ras1.ref = "capa_lyr" + str(i + 1) + "@1" ras1.bandNumber = 1 entries.append(ras1) formula = '((' + entries[0].ref + ' * ' + entries[ 1].ref + ')^ 0.5)* 1000000' readRst = QgsRasterLayer(lstStnd_Capa[0]) output = tempdir + "/Capacity.tif" calc = QgsRasterCalculator(formula, output, 'GTiff', readRst.extent(), readRst.width(), readRst.height(), entries) calc.processCalculation() return output except: self.userWarning( "Error in Create Adaptive Capacity map", "Can not create Create Adaptive Capacity map, Exit")
def calc_10_toa(self, dir_output, dir_btir1, temp_folder, val_tir1_rmult, val_tir1_radd): self.dir_output = dir_output self.path = os.path.join(str(Path(dir_output).parent), 'temp_folder', '') self.temp_folder = temp_folder self.dir_btir1 = dir_btir1 self.dir_output_temp = self.path + '10 - TOA.tif' self.val_tir1_rmult = val_tir1_rmult self.val_tir1_radd = val_tir1_radd entries = [] band10 = QgsRasterLayer(self.dir_btir1) ras = QgsRasterCalculatorEntry() ras.ref = 'band10@1' ras.raster = band10 ras.bandNumber = 1 entries.append(ras) if self.temp_folder == 'yes': calc = QgsRasterCalculator( str(self.val_tir1_rmult) + '* "band10@1" +' + str(self.val_tir1_radd), self.dir_output_temp, 'GTiff', band10.extent(), band10.width(), band10.height(), entries) calc.processCalculation() elif self.temp_folder == 'no': calc = QgsRasterCalculator( str(self.val_tir1_rmult) + '* "band10@1" +' + str(self.val_tir1_radd), self.dir_output, 'GTiff', band10.extent(), band10.width(), band10.height(), entries) calc.processCalculation() iface.addRasterLayer(str(self.dir_output))
def calc_11_d(self, dir_output, dir_e_11, temp_folder, val_attransmit2): self.dir_output = dir_output self.path = os.path.join(str(Path(dir_output).parent), 'temp_folder', '') self.temp_folder = temp_folder self.dir_e_11 = dir_e_11 self.dir_output_temp = self.path + '11 - D.tif' self.val_attransmit2 = val_attransmit2 entries = [] e_11 = QgsRasterLayer(self.dir_e_11) ras = QgsRasterCalculatorEntry() ras.ref = '11 - e@1' ras.raster = e_11 ras.bandNumber = 1 entries.append(ras) if self.temp_folder == 'yes': calc = QgsRasterCalculator( '( 1 - ' + str(self.val_attransmit2) + ' )* ( 1 + ( 1 - "11 - e@1" ) * ' + str(self.val_attransmit2) + ')', self.dir_output_temp, 'GTiff', e_11.extent(), e_11.width(), e_11.height(), entries) calc.processCalculation() elif self.temp_folder == 'no': calc = QgsRasterCalculator( '( 1 - ' + str(self.val_attransmit2) + ' )* ( 1 + ( 1 - "11 - e@1" ) * ' + str(self.val_attransmit2) + ')', self.dir_output, 'GTiff', e_11.extent(), e_11.width(), e_11.height(), entries) calc.processCalculation() iface.addRasterLayer(str(self.dir_output))
def calc_11_toa_L7(self, dir_output, dir_btir2, temp_folder): self.temp_folder = temp_folder self.dir_output = dir_output self.dir_btir2 = dir_btir2 self.dir_output_temp = str( Path(dir_output).parent) + '\temp_folder\\11 - TOA.tif' entries = [] band11 = QgsRasterLayer(self.dir_btir2) ras = QgsRasterCalculatorEntry() ras.ref = 'band11@1' ras.raster = band11 ras.bandNumber = 1 entries.append(ras) if self.temp_folder == 'yes': calc = QgsRasterCalculator( '((17.04 - 0) / (255 - 1)) * ("band11@1" - 1) + 0', self.dir_output_temp, 'GTiff', band11.extent(), band11.width(), band11.height(), entries) calc.processCalculation() elif self.temp_folder == 'no': calc = QgsRasterCalculator( '((17.04 - 0) / (255 - 1)) * ("band11@1" - 1) + 0', self.dir_output, 'GTiff', band11.extent(), band11.width(), band11.height(), entries) calc.processCalculation() iface.addRasterLayer(str(self.dir_output))
def calc_10_cbesar(self, dir_output, dir_e_10, temp_folder, val_attransmit1): self.dir_output = dir_output self.path = os.path.join(str(Path(dir_output).parent), 'temp_folder', '') self.temp_folder = temp_folder self.dir_e_10 = dir_e_10 self.dir_output_temp = self.path + '10 - C besar.tif' self.val_attransmit1 = val_attransmit1 entries = [] e_10 = QgsRasterLayer(self.dir_e_10) ras = QgsRasterCalculatorEntry() ras.ref = '10 - e@1' ras.raster = e_10 ras.bandNumber = 1 entries.append(ras) if self.temp_folder == 'yes': calc = QgsRasterCalculator( '"10 - e@1" * ' + str(self.val_attransmit1), self.dir_output_temp, 'GTiff', e_10.extent(), e_10.width(), e_10.height(), entries) calc.processCalculation() elif self.temp_folder == 'no': calc = QgsRasterCalculator( '"10 - e@1" * ' + str(self.val_attransmit1), self.dir_output, 'GTiff', e_10.extent(), e_10.width(), e_10.height(), entries) calc.processCalculation() iface.addRasterLayer(str(self.dir_output))
def calc_10_bt_L7( self, dir_output, dir_toa_10, temp_folder, ): self.temp_folder = temp_folder dir_output = self.dlg.fw_output.filePath() dir_toa_10 = str( Path(dir_output).parent) + '\\temp_folder\\10 - TOA.tif' dir_output_temp = str( Path(dir_output).parent) + '\\temp_folder\\10 - BT.tif' entries = [] toa_10 = QgsRasterLayer(output_toa_10) ras = QgsRasterCalculatorEntry() ras.ref = '10 - TOA@1' ras.raster = toa_10 ras.bandNumber = 1 entries.append(ras) if self.temp_folder == 'yes': calc = QgsRasterCalculator( str(L_TIR1_K2_L7) + ' / ln ( ( ' + str(L_TIR1_K1_L7) + ' / "10 - TOA@1" ) + 1 )', output_bt_10, 'GTiff', toa_10.extent(), toa_10.width(), toa_10.height(), entries) calc.processCalculation() elif self.temp_folder == 'no': calc = QgsRasterCalculator( str(L_TIR1_K2_L7) + ' / ln ( ( ' + str(L_TIR1_K1_L7) + ' / "10 - TOA@1" ) + 1 )', output_bt_10, 'GTiff', toa_10.extent(), toa_10.width(), toa_10.height(), entries) calc.processCalculation() iface.addRasterLayer(str(self.dir_output))
def NDVI_calc(self , layers): entries = [] for l in layers: layer = QgsRasterCalculatorEntry() layer = QgsRasterCalculatorEntry() layer.ref = l.name() +'@1' layer.raster = l layer.bandNumber = 1 entries.append(layer) # Original path: C:/Users/fumibol/Documents/Wetlands/Python/QGIS arcPython/NDVI plugin/Output/NDVI.tif # for entry in entries: raster_salida = "" # First it was raster_salida = ruta + os.path.sep + raster_salida + '.tif' raster_salida = unicode(self.dlg.ui.ln_name_ndvi.text()) expression = '(' + entries[1].ref + ' + ' + entries[0].ref + ')/(' + entries[1].ref + ' - ' + entries[0].ref + '+ 1)' calc = QgsRasterCalculator(expression, raster_salida, 'GTiff', layers[0].extent(), layers[0].width(), layers[0].height(), entries) calc.processCalculation() # QgsMapLayerRegistry.instance().addMapLayer('C:/Users/fumibol/Documents/Wetlands/Python/QGIS arcPython/NDVI plugin/Output/NDVI.tif' , 'NDVI result') rl = self.iface.addRasterLayer(raster_salida , 'NDVI result') QMessageBox.information(self.iface.mainWindow(),"Success!" , "Raster image " + entries[0].ref + " created successfully ")
def lulc_rasters(self): tempdir = self.gettempdir() classes = self.lulc_classess() layerpath = self.lulc_study_area() fileInfo = QFileInfo(layerpath) baseName = fileInfo.baseName() lyr = QgsRasterLayer(layerpath, baseName) entries = [] ras = QgsRasterCalculatorEntry() ras.ref = baseName + '@1' ras.raster = lyr ras.bandNumber = 1 entries.append(ras) # List of output rasters for lulc types lulc_list = [] for i in classes: formula = "(" + "\"" + ras.ref + "\"" + ' = ' + str( i) + " ) " + " * " + str(i) output = tempdir + "/" + str(baseName) + "_%s.tif" % str(i) lulc_list.append(output) calc = QgsRasterCalculator(formula, output, 'GTiff', lyr.extent(), lyr.width(), lyr.height(), entries) calc.processCalculation() del entries return lulc_list
def sum_second_impact_pop(self): # Get temporary directory. tempdir = self.gettempdir() # Get layers already created in temporary directory. first_area_list, second_area_list, first_pop_list, second_pop_list = self.pre_siam( ) entries = [] for i in range(0, len(second_pop_list)): raster = second_pop_list[i] readRst = processing.getObject(str(raster)) ras1 = QgsRasterCalculatorEntry() ras1.raster = readRst ras1.ref = "second_impact_pop_" + str(i + 1) + "@1" ras1.bandNumber = 1 entries.append(ras1) reflist = " + ".join([ent.ref for ent in entries]) formula = '(' + reflist + ')' readRst = QgsRasterLayer(second_pop_list[0]) sum_second_impact_pop = tempdir + "/sum_second_impact_pop.tif" calc = QgsRasterCalculator(formula, sum_second_impact_pop, 'GTiff', readRst.extent(), readRst.width(), readRst.height(), entries) calc.processCalculation() return sum_second_impact_pop
def split_bands(pathIn,pathOut): # Recibe un path de entrada (raster multibanda) y devuelve las bandas por separado fileInfo=QFileInfo(pathIn) baseName=fileInfo.baseName() layer=QgsRasterLayer(pathIn, baseName) if not layer.isValid(): print "Error importing Micasense Mosaic to split" print "Splitting bands from " + baseName numBands=layer.bandCount() i=1 entries=[] output=[] while(i<=numBands): band = QgsRasterCalculatorEntry() band.ref = "band@"+str(i) band.raster=layer band.bandNumber=i entries.append(band) # Saves the current band as a separate file calc=QgsRasterCalculator(band.ref, pathOut+ "/" +baseName+"_band_"+str(i)+".tif","GTiff",layer.extent(),layer.width(),layer.height(), entries) calc.processCalculation() output.append(pathOut+"/"+baseName+"_band_"+str(i)+".tif") i=i+1 return output
def second_impact_rasters(self): tempdir = self.gettempdir() classes = self.second_impact_classes() layer = self.second_impact_layer() lyrPath = layer.source() lyrName = layer.name() lyr2 = QgsRasterLayer(lyrPath, lyrName) entries = [] ras1 = QgsRasterCalculatorEntry() ras1.ref = lyrName + '@1' ras1.raster = lyr2 ras1.bandNumber = 1 entries.append(ras1) # List of output rasters for lulc types second_list = [] for i in classes: formula = "(" + "\"" + ras1.ref + "\"" + ' = ' + str( i) + " ) " + " * " + str(i) output = tempdir + "/" + str(lyrName) + "_%s.tif" % str(i) second_list.append(output) calc = QgsRasterCalculator(formula, output, 'GTiff', lyr2.extent(), lyr2.width(), lyr2.height(), entries) calc.processCalculation() del entries return second_list
def NDVI(banda3, banda4, output): entries = [] raster1 = QgsRasterCalculatorEntry() raster1.ref = 'banda3@1' raster1.raster = banda3 raster1.bandNumber = 1 entries.append(raster1) raster2 = QgsRasterCalculatorEntry() raster2.ref = 'banda4@1' raster2.raster = banda4 raster2.bandNumber = 1 entries.append(raster2) calc = QgsRasterCalculator('(banda4@1 + banda3@1) / (banda4@1 - banda3@1)', output, 'GTiff', banda3.extent(), banda3.width(), banda3.height(), entries) calc.processCalculation()
def processAlgorithm(self, parameters, context, feedback): expression = self.getParameterValue(self.EXPRESSION) layersValue = self.getParameterValue(self.LAYERS) layersDict = {} if layersValue: layers = [QgsProcessingUtils.mapLayerFromString(f, context) for f in layersValue.split(";")] layersDict = {os.path.basename(lyr.source().split(".")[0]): lyr for lyr in layers} for lyr in QgsProcessingUtils.compatibleRasterLayers(context.project()): name = lyr.name() if (name + "@") in expression: layersDict[name] = lyr entries = [] for name, lyr in layersDict.items(): for n in range(lyr.bandCount()): entry = QgsRasterCalculatorEntry() entry.ref = '{:s}@{:d}'.format(name, n + 1) entry.raster = lyr entry.bandNumber = n + 1 entries.append(entry) output = self.getOutputValue(self.OUTPUT) extentValue = self.getParameterValue(self.EXTENT) if not extentValue: extentValue = QgsProcessingUtils.combineLayerExtents(layersValue) if extentValue: extent = extentValue.split(',') bbox = QgsRectangle(float(extent[0]), float(extent[2]), float(extent[1]), float(extent[3])) else: if layersDict: bbox = list(layersDict.values())[0].extent() for lyr in layersDict.values(): bbox.combineExtentWith(lyr.extent()) else: raise GeoAlgorithmExecutionException(self.tr("No layers selected")) def _cellsize(layer): return (layer.extent().xMaximum() - layer.extent().xMinimum()) / layer.width() cellsize = self.getParameterValue(self.CELLSIZE) or min([_cellsize(lyr) for lyr in layersDict.values()]) width = math.floor((bbox.xMaximum() - bbox.xMinimum()) / cellsize) height = math.floor((bbox.yMaximum() - bbox.yMinimum()) / cellsize) driverName = GdalUtils.getFormatShortNameFromFilename(output) calc = QgsRasterCalculator(expression, output, driverName, bbox, width, height, entries) res = calc.processCalculation() if res == QgsRasterCalculator.ParserError: raise GeoAlgorithmExecutionException(self.tr("Error parsing formula"))
def processAlgorithm(self, parameters, context, feedback): expression = self.parameterAsString(parameters, self.EXPRESSION, context) layers = self.parameterAsLayerList(parameters, self.LAYERS, context) layersDict = {} if layers: layersDict = {os.path.basename(lyr.source().split(".")[0]): lyr for lyr in layers} for lyr in QgsProcessingUtils.compatibleRasterLayers(context.project()): name = lyr.name() if (name + "@") in expression: layersDict[name] = lyr entries = [] for name, lyr in layersDict.items(): for n in range(lyr.bandCount()): entry = QgsRasterCalculatorEntry() entry.ref = '{:s}@{:d}'.format(name, n + 1) entry.raster = lyr entry.bandNumber = n + 1 entries.append(entry) output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) bbox = self.parameterAsExtent(parameters, self.EXTENT, context) if bbox.isNull(): bbox = QgsProcessingUtils.combineLayerExtents(layers) if bbox.isNull(): if layersDict: bbox = list(layersDict.values())[0].extent() for lyr in layersDict.values(): bbox.combineExtentWith(lyr.extent()) else: raise QgsProcessingException(self.tr("No layers selected")) def _cellsize(layer): return (layer.extent().xMaximum() - layer.extent().xMinimum()) / layer.width() cellsize = self.parameterAsDouble(parameters, self.CELLSIZE, context) or min([_cellsize(lyr) for lyr in layersDict.values()]) width = math.floor((bbox.xMaximum() - bbox.xMinimum()) / cellsize) height = math.floor((bbox.yMaximum() - bbox.yMinimum()) / cellsize) driverName = GdalUtils.getFormatShortNameFromFilename(output) calc = QgsRasterCalculator(expression, output, driverName, bbox, width, height, entries) res = calc.processCalculation() if res == QgsRasterCalculator.ParserError: raise QgsProcessingException(self.tr("Error parsing formula")) return {self.OUTPUT: output}
def reclassifyRaster(prjpath, inRasterName, bandnum, minValue, tupleUpValues, outRasterName): """ Reclassify a raster to groups defined by tupleUpValues.""" # Get raster inRaster=getRasterLayerByName(inRasterName) if not inRaster: message=inRasterName+ " not loaded or not a raster!" QMessageBox.critical(None,'Error',message, QMessageBox.Ok) return False # Check prjpath exists if not os.path.isdir(prjpath): message= prjpath + " does not exist!" QMessageBox.critical(None,'Error',message, QMessageBox.Ok) return False # Define band boh = QgsRasterCalculatorEntry() bandName=inRasterName+'@'+str(bandnum) boh.ref = bandName boh.raster = inRaster boh.bandNumber =bandnum # Prepare entries entries = [] entries.append( boh ) # Prepare calculation command bandNameAddStr= '<='+ bandName + ' AND ' + bandName + '<' i = 1 lowerVal=0 calcCommand="" for upValue in tupleUpValues: calcCommand = calcCommand + '( ' + str(minValue) + bandNameAddStr calcCommand = calcCommand + str(upValue) + ')' + '*' + str(i) if i!=len(tupleUpValues): calcCommand = calcCommand + ' + ' minValue = upValue i = i + 1 # Process calculation with input extent and resolution pathFilename=os.path.join( prjpath, outRasterName) + '.tif' calc = QgsRasterCalculator(calcCommand, pathFilename, 'GTiff', inRaster.extent(), inRaster.width(), inRaster.height(), entries ) if not calc: return False ok= (calc.processCalculation() == 0) return ok
def StringToRaster(raster,banda): fileInfo = QFileInfo(raster) path = fileInfo.filePath() baseName = fileInfo.baseName() global layerglobal layerglobal = QgsRasterLayer(path, baseName) QgsMapLayerRegistry.instance().addMapLayer(layerglobal) if layerglobal.isValid() is True: bandaref=str(banda)+'@1' # Define band1 banda = QgsRasterCalculatorEntry() banda.ref = bandaref banda.raster = layerglobal banda.bandNumber = 1 entries.append( banda ) else: print "Unable to read basename and file path - Your string is probably invalid" +str(baseName)
def adjustRasterToBaseRaster (baseRaster, adjustingRaster, outputPath): entries = [] rCalcObj = QgsRasterCalculatorEntry() rCalcObj.ref = 'rCalcObj@1' rCalcObj.raster = adjustingRaster rCalcObj.bandNumber = 1 entries.append(rCalcObj) #print '---' #print baseRaster.extent() #print baseRaster.width() #print baseRaster.height() #print '---' calc = QgsRasterCalculator('rCalcObj@1', outputPath, 'GTiff', baseRaster.extent(), baseRaster.width(), baseRaster.height(), entries) #print 'calc' calc.processCalculation()
def generateOneValueRasterQGisCalc (baseRaster, value, outputPath): """ Generates raster with extent and resolution of baseRaster, each pixel is value. QgsRasterCalculator used :param baseRaster: :param value: output value :param outputPath: path for output file """ entries = [] rCalcObj = QgsRasterCalculatorEntry() rCalcObj.ref = 'rCalcObj@1' rCalcObj.raster = baseRaster rCalcObj.bandNumber = 1 entries.append(rCalcObj) calc = QgsRasterCalculator(str(value), outputPath, 'GTiff', baseRaster.extent(), baseRaster.width(), baseRaster.height(), entries) calc.processCalculation()
def processAlgorithm(self, parameters, context, feedback): expression = self.parameterAsString(parameters, self.EXPRESSION, context) layers = self.parameterAsLayerList(parameters, self.LAYERS, context) layersDict = {} if layers: layersDict = {lyr.source(): lyr for lyr in layers} crs = self.parameterAsCrs(parameters, self.CRS, context) if crs is None or not crs.isValid(): if not layers: raise QgsProcessingException(self.tr("No reference layer selected nor CRS provided")) else: crs = list(layersDict.values())[0].crs() bbox = self.parameterAsExtent(parameters, self.EXTENT, context) if bbox.isNull() and not layers: raise QgsProcessingException(self.tr("No reference layer selected nor extent box provided")) if not bbox.isNull(): bboxCrs = self.parameterAsExtentCrs(parameters, self.EXTENT, context) if bboxCrs != crs: transform = QgsCoordinateTransform(bboxCrs, crs, context.project()) bbox = transform.transformBoundingBox(bbox) if bbox.isNull() and layers: bbox = QgsProcessingUtils.combineLayerExtents(layers, crs, context) cellsize = self.parameterAsDouble(parameters, self.CELLSIZE, context) if cellsize == 0 and not layers: raise QgsProcessingException(self.tr("No reference layer selected nor cellsize value provided")) def _cellsize(layer): ext = layer.extent() if layer.crs() != crs: transform = QgsCoordinateTransform(layer.crs(), crs, context.project()) ext = transform.transformBoundingBox(ext) return (ext.xMaximum() - ext.xMinimum()) / layer.width() if cellsize == 0: cellsize = min([_cellsize(lyr) for lyr in layersDict.values()]) # check for layers available in the model layersDictCopy = layersDict.copy() # need a shallow copy because next calls invalidate iterator for lyr in layersDictCopy.values(): expression = self.mappedNameToLayer(lyr, expression, layersDict, context) # check for layers available in the project for lyr in QgsProcessingUtils.compatibleRasterLayers(context.project()): expression = self.mappedNameToLayer(lyr, expression, layersDict, context) # create the list of layers to be passed as inputs to RasterCalculaltor # at this phase expression has been modified to match available layers # in the current scope entries = [] for name, lyr in layersDict.items(): for n in range(lyr.bandCount()): ref = '{:s}@{:d}'.format(name, n + 1) if ref in expression: entry = QgsRasterCalculatorEntry() entry.ref = ref entry.raster = lyr entry.bandNumber = n + 1 entries.append(entry) # Append any missing entry from the current project for entry in QgsRasterCalculatorEntry.rasterEntries(): if not [e for e in entries if e.ref == entry.ref]: entries.append(entry) output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) width = round((bbox.xMaximum() - bbox.xMinimum()) / cellsize) height = round((bbox.yMaximum() - bbox.yMinimum()) / cellsize) driverName = GdalUtils.getFormatShortNameFromFilename(output) calc = QgsRasterCalculator(expression, output, driverName, bbox, crs, width, height, entries, context.transformContext()) res = calc.processCalculation(feedback) if res == QgsRasterCalculator.ParserError: raise QgsProcessingException(self.tr("Error parsing formula")) return {self.OUTPUT: output}
def processAlgorithm(self, parameters, context, feedback): expression = self.parameterAsString(parameters, self.EXPRESSION, context) layers = self.parameterAsLayerList(parameters, self.LAYERS, context) layersDict = {} if layers: layersDict = {os.path.basename(lyr.source().split(".")[0]): lyr for lyr in layers} crs = self.parameterAsCrs(parameters, self.CRS, context) if not layers and not crs.isValid(): raise QgsProcessingException(self.tr("No reference layer selected nor CRS provided")) if not crs.isValid() and layers: crs = list(layersDict.values())[0].crs() bbox = self.parameterAsExtent(parameters, self.EXTENT, context) if not layers and bbox.isNull(): raise QgsProcessingException(self.tr("No reference layer selected nor extent box provided")) if not bbox.isNull(): bboxCrs = self.parameterAsExtentCrs(parameters, self.EXTENT, context) if bboxCrs != crs: transform = QgsCoordinateTransform(bboxCrs, crs, context.project()) bbox = transform.transformBoundingBox(bbox) if bbox.isNull() and layers: bbox = QgsProcessingUtils.combineLayerExtents(layers, crs) cellsize = self.parameterAsDouble(parameters, self.CELLSIZE, context) if not layers and cellsize == 0: raise QgsProcessingException(self.tr("No reference layer selected nor cellsize value provided")) def _cellsize(layer): ext = layer.extent() if layer.crs() != crs: transform = QgsCoordinateTransform(layer.crs(), crs, context.project()) ext = transform.transformBoundingBox(ext) return (ext.xMaximum() - ext.xMinimum()) / layer.width() if cellsize == 0: cellsize = min([_cellsize(lyr) for lyr in layersDict.values()]) for lyr in QgsProcessingUtils.compatibleRasterLayers(context.project()): name = lyr.name() if (name + "@") in expression: layersDict[name] = lyr entries = [] for name, lyr in layersDict.items(): for n in range(lyr.bandCount()): ref = '{:s}@{:d}'.format(name, n + 1) if ref in expression: entry = QgsRasterCalculatorEntry() entry.ref = ref entry.raster = lyr entry.bandNumber = n + 1 entries.append(entry) output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) width = math.floor((bbox.xMaximum() - bbox.xMinimum()) / cellsize) height = math.floor((bbox.yMaximum() - bbox.yMinimum()) / cellsize) driverName = GdalUtils.getFormatShortNameFromFilename(output) calc = QgsRasterCalculator(expression, output, driverName, bbox, crs, width, height, entries) res = calc.processCalculation(feedback) if res == QgsRasterCalculator.ParserError: raise QgsProcessingException(self.tr("Error parsing formula")) return {self.OUTPUT: output}
##reflectance_mult=number 0 ##reflectance_add=number 0 ##sun_elevation=number 0 ##inImage=raster ##outImage=output raster from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry lyr = processing.getObject(inImage) entries=[] rasterCalcEntry=QgsRasterCalculatorEntry() rasterCalcEntry.ref='IMG@1' rasterCalcEntry.raster=lyr rasterCalcEntry.bandNumber=1 entries.append(rasterCalcEntry) if not ".tif" in outImage: outImage=outImage+".tif" noData=-3.4028234663852886e+38 radElev = sun_elevation*3.14159/180 calc=QgsRasterCalculator('(IMG@1 != 0)*('+str(reflectance_mult)+' * IMG@1 + '+str(reflectance_add)+')/sin('+str(radElev)+') + (IMG@1 = 0) * '+str(noData), outImage, "GTiff", lyr.extent(), lyr.crs(), lyr.width(), lyr.height(), entries) calc.processCalculation()
def StringToRaster(raster): # Check if string is provided fileInfo = QFileInfo(raster) path = fileInfo.filePath() baseName = fileInfo.baseName() layer = QgsRasterLayer(path, baseName) #QgsMapLayerRegistry.instance().addMapLayer(layer) entries = [] # Define band1 boh1 = QgsRasterCalculatorEntry() boh1.ref = 'ndvi20160607sentinel@5' boh1.raster = layer boh1.bandNumber = 5 entries.append( boh1 ) # Process calculation with input extent and resolution calc = QgsRasterCalculator( '(ndvi20160607sentinel@5) * 166.67 + 111.67', 'C:/Hackathon Farmhack data/Output/outputfile.tif', 'GTiff', layer.extent(), layer.width(), layer.height(), entries ) calc.processCalculation() fileInfo = QFileInfo('C:/Hackathon Farmhack data/Output/outputfile.tif') path = fileInfo.filePath() baseName = fileInfo.baseName() layer = QgsRasterLayer(path, baseName) #QgsMapLayerRegistry.instance().addMapLayer(layer) if layer.isValid() is True: print "Layer was loaded successfully!" else: print "Unable to read basename and file path - Your string is probably invalid" shape = QgsVectorLayer('C:/Hackathon Farmhack data/perceel-hier-rdnew.geojson', 'perceel', 'ogr') #QgsMapLayerRegistry.instance().addMapLayer(shape) xmin = (shape.extent().xMinimum()) #extract the minimum x coord from our layer xmax = (shape.extent().xMaximum()) #extract our maximum x coord from our layer ymin = (shape.extent().yMinimum()) #extract our minimum y coord from our layer ymax = (shape.extent().yMaximum()) #extract our maximum y coord from our layer #prepare the extent in a format the VectorGrid tool can interpret (xmin,xmax,ymin,ymax) extent = str(xmin)+ ',' + str(xmax)+ ',' +str(ymin)+ ',' +str(ymax) # raster the given shape processing.runalg('qgis:vectorgrid', extent, 20, 20, 0, 'C:/Hackathon Farmhack data/Output/rasterShapes.geojson') shapeRaster = QgsVectorLayer('C:/Hackathon Farmhack data/Output/rasterShapes.geojson', 'perceelRaster', 'ogr') shapeRaster.setCrs(QgsCoordinateReferenceSystem(28992, QgsCoordinateReferenceSystem.EpsgCrsId)) #QgsMapLayerRegistry.instance().addMapLayer(shapeRaster) #clip the raster returned processing.runalg('qgis:clip', shapeRaster, shape, 'C:/Hackathon Farmhack data/Output/clippedRaster.shp') #define oldPath and newPath ogr2ogr.main(["","-f", "ESRI Shapefile", "-s_srs", "epsg:28992", "-t_srs", "epsg:32632", "C:/Hackathon Farmhack data/Output/clippedRasterNew.shp", "C:/Hackathon Farmhack data/Output/clippedRaster.shp"]) clippedRaster = QgsVectorLayer('C:/Hackathon Farmhack data/Output/clippedRasterNew.shp', 'clippedRaster', 'ogr') clippedRaster.setCrs(QgsCoordinateReferenceSystem(32632, QgsCoordinateReferenceSystem.EpsgCrsId)) #QgsMapLayerRegistry.instance().addMapLayer(clippedRaster) #zonalstatistics processing.runalg('qgis:zonalstatistics', layer, 1, clippedRaster, '', False, 'C:/Hackathon Farmhack data/Output/filledRaster.geojson') filledRaster = QgsVectorLayer('C:/Hackathon Farmhack data/Output/filledRaster.geojson', 'filledRaster', 'ogr') filledRaster.setCrs(QgsCoordinateReferenceSystem(32632, QgsCoordinateReferenceSystem.EpsgCrsId)) #QgsMapLayerRegistry.instance().addMapLayer(filledRaster) ogr2ogr.main(["","-f", "GeoJSON", "-s_srs", "epsg:32632", "-t_srs", "epsg:4326", "C:/Hackathon Farmhack data/Output/taakkaart.geojson", "C:/Hackathon Farmhack data/Output/filledRaster.geojson"]) taakkaart = QgsVectorLayer('C:/Hackathon Farmhack data/Output/taakkaart.geojson', 'taakkaart', 'ogr') QgsMapLayerRegistry.instance().addMapLayer(taakkaart)