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 Calibracao (imagem, output):
entries = []
raster1 = QgsRasterCalculatorEntry()
raster1.ref = 'imagem@1'
raster1.raster = imagem
raster1.bandNumber = 1
entries.append (raster1)
calc =QgsRasterCalculator ('0.9614*imagem@1 - 65.706', output, 'GTiff', imagem.extent(), imagem.width(), imagem.height(), entries)
calc.processCalculation()
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 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 Evapo (imagem, output):
entries = []
raster1 = QgsRasterCalculatorEntry()
raster1.ref = 'imagem@1'
raster1.raster = imagem
raster1.bandNumber = 1
entries.append (raster1)
calc =QgsRasterCalculator ('imagem@1 * 0.1', output, 'GTiff', imagem.extent(), imagem.width(), imagem.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 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 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 processAlgorithm(self, parameters, context, model_feedback):
# Use a multi-step feedback, so that individual child algorithm progress reports are adjusted for the
# overall progress through the model
sample_raster = self.parameterAsRasterLayer(parameters, 'SAMPLE',
context)
layers = self.parameterAsLayerList(parameters, 'LAYERS', context)
letter_order = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
raster_entries = []
for idx, raster_layer in enumerate(layers):
for band in range(1, raster_layer.bandCount() + 1):
raster_entry = QgsRasterCalculatorEntry()
raster_entry.raster = raster_layer
raster_entry.bandNumber = band
raster_entry.ref = "{}@{}".format(letter_order[idx], band)
print(raster_entry.ref)
raster_entries.append(raster_entry)
#output_raster_path = os.path.join(tempfile.mkdtemp(),"OUTPUT.tif")
#output_raster_path = parameters['OUTPUT']
output_raster_path = self.parameterAsOutputLayer(
parameters, 'OUTPUT', context)
tc = QgsCoordinateTransformContext(
QgsProject.instance().transformContext())
print('extent', sample_raster.extent())
print('widht', sample_raster.width())
print('height', sample_raster.height())
print(type(sample_raster.extent()))
calc = QgsRasterCalculator(parameters['FORMULA'], output_raster_path,
'GTiff', sample_raster.extent(),
sample_raster.width(),
sample_raster.height(), raster_entries, tc)
print("COPERNICUSRASTERCALC",
parameters['FORMULA'], output_raster_path, 'GTiff',
sample_raster.extent(), sample_raster.width(),
sample_raster.height(), raster_entries, tc)
#return results
if calc.processCalculation() == 0:
rasterCalcError = "No error"
results = {'ERROR': '', 'OUTPUT': output_raster_path}
else:
rasterCalcError = calc.lastError()
results = {'OUTPUT': '', 'ERROR': rasterCalcError}
return results
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 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.
rasterInput = self.parameterAsRasterLayer(
parameters,
self.INPUT,
context
)
outputFile = self.parameterAsOutputLayer(
parameters,
self.OUTPUT,
context
)
feedback.pushInfo('Output File: ' + outputFile)
rExtent = rasterInput.extent()
provider = rasterInput.dataProvider()
stats = provider.bandStatistics(1, QgsRasterBandStats.All, rExtent, 0)
minVal = stats.minimumValue
maxVal = stats.maximumValue
rCalcEntry = QgsRasterCalculatorEntry()
rCalcEntry.ref = 'r1@1'
rCalcEntry.raster = rasterInput
SMethod = self.parameterAsEnum(parameters, self.CHOICE_METHOD, context)
if SMethod == 0:
formula = '((r1@1 - %s) / (%s - %s))' % (minVal, maxVal, minVal)
elif SMethod == 1:
formula = '((%s - r1@1 ) / (%s - %s))' % (maxVal, maxVal, minVal)
feedback.pushInfo('Formula: ' + str(formula))
calc = QgsRasterCalculator(formula, outputFile, 'GTiff', rExtent, rasterInput.width(), rasterInput.height(), [rCalcEntry])
feedback.pushInfo("p calc1")
calc.processCalculation()
feedback.pushInfo("p calc1")
return {self.OUTPUT: outputFile}
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 executeCalculations(self):
for root, dirs, files in os.walk(self.rootDir):
for dir in dirs:
newDir = self.rootDir + '/' + dir
print("------------------------------")
print("SCANNING DIRECTORY: " + newDir)
#Variables needed for raster calculation
rasIndex = 1
ras = []
entries = []
rlayers = []
for subRoot, subDirs, subFiles in os.walk(newDir):
#print("Subfiles of directory: " + str(subFiles))
for fileName in subFiles:
if (fileName.endswith(".tif")
and fileName[len(fileName) - 5] != "A"
and fileName[len(fileName) - 7] != "B"):
print("Evaluating SRB TIF file of band " +
fileName[len(fileName) - 5] + ": " +
fileName)
#Figure out properties of file
tifFile = newDir + '/' + fileName # + ".tif"
bandNumber = fileName[len(fileName) - 5]
#Create a raster layer
rlayer = QgsRasterLayer(tifFile,
"Band" + bandNumber)
if not rlayer.isValid():
print("Layer failed to load!")
continue
rlayers.append(rlayer)
#Create a raster calculator entry
ref = 'lyr@' + str(rasIndex)
ras = QgsRasterCalculatorEntry()
ras.ref = ref
ras.raster = rlayer
ras.bandNumber = 1
entries.append(ras)
rasIndex += 1
if (len(rlayers) > 0 and len(entries) > 0):
#Obtain desired output path
outDir = self.obtainOutDir(dir)
#Calculate average for this directory
self.calculateAvgAndOutput(rlayers, entries, outDir)
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 calc_11_e(self, dir_output, dir_pv, dir_c_kecil_11, temp_folder,
val_tir2emissivitys, val_tir2emissivityv):
self.dir_output = dir_output
self.path = os.path.join(str(Path(dir_output).parent), 'temp_folder',
'')
self.temp_folder = temp_folder
self.dir_pv = dir_pv
self.dir_c_kecil_11 = dir_c_kecil_11
self.dir_output_temp = self.path + '11 - e.tif'
self.val_tir2emissivitys = val_tir2emissivitys
self.val_tir2emissivityv = val_tir2emissivityv
entries = []
pv = QgsRasterLayer(self.dir_pv)
ras = QgsRasterCalculatorEntry()
ras.ref = 'Pv@1'
ras.raster = pv
ras.bandNumber = 1
entries.append(ras)
c_kecil_11 = QgsRasterLayer(self.dir_c_kecil_11)
ras = QgsRasterCalculatorEntry()
ras.ref = '11 - c kecil@1'
ras.raster = c_kecil_11
ras.bandNumber = 1
entries.append(ras)
if self.temp_folder == 'yes':
calc = QgsRasterCalculator(
str(self.val_tir2emissivityv) + ' * "Pv@1" + ' +
str(self.val_tir2emissivitys) +
' * ( 1 - "Pv@1" ) + "11 - c kecil@1"', self.dir_output_temp,
'GTiff', c_kecil_11.extent(), c_kecil_11.width(),
c_kecil_11.height(), entries)
calc.processCalculation()
elif self.temp_folder == 'no':
calc = QgsRasterCalculator(
str(self.val_tir2emissivityv) + ' * "Pv@1" + ' +
str(self.val_tir2emissivitys) +
' * ( 1 - "Pv@1" ) + "11 - c kecil@1"', self.dir_output,
'GTiff', c_kecil_11.extent(), c_kecil_11.width(),
c_kecil_11.height(), entries)
calc.processCalculation()
iface.addRasterLayer(str(self.dir_output))
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 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 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 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 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 qgs_map_calculator(self, rasterLayer, temp_path, red, green, blue):
entries = []
# Define 3 bands
rasterFilterQgs = '( temp@1 = ' + str(red) + 'AND temp@2 = ' + str(
green) + 'AND temp@3 = ' + str(blue) + ') * 1'
for i in range(3):
ent = QgsRasterCalculatorEntry()
ent.ref = 'temp@' + str(i + 1)
ent.raster = rasterLayer
ent.bandNumber = i + 1
entries.append(ent)
file = temp_path + '/temp_qgs.tif'
calc = QgsRasterCalculator(rasterFilterQgs, file, 'GTiff',
rasterLayer.extent(), rasterLayer.width(),
rasterLayer.height(), entries)
calc.processCalculation()
return file
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 processSlopeHighpassAlgorithm(self, INPUT_CUTOFF, INPUT_SLOPE,
INPUT_EXTENT, OUTPUT_FILE, feedback):
if (os.path.isfile(OUTPUT_FILE)):
return 0
ras = QgsRasterCalculatorEntry()
ras.ref = 'slope@1'
ras.raster = INPUT_SLOPE
ras.bandNumber = 1
entries = [ras]
calc = QgsRasterCalculator('slope@1 >= {}'.format(INPUT_CUTOFF),
OUTPUT_FILE, 'GTiff', INPUT_EXTENT,
ras.raster.width(), ras.raster.height(),
entries)
return 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 calc_a0(self, dir_output, dir_E1, dir_E2, temp_folder, A10, A11):
self.dir_output = dir_output
self.path = os.path.join(str(Path(dir_output).parent), 'temp_folder',
'')
self.temp_folder = temp_folder
self.dir_E1 = dir_E1
self.dir_E2 = dir_E2
self.dir_output_temp = self.path + 'A0.tif'
self.A10 = A10
self.A11 = A11
entries = []
E1 = QgsRasterLayer(self.dir_E1)
ras = QgsRasterCalculatorEntry()
ras.ref = 'E1@1'
ras.raster = E1
ras.bandNumber = 1
entries.append(ras)
E2 = QgsRasterLayer(self.dir_E2)
ras = QgsRasterCalculatorEntry()
ras.ref = 'E2@1'
ras.raster = E2
ras.bandNumber = 1
entries.append(ras)
if self.temp_folder == 'yes':
calc = QgsRasterCalculator(
'"E1@1" * ' + self.A10 + ' + "E2@1" * ' + self.A11,
self.dir_output_temp, 'GTiff', E2.extent(), E2.width(),
E2.height(), entries)
calc.processCalculation()
elif self.temp_folder == 'no':
calc = QgsRasterCalculator(
'"E1@1" * ' + self.A10 + ' + "E2@1" * ' + self.A11,
self.dir_output, 'GTiff', E2.extent(), E2.width(), E2.height(),
entries)
calc.processCalculation()
iface.addRasterLayer(str(self.dir_output))
def raster_calculator_from_config(qgs_raster_layers, expression_alias, expression_template, qgs_raster_base_layer, output_raster, band=1):
"""
Apply raster calculator using layers name.
:param qgs_raster_layers: A list with QgsRasterLayer.
:param expression_alias: A list with expression alias. Example: ['v', 's', 'a', 'r', 'e'].
:param expression_template: A string with expression template. Example: '1 + (100 * "{v}") + (30 * "{s}")+ (10 * "{a}") + (5 * "{r}") + (2 * "{e}")'.
:param qgs_raster_base_layer: A QgsRasterLayer to extract geotransform.
:param output_raster: A string with output raster path.
:param band: A int with band number to perform raster calculator.
:return: A string with status message.
"""
if len(qgs_raster_layers) != len(expression_alias):
raise ValueError(u'Layers count({}) differ from expression alias ({})'.format(len(qgs_raster_layers), len(expression_alias)))
entries = []
alias = {}
elements_idx = 0
if not qgs_raster_base_layer or not qgs_raster_base_layer.isValid():
raise ValueError(u'Base layer "{}" does not exist or is not valid'.format(qgs_raster_base_layer))
for layer in qgs_raster_layers:
layer_name = layer.name()
if not layer.isValid():
result = 6
msg = u'Layer "{}" not valid.'.format(layer_name)
return result, msg
else:
ref = layer_name + unicode('@' + str(band))
entry = QgsRasterCalculatorEntry()
entry.ref = ref
entry.raster = layer
entry.bandNumber = band
entries.append(entry)
alias[expression_alias[elements_idx]] = ref
elements_idx += 1
expression = expression_template.format(**alias)
__logger.info(u'Running raster calculator with expression: {}...'.format(expression))
return raster_calculator(entries, qgs_raster_base_layer, output_raster, expression)
def NDWI(band3, band8, output):
entries = []
#define raster 1 (band8)
raster1 = QgsRasterCalculatorEntry()
raster1.ref = 'band8@1'
raster1.raster = band8
raster1.bandNumber = 1
entries.append(raster1)
#define raster 2 (band3)
raster2 = QgsRasterCalculatorEntry()
raster2.ref = 'band3@1'
raster2.raster = band3
raster2.bandNumber = 1
entries.append(raster2)
#NDWI Procesado de las bandas
# calc=QgsRasterCalculator('("band3@1"-"band8@1")/("band3@1"+"band8@1")',output,'GTiff',band8.extent(),band8.width(),band8.height(),entries)
calc = QgsRasterCalculator(
'(("band3@1"-"band8@1")/("band3@1"+"band8@1"))*100', output, 'GTiff',
band8.extent(), band8.width(), band8.height(), entries)
calc.processCalculation()
def calc_11_ckecil(self, dir_output, dir_pv, temp_folder,
val_tir2emissivitys, val_tir2emissivityv,
val_geometrical):
self.dir_output = dir_output
self.path = os.path.join(str(Path(dir_output).parent), 'temp_folder',
'')
self.temp_folder = temp_folder
self.dir_pv = dir_pv
self.dir_output_temp = self.path + '11 - c kecil.tif'
self.val_tir2emissivitys = val_tir2emissivitys
self.val_tir2emissivityv = val_tir2emissivityv
self.val_geometrical = val_geometrical
entries = []
pv = QgsRasterLayer(self.dir_pv)
ras = QgsRasterCalculatorEntry()
ras.ref = 'Pv@1'
ras.raster = pv
ras.bandNumber = 1
entries.append(ras)
if self.temp_folder == 'yes':
calc = QgsRasterCalculator(
'( 1 - ' + str(self.val_tir2emissivitys) + ' ) * ' +
str(self.val_tir2emissivityv) + ' * ' +
str(self.val_geometrical) + ' * ( 1 - "Pv@1" )',
self.dir_output_temp, 'GTiff', pv.extent(), pv.width(),
pv.height(), entries)
calc.processCalculation()
elif self.temp_folder == 'no':
calc = QgsRasterCalculator(
'( 1 - ' + str(self.val_tir2emissivitys) + ' ) * ' +
str(self.val_tir2emissivityv) + ' * ' +
str(self.val_geometrical) + ' * ( 1 - "Pv@1" )',
self.dir_output, 'GTiff', pv.extent(), pv.width(), pv.height(),
entries)
calc.processCalculation()
iface.addRasterLayer(str(self.dir_output))
def calc_ipvi(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}/({0} + {1})'.format(ir.ref, r.ref)
calc = QgsRasterCalculator(expression, self.output, "GTiff",
self.red.extent(), self.red.width(),
self.red.height(), entries)
calc.processCalculation()
def processWithRasterCalculator(self, parameters, context, feedback): #pylint: disable=unused-argument,missing-docstring
raster1 = self.parameterAsRasterLayer(parameters, self.RASTER1,
context)
band1 = self.parameterAsInt(parameters, self.BAND1, context)
raster2 = self.parameterAsRasterLayer(parameters, self.RASTER2,
context)
band2 = self.parameterAsInt(parameters, self.BAND2, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
bbox = raster1.extent()
# cellsize = (bbox.xMaximum() - bbox.xMinimum()) / raster1.width()
# width = round((bbox.xMaximum() - bbox.xMinimum()) / cellsize)
# height = round((bbox.yMaximum() - bbox.yMinimum()) / cellsize)
width = raster1.width()
height = raster1.height()
driver = GdalUtils.getFormatShortNameFromFilename(output)
crs = raster1.crs()
entry1 = QgsRasterCalculatorEntry()
entry1.ref = 'A@%d' % band1
entry1.raster = raster1
entry1.bandNumber = 1
entry2 = QgsRasterCalculatorEntry()
entry2.ref = 'B@%d' % band2
entry2.raster = raster2
entry2.bandNumber = 1
entries = [entry1, entry2]
expression = "A@%d - B@%d" % (band1, band2)
calc = QgsRasterCalculator(expression, output, driver, bbox, crs,
width, height, entries)
res = calc.processCalculation(feedback)
if res == QgsRasterCalculator.ParserError:
raise QgsProcessingException(self.tr("Error parsing formula"))
return {self.OUTPUT: output}
def multiply_pop_second_impacts(self):
tempdir = self.gettempdir()
second_list = self.second_impact_rasters()
pop_boundary_fullpath = self.pop_boundary()
# Get Population area layer info.
fileInfo = QFileInfo(pop_boundary_fullpath)
poplyrName = fileInfo.baseName()
poplyr = QgsRasterLayer(pop_boundary_fullpath, poplyrName)
# poplyrName = pop_layer.name()
popras = QgsRasterCalculatorEntry()
popras.ref = poplyrName + '@1'
popras.raster = poplyr
popras.bandNumber = 1
second_pop_list = []
# multiply lulc classes with first impact class layers.
for fullpathlayer1 in second_list:
fileInfo1 = QFileInfo(fullpathlayer1)
baseName1 = fileInfo1.baseName()
firstlyr = processing.getObject(str(fullpathlayer1))
ras1 = QgsRasterCalculatorEntry()
ras1.ref = baseName1 + '@1'
ras1.raster = firstlyr
ras1.bandNumber = 1
entries1 = []
entries1.append(popras)
entries1.append(ras1)
formula1 = "\"" + ras1.ref + "\"" + ' * ' + "\"" + popras.ref + "\""
output1 = tempdir + "/%s_%s.tif" % (str(baseName1),
str(poplyrName))
second_pop_list.append(output1)
calc1 = QgsRasterCalculator(formula1, output1, 'GTiff',
firstlyr.extent(), firstlyr.width(),
firstlyr.height(), entries1)
calc1.processCalculation()
del entries1
return second_pop_list
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 calc_pv(self, dir_output, dir_ndvi, temp_folder, val_ndvis, val_ndviv):
self.dir_output = dir_output
self.path = os.path.join(str(Path(dir_output).parent), 'temp_folder',
'')
self.temp_folder = temp_folder
self.dir_ndvi = dir_ndvi
self.dir_output_temp = self.path + 'Pv.tif'
self.val_ndvis = val_ndvis
self.val_ndviv = val_ndviv
entries = []
ndvi = QgsRasterLayer(self.dir_ndvi)
ras = QgsRasterCalculatorEntry()
ras.ref = 'ndvi@1'
ras.raster = ndvi
ras.bandNumber = 1
entries.append(ras)
if self.temp_folder == 'yes':
calc = QgsRasterCalculator(
'( ( "ndvi@1" - ' + str(self.val_ndvis) + ' ) / ( ' +
str(self.val_ndviv) + ' - ' + str(self.val_ndvis) +
' ) ) * ( ( "ndvi@1" - ' + str(self.val_ndvis) + ' ) / ( ' +
str(self.val_ndviv) + ' - ' + str(self.val_ndvis) + ' ) )',
self.dir_output_temp, 'GTiff', ndvi.extent(), ndvi.width(),
ndvi.height(), entries)
calc.processCalculation()
elif self.temp_folder == 'no':
calc = QgsRasterCalculator(
'( ( "ndvi@1" - ' + str(self.val_ndvis) + ' ) / ( ' +
str(self.val_ndviv) + ' - ' + str(self.val_ndvis) +
' ) ) * ( ( "ndvi@1" - ' + str(self.val_ndvis) + ' ) / ( ' +
str(self.val_ndviv) + ' - ' + str(self.val_ndvis) + ' ) )',
self.dir_output, 'GTiff', ndvi.extent(), ndvi.width(),
ndvi.height(), entries)
calc.processCalculation()
iface.addRasterLayer(str(self.dir_output))
def calc_a2(self, dir_output, dir_A, dir_E2, temp_folder, B11):
self.dir_output = dir_output
self.path = os.path.join(str(Path(dir_output).parent), 'temp_folder',
'')
self.temp_folder = temp_folder
self.dir_A = dir_A
self.dir_E2 = dir_E2
self.dir_output_temp = self.path + 'A2.tif'
self.B11 = B11
entries = []
A = QgsRasterLayer(self.dir_A)
ras = QgsRasterCalculatorEntry()
ras.ref = 'A@1'
ras.raster = A
ras.bandNumber = 1
entries.append(ras)
E2 = QgsRasterLayer(self.dir_E2)
ras = QgsRasterCalculatorEntry()
ras.ref = 'E2@1'
ras.raster = E2
ras.bandNumber = 1
entries.append(ras)
if self.temp_folder == 'yes':
calc = QgsRasterCalculator('"A@1" + "E2@1" * ' + self.B11 + ' ',
self.dir_output_temp, 'GTiff',
E2.extent(), E2.width(), E2.height(),
entries)
calc.processCalculation()
elif self.temp_folder == 'no':
calc = QgsRasterCalculator('"A@1" + "E2@1" * ' + self.B11 + ' ',
self.dir_output, 'GTiff', E2.extent(),
E2.width(), E2.height(), entries)
calc.processCalculation()
iface.addRasterLayer(str(self.dir_output))
def calc_a1(self, dir_output, dir_A, dir_E1, temp_folder, B10):
self.dir_output = dir_output
self.path = os.path.join(str(Path(dir_output).parent), 'temp_folder',
'')
self.temp_folder = temp_folder
self.dir_A = dir_A
self.dir_E1 = dir_E1
self.dir_output_temp = self.path + 'A1.tif'
self.B10 = B10
entries = []
A = QgsRasterLayer(self.dir_A)
ras = QgsRasterCalculatorEntry()
ras.ref = 'A@1'
ras.raster = A
ras.bandNumber = 1
entries.append(ras)
E1 = QgsRasterLayer(self.dir_E1)
ras = QgsRasterCalculatorEntry()
ras.ref = 'E1@1'
ras.raster = E1
ras.bandNumber = 1
entries.append(ras)
if self.temp_folder == 'yes':
calc = QgsRasterCalculator('1 + "A@1" + "E1@1" * ' + self.B10,
self.dir_output_temp, 'GTiff',
E1.extent(), E1.width(), E1.height(),
entries)
calc.processCalculation()
elif self.temp_folder == 'no':
calc = QgsRasterCalculator('1 + "A@1" + "E1@1" * ' + self.B10,
self.dir_output, 'GTiff', E1.extent(),
E1.width(), E1.height(), entries)
calc.processCalculation()
iface.addRasterLayer(str(self.dir_output))
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 setList(self, options):
self.options = options
self.listWidget.clear()
entries = QgsRasterCalculatorEntry.rasterEntries()
def _find_source(name):
for entry in entries:
if entry.ref == name:
return entry.raster.source()
return ''
for name in options.keys():
item = QListWidgetItem(name, self.listWidget)
tooltip = _find_source(name)
if tooltip:
item.setData(Qt.ToolTipRole, tooltip)
self.listWidget.addItem(item)
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)
##inImage_red=raster
##inImage_nir=raster
##outImage=output raster
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
lyr = processing.getObject(inImage_red)
entries=[]
rasterCalcEntry=QgsRasterCalculatorEntry()
rasterCalcEntry.ref='R@1'
rasterCalcEntry.raster=lyr
rasterCalcEntry.bandNumber=1
entries.append(rasterCalcEntry)
lyr = processing.getObject(inImage_nir)
rasterCalcEntry=QgsRasterCalculatorEntry()
rasterCalcEntry.ref='NIR@1'
rasterCalcEntry.raster=lyr
rasterCalcEntry.bandNumber=1
entries.append(rasterCalcEntry)
if not ".tif" in outImage:
outImage=outImage+".tif"
noData=-3.4028234663852886e+38
calc=QgsRasterCalculator('1.0*(NIR@1 - R@1)/(NIR@1 + R@1)+0.0', outImage, "GTiff", lyr.extent(), lyr.crs(), lyr.width(), lyr.height(), entries)
calc.processCalculation()
def _get_options(self):
entries = QgsRasterCalculatorEntry.rasterEntries()
options = {}
for entry in entries:
options[entry.ref] = entry.ref
return options
