Python QgsMultiRenderChecker.setControlPathPrefix方法代码示例

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
    def testRenderLineLayerDataDefined(self):
        """ test that rendering a line symbol with data defined enabled layer works"""

        lines_shp = os.path.join(TEST_DATA_DIR, 'lines.shp')
        lines_layer = QgsVectorLayer(lines_shp, 'Lines', 'ogr')
        QgsProject.instance().addMapLayer(lines_layer)

        layer = QgsSimpleLineSymbolLayer()
        layer.setDataDefinedProperty(QgsSymbolLayer.PropertyLayerEnabled, QgsProperty.fromExpression("Name='Highway'"))
        layer.setColor(QColor(100, 150, 150))
        layer.setWidth(5)

        symbol = QgsLineSymbol()
        symbol.changeSymbolLayer(0, layer)
        lines_layer.setRenderer(QgsSingleSymbolRenderer(symbol))

        ms = QgsMapSettings()
        ms.setOutputSize(QSize(400, 400))
        ms.setOutputDpi(96)
        ms.setExtent(QgsRectangle(-133, 22, -70, 52))
        ms.setLayers([lines_layer])

        renderchecker = QgsMultiRenderChecker()
        renderchecker.setMapSettings(ms)
        renderchecker.setControlPathPrefix('symbol_layer')
        renderchecker.setControlName('expected_linelayer_ddenabled')
        self.assertTrue(renderchecker.runTest('linelayer_ddenabled'))
        QgsProject.instance().removeMapLayer(lines_layer)

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
 def testRenderWithin(self):
     self.layer.renderer().setTolerance(10)
     renderchecker = QgsMultiRenderChecker()
     renderchecker.setMapSettings(self.mapsettings)
     renderchecker.setControlPathPrefix('cluster_renderer')
     renderchecker.setControlName('expected_cluster_cluster')
     self.assertTrue(renderchecker.runTest('expected_cluster_cluster'))

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
    def renderCheck(self, mismatch=0, colortol=0, imgpath='', grpprefix=''):
        """Check rendered map canvas or existing image against control image

        :mismatch: number of pixels different from control, and still valid
        :colortol: maximum difference for each color component including alpha
        :imgpath: existing image; if present, skips rendering canvas
        :grpprefix: compare test image/rendering against different test group
        """
        if not grpprefix:
            grpprefix = self._TestGroupPrefix
        chk = QgsMultiRenderChecker()

        chk.setControlPathPrefix('expected_' + grpprefix)

        chk.setControlName(self._Test)

        if imgpath:
            chk.setRenderedImage(imgpath)

        ms = self._MapSettings  # class settings
        if self._TestMapSettings is not None:
            ms = self._TestMapSettings  # per test settings
        chk.setMapSettings(ms)

        chk.setColorTolerance(colortol)
        # noinspection PyUnusedLocal
        res = chk.runTest(self._Test, mismatch)
        if PALREPORT and not res:  # don't report ok checks
            testname = self._TestGroup + ' . ' + self._Test
            PALREPORTS[testname] = chk.report()
        msg = '\nRender check failed for "{0}"'.format(self._Test)
        return res, msg

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
 def testRenderNoCluster(self):
     self.layer.renderer().setTolerance(1)
     renderchecker = QgsMultiRenderChecker()
     renderchecker.setMapSettings(self.mapsettings)
     renderchecker.setControlPathPrefix('displacement_renderer')
     renderchecker.setControlName('expected_displacement_no_cluster')
     self.assertTrue(renderchecker.runTest('displacement_no_cluster'))

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
    def testRenderMarkerLayerDataDefined(self):
        """ test that rendering a marker symbol with data defined enabled layer works"""

        points_shp = os.path.join(TEST_DATA_DIR, 'points.shp')
        points_layer = QgsVectorLayer(points_shp, 'Points', 'ogr')
        QgsProject.instance().addMapLayer(points_layer)

        layer = QgsSimpleMarkerSymbolLayer()
        layer.setDataDefinedProperty(QgsSymbolLayer.PropertyLayerEnabled, QgsProperty.fromExpression("Class='Biplane'"))
        layer.setColor(QColor(100, 150, 150))
        layer.setSize(5)
        layer.setStrokeStyle(Qt.NoPen)

        symbol = QgsMarkerSymbol()
        symbol.changeSymbolLayer(0, layer)
        points_layer.setRenderer(QgsSingleSymbolRenderer(symbol))

        ms = QgsMapSettings()
        ms.setOutputSize(QSize(400, 400))
        ms.setOutputDpi(96)
        ms.setExtent(QgsRectangle(-133, 22, -70, 52))
        ms.setLayers([points_layer])

        renderchecker = QgsMultiRenderChecker()
        renderchecker.setMapSettings(ms)
        renderchecker.setControlPathPrefix('symbol_layer')
        renderchecker.setControlName('expected_markerlayer_ddenabled')
        self.assertTrue(renderchecker.runTest('markerlayer_ddenabled'))
        QgsProject.instance().removeMapLayer(points_layer)

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
    def testRenderFillLayerDataDefined(self):
        """ test that rendering a fill symbol with data defined enabled layer works"""

        polys_shp = os.path.join(TEST_DATA_DIR, 'polys.shp')
        polys_layer = QgsVectorLayer(polys_shp, 'Polygons', 'ogr')
        QgsProject.instance().addMapLayer(polys_layer)

        layer = QgsSimpleFillSymbolLayer()
        layer.setDataDefinedProperty("enabled", QgsDataDefined("Name='Lake'"))
        layer.setBorderStyle(Qt.NoPen)
        layer.setColor(QColor(100, 150, 150))

        symbol = QgsFillSymbol()
        symbol.changeSymbolLayer(0, layer)
        polys_layer.setRenderer(QgsSingleSymbolRenderer(symbol))

        ms = QgsMapSettings()
        ms.setOutputSize(QSize(400, 400))
        ms.setOutputDpi(96)
        ms.setExtent(QgsRectangle(-133, 22, -70, 52))
        ms.setLayers([polys_layer])

        renderchecker = QgsMultiRenderChecker()
        renderchecker.setMapSettings(ms)
        renderchecker.setControlPathPrefix('symbol_layer')
        renderchecker.setControlName('expected_filllayer_ddenabled')
        self.assertTrue(renderchecker.runTest('filllayer_ddenabled'))
        QgsProject.instance().removeMapLayer(polys_layer)

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
 def testRenderGrid(self):
     self.layer.renderer().setTolerance(10)
     self.layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid)
     renderchecker = QgsMultiRenderChecker()
     renderchecker.setMapSettings(self.mapsettings)
     renderchecker.setControlPathPrefix('displacement_renderer')
     renderchecker.setControlName('expected_displacement_grid')
     self.assertTrue(renderchecker.runTest('expected_displacement_grid'))

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
 def checkImage(self, name, reference_image, rendered_image, size_tolerance=0):
     checker = QgsMultiRenderChecker()
     checker.setControlPathPrefix("layout_exporter")
     checker.setControlName("expected_layoutexporter_" + reference_image)
     checker.setRenderedImage(rendered_image)
     checker.setColorTolerance(2)
     checker.setSizeTolerance(size_tolerance, size_tolerance)
     result = checker.runTest(name, 20)
     self.report += checker.report()
     print((self.report))
     return result

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
 def testRenderWithin(self):
     layer, renderer, mapsettings = self._setUp()
     layer.renderer().setTolerance(10)
     renderchecker = QgsMultiRenderChecker()
     renderchecker.setMapSettings(mapsettings)
     renderchecker.setControlPathPrefix('displacement_renderer')
     renderchecker.setControlName('expected_displacement_cluster')
     res = renderchecker.runTest('expected_displacement_cluster')
     self.report += renderchecker.report()
     self.assertTrue(res)
     self._tearDown(layer)

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
 def imageCheck(self, name, reference_image, image):
     self.report += "<h2>Render {}</h2>\n".format(name)
     temp_dir = QDir.tempPath() + '/'
     file_name = temp_dir + 'annotation_' + name + ".png"
     image.save(file_name, "PNG")
     checker = QgsMultiRenderChecker()
     checker.setControlPathPrefix("annotations")
     checker.setControlName("expected_" + reference_image)
     checker.setRenderedImage(file_name)
     checker.setColorTolerance(2)
     result = checker.runTest(name, 20)
     self.report += checker.report()
     print((self.report))
     return result

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
 def testRenderGridAdjust(self):
     layer, renderer, mapsettings = self._setUp()
     layer.renderer().setTolerance(10)
     layer.renderer().setCircleRadiusAddition(5)
     layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid)
     layer.renderer().setCircleColor(QColor())
     renderchecker = QgsMultiRenderChecker()
     renderchecker.setMapSettings(mapsettings)
     renderchecker.setControlPathPrefix('displacement_renderer')
     renderchecker.setControlName('expected_displacement_adjust_grid')
     res = renderchecker.runTest('expected_displacement_adjust_grid')
     self.report += renderchecker.report()
     self.assertTrue(res)
     self._tearDown(layer)

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
 def testClusterRingLabels(self):
     layer, renderer, mapsettings = self._setUp()
     layer.renderer().setTolerance(10)
     layer.renderer().setLabelAttributeName('Class')
     layer.renderer().setLabelDistanceFactor(0.35)
     f = QgsFontUtils.getStandardTestFont('Bold', 14)
     layer.renderer().setLabelFont(f)
     renderchecker = QgsMultiRenderChecker()
     renderchecker.setMapSettings(mapsettings)
     renderchecker.setControlPathPrefix('displacement_renderer')
     renderchecker.setControlName('expected_displacement_cluster_ring_labels')
     res = renderchecker.runTest('expected_displacement_cluster_ring_labels')
     self.report += renderchecker.report()
     self.assertTrue(res)
     self._tearDown(layer)

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
    def testRenderVariables(self):
        """ test rendering with expression variables in marker """
        self.layer.renderer().setTolerance(10)

        old_marker = self.layer.renderer().clusterSymbol().clone()

        new_marker = QgsMarkerSymbol.createSimple({'color': '#ffff00', 'size': '3', 'outline_style': 'no'})
        new_marker.symbolLayer(0).setDataDefinedProperty(QgsSymbolLayer.PropertyFillColor, QgsProperty.fromExpression('@cluster_color'))
        new_marker.symbolLayer(0).setDataDefinedProperty(QgsSymbolLayer.PropertySize, QgsProperty.fromExpression('@cluster_size*2'))
        self.layer.renderer().setClusterSymbol(new_marker)
        renderchecker = QgsMultiRenderChecker()
        renderchecker.setMapSettings(self.mapsettings)
        renderchecker.setControlPathPrefix('cluster_renderer')
        renderchecker.setControlName('expected_cluster_variables')
        result = renderchecker.runTest('expected_cluster_variables')
        self.layer.renderer().setClusterSymbol(old_marker)
        self.assertTrue(result)

# 需要导入模块: from qgis.core import QgsMultiRenderChecker [as 别名]
# 或者: from qgis.core.QgsMultiRenderChecker import setControlPathPrefix [as 别名]
 def testClusterConcentricLabelsDifferentSizesFarther(self):
     layer, renderer, mapsettings = self._setUp()
     renderer.setEmbeddedRenderer(self._create_categorized_renderer())
     layer.renderer().setTolerance(10)
     layer.renderer().setLabelAttributeName('Class')
     layer.renderer().setLabelDistanceFactor(1)
     f = QgsFontUtils.getStandardTestFont('Bold', 14)
     layer.renderer().setLabelFont(f)
     layer.renderer().setPlacement(QgsPointDisplacementRenderer.ConcentricRings)
     renderchecker = QgsMultiRenderChecker()
     renderchecker.setMapSettings(mapsettings)
     renderchecker.setControlPathPrefix('displacement_renderer')
     renderchecker.setControlName('expected_displacement_cluster_concentric_labels_diff_size_farther')
     res = renderchecker.runTest('expected_displacement_cluster_concentric_labels_diff_size_farther')
     self.report += renderchecker.report()
     self.assertTrue(res)
     self._tearDown(layer)