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]
