Python iface.activeLayer函数代码示例

    def eventFilter(self, obj, event):
        if event is None or self is None or QEvent is None:
            return False
        if event.type() == QEvent.ContextMenu:
            layer = iface.activeLayer()
            #if layer is not None and layer.type() == QgsMapLayer.VectorLayer:
            (index,indexStr) = self.checkLayerAttribute( layer, False )
            if index != -1:
                globalPos = iface.mapCanvas().mapToGlobal(event.pos())
                myMenu = QMenu()
                str1 = self.tr("Add selected tile raster layer(s)")
                str3 = self.tr("Add all tile raster layer(s)")
                str2 = self.tr("Show tile previews in map")
                if len(layer.selectedFeatures()) != 0: 
                    myMenu.addAction(QIcon(":/plugins/tileindex/icon/mActionAddImage.png"),str1)
                myMenu.addAction(QIcon(":/plugins/tileindex/icon/mActionAddRasterLayer.png"),str3)
                myMenu.addAction(QIcon(":/plugins/tileindex/icon/mActionMapTips.png"),str2)
                selectedAction = myMenu.exec_(globalPos)
                if selectedAction:
                    if selectedAction.text() == str1:
                        count = self.addSelectedTiles( iface.activeLayer() )
                    elif selectedAction.text() == str3:
                        self.addAllTiles( iface.activeLayer() )
                    elif selectedAction.text() == str2:
                        self.showPreview(layer)
                    else:
                        return False
                    return True
                return False

        return False

    def __init__(self, alg):
        super(FieldsCalculatorDialog, self).__init__(None)
        self.setupUi(self)

        self.executed = False
        self._wasExecuted = False
        self.alg = alg
        self.layer = None

        self.cmbInputLayer.setFilters(QgsMapLayerProxyModel.VectorLayer)
        try:
            if iface.activeLayer().type() == QgsMapLayer.VectorLayer:
                self.cmbInputLayer.setLayer(iface.activeLayer())
        except:
            pass

        self.cmbInputLayer.layerChanged.connect(self.updateLayer)
        self.btnBrowse.clicked.connect(self.selectFile)
        self.mNewFieldGroupBox.toggled.connect(self.toggleExistingGroup)
        self.mUpdateExistingGroupBox.toggled.connect(self.toggleNewGroup)
        self.mOutputFieldTypeComboBox.currentIndexChanged.connect(self.setupSpinboxes)

        # Default values for field width and precision
        self.mOutputFieldWidthSpinBox.setValue(10)
        self.mOutputFieldPrecisionSpinBox.setValue(3)

        # Output is a shapefile, so limit maximum field name length
        self.mOutputFieldNameLineEdit.setMaxLength(10)

        self.manageGui()

    def fetchResults(self, string, context, feedback):
        # collect results in main thread, since this method is inexpensive and
        # accessing the processing registry/current layer is not thread safe

        if iface.activeLayer() is None or iface.activeLayer().type() != QgsMapLayer.VectorLayer or not iface.activeLayer().selectedFeatureCount():
            return

        for a in QgsApplication.processingRegistry().algorithms():
            if not a.flags() & QgsProcessingAlgorithm.FlagSupportsInPlaceEdits:
                continue

            if not a.supportInPlaceEdit(iface.activeLayer()):
                continue

            if QgsLocatorFilter.stringMatches(a.displayName(), string) or [t for t in a.tags() if QgsLocatorFilter.stringMatches(t, string)] or \
                    (context.usingPrefix and not string):
                result = QgsLocatorResult()
                result.filter = self
                result.displayString = a.displayName()
                result.icon = a.icon()
                result.userData = a.id()
                if string and QgsLocatorFilter.stringMatches(a.displayName(), string):
                    result.score = float(len(string)) / len(a.displayName())
                else:
                    result.score = 0
                self.resultFetched.emit(result)

    def mapaPlantillaPdf(self):
        import time

        registry = QgsMapLayerRegistry.instance()
        layers = registry.mapLayers().values()
        layerName = iface.activeLayer().name()
        # Add layer to map render
        myMapRenderer = QgsMapRenderer()
        myMapRenderer.setLayerSet(layerName)
        myMapRenderer.setProjectionsEnabled(False)

        # Load template
        layer = iface.activeLayer()
        canvas = iface.mapCanvas()
        extent = layer.extent()
        #canvas = QgsMapCanvas()
        ms = canvas.mapSettings()
        myComposition = QgsComposition(ms)

        # uso plantilla
        if (extent.width() > extent.height()):
            tipo = 'h'
            myFile = os.path.join(os.path.dirname(__file__), 'template_h2.qpt')
        else:
            # plantilla vertical
            tipo = 'v'
            myFile = os.path.join(os.path.dirname(__file__), 'template_v2.qpt')
        #myFile = '/home/jose/Documentos/pyqgis/template_h.qpt'
        myTemplateFile = file(myFile, 'rt')
        myTemplateContent = myTemplateFile.read()
        myTemplateFile.close()
        myDocument = QDomDocument()
        myDocument.setContent(myTemplateContent)
        myComposition.loadFromTemplate(myDocument)

        # Sustituir textos
        substitution_map = {'TITULO': u'TEMÁTICO','EDIFICIO':self.dlg.comboBoxEdificio.currentText(),'FECHA': time.strftime("%d/%m/%Y") ,'AUTOR': u'José Manuel Mira','ORGANISMO': 'Universidad de Alicante'}
        myComposition.loadFromTemplate(myDocument, substitution_map)

        # Zoom a capa
        myMap = myComposition.getComposerMapById(0)
        myExtent = iface.activeLayer().extent()
        myMap.setNewExtent(myExtent)

        # Save image
        salidaPNG = "mapa_" + layer.name() + "_" + time.strftime("%Y%m%d%H%M%S") + ".png"
        myImage = myComposition.printPageAsRaster(0)
        myImage.save(salidaPNG)

        # export PDF
        import time
        salidaPDF = "mapa_" + layer.name() + "_" + time.strftime("%Y%m%d%H%M%S") + ".pdf"
        myComposition.exportAsPDF(salidaPDF)

        QMessageBox.information(self.iface.mainWindow(), "Resultado", "Los mapas, " + salidaPNG + " y "+ salidaPDF+ " han sido creados exitosamente.")

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 tematico(self):
        layer = iface.activeLayer()
        usos = {
            u"Administración": ("#b3cde3", u"Administración"),
            "Despacho": ("#fbb4ae", "Despacho"),
            "Docencia": ("#ccebc5", "Docencia"),
            "Laboratorio": ("#decbe4", "Laboratorio"),
            "Salas": ("#fed9a6", "Salas"),
            "Muros": ("#808080", "Muros"),
            "": ("white", "Resto")}
        categorias = []
        for estancia, (color, label) in usos.items():
            sym = QgsSymbolV2.defaultSymbol(layer.geometryType())
            sym.setColor(QColor(color))
            category = QgsRendererCategoryV2(estancia, sym, label)
            categorias.append(category)

            field = "activresum"
            index = layer.fieldNameIndex("activresum")
            # comprueba que existe el campo activresum
            if (index == -1):
                QMessageBox.critical(None, "Field error", "No existe el campo activresum. Seleccione la capa adecuada")
                break

            renderer = QgsCategorizedSymbolRendererV2(field, categorias)
            layer.setRendererV2(renderer)
            QgsMapLayerRegistry.instance().addMapLayer(layer)
            layer.triggerRepaint()
            layer.setName(layer.name()[:6] + u' (uso)')
            # actualizar metadatos
            layer.setTitle(u"Planta de edificio " + layer.name()[:6] + u' (uso)' )
            layer.setAbstract(u"Edificio procedente del Sistema de Informacion Geografica de la Universidad de Alicante (SIGUA)")

def execute_in_place(alg, parameters, context=None, feedback=None):
    """Executes an algorithm modifying features in-place, if the INPUT
    parameter is not defined, the current active layer will be used as
    INPUT.

    :param alg: algorithm to run
    :type alg: QgsProcessingAlgorithm
    :param parameters: parameters of the algorithm
    :type parameters: dict
    :param context: context, defaults to None
    :param context: QgsProcessingContext, optional
    :param feedback: feedback, defaults to None
    :param feedback: QgsProcessingFeedback, optional
    :raises QgsProcessingException: raised when the layer is not editable or the layer cannot be found in the current project
    :return: a tuple with true if success and results
    :rtype: tuple
    """

    if feedback is None:
        feedback = QgsProcessingFeedback()
    if context is None:
        context = dataobjects.createContext(feedback)

    if not 'INPUT' in parameters or not parameters['INPUT']:
        parameters['INPUT'] = iface.activeLayer()
    ok, results = execute_in_place_run(alg, parameters, context=context, feedback=feedback)
    if ok:
        if isinstance(parameters['INPUT'], QgsProcessingFeatureSourceDefinition):
            layer = alg.parameterAsVectorLayer({'INPUT': parameters['INPUT'].source}, 'INPUT', context)
        elif isinstance(parameters['INPUT'], QgsVectorLayer):
            layer = parameters['INPUT']
        if layer:
            layer.triggerRepaint()
    return ok, results

    def onOk(self):
      self.ui.textEdit.clear()
      self.ui.view.scene().clear()
            
      aLayer = iface.activeLayer()   
      
      if aLayer is None:
	QMessageBox.warning(self, unicode("DiagLeg"),
				  unicode("Please select a Layer and try again!"),
				  QMessageBox.Ok
				  );
	return
      
      provider = aLayer.dataProvider()
      	
      listFields = []
      fields = aLayer.pendingFields()
      
      for i in range(fields.count()):
	field = fields[i]
	listFields.append(field.name())
    
      #First we create the system temp to get the name, and then a .qml created by Qgis when it saved the style
      f = tempfile.NamedTemporaryFile(delete=True)      
      aLayer.saveNamedStyle(f.name);
                  
      strTmp=f.name+".qml"      
      
      self.importDOM(strTmp,listFields)      
     
      #Remember to delete both files!
      f.close()
      b=QFile(strTmp).remove()

    def save_color_map(self):
        """
        Save the currently open color-map as a qml-file into the project folder.
        :return:
        :rtype:
        """
        from mole import extensions

        layer = iface.activeLayer()
        selected_layer = self.layers_dropdown.currentText()
        if layer.name() != selected_layer:
            layer = layer_interaction.find_layer_by_name(selected_layer)

        out_path = os.path.dirname(layer.publicSource())
        out_path = os.path.join(out_path, layer.name() + '.qml')
        self.update_color_values()
        entry_written = self.color_entry_manager.write_color_map_as_qml(layer.name(), out_path)
        if entry_written:
            self.message_label.setStyleSheet(_fromUtf8("color: green;"))
            self.message_label.setText('Success - Legend was successfully written to \n\t"{}".'.format(out_path))
        else:
            self.message_label.setStyleSheet(_fromUtf8("color: red;"))
            self.message_label.setText('Failure - Could not write legend to to \n\t"{}".'.format(out_path))
        activeextensions = extensions.by_layername(layer.name())
        try:
            activeextensions[0].colortable = out_path
        except:
            pass

    def __init__(self, alg, in_place=False, parent=None):
        super().__init__(parent)

        self.feedback_dialog = None
        self.in_place = in_place
        self.active_layer = None

        self.context = None
        self.feedback = None

        self.setAlgorithm(alg)
        self.setMainWidget(self.getParametersPanel(alg, self))

        if not self.in_place:
            self.runAsBatchButton = QPushButton(QCoreApplication.translate("AlgorithmDialog", "Run as Batch Process…"))
            self.runAsBatchButton.clicked.connect(self.runAsBatch)
            self.buttonBox().addButton(self.runAsBatchButton, QDialogButtonBox.ResetRole) # reset role to ensure left alignment
        else:
            self.active_layer = iface.activeLayer()
            self.runAsBatchButton = None
            has_selection = self.active_layer and (self.active_layer.selectedFeatureCount() > 0)
            self.buttonBox().button(QDialogButtonBox.Ok).setText(QCoreApplication.translate("AlgorithmDialog", "Modify Selected Features")
                                                                 if has_selection else QCoreApplication.translate("AlgorithmDialog", "Modify All Features"))
            self.buttonBox().button(QDialogButtonBox.Close).setText(QCoreApplication.translate("AlgorithmDialog", "Cancel"))
            self.setWindowTitle(self.windowTitle() + ' | ' + self.active_layer.name())

def dms (lat, lon):
    """
    Add a point at the lat and lon for the current layer using DMS notation
    """

    lat,lon = lat, lon

    l_lat = lat.upper().split()
    l_lon = lon.upper().split()

    # need to add validation tests

    if l_lat[3] == 'N':
        ddlat = float(l_lat[0])+(float(l_lat[1])/60)+float(l_lat[2])/3600
    elif l_lat[3] == 'S':
        ddlat = (float(l_lat[0])+float(l_lat[1])/60+float(l_lat[2])/3600)*-1
    else:
        ddlat = '0'

    if l_lon [3] == 'E':
        ddlon = float(l_lon[0])+float(l_lon[1])/60+float(l_lon[2])/3600
    elif l_lon[3] == 'W':
        ddlon = (float(l_lon[0])+float(l_lon[1])/60+float(l_lon[2])/3600)*-1
    else:
        ddlon = '0'

    layer = iface.activeLayer()
    f = QgsFeature(layer.pendingFields())
    geom = QgsGeometry.fromPoint(QgsPoint(ddlon,ddlat))
    f.setGeometry(geom)
    layer.addFeature(f)
    iface.mapCanvas().refresh()

 def filter_selection(self):
     '''
     filter the active layer by selected objects
     '''
     if not self.login:
         return
     # either name of layer or group have to match a category
     active_layer = iface.activeLayer()
     categories = self.categories.keys()
     layer_error = (u'Sie müssen im Layerfenster einen '
                    u'Layer auswählen, wahlweise aus den Gruppen '
                    u'Einrichtungen oder Filter.')
     if not active_layer:
         QtGui.QMessageBox.information(self, 'Fehler', layer_error)
         return
     else:
         layer_name = active_layer.name()
         if layer_name in categories:
             category = layer_name
         else:
             project_tree = QgsProject.instance().layerTreeRoot()
             layer_item = project_tree.findLayer(active_layer.id())
             group = layer_item.parent()
             group_name = group.name()
             if group_name in categories:
                 category = group_name
             else:
                 QtGui.QMessageBox.information(self, 'Fehler', layer_error)
                 return
         selected_feats = active_layer.selectedFeatures()
         if not selected_feats:
             msg = (u'Im ausgewählten Layer {} sind keine '
                    u'Einrichtungen selektiert.'.format(layer_name))
             QtGui.QMessageBox.information(self, 'Fehler', msg)
             return
 
         parent_group = get_group('Filter')
         subgroup = get_group(category, parent_group)
         ids = [str(f.attribute('sel_id')) for f in selected_feats]
         name, ok = QtGui.QInputDialog.getText(
             self, 'Filter', 'Name des zu erstellenden Layers',
             text=get_unique_layer_name(category, subgroup))
         if not ok:
             return
         
         subset = 'sel_id in ({})'.format(','.join(ids))
         layer = QgsVectorLayer(active_layer.source(), name, "postgres")
         remove_layer(name, subgroup)
         
         QgsMapLayerRegistry.instance().addMapLayer(layer, False)
         subgroup.addLayer(layer)
         layer.setSubsetString(subset)
         symbology = SimpleSymbology(self.colors[category], shape='triangle')
         symbology.apply(layer)
         self.copy_editor_attrs(active_layer, layer)

    def select_output_file(self):
        global nameloadfile
        filename     = QFileDialog.getOpenFileName(self.dlg, "Select output file ","", '*.*')
        nameloadfile = start_rwt.format_rwt_file(filename,self)
        layer        = iface.activeLayer()   # Cria uma layer 
        start_rwt.update_rwt_form(layer,self,filename)
        
#        if nameloadfile=='StAMPs':
#            start_rwt.update_stp_rwt_form(layer,self,filename)
#        
        print"estou no selectfile:",nameloadfile

def point_at(x, y):
    """
    Add a point at the x and y for the current layer
    """
    x, y = float(x), float(y)
    layer = iface.activeLayer()
    f = QgsFeature(layer.pendingFields())
    geom = QgsGeometry.fromPoint(QgsPoint(x, y))
    f.setGeometry(geom)
    layer.addFeature(f)
    iface.mapCanvas().refresh()

def point_at_dms(lat, lon):
    """
    Add a point at the lat and lon for the current layer using DMS notation
    """

    ddlat, ddlon = dms_to_dd(lat, lon)

    layer = iface.activeLayer()
    f = QgsFeature(layer.pendingFields())
    geom = QgsGeometry.fromPoint(QgsPoint(ddlon, ddlat))
    f.setGeometry(geom)
    layer.addFeature(f)
    iface.mapCanvas().refresh()