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 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 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 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 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 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 __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 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 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())
