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)
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)
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 testuniqueId(self):
doc = QDomDocument()
documentElement = doc.createElement('ComposerItemClipboard')
self.mComposition.writeXml(documentElement, doc)
self.mComposition.addItemsFromXml(documentElement, doc)
# test if both composer maps have different ids
newMap = QgsComposerMap(self.mComposition, 0, 0, 10, 10)
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 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 uniqueId(self, mComposerMap, mComposition):
doc = QDomDocument()
documentElement = doc.createElement( "ComposerItemClipboard" )
mComposerMap.writeXML( documentElement, doc )
mComposition.addItemsFromXML( documentElement, doc, 0, false )
#test if both composer maps have different ids
newMap = QgsComposerMap()
mapList = mComposition.composerMapItems()
for mapIt in mapList:
if mapIt != mComposerMap:
newMap = mapIt
break
oldId = mComposerMap.id()
newId = newMap.id()
mComposition.removeComposerItem( newMap );
print "old: "+str(oldId)
print "new "+str(newId)
assert oldId != newId
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)
class TestQgsAtlasComposition(unittest.TestCase):
def testCase(self):
self.TEST_DATA_DIR = unitTestDataPath()
tmppath = tempfile.mkdtemp()
for file in glob.glob(
os.path.join(self.TEST_DATA_DIR, 'france_parts.*')):
shutil.copy(os.path.join(self.TEST_DATA_DIR, file), tmppath)
vectorFileInfo = QFileInfo(tmppath + "/france_parts.shp")
mVectorLayer = QgsVectorLayer(vectorFileInfo.filePath(),
vectorFileInfo.completeBaseName(), "ogr")
QgsMapLayerRegistry.instance().addMapLayers([mVectorLayer])
# create composition with composer map
self.mapSettings = QgsMapSettings()
layerStringList = []
layerStringList.append(mVectorLayer.id())
self.mapSettings.setLayers(layerStringList)
self.mapSettings.setCrsTransformEnabled(True)
self.mapSettings.setMapUnits(QGis.Meters)
# select epsg:2154
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(2154)
self.mapSettings.setDestinationCrs(crs)
self.mComposition = QgsComposition(self.mapSettings)
self.mComposition.setPaperSize(297, 210)
# fix the renderer, fill with green
props = {"color": "0,127,0"}
fillSymbol = QgsFillSymbolV2.createSimple(props)
renderer = QgsSingleSymbolRendererV2(fillSymbol)
mVectorLayer.setRendererV2(renderer)
# the atlas map
self.mAtlasMap = QgsComposerMap(self.mComposition, 20, 20, 130, 130)
self.mAtlasMap.setFrameEnabled(True)
self.mComposition.addComposerMap(self.mAtlasMap)
# the atlas
self.mAtlas = self.mComposition.atlasComposition()
self.mAtlas.setCoverageLayer(mVectorLayer)
self.mAtlas.setEnabled(True)
self.mComposition.setAtlasMode(QgsComposition.ExportAtlas)
# an overview
mOverview = QgsComposerMap(self.mComposition, 180, 20, 50, 50)
mOverview.setFrameEnabled(True)
mOverview.setOverviewFrameMap(self.mAtlasMap.id())
self.mComposition.addComposerMap(mOverview)
nextent = QgsRectangle(49670.718, 6415139.086, 699672.519, 7065140.887)
mOverview.setNewExtent(nextent)
# set the fill symbol of the overview map
props2 = {"color": "127,0,0,127"}
fillSymbol2 = QgsFillSymbolV2.createSimple(props2)
mOverview.setOverviewFrameMapSymbol(fillSymbol2)
# header label
self.mLabel1 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel1)
self.mLabel1.setText("[% \"NAME_1\" %] area")
self.mLabel1.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel1.adjustSizeToText()
self.mLabel1.setSceneRect(QRectF(150, 5, 60, 15))
qWarning(
"header label font: %s exactMatch:%s" %
(self.mLabel1.font().toString(), self.mLabel1.font().exactMatch()))
# feature number label
self.mLabel2 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel2)
self.mLabel2.setText("# [%$feature || ' / ' || $numfeatures%]")
self.mLabel2.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel2.adjustSizeToText()
self.mLabel2.setSceneRect(QRectF(150, 200, 60, 15))
qWarning(
"feature number label font: %s exactMatch:%s" %
(self.mLabel2.font().toString(), self.mLabel2.font().exactMatch()))
self.filename_test()
self.autoscale_render_test()
self.autoscale_render_test_old_api()
self.fixedscale_render_test()
self.predefinedscales_render_test()
self.hidden_render_test()
self.legend_test()
shutil.rmtree(tmppath, True)
def filename_test(self):
self.mAtlas.setFilenamePattern("'output_' || $feature")
self.mAtlas.beginRender()
for i in range(0, self.mAtlas.numFeatures()):
self.mAtlas.prepareForFeature(i)
expected = "output_%d" % (i + 1)
assert self.mAtlas.currentFilename() == expected
self.mAtlas.endRender()
def autoscale_render_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_autoscale%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlasMap.setAtlasDriven(False)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlasMap.setAtlasMargin(0)
def autoscale_render_test_old_api(self):
self.mAtlas.setComposerMap(self.mAtlasMap)
self.mAtlas.setFixedScale(False)
self.mAtlas.setMargin(0.10)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker(
'atlas_autoscale_old_api%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlas.setFixedScale(True)
self.mAtlas.setMargin(0)
self.mAtlas.setComposerMap(None)
self.mAtlasMap.setAtlasDriven(False)
def fixedscale_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_fixedscale%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def predefinedscales_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Predefined)
scales = [1800000, 5000000]
self.mAtlas.setPredefinedScales(scales)
for i, s in enumerate(self.mAtlas.predefinedScales()):
assert s == scales[i]
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker(
'atlas_predefinedscales%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def hidden_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(True)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_hiding%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlas.setHideCoverage(False)
def sorting_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(False)
self.mAtlas.setSortFeatures(True)
self.mAtlas.setSortKeyAttributeIndex(4) # departement name
self.mAtlas.setSortAscending(False)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_sorting%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def filtering_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(False)
self.mAtlas.setSortFeatures(False)
self.mAtlas.setFilterFeatures(True)
self.mAtlas.setFeatureFilter(
"substr(NAME_1,1,1)='P'") # select only 'Pays de la loire'
self.mAtlas.beginRender()
for i in range(0, 1):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_filtering%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def legend_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
# add a point layer
ptLayer = QgsVectorLayer(
"Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)",
"points", "memory")
pr = ptLayer.dataProvider()
f1 = QgsFeature(1)
f1.initAttributes(2)
f1.setAttribute(0, 1)
f1.setAttribute(1, "Test label 1")
f1.setGeometry(QgsGeometry.fromPoint(QgsPoint(-0.638, 48.954)))
f2 = QgsFeature(2)
f2.initAttributes(2)
f2.setAttribute(0, 2)
f2.setAttribute(1, "Test label 2")
f2.setGeometry(QgsGeometry.fromPoint(QgsPoint(-1.682, 48.550)))
pr.addFeatures([f1, f2])
# categorized symbology
r = QgsCategorizedSymbolRendererV2("attr", [
QgsRendererCategoryV2(
1, QgsMarkerSymbolV2.createSimple({"color": "255,0,0"}),
"red"),
QgsRendererCategoryV2(
2, QgsMarkerSymbolV2.createSimple({"color": "0,0,255"}),
"blue")
])
ptLayer.setRendererV2(r)
QgsMapLayerRegistry.instance().addMapLayer(ptLayer)
# add the point layer to the map settings
layers = self.mapSettings.layers()
layers = [ptLayer.id()] + layers
self.mapSettings.setLayers(layers)
# add a legend
legend = QgsComposerLegend(self.mComposition)
legend.moveBy(200, 100)
# sets the legend filter parameter
legend.setComposerMap(self.mAtlasMap)
legend.setLegendFilterOutAtlas(True)
self.mComposition.addComposerLegend(legend)
self.mAtlas.beginRender()
self.mAtlas.prepareForFeature(0)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_legend', self.mComposition)
myTestResult, myMessage = checker.testComposition()
assert myTestResult
self.mAtlas.endRender()
# restore state
self.mapSettings.setLayers([layers[1]])
self.mComposition.removeComposerItem(legend)
QgsMapLayerRegistry.instance().removeMapLayer(ptLayer.id())
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'
QgsMapLayerRegistry.instance().addMapLayers([mRasterLayer])
# create composition with composer map
self.mMapSettings = QgsMapSettings()
self.mMapSettings.setLayers([mRasterLayer.id()])
self.mMapSettings.setCrsTransformEnabled(False)
self.mComposition = QgsComposition(self.mMapSettings)
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.setOverviewFrameMap(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.setOverviewFrameMap(self.mComposerMap.id())
overviewMap.setOverviewBlendMode(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.setOverviewFrameMap(self.mComposerMap.id())
overviewMap.setOverviewInverted(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.setOverviewFrameMap(self.mComposerMap.id())
overviewMap.setOverviewInverted(False)
overviewMap.setOverviewCentered(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]
class TestQgsAtlasComposition(unittest.TestCase):
def testCase(self):
self.TEST_DATA_DIR = unitTestDataPath()
vectorFileInfo = QFileInfo( self.TEST_DATA_DIR + "/france_parts.shp")
mVectorLayer = QgsVectorLayer( vectorFileInfo.filePath(), vectorFileInfo.completeBaseName(), "ogr" )
QgsMapLayerRegistry.instance().addMapLayers( [mVectorLayer] )
# create composition with composer map
mMapRenderer = QgsMapRenderer()
layerStringList = []
layerStringList.append( mVectorLayer.id() )
mMapRenderer.setLayerSet( layerStringList )
mMapRenderer.setProjectionsEnabled( True )
mMapRenderer.setMapUnits( QGis.Meters )
# select epsg:2154
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid( 2154 )
mMapRenderer.setDestinationCrs( crs )
self.mComposition = QgsComposition( mMapRenderer )
self.mComposition.setPaperSize( 297, 210 )
# fix the renderer, fill with green
props = { "color": "0,127,0" }
fillSymbol = QgsFillSymbolV2.createSimple( props )
renderer = QgsSingleSymbolRendererV2( fillSymbol )
mVectorLayer.setRendererV2( renderer )
# the atlas map
self.mAtlasMap = QgsComposerMap( self.mComposition, 20, 20, 130, 130 )
self.mAtlasMap.setFrameEnabled( True )
self.mComposition.addComposerMap( self.mAtlasMap )
# the atlas
self.mAtlas = self.mComposition.atlasComposition()
self.mAtlas.setCoverageLayer( mVectorLayer )
self.mAtlas.setEnabled( True )
self.mComposition.setAtlasMode( QgsComposition.ExportAtlas )
# an overview
mOverview = QgsComposerMap( self.mComposition, 180, 20, 50, 50 )
mOverview.setFrameEnabled( True )
mOverview.setOverviewFrameMap( self.mAtlasMap.id() )
self.mComposition.addComposerMap( mOverview )
nextent = QgsRectangle( 49670.718, 6415139.086, 699672.519, 7065140.887 )
mOverview.setNewExtent( nextent )
# set the fill symbol of the overview map
props2 = { "color": "127,0,0,127" }
fillSymbol2 = QgsFillSymbolV2.createSimple( props2 )
mOverview.setOverviewFrameMapSymbol( fillSymbol2 )
# header label
self.mLabel1 = QgsComposerLabel( self.mComposition )
self.mComposition.addComposerLabel( self.mLabel1 )
self.mLabel1.setText( "[% \"NAME_1\" %] area" )
self.mLabel1.setFont( QgsFontUtils.getStandardTestFont() )
self.mLabel1.adjustSizeToText()
self.mLabel1.setSceneRect( QRectF( 150, 5, 60, 15 ) )
qWarning( "header label font: %s exactMatch:%s" % ( self.mLabel1.font().toString(), self.mLabel1.font().exactMatch() ) )
# feature number label
self.mLabel2 = QgsComposerLabel( self.mComposition )
self.mComposition.addComposerLabel( self.mLabel2 )
self.mLabel2.setText( "# [%$feature || ' / ' || $numfeatures%]" )
self.mLabel2.setFont( QgsFontUtils.getStandardTestFont() )
self.mLabel2.adjustSizeToText()
self.mLabel2.setSceneRect( QRectF( 150, 200, 60, 15 ) )
qWarning( "feature number label font: %s exactMatch:%s" % ( self.mLabel2.font().toString(), self.mLabel2.font().exactMatch() ) )
self.filename_test()
self.autoscale_render_test()
self.autoscale_render_test_old_api()
self.fixedscale_render_test()
self.predefinedscales_render_test()
self.hidden_render_test()
def filename_test( self ):
self.mAtlas.setFilenamePattern( "'output_' || $feature" )
self.mAtlas.beginRender()
for i in range(0, self.mAtlas.numFeatures()):
self.mAtlas.prepareForFeature( i )
expected = "output_%d" % (i+1)
assert self.mAtlas.currentFilename() == expected
self.mAtlas.endRender()
def autoscale_render_test( self ):
self.mAtlasMap.setAtlasDriven( True )
self.mAtlasMap.setAtlasScalingMode( QgsComposerMap.Auto )
self.mAtlasMap.setAtlasMargin( 0.10 )
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature( i )
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_autoscale%d' % (i + 1), self.mComposition)
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlasMap.setAtlasDriven( False )
self.mAtlasMap.setAtlasScalingMode( QgsComposerMap.Fixed )
self.mAtlasMap.setAtlasMargin( 0 )
def autoscale_render_test_old_api( self ):
self.mAtlas.setComposerMap( self.mAtlasMap )
self.mAtlas.setFixedScale( False )
self.mAtlas.setMargin( 0.10 )
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature( i )
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_autoscale_old_api%d' % (i + 1), self.mComposition)
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlas.setFixedScale( True )
self.mAtlas.setMargin( 0 )
self.mAtlas.setComposerMap( None )
self.mAtlasMap.setAtlasDriven( False )
def fixedscale_render_test( self ):
self.mAtlasMap.setAtlasDriven( True )
self.mAtlasMap.setAtlasScalingMode( QgsComposerMap.Fixed )
self.mAtlasMap.setNewExtent( QgsRectangle( 209838.166, 6528781.020, 610491.166, 6920530.620 ) )
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature( i )
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_fixedscale%d' % (i + 1), self.mComposition)
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def predefinedscales_render_test( self ):
self.mAtlasMap.setAtlasDriven( True )
self.mAtlasMap.setNewExtent( QgsRectangle( 209838.166, 6528781.020, 610491.166, 6920530.620 ) )
self.mAtlasMap.setAtlasScalingMode( QgsComposerMap.Predefined )
scales = [1800000, 5000000]
self.mAtlas.setPredefinedScales( scales )
for i, s in enumerate(self.mAtlas.predefinedScales()):
assert s == scales[i]
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature( i )
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_predefinedscales%d' % (i + 1), self.mComposition)
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def hidden_render_test( self ):
self.mAtlasMap.setNewExtent( QgsRectangle( 209838.166, 6528781.020, 610491.166, 6920530.620 ) )
self.mAtlasMap.setAtlasScalingMode( QgsComposerMap.Fixed )
self.mAtlas.setHideCoverage( True )
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature( i )
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_hiding%d' % (i + 1), self.mComposition)
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def sorting_render_test( self ):
self.mAtlasMap.setNewExtent( QgsRectangle( 209838.166, 6528781.020, 610491.166, 6920530.620 ) )
self.mAtlasMap.setAtlasScalingMode( QgsComposerMap.Fixed )
self.mAtlas.setHideCoverage( False )
self.mAtlas.setSortFeatures( True )
self.mAtlas.setSortKeyAttributeIndex( 4 ) # departement name
self.mAtlas.setSortAscending( False )
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature( i )
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_sorting%d' % (i + 1), self.mComposition)
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def filtering_render_test( self ):
self.mAtlasMap.setNewExtent( QgsRectangle( 209838.166, 6528781.020, 610491.166, 6920530.620 ) )
self.mAtlasMap.setAtlasScalingMode( QgsComposerMap.Fixed )
self.mAtlas.setHideCoverage( False )
self.mAtlas.setSortFeatures( False )
self.mAtlas.setFilterFeatures( True )
self.mAtlas.setFeatureFilter( "substr(NAME_1,1,1)='P'" ) # select only 'Pays de la loire'
self.mAtlas.beginRender()
for i in range(0, 1):
self.mAtlas.prepareForFeature( i )
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_filtering%d' % (i + 1), self.mComposition)
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def exportToPdf(self, print_context, targetFile=None):
self.iface.mapCanvas().setDestinationCrs(
self.settings_instance.projection.crs())
myComposition = QgsComposition(self.iface.mapCanvas().mapSettings())
template = self.env.get_template(print_context['template'])
custom_qpt = template.render(CONTEXT=print_context)
myDocument = QDomDocument()
myDocument.setContent(custom_qpt)
myComposition.loadFromTemplate(myDocument)
suggestedFile = os.path.join(
self.settings_instance.projectFolderPath.text(),
print_context['title'] + ".pdf")
if not targetFile:
targetFile = QFileDialog.getSaveFileName(
None, "Export " + print_context['job'], suggestedFile, "*.pdf")
interactive = True
if not targetFile:
return
else:
interactive = None
outputDir = tempfile.gettempdir()
with open(os.path.join(targetFile + '.qpt'), "wb") as qpt_file:
qpt_file.write(custom_qpt)
if print_context['type'] == 'report':
myComposition.exportAsPDF(targetFile)
elif print_context['type'] == 'map':
print myComposition.getComposerMapById(0)
print myComposition.getComposerItemById('5')
for composer_map in myComposition.composerMapItems():
print composer_map, composer_map.id()
fdtm_extent = None
for layer in [
self.settings_instance.EPpLayer,
self.settings_instance.EApLayer,
self.settings_instance.WRLayer,
self.settings_instance.WDSLayer
]:
if layer.featureCount() > 0:
if fdtm_extent:
fdtm_extent.combineExtentWith(layer.extent())
else:
fdtm_extent = layer.extent()
fdtm_extent.scale(1.1)
composer_map.zoomToExtent(fdtm_extent)
composer_map.updateItem()
myComposition.refreshItems()
myComposition.exportAsPDF(targetFile)
elif print_context['type'] == 'mapppp':
print print_context
myComposition = QgsComposition(
self.iface.mapCanvas().mapSettings())
myComposition.setPlotStyle(QgsComposition.Print)
myComposition.setPaperSize(297, 210)
composer_map = QgsComposerMap(myComposition, 10, 10, 190, 190)
fdtm_extent = self.settings_instance.EPpLayer.extent()
for layer in [
self.settings_instance.EApLayer,
self.settings_instance.WRLayer,
self.settings_instance.WDSLayer
]:
fdtm_extent.combineExtentWith(layer.extent())
composer_map.zoomToExtent(fdtm_extent)
composer_map.updateItem()
myComposition.addItem(composer_map)
table = QgsComposerAttributeTable(myComposition)
table.setItemPosition(205, 170)
table.setVectorLayer(QgsMapLayerRegistry.instance().mapLayer(
print_context['id']))
table.setMaximumNumberOfFeatures(20)
table.setFilterFeatures(True)
col1 = QgsComposerTableColumn()
col1.setAttribute('types')
col1.setHeading("types")
col2 = QgsComposerTableColumn()
col2.setAttribute('project units')
col2.setHeading("project units")
col3 = QgsComposerTableColumn()
col3.setAttribute('Areas')
col3.setHeading("Areas")
col4 = QgsComposerTableColumn()
col4.setAttribute('Lengths')
col4.setHeading("Lengths")
col5 = QgsComposerTableColumn()
col5.setAttribute('Cost')
col5.setHeading("Cost")
table.setColumns([col1, col2, col3, col4, col5])
myComposition.addItem(table)
myComposition.exportAsPDF(targetFile)
elif print_context['type'] == 'atlas':
myComposition.setAtlasMode(QgsComposition.ExportAtlas)
for composer_map in myComposition.composerMapItems():
print composer_map, composer_map.id()
atlas = myComposition.atlasComposition()
atlas.setComposerMap(composer_map) #DEPRECATED
atlas.setPredefinedScales(self.PREDEFINED_SCALES)
composer_map.setAtlasDriven(True)
composer_map.setAtlasScalingMode(QgsComposerMap.Predefined)
atlas.beginRender()
rendered_pdf = []
progress = progressBar(self, "exporting " + print_context['job'],
atlas.numFeatures())
for i in range(0, atlas.numFeatures()):
atlas.prepareForFeature(i)
current_filename = atlas.currentFilename()
file_name = '_'.join(current_filename.split())
file_path = '%s.pdf' % file_name
path = os.path.join(outputDir, file_path)
myComposition.exportAsPDF(path)
rendered_pdf.append(path)
progress.setStep(i)
progress.stop(print_context['job'] + "exported to " + targetFile)
atlas.endRender()
merge_pdfs(rendered_pdf, targetFile)
if interactive:
open_file(targetFile)
return targetFile
class TestQgsAtlasComposition(unittest.TestCase):
def testCase(self):
self.TEST_DATA_DIR = unitTestDataPath()
tmppath = tempfile.mkdtemp()
for file in glob.glob(
os.path.join(self.TEST_DATA_DIR, 'france_parts.*')):
shutil.copy(os.path.join(self.TEST_DATA_DIR, file), tmppath)
vectorFileInfo = QFileInfo(tmppath + "/france_parts.shp")
mVectorLayer = QgsVectorLayer(vectorFileInfo.filePath(),
vectorFileInfo.completeBaseName(), "ogr")
QgsMapLayerRegistry.instance().addMapLayers([mVectorLayer])
# create composition with composer map
mMapRenderer = QgsMapRenderer()
layerStringList = []
layerStringList.append(mVectorLayer.id())
mMapRenderer.setLayerSet(layerStringList)
mMapRenderer.setProjectionsEnabled(True)
mMapRenderer.setMapUnits(QGis.Meters)
# select epsg:2154
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(2154)
mMapRenderer.setDestinationCrs(crs)
self.mComposition = QgsComposition(mMapRenderer)
self.mComposition.setPaperSize(297, 210)
# fix the renderer, fill with green
props = {"color": "0,127,0"}
fillSymbol = QgsFillSymbolV2.createSimple(props)
renderer = QgsSingleSymbolRendererV2(fillSymbol)
mVectorLayer.setRendererV2(renderer)
# the atlas map
self.mAtlasMap = QgsComposerMap(self.mComposition, 20, 20, 130, 130)
self.mAtlasMap.setFrameEnabled(True)
self.mComposition.addComposerMap(self.mAtlasMap)
# the atlas
self.mAtlas = self.mComposition.atlasComposition()
self.mAtlas.setCoverageLayer(mVectorLayer)
self.mAtlas.setEnabled(True)
self.mComposition.setAtlasMode(QgsComposition.ExportAtlas)
# an overview
mOverview = QgsComposerMap(self.mComposition, 180, 20, 50, 50)
mOverview.setFrameEnabled(True)
mOverview.setOverviewFrameMap(self.mAtlasMap.id())
self.mComposition.addComposerMap(mOverview)
nextent = QgsRectangle(49670.718, 6415139.086, 699672.519, 7065140.887)
mOverview.setNewExtent(nextent)
# set the fill symbol of the overview map
props2 = {"color": "127,0,0,127"}
fillSymbol2 = QgsFillSymbolV2.createSimple(props2)
mOverview.setOverviewFrameMapSymbol(fillSymbol2)
# header label
self.mLabel1 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel1)
self.mLabel1.setText("[% \"NAME_1\" %] area")
self.mLabel1.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel1.adjustSizeToText()
self.mLabel1.setSceneRect(QRectF(150, 5, 60, 15))
qWarning(
"header label font: %s exactMatch:%s" %
(self.mLabel1.font().toString(), self.mLabel1.font().exactMatch()))
# feature number label
self.mLabel2 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel2)
self.mLabel2.setText("# [%$feature || ' / ' || $numfeatures%]")
self.mLabel2.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel2.adjustSizeToText()
self.mLabel2.setSceneRect(QRectF(150, 200, 60, 15))
qWarning(
"feature number label font: %s exactMatch:%s" %
(self.mLabel2.font().toString(), self.mLabel2.font().exactMatch()))
self.filename_test()
self.autoscale_render_test()
self.autoscale_render_test_old_api()
self.fixedscale_render_test()
self.predefinedscales_render_test()
self.hidden_render_test()
shutil.rmtree(tmppath, True)
def filename_test(self):
self.mAtlas.setFilenamePattern("'output_' || $feature")
self.mAtlas.beginRender()
for i in range(0, self.mAtlas.numFeatures()):
self.mAtlas.prepareForFeature(i)
expected = "output_%d" % (i + 1)
assert self.mAtlas.currentFilename() == expected
self.mAtlas.endRender()
def autoscale_render_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_autoscale%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlasMap.setAtlasDriven(False)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlasMap.setAtlasMargin(0)
def autoscale_render_test_old_api(self):
self.mAtlas.setComposerMap(self.mAtlasMap)
self.mAtlas.setFixedScale(False)
self.mAtlas.setMargin(0.10)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker(
'atlas_autoscale_old_api%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlas.setFixedScale(True)
self.mAtlas.setMargin(0)
self.mAtlas.setComposerMap(None)
self.mAtlasMap.setAtlasDriven(False)
def fixedscale_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_fixedscale%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def predefinedscales_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Predefined)
scales = [1800000, 5000000]
self.mAtlas.setPredefinedScales(scales)
for i, s in enumerate(self.mAtlas.predefinedScales()):
assert s == scales[i]
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker(
'atlas_predefinedscales%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def hidden_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(True)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_hiding%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def sorting_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(False)
self.mAtlas.setSortFeatures(True)
self.mAtlas.setSortKeyAttributeIndex(4) # departement name
self.mAtlas.setSortAscending(False)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_sorting%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def filtering_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(False)
self.mAtlas.setSortFeatures(False)
self.mAtlas.setFilterFeatures(True)
self.mAtlas.setFeatureFilter(
"substr(NAME_1,1,1)='P'") # select only 'Pays de la loire'
self.mAtlas.beginRender()
for i in range(0, 1):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_filtering%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
class TestQgsComposerMap(TestCase):
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 testGrid(self):
"""Test that we can create a grid for a map."""
myRectangle = QgsRectangle(781662.375, 3339523.125,
793062.375, 3345223.125)
self.mComposerMap.setNewExtent(myRectangle)
self.mComposerMap.setGridEnabled(True)
self.mComposerMap.setGridIntervalX(2000)
self.mComposerMap.setGridIntervalY(2000)
self.mComposerMap.setShowGridAnnotation(True)
self.mComposerMap.setGridPenWidth(0.5)
self.mComposerMap.setGridPenColor(QColor(0,255,0))
self.mComposerMap.setGridAnnotationPrecision(0)
self.mComposerMap.setGridAnnotationPosition(QgsComposerMap.Disabled,
QgsComposerMap.Left)
self.mComposerMap.setGridAnnotationPosition(
QgsComposerMap.OutsideMapFrame,
QgsComposerMap.Right)
self.mComposerMap.setGridAnnotationPosition(QgsComposerMap.Disabled,
QgsComposerMap.Top)
self.mComposerMap.setGridAnnotationPosition(
QgsComposerMap.OutsideMapFrame,
QgsComposerMap.Bottom)
self.mComposerMap.setGridAnnotationDirection(QgsComposerMap.Horizontal,
QgsComposerMap.Right)
self.mComposerMap.setGridAnnotationDirection(QgsComposerMap.Horizontal,
QgsComposerMap.Bottom)
self.mComposerMap.setAnnotationFontColor(QColor(255,0,0,150))
self.mComposerMap.setGridBlendMode(QPainter.CompositionMode_Overlay)
checker = QgsCompositionChecker()
myPath = os.path.join(TEST_DATA_DIR,
'control_images',
'expected_composermap',
'composermap_landsat_grid.png')
myTestResult, myMessage = checker.testComposition('Composer map grid',
self.mComposition, myPath)
self.mComposerMap.setGridEnabled(False)
self.mComposerMap.setShowGridAnnotation(False)
assert myTestResult == True, myMessage
def testOverviewMap(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375, 3341423.125,
789262.375, 3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125,
793062.375, 3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
checker = QgsCompositionChecker()
myPngPath = os.path.join(TEST_DATA_DIR,
'control_images',
'expected_composermap',
'composermap_landsat_overview.png')
myTestResult, myMessage = checker.testComposition(
'Composer map overview',
self.mComposition,
myPngPath)
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
def testOverviewMapBlend(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375, 3341423.125,
789262.375, 3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125,
793062.375, 3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
overviewMap.setOverviewBlendMode(QPainter.CompositionMode_Multiply)
checker = QgsCompositionChecker()
myPngPath = os.path.join(TEST_DATA_DIR,
'control_images',
'expected_composermap',
'composermap_landsat_overview_blend.png')
myTestResult, myMessage = checker.testComposition(
'Composer map overview blending',
self.mComposition,
myPngPath)
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
def testOverviewMapInvert(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375, 3341423.125,
789262.375, 3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125,
793062.375, 3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
overviewMap.setOverviewInverted(True)
checker = QgsCompositionChecker()
myPngPath = os.path.join(TEST_DATA_DIR,
'control_images',
'expected_composermap',
'composermap_landsat_overview_invert.png')
myTestResult, myMessage = checker.testComposition(
'Composer map overview inverted',
self.mComposition,
myPngPath)
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
# Fails because addItemsFromXML has been commented out in sip
@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 testZebraStyle(self):
self.mComposerMap.setGridFrameStyle(QgsComposerMap.Zebra)
myRectangle = QgsRectangle(785462.375, 3341423.125,
789262.375, 3343323.125)
self.mComposerMap.setNewExtent( myRectangle )
self.mComposerMap.setGridEnabled(True)
self.mComposerMap.setGridIntervalX(2000)
self.mComposerMap.setGridIntervalY(2000)
checker = QgsCompositionChecker()
myPngPath = os.path.join(TEST_DATA_DIR,
'control_images',
'expected_composermap',
'composermap_zebra_style.png')
testResult, myMessage = checker.testComposition('Composer map zebra',
self.mComposition,
myPngPath)
assert testResult == True, myMessage
class TestQgsComposerMap(TestCase):
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().addMapLayer(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 testGrid(self):
"""Test that we can create a grid for a map."""
myRectangle = QgsRectangle(781662.375, 3339523.125,
793062.375, 3345223.125)
self.mComposerMap.setNewExtent(myRectangle)
self.mComposerMap.setGridEnabled(True)
self.mComposerMap.setGridIntervalX(2000)
self.mComposerMap.setGridIntervalY(2000)
self.mComposerMap.setShowGridAnnotation(True)
self.mComposerMap.setGridPenWidth(0.5)
self.mComposerMap.setGridAnnotationPrecision(0)
self.mComposerMap.setGridAnnotationPosition(QgsComposerMap.Disabled,
QgsComposerMap.Left)
self.mComposerMap.setGridAnnotationPosition(
QgsComposerMap.OutsideMapFrame,
QgsComposerMap.Right)
self.mComposerMap.setGridAnnotationPosition(QgsComposerMap.Disabled,
QgsComposerMap.Top)
self.mComposerMap.setGridAnnotationPosition(
QgsComposerMap.OutsideMapFrame,
QgsComposerMap.Bottom)
self.mComposerMap.setGridAnnotationDirection(QgsComposerMap.Horizontal,
QgsComposerMap.Right)
self.mComposerMap.setGridAnnotationDirection(QgsComposerMap.Horizontal,
QgsComposerMap.Bottom)
checker = QgsCompositionChecker()
myPath = os.path.join(TEST_DATA_DIR,
"control_images",
"expected_composermap",
"composermap_landsat_grid.png")
testResult = checker.testComposition("Composer map grid",
self.mComposition, myPath)
self.mComposerMap.setGridEnabled(False)
self.mComposerMap.setShowGridAnnotation(False)
print testResult
assert testResult[0] == True
def testOverviewMap(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375, 3341423.125,
789262.375, 3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125,
793062.375, 3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
checker = QgsCompositionChecker()
myPngPath = os.path.join(TEST_DATA_DIR,
"control_images",
"expected_composermap",
"composermap_landsat_overview.png")
testResult = checker.testComposition("Composer map overview",
self.mComposition,
myPngPath)
self.mComposition.removeComposerItem(overviewMap)
assert testResult[0] == True
def uniqueId(self, mComposerMap, mComposition):
doc = QDomDocument()
documentElement = doc.createElement( "ComposerItemClipboard" )
mComposerMap.writeXML( documentElement, doc )
mComposition.addItemsFromXML( documentElement, doc, 0, false )
#test if both composer maps have different ids
newMap = QgsComposerMap()
mapList = mComposition.composerMapItems()
for mapIt in mapList:
if mapIt != mComposerMap:
newMap = mapIt
break
oldId = mComposerMap.id()
newId = newMap.id()
mComposition.removeComposerItem( newMap );
print "old: "+str(oldId)
print "new "+str(newId)
assert oldId != newId
def zebraStyle(self):
mComposerMap.setGridFrameStyle( QgsComposerMap.Zebra )
mComposerMap.setGridEnabled( True )
myPngPath = os.path.join(TEST_DATA_DIR,
"control_images",
"expected_composermap",
"composermap_zebra_style.png")
testResult = checker.testComposition("Composer map zebra",
self.mComposition,
myPngPath)
assert testResult[0] == True
class TestQgsAtlasComposition(unittest.TestCase):
def testCase(self):
self.TEST_DATA_DIR = unitTestDataPath()
tmppath = tempfile.mkdtemp()
for file in glob.glob(os.path.join(self.TEST_DATA_DIR, 'france_parts.*')):
shutil.copy(os.path.join(self.TEST_DATA_DIR, file), tmppath)
vectorFileInfo = QFileInfo(tmppath + "/france_parts.shp")
mVectorLayer = QgsVectorLayer(vectorFileInfo.filePath(), vectorFileInfo.completeBaseName(), "ogr")
QgsProject.instance().addMapLayers([mVectorLayer])
self.layers = [mVectorLayer]
# create composition with composer map
# select epsg:2154
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(2154)
QgsProject.instance().setCrs(crs)
self.mComposition = QgsComposition(QgsProject.instance())
self.mComposition.setPaperSize(297, 210)
# fix the renderer, fill with green
props = {"color": "0,127,0"}
fillSymbol = QgsFillSymbol.createSimple(props)
renderer = QgsSingleSymbolRenderer(fillSymbol)
mVectorLayer.setRenderer(renderer)
# the atlas map
self.mAtlasMap = QgsComposerMap(self.mComposition, 20, 20, 130, 130)
self.mAtlasMap.setFrameEnabled(True)
self.mAtlasMap.setLayers([mVectorLayer])
self.mComposition.addComposerMap(self.mAtlasMap)
# the atlas
self.mAtlas = self.mComposition.atlasComposition()
self.mAtlas.setCoverageLayer(mVectorLayer)
self.mAtlas.setEnabled(True)
self.mComposition.setAtlasMode(QgsComposition.ExportAtlas)
# an overview
self.mOverview = QgsComposerMap(self.mComposition, 180, 20, 50, 50)
self.mOverview.setFrameEnabled(True)
self.mOverview.overview().setFrameMap(self.mAtlasMap.id())
self.mOverview.setLayers([mVectorLayer])
self.mComposition.addComposerMap(self.mOverview)
nextent = QgsRectangle(49670.718, 6415139.086, 699672.519, 7065140.887)
self.mOverview.setNewExtent(nextent)
# set the fill symbol of the overview map
props2 = {"color": "127,0,0,127"}
fillSymbol2 = QgsFillSymbol.createSimple(props2)
self.mOverview.overview().setFrameSymbol(fillSymbol2)
# header label
self.mLabel1 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel1)
self.mLabel1.setText("[% \"NAME_1\" %] area")
self.mLabel1.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel1.adjustSizeToText()
self.mLabel1.setSceneRect(QRectF(150, 5, 60, 15))
qWarning(
"header label font: %s exactMatch:%s" % (self.mLabel1.font().toString(), self.mLabel1.font().exactMatch()))
# feature number label
self.mLabel2 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel2)
self.mLabel2.setText("# [%@atlas_featurenumber || ' / ' || @atlas_totalfeatures%]")
self.mLabel2.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel2.adjustSizeToText()
self.mLabel2.setSceneRect(QRectF(150, 200, 60, 15))
qWarning("feature number label font: %s exactMatch:%s" % (
self.mLabel2.font().toString(), self.mLabel2.font().exactMatch()))
self.filename_test()
self.autoscale_render_test()
self.fixedscale_render_test()
self.predefinedscales_render_test()
self.hidden_render_test()
self.legend_test()
self.rotation_test()
shutil.rmtree(tmppath, True)
def filename_test(self):
self.mAtlas.setFilenamePattern("'output_' || @atlas_featurenumber")
self.mAtlas.beginRender()
for i in range(0, self.mAtlas.numFeatures()):
self.mAtlas.prepareForFeature(i)
expected = "output_%d" % (i + 1)
self.assertEqual(self.mAtlas.currentFilename(), expected)
self.mAtlas.endRender()
def autoscale_render_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_autoscale%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlasMap.setAtlasDriven(False)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlasMap.setAtlasMargin(0)
def fixedscale_render_test(self):
self.mAtlasMap.setNewExtent(QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_fixedscale%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def predefinedscales_render_test(self):
self.mAtlasMap.setNewExtent(QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Predefined)
scales = [1800000, 5000000]
self.mAtlas.setPredefinedScales(scales)
for i, s in enumerate(self.mAtlas.predefinedScales()):
assert s == scales[i]
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_predefinedscales%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def hidden_render_test(self):
self.mAtlasMap.setNewExtent(QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(True)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_hiding%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlas.setHideCoverage(False)
def sorting_render_test(self):
self.mAtlasMap.setNewExtent(QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(False)
self.mAtlas.setSortFeatures(True)
self.mAtlas.setSortKeyAttributeIndex(4) # departement name
self.mAtlas.setSortAscending(False)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_sorting%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def filtering_render_test(self):
self.mAtlasMap.setNewExtent(QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(False)
self.mAtlas.setSortFeatures(False)
self.mAtlas.setFilterFeatures(True)
self.mAtlas.setFeatureFilter("substr(NAME_1,1,1)='P'") # select only 'Pays de la loire'
self.mAtlas.beginRender()
for i in range(0, 1):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_filtering%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def legend_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
# add a point layer
ptLayer = QgsVectorLayer("Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)", "points", "memory")
pr = ptLayer.dataProvider()
f1 = QgsFeature(1)
f1.initAttributes(2)
f1.setAttribute(0, 1)
f1.setAttribute(1, "Test label 1")
f1.setGeometry(QgsGeometry.fromPoint(QgsPointXY(-0.638, 48.954)))
f2 = QgsFeature(2)
f2.initAttributes(2)
f2.setAttribute(0, 2)
f2.setAttribute(1, "Test label 2")
f2.setGeometry(QgsGeometry.fromPoint(QgsPointXY(-1.682, 48.550)))
pr.addFeatures([f1, f2])
# categorized symbology
r = QgsCategorizedSymbolRenderer("attr", [QgsRendererCategory(1, QgsMarkerSymbol.createSimple({"color": "255,0,0"}), "red"),
QgsRendererCategory(2, QgsMarkerSymbol.createSimple({"color": "0,0,255"}), "blue")])
ptLayer.setRenderer(r)
QgsProject.instance().addMapLayer(ptLayer)
# add the point layer to the map settings
layers = self.layers
layers = [ptLayer] + layers
self.mAtlasMap.setLayers(layers)
self.mOverview.setLayers(layers)
# add a legend
legend = QgsComposerLegend(self.mComposition)
legend.moveBy(200, 100)
# sets the legend filter parameter
legend.setComposerMap(self.mAtlasMap)
legend.setLegendFilterOutAtlas(True)
self.mComposition.addComposerLegend(legend)
self.mAtlas.beginRender()
self.mAtlas.prepareForFeature(0)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_legend', self.mComposition)
myTestResult, myMessage = checker.testComposition()
assert myTestResult
self.mAtlas.endRender()
# restore state
self.mAtlasMap.setLayers([layers[1]])
self.mComposition.removeComposerItem(legend)
QgsProject.instance().removeMapLayer(ptLayer.id())
def rotation_test(self):
# We will create a polygon layer with a rotated rectangle.
# Then we will make it the object layer for the atlas,
# rotate the map and test that the bounding rectangle
# is smaller than the bounds without rotation.
polygonLayer = QgsVectorLayer('Polygon', 'test_polygon', 'memory')
poly = QgsFeature(polygonLayer.pendingFields())
points = [(10, 15), (15, 10), (45, 40), (40, 45)]
poly.setGeometry(QgsGeometry.fromPolygon([[QgsPointXY(x[0], x[1]) for x in points]]))
polygonLayer.dataProvider().addFeatures([poly])
QgsProject.instance().addMapLayer(polygonLayer)
# Recreating the composer locally
composition = QgsComposition(QgsProject.instance())
composition.setPaperSize(297, 210)
# the atlas map
atlasMap = QgsComposerMap(composition, 20, 20, 130, 130)
atlasMap.setFrameEnabled(True)
atlasMap.setLayers([polygonLayer])
atlasMap.setNewExtent(QgsRectangle(0, 0, 100, 50))
composition.addComposerMap(atlasMap)
# the atlas
atlas = composition.atlasComposition()
atlas.setCoverageLayer(polygonLayer)
atlas.setEnabled(True)
composition.setAtlasMode(QgsComposition.ExportAtlas)
atlasMap.setAtlasDriven(True)
atlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
atlasMap.setAtlasMargin(0.0)
# Testing
atlasMap.setMapRotation(0.0)
atlas.firstFeature()
nonRotatedExtent = QgsRectangle(atlasMap.currentMapExtent())
atlasMap.setMapRotation(45.0)
atlas.firstFeature()
rotatedExtent = QgsRectangle(atlasMap.currentMapExtent())
assert rotatedExtent.width() < nonRotatedExtent.width() * 0.9
assert rotatedExtent.height() < nonRotatedExtent.height() * 0.9
QgsProject.instance().removeMapLayer(polygonLayer)
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)
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 testOverviewMap(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
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)
overviewMap.setLayers([self.raster_layer])
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)
overviewMap.setLayers([self.raster_layer])
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)
overviewMap.setLayers([self.raster_layer])
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
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 testuniqueId(self):
doc = QDomDocument()
documentElement = doc.createElement('ComposerItemClipboard')
self.mComposition.writeXml(documentElement, doc)
self.mComposition.addItemsFromXml(documentElement, doc)
# test if both composer maps have different ids
newMap = QgsComposerMap(self.mComposition, 0, 0, 10, 10)
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.setReferenceMap(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]
class TestQgsComposerMap(TestCase):
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 = []
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 testOverviewMap(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375, 3341423.125,
789262.375, 3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125,
793062.375, 3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
checker = QgsCompositionChecker('composermap_overview', self.mComposition)
myTestResult, myMessage = checker.testComposition()
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
def testOverviewMapBlend(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375, 3341423.125,
789262.375, 3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125,
793062.375, 3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
overviewMap.setOverviewBlendMode(QPainter.CompositionMode_Multiply)
checker = QgsCompositionChecker('composermap_overview_blending', self.mComposition)
myTestResult, myMessage = checker.testComposition()
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
def testOverviewMapInvert(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375, 3341423.125,
789262.375, 3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125,
793062.375, 3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
overviewMap.setOverviewInverted(True)
checker = QgsCompositionChecker('composermap_overview_invert', self.mComposition)
myTestResult, myMessage = checker.testComposition()
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
def testOverviewMapCenter(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375+5000, 3341423.125,
789262.375+5000, 3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125,
793062.375, 3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
overviewMap.setOverviewInverted(False)
overviewMap.setOverviewCentered(True)
checker = QgsCompositionChecker('composermap_overview_center', self.mComposition)
myTestResult, myMessage = checker.testComposition()
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
# Fails because addItemsFromXML has been commented out in sip
@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]
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)
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 testOverviewMap(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
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)
overviewMap.setLayers([self.raster_layer])
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)
overviewMap.setLayers([self.raster_layer])
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)
overviewMap.setLayers([self.raster_layer])
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
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 testuniqueId(self):
doc = QDomDocument()
documentElement = doc.createElement('ComposerItemClipboard')
self.mComposition.writeXml(documentElement, doc)
self.mComposition.addItemsFromXml(documentElement, doc)
# test if both composer maps have different ids
newMap = QgsComposerMap(self.mComposition, 0, 0, 10, 10)
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.setReferenceMap(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]
class TestQgsComposerMap(TestCase):
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 = []
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 testGrid(self):
"""Test that we can create a grid for a map."""
myRectangle = QgsRectangle(781662.375, 3339523.125, 793062.375,
3345223.125)
self.mComposerMap.setNewExtent(myRectangle)
self.mComposerMap.setGridEnabled(True)
self.mComposerMap.setGridIntervalX(2000)
self.mComposerMap.setGridIntervalY(2000)
self.mComposerMap.setShowGridAnnotation(True)
self.mComposerMap.setGridPenWidth(0.5)
self.mComposerMap.setGridPenColor(QColor(0, 255, 0))
self.mComposerMap.setGridAnnotationPrecision(0)
self.mComposerMap.setGridAnnotationPosition(QgsComposerMap.Disabled,
QgsComposerMap.Left)
self.mComposerMap.setGridAnnotationPosition(
QgsComposerMap.OutsideMapFrame, QgsComposerMap.Right)
self.mComposerMap.setGridAnnotationPosition(QgsComposerMap.Disabled,
QgsComposerMap.Top)
self.mComposerMap.setGridAnnotationPosition(
QgsComposerMap.OutsideMapFrame, QgsComposerMap.Bottom)
self.mComposerMap.setGridAnnotationDirection(QgsComposerMap.Horizontal,
QgsComposerMap.Right)
self.mComposerMap.setGridAnnotationDirection(QgsComposerMap.Horizontal,
QgsComposerMap.Bottom)
self.mComposerMap.setAnnotationFontColor(QColor(255, 0, 0, 150))
self.mComposerMap.setGridBlendMode(QPainter.CompositionMode_Overlay)
checker = QgsCompositionChecker('composermap_grid', self.mComposition)
myTestResult, myMessage = checker.testComposition()
self.mComposerMap.setGridEnabled(False)
self.mComposerMap.setShowGridAnnotation(False)
assert myTestResult == True, myMessage
def testOverviewMap(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375, 3341423.125, 789262.375,
3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125, 793062.375,
3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
checker = QgsCompositionChecker('composermap_overview',
self.mComposition)
myTestResult, myMessage = checker.testComposition()
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
def testOverviewMapBlend(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375, 3341423.125, 789262.375,
3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125, 793062.375,
3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
overviewMap.setOverviewBlendMode(QPainter.CompositionMode_Multiply)
checker = QgsCompositionChecker('composermap_overview_blending',
self.mComposition)
myTestResult, myMessage = checker.testComposition()
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
def testOverviewMapInvert(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375, 3341423.125, 789262.375,
3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125, 793062.375,
3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
overviewMap.setOverviewInverted(True)
checker = QgsCompositionChecker('composermap_overview_invert',
self.mComposition)
myTestResult, myMessage = checker.testComposition()
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
def testOverviewMapCenter(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375 + 5000, 3341423.125,
789262.375 + 5000, 3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125, 793062.375,
3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
overviewMap.setOverviewInverted(False)
overviewMap.setOverviewCentered(True)
checker = QgsCompositionChecker('composermap_overview_center',
self.mComposition)
myTestResult, myMessage = checker.testComposition()
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
# Fails because addItemsFromXML has been commented out in sip
@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 testZebraStyle(self):
self.mComposerMap.setGridFrameStyle(QgsComposerMap.Zebra)
myRectangle = QgsRectangle(785462.375, 3341423.125, 789262.375,
3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
self.mComposerMap.setGridEnabled(True)
self.mComposerMap.setGridIntervalX(2000)
self.mComposerMap.setGridIntervalY(2000)
self.mComposerMap.setGridFrameWidth(10)
self.mComposerMap.setGridFramePenSize(1)
self.mComposerMap.setGridPenWidth(0.5)
self.mComposerMap.setGridFramePenColor(QColor(255, 100, 0, 200))
self.mComposerMap.setGridFrameFillColor1(QColor(50, 90, 50, 100))
self.mComposerMap.setGridFrameFillColor2(QColor(200, 220, 100, 60))
checker = QgsCompositionChecker('composermap_zebrastyle',
self.mComposition)
myTestResult, myMessage = checker.testComposition()
assert myTestResult == True, 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]
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'
QgsMapLayerRegistry.instance().addMapLayers([mRasterLayer])
# create composition with composer map
self.mMapSettings = QgsMapSettings()
self.mMapSettings.setLayers([mRasterLayer.id()])
self.mMapSettings.setCrsTransformEnabled(False)
self.mComposition = QgsComposition(self.mMapSettings)
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, 1e03)
for i in range(0, 6):
assert abs(p[i] - pexpected[i]) < ptolerance[i]
class TestQgsAtlasComposition(unittest.TestCase):
def testCase(self):
self.TEST_DATA_DIR = unitTestDataPath()
tmppath = tempfile.mkdtemp()
for file in glob.glob(os.path.join(self.TEST_DATA_DIR, 'france_parts.*')):
shutil.copy(os.path.join(self.TEST_DATA_DIR, file), tmppath)
vectorFileInfo = QFileInfo(tmppath + "/france_parts.shp")
mVectorLayer = QgsVectorLayer(vectorFileInfo.filePath(), vectorFileInfo.completeBaseName(), "ogr")
QgsMapLayerRegistry.instance().addMapLayers([mVectorLayer])
# create composition with composer map
self.mapSettings = QgsMapSettings()
layerStringList = []
layerStringList.append(mVectorLayer.id())
self.mapSettings.setLayers(layerStringList)
self.mapSettings.setCrsTransformEnabled(True)
self.mapSettings.setMapUnits(QGis.Meters)
# select epsg:2154
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(2154)
self.mapSettings.setDestinationCrs(crs)
self.mComposition = QgsComposition(self.mapSettings)
self.mComposition.setPaperSize(297, 210)
# fix the renderer, fill with green
props = {"color": "0,127,0"}
fillSymbol = QgsFillSymbolV2.createSimple(props)
renderer = QgsSingleSymbolRendererV2(fillSymbol)
mVectorLayer.setRendererV2(renderer)
# the atlas map
self.mAtlasMap = QgsComposerMap(self.mComposition, 20, 20, 130, 130)
self.mAtlasMap.setFrameEnabled(True)
self.mComposition.addComposerMap(self.mAtlasMap)
# the atlas
self.mAtlas = self.mComposition.atlasComposition()
self.mAtlas.setCoverageLayer(mVectorLayer)
self.mAtlas.setEnabled(True)
self.mComposition.setAtlasMode(QgsComposition.ExportAtlas)
# an overview
mOverview = QgsComposerMap(self.mComposition, 180, 20, 50, 50)
mOverview.setFrameEnabled(True)
mOverview.setOverviewFrameMap(self.mAtlasMap.id())
self.mComposition.addComposerMap(mOverview)
nextent = QgsRectangle(49670.718, 6415139.086, 699672.519, 7065140.887)
mOverview.setNewExtent(nextent)
# set the fill symbol of the overview map
props2 = {"color": "127,0,0,127"}
fillSymbol2 = QgsFillSymbolV2.createSimple(props2)
mOverview.setOverviewFrameMapSymbol(fillSymbol2)
# header label
self.mLabel1 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel1)
self.mLabel1.setText("[% \"NAME_1\" %] area")
self.mLabel1.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel1.adjustSizeToText()
self.mLabel1.setSceneRect(QRectF(150, 5, 60, 15))
qWarning(
"header label font: %s exactMatch:%s" % (self.mLabel1.font().toString(), self.mLabel1.font().exactMatch()))
# feature number label
self.mLabel2 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel2)
self.mLabel2.setText("# [%$feature || ' / ' || $numfeatures%]")
self.mLabel2.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel2.adjustSizeToText()
self.mLabel2.setSceneRect(QRectF(150, 200, 60, 15))
qWarning("feature number label font: %s exactMatch:%s" % (
self.mLabel2.font().toString(), self.mLabel2.font().exactMatch()))
self.filename_test()
self.autoscale_render_test()
self.autoscale_render_test_old_api()
self.fixedscale_render_test()
self.predefinedscales_render_test()
self.hidden_render_test()
self.legend_test()
shutil.rmtree(tmppath, True)
def filename_test(self):
self.mAtlas.setFilenamePattern("'output_' || $feature")
self.mAtlas.beginRender()
for i in range(0, self.mAtlas.numFeatures()):
self.mAtlas.prepareForFeature(i)
expected = "output_%d" % (i + 1)
assert self.mAtlas.currentFilename() == expected
self.mAtlas.endRender()
def autoscale_render_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_autoscale%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlasMap.setAtlasDriven(False)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlasMap.setAtlasMargin(0)
def autoscale_render_test_old_api(self):
self.mAtlas.setComposerMap(self.mAtlasMap)
self.mAtlas.setFixedScale(False)
self.mAtlas.setMargin(0.10)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_autoscale_old_api%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlas.setFixedScale(True)
self.mAtlas.setMargin(0)
self.mAtlas.setComposerMap(None)
self.mAtlasMap.setAtlasDriven(False)
def fixedscale_render_test(self):
self.mAtlasMap.setNewExtent(QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_fixedscale%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def predefinedscales_render_test(self):
self.mAtlasMap.setNewExtent(QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Predefined)
scales = [1800000, 5000000]
self.mAtlas.setPredefinedScales(scales)
for i, s in enumerate(self.mAtlas.predefinedScales()):
assert s == scales[i]
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_predefinedscales%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def hidden_render_test(self):
self.mAtlasMap.setNewExtent(QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(True)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_hiding%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlas.setHideCoverage(False)
def sorting_render_test(self):
self.mAtlasMap.setNewExtent(QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(False)
self.mAtlas.setSortFeatures(True)
self.mAtlas.setSortKeyAttributeIndex(4) # departement name
self.mAtlas.setSortAscending(False)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_sorting%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def filtering_render_test(self):
self.mAtlasMap.setNewExtent(QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(False)
self.mAtlas.setSortFeatures(False)
self.mAtlas.setFilterFeatures(True)
self.mAtlas.setFeatureFilter("substr(NAME_1,1,1)='P'") # select only 'Pays de la loire'
self.mAtlas.beginRender()
for i in range(0, 1):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_filtering%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def legend_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
# add a point layer
ptLayer = QgsVectorLayer("Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)", "points", "memory")
pr = ptLayer.dataProvider()
f1 = QgsFeature(1)
f1.initAttributes(2)
f1.setAttribute(0, 1)
f1.setAttribute(1, "Test label 1")
f1.setGeometry(QgsGeometry.fromPoint(QgsPoint(-0.638, 48.954)))
f2 = QgsFeature(2)
f2.initAttributes(2)
f2.setAttribute(0, 2)
f2.setAttribute(1, "Test label 2")
f2.setGeometry(QgsGeometry.fromPoint(QgsPoint(-1.682, 48.550)))
pr.addFeatures([f1, f2])
# categorized symbology
r = QgsCategorizedSymbolRendererV2("attr", [QgsRendererCategoryV2(1, QgsMarkerSymbolV2.createSimple({"color": "255,0,0"}), "red"),
QgsRendererCategoryV2(2, QgsMarkerSymbolV2.createSimple({"color": "0,0,255"}), "blue")])
ptLayer.setRendererV2(r)
QgsMapLayerRegistry.instance().addMapLayer(ptLayer)
# add the point layer to the map settings
layers = self.mapSettings.layers()
layers = [ptLayer.id()] + layers
self.mapSettings.setLayers(layers)
# add a legend
legend = QgsComposerLegend(self.mComposition)
legend.moveBy(200, 100)
# sets the legend filter parameter
legend.setComposerMap(self.mAtlasMap)
legend.setLegendFilterOutAtlas(True)
self.mComposition.addComposerLegend(legend)
self.mAtlas.beginRender()
self.mAtlas.prepareForFeature(0)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_legend', self.mComposition)
myTestResult, myMessage = checker.testComposition()
assert myTestResult
self.mAtlas.endRender()
# restore state
self.mapSettings.setLayers([layers[1]])
self.mComposition.removeComposerItem(legend)
QgsMapLayerRegistry.instance().removeMapLayer(ptLayer.id())
class TestQgsComposerMap(TestCase):
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 testGrid(self):
"""Test that we can create a grid for a map."""
myRectangle = QgsRectangle(781662.375, 3339523.125,
793062.375, 3345223.125)
self.mComposerMap.setNewExtent(myRectangle)
self.mComposerMap.setGridEnabled(True)
self.mComposerMap.setGridIntervalX(2000)
self.mComposerMap.setGridIntervalY(2000)
self.mComposerMap.setShowGridAnnotation(True)
self.mComposerMap.setGridPenWidth(0.5)
self.mComposerMap.setGridAnnotationPrecision(0)
self.mComposerMap.setGridAnnotationPosition(QgsComposerMap.Disabled,
QgsComposerMap.Left)
self.mComposerMap.setGridAnnotationPosition(
QgsComposerMap.OutsideMapFrame,
QgsComposerMap.Right)
self.mComposerMap.setGridAnnotationPosition(QgsComposerMap.Disabled,
QgsComposerMap.Top)
self.mComposerMap.setGridAnnotationPosition(
QgsComposerMap.OutsideMapFrame,
QgsComposerMap.Bottom)
self.mComposerMap.setGridAnnotationDirection(QgsComposerMap.Horizontal,
QgsComposerMap.Right)
self.mComposerMap.setGridAnnotationDirection(QgsComposerMap.Horizontal,
QgsComposerMap.Bottom)
checker = QgsCompositionChecker()
myPath = os.path.join(TEST_DATA_DIR,
'control_images',
'expected_composermap',
'composermap_landsat_grid.png')
myTestResult, myMessage = checker.testComposition('Composer map grid',
self.mComposition, myPath)
self.mComposerMap.setGridEnabled(False)
self.mComposerMap.setShowGridAnnotation(False)
assert myTestResult == True, myMessage
def testOverviewMap(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375, 3341423.125,
789262.375, 3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125,
793062.375, 3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
checker = QgsCompositionChecker()
myPngPath = os.path.join(TEST_DATA_DIR,
'control_images',
'expected_composermap',
'composermap_landsat_overview.png')
myTestResult, myMessage = checker.testComposition(
'Composer map overview',
self.mComposition,
myPngPath)
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
def testOverviewMapBlend(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375, 3341423.125,
789262.375, 3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125,
793062.375, 3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
overviewMap.setOverviewBlendMode(QPainter.CompositionMode_Multiply)
checker = QgsCompositionChecker()
myPngPath = os.path.join(TEST_DATA_DIR,
'control_images',
'expected_composermap',
'composermap_landsat_overview_blend.png')
myTestResult, myMessage = checker.testComposition(
'Composer map overview blending',
self.mComposition,
myPngPath)
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
def testOverviewMapInvert(self):
overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
overviewMap.setFrameEnabled(True)
self.mComposition.addComposerMap(overviewMap)
# zoom in
myRectangle = QgsRectangle(785462.375, 3341423.125,
789262.375, 3343323.125)
self.mComposerMap.setNewExtent(myRectangle)
myRectangle2 = QgsRectangle(781662.375, 3339523.125,
793062.375, 3350923.125)
overviewMap.setNewExtent(myRectangle2)
overviewMap.setOverviewFrameMap(self.mComposerMap.id())
overviewMap.setOverviewInverted(True)
checker = QgsCompositionChecker()
myPngPath = os.path.join(TEST_DATA_DIR,
'control_images',
'expected_composermap',
'composermap_landsat_overview_invert.png')
myTestResult, myMessage = checker.testComposition(
'Composer map overview inverted',
self.mComposition,
myPngPath)
self.mComposition.removeComposerItem(overviewMap)
assert myTestResult == True, myMessage
# Fails because addItemsFromXML has been commented out in sip
@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 testZebraStyle(self):
self.mComposerMap.setGridFrameStyle(QgsComposerMap.Zebra)
myRectangle = QgsRectangle(785462.375, 3341423.125,
789262.375, 3343323.125)
self.mComposerMap.setNewExtent( myRectangle )
self.mComposerMap.setGridEnabled(True)
self.mComposerMap.setGridIntervalX(2000)
self.mComposerMap.setGridIntervalY(2000)
checker = QgsCompositionChecker()
myPngPath = os.path.join(TEST_DATA_DIR,
'control_images',
'expected_composermap',
'composermap_zebra_style.png')
testResult, myMessage = checker.testComposition('Composer map zebra',
self.mComposition,
myPngPath)
assert testResult == True, myMessage
class TestQgsAtlasComposition(unittest.TestCase):
def testCase(self):
self.TEST_DATA_DIR = unitTestDataPath()
tmppath = tempfile.mkdtemp()
for file in glob.glob(
os.path.join(self.TEST_DATA_DIR, 'france_parts.*')):
shutil.copy(os.path.join(self.TEST_DATA_DIR, file), tmppath)
vectorFileInfo = QFileInfo(tmppath + "/france_parts.shp")
mVectorLayer = QgsVectorLayer(vectorFileInfo.filePath(),
vectorFileInfo.completeBaseName(), "ogr")
QgsProject.instance().addMapLayers([mVectorLayer])
self.layers = [mVectorLayer]
# create composition with composer map
# select epsg:2154
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(2154)
QgsProject.instance().setCrs(crs)
self.mComposition = QgsComposition(QgsProject.instance())
self.mComposition.setPaperSize(297, 210)
# fix the renderer, fill with green
props = {"color": "0,127,0"}
fillSymbol = QgsFillSymbol.createSimple(props)
renderer = QgsSingleSymbolRenderer(fillSymbol)
mVectorLayer.setRenderer(renderer)
# the atlas map
self.mAtlasMap = QgsComposerMap(self.mComposition, 20, 20, 130, 130)
self.mAtlasMap.setFrameEnabled(True)
self.mAtlasMap.setLayers([mVectorLayer])
self.mComposition.addComposerMap(self.mAtlasMap)
# the atlas
self.mAtlas = self.mComposition.atlasComposition()
self.mAtlas.setCoverageLayer(mVectorLayer)
self.mAtlas.setEnabled(True)
self.mComposition.setAtlasMode(QgsComposition.ExportAtlas)
# an overview
self.mOverview = QgsComposerMap(self.mComposition, 180, 20, 50, 50)
self.mOverview.setFrameEnabled(True)
self.mOverview.overview().setFrameMap(self.mAtlasMap.id())
self.mOverview.setLayers([mVectorLayer])
self.mComposition.addComposerMap(self.mOverview)
nextent = QgsRectangle(49670.718, 6415139.086, 699672.519, 7065140.887)
self.mOverview.setNewExtent(nextent)
# set the fill symbol of the overview map
props2 = {"color": "127,0,0,127"}
fillSymbol2 = QgsFillSymbol.createSimple(props2)
self.mOverview.overview().setFrameSymbol(fillSymbol2)
# header label
self.mLabel1 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel1)
self.mLabel1.setText("[% \"NAME_1\" %] area")
self.mLabel1.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel1.adjustSizeToText()
self.mLabel1.setSceneRect(QRectF(150, 5, 60, 15))
qWarning(
"header label font: %s exactMatch:%s" %
(self.mLabel1.font().toString(), self.mLabel1.font().exactMatch()))
# feature number label
self.mLabel2 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel2)
self.mLabel2.setText(
"# [%@atlas_featurenumber || ' / ' || @atlas_totalfeatures%]")
self.mLabel2.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel2.adjustSizeToText()
self.mLabel2.setSceneRect(QRectF(150, 200, 60, 15))
qWarning(
"feature number label font: %s exactMatch:%s" %
(self.mLabel2.font().toString(), self.mLabel2.font().exactMatch()))
self.filename_test()
self.autoscale_render_test()
self.fixedscale_render_test()
self.predefinedscales_render_test()
self.hidden_render_test()
self.legend_test()
self.rotation_test()
shutil.rmtree(tmppath, True)
def filename_test(self):
self.mAtlas.setFilenamePattern("'output_' || @atlas_featurenumber")
self.mAtlas.beginRender()
for i in range(0, self.mAtlas.numFeatures()):
self.mAtlas.prepareForFeature(i)
expected = "output_%d" % (i + 1)
self.assertEqual(self.mAtlas.currentFilename(), expected)
self.mAtlas.endRender()
def autoscale_render_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_autoscale%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlasMap.setAtlasDriven(False)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlasMap.setAtlasMargin(0)
def fixedscale_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_fixedscale%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def predefinedscales_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Predefined)
scales = [1800000, 5000000]
self.mAtlas.setPredefinedScales(scales)
for i, s in enumerate(self.mAtlas.predefinedScales()):
assert s == scales[i]
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker(
'atlas_predefinedscales%d' % (i + 1), self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def hidden_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(True)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_hiding%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
self.mAtlas.setHideCoverage(False)
def sorting_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(False)
self.mAtlas.setSortFeatures(True)
self.mAtlas.setSortKeyAttributeIndex(4) # departement name
self.mAtlas.setSortAscending(False)
self.mAtlas.beginRender()
for i in range(0, 2):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_sorting%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def filtering_render_test(self):
self.mAtlasMap.setNewExtent(
QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)
self.mAtlas.setHideCoverage(False)
self.mAtlas.setSortFeatures(False)
self.mAtlas.setFilterFeatures(True)
self.mAtlas.setFeatureFilter(
"substr(NAME_1,1,1)='P'") # select only 'Pays de la loire'
self.mAtlas.beginRender()
for i in range(0, 1):
self.mAtlas.prepareForFeature(i)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_filtering%d' % (i + 1),
self.mComposition)
checker.setControlPathPrefix("atlas")
myTestResult, myMessage = checker.testComposition(0, 200)
assert myTestResult
self.mAtlas.endRender()
def legend_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
# add a point layer
ptLayer = QgsVectorLayer(
"Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)",
"points", "memory")
pr = ptLayer.dataProvider()
f1 = QgsFeature(1)
f1.initAttributes(2)
f1.setAttribute(0, 1)
f1.setAttribute(1, "Test label 1")
f1.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(-0.638, 48.954)))
f2 = QgsFeature(2)
f2.initAttributes(2)
f2.setAttribute(0, 2)
f2.setAttribute(1, "Test label 2")
f2.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(-1.682, 48.550)))
pr.addFeatures([f1, f2])
# categorized symbology
r = QgsCategorizedSymbolRenderer("attr", [
QgsRendererCategory(
1, QgsMarkerSymbol.createSimple({"color": "255,0,0"}), "red"),
QgsRendererCategory(
2, QgsMarkerSymbol.createSimple({"color": "0,0,255"}), "blue")
])
ptLayer.setRenderer(r)
QgsProject.instance().addMapLayer(ptLayer)
# add the point layer to the map settings
layers = self.layers
layers = [ptLayer] + layers
self.mAtlasMap.setLayers(layers)
self.mOverview.setLayers(layers)
# add a legend
legend = QgsComposerLegend(self.mComposition)
legend.moveBy(200, 100)
# sets the legend filter parameter
legend.setComposerMap(self.mAtlasMap)
legend.setLegendFilterOutAtlas(True)
self.mComposition.addComposerLegend(legend)
self.mAtlas.beginRender()
self.mAtlas.prepareForFeature(0)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_legend', self.mComposition)
myTestResult, myMessage = checker.testComposition()
assert myTestResult
self.mAtlas.endRender()
# restore state
self.mAtlasMap.setLayers([layers[1]])
self.mComposition.removeComposerItem(legend)
QgsProject.instance().removeMapLayer(ptLayer.id())
def rotation_test(self):
# We will create a polygon layer with a rotated rectangle.
# Then we will make it the object layer for the atlas,
# rotate the map and test that the bounding rectangle
# is smaller than the bounds without rotation.
polygonLayer = QgsVectorLayer('Polygon', 'test_polygon', 'memory')
poly = QgsFeature(polygonLayer.pendingFields())
points = [(10, 15), (15, 10), (45, 40), (40, 45)]
poly.setGeometry(
QgsGeometry.fromPolygonXY(
[[QgsPointXY(x[0], x[1]) for x in points]]))
polygonLayer.dataProvider().addFeatures([poly])
QgsProject.instance().addMapLayer(polygonLayer)
# Recreating the composer locally
composition = QgsComposition(QgsProject.instance())
composition.setPaperSize(297, 210)
# the atlas map
atlasMap = QgsComposerMap(composition, 20, 20, 130, 130)
atlasMap.setFrameEnabled(True)
atlasMap.setLayers([polygonLayer])
atlasMap.setNewExtent(QgsRectangle(0, 0, 100, 50))
composition.addComposerMap(atlasMap)
# the atlas
atlas = composition.atlasComposition()
atlas.setCoverageLayer(polygonLayer)
atlas.setEnabled(True)
composition.setAtlasMode(QgsComposition.ExportAtlas)
atlasMap.setAtlasDriven(True)
atlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
atlasMap.setAtlasMargin(0.0)
# Testing
atlasMap.setMapRotation(0.0)
atlas.firstFeature()
nonRotatedExtent = QgsRectangle(atlasMap.currentMapExtent())
atlasMap.setMapRotation(45.0)
atlas.firstFeature()
rotatedExtent = QgsRectangle(atlasMap.currentMapExtent())
assert rotatedExtent.width() < nonRotatedExtent.width() * 0.9
assert rotatedExtent.height() < nonRotatedExtent.height() * 0.9
QgsProject.instance().removeMapLayer(polygonLayer)
