def testPalettedColorTableToClassData(self):
entries = [QgsColorRampShader.ColorRampItem(5, QColor(255, 0, 0), 'item1'),
QgsColorRampShader.ColorRampItem(3, QColor(0, 255, 0), 'item2'),
QgsColorRampShader.ColorRampItem(6, QColor(0, 0, 255), 'item3'),
]
classes = QgsPalettedRasterRenderer.colorTableToClassData(entries)
self.assertEqual(classes[0].value, 5)
self.assertEqual(classes[1].value, 3)
self.assertEqual(classes[2].value, 6)
self.assertEqual(classes[0].label, 'item1')
self.assertEqual(classes[1].label, 'item2')
self.assertEqual(classes[2].label, 'item3')
self.assertEqual(classes[0].color.name(), '#ff0000')
self.assertEqual(classes[1].color.name(), '#00ff00')
self.assertEqual(classes[2].color.name(), '#0000ff')
# test #13263
path = os.path.join(unitTestDataPath('raster'),
'hub13263.vrt')
info = QFileInfo(path)
base_name = info.baseName()
layer = QgsRasterLayer(path, base_name)
self.assertTrue(layer.isValid(), 'Raster not loaded: {}'.format(path))
classes = QgsPalettedRasterRenderer.colorTableToClassData(layer.dataProvider().colorTable(1))
self.assertEqual(len(classes), 4)
classes = QgsPalettedRasterRenderer.colorTableToClassData(layer.dataProvider().colorTable(15))
self.assertEqual(len(classes), 256)
def testImportIntoGpkg(self):
# init target file
test_gpkg = tempfile.mktemp(suffix='.gpkg', dir=self.testDataDir)
gdal.GetDriverByName('GPKG').Create(test_gpkg, 1, 1, 1)
source = QgsRasterLayer(os.path.join(self.testDataDir, 'raster', 'band3_byte_noct_epsg4326.tif'), 'my', 'gdal')
self.assertTrue(source.isValid())
provider = source.dataProvider()
fw = QgsRasterFileWriter(test_gpkg)
fw.setOutputFormat('gpkg')
fw.setCreateOptions(['RASTER_TABLE=imported_table', 'APPEND_SUBDATASET=YES'])
pipe = QgsRasterPipe()
self.assertTrue(pipe.set(provider.clone()))
projector = QgsRasterProjector()
projector.setCrs(provider.crs(), provider.crs())
self.assertTrue(pipe.insert(2, projector))
self.assertEqual(fw.writeRaster(pipe,
provider.xSize(),
provider.ySize(),
provider.extent(),
provider.crs()), 0)
# Check that the test geopackage contains the raster layer and compare
rlayer = QgsRasterLayer('GPKG:%s:imported_table' % test_gpkg)
self.assertTrue(rlayer.isValid())
out_provider = rlayer.dataProvider()
self.assertEqual(provider.block(1, provider.extent(), source.width(), source.height()).data(),
out_provider.block(1, out_provider.extent(), rlayer.width(), rlayer.height()).data())
# remove result file
os.unlink(test_gpkg)
def testShaderCrash(self):
"""Check if we assign a shader and then reassign it no crash occurs."""
myPath = os.path.join(unitTestDataPath('raster'),
'band1_float32_noct_epsg4326.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
myRasterLayer = QgsRasterLayer(myPath, myBaseName)
myMessage = 'Raster not loaded: %s' % myPath
assert myRasterLayer.isValid(), myMessage
myRasterShader = QgsRasterShader()
myColorRampShader = QgsColorRampShader()
myColorRampShader.setColorRampType(QgsColorRampShader.INTERPOLATED)
myItems = []
myItem = QgsColorRampShader.ColorRampItem(10,
QtGui.QColor('#ffff00'), 'foo')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(100,
QtGui.QColor('#ff00ff'), 'bar')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(1000,
QtGui.QColor('#00ff00'), 'kazam')
myItems.append(myItem)
myColorRampShader.setColorRampItemList(myItems)
myRasterShader.setRasterShaderFunction(myColorRampShader)
myPseudoRenderer = QgsSingleBandPseudoColorRenderer(
myRasterLayer.dataProvider(), 1, myRasterShader)
myRasterLayer.setRenderer(myPseudoRenderer)
return
######## works first time #############
myRasterShader = QgsRasterShader()
myColorRampShader = QgsColorRampShader()
myColorRampShader.setColorRampType(QgsColorRampShader.INTERPOLATED)
myItems = []
myItem = QgsColorRampShader.ColorRampItem(10,
QtGui.QColor('#ffff00'), 'foo')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(100,
QtGui.QColor('#ff00ff'), 'bar')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(1000,
QtGui.QColor('#00ff00'), 'kazam')
myItems.append(myItem)
myColorRampShader.setColorRampItemList(myItems)
myRasterShader.setRasterShaderFunction(myColorRampShader)
######## crash on next line (fixed now)##################
myPseudoRenderer = QgsSingleBandPseudoColorRenderer(
myRasterLayer.dataProvider(), 1, myRasterShader)
myRasterLayer.setRenderer(myPseudoRenderer)
def testSetDataSource(self):
"""Test change data source"""
temp_dir = QTemporaryDir()
options = QgsDataProvider.ProviderOptions()
myPath = os.path.join(unitTestDataPath('raster'),
'band1_float32_noct_epsg4326.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
layer = QgsRasterLayer(myPath, myBaseName)
renderer = QgsSingleBandGrayRenderer(layer.dataProvider(), 2)
image = layer.previewAsImage(QSize(400, 400))
self.assertFalse(image.isNull())
self.assertTrue(image.save(os.path.join(temp_dir.path(), 'expected.png'), "PNG"))
layer.setDataSource(myPath.replace('4326.tif', '4326-BAD_SOURCE.tif'), 'bad_layer', 'gdal', options)
self.assertFalse(layer.isValid())
image = layer.previewAsImage(QSize(400, 400))
self.assertTrue(image.isNull())
layer.setDataSource(myPath.replace('4326-BAD_SOURCE.tif', '4326.tif'), 'bad_layer', 'gdal', options)
self.assertTrue(layer.isValid())
image = layer.previewAsImage(QSize(400, 400))
self.assertFalse(image.isNull())
self.assertTrue(image.save(os.path.join(temp_dir.path(), 'actual.png'), "PNG"))
self.assertTrue(filecmp.cmp(os.path.join(temp_dir.path(), 'actual.png'), os.path.join(temp_dir.path(), 'expected.png')), False)
def testLayerRemovalBeforeRun(self):
"""test behavior when layer is removed before task begins"""
path = os.path.join(unitTestDataPath(), 'raster', 'with_color_table.tif')
raster_layer = QgsRasterLayer(path, "test")
self.assertTrue(raster_layer.isValid())
pipe = QgsRasterPipe()
self.assertTrue(pipe.set(raster_layer.dataProvider().clone()))
tmp = create_temp_filename('remove_layer.tif')
writer = QgsRasterFileWriter(tmp)
task = QgsRasterFileWriterTask(writer, pipe, 100, 100, raster_layer.extent(), raster_layer.crs())
task.writeComplete.connect(self.onSuccess)
task.errorOccurred.connect(self.onFail)
# remove layer
raster_layer = None
QgsApplication.taskManager().addTask(task)
while not self.success and not self.fail:
QCoreApplication.processEvents()
# in this case will still get a positive result - since the pipe is cloned before the task
# begins the task is no longer dependent on the original layer
self.assertTrue(self.success)
self.assertFalse(self.fail)
self.assertTrue(os.path.exists(tmp))
def testIdentify(self):
myPath = os.path.join(unitTestDataPath(), 'landsat.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
myRasterLayer = QgsRasterLayer(myPath, myBaseName)
myMessage = 'Raster not loaded: %s' % myPath
assert myRasterLayer.isValid(), myMessage
myPoint = QgsPoint(786690, 3345803)
#print 'Extents: %s' % myRasterLayer.extent().toString()
#myResult, myRasterValues = myRasterLayer.identify(myPoint)
#assert myResult
myRasterValues = myRasterLayer.dataProvider().identify(myPoint, QgsRasterDataProvider.IdentifyFormatValue )
assert len( myRasterValues ) > 0
# Get the name of the first band
myBand = myRasterValues.keys()[0]
#myExpectedName = QString('Band 1')
myExpectedBand = 1
myMessage = 'Expected "%s" got "%s" for first raster band name' % (
myExpectedBand, myBand)
assert myExpectedBand == myBand, myMessage
# Convert each band value to a list of ints then to a string
myValues = myRasterValues.values()
myIntValues = []
for myValue in myValues:
#myIntValues.append(int(str(myValue)))
myIntValues.append( myValue.toInt()[0] )
myValues = str(myIntValues)
myExpectedValues = '[127, 141, 112, 72, 86, 126, 156, 211, 170]'
myMessage = 'Expected: %s\nGot: %s' % (myValues, myExpectedValues)
self.assertEquals(myValues, myExpectedValues, myMessage)
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 loadLabelImage(imagepath, labeldescriptor = None):
"""
Load a labeled single band raster in the canvas
Keyword arguments:
imagepath -- the path to the image
labeldescriptor -- a dictionnary for label (int) to tuple (QColor, QString) conversion
"""
if imagepath is None:
return
name = os.path.splitext( os.path.basename(imagepath) )[0]
qgslayer = QgsRasterLayer(imagepath, name)
if not qgslayer.isValid():
QtGui.QMessageBox.critical(None,
u"Erreur",
u"Impossible de charger la couche %s" % unicode(imagepath))
QgsMapLayerRegistry.instance().addMapLayer(qgslayer)
qgslayer.setDrawingStyle('SingleBandPseudoColor')
colorlist = []
max_label = 0
for label in sorted(labeldescriptor.keys()):
color = labeldescriptor[label][0]
labeltxt = labeldescriptor[label][1]
colorlist.append(QgsColorRampShader.ColorRampItem(label, color, labeltxt))
if labeltxt > max_label:
max_label = labeltxt
s = QgsRasterShader()
c = QgsColorRampShader()
c.setColorRampType(QgsColorRampShader.INTERPOLATED)
c.setColorRampItemList(colorlist)
s.setRasterShaderFunction(c)
ps = QgsSingleBandPseudoColorRenderer(qgslayer.dataProvider(), 1, s)
qgslayer.setRenderer(ps)
for bandNo in range(1,qgslayer.dataProvider().bandCount()+1):
qgslayer.dataProvider().setUseSrcNoDataValue( bandNo, False )
QGisLayers.iface.legendInterface().refreshLayerSymbology(qgslayer)
if hasattr(qgslayer, "setCacheImage"):
qgslayer.setCacheImage(None)
qgslayer.triggerRepaint()
def testPrintMapFromTemplate(self):
"""Test that we can get a map to render in the template."""
myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif')
myFileInfo = QFileInfo(myPath)
myRasterLayer = QgsRasterLayer(myFileInfo.filePath(),
myFileInfo.completeBaseName())
myRenderer = QgsMultiBandColorRenderer(
myRasterLayer.dataProvider(), 2, 3, 4
)
#mRasterLayer.setRenderer( rasterRenderer )
myPipe = myRasterLayer.pipe()
assert myPipe.set(myRenderer), "Cannot set pipe renderer"
QgsMapLayerRegistry.instance().addMapLayers([myRasterLayer])
myMapRenderer = QgsMapRenderer()
myLayerStringList = []
myLayerStringList.append(myRasterLayer.id())
myMapRenderer.setLayerSet(myLayerStringList)
myMapRenderer.setProjectionsEnabled(False)
myComposition = QgsComposition(myMapRenderer)
myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt')
myTemplateFile = file(myFile, 'rt')
myTemplateContent = myTemplateFile.read()
myTemplateFile.close()
myDocument = QDomDocument()
myDocument.setContent(myTemplateContent)
myComposition.loadFromTemplate(myDocument)
# now render the map, first zooming to the raster extents
myMap = myComposition.getComposerMapById(0)
myMessage = ('Map 0 could not be found in template %s', myFile)
assert myMap is not None, myMessage
myExtent = myRasterLayer.extent()
myMap.setNewExtent(myExtent)
myImagePath = os.path.join(str(QDir.tempPath()),
'template_map_render_python.png')
myPageNumber = 0
myImage = myComposition.printPageAsRaster(myPageNumber)
myImage.save(myImagePath)
assert os.path.exists(myImagePath), 'Map render was not created.'
# Not sure if this is a predictable way to test but its quicker than
# rendering.
myFileSize = QFileInfo(myImagePath).size()
myExpectedFileSize = 100000
myMessage = ('Expected file size to be greater than %s, got %s'
' for %s' %
(myExpectedFileSize, myFileSize, myImagePath))
assert myFileSize > myExpectedFileSize, myMessage
def test_qgis_raster_layer_loading(self):
"""Test that reading from QgsRasterLayer works."""
# This line is the cause of the problem:
qgis_layer = QgsRasterLayer(RASTER_BASE + '.tif', 'test')
layer = Raster(data=qgis_layer)
qgis_extent = qgis_layer.dataProvider().extent()
qgis_extent = [qgis_extent.xMinimum(), qgis_extent.yMinimum(),
qgis_extent.xMaximum(), qgis_extent.yMaximum()]
layer_exent = layer.get_bounding_box()
self.assertListEqual(
layer_exent, qgis_extent,
'Expected %s extent, got %s' % (qgis_extent, layer_exent))
def testPalettedBand(self):
""" test paletted raster render band"""
path = os.path.join(unitTestDataPath(),
'landsat_4326.tif')
info = QFileInfo(path)
base_name = info.baseName()
layer = QgsRasterLayer(path, base_name)
self.assertTrue(layer.isValid(), 'Raster not loaded: {}'.format(path))
renderer = QgsPalettedRasterRenderer(layer.dataProvider(), 2,
[QgsPalettedRasterRenderer.Class(137, QColor(0, 255, 0), 'class 2'),
QgsPalettedRasterRenderer.Class(138, QColor(255, 0, 0), 'class 1'),
QgsPalettedRasterRenderer.Class(139, QColor(0, 0, 255), 'class 1')])
layer.setRenderer(renderer)
ms = QgsMapSettings()
ms.setLayers([layer])
ms.setExtent(layer.extent())
checker = QgsRenderChecker()
checker.setControlName("expected_paletted_renderer_band2")
checker.setMapSettings(ms)
self.assertTrue(checker.runTest("expected_paletted_renderer_band2"), "Paletted rendering test failed")
renderer = QgsPalettedRasterRenderer(layer.dataProvider(), 3,
[QgsPalettedRasterRenderer.Class(120, QColor(0, 255, 0), 'class 2'),
QgsPalettedRasterRenderer.Class(123, QColor(255, 0, 0), 'class 1'),
QgsPalettedRasterRenderer.Class(124, QColor(0, 0, 255), 'class 1')])
layer.setRenderer(renderer)
ms = QgsMapSettings()
ms.setLayers([layer])
ms.setExtent(layer.extent())
checker = QgsRenderChecker()
checker.setControlName("expected_paletted_renderer_band3")
checker.setMapSettings(ms)
self.assertTrue(checker.runTest("expected_paletted_renderer_band3"), "Paletted rendering test failed")
def getRasterSublayer(path, param):
layer = QgsRasterLayer(path)
try:
# If the layer is a raster layer and has multiple sublayers, let the user chose one.
# Based on QgisApp::askUserForGDALSublayers
if layer and param.showSublayersDialog and layer.dataProvider().name() == "gdal" and len(layer.subLayers()) > 1:
layers = []
subLayerNum = 0
# simplify raster sublayer name
for subLayer in layer.subLayers():
# if netcdf/hdf use all text after filename
if bool(re.match('netcdf', subLayer, re.I)) or bool(re.match('hdf', subLayer, re.I)):
subLayer = subLayer.split(path)[1]
subLayer = subLayer[1:]
else:
# remove driver name and file name
subLayer.replace(subLayer.split(QgsDataProvider.SUBLAYER_SEPARATOR)[0], "")
subLayer.replace(path, "")
# remove any : or " left over
if subLayer.startswith(":"):
subLayer = subLayer[1:]
if subLayer.startswith("\""):
subLayer = subLayer[1:]
if subLayer.endswith(":"):
subLayer = subLayer[:-1]
if subLayer.endswith("\""):
subLayer = subLayer[:-1]
ld = QgsSublayersDialog.LayerDefinition()
ld.layerId = subLayerNum
ld.layerName = subLayer
layers.append(ld)
subLayerNum = subLayerNum + 1
# Use QgsSublayersDialog
# Would be good if QgsSublayersDialog had an option to allow only one sublayer to be selected
chooseSublayersDialog = QgsSublayersDialog(QgsSublayersDialog.Gdal, "gdal")
chooseSublayersDialog.populateLayerTable(layers)
if chooseSublayersDialog.exec_():
return layer.subLayers()[chooseSublayersDialog.selectionIndexes()[0]]
else:
# If user pressed cancel then just return the input path
return path
else:
# If the sublayers selection dialog is not to be shown then just return the input path
return path
except:
# If the layer is not a raster layer, then just return the input path
return path
def test_setRenderer(self):
myPath = os.path.join(unitTestDataPath("raster"), "band1_float32_noct_epsg4326.tif")
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
layer = QgsRasterLayer(myPath, myBaseName)
self.rendererChanged = False
layer.rendererChanged.connect(self.onRendererChanged)
rShader = QgsRasterShader()
r = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1, rShader)
layer.setRenderer(r)
assert self.rendererChanged
assert layer.renderer() == r
def testPalettedRendererWithNegativeColorValue(self):
""" test paletted raster renderer with negative values in color table"""
path = os.path.join(unitTestDataPath('raster'),
'hub13263.vrt')
info = QFileInfo(path)
base_name = info.baseName()
layer = QgsRasterLayer(path, base_name)
self.assertTrue(layer.isValid(), 'Raster not loaded: {}'.format(path))
renderer = QgsPalettedRasterRenderer(layer.dataProvider(), 1,
[QgsPalettedRasterRenderer.Class(-1, QColor(0, 255, 0), 'class 2'),
QgsPalettedRasterRenderer.Class(3, QColor(255, 0, 0), 'class 1')])
self.assertEqual(renderer.nColors(), 2)
self.assertEqual(renderer.usesBands(), [1])
def write(self, theRasterName):
print theRasterName
path = "%s/%s" % (self.testDataDir, theRasterName)
# myFileInfo = QFileInfo( path )
# myBaseName = myFileInfo.baseName()
rasterLayer = QgsRasterLayer(path, "test")
if not rasterLayer.isValid():
return False
provider = rasterLayer.dataProvider()
tmpFile = QTemporaryFile()
tmpFile.open() # fileName is no avialable until open
tmpName = tmpFile.fileName()
tmpFile.close()
# do not remove when class is destroyd so that we can read the file and see difference
tmpFile.setAutoRemove(False)
fileWriter = QgsRasterFileWriter(tmpName)
pipe = QgsRasterPipe()
if not pipe.set(provider.clone()):
print "Cannot set pipe provider"
return False
# nuller = QgsRasterNuller()
# nuller.setNoData( ... )
# if not pipe.insert( 1, nuller ):
# print "Cannot set pipe nuller"
# return False
projector = QgsRasterProjector()
projector.setCRS(provider.crs(), provider.crs())
if not pipe.insert(2, projector):
print "Cannot set pipe projector"
return False
fileWriter.writeRaster(pipe, provider.xSize(), provider.ySize(), provider.extent(), provider.crs())
checker = QgsRasterChecker()
ok = checker.runTest("gdal", tmpName, "gdal", path)
self.report += checker.report()
# All OK, we can delete the file
tmpFile.setAutoRemove(ok)
return ok
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 _testGeneratePyramids(self, pyramidFormat):
tmpName = tempfile.mktemp(suffix='.tif')
source = QgsRasterLayer(os.path.join(self.testDataDir, 'raster', 'byte.tif'), 'my', 'gdal')
self.assertTrue(source.isValid())
provider = source.dataProvider()
fw = QgsRasterFileWriter(tmpName)
fw.setBuildPyramidsFlag(QgsRaster.PyramidsFlagYes)
fw.setPyramidsFormat(pyramidFormat)
fw.setPyramidsList([2])
pipe = QgsRasterPipe()
self.assertTrue(pipe.set(provider.clone()))
projector = QgsRasterProjector()
projector.setCrs(provider.crs(), provider.crs())
self.assertTrue(pipe.insert(2, projector))
self.assertEqual(fw.writeRaster(pipe,
provider.xSize(),
provider.ySize(),
provider.extent(),
provider.crs()), 0)
del fw
ds = gdal.Open(tmpName)
self.assertEqual(ds.GetRasterBand(1).GetOverviewCount(), 1)
fl = ds.GetFileList()
if pyramidFormat == QgsRaster.PyramidsGTiff:
self.assertEqual(len(fl), 2, fl)
self.assertIn('.ovr', fl[1])
elif pyramidFormat == QgsRaster.PyramidsInternal:
self.assertEqual(len(fl), 1, fl)
elif pyramidFormat == QgsRaster.PyramidsErdas:
self.assertEqual(len(fl), 2, fl)
self.assertIn('.aux', fl[1])
os.unlink(tmpName)
def testSuccess(self):
"""test successfully writing a layer"""
path = os.path.join(unitTestDataPath(), 'raster', 'with_color_table.tif')
raster_layer = QgsRasterLayer(path, "test")
self.assertTrue(raster_layer.isValid())
pipe = QgsRasterPipe()
self.assertTrue(pipe.set(raster_layer.dataProvider().clone()))
tmp = create_temp_filename('success.tif')
writer = QgsRasterFileWriter(tmp)
task = QgsRasterFileWriterTask(writer, pipe, 100, 100, raster_layer.extent(), raster_layer.crs())
task.writeComplete.connect(self.onSuccess)
task.errorOccurred.connect(self.onFail)
QgsApplication.taskManager().addTask(task)
while not self.success and not self.fail:
QCoreApplication.processEvents()
self.assertTrue(self.success)
self.assertFalse(self.fail)
self.assertTrue(os.path.exists(tmp))
class TestQgsLayoutMap(unittest.TestCase, LayoutItemTestCase):
@classmethod
def setUpClass(cls):
cls.item_class = QgsLayoutItemMap
def setUp(self):
self.report = "<h1>Python QgsLayoutItemMap Tests</h1>\n"
def tearDown(self):
report_file_path = "%s/qgistest.html" % QDir.tempPath()
with open(report_file_path, 'a') as report_file:
report_file.write(self.report)
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 layout with layout map
self.layout = QgsLayout(QgsProject.instance())
self.layout.initializeDefaults()
self.map = QgsLayoutItemMap(self.layout)
self.map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
self.map.setFrameEnabled(True)
self.map.setLayers([self.raster_layer])
self.layout.addLayoutItem(self.map)
def testMapCrs(self):
# create layout with layout map
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
layout.initializeDefaults()
# check that new maps inherit project CRS
QgsProject.instance().setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
map.setFrameEnabled(True)
rectangle = QgsRectangle(-13838977, 2369660, -8672298, 6250909)
map.setExtent(rectangle)
map.setLayers([self.vector_layer])
layout.addLayoutItem(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 = QgsLayoutChecker('composermap_crs3857', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
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 = QgsLayoutChecker('composermap_crs4326', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
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 testContainsAdvancedEffects(self):
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
map = QgsLayoutItemMap(layout)
self.assertFalse(map.containsAdvancedEffects())
self.vector_layer.setBlendMode(QPainter.CompositionMode_Darken)
result = map.containsAdvancedEffects()
self.vector_layer.setBlendMode(QPainter.CompositionMode_SourceOver)
self.assertTrue(result)
def testRasterization(self):
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
map = QgsLayoutItemMap(layout)
self.assertFalse(map.requiresRasterization())
self.vector_layer.setBlendMode(QPainter.CompositionMode_Darken)
self.assertFalse(map.requiresRasterization())
self.assertTrue(map.containsAdvancedEffects())
map.setBackgroundEnabled(False)
self.assertTrue(map.requiresRasterization())
map.setBackgroundEnabled(True)
map.setBackgroundColor(QColor(1, 1, 1, 1))
self.assertTrue(map.requiresRasterization())
self.vector_layer.setBlendMode(QPainter.CompositionMode_SourceOver)
def testLabelMargin(self):
"""
Test rendering map item with a label margin set
"""
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(20)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'X'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl",
"memory")
vl.setRenderer(QgsNullSymbolRenderer())
f = QgsFeature(vl.fields(), 1)
for x in range(15):
for y in range(15):
f.setGeometry(QgsPoint(x, y))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
p = QgsProject()
engine_settings = QgsLabelingEngineSettings()
engine_settings.setFlag(QgsLabelingEngineSettings.UsePartialCandidates,
False)
engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly,
True)
p.setLabelingEngineSettings(engine_settings)
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(True)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
layout.addLayoutItem(map)
checker = QgsLayoutChecker('composermap_label_nomargin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
map.setLabelMargin(
QgsLayoutMeasurement(15, QgsUnitTypes.LayoutMillimeters))
checker = QgsLayoutChecker('composermap_label_margin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
map.setLabelMargin(
QgsLayoutMeasurement(3, QgsUnitTypes.LayoutCentimeters))
checker = QgsLayoutChecker('composermap_label_cm_margin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
map.setMapRotation(45)
map.zoomToExtent(vl.extent())
map.setScale(map.scale() * 1.2)
checker = QgsLayoutChecker('composermap_rotated_label_margin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
# data defined
map.setMapRotation(0)
map.zoomToExtent(vl.extent())
map.dataDefinedProperties().setProperty(
QgsLayoutObject.MapLabelMargin, QgsProperty.fromExpression('1+3'))
map.refresh()
checker = QgsLayoutChecker('composermap_dd_label_margin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
def testPartialLabels(self):
"""
Test rendering map item with a show partial labels flag
"""
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(20)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'X'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl",
"memory")
vl.setRenderer(QgsNullSymbolRenderer())
f = QgsFeature(vl.fields(), 1)
for x in range(15):
for y in range(15):
f.setGeometry(QgsPoint(x, y))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
p = QgsProject()
engine_settings = QgsLabelingEngineSettings()
engine_settings.setFlag(QgsLabelingEngineSettings.UsePartialCandidates,
False)
engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly,
True)
p.setLabelingEngineSettings(engine_settings)
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(True)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
layout.addLayoutItem(map)
# default should always be to hide partial labels
self.assertFalse(map.mapFlags() & QgsLayoutItemMap.ShowPartialLabels)
# hiding partial labels (the default)
map.setMapFlags(QgsLayoutItemMap.MapItemFlags())
checker = QgsLayoutChecker('composermap_label_nomargin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
# showing partial labels
map.setMapFlags(QgsLayoutItemMap.ShowPartialLabels)
checker = QgsLayoutChecker('composermap_show_partial_labels', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
def testBlockingItems(self):
"""
Test rendering map item with blocking items
"""
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(20)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'X'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl",
"memory")
vl.setRenderer(QgsNullSymbolRenderer())
f = QgsFeature(vl.fields(), 1)
for x in range(15):
for y in range(15):
f.setGeometry(QgsPoint(x, y))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
p = QgsProject()
engine_settings = QgsLabelingEngineSettings()
engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly,
True)
p.setLabelingEngineSettings(engine_settings)
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(True)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
map.setId('map')
layout.addLayoutItem(map)
map2 = QgsLayoutItemMap(layout)
map2.attemptSetSceneRect(QRectF(0, 5, 50, 80))
map2.setFrameEnabled(True)
map2.setBackgroundEnabled(False)
map2.setId('map2')
layout.addLayoutItem(map2)
map3 = QgsLayoutItemMap(layout)
map3.attemptSetSceneRect(QRectF(150, 160, 50, 50))
map3.setFrameEnabled(True)
map3.setBackgroundEnabled(False)
map3.setId('map3')
layout.addLayoutItem(map3)
map.addLabelBlockingItem(map2)
map.addLabelBlockingItem(map3)
map.setMapFlags(QgsLayoutItemMap.MapItemFlags())
checker = QgsLayoutChecker('composermap_label_blockers', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
doc = QDomDocument("testdoc")
elem = layout.writeXml(doc, QgsReadWriteContext())
l2 = QgsLayout(p)
self.assertTrue(l2.readXml(elem, doc, QgsReadWriteContext()))
map_restore = [
i for i in l2.items()
if isinstance(i, QgsLayoutItemMap) and i.id() == 'map'
][0]
map2_restore = [
i for i in l2.items()
if isinstance(i, QgsLayoutItemMap) and i.id() == 'map2'
][0]
map3_restore = [
i for i in l2.items()
if isinstance(i, QgsLayoutItemMap) and i.id() == 'map3'
][0]
self.assertTrue(map_restore.isLabelBlockingItem(map2_restore))
self.assertTrue(map_restore.isLabelBlockingItem(map3_restore))
def run(self):
try:
processing.run(
"gdal:slope", {
'INPUT': self.dem,
'BAND': 1,
'SCALE': 1,
'AS_PERCENT': True,
'COMPUTE_EDGES': False,
'ZEVENBERGEN': False,
'OPTIONS': '',
'OUTPUT': os.path.join(self.doss, 'rRawSlope.tif')
})
rRawSlope = QgsRasterLayer(
os.path.join(self.doss, 'rRawSlope.tif'), 'rRawSlope')
# creation du raster Exokarst si besoin
if self.field_karst_features is None:
rKarstFeatures = None
else:
processing.run(
"gdal:rasterize", {
'INPUT': self.layer_karst_features,
'FIELD': self.field_karst_features,
'HEIGHT': self.raster_info['resolution_y'],
'WIDTH': self.raster_info['resolution_x'],
'UNITS': 1,
'EXTENT': self.raster_info['extent']['str_extent'],
'OUTPUT': os.path.join(self.doss, 'rKarstFeatures.tif')
})
rKarstFeatures = QgsRasterLayer(
os.path.join(self.doss, 'rKarstFeatures.tif'),
'rKarstFeatures')
processing.run(
"native:reclassifybytable", {
'INPUT_RASTER': rRawSlope,
'RASTER_BAND': 1,
'TABLE': self.reclass_rules_pente,
'NO_DATA': -9999,
'RANGE_BOUNDARIES': 0,
'NODATA_FOR_MISSING': False,
'DATA_TYPE': 5,
'OUTPUT': os.path.join(self.doss, 'rSlope.tif')
})
rSlope = QgsRasterLayer(os.path.join(self.doss, 'rSlope.tif'),
'rSlope')
# preparation des variables pour le croisement
val_i = range(0, self.raster_info['size_x'], 1)
val_j = range(0, self.raster_info['size_y'], 1)
pSlope = rSlope.dataProvider()
if rKarstFeatures is None:
pKarstFeatures = None
else:
rKarstFeatures = QgsRasterLayer(
os.path.join(self.doss, 'rKarstFeatures.tif'),
'rKarstFeatures')
pKarstFeatures = rKarstFeatures.dataProvider()
ValCarteI = numpy.zeros(
(self.raster_info['size_y'], self.raster_info['size_x']),
numpy.int16)
# iteration sur les pixels: selection de la valeur la plus faible et ecriture dans l'array
for j in val_j:
self.progress.emit(j, len(val_j))
for i in val_i:
pos = QgsPointXY(
(self.raster_info['extent']['Xmin'] +
(i + 1) * self.raster_info['resolution_x']) -
self.raster_info['resolution_x'] / 2,
(self.raster_info['extent']['Ymax'] -
j * self.raster_info['resolution_y']) -
self.raster_info['resolution_y'] / 2)
valSlope, found = pSlope.sample(pos, 1)
if not found:
valSlope = 6
if pKarstFeatures is None:
valKarstFeatures = 0
else:
valKarstFeatures, found = pKarstFeatures.sample(pos, 1)
if not found:
valSlope = 6
ValCarteI[j, i] = max([
valSlope, valKarstFeatures
]) if (valSlope, valKarstFeatures) != (None, None) else 0
# ecriture du raster a partir de l'array
raster = gdal.GetDriverByName('Gtiff').Create(
str(self.doss) + '/I_factor.tif', self.raster_info['size_x'],
self.raster_info['size_y'], 1, gdal.GDT_Byte)
raster.SetProjection(self.raster_info['projection_wkt'])
raster.SetGeoTransform((
self.raster_info['extent']['Xmin'],
float(self.raster_info['resolution_x']),
0.0,
self.raster_info['extent']['Ymax'],
0.0,
float(-self.raster_info['resolution_y']),
))
Band = raster.GetRasterBand(1)
Band.WriteArray(ValCarteI, 0, 0)
Band.FlushCache()
Band.SetNoDataValue(6)
# fermeture des connexions
rKarstFeatures = None
rSlope = None
Raster = None
self.results.emit()
except Exception as e:
self.error.emit(
Exception('An error happen when generating the I Factor: %s' %
str(e)))
finally:
self.finished.emit()
class TestQgsLayoutMap(unittest.TestCase, LayoutItemTestCase):
@classmethod
def setUpClass(cls):
cls.item_class = QgsLayoutItemMap
def setUp(self):
self.report = "<h1>Python QgsLayoutItemMap Tests</h1>\n"
def tearDown(self):
report_file_path = "%s/qgistest.html" % QDir.tempPath()
with open(report_file_path, 'a') as report_file:
report_file.write(self.report)
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 layout with layout map
self.layout = QgsLayout(QgsProject.instance())
self.layout.initializeDefaults()
self.map = QgsLayoutItemMap(self.layout)
self.map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
self.map.setFrameEnabled(True)
self.map.setLayers([self.raster_layer])
self.layout.addLayoutItem(self.map)
def testMapCrs(self):
# create layout with layout map
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
layout.initializeDefaults()
# check that new maps inherit project CRS
QgsProject.instance().setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
map.setFrameEnabled(True)
rectangle = QgsRectangle(-13838977, 2369660, -8672298, 6250909)
map.setExtent(rectangle)
map.setLayers([self.vector_layer])
layout.addLayoutItem(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 = QgsLayoutChecker('composermap_crs3857', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
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 = QgsLayoutChecker('composermap_crs4326', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
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 testContainsAdvancedEffects(self):
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
map = QgsLayoutItemMap(layout)
self.assertFalse(map.containsAdvancedEffects())
self.vector_layer.setBlendMode(QPainter.CompositionMode_Darken)
result = map.containsAdvancedEffects()
self.vector_layer.setBlendMode(QPainter.CompositionMode_SourceOver)
self.assertTrue(result)
def testRasterization(self):
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
map = QgsLayoutItemMap(layout)
self.assertFalse(map.requiresRasterization())
self.vector_layer.setBlendMode(QPainter.CompositionMode_Darken)
self.assertFalse(map.requiresRasterization())
self.assertTrue(map.containsAdvancedEffects())
map.setBackgroundEnabled(False)
self.assertTrue(map.requiresRasterization())
map.setBackgroundEnabled(True)
map.setBackgroundColor(QColor(1, 1, 1, 1))
self.assertTrue(map.requiresRasterization())
self.vector_layer.setBlendMode(QPainter.CompositionMode_SourceOver)
def testLabelMargin(self):
"""
Test rendering map item with a label margin set
"""
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(20)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'X'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl", "memory")
vl.setRenderer(QgsNullSymbolRenderer())
f = QgsFeature(vl.fields(), 1)
for x in range(15):
for y in range(15):
f.setGeometry(QgsPoint(x, y))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
p = QgsProject()
engine_settings = QgsLabelingEngineSettings()
engine_settings.setFlag(QgsLabelingEngineSettings.UsePartialCandidates, False)
engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly, True)
p.setLabelingEngineSettings(engine_settings)
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(True)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
layout.addLayoutItem(map)
checker = QgsLayoutChecker('composermap_label_nomargin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
map.setLabelMargin(QgsLayoutMeasurement(15, QgsUnitTypes.LayoutMillimeters))
checker = QgsLayoutChecker('composermap_label_margin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
map.setLabelMargin(QgsLayoutMeasurement(3, QgsUnitTypes.LayoutCentimeters))
checker = QgsLayoutChecker('composermap_label_cm_margin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
map.setMapRotation(45)
map.zoomToExtent(vl.extent())
map.setScale(map.scale() * 1.2)
checker = QgsLayoutChecker('composermap_rotated_label_margin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
# data defined
map.setMapRotation(0)
map.zoomToExtent(vl.extent())
map.dataDefinedProperties().setProperty(QgsLayoutObject.MapLabelMargin, QgsProperty.fromExpression('1+3'))
map.refresh()
checker = QgsLayoutChecker('composermap_dd_label_margin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
def testPartialLabels(self):
"""
Test rendering map item with a show partial labels flag
"""
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(20)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'X'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl", "memory")
vl.setRenderer(QgsNullSymbolRenderer())
f = QgsFeature(vl.fields(), 1)
for x in range(15):
for y in range(15):
f.setGeometry(QgsPoint(x, y))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
p = QgsProject()
engine_settings = QgsLabelingEngineSettings()
engine_settings.setFlag(QgsLabelingEngineSettings.UsePartialCandidates, False)
engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly, True)
p.setLabelingEngineSettings(engine_settings)
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(True)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
layout.addLayoutItem(map)
# default should always be to hide partial labels
self.assertFalse(map.mapFlags() & QgsLayoutItemMap.ShowPartialLabels)
# hiding partial labels (the default)
map.setMapFlags(QgsLayoutItemMap.MapItemFlags())
checker = QgsLayoutChecker('composermap_label_nomargin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
# showing partial labels
map.setMapFlags(QgsLayoutItemMap.ShowPartialLabels)
checker = QgsLayoutChecker('composermap_show_partial_labels', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
def testBlockingItems(self):
"""
Test rendering map item with blocking items
"""
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(20)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'X'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl", "memory")
vl.setRenderer(QgsNullSymbolRenderer())
f = QgsFeature(vl.fields(), 1)
for x in range(15):
for y in range(15):
f.setGeometry(QgsPoint(x, y))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
p = QgsProject()
engine_settings = QgsLabelingEngineSettings()
engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly, True)
p.setLabelingEngineSettings(engine_settings)
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(True)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
map.setId('map')
layout.addLayoutItem(map)
map2 = QgsLayoutItemMap(layout)
map2.attemptSetSceneRect(QRectF(0, 5, 50, 80))
map2.setFrameEnabled(True)
map2.setBackgroundEnabled(False)
map2.setId('map2')
layout.addLayoutItem(map2)
map3 = QgsLayoutItemMap(layout)
map3.attemptSetSceneRect(QRectF(150, 160, 50, 50))
map3.setFrameEnabled(True)
map3.setBackgroundEnabled(False)
map3.setId('map3')
layout.addLayoutItem(map3)
map.addLabelBlockingItem(map2)
map.addLabelBlockingItem(map3)
map.setMapFlags(QgsLayoutItemMap.MapItemFlags())
checker = QgsLayoutChecker('composermap_label_blockers', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
doc = QDomDocument("testdoc")
elem = layout.writeXml(doc, QgsReadWriteContext())
l2 = QgsLayout(p)
self.assertTrue(l2.readXml(elem, doc, QgsReadWriteContext()))
map_restore = [i for i in l2.items() if isinstance(i, QgsLayoutItemMap) and i.id() == 'map'][0]
map2_restore = [i for i in l2.items() if isinstance(i, QgsLayoutItemMap) and i.id() == 'map2'][0]
map3_restore = [i for i in l2.items() if isinstance(i, QgsLayoutItemMap) and i.id() == 'map3'][0]
self.assertTrue(map_restore.isLabelBlockingItem(map2_restore))
self.assertTrue(map_restore.isLabelBlockingItem(map3_restore))
def CrossTab(raster1, raster2, vector1, diretorioOut, resolucao, campoID,
weight111, weight112, weight121, weight122, weight199, weight299,
weight399, weight499599):
fileInfo1 = QFileInfo(raster1)
path1 = fileInfo1.filePath()
baseName1 = fileInfo1.baseName()
layer1 = QgsRasterLayer(path1, baseName1)
QgsMapLayerRegistry.instance().addMapLayer(layer1)
if layer1.isValid() is True:
print "Layer1 was loaded successfully!"
else:
print "Unable to read basename and file path - Your string is probably invalid"
provider1 = layer1.dataProvider()
extent1 = provider1.extent()
rows1 = layer1.height()
cols1 = layer1.width()
block1 = provider1.block(1, extent1, cols1, rows1)
fileInfo2 = QFileInfo(raster2)
path2 = fileInfo2.filePath()
baseName2 = fileInfo2.baseName()
layer2 = QgsRasterLayer(path2, baseName2)
QgsMapLayerRegistry.instance().addMapLayer(layer2)
if layer2.isValid() is True:
print "Layer2 was loaded successfully!"
else:
print "Unable to read basename and file path - Your string is probably invalid"
provider2 = layer2.dataProvider()
extent2 = provider2.extent()
rows2 = layer2.height()
cols2 = layer2.width()
block2 = provider2.block(1, extent2, cols2, rows2)
fileInfo3 = QFileInfo(vector1)
path3 = fileInfo3.filePath()
baseName3 = fileInfo3.baseName()
layer3 = QgsVectorLayer("%s" % (vector1), "vector1", "ogr")
QgsMapLayerRegistry.instance().addMapLayer(layer3)
feats_count = layer3.featureCount()
if layer3.isValid() is True:
print "Layer3 was loaded successfully!"
else:
print "Unable to read basename and file path - Your string is probably invalid"
valoresBGRI = []
valoresBGRIunicos = []
# lista de valores BGRI unicos
for feature in layer3.getFeatures():
objectid = feature.attributes()[layer3.fieldNameIndex(campoID)]
valoresBGRI.append(objectid)
for v in valoresBGRI:
if v not in valoresBGRIunicos:
valoresBGRIunicos.append(v)
a = len(valoresBGRIunicos)
print a
feats_count = layer3.featureCount()
print feats_count
valoresCLCunicos = [111, 112, 121, 122, 199, 299, 399, 499, 599]
b = len(valoresCLCunicos)
print b
crossTabMatrix = [[0 for y in range(b + 1)] for x in range(a + 1)]
for y in range(b):
crossTabMatrix[0][y + 1] = valoresCLCunicos[y]
for x in range(a):
crossTabMatrix[x + 1][0] = valoresBGRIunicos[x]
#print crossTabMatrix
#crosstab
for i in range(rows1):
for j in range(cols1):
cell_value1 = int(block1.value(i, j))
cell_value2 = int(block2.value(i, j))
for y in range(b):
for x in range(a):
if cell_value1 == crossTabMatrix[
x + 1][0] and cell_value2 == crossTabMatrix[0][y +
1]:
crossTabMatrix[x + 1][y + 1] += 1
#print crossTabMatrix
#exportar a tabulacao para csv
csvfile = diretorioOut + r"\crosstab.csv"
print csvfile
with open(csvfile, "w") as output:
writer = csv.writer(output, lineterminator='\n')
writer.writerows(crossTabMatrix)
# Adicionar campos para calculo (Campo1, Campo 2)
shp_uri = vector1
shp = QgsVectorLayer(shp_uri, 'bgri', 'ogr')
caps = shp.dataProvider().capabilities()
if caps & QgsVectorDataProvider.AddAttributes:
res = shp.dataProvider().addAttributes([
QgsField("E", QVariant.Double),
QgsField("TOTAL", QVariant.Double)
])
#if caps & QgsVectorDataProvider.DeleteAttributes:
# res = shp.dataProvider().deleteAttributes([0])
shp.updateFields()
QgsMapLayerRegistry.instance().addMapLayer(shp)
# Get input (csv) and target (Shapefile) layers
csv_uri = 'file:///' + diretorioOut + r'/crosstab.csv?delimiter=,'
print csv_uri
csvlayer = QgsVectorLayer(csv_uri, "crosstab", "delimitedtext")
QgsMapLayerRegistry.instance().addMapLayer(csvlayer)
# Set properties for the join
shpField = campoID
csvField = '0_1'
joinObject = QgsVectorJoinInfo()
joinObject.joinLayerId = csvlayer.id()
joinObject.joinFieldName = csvField
joinObject.targetFieldName = shpField
joinObject.memoryCache = True
shp.addJoin(joinObject)
# Calcular pesos, TOTAL e E
# Update do campo TOTAL no shapefile
resolucao2 = int(resolucao) * int(resolucao)
expressionT = QgsExpression(
"(crosstab_111_1+crosstab_112_1+crosstab_121_1+crosstab_122_1+crosstab_199_1+crosstab_299_1+crosstab_399_1+crosstab_499_1+crosstab_599_1)*{}"
.format(resolucao2))
indexT = shp.fieldNameIndex("TOTAL")
expressionT.prepare(shp.pendingFields())
shp.startEditing()
for feature in shp.getFeatures():
valueT = expressionT.evaluate(feature)
shp.changeAttributeValue(feature.id(), indexT, valueT)
shp.commitChanges()
# Update do campo E no shapefile
expressionE = QgsExpression(
"((crosstab_111_1*{})/TOTAL)*{}+((crosstab_112_1*{})/TOTAL)*{}+((crosstab_121_1*{})/TOTAL)*{}+((crosstab_122_1*{})/TOTAL)*{}+((crosstab_199_1*{})/TOTAL)*{}+((crosstab_299_1*{})/TOTAL)*{}+((crosstab_399_1*{})/TOTAL)*{}"
.format(resolucao2, weight111, resolucao2, weight112, resolucao2,
weight121, resolucao2, weight122, resolucao2, weight199,
resolucao2, weight299, resolucao2, weight399))
indexE = shp.fieldNameIndex("E")
expressionE.prepare(shp.pendingFields())
shp.startEditing()
for feature in shp.getFeatures():
valueE = expressionE.evaluate(feature)
shp.changeAttributeValue(feature.id(), indexE, valueE)
shp.commitChanges()
def createMapLayer(self,
mapLayerName,
layerStyleName,
boundingBox,
layerTime="",
minMaxRange=None):
"""Will create a QGIS valid raster layer for the
parsed map, using the passed parameters to get the
layer we need, with the requested style, and optionally
a time dimension.
The possibility of using WMS-T (Time) is provided by
a 'hack' (QGIS does not allow it through its WMS provider
API), taken from Anita Graser's Time Manager (GPL2).
:param mapLayerName: The name identifier of the coverage we want
to retrieve..
:type mapLayerName: str
:param layerStyleName: The name identifier of the layer style we want
used to paint our layer.
:type layerStyleName: str
:param layerTime: The time dimension we want (optional).
:type layerTime: str
:param minMaxRange: A tuple or list containing the min and max values to
be used in the request of this map. Used for rendering
the proper colors. If none or not provided, it will
ask the server for the max-min values of this time-defined
map and use them instead.
:type minMaxRange: list or tuple with floats (min, max)
:returns: A QGIS-compatible raster layer object with the given parameters.
:rtype: QgsRasterLayer
"""
if self.mapInfo is None:
self.getMapInfoFromCapabilities()
if minMaxRange == None:
minMaxRange = self.getMinMaxRasterValuesFromTimeRange(
mapLayerName, layerStyleName, [layerTime], boundingBox)
rasterMinMaxValues = str(minMaxRange[0]) + "," + str(minMaxRange[1])
print("Raster range for " + mapLayerName + "_" + layerStyleName +
": " + rasterMinMaxValues)
finalUrl = self.baseWMSUrl.format(layer=mapLayerName,
style=layerStyleName,
url=self.mapInfo.getURL())
print("FinalUrl : " + finalUrl)
#We add an UUID to guarantee uniqueness in the layer name and id
layerName = self.mapInfo.getName() + "-" + str(uuid.uuid4())
print("LayerName :" + layerName)
resultLayer = QgsRasterLayer(finalUrl, layerName, 'wms')
if resultLayer.isValid():
print "Layer is valid"
print resultLayer
else:
print "Layer is not valid"
print("Wms uri : " + resultLayer.dataProvider().dataSourceUri())
##print (self.qgisWMSThack+resultLayer.dataProvider().dataSourceUri()
## + "?TIME={time}%26COLORSCALERANGE={scale}%26BBOX={bbox}"
## .format(time = layerTime,
## scale=rasterMinMaxValues,
## bbox=str(boundingBox)) )
#HACK taken from Anita Graser's Time Manager:
#https://github.com/anitagraser/TimeManager/blob/master/raster/wmstlayer.py
#(Under GPL2 license) with an extra added for COLORSCALERANGE ncWMS attribute
#and BOUNDINGBOX information (which is removed when constructing layers by qgis
#it seems?)
#TODO: Bounding box information is not processed by QGIS. QGIS C++ WMS provider
#apparently re-creates the request with a previously read bounding box information
#from the capabilities.xml file. This needs a workaround, or reature request to QGIS.
resultLayer.dataProvider().setDataSourceUri(
self.qgisWMSThack + resultLayer.dataProvider().dataSourceUri() +
"?TIME={time}%26COLORSCALERANGE={scale}%26BBOX={bbox}".format(
time=layerTime,
scale=rasterMinMaxValues,
bbox=str(boundingBox)))
if resultLayer.isValid():
self.mapLayer = resultLayer
else:
raise StandardError('No se pudo crear una capa válida.')
class TestQgsLayoutMap(unittest.TestCase, LayoutItemTestCase):
@classmethod
def setUpClass(cls):
cls.item_class = QgsLayoutItemMap
def setUp(self):
self.report = "<h1>Python QgsLayoutItemMap Tests</h1>\n"
def tearDown(self):
report_file_path = "%s/qgistest.html" % QDir.tempPath()
with open(report_file_path, 'a') as report_file:
report_file.write(self.report)
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()
QgsProject.instance().addMapLayers(
[self.raster_layer, self.vector_layer])
# create layout with layout map
self.layout = QgsLayout(QgsProject.instance())
self.layout.initializeDefaults()
self.map = QgsLayoutItemMap(self.layout)
self.map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
self.map.setFrameEnabled(True)
self.map.setLayers([self.raster_layer])
self.layout.addLayoutItem(self.map)
def testOverviewMap(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
checker = QgsLayoutChecker('composermap_overview', self.layout)
checker.setColorTolerance(6)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
self.assertTrue(myTestResult, myMessage)
def testOverviewMapBlend(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
overviewMap.overview().setBlendMode(QPainter.CompositionMode_Multiply)
checker = QgsLayoutChecker('composermap_overview_blending',
self.layout)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
self.assertTrue(myTestResult, myMessage)
def testOverviewMapInvert(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
overviewMap.overview().setInverted(True)
checker = QgsLayoutChecker('composermap_overview_invert', self.layout)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
self.assertTrue(myTestResult, myMessage)
def testOverviewMapCenter(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(192, -288, 320, -224)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
overviewMap.overview().setInverted(False)
overviewMap.overview().setCentered(True)
checker = QgsLayoutChecker('composermap_overview_center', self.layout)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
self.assertTrue(myTestResult, myMessage)
def testAsMapLayer(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
map = QgsLayoutItemMap(l)
map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
l.addLayoutItem(map)
overviewMap = QgsLayoutItemMap(l)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
l.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(map)
layer = overviewMap.overview().asMapLayer()
self.assertIsNotNone(layer)
self.assertTrue(layer.isValid())
self.assertEqual(
[f.geometry().asWkt() for f in layer.getFeatures()],
['Polygon ((96 -120, 160 -120, 160 -152, 96 -152, 96 -120))'])
# check that layer has correct renderer
fill_symbol = QgsFillSymbol.createSimple({
'color': '#00ff00',
'outline_color': '#ff0000',
'outline_width': '10'
})
overviewMap.overview().setFrameSymbol(fill_symbol)
layer = overviewMap.overview().asMapLayer()
self.assertIsInstance(layer.renderer(), QgsSingleSymbolRenderer)
self.assertEqual(
layer.renderer().symbol().symbolLayer(0).properties()['color'],
'0,255,0,255')
self.assertEqual(
layer.renderer().symbol().symbolLayer(0).properties()
['outline_color'], '255,0,0,255')
# test layer blend mode
self.assertEqual(layer.blendMode(),
QPainter.CompositionMode_SourceOver)
overviewMap.overview().setBlendMode(QPainter.CompositionMode_Clear)
layer = overviewMap.overview().asMapLayer()
self.assertEqual(layer.blendMode(), QPainter.CompositionMode_Clear)
# should have no effect
overviewMap.setMapRotation(45)
layer = overviewMap.overview().asMapLayer()
self.assertEqual(
[f.geometry().asWkt() for f in layer.getFeatures()],
['Polygon ((96 -120, 160 -120, 160 -152, 96 -152, 96 -120))'])
map.setMapRotation(15)
layer = overviewMap.overview().asMapLayer()
self.assertEqual(
[f.geometry().asWkt(0) for f in layer.getFeatures()],
['Polygon ((93 -129, 155 -112, 163 -143, 101 -160, 93 -129))'])
# with reprojection
map.setCrs(QgsCoordinateReferenceSystem('EPSG:3875'))
layer = overviewMap.overview().asMapLayer()
self.assertEqual([
f.geometry().asWkt(0) for f in layer.getFeatures()
], [
'Polygon ((93 -129, 96 -128, 99 -127, 102 -126, 105 -126, 108 -125, 111 -124, 114 -123, 116 -123, 119 -122, 122 -121, 125 -120, 128 -119, 131 -119, 134 -118, 137 -117, 140 -116, 143 -115, 146 -115, 149 -114, 152 -113, 155 -112, 155 -114, 156 -115, 156 -117, 156 -118, 157 -120, 157 -121, 158 -123, 158 -124, 158 -126, 159 -127, 159 -128, 160 -130, 160 -131, 160 -133, 161 -134, 161 -136, 161 -137, 162 -139, 162 -140, 163 -142, 163 -143, 160 -144, 157 -145, 154 -146, 151 -146, 148 -147, 145 -148, 142 -149, 140 -149, 137 -150, 134 -151, 131 -152, 128 -153, 125 -153, 122 -154, 119 -155, 116 -156, 113 -157, 110 -157, 107 -158, 104 -159, 101 -160, 101 -158, 100 -157, 100 -155, 100 -154, 99 -152, 99 -151, 98 -149, 98 -148, 98 -146, 97 -145, 97 -144, 96 -142, 96 -141, 96 -139, 95 -138, 95 -136, 95 -135, 94 -133, 94 -132, 93 -130, 93 -129))'
])
map.setCrs(overviewMap.crs())
# with invert
overviewMap.overview().setInverted(True)
layer = overviewMap.overview().asMapLayer()
self.assertEqual([
f.geometry().asWkt(0) for f in layer.getFeatures()
], [
'Polygon ((-53 -128, 128 53, 309 -128, 128 -309, -53 -128),(93 -129, 101 -160, 163 -143, 155 -112, 93 -129))'
])
def test_StackingPosition(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
overviewMap = QgsLayoutItemMap(l)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
l.addLayoutItem(overviewMap)
overviewMap.overview().setStackingPosition(
QgsLayoutItemMapItem.StackBelowMap)
self.assertEqual(overviewMap.overview().stackingPosition(),
QgsLayoutItemMapItem.StackBelowMap)
overviewMap.overview().setStackingPosition(
QgsLayoutItemMapItem.StackBelowMapLayer)
self.assertEqual(overviewMap.overview().stackingPosition(),
QgsLayoutItemMapItem.StackBelowMapLayer)
overviewMap.overview().setStackingLayer(self.raster_layer)
self.assertEqual(overviewMap.overview().stackingLayer(),
self.raster_layer)
overviewMap.overview().setStackingLayer(self.vector_layer)
self.assertEqual(overviewMap.overview().stackingLayer(),
self.vector_layer)
overviewMap.overview().setStackingLayer(None)
self.assertIsNone(overviewMap.overview().stackingLayer())
def test_ModifyMapLayerList(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
overviewMap = QgsLayoutItemMap(l)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
l.addLayoutItem(overviewMap)
map = QgsLayoutItemMap(l)
map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
l.addLayoutItem(map)
self.assertFalse(overviewMap.overviews().modifyMapLayerList([]))
self.assertEqual(
overviewMap.overviews().modifyMapLayerList(
[self.raster_layer, self.vector_layer]),
[self.raster_layer, self.vector_layer])
overviewMap.overview().setLinkedMap(map)
overviewMap.overview().setStackingPosition(
QgsLayoutItemMapItem.StackBelowMap)
self.assertEqual(
overviewMap.overviews().modifyMapLayerList(
[self.raster_layer, self.vector_layer]), [
self.raster_layer, self.vector_layer,
overviewMap.overview().asMapLayer()
])
overviewMap.overview().setStackingPosition(
QgsLayoutItemMapItem.StackBelowMapLayer)
self.assertEqual(
overviewMap.overviews().modifyMapLayerList(
[self.raster_layer, self.vector_layer]),
[self.raster_layer, self.vector_layer])
overviewMap.overview().setStackingLayer(self.raster_layer)
self.assertEqual(
overviewMap.overviews().modifyMapLayerList(
[self.raster_layer, self.vector_layer]), [
self.raster_layer,
overviewMap.overview().asMapLayer(), self.vector_layer
])
overviewMap.overview().setStackingLayer(self.vector_layer)
self.assertEqual(
overviewMap.overviews().modifyMapLayerList(
[self.raster_layer, self.vector_layer]), [
self.raster_layer, self.vector_layer,
overviewMap.overview().asMapLayer()
])
overviewMap.overview().setStackingPosition(
QgsLayoutItemMapItem.StackAboveMapLayer)
overviewMap.overview().setStackingLayer(None)
self.assertEqual(
overviewMap.overviews().modifyMapLayerList(
[self.raster_layer, self.vector_layer]),
[self.raster_layer, self.vector_layer])
overviewMap.overview().setStackingLayer(self.raster_layer)
self.assertEqual(
overviewMap.overviews().modifyMapLayerList(
[self.raster_layer, self.vector_layer]), [
overviewMap.overview().asMapLayer(), self.raster_layer,
self.vector_layer
])
overviewMap.overview().setStackingLayer(self.vector_layer)
self.assertEqual(
overviewMap.overviews().modifyMapLayerList(
[self.raster_layer, self.vector_layer]), [
self.raster_layer,
overviewMap.overview().asMapLayer(), self.vector_layer
])
overviewMap.overview().setStackingPosition(
QgsLayoutItemMapItem.StackBelowMapLabels)
self.assertEqual(
overviewMap.overviews().modifyMapLayerList(
[self.raster_layer, self.vector_layer]), [
overviewMap.overview().asMapLayer(), self.raster_layer,
self.vector_layer
])
overviewMap.overview().setStackingPosition(
QgsLayoutItemMapItem.StackAboveMapLabels)
self.assertEqual(
overviewMap.overviews().modifyMapLayerList(
[self.raster_layer, self.vector_layer]),
[self.raster_layer, self.vector_layer])
# two overviews
overviewMap.overview().setStackingPosition(
QgsLayoutItemMapItem.StackBelowMap)
overviewMap.overviews().addOverview(
QgsLayoutItemMapOverview('x', overviewMap))
overviewMap.overviews().overview(1).setLinkedMap(map)
overviewMap.overviews().overview(1).setStackingPosition(
QgsLayoutItemMapItem.StackBelowMapLabels)
self.assertEqual(
overviewMap.overviews().modifyMapLayerList(
[self.raster_layer, self.vector_layer]), [
overviewMap.overviews().overview(1).asMapLayer(),
self.raster_layer, self.vector_layer,
overviewMap.overview().asMapLayer()
])
def testOverviewStacking(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
map = QgsLayoutItemMap(l)
map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
map.setFrameEnabled(True)
map.setLayers([self.raster_layer])
l.addLayoutItem(map)
overviewMap = QgsLayoutItemMap(l)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
l.addLayoutItem(overviewMap)
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(-20, -276, 276, 20)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(map)
overviewMap.overview().setInverted(True)
overviewMap.overview().setStackingPosition(
QgsLayoutItemMapItem.StackBelowMapLayer)
overviewMap.overview().setStackingLayer(self.raster_layer)
checker = QgsLayoutChecker('composermap_overview_belowmap', l)
checker.setColorTolerance(6)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.assertTrue(myTestResult, myMessage)
overviewMap.overview().setStackingPosition(
QgsLayoutItemMapItem.StackAboveMapLayer)
overviewMap.overview().setStackingLayer(self.raster_layer)
checker = QgsLayoutChecker('composermap_overview_abovemap', l)
checker.setColorTolerance(6)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.assertTrue(myTestResult, myMessage)
def testPalettedClassDataFromLayer(self):
# no layer
classes = QgsPalettedRasterRenderer.classDataFromRaster(None, 1)
self.assertFalse(classes)
# 10 class layer
path = os.path.join(unitTestDataPath('raster'),
'with_color_table.tif')
info = QFileInfo(path)
base_name = info.baseName()
layer10 = QgsRasterLayer(path, base_name)
classes = QgsPalettedRasterRenderer.classDataFromRaster(layer10.dataProvider(), 1)
self.assertEqual(len(classes), 10)
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[0].label, '1')
self.assertEqual(classes[1].value, 2)
self.assertEqual(classes[1].label, '2')
self.assertEqual(classes[2].value, 3)
self.assertEqual(classes[2].label, '3')
self.assertEqual(classes[3].value, 4)
self.assertEqual(classes[3].label, '4')
self.assertEqual(classes[4].value, 5)
self.assertEqual(classes[4].label, '5')
self.assertEqual(classes[5].value, 6)
self.assertEqual(classes[5].label, '6')
self.assertEqual(classes[6].value, 7)
self.assertEqual(classes[6].label, '7')
self.assertEqual(classes[7].value, 8)
self.assertEqual(classes[7].label, '8')
self.assertEqual(classes[8].value, 9)
self.assertEqual(classes[8].label, '9')
self.assertEqual(classes[9].value, 10)
self.assertEqual(classes[9].label, '10')
# bad band
self.assertFalse(QgsPalettedRasterRenderer.classDataFromRaster(layer10.dataProvider(), 10101010))
# with ramp
r = QgsGradientColorRamp(QColor(200, 0, 0, 100), QColor(0, 200, 0, 200))
classes = QgsPalettedRasterRenderer.classDataFromRaster(layer10.dataProvider(), 1, r)
self.assertEqual(len(classes), 10)
self.assertEqual(classes[0].color.name(), '#c80000')
self.assertEqual(classes[1].color.name(), '#b21600')
self.assertEqual(classes[2].color.name(), '#9c2c00')
self.assertEqual(classes[3].color.name(), '#854200')
self.assertEqual(classes[4].color.name(), '#6f5900')
self.assertEqual(classes[5].color.name(), '#596f00')
self.assertEqual(classes[6].color.name(), '#428500')
self.assertEqual(classes[7].color.name(), '#2c9c00')
self.assertEqual(classes[8].color.name(), '#16b200')
self.assertEqual(classes[9].color.name(), '#00c800')
# 30 class layer
path = os.path.join(unitTestDataPath('raster'),
'unique_1.tif')
info = QFileInfo(path)
base_name = info.baseName()
layer10 = QgsRasterLayer(path, base_name)
classes = QgsPalettedRasterRenderer.classDataFromRaster(layer10.dataProvider(), 1)
self.assertEqual(len(classes), 30)
expected = [11, 21, 22, 24, 31, 82, 2002, 2004, 2014, 2019, 2027, 2029, 2030, 2080, 2081, 2082, 2088, 2092, 2097, 2098, 2099, 2105, 2108, 2110, 2114, 2118, 2126, 2152, 2184, 2220]
self.assertEqual([c.value for c in classes], expected)
# bad layer
path = os.path.join(unitTestDataPath('raster'),
'hub13263.vrt')
info = QFileInfo(path)
base_name = info.baseName()
layer = QgsRasterLayer(path, base_name)
classes = QgsPalettedRasterRenderer.classDataFromRaster(layer.dataProvider(), 1)
self.assertFalse(classes)
def readRasterLayer(i, allBandData):
# pylint: disable=too-many-locals
fileInfo = QFileInfo(shared.rasterFileName[i])
fileBaseName = fileInfo.baseName()
layer = QgsRasterLayer(shared.rasterFileName[i], fileBaseName)
if not layer.isValid():
shared.fpOut.write("Raster layer '" + shared.rasterFileName[i] +
"'failed to load")
return -1
# Store the title as the first list item
allBandData.append(shared.rasterFileTitle[i])
# Get more info
xSize = layer.width()
ySize = layer.height()
cellWidth = layer.rasterUnitsPerPixelX()
cellHeight = layer.rasterUnitsPerPixelY()
provider = layer.dataProvider()
extnt = provider.extent()
dpi = provider.dpi()
shared.fpOut.write("Raster layer '" + shared.rasterFileTitle[i] +
"' loaded with X, Y resolution = " + str(cellWidth) +
", " + str(cellHeight) + " m\n")
#shared.fpOut.write(layer.metadata())
#shared.fpOut.write(layer.rasterType())
# Store the above as the second list item
allBandData.append(
[provider, xSize, ySize, cellWidth, cellHeight, extnt, dpi])
# Now store the data for each band as a QgsRasterBlock
nBands = layer.bandCount()
for band in range(nBands):
#shared.fpOut.write(layer.bandName(i))
bandData = provider.block(band, extnt, xSize, ySize)
# Store as a further list item
allBandData.append(bandData)
# Sort out style
#shared.fpOut.write("Style file " + str(i) + " is " + shared.rasterFileStyle[i])
if not shared.rasterFileStyle[i]:
# No style file specified, so try the default style for this layer
shared.rasterFileStyle[i] = layer.styleURI()
#shared.fpOut.write("Trying default style file " + shared.rasterFileStyle[i])
if not layer.loadDefaultStyle():
shared.fpOut.write("Could not load default style '" +
shared.rasterFileStyle[i] +
"' for raster layer '" +
shared.rasterFileTitle[i] + "'")
else:
# A style file was specified, so try to load it
#shared.fpOut.write("Trying style file " + shared.rasterFileStyle[i])
if not layer.loadNamedStyle(shared.rasterFileStyle[i]):
shared.fpOut.write("Could not load style '" +
shared.rasterFileStyle[i] +
"' for raster layer '" +
shared.rasterFileTitle[i] + "'")
# Set opacity
layer.renderer().setOpacity(shared.rasterFileOpacity[i])
# Add this layer to the app's registry
QgsProject.instance().addMapLayer(layer)
return layer
def on_cannyPushButton_clicked(self):
raster_layer_name = self.rasterLayerComboBox.currentText()
raster_layer = QgsProject.instance().mapLayersByName(
raster_layer_name)[0]
provider = raster_layer.dataProvider()
extent = provider.extent()
rows = raster_layer.height()
cols = raster_layer.width()
# 读取栅格值
block = provider.block(1, extent, cols, rows)
img = np.zeros([rows, cols, 3], np.uint8)
band_num = 3
for band_index in range(band_num):
block = provider.block(band_index + 1, extent, cols, rows)
# for row_index in range(rows):
# for col_index in range(cols):
# img[row_index][col_index][band_index] = block.value(
# row_index, col_index)
img[:, :,
band_index] = np.array(block.data()).reshape([rows, cols])
print(img)
print(img.shape)
edges = cv2.Canny(img, 200, 400, 15)
plt.subplot(121)
plt.imshow(img)
plt.title('Original Image')
plt.xticks([])
plt.yticks([])
plt.subplot(122)
plt.imshow(edges, cmap='gray')
plt.title('Edge Image')
plt.xticks([])
plt.yticks([])
plt.show()
cv2.imwrite(r'edge_result.jpg', edges)
# 写入Tiff
driver = gdal.GetDriverByName('GTiff')
# 创建图像
print(f'cols {cols}, rows {rows}')
ds = driver.Create('edge_result.tif',
xsize=cols,
ysize=rows,
bands=1,
eType=gdal.GDT_Byte)
# 设置参考坐标系
crs_wkt = raster_layer.crs().toWkt()
ds.SetProjection(crs_wkt)
print(crs_wkt)
# srs = osr.SpatialReference()
# srs.SetUTM(12, 1)
# srs.SetWellKnownGeogCS('WGS84')
# ds.SetProjection(srs.ExportToWkt())
# 设置Tiff的图像转换参数
transformParam = [
extent.xMinimum(), (extent.width() / cols), 0,
extent.yMaximum(), 0, -(extent.height() / rows)
]
ds.SetGeoTransform(transformParam)
print(transformParam)
# 写入数据
ds.GetRasterBand(1).WriteArray(edges[:, :])
# 关闭文件
ds = None
# 添加至图层并设置样式
rlayer = QgsRasterLayer('edge_result.tif', "result tif layer")
QgsProject.instance().addMapLayer(rlayer)
palette_raster_render = QgsPalettedRasterRenderer(
rlayer.dataProvider(), 1, [
QgsPalettedRasterRenderer.Class(0, QtGui.QColor(0, 0, 0, 0)),
QgsPalettedRasterRenderer.Class(255,
QtGui.QColor(255, 0, 0, 255))
])
rlayer.setRenderer(palette_raster_render)
def testTransparency(self):
myPath = os.path.join(unitTestDataPath('raster'),
'band1_float32_noct_epsg4326.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
myRasterLayer = QgsRasterLayer(myPath, myBaseName)
myMessage = 'Raster not loaded: %s' % myPath
assert myRasterLayer.isValid(), myMessage
renderer = QgsSingleBandGrayRenderer(myRasterLayer.dataProvider(), 1)
myRasterLayer.setRenderer(renderer)
myRasterLayer.setContrastEnhancement(
QgsContrastEnhancement.StretchToMinimumMaximum,
QgsRasterMinMaxOrigin.MinMax)
myContrastEnhancement = myRasterLayer.renderer().contrastEnhancement()
# print ("myContrastEnhancement.minimumValue = %.17g" %
# myContrastEnhancement.minimumValue())
# print ("myContrastEnhancement.maximumValue = %.17g" %
# myContrastEnhancement.maximumValue())
# Unfortunately the minimum/maximum values calculated in C++ and Python
# are slightly different (e.g. 3.3999999521443642e+38 x
# 3.3999999521444001e+38)
# It is not clear where the precision is lost.
# We set the same values as C++.
myContrastEnhancement.setMinimumValue(-3.3319999287625854e+38)
myContrastEnhancement.setMaximumValue(3.3999999521443642e+38)
#myType = myRasterLayer.dataProvider().dataType(1);
#myEnhancement = QgsContrastEnhancement(myType);
myTransparentSingleValuePixelList = []
rasterTransparency = QgsRasterTransparency()
myTransparentPixel1 = \
QgsRasterTransparency.TransparentSingleValuePixel()
myTransparentPixel1.min = -2.5840000772112106e+38
myTransparentPixel1.max = -1.0879999684602689e+38
myTransparentPixel1.percentTransparent = 50
myTransparentSingleValuePixelList.append(myTransparentPixel1)
myTransparentPixel2 = \
QgsRasterTransparency.TransparentSingleValuePixel()
myTransparentPixel2.min = 1.359999960575336e+37
myTransparentPixel2.max = 9.520000231087593e+37
myTransparentPixel2.percentTransparent = 70
myTransparentSingleValuePixelList.append(myTransparentPixel2)
rasterTransparency.setTransparentSingleValuePixelList(
myTransparentSingleValuePixelList)
rasterRenderer = myRasterLayer.renderer()
assert rasterRenderer
rasterRenderer.setRasterTransparency(rasterTransparency)
QgsProject.instance().addMapLayers([
myRasterLayer,
])
myMapSettings = QgsMapSettings()
myMapSettings.setLayers([myRasterLayer])
myMapSettings.setExtent(myRasterLayer.extent())
myChecker = QgsRenderChecker()
myChecker.setControlName("expected_raster_transparency")
myChecker.setMapSettings(myMapSettings)
myResultFlag = myChecker.runTest("raster_transparency_python")
assert myResultFlag, "Raster transparency rendering test failed"
class TestQgsBlendModes(unittest.TestCase):
def __init__(self, methodName):
"""Run once on class initialization."""
unittest.TestCase.__init__(self, methodName)
self.iface = get_iface()
# initialize class MapRegistry, Canvas, MapRenderer, Map and PAL
self.mMapRegistry = QgsProject.instance()
# create point layer
myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp')
self.mPointLayer = QgsVectorLayer(myShpFile, 'Points', 'ogr')
self.mMapRegistry.addMapLayer(self.mPointLayer)
self.mSimplifyMethod = QgsVectorSimplifyMethod()
self.mSimplifyMethod.setSimplifyHints(
QgsVectorSimplifyMethod.NoSimplification)
# create polygon layer
myShpFile = os.path.join(TEST_DATA_DIR, 'polys.shp')
self.mPolygonLayer = QgsVectorLayer(myShpFile, 'Polygons', 'ogr')
self.mPolygonLayer.setSimplifyMethod(self.mSimplifyMethod)
self.mMapRegistry.addMapLayer(self.mPolygonLayer)
# create line layer
myShpFile = os.path.join(TEST_DATA_DIR, 'lines.shp')
self.mLineLayer = QgsVectorLayer(myShpFile, 'Lines', 'ogr')
self.mLineLayer.setSimplifyMethod(self.mSimplifyMethod)
self.mMapRegistry.addMapLayer(self.mLineLayer)
# create two raster layers
myRasterFile = os.path.join(TEST_DATA_DIR, 'rgb256x256.png')
self.mRasterLayer1 = QgsRasterLayer(myRasterFile, "raster1")
self.mRasterLayer2 = QgsRasterLayer(myRasterFile, "raster2")
myMultiBandRenderer1 = QgsMultiBandColorRenderer(
self.mRasterLayer1.dataProvider(), 1, 2, 3)
self.mRasterLayer1.setRenderer(myMultiBandRenderer1)
self.mMapRegistry.addMapLayer(self.mRasterLayer1)
myMultiBandRenderer2 = QgsMultiBandColorRenderer(
self.mRasterLayer2.dataProvider(), 1, 2, 3)
self.mRasterLayer2.setRenderer(myMultiBandRenderer2)
self.mMapRegistry.addMapLayer(self.mRasterLayer2)
# to match blend modes test comparisons background
self.mapSettings = QgsMapSettings()
self.mapSettings.setLayers([self.mRasterLayer1, self.mRasterLayer2])
self.mapSettings.setBackgroundColor(QColor(152, 219, 249))
self.mapSettings.setOutputSize(QSize(400, 400))
self.mapSettings.setOutputDpi(96)
self.extent = QgsRectangle(-118.8888888888887720, 22.8002070393376783,
-83.3333333333331581, 46.8719806763287536)
def testVectorBlending(self):
"""Test that blend modes work for vector layers."""
# Add vector layers to map
myLayers = [self.mLineLayer, self.mPolygonLayer]
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.extent)
# Set blending modes for both layers
self.mLineLayer.setBlendMode(QPainter.CompositionMode_Difference)
self.mPolygonLayer.setBlendMode(QPainter.CompositionMode_Difference)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_vector_blendmodes")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
myResult = checker.runTest("vector_blendmodes", 20)
myMessage = ('vector blending failed')
assert myResult, myMessage
# Reset layers
self.mLineLayer.setBlendMode(QPainter.CompositionMode_SourceOver)
self.mPolygonLayer.setBlendMode(QPainter.CompositionMode_SourceOver)
def testVectorFeatureBlending(self):
"""Test that feature blend modes work for vector layers."""
# Add vector layers to map
myLayers = [self.mLineLayer, self.mPolygonLayer]
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.extent)
# Set feature blending for line layer
self.mLineLayer.setFeatureBlendMode(QPainter.CompositionMode_Plus)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_vector_featureblendmodes")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
myResult = checker.runTest("vector_featureblendmodes", 20)
myMessage = ('vector feature blending failed')
assert myResult, myMessage
# Reset layers
self.mLineLayer.setFeatureBlendMode(
QPainter.CompositionMode_SourceOver)
def testVectorLayerOpacity(self):
"""Test that layer opacity works for vector layers."""
# Add vector layers to map
myLayers = [self.mLineLayer, self.mPolygonLayer]
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.extent)
# Set feature blending for line layer
self.mLineLayer.setOpacity(0.5)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_vector_layertransparency")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
myResult = checker.runTest("vector_layertransparency", 20)
myMessage = ('vector layer transparency failed')
assert myResult, myMessage
def testRasterBlending(self):
"""Test that blend modes work for raster layers."""
# Add raster layers to map
myLayers = [self.mRasterLayer1, self.mRasterLayer2]
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.mRasterLayer1.extent())
# Set blending mode for top layer
self.mRasterLayer1.setBlendMode(QPainter.CompositionMode_Difference)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_raster_blendmodes")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
checker.setColorTolerance(1)
myResult = checker.runTest("raster_blendmodes", 20)
myMessage = ('raster blending failed')
assert myResult, myMessage
def testPalettedClassDataFromLayer(self):
# no layer
classes = QgsPalettedRasterRenderer.classDataFromRaster(None, 1)
self.assertFalse(classes)
# 10 class layer
path = os.path.join(unitTestDataPath('raster'), 'with_color_table.tif')
info = QFileInfo(path)
base_name = info.baseName()
layer10 = QgsRasterLayer(path, base_name)
classes = QgsPalettedRasterRenderer.classDataFromRaster(
layer10.dataProvider(), 1)
self.assertEqual(len(classes), 10)
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[0].label, '1')
self.assertEqual(classes[1].value, 2)
self.assertEqual(classes[1].label, '2')
self.assertEqual(classes[2].value, 3)
self.assertEqual(classes[2].label, '3')
self.assertEqual(classes[3].value, 4)
self.assertEqual(classes[3].label, '4')
self.assertEqual(classes[4].value, 5)
self.assertEqual(classes[4].label, '5')
self.assertEqual(classes[5].value, 6)
self.assertEqual(classes[5].label, '6')
self.assertEqual(classes[6].value, 7)
self.assertEqual(classes[6].label, '7')
self.assertEqual(classes[7].value, 8)
self.assertEqual(classes[7].label, '8')
self.assertEqual(classes[8].value, 9)
self.assertEqual(classes[8].label, '9')
self.assertEqual(classes[9].value, 10)
self.assertEqual(classes[9].label, '10')
# bad band
self.assertFalse(
QgsPalettedRasterRenderer.classDataFromRaster(
layer10.dataProvider(), 10101010))
# with ramp
r = QgsGradientColorRamp(QColor(200, 0, 0, 100),
QColor(0, 200, 0, 200))
classes = QgsPalettedRasterRenderer.classDataFromRaster(
layer10.dataProvider(), 1, r)
self.assertEqual(len(classes), 10)
self.assertEqual(classes[0].color.name(), '#c80000')
self.assertEqual(classes[1].color.name(), '#b21600')
self.assertEqual(classes[2].color.name(), '#9c2c00')
self.assertEqual(classes[3].color.name(), '#854200')
self.assertEqual(classes[4].color.name(), '#6f5900')
self.assertEqual(classes[5].color.name(), '#596f00')
self.assertEqual(classes[6].color.name(), '#428500')
self.assertEqual(classes[7].color.name(), '#2c9c00')
self.assertEqual(classes[8].color.name(), '#16b200')
self.assertEqual(classes[9].color.name(), '#00c800')
# 30 class layer
path = os.path.join(unitTestDataPath('raster'), 'unique_1.tif')
info = QFileInfo(path)
base_name = info.baseName()
layer10 = QgsRasterLayer(path, base_name)
classes = QgsPalettedRasterRenderer.classDataFromRaster(
layer10.dataProvider(), 1)
self.assertEqual(len(classes), 30)
expected = [
11, 21, 22, 24, 31, 82, 2002, 2004, 2014, 2019, 2027, 2029, 2030,
2080, 2081, 2082, 2088, 2092, 2097, 2098, 2099, 2105, 2108, 2110,
2114, 2118, 2126, 2152, 2184, 2220
]
self.assertEqual([c.value for c in classes], expected)
# bad layer
path = os.path.join(unitTestDataPath('raster'), 'hub13263.vrt')
info = QFileInfo(path)
base_name = info.baseName()
layer = QgsRasterLayer(path, base_name)
classes = QgsPalettedRasterRenderer.classDataFromRaster(
layer.dataProvider(), 1)
self.assertFalse(classes)
def testPaletted(self):
""" test paletted raster renderer with raster with color table"""
path = os.path.join(unitTestDataPath('raster'), 'with_color_table.tif')
info = QFileInfo(path)
base_name = info.baseName()
layer = QgsRasterLayer(path, base_name)
self.assertTrue(layer.isValid(), 'Raster not loaded: {}'.format(path))
renderer = QgsPalettedRasterRenderer(layer.dataProvider(), 1, [
QgsPalettedRasterRenderer.Class(1, QColor(0, 255, 0), 'class 2'),
QgsPalettedRasterRenderer.Class(3, QColor(255, 0, 0), 'class 1')
])
self.assertEqual(renderer.nColors(), 2)
self.assertEqual(renderer.usesBands(), [1])
# test labels
self.assertEqual(renderer.label(1), 'class 2')
self.assertEqual(renderer.label(3), 'class 1')
self.assertFalse(renderer.label(101))
# test legend symbology - should be sorted by value
legend = renderer.legendSymbologyItems()
self.assertEqual(legend[0][0], 'class 2')
self.assertEqual(legend[1][0], 'class 1')
self.assertEqual(legend[0][1].name(), '#00ff00')
self.assertEqual(legend[1][1].name(), '#ff0000')
# test retrieving classes
classes = renderer.classes()
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[1].value, 3)
self.assertEqual(classes[0].label, 'class 2')
self.assertEqual(classes[1].label, 'class 1')
self.assertEqual(classes[0].color.name(), '#00ff00')
self.assertEqual(classes[1].color.name(), '#ff0000')
# test set label
# bad index
renderer.setLabel(1212, 'bad')
renderer.setLabel(3, 'new class')
self.assertEqual(renderer.label(3), 'new class')
# color ramp
r = QgsLimitedRandomColorRamp(5)
renderer.setSourceColorRamp(r)
self.assertEqual(renderer.sourceColorRamp().type(), 'random')
self.assertEqual(renderer.sourceColorRamp().count(), 5)
# clone
new_renderer = renderer.clone()
classes = new_renderer.classes()
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[1].value, 3)
self.assertEqual(classes[0].label, 'class 2')
self.assertEqual(classes[1].label, 'new class')
self.assertEqual(classes[0].color.name(), '#00ff00')
self.assertEqual(classes[1].color.name(), '#ff0000')
self.assertEqual(new_renderer.sourceColorRamp().type(), 'random')
self.assertEqual(new_renderer.sourceColorRamp().count(), 5)
# write to xml and read
doc = QDomDocument('testdoc')
elem = doc.createElement('qgis')
renderer.writeXml(doc, elem)
restored = QgsPalettedRasterRenderer.create(
elem.firstChild().toElement(), layer.dataProvider())
self.assertTrue(restored)
self.assertEqual(restored.usesBands(), [1])
classes = restored.classes()
self.assertTrue(classes)
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[1].value, 3)
self.assertEqual(classes[0].label, 'class 2')
self.assertEqual(classes[1].label, 'new class')
self.assertEqual(classes[0].color.name(), '#00ff00')
self.assertEqual(classes[1].color.name(), '#ff0000')
self.assertEqual(restored.sourceColorRamp().type(), 'random')
self.assertEqual(restored.sourceColorRamp().count(), 5)
# render test
layer.setRenderer(renderer)
ms = QgsMapSettings()
ms.setLayers([layer])
ms.setExtent(layer.extent())
checker = QgsRenderChecker()
checker.setControlName("expected_paletted_renderer")
checker.setMapSettings(ms)
self.assertTrue(checker.runTest("expected_paletted_renderer"),
"Paletted rendering test failed")
class TestQgsRasterRendererCreateSld(unittest.TestCase):
"""
This class tests the creation of SLD from QGis raster layers
"""
@classmethod
def setUpClass(self):
pass
def setUp(self):
pass
def tearDown(self):
pass
def __init__(self, methodName):
"""Run once on class initialization."""
unittest.TestCase.__init__(self, methodName)
myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif')
rasterFileInfo = QFileInfo(myPath)
self.raster_layer = QgsRasterLayer(rasterFileInfo.filePath(),
rasterFileInfo.completeBaseName())
def testSingleBandPseudoColorRenderer_Interpolated(self):
# get min and max of the band to renderer
bandNo = 3
stats = self.raster_layer.dataProvider().bandStatistics(
bandNo, QgsRasterBandStats.Min | QgsRasterBandStats.Max)
minValue = stats.minimumValue
maxValue = stats.maximumValue
# create shader for the renderer
shader = QgsRasterShader(minValue, maxValue)
colorRampShaderFcn = QgsColorRampShader(minValue, maxValue)
colorRampShaderFcn.setColorRampType(QgsColorRampShader.Interpolated)
colorRampShaderFcn.setClassificationMode(QgsColorRampShader.Continuous)
colorRampShaderFcn.setClip(True)
items = []
for index in range(10):
items.append(
QgsColorRampShader.ColorRampItem(
index, QColor('#{0:02d}{0:02d}{0:02d}'.format(index)),
"{}".format(index)))
colorRampShaderFcn.setColorRampItemList(items)
shader.setRasterShaderFunction(colorRampShaderFcn)
# create instance to test
rasterRenderer = QgsSingleBandPseudoColorRenderer(
self.raster_layer.dataProvider(), bandNo, shader)
self.raster_layer.setRenderer(rasterRenderer)
# do test
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertNoOpacity(root)
self.assertChannelBand(root, 'sld:GrayChannel', '{}'.format(bandNo))
# check ColorMapEntry classes
colorMap = root.elementsByTagName('sld:ColorMap')
colorMap = colorMap.item(0).toElement()
self.assertFalse(colorMap.isNull())
self.assertEqual(colorMap.attribute('type'), 'ramp')
colorMapEntries = colorMap.elementsByTagName('sld:ColorMapEntry')
self.assertEqual(colorMapEntries.count(), 10)
for index in range(colorMapEntries.count()):
colorMapEntry = colorMapEntries.at(index).toElement()
self.assertEqual(colorMapEntry.attribute('quantity'),
'{}'.format(index))
self.assertEqual(colorMapEntry.attribute('label'),
'{}'.format(index))
self.assertEqual(colorMapEntry.attribute('opacity'), '')
self.assertEqual(colorMapEntry.attribute('color'),
'#{0:02d}{0:02d}{0:02d}'.format(index))
def testSingleBandPseudoColorRenderer_Discrete(self):
# get min and max of the band to renderer
bandNo = 3
stats = self.raster_layer.dataProvider().bandStatistics(
bandNo, QgsRasterBandStats.Min | QgsRasterBandStats.Max)
minValue = stats.minimumValue
maxValue = stats.maximumValue
# create shader for the renderer
shader = QgsRasterShader(minValue, maxValue)
colorRampShaderFcn = QgsColorRampShader(minValue, maxValue)
colorRampShaderFcn.setColorRampType(QgsColorRampShader.Discrete)
colorRampShaderFcn.setClassificationMode(QgsColorRampShader.Continuous)
colorRampShaderFcn.setClip(True)
items = []
for index in range(10):
items.append(
QgsColorRampShader.ColorRampItem(
index, QColor('#{0:02d}{0:02d}{0:02d}'.format(index)),
"{}".format(index)))
colorRampShaderFcn.setColorRampItemList(items)
shader.setRasterShaderFunction(colorRampShaderFcn)
# create instance to test
rasterRenderer = QgsSingleBandPseudoColorRenderer(
self.raster_layer.dataProvider(), bandNo, shader)
self.raster_layer.setRenderer(rasterRenderer)
# do test
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertNoOpacity(root)
self.assertChannelBand(root, 'sld:GrayChannel', '{}'.format(bandNo))
# check ColorMapEntry classes
colorMap = root.elementsByTagName('sld:ColorMap')
colorMap = colorMap.item(0).toElement()
self.assertFalse(colorMap.isNull())
self.assertEqual(colorMap.attribute('type'), 'intervals')
colorMapEntries = colorMap.elementsByTagName('sld:ColorMapEntry')
self.assertEqual(colorMapEntries.count(), 10)
for index in range(colorMapEntries.count()):
colorMapEntry = colorMapEntries.at(index).toElement()
self.assertEqual(colorMapEntry.attribute('quantity'),
'{}'.format(index))
self.assertEqual(colorMapEntry.attribute('label'),
'{}'.format(index))
self.assertEqual(colorMapEntry.attribute('opacity'), '')
self.assertEqual(colorMapEntry.attribute('color'),
'#{0:02d}{0:02d}{0:02d}'.format(index))
def testSingleBandPseudoColorRenderer_Exact(self):
# get min and max of the band to renderer
bandNo = 3
stats = self.raster_layer.dataProvider().bandStatistics(
bandNo, QgsRasterBandStats.Min | QgsRasterBandStats.Max)
minValue = stats.minimumValue
maxValue = stats.maximumValue
# create shader for the renderer
shader = QgsRasterShader(minValue, maxValue)
colorRampShaderFcn = QgsColorRampShader(minValue, maxValue)
colorRampShaderFcn.setColorRampType(QgsColorRampShader.Exact)
colorRampShaderFcn.setClassificationMode(QgsColorRampShader.Continuous)
colorRampShaderFcn.setClip(True)
items = []
for index in range(10):
items.append(
QgsColorRampShader.ColorRampItem(
index, QColor('#{0:02d}{0:02d}{0:02d}'.format(index)),
"{}".format(index)))
colorRampShaderFcn.setColorRampItemList(items)
shader.setRasterShaderFunction(colorRampShaderFcn)
# create instance to test
rasterRenderer = QgsSingleBandPseudoColorRenderer(
self.raster_layer.dataProvider(), bandNo, shader)
self.raster_layer.setRenderer(rasterRenderer)
# do test
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertNoOpacity(root)
self.assertChannelBand(root, 'sld:GrayChannel', '{}'.format(bandNo))
# check ColorMapEntry classes
colorMap = root.elementsByTagName('sld:ColorMap')
colorMap = colorMap.item(0).toElement()
self.assertFalse(colorMap.isNull())
self.assertEqual(colorMap.attribute('type'), 'values')
self.assertFalse(colorMap.hasAttribute('extendend'))
colorMapEntries = colorMap.elementsByTagName('sld:ColorMapEntry')
self.assertEqual(colorMapEntries.count(), 10)
for index in range(colorMapEntries.count()):
colorMapEntry = colorMapEntries.at(index).toElement()
self.assertEqual(colorMapEntry.attribute('quantity'),
'{}'.format(index))
self.assertEqual(colorMapEntry.attribute('label'),
'{}'.format(index))
self.assertEqual(colorMapEntry.attribute('opacity'), '')
self.assertEqual(colorMapEntry.attribute('color'),
'#{0:02d}{0:02d}{0:02d}'.format(index))
# add check that is set ColoMap extended="true" if colormap is bigger that 255 entries
# !NOTE! can't reuse previous shader => segmentation fault
shader = QgsRasterShader(minValue, maxValue)
colorRampShaderFcn = QgsColorRampShader(minValue, maxValue)
colorRampShaderFcn.setColorRampType(QgsColorRampShader.Exact)
colorRampShaderFcn.setClassificationMode(QgsColorRampShader.Continuous)
colorRampShaderFcn.setClip(True)
items = []
for index in range(255):
items.append(
QgsColorRampShader.ColorRampItem(
index, QColor.fromHsv(index, 255, 255, 255),
"{}".format(index)))
colorRampShaderFcn.setColorRampItemList(items)
shader.setRasterShaderFunction(colorRampShaderFcn)
# create instance to test
rasterRenderer = QgsSingleBandPseudoColorRenderer(
self.raster_layer.dataProvider(), bandNo, shader)
# self.raster_layer.setRenderer(rasterRenderer)
# dom, root = self.rendererToSld(self.raster_layer.renderer())
# self.assertTrue( colorMap.hasAttribute( 'extendend' ) )
# self.assertEqual( colorMap.attribute( 'extendend' ), 'true' )
def testPalettedRasterRenderer(self):
# create 10 color classes
#classesString = '122 0 0 0 255 122\n123 1 1 1 255 123\n124 2 2 2 255 124\n125 3 3 3 255 125\n126 4 4 4 255 126\n127 5 5 5 255 127\n128 6 6 6 255 128\n129 7 7 7 255 129\n130 8 8 8 255 130'
classesString = ''
for index in range(10):
classesString += '{0} {0} {0} {0} 255 {0}\n'.format(index)
classes = QgsPalettedRasterRenderer.classDataFromString(classesString)
rasterRenderer = QgsPalettedRasterRenderer(
self.raster_layer.dataProvider(), 3, classes)
self.raster_layer.setRenderer(rasterRenderer)
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertNoOpacity(root)
self.assertChannelBand(root, 'sld:GrayChannel', '3')
# check ColorMapEntry classes
colorMap = root.elementsByTagName('sld:ColorMap')
colorMap = colorMap.item(0).toElement()
self.assertFalse(colorMap.isNull())
self.assertEqual(colorMap.attribute('type'), 'values')
self.assertFalse(colorMap.hasAttribute('extendend'))
colorMapEntries = colorMap.elementsByTagName('sld:ColorMapEntry')
self.assertEqual(colorMapEntries.count(), 10)
for index in range(colorMapEntries.count()):
colorMapEntry = colorMapEntries.at(index).toElement()
self.assertEqual(colorMapEntry.attribute('quantity'),
'{}'.format(index))
self.assertEqual(colorMapEntry.attribute('label'),
'{}'.format(index))
self.assertEqual(colorMapEntry.attribute('opacity'), '')
self.assertEqual(colorMapEntry.attribute('color'),
'#{0:02d}{0:02d}{0:02d}'.format(index))
# add check that is set ColoMap extended="true" if colormap is bigger that 255 entries
classesString = ''
values = range(255)
for index in range(255):
classesString += '{0} {1} {1} {1} 255 {0}\n'.format(
index, random.choice(values))
classes = QgsPalettedRasterRenderer.classDataFromString(classesString)
rasterRenderer = QgsPalettedRasterRenderer(
self.raster_layer.dataProvider(), 3, classes)
self.raster_layer.setRenderer(rasterRenderer)
dom, root = self.rendererToSld(self.raster_layer.renderer())
colorMap = root.elementsByTagName('sld:ColorMap')
colorMap = colorMap.item(0).toElement()
self.assertTrue(colorMap.hasAttribute('extended'))
self.assertEqual(colorMap.attribute('extended'), 'true')
def testMultiBandColorRenderer(self):
rasterRenderer = QgsMultiBandColorRenderer(
self.raster_layer.dataProvider(), 3, 1, 2)
self.raster_layer.setRenderer(rasterRenderer)
self.raster_layer.setContrastEnhancement(
algorithm=QgsContrastEnhancement.StretchToMinimumMaximum,
limits=QgsRasterMinMaxOrigin.MinMax)
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertNoOpacity(root)
self.assertChannelBand(root, 'sld:RedChannel', '3')
self.assertChannelBand(root, 'sld:GreenChannel', '1')
self.assertChannelBand(root, 'sld:BlueChannel', '2')
def testSingleBandGrayRenderer(self):
# check with StretchToMinimumMaximum
rasterRenderer = QgsSingleBandGrayRenderer(
self.raster_layer.dataProvider(), 3)
self.raster_layer.setRenderer(rasterRenderer)
self.raster_layer.setContrastEnhancement(
algorithm=QgsContrastEnhancement.StretchToMinimumMaximum,
limits=QgsRasterMinMaxOrigin.MinMax)
maximum = self.raster_layer.renderer().contrastEnhancement(
).maximumValue()
minmum = self.raster_layer.renderer().contrastEnhancement(
).minimumValue()
self.assertEqual(minmum, 51)
self.assertEqual(maximum, 172)
# check default values
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertNoOpacity(root)
self.assertChannelBand(root, 'sld:GrayChannel', '3')
elements = root.elementsByTagName('sld:ContrastEnhancement')
self.assertEqual(len(elements), 1)
enhancement = elements.at(0).toElement()
self.assertFalse(enhancement.isNull())
normalize = enhancement.firstChildElement('sld:Normalize')
self.assertFalse(normalize.isNull())
self.assertVendorOption(normalize, 'algorithm',
'StretchToMinimumMaximum')
self.assertVendorOption(normalize, 'minValue', '51')
self.assertVendorOption(normalize, 'maxValue', '172')
elements = root.elementsByTagName('sld:ColorMap')
self.assertEqual(len(elements), 1)
colorMap = elements.at(0).toElement()
self.assertFalse(colorMap.isNull())
colorMapEntries = colorMap.elementsByTagName('sld:ColorMapEntry')
self.assertEqual(len(colorMapEntries), 2)
clorMap1 = colorMapEntries.at(0)
self.assertEqual(clorMap1.attributes().namedItem('color').nodeValue(),
'#000000')
self.assertEqual(
clorMap1.attributes().namedItem('quantity').nodeValue(), '0')
clorMap2 = colorMapEntries.at(1)
self.assertEqual(clorMap2.attributes().namedItem('color').nodeValue(),
'#ffffff')
self.assertEqual(
clorMap2.attributes().namedItem('quantity').nodeValue(), '255')
# check when StretchAndClipToMinimumMaximum
# then min/max have always to be the real one and not that set in the contrastEnhancement
self.raster_layer.setContrastEnhancement(
algorithm=QgsContrastEnhancement.StretchAndClipToMinimumMaximum,
limits=QgsRasterMinMaxOrigin.MinMax)
minmum = self.raster_layer.renderer().contrastEnhancement(
).setMinimumValue(100)
maximum = self.raster_layer.renderer().contrastEnhancement(
).maximumValue()
minmum = self.raster_layer.renderer().contrastEnhancement(
).minimumValue()
self.assertEqual(minmum, 100)
self.assertEqual(maximum, 172)
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertNoOpacity(root)
self.assertChannelBand(root, 'sld:GrayChannel', '3')
elements = root.elementsByTagName('sld:ContrastEnhancement')
self.assertEqual(len(elements), 1)
enhancement = elements.at(0).toElement()
self.assertFalse(enhancement.isNull())
normalize = enhancement.firstChildElement('sld:Normalize')
self.assertFalse(normalize.isNull())
self.assertVendorOption(normalize, 'minValue', '51')
self.assertVendorOption(normalize, 'maxValue', '172')
elements = root.elementsByTagName('sld:ColorMap')
self.assertEqual(len(elements), 1)
colorMap = elements.at(0).toElement()
self.assertFalse(colorMap.isNull())
colorMapEntries = colorMap.elementsByTagName('sld:ColorMapEntry')
self.assertEqual(len(colorMapEntries), 4)
clorMap1 = colorMapEntries.at(0)
self.assertEqual(clorMap1.attributes().namedItem('color').nodeValue(),
'#000000')
self.assertEqual(
clorMap1.attributes().namedItem('quantity').nodeValue(), '100')
self.assertEqual(
clorMap1.attributes().namedItem('opacity').nodeValue(), '0')
clorMap2 = colorMapEntries.at(1)
self.assertEqual(clorMap2.attributes().namedItem('color').nodeValue(),
'#000000')
self.assertEqual(
clorMap2.attributes().namedItem('quantity').nodeValue(), '100')
clorMap3 = colorMapEntries.at(2)
self.assertEqual(clorMap3.attributes().namedItem('color').nodeValue(),
'#ffffff')
self.assertEqual(
clorMap3.attributes().namedItem('quantity').nodeValue(), '172')
clorMap4 = colorMapEntries.at(3)
self.assertEqual(clorMap4.attributes().namedItem('color').nodeValue(),
'#ffffff')
self.assertEqual(
clorMap4.attributes().namedItem('quantity').nodeValue(), '172')
self.assertEqual(
clorMap4.attributes().namedItem('opacity').nodeValue(), '0')
# check when ClipToMinimumMaximum
# then min/max have always to be the real one and not that set in the contrastEnhancement
self.raster_layer.setContrastEnhancement(
algorithm=QgsContrastEnhancement.ClipToMinimumMaximum,
limits=QgsRasterMinMaxOrigin.MinMax)
minmum = self.raster_layer.renderer().contrastEnhancement(
).setMinimumValue(100)
maximum = self.raster_layer.renderer().contrastEnhancement(
).maximumValue()
minmum = self.raster_layer.renderer().contrastEnhancement(
).minimumValue()
self.assertEqual(minmum, 100)
self.assertEqual(maximum, 172)
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertNoOpacity(root)
self.assertChannelBand(root, 'sld:GrayChannel', '3')
elements = root.elementsByTagName('sld:ContrastEnhancement')
self.assertEqual(len(elements), 1)
enhancement = elements.at(0).toElement()
self.assertFalse(enhancement.isNull())
normalize = enhancement.firstChildElement('sld:Normalize')
self.assertFalse(normalize.isNull())
self.assertVendorOption(normalize, 'minValue', '51')
self.assertVendorOption(normalize, 'maxValue', '172')
elements = root.elementsByTagName('sld:ColorMap')
self.assertEqual(len(elements), 1)
colorMap = elements.at(0).toElement()
self.assertFalse(colorMap.isNull())
colorMapEntries = colorMap.elementsByTagName('sld:ColorMapEntry')
self.assertEqual(len(colorMapEntries), 4)
clorMap1 = colorMapEntries.at(0)
self.assertEqual(clorMap1.attributes().namedItem('color').nodeValue(),
'#000000')
self.assertEqual(
clorMap1.attributes().namedItem('quantity').nodeValue(), '100')
self.assertEqual(
clorMap1.attributes().namedItem('opacity').nodeValue(), '0')
clorMap2 = colorMapEntries.at(1)
self.assertEqual(clorMap2.attributes().namedItem('color').nodeValue(),
'#000000')
self.assertEqual(
clorMap2.attributes().namedItem('quantity').nodeValue(), '100')
clorMap3 = colorMapEntries.at(2)
self.assertEqual(clorMap3.attributes().namedItem('color').nodeValue(),
'#ffffff')
self.assertEqual(
clorMap3.attributes().namedItem('quantity').nodeValue(), '172')
clorMap4 = colorMapEntries.at(3)
self.assertEqual(clorMap4.attributes().namedItem('color').nodeValue(),
'#ffffff')
self.assertEqual(
clorMap4.attributes().namedItem('quantity').nodeValue(), '172')
self.assertEqual(
clorMap4.attributes().namedItem('opacity').nodeValue(), '0')
def testRasterRenderer(self):
class fakerenderer(QgsRasterRenderer):
def __init__(self, interface):
QgsRasterRenderer.__init__(self, interface, '')
rasterRenderer = fakerenderer(self.raster_layer.dataProvider())
self.raster_layer.setRenderer(rasterRenderer)
# check opacity default value is not exported
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertNoOpacity(root)
# check if opacity is not the default value
rasterRenderer.setOpacity(1.1)
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertOpacity(root, '1.1')
# check gamma properties from [-100:0] stretched to [0:1]
# and (0:100] stretche dto (1:100]
# dom, root = self.rendererToSld(rasterRenderer, {'contrast': '-100'})
# self.assertGamma(root, '0')
# dom, root = self.rendererToSld(rasterRenderer, {'contrast': '-50'})
# self.assertGamma(root, '0.5')
# dom, root = self.rendererToSld(rasterRenderer, {'contrast': '0'})
# self.assertGamma(root, '1')
# dom, root = self.rendererToSld(rasterRenderer, {'contrast': '1'})
# self.assertGamma(root, '1')
# dom, root = self.rendererToSld(rasterRenderer, {'contrast': '100'})
# self.assertGamma(root, '100')
# # input contrast are always integer, btw the value is managed also if it's double
# dom, root = self.rendererToSld(rasterRenderer, {'contrast': '1.1'})
# self.assertGamma(root, '1.1')
# dom, root = self.rendererToSld(rasterRenderer, {'contrast': '1.6'})
# self.assertGamma(root, '1.6')
# dom, root = self.rendererToSld(rasterRenderer, {'contrast': '-50.5'})
# self.assertGamma(root, '0.495')
# dom, root = self.rendererToSld(rasterRenderer, {'contrast': '-0.1'})
# self.assertGamma(root, '0.999')
def testStretchingAlgorithm(self):
rasterRenderer = QgsMultiBandColorRenderer(
self.raster_layer.dataProvider(), 3, 1, 2)
self.raster_layer.setRenderer(rasterRenderer)
# check StretchToMinimumMaximum stretching alg
self.raster_layer.setContrastEnhancement(
algorithm=QgsContrastEnhancement.StretchToMinimumMaximum,
limits=QgsRasterMinMaxOrigin.MinMax)
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertContrastEnhancement(root, 'sld:RedChannel',
'StretchToMinimumMaximum', '51', '172')
self.assertContrastEnhancement(root, 'sld:GreenChannel',
'StretchToMinimumMaximum', '122', '130')
self.assertContrastEnhancement(root, 'sld:BlueChannel',
'StretchToMinimumMaximum', '133', '148')
# check StretchAndClipToMinimumMaximum stretching alg
self.raster_layer.setContrastEnhancement(
algorithm=QgsContrastEnhancement.StretchAndClipToMinimumMaximum,
limits=QgsRasterMinMaxOrigin.MinMax)
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertContrastEnhancement(root, 'sld:RedChannel', 'ClipToZero',
'51', '172')
self.assertContrastEnhancement(root, 'sld:GreenChannel', 'ClipToZero',
'122', '130')
self.assertContrastEnhancement(root, 'sld:BlueChannel', 'ClipToZero',
'133', '148')
# check ClipToMinimumMaximum stretching alg
self.raster_layer.setContrastEnhancement(
algorithm=QgsContrastEnhancement.ClipToMinimumMaximum,
limits=QgsRasterMinMaxOrigin.MinMax)
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertContrastEnhancement(root, 'sld:RedChannel',
'ClipToMinimumMaximum', '51', '172')
self.assertContrastEnhancement(root, 'sld:GreenChannel',
'ClipToMinimumMaximum', '122', '130')
self.assertContrastEnhancement(root, 'sld:BlueChannel',
'ClipToMinimumMaximum', '133', '148')
# check NoEnhancement stretching alg
self.raster_layer.setContrastEnhancement(
algorithm=QgsContrastEnhancement.NoEnhancement)
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertContrastEnhancement(root, 'sld:RedChannel')
self.assertContrastEnhancement(root, 'sld:GreenChannel')
self.assertContrastEnhancement(root, 'sld:BlueChannel')
def assertVendorOption(self, root, name, expectedValue):
"""Set expectedValue=None to check that the vendor option is not present."""
vendorOptions = root.elementsByTagName('sld:VendorOption')
found = False
for vendorOptionIndex in range(vendorOptions.count()):
vendorOption = vendorOptions.at(vendorOptionIndex)
self.assertEqual('sld:VendorOption', vendorOption.nodeName())
if (vendorOption.attributes().namedItem('name').nodeValue() == name
):
found = True
self.assertEqual(vendorOption.firstChild().nodeValue(),
expectedValue)
if (expectedValue is None) and found:
self.fail(
"found VendorOption: {} where supposed not present".format(
name))
if expectedValue and not found:
self.fail("Not found VendorOption: {}".format(name))
def assertGamma(self, root, expectedValue, index=0):
enhancement = root.elementsByTagName('sld:ContrastEnhancement').item(
index)
gamma = enhancement.firstChildElement('sld:GammaValue')
self.assertEqual(expectedValue, gamma.firstChild().nodeValue())
def assertOpacity(self, root, expectedValue, index=0):
opacity = root.elementsByTagName('sld:Opacity').item(index)
self.assertEqual(expectedValue, opacity.firstChild().nodeValue())
def assertNoOpacity(self, root):
opacities = root.elementsByTagName('sld:Opacity')
self.assertEqual(opacities.size(), 0)
def assertContrastEnhancement(self,
root,
bandTag,
expectedAlg=None,
expectedMin=None,
expectedMax=None,
index=0):
channelSelection = root.elementsByTagName('sld:ChannelSelection').item(
index)
self.assertIsNotNone(channelSelection)
band = channelSelection.firstChildElement(bandTag)
# check if no enhancement alg is iset
if (not expectedAlg):
contrastEnhancementName = band.firstChildElement(
'sld:ContrastEnhancement')
self.assertEqual('',
contrastEnhancementName.firstChild().nodeName())
return
# check if enhancement alg is set
contrastEnhancementName = band.firstChildElement(
'sld:ContrastEnhancement')
self.assertEqual('sld:Normalize',
contrastEnhancementName.firstChild().nodeName())
normalize = contrastEnhancementName.firstChildElement('sld:Normalize')
vendorOptions = normalize.elementsByTagName('VendorOption')
for vendorOptionIndex in range(vendorOptions.count()):
vendorOption = vendorOptions.at(vendorOptionIndex)
self.assertEqual('VendorOption', vendorOption.nodeName())
if (vendorOption.attributes().namedItem('name').nodeValue() ==
'algorithm'):
self.assertEqual(expectedAlg,
vendorOption.firstChild().nodeValue())
elif (vendorOption.attributes().namedItem('name').nodeValue() ==
'minValue'):
self.assertEqual(expectedMin,
vendorOption.firstChild().nodeValue())
elif (vendorOption.attributes().namedItem('name').nodeValue() ==
'maxValue'):
self.assertEqual(expectedMax,
vendorOption.firstChild().nodeValue())
else:
self.fail('Unrecognised vendorOption name {}'.format(
vendorOption.attributes().namedItem('name').nodeValue()))
def assertChannelBand(self, root, bandTag, expectedValue, index=0):
channelSelection = root.elementsByTagName('sld:ChannelSelection').item(
index)
self.assertIsNotNone(channelSelection)
band = channelSelection.firstChildElement(bandTag)
sourceChannelName = band.firstChildElement('sld:SourceChannelName')
self.assertEqual(expectedValue,
sourceChannelName.firstChild().nodeValue())
def rendererToSld(self, renderer, properties={}):
dom = QDomDocument()
root = dom.createElement("FakeRoot")
dom.appendChild(root)
renderer.toSld(dom, root, properties)
return dom, root
class TestQgsLayoutMap(unittest.TestCase, LayoutItemTestCase):
@classmethod
def setUpClass(cls):
cls.item_class = QgsLayoutItemMap
cls.report = "<h1>Python QgsLayoutItemMap Tests</h1>\n"
@classmethod
def tearDownClass(cls):
report_file_path = "%s/qgistest.html" % QDir.tempPath()
with open(report_file_path, 'a') as report_file:
report_file.write(cls.report)
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 layout with layout map
self.layout = QgsLayout(QgsProject.instance())
self.layout.initializeDefaults()
self.map = QgsLayoutItemMap(self.layout)
self.map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
self.map.setFrameEnabled(True)
self.map.setLayers([self.raster_layer])
self.layout.addLayoutItem(self.map)
def testMapCrs(self):
# create layout with layout map
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
layout.initializeDefaults()
# check that new maps inherit project CRS
QgsProject.instance().setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
map.setFrameEnabled(True)
rectangle = QgsRectangle(-13838977, 2369660, -8672298, 6250909)
map.setExtent(rectangle)
map.setLayers([self.vector_layer])
layout.addLayoutItem(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 = QgsLayoutChecker('composermap_crs3857', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
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 = QgsLayoutChecker('composermap_crs4326', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
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 testContainsAdvancedEffects(self):
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
map = QgsLayoutItemMap(layout)
self.assertFalse(map.containsAdvancedEffects())
self.vector_layer.setBlendMode(QPainter.CompositionMode_Darken)
result = map.containsAdvancedEffects()
self.vector_layer.setBlendMode(QPainter.CompositionMode_SourceOver)
self.assertTrue(result)
def testRasterization(self):
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
map = QgsLayoutItemMap(layout)
self.assertFalse(map.requiresRasterization())
self.vector_layer.setBlendMode(QPainter.CompositionMode_Darken)
self.assertFalse(map.requiresRasterization())
self.assertTrue(map.containsAdvancedEffects())
map.setBackgroundEnabled(False)
self.assertTrue(map.requiresRasterization())
map.setBackgroundEnabled(True)
map.setBackgroundColor(QColor(1, 1, 1, 1))
self.assertTrue(map.requiresRasterization())
self.vector_layer.setBlendMode(QPainter.CompositionMode_SourceOver)
def testLabelMargin(self):
"""
Test rendering map item with a label margin set
"""
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(20)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'X'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl",
"memory")
vl.setRenderer(QgsNullSymbolRenderer())
f = QgsFeature(vl.fields(), 1)
for x in range(15):
for y in range(15):
f.setGeometry(QgsPoint(x, y))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
p = QgsProject()
engine_settings = QgsLabelingEngineSettings()
engine_settings.setFlag(QgsLabelingEngineSettings.UsePartialCandidates,
False)
engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly,
True)
p.setLabelingEngineSettings(engine_settings)
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(True)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
layout.addLayoutItem(map)
checker = QgsLayoutChecker('composermap_label_nomargin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
map.setLabelMargin(
QgsLayoutMeasurement(15, QgsUnitTypes.LayoutMillimeters))
checker = QgsLayoutChecker('composermap_label_margin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
map.setLabelMargin(
QgsLayoutMeasurement(3, QgsUnitTypes.LayoutCentimeters))
checker = QgsLayoutChecker('composermap_label_cm_margin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
map.setMapRotation(45)
map.zoomToExtent(vl.extent())
map.setScale(map.scale() * 1.2)
checker = QgsLayoutChecker('composermap_rotated_label_margin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
# data defined
map.setMapRotation(0)
map.zoomToExtent(vl.extent())
map.dataDefinedProperties().setProperty(
QgsLayoutObject.MapLabelMargin, QgsProperty.fromExpression('1+3'))
map.refresh()
checker = QgsLayoutChecker('composermap_dd_label_margin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
def testPartialLabels(self):
"""
Test rendering map item with a show partial labels flag
"""
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(20)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'X'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl",
"memory")
vl.setRenderer(QgsNullSymbolRenderer())
f = QgsFeature(vl.fields(), 1)
for x in range(15):
for y in range(15):
f.setGeometry(QgsPoint(x, y))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
p = QgsProject()
engine_settings = QgsLabelingEngineSettings()
engine_settings.setFlag(QgsLabelingEngineSettings.UsePartialCandidates,
False)
engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly,
True)
p.setLabelingEngineSettings(engine_settings)
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(True)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
layout.addLayoutItem(map)
# default should always be to hide partial labels
self.assertFalse(map.mapFlags() & QgsLayoutItemMap.ShowPartialLabels)
# hiding partial labels (the default)
map.setMapFlags(QgsLayoutItemMap.MapItemFlags())
checker = QgsLayoutChecker('composermap_label_nomargin', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
# showing partial labels
map.setMapFlags(QgsLayoutItemMap.ShowPartialLabels)
checker = QgsLayoutChecker('composermap_show_partial_labels', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
def testBlockingItems(self):
"""
Test rendering map item with blocking items
"""
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(20)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'X'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl",
"memory")
vl.setRenderer(QgsNullSymbolRenderer())
f = QgsFeature(vl.fields(), 1)
for x in range(15):
for y in range(15):
f.setGeometry(QgsPoint(x, y))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
p = QgsProject()
engine_settings = QgsLabelingEngineSettings()
engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly,
True)
p.setLabelingEngineSettings(engine_settings)
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(True)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
map.setId('map')
layout.addLayoutItem(map)
map2 = QgsLayoutItemMap(layout)
map2.attemptSetSceneRect(QRectF(0, 5, 50, 80))
map2.setFrameEnabled(True)
map2.setBackgroundEnabled(False)
map2.setId('map2')
layout.addLayoutItem(map2)
map3 = QgsLayoutItemMap(layout)
map3.attemptSetSceneRect(QRectF(150, 160, 50, 50))
map3.setFrameEnabled(True)
map3.setBackgroundEnabled(False)
map3.setId('map3')
layout.addLayoutItem(map3)
map.addLabelBlockingItem(map2)
map.addLabelBlockingItem(map3)
map.setMapFlags(QgsLayoutItemMap.MapItemFlags())
checker = QgsLayoutChecker('composermap_label_blockers', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
doc = QDomDocument("testdoc")
elem = layout.writeXml(doc, QgsReadWriteContext())
l2 = QgsLayout(p)
self.assertTrue(l2.readXml(elem, doc, QgsReadWriteContext()))
map_restore = [
i for i in l2.items()
if isinstance(i, QgsLayoutItemMap) and i.id() == 'map'
][0]
map2_restore = [
i for i in l2.items()
if isinstance(i, QgsLayoutItemMap) and i.id() == 'map2'
][0]
map3_restore = [
i for i in l2.items()
if isinstance(i, QgsLayoutItemMap) and i.id() == 'map3'
][0]
self.assertTrue(map_restore.isLabelBlockingItem(map2_restore))
self.assertTrue(map_restore.isLabelBlockingItem(map3_restore))
def testTheme(self):
layout = QgsLayout(QgsProject.instance())
map = QgsLayoutItemMap(layout)
self.assertFalse(map.followVisibilityPreset())
self.assertFalse(map.followVisibilityPresetName())
spy = QSignalSpy(map.themeChanged)
map.setFollowVisibilityPresetName('theme')
self.assertFalse(map.followVisibilityPreset())
self.assertEqual(map.followVisibilityPresetName(), 'theme')
# should not be emitted - followVisibilityPreset is False
self.assertEqual(len(spy), 0)
map.setFollowVisibilityPresetName('theme2')
self.assertEqual(map.followVisibilityPresetName(), 'theme2')
self.assertEqual(len(spy), 0)
map.setFollowVisibilityPresetName('')
map.setFollowVisibilityPreset(True)
# should not be emitted - followVisibilityPresetName is empty
self.assertEqual(len(spy), 0)
self.assertFalse(map.followVisibilityPresetName())
self.assertTrue(map.followVisibilityPreset())
map.setFollowVisibilityPresetName('theme')
self.assertEqual(len(spy), 1)
self.assertEqual(spy[-1][0], 'theme')
map.setFollowVisibilityPresetName('theme')
self.assertEqual(len(spy), 1)
map.setFollowVisibilityPresetName('theme2')
self.assertEqual(len(spy), 2)
self.assertEqual(spy[-1][0], 'theme2')
map.setFollowVisibilityPreset(False)
self.assertEqual(len(spy), 3)
self.assertFalse(spy[-1][0])
map.setFollowVisibilityPreset(False)
self.assertEqual(len(spy), 3)
map.setFollowVisibilityPresetName('theme3')
self.assertEqual(len(spy), 3)
map.setFollowVisibilityPreset(True)
self.assertEqual(len(spy), 4)
self.assertEqual(spy[-1][0], 'theme3')
map.setFollowVisibilityPreset(True)
self.assertEqual(len(spy), 4)
# data defined theme
map.dataDefinedProperties().setProperty(
QgsLayoutObject.MapStylePreset, QgsProperty.fromValue('theme4'))
map.refresh()
self.assertEqual(len(spy), 5)
self.assertEqual(spy[-1][0], 'theme4')
map.refresh()
self.assertEqual(len(spy), 5)
map.dataDefinedProperties().setProperty(
QgsLayoutObject.MapStylePreset, QgsProperty.fromValue('theme6'))
map.refresh()
self.assertEqual(len(spy), 6)
self.assertEqual(spy[-1][0], 'theme6')
def testClipping(self):
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(30)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'XXXX'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Polygon?crs=epsg:4326&field=id:integer", "vl",
"memory")
props = {
"color": "127,255,127",
'outline_style': 'solid',
'outline_width': '1',
'outline_color': '0,0,255'
}
fillSymbol = QgsFillSymbol.createSimple(props)
renderer = QgsSingleSymbolRenderer(fillSymbol)
vl.setRenderer(renderer)
f = QgsFeature(vl.fields(), 1)
for x in range(0, 15, 3):
for y in range(0, 15, 3):
f.setGeometry(QgsGeometry(QgsPoint(x, y)).buffer(1, 3))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
p = QgsProject()
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(False)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
layout.addLayoutItem(map)
shape = QgsLayoutItemShape(layout)
layout.addLayoutItem(shape)
shape.setShapeType(QgsLayoutItemShape.Ellipse)
shape.attemptSetSceneRect(QRectF(10, 10, 180, 180))
props = {"color": "0,0,0,0", 'outline_style': 'no'}
fillSymbol = QgsFillSymbol.createSimple(props)
shape.setSymbol(fillSymbol)
map.itemClippingSettings().setEnabled(True)
map.itemClippingSettings().setSourceItem(shape)
map.itemClippingSettings().setForceLabelsInsideClipPath(False)
map.itemClippingSettings().setFeatureClippingType(
QgsMapClippingRegion.FeatureClippingType.ClipToIntersection)
checker = QgsLayoutChecker('composermap_itemclip', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
def testClippingForceLabelsInside(self):
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(30)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'XXXX'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Polygon?crs=epsg:4326&field=id:integer", "vl",
"memory")
props = {
"color": "127,255,127",
'outline_style': 'solid',
'outline_width': '1',
'outline_color': '0,0,255'
}
fillSymbol = QgsFillSymbol.createSimple(props)
renderer = QgsSingleSymbolRenderer(fillSymbol)
vl.setRenderer(renderer)
f = QgsFeature(vl.fields(), 1)
for x in range(0, 15, 3):
for y in range(0, 15, 3):
f.setGeometry(QgsGeometry(QgsPoint(x, y)).buffer(1, 3))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
p = QgsProject()
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(False)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
layout.addLayoutItem(map)
shape = QgsLayoutItemShape(layout)
layout.addLayoutItem(shape)
shape.setShapeType(QgsLayoutItemShape.Ellipse)
shape.attemptSetSceneRect(QRectF(10, 10, 180, 180))
props = {"color": "0,0,0,0", 'outline_style': 'no'}
fillSymbol = QgsFillSymbol.createSimple(props)
shape.setSymbol(fillSymbol)
map.itemClippingSettings().setEnabled(True)
map.itemClippingSettings().setSourceItem(shape)
map.itemClippingSettings().setForceLabelsInsideClipPath(True)
map.itemClippingSettings().setFeatureClippingType(
QgsMapClippingRegion.FeatureClippingType.ClipPainterOnly)
checker = QgsLayoutChecker('composermap_itemclip_force_labels_inside',
layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
def testClippingOverview(self):
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(30)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'XXXX'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Polygon?crs=epsg:4326&field=id:integer", "vl",
"memory")
props = {
"color": "127,255,127",
'outline_style': 'solid',
'outline_width': '1',
'outline_color': '0,0,255'
}
fillSymbol = QgsFillSymbol.createSimple(props)
renderer = QgsSingleSymbolRenderer(fillSymbol)
vl.setRenderer(renderer)
f = QgsFeature(vl.fields(), 1)
for x in range(0, 15, 3):
for y in range(0, 15, 3):
f.setGeometry(QgsGeometry(QgsPoint(x, y)).buffer(1, 3))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
vl2 = vl.clone()
vl2.setLabelsEnabled(False)
p = QgsProject()
p.addMapLayer(vl)
p.addMapLayer(vl2)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(False)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
layout.addLayoutItem(map)
map2 = QgsLayoutItemMap(layout)
map2.attemptSetSceneRect(QRectF(160, 150, 70, 70))
map2.setFrameEnabled(True)
map2extent = vl.extent()
map2extent.grow(3)
map2.zoomToExtent(map2extent)
map2.setLayers([vl2])
layout.addLayoutItem(map2)
overview = QgsLayoutItemMapOverview("t", map2)
overview.setLinkedMap(map)
props = {
"color": "0,0,0,0",
'outline_style': 'solid',
'outline_width': '1',
'outline_color': '0,0,255'
}
fillSymbol = QgsFillSymbol.createSimple(props)
overview.setFrameSymbol(fillSymbol)
map2.overviews().addOverview(overview)
shape = QgsLayoutItemShape(layout)
layout.addLayoutItem(shape)
shape.setShapeType(QgsLayoutItemShape.Ellipse)
shape.attemptSetSceneRect(QRectF(10, 10, 180, 180))
props = {"color": "0,0,0,0", 'outline_style': 'no'}
fillSymbol = QgsFillSymbol.createSimple(props)
shape.setSymbol(fillSymbol)
map.itemClippingSettings().setEnabled(True)
map.itemClippingSettings().setSourceItem(shape)
map.itemClippingSettings().setForceLabelsInsideClipPath(False)
map.itemClippingSettings().setFeatureClippingType(
QgsMapClippingRegion.FeatureClippingType.ClipToIntersection)
checker = QgsLayoutChecker('composermap_itemclip_overview', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
def testClippingHideClipSource(self):
"""
When an item is set to be the clip source, it shouldn't render anything itself
"""
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(30)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'XXXX'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Polygon?crs=epsg:4326&field=id:integer", "vl",
"memory")
props = {
"color": "127,255,127",
'outline_style': 'solid',
'outline_width': '1',
'outline_color': '0,0,255'
}
fillSymbol = QgsFillSymbol.createSimple(props)
renderer = QgsSingleSymbolRenderer(fillSymbol)
vl.setRenderer(renderer)
f = QgsFeature(vl.fields(), 1)
for x in range(0, 15, 3):
for y in range(0, 15, 3):
f.setGeometry(QgsGeometry(QgsPoint(x, y)).buffer(1, 3))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
p = QgsProject()
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(False)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
layout.addLayoutItem(map)
shape = QgsLayoutItemShape(layout)
layout.addLayoutItem(shape)
shape.setShapeType(QgsLayoutItemShape.Ellipse)
shape.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.itemClippingSettings().setEnabled(True)
map.itemClippingSettings().setSourceItem(shape)
map.itemClippingSettings().setForceLabelsInsideClipPath(False)
map.itemClippingSettings().setFeatureClippingType(
QgsMapClippingRegion.FeatureClippingType.ClipToIntersection)
checker = QgsLayoutChecker('composermap_itemclip_nodrawsource', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
def testClippingBackgroundFrame(self):
"""
Make sure frame/background are also clipped
"""
vl = QgsVectorLayer("Polygon?crs=epsg:4326&field=id:integer", "vl",
"memory")
props = {
"color": "127,255,127",
'outline_style': 'solid',
'outline_width': '1',
'outline_color': '0,0,255'
}
fillSymbol = QgsFillSymbol.createSimple(props)
renderer = QgsSingleSymbolRenderer(fillSymbol)
vl.setRenderer(renderer)
f = QgsFeature(vl.fields(), 1)
for x in range(0, 15, 3):
for y in range(0, 15, 3):
f.setGeometry(QgsGeometry(QgsPoint(x, y)).buffer(1, 3))
vl.dataProvider().addFeature(f)
p = QgsProject()
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(True)
map.setFrameStrokeWidth(
QgsLayoutMeasurement(2, QgsUnitTypes.LayoutMillimeters))
map.setBackgroundEnabled(True)
map.setBackgroundColor(QColor(200, 255, 200))
map.zoomToExtent(vl.extent())
map.setLayers([vl])
layout.addLayoutItem(map)
shape = QgsLayoutItemShape(layout)
layout.addLayoutItem(shape)
shape.setShapeType(QgsLayoutItemShape.Ellipse)
shape.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.itemClippingSettings().setEnabled(True)
map.itemClippingSettings().setSourceItem(shape)
map.itemClippingSettings().setFeatureClippingType(
QgsMapClippingRegion.FeatureClippingType.ClipPainterOnly)
checker = QgsLayoutChecker('composermap_itemclip_background', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
def testMainAnnotationLayer(self):
"""
Make sure main annotation layer is rendered in maps above all other layers
"""
p = QgsProject()
vl = QgsVectorLayer("Polygon?crs=epsg:4326&field=fldtxt:string",
"layer", "memory")
sym3 = QgsFillSymbol.createSimple({'color': '#b200b2'})
vl.renderer().setSymbol(sym3)
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(True)
map.setFrameStrokeWidth(
QgsLayoutMeasurement(2, QgsUnitTypes.LayoutMillimeters))
map.setBackgroundEnabled(True)
map.setBackgroundColor(QColor(200, 255, 200))
map.zoomToExtent(QgsRectangle(10, 30, 20, 35))
map.setLayers([vl])
layout.addLayoutItem(map)
# add polygon to layer
f = QgsFeature()
f.setGeometry(QgsGeometry.fromRect(QgsRectangle(5, 25, 25, 45)))
self.assertTrue(vl.dataProvider().addFeatures([f]))
# no annotation yet...
checker = QgsLayoutChecker('composermap_annotation_empty', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
annotation_layer = p.mainAnnotationLayer()
annotation_layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
annotation_geom = QgsGeometry.fromRect(QgsRectangle(12, 30, 18, 33))
annotation = QgsAnnotationPolygonItem(
annotation_geom.constGet().clone())
sym3 = QgsFillSymbol.createSimple({
'color': '#ff0000',
'outline_style': 'no'
})
annotation.setSymbol(sym3)
annotation_layer.addItem(annotation)
# annotation must be drawn above map layers
checker = QgsLayoutChecker('composermap_annotation_item', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
def testCrsChanged(self):
"""
Test that the CRS changed signal is emitted in the right circumstances
"""
p = QgsProject()
layout = QgsLayout(p)
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
spy = QSignalSpy(map.crsChanged)
# map has no explicit crs set, so follows project crs => signal should be emitted
# when project crs is changed
p.setCrs(QgsCoordinateReferenceSystem('EPSG:3111'))
self.assertEqual(len(spy), 1)
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
self.assertEqual(len(spy), 2)
# set explicit crs on map item
map.setCrs(QgsCoordinateReferenceSystem('EPSG:28356'))
self.assertEqual(len(spy), 3)
map.setCrs(QgsCoordinateReferenceSystem('EPSG:28356'))
self.assertEqual(len(spy), 3)
map.setCrs(QgsCoordinateReferenceSystem('EPSG:28355'))
self.assertEqual(len(spy), 4)
# should not care about project crs changes anymore..
p.setCrs(QgsCoordinateReferenceSystem('EPSG:3111'))
self.assertEqual(len(spy), 4)
# set back to project crs
map.setCrs(QgsCoordinateReferenceSystem())
self.assertEqual(len(spy), 5)
map.setCrs(QgsCoordinateReferenceSystem('EPSG:28355'))
self.assertEqual(len(spy), 6)
# data defined crs
map.dataDefinedProperties().setProperty(
QgsLayoutObject.MapCrs, QgsProperty.fromValue('EPSG:4283'))
self.assertEqual(len(spy), 6)
map.refresh()
self.assertEqual(len(spy), 7)
def testMapSettingsDpiTarget(self):
"""
Test that the CRS changed signal is emitted in the right circumstances
"""
p = QgsProject()
layout = QgsLayout(p)
layout.renderContext().setDpi(111.1)
map = QgsLayoutItemMap(layout)
ms = map.mapSettings(QgsRectangle(0, 0, 1, 1), QSizeF(10, 10), 96,
False)
self.assertEqual(ms.dpiTarget(), 111.1)
class MinimalPlugin:
def __init__(self, iface):
self.iface = iface
self.project = QgsProject.instance()
def initGui(self):
self.action = QAction('Init_data!', self.iface.mainWindow())
self.action.triggered.connect(self.run)
self.iface.addToolBarIcon(self.action)
self.action2 = QAction('Convert to colormap!', self.iface.mainWindow())
self.action2.triggered.connect(self.colormap)
self.iface.addToolBarIcon(self.action2)
self.action3 = QAction('Add points!', self.iface.mainWindow())
self.action3.triggered.connect(self.points)
self.iface.addToolBarIcon(self.action3)
def unload(self):
self.iface.removeToolBarIcon(self.action)
del self.action
def run(self):
self.project.read('C:/Users/william/Documents/Qgis/example.qgs')
#project = QgsProject.instance()
path_to_tif = os.path.join(QgsProject.instance().homePath(),
"qgis_sample_data", "raster",
"SR_50M_alaska_nad.TIF")
self.rlayer = QgsRasterLayer(path_to_tif)
if not self.rlayer.isValid():
print("Layer failed to load!")
QgsProject.instance().addMapLayer(self.rlayer)
QMessageBox.information(None, 'Example:', 'Data is loaded!')
def colormap(self):
self.project.read('C:/Users/william/Documents/Qgis/example.qgs')
#project = QgsProject.instance()
path_to_tif = os.path.join(QgsProject.instance().homePath(),
"qgis_sample_data", "raster",
"SR_50M_alaska_nad.TIF")
self.rlayer = QgsRasterLayer(path_to_tif)
fcn = QgsColorRampShader()
fcn.setColorRampType(QgsColorRampShader.Interpolated)
lst = [
QgsColorRampShader.ColorRampItem(0, QColor(0, 25, 25)),
QgsColorRampShader.ColorRampItem(255, QColor(255, 255, 0))
]
fcn.setColorRampItemList(lst)
shader = QgsRasterShader()
shader.setRasterShaderFunction(fcn)
renderer = QgsSingleBandPseudoColorRenderer(self.rlayer.dataProvider(),
1, shader)
self.rlayer.setRenderer(renderer)
QgsProject.instance().addMapLayer(self.rlayer)
QgsProject.instance().layerTreeRoot()
QMessageBox.information(None, 'Example:', 'Colormap is loaded!')
def points(self):
path_to_ports_layer = os.path.join(QgsProject.instance().homePath(),
"qgis_sample_data", "climate",
"climate.shp")
vlayer = QgsVectorLayer(path_to_ports_layer)
if not vlayer.isValid():
print("Layer failed to load!")
QgsProject.instance().addMapLayer(vlayer)
class TestQgsBlendModes(TestCase):
def __init__(self, methodName):
"""Run once on class initialisation."""
unittest.TestCase.__init__(self, methodName)
# initialize class MapRegistry, Canvas, MapRenderer, Map and PAL
self.mMapRegistry = QgsMapLayerRegistry.instance()
# create point layer
myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp')
self.mPointLayer = QgsVectorLayer(myShpFile, 'Points', 'ogr')
self.mMapRegistry.addMapLayer(self.mPointLayer)
self.mSimplifyMethod = QgsVectorSimplifyMethod() ;
self.mSimplifyMethod.setSimplifyHints(QgsVectorSimplifyMethod.NoSimplification);
# create polygon layer
myShpFile = os.path.join(TEST_DATA_DIR, 'polys.shp')
self.mPolygonLayer = QgsVectorLayer(myShpFile, 'Polygons', 'ogr')
self.mPolygonLayer.setSimplifyMethod(self.mSimplifyMethod)
self.mMapRegistry.addMapLayer(self.mPolygonLayer)
# create line layer
myShpFile = os.path.join(TEST_DATA_DIR, 'lines.shp')
self.mLineLayer = QgsVectorLayer(myShpFile, 'Lines', 'ogr')
self.mLineLayer.setSimplifyMethod(self.mSimplifyMethod)
self.mMapRegistry.addMapLayer(self.mLineLayer)
# create two raster layers
myRasterFile = os.path.join(TEST_DATA_DIR, 'landsat.tif')
self.mRasterLayer1 = QgsRasterLayer(myRasterFile, "raster1")
self.mRasterLayer2 = QgsRasterLayer(myRasterFile, "raster2")
myMultiBandRenderer1 = QgsMultiBandColorRenderer(self.mRasterLayer1.dataProvider(), 2, 3, 4)
self.mRasterLayer1.setRenderer(myMultiBandRenderer1)
self.mMapRegistry.addMapLayer(self.mRasterLayer1)
myMultiBandRenderer2 = QgsMultiBandColorRenderer(self.mRasterLayer2.dataProvider(), 2, 3, 4)
self.mRasterLayer2.setRenderer(myMultiBandRenderer2)
self.mMapRegistry.addMapLayer(self.mRasterLayer2)
# to match blend modes test comparisons background
self.mCanvas = CANVAS
self.mCanvas.setCanvasColor(QColor(152, 219, 249))
self.mMap = self.mCanvas.map()
self.mMap.resize(QSize(400, 400))
self.mapSettings = self.mCanvas.mapSettings()
self.mapSettings.setOutputSize(QSize(400, 400))
def testVectorBlending(self):
"""Test that blend modes work for vector layers."""
#Add vector layers to map
myLayers = []
myLayers.append(self.mLineLayer.id())
myLayers.append(self.mPolygonLayer.id())
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.mPointLayer.extent())
#Set blending modes for both layers
self.mLineLayer.setBlendMode(QPainter.CompositionMode_Difference)
self.mPolygonLayer.setBlendMode(QPainter.CompositionMode_Difference)
checker = QgsRenderChecker()
checker.setControlName("expected_vector_blendmodes")
checker.setMapSettings(self.mapSettings)
myResult = checker.runTest("vector_blendmodes");
myMessage = ('vector blending failed')
assert myResult, myMessage
#Reset layers
self.mLineLayer.setBlendMode(QPainter.CompositionMode_SourceOver)
self.mPolygonLayer.setBlendMode(QPainter.CompositionMode_SourceOver)
def testVectorFeatureBlending(self):
"""Test that feature blend modes work for vector layers."""
#Add vector layers to map
myLayers = []
myLayers.append(self.mLineLayer.id())
myLayers.append(self.mPolygonLayer.id())
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.mPointLayer.extent())
#Set feature blending for line layer
self.mLineLayer.setFeatureBlendMode(QPainter.CompositionMode_Plus)
checker = QgsRenderChecker()
checker.setControlName("expected_vector_featureblendmodes")
checker.setMapSettings(self.mapSettings)
myResult = checker.runTest("vector_featureblendmodes");
myMessage = ('vector feature blending failed')
assert myResult, myMessage
#Reset layers
self.mLineLayer.setFeatureBlendMode(QPainter.CompositionMode_SourceOver)
def testVectorLayerTransparency(self):
"""Test that layer transparency works for vector layers."""
#Add vector layers to map
myLayers = []
myLayers.append(self.mLineLayer.id())
myLayers.append(self.mPolygonLayer.id())
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.mPointLayer.extent())
#Set feature blending for line layer
self.mLineLayer.setLayerTransparency( 50 )
checker = QgsRenderChecker()
checker.setControlName("expected_vector_layertransparency")
checker.setMapSettings(self.mapSettings)
myResult = checker.runTest("vector_layertransparency");
myMessage = ('vector layer transparency failed')
assert myResult, myMessage
def testRasterBlending(self):
"""Test that blend modes work for raster layers."""
#Add raster layers to map
myLayers = []
myLayers.append(self.mRasterLayer1.id())
myLayers.append(self.mRasterLayer2.id())
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.mRasterLayer1.extent())
#Set blending mode for top layer
self.mRasterLayer1.setBlendMode(QPainter.CompositionMode_Plus)
checker = QgsRenderChecker()
checker.setControlName("expected_raster_blendmodes")
checker.setMapSettings(self.mapSettings)
myResult = checker.runTest("raster_blendmodes");
myMessage = ('raster blending failed')
assert myResult, myMessage
class TestQgsLayoutMap(unittest.TestCase, LayoutItemTestCase):
@classmethod
def setUpClass(cls):
cls.item_class = QgsLayoutItemMap
def setUp(self):
self.report = "<h1>Python QgsLayoutItemMap Tests</h1>\n"
def tearDown(self):
report_file_path = "%s/qgistest.html" % QDir.tempPath()
with open(report_file_path, 'a') as report_file:
report_file.write(self.report)
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 layout with layout map
self.layout = QgsLayout(QgsProject.instance())
self.layout.initializeDefaults()
self.map = QgsLayoutItemMap(self.layout)
self.map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
self.map.setFrameEnabled(True)
self.map.setLayers([self.raster_layer])
self.layout.addLayoutItem(self.map)
def testOverviewMap(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
checker = QgsLayoutChecker('composermap_overview', self.layout)
checker.setColorTolerance(6)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
assert myTestResult, myMessage
def testOverviewMapBlend(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
overviewMap.overview().setBlendMode(QPainter.CompositionMode_Multiply)
checker = QgsLayoutChecker('composermap_overview_blending',
self.layout)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
assert myTestResult, myMessage
def testOverviewMapInvert(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
overviewMap.overview().setInverted(True)
checker = QgsLayoutChecker('composermap_overview_invert', self.layout)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
assert myTestResult, myMessage
def testOverviewMapCenter(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(192, -288, 320, -224)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
overviewMap.overview().setInverted(False)
overviewMap.overview().setCentered(True)
checker = QgsLayoutChecker('composermap_overview_center', self.layout)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
assert myTestResult, myMessage
def testMapCrs(self):
# create layout with layout map
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
layout.initializeDefaults()
# check that new maps inherit project CRS
QgsProject.instance().setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
map.setFrameEnabled(True)
rectangle = QgsRectangle(-13838977, 2369660, -8672298, 6250909)
map.setExtent(rectangle)
map.setLayers([self.vector_layer])
layout.addLayoutItem(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 = QgsLayoutChecker('composermap_crs3857', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
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 = QgsLayoutChecker('composermap_crs4326', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
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 testContainsAdvancedEffects(self):
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
map = QgsLayoutItemMap(layout)
self.assertFalse(map.containsAdvancedEffects())
self.vector_layer.setBlendMode(QPainter.CompositionMode_Darken)
result = map.containsAdvancedEffects()
self.vector_layer.setBlendMode(QPainter.CompositionMode_SourceOver)
self.assertTrue(result)
def testRasterization(self):
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
map = QgsLayoutItemMap(layout)
self.assertFalse(map.requiresRasterization())
self.vector_layer.setBlendMode(QPainter.CompositionMode_Darken)
self.assertFalse(map.requiresRasterization())
self.assertTrue(map.containsAdvancedEffects())
map.setBackgroundEnabled(False)
self.assertTrue(map.requiresRasterization())
map.setBackgroundEnabled(True)
map.setBackgroundColor(QColor(1, 1, 1, 1))
self.assertTrue(map.requiresRasterization())
self.vector_layer.setBlendMode(QPainter.CompositionMode_SourceOver)
def testPaletted(self):
""" test paletted raster renderer with raster with color table"""
path = os.path.join(unitTestDataPath('raster'),
'with_color_table.tif')
info = QFileInfo(path)
base_name = info.baseName()
layer = QgsRasterLayer(path, base_name)
self.assertTrue(layer.isValid(), 'Raster not loaded: {}'.format(path))
renderer = QgsPalettedRasterRenderer(layer.dataProvider(), 1,
[QgsPalettedRasterRenderer.Class(1, QColor(0, 255, 0), 'class 2'),
QgsPalettedRasterRenderer.Class(3, QColor(255, 0, 0), 'class 1')])
self.assertEqual(renderer.nColors(), 2)
self.assertEqual(renderer.usesBands(), [1])
# test labels
self.assertEqual(renderer.label(1), 'class 2')
self.assertEqual(renderer.label(3), 'class 1')
self.assertFalse(renderer.label(101))
# test legend symbology - should be sorted by value
legend = renderer.legendSymbologyItems()
self.assertEqual(legend[0][0], 'class 2')
self.assertEqual(legend[1][0], 'class 1')
self.assertEqual(legend[0][1].name(), '#00ff00')
self.assertEqual(legend[1][1].name(), '#ff0000')
# test retrieving classes
classes = renderer.classes()
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[1].value, 3)
self.assertEqual(classes[0].label, 'class 2')
self.assertEqual(classes[1].label, 'class 1')
self.assertEqual(classes[0].color.name(), '#00ff00')
self.assertEqual(classes[1].color.name(), '#ff0000')
# test set label
# bad index
renderer.setLabel(1212, 'bad')
renderer.setLabel(3, 'new class')
self.assertEqual(renderer.label(3), 'new class')
# color ramp
r = QgsLimitedRandomColorRamp(5)
renderer.setSourceColorRamp(r)
self.assertEqual(renderer.sourceColorRamp().type(), 'random')
self.assertEqual(renderer.sourceColorRamp().count(), 5)
# clone
new_renderer = renderer.clone()
classes = new_renderer.classes()
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[1].value, 3)
self.assertEqual(classes[0].label, 'class 2')
self.assertEqual(classes[1].label, 'new class')
self.assertEqual(classes[0].color.name(), '#00ff00')
self.assertEqual(classes[1].color.name(), '#ff0000')
self.assertEqual(new_renderer.sourceColorRamp().type(), 'random')
self.assertEqual(new_renderer.sourceColorRamp().count(), 5)
# write to xml and read
doc = QDomDocument('testdoc')
elem = doc.createElement('qgis')
renderer.writeXml(doc, elem)
restored = QgsPalettedRasterRenderer.create(elem.firstChild().toElement(), layer.dataProvider())
self.assertTrue(restored)
self.assertEqual(restored.usesBands(), [1])
classes = restored.classes()
self.assertTrue(classes)
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[1].value, 3)
self.assertEqual(classes[0].label, 'class 2')
self.assertEqual(classes[1].label, 'new class')
self.assertEqual(classes[0].color.name(), '#00ff00')
self.assertEqual(classes[1].color.name(), '#ff0000')
self.assertEqual(restored.sourceColorRamp().type(), 'random')
self.assertEqual(restored.sourceColorRamp().count(), 5)
# render test
layer.setRenderer(renderer)
ms = QgsMapSettings()
ms.setLayers([layer])
ms.setExtent(layer.extent())
checker = QgsRenderChecker()
checker.setControlName("expected_paletted_renderer")
checker.setMapSettings(ms)
self.assertTrue(checker.runTest("expected_paletted_renderer"), "Paletted rendering test failed")
def run(self):
try:
processing.run(
"gdal:rasterize", {
'INPUT': self.layer_sol,
'FIELD': self.field_sol,
'HEIGHT': self.raster_info['resolution_y'],
'WIDTH': self.raster_info['resolution_x'],
'UNITS': 1,
'EXTENT': self.raster_info['extent']['str_extent'],
'OUTPUT': os.path.join(self.doss, 'rSol.tif')
})
processing.run(
"grass7:r.resample", {
'input':
self.layer_zns,
'GRASS_REGION_PARAMETER':
self.raster_info['extent']['str_extent'],
'GRASS_REGION_CELLSIZE_PARAMETER':
self.raster_info['resolution_x'],
'output':
os.path.join(self.doss, 'rZNS.tif')
})
if self.layer_epikarst is None:
pass
else:
processing.run(
"gdal:rasterize", {
'INPUT': self.layer_epikarst,
'FIELD': self.field_epikarst,
'HEIGHT': self.raster_info['resolution_y'],
'WIDTH': self.raster_info['resolution_x'],
'UNITS': 1,
'EXTENT': self.raster_info['extent']['str_extent'],
'OUTPUT': os.path.join(self.doss, 'rEpikarst.tif')
})
if self.layer_sinking is None:
pass
else:
processing.run(
"gdal:rasterize", {
'INPUT': self.layer_sinking,
'FIELD': self.field_sinking,
'HEIGHT': self.raster_info['resolution_y'],
'WIDTH': self.raster_info['resolution_x'],
'UNITS': 1,
'EXTENT': self.raster_info['extent']['str_extent'],
'OUTPUT': os.path.join(self.doss, 'rSinking.tif')
})
# Preparation des donnees pour la comparaison des valeurs des rasters sur chaque pixel
val_i = range(0, self.raster_info['size_x'], 1)
val_j = range(0, self.raster_info['size_y'], 1)
if self.layer_epikarst is None:
pass
else:
rEpikarst = QgsRasterLayer(
os.path.join(self.doss, 'rEpikarst.tif'), 'rEpikarst')
pEpikarst = rEpikarst.dataProvider()
if self.layer_sinking is None:
pass
else:
rSinking = QgsRasterLayer(
os.path.join(self.doss, 'rSinking.tif'), 'rSinking')
pSinking = rSinking.dataProvider()
rZNS = QgsRasterLayer(os.path.join(self.doss, 'rZNS.tif'), 'rZNS')
pZNS = rZNS.dataProvider()
rSol = QgsRasterLayer(os.path.join(self.doss, 'rSol.tif'), 'rSol')
pSol = rSol.dataProvider()
# iteration sur les pixels: selection de la valeur la plus faible et ecriture dans l'array
ValCarteP = numpy.zeros(
(self.raster_info['size_y'], self.raster_info['size_x']),
numpy.int16)
for j in val_j:
self.progress.emit(j, len(val_j))
for i in val_i:
valeur = []
pos = QgsPointXY(
(self.raster_info['extent']['Xmin'] +
(i + 1) * self.raster_info['resolution_x']) -
self.raster_info['resolution_x'] / 2,
(self.raster_info['extent']['Ymax'] -
j * self.raster_info['resolution_y']) -
self.raster_info['resolution_y'] / 2)
if self.layer_sol is None:
valSol = 6
else:
valSol, found = pSol.sample(pos, 1)
if not found or valSol == 0:
valSol = 6
if self.layer_zns is None:
valZNS = 6
else:
valZNS, found = pZNS.sample(pos, 1)
if not found or valZNS == 0:
valZNS = 6
if self.layer_epikarst is None:
valEpikarst = 6
else:
valEpikarst, found = pEpikarst.sample(pos, 1)
if not found or valEpikarst == 0:
valEpikarst = 6
if self.layer_sinking is None:
valSinking = 6
else:
valSinking, found = pSinking.sample(pos, 1)
if not found or valSinking == 0:
valSinking = 6
valeur.append(valSol)
valeur.append(valZNS)
valeur.append(valEpikarst)
valeur.append(valSinking)
ValCarteP[j, i] = min(valeur)
# ecriture du raster a partir de l'array
raster = gdal.GetDriverByName('Gtiff').Create(
os.path.join(self.doss,
'P_factor.tif'), self.raster_info['size_x'],
self.raster_info['size_y'], 1, gdal.GDT_Byte)
# proj = osr.SpatialReference()
# proj.ImportFromWkt(raster_info['projection_wkt'])
raster.SetProjection(self.raster_info['projection_wkt'])
raster.SetGeoTransform((
self.raster_info['extent']['Xmin'],
float(self.raster_info['resolution_x']),
0.0,
self.raster_info['extent']['Ymax'],
0.0,
float(-self.raster_info['resolution_y']),
))
Band = raster.GetRasterBand(1)
Band.WriteArray(ValCarteP, 0, 0)
Band.FlushCache()
Band.SetNoDataValue(6)
# fermeture des connexions
rSol = None
rSinking = None
rZNS = None
rEpikarst = None
raster = None
self.results.emit()
except Exception as e:
self.error.emit(
Exception('An error happen when generating the P Factor: %s' %
str(e)))
finally:
self.finished.emit()
def calcularArea(
self, clasesMuestras
): #Calcula el area de la superficie del mapa de covertura del suelo (Raster o Vector)
error = True
self.reultados.append("Inicia proceso de cálculo de áreas")
idLayerQg = self.itemSuperficie.currentData()
if (idLayerQg == 1):
if str(os.path.splitext(
self.rutaCSVSuperficie)[1]) == ".tif" or str(
os.path.splitext(self.rutaCSVSuperficie)[1]) == ".TIF":
layerArea = QgsRasterLayer(self.rutaCSVSuperficie,
"aleatorios", "gdal")
else:
layerArea = QgsVectorLayer(self.rutaCSVSuperficie,
"aleatorios", "ogr")
else:
layerArea = QgsProject.instance().mapLayer(str(idLayerQg))
if str(layerArea.type()) == "QgsMapLayerType.VectorLayer":
features = layerArea.getFeatures()
clases = self.columClase.currentText()
features = layerArea.getFeatures()
field = [f[clases] for f in features]
Clasesunicas = np.unique(np.array(field))
matrizAreaClass = np.empty((len(Clasesunicas), 2)).astype(str)
if (len(clasesMuestras) == len(Clasesunicas)):
#print(sorted(np.array(clasesMuestras).astype(str)))
#print(sorted(np.array(Clasesunicas).astype(str)))
classMapa = sorted(np.array(Clasesunicas).astype(str))
classMuestras = sorted(np.array(clasesMuestras).astype(str))
x = np.array_equal(classMuestras, classMapa)
if (x):
i = 0
self.reultados.append("Áreas por clase:")
for clase in Clasesunicas:
expr = QgsExpression("\"{}\"='{}'".format(
clases, clase))
clasesArea = layerArea.getFeatures(
QgsFeatureRequest(expr))
suma = 0
for areas in clasesArea:
ha = areas.geometry().area() / 10000
suma = suma + ha
matrizAreaClass[i][0] = str(clase)
matrizAreaClass[i][1] = str(round(float(str(suma)), 0))
self.reultados.append(
str(matrizAreaClass[i][0]) + ": \t" +
str(matrizAreaClass[i][1]))
i += 1
else:
QMessageBox.information(
self, "Error",
"Hay clases que no coinciden en vector de muestras y mapa temático",
QMessageBox.Ok)
error = False
matrizAreaClass = 0
else:
QMessageBox.information(
self, "Error",
"Las clases del vector de muestras no tiene la misma cantidad de clases que el mapa temático",
QMessageBox.Ok)
error = False
matrizAreaClass = 0
else:
pathRaster = layerArea.dataProvider().dataSourceUri()
data = gdal.Open(pathRaster, gdal.GA_ReadOnly)
getProjec = data.GetProjection()
encontrarMetros = getProjec.find("metre")
if encontrarMetros != -1:
clasesNew = []
geotr = data.GetGeoTransform()
pixel_area = abs(geotr[1] * geotr[5])
band = data.GetRasterBand(1).ReadAsArray().astype(int)
unicos = np.unique(band)
clasesMuestras = clasesMuestras.astype(str)
unicos = unicos.astype(str)
for clase in clasesMuestras:
if clase in unicos:
clasesNew.append(clase)
if (len(clasesMuestras) == len(clasesNew)):
classMapa = sorted(np.array(clasesNew).astype(str))
classMuestras = sorted(
np.array(clasesMuestras).astype(str))
if (np.array_equal(classMuestras, classMapa)):
i = 0
self.reultados.append("Áreas por clase:")
matrizAreaClass = np.empty(
(len(classMapa), 2)).astype(str)
for clase in clasesNew:
condition = np.bitwise_not(band != int(clase))
totalClase = np.extract(condition, band)
total = len(totalClase)
matrizAreaClass[i][0] = str(clase)
matrizAreaClass[i][1] = str(
round(float(str((total * pixel_area) / 10000)),
0))
self.reultados.append(
str(matrizAreaClass[i][0]) + ": \t" +
str(matrizAreaClass[i][1]))
i += 1
else:
QMessageBox.information(
self, "Error",
"Hay clases que no coinciden en vector de muestras y mapa temático",
QMessageBox.Ok)
error = False
matrizAreaClass = 0
else:
QMessageBox.information(
self, "Error",
"Las clases del vector de muestras no tiene la misma cantidad de clases que el mapa temático",
QMessageBox.Ok)
error = False
matrizAreaClass = 0
else:
QMessageBox.information(
self, "Error",
"El Raster debe de estar en unidades Metricas",
QMessageBox.Ok)
error = False
matrizAreaClass = 0
return matrizAreaClass, error
def testBilinearResample(self):
path = os.path.join(unitTestDataPath(), 'landsat.tif')
raster_layer = QgsRasterLayer(path, 'test')
self.assertTrue(raster_layer.isValid())
extent = QgsRectangle(785994.37761193525511771,
3346249.2209800467826426,
786108.49096253968309611,
3346362.94137834152206779)
renderer = QgsSingleBandGrayRenderer(raster_layer.dataProvider(), 1)
filter = QgsRasterResampleFilter(renderer)
# default (nearest neighbour) resampling
block = filter.block(1, extent, 2, 2)
self.checkBlockContents(block, [[124, 127], [125, 126]])
block = filter.block(1, extent, 4, 4)
self.checkBlockContents(block,
[[124, 124, 127, 127], [124, 124, 127, 127],
[125, 125, 126, 126], [125, 125, 126, 126]])
block = filter.block(1, extent, 8, 8)
self.checkBlockContents(block,
[[124, 124, 124, 124, 127, 127, 127, 127],
[124, 124, 124, 124, 127, 127, 127, 127],
[124, 124, 124, 124, 127, 127, 127, 127],
[124, 124, 124, 124, 127, 127, 127, 127],
[125, 125, 125, 125, 126, 126, 126, 126],
[125, 125, 125, 125, 126, 126, 126, 126],
[125, 125, 125, 125, 126, 126, 126, 126],
[125, 125, 125, 125, 126, 126, 126, 126]])
# with resampling
filter.setZoomedInResampler(QgsBilinearRasterResampler())
block = filter.block(1, extent, 2, 2)
self.checkBlockContents(block, [[124, 127], [125, 126]])
block = filter.block(1, extent, 4, 4)
self.checkBlockContents(block,
[[124, 124, 126, 126], [124, 124, 125, 126],
[124, 124, 125, 126], [125, 125, 125, 126]])
block = filter.block(1, extent, 8, 8)
self.checkBlockContents(block,
[[124, 124, 124, 125, 125, 126, 126, 126],
[124, 124, 124, 125, 125, 126, 126, 126],
[124, 124, 124, 124, 125, 125, 126, 126],
[124, 124, 124, 124, 125, 125, 126, 126],
[124, 124, 124, 124, 125, 125, 126, 126],
[124, 124, 124, 124, 125, 125, 126, 126],
[125, 125, 125, 125, 125, 125, 126, 126],
[125, 125, 125, 125, 125, 125, 126, 126]])
# with oversampling
extent = QgsRectangle(785878.92593475803732872,
3346136.27493690419942141,
786223.56509550288319588,
3346477.7564090033993125)
block = filter.block(1, extent, 2, 2)
self.checkBlockContents(block, [[127, 126], [125, 126]])
block = filter.block(1, extent, 4, 4)
self.checkBlockContents(block,
[[125, 127, 127, 127], [126, 127, 127, 126],
[125, 126, 126, 126], [127, 125, 125, 125]])
block = filter.block(1, extent, 8, 8)
self.checkBlockContents(block,
[[126, 126, 126, 126, 125, 125, 125, 126],
[126, 126, 125, 125, 125, 126, 126, 126],
[126, 125, 124, 124, 125, 126, 126, 126],
[126, 125, 124, 124, 125, 126, 126, 126],
[125, 125, 124, 124, 124, 126, 126, 126],
[125, 125, 125, 125, 125, 126, 126, 126],
[125, 125, 125, 125, 125, 126, 126, 126],
[125, 125, 126, 126, 125, 125, 125, 125]])
filter.setMaxOversampling(2)
block = filter.block(1, extent, 2, 2)
self.checkBlockContents(block, [[127, 126], [125, 126]])
block = filter.block(1, extent, 4, 4)
self.checkBlockContents(block,
[[125, 127, 127, 127], [126, 127, 127, 126],
[125, 126, 126, 126], [127, 125, 125, 125]])
block = filter.block(1, extent, 8, 8)
self.checkBlockContents(block,
[[126, 126, 126, 126, 125, 125, 125, 126],
[126, 126, 125, 125, 125, 126, 126, 126],
[126, 125, 124, 124, 125, 126, 126, 126],
[126, 125, 124, 124, 125, 126, 126, 126],
[125, 125, 124, 124, 124, 126, 126, 126],
[125, 125, 125, 125, 125, 126, 126, 126],
[125, 125, 125, 125, 125, 126, 126, 126],
[125, 125, 126, 126, 125, 125, 125, 125]])
filter.setMaxOversampling(4)
block = filter.block(1, extent, 2, 2)
self.checkBlockContents(block, [[127, 126], [125, 126]])
block = filter.block(1, extent, 4, 4)
self.checkBlockContents(block,
[[125, 127, 127, 127], [126, 127, 127, 126],
[125, 126, 126, 126], [127, 125, 125, 125]])
block = filter.block(1, extent, 8, 8)
self.checkBlockContents(block,
[[126, 126, 126, 126, 125, 125, 125, 126],
[126, 126, 125, 125, 125, 126, 126, 126],
[126, 125, 124, 124, 125, 126, 126, 126],
[126, 125, 124, 124, 125, 126, 126, 126],
[125, 125, 124, 124, 124, 126, 126, 126],
[125, 125, 125, 125, 125, 126, 126, 126],
[125, 125, 125, 125, 125, 126, 126, 126],
[125, 125, 126, 126, 125, 125, 125, 125]])
def convert_track(self, filename):
self.file_name = filename
if self.file_name[-3:] == 'gpx':
# Set parameters to load file like a layer. Get track like a points, not a line
uri = self.file_name + "|layername=track_points"
# Load Layer with points of track gpx o line KML
self.points = QgsVectorLayer(uri, "Original Points", "ogr")
# Check if load is correct
if not self.points.isValid():
self.info("Track failed to load! /n" + filename)
else:
self.info("Track Load Correct! " + filename)
elif self.file_name[-3:] == 'kml':
uri = self.file_name
# Set parameters to load file like a layer. Get track like a line
# Load Layer with points of track gpx o line KML
lines = QgsVectorLayer(uri, "Original Line", "ogr")
# Check if load is correct
if not lines.isValid():
self.info("Track failed to load! /n" + filename)
else:
self.info("Track Load Correct! " + filename)
# KML is a line convert line in points
for line in lines.getFeatures():
# Create a layer for points in memory
self.points = QgsVectorLayer("Point?crs=epsg:4326&index=yes",
"Original Points", "memory")
features = []
for vertex in line.geometry().vertices():
feature = QgsFeature()
feature.setGeometry(vertex)
features.append(feature)
self.points.dataProvider().addFeatures(features)
# Set parameters to load the Digital Elevation Model of IGN
if self.comboBox.currentIndex() == 3:
uri = "dpiMode=7&identifier=mdt:Elevacion4258_1000&url=http://www.ign.es/wcs/mdt"
uri2 = "dpiMode=7&identifier=Elevacion4258_1000&url=http://servicios.idee.es/wcs-inspire/mdt?version%3D1.1.2"
elif self.comboBox.currentIndex() == 2:
uri = "dpiMode=7&identifier=mdt:Elevacion4258_500&url=http://www.ign.es/wcs/mdt"
uri2 = "dpiMode=7&identifier=Elevacion4258_500&url=http://servicios.idee.es/wcs-inspire/mdt?version%3D1.1.2"
elif self.comboBox.currentIndex() == 1:
uri = "dpiMode=7&identifier=mdt:Elevacion4258_200&url=http://www.ign.es/wcs/mdt"
uri2 = "dpiMode=7&identifier=Elevacion4258_200&url=http://servicios.idee.es/wcs-inspire/mdt?version%3D1.1.2"
else:
uri = "dpiMode=7&identifier=mdt:Elevacion4258_25&url=http://www.ign.es/wcs/mdt"
uri2 = "dpiMode=7&identifier=Elevacion4258_25&url=http://servicios.idee.es/wcs-inspire/mdt?version%3D1.1.2"
DEM = QgsRasterLayer(uri, 'my wcs layer', 'wcs')
if not DEM.isValid():
self.info("DEM failed to load!")
else:
self.info("DEM Load Correct!")
# For calculate distance between points
d = QgsDistanceArea()
d.setEllipsoid('WGS84')
point_origin = 0
# For make profile
self.all_coord_m = []
self.all_coord_z = []
self.ymax = 0
# Start to create KML file (firts lines of file)
self.start_creation_kml()
# Start to create GPX file (firts lines of file)
self.start_creation_gpx()
# For put time in points of track
self.track_day = QDateTime.currentDateTime()
# For each point in the track, analize information
for point in self.points.getFeatures():
# Get Geometry of feature like a point
geompt = point.geometry().asPoint()
if not DEM.isValid():
if self.file_name[-3:] == 'kml':
elevation = [0, 0]
else:
elevation = [point['ele'], point['ele']]
else:
# Find this point in DEM and return his elevation
elevation = DEM.dataProvider().identify(
geompt, QgsRaster.IdentifyFormatValue).results()
#print (elevation[1],point['ele'])
# Get Value of original point (y - Latitude, x - Longitude)
self.coor_x = geompt.x()
self.coor_y = geompt.y()
if len(elevation) > 0:
# Set value of elevation like coordinate Z
self.coor_z = elevation[1]
else:
self.info('Point ' + str(self.coor_y) + " / " +
str(self.coor_x) + " Not Found / No encontrado")
self.coor_z = 0
# Calculate lenght of track
if not point_origin == 0:
self.distance = d.measureLine(point_origin, geompt)
self.coor_m += (self.distance / 1000) # Distance in km
point_origin = geompt
else:
self.coor_m = 0
self.distance = 0
point_origin = geompt
# Maxium Hight for profile
if self.ymax < self.coor_z:
self.ymax = self.coor_z
# Acumulate points (distance / Elevation) for make profile
self.all_coord_m.append(self.coor_m)
self.all_coord_z.append(self.coor_z)
# Put a time in points
if self.file_name[-3:] == 'kml':
self.track_day = self.track_day.addSecs(1)
else:
if point['time'] == None:
# If track hase no time add 1 second to previous time
self.track_day = self.track_day.addSecs(1)
else:
# Get point time from track
self.track_day = point['time']
# Add point in the new kml file
self.add_points_kml()
# Add point in the new GPX file
self.add_points_gpx()
# Close and write finish of kml file
self.finish_kml()
# Close and write finish of gpx file
self.finish_gpx()
class TestQgsLayoutMap(unittest.TestCase, LayoutItemTestCase):
@classmethod
def setUpClass(cls):
cls.item_class = QgsLayoutItemMap
def setUp(self):
self.report = "<h1>Python QgsLayoutItemMap Tests</h1>\n"
def tearDown(self):
report_file_path = "%s/qgistest.html" % QDir.tempPath()
with open(report_file_path, 'a') as report_file:
report_file.write(self.report)
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()
QgsProject.instance().addMapLayers([self.raster_layer, self.vector_layer])
# create layout with layout map
self.layout = QgsLayout(QgsProject.instance())
self.layout.initializeDefaults()
self.map = QgsLayoutItemMap(self.layout)
self.map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
self.map.setFrameEnabled(True)
self.map.setLayers([self.raster_layer])
self.layout.addLayoutItem(self.map)
def testOverviewMap(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
checker = QgsLayoutChecker('composermap_overview', self.layout)
checker.setColorTolerance(6)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
self.assertTrue(myTestResult, myMessage)
def testOverviewMapBlend(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
overviewMap.overview().setBlendMode(QPainter.CompositionMode_Multiply)
checker = QgsLayoutChecker('composermap_overview_blending', self.layout)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
self.assertTrue(myTestResult, myMessage)
def testOverviewMapInvert(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
overviewMap.overview().setInverted(True)
checker = QgsLayoutChecker('composermap_overview_invert', self.layout)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
self.assertTrue(myTestResult, myMessage)
def testOverviewMapCenter(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(192, -288, 320, -224)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
overviewMap.overview().setInverted(False)
overviewMap.overview().setCentered(True)
checker = QgsLayoutChecker('composermap_overview_center', self.layout)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
self.assertTrue(myTestResult, myMessage)
def testAsMapLayer(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
map = QgsLayoutItemMap(l)
map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
l.addLayoutItem(map)
overviewMap = QgsLayoutItemMap(l)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
l.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(map)
layer = overviewMap.overview().asMapLayer()
self.assertIsNotNone(layer)
self.assertTrue(layer.isValid())
self.assertEqual([f.geometry().asWkt() for f in layer.getFeatures()], ['Polygon ((96 -120, 160 -120, 160 -152, 96 -152, 96 -120))'])
# check that layer has correct renderer
fill_symbol = QgsFillSymbol.createSimple({'color': '#00ff00', 'outline_color': '#ff0000', 'outline_width': '10'})
overviewMap.overview().setFrameSymbol(fill_symbol)
layer = overviewMap.overview().asMapLayer()
self.assertIsInstance(layer.renderer(), QgsSingleSymbolRenderer)
self.assertEqual(layer.renderer().symbol().symbolLayer(0).properties()['color'], '0,255,0,255')
self.assertEqual(layer.renderer().symbol().symbolLayer(0).properties()['outline_color'], '255,0,0,255')
# test layer blend mode
self.assertEqual(layer.blendMode(), QPainter.CompositionMode_SourceOver)
overviewMap.overview().setBlendMode(QPainter.CompositionMode_Clear)
layer = overviewMap.overview().asMapLayer()
self.assertEqual(layer.blendMode(), QPainter.CompositionMode_Clear)
# should have no effect
overviewMap.setMapRotation(45)
layer = overviewMap.overview().asMapLayer()
self.assertEqual([f.geometry().asWkt() for f in layer.getFeatures()], ['Polygon ((96 -120, 160 -120, 160 -152, 96 -152, 96 -120))'])
map.setMapRotation(15)
layer = overviewMap.overview().asMapLayer()
self.assertEqual([f.geometry().asWkt(0) for f in layer.getFeatures()], ['Polygon ((93 -129, 155 -112, 163 -143, 101 -160, 93 -129))'])
# with reprojection
map.setCrs(QgsCoordinateReferenceSystem('EPSG:3875'))
layer = overviewMap.overview().asMapLayer()
self.assertEqual([f.geometry().asWkt(0) for f in layer.getFeatures()], ['Polygon ((93 -129, 96 -128, 99 -127, 102 -126, 105 -126, 108 -125, 111 -124, 114 -123, 116 -123, 119 -122, 122 -121, 125 -120, 128 -119, 131 -119, 134 -118, 137 -117, 140 -116, 143 -115, 146 -115, 149 -114, 152 -113, 155 -112, 155 -114, 156 -115, 156 -117, 156 -118, 157 -120, 157 -121, 158 -123, 158 -124, 158 -126, 159 -127, 159 -128, 160 -130, 160 -131, 160 -133, 161 -134, 161 -136, 161 -137, 162 -139, 162 -140, 163 -142, 163 -143, 160 -144, 157 -145, 154 -146, 151 -146, 148 -147, 145 -148, 142 -149, 140 -149, 137 -150, 134 -151, 131 -152, 128 -153, 125 -153, 122 -154, 119 -155, 116 -156, 113 -157, 110 -157, 107 -158, 104 -159, 101 -160, 101 -158, 100 -157, 100 -155, 100 -154, 99 -152, 99 -151, 98 -149, 98 -148, 98 -146, 97 -145, 97 -144, 96 -142, 96 -141, 96 -139, 95 -138, 95 -136, 95 -135, 94 -133, 94 -132, 93 -130, 93 -129))'])
map.setCrs(overviewMap.crs())
# with invert
overviewMap.overview().setInverted(True)
layer = overviewMap.overview().asMapLayer()
self.assertEqual([f.geometry().asWkt(0) for f in layer.getFeatures()], ['Polygon ((-53 -128, 128 53, 309 -128, 128 -309, -53 -128),(93 -129, 101 -160, 163 -143, 155 -112, 93 -129))'])
def test_StackingPosition(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
overviewMap = QgsLayoutItemMap(l)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
l.addLayoutItem(overviewMap)
overviewMap.overview().setStackingPosition(QgsLayoutItemMapItem.StackBelowMap)
self.assertEqual(overviewMap.overview().stackingPosition(), QgsLayoutItemMapItem.StackBelowMap)
overviewMap.overview().setStackingPosition(QgsLayoutItemMapItem.StackBelowMapLayer)
self.assertEqual(overviewMap.overview().stackingPosition(), QgsLayoutItemMapItem.StackBelowMapLayer)
overviewMap.overview().setStackingLayer(self.raster_layer)
self.assertEqual(overviewMap.overview().stackingLayer(), self.raster_layer)
overviewMap.overview().setStackingLayer(self.vector_layer)
self.assertEqual(overviewMap.overview().stackingLayer(), self.vector_layer)
overviewMap.overview().setStackingLayer(None)
self.assertIsNone(overviewMap.overview().stackingLayer())
def test_ModifyMapLayerList(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
overviewMap = QgsLayoutItemMap(l)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
l.addLayoutItem(overviewMap)
map = QgsLayoutItemMap(l)
map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
l.addLayoutItem(map)
self.assertFalse(overviewMap.overviews().modifyMapLayerList([]))
self.assertEqual(overviewMap.overviews().modifyMapLayerList([self.raster_layer, self.vector_layer]), [self.raster_layer, self.vector_layer])
overviewMap.overview().setLinkedMap(map)
overviewMap.overview().setStackingPosition(QgsLayoutItemMapItem.StackBelowMap)
self.assertEqual(overviewMap.overviews().modifyMapLayerList([self.raster_layer, self.vector_layer]),
[self.raster_layer, self.vector_layer, overviewMap.overview().asMapLayer()])
overviewMap.overview().setStackingPosition(QgsLayoutItemMapItem.StackBelowMapLayer)
self.assertEqual(overviewMap.overviews().modifyMapLayerList([self.raster_layer, self.vector_layer]),
[self.raster_layer, self.vector_layer])
overviewMap.overview().setStackingLayer(self.raster_layer)
self.assertEqual(overviewMap.overviews().modifyMapLayerList([self.raster_layer, self.vector_layer]),
[self.raster_layer, overviewMap.overview().asMapLayer(), self.vector_layer])
overviewMap.overview().setStackingLayer(self.vector_layer)
self.assertEqual(overviewMap.overviews().modifyMapLayerList([self.raster_layer, self.vector_layer]),
[self.raster_layer, self.vector_layer, overviewMap.overview().asMapLayer()])
overviewMap.overview().setStackingPosition(QgsLayoutItemMapItem.StackAboveMapLayer)
overviewMap.overview().setStackingLayer(None)
self.assertEqual(overviewMap.overviews().modifyMapLayerList([self.raster_layer, self.vector_layer]),
[self.raster_layer, self.vector_layer])
overviewMap.overview().setStackingLayer(self.raster_layer)
self.assertEqual(overviewMap.overviews().modifyMapLayerList([self.raster_layer, self.vector_layer]),
[overviewMap.overview().asMapLayer(), self.raster_layer, self.vector_layer])
overviewMap.overview().setStackingLayer(self.vector_layer)
self.assertEqual(overviewMap.overviews().modifyMapLayerList([self.raster_layer, self.vector_layer]),
[self.raster_layer, overviewMap.overview().asMapLayer(), self.vector_layer])
overviewMap.overview().setStackingPosition(QgsLayoutItemMapItem.StackBelowMapLabels)
self.assertEqual(overviewMap.overviews().modifyMapLayerList([self.raster_layer, self.vector_layer]),
[overviewMap.overview().asMapLayer(), self.raster_layer, self.vector_layer])
overviewMap.overview().setStackingPosition(QgsLayoutItemMapItem.StackAboveMapLabels)
self.assertEqual(overviewMap.overviews().modifyMapLayerList([self.raster_layer, self.vector_layer]),
[self.raster_layer, self.vector_layer])
# two overviews
overviewMap.overview().setStackingPosition(QgsLayoutItemMapItem.StackBelowMap)
overviewMap.overviews().addOverview(QgsLayoutItemMapOverview('x', overviewMap))
overviewMap.overviews().overview(1).setLinkedMap(map)
overviewMap.overviews().overview(1).setStackingPosition(QgsLayoutItemMapItem.StackBelowMapLabels)
self.assertEqual(overviewMap.overviews().modifyMapLayerList([self.raster_layer, self.vector_layer]),
[overviewMap.overviews().overview(1).asMapLayer(), self.raster_layer, self.vector_layer, overviewMap.overview().asMapLayer()])
def testOverviewStacking(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
map = QgsLayoutItemMap(l)
map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
map.setFrameEnabled(True)
map.setLayers([self.raster_layer])
l.addLayoutItem(map)
overviewMap = QgsLayoutItemMap(l)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
l.addLayoutItem(overviewMap)
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(-20, -276, 276, 20)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(map)
overviewMap.overview().setInverted(True)
overviewMap.overview().setStackingPosition(QgsLayoutItemMapItem.StackBelowMapLayer)
overviewMap.overview().setStackingLayer(self.raster_layer)
checker = QgsLayoutChecker('composermap_overview_belowmap', l)
checker.setColorTolerance(6)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.assertTrue(myTestResult, myMessage)
overviewMap.overview().setStackingPosition(QgsLayoutItemMapItem.StackAboveMapLayer)
overviewMap.overview().setStackingLayer(self.raster_layer)
checker = QgsLayoutChecker('composermap_overview_abovemap', l)
checker.setColorTolerance(6)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.assertTrue(myTestResult, myMessage)
class TestQgsComposerMap(unittest.TestCase):
def __init__(self, methodName):
"""Run once on class initialization."""
unittest.TestCase.__init__(self, methodName)
myPath = os.path.join(TEST_DATA_DIR, 'rgb256x256.png')
rasterFileInfo = QFileInfo(myPath)
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 TestQgsBlendModes(unittest.TestCase):
def __init__(self, methodName):
"""Run once on class initialization."""
unittest.TestCase.__init__(self, methodName)
self.iface = get_iface()
# initialize class MapRegistry, Canvas, MapRenderer, Map and PAL
self.mMapRegistry = QgsProject.instance()
# create point layer
myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp')
self.mPointLayer = QgsVectorLayer(myShpFile, 'Points', 'ogr')
self.mMapRegistry.addMapLayer(self.mPointLayer)
self.mSimplifyMethod = QgsVectorSimplifyMethod()
self.mSimplifyMethod.setSimplifyHints(QgsVectorSimplifyMethod.NoSimplification)
# create polygon layer
myShpFile = os.path.join(TEST_DATA_DIR, 'polys.shp')
self.mPolygonLayer = QgsVectorLayer(myShpFile, 'Polygons', 'ogr')
self.mPolygonLayer.setSimplifyMethod(self.mSimplifyMethod)
self.mMapRegistry.addMapLayer(self.mPolygonLayer)
# create line layer
myShpFile = os.path.join(TEST_DATA_DIR, 'lines.shp')
self.mLineLayer = QgsVectorLayer(myShpFile, 'Lines', 'ogr')
self.mLineLayer.setSimplifyMethod(self.mSimplifyMethod)
self.mMapRegistry.addMapLayer(self.mLineLayer)
# create two raster layers
myRasterFile = os.path.join(TEST_DATA_DIR, 'rgb256x256.png')
self.mRasterLayer1 = QgsRasterLayer(myRasterFile, "raster1")
self.mRasterLayer2 = QgsRasterLayer(myRasterFile, "raster2")
myMultiBandRenderer1 = QgsMultiBandColorRenderer(self.mRasterLayer1.dataProvider(), 1, 2, 3)
self.mRasterLayer1.setRenderer(myMultiBandRenderer1)
self.mMapRegistry.addMapLayer(self.mRasterLayer1)
myMultiBandRenderer2 = QgsMultiBandColorRenderer(self.mRasterLayer2.dataProvider(), 1, 2, 3)
self.mRasterLayer2.setRenderer(myMultiBandRenderer2)
self.mMapRegistry.addMapLayer(self.mRasterLayer2)
# to match blend modes test comparisons background
self.mapSettings = QgsMapSettings()
self.mapSettings.setLayers([self.mRasterLayer1, self.mRasterLayer2])
self.mapSettings.setBackgroundColor(QColor(152, 219, 249))
self.mapSettings.setOutputSize(QSize(400, 400))
self.mapSettings.setOutputDpi(96)
self.extent = QgsRectangle(-118.8888888888887720, 22.8002070393376783, -83.3333333333331581, 46.8719806763287536)
def testVectorBlending(self):
"""Test that blend modes work for vector layers."""
# Add vector layers to map
myLayers = [self.mLineLayer, self.mPolygonLayer]
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.extent)
# Set blending modes for both layers
self.mLineLayer.setBlendMode(QPainter.CompositionMode_Difference)
self.mPolygonLayer.setBlendMode(QPainter.CompositionMode_Difference)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_vector_blendmodes")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
myResult = checker.runTest("vector_blendmodes", 20)
myMessage = ('vector blending failed')
assert myResult, myMessage
# Reset layers
self.mLineLayer.setBlendMode(QPainter.CompositionMode_SourceOver)
self.mPolygonLayer.setBlendMode(QPainter.CompositionMode_SourceOver)
def testVectorFeatureBlending(self):
"""Test that feature blend modes work for vector layers."""
# Add vector layers to map
myLayers = [self.mLineLayer, self.mPolygonLayer]
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.extent)
# Set feature blending for line layer
self.mLineLayer.setFeatureBlendMode(QPainter.CompositionMode_Plus)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_vector_featureblendmodes")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
myResult = checker.runTest("vector_featureblendmodes", 20)
myMessage = ('vector feature blending failed')
assert myResult, myMessage
# Reset layers
self.mLineLayer.setFeatureBlendMode(QPainter.CompositionMode_SourceOver)
def testVectorLayerTransparency(self):
"""Test that layer transparency works for vector layers."""
# Add vector layers to map
myLayers = [self.mLineLayer, self.mPolygonLayer]
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.extent)
# Set feature blending for line layer
self.mLineLayer.setLayerTransparency(50)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_vector_layertransparency")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
myResult = checker.runTest("vector_layertransparency", 20)
myMessage = ('vector layer transparency failed')
assert myResult, myMessage
def testRasterBlending(self):
"""Test that blend modes work for raster layers."""
# Add raster layers to map
myLayers = [self.mRasterLayer1, self.mRasterLayer2]
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.mRasterLayer1.extent())
# Set blending mode for top layer
self.mRasterLayer1.setBlendMode(QPainter.CompositionMode_Difference)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_raster_blendmodes")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
checker.setColorTolerance(1)
myResult = checker.runTest("raster_blendmodes", 20)
myMessage = ('raster blending failed')
assert myResult, myMessage
def run(self):
try:
if self.karst_features is not None:
self.karst_features.startEditing()
self.karst_features.dataProvider().addAttributes(
[QgsField('temp', QVariant.Int)])
self.karst_features.commitChanges()
self.karst_features.startEditing()
for feat in self.karst_features.getFeatures():
self.karst_features.changeAttributeValue(
feat.id(),
self.karst_features.fields().indexFromName('temp'), 4)
self.karst_features.commitChanges()
processing.run(
"gdal:rasterize", {
'INPUT': self.karst_features,
'FIELD': 'temp',
'HEIGHT': self.raster_info['resolution_y'],
'WIDTH': self.raster_info['resolution_x'],
'UNITS': 1,
'EXTENT': self.raster_info['extent']['str_extent'],
'OUTPUT': str(self.doss) + '/rKarst_features.tif'
})
self.karst_features.startEditing()
self.karst_features.dataProvider().deleteAttributes(
[self.karst_features.fields().indexFromName('temp')])
self.karst_features.updateFields()
self.karst_features.commitChanges()
rKarst_features = QgsRasterLayer(
str(self.doss) + '/rKarst_features.tif', 'rKarst_features')
else:
rKarst_features = None
# Croisement des valeurs des rasters sur chaque pixel
valCarteKa = numpy.zeros(
(self.raster_info['size_y'], self.raster_info['size_x']),
numpy.int16)
val_i = range(0, self.raster_info['size_x'], 1)
val_j = range(0, self.raster_info['size_y'], 1)
if rKarst_features is None:
pKarst_features = None
else:
pKarst_features = rKarst_features.dataProvider()
for j in val_j:
self.progress.emit(j, len(val_j))
for i in val_i:
pos = QgsPointXY(
(self.raster_info['extent']['Xmin'] +
(i + 1) * self.raster_info['resolution_x']) -
self.raster_info['resolution_x'] / 2,
(self.raster_info['extent']['Ymax'] -
j * self.raster_info['resolution_y']) -
self.raster_info['resolution_y'] / 2)
if pKarst_features:
valKarst_features, found = pKarst_features.sample(
pos, 1)
if found and valKarst_features:
valCarteKa[j, i] = 4
else:
valCarteKa[j, i] = self.mangin
else:
valCarteKa[j, i] = self.mangin
# ecriture du raster a partir de l'array
raster = gdal.GetDriverByName('Gtiff').Create(
str(self.doss) + '/Ka_factor.tif', self.raster_info['size_x'],
self.raster_info['size_y'], 1, gdal.GDT_Byte)
raster.SetProjection(self.raster_info['projection_wkt'])
raster.SetGeoTransform((
self.raster_info['extent']['Xmin'],
float(self.raster_info['resolution_x']),
0.0,
self.raster_info['extent']['Ymax'],
0.0,
float(-self.raster_info['resolution_y']),
))
Band = raster.GetRasterBand(1)
Band.WriteArray(valCarteKa, 0, 0)
Band.FlushCache()
Band.SetNoDataValue(0)
# fermeture des connexions
rKarst_features = None
Raster = None
self.results.emit()
except Exception as e:
self.error.emit(
Exception('An error happen when generating the Ka Factor: %s' %
str(e)))
finally:
self.finished.emit()
def process(self, data):
# data = {upd/npd: {dating = [calendar years BP, ...], uncert = [calendar years, ...], coords = [[x, y], ...], accur = [accuracy, ...]}}
UPD_t_ds = np.round(data["upd"]["dating"]).astype(
int
) # mean datings of archaeological components (calendar years BP)
UPD_uncert_ds = np.round(data["upd"]["uncert"]).astype(
int) # uncertainties of the datings (calendar years)
UPD_As = np.round(data["upd"]["coords"]).astype(
int) # spatial coordinates of archaeological components (metres)
UPD_accurs = np.round(data["upd"]["accur"]).astype(
int
) # accuracies of spatial coordinates of archaeological components (+-metres)
NPD_t_ds = np.round(data["npd"]["dating"]).astype(
int
) # measured radiocarbon ages of archaeological components (radiocarbon years)
NPD_uncert_ds = np.round(data["npd"]["uncert"]).astype(
int
) # 1-sigma uncertainties of the measured radiocarbon ages (radiocarbon years)
NPD_As = np.round(data["npd"]["coords"]).astype(
int) # spatial coordinates of archaeological components (metres)
NPD_accurs = np.round(data["npd"]["accur"]).astype(
int
) # accuracies of spatial coordinates of archaeological components (+-metres)
if (not UPD_t_ds.size) and (not NPD_t_ds.size):
return
s_halflife = self.s_duration / 2 # expected half-life of a settlement in years
s_radius = self.s_diameter / 2 # expected radius of a settlement in metres
# temporal extent
t_min = np.inf
t_max = -np.inf
if UPD_t_ds.size:
t_min = min(t_min,
(UPD_t_ds - UPD_uncert_ds).min() - self.s_duration)
t_max = max(t_max,
(UPD_t_ds + UPD_uncert_ds).max() + self.s_duration)
if NPD_t_ds.size:
t_min = min(t_min,
(NPD_t_ds - 2 * NPD_uncert_ds).min() - self.s_duration)
t_max = max(t_max,
(NPD_t_ds + 2 * NPD_uncert_ds).max() + self.s_duration)
t_min, t_max = [
int(round(value / 10) * 10) for value in [t_min, t_max]
]
if self.time_from is not None:
t_max = min(t_max, self.time_from)
if self.time_to is not None:
t_min = max(t_min, self.time_to)
ts_slices = np.arange(t_max, t_min - 2 * self.time_step,
-self.time_step).tolist() # times of time slices
# prepare lookup for probability distributions of 14C datings
self.setLabelText("Calibrating radiocarbon dates")
cal_curve = load_curve(
os.path.join(os.path.dirname(__file__), "intcal13.14c")
) # [[CalBP, ConvBP, CalSigma], ...], sorted by CalBP
# filter calibration curve to include only time-step dates
cal_curve = cal_curve[(cal_curve[:, 0] >= t_min)
& (cal_curve[:, 0] <= t_max)][::-1]
ts = cal_curve[:, 0]
curve_conv_age = cal_curve[:, 1]
curve_uncert = cal_curve[:, 2]
if ts[-1] < ts_slices[-1]:
ts_slices.append(ts[-1])
# calculate probability distributions for all combinations of 14c age and uncertainty
unique_dates = set() # ((age, uncert), ...)
for idx in range(NPD_t_ds.shape[0]):
unique_dates.add((NPD_t_ds[idx], NPD_uncert_ds[idx]))
lookup_14c = defaultdict(
dict
) # {age: {uncert: D, ...}, ...}; D[ti] = p; where ti = index in ts, p = probability
cmax = len(unique_dates)
cnt = 0
for age, uncert in unique_dates:
QtWidgets.QApplication.processEvents()
if not self.running:
return
self.setValue((cnt / cmax) * 100)
cnt += 1
lookup_14c[age][uncert] = calibrate(age, uncert, curve_conv_age,
curve_uncert)
# prepare lookup of spatial probability distribution around evidence points
self.setLabelText("Calculating spatial probability distribution")
self.setValue(0)
accurs = set()
accurs.update(UPD_accurs.tolist())
accurs.update(NPD_accurs.tolist())
lookup_f_s = {
} # {accur: M, ...}; M[n, n] = f_s(d, accur, s_radius); where center is point A and n is 2 * [maximum distance from A in raster units] + 1; where f_s > 0
cnt = 0
cmax = len(accurs)
for accur in accurs:
QtWidgets.QApplication.processEvents()
if not self.running:
return
self.setValue((cnt / cmax) * 100)
cnt += 1
r = int(round((accur + 2 * s_radius) / self.cell_size))
n = 2 * r + 1
lookup_f_s[accur] = np.zeros((n, n), dtype=float)
rcs = np.argwhere(np.ones((n, n), dtype=bool))
mask = (rcs > r).all(axis=1)
for row, col in rcs[mask]:
d = (((row - r)**2 + (col - r)**2)**0.5) * self.cell_size
if self.approximate:
p = f_s_approx(d, accur, s_radius)
else:
p = f_S_lens(d, accur, s_radius) / f_S(accur, s_radius)
if (p == np.inf) or np.isnan(p):
p = 0
lookup_f_s[accur][row, col] = p
lookup_f_s[accur][n - row, col] = p
lookup_f_s[accur][row, n - col] = p
lookup_f_s[accur][n - row, n - col] = p
lookup_f_s[accur][0, 0] = lookup_f_s[accur][0, 1]
# spatial extent
row_min, col_min = np.inf, np.inf
row_max, col_max = -np.inf, -np.inf
for As, accurs in [[UPD_As, UPD_accurs], [NPD_As, NPD_accurs]]:
for idx in range(As.shape[0]):
A = As[idx]
accur = accurs[idx]
r = int(lookup_f_s[accur].shape[0] / 2)
col, row = np.round(A / self.cell_size).astype(int)
row_min = min(row_min, row - r - 1)
col_min = min(col_min, col - r - 1)
row_max = max(row_max, row + r)
col_max = max(col_max, col + r)
width, height = (col_max - col_min), (row_max - row_min)
x0, y0 = col_min * self.cell_size, row_min * self.cell_size
# calculate time-slices
self.setLabelText("Generating time-slices")
paths = []
summed = []
val_max = -np.inf
grid_summed = np.zeros((height, width), dtype=float)
t_slice_prev = ts_slices.pop(0)
t_slice = ts_slices.pop(0)
n_slice = 1
for ti in range(ts.shape[0]):
QtWidgets.QApplication.processEvents()
if not self.running:
return
self.setValue((ti / ts.shape[0]) * 100)
grid = np.ones((height, width), dtype=float)
for idx in range(UPD_t_ds.shape[0]):
t_d = UPD_t_ds[idx]
uncert_d = UPD_uncert_ds[idx]
A = UPD_As[idx]
accur = UPD_accurs[idx]
M = 1 - lookup_f_s[accur] * f_t_UPD(ts[ti], t_d, uncert_d,
s_halflife)
r = int((M.shape[0] - 1) / 2)
col0, row0 = np.round((A - [x0, y0]) / self.cell_size - r -
1).astype(int)
dc = grid.shape[1] - (col0 + M.shape[0])
if dc < 0:
M = M[:, :dc]
dr = grid.shape[0] - (row0 + M.shape[0])
if dr < 0:
M = M[:dr]
grid[row0:row0 + M.shape[0], col0:col0 + M.shape[0]] *= M
for idx in range(NPD_t_ds.shape[0]):
t_d = NPD_t_ds[idx]
uncert_d = NPD_uncert_ds[idx]
A = NPD_As[idx]
accur = NPD_accurs[idx]
M = 1 - lookup_f_s[accur] * f_t_NPD(
ts[ti], s_halflife, lookup_14c[t_d][uncert_d], ts)
r = int((M.shape[0] - 1) / 2)
col0, row0 = np.round((A - [x0, y0]) / self.cell_size - r -
1).astype(int)
dc = grid.shape[1] - (col0 + M.shape[0])
if dc < 0:
M = M[:, :dc]
dr = grid.shape[0] - (row0 + M.shape[0])
if dr < 0:
M = M[:dr]
grid[row0:row0 + M.shape[0], col0:col0 + M.shape[0]] *= M
grid = 1 - grid
grid[np.isnan(grid)] = 0
grid[grid == np.inf] = 0
summed.append(grid.sum())
if ts[ti] <= t_slice:
val_max = max(val_max, grid_summed.max())
t_ce, cebce = bp_to_ce(t_slice_prev)
t_ce2, cebce2 = bp_to_ce(t_slice)
datestr = "%03d_%d_%s_-_%d_%s" % (n_slice, t_ce, cebce, t_ce2,
cebce2)
paths.append([
datestr,
os.path.join(self.path_layers, "ede_%s.tif" % (datestr))
])
self.save_raster(grid_summed, x0, y0, paths[-1][1])
t_slice_prev = t_slice
t_slice = ts_slices.pop(0)
n_slice += 1
grid_summed[:] = grid
else:
grid_summed += grid
if self.path_summed:
self.save_summed(ts, summed)
project = QgsProject.instance()
val_max = val_max * 0.9
self.setLabelText("Rendering time-slices")
cnt = 0
cmax = len(paths)
for datestr, path in paths:
QtWidgets.QApplication.processEvents()
if not self.running:
return
self.setValue((cnt / cmax) * 100)
cnt += 1
layer = QgsRasterLayer(path, "EDE_%s" % (datestr))
layer.setCrs(self.crs)
s = QgsRasterShader()
c = QgsColorRampShader()
c.setColorRampType(QgsColorRampShader.Interpolated)
i = []
i.append(QgsColorRampShader.ColorRampItem(0, self.colors[0]))
i.append(
QgsColorRampShader.ColorRampItem(val_max / 2, self.colors[1]))
i.append(QgsColorRampShader.ColorRampItem(val_max, self.colors[2]))
c.setColorRampItemList(i)
s.setRasterShaderFunction(c)
ps = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1, s)
ps.setClassificationMin(0)
ps.setClassificationMax(val_max)
layer.setRenderer(ps)
self.save_rendered(
layer, os.path.join(self.path_rendered, "%s.tif" % (datestr)))
project.addMapLayer(layer)
def testTransparency(self):
myPath = os.path.join(unitTestDataPath('raster'),
'band1_float32_noct_epsg4326.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
myRasterLayer = QgsRasterLayer(myPath, myBaseName)
myMessage = 'Raster not loaded: %s' % myPath
assert myRasterLayer.isValid(), myMessage
renderer = QgsSingleBandGrayRenderer(myRasterLayer.dataProvider(), 1)
myRasterLayer.setRenderer(renderer)
myRasterLayer.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.StretchToMinimumMaximum,
QgsRasterLayer.ContrastEnhancementMinMax)
myContrastEnhancement = myRasterLayer.renderer().contrastEnhancement()
#print ("myContrastEnhancement.minimumValue = %.17g" %
# myContrastEnhancement.minimumValue())
#print ("myContrastEnhancement.maximumValue = %.17g" %
# myContrastEnhancement.maximumValue())
# Unfortunately the minimum/maximum values calculated in C++ and Python
# are slightly different (e.g. 3.3999999521443642e+38 x
# 3.3999999521444001e+38)
# It is not clear where the precision is lost.
# We set the same values as C++.
myContrastEnhancement.setMinimumValue(-3.3319999287625854e+38)
myContrastEnhancement.setMaximumValue(3.3999999521443642e+38)
#myType = myRasterLayer.dataProvider().dataType(1);
#myEnhancement = QgsContrastEnhancement(myType);
myTransparentSingleValuePixelList = []
rasterTransparency = QgsRasterTransparency()
myTransparentPixel1 = \
QgsRasterTransparency.TransparentSingleValuePixel()
myTransparentPixel1.min = -2.5840000772112106e+38
myTransparentPixel1.max = -1.0879999684602689e+38
myTransparentPixel1.percentTransparent = 50
myTransparentSingleValuePixelList.append(myTransparentPixel1)
myTransparentPixel2 = \
QgsRasterTransparency.TransparentSingleValuePixel()
myTransparentPixel2.min = 1.359999960575336e+37
myTransparentPixel2.max = 9.520000231087593e+37
myTransparentPixel2.percentTransparent = 70
myTransparentSingleValuePixelList.append(myTransparentPixel2)
rasterTransparency.setTransparentSingleValuePixelList(
myTransparentSingleValuePixelList)
rasterRenderer = myRasterLayer.renderer()
assert rasterRenderer
rasterRenderer.setRasterTransparency(rasterTransparency)
QgsMapLayerRegistry.instance().addMapLayers([ myRasterLayer, ])
myMapRenderer = QgsMapRenderer()
myLayers = QStringList()
myLayers.append(myRasterLayer.id())
myMapRenderer.setLayerSet(myLayers)
myMapRenderer.setExtent(myRasterLayer.extent())
myChecker = QgsRenderChecker()
myChecker.setControlName("expected_raster_transparency")
myChecker.setMapRenderer(myMapRenderer)
myResultFlag = myChecker.runTest("raster_transparency_python");
assert myResultFlag, "Raster transparency rendering test failed"
class TestQgsBlendModes(TestCase):
def __init__(self, methodName):
"""Run once on class initialisation."""
unittest.TestCase.__init__(self, methodName)
# initialize class MapRegistry, Canvas, MapRenderer, Map and PAL
self.mMapRegistry = QgsMapLayerRegistry.instance()
# create point layer
myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp')
self.mPointLayer = QgsVectorLayer(myShpFile, 'Points', 'ogr')
self.mMapRegistry.addMapLayer(self.mPointLayer)
# create polygon layer
myShpFile = os.path.join(TEST_DATA_DIR, 'polys.shp')
self.mPolygonLayer = QgsVectorLayer(myShpFile, 'Polygons', 'ogr')
self.mMapRegistry.addMapLayer(self.mPolygonLayer)
# create two raster layers
myRasterFile = os.path.join(TEST_DATA_DIR, 'landsat.tif')
self.mRasterLayer1 = QgsRasterLayer(myRasterFile, "raster1")
self.mRasterLayer2 = QgsRasterLayer(myRasterFile, "raster2")
myMultiBandRenderer1 = QgsMultiBandColorRenderer(self.mRasterLayer1.dataProvider(), 2, 3, 4)
self.mRasterLayer1.setRenderer(myMultiBandRenderer1)
self.mMapRegistry.addMapLayer(self.mRasterLayer1)
myMultiBandRenderer2 = QgsMultiBandColorRenderer(self.mRasterLayer2.dataProvider(), 2, 3, 4)
self.mRasterLayer2.setRenderer(myMultiBandRenderer2)
self.mMapRegistry.addMapLayer(self.mRasterLayer2)
# to match blend modes test comparisons background
self.mCanvas = CANVAS
self.mCanvas.setCanvasColor(QColor(152, 219, 249))
self.mMap = self.mCanvas.map()
self.mMap.resize(QSize(400, 400))
self.mMapRenderer = self.mCanvas.mapRenderer()
self.mMapRenderer.setOutputSize(QSize(400, 400), 72)
def testVectorBlending(self):
"""Test that blend modes work for vector layers."""
#Add vector layers to map
myLayers = QStringList()
myLayers.append(self.mPointLayer.id())
myLayers.append(self.mPolygonLayer.id())
self.mMapRenderer.setLayerSet(myLayers)
self.mMapRenderer.setExtent(self.mPointLayer.extent())
#Set blending modes for both layers
self.mPointLayer.setBlendMode(QPainter.CompositionMode_Overlay)
self.mPolygonLayer.setBlendMode(QPainter.CompositionMode_Multiply)
checker = QgsRenderChecker()
checker.setControlName("expected_vector_blendmodes")
checker.setMapRenderer(self.mMapRenderer)
myResult = checker.runTest("vector_blendmodes");
myMessage = ('vector blending failed')
assert myResult, myMessage
def testRasterBlending(self):
"""Test that blend modes work for raster layers."""
#Add raster layers to map
myLayers = QStringList()
myLayers.append(self.mRasterLayer1.id())
myLayers.append(self.mRasterLayer2.id())
self.mMapRenderer.setLayerSet(myLayers)
self.mMapRenderer.setExtent(self.mRasterLayer1.extent())
#Set blending mode for top layer
self.mRasterLayer1.setBlendMode(QPainter.CompositionMode_Plus)
checker = QgsRenderChecker()
checker.setControlName("expected_raster_blendmodes")
checker.setMapRenderer(self.mMapRenderer)
myResult = checker.runTest("raster_blendmodes");
myMessage = ('raster blending failed')
assert myResult, myMessage
def createMapLayer(self, mapLayerName, layerStyleName, boundingBox, layerTime="", minMaxRange=None):
"""Will create a QGIS valid raster layer for the
parsed map, using the passed parameters to get the
layer we need, with the requested style, and optionally
a time dimension.
The possibility of using WMS-T (Time) is provided by
a 'hack' (QGIS does not allow it through its WMS provider
API), taken from Anita Graser's Time Manager (GPL2).
:param mapLayerName: The name identifier of the coverage we want
to retrieve..
:type mapLayerName: str
:param layerStyleName: The name identifier of the layer style we want
used to paint our layer.
:type layerStyleName: str
:param layerTime: The time dimension we want (optional).
:type layerTime: str
:param minMaxRange: A tuple or list containing the min and max values to
be used in the request of this map. Used for rendering
the proper colors. If none or not provided, it will
ask the server for the max-min values of this time-defined
map and use them instead.
:type minMaxRange: list or tuple with floats (min, max)
:returns: A QGIS-compatible raster layer object with the given parameters.
:rtype: QgsRasterLayer
"""
if self.mapInfo is None:
self.getMapInfoFromCapabilities()
if minMaxRange == None:
minMaxRange = self.getMinMaxRasterValuesFromTimeRange(
mapLayerName, layerStyleName, [layerTime], boundingBox)
rasterMinMaxValues = str(minMaxRange[0])+","+str(minMaxRange[1])
#print("Raster range for "+mapLayerName+"_"+layerStyleName+": "+rasterMinMaxValues)
finalUrl = self.baseWMSUrl.format(layer=mapLayerName,
style=layerStyleName,
url=self.mapInfo.getURL())
#We add an UUID to guarantee uniqueness in the layer name and id
layerName = self.mapInfo.getName()+"-"+str(uuid.uuid4())
resultLayer = QgsRasterLayer(finalUrl, layerName, 'wms')
#HACK taken from Anita Graser's Time Manager:
#https://github.com/anitagraser/TimeManager/blob/master/raster/wmstlayer.py
#(Under GPL2 license) with an extra added for COLORSCALERANGE ncWMS attribute
#and BOUNDINGBOX information (which is removed when constructing layers by qgis
#it seems?)
#TODO: Bounding box information is not processed by QGIS. QGIS C++ WMS provider
#apparently re-creates the request with a previously read bounding box information
#from the capabilities.xml file. This needs a workaround, or reature request to QGIS.
resultLayer.dataProvider().setDataSourceUri(self.qgisWMSThack
+ resultLayer.dataProvider().dataSourceUri()
+ "?TIME={time}%26COLORSCALERANGE={scale}%26BBOX={bbox}"
.format(time = layerTime,
scale=rasterMinMaxValues,
bbox=str(boundingBox)))
if resultLayer.isValid():
self.mapLayer = resultLayer
else:
raise StandardError('No se pudo crear una capa válida.')
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())
# 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.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 TestQgsLayoutMap(unittest.TestCase, LayoutItemTestCase):
@classmethod
def setUpClass(cls):
cls.item_class = QgsLayoutItemMap
def setUp(self):
self.report = "<h1>Python QgsLayoutItemMap Tests</h1>\n"
def tearDown(self):
report_file_path = "%s/qgistest.html" % QDir.tempPath()
with open(report_file_path, 'a') as report_file:
report_file.write(self.report)
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 layout with layout map
self.layout = QgsLayout(QgsProject.instance())
self.layout.initializeDefaults()
self.map = QgsLayoutItemMap(self.layout)
self.map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
self.map.setFrameEnabled(True)
self.map.setLayers([self.raster_layer])
self.layout.addLayoutItem(self.map)
def testOverviewMap(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
checker = QgsLayoutChecker('composermap_overview', self.layout)
checker.setColorTolerance(6)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
assert myTestResult, myMessage
def testOverviewMapBlend(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
overviewMap.overview().setBlendMode(QPainter.CompositionMode_Multiply)
checker = QgsLayoutChecker('composermap_overview_blending', self.layout)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
assert myTestResult, myMessage
def testOverviewMapInvert(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(96, -152, 160, -120)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
overviewMap.overview().setInverted(True)
checker = QgsLayoutChecker('composermap_overview_invert', self.layout)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
assert myTestResult, myMessage
def testOverviewMapCenter(self):
overviewMap = QgsLayoutItemMap(self.layout)
overviewMap.attemptSetSceneRect(QRectF(20, 130, 70, 70))
overviewMap.setFrameEnabled(True)
overviewMap.setLayers([self.raster_layer])
self.layout.addLayoutItem(overviewMap)
# zoom in
myRectangle = QgsRectangle(192, -288, 320, -224)
self.map.setExtent(myRectangle)
myRectangle2 = QgsRectangle(0, -256, 256, 0)
overviewMap.setExtent(myRectangle2)
overviewMap.overview().setLinkedMap(self.map)
overviewMap.overview().setInverted(False)
overviewMap.overview().setCentered(True)
checker = QgsLayoutChecker('composermap_overview_center', self.layout)
checker.setControlPathPrefix("composer_mapoverview")
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.layout.removeLayoutItem(overviewMap)
assert myTestResult, myMessage
def testMapCrs(self):
# create layout with layout map
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
layout.initializeDefaults()
# check that new maps inherit project CRS
QgsProject.instance().setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(20, 20, 200, 100))
map.setFrameEnabled(True)
rectangle = QgsRectangle(-13838977, 2369660, -8672298, 6250909)
map.setExtent(rectangle)
map.setLayers([self.vector_layer])
layout.addLayoutItem(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 = QgsLayoutChecker('composermap_crs3857', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
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 = QgsLayoutChecker('composermap_crs4326', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
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 testContainsAdvancedEffects(self):
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
map = QgsLayoutItemMap(layout)
self.assertFalse(map.containsAdvancedEffects())
self.vector_layer.setBlendMode(QPainter.CompositionMode_Darken)
result = map.containsAdvancedEffects()
self.vector_layer.setBlendMode(QPainter.CompositionMode_SourceOver)
self.assertTrue(result)
def testRasterization(self):
map_settings = QgsMapSettings()
map_settings.setLayers([self.vector_layer])
layout = QgsLayout(QgsProject.instance())
map = QgsLayoutItemMap(layout)
self.assertFalse(map.requiresRasterization())
self.vector_layer.setBlendMode(QPainter.CompositionMode_Darken)
self.assertFalse(map.requiresRasterization())
self.assertTrue(map.containsAdvancedEffects())
map.setBackgroundEnabled(False)
self.assertTrue(map.requiresRasterization())
map.setBackgroundEnabled(True)
map.setBackgroundColor(QColor(1, 1, 1, 1))
self.assertTrue(map.requiresRasterization())
self.vector_layer.setBlendMode(QPainter.CompositionMode_SourceOver)
class TestQGISRasterTools(unittest.TestCase):
def setUp(self):
self.raster = QgsRasterLayer(RASTER_BASE + '.tif', 'test')
self.provider = self.raster.dataProvider()
self.extent = self.raster.extent()
self.x_res = self.raster.rasterUnitsPerPixelX()
self.y_res = self.raster.rasterUnitsPerPixelY()
def test_pixels_to_points(self):
points = pixels_to_points(
self.raster, threshold_min=1.0, threshold_max=1.5)
# There are four such pixels only
self.assertEquals(points.featureCount(), 4)
for point in points.dataProvider().getFeatures():
point = point.geometry().asPoint()
# Move point in center of the pixels and get the value
value = self.provider.identify(
QgsPoint(
point.x() + 0.5 * self.x_res,
point.y() - 0.5 * self.y_res),
QgsRaster.IdentifyFormatValue,
self.extent)
value = value.results()[1]
self.assertGreater(value, 1.0)
self.assertLess(value, 1.5)
# Infinite threshold test
points = pixels_to_points(self.raster, threshold_min=1.1)
self.assertEquals(points.featureCount(), 8)
for point in points.dataProvider().getFeatures():
point = point.geometry().asPoint()
# Move point in center of the pixels and get the value
value = self.provider.identify(
QgsPoint(
point.x() + 0.5 * self.x_res,
point.y() - 0.5 * self.y_res),
QgsRaster.IdentifyFormatValue,
self.extent)
value = value.results()[1]
self.assertGreater(value, 1.1)
test_pixels_to_points.slow = True
def test_polygonize(self):
"""Test if polygonize works"""
geometry = polygonize(
self.raster, threshold_min=1.0, threshold_max=1.5)
# Result is one square
self.assertTrue(geometry.isGeosValid())
self.assertFalse(geometry.isMultipart())
# noinspection PyArgumentEqualDefault
geometry = polygonize(self.raster, threshold_min=0.0)
# Result is several polygons
self.assertTrue(geometry.isGeosValid())
self.assertTrue(geometry.isMultipart())
expected = QgsVectorLayer(VECTOR_BASE + '.shp', 'test', 'ogr')
for feature in expected.getFeatures():
# the layer has one feature only
expected_geom = feature.geometry()
self.assertTrue((geometry.isGeosEqual(expected_geom)))
test_polygonize.slow = True
def test_clip_raster(self):
"""Test clip_raster work"""
new_raster = clip_raster(
self.raster,
self.raster.width(),
self.raster.height(),
self.extent
)
self.assertEqual(self.raster.rasterUnitsPerPixelY(),
new_raster.rasterUnitsPerPixelY())
self.assertEqual(self.raster.rasterUnitsPerPixelX(),
new_raster.rasterUnitsPerPixelX())
self.assertEqual(self.raster.extent(),
new_raster.extent())
self.assertEqual(self.raster.width(),
new_raster.width())
self.assertEqual(self.raster.height(),
new_raster.height())
# Set extent as 1/2 of self.extent
center = self.extent.center()
x_max, y_max = center.x(), center.y()
new_extent = QgsRectangle(
self.extent.xMinimum(),
self.extent.yMinimum(),
x_max,
y_max
)
new_raster = clip_raster(
self.raster,
self.raster.width(),
self.raster.height(),
new_extent
)
self.assertAlmostEquals(
self.raster.rasterUnitsPerPixelY(),
2 * new_raster.rasterUnitsPerPixelY())
self.assertAlmostEquals(
self.raster.rasterUnitsPerPixelX(),
2 * new_raster.rasterUnitsPerPixelX())
self.assertEqual(new_extent, new_raster.extent())
self.assertEqual(self.raster.width(), new_raster.width())
self.assertEqual(self.raster.height(), new_raster.height())
test_clip_raster.slow = True
def run(self):
try:
processing.run(
"gdal:rasterize", {
'INPUT': self.layer_lithology,
'FIELD': self.field_lithology,
'HEIGHT': self.raster_info['resolution_y'],
'WIDTH': self.raster_info['resolution_x'],
'UNITS': 1,
'EXTENT': self.raster_info['extent']['str_extent'],
'OUTPUT': os.path.join(self.doss, 'rLithology.tif')
})
if self.layer_structure is None:
pass
else:
self.layer_structure.startEditing()
self.layer_structure.dataProvider().addAttributes(
[QgsField('temp', QVariant.Int)])
self.layer_structure.commitChanges()
self.layer_structure.startEditing()
field_structure = self.layer_structure.fields().indexFromName(
'temp')
for feat in self.layer_structure.getFeatures():
self.layer_structure.changeAttributeValue(
feat.id(), field_structure, 4)
self.layer_structure.commitChanges()
processing.run(
"gdal:rasterize", {
'INPUT': self.layer_structure,
'FIELD': 'temp',
'HEIGHT': self.raster_info['resolution_y'],
'WIDTH': self.raster_info['resolution_x'],
'UNITS': 1,
'EXTENT': self.raster_info['extent']['str_extent'],
'OUTPUT': os.path.join(self.doss, 'rStructure.tif')
})
self.layer_structure.startEditing()
self.layer_structure.dataProvider().deleteAttributes(
[field_structure])
self.layer_structure.updateFields()
self.layer_structure.commitChanges()
# Preparation des donnees pour la comparaison des valeurs des rasters sur chaque pixel
val_i = range(0, self.raster_info['size_x'], 1)
val_j = range(0, self.raster_info['size_y'], 1)
if self.layer_lithology is None:
pass
else:
rLithology = QgsRasterLayer(
os.path.join(self.doss, 'rLithology.tif'), 'rLithology')
pLithology = rLithology.dataProvider()
if self.layer_structure is None:
pStructure = None
else:
rStructure = QgsRasterLayer(
os.path.join(self.doss, 'rStructure.tif'), 'rStructure')
pStructure = rStructure.dataProvider()
# iteration sur les pixels
ValCarteR = numpy.zeros(
(self.raster_info['size_y'], self.raster_info['size_x']),
numpy.int16)
for j in val_j:
self.progress.emit(j, len(val_j))
for i in val_i:
pos = QgsPointXY(
(self.raster_info['extent']['Xmin'] +
(i + 1) * self.raster_info['resolution_x']) -
self.raster_info['resolution_x'] / 2,
(self.raster_info['extent']['Ymax'] -
j * self.raster_info['resolution_y']) -
self.raster_info['resolution_y'] / 2)
if self.layer_lithology is None:
valLithology = 6
else:
valLithology, found = pLithology.sample(pos, 1)
if not found or valLithology == 0:
valLithology = 6
if self.layer_structure is None:
valStructure = 0
else:
valStructure, found = pStructure.sample(pos, 1)
if not found or valStructure == 0:
valStructure = 0
else:
valStructure = 4
ValCarteR[
j,
i] = valLithology + valStructure if valLithology + valStructure <= 4 else 4
# ecriture du raster a partir de l'array
raster = gdal.GetDriverByName('Gtiff').Create(
os.path.join(self.doss,
'R_factor.tif'), self.raster_info['size_x'],
self.raster_info['size_y'], 1, gdal.GDT_Byte)
raster.SetProjection(self.raster_info['projection_wkt'])
raster.SetGeoTransform((
self.raster_info['extent']['Xmin'],
float(self.raster_info['resolution_x']),
0.0,
self.raster_info['extent']['Ymax'],
0.0,
float(-self.raster_info['resolution_y']),
))
Band = raster.GetRasterBand(1)
Band.WriteArray(ValCarteR, 0, 0)
Band.FlushCache()
Band.SetNoDataValue(6)
# fermeture des connexions
rLithology = None
rStructure = None
Raster = None
self.results.emit()
except Exception as e:
self.error.emit(
Exception('An error happen when generating the R Factor: %s' %
str(e)))
finally:
self.finished.emit()
class TestQgsBlendModes(TestCase):
def __init__(self, methodName):
"""Run once on class initialisation."""
unittest.TestCase.__init__(self, methodName)
# initialize class MapRegistry, Canvas, MapRenderer, Map and PAL
self.mMapRegistry = QgsMapLayerRegistry.instance()
# create point layer
myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp')
self.mPointLayer = QgsVectorLayer(myShpFile, 'Points', 'ogr')
self.mMapRegistry.addMapLayer(self.mPointLayer)
self.mSimplifyMethod = QgsVectorSimplifyMethod()
self.mSimplifyMethod.setSimplifyHints(
QgsVectorSimplifyMethod.NoSimplification)
# create polygon layer
myShpFile = os.path.join(TEST_DATA_DIR, 'polys.shp')
self.mPolygonLayer = QgsVectorLayer(myShpFile, 'Polygons', 'ogr')
self.mPolygonLayer.setSimplifyMethod(self.mSimplifyMethod)
self.mMapRegistry.addMapLayer(self.mPolygonLayer)
# create line layer
myShpFile = os.path.join(TEST_DATA_DIR, 'lines.shp')
self.mLineLayer = QgsVectorLayer(myShpFile, 'Lines', 'ogr')
self.mLineLayer.setSimplifyMethod(self.mSimplifyMethod)
self.mMapRegistry.addMapLayer(self.mLineLayer)
# create two raster layers
myRasterFile = os.path.join(TEST_DATA_DIR, 'landsat.tif')
self.mRasterLayer1 = QgsRasterLayer(myRasterFile, "raster1")
self.mRasterLayer2 = QgsRasterLayer(myRasterFile, "raster2")
myMultiBandRenderer1 = QgsMultiBandColorRenderer(
self.mRasterLayer1.dataProvider(), 2, 3, 4)
self.mRasterLayer1.setRenderer(myMultiBandRenderer1)
self.mMapRegistry.addMapLayer(self.mRasterLayer1)
myMultiBandRenderer2 = QgsMultiBandColorRenderer(
self.mRasterLayer2.dataProvider(), 2, 3, 4)
self.mRasterLayer2.setRenderer(myMultiBandRenderer2)
self.mMapRegistry.addMapLayer(self.mRasterLayer2)
# to match blend modes test comparisons background
self.mCanvas = CANVAS
self.mCanvas.setCanvasColor(QColor(152, 219, 249))
self.mMap = self.mCanvas.map()
self.mMap.resize(QSize(400, 400))
self.mapSettings = self.mCanvas.mapSettings()
self.mapSettings.setOutputSize(QSize(400, 400))
def testVectorBlending(self):
"""Test that blend modes work for vector layers."""
#Add vector layers to map
myLayers = []
myLayers.append(self.mLineLayer.id())
myLayers.append(self.mPolygonLayer.id())
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.mPointLayer.extent())
#Set blending modes for both layers
self.mLineLayer.setBlendMode(QPainter.CompositionMode_Difference)
self.mPolygonLayer.setBlendMode(QPainter.CompositionMode_Difference)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_vector_blendmodes")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
myResult = checker.runTest("vector_blendmodes", 20)
myMessage = ('vector blending failed')
assert myResult, myMessage
#Reset layers
self.mLineLayer.setBlendMode(QPainter.CompositionMode_SourceOver)
self.mPolygonLayer.setBlendMode(QPainter.CompositionMode_SourceOver)
def testVectorFeatureBlending(self):
"""Test that feature blend modes work for vector layers."""
#Add vector layers to map
myLayers = []
myLayers.append(self.mLineLayer.id())
myLayers.append(self.mPolygonLayer.id())
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.mPointLayer.extent())
#Set feature blending for line layer
self.mLineLayer.setFeatureBlendMode(QPainter.CompositionMode_Plus)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_vector_featureblendmodes")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
myResult = checker.runTest("vector_featureblendmodes", 20)
myMessage = ('vector feature blending failed')
assert myResult, myMessage
#Reset layers
self.mLineLayer.setFeatureBlendMode(
QPainter.CompositionMode_SourceOver)
def testVectorLayerTransparency(self):
"""Test that layer transparency works for vector layers."""
#Add vector layers to map
myLayers = []
myLayers.append(self.mLineLayer.id())
myLayers.append(self.mPolygonLayer.id())
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.mPointLayer.extent())
#Set feature blending for line layer
self.mLineLayer.setLayerTransparency(50)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_vector_layertransparency")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
myResult = checker.runTest("vector_layertransparency", 20)
myMessage = ('vector layer transparency failed')
assert myResult, myMessage
def testRasterBlending(self):
"""Test that blend modes work for raster layers."""
#Add raster layers to map
myLayers = []
myLayers.append(self.mRasterLayer1.id())
myLayers.append(self.mRasterLayer2.id())
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.mRasterLayer1.extent())
#Set blending mode for top layer
self.mRasterLayer1.setBlendMode(QPainter.CompositionMode_Plus)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_raster_blendmodes")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
checker.setColorTolerance(1)
myResult = checker.runTest("raster_blendmodes", 20)
myMessage = ('raster blending failed')
assert myResult, myMessage
