def testRemoveComposition(self): project = QgsProject() composition = QgsComposition(project) composition.setName('test composition') self.manager = QgsLayoutManager(project) composition_removed_spy = QSignalSpy(self.manager.compositionRemoved) composition_about_to_be_removed_spy = QSignalSpy(self.manager.compositionAboutToBeRemoved) # tests that composition still exists when compositionAboutToBeRemoved is fired self.manager.compositionAboutToBeRemoved.connect(self.aboutToBeRemoved) # not added, should fail self.assertFalse(self.manager.removeComposition(composition)) self.assertEqual(len(composition_removed_spy), 0) self.assertEqual(len(composition_about_to_be_removed_spy), 0) self.assertTrue(self.manager.addComposition(composition)) self.assertEqual(self.manager.compositions(), [composition]) self.assertTrue(self.manager.removeComposition(composition)) self.assertEqual(len(self.manager.compositions()), 0) self.assertEqual(len(composition_removed_spy), 1) self.assertEqual(composition_removed_spy[0][0], 'test composition') self.assertEqual(len(composition_about_to_be_removed_spy), 1) self.assertEqual(composition_about_to_be_removed_spy[0][0], 'test composition') self.assertTrue(self.aboutFired) self.manager = None
def testSubstitutionMap(self): """Test that we can use degree symbols in substitutions. """ # Create a point and convert it to text containing a degree symbol. myPoint = QgsPoint(12.3, -33.33) myCoordinates = myPoint.toDegreesMinutesSeconds(2) myTokens = myCoordinates.split(',') myLongitude = myTokens[0] myLatitude = myTokens[1] myText = 'Latitude: %s, Longitude: %s' % (myLatitude, myLongitude) # Load the composition with the substitutions myComposition = QgsComposition(self.iface.mapCanvas().mapRenderer()) mySubstitutionMap = {'replace-me': myText} myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt') myTemplateFile = file(myFile, 'rt') myTemplateContent = myTemplateFile.read() myTemplateFile.close() myDocument = QDomDocument() myDocument.setContent(myTemplateContent) myComposition.loadFromTemplate(myDocument, mySubstitutionMap) # We should be able to get map0 myMap = myComposition.getComposerMapById(0) myMessage = ('Map 0 could not be found in template %s', myFile) assert myMap is not None, myMessage
def testTrueNorth(self): """Test syncing picture to true north""" mapSettings = QgsMapSettings() composition = QgsComposition(mapSettings, QgsProject.instance()) composerMap = QgsComposerMap(composition) composerMap.setCrs(QgsCoordinateReferenceSystem.fromEpsgId(3575)) composerMap.setNewExtent(QgsRectangle(-2126029.962, -2200807.749, -119078.102, -757031.156)) composition.addComposerMap(composerMap) composerPicture = QgsComposerPicture(composition) composition.addComposerPicture(composerPicture) composerPicture.setRotationMap(composerMap.id()) self.assertTrue(composerPicture.rotationMap() >= 0) composerPicture.setNorthMode(QgsComposerPicture.TrueNorth) self.assertAlmostEqual(composerPicture.pictureRotation(), 37.20, 1) # shift map composerMap.setNewExtent(QgsRectangle(2120672.293, -3056394.691, 2481640.226, -2796718.780)) self.assertAlmostEqual(composerPicture.pictureRotation(), -38.18, 1) # rotate map composerMap.setMapRotation(45) self.assertAlmostEqual(composerPicture.pictureRotation(), -38.18 + 45, 1) # add an offset composerPicture.setNorthOffset(-10) self.assertAlmostEqual(composerPicture.pictureRotation(), -38.18 + 35, 1)
class TestQgsComposerShapes(unittest.TestCase): def __init__(self, methodName): """Run once on class initialization.""" unittest.TestCase.__init__(self, methodName) # create composition self.mComposition = QgsComposition(QgsProject.instance()) self.mComposition.setPaperSize(297, 210) self.mComposerShape = QgsComposerShape(20, 20, 150, 100, self.mComposition) self.mComposerShape.setBackgroundColor(QColor.fromRgb(255, 150, 0)) self.mComposition.addComposerShape(self.mComposerShape) def testRectangle(self): """Test rectangle composer shape""" self.mComposerShape.setShapeType(QgsComposerShape.Rectangle) checker = QgsCompositionChecker('composershapes_rectangle', self.mComposition) checker.setControlPathPrefix("composer_shapes") myTestResult, myMessage = checker.testComposition() assert myTestResult, myMessage def testEllipse(self): """Test ellipse composer shape""" self.mComposerShape.setShapeType(QgsComposerShape.Ellipse) checker = QgsCompositionChecker('composershapes_ellipse', self.mComposition) checker.setControlPathPrefix("composer_shapes") myTestResult, myMessage = checker.testComposition() assert myTestResult, myMessage def testTriangle(self): """Test triangle composer shape""" self.mComposerShape.setShapeType(QgsComposerShape.Triangle) checker = QgsCompositionChecker('composershapes_triangle', self.mComposition) checker.setControlPathPrefix("composer_shapes") myTestResult, myMessage = checker.testComposition() assert myTestResult, myMessage def testRoundedRectangle(self): """Test rounded rectangle composer shape""" self.mComposerShape.setShapeType(QgsComposerShape.Rectangle) self.mComposerShape.setCornerRadius(30) checker = QgsCompositionChecker('composershapes_roundedrect', self.mComposition) checker.setControlPathPrefix("composer_shapes") myTestResult, myMessage = checker.testComposition() self.mComposerShape.setCornerRadius(0) assert myTestResult, myMessage
def testReadWriteXml(self): """ Test reading and writing layout manager state to XML """ project = QgsProject() manager = QgsLayoutManager(project) # add a bunch of compositions composition = QgsComposition(project) composition.setName('test composition') composition2 = QgsComposition(project) composition2.setName('test composition2') composition3 = QgsComposition(project) composition3.setName('test composition3') manager.addComposition(composition) manager.addComposition(composition2) manager.addComposition(composition3) # save to xml doc = QDomDocument("testdoc") elem = manager.writeXml(doc) doc.appendChild(elem) # restore from xml project2 = QgsProject() manager2 = QgsLayoutManager(project2) self.assertTrue(manager2.readXml(elem, doc)) self.assertEqual(len(manager2.compositions()), 3) names = [c.name() for c in manager2.compositions()] self.assertEqual(set(names), {'test composition', 'test composition2', 'test composition3'})
def testAddComposition(self): project = QgsProject() composition = QgsComposition(project) composition.setName('test composition') manager = QgsLayoutManager(project) composition_about_to_be_added_spy = QSignalSpy(manager.compositionAboutToBeAdded) composition_added_spy = QSignalSpy(manager.compositionAdded) self.assertTrue(manager.addComposition(composition)) self.assertEqual(len(composition_about_to_be_added_spy), 1) self.assertEqual(composition_about_to_be_added_spy[0][0], 'test composition') self.assertEqual(len(composition_added_spy), 1) self.assertEqual(composition_added_spy[0][0], 'test composition') # adding it again should fail self.assertFalse(manager.addComposition(composition)) # try adding a second composition composition2 = QgsComposition(project) composition2.setName('test composition2') self.assertTrue(manager.addComposition(composition2)) self.assertEqual(len(composition_added_spy), 2) self.assertEqual(composition_about_to_be_added_spy[1][0], 'test composition2') self.assertEqual(len(composition_about_to_be_added_spy), 2) self.assertEqual(composition_added_spy[1][0], 'test composition2') # adding a composition with duplicate name should fail composition3 = QgsComposition(project) composition3.setName('test composition2') self.assertFalse(manager.addComposition(composition3))
def make_pdf(): canvas = QgsMapCanvas() # Load our project QgsProject.instance().read(QFileInfo(project_path)) bridge = QgsLayerTreeMapCanvasBridge( QgsProject.instance().layerTreeRoot(), canvas) bridge.setCanvasLayers() if canvas.layerCount() < 1: print 'No layers loaded from this project, exiting.' return print canvas.mapSettings().extent().toString() template_file = file(template_path) template_content = template_file.read() template_file.close() document = QDomDocument() document.setContent(template_content) composition = QgsComposition(canvas.mapSettings()) # You can use this to replace any string like this [key] # in the template with a new value. e.g. to replace # [date] pass a map like this {'date': '1 Jan 2012'} substitution_map = { 'DATE_TIME_START': TIME_START, 'DATE_TIME_END': TIME_STOP} composition.loadFromTemplate(document, substitution_map) # You must set the id in the template map_item = composition.getComposerItemById('map') map_item.setMapCanvas(canvas) map_item.zoomToExtent(canvas.extent()) # You must set the id in the template legend_item = composition.getComposerItemById('legend') legend_item.updateLegend() composition.refreshItems() composition.exportAsPDF( '/home/web/reports/pdf/%s/%s.pdf' % (TIME_SLICE, LABEL)) QgsProject.instance().clear()
def loadComposersFromProject( self, doc ): ''' Load composers from project document ''' composerNodeList = doc.elementsByTagName( "Composer" ); i = 0 while i < composerNodeList.size() : composerElem = composerNodeList.at(i).toElement() title = composerElem.attribute( "title" ) visible = composerElem.attribute( "visible" ) composition = QgsComposition( self.canvas.mapSettings() ); compositionNodeList = composerElem.elementsByTagName( "Composition" ) if compositionNodeList.size() > 0 : compositionElem = compositionNodeList.at( 0 ).toElement(); composition.readXML( compositionElem, doc ); atlasElem = composerElem.firstChildElement( "Atlas" ); composition.atlasComposition().readXML( atlasElem, doc ); composition.addItemsFromXML( composerElem, doc ); composition.atlasComposition().readXMLMapSettings( atlasElem, doc ); self.composers.append({ 'title': title, 'visible': visible, 'composition': composition }) i += 1
def testPrintMapFromTemplate(self): """Test that we can get a map to render in the template.""" myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif') myFileInfo = QFileInfo(myPath) myRasterLayer = QgsRasterLayer(myFileInfo.filePath(), myFileInfo.completeBaseName()) myRenderer = QgsMultiBandColorRenderer( myRasterLayer.dataProvider(), 2, 3, 4 ) #mRasterLayer.setRenderer( rasterRenderer ) myPipe = myRasterLayer.pipe() assert myPipe.set(myRenderer), "Cannot set pipe renderer" QgsMapLayerRegistry.instance().addMapLayers([myRasterLayer]) myMapRenderer = QgsMapRenderer() myLayerStringList = [] myLayerStringList.append(myRasterLayer.id()) myMapRenderer.setLayerSet(myLayerStringList) myMapRenderer.setProjectionsEnabled(False) myComposition = QgsComposition(myMapRenderer) myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt') myTemplateFile = file(myFile, 'rt') myTemplateContent = myTemplateFile.read() myTemplateFile.close() myDocument = QDomDocument() myDocument.setContent(myTemplateContent) myComposition.loadFromTemplate(myDocument) # now render the map, first zooming to the raster extents myMap = myComposition.getComposerMapById(0) myMessage = ('Map 0 could not be found in template %s', myFile) assert myMap is not None, myMessage myExtent = myRasterLayer.extent() myMap.setNewExtent(myExtent) myImagePath = os.path.join(str(QDir.tempPath()), 'template_map_render_python.png') myPageNumber = 0 myImage = myComposition.printPageAsRaster(myPageNumber) myImage.save(myImagePath) assert os.path.exists(myImagePath), 'Map render was not created.' # Not sure if this is a predictable way to test but its quicker than # rendering. myFileSize = QFileInfo(myImagePath).size() myExpectedFileSize = 100000 myMessage = ('Expected file size to be greater than %s, got %s' ' for %s' % (myExpectedFileSize, myFileSize, myImagePath)) assert myFileSize > myExpectedFileSize, myMessage
class TestQgsComposerPicture(unittest.TestCase): @classmethod def setUpClass(cls): # Bring up a simple HTTP server, for remote picture tests os.chdir(unitTestDataPath() + "") handler = SimpleHTTPServer.SimpleHTTPRequestHandler cls.httpd = SocketServer.TCPServer(("localhost", 0), handler) cls.port = cls.httpd.server_address[1] cls.httpd_thread = threading.Thread(target=cls.httpd.serve_forever) cls.httpd_thread.setDaemon(True) cls.httpd_thread.start() def __init__(self, methodName): """Run once on class initialization.""" unittest.TestCase.__init__(self, methodName) TEST_DATA_DIR = unitTestDataPath() self.pngImage = TEST_DATA_DIR + "/sample_image.png" # create composition self.mapSettings = QgsMapSettings() self.composition = QgsComposition(self.mapSettings) self.composition.setPaperSize(297, 210) self.composerPicture = QgsComposerPicture(self.composition) self.composerPicture.setPicturePath(self.pngImage) self.composerPicture.setSceneRect(QRectF(70, 70, 100, 100)) self.composerPicture.setFrameEnabled(True) self.composition.addComposerPicture(self.composerPicture) def testResizeZoom(self): """Test picture resize zoom mode.""" self.composerPicture.setResizeMode(QgsComposerPicture.Zoom) checker = QgsCompositionChecker("composerpicture_resize_zoom", self.composition) checker.setControlPathPrefix("composer_picture") testResult, message = checker.testComposition() assert testResult, message 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) checker.setControlPathPrefix("composer_picture") testResult, message = checker.testComposition() self.composerPicture.setPicturePath(self.pngImage) assert testResult, message
def testSaveAsTemplate(self): """ Test saving composition as template """ project = QgsProject() manager = QgsLayoutManager(project) doc = QDomDocument("testdoc") self.assertFalse(manager.saveAsTemplate('not in manager', doc)) composition = QgsComposition(project) composition.setName('test composition') manager.addComposition(composition) self.assertTrue(manager.saveAsTemplate('test composition', doc))
def testNoSubstitutionMap(self): """Test that we can get a map if we use no text substitutions.""" myComposition = QgsComposition(self.iface.mapCanvas().mapRenderer()) myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt') with open(myFile) as f: myTemplateContent = f.read() myDocument = QDomDocument() myDocument.setContent(myTemplateContent) myComposition.loadFromTemplate(myDocument) # We should be able to get map0 myMap = myComposition.getComposerMapById(0) myMessage = ('Map 0 could not be found in template %s', myFile) assert myMap is not None, myMessage
def testComposerHtmlAccessor(self): """Test that we can retrieve the ComposerHtml instance given an item. """ myComposition = QgsComposition(self.iface.mapCanvas().mapRenderer()) mySubstitutionMap = {'replace-me': 'Foo bar'} myFile = os.path.join(TEST_DATA_DIR, 'template.qpt') with open(myFile, 'rt') as myTemplateFile: myTemplateContent = myTemplateFile.read() myDocument = QDomDocument() myDocument.setContent(myTemplateContent) myComposition.loadFromTemplate(myDocument, mySubstitutionMap) myItem = myComposition.getComposerItemById('html-test') myComposerHtml = myComposition.getComposerHtmlByItem(myItem) myMessage = 'Could not retrieve the composer html given an item' self.assertIsNotNone(myComposerHtml, myMessage)
def __init__(self, methodName): """Run once on class initialization.""" unittest.TestCase.__init__(self, methodName) myPath = os.path.join(TEST_DATA_DIR, 'rgb256x256.png') rasterFileInfo = QFileInfo(myPath) self.raster_layer = QgsRasterLayer(rasterFileInfo.filePath(), rasterFileInfo.completeBaseName()) rasterRenderer = QgsMultiBandColorRenderer( self.raster_layer.dataProvider(), 1, 2, 3) self.raster_layer.setRenderer(rasterRenderer) myPath = os.path.join(TEST_DATA_DIR, 'points.shp') vector_file_info = QFileInfo(myPath) self.vector_layer = QgsVectorLayer(vector_file_info.filePath(), vector_file_info.completeBaseName(), 'ogr') assert self.vector_layer.isValid() # pipe = mRasterLayer.pipe() # assert pipe.set(rasterRenderer), 'Cannot set pipe renderer' QgsProject.instance().addMapLayers([self.raster_layer, self.vector_layer]) # create composition with composer map self.mComposition = QgsComposition(QgsProject.instance()) self.mComposition.setPaperSize(297, 210) self.mComposerMap = QgsComposerMap(self.mComposition, 20, 20, 200, 100) self.mComposerMap.setFrameEnabled(True) self.mComposerMap.setLayers([self.raster_layer]) self.mComposition.addComposerMap(self.mComposerMap)
def _set_up_composition(self, width, height, dpi): # set up composition and add map self._c = QgsComposition(self._TestMapSettings, QgsProject.instance()) """:type: QgsComposition""" # self._c.setUseAdvancedEffects(False) self._c.setPrintResolution(dpi) # 600 x 400 px = 211.67 x 141.11 mm @ 72 dpi paperw = width * 25.4 / dpi paperh = height * 25.4 / dpi self._c.setPaperSize(paperw, paperh) # NOTE: do not use QgsComposerMap(self._c, 0, 0, paperw, paperh) since # it only takes integers as parameters and the composition will grow # larger based upon union of item scene rectangles and a slight buffer # see end of QgsComposition::compositionBounds() # add map as small graphics item first, then set its scene QRectF later self._cmap = QgsComposerMap(self._c, 10, 10, 10, 10) """:type: QgsComposerMap""" self._cmap.setPreviewMode(QgsComposerMap.Render) self._cmap.setFrameEnabled(False) self._c.addComposerMap(self._cmap) # now expand map to fill page and set its extent self._cmap.setSceneRect(QRectF(0, 0, paperw, paperw)) self._cmap.setNewExtent(self.aoiExtent()) # self._cmap.updateCachedImage() self._c.setPlotStyle(QgsComposition.Print)
def __init__(self, methodName): """Run once on class initialization.""" unittest.TestCase.__init__(self, methodName) self.mapSettings = QgsMapSettings() # create composition self.mComposition = QgsComposition(self.mapSettings) self.mComposition.setPaperSize(297, 210) # create polygon = QPolygonF() polygon.append(QPointF(0.0, 0.0)) polygon.append(QPointF(100.0, 0.0)) polygon.append(QPointF(200.0, 100.0)) polygon.append(QPointF(100.0, 200.0)) self.mComposerPolygon = QgsComposerPolygon(polygon, self.mComposition) self.mComposition.addComposerPolygon(self.mComposerPolygon) # style props = {} props["color"] = "green" props["style"] = "solid" props["style_border"] = "solid" props["color_border"] = "black" props["width_border"] = "10.0" props["joinstyle"] = "miter" style = QgsFillSymbol.createSimple(props) self.mComposerPolygon.setPolygonStyleSymbol(style)
def testComposerHtmlAccessor(self): """Test that we can retrieve the ComposerHtml instance given an item. """ myComposition = QgsComposition(CANVAS.mapRenderer()) mySubstitutionMap = {"replace-me": "Foo bar"} myFile = os.path.join(TEST_DATA_DIR, "template.qpt") myTemplateFile = file(myFile, "rt") myTemplateContent = myTemplateFile.read() myTemplateFile.close() myDocument = QDomDocument() myDocument.setContent(myTemplateContent) myComposition.loadFromTemplate(myDocument, mySubstitutionMap) myItem = myComposition.getComposerItemById("html-test") myComposerHtml = myComposition.getComposerHtmlByItem(myItem) myMessage = "Could not retrieve the composer html given an item" assert myComposerHtml is not None, myMessage
def __init__(self, methodName): """Run once on class initialization.""" unittest.TestCase.__init__(self, methodName) self.mapSettings = QgsMapSettings() # create composition self.mComposition = QgsComposition(self.mapSettings, QgsProject.instance()) self.mComposition.setPaperSize(297, 210) # create polygon = QPolygonF() polygon.append(QPointF(0.0, 0.0)) polygon.append(QPointF(100.0, 0.0)) polygon.append(QPointF(200.0, 100.0)) polygon.append(QPointF(100.0, 200.0)) self.mComposerPolyline = QgsComposerPolyline( polygon, self.mComposition) self.mComposition.addComposerPolyline(self.mComposerPolyline) # style props = {} props["color"] = "0,0,0,255" props["width"] = "10.0" props["capstyle"] = "square" style = QgsLineSymbol.createSimple(props) self.mComposerPolyline.setPolylineStyleSymbol(style)
def __init__(self, methodName): """Run once on class initialisation.""" unittest.TestCase.__init__(self, methodName) myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif') rasterFileInfo = QFileInfo(myPath) mRasterLayer = QgsRasterLayer(rasterFileInfo.filePath(), rasterFileInfo.completeBaseName()) rasterRenderer = QgsMultiBandColorRenderer( mRasterLayer.dataProvider(), 2, 3, 4) mRasterLayer.setRenderer(rasterRenderer) #pipe = mRasterLayer.pipe() #assert pipe.set(rasterRenderer), 'Cannot set pipe renderer' QgsMapLayerRegistry.instance().addMapLayers([mRasterLayer]) # create composition with composer map self.mMapRenderer = QgsMapRenderer() layerStringList = QStringList() layerStringList.append(mRasterLayer.id()) self.mMapRenderer.setLayerSet(layerStringList) self.mMapRenderer.setProjectionsEnabled(False) self.mComposition = QgsComposition(self.mMapRenderer) self.mComposition.setPaperSize(297, 210) self.mComposerMap = QgsComposerMap(self.mComposition, 20, 20, 200, 100) self.mComposerMap.setFrameEnabled(True) self.mComposition.addComposerMap(self.mComposerMap)
def testDataDefinedTitle(self): mapSettings = QgsMapSettings() # NOQA composition = QgsComposition(QgsProject.instance()) composition.setPaperSize(297, 210) legend = QgsComposerLegend(composition) composition.addComposerLegend(legend) legend.setTitle('original') self.assertEqual(legend.title(), 'original') self.assertEqual(legend.legendSettings().title(), 'original') legend.dataDefinedProperties().setProperty(QgsComposerObject.LegendTitle, QgsProperty.fromExpression("'new'")) legend.refreshDataDefinedProperty() self.assertEqual(legend.title(), 'original') self.assertEqual(legend.legendSettings().title(), 'new')
def testDataDefinedColumnCount(self): mapSettings = QgsMapSettings() # NOQA composition = QgsComposition(QgsProject.instance()) composition.setPaperSize(297, 210) legend = QgsComposerLegend(composition) composition.addComposerLegend(legend) legend.setColumnCount(2) self.assertEqual(legend.columnCount(), 2) self.assertEqual(legend.legendSettings().columnCount(), 2) legend.dataDefinedProperties().setProperty(QgsComposerObject.LegendColumnCount, QgsProperty.fromExpression("5")) legend.refreshDataDefinedProperty() self.assertEqual(legend.columnCount(), 2) self.assertEqual(legend.legendSettings().columnCount(), 5)
def testDataDefinedBackgroundColor(self): mapSettings = QgsMapSettings() # NOQA composition = QgsComposition(QgsProject.instance()) composition.setPaperSize(297, 210) item = QgsComposerLabel(composition) composition.addComposerLabel(item) item.setBackgroundColor(QColor(255, 0, 0)) self.assertEqual(item.backgroundColor(), QColor(255, 0, 0)) self.assertEqual(item.brush().color().name(), QColor(255, 0, 0).name()) item.dataDefinedProperties().setProperty(QgsComposerObject.BackgroundColor, QgsProperty.fromExpression("'blue'")) item.refreshDataDefinedProperty() self.assertEqual(item.backgroundColor(), QColor(255, 0, 0)) # should not change self.assertEqual(item.brush().color().name(), QColor(0, 0, 255).name())
def setup_composition(self): """Set up the composition ready for drawing elements onto it.""" LOGGER.debug('InaSAFE Map setupComposition called') canvas = self.iface.mapCanvas() renderer = canvas.mapRenderer() self.composition = QgsComposition(renderer) self.composition.setPlotStyle(QgsComposition.Preview) # or preview self.composition.setPrintResolution(self.page_dpi) self.composition.setPrintAsRaster(True)
def export_pdf(self, title=''): ''' Export Composition (map view and checked layers) to PDF ''' title = self.active_scenario.name if self.active_scenario else '' dialog = ExportPDFDialog(title=title, parent=self) result = dialog.exec_() ok = result == QtGui.QDialog.Accepted if not ok: return title = dialog.title date = dialog.date filepath = browse_file(None, 'Export', PDF_FILTER, save=True, parent=self) if not filepath: return bridge = QgsLayerTreeMapCanvasBridge( QgsProject.instance().layerTreeRoot(), self.canvas) bridge.setCanvasLayers() template_file = file(REPORT_TEMPLATE_PATH) template_content = template_file.read() template_file.close() document = QDomDocument() document.setContent(template_content) composition = QgsComposition(self.canvas.mapSettings()) # You can use this to replace any string like this [key] # in the template with a new value. e.g. to replace # [date] pass a map like this {'date': '1 Jan 2012'} substitution_map = { 'TITLE': title, 'DATE_TIME': date} composition.loadFromTemplate(document, substitution_map) # You must set the id in the template map_item = composition.getComposerItemById('map') map_item.setMapCanvas(self.canvas) map_item.zoomToExtent(self.canvas.extent()) # You must set the id in the template legend_item = composition.getComposerItemById('legend') legend_item.updateLegend() composition.refreshItems() composition.exportAsPDF(filepath) if sys.platform.startswith('darwin'): subprocess.call(('open', filepath)) elif os.name == 'nt': os.startfile(filepath) elif os.name == 'posix': subprocess.call(('xdg-open', filepath))
def from_file(cls, template_path, mapsettings, data=None): """ Create a template object from the given template path, map setttings, and data. :param template_path: The template path. :param mapsettings: QgsMapSettings used to render the map. :param data: A dict of data to use for labels. :return: A ComposerTemplate obect which wraps the created template. """ if not data: data = {} with open(template_path) as f: template_content = f.read() document = QDomDocument() document.setContent(template_content) composition = QgsComposition(mapsettings) composition.loadFromTemplate(document, data) return cls(composition)
def testRenameSignal(self): project = QgsProject() manager = QgsLayoutManager(project) composition = QgsComposition(project) composition.setName('c1') manager.addComposition(composition) composition2 = QgsComposition(project) composition2.setName('c2') manager.addComposition(composition2) composition_renamed_spy = QSignalSpy(manager.compositionRenamed) composition.setName('d1') self.assertEqual(len(composition_renamed_spy), 1) self.assertEqual(composition_renamed_spy[0][0], composition) self.assertEqual(composition_renamed_spy[0][1], 'd1') composition2.setName('d2') self.assertEqual(len(composition_renamed_spy), 2) self.assertEqual(composition_renamed_spy[1][0], composition2) self.assertEqual(composition_renamed_spy[1][1], 'd2')
def testMapCrs(self): # create composition with composer map map_settings = QgsMapSettings() map_settings.setLayers([self.vector_layer]) composition = QgsComposition(QgsProject.instance()) composition.setPaperSize(297, 210) # check that new maps inherit project CRS QgsProject.instance().setCrs(QgsCoordinateReferenceSystem('EPSG:4326')) map = QgsComposerMap(composition, 20, 20, 200, 100) map.setFrameEnabled(True) rectangle = QgsRectangle(-13838977, 2369660, -8672298, 6250909) map.setNewExtent(rectangle) map.setLayers([self.vector_layer]) composition.addComposerMap(map) self.assertEqual(map.crs().authid(), 'EPSG:4326') self.assertFalse(map.presetCrs().isValid()) # overwrite CRS map.setCrs(QgsCoordinateReferenceSystem('EPSG:3857')) self.assertEqual(map.crs().authid(), 'EPSG:3857') self.assertEqual(map.presetCrs().authid(), 'EPSG:3857') checker = QgsCompositionChecker('composermap_crs3857', composition) checker.setControlPathPrefix("composer_map") result, message = checker.testComposition() self.assertTrue(result, message) # overwrite CRS map.setCrs(QgsCoordinateReferenceSystem('EPSG:4326')) self.assertEqual(map.presetCrs().authid(), 'EPSG:4326') self.assertEqual(map.crs().authid(), 'EPSG:4326') rectangle = QgsRectangle(-124, 17, -78, 52) map.zoomToExtent(rectangle) checker = QgsCompositionChecker('composermap_crs4326', composition) checker.setControlPathPrefix("composer_map") result, message = checker.testComposition() self.assertTrue(result, message) # change back to project CRS map.setCrs(QgsCoordinateReferenceSystem()) self.assertEqual(map.crs().authid(), 'EPSG:4326') self.assertFalse(map.presetCrs().isValid())
def setup_composition(self): """Set up the composition ready for drawing elements onto it.""" LOGGER.debug('InaSAFE Map setupComposition called') myCanvas = self.iface.mapCanvas() myRenderer = myCanvas.mapRenderer() self.composition = QgsComposition(myRenderer) self.composition.setPlotStyle(QgsComposition.Print) # or preview self.composition.setPaperSize(self.pageWidth, self.pageHeight) self.composition.setPrintResolution(self.pageDpi) self.composition.setPrintAsRaster(True)
def testCompositions(self): project = QgsProject() manager = QgsLayoutManager(project) composition = QgsComposition(project) composition.setName('test composition') composition2 = QgsComposition(project) composition2.setName('test composition2') composition3 = QgsComposition(project) composition3.setName('test composition3') manager.addComposition(composition) self.assertEqual(manager.compositions(), [composition]) manager.addComposition(composition2) self.assertEqual(set(manager.compositions()), {composition, composition2}) manager.addComposition(composition3) self.assertEqual(set(manager.compositions()), {composition, composition2, composition3})
def __init__(self, methodName): """Run once on class initialization.""" unittest.TestCase.__init__(self, methodName) # create composition self.mComposition = QgsComposition(QgsProject.instance()) self.mComposition.setPaperSize(297, 210) self.mComposerShape = QgsComposerShape(20, 20, 150, 100, self.mComposition) self.mComposerShape.setBackgroundColor(QColor.fromRgb(255, 150, 0)) self.mComposition.addComposerShape(self.mComposerShape)
class Map(): """A class for creating a map.""" def __init__(self, iface): """Constructor for the Map class. :param iface: Reference to the QGIS iface object. :type iface: QgsAppInterface """ LOGGER.debug('InaSAFE Map class initialised') self.iface = iface self.layer = iface.activeLayer() self.keywordIO = KeywordIO() self.printer = None self.composition = None self.legend = None self.pageWidth = 210 # width in mm self.pageHeight = 297 # height in mm self.pageDpi = 300.0 self.pageMargin = 10 # margin in mm self.verticalSpacing = 1 # vertical spacing between elements self.showFramesFlag = False # intended for debugging use only # make a square map where width = height = page width self.mapHeight = self.pageWidth - (self.pageMargin * 2) self.mapWidth = self.mapHeight self.disclaimer = self.tr('InaSAFE has been jointly developed by' ' BNPB, AusAid & the World Bank') def tr(self, string): """We implement this since we do not inherit QObject. :param string: String for translation. :type string: QString, str :returns: Translated version of theString. :rtype: QString """ # noinspection PyCallByClass,PyTypeChecker,PyArgumentList return QtCore.QCoreApplication.translate('Map', string) def set_impact_layer(self, layer): """Set the layer that will be used for stats, legend and reporting. :param layer: Layer that will be used for stats, legend and reporting. :type layer: QgsMapLayer, QgsRasterLayer, QgsVectorLayer """ self.layer = layer def setup_composition(self): """Set up the composition ready for drawing elements onto it.""" LOGGER.debug('InaSAFE Map setupComposition called') myCanvas = self.iface.mapCanvas() myRenderer = myCanvas.mapRenderer() self.composition = QgsComposition(myRenderer) self.composition.setPlotStyle(QgsComposition.Print) # or preview self.composition.setPaperSize(self.pageWidth, self.pageHeight) self.composition.setPrintResolution(self.pageDpi) self.composition.setPrintAsRaster(True) def compose_map(self): """Place all elements on the map ready for printing.""" self.setup_composition() # Keep track of our vertical positioning as we work our way down # the page placing elements on it. myTopOffset = self.pageMargin self.draw_logo(myTopOffset) myLabelHeight = self.draw_title(myTopOffset) # Update the map offset for the next row of content myTopOffset += myLabelHeight + self.verticalSpacing myComposerMap = self.draw_map(myTopOffset) self.draw_scalebar(myComposerMap, myTopOffset) # Update the top offset for the next horizontal row of items myTopOffset += self.mapHeight + self.verticalSpacing - 1 myImpactTitleHeight = self.draw_impact_title(myTopOffset) # Update the top offset for the next horizontal row of items if myImpactTitleHeight: myTopOffset += myImpactTitleHeight + self.verticalSpacing + 2 self.draw_legend(myTopOffset) self.draw_host_and_time(myTopOffset) self.draw_disclaimer() def render(self): """Render the map composition to an image and save that to disk. :returns: A three-tuple of: * str: myImagePath - absolute path to png of rendered map * QImage: myImage - in memory copy of rendered map * QRectF: myTargetArea - dimensions of rendered map :rtype: tuple """ LOGGER.debug('InaSAFE Map renderComposition called') # NOTE: we ignore self.composition.printAsRaster() and always rasterise myWidth = (int)(self.pageDpi * self.pageWidth / 25.4) myHeight = (int)(self.pageDpi * self.pageHeight / 25.4) myImage = QtGui.QImage(QtCore.QSize(myWidth, myHeight), QtGui.QImage.Format_ARGB32) myImage.setDotsPerMeterX(dpi_to_meters(self.pageDpi)) myImage.setDotsPerMeterY(dpi_to_meters(self.pageDpi)) # Only works in Qt4.8 #myImage.fill(QtGui.qRgb(255, 255, 255)) # Works in older Qt4 versions myImage.fill(55 + 255 * 256 + 255 * 256 * 256) myImagePainter = QtGui.QPainter(myImage) mySourceArea = QtCore.QRectF(0, 0, self.pageWidth, self.pageHeight) myTargetArea = QtCore.QRectF(0, 0, myWidth, myHeight) self.composition.render(myImagePainter, myTargetArea, mySourceArea) myImagePainter.end() myImagePath = unique_filename(prefix='mapRender_', suffix='.png', dir=temp_dir()) myImage.save(myImagePath) return myImagePath, myImage, myTargetArea def make_pdf(self, filename): """Generate the printout for our final map. :param filename: Path on the file system to which the pdf should be saved. If None, a generated file name will be used. :type filename: str :returns: File name of the output file (equivalent to filename if provided). :rtype: str """ LOGGER.debug('InaSAFE Map printToPdf called') if filename is None: myMapPdfPath = unique_filename(prefix='report', suffix='.pdf', dir=temp_dir('work')) else: # We need to cast to python string in case we receive a QString myMapPdfPath = str(filename) self.compose_map() self.printer = setup_printer(myMapPdfPath) _, myImage, myRectangle = self.render() myPainter = QtGui.QPainter(self.printer) myPainter.drawImage(myRectangle, myImage, myRectangle) myPainter.end() return myMapPdfPath def draw_logo(self, top_offset): """Add a picture containing the logo to the map top left corner :param top_offset: Vertical offset at which the logo should be drawn. :type top_offset: int """ myLogo = QgsComposerPicture(self.composition) myLogo.setPictureFile(':/plugins/inasafe/bnpb_logo.png') myLogo.setItemPosition(self.pageMargin, top_offset, 10, 10) if qgis_version() >= 10800: # 1.8 or newer myLogo.setFrameEnabled(self.showFramesFlag) else: myLogo.setFrame(self.showFramesFlag) myLogo.setZValue(1) # To ensure it overlays graticule markers self.composition.addItem(myLogo) def draw_title(self, top_offset): """Add a title to the composition. :param top_offset: Vertical offset at which the logo should be drawn. :type top_offset: int :returns: The height of the label as rendered. :rtype: float """ LOGGER.debug('InaSAFE Map drawTitle called') myFontSize = 14 myFontWeight = QtGui.QFont.Bold myItalicsFlag = False myFont = QtGui.QFont('verdana', myFontSize, myFontWeight, myItalicsFlag) myLabel = QgsComposerLabel(self.composition) myLabel.setFont(myFont) myHeading = self.tr('InaSAFE - Indonesia Scenario Assessment' ' for Emergencies') myLabel.setText(myHeading) myLabel.adjustSizeToText() myLabelHeight = 10.0 # determined using qgis map composer myLabelWidth = 170.0 # item - position and size...option myLeftOffset = self.pageWidth - self.pageMargin - myLabelWidth myLabel.setItemPosition( myLeftOffset, top_offset - 2, # -2 to push it up a little myLabelWidth, myLabelHeight, ) myLabel.setFrame(self.showFramesFlag) self.composition.addItem(myLabel) return myLabelHeight def draw_map(self, top_offset): """Add a map to the composition and return the composer map instance. :param top_offset: Vertical offset at which the logo should be drawn. :type top_offset: int :returns: The composer map. :rtype: QgsComposerMap """ LOGGER.debug('InaSAFE Map drawMap called') myMapWidth = self.mapWidth myComposerMap = QgsComposerMap(self.composition, self.pageMargin, top_offset, myMapWidth, self.mapHeight) #myExtent = self.iface.mapCanvas().extent() # The dimensions of the map canvas and the print compser map may # differ. So we set the map composer extent using the canvas and # then defer to the map canvas's map extents thereafter # Update: disabled as it results in a rectangular rather than # square map #myComposerMap.setNewExtent(myExtent) myComposerExtent = myComposerMap.extent() # Recenter the composer map on the center of the canvas # Note that since the composer map is square and the canvas may be # arbitrarily shaped, we center based on the longest edge myCanvasExtent = self.iface.mapCanvas().extent() myWidth = myCanvasExtent.width() myHeight = myCanvasExtent.height() myLongestLength = myWidth if myWidth < myHeight: myLongestLength = myHeight myHalfLength = myLongestLength / 2 myCenter = myCanvasExtent.center() myMinX = myCenter.x() - myHalfLength myMaxX = myCenter.x() + myHalfLength myMinY = myCenter.y() - myHalfLength myMaxY = myCenter.y() + myHalfLength mySquareExtent = QgsRectangle(myMinX, myMinY, myMaxX, myMaxY) myComposerMap.setNewExtent(mySquareExtent) myComposerMap.setGridEnabled(True) myNumberOfSplits = 5 # .. todo:: Write logic to adjust preciosn so that adjacent tick marks # always have different displayed values myPrecision = 2 myXInterval = myComposerExtent.width() / myNumberOfSplits myComposerMap.setGridIntervalX(myXInterval) myYInterval = myComposerExtent.height() / myNumberOfSplits myComposerMap.setGridIntervalY(myYInterval) myComposerMap.setGridStyle(QgsComposerMap.Cross) myCrossLengthMM = 1 myComposerMap.setCrossLength(myCrossLengthMM) myComposerMap.setZValue(0) # To ensure it does not overlay logo myFontSize = 6 myFontWeight = QtGui.QFont.Normal myItalicsFlag = False myFont = QtGui.QFont('verdana', myFontSize, myFontWeight, myItalicsFlag) myComposerMap.setGridAnnotationFont(myFont) myComposerMap.setGridAnnotationPrecision(myPrecision) myComposerMap.setShowGridAnnotation(True) myComposerMap.setGridAnnotationDirection( QgsComposerMap.BoundaryDirection) self.composition.addItem(myComposerMap) self.draw_graticule_mask(top_offset) return myComposerMap def draw_graticule_mask(self, top_offset): """A helper function to mask out graticule labels. It will hide labels on the right side by over painting a white rectangle with white border on them. **kludge** :param top_offset: Vertical offset at which the logo should be drawn. :type top_offset: int """ LOGGER.debug('InaSAFE Map drawGraticuleMask called') myLeftOffset = self.pageMargin + self.mapWidth myRect = QgsComposerShape(myLeftOffset + 0.5, top_offset, self.pageWidth - myLeftOffset, self.mapHeight + 1, self.composition) myRect.setShapeType(QgsComposerShape.Rectangle) myRect.setLineWidth(0.1) myRect.setFrame(False) myRect.setOutlineColor(QtGui.QColor(255, 255, 255)) myRect.setFillColor(QtGui.QColor(255, 255, 255)) myRect.setOpacity(100) # These two lines seem superfluous but are needed myBrush = QtGui.QBrush(QtGui.QColor(255, 255, 255)) myRect.setBrush(myBrush) self.composition.addItem(myRect) def draw_native_scalebar(self, composer_map, top_offset): """Draw a scale bar using QGIS' native drawing. In the case of geographic maps, scale will be in degrees, not km. :param composer_map: Composer map on which to draw the scalebar. :type composer_map: QgsComposerMap :param top_offset: Vertical offset at which the logo should be drawn. :type top_offset: int """ LOGGER.debug('InaSAFE Map drawNativeScaleBar called') myScaleBar = QgsComposerScaleBar(self.composition) myScaleBar.setStyle('Numeric') # optionally modify the style myScaleBar.setComposerMap(composer_map) myScaleBar.applyDefaultSize() myScaleBarHeight = myScaleBar.boundingRect().height() myScaleBarWidth = myScaleBar.boundingRect().width() # -1 to avoid overlapping the map border myScaleBar.setItemPosition( self.pageMargin + 1, top_offset + self.mapHeight - (myScaleBarHeight * 2), myScaleBarWidth, myScaleBarHeight) myScaleBar.setFrame(self.showFramesFlag) # Disabled for now #self.composition.addItem(myScaleBar) def draw_scalebar(self, composer_map, top_offset): """Add a numeric scale to the bottom left of the map. We draw the scale bar manually because QGIS does not yet support rendering a scale bar for a geographic map in km. .. seealso:: :meth:`drawNativeScaleBar` :param composer_map: Composer map on which to draw the scalebar. :type composer_map: QgsComposerMap :param top_offset: Vertical offset at which the logo should be drawn. :type top_offset: int """ LOGGER.debug('InaSAFE Map drawScaleBar called') myCanvas = self.iface.mapCanvas() myRenderer = myCanvas.mapRenderer() # # Add a linear map scale # myDistanceArea = QgsDistanceArea() myDistanceArea.setSourceCrs(myRenderer.destinationCrs().srsid()) myDistanceArea.setProjectionsEnabled(True) # Determine how wide our map is in km/m # Starting point at BL corner myComposerExtent = composer_map.extent() myStartPoint = QgsPoint(myComposerExtent.xMinimum(), myComposerExtent.yMinimum()) # Ending point at BR corner myEndPoint = QgsPoint(myComposerExtent.xMaximum(), myComposerExtent.yMinimum()) myGroundDistance = myDistanceArea.measureLine(myStartPoint, myEndPoint) # Get the equivalent map distance per page mm myMapWidth = self.mapWidth # How far is 1mm on map on the ground in meters? myMMToGroundDistance = myGroundDistance / myMapWidth #print 'MM:', myMMDistance # How long we want the scale bar to be in relation to the map myScaleBarToMapRatio = 0.5 # How many divisions the scale bar should have myTickCount = 5 myScaleBarWidthMM = myMapWidth * myScaleBarToMapRatio myPrintSegmentWidthMM = myScaleBarWidthMM / myTickCount # Segment width in real world (m) # We apply some logic here so that segments are displayed in meters # if each segment is less that 1000m otherwise km. Also the segment # lengths are rounded down to human looking numbers e.g. 1km not 1.1km myUnits = '' myGroundSegmentWidth = myPrintSegmentWidthMM * myMMToGroundDistance if myGroundSegmentWidth < 1000: myUnits = 'm' myGroundSegmentWidth = round(myGroundSegmentWidth) # adjust the segment width now to account for rounding myPrintSegmentWidthMM = myGroundSegmentWidth / myMMToGroundDistance else: myUnits = 'km' # Segment with in real world (km) myGroundSegmentWidth = round(myGroundSegmentWidth / 1000) myPrintSegmentWidthMM = ((myGroundSegmentWidth * 1000) / myMMToGroundDistance) # Now adjust the scalebar width to account for rounding myScaleBarWidthMM = myTickCount * myPrintSegmentWidthMM #print "SBWMM:", myScaleBarWidthMM #print "SWMM:", myPrintSegmentWidthMM #print "SWM:", myGroundSegmentWidthM #print "SWKM:", myGroundSegmentWidthKM # start drawing in line segments myScaleBarHeight = 5 # mm myLineWidth = 0.3 # mm myInsetDistance = 7 # how much to inset the scalebar into the map by myScaleBarX = self.pageMargin + myInsetDistance myScaleBarY = (top_offset + self.mapHeight - myInsetDistance - myScaleBarHeight) # mm # Draw an outer background box - shamelessly hardcoded buffer myRect = QgsComposerShape( myScaleBarX - 4, # left edge myScaleBarY - 3, # top edge myScaleBarWidthMM + 13, # right edge myScaleBarHeight + 6, # bottom edge self.composition) myRect.setShapeType(QgsComposerShape.Rectangle) myRect.setLineWidth(myLineWidth) myRect.setFrame(False) myBrush = QtGui.QBrush(QtGui.QColor(255, 255, 255)) # workaround for missing setTransparentFill missing from python api myRect.setBrush(myBrush) self.composition.addItem(myRect) # Set up the tick label font myFontWeight = QtGui.QFont.Normal myFontSize = 6 myItalicsFlag = False myFont = QtGui.QFont('verdana', myFontSize, myFontWeight, myItalicsFlag) # Draw the bottom line myUpshift = 0.3 # shift the bottom line up for better rendering myRect = QgsComposerShape(myScaleBarX, myScaleBarY + myScaleBarHeight - myUpshift, myScaleBarWidthMM, 0.1, self.composition) myRect.setShapeType(QgsComposerShape.Rectangle) myRect.setLineWidth(myLineWidth) myRect.setFrame(False) self.composition.addItem(myRect) # Now draw the scalebar ticks for myTickCountIterator in range(0, myTickCount + 1): myDistanceSuffix = '' if myTickCountIterator == myTickCount: myDistanceSuffix = ' ' + myUnits myRealWorldDistance = ( '%.0f%s' % (myTickCountIterator * myGroundSegmentWidth, myDistanceSuffix)) #print 'RW:', myRealWorldDistance myMMOffset = myScaleBarX + (myTickCountIterator * myPrintSegmentWidthMM) #print 'MM:', myMMOffset myTickHeight = myScaleBarHeight / 2 # Lines are not exposed by the api yet so we # bodge drawing lines using rectangles with 1px height or width myTickWidth = 0.1 # width or rectangle to be drawn myUpTickLine = QgsComposerShape( myMMOffset, myScaleBarY + myScaleBarHeight - myTickHeight, myTickWidth, myTickHeight, self.composition) myUpTickLine.setShapeType(QgsComposerShape.Rectangle) myUpTickLine.setLineWidth(myLineWidth) myUpTickLine.setFrame(False) self.composition.addItem(myUpTickLine) # # Add a tick label # myLabel = QgsComposerLabel(self.composition) myLabel.setFont(myFont) myLabel.setText(myRealWorldDistance) myLabel.adjustSizeToText() myLabel.setItemPosition(myMMOffset - 3, myScaleBarY - myTickHeight) myLabel.setFrame(self.showFramesFlag) self.composition.addItem(myLabel) def draw_impact_title(self, top_offset): """Draw the map subtitle - obtained from the impact layer keywords. :param top_offset: Vertical offset at which the logo should be drawn. :type top_offset: int :returns: The height of the label as rendered. :rtype: float """ LOGGER.debug('InaSAFE Map drawImpactTitle called') myTitle = self.map_title() if myTitle is None: myTitle = '' myFontSize = 20 myFontWeight = QtGui.QFont.Bold myItalicsFlag = False myFont = QtGui.QFont('verdana', myFontSize, myFontWeight, myItalicsFlag) myLabel = QgsComposerLabel(self.composition) myLabel.setFont(myFont) myHeading = myTitle myLabel.setText(myHeading) myLabelWidth = self.pageWidth - (self.pageMargin * 2) myLabelHeight = 12 myLabel.setItemPosition(self.pageMargin, top_offset, myLabelWidth, myLabelHeight) myLabel.setFrame(self.showFramesFlag) self.composition.addItem(myLabel) return myLabelHeight def draw_legend(self, top_offset): """Add a legend to the map using our custom legend renderer. .. note:: getLegend generates a pixmap in 150dpi so if you set the map to a higher dpi it will appear undersized. :param top_offset: Vertical offset at which the logo should be drawn. :type top_offset: int """ LOGGER.debug('InaSAFE Map drawLegend called') mapLegendAttributes = self.map_legend_attributes() legendNotes = mapLegendAttributes.get('legend_notes', None) legendUnits = mapLegendAttributes.get('legend_units', None) legendTitle = mapLegendAttributes.get('legend_title', None) LOGGER.debug(mapLegendAttributes) myLegend = MapLegend(self.layer, self.pageDpi, legendTitle, legendNotes, legendUnits) self.legend = myLegend.get_legend() myPicture1 = QgsComposerPicture(self.composition) myLegendFilePath = unique_filename(prefix='legend', suffix='.png', dir='work') self.legend.save(myLegendFilePath, 'PNG') myPicture1.setPictureFile(myLegendFilePath) myLegendHeight = points_to_mm(self.legend.height(), self.pageDpi) myLegendWidth = points_to_mm(self.legend.width(), self.pageDpi) myPicture1.setItemPosition(self.pageMargin, top_offset, myLegendWidth, myLegendHeight) myPicture1.setFrame(False) self.composition.addItem(myPicture1) os.remove(myLegendFilePath) def draw_image(self, theImage, theWidthMM, theLeftOffset, theTopOffset): """Helper to draw an image directly onto the QGraphicsScene. This is an alternative to using QgsComposerPicture which in some cases leaves artifacts under windows. The Pixmap will have a transform applied to it so that it is rendered with the same resolution as the composition. :param theImage: Image that will be rendered to the layout. :type theImage: QImage :param theWidthMM: Desired width in mm of output on page. :type theWidthMM: int :param theLeftOffset: Offset from left of page. :type theLeftOffset: int :param theTopOffset: Offset from top of page. :type theTopOffset: int :returns: Graphics scene item. :rtype: QGraphicsSceneItem """ LOGGER.debug('InaSAFE Map drawImage called') myDesiredWidthMM = theWidthMM # mm myDesiredWidthPX = mm_to_points(myDesiredWidthMM, self.pageDpi) myActualWidthPX = theImage.width() myScaleFactor = myDesiredWidthPX / myActualWidthPX LOGGER.debug('%s %s %s' % (myScaleFactor, myActualWidthPX, myDesiredWidthPX)) myTransform = QtGui.QTransform() myTransform.scale(myScaleFactor, myScaleFactor) myTransform.rotate(0.5) # noinspection PyArgumentList myItem = self.composition.addPixmap(QtGui.QPixmap.fromImage(theImage)) myItem.setTransform(myTransform) myItem.setOffset(theLeftOffset / myScaleFactor, theTopOffset / myScaleFactor) return myItem def draw_host_and_time(self, top_offset): """Add a note with hostname and time to the composition. :param top_offset: Vertical offset at which the logo should be drawn. :type top_offset: int """ LOGGER.debug('InaSAFE Map drawDisclaimer called') #elapsed_time: 11.612545 #user: timlinux #host_name: ultrabook #time_stamp: 2012-10-13_23:10:31 #myUser = self.keywordIO.readKeywords(self.layer, 'user') #myHost = self.keywordIO.readKeywords(self.layer, 'host_name') myDateTime = self.keywordIO.read_keywords(self.layer, 'time_stamp') myTokens = myDateTime.split('_') myDate = myTokens[0] myTime = myTokens[1] #myElapsedTime = self.keywordIO.readKeywords(self.layer, # 'elapsed_time') #myElapsedTime = humaniseSeconds(myElapsedTime) myLongVersion = get_version() myTokens = myLongVersion.split('.') myVersion = '%s.%s.%s' % (myTokens[0], myTokens[1], myTokens[2]) myLabelText = self.tr( 'Date and time of assessment: %1 %2\n' 'Special note: This assessment is a guide - we strongly recommend ' 'that you ground truth the results shown here before deploying ' 'resources and / or personnel.\n' 'Assessment carried out using InaSAFE release %3 (QGIS ' 'plugin version).').arg(myDate).arg(myTime).arg(myVersion) myFontSize = 6 myFontWeight = QtGui.QFont.Normal myItalicsFlag = True myFont = QtGui.QFont('verdana', myFontSize, myFontWeight, myItalicsFlag) myLabel = QgsComposerLabel(self.composition) myLabel.setFont(myFont) myLabel.setText(myLabelText) myLabel.adjustSizeToText() myLabelHeight = 50.0 # mm determined using qgis map composer myLabelWidth = (self.pageWidth / 2) - self.pageMargin myLeftOffset = self.pageWidth / 2 # put in right half of page myLabel.setItemPosition( myLeftOffset, top_offset, myLabelWidth, myLabelHeight, ) myLabel.setFrame(self.showFramesFlag) self.composition.addItem(myLabel) def draw_disclaimer(self): """Add a disclaimer to the composition.""" LOGGER.debug('InaSAFE Map drawDisclaimer called') myFontSize = 10 myFontWeight = QtGui.QFont.Normal myItalicsFlag = True myFont = QtGui.QFont('verdana', myFontSize, myFontWeight, myItalicsFlag) myLabel = QgsComposerLabel(self.composition) myLabel.setFont(myFont) myLabel.setText(self.disclaimer) myLabel.adjustSizeToText() myLabelHeight = 7.0 # mm determined using qgis map composer myLabelWidth = self.pageWidth # item - position and size...option myLeftOffset = self.pageMargin myTopOffset = self.pageHeight - self.pageMargin myLabel.setItemPosition( myLeftOffset, myTopOffset, myLabelWidth, myLabelHeight, ) myLabel.setFrame(self.showFramesFlag) self.composition.addItem(myLabel) def map_title(self): """Get the map title from the layer keywords if possible. :returns: None on error, otherwise the title. :rtype: None, str """ LOGGER.debug('InaSAFE Map getMapTitle called') try: myTitle = self.keywordIO.read_keywords(self.layer, 'map_title') return myTitle except KeywordNotFoundError: return None except Exception: return None def map_legend_attributes(self): """Get the map legend attribute from the layer keywords if possible. :returns: None on error, otherwise the attributes (notes and units). :rtype: None, str """ LOGGER.debug('InaSAFE Map getMapLegendAtributes called') legendAttributes = ['legend_notes', 'legend_units', 'legend_title'] dictLegendAttributes = {} for myLegendAttribute in legendAttributes: try: dictLegendAttributes[myLegendAttribute] = \ self.keywordIO.read_keywords(self.layer, myLegendAttribute) except KeywordNotFoundError: pass except Exception: pass return dictLegendAttributes def showComposer(self): """Show the composition in a composer view so the user can tweak it. """ myView = QgsComposerView(self.iface.mainWindow()) myView.show() def write_template(self, template_path): """Write current composition as a template that can be re-used in QGIS. :param template_path: Path to which template should be written. :type template_path: str """ myDocument = QtXml.QDomDocument() myElement = myDocument.createElement('Composer') myDocument.appendChild(myElement) self.composition.writeXML(myElement, myDocument) myXml = myDocument.toByteArray() myFile = file(template_path, 'wb') myFile.write(myXml) myFile.close() def render_template(self, template_path, output_path): """Load a QgsComposer map from a template and render it. .. note:: THIS METHOD IS EXPERIMENTAL AND CURRENTLY NON FUNCTIONAL :param template_path: Path to the template that should be loaded. :type template_path: str :param output_path: Path for the output pdf. :type output_path: str """ self.setup_composition() myResolution = self.composition.printResolution() self.printer = setup_printer(output_path, resolution=myResolution) if self.composition: myFile = QtCore.QFile(template_path) myDocument = QtXml.QDomDocument() myDocument.setContent(myFile, False) # .. todo:: fix magic param myNodeList = myDocument.elementsByTagName('Composer') if myNodeList.size() > 0: myElement = myNodeList.at(0).toElement() self.composition.readXML(myElement, myDocument) self.make_pdf(output_path)
def setUp(self): """Run before each test.""" self.iface = get_iface() self.mapSettings = QgsMapSettings() self.mComposition = QgsComposition(QgsProject.instance()) self.mComposition.setPaperSize(297, 210) # A4 landscape
class TestQgsComposerPolygon(unittest.TestCase): def __init__(self, methodName): """Run once on class initialization.""" unittest.TestCase.__init__(self, methodName) # create composition self.mComposition = QgsComposition(QgsProject.instance()) self.mComposition.setPaperSize(297, 210) # create polygon = QPolygonF() polygon.append(QPointF(0.0, 0.0)) polygon.append(QPointF(100.0, 0.0)) polygon.append(QPointF(200.0, 100.0)) polygon.append(QPointF(100.0, 200.0)) self.mComposerPolygon = QgsComposerPolygon(polygon, self.mComposition) self.mComposition.addComposerPolygon(self.mComposerPolygon) # style props = {} props["color"] = "green" props["style"] = "solid" props["style_border"] = "solid" props["color_border"] = "black" props["width_border"] = "10.0" props["joinstyle"] = "miter" style = QgsFillSymbol.createSimple(props) self.mComposerPolygon.setPolygonStyleSymbol(style) def testDisplayName(self): """Test if displayName is valid""" self.assertEqual(self.mComposerPolygon.displayName(), "<polygon>") def testType(self): """Test if type is valid""" self.assertEqual( self.mComposerPolygon.type(), QgsComposerItem.ComposerPolygon) 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 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 def testSelectedNode(self): """Test selectedNode and deselectNode 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.deselectNode() self.mComposerPolygon.setDisplayNodes(False) checker = QgsCompositionChecker( 'composerpolygon_defaultstyle', self.mComposition) checker.setControlPathPrefix("composer_polygon") myTestResult, myMessage = checker.testComposition() assert myTestResult, myMessage def testRemoveNode(self): """Test removeNode method""" rc = self.mComposerPolygon.removeNode(100) self.assertEqual(rc, False) checker = QgsCompositionChecker( 'composerpolygon_defaultstyle', self.mComposition) checker.setControlPathPrefix("composer_polygon") myTestResult, myMessage = checker.testComposition() assert myTestResult, myMessage self.assertEqual(self.mComposerPolygon.nodesSize(), 4) def testAddNode(self): """Test addNode method""" # default searching radius is 10 self.assertEqual(self.mComposerPolygon.nodesSize(), 4) rc = self.mComposerPolygon.addNode(QPointF(50.0, 10.0)) self.assertEqual(rc, False) # default searching radius is 10 self.assertEqual(self.mComposerPolygon.nodesSize(), 4) rc = self.mComposerPolygon.addNode(QPointF(50.0, 9.99)) self.assertEqual(rc, True) self.assertEqual(self.mComposerPolygon.nodesSize(), 5) def testAddNodeCustomRadius(self): """Test addNode with custom radius""" # default searching radius is 10 self.assertEqual(self.mComposerPolygon.nodesSize(), 4) rc = self.mComposerPolygon.addNode(QPointF(50.0, 8.1), True, 8.0) self.assertEqual(rc, False) self.assertEqual(self.mComposerPolygon.nodesSize(), 4) # default searching radius is 10 rc = self.mComposerPolygon.addNode(QPointF(50.0, 7.9), True, 8.0) self.assertEqual(rc, True) self.assertEqual(self.mComposerPolygon.nodesSize(), 5) def testAddNodeWithoutCheckingArea(self): """Test addNode without checking the maximum distance allowed""" # default searching radius is 10 self.assertEqual(self.mComposerPolygon.nodesSize(), 4) rc = self.mComposerPolygon.addNode(QPointF(50.0, 20.0)) self.assertEqual(rc, False) self.assertEqual(self.mComposerPolygon.nodesSize(), 4) # default searching radius is 10 self.assertEqual(self.mComposerPolygon.nodesSize(), 4) rc = self.mComposerPolygon.addNode(QPointF(50.0, 20.0), False) self.assertEqual(rc, True) self.assertEqual(self.mComposerPolygon.nodesSize(), 5) checker = QgsCompositionChecker( 'composerpolygon_addnode', self.mComposition) checker.setControlPathPrefix("composer_polygon") myTestResult, myMessage = checker.testComposition() assert myTestResult, myMessage def testMoveNode(self): """Test moveNode method""" rc = self.mComposerPolygon.moveNode(30, QPointF(100.0, 300.0)) self.assertEqual(rc, False) rc = self.mComposerPolygon.moveNode(3, QPointF(100.0, 150.0)) self.assertEqual(rc, True) checker = QgsCompositionChecker( 'composerpolygon_movenode', self.mComposition) checker.setControlPathPrefix("composer_polygon") myTestResult, myMessage = checker.testComposition() assert myTestResult, myMessage def testNodeAtPosition(self): """Test nodeAtPosition method""" # default searching radius is 10 rc = self.mComposerPolygon.nodeAtPosition(QPointF(100.0, 210.0)) self.assertEqual(rc, -1) # default searching radius is 10 rc = self.mComposerPolygon.nodeAtPosition( QPointF(100.0, 210.0), False) self.assertEqual(rc, 3) # default searching radius is 10 rc = self.mComposerPolygon.nodeAtPosition( QPointF(100.0, 210.0), True, 10.1) self.assertEqual(rc, 3)
class TestQgsComposerPicture(unittest.TestCase): @classmethod def setUpClass(cls): # Bring up a simple HTTP server, for remote picture tests os.chdir(unitTestDataPath() + '') handler = http.server.SimpleHTTPRequestHandler cls.httpd = socketserver.TCPServer(('localhost', 0), handler) cls.port = cls.httpd.server_address[1] cls.httpd_thread = threading.Thread(target=cls.httpd.serve_forever) cls.httpd_thread.setDaemon(True) cls.httpd_thread.start() def __init__(self, methodName): """Run once on class initialization.""" unittest.TestCase.__init__(self, methodName) TEST_DATA_DIR = unitTestDataPath() self.pngImage = TEST_DATA_DIR + "/sample_image.png" # create composition self.composition = QgsComposition(QgsProject.instance()) self.composition.setPaperSize(297, 210) self.composerPicture = QgsComposerPicture(self.composition) self.composerPicture.setPicturePath(self.pngImage) self.composerPicture.setSceneRect(QRectF(70, 70, 100, 100)) self.composerPicture.setFrameEnabled(True) self.composition.addComposerPicture(self.composerPicture) def testResizeZoom(self): """Test picture resize zoom mode.""" self.composerPicture.setResizeMode(QgsComposerPicture.Zoom) checker = QgsCompositionChecker('composerpicture_resize_zoom', self.composition) checker.setControlPathPrefix("composer_picture") testResult, message = checker.testComposition() assert testResult, message @unittest.skip('test is broken for qt5/python3 - feature works') 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) checker.setControlPathPrefix("composer_picture") testResult, message = checker.testComposition() self.composerPicture.setPicturePath(self.pngImage) assert testResult, message def testGridNorth(self): """Test syncing picture to grid north""" composition = QgsComposition(QgsProject.instance()) composerMap = QgsComposerMap(composition) composerMap.setNewExtent(QgsRectangle(0, -256, 256, 0)) composition.addComposerMap(composerMap) composerPicture = QgsComposerPicture(composition) composition.addComposerPicture(composerPicture) composerPicture.setRotationMap(composerMap.id()) self.assertTrue(composerPicture.rotationMap() >= 0) composerPicture.setNorthMode(QgsComposerPicture.GridNorth) composerMap.setMapRotation(45) self.assertEqual(composerPicture.pictureRotation(), 45) # add an offset composerPicture.setNorthOffset(-10) self.assertEqual(composerPicture.pictureRotation(), 35) def testTrueNorth(self): """Test syncing picture to true north""" composition = QgsComposition(QgsProject.instance()) composerMap = QgsComposerMap(composition) composerMap.setCrs(QgsCoordinateReferenceSystem.fromEpsgId(3575)) composerMap.setNewExtent( QgsRectangle(-2126029.962, -2200807.749, -119078.102, -757031.156)) composition.addComposerMap(composerMap) composerPicture = QgsComposerPicture(composition) composition.addComposerPicture(composerPicture) composerPicture.setRotationMap(composerMap.id()) self.assertTrue(composerPicture.rotationMap() >= 0) composerPicture.setNorthMode(QgsComposerPicture.TrueNorth) self.assertAlmostEqual(composerPicture.pictureRotation(), 37.20, 1) # shift map composerMap.setNewExtent( QgsRectangle(2120672.293, -3056394.691, 2481640.226, -2796718.780)) self.assertAlmostEqual(composerPicture.pictureRotation(), -38.18, 1) # rotate map composerMap.setMapRotation(45) self.assertAlmostEqual(composerPicture.pictureRotation(), -38.18 + 45, 1) # add an offset composerPicture.setNorthOffset(-10) self.assertAlmostEqual(composerPicture.pictureRotation(), -38.18 + 35, 1)
class TestQgsComposerShapes(unittest.TestCase): def __init__(self, methodName): """Run once on class initialisation.""" unittest.TestCase.__init__(self, methodName) self.mapSettings = QgsMapSettings() # create composition self.mComposition = QgsComposition(self.mapSettings) self.mComposition.setPaperSize(297, 210) self.mComposerShape = QgsComposerShape(20, 20, 150, 100, self.mComposition) self.mComposerShape.setBackgroundColor(QColor.fromRgb(255, 150, 0)) self.mComposition.addComposerShape(self.mComposerShape) def testRectangle(self): """Test rectangle composer shape""" self.mComposerShape.setShapeType(QgsComposerShape.Rectangle) checker = QgsCompositionChecker('composershapes_rectangle', self.mComposition) checker.setControlPathPrefix("composer_shapes") myTestResult, myMessage = checker.testComposition() assert myTestResult, myMessage def testEllipse(self): """Test ellipse composer shape""" self.mComposerShape.setShapeType(QgsComposerShape.Ellipse) checker = QgsCompositionChecker('composershapes_ellipse', self.mComposition) checker.setControlPathPrefix("composer_shapes") myTestResult, myMessage = checker.testComposition() assert myTestResult, myMessage def testTriangle(self): """Test triangle composer shape""" self.mComposerShape.setShapeType(QgsComposerShape.Triangle) checker = QgsCompositionChecker('composershapes_triangle', self.mComposition) checker.setControlPathPrefix("composer_shapes") myTestResult, myMessage = checker.testComposition() assert myTestResult, myMessage def testRoundedRectangle(self): """Test rounded rectangle composer shape""" self.mComposerShape.setShapeType(QgsComposerShape.Rectangle) self.mComposerShape.setCornerRadius(30) checker = QgsCompositionChecker('composershapes_roundedrect', self.mComposition) checker.setControlPathPrefix("composer_shapes") myTestResult, myMessage = checker.testComposition() self.mComposerShape.setCornerRadius(0) assert myTestResult, myMessage
class TestComposerBase(TestQgsPalLabeling): layer = None """:type: QgsVectorLayer""" @classmethod def setUpClass(cls): if not cls._BaseSetup: TestQgsPalLabeling.setUpClass() # the blue background (set via layer style) to match renderchecker's TestQgsPalLabeling.loadFeatureLayer('background', True) cls._TestKind = 0 # OutputKind.(Img|Svg|Pdf) @classmethod def tearDownClass(cls): """Run after all tests""" TestQgsPalLabeling.tearDownClass() cls.removeMapLayer(cls.layer) cls.layer = None def setUp(self): """Run before each test.""" super(TestComposerBase, self).setUp() self._TestImage = '' # ensure per test map settings stay encapsulated self._TestMapSettings = self.cloneMapSettings(self._MapSettings) self._Mismatch = 0 self._ColorTol = 0 self._Mismatches.clear() self._ColorTols.clear() def _set_up_composition(self, width, height, dpi): # set up composition and add map self._c = QgsComposition(QgsProject.instance()) """:type: QgsComposition""" # self._c.setUseAdvancedEffects(False) self._c.setPrintResolution(dpi) # 600 x 400 px = 211.67 x 141.11 mm @ 72 dpi paperw = width * 25.4 / dpi paperh = height * 25.4 / dpi self._c.setPaperSize(paperw, paperh) # NOTE: do not use QgsComposerMap(self._c, 0, 0, paperw, paperh) since # it only takes integers as parameters and the composition will grow # larger based upon union of item scene rectangles and a slight buffer # see end of QgsComposition::compositionBounds() # add map as small graphics item first, then set its scene QRectF later self._cmap = QgsComposerMap(self._c, 10, 10, 10, 10) """:type: QgsComposerMap""" self._cmap.setPreviewMode(QgsComposerMap.Render) self._cmap.setFrameEnabled(False) self._cmap.setLayers(self._TestMapSettings.layers()) self._c.addComposerMap(self._cmap) # now expand map to fill page and set its extent self._cmap.setSceneRect(QRectF(0, 0, paperw, paperw)) self._cmap.setNewExtent(self.aoiExtent()) # self._cmap.updateCachedImage() self._c.setPlotStyle(QgsComposition.Print) # noinspection PyUnusedLocal def _get_composer_image(self, width, height, dpi): image = QImage(QSize(width, height), self._TestMapSettings.outputImageFormat()) image.fill(QColor(152, 219, 249).rgb()) image.setDotsPerMeterX(dpi / 25.4 * 1000) image.setDotsPerMeterY(dpi / 25.4 * 1000) p = QPainter(image) p.setRenderHint( QPainter.Antialiasing, self._TestMapSettings.testFlag(QgsMapSettings.Antialiasing)) self._c.renderPage(p, 0) p.end() # image = self._c.printPageAsRaster(0) # """:type: QImage""" if image.isNull(): return False, '' filepath = getTempfilePath('png') res = image.save(filepath, 'png') if not res: os.unlink(filepath) filepath = '' return res, filepath def _get_composer_svg_image(self, width, height, dpi): # from qgscomposer.cpp, QgsComposer::on_mActionExportAsSVG_triggered, # near end of function svgpath = getTempfilePath('svg') temp_size = os.path.getsize(svgpath) svg_g = QSvgGenerator() # noinspection PyArgumentList svg_g.setTitle(QgsProject.instance().title()) svg_g.setFileName(svgpath) svg_g.setSize(QSize(width, height)) svg_g.setViewBox(QRect(0, 0, width, height)) svg_g.setResolution(dpi) sp = QPainter(svg_g) self._c.renderPage(sp, 0) sp.end() if temp_size == os.path.getsize(svgpath): return False, '' image = QImage(width, height, self._TestMapSettings.outputImageFormat()) image.fill(QColor(152, 219, 249).rgb()) image.setDotsPerMeterX(dpi / 25.4 * 1000) image.setDotsPerMeterY(dpi / 25.4 * 1000) svgr = QSvgRenderer(svgpath) p = QPainter(image) p.setRenderHint( QPainter.Antialiasing, self._TestMapSettings.testFlag(QgsMapSettings.Antialiasing)) p.setRenderHint(QPainter.TextAntialiasing) svgr.render(p) p.end() filepath = getTempfilePath('png') res = image.save(filepath, 'png') if not res: os.unlink(filepath) filepath = '' # TODO: remove .svg file as well? return res, filepath def _get_composer_pdf_image(self, width, height, dpi): pdfpath = getTempfilePath('pdf') temp_size = os.path.getsize(pdfpath) p = QPrinter() p.setOutputFormat(QPrinter.PdfFormat) p.setOutputFileName(pdfpath) p.setPaperSize(QSizeF(self._c.paperWidth(), self._c.paperHeight()), QPrinter.Millimeter) p.setFullPage(True) p.setColorMode(QPrinter.Color) p.setResolution(self._c.printResolution()) pdf_p = QPainter(p) # page_mm = p.pageRect(QPrinter.Millimeter) # page_px = p.pageRect(QPrinter.DevicePixel) # self._c.render(pdf_p, page_px, page_mm) self._c.renderPage(pdf_p, 0) pdf_p.end() if temp_size == os.path.getsize(pdfpath): return False, '' filepath = getTempfilePath('png') # Poppler (pdftocairo or pdftoppm): # PDFUTIL -png -singlefile -r 72 -x 0 -y 0 -W 420 -H 280 in.pdf pngbase # muPDF (mudraw): # PDFUTIL -c rgb[a] -r 72 -w 420 -h 280 -o out.png in.pdf if PDFUTIL.strip().endswith('pdftocairo'): filebase = os.path.join( os.path.dirname(filepath), os.path.splitext(os.path.basename(filepath))[0]) call = [ PDFUTIL, '-png', '-singlefile', '-r', str(dpi), '-x', '0', '-y', '0', '-W', str(width), '-H', str(height), pdfpath, filebase ] elif PDFUTIL.strip().endswith('mudraw'): call = [ PDFUTIL, '-c', 'rgba', '-r', str(dpi), '-w', str(width), '-h', str(height), # '-b', '8', '-o', filepath, pdfpath ] else: return False, '' qDebug("_get_composer_pdf_image call: {0}".format(' '.join(call))) res = False try: subprocess.check_call(call) res = True except subprocess.CalledProcessError as e: qDebug("_get_composer_pdf_image failed!\n" "cmd: {0}\n" "returncode: {1}\n" "message: {2}".format(e.cmd, e.returncode, e.message)) if not res: os.unlink(filepath) filepath = '' return res, filepath def get_composer_output(self, kind): ms = self._TestMapSettings osize = ms.outputSize() width, height, dpi = osize.width(), osize.height(), ms.outputDpi() self._set_up_composition(width, height, dpi) if kind == OutputKind.Svg: return self._get_composer_svg_image(width, height, dpi) elif kind == OutputKind.Pdf: return self._get_composer_pdf_image(width, height, dpi) else: # OutputKind.Img return self._get_composer_image(width, height, dpi) # noinspection PyUnusedLocal def checkTest(self, **kwargs): self.lyr.writeToLayer(self.layer) ms = self._MapSettings # class settings settings_type = 'Class' if self._TestMapSettings is not None: ms = self._TestMapSettings # per test settings settings_type = 'Test' if 'PAL_VERBOSE' in os.environ: qDebug('MapSettings type: {0}'.format(settings_type)) qDebug(mapSettingsString(ms)) res_m, self._TestImage = self.get_composer_output(self._TestKind) self.assertTrue(res_m, 'Failed to retrieve/save output from composer') self.saveControlImage(self._TestImage) mismatch = 0 if 'PAL_NO_MISMATCH' not in os.environ: # some mismatch expected mismatch = self._Mismatch if self._Mismatch else 20 if self._TestGroup in self._Mismatches: mismatch = self._Mismatches[self._TestGroup] colortol = 0 if 'PAL_NO_COLORTOL' not in os.environ: colortol = self._ColorTol if self._ColorTol else 0 if self._TestGroup in self._ColorTols: colortol = self._ColorTols[self._TestGroup] self.assertTrue(*self.renderCheck( mismatch=mismatch, colortol=colortol, imgpath=self._TestImage))
class TestQgsComposerHtml(unittest.TestCase): def setUp(self): """Run before each test.""" self.iface = get_iface() self.mapSettings = QgsMapSettings() self.mComposition = QgsComposition(QgsProject.instance()) self.mComposition.setPaperSize(297, 210) # A4 landscape def tearDown(self): """Run after each test.""" print("Tear down") def htmlUrl(self): """Helper to get the url of the html doc.""" myPath = os.path.join(TEST_DATA_DIR, "test_html.html") myUrl = QUrl("file:///" + myPath) return myUrl def testTable(self): """Test we can render a html table in a single frame.""" composerHtml = QgsComposerHtml(self.mComposition, False) htmlFrame = QgsComposerFrame(self.mComposition, composerHtml, 0, 0, 100, 200) htmlFrame.setFrameEnabled(True) composerHtml.addFrame(htmlFrame) composerHtml.setUrl(self.htmlUrl()) checker = QgsCompositionChecker('composerhtml_table', self.mComposition) checker.setControlPathPrefix("composer_html") myTestResult, myMessage = checker.testComposition() qDebug(myMessage) self.mComposition.removeMultiFrame(composerHtml) composerHtml = None assert myTestResult, myMessage 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 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) checker1.setControlPathPrefix("composer_html") myTestResult, myMessage = checker1.testComposition(myPage, 200) assert myTestResult, myMessage print("Checking page 2") myPage = 1 checker2 = QgsCompositionChecker('composerhtml_smartbreaks2', self.mComposition) checker2.setControlPathPrefix("composer_html") myTestResult, myMessage = checker2.testComposition(myPage, 200) assert myTestResult, myMessage self.mComposition.removeMultiFrame(composerHtml) composerHtml = None assert myTestResult, myMessage
class TestQgsComposerMap(unittest.TestCase): def __init__(self, methodName): """Run once on class initialization.""" unittest.TestCase.__init__(self, methodName) myPath = os.path.join(TEST_DATA_DIR, 'rgb256x256.png') rasterFileInfo = QFileInfo(myPath) mRasterLayer = QgsRasterLayer(rasterFileInfo.filePath(), rasterFileInfo.completeBaseName()) rasterRenderer = QgsMultiBandColorRenderer(mRasterLayer.dataProvider(), 1, 2, 3) mRasterLayer.setRenderer(rasterRenderer) #pipe = mRasterLayer.pipe() #assert pipe.set(rasterRenderer), 'Cannot set pipe renderer' QgsProject.instance().addMapLayers([mRasterLayer]) # create composition with composer map self.mMapSettings = QgsMapSettings() self.mMapSettings.setLayers([mRasterLayer]) self.mMapSettings.setCrsTransformEnabled(False) self.mComposition = QgsComposition(self.mMapSettings, QgsProject.instance()) self.mComposition.setPaperSize(297, 210) self.mComposerMap = QgsComposerMap(self.mComposition, 20, 20, 200, 100) self.mComposerMap.setFrameEnabled(True) self.mComposition.addComposerMap(self.mComposerMap) def testOverviewMap(self): overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70) overviewMap.setFrameEnabled(True) self.mComposition.addComposerMap(overviewMap) # zoom in myRectangle = QgsRectangle(96, -152, 160, -120) self.mComposerMap.setNewExtent(myRectangle) myRectangle2 = QgsRectangle(0, -256, 256, 0) overviewMap.setNewExtent(myRectangle2) overviewMap.overview().setFrameMap(self.mComposerMap.id()) checker = QgsCompositionChecker('composermap_overview', self.mComposition) checker.setControlPathPrefix("composer_mapoverview") myTestResult, myMessage = checker.testComposition() self.mComposition.removeComposerItem(overviewMap) assert myTestResult, myMessage def testOverviewMapBlend(self): overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70) overviewMap.setFrameEnabled(True) self.mComposition.addComposerMap(overviewMap) # zoom in myRectangle = QgsRectangle(96, -152, 160, -120) self.mComposerMap.setNewExtent(myRectangle) myRectangle2 = QgsRectangle(0, -256, 256, 0) overviewMap.setNewExtent(myRectangle2) overviewMap.overview().setFrameMap(self.mComposerMap.id()) overviewMap.overview().setBlendMode(QPainter.CompositionMode_Multiply) checker = QgsCompositionChecker('composermap_overview_blending', self.mComposition) checker.setControlPathPrefix("composer_mapoverview") myTestResult, myMessage = checker.testComposition() self.mComposition.removeComposerItem(overviewMap) assert myTestResult, myMessage def testOverviewMapInvert(self): overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70) overviewMap.setFrameEnabled(True) self.mComposition.addComposerMap(overviewMap) # zoom in myRectangle = QgsRectangle(96, -152, 160, -120) self.mComposerMap.setNewExtent(myRectangle) myRectangle2 = QgsRectangle(0, -256, 256, 0) overviewMap.setNewExtent(myRectangle2) overviewMap.overview().setFrameMap(self.mComposerMap.id()) overviewMap.overview().setInverted(True) checker = QgsCompositionChecker('composermap_overview_invert', self.mComposition) checker.setControlPathPrefix("composer_mapoverview") myTestResult, myMessage = checker.testComposition() self.mComposition.removeComposerItem(overviewMap) assert myTestResult, myMessage def testOverviewMapCenter(self): overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70) overviewMap.setFrameEnabled(True) self.mComposition.addComposerMap(overviewMap) # zoom in myRectangle = QgsRectangle(192, -288, 320, -224) self.mComposerMap.setNewExtent(myRectangle) myRectangle2 = QgsRectangle(0, -256, 256, 0) overviewMap.setNewExtent(myRectangle2) overviewMap.overview().setFrameMap(self.mComposerMap.id()) overviewMap.overview().setInverted(False) overviewMap.overview().setCentered(True) checker = QgsCompositionChecker('composermap_overview_center', self.mComposition) checker.setControlPathPrefix("composer_mapoverview") myTestResult, myMessage = checker.testComposition() self.mComposition.removeComposerItem(overviewMap) assert myTestResult, myMessage # Fails because addItemsFromXml has been commented out in sip @unittest.expectedFailure def testuniqueId(self): doc = QDomDocument() documentElement = doc.createElement('ComposerItemClipboard') self.mComposition.writeXml(documentElement, doc) self.mComposition.addItemsFromXml(documentElement, doc, 0, False) # test if both composer maps have different ids newMap = QgsComposerMap() mapList = self.mComposition.composerMapItems() for mapIt in mapList: if mapIt != self.mComposerMap: newMap = mapIt break oldId = self.mComposerMap.id() newId = newMap.id() self.mComposition.removeComposerItem(newMap) myMessage = 'old: %s new: %s' % (oldId, newId) assert oldId != newId, myMessage def testWorldFileGeneration(self): myRectangle = QgsRectangle(781662.375, 3339523.125, 793062.375, 3345223.125) self.mComposerMap.setNewExtent(myRectangle) self.mComposerMap.setMapRotation(30.0) self.mComposition.setGenerateWorldFile(True) self.mComposition.setWorldFileMap(self.mComposerMap) p = self.mComposition.computeWorldFileParameters() pexpected = (4.180480199790922, 2.4133064516129026, 779443.7612381146, 2.4136013686911886, -4.179969388427311, 3342408.5663611) ptolerance = (0.001, 0.001, 1, 0.001, 0.001, 1e+03) for i in range(0, 6): assert abs(p[i] - pexpected[i]) < ptolerance[i]