def addTiles(self, layer, files): count = 0 layers = [] QApplication.setOverrideCursor( Qt.WaitCursor ) iface.mapCanvas().freeze(True) for fileName in files: print("TileIndex plugin : loading raster file %s" % fileName) fileInfo = QFileInfo(fileName) rlayer = QgsRasterLayer(fileName, fileInfo.baseName()) if rlayer is None: print("TileIndex plugin : raster file %s could not be loaded..." % fileName) continue layers.append(rlayer) count = count + 1 print("TileIndex plugin : adding %d layers to map registry" % count) QgsMapLayerRegistry.instance().addMapLayers(layers) iface.mapCanvas().freeze(False) iface.mapCanvas().refresh() print("TileIndex plugin : done adding layers") QApplication.restoreOverrideCursor() # restore active layer if qgis >= 1.9 if count > 0: if QGis.QGIS_VERSION_INT >= 10900: iface.legendInterface().setCurrentLayer(layer) else: iface.setActiveLayer(layer) return count
def populateLayers(self): groups = {} rels = iface.legendInterface().groupLayerRelationship() groupedLayers = {} for rel in rels: groupName = rel[0] if groupName != '': groupLayers = rel[1] groups[groupName] = [] for layerid in groupLayers: groups[groupName].append(QgsMapLayerRegistry.instance().mapLayer(layerid)) groupedLayers[layerid] = groupName self.layersItem = QTreeWidgetItem() self.layersItem.setText(0, "Layers and Groups") layers = iface.legendInterface().layers() for layer in layers: print layer.type() if layer.id() not in groupedLayers: item = TreeLayerItem(layer, self.layersTree) self.layersItem.addChild(item) else: groupName = groupedLayers[layer.id()] try: groupLayers = groups[groupName] except KeyError: continue item = TreeGroupItem(groupName, groupLayers, self.layersTree) self.layersItem.addChild(item) del groups[groupName] self.layersTree.addTopLevelItem(self.layersItem) self.layersTree.expandAll() self.layersTree.resizeColumnToContents(0) self.layersTree.resizeColumnToContents(1)
def groupify(self): with self.groupAssignmentLock: self.layersToBeGrouped = len(self.layerList) self.getGeneratedGroup() registryAddedLayers = QgsMapLayerRegistry.instance().addMapLayers( self.layerList, False) for item in registryAddedLayers: if item not in self.layerList: #print("****WARNING: A LAYER WAS NOT ADDED TO THE REGISTRY: "+str(item)+" --- ID : "+item.id()) self.errorCount = self.errorCount + 1 pass self.correctlyRegisteredLayers = sorted( self.layerList, key=lambda layer: layer.name()) for layer in self.correctlyRegisteredLayers: self.generatedGroup.addLayer(layer) iface.legendInterface().setLayerVisible(layer, False) #We combine the group extents so all the layers are zoomed #equally on play. extent = QgsRectangle() extent.setMinimal() for child in self.generatedGroup.children(): if isinstance(child, QgsLayerTreeLayer): extent.combineExtentWith(child.layer().extent()) iface.mapCanvas().setExtent(extent) iface.mapCanvas().refresh() if self.errorCount > 0: self.errorsFound.emit(self.errorCount)
def style_prod_traj_trend(outfile): # Trends layer layer_ndvi = iface.addRasterLayer(outfile, 'Productivity trajectory trend') provider = layer_ndvi.dataProvider() # Set a colormap centred on zero, going to the extreme value significant to # three figures stats = provider.bandStatistics(1, QgsRasterBandStats.All) #TODO: Make this a 2% stretch rather than simple linear stretch extreme = get_extreme(stats.minimumValue, stats.maximumValue) fcn = QgsColorRampShader() fcn.setColorRampType(QgsColorRampShader.INTERPOLATED) lst = [ QgsColorRampShader.ColorRampItem(-extreme, QtGui.QColor(153, 51, 4), '-{} (declining)'.format(extreme)), QgsColorRampShader.ColorRampItem(0, QtGui.QColor(246, 246, 234), '0 (stable)'), QgsColorRampShader.ColorRampItem(extreme, QtGui.QColor(0, 140, 121), '{} (increasing)'.format(extreme)) ] fcn.setColorRampItemList(lst) shader = QgsRasterShader() shader.setRasterShaderFunction(fcn) pseudoRenderer = QgsSingleBandPseudoColorRenderer( layer_ndvi.dataProvider(), 1, shader) layer_ndvi.setRenderer(pseudoRenderer) layer_ndvi.triggerRepaint() iface.legendInterface().refreshLayerSymbology(layer_ndvi)
def style_prod_state_emerg(outfile): # Significance layer layer = iface.addRasterLayer(outfile, 'Productivity state (emerging)') fcn = QgsColorRampShader() fcn.setColorRampType(QgsColorRampShader.EXACT) lst = [ QgsColorRampShader.ColorRampItem(-2, QtGui.QColor(0, 0, 0), 'No data'), QgsColorRampShader.ColorRampItem(-1, QtGui.QColor(153, 51, 4), 'Significant decrease'), QgsColorRampShader.ColorRampItem(0, QtGui.QColor(246, 246, 234), 'No significant change'), QgsColorRampShader.ColorRampItem(1, QtGui.QColor(0, 140, 121), 'Significant increase'), QgsColorRampShader.ColorRampItem(2, QtGui.QColor(58, 77, 214), 'Water'), QgsColorRampShader.ColorRampItem(3, QtGui.QColor(192, 105, 223), 'Urban land cover') ] fcn.setColorRampItemList(lst) shader = QgsRasterShader() shader.setRasterShaderFunction(fcn) pseudoRenderer = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1, shader) layer.setRenderer(pseudoRenderer) layer.triggerRepaint() iface.legendInterface().refreshLayerSymbology(layer)
def onStyle(self): """Apply new style for currently selected layer. Show error message dialog on failure. """ layer = self.getActiveLayer() if not layer: # no layer is currently selected, nothing to do return # apply new style on currently selected layer try: layer.loadNamedStyle(self.stylePath()) except SafecastError as e: # print error message on failure QMessageBox.critical( None, self.tr("Error"), self.tr("Failed to apply style: {0}").format(e), QMessageBox.Abort) # If caching is enabled, a simple canvas refresh might not be sufficient # to trigger a redraw and you must clear the cached image for the layer if iface.mapCanvas().isCachingEnabled(): layer.setCacheImage(None) else: iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(layer)
def style_land_cover_lc_target(outfile): layer_lc_target = iface.addRasterLayer(outfile, 'Land cover (target)') fcn = QgsColorRampShader() fcn.setColorRampType(QgsColorRampShader.EXACT) lst = [ QgsColorRampShader.ColorRampItem(1, QtGui.QColor('#a50f15'), 'Cropland'), QgsColorRampShader.ColorRampItem(2, QtGui.QColor('#006d2c'), 'Forest land'), QgsColorRampShader.ColorRampItem(3, QtGui.QColor('#d8d800'), 'Grassland'), QgsColorRampShader.ColorRampItem(4, QtGui.QColor('#08519c'), 'Wetlands'), QgsColorRampShader.ColorRampItem(5, QtGui.QColor('#54278f'), 'Settlements'), QgsColorRampShader.ColorRampItem(6, QtGui.QColor('#252525'), 'Other land') ] fcn.setColorRampItemList(lst) shader = QgsRasterShader() shader.setRasterShaderFunction(fcn) pseudoRenderer = QgsSingleBandPseudoColorRenderer( layer_lc_target.dataProvider(), 1, shader) layer_lc_target.setRenderer(pseudoRenderer) layer_lc_target.triggerRepaint() iface.legendInterface().refreshLayerSymbology(layer_lc_target)
def setLayerRGB(layer, r, g, b): renderer = QgsMultiBandColorRenderer(layer.dataProvider(), r + 1, g + 1, b + 1) layer.setRenderer(renderer) layer.setDefaultContrastEnhancement() layer.triggerRepaint() iface.legendInterface().refreshLayerSymbology(layer)
def accept(self): AlgorithmDialog.accept(self) # handling output when to be loaded for out in self.alg.outputs: if isinstance(out, (OutputRaster)) and out.open: layer = dataobjects.getObjectFromUri(out.value) if layer: # test if an explicite name has been given for the layer name = self.alg.name if (out.name in self.alg.namedOutputs): name = self.alg.namedOutputs[out.name] layer.setName(name) ChloeUtils.setLayerSymbology(layer, 'continuous.qml') iface.legendInterface().refreshLayerSymbology(layer) elif isinstance(out, (OutputTable)) and out.open: table = dataobjects.getObjectFromUri(out.value) if table: name = self.alg.name + '_csv' if (out.name in self.alg.namedOutputs): name = self.alg.namedOutputs[out.name] table.setName(name) if isinstance(out, OutputDirectory): # === import all asc for multi algorithm open_all_asc = self.alg.getParameterValue('OPEN_ALL_ASC') output_dir = self.alg.getOutputValue('OUTPUT_DIR').encode('utf-8') if self.alg.open_all_asc: for file in glob.glob(output_dir+"/*.asc"): load_it = QgsRasterLayer(file, os.path.splitext(os.path.basename(file))[0]) QgsMapLayerRegistry.instance().addMapLayer(load_it) ChloeUtils.setLayerSymbology(load_it, 'continuous.qml') self.close()
def style_land_cover_land_deg(outfile): layer_deg = iface.addRasterLayer( outfile, QtGui.QApplication.translate('LDMPPlugin', 'Land cover (degradation)')) if not layer_deg.isValid(): log('Failed to add layer') return None fcn = QgsColorRampShader() fcn.setColorRampType(QgsColorRampShader.EXACT) #TODO The GPG doesn't seem to allow for possibility of improvement...? lst = [ QgsColorRampShader.ColorRampItem( -1, QtGui.QColor(153, 51, 4), QtGui.QApplication.translate('LDMPPlugin', 'Degradation')), QgsColorRampShader.ColorRampItem( 0, QtGui.QColor(246, 246, 234), QtGui.QApplication.translate('LDMPPlugin', 'Stable')), QgsColorRampShader.ColorRampItem( 1, QtGui.QColor(0, 140, 121), QtGui.QApplication.translate('LDMPPlugin', 'Improvement')) ] fcn.setColorRampItemList(lst) shader = QgsRasterShader() shader.setRasterShaderFunction(fcn) pseudoRenderer = QgsSingleBandPseudoColorRenderer(layer_deg.dataProvider(), 1, shader) layer_deg.setRenderer(pseudoRenderer) layer_deg.triggerRepaint() iface.legendInterface().refreshLayerSymbology(layer_deg)
def addStyle(self, pglayername, vlayer, uri): """Add style to layer. Assumes tablename if stylename :param pglayername: layer to query for in public.layer_styles :param vlayer: layer to apply style for :return: True if no error """ qmlfile = os.path.join(JupiterAux.pluginpath(), 'style', 'borehole.qml') msg, styleloaded = vlayer.loadNamedStyle(qmlfile, True) iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(vlayer) vlayer.triggerRepaint() return True JupiterAux.log_info(u'Loading default style from db...') db = JupiterDb() styleqml = db.get_style(pglayername) if styleqml: #vlayer.applyNamedStyle(pglayername) styleok = vlayer.loadNamedStyle(styleqml, True) iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(vlayer) vlayer.triggerRepaint() JupiterAux.log_info(u'Style applied to: {}'.format(pglayername)) else: JupiterAux.log_info( u'Table {} has no default style in db'.format(pglayername)) return True
def change_color(): active_layer = iface.activeLayer() renderer = active_layer.rendererV2() symbol = renderer.symbol() symbol.setColor(QColor(Qt.red)) iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(active_layer)
def load(self, crs, idSubgrupo = None): vlayerQml = os.path.join(self.abstractDb.getQmlDir(), self.qmlName+'.qml') database = self.abstractDb.db.databaseName() vlayer = iface.addVectorLayer(self.uri.uri(), self.layer_name, self.provider) if not vlayer: return None vlayer.setCrs(crs) if self.schema <> 'views': vlayer.loadNamedStyle(vlayerQml, False) attrList = vlayer.pendingFields() for field in attrList: i = vlayer.fieldNameIndex(field.name()) if vlayer.editorWidgetV2(i) == 'ValueRelation': groupList = iface.legendInterface().groups() groupRelationshipList = iface.legendInterface().groupLayerRelationship() filename = os.path.basename(database).split('.')[0] if filename not in groupList: idx = iface.legendInterface().addGroup(filename, True,-1) domainIdGroup = iface.legendInterface().addGroup(self.tr("Dominios"), True, idx) else: idx = groupList.index(filename) if "Dominios" not in groupList[idx::]: domainIdGroup = iface.legendInterface().addGroup(self.tr("Dominios"), True, idx) else: domainIdGroup = groupList[idx::].index("Dominios") valueRelationDict = vlayer.editorWidgetV2Config(i) domainTableName = valueRelationDict['Layer'] loadedLayers = iface.legendInterface().layers() domainLoaded = False for ll in loadedLayers: if ll.name() == domainTableName: candidateUri = QgsDataSourceURI(ll.dataProvider().dataSourceUri()) if database == candidateUri.database(): domainLoaded = True domLayer = ll if not domainLoaded: uri = QgsDataSourceURI() uri.setDatabase(database) uri.setDataSource('', 'dominios_'+domainTableName, None) #TODO Load domain layer into a group domLayer = iface.addVectorLayer(uri.uri(), domainTableName, self.provider) iface.legendInterface().moveLayer(domLayer, domainIdGroup) valueRelationDict['Layer'] = domLayer.id() vlayer.setEditorWidgetV2Config(i,valueRelationDict) self.qmlLoaded.emit() iface.legendInterface().moveLayer(vlayer, idSubgrupo) if not vlayer.isValid(): QgsMessageLog.logMessage(vlayer.error().summary(), "DSG Tools Plugin", QgsMessageLog.CRITICAL) return vlayer
def prepareLoad(self): dbName = self.abstractDb.getDatabaseName() groupList = iface.legendInterface().groups() if dbName in groupList: return groupList.index(dbName) else: parentTreeNode = iface.legendInterface().addGroup(self.abstractDb.getDatabaseName(), -1) return parentTreeNode
def processAlgorithm(self, progress): filename = self.getParameterValue(self.INPUT) layer = dataobjects.getObjectFromUri(filename) style = self.getParameterValue(self.STYLE) layer.loadNamedStyle(style) self.setOutputValue(self.OUTPUT, filename) iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(layer)
def style_prod_traj_trend(outfile): # Trends layer layer_ndvi = iface.addRasterLayer( outfile, QtGui.QApplication.translate( 'LDMPPlugin', 'Productivity trajectory trend\n(slope of NDVI * 10000)')) if not layer_ndvi.isValid(): log('Failed to add layer') return None provider = layer_ndvi.dataProvider() # Set a colormap centred on zero, going to the extreme value significant to # three figures (after a 2 percent stretch) ds = gdal.Open(outfile) band1 = np.array(ds.GetRasterBand(1).ReadAsArray()) band1[band1 >= 9997] = 0 ds = None cutoffs = np.percentile(band1, [2, 98]) extreme = get_extreme(cutoffs[0], cutoffs[1]) fcn = QgsColorRampShader() fcn.setColorRampType(QgsColorRampShader.INTERPOLATED) lst = [ QgsColorRampShader.ColorRampItem( -extreme, QtGui.QColor(153, 51, 4), QtGui.QApplication.translate('LDMPPlugin', '-{} (declining)').format(extreme)), QgsColorRampShader.ColorRampItem( 0, QtGui.QColor(246, 246, 234), QtGui.QApplication.translate('LDMPPlugin', '0 (stable)')), QgsColorRampShader.ColorRampItem( extreme, QtGui.QColor(0, 140, 121), QtGui.QApplication.translate('LDMPPlugin', '{} (increasing)').format(extreme)), QgsColorRampShader.ColorRampItem( 9997, QtGui.QColor(0, 0, 0), QtGui.QApplication.translate('LDMPPlugin', 'No data')), QgsColorRampShader.ColorRampItem( 9998, QtGui.QColor(58, 77, 214), QtGui.QApplication.translate('LDMPPlugin', 'Water')), QgsColorRampShader.ColorRampItem( 9999, QtGui.QColor(192, 105, 223), QtGui.QApplication.translate('LDMPPlugin', 'Urban land cover')) ] fcn.setColorRampItemList(lst) shader = QgsRasterShader() shader.setRasterShaderFunction(fcn) pseudoRenderer = QgsSingleBandPseudoColorRenderer( layer_ndvi.dataProvider(), 1, shader) layer_ndvi.setRenderer(pseudoRenderer) layer_ndvi.triggerRepaint() iface.legendInterface().refreshLayerSymbology(layer_ndvi)
def load(fileName, name=None, crs=None, style=None, isRaster=False): """Loads a layer/table into the current project, given its file. """ if fileName is None: return prjSetting = None settings = QSettings() if crs is not None: prjSetting = settings.value('/Projections/defaultBehaviour') settings.setValue('/Projections/defaultBehaviour', '') if name is None: name = os.path.split(fileName)[1] if isRaster: qgslayer = QgsRasterLayer(fileName, name) if qgslayer.isValid(): if crs is not None and qgslayer.crs() is None: qgslayer.setCrs(crs, False) if style is None: style = ProcessingConfig.getSetting( ProcessingConfig.RASTER_STYLE) qgslayer.loadNamedStyle(style) QgsMapLayerRegistry.instance().addMapLayers([qgslayer]) iface.legendInterface().refreshLayerSymbology(qgslayer) else: if prjSetting: settings.setValue('/Projections/defaultBehaviour', prjSetting) raise RuntimeError( 'Could not load layer: ' + unicode(fileName) + '\nCheck the processing framework log to look for errors') else: qgslayer = QgsVectorLayer(fileName, name, 'ogr') if qgslayer.isValid(): if crs is not None and qgslayer.crs() is None: qgslayer.setCrs(crs, False) if style is None: if qgslayer.geometryType() == QGis.Point: style = ProcessingConfig.getSetting( ProcessingConfig.VECTOR_POINT_STYLE) elif qgslayer.geometryType() == QGis.Line: style = ProcessingConfig.getSetting( ProcessingConfig.VECTOR_LINE_STYLE) else: style = ProcessingConfig.getSetting( ProcessingConfig.VECTOR_POLYGON_STYLE) qgslayer.loadNamedStyle(style) QgsMapLayerRegistry.instance().addMapLayers([qgslayer]) if prjSetting: settings.setValue('/Projections/defaultBehaviour', prjSetting) return qgslayer
def loadLayer(self, inputParam, idSubgrupo, loadedLayers, useInheritance, useQml, uniqueLoad, stylePath, domainDict, multiColumnsDict, domLayerDict, edgvVersion, geomColumn = None, isView = False): """ Loads a layer :param lyrName: Layer nmae :param loadedLayers: list of loaded layers :param idSubgrupo: sub group id :param uniqueLoad: boolean to mark if the layer should only be loaded once :param stylePath: path to the styles used :param domLayerDict: domain dictionary :return: """ if isinstance(inputParam,dict): lyrName = inputParam['lyrName'] schema = inputParam['tableSchema'] geomColumn = inputParam['geom'] tableName = inputParam['tableName'] srid = self.geomDict['tablePerspective'][tableName]['srid'] else: lyrName = inputParam tableName = self.geomDict['tablePerspective'][lyrName]['tableName'] schema = self.geomDict['tablePerspective'][lyrName]['schema'] geomColumn = self.geomDict['tablePerspective'][lyrName]['geometryColumn'] srid = self.geomDict['tablePerspective'][lyrName]['srid'] if uniqueLoad: lyr = self.checkLoaded(tableName, loadedLayers) if lyr: return lyr fullName = '''"{0}"."{1}"'''.format(schema, tableName) pkColumn = self.abstractDb.getPrimaryKeyColumn(fullName) if useInheritance or self.abstractDb.getDatabaseVersion() in ['3.0', 'Non_Edgv']: sql = '' else: sql = self.abstractDb.gen.loadLayerFromDatabase(fullName, pkColumn=pkColumn) self.setDataSource(schema, tableName, geomColumn, sql, pkColumn=pkColumn) vlayer = iface.addVectorLayer(self.uri.uri(), tableName, self.provider) crs = QgsCoordinateReferenceSystem(int(srid), QgsCoordinateReferenceSystem.EpsgCrsId) if vlayer: vlayer.setCrs(crs) if useQml: vlayer = self.setDomainsAndRestrictionsWithQml(vlayer) else: vlayer = self.setDomainsAndRestrictions(vlayer, tableName, domainDict, multiColumnsDict, domLayerDict) if stylePath: fullPath = self.getStyle(stylePath, tableName) if fullPath: vlayer.applyNamedStyle(fullPath) iface.legendInterface().moveLayer(vlayer, idSubgrupo) if not vlayer.isValid(): QgsMessageLog.logMessage(vlayer.error().summary(), "DSG Tools Plugin", QgsMessageLog.CRITICAL) vlayer = self.createMeasureColumn(vlayer) return vlayer
def processAlgorithm(self, progress): filename = self.getParameterValue(self.INPUT) style = self.getParameterValue(self.STYLE) dataobjects.resetLoadedLayers() layer = dataobjects.getObjectFromUri(filename, False) if layer is None: dataobjects.load(filename, os.path.basename(filename), style=style) else: layer.loadNamedStyle(style) layer.triggerRepaint() iface.legendInterface().refreshLayerSymbology(layer) self.setOutputValue(self.OUTPUT, filename)
def processAlgorithm(self, progress): filename = self.getParameterValue(self.INPUT) layer = dataobjects.getObjectFromUri(filename) style = self.getParameterValue(self.STYLE) layer = dataobjects.getObjectFromUri(filename, False) if layer is None: dataobjects.load(filename, os.path.basename(filename), style=style) self.getOutputFromName(self.OUTPUT).open = False else: layer.loadNamedStyle(style) iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(layer)
def processAlgorithm(self, progress): filename = self.getParameterValue(self.INPUT) style = self.getParameterValue(self.STYLE) layer = dataobjects.getObjectFromUri(filename, False) if layer is None: dataobjects.load(filename, os.path.basename(filename), style=style) self.getOutputFromName(self.OUTPUT).open = False else: layer.loadNamedStyle(style) iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(layer) layer.triggerRepaint()
def processAlgorithm(self, progress): filename = self.getParameterValue(self.INPUT) layer = dataobjects.getObjectFromUri(filename) style = self.getParameterValue(self.STYLE) with open(style) as f: xml = "".join(f.readlines()) d = QDomDocument(); d.setContent(xml); n = d.firstChild(); layer.readSymbology(n, '') self.setOutputValue(self.OUTPUT, filename) iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(layer)
def load(fileName, name=None, crs=None, style=None): """Loads a layer/table into the current project, given its file. """ if fileName is None: return prjSetting = None settings = QSettings() if crs is not None: prjSetting = settings.value('/Projections/defaultBehaviour') settings.setValue('/Projections/defaultBehaviour', '') if name is None: name = path.split(fileName)[1] qgslayer = QgsVectorLayer(fileName, name, 'ogr') if qgslayer.isValid(): if crs is not None and qgslayer.crs() is None: qgslayer.setCrs(crs, False) if style is None: if qgslayer.geometryType == 0: style = ProcessingConfig.getSetting( ProcessingConfig.VECTOR_POINT_STYLE) elif qgslayer.geometryType == 1: style = ProcessingConfig.getSetting( ProcessingConfig.VECTOR_LINE_STYLE) else: style = ProcessingConfig.getSetting( ProcessingConfig.VECTOR_POLYGON_STYLE) qgslayer.loadNamedStyle(style) QgsMapLayerRegistry.instance().addMapLayers([qgslayer]) else: qgslayer = QgsRasterLayer(fileName, name) if qgslayer.isValid(): if crs is not None and qgslayer.crs() is None: qgslayer.setCrs(crs, False) if style is None: style = ProcessingConfig.getSetting( ProcessingConfig.RASTER_STYLE) qgslayer.loadNamedStyle(style) QgsMapLayerRegistry.instance().addMapLayers([qgslayer]) iface.legendInterface().refreshLayerSymbology(qgslayer) else: if prjSetting: settings.setValue('/Projections/defaultBehaviour', prjSetting) raise RuntimeError( 'Could not load layer: ' + unicode(fileName) + '\nCheck the procesing framework log to look for errors') if prjSetting: settings.setValue('/Projections/defaultBehaviour', prjSetting) return qgslayer
def processAlgorithm(self, progress): filename = self.getParameterValue(self.INPUT) layer = dataobjects.getObjectFromUri(filename) style = self.getParameterValue(self.STYLE) with open(style) as f: xml = "".join(f.readlines()) d = QDomDocument() d.setContent(xml) n = d.firstChild() layer.readSymbology(n, '') self.setOutputValue(self.OUTPUT, filename) iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(layer)
def _onNewLayerGroupGenerated(self, groupObject, layerList): """ Currently only used to show the first image of a newly created group so the user knows when the operation finishes. :param groupObject: The legend group object which was created. :type groupObject: QgsLayerTreeGrupo :param layerList: The layers which are held in the group object. :type layerList: [QgsLayer] """ if (layerList[0]).isValid() is True: iface.legendInterface().setLayerVisible(layerList[0], True) else: self.postInformationMessageToUser("There was a problem showing a layer.")
def updateColorMap(self, ds): """ update color map of the current data set given the settings """ if not ds.custom["c_basic"]: cm = ds.custom["c_advancedColorMap"] else: cm = self._colorMapBasic(ds) if not cm: return cm.alpha = ds.custom["c_alpha"] ds.config["c_colormap"] = cm iface.legendInterface().refreshLayerSymbology(self)
def loadLayer(self, inputParam, loadedLayers, idSubgrupo, uniqueLoad, stylePath, domLayerDict): """ Loads a layer :param lyrName: Layer nmae :param loadedLayers: list of loaded layers :param idSubgrupo: sub group id :param uniqueLoad: boolean to mark if the layer should only be loaded once :param stylePath: path to the styles used :param domLayerDict: domain dictionary :return: """ if isinstance(inputParam, dict): lyrName = inputParam['lyrName'] schema = inputParam['tableSchema'] geomColumn = inputParam['geom'] tableName = inputParam['tableName'] srid = self.geomDict['tablePerspective'][tableName]['srid'] else: lyrName = inputParam tableName = self.geomDict['tablePerspective'][lyrName]['tableName'] schema = self.geomDict['tablePerspective'][lyrName]['schema'] geomColumn = self.geomDict['tablePerspective'][lyrName][ 'geometryColumn'] srid = self.geomDict['tablePerspective'][lyrName]['srid'] if uniqueLoad: lyr = self.checkLoaded(lyrName, loadedLayers) if lyr: return lyr self.setDataSource('', '_'.join([schema, tableName]), geomColumn, '') vlayer = iface.addVectorLayer(self.uri.uri(), tableName, self.provider) crs = QgsCoordinateReferenceSystem( int(srid), QgsCoordinateReferenceSystem.EpsgCrsId) vlayer.setCrs(crs) vlayer = self.setDomainsAndRestrictionsWithQml(vlayer) vlayer = self.setMulti(vlayer, domLayerDict) if stylePath: fullPath = self.getStyle(stylePath, tableName) if fullPath: vlayer.applyNamedStyle(fullPath) iface.legendInterface().moveLayer(vlayer, idSubgrupo) if not vlayer.isValid(): QgsMessageLog.logMessage(vlayer.error().summary(), "DSG Tools Plugin", QgsMessageLog.CRITICAL) vlayer = self.createMeasureColumn(vlayer) return vlayer
def get_bounding_box(self): """ Get the geometry of the bbox in WGS84 @rtype: QGsRectangle in WGS84 @return: the extent of the map canvas """ # If mapCanvas is checked if self.radioButton_extentMapCanvas.isChecked(): geom_extent = iface.mapCanvas().extent() if hasattr(iface.mapCanvas(), "mapSettings"): source_crs = iface.mapCanvas().mapSettings().destinationCrs() else: source_crs = iface.mapCanvas().mapRenderer().destinationCrs() else: # Else if a layer is checked index = self.comboBox_extentLayer.currentIndex() layer_id = self.comboBox_extentLayer.itemData(index) layers = iface.legendInterface().layers() for layer in layers: if layer.id() == layer_id: geom_extent = layer.extent() source_crs = layer.crs() break else: # the layer could be deleted before layer_name = self.comboBox_extentLayer.itemText(index) raise NoLayerException(suffix=layer_name) geom_extent = QgsGeometry.fromRect(geom_extent) epsg_4326 = QgsCoordinateReferenceSystem('EPSG:4326') crs_transform = QgsCoordinateTransform(source_crs, epsg_4326) geom_extent.transform(crs_transform) return geom_extent.boundingBox()
def AddRasterLayer(theRaster): # Loop over all the parent group layers for this raster # ensuring they are in the tree in correct, nested order parentGroup = None if len(theRaster.data()) > 0: for aGroup in theRaster.data()["group_layers"]: parentGroup = AddGroup(aGroup, parentGroup) assert parentGroup, "All rasters should be nested and so parentGroup should be instantiated by now" # Only add the layer if it's not already in the registry if not QgsMapLayerRegistry.instance().mapLayersByName(theRaster.text()): rOutput = QgsRasterLayer(theRaster.data()["filepath"], theRaster.text()) QgsMapLayerRegistry.instance().addMapLayer(rOutput, False) parentGroup.addLayer(rOutput) # call Konrad's symbology method here using data()["symbology"] RasterSymbolizer(rOutput).render_GCD(theRaster.data()["symbology"]) if theRaster.data()["symbology"].lower() == "dem": demPath, demExtension = os.path.splitext( theRaster.data()["filepath"]) hillshadePath = demPath + "HS" + demExtension if os.path.isfile(hillshadePath): rHillshade = QgsRasterLayer(hillshadePath, "Hillshade") QgsMapLayerRegistry.instance().addMapLayer(rHillshade, False) lHillshade = parentGroup.addLayer(rHillshade) legend = iface.legendInterface() legend.setLayerExpanded(rHillshade, False) # if the layer already exists trigger a refresh else: print "REFRESJH" QgsMapLayerRegistry.instance().mapLayersByName(theRaster.text())[0].triggerRepaint()
def initGui(self): # define icons self.undoEnabledIcon=icon = QIcon(os.path.dirname(__file__) + "/icons/undo.png") self.undoDisabledIcon=icon = QIcon(os.path.dirname(__file__) + "/icons/undo-disabled.png") self.redoEnabledIcon=icon = QIcon(os.path.dirname(__file__) + "/icons/redo.png") self.redoDisabledIcon=icon = QIcon(os.path.dirname(__file__) + "/icons/redo-disabled.png") #define undo and redo actions self.uaction = QAction(self.undoDisabledIcon,"undo", self.iface.mainWindow()) self.uaction.triggered.connect(self.undoAction) self.uaction.setDisabled(True) self.raction = QAction(self.redoDisabledIcon,"redo", self.iface.mainWindow()) self.raction.triggered.connect(self.redoAction) self.raction.setDisabled(True) #define signals connections self.mapLayerRegistry = QgsMapLayerRegistry.instance() self.mapLayerRegistry.layersWillBeRemoved.connect(self.layersRemovedAction) self.mapLayerRegistry.legendLayersAdded.connect(self.layersAddedAction) self.iface.legendInterface().currentLayerChanged.connect(self.currentLayerChanges) # Add toolbar button and menu item self.toolBar = self.iface.addToolBar("Undo properties changes") self.toolBar.setObjectName("Undo properties changes") self.toolBar.addAction(self.uaction) self.toolBar.addAction(self.raction) self.iface.addPluginToMenu(u"&undo properties changes", self.uaction) self.iface.addPluginToMenu(u"&undo properties changes", self.raction) # register currently loaded layers self.layersAddedAction(iface.legendInterface().layers())
def get_editable_layers(): """Liste der Tabellen, für die in der Layerliste der Status editable aktiviert ist. Dient dazu, sicherzustellen, dass keine Datenbankoperationen auf editierbare Layer zugreifen.""" elayers = set([]) # Zuerst leere Liste anlegen layers = iface.legendInterface().layers() # logger.debug(u'Layerliste erstellt') if len(layers) > 0: # über Layer iterieren for lay in layers: lyattr = {} # Attributstring für Layer splitten for le in lay.source().split(u' '): if u'=' in le: key, value = le.split(u'=', 1) lyattr[key] = value.strip(u'"').strip(u"'") # Falls Abschnitte 'table' und 'dbname' existieren, handelt es sich um einen Datenbank-Layer if u'table' in lyattr and u'dbname' in lyattr: if lay.isEditable(): elayers.add(lyattr['table']) return elayers
def _onNewLayerGroupGenerated(self, groupObject, layerList): """ Currently only used to show the first image of a newly created group so the user knows when the operation finishes. :param groupObject: The legend group object which was created. :type groupObject: QgsLayerTreeGrupo :param layerList: The layers which are held in the group object. :type layerList: [QgsLayer] """ if (layerList[0]).isValid(): iface.legendInterface().setLayerVisible(layerList[0], True) else: self.postInformationMessageToUser( "There was a problem showing a layer.")
def __init__(self, layer, tree): QTreeWidgetItem.__init__(self) self.layer = layer self.setText(0, layer.name()) self.setIcon(0, self.layerIcon) if iface.legendInterface().isLayerVisible(layer): self.setCheckState(0, Qt.Checked) else: self.setCheckState(0, Qt.Unchecked) if layer.type() == layer.VectorLayer: self.popupItem = QTreeWidgetItem(self) self.popupItem.setText(0, "Info popup content") self.combo = QComboBox() options = ["No popup", "Show all attributes"] options.extend(["FIELD:" + f.name() for f in self.layer.pendingFields()]) for option in options: self.combo.addItem(option) self.addChild(self.popupItem) tree.setItemWidget(self.popupItem, 1, self.combo) self.visibleItem = QTreeWidgetItem(self) self.visibleCheck = QCheckBox() self.visibleCheck.setChecked(True) self.visibleItem.setText(0, "Visible") self.addChild(self.visibleItem) tree.setItemWidget(self.visibleItem, 1, self.visibleCheck)
def checkBeforeOpeningParametersDialog1(self): # self.parameters[0] # ESCAPED_NEWLINE', 'NEWLINE', '__doc__', '__init__', '__module__', '__str__', 'default', 'description' #'evaluateExpressions', 'getAsScriptCode', 'getValueAsCommandLineParameter', 'hidden', 'isAdvanced', 'multiline', 'name', 'optional', 'setDefaultValue', 'setValue', 'todict', 'tr', 'typeName', 'value' #param.setValue(QgsExpressionContextUtils.projectScope().variable(self.PROP_1)) self.parameters = [] self.param_info = {} layers = iface.legendInterface().selectedLayers() for layer in layers: for [prop_name] in self.PROPS: self.addParameter( ParameterString( #name='', description='', default=None, multiline=False, optional=False, evaluateExpressions=False layer.id() + u"/" + prop_name #name , layer.name() + u" / " + prop_name #desc , layer.customProperty(prop_name) #def , False #mline , True #opt #, False #for 2.14 )) self.param_info[layer.id() + u"/" + prop_name] = [layer, prop_name]
def __init__(self, layer, tree): QTreeWidgetItem.__init__(self) self.layer = layer self.setText(0, layer.name()) self.setIcon(0, self.layerIcon) if iface.legendInterface().isLayerVisible(layer): self.setCheckState(0, Qt.Checked) else: self.setCheckState(0, Qt.Unchecked) if layer.type() == layer.VectorLayer: self.popupItem = QTreeWidgetItem(self) self.popupItem.setText(0, "Info popup content") self.combo = QComboBox() options = ["No popup", "Show all attributes"] options.extend( ["FIELD:" + f.name() for f in self.layer.pendingFields()]) for option in options: self.combo.addItem(option) self.addChild(self.popupItem) tree.setItemWidget(self.popupItem, 1, self.combo) self.visibleItem = QTreeWidgetItem(self) self.visibleCheck = QCheckBox() self.visibleCheck.setChecked(True) self.visibleItem.setText(0, "Visible") self.addChild(self.visibleItem) tree.setItemWidget(self.visibleItem, 1, self.visibleCheck)
def borrarRegistro(self): registryLayers = QgsMapLayerRegistry.instance().mapLayers().keys() legendLayers = [ layer.id() for layer in iface.legendInterface().layers() ] QgsMapLayerRegistry.instance().removeMapLayers(registryLayers) QgsMapLayerRegistry.instance().removeMapLayers(legendLayers)
def get_database_QKan(silent = False): """Ermittlung der aktuellen QpatiaLite-Datenbank aus den geladenen Layern""" database_QKan = u'' epsg = u'' layers = iface.legendInterface().layers() # logger.debug(u'Layerliste erstellt') logger.error(u'Keine Layer vorhanden...') if len(layers) == 0 and not silent: iface.mainWindow().statusBar().clearMessage() iface.messageBar().pushMessage(u"Fehler: ", u"Kein QKan-Projekt geladen!", level=QgsMessageBar.CRITICAL) QgsMessageLog.logMessage(u"\nKein QKan-Projekt geladen!", level=QgsMessageLog.CRITICAL) return False, False # Über Layer iterieren for lay in layers: lyattr = {} # Attributstring für Layer splitten split = re.compile("['\"] ").split(lay.source()) for le in split: if '=' in le: key, value = le.split('=', 1) lyattr[key] = value.strip('"').strip('\'') # Falls Abschnitte 'table' und 'dbname' existieren, handelt es sich um einen Datenbank-Layer if 'table' in lyattr and 'dbname' in lyattr: if lyattr['table'] == 'flaechen': if database_QKan == '': database_QKan = lyattr['dbname'] epsg = str(int(lay.crs().postgisSrid())) elif database_QKan != lyattr['dbname']: logger.warning(u'Abweichende Datenbankanbindung gefunden: {}'.format(lyattr['dbname'])) return False, False # Im Projekt sind mehrere Sqlite-Datenbanken eingebungen... return database_QKan, epsg
def get_raster_layer_list(iface, visibility='all'): """ Iterate over all layers and return a list of the currently visible WMS-files. :param iface: The Qgis-interface that will be accessed :type iface: QgisInterface :return: A list containing raster layers with the given visibility-value :rtype: list """ active_raster_layers = [] layer_list = QgsMapLayerRegistry.instance().mapLayers() interface = iface.legendInterface() if visibility == 'visible': for key, layer in layer_list.iteritems(): if layer.type() == QgsMapLayer.RasterLayer and interface.isLayerVisible(layer): active_raster_layers.append(layer) return active_raster_layers elif visibility == 'invisible': for key, layer in layer_list.iteritems(): if layer.type() == QgsMapLayer.RasterLayer and not interface.isLayerVisible(layer): active_raster_layers.append(layer) return active_raster_layers else: for key, layer in layer_list.iteritems(): if layer.type() == QgsMapLayer.RasterLayer: active_raster_layers.append(layer) return active_raster_layers
def all_legend_layers(): legend = iface.legendInterface() layers = legend.layers() list_layers = [] for each_layer in layers: list_layers.append(each_layer.name()) return list_layers
def get_layers(): global schema_name, layer_other_x_sector layers = iface.legendInterface().layers() if len(layers) == 0: return # Initialize variables layer_other_x_sector = None table_other_x_sector = dao_controller.getSettingsParameter('database', 'table_other_x_sector') table_other_x_sector = '"'+schema_name+'"."'+table_other_x_sector+'"' # Iterate over all layers to get the ones set in config file for cur_layer in layers: uri = cur_layer.dataProvider().dataSourceUri().lower() pos_ini = uri.find('table=') pos_fi = uri.find('" ') uri_table = uri if pos_ini <> -1 and pos_fi <> -1: uri_table = uri[pos_ini+6:pos_fi+1] if table_other_x_sector == uri_table: layer_other_x_sector = cur_layer if layer_other_x_sector is None: utils_pavements.showWarning("No s'ha trobat la capa: "+table_other_x_sector) return
def db_view_sel(self,lista): # sele="Nomefile IN ('G994_000100') AND ((EXT='') or (Ext is Null))" # index=0 # for group in iface.legendInterface().groupLayerRelationship() : # if group[0]=="Catasto": # index+=1 # if index==0: # db_view_all(self,lista) # else: # layers = QgsMapLayerRegistry.instance().mapLayers() # for name, layer in layers.iteritems(): # layerType = layer.type() # if layerType == QgsMapLayer.VectorLayer: # layer.setSubsetString(lista) index = 0 for group in iface.legendInterface().groupLayerRelationship(): if group[0] == "Catasto": index+=1 gruppo = group[1] layers = QgsMapLayerRegistry.instance().mapLayers() for name, layer in layers.iteritems(): if name in gruppo: if layer.type() == QgsMapLayer.VectorLayer: layer.setSubsetString(lista) if index == 0: db_view_all(self, lista) db_view_change_style()
def updateInputLayer(self): """ create the input layer and update available options """ if self.mode != self.ASK_FOR_INPUT_MODE: return self.deleteInputLayer() index = self.cboInputLayer.currentIndex() if index < 0: filename = self.cboInputLayer.currentText() if filename == "": return False layerName = QFileInfo(filename).completeBaseName() layer = qgis.core.QgsVectorLayer(filename, layerName, "ogr") if not layer.isValid() or layer.type() != qgis.core.QgsMapLayer.VectorLayer: layer.deleteLater() return False self.inLayer = layer self.inLayerMustBeDestroyed = True else: legendIndex = self.cboInputLayer.itemData(index) self.inLayer = iface.legendInterface().layers()[legendIndex] self.inLayerMustBeDestroyed = False # update the output table name self.cboTable.setEditText(self.inLayer.name()) self.checkSupports() return True
def db_view_change_style(): in_file =open(os.getenv("HOME")+'/.qgis2/python/plugins/Cxf_in/setting.sty', 'r') for line in in_file: if line[:4]=="att:": dirstili=line.split (":",2)[2].replace("\n","") if(os.path.exists(dirstili) ==False): dirstili= os.getenv("HOME")+'/.qgis2/python/plugins/Cxf_in/QML_Default' in_file.close() layers = iface.legendInterface().layers() for layer in layers: if layer.name() == "Particelle": layer.loadNamedStyle(dirstili+'/part.qml') elif layer.name() == "Fabbricati": layer.loadNamedStyle(dirstili+'/fab.qml') elif layer.name() == "Strade": layer.loadNamedStyle(dirstili+'/strade.qml') elif layer.name() == "Confine": layer.loadNamedStyle(dirstili+'/conf.qml') elif layer.name() == "Acque": layer.loadNamedStyle(dirstili+'/acque.qml') elif layer.name() == "Linee": layer.loadNamedStyle(dirstili+'/linee.qml') elif layer.name() == "Simboli": layer.loadNamedStyle(dirstili+'/Simboli.qml') elif layer.name() == "Testi": layer.loadNamedStyle(dirstili+'/testo.qml') elif layer.name() == "Fiduciali": layer.loadNamedStyle(dirstili+'/fidu.qml') iface.mapCanvas().refresh()
def updateInputLayer(self): """ create the input layer and update available options """ if self.mode != self.ASK_FOR_INPUT_MODE: return self.deleteInputLayer() index = self.cboInputLayer.currentIndex() if index < 0: filename = self.cboInputLayer.currentText() if filename == "": return False layerName = QFileInfo(filename).completeBaseName() layer = qgis.core.QgsVectorLayer(filename, layerName, "ogr") if not layer.isValid( ) or layer.type() != qgis.core.QgsMapLayer.VectorLayer: layer.deleteLater() return False self.inLayer = layer self.inLayerMustBeDestroyed = True else: legendIndex = self.cboInputLayer.itemData(index) self.inLayer = iface.legendInterface().layers()[legendIndex] self.inLayerMustBeDestroyed = False # update the output table name self.cboTable.setEditText(self.inLayer.name()) self.checkSupports() return True
def add_xml_background_map(self, xml, layer_name = 'GoogleMaps', group=None, visible=True): ''' add background map from xml file to given group (or root) ''' for child in group.children(): pass layer = QgsRasterLayer(xml, layer_name) #layer = QgsRasterLayer("http://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer?f=json&pretty=true", "layer") remove_layer(layer_name, group) QgsMapLayerRegistry.instance().addMapLayer(layer, group is None) if group: treelayer = group.addLayer(layer) QgsLegendRenderer.setNodeLegendStyle( treelayer, QgsComposerLegendStyle.Hidden) iface.legendInterface().setLayerVisible(layer, visible)
def get_map_layers():#list type is wrong layer_list = [] legend = iface.legendInterface() layers = legend.layers() for layer in layers: # layer_list.append(layer.name()) layer_list.append(layer) return layer_list
def onNextFrameRequested(self): if self.nextFrame is None or self.nextFrame < self.animationBeginTime: self.nextFrame = self.animationBeginTime elif self.nextFrame > self.animationEndTime: #print("====END====") #print(self.nextFrame) #print(self.animationEndTime) #print("====END====") self.pause() self.nextFrame = self.animationBeginTime self.animationPlaybackEnd.emit() return self.framesShown = [] for animation in self.animationElements: try: layer = animation.getFrameByTime(self.nextFrame, self.timeDeviationTolerance) try: iface.legendInterface().setLayerVisible(layer, True) except RuntimeError: #Will happen if the animator attempts to set as visible #a no longer existing layer (i.e. if the user removes #that layer or group from the legend interface). self.pause() self.errorSignal.emit("A layer for this animation was not found.\nWas it removed?"\ " Please, click\nagain on prepare animation to fix this issue.") self.framesShown.append(layer) except KeyError: #print("MAP NOT FOUND ANIMATIONCONTROLLER"+str(self.nextFrame)) continue #print("MAP SEARCH FINISHED") try: nextFrameToBeDisplayedIndex = \ abs((self.animationBeginTime - self.nextFrame).total_seconds())/self.timeDeltaPerFrame.total_seconds() except TypeError: #Will happen if this animation is reset while running. self.pause() return #print("next frame to show int: "+str(nextFrameToBeDisplayedIndex)) self.newFrameShown.emit((nextFrameToBeDisplayedIndex, str(self.nextFrame))) self.nextFrame = self.nextFrame + self.timeDeltaPerFrame
def processAlgorithm(self, progress): filename = self.getParameterValue(self.INPUT) layer = dataobjects.getObjectFromUri(filename) style = self.getParameterValue(self.STYLE) if layer is None: dataobjects.load(filename, os.path.basename(filename), style=style) self.getOutputFromName(self.OUTPUT).open = False else: with open(style) as f: xml = "".join(f.readlines()) d = QDomDocument() d.setContent(xml) n = d.firstChild() layer.readSymbology(n, '') self.setOutputValue(self.OUTPUT, filename) iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(layer)
def getGroups(): groups = {} rels = iface.legendInterface().groupLayerRelationship() for rel in rels: groupName = rel[0] if groupName != '': groupLayers = rel[1] groups[groupName] = [QgsMapLayerRegistry.instance().mapLayer(layerid) for layerid in groupLayers] return groups
def showNewImage(self, image): """ Will order this UI to post a new image to the user through the qgis window. :param image: a tuple consisting of (imageOrLayerObject, Name, Service) :type image: (QgsRasterLayer, String, String) """ self.postInformationMessageToUser("Layer '"+image[1]+"' ["+image[2]+"]retrieved") layer = image[0] if layer.isValid() is True: QgsMapLayerRegistry.instance().addMapLayer(layer) iface.zoomToActiveLayer() iface.legendInterface().refreshLayerSymbology(layer) else: self.postInformationMessageToUser("There was a problem loading the layer.")
def __init__(self): QtGui.QDialog.__init__(self) self.ui = Ui_Dialog() self.ui.setupUi(self) #QtCore.QObject.connect(self.ui.locationButton, QtCore.SIGNAL('clicked()'), self.openLocation) layers = iface.legendInterface().layers() for l in layers: self.ui.inputLayer.addItem(l.name()) self.ui.targetLayer.addItem(l.name())