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 accept(self):
"""
Handle OK button
"""
layer_title = self.input_title.text()
netcdf_uri = 'NETCDF:"'+self.file_path+'":'+self.subdataset
output_uri = self.file_dir + "/" + layer_title + ".tif"
# check if default folder is used
if not self.use_default_dir.isChecked():
self.file_dir = self.output_path.text()
output_uri = self.file_dir
#self.display_log.append("Result path " + output_uri)
full_cmd = 'gdal_translate -b ' + self.band + ' -a_srs ' + self.input_authid +' -of GTiff ' + netcdf_uri + ' "' + output_uri +'"'
subprocess.Popen(full_cmd, shell=True)
# if not self.use_input_crs.isChecked():
# transformed_uri = self.file_dir + "/" + layer_title + "_transformed.tif"
# transform_cmd = 'gdalwarp -overwrite -s_srs ' + self.input_authid + ' -t_srs '+ self.output_authid +' -of GTiff ' + output_uri + '' + transformed_uri +''
# subprocess.Popen(transform_cmd, shell=True)
# output_uri = transformed_uri
file_info = QFileInfo(output_uri)
base_name = file_info.baseName()
result_layer = QgsRasterLayer(output_uri, base_name)
result_layer.isValid()
if not result_layer.isValid():
QgsMessageLog.logMessage("Layer is invalid")
msg_bar = self.iface.messageBar().createMessage("Warning", "Layer is not loaded automatically")
self.uri = output_uri
self.base_name = base_name
button_load_result = QPushButton(msg_bar)
button_load_result.setText("Load Result")
button_load_result.pressed.connect(self.load_manually)
msg_bar.layout().addWidget(button_load_result)
self.iface.messageBar().pushWidget(msg_bar, QgsMessageBar.WARNING, duration=15)
else:
QgsMapLayerRegistry.instance().addMapLayer(result_layer)
def _export_composition_as_image(self, composition, file_path):
"""
Export the composition as a raster image.
"""
num_pages = composition.numPages()
for p in range(num_pages):
img = composition.printPageAsRaster(p)
if img.isNull():
msg = QApplication.translate("DocumentGenerator",
u"Memory allocation error. Please try "
u"a lower resolution or a smaller paper size.")
raise Exception(msg)
if p == 0:
state = img.save(file_path)
else:
fi = QFileInfo(file_path)
file_path = u"{0}/{1}_{2}.{3}".format(fi.absolutePath(),
fi.baseName(),
(p+1), fi.suffix())
state = img.save(file_path)
if not state:
msg = QApplication.translate("DocumentGenerator",
u"Error creating {0}.".format(file_path))
raise Exception(msg)
def _add_tabular_layer(self, tabular_layer, layer_name):
"""Add a tabular layer to the folder.
:param tabular_layer: The layer to add.
:type tabular_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
output = QFileInfo(
self.uri.filePath(layer_name + '.csv'))
QgsVectorFileWriter.writeAsVectorFormat(
tabular_layer,
output.absoluteFilePath(),
'utf-8',
None,
'CSV')
assert output.exists()
return True, output.baseName()
def testIdentify(self):
myPath = os.path.join(unitTestDataPath(), 'landsat.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
myRasterLayer = QgsRasterLayer(myPath, myBaseName)
myMessage = 'Raster not loaded: %s' % myPath
assert myRasterLayer.isValid(), myMessage
myPoint = QgsPoint(786690, 3345803)
#print 'Extents: %s' % myRasterLayer.extent().toString()
#myResult, myRasterValues = myRasterLayer.identify(myPoint)
#assert myResult
myRasterValues = myRasterLayer.dataProvider().identify(myPoint, QgsRasterDataProvider.IdentifyFormatValue )
assert len( myRasterValues ) > 0
# Get the name of the first band
myBand = myRasterValues.keys()[0]
#myExpectedName = QString('Band 1')
myExpectedBand = 1
myMessage = 'Expected "%s" got "%s" for first raster band name' % (
myExpectedBand, myBand)
assert myExpectedBand == myBand, myMessage
# Convert each band value to a list of ints then to a string
myValues = myRasterValues.values()
myIntValues = []
for myValue in myValues:
#myIntValues.append(int(str(myValue)))
myIntValues.append( myValue.toInt()[0] )
myValues = str(myIntValues)
myExpectedValues = '[127, 141, 112, 72, 86, 126, 156, 211, 170]'
myMessage = 'Expected: %s\nGot: %s' % (myValues, myExpectedValues)
self.assertEquals(myValues, myExpectedValues, myMessage)
def run_clicked(self):
start = clock()
self.setEnabled(False)
input = self.layerPath
if unicode(self.output.text()) == '':
try:
output = os.environ['temp']+'out'+unicode(int(clock()*10000))+'.tif'
except:
if os.access('/tmp/kuw_filter', os.F_OK)==False:
os.mkdir('/tmp/kuw_filter')
output = '/tmp/kuw_filter/out'+unicode(int(clock()*10000))+'.tif'
else:
output = unicode(self.output.text())
refb = int(self.refb.text())
memuse = int(self.mem.text())
self.setCursor(QCursor(Qt.WaitCursor))
if dofilter(self, input, output, refb, memuse) :
self.msgbox(QApplication.translate('kuw_filterdialog','Time elapsed:\n ', None, QApplication.UnicodeUTF8)+unicode(int((clock()-start)/3600))+'h'+unicode(int((clock()-start)/60))+'m'+unicode((0.5+clock()-start)%60)[0:5]+'s')
if self.addout.isChecked():
fileName = unicode(output)
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
iface.addRasterLayer(fileName, baseName)
self.setCursor(QCursor(Qt.ArrowCursor))
self.setEnabled(True)
self.close()
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 testIdentify(self):
myPath = os.path.abspath(os.path.join(__file__, '..', '..', '..', 'testdata', 'landsat.tif'))
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
myRasterLayer = QgsRasterLayer(myPath, myBaseName)
myMessage = 'Raster not loaded: %s' % myPath
assert myRasterLayer.isValid(), myMessage
myPoint = QgsPoint(786690, 3345803)
#print 'Extents: %s' % myRasterLayer.extent().toString()
myResult, myRasterValues = myRasterLayer.identify(myPoint)
assert myResult
# Get the name of the first band
myBandName = myRasterValues.keys()[0]
myExpectedName = QString('Band 1')
myMessage = 'Expected "%s" got "%s" for first raster band name' % (
myExpectedName, myBandName)
assert myExpectedName == myBandName, myMessage
# Convert each band value to a list of ints then to a string
myValues = myRasterValues.values()
myIntValues = []
for myValue in myValues:
myIntValues.append(int(str(myValue)))
myValues = str(myIntValues)
myExpectedValues = '[127, 141, 112, 72, 86, 126, 156, 211, 170]'
myMessage = 'Expected: %s\nGot: %s' % (myValues, myExpectedValues)
self.assertEquals(myValues, myExpectedValues, myMessage)
def accept(self):
input_path = str(self.leInputPath.text())
output_path = str(self.leOutputPath.text())
if not output_path.endswith('.tif'):
QMessageBox.warning(
self.parent, self.tr('InaSAFE'),
(self.tr('Output file name must be tif file')))
if not os.path.exists(input_path):
QMessageBox.warning(
self.parent, self.tr('InaSAFE'),
(self.tr('Input file is not exist')))
return
my_algorithm = str(self.cboAlgorithm.currentText()).lower()
fileName = convert_mmi_data(input_path, output_path,
the_algorithm=my_algorithm,
algorithm_name=False)
if self.cBLoadLayer.isChecked():
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
my_raster_layer = QgsRasterLayer(fileName, baseName)
if not my_raster_layer.isValid():
LOGGER.debug("Failed to load")
else:
QgsMapLayerRegistry.instance().addMapLayer(my_raster_layer)
self.done(self.Accepted)
if not self.test_mode:
QMessageBox.warning(
self.parent, self.tr('InaSAFE'),
(self.tr('Success to convert %1 to %2').
arg(input_path).arg(output_path)))
def __load_layer(self, path):
fileName = path
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
rlayer = QgsRasterLayer(fileName, baseName)
if not rlayer.isValid():
raise Exception("Computation finished, but layer failed to load. Inspect the path zou specified for the output layer.")
return rlayer
def importSplus(self):
dlg = splusimport.Dialog(self.iface)
dlg.setModal(True)
dlg.setWindowTitle('Import S-Plus map')
if dlg.exec_() == QDialog.Accepted:
file = QFileInfo(dlg.lineEdit_2.text())
nl = QgsVectorLayer(dlg.lineEdit_2.text(), unicode(file.baseName()), "ogr")
QgsMapLayerRegistry.instance().addMapLayers([nl])
def open_raster(self):
path = self.le_shapefile.text()
file_info = QFileInfo(path)
layer = QgsRasterLayer(path, file_info.baseName())
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().addMapLayer(layer)
self.signalStatus.emit(3, tr('Successful import from %s' % path))
def addRasterLayer(self, maps):
for m in maps:
fileName = m
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
self.layer = QgsRasterLayer(fileName, baseName)
if not self.layer.isValid():
QMessageBox.warning( self, self.tr( "Output error") , 'File '+m+' could not be added to the map canvas')
QgsMapLayerRegistry.instance().addMapLayer(self.layer,True)
def updateGifPath(self):
fileName = self.txtGifPath.text()
f = QFileInfo(fileName)
if f.dir().exists and not f.baseName().isEmpty() and not f.suffix().isEmpty():
self.txtGifPath.setText(fileName)
return True
else:
QMessageBox.warning(self, u"{0} -- warning".format(Img2GifWidget.AppName),
u"要生成的GIF存储路径{0}不是有效的GIF文件".format(unicode(fileName)))
return False
def load_register_raster_layer(layerReg, layer_fname):
fileInfo = QFileInfo(layer_fname)
base_name = fileInfo.baseName()
layer = QgsRasterLayer(layer_fname, base_name)
if not layer.isValid():
print "Raster layer failed to load from file %s (as '%s')!" \
% (layer_fname, base_name)
return None
layerReg.addMapLayer(layer)
return layer
def testIssue7023(self):
"""Check if converting a raster from 1.8 to 2 works."""
myPath = os.path.join(unitTestDataPath("raster"), "raster-pallette-crash2.tif")
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
myRasterLayer = QgsRasterLayer(myPath, myBaseName)
myMessage = "Raster not loaded: %s" % myPath
assert myRasterLayer.isValid(), myMessage
# crash on next line
QgsMapLayerRegistry.instance().addMapLayers([myRasterLayer])
def getExtent(extentRaster):
fileInfo = QFileInfo(extentRaster)
baseName = fileInfo.baseName()
rlayer = processing.getObject(extentRaster)
extent = rlayer.extent()
xmin = extent.xMinimum()
xmax = extent.xMaximum()
ymin = extent.yMinimum()
ymax = extent.yMaximum()
return "%f,%f,%f,%f"% (xmin, xmax, ymin, ymax)
def testShaderCrash(self):
"""Check if we assign a shader and then reassign it no crash occurs."""
myPath = os.path.abspath(
os.path.join(__file__, '..', '..', '..', 'testdata', 'raster',
'band1_float32_noct_epsg4326.tif'))
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
myRasterLayer = QgsRasterLayer(myPath, myBaseName)
myMessage = 'Raster not loaded: %s' % myPath
assert myRasterLayer.isValid(), myMessage
myRasterShader = QgsRasterShader()
myColorRampShader = QgsColorRampShader()
myColorRampShader.setColorRampType(QgsColorRampShader.INTERPOLATED)
myItems = []
myItem = QgsColorRampShader.ColorRampItem(10, QtGui.QColor('#ffff00'),
'foo')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(100, QtGui.QColor('#ff00ff'),
'bar')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(1000,
QtGui.QColor('#00ff00'),
'kazam')
myItems.append(myItem)
myColorRampShader.setColorRampItemList(myItems)
myRasterShader.setRasterShaderFunction(myColorRampShader)
myPseudoRenderer = QgsSingleBandPseudoColorRenderer(
myRasterLayer.dataProvider(), 1, myRasterShader)
myRasterLayer.setRenderer(myPseudoRenderer)
return
######## works first time #############
myRasterShader = QgsRasterShader()
myColorRampShader = QgsColorRampShader()
myColorRampShader.setColorRampType(QgsColorRampShader.INTERPOLATED)
myItems = []
myItem = QgsColorRampShader.ColorRampItem(10, QtGui.QColor('#ffff00'),
'foo')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(100, QtGui.QColor('#ff00ff'),
'bar')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(1000,
QtGui.QColor('#00ff00'),
'kazam')
myItems.append(myItem)
myColorRampShader.setColorRampItemList(myItems)
myRasterShader.setRasterShaderFunction(myColorRampShader)
######## crash on next line ##################
myPseudoRenderer = QgsSingleBandPseudoColorRenderer(
myRasterLayer.dataProvider(), 1, myRasterShader)
myRasterLayer.setRenderer(myPseudoRenderer)
def testIssue7023(self):
"""Check if converting a raster from 1.8 to 2 works."""
myPath = os.path.join(unitTestDataPath('raster'),
'raster-pallette-crash2.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
myRasterLayer = QgsRasterLayer(myPath, myBaseName)
myMessage = 'Raster not loaded: %s' % myPath
assert myRasterLayer.isValid(), myMessage
# crash on next line
QgsMapLayerRegistry.instance().addMapLayers([myRasterLayer])
def grassExtent(vector1):
#Set GRASS extent
fileInfo0 = QFileInfo(vector1)
path0 = fileInfo0.filePath()
baseName0 = fileInfo0.baseName()
layer0 = QgsVectorLayer("%s" % (vector1), "vector1", "ogr")
ext = layer0.extent()
(xmin, xmax, ymin, ymax) = (ext.xMinimum(), ext.xMaximum(), ext.yMinimum(),
ext.yMaximum())
grassExtent = str(xmin) + "," + str(xmax) + "," + str(ymin) + "," + str(
ymax)
return grassExtent
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 calculate(self):
self.dlg.progressBar.setValue(0)
rows = self.dlg.table.rowCount()
if rows == 0:
msg = QMessageBox()
msg.setWindowTitle("Error!")
msg.setText("Choose minimum one input layer!")
msg.exec_()
return
paths = []
means = []
for row in range(rows):
path = self.dlg.table.cellWidget(row, 0).currentLayer().source()
mean = self.dlg.table.cellWidget(row, 2).value()
paths.append(path)
means.append(mean)
rasters = []
# parameters of the first raster
f1 = gdal.Open(paths[0])
size_x = f1.RasterXSize
size_y = f1.RasterYSize
proj = f1.GetProjection ()
georef = f1.GetGeoTransform()
del f1
for path in paths:
f = gdal.Open(path)
raster = f.ReadAsArray()
rasters.append(raster)
# covariance matrix and inverted covariance matrix
covariance = numpy.cov([i.ravel() for i in rasters])
inv_covariance = numpy.linalg.inv(covariance)
means = numpy.array(means)
# calculate mahalanobis distances for each pixel
rasters = numpy.dstack(rasters).reshape(-1, len(rasters))
result = cdist(rasters, means[None, :], metric='mahalanobis', VI=inv_covariance)
result = result.reshape(size_y, size_x)
# new raster
driver = gdal.GetDriverByName('GTiff')
fileName = self.dlg.outputPath.text()
output = driver.Create(fileName, size_x, size_y, 1, gdal.GDT_Float32)
output.GetRasterBand(1).WriteArray(result)
output.SetProjection( proj )
output.SetGeoTransform( georef )
output.FlushCache()
output = None
self.dlg.progressBar.setValue(100)
# add result to canvas
if self.dlg.checkBox.isChecked():
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
new_layer = QgsRasterLayer(fileName, baseName)
QgsMapLayerRegistry.instance().addMapLayer(new_layer)
def accept(self):
"""Handler for when OK is clicked.
"""
input_path = self.input_path.text()
input_title = self.line_edit_title.text()
input_source = self.line_edit_source.text()
output_path = self.output_path.text()
if not output_path.endswith('.tif'):
# noinspection PyArgumentList,PyCallByClass,PyTypeChecker
QMessageBox.warning(
self,
self.tr('InaSAFE'),
(self.tr('Output file name must be tif file')))
if not os.path.exists(input_path):
# noinspection PyArgumentList,PyCallByClass,PyTypeChecker
QMessageBox.warning(
self,
self.tr('InaSAFE'),
(self.tr('Input file does not exist')))
return
if self.nearest_mode.isChecked():
algorithm = 'nearest'
else:
algorithm = 'invdist'
QtGui.qApp.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
file_name = convert_mmi_data(
input_path,
input_title,
input_source,
output_path,
algorithm=algorithm,
algorithm_filename_flag=True)
QtGui.qApp.restoreOverrideCursor()
if self.load_result.isChecked():
file_info = QFileInfo(file_name)
base_name = file_info.baseName()
layer = QgsRasterLayer(file_name, base_name)
# noinspection PyTypeChecker
mmi_ramp(layer)
layer.saveDefaultStyle()
if not layer.isValid():
LOGGER.debug("Failed to load")
else:
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().addMapLayers([layer])
iface.zoomToActiveLayer()
self.done(self.Accepted)
def accept(self):
"""Handler for when OK is clicked.
"""
input_path = self.input_path.text()
input_title = self.line_edit_title.text()
input_source = self.line_edit_source.text()
output_path = self.output_path.text()
if not output_path.endswith('.tif'):
# noinspection PyArgumentList,PyCallByClass,PyTypeChecker
QMessageBox.warning(
self,
self.tr('InaSAFE'),
(self.tr('Output file name must be tif file')))
if not os.path.exists(input_path):
# noinspection PyArgumentList,PyCallByClass,PyTypeChecker
QMessageBox.warning(
self,
self.tr('InaSAFE'),
(self.tr('Input file does not exist')))
return
if self.nearest_mode.isChecked():
algorithm = 'nearest'
else:
algorithm = 'invdist'
QtGui.qApp.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
file_name = convert_mmi_data(
input_path,
input_title,
input_source,
output_path,
algorithm=algorithm,
algorithm_filename_flag=True)
QtGui.qApp.restoreOverrideCursor()
if self.load_result.isChecked():
file_info = QFileInfo(file_name)
base_name = file_info.baseName()
layer = QgsRasterLayer(file_name, base_name)
# noinspection PyTypeChecker
mmi_ramp(layer)
layer.saveDefaultStyle()
if not layer.isValid():
LOGGER.debug("Failed to load")
else:
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().addMapLayers([layer])
iface.zoomToActiveLayer()
self.done(self.Accepted)
def ExportHUMgrid2raster(diretorioOut, resolucao):
resultado3 = diretorioOut + r"\resultado.shp"
layer = QgsVectorLayer(resultado3, 'resultado', 'ogr')
ext = layer.extent()
(xmin, xmax, ymin, ymax) = (ext.xMinimum(), ext.xMaximum(), ext.yMinimum(),
ext.yMaximum())
grassExtent = str(xmin) + "," + str(xmax) + "," + str(ymin) + "," + str(
ymax)
QgsMapLayerRegistry.instance().addMapLayer(layer)
query = '"sumINDIVAL" is null'
selection = layer.getFeatures(
QgsFeatureRequest().setFilterExpression(query))
layer.setSelectedFeatures([k.id() for k in selection])
selection = layer.getFeatures(
QgsFeatureRequest().setFilterExpression(query))
layer.setSelectedFeatures([k.id() for k in selection])
# Update do campo sumINDIVAL no shapefile
expressionB = QgsExpression("0")
indexB = layer.fieldNameIndex("sumINDIVAL")
expressionB.prepare(layer.pendingFields())
layer.startEditing()
for feature in layer.getFeatures(
QgsFeatureRequest().setFilterExpression(query)):
valueB = expressionB.evaluate(feature)
layer.changeAttributeValue(feature.id(), indexB, valueB)
layer.commitChanges()
layer.updateExtents()
layer.dataProvider().forceReload()
layer.removeSelection()
print 'Updated!'
resultado4 = diretorioOut + r"\centroides.shp"
processing.runalg("qgis:polygoncentroids", resultado3, resultado4)
layer1 = QgsVectorLayer(resultado4, 'centroides', 'ogr')
QgsMapLayerRegistry.instance().addMapLayer(layer1)
resultado5 = diretorioOut + r"\resultado.tif"
#processing.runalg("saga:shapestogrid",resultado4,"sumINDIVAL",2,4,0,0,3,grassExtent,resolucao,0,resultado5)
processing.runalg("grass7:v.to.rast.attribute", resultado4, 0,
"sumINDIVAL", grassExtent, resolucao, -1, 0.0001,
resultado5)
fileInfo2 = QFileInfo(resultado5)
path2 = fileInfo2.filePath()
baseName2 = fileInfo2.baseName()
layer2 = QgsRasterLayer(path2, baseName2)
if layer2.isValid() is True:
QgsMapLayerRegistry.instance().addMapLayer(layer2)
print "Layer2 was loaded successfully!"
else:
print "Unable to read basename2 and file path2 - Your string is probably invalid"
def testShaderCrash(self):
"""Check if we assign a shader and then reassign it no crash occurs."""
myPath = os.path.join(unitTestDataPath('raster'),
'band1_float32_noct_epsg4326.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
myRasterLayer = QgsRasterLayer(myPath, myBaseName)
myMessage = 'Raster not loaded: %s' % myPath
assert myRasterLayer.isValid(), myMessage
myRasterShader = QgsRasterShader()
myColorRampShader = QgsColorRampShader()
myColorRampShader.setColorRampType(QgsColorRampShader.INTERPOLATED)
myItems = []
myItem = QgsColorRampShader.ColorRampItem(10,
QtGui.QColor('#ffff00'), 'foo')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(100,
QtGui.QColor('#ff00ff'), 'bar')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(1000,
QtGui.QColor('#00ff00'), 'kazam')
myItems.append(myItem)
myColorRampShader.setColorRampItemList(myItems)
myRasterShader.setRasterShaderFunction(myColorRampShader)
myPseudoRenderer = QgsSingleBandPseudoColorRenderer(
myRasterLayer.dataProvider(), 1, myRasterShader)
myRasterLayer.setRenderer(myPseudoRenderer)
return
######## works first time #############
myRasterShader = QgsRasterShader()
myColorRampShader = QgsColorRampShader()
myColorRampShader.setColorRampType(QgsColorRampShader.INTERPOLATED)
myItems = []
myItem = QgsColorRampShader.ColorRampItem(10,
QtGui.QColor('#ffff00'), 'foo')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(100,
QtGui.QColor('#ff00ff'), 'bar')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(1000,
QtGui.QColor('#00ff00'), 'kazam')
myItems.append(myItem)
myColorRampShader.setColorRampItemList(myItems)
myRasterShader.setRasterShaderFunction(myColorRampShader)
######## crash on next line (fixed now)##################
myPseudoRenderer = QgsSingleBandPseudoColorRenderer(
myRasterLayer.dataProvider(), 1, myRasterShader)
myRasterLayer.setRenderer(myPseudoRenderer)
def _add_raster_layer(self, raster_layer, layer_name):
"""Add a raster layer to the folder.
:param raster_layer: The layer to add.
:type raster_layer: QgsRasterLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
if not self.is_writable():
return False, 'The destination is not writable.'
output = QFileInfo(self.uri.filePath(layer_name + '.tif'))
source = QFileInfo(raster_layer.source())
if source.exists() and source.suffix() in ['tiff', 'tif']:
# If it's tiff file based.
QFile.copy(source.absoluteFilePath(), output.absoluteFilePath())
else:
# If it's not file based.
renderer = raster_layer.renderer()
provider = raster_layer.dataProvider()
crs = raster_layer.crs()
pipe = QgsRasterPipe()
pipe.set(provider.clone())
pipe.set(renderer.clone())
file_writer = QgsRasterFileWriter(output.absoluteFilePath())
file_writer.Mode(1)
file_writer.writeRaster(
pipe,
provider.xSize(),
provider.ySize(),
provider.extent(),
crs)
del file_writer
assert output.exists()
return True, output.baseName()
def _add_raster_layer(self, raster_layer, layer_name):
"""Add a raster layer to the folder.
:param raster_layer: The layer to add.
:type raster_layer: QgsRasterLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
if not self.is_writable():
return False, 'The destination is not writable.'
output = QFileInfo(self.uri.filePath(layer_name + '.tif'))
source = QFileInfo(raster_layer.source())
if source.exists() and source.suffix() in ['tiff', 'tif']:
# If it's tiff file based.
QFile.copy(source.absoluteFilePath(), output.absoluteFilePath())
else:
# If it's not file based.
renderer = raster_layer.renderer()
provider = raster_layer.dataProvider()
crs = raster_layer.crs()
pipe = QgsRasterPipe()
pipe.set(provider.clone())
pipe.set(renderer.clone())
file_writer = QgsRasterFileWriter(output.absoluteFilePath())
file_writer.Mode(1)
file_writer.writeRaster(
pipe,
provider.xSize(),
provider.ySize(),
provider.extent(),
crs)
del file_writer
assert output.exists()
return True, output.baseName()
def _updateRecentsMenu(self):
# Ensures the recent files menu matches the recent file names
# into the recent_file_names attribute.
# This shoud be called each time the recent_file_names is modified.
self.ui.menuRecent_Files.clear()
for recent_file_name in self.recent_file_names:
recent_file_info = QFileInfo(recent_file_name)
action_text = recent_file_info.baseName() + " ["
action_text += recent_file_info.canonicalFilePath() + "]"
file_action = self.ui.menuRecent_Files.addAction(action_text)
file_name = recent_file_info.canonicalFilePath()
file_action.triggered.connect(self._genRecentOpenSlot(file_name))
self.ui.menuRecent_Files.addSeparator()
self.ui.menuRecent_Files.addAction(self.ui.actionClear_All)
def StringToRaster(raster):
# Mira si se le pasa un string
if isinstance(raster, basestring):
fileInfo = QFileInfo(raster)
baseName = fileInfo.baseName()
path = fileInfo.filePath()
# Chequea el base name y la ruta
if (baseName and path):
raster = QgsRasterLayer(path, baseName) # carga la capa raster
if not raster.isValid():
print("Fallo al cargar la capa raster")
return
else:
print("Ruta de la capa raster o nombre de la capa incorrectos")
return
return raster
def test_setRenderer(self):
myPath = os.path.join(unitTestDataPath('raster'),
'band1_float32_noct_epsg4326.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
layer = QgsRasterLayer(myPath, myBaseName)
self.rendererChanged = False
layer.rendererChanged.connect(self.onRendererChanged)
rShader = QgsRasterShader()
r = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1, rShader)
layer.setRenderer(r)
assert self.rendererChanged
assert layer.renderer() == r
def create_shp(self, shpfile_path, crsID=None):
fileInfo = QFileInfo(shpfile_path)
baseName = fileInfo.baseName()
try:
layer = qgc.QgsVectorLayer(shpfile_path, baseName, "none")
except:
layer = qgc.QgsVectorLayer(shpfile_path, baseName, "none")
sourceCrs = layer.crs()
destCrs = None
if crsID == None:
destCrs = qgc.QgsCoordinateReferenceSystem(4326)
else:
destCrs = qgc.QgsCoordinateReferenceSystem(crsID)
return layer
class FileImport:
def __init__(self):
"""
Initialize the File Import Class
"""
self.com = Communicate()
self.filePath = ''
self.fileInfo = None
self.baseName = None
self.rLayer = None
def file_input(self, path):
"""
Set the path and Setup the File to be used later
:param path: Path to the file you wish to use
:type path: str
:return: None
"""
if path == '':
self.com.log("FILE PATH EMPTY", 2)
raise IOError
self.filePath = path
self.fileInfo = QFileInfo(self.filePath)
self.baseName = self.fileInfo.baseName()
# Ensure that this stays in as this is how the Raster is imported.
self.check_file_type()
def check_file_type(self):
"""
Validate the File type as a Valid Raster layer
:return: None
"""
self.rLayer = QgsRasterLayer(self.filePath, self.baseName)
if not self.rLayer.isValid():
self.rLayer = None
self.com.log("Check File Type Error: Layer Invalid", 2)
def get_rLayer(self):
"""
Get the rLayer
:return: rLayer Obj
"""
return self.rLayer
def sign(self):
try:
chosen_hash = hashes.SHA256()
hasher = hashes.Hash(chosen_hash, default_backend())
try:
with open(self.keyPath, "rb") as key_file:
private_key = serialization.load_pem_private_key(key_file.read(), password=None, backend=default_backend())
except IOError:
QtGui.QMessageBox.critical(self, 'Error!', "Opening key file failed!", QtGui.QMessageBox.Ok)
try:
with open(self.filePath, 'rb') as f:
info = QFileInfo(self.filePath)
while True:
data = f.read(BUFFER_SIZE)
if not data:
break
hasher.update(data)
except IOError:
QtGui.QMessageBox.critical(self, 'Error!', "Opening file to sign has failed!", QtGui.QMessageBox.Ok)
digest = hasher.finalize()
signature = private_key.sign(digest, utils.Prehashed(chosen_hash))
public_key = private_key.public_key()
public_key.verify(signature, digest, utils.Prehashed(chosen_hash))
try:
with open("publicKey.pem", "wb") as f:
serialized_public = public_key.public_bytes(encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo)
f.write(serialized_public)
except IOError:
QtGui.QMessageBox.critical(self, 'Error!', "Saving the public key has failed!", QtGui.QMessageBox.Ok)
try:
with open(info.baseName()+"_signed.sig", "wb") as f:
f.write(signature)
except IOError:
QtGui.QMessageBox.critical(self, 'Error!', "Saving the signature of the file has failed!", QtGui.QMessageBox.Ok)
self.outcomeLabel.setText("Sign successful!")
QtGui.QApplication.processEvents()
QtGui.QMessageBox.information(self, 'Success!', "File has been signed successfully!")
except:
self.outcomeLabel.setText("Signing unsuccessful!")
QtGui.QApplication.processEvents()
QtGui.QMessageBox.warning(self, 'Failure!', "File has not been signed successfully!")
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 test_setRenderer(self):
myPath = os.path.join(unitTestDataPath('raster'),
'band1_float32_noct_epsg4326.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
layer = QgsRasterLayer(myPath, myBaseName)
self.rendererChanged = False
QObject.connect(layer, SIGNAL("rendererChanged()"),
self.onRendererChanged)
rShader = QgsRasterShader()
r = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1, rShader)
layer.setRenderer(r)
assert self.rendererChanged
assert layer.renderer() == r
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 browsePath(self):
"""用户点击了浏览路径的按钮。如果成功设置了路径，就返回True，如果用户取消了操作或者出错，就返回False
返回的用途参见showEvent()"""
filename = QFileDialog.getOpenFileName(self, self.windowTitle())
if filename == "":
return False
fi = QFileInfo(filename)
if fi.isSymLink():
filename = fi.symLinkTarget()
if not os.path.exists(filename):
QMessageBox.information(self, self.windowTitle(), self.trUtf8("快捷方式所指向的程序不正确。"))
return False
fi = QFileInfo(filename)
self.txtName.setText(fi.baseName())
self.txtPath.setText(fi.absoluteFilePath())
self.setFileIcon(fi.absoluteFilePath())
self.txtDir.setText(fi.dir().absolutePath())
return True
def __add_raster_layer(self, rasterfile, legend_name=None):
try:
if VRP_DEBUG is True: QgsMessageLog.logMessage('export pdf (__add_raster_layer): {0}'.format(rasterfile), DLG_CAPTION)
if legend_name is None:
fileinfo = QFileInfo(rasterfile)
basename = fileinfo.baseName()
else:
basename = legend_name
lyr = QgsRasterLayer(rasterfile, basename)
if not lyr.isValid():
QgsMessageLog.logMessage( u'Raster [{0}] konnte nicht geladen werden!'.format(rasterfile), DLG_CAPTION)
return None
QgsMapLayerRegistry.instance().addMapLayer(lyr)
return lyr
except:
msg = 'export pdf (__add_raster_layer): {0}'.format(traceback.format_exc())
QgsMessageLog.logMessage(msg, DLG_CAPTION)
return None
def updateTable(self, id):
filePath = QFileDialog.getOpenFileName(self, "请选择库", self.alloneEnv,
"Library(*.lib)")
if filePath.isEmpty():
return
fileinfo = QFileInfo(filePath)
libPath = fileinfo.absoluteDir().absolutePath()
libName = fileinfo.baseName()
# 支持选择文件后与系统ALLONEDIR比较一下变成相对路径
# 并且能够手动输入相对路径或包含$(ALLONEDIR)的相对路径
env = QString(os.getenv('ALLONEDIR', '../..').replace('\\', '/'))
if env.endsWith('/'):
env.remove(env.lastIndexOf('/'), 1)
if libPath.contains(env):
libPath.replace(env, QString('$$ALLONEDIR'))
self.tw_interface.setItem(id, 1, QTableWidgetItem(libPath))
self.tw_interface.setItem(id, 0, QTableWidgetItem(libName))
def accept(self):
"""Handler for when OK is clicked.
"""
input_path = str(self.leInputPath.text())
output_path = str(self.leOutputPath.text())
if not output_path.endswith('.tif'):
# noinspection PyArgumentList
QMessageBox.warning(
self.parent, self.tr('InaSAFE'),
(self.tr('Output file name must be tif file')))
if not os.path.exists(input_path):
# noinspection PyArgumentList
QMessageBox.warning(
self.parent, self.tr('InaSAFE'),
(self.tr('Input file is not exist')))
return
if self.radNearest.isChecked():
my_algorithm = 'nearest'
else:
my_algorithm = 'invdist'
QtGui.qApp.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
fileName = convert_mmi_data(
input_path, output_path,
algorithm=my_algorithm,
algorithm_filename_flag=False)
QtGui.qApp.restoreOverrideCursor()
if self.cBLoadLayer.isChecked():
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
layer = QgsRasterLayer(fileName, baseName)
layer.setGrayBandName(layer.bandName(1))
layer.setDrawingStyle(QgsRasterLayer.SingleBandPseudoColor)
layer.setColorShadingAlgorithm(QgsRasterLayer.PseudoColorShader)
layer.saveDefaultStyle()
if not layer.isValid():
LOGGER.debug("Failed to load")
else:
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().addMapLayer(layer)
self.done(self.Accepted)
def selectFeat(self):
"""Activate the select tools to review track graph"""
self.iface.mapCanvas().setMapTool(QgsMapToolZoom(self.canvas, False))
st = None
# 1 Get the vector layer
layers = self.iface.legendInterface().layers()
selected_lignes = self.dockwidget.TracksInput.currentIndex()
linesLayer = layers[self.vect_list[selected_lignes]]
# 2 Get the raster layer
selected_lignes = self.dockwidget.DEMInput.currentIndex()
DEMLayer = layers[self.rast_list[selected_lignes]]
# Load raster layer
fileName = DEMLayer.publicSource()
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
# keep raster path for the RasterCalculator operation
pathRaster = os.path.dirname(fileName)
dem = QgsRasterLayer(fileName, baseName)
if not dem.isValid():
QgsMessageLog.logMessage("Layer failed to load!",
"PisteCreator",
level=Qgis.Info)
# 3
self.ConfigParser = GrumpyConfigParser()
self.ConfigParser.optionxform = str
configFilePath = os.path.join(
os.path.abspath(os.path.dirname(__file__)), 'option.cfg')
self.ConfigParser.read(configFilePath)
side_distance = self.ConfigParser.getint('calculation_variable',
'side_distance')
interpolate_act = self.ConfigParser.getboolean('calculation_variable',
'interpolate_act')
# 4 Activate Maptools
self.PisteCreatorTool = SelectMapTool(self.iface, self.updateGraph,
linesLayer, dem, side_distance,
interpolate_act)
self.iface.mapCanvas().setMapTool(self.PisteCreatorTool)
def on_open(self):
'''打开现有配置'''
fileName = QFileDialog.getOpenFileName(
self, "选择现有模板", app.g_pwd + os.sep + "configurations",
"Config (*.json)")
if fileName.isEmpty():
return
self.path = fileName
with open(app.QString2str(fileName), 'r') as f:
content = f.read()
fileInfo = QFileInfo(fileName)
if not fileInfo.exists():
return
config = Configuration()
config.fromJson(content)
config.allone_dir = os.getenv('ALLONEDIR', '../..').replace('\\', '/')
self.addConfig(fileInfo.baseName(), fileInfo.filePath(), content)
self.on_select()
def layer_uri(self, layer_name):
"""Get layer URI.
:param layer_name: The name of the layer to fetch.
:type layer_name: str
:return: The URI to the layer.
:rtype: str
.. versionadded:: 4.0
"""
layers = self.layers()
for layer, extension in product(layers, EXTENSIONS):
one_file = QFileInfo(self.uri.filePath(layer + '.' + extension))
if one_file.exists():
if one_file.baseName() == layer_name:
return one_file.absoluteFilePath()
else:
return None
def openVectorFile(sFileName, sLayerName, iLayerEPSG, sLayerField):
# Check layer in registry
bMapLayer = checkMapLayer(sLayerName)
# Upload or reload layer
if bMapLayer is False:
# Get layer information and data
oFileInfo = QFileInfo(sFileName)
oFilePath = oFileInfo.filePath()
oFileBase = oFileInfo.baseName()
# Define layer object
oMapLayer = QgsVectorLayer(sFileName, sLayerName, "ogr")
# Set layer crs
oCrs = oMapLayer.crs()
oCrs.createFromId(iLayerEPSG)
oMapLayer.setCrs(oCrs)
# Label point(s)
oPoint = QgsPalLayerSettings()
oPoint.readFromLayer(oMapLayer)
oPoint.enabled = True
oPoint.fieldName = sLayerField
oPoint.placement = QgsPalLayerSettings.AroundPoint
oPoint.textColor = QColor('yellow')
oPoint.textTransp = 0
oPoint.setDataDefinedProperty(QgsPalLayerSettings.Size, True, True,
'8', '')
oPoint.writeToLayer(oMapLayer)
# Redefine name (sometimes qgis upload shapefile including filename
sLayerName_Shorted = str(oMapLayer.name().split()[0])
oMapLayer.setLayerName(sLayerName_Shorted)
else:
# Layer available in registry
oMapLayer = getMapLayer(sLayerName)
return oMapLayer, bMapLayer
def accept(self):
"""Handler for when OK is clicked.
"""
input_path = str(self.input_path.text())
output_path = str(self.output_path.text())
if not output_path.endswith('.tif'):
# noinspection PyArgumentList
QMessageBox.warning(
self.parent, self.tr('InaSAFE'),
(self.tr('Output file name must be tif file')))
if not os.path.exists(input_path):
# noinspection PyArgumentList
QMessageBox.warning(
self.parent, self.tr('InaSAFE'),
(self.tr('Input file is not exist')))
return
if self.nearest_mode.isChecked():
my_algorithm = 'nearest'
else:
my_algorithm = 'invdist'
QtGui.qApp.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
file_name = convert_mmi_data(
input_path, output_path,
algorithm=my_algorithm,
algorithm_filename_flag=False)
QtGui.qApp.restoreOverrideCursor()
if self.load_result.isChecked():
file_info = QFileInfo(file_name)
base_name = file_info.baseName()
layer = QgsRasterLayer(file_name, base_name)
mmi_ramp(layer)
layer.saveDefaultStyle()
if not layer.isValid():
LOGGER.debug("Failed to load")
else:
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().addMapLayer(layer)
self.done(self.Accepted)
def on_new(self):
'''新建向导'''
app.g_configurations = Configuration() # 用来渲染的配置数据
dlg = wizard.MyWizard()
if dlg.exec_():
app.g_configurations.initialized = True
app.g_projects.append(app.g_configurations)
content = app.g_configurations.toJson()
self.path = QFileDialog.getSaveFileName(
self, "选择模板保存的路径",
app.g_pwd + os.sep + "configurations" + os.sep +
app.g_configurations.project_name.encode('utf-8') + ".json",
"Config (*.json)")
fileInfo = QFileInfo(self.path)
if not self.path.isEmpty():
path = app.QString2str(self.path)
with open(path, 'w+') as f:
f.write(content)
self.addConfig(fileInfo.baseName(), fileInfo.filePath(),
content)
def layer_uri(self, layer_name):
"""Get layer URI.
:param layer_name: The name of the layer to fetch.
:type layer_name: str
:return: The URI to the layer.
:rtype: str
.. versionadded:: 4.0
"""
layers = self.layers()
for layer, extension in product(layers, EXTENSIONS):
one_file = QFileInfo(
self.uri.filePath(layer + '.' + extension))
if one_file.exists():
if one_file.baseName() == layer_name:
return one_file.absoluteFilePath()
else:
return None
def __add_layers(self, thema):
try:
layers = []
for quelle in thema.quellen:
pfad = quelle.pfad.replace('{gem_name}', self.gem_name)
qml = None
if not quelle.qml is None:
qml = quelle.qml.replace('{gem_name}', self.gem_name)
if VRP_DEBUG is True: QgsMessageLog.logMessage('adding lyr:\n{0}\n{1}'.format(pfad, qml), DLG_CAPTION)
if pfad.lower().endswith('.shp') is True:
lyr = QgsVectorLayer(pfad, quelle.name, 'ogr')
if not quelle.filter is None:
if VRP_DEBUG is True: QgsMessageLog.logMessage('{0}'.format(quelle.filter), DLG_CAPTION)
#exp = QgsExpression(quelle.filter)
#if exp.hasParserError():
# QgsMessageLog.logMessage( u'Filter ungültig!\nQuelle:[{0}]\nFilter:{1}'.format(quelle.name, quelle.filter), DLG_CAPTION)
#else:
# exp.prepare(lyr.pendingFields())
lyr.setSubsetString(quelle.filter)
else:
fileinfo = QFileInfo(pfad)
basename = fileinfo.baseName()
lyr = QgsRasterLayer(pfad, basename)
if not lyr.isValid():
QgsMessageLog.logMessage( u'Raster [{0}] konnte nicht geladen werden:\n{1}'.format(thema.name, pfad), DLG_CAPTION)
continue
if not qml is None:
lyr.loadNamedStyle(qml)
QgsMapLayerRegistry.instance().addMapLayer(lyr)
#turn off layer, if no qml present
#for layer that should not be displayed but should be
#used for statistics
if qml is None:
self.legiface.setLayerVisible(lyr, False)
layers.append(lyr)
return layers
except:
msg = 'export pdf (__add_layers): {0}'.format(sys.exc_info()[0])
QgsMessageLog.logMessage(msg, DLG_CAPTION)
return None
def _add_vector_layer(self, vector_layer, layer_name):
"""Add a vector layer to the folder.
:param vector_layer: The layer to add.
:type vector_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
if not self.is_writable():
return False, 'The destination is not writable.'
output = QFileInfo(
self.uri.filePath(layer_name + '.' + self._default_vector_format))
driver_mapping = {
'shp': 'ESRI Shapefile',
'kml': 'KML',
'geojson': 'GeoJSON',
}
QgsVectorFileWriter.writeAsVectorFormat(
vector_layer,
output.absoluteFilePath(),
'utf-8',
vector_layer.crs(),
driver_mapping[self._default_vector_format])
assert output.exists()
return True, output.baseName()
def _add_vector_layer(self, vector_layer, layer_name):
"""Add a vector layer to the folder.
:param vector_layer: The layer to add.
:type vector_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
if not self.is_writable():
return False, 'The destination is not writable.'
output = QFileInfo(
self.uri.filePath(layer_name + '.' + self._default_vector_format))
driver_mapping = {
'shp': 'ESRI Shapefile',
'kml': 'KML',
'geojson': 'GeoJSON',
}
QgsVectorFileWriter.writeAsVectorFormat(
vector_layer,
output.absoluteFilePath(),
'utf-8',
vector_layer.crs(),
driver_mapping[self._default_vector_format])
assert output.exists()
return True, output.baseName()
def accept(self):
"""Handler for when OK is clicked.
"""
input_path = str(self.leInputPath.text())
output_path = str(self.leOutputPath.text())
if not output_path.endswith('.tif'):
# noinspection PyArgumentList
QMessageBox.warning(self.parent, self.tr('InaSAFE'),
(self.tr('Output file name must be tif file')))
if not os.path.exists(input_path):
# noinspection PyArgumentList
QMessageBox.warning(self.parent, self.tr('InaSAFE'),
(self.tr('Input file is not exist')))
return
if self.radNearest.isChecked():
my_algorithm = 'nearest'
else:
my_algorithm = 'invdist'
fileName = convert_mmi_data(input_path,
output_path,
the_algorithm=my_algorithm,
algorithm_name=False)
if self.cBLoadLayer.isChecked():
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
layer = QgsRasterLayer(fileName, baseName)
layer.setGrayBandName(layer.bandName(1))
layer.setDrawingStyle(QgsRasterLayer.SingleBandPseudoColor)
layer.setColorShadingAlgorithm(QgsRasterLayer.PseudoColorShader)
layer.saveDefaultStyle()
if not layer.isValid():
LOGGER.debug("Failed to load")
else:
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().addMapLayer(layer)
self.done(self.Accepted)
def _add_tabular_layer(self, tabular_layer, layer_name):
"""Add a tabular layer to the folder.
:param tabular_layer: The layer to add.
:type tabular_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
output = QFileInfo(self.uri.filePath(layer_name + '.csv'))
QgsVectorFileWriter.writeAsVectorFormat(tabular_layer,
output.absoluteFilePath(),
'utf-8', None, 'CSV')
assert output.exists()
return True, output.baseName()
def testTransparency(self):
myPath = os.path.join(unitTestDataPath('raster'),
'band1_float32_noct_epsg4326.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
myRasterLayer = QgsRasterLayer(myPath, myBaseName)
myMessage = 'Raster not loaded: %s' % myPath
assert myRasterLayer.isValid(), myMessage
renderer = QgsSingleBandGrayRenderer(myRasterLayer.dataProvider(), 1)
myRasterLayer.setRenderer(renderer)
myRasterLayer.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.StretchToMinimumMaximum,
QgsRasterLayer.ContrastEnhancementMinMax)
myContrastEnhancement = myRasterLayer.renderer().contrastEnhancement()
#print ("myContrastEnhancement.minimumValue = %.17g" %
# myContrastEnhancement.minimumValue())
#print ("myContrastEnhancement.maximumValue = %.17g" %
# myContrastEnhancement.maximumValue())
# Unfortunately the minimum/maximum values calculated in C++ and Python
# are slightly different (e.g. 3.3999999521443642e+38 x
# 3.3999999521444001e+38)
# It is not clear where the precision is lost.
# We set the same values as C++.
myContrastEnhancement.setMinimumValue(-3.3319999287625854e+38)
myContrastEnhancement.setMaximumValue(3.3999999521443642e+38)
#myType = myRasterLayer.dataProvider().dataType(1);
#myEnhancement = QgsContrastEnhancement(myType);
myTransparentSingleValuePixelList = []
rasterTransparency = QgsRasterTransparency()
myTransparentPixel1 = \
QgsRasterTransparency.TransparentSingleValuePixel()
myTransparentPixel1.min = -2.5840000772112106e+38
myTransparentPixel1.max = -1.0879999684602689e+38
myTransparentPixel1.percentTransparent = 50
myTransparentSingleValuePixelList.append(myTransparentPixel1)
myTransparentPixel2 = \
QgsRasterTransparency.TransparentSingleValuePixel()
myTransparentPixel2.min = 1.359999960575336e+37
myTransparentPixel2.max = 9.520000231087593e+37
myTransparentPixel2.percentTransparent = 70
myTransparentSingleValuePixelList.append(myTransparentPixel2)
rasterTransparency.setTransparentSingleValuePixelList(
myTransparentSingleValuePixelList)
rasterRenderer = myRasterLayer.renderer()
assert rasterRenderer
rasterRenderer.setRasterTransparency(rasterTransparency)
QgsMapLayerRegistry.instance().addMapLayers([ myRasterLayer, ])
myMapRenderer = QgsMapRenderer()
myLayers = QStringList()
myLayers.append(myRasterLayer.id())
myMapRenderer.setLayerSet(myLayers)
myMapRenderer.setExtent(myRasterLayer.extent())
myChecker = QgsRenderChecker()
myChecker.setControlName("expected_raster_transparency")
myChecker.setMapRenderer(myMapRenderer)
myResultFlag = myChecker.runTest("raster_transparency_python");
assert myResultFlag, "Raster transparency rendering test failed"
def main():
# supply path to qgis install location
QgsApplication.setPrefixPath("/usr/share/qgis", True)
# create a reference to the QgsApplication, setting the
# second argument to False disables the GUI
qgs = QgsApplication([], False)
# load providers
qgs.initQgis()
fileName = sys.argv[1]
layerStyle = sys.argv[2]
destinationFile = sys.argv[3]
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
rlayer = QgsRasterLayer(fileName, baseName)
if not rlayer.isValid():
print "Layer failed to load!"
rlayer.loadNamedStyle(layerStyle)
QgsMapLayerRegistry.instance().addMapLayer(rlayer)
# create image
minsize = 2048
factor = 1
w = rlayer.width()
h = rlayer.height()
if w < minsize or h < minsize:
if h > w:
factor = minsize / h
else:
factor = minsize / w
img = QImage(QSize(w * factor, h * factor),
QImage.Format_ARGB32_Premultiplied)
# set image's background color (can get noise otherwise)
color = QColor(255, 255, 255)
img.fill(color.rgb())
# create painter
p = QPainter()
p.begin(img)
p.setRenderHint(QPainter.Antialiasing)
render = QgsMapRenderer()
# set layer set
lst = [rlayer.id()] # add ID of every layer
render.setLayerSet(lst)
# set extent
rect = QgsRectangle(render.fullExtent())
rect.scale(1.0)
render.setExtent(rect)
# set output size
render.setOutputSize(img.size(), img.logicalDpiX())
# do the rendering
render.render(p)
p.end()
# save image
img.save(destinationFile, "png")
QgsApplication.exitQgis()
def Addlayer_OutputFile(self, outputpath):
if (os.path.isfile(outputpath)):
fileName = outputpath
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
Drainage._iface.addRasterLayer(fileName, baseName)
def accept(self):
"""Handler for when OK is clicked."""
input_path = self.input_path.text()
input_title = self.line_edit_title.text()
input_source = self.line_edit_source.text()
output_path = self.output_path.text()
if not output_path.endswith('.tif'):
# noinspection PyArgumentList,PyCallByClass,PyTypeChecker
QMessageBox.warning(
self,
self.tr('InaSAFE'),
(self.tr('Output file name must be tif file')))
if not os.path.exists(input_path):
# noinspection PyArgumentList,PyCallByClass,PyTypeChecker
QMessageBox.warning(
self,
self.tr('InaSAFE'),
(self.tr('Input file does not exist')))
return
if self.nearest_mode.isChecked():
algorithm = 'nearest'
else:
algorithm = 'invdist'
QtGui.qApp.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
file_name = convert_mmi_data(
input_path,
input_title,
input_source,
output_path,
algorithm=algorithm,
algorithm_filename_flag=True)
# reclassify raster
file_info = QFileInfo(file_name)
base_name = file_info.baseName()
self.output_layer = QgsRasterLayer(file_name, base_name)
self.output_layer.keywords = KeywordIO.read_keywords(self.output_layer)
self.output_layer.keywords['classification'] = (
earthquake_mmi_scale['key'])
keywords = self.output_layer.keywords
if self.output_layer.isValid():
self.output_layer = reclassify(
self.output_layer, overwrite_input=True)
KeywordIO.write_keywords(self.output_layer, keywords)
else:
LOGGER.debug("Failed to load")
QtGui.qApp.restoreOverrideCursor()
if self.load_result.isChecked():
# noinspection PyTypeChecker
mmi_ramp_roman(self.output_layer)
self.output_layer.saveDefaultStyle()
if not self.output_layer.isValid():
LOGGER.debug("Failed to load")
else:
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().addMapLayer(self.output_layer)
iface.zoomToActiveLayer()
if (self.keyword_wizard_checkbox.isChecked() and
self.keyword_wizard_checkbox.isEnabled()):
self.launch_keyword_wizard()
self.done(self.Accepted)
