Python core.QgsPalLayerSettings类代码示例

 def defaultSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.enabled = True
     lyr.fieldName = 'text'  # default in data sources
     lyr.textFont = self._TestFont
     lyr.textNamedStyle = 'Medium'
     return lyr

    def prepare_ordered_marker(self, coords, idx):
        """
        Try to display nice marker on a point layer, showing the order of
        the path computed by OSRM.
        """
        self.tsp_marker_lr = QgsVectorLayer(
            "Point?crs=epsg:4326&field=id:integer"
            "&field=TSP_nb:integer(20)&field=Origin_nb:integer(20)",
            "tsp_markers_osrm{}".format(self.nb_route), "memory")
        symbol = QgsSymbolV2.defaultSymbol(self.tsp_marker_lr.geometryType())
        symbol.setSize(4.5)
        symbol.setColor(QtGui.QColor("yellow"))

        ordered_pts = \
            [coords[i["waypoint_index"]] for i in self.parsed['waypoints']]
        print("ordered_pts : ", ordered_pts)

        features = []
        for nb, pt in enumerate(ordered_pts):
            ft = QgsFeature()
            ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(pt)))
            ft.setAttributes([nb, nb + 1, coords.index(pt)])
            features.append(ft)
        self.tsp_marker_lr.dataProvider().addFeatures(features)

        pal_lyr = QgsPalLayerSettings()
        pal_lyr.readFromLayer(self.tsp_marker_lr)
        pal_lyr.enabled = True
        pal_lyr.fieldName = 'TSP_nb'
        pal_lyr.placement= QgsPalLayerSettings.OverPoint
        pal_lyr.setDataDefinedProperty(QgsPalLayerSettings.Size,True,True,'12','')
        pal_lyr.writeToLayer(self.tsp_marker_lr)

        self.tsp_marker_lr.setRendererV2(QgsSingleSymbolRendererV2(symbol))
        QgsMapLayerRegistry.instance().addMapLayer(self.tsp_marker_lr)

 def test_settings_enable_pal(self):
     # Verify default PAL settings enable PAL labeling for layer
     lyr = QgsPalLayerSettings()
     lyr.writeToLayer(self.layer)
     palset = self.layer.customProperty('labeling', '')
     msg = '\nExpected: Empty string\nGot: {0}'.format(palset)
     self.assertEqual(palset, 'pal', msg)

 def test_settings_enable_pal(self):
     # Verify default PAL settings enable PAL labeling for layer
     lyr = QgsPalLayerSettings()
     lyr.writeToLayer(self.layer)
     palset = self.layer.customProperty("labeling", "").toString()
     msg = "\nExpected: Empty string\nGot: {0}".format(palset)
     self.assertEqual(palset, "pal", msg)

 def defaultLayerSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.enabled = True
     lyr.fieldName = "text"  # default in test data sources
     font = self.getTestFont()
     font.setPointSize(32)
     lyr.textFont = font
     lyr.textNamedStyle = "Roman"
     return lyr

 def defaultSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.enabled = True
     lyr.fieldName = 'text'  # default in data sources
     font = self.getTestFont()
     font.setPointSize(48)
     lyr.textFont = font
     lyr.textNamedStyle = 'Roman'
     return lyr

 def defaultLayerSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.fieldName = 'text'  # default in test data sources
     font = self.getTestFont()
     font.setPointSize(32)
     format = lyr.format()
     format.setFont(font)
     format.setNamedStyle('Roman')
     format.setSize(32)
     format.setSizeUnit(QgsUnitTypes.RenderPoints)
     format.buffer().setJoinStyle(Qt.BevelJoin)
     lyr.setFormat(format)
     return lyr

    def test_write_read_settings(self):
        # Verify written PAL settings are same when read from layer
        # load and write default test settings
        lyr1 = self.defaultLayerSettings()
        lyr1dict = self.settingsDict(lyr1)
        # print lyr1dict
        lyr1.writeToLayer(self.layer)

        # read settings
        lyr2 = QgsPalLayerSettings()
        lyr2.readFromLayer(self.layer)
        lyr2dict = self.settingsDict(lyr1)
        # print lyr2dict

        msg = '\nLayer settings read not same as settings written'
        self.assertDictEqual(lyr1dict, lyr2dict, msg)

    def checkRemovingLabeledLayerInvalidatesLabelCache(self, job_type):
        """ removing a previously labeled layer should invalidate any previous label caches"""
        layer = QgsVectorLayer("Point?field=fldtxt:string",
                               "layer1", "memory")

        labelSettings = QgsPalLayerSettings()
        labelSettings.fieldName = "fldtxt"
        layer.setLabeling(QgsVectorLayerSimpleLabeling(labelSettings))
        layer.setLabelsEnabled(True)

        layer2 = QgsVectorLayer("Point?field=fldtxt:string",
                                "layer2", "memory")
        layer2.setLabeling(QgsVectorLayerSimpleLabeling(labelSettings))
        layer2.setLabelsEnabled(True)

        settings = QgsMapSettings()
        settings.setExtent(QgsRectangle(5, 25, 25, 45))
        settings.setOutputSize(QSize(600, 400))
        settings.setLayers([layer, layer2])

        # with cache - first run should populate cache
        cache = QgsMapRendererCache()
        job = job_type(settings)
        job.setCache(cache)
        job.start()
        job.waitForFinished()
        self.assertFalse(job.usedCachedLabels())
        self.assertTrue(cache.hasCacheImage('_labels_'))
        self.assertTrue(job.takeLabelingResults())

        self.assertEqual(set(cache.dependentLayers('_labels_')), {layer, layer2})

        # remove a previously labeled layer
        settings.setLayers([layer2])

        # second job should not be able to use label cache, since a labeled layer was removed
        job = job_type(settings)
        job.setCache(cache)
        job.start()
        job.waitForFinished()
        # shouldn't use cache
        self.assertFalse(job.usedCachedLabels())
        # but results should have been cached
        self.assertTrue(cache.hasCacheImage('_labels_'))
        self.assertEqual(set(cache.dependentLayers('_labels_')), {layer2})
        self.assertTrue(job.takeLabelingResults())

    def checkAddingNewNonLabeledLayerKeepsLabelCache(self, job_type):
        """ adding a new non-labeled layer should keep any previous label caches"""
        layer = QgsVectorLayer("Point?field=fldtxt:string",
                               "layer1", "memory")

        labelSettings = QgsPalLayerSettings()
        labelSettings.fieldName = "fldtxt"
        layer.setLabeling(QgsVectorLayerSimpleLabeling(labelSettings))
        layer.setLabelsEnabled(True)

        settings = QgsMapSettings()
        settings.setExtent(QgsRectangle(5, 25, 25, 45))
        settings.setOutputSize(QSize(600, 400))
        settings.setLayers([layer])

        # with cache - first run should populate cache
        cache = QgsMapRendererCache()
        job = job_type(settings)
        job.setCache(cache)
        job.start()
        job.waitForFinished()
        self.assertFalse(job.usedCachedLabels())
        self.assertTrue(cache.hasCacheImage('_labels_'))
        self.assertTrue(job.takeLabelingResults())

        self.assertEqual(cache.dependentLayers('_labels_'), [layer])

        # add another, non-labeled layer
        layer2 = QgsVectorLayer("Point?field=fldtxt:string",
                                "layer2", "memory")
        settings.setLayers([layer, layer2])

        # second job should use label cache, since new layer was not labeled
        job = job_type(settings)
        job.setCache(cache)
        job.start()
        job.waitForFinished()
        # should use cache
        self.assertTrue(job.usedCachedLabels())
        # results should have been cached
        self.assertTrue(cache.hasCacheImage('_labels_'))
        self.assertEqual(set(cache.dependentLayers('_labels_')), {layer})
        self.assertTrue(job.takeLabelingResults())

def remove_mask_filter(layer):
    if not isinstance(layer, QgsVectorLayer):
        return False

    # check if a layer has already a mask filter enabled
    if layer.labeling() is None:
        return False

    settings = layer.labeling().settings()

    try:
        if settings.dataDefinedProperties().hasProperty(QgsPalLayerSettings.Show) and \
                settings.dataDefinedProperties().property(QgsPalLayerSettings.Show).expressionString().startswith(SPATIAL_FILTER):
            # new settings
            settings = QgsPalLayerSettings(layer.labeling().settings())
            settings.dataDefinedProperties().setProperty(QgsPalLayerSettings.Show, True)
            if isinstance(layer.labeling(), QgsVectorLayerSimpleLabeling):
                layer.setLabeling(QgsVectorLayerSimpleLabeling(settings))
    except Exception as e:
        for m in e.args:
            QgsMessageLog.logMessage(m, 'Extensions')

    def checkRepaintLabeledLayerInvalidatesLabelCache(self, job_type):
        layer = QgsVectorLayer("Point?field=fldtxt:string",
                               "layer1", "memory")

        labelSettings = QgsPalLayerSettings()
        labelSettings.fieldName = "fldtxt"
        layer.setLabeling(QgsVectorLayerSimpleLabeling(labelSettings))
        layer.setLabelsEnabled(True)

        settings = QgsMapSettings()
        settings.setExtent(QgsRectangle(5, 25, 25, 45))
        settings.setOutputSize(QSize(600, 400))
        settings.setLayers([layer])

        # with cache - first run should populate cache
        cache = QgsMapRendererCache()
        job = job_type(settings)
        job.setCache(cache)
        job.start()
        job.waitForFinished()
        self.assertFalse(job.usedCachedLabels())
        self.assertTrue(cache.hasCacheImage('_labels_'))
        self.assertTrue(job.takeLabelingResults())

        self.assertEqual(cache.dependentLayers('_labels_'), [layer])

        # trigger repaint on layer - should invalidate cache and block use of cached labels
        layer.triggerRepaint()
        self.assertFalse(cache.hasCacheImage('_labels_'))

        # second job should not use label cache, since layer was repainted
        job = job_type(settings)
        job.setCache(cache)
        job.start()
        job.waitForFinished()
        # shouldn't use cache
        self.assertFalse(job.usedCachedLabels())
        # but results should have been cached
        self.assertTrue(cache.hasCacheImage('_labels_'))
        self.assertTrue(job.takeLabelingResults())

 def createLayer(self):
     '''Create a memory layer from the zoom to locations'''
     rowcnt = self.resultsTable.rowCount()
     if rowcnt == 0:
         return
     attr = []
     for item, label in enumerate(LABELS[0:self.numCol]):
         label = label.lower()
         if item <= 1:
             attr.append(QgsField(label, QVariant.Double))
         else:
             attr.append(QgsField(label, QVariant.String))
     ptLayer = QgsVectorLayer("Point?crs=epsg:4326", u"Lat Lon Locations", "memory")
     provider = ptLayer.dataProvider()
     provider.addAttributes(attr)
     ptLayer.updateFields()
     
     for id in range(rowcnt):
         item = self.resultsTable.item(id, 0).data(Qt.UserRole)
         feature = QgsFeature()
         feature.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(item.lon, item.lat)))
         attr = [item.lat, item.lon, item.label]
         for i in range(3, self.numCol):
             attr.append(item.data[i-3])
         feature.setAttributes(attr)
         provider.addFeatures([feature])
     
     ptLayer.updateExtents()
     if self.settings.multiZoomStyleID == 1:
         settings = QgsPalLayerSettings()
         settings.fieldName = 'label'
         settings.placement = QgsPalLayerSettings.AroundPoint
         labeling = QgsVectorLayerSimpleLabeling(settings)
         ptLayer.setLabeling(labeling)
         ptLayer.setLabelsEnabled(True)
     elif self.settings.multiZoomStyleID == 2 and os.path.isfile(self.settings.customQMLFile()):
         ptLayer.loadNamedStyle(self.settings.customQMLFile())
         
     QgsProject.instance().addMapLayer(ptLayer)

def add_mask_filter(layer):
    if not isinstance(layer, QgsVectorLayer):
        return False

    
    # check if a layer has already a mask filter enabled
    if layer.labeling() is None:
        return False

    try:
        expr = "%s(%d)" % (SPATIAL_FILTER, layer.crs().postgisSrid())
        prop = QgsProperty()
        prop.setExpressionString(expr)

        # new settings
        settings = QgsPalLayerSettings(layer.labeling().settings())
        settings.dataDefinedProperties().setProperty(QgsPalLayerSettings.Show, prop)
        if isinstance(layer.labeling(), QgsVectorLayerSimpleLabeling):
            layer.setLabeling(QgsVectorLayerSimpleLabeling(settings))
        
    except Exception as e:
        for m in e.args:
            QgsMessageLog.logMessage(m, 'Extensions')

 def defaultLayerSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.enabled = True
     lyr.fieldName = 'text'  # default in test data sources
     font = self.getTestFont()
     font.setPointSize(32)
     lyr.textFont = font
     lyr.textNamedStyle = 'Roman'
     lyr.bufferJoinStyle = Qt.BevelJoin  # handle change of default join style
     return lyr