Python QgsCompositionChecker.testComposition方法代码示例

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def testHtmlSmartBreaks(self):
        """Test rendering to multiframes with smart breaks."""
        composerHtml = QgsComposerHtml(self.mComposition, False)
        htmlFrame = QgsComposerFrame(self.mComposition, composerHtml,
                                     10, 10, 100, 52)
        composerHtml.addFrame(htmlFrame)
        composerHtml.setResizeMode(
            QgsComposerMultiFrame.RepeatUntilFinished)
        composerHtml.setUseSmartBreaks( True )
        composerHtml.setUrl(self.htmlUrl())
        composerHtml.frame(0).setFrameEnabled(True)

        print "Checking page 1"
        myPage = 0
        checker1 = QgsCompositionChecker('composerhtml_smartbreaks1', self.mComposition)
        myTestResult, myMessage = checker1.testComposition( myPage, 200 )
        assert myTestResult, myMessage

        print "Checking page 2"
        myPage = 1
        checker2 = QgsCompositionChecker('composerhtml_smartbreaks2', self.mComposition)
        myTestResult, myMessage = checker2.testComposition( myPage, 200 )
        assert myTestResult, myMessage

        self.mComposition.removeMultiFrame( composerHtml )
        composerHtml = None

        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def testTableMultiFrame(self):
        """Test we can render to multiframes."""
        composerHtml = QgsComposerHtml(self.mComposition, False)
        htmlFrame = QgsComposerFrame(self.mComposition, composerHtml,
                                     10, 10, 100, 50)
        composerHtml.addFrame(htmlFrame)
        composerHtml.setResizeMode(
            QgsComposerMultiFrame.RepeatUntilFinished)
        composerHtml.setUseSmartBreaks(False)
        composerHtml.setUrl(self.htmlUrl())
        composerHtml.frame(0).setFrameEnabled(True)

        print("Checking page 1")
        myPage = 0
        checker1 = QgsCompositionChecker('composerhtml_multiframe1', self.mComposition)
        checker1.setControlPathPrefix("composer_html")
        myTestResult, myMessage = checker1.testComposition(myPage)
        assert myTestResult, myMessage

        print("Checking page 2")
        myPage = 1
        checker2 = QgsCompositionChecker('composerhtml_multiframe2', self.mComposition)
        checker2.setControlPathPrefix("composer_html")
        myTestResult, myMessage = checker2.testComposition(myPage)
        assert myTestResult, myMessage

        self.mComposition.removeMultiFrame(composerHtml)
        composerHtml = None

        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def tableMultiFrame(self):
        TEST_DATA_DIR = unitTestDataPath()
        htmlItem = QgsComposerHtml( self.mComposition,  False )
        htmlFrame = QgsComposerFrame( self.mComposition,  htmlItem,  10,  10,  100,  50 )
        htmlItem.addFrame( htmlFrame )
        htmlItem.setResizeMode( QgsComposerMultiFrame.RepeatUntilFinished )
    
        htmlItem.setUrl( QUrl( QString( "file:///%1" ).arg( QString( TEST_DATA_DIR ) + QDir.separator() +  "html_table.html" )  ) )
        htmlItem.frame( 0 ).setFrameEnabled( True )
    
        result = True

        #page 1
        checker1 = QgsCompositionChecker(  )
        if not checker1.testComposition( "Composer html table", self.mComposition, QString( QString( TEST_DATA_DIR ) + QDir.separator() + "control_images" + QDir.separator() + "expected_composerhtml" + QDir.separator() + "composerhtml_table_multiframe1.png" ),  0 ):
            result = False
            
        checker2 = QgsCompositionChecker( )
        if not checker2.testComposition( "Composer html table", self.mComposition, QString( QString( TEST_DATA_DIR ) + QDir.separator() + "control_images" + QDir.separator() + "expected_composerhtml" + QDir.separator() + "composerhtml_table_multiframe2.png" ) ,  1 ):
            result = False
            
        checker3 = QgsCompositionChecker(  )
        if not checker3.testComposition( "Composer html table", self.mComposition, QString( QString( TEST_DATA_DIR ) + QDir.separator() + "control_images" + QDir.separator() + "expected_composerhtml" + QDir.separator() + "composerhtml_table_multiframe3.png" ),  2 ):
            result = False
            
        self.mComposition.removeMultiFrame( htmlItem )
        del htmlItem
        
        assert result == True

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def testDisplayNodes(self):
        """Test displayNodes method"""

        self.mComposerPolygon.setDisplayNodes(True)
        checker = QgsCompositionChecker("composerpolygon_displaynodes", self.mComposition)
        checker.setControlPathPrefix("composer_polygon")
        myTestResult, myMessage = checker.testComposition()
        assert myTestResult, myMessage

        self.mComposerPolygon.setDisplayNodes(False)
        checker = QgsCompositionChecker("composerpolygon_defaultstyle", self.mComposition)
        checker.setControlPathPrefix("composer_polygon")
        myTestResult, myMessage = checker.testComposition()
        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def testGrid(self):
        """Test that we can create a grid for a map."""
        myRectangle = QgsRectangle(781662.375, 3339523.125,
                                   793062.375, 3345223.125)
        self.mComposerMap.setNewExtent(myRectangle)
        self.mComposerMap.setGridEnabled(True)
        self.mComposerMap.setGridIntervalX(2000)
        self.mComposerMap.setGridIntervalY(2000)
        self.mComposerMap.setShowGridAnnotation(True)
        self.mComposerMap.setGridPenWidth(0.5)
        self.mComposerMap.setGridPenColor(QColor(0,255,0))
        self.mComposerMap.setGridAnnotationPrecision(0)
        self.mComposerMap.setGridAnnotationPosition(QgsComposerMap.Disabled,
                                                    QgsComposerMap.Left)
        self.mComposerMap.setGridAnnotationPosition(
            QgsComposerMap.OutsideMapFrame,
            QgsComposerMap.Right)
        self.mComposerMap.setGridAnnotationPosition(QgsComposerMap.Disabled,
                                                    QgsComposerMap.Top)
        self.mComposerMap.setGridAnnotationPosition(
            QgsComposerMap.OutsideMapFrame,
            QgsComposerMap.Bottom)
        self.mComposerMap.setGridAnnotationDirection(QgsComposerMap.Horizontal,
                                                     QgsComposerMap.Right)
        self.mComposerMap.setGridAnnotationDirection(QgsComposerMap.Horizontal,
                                                     QgsComposerMap.Bottom)
        self.mComposerMap.setAnnotationFontColor(QColor(255,0,0,150))
        self.mComposerMap.setGridBlendMode(QPainter.CompositionMode_Overlay)
        checker = QgsCompositionChecker('composermap_grid', self.mComposition)
        myTestResult, myMessage = checker.testComposition()
        self.mComposerMap.setGridEnabled(False)
        self.mComposerMap.setShowGridAnnotation(False)

        assert myTestResult == True, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def testGrid(self):
        """Test that we can create a grid for a map."""
        myRectangle = QgsRectangle(781662.375, 3339523.125,
                                   793062.375, 3345223.125)
        self.mComposerMap.setNewExtent(myRectangle)
        self.mComposerMap.grid().setEnabled(True)
        self.mComposerMap.grid().setIntervalX(2000)
        self.mComposerMap.grid().setIntervalY(2000)
        self.mComposerMap.grid().setAnnotationEnabled(True)
        self.mComposerMap.grid().setGridLineColor(QColor(0, 255, 0))
        self.mComposerMap.grid().setGridLineWidth(0.5)
        self.mComposerMap.grid().setAnnotationFont(QgsFontUtils.getStandardTestFont())
        self.mComposerMap.grid().setAnnotationPrecision(0)
        self.mComposerMap.grid().setAnnotationDisplay(QgsComposerMapGrid.HideAll, QgsComposerMapGrid.Left)
        self.mComposerMap.grid().setAnnotationPosition(QgsComposerMapGrid.OutsideMapFrame, QgsComposerMapGrid.Right)
        self.mComposerMap.grid().setAnnotationDisplay(QgsComposerMapGrid.HideAll, QgsComposerMapGrid.Top)
        self.mComposerMap.grid().setAnnotationPosition(QgsComposerMapGrid.OutsideMapFrame, QgsComposerMapGrid.Bottom)
        self.mComposerMap.grid().setAnnotationDirection(QgsComposerMapGrid.Horizontal, QgsComposerMapGrid.Right)
        self.mComposerMap.grid().setAnnotationDirection(QgsComposerMapGrid.Horizontal, QgsComposerMapGrid.Bottom)
        self.mComposerMap.grid().setAnnotationFontColor(QColor(255, 0, 0, 150))
        self.mComposerMap.grid().setBlendMode(QPainter.CompositionMode_Overlay)
        self.mComposerMap.updateBoundingRect()

        checker = QgsCompositionChecker('composermap_grid', self.mComposition)
        checker.setControlPathPrefix("composer_mapgrid")
        myTestResult, myMessage = checker.testComposition()
        self.mComposerMap.grid().setEnabled(False)
        self.mComposerMap.grid().setAnnotationEnabled(False)

        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
 def testOverviewMapCenter(self):
     overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
     overviewMap.setFrameEnabled(True)
     self.mComposition.addComposerMap(overviewMap)
     # zoom in
     myRectangle = QgsRectangle(785462.375+5000, 3341423.125,
                                789262.375+5000, 3343323.125)
     self.mComposerMap.setNewExtent(myRectangle)
     myRectangle2 = QgsRectangle(781662.375, 3339523.125,
                                 793062.375, 3350923.125)
     overviewMap.setNewExtent(myRectangle2)
     overviewMap.setOverviewFrameMap(self.mComposerMap.id())
     overviewMap.setOverviewInverted(False)
     overviewMap.setOverviewCentered(True)
     checker = QgsCompositionChecker()
     myPngPath = os.path.join(TEST_DATA_DIR,
                              'control_images',
                              'expected_composermap',
                              'composermap_landsat_overview_center.png')
     myTestResult, myMessage = checker.testComposition(
                               'Composer map overview centered',
                               self.mComposition,
                               myPngPath)
     self.mComposition.removeComposerItem(overviewMap)
     assert myTestResult == True, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def testResizeZoom(self):
        """Test picture resize zoom mode."""
        self.composerPicture.setResizeMode(QgsComposerPicture.Zoom)

        checker = QgsCompositionChecker('composerpicture_resize_zoom', self.composition)
        testResult, message = checker.testComposition()

        assert testResult, message

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def testDefaultStyle(self):
        """Test polygon rendering with default style."""

        self.mComposerPolygon.setDisplayNodes(False)
        checker = QgsCompositionChecker("composerpolygon_defaultstyle", self.mComposition)
        checker.setControlPathPrefix("composer_polygon")
        myTestResult, myMessage = checker.testComposition()
        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def testSelectedNode(self):
        """Test selectedNode and unselectNode methods"""

        self.mComposerPolygon.setDisplayNodes(True)

        self.mComposerPolygon.setSelectedNode(3)
        checker = QgsCompositionChecker("composerpolygon_selectednode", self.mComposition)
        checker.setControlPathPrefix("composer_polygon")
        myTestResult, myMessage = checker.testComposition()
        assert myTestResult, myMessage

        self.mComposerPolygon.unselectNode()
        self.mComposerPolygon.setDisplayNodes(False)
        checker = QgsCompositionChecker("composerpolygon_defaultstyle", self.mComposition)
        checker.setControlPathPrefix("composer_polygon")
        myTestResult, myMessage = checker.testComposition()
        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def testZebraStyleSides(self):
        self.mComposerMap.grid().setFrameStyle(QgsComposerMapGrid.Zebra)
        myRectangle = QgsRectangle(781662.375, 3339523.125, 793062.375, 3345223.125)
        self.mComposerMap.setNewExtent(myRectangle)
        self.mComposerMap.grid().setIntervalX(2000)
        self.mComposerMap.grid().setIntervalY(2000)
        self.mComposerMap.grid().setGridLineColor(QColor(0, 0, 0))
        self.mComposerMap.grid().setAnnotationFontColor(QColor(0, 0, 0))
        self.mComposerMap.grid().setBlendMode(QPainter.CompositionMode_SourceOver)
        self.mComposerMap.grid().setFrameStyle(QgsComposerMapGrid.Zebra)
        self.mComposerMap.grid().setFrameWidth(10)
        self.mComposerMap.grid().setFramePenSize(1)
        self.mComposerMap.grid().setGridLineWidth(0.5)
        self.mComposerMap.grid().setFramePenColor(QColor(0, 0, 0))
        self.mComposerMap.grid().setFrameFillColor1(QColor(0, 0, 0))
        self.mComposerMap.grid().setFrameFillColor2(QColor(255, 255, 255))
        self.mComposerMap.grid().setEnabled(True)

        self.mComposerMap.grid().setFrameSideFlag(QgsComposerMapGrid.FrameLeft, True)
        self.mComposerMap.grid().setFrameSideFlag(QgsComposerMapGrid.FrameRight, False)
        self.mComposerMap.grid().setFrameSideFlag(QgsComposerMapGrid.FrameTop, False)
        self.mComposerMap.grid().setFrameSideFlag(QgsComposerMapGrid.FrameBottom, False)
        self.mComposerMap.updateBoundingRect()

        checker = QgsCompositionChecker('composermap_zebrastyle_left', self.mComposition)
        checker.setControlPathPrefix("composer_mapgrid")
        myTestResult, myMessage = checker.testComposition(0, 100)
        assert myTestResult, myMessage

        self.mComposerMap.grid().setFrameSideFlag(QgsComposerMapGrid.FrameTop, True)
        self.mComposerMap.updateBoundingRect()
        checker = QgsCompositionChecker('composermap_zebrastyle_lefttop', self.mComposition)
        checker.setControlPathPrefix("composer_mapgrid")
        myTestResult, myMessage = checker.testComposition(0, 100)
        assert myTestResult, myMessage

        self.mComposerMap.grid().setFrameSideFlag(QgsComposerMapGrid.FrameRight, True)
        self.mComposerMap.updateBoundingRect()
        checker = QgsCompositionChecker('composermap_zebrastyle_lefttopright', self.mComposition)
        checker.setControlPathPrefix("composer_mapgrid")
        myTestResult, myMessage = checker.testComposition(0, 100)
        assert myTestResult, myMessage

        self.mComposerMap.grid().setFrameSideFlag(QgsComposerMapGrid.FrameBottom, True)
        self.mComposerMap.grid().setFrameStyle(QgsComposerMapGrid.NoFrame)

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def testRemoteImage(self):
        """Test fetching remote picture."""
        self.composerPicture.setPicturePath('http://localhost:' + str(TestQgsComposerPicture.port) + '/qgis_local_server/logo.png')

        checker = QgsCompositionChecker('composerpicture_remote', self.composition)
        testResult, message = checker.testComposition()

        self.composerPicture.setPicturePath(self.pngImage)
        assert testResult, message

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def testTriangle(self):
        """Test triangle composer shape"""

        self.mComposerShape.setShapeType(QgsComposerShape.Triangle)

        checker = QgsCompositionChecker('composershapes_triangle', self.mComposition)
        myTestResult, myMessage = checker.testComposition()

        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def testEllipse(self):
        """Test ellipse composer shape"""

        self.mComposerShape.setShapeType(QgsComposerShape.Ellipse)

        checker = QgsCompositionChecker('composershapes_ellipse', self.mComposition)
        myTestResult, myMessage = checker.testComposition()

        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import testComposition [as 别名]
    def legend_test(self):
        self.mAtlasMap.setAtlasDriven(True)
        self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
        self.mAtlasMap.setAtlasMargin(0.10)

        # add a point layer
        ptLayer = QgsVectorLayer("Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)", "points", "memory")

        pr = ptLayer.dataProvider()
        f1 = QgsFeature(1)
        f1.initAttributes(2)
        f1.setAttribute(0, 1)
        f1.setAttribute(1, "Test label 1")
        f1.setGeometry(QgsGeometry.fromPoint(QgsPointXY(-0.638, 48.954)))
        f2 = QgsFeature(2)
        f2.initAttributes(2)
        f2.setAttribute(0, 2)
        f2.setAttribute(1, "Test label 2")
        f2.setGeometry(QgsGeometry.fromPoint(QgsPointXY(-1.682, 48.550)))
        pr.addFeatures([f1, f2])

        # categorized symbology
        r = QgsCategorizedSymbolRenderer("attr", [QgsRendererCategory(1, QgsMarkerSymbol.createSimple({"color": "255,0,0"}), "red"),
                                                  QgsRendererCategory(2, QgsMarkerSymbol.createSimple({"color": "0,0,255"}), "blue")])
        ptLayer.setRenderer(r)

        QgsProject.instance().addMapLayer(ptLayer)

        # add the point layer to the map settings
        layers = self.layers
        layers = [ptLayer] + layers
        self.mAtlasMap.setLayers(layers)
        self.mOverview.setLayers(layers)

        # add a legend
        legend = QgsComposerLegend(self.mComposition)
        legend.moveBy(200, 100)
        # sets the legend filter parameter
        legend.setComposerMap(self.mAtlasMap)
        legend.setLegendFilterOutAtlas(True)
        self.mComposition.addComposerLegend(legend)

        self.mAtlas.beginRender()

        self.mAtlas.prepareForFeature(0)
        self.mLabel1.adjustSizeToText()

        checker = QgsCompositionChecker('atlas_legend', self.mComposition)
        myTestResult, myMessage = checker.testComposition()
        assert myTestResult

        self.mAtlas.endRender()

        # restore state
        self.mAtlasMap.setLayers([layers[1]])
        self.mComposition.removeComposerItem(legend)
        QgsProject.instance().removeMapLayer(ptLayer.id())