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)