def test_run(self):
function = FloodRasterRoadsFunction.instance()
hazard_path = test_data_path('hazard', 'continuous_flood_20_20.asc')
exposure_path = test_data_path('exposure', 'roads.shp')
# noinspection PyCallingNonCallable
hazard_layer = QgsRasterLayer(hazard_path, 'Flood')
# noinspection PyCallingNonCallable
exposure_layer = QgsVectorLayer(exposure_path, 'Roads', 'ogr')
# Let's set the extent to the hazard extent
extent = hazard_layer.extent()
rect_extent = [
extent.xMinimum(), extent.yMaximum(),
extent.xMaximum(), extent.yMinimum()]
function.hazard = SafeLayer(hazard_layer)
function.exposure = SafeLayer(exposure_layer)
function.requested_extent = rect_extent
function.run()
impact = function.impact
keywords = impact.get_keywords()
self.assertEquals(function.target_field, keywords['target_field'])
expected_inundated_feature = 182
count = sum(impact.get_data(attribute=function.target_field))
self.assertEquals(count, expected_inundated_feature)
def test_run_without_population_field(self):
impact_function = AshRasterPlacesFunction.instance()
hazard_path = standard_data_path("hazard", "ash_raster_wgs84.tif")
exposure_path = standard_data_path("exposure", "places.shp")
hazard_layer = QgsRasterLayer(hazard_path, "Ash")
exposure_layer = QgsVectorLayer(exposure_path, "Places", "ogr")
impact_function.hazard = hazard_layer
impact_function.exposure = exposure_layer
# Let's set the extent to the hazard extent
extent = hazard_layer.extent()
rect_extent = [extent.xMinimum(), extent.yMaximum(), extent.xMaximum(), extent.yMinimum()]
impact_function.requested_extent = rect_extent
impact_function.run()
impact_layer = impact_function.impact
# Extract calculated result
impact_data = impact_layer.get_data()
# 1 = inundated, 2 = wet, 3 = dry
expected_result = {0: 0, 1: 135, 2: 62, 3: 1, 4: 0}
result = {0: 0, 1: 0, 2: 0, 3: 0, 4: 0}
for feature in impact_data:
inundated_status = feature[impact_function.target_field]
result[inundated_status] += 1
self.assertDictEqual(expected_result, result)
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 on_pushButton_clicked(self):
"""Wow - an autoconnected slot!"""
print 'Click!'
myPath = os.path.join(
os.path.dirname(__file__),
'landsat.tif')
print myPath
layer = QgsRasterLayer(myPath, 'A Layer')
QgsMapLayerRegistry.instance().addMapLayers([layer])
layer.setGrayBandName(layer.bandName(1))
layer.setDrawingStyle(QgsRasterLayer.SingleBandPseudoColor)
layer.setColorShadingAlgorithm(QgsRasterLayer.PseudoColorShader)
layer.saveDefaultStyle()
self.widget.zoomToFullExtent()
print self.widget.extent().toString()
print layer.extent().toString()
self.widget.refresh()
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 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 test_raster_to_vector_and_line_intersection(self):
"""Test the core part of the analysis.
1. Test creation of spatial index of flood cells
2. Test intersection of flood cells with roads layer
"""
raster_name = standard_data_path(
'hazard',
'tsunami_wgs84.tif')
exposure_name = standard_data_path(
'exposure',
'roads_osm_4326.shp')
raster = QgsRasterLayer(raster_name, 'Flood')
exposure = QgsVectorLayer(exposure_name, 'Exposure', 'ogr')
ranges = OrderedDict()
ranges[0] = [0, 1]
ranges[1] = [1, 2]
ranges[2] = [2, 100]
index, flood_cells_map = _raster_to_vector_cells(
raster, ranges, exposure.crs())
self.assertEqual(len(flood_cells_map), 4198)
rect_with_all_cells = raster.extent()
rect_with_4_cells = QgsRectangle(106.824, -6.177, 106.825, -6.179)
rect_with_0_cells = QgsRectangle(106.818, -6.168, 106.828, -6.175)
self.assertEqual(len(index.intersects(rect_with_all_cells)), 4198)
self.assertEqual(len(index.intersects(rect_with_4_cells)), 43)
self.assertEqual(len(index.intersects(rect_with_0_cells)), 504)
layer = create_layer(exposure)
new_field = QgsField('flooded', QVariant.Int)
layer.dataProvider().addAttributes([new_field])
request = QgsFeatureRequest()
_intersect_lines_with_vector_cells(
exposure, request, index, flood_cells_map, layer, 'flooded')
feature_count = layer.featureCount()
self.assertEqual(feature_count, 388)
flooded = 0
iterator = layer.getFeatures()
for feature in iterator:
attributes = feature.attributes()
if attributes[3] == 1:
flooded += 1
self.assertEqual(flooded, 40)
def test_run(self):
"""Test the tsunami on roads IF"""
impact_function = TsunamiRasterRoadsFunction.instance()
hazard_path = test_data_path('hazard', 'tsunami_wgs84.tif')
exposure_path = test_data_path('exposure', 'roads.shp')
hazard_layer = QgsRasterLayer(hazard_path, 'Tsunami')
exposure_layer = QgsVectorLayer(exposure_path, 'Roads', 'ogr')
impact_function.hazard = hazard_layer
impact_function.exposure = exposure_layer
# Let's set the extent to the hazard extent
extent = hazard_layer.extent()
rect_extent = [
extent.xMinimum(), extent.yMaximum(),
extent.xMaximum(), extent.yMinimum()]
impact_function.requested_extent = rect_extent
impact_function.run()
impact_layer = impact_function.impact
# Extract calculated result
impact_data = impact_layer.get_data()
self.assertEqual(len(impact_data), 3580)
# 1 = inundated, 2 = wet, 3 = dry
expected_result = {
0: 3218,
1: 88,
2: 107,
3: 114,
4: 53
}
result = {
0: 0,
1: 0,
2: 0,
3: 0,
4: 0
}
for feature in impact_data:
inundated_status = feature[impact_function.target_field]
result[inundated_status] += 1
message = 'Expecting %s, but it returns %s' % (expected_result, result)
self.assertEqual(expected_result, result, message)
def clip_layers(first_layer_path, second_layer_path):
"""Clip and resample layers with the reference to the first layer.
:param first_layer_path: Path to the first layer path.
:type first_layer_path: str
:param second_layer_path: Path to the second layer path.
:type second_layer_path: str
:return: Path to the clipped datasets (clipped 1st layer, clipped 2nd
layer).
:rtype: tuple(str, str)
:raise
FileNotFoundError
"""
base_name, _ = os.path.splitext(first_layer_path)
# noinspection PyCallingNonCallable
first_layer = QgsRasterLayer(first_layer_path, base_name)
base_name, _ = os.path.splitext(second_layer_path)
# noinspection PyCallingNonCallable
second_layer = QgsRasterLayer(second_layer_path, base_name)
# Get the firs_layer extents as an array in EPSG:4326
first_layer_geo_extent = extent_to_geoarray(
first_layer.extent(),
first_layer.crs())
first_layer_geo_cell_size, _ = get_wgs84_resolution(first_layer)
second_layer_geo_cell_size, _ = get_wgs84_resolution(second_layer)
if first_layer_geo_cell_size < second_layer_geo_cell_size:
cell_size = first_layer_geo_cell_size
else:
cell_size = second_layer_geo_cell_size
clipped_first_layer = clip_layer(
layer=first_layer,
extent=first_layer_geo_extent,
cell_size=cell_size)
clipped_second_layer = clip_layer(
layer=second_layer,
extent=first_layer_geo_extent,
cell_size=cell_size)
return clipped_first_layer, clipped_second_layer
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))
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"
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 mapa_final_no_compensatorio(n_variables, pesos, raster_inputs,
raster_salida):
ecuacion = '('
for a, b in zip(range(n_variables), pesos):
if a < n_variables - 1:
ecuacion += ("(" + str(b) + "^10) * " + "'(1 - (layer" +
str(a + 1) + "@1 ^10))'" + ' + ')
else:
ecuacion += ("(" + str(b) + "^10) * " + "'(1 - (layer" +
str(a + 1) + "@1 ^10))'")
ecuacion += ' ) ^ 1/10'
entries = []
#abre el archivo raster1
fileInfo = QFileInfo(raster_inputs[0])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer1 = QgsRasterLayer(path, baseName)
var1 = QgsRasterCalculatorEntry()
var1.ref = 'layer1@1'
var1.raster = layer1
var1.bandNumber = 1
entries.append(var1)
if n_variables == 2:
fileInfo = QFileInfo(raster_inputs[1])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer2 = QgsRasterLayer(path, baseName)
var2 = QgsRasterCalculatorEntry()
var2.ref = 'layer2@1'
var2.raster = layer2
var2.bandNumber = 1
entries.append(var2)
elif n_variables == 3:
fileInfo = QFileInfo(raster_inputs[1])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer2 = QgsRasterLayer(path, baseName)
var2 = QgsRasterCalculatorEntry()
var2.ref = 'layer2@1'
var2.raster = layer2
var2.bandNumber = 1
entries.append(var2)
fileInfo = QFileInfo(raster_inputs[2])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer3 = QgsRasterLayer(path, baseName)
var3 = QgsRasterCalculatorEntry()
var3.ref = 'layer3@1'
var3.raster = layer3
var3.bandNumber = 1
entries.append(var3)
elif n_variables == 4:
fileInfo = QFileInfo(raster_inputs[1])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer2 = QgsRasterLayer(path, baseName)
var2 = QgsRasterCalculatorEntry()
var2.ref = 'layer2@1'
var2.raster = layer2
var2.bandNumber = 1
entries.append(var2)
fileInfo = QFileInfo(raster_inputs[2])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer3 = QgsRasterLayer(path, baseName)
var3 = QgsRasterCalculatorEntry()
var3.ref = 'layer3@1'
var3.raster = layer3
var3.bandNumber = 1
entries.append(var3)
fileInfo = QFileInfo(raster_inputs[3])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer4 = QgsRasterLayer(path, baseName)
var4 = QgsRasterCalculatorEntry()
var4.ref = 'layer4@1'
var4.raster = layer4
var4.bandNumber = 1
entries.append(var4)
elif n_variables == 5:
fileInfo = QFileInfo(raster_inputs[1])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer2 = QgsRasterLayer(path, baseName)
var2 = QgsRasterCalculatorEntry()
var2.ref = 'layer2@1'
var2.raster = layer2
var2.bandNumber = 1
entries.append(var2)
fileInfo = QFileInfo(raster_inputs[2])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer3 = QgsRasterLayer(path, baseName)
var3 = QgsRasterCalculatorEntry()
var3.ref = 'layer3@1'
var3.raster = layer3
var3.bandNumber = 1
entries.append(var3)
fileInfo = QFileInfo(raster_inputs[3])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer4 = QgsRasterLayer(path, baseName)
var4 = QgsRasterCalculatorEntry()
var4.ref = 'layer4@1'
var4.raster = layer4
var4.bandNumber = 1
entries.append(var4)
fileInfo = QFileInfo(raster_inputs[4])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer5 = QgsRasterLayer(path, baseName)
var5 = QgsRasterCalculatorEntry()
var5.ref = 'layer5@1'
var5.raster = layer5
var5.bandNumber = 1
entries.append(var5)
calc = QgsRasterCalculator(ecuacion, raster_salida,
'GTiff', layer1.extent(), layer1.width(),
layer1.height(), entries)
calc.processCalculation()
class PolygonMapWindow(QMainWindow):
"""Open a map window where the user can draw a polygon and use it to crop data.
Shares a lot of similarities with MapWindow calss, but there're enough differences
that I decided not to inherit from it."""
# signal emitted when polygons succesfully selected
finished = pyqtSignal()
def __init__(self):
QMainWindow.__init__(self)
# creating map canvas, which draws the maplayers
# setting up features like canvas color
self.canvas = QgsMapCanvas()
self.canvas.setMinimumSize(550, 700)
self.canvas.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
# Qmainwindow requires a central widget. Canvas is placed
self.setCentralWidget(self.canvas)
# creating each desired action
self.actionGet = QAction("Return polygon and close", self)
self.actionPan = QAction("Pan tool", self)
self.actionDraw = QAction("Polygon tool", self)
self.actionConnect = QAction("Connect polygon", self)
self.actionClear = QAction("Clear", self)
self.actionCancel = QAction("Cancel and close", self)
# these two function as on/off. the rest are clickable
self.actionPan.setCheckable(True)
self.actionDraw.setCheckable(True)
# when actions are clicked, do corresponding function
self.actionPan.triggered.connect(self.pan)
self.actionDraw.triggered.connect(self.draw)
self.actionClear.triggered.connect(self.clear)
self.actionGet.triggered.connect(self.finishedSelection)
self.actionConnect.triggered.connect(self.connect)
self.actionCancel.triggered.connect(self.cancel)
# toolbar at the top of the screen: houses actions as buttons
# change order here to change their placement on toolbar
self.toolbar = self.addToolBar("Canvas actions")
self.toolbar.setContextMenuPolicy(Qt.PreventContextMenu)
self.toolbar.setMovable(False)
self.toolbar.addAction(self.actionGet)
self.toolbar.addAction(self.actionPan)
self.toolbar.addAction(self.actionDraw)
self.toolbar.addAction(self.actionConnect)
self.toolbar.addAction(self.actionClear)
self.toolbar.addAction(self.actionCancel)
# link actions to premade map tools
self.toolPan = QgsMapToolPan(self.canvas)
self.toolPan.setAction(self.actionPan)
self.toolDraw = PolygonMapTool(self.canvas)
self.toolDraw.setAction(self.actionDraw)
# set draw tool by default
self.draw()
def pan(self):
"""Simply activates the tool"""
self.canvas.setMapTool(self.toolPan)
# make sure the other button isn't checked to avoid confusion
self.actionDraw.setChecked(False)
def draw(self):
"""Activates draw tool"""
self.canvas.setMapTool(self.toolDraw)
self.actionPan.setChecked(False)
def clear(self):
self.toolDraw.reset()
def connect(self):
"""Calls the polygon tool to connect an unconnected polygon"""
self.toolDraw.finishPolygon()
def finishedSelection(self):
"""Activated when user clicks 'returns selection'. Closes window
and emits signal to indicate the job is finished"""
self.close()
self.finished.emit()
def cancel(self):
"""In case user changes their mind. Does the same as above, but doesn't
emit signal."""
self.close()
def showCanvas(self):
"""Shows the map canvas with a vector background map for reference"""
"""
url = ("https://vm0160.kaj.pouta.csc.fi/geoserver/ows?service=wfs&version=2.0.0"+
"&request=GetFeature&typename=ogiir:maakuntajako_4500k&pagingEnabled=true")
#self.bg_layer = QgsVectorLayer(url, "BACKGROUND-REMOVE", "WFS")
"""
self.bg_layer = QgsRasterLayer(
"url=https://vm0160.kaj.pouta.csc.fi/ogiir_cache/wmts/1.0.0/" +
"WMTSCapabilities.xml&crs=EPSG:3067&dpiMode=7&format=image/" +
"png&layers=taustakartta&styles=default&tileMatrixSet=GRIDI-FIN",
'GEOCUBES POLYGON BG-LAYER - TEMPORARY', 'wms')
if self.bg_layer.isValid():
QgsProject.instance().addMapLayer(self.bg_layer, False)
self.canvas.setExtent(self.bg_layer.extent())
self.canvas.setLayers([self.bg_layer])
self.show()
def closeEvent(self, event):
"""Activated anytime Mapwindow is closed either programmatically or
if the user finds some other way to close the window. Automatically
finishes the polygon if it's unconnected."""
try:
QgsProject.instance().removeMapLayer(self.bg_layer)
except Exception:
pass
self.toolDraw.finishPolygon()
QMainWindow.closeEvent(self, event)
def getPolygon(self):
return self.toolDraw.getPoints()
def getPolygonBbox(self):
return self.toolDraw.getPolyBbox()
class BBOXDialog(QDialog, FORM_CLASS):
def __init__(self, inp_sparql, triplestoreconf, endpointIndex):
super(QDialog, self).__init__()
self.setupUi(self)
self.inp_sparql = inp_sparql
self.triplestoreconf = triplestoreconf
self.endpointIndex = endpointIndex
self.vl = QgsVectorLayer("Point", "temporary_points", "memory")
self.map_canvas = QgsMapCanvas(self)
self.layerExtentOrBBOX = False
self.map_canvas.setMinimumSize(500, 475)
uri = "url=http://a.tile.openstreetmap.org/{z}/{x}/{y}.png&zmin=0&type=xyz"
self.mts_layer = QgsRasterLayer(uri, 'OSM', 'wms')
if not self.mts_layer.isValid():
print("Layer failed to load!")
self.rect_tool = RectangleMapTool(self.map_canvas)
self.map_canvas.setMapTool(self.rect_tool)
self.map_canvas.setExtent(self.mts_layer.extent())
self.map_canvas.setLayers([self.vl, self.mts_layer])
self.map_canvas.setCurrentLayer(self.mts_layer)
#chooseLayerLabel=QLabel("Choose Layer Extent:",self)
#chooseLayerLabel.move(0,480)
#self.chooseBBOXLayer=QComboBox(self)
#self.chooseBBOXLayer.move(150,475)
#b2 = QPushButton("Apply Layer Extent",self)
#b2.move(10,500)
self.b2.clicked.connect(self.setBBOXExtentQuery)
layers = QgsProject.instance().layerTreeRoot().children()
for layer in layers:
self.chooseBBOXLayer.addItem(layer.name())
#b1 = QPushButton("Apply BBOX",self)
#b1.move(400,500)
self.b1.clicked.connect(self.setBBOXInQuery)
def setBBOXExtentQuery(self):
self.mts_layer = QgsProject.instance().layerTreeRoot().children()[
self.chooseBBOXLayer.currentIndex()].layer()
self.layerExtentOrBBOX = True
self.setBBOXInQuery()
def setBBOXInQuery(self):
if self.layerExtentOrBBOX:
xMax = self.mts_layer.extent().xMaximum()
xMin = self.mts_layer.extent().xMinimum()
yMin = self.mts_layer.extent().yMinimum()
yMax = self.mts_layer.extent().yMaximum()
pointt1 = QgsGeometry.fromPointXY(QgsPointXY(xMax, yMin))
pointt2 = QgsGeometry.fromPointXY(QgsPointXY(xMin, yMin))
pointt3 = QgsGeometry.fromPointXY(QgsPointXY(xMin, yMax))
pointt4 = QgsGeometry.fromPointXY(QgsPointXY(xMax, yMax))
sourceCrs = QgsCoordinateReferenceSystem(
self.mts_layer.sourceCrs())
else:
pointt1 = QgsGeometry.fromWkt(self.rect_tool.point1.asWkt())
pointt2 = QgsGeometry.fromWkt(self.rect_tool.point2.asWkt())
pointt3 = QgsGeometry.fromWkt(self.rect_tool.point3.asWkt())
pointt4 = QgsGeometry.fromWkt(self.rect_tool.point4.asWkt())
sourceCrs = QgsCoordinateReferenceSystem(self.mts_layer.crs())
destCrs = QgsCoordinateReferenceSystem(4326)
tr = QgsCoordinateTransform(sourceCrs, destCrs, QgsProject.instance())
pointt1.transform(tr)
pointt2.transform(tr)
pointt3.transform(tr)
pointt4.transform(tr)
polygon = QgsGeometry.fromPolylineXY([
pointt1.asPoint(),
pointt2.asPoint(),
pointt3.asPoint(),
pointt4.asPoint()
])
center = polygon.centroid()
#distance = QgsDistanceArea()
#distance.setSourceCrs(destCrs)
#distance.setEllipsoidalMode(True)
#distance.setEllipsoid('WGS84')
widthm = 100 #distance.measureLine(pointt1, pointt2)
self.curbbox = []
self.curbbox.append(pointt1)
self.curbbox.append(pointt2)
self.curbbox.append(pointt3)
self.curbbox.append(pointt4)
self.close()
curquery = self.inp_sparql.toPlainText()
if "bboxquery" in self.triplestoreconf[
self.endpointIndex] and self.triplestoreconf[
self.endpointIndex]["bboxquery"]["type"] == "minmax":
curquery = curquery[0:curquery.rfind('}')] + self.triplestoreconf[
self.endpointIndex]["bboxquery"]["query"].replace(
"%%minPoint%%", pointt2.asWkt()).replace(
"%%maxPoint%%",
pointt4.asWkt()) + curquery[curquery.rfind('}') + 1:]
elif "bboxquery" in self.triplestoreconf[
self.endpointIndex] and self.triplestoreconf[
self.
endpointIndex]["bboxquery"]["type"] == "pointdistance":
curquery = curquery[0:curquery.rfind('}')] + self.triplestoreconf[
self.endpointIndex]["bboxquery"]["query"].replace(
"%%lat%%", str(center.asPoint().y())).replace(
"%%lon%%", str(center.asPoint().x())).replace(
"%%distance%%",
str(widthm /
1000)) + curquery[curquery.rfind('}') + 1:]
self.inp_sparql.setPlainText(curquery)
def test_clipBoth(self):
"""Raster and Vector layers can be clipped
"""
# Create a vector layer
myName = 'padang'
myVectorLayer = QgsVectorLayer(VECTOR_PATH, myName, 'ogr')
myMessage = 'Did not find layer "%s" in path "%s"' % \
(myName, VECTOR_PATH)
assert myVectorLayer.isValid(), myMessage
# Create a raster layer
myName = 'shake'
myRasterLayer = QgsRasterLayer(RASTERPATH, myName)
myMessage = 'Did not find layer "%s" in path "%s"' % \
(myName, RASTERPATH)
assert myRasterLayer.isValid(), myMessage
# Create a bounding box
myViewportGeoExtent = [99.53, -1.22, 101.20, -0.36]
# Get the Hazard extents as an array in EPSG:4326
myHazardGeoExtent = [myRasterLayer.extent().xMinimum(),
myRasterLayer.extent().yMinimum(),
myRasterLayer.extent().xMaximum(),
myRasterLayer.extent().yMaximum()]
# Get the Exposure extents as an array in EPSG:4326
myExposureGeoExtent = [myVectorLayer.extent().xMinimum(),
myVectorLayer.extent().yMinimum(),
myVectorLayer.extent().xMaximum(),
myVectorLayer.extent().yMaximum()]
# Now work out the optimal extent between the two layers and
# the current view extent. The optimal extent is the intersection
# between the two layers and the viewport.
# Extent is returned as an array [xmin,ymin,xmax,ymax]
myGeoExtent = getOptimalExtent(myHazardGeoExtent,
myExposureGeoExtent,
myViewportGeoExtent)
# Clip the vector to the bbox
myResult = clip_layer(myVectorLayer, myGeoExtent)
# Check the output is valid
assert os.path.exists(myResult.source())
readSafeLayer(myResult.source())
# Clip the raster to the bbox
myResult = clip_layer(myRasterLayer, myGeoExtent)
# Check the output is valid
assert os.path.exists(myResult.source())
readSafeLayer(myResult.source())
# -------------------------------
# Check the extra keywords option
# -------------------------------
# Clip the vector to the bbox
myResult = clip_layer(myVectorLayer, myGeoExtent,
extra_keywords={'kermit': 'piggy'})
# Check the output is valid
assert os.path.exists(myResult.source())
L = readSafeLayer(myResult.source())
kwds = L.get_keywords()
# myMessage = 'Extra keyword wasn\'t found in %s: %s' % (myResult,
# kwds)
assert kwds['kermit'] == 'piggy'
# Clip the raster to the bbox
myResult = clip_layer(myRasterLayer, myGeoExtent,
extra_keywords={'zoot': 'animal'})
# Check the output is valid
assert os.path.exists(myResult.source())
L = readSafeLayer(myResult.source())
kwds = L.get_keywords()
myMessage = 'Extra keyword was not found in %s: %s' % (
myResult.source(), kwds)
assert kwds['zoot'] == 'animal', myMessage
def select_HDF5_file(self):
"""Run method that performs all the real work"""
# show the dialog
#self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# close the dialog
self.dlg.close()
# See if OK was pressed
if result:
#### to open windows browser and search for HDF5 files only:
myfileNames = QFileDialog.getOpenFileNames(self.dlg,
self.tr("HDF5 File Selector"),
"",
self.tr("HDF5 (*.hdf5 *.h5)"))
#### to loop through all selected HDF5 files, just handling one for now
for i in myfileNames:
#### bind the HDF5 file
myfile = QgsRasterLayer(i)
#### to deal with multiple datasets within file
if (len(myfile.subLayers()) > 1):
#### to open dataset with desired data and name it Reflectance
#mydset = QgsRasterLayer(myfile.subLayers()[0], 'Reflectance')
fileName = myfile.subLayers()[0]
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
mydset = QgsRasterLayer(fileName, baseName)
##################################### Trials of setting proper extent begin here
print 'Extent before: '
print mydset.extent().toString()
########################## test almost worked
### loaded layer in right place but without data
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#mydset.setExtent(rect)
####################################
######################## test almost worked
### loaded layer in right place but without data
#size = QSizeF(1,1)
#point = QPointF(326380.0, 4103390.0)
#rect = QRectF(point, size)
#rect = QgsRectangle(rect)
#mydset.setExtent(rect)
###################################
########################## did not change extent
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#context = QgsRenderContext()
#context.setExtent(rect)
#mydset.draw(context)
####################################
#################################### did not change extent
#size = QSizeF(1,1)
#point = QPointF(326380.0, 4103390.0)
#rect = QRectF(point, size)
#rect = QgsRectangle(rect)
#context = QgsRenderContext()
#context.setExtent(rect)
#mydset.draw(context)
#####################################
###################################### did not change extent
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#context = QgsRenderContext()
#context.setExtent(rect)
#print 'Context extent: '
#print context.extent().toString() #this printed correct extent
#mydset.createMapRenderer(context)
#######################################
######################## test almost worked
### loaded layer in right place but without data
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#provider = mydset.dataProvider().clone()
#mydset.setExtent(rect)
#provider.reloadData()
######################################
########################################
# did not change extent, loaded data
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#context = QgsRenderContext()
#context.setExtent(rect)
#renderer = mydset.createMapRenderer(context)
#renderer.render()
#########################################
###########################################
# did not change extent, loaded data
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#mydset.dataProvider().block(52, rect, 1332, 2853)
##########################################
#############################################
# did not change extent, loaded data
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#mydset.dataProvider().block(426, rect, 1332, 2853)
###############################################
#################################################
# changed extent but overwrote to no data
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#mydset.setExtent(rect)
#mydset.dataProvider().reload()
####################################################
####################################################
# changed extent but overwrote to no data
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#mydset.setExtent(rect)
#mydset.dataProvider().block(52, rect, 1332, 2853)
#mydset.dataProvider().reload()
#####################################################
#############################################
# not setting new cloned data provider correctly
# method wants QString object but gets meaningless string
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#provider = mydset.dataProvider()
#print 'Provider: '
#print provider
#clone = provider.clone()
#print 'Provider clone: '
#print clone
#clone.block(1, rect, 1332, 2853)
#mydset.setDataProvider(str(clone))
#print 'New provider: '
#print mydset.dataProvider()
##############################################
######## printing result of extent changes
print 'Extent after: '
print mydset.extent().toString()
###################################
####################################### Trials of setting proper extent end here
#### to set proper Coordinate Reference System (crs) info
crs = mydset.crs()
crs.createFromId(32611)
mydset.setCrs(crs)
### this was josh's recommendation
#mycrs = QgsCoordinateReferenceSystem(32611)
#self.iface.mapCanvas().mapRenderer().setDestinationCrs(mycrs)
#### to set raster bands to load as RGB
mydset.renderer().setGreenBand(34)
mydset.renderer().setRedBand(52)
mydset.renderer().setBlueBand(18)
####### Tristan changes
#myrenderer = mydset.renderer()
#print 'Renderer Type: '
#print mydset.renderer().type()
# print 'Renderer block before: '
#print myrenderer.block(426, rect, 1, 1)
#myrenderer.block(426, rect, 1, 1)
#print 'Renderer block after: '
#print myrenderer.block() not enough arguments
#if hasattr(mydset, "setCacheImage"):
#mydset.setCacheImage(None)
#mydset.triggerRepaint()
#mydset.dataProvider().reloadData()
#mydset.triggerRepaint()
#self.iface.legendInterface().refreshLayerSymbology(mydset)
#mydset.reload()
#mydset.reloadData()
#mydset.triggerRepaint()
#mydset.draw()
#print 'Extent: '
#print mydset.extent().toString()
# ident = rlayer.dataProvider().identify(QgsPoint(15.30, 40.98), \
# QgsRaster.IdentifyFormatValue)
# if ident.isValid():
# print ident.results()
####### End Tristan changes
#### to add selected dataset/raster to map canvas
QgsMapLayerRegistry.instance().addMapLayer(mydset)
#canvas=QgsMapCanvas()
#canvas.show()
#canvas.setExtent(mydset.extent())
#canvas.setLayerSet([QgsMapCanvasLayer(mydset)])
####################################### Script for getting all raster values
# takes 11 minutes to run on (426,1332,2583)
#list = []
#for x in range(mydset.width()):
#x_coord = x
#print 'Doing ' +str(x) + 'x right now...'
#for y in range(mydset.height()):
#y_coord = y
#ident = mydset.dataProvider().identify(QgsPoint(x_coord, y_coord), \
#QgsRaster.IdentifyFormatValue)
#list.append(ident.results().values())
#print 'Length of list is: '
#print len(list)
#print 'Length of list[0] is: '
#print len(list[0])
############################################
#if ident.isValid():
#print ident.results()
def idw_interpolation(layer, parent_dialog):
"""Run interpolation using inverse distance weight algorithm
:param layer: Vector layer with drivetimes
:type layer: QgsVectorLayer
:param parent_dialog: A dialog that called this function.
:type parent_dialog: QProgressDialog
:returns raster_layer: Interpolated raster layer with drivetimes
:rtype raster_layer: QgsRasterLayer
"""
raster_layer = None
try:
Processing.initialize()
Processing.updateAlgsList()
output_raster = processing.runalg('gdalogr:gridinvdist', layer,
'minutes', 2, 0, 0, 0, 0, 0, 0, 0, 5,
"[temporary file]")
output_file = output_raster['OUTPUT']
file_info = QFileInfo(output_file)
base_name = file_info.baseName()
# retrieving the raster output , styling it and load it in Qgis
raster_layer = QgsRasterLayer(output_file, base_name)
except Exception as exception: # pylint: disable=broad-except
# noinspection PyCallByClass,PyTypeChecker,PyArgumentList
if parent_dialog:
display_warning_message_box(
parent_dialog, parent_dialog.tr('Error'),
parent_dialog.tr('Error loading isochrone map,'
'please check if you have processing '
'plugin installed '))
else:
display_warning_message_box(
parent_dialog, 'Error', 'Error loading isochrone map,'
'please check if you have processing '
'plugin installed ')
if raster_layer:
if raster_layer.isValid():
color_shader = QgsColorRampShader()
color_shader.setColorRampType(QgsColorRampShader.INTERPOLATED)
colors = {
'deep_green': '#1a9641',
'light_green': '#a6d96a',
'pale_yellow': '#ffffc0',
'light_red': '#fdae61',
'red': '#d7191c'
}
provider = raster_layer.dataProvider()
stats = provider.bandStatistics(1, QgsRasterBandStats.All,
raster_layer.extent(), 0)
values = {}
if stats:
min = stats.minimumValue
max = stats.maximumValue
stat_range = max - min
add = stat_range / 4
values[0] = min
value = min
for index in range(1, 4):
value += add
values[index] = value
values[4] = max
else:
display_warning_message_box(
parent_dialog, parent_dialog.tr('Error'),
parent_dialog.tr('Error loading isochrone map'
' Problem indexing the isochrones map'))
color_list = [
QgsColorRampShader.ColorRampItem(values[0],
QColor(colors['deep_green'])),
QgsColorRampShader.ColorRampItem(values[1],
QColor(
colors['light_green'])),
QgsColorRampShader.ColorRampItem(values[2],
QColor(
colors['pale_yellow'])),
QgsColorRampShader.ColorRampItem(values[3],
QColor(colors['light_red'])),
QgsColorRampShader.ColorRampItem(values[4],
QColor(colors['red']))
]
color_shader.setColorRampItemList(color_list)
raster_shader = QgsRasterShader()
raster_shader.setRasterShaderFunction(color_shader)
renderer = QgsSingleBandPseudoColorRenderer(
raster_layer.dataProvider(), 1, raster_shader)
raster_layer.setRenderer(renderer)
else:
if parent_dialog:
display_warning_message_box(
parent_dialog, parent_dialog.tr('Problem'),
parent_dialog.tr('Problem styling the isochrone map'))
else:
display_warning_message_box(
parent_dialog, 'Problem',
'Problem styling the isochrone map')
QgsMapLayerRegistry.instance().addMapLayers([raster_layer])
else:
if parent_dialog:
display_warning_message_box(
parent_dialog, parent_dialog.tr('Error'),
parent_dialog.tr('Error loading isochrone map '
'Could not load interpolated file!'))
else:
display_warning_message_box(
parent_dialog, 'Error', 'Error loading isochrone map '
'Could not load interpolated file!')
return raster_layer
def test_clipBoth(self):
"""Raster and Vector layers can be clipped
"""
# Create a vector layer
myName = 'padang'
myVectorLayer = QgsVectorLayer(VECTOR_PATH, myName, 'ogr')
myMessage = 'Did not find layer "%s" in path "%s"' % (myName,
VECTOR_PATH)
assert myVectorLayer.isValid(), myMessage
# Create a raster layer
myName = 'shake'
myRasterLayer = QgsRasterLayer(RASTERPATH, myName)
myMessage = 'Did not find layer "%s" in path "%s"' % (myName,
RASTERPATH)
assert myRasterLayer.isValid(), myMessage
# Create a bounding box
myViewportGeoExtent = [99.53, -1.22, 101.20, -0.36]
# Get the Hazard extents as an array in EPSG:4326
myHazardGeoExtent = [
myRasterLayer.extent().xMinimum(),
myRasterLayer.extent().yMinimum(),
myRasterLayer.extent().xMaximum(),
myRasterLayer.extent().yMaximum()
]
# Get the Exposure extents as an array in EPSG:4326
myExposureGeoExtent = [
myVectorLayer.extent().xMinimum(),
myVectorLayer.extent().yMinimum(),
myVectorLayer.extent().xMaximum(),
myVectorLayer.extent().yMaximum()
]
# Now work out the optimal extent between the two layers and
# the current view extent. The optimal extent is the intersection
# between the two layers and the viewport.
# Extent is returned as an array [xmin,ymin,xmax,ymax]
myGeoExtent = getOptimalExtent(myHazardGeoExtent, myExposureGeoExtent,
myViewportGeoExtent)
# Clip the vector to the bbox
myResult = clipLayer(myVectorLayer, myGeoExtent)
# Check the output is valid
assert os.path.exists(myResult)
readSafeLayer(myResult)
# Clip the raster to the bbox
myResult = clipLayer(myRasterLayer, myGeoExtent)
# Check the output is valid
assert os.path.exists(myResult)
readSafeLayer(myResult)
# -------------------------------
# Check the extra keywords option
# -------------------------------
# Clip the vector to the bbox
myResult = clipLayer(myVectorLayer,
myGeoExtent,
theExtraKeywords={'kermit': 'piggy'})
# Check the output is valid
assert os.path.exists(myResult)
L = readSafeLayer(myResult)
kwds = L.get_keywords()
myMessage = 'Extra keyword was not found in %s: %s' % (myResult, kwds)
assert kwds['kermit'] == 'piggy'
# Clip the raster to the bbox
myResult = clipLayer(myRasterLayer,
myGeoExtent,
theExtraKeywords={'zoot': 'animal'})
# Check the output is valid
assert os.path.exists(myResult)
L = readSafeLayer(myResult)
kwds = L.get_keywords()
myMessage = 'Extra keyword was not found in %s: %s' % (myResult, kwds)
assert kwds['zoot'] == 'animal', myMessage
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.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 = []
myLayers.append(self.mLineLayer.id())
myLayers.append(self.mPolygonLayer.id())
self.mMapRenderer.setLayerSet(myLayers)
self.mMapRenderer.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.setMapRenderer(self.mMapRenderer)
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.mMapRenderer.setLayerSet(myLayers)
self.mMapRenderer.setExtent(self.mPointLayer.extent())
#Set feature blending for line layer
self.mLineLayer.setFeatureBlendMode(QPainter.CompositionMode_Plus)
checker = QgsRenderChecker()
checker.setControlName("expected_vector_featureblendmodes")
checker.setMapRenderer(self.mMapRenderer)
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.mMapRenderer.setLayerSet(myLayers)
self.mMapRenderer.setExtent(self.mPointLayer.extent())
#Set feature blending for line layer
self.mLineLayer.setLayerTransparency(50)
checker = QgsRenderChecker()
checker.setControlName("expected_vector_layertransparency")
checker.setMapRenderer(self.mMapRenderer)
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.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 idw_interpolation(layer, parent_dialog):
"""Run interpolation using inverse distance weight algorithm
:param layer: Vector layer with drivetimes
:type layer: QgsVectorLayer
:param parent_dialog: A dialog that called this function.
:type parent_dialog: QProgressDialog
:returns raster_layer: Interpolated raster layer with drivetimes
:rtype raster_layer: QgsRasterLayer
"""
raster_layer = None
try:
Processing.initialize()
Processing.updateAlgsList()
output_raster = processing.runalg(
'gdalogr:gridinvdist',
layer,
'minutes',
2, 0, 0, 0, 0, 0, 0, 0, 5,
"[temporary file]")
output_file = output_raster['OUTPUT']
file_info = QFileInfo(output_file)
base_name = file_info.baseName()
# retrieving the raster output , styling it and load it in Qgis
raster_layer = QgsRasterLayer(output_file, base_name)
except Exception as exception: # pylint: disable=broad-except
# noinspection PyCallByClass,PyTypeChecker,PyArgumentList
if parent_dialog:
display_warning_message_box(
parent_dialog,
parent_dialog.tr(
'Error'),
parent_dialog.tr('Error loading isochrone map,'
'please check if you have processing '
'plugin installed '))
else:
display_warning_message_box(
parent_dialog,
'Error',
'Error loading isochrone map,'
'please check if you have processing '
'plugin installed ')
if raster_layer:
if raster_layer.isValid():
color_shader = QgsColorRampShader()
color_shader.setColorRampType(QgsColorRampShader.INTERPOLATED)
colors = {
'deep_green': '#1a9641',
'light_green': '#a6d96a',
'pale_yellow': '#ffffc0',
'light_red': '#fdae61',
'red': '#d7191c'
}
provider = raster_layer.dataProvider()
stats = provider.bandStatistics(
1,
QgsRasterBandStats.All,
raster_layer.extent(),
0)
values = {}
if stats:
min = stats.minimumValue
max = stats.maximumValue
stat_range = max - min
add = stat_range / 4
values[0] = min
value = min
for index in range(1, 4):
value += add
values[index] = value
values[4] = max
else:
display_warning_message_box(
parent_dialog,
parent_dialog.tr(
'Error'),
parent_dialog.tr('Error loading isochrone map'
' Problem indexing the isochrones map'))
color_list = [
QgsColorRampShader.ColorRampItem(
values[0],
QColor(colors['deep_green'])),
QgsColorRampShader.ColorRampItem(
values[1],
QColor(colors['light_green'])),
QgsColorRampShader.ColorRampItem(
values[2],
QColor(colors['pale_yellow'])),
QgsColorRampShader.ColorRampItem(
values[3],
QColor(colors['light_red'])),
QgsColorRampShader.ColorRampItem(
values[4],
QColor(colors['red']))
]
color_shader.setColorRampItemList(color_list)
raster_shader = QgsRasterShader()
raster_shader.setRasterShaderFunction(color_shader)
renderer = QgsSingleBandPseudoColorRenderer(
raster_layer.dataProvider(),
1,
raster_shader)
raster_layer.setRenderer(renderer)
else:
if parent_dialog:
display_warning_message_box(
parent_dialog,
parent_dialog.tr(
'Problem'),
parent_dialog.tr('Problem styling the isochrone map'))
else:
display_warning_message_box(
parent_dialog,
'Problem',
'Problem styling the isochrone map')
QgsMapLayerRegistry.instance().addMapLayers([raster_layer])
else:
if parent_dialog:
display_warning_message_box(
parent_dialog,
parent_dialog.tr(
'Error'),
parent_dialog.tr('Error loading isochrone map '
'Could not load interpolated file!'))
else:
display_warning_message_box(
parent_dialog,
'Error',
'Error loading isochrone map '
'Could not load interpolated file!')
return raster_layer
dataOut = tempfile.mktemp('.tif')
except Exception, e:
raise Exception(
'Problem creating temporary file to store raster data: ' + str(e))
# TODO: Work out if the response is an XML error
update.emit({'progress': 10, 'message': 'Downloading file...'})
urllib.urlretrieve(bigURL, dataOut)
# Load data as QgsRasterLayer and then re-save it, ensuring it has the correct projection info
a = QgsRasterLayer(dataOut, "temporary raster layer")
# Double-confirm projection info (sometimes WCS has it in the meta but not the file)
crs = a.crs()
crs.createFromId(int(srs.split(':')[1]))
a.setCrs(crs)
update.emit({'progress': 90, 'message': 'Saving file...'})
writer = QgsRasterFileWriter(output_file)
pipe = QgsRasterPipe()
width, height = a.width(), a.height()
extent = a.extent()
provider = a.dataProvider()
pipe.set(provider.clone())
writer.writeRaster(pipe, width, height, extent, a.crs())
a = None
pipe = None
provider = None
# Delete temp file
os.remove(dataOut)
return output_file
def test_clip_both(self):
"""Raster and Vector layers can be clipped."""
# Create a vector layer
layer_name = 'padang'
vector_layer = QgsVectorLayer(VECTOR_PATH, layer_name, 'ogr')
message = (
'Did not find layer "%s" in path "%s"' % (layer_name, VECTOR_PATH))
assert vector_layer.isValid(), message
# Create a raster layer
layer_name = 'shake'
raster_layer = QgsRasterLayer(RASTERPATH, layer_name)
message = (
'Did not find layer "%s" in path "%s"' % (layer_name, RASTERPATH))
assert raster_layer.isValid(), message
# Create a bounding box
view_port_geo_extent = [99.53, -1.22, 101.20, -0.36]
# Get the Hazard extents as an array in EPSG:4326
hazard_geo_extent = [
raster_layer.extent().xMinimum(),
raster_layer.extent().yMinimum(),
raster_layer.extent().xMaximum(),
raster_layer.extent().yMaximum()
]
# Get the Exposure extents as an array in EPSG:4326
exposure_geo_extent = [
vector_layer.extent().xMinimum(),
vector_layer.extent().yMinimum(),
vector_layer.extent().xMaximum(),
vector_layer.extent().yMaximum()
]
# Now work out the optimal extent between the two layers and
# the current view extent. The optimal extent is the intersection
# between the two layers and the viewport.
# Extent is returned as an array [xmin,ymin,xmax,ymax]
geo_extent = get_optimal_extent(
hazard_geo_extent, exposure_geo_extent, view_port_geo_extent)
# Clip the vector to the bbox
result = clip_layer(vector_layer, geo_extent)
# Check the output is valid
assert os.path.exists(result.source())
read_safe_layer(result.source())
# Clip the raster to the bbox
result = clip_layer(raster_layer, geo_extent)
# Check the output is valid
assert os.path.exists(result.source())
read_safe_layer(result.source())
# -------------------------------
# Check the extra keywords option
# -------------------------------
# Clip the vector to the bbox
result = clip_layer(
vector_layer, geo_extent, extra_keywords={'title': 'piggy'})
# Check the output is valid
assert os.path.exists(result.source())
safe_layer = read_safe_layer(result.source())
keywords = safe_layer.get_keywords()
# message = 'Extra keyword was not found in %s: %s' % (myResult,
# keywords)
assert keywords['title'] == 'piggy'
# Clip the raster to the bbox
result = clip_layer(
raster_layer, geo_extent, extra_keywords={'email': 'animal'})
# Check the output is valid
assert os.path.exists(result.source())
safe_layer = read_safe_layer(result.source())
keywords = safe_layer.get_keywords()
message = ('Extra keyword was not found in %s: %s' %
(result.source(), keywords))
assert keywords['email'] == 'animal', message
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
import glob, os
from PyQt4.QtCore import QFileInfo
from qgis.core import QgsRasterLayer, QgsRectangle
os.chdir(Select_directory)
rlist = []
extent = QgsRectangle()
extent.setMinimal()
for raster in glob.glob("*.tif"):
fileInfo = QFileInfo(raster)
baseName = fileInfo.baseName()
rlayer = QgsRasterLayer(raster, baseName)
# Combine raster layers to list
rlist.append(rlayer)
# Combine raster extents
extent.combineExtentWith(rlayer.extent())
# Get extent
xmin = extent.xMinimum()
xmax = extent.xMaximum()
ymin = extent.yMinimum()
ymax = extent.yMaximum()
# Run algorithm and set relevant parameters
processing.runalg(
"grass:r.series", {
"input": rlist,
"-n": False,
"method": 3,
"range": '-10000000000,10000000000',
"GRASS_REGION_PARAMETER": "%f,%f,%f,%f" % (xmin, xmax, ymin, ymax),
"GRASS_REGION_CELLSIZE_PARAMETER": 0,
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
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 ProcessNBR(self, inFileA, inFileB):
msg = u"NBR Processing for " + self.sceneID + "..."
iface.mainWindow().statusBar().showMessage(msg)
QgsMessageLog.logMessage(msg, level=QgsMessageLog.INFO)
try:
calculatorEntryList = []
tempOutFile = self.outFileNBR.replace("NBR", "NBR_temp")
fileInfo1 = QFileInfo(inFileA)
baseName1 = fileInfo1.baseName()
newLayer1 = QgsRasterLayer(inFileA, baseName1)
boh1 = QgsRasterCalculatorEntry()
boh1.ref = "boh@1"
boh1.bandNumber = 1
calculatorEntryList.append(boh1)
boh1.raster = newLayer1
if newLayer1.isValid():
extents = newLayer1.extent()
colCt = newLayer1.width()
rowCt = newLayer1.height()
else:
raise IOError(u"Error, Invalid layer read!")
fileInfo2 = QFileInfo(inFileB)
baseName2 = fileInfo2.baseName()
newLayer2 = QgsRasterLayer(inFileB, baseName2)
boh2 = QgsRasterCalculatorEntry()
boh2.ref = "boh@2"
boh2.bandNumber = 1
calculatorEntryList.append(boh2)
boh2.raster = newLayer2
if not newLayer2.isValid():
raise IOError(u"Error, Invalid layer read!")
formula = ("(((boh@1 != 0 AND boh@2 != 0) * "
"(boh@1 - boh@2) / (boh@1 + boh@2) * 1000) + "
"((boh@1 = 0 OR boh@2 = 0) * " + str(self.minShort) +
"))")
# Process calculation with input extent and resolution
calc = QgsRasterCalculator(formula, tempOutFile, 'GTiff', extents,
colCt, rowCt, calculatorEntryList)
result = calc.processCalculation()
if result != 0:
raise RuntimeError(u"Raster calculator failed.")
# convert Raster Calculator result to int 16
self.Float2IntTif(tempOutFile, self.outFileNBR)
except:
raise RuntimeError(u"Unspecified error when calculating NBR")
finally:
# cleanup
calculatorEntryList = None
fileInfo1 = None
baseName1 = None
fileInfo2 = None
baseName2 = None
formula = None
boh1 = None
boh2 = None
calc = None
newLayer1 = None
newLayer2 = None
del calculatorEntryList
del fileInfo1
del baseName1
del fileInfo2
del baseName2
del formula
del boh1
del boh2
del calc
del newLayer1
del newLayer2
gc.collect()
msg = u"NBR Processing for " + self.sceneID + " Completed"
iface.mainWindow().statusBar().showMessage(msg)
QgsMessageLog.logMessage(msg, level=QgsMessageLog.INFO)
iface.mainWindow().statusBar().showMessage("")
return result
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 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"
def raster_calc_qgis(ecuacion, raster_inputs, raster_salida):
n_variables = len(raster_inputs)
entries = []
#abre el archivo raster1
fileInfo = QFileInfo(raster_inputs[0])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer1 = QgsRasterLayer(path, baseName)
var1 = QgsRasterCalculatorEntry()
var1.ref = 'layer1@1'
var1.raster = layer1
var1.bandNumber = 1
entries.append(var1)
if n_variables == 2:
fileInfo = QFileInfo(raster_inputs[1])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer2 = QgsRasterLayer(path, baseName)
var2 = QgsRasterCalculatorEntry()
var2.ref = 'layer2@1'
var2.raster = layer2
var2.bandNumber = 1
entries.append(var2)
elif n_variables == 3:
fileInfo = QFileInfo(raster_inputs[1])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer2 = QgsRasterLayer(path, baseName)
var2 = QgsRasterCalculatorEntry()
var2.ref = 'layer2@1'
var2.raster = layer2
var2.bandNumber = 1
entries.append(var2)
fileInfo = QFileInfo(raster_inputs[2])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer3 = QgsRasterLayer(path, baseName)
var3 = QgsRasterCalculatorEntry()
var3.ref = 'layer3@1'
var3.raster = layer3
var3.bandNumber = 1
entries.append(var3)
elif n_variables == 4:
fileInfo = QFileInfo(raster_inputs[1])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer2 = QgsRasterLayer(path, baseName)
var2 = QgsRasterCalculatorEntry()
var2.ref = 'layer2@1'
var2.raster = layer2
var2.bandNumber = 1
entries.append(var2)
fileInfo = QFileInfo(raster_inputs[2])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer3 = QgsRasterLayer(path, baseName)
var3 = QgsRasterCalculatorEntry()
var3.ref = 'layer3@1'
var3.raster = layer3
var3.bandNumber = 1
entries.append(var3)
fileInfo = QFileInfo(raster_inputs[3])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer4 = QgsRasterLayer(path, baseName)
var4 = QgsRasterCalculatorEntry()
var4.ref = 'layer4@1'
var4.raster = layer4
var4.bandNumber = 1
entries.append(var4)
elif n_variables == 5:
fileInfo = QFileInfo(raster_inputs[1])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer2 = QgsRasterLayer(path, baseName)
var2 = QgsRasterCalculatorEntry()
var2.ref = 'layer2@1'
var2.raster = layer2
var2.bandNumber = 1
entries.append(var2)
fileInfo = QFileInfo(raster_inputs[2])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer3 = QgsRasterLayer(path, baseName)
var3 = QgsRasterCalculatorEntry()
var3.ref = 'layer3@1'
var3.raster = layer3
var3.bandNumber = 1
entries.append(var3)
fileInfo = QFileInfo(raster_inputs[3])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer4 = QgsRasterLayer(path, baseName)
var4 = QgsRasterCalculatorEntry()
var4.ref = 'layer4@1'
var4.raster = layer4
var4.bandNumber = 1
entries.append(var4)
fileInfo = QFileInfo(raster_inputs[4])
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer5 = QgsRasterLayer(path, baseName)
var5 = QgsRasterCalculatorEntry()
var5.ref = 'layer5@1'
var5.raster = layer5
var5.bandNumber = 1
entries.append(var5)
calc = QgsRasterCalculator(ecuacion, raster_salida,
'GTiff', layer1.extent(), layer1.width(),
layer1.height(), entries)
calc.processCalculation()
class ProjectModule(Module):
def __init__(self, plugin):
super(ProjectModule, self).__init__(plugin)
# Project settings
# self.projectLayerView = None # QgsLayerTreeView()
self.metadata = None # Metadata()
self.projectGroupIndex = -1
self.drawingsGroupIndex = -1
self.drawingsGroupName = ''
self.geoLayer = None # QgsRasterLayer()
self.plan = None # Collection()
self.section = None # Collection()
self.grid = None # Collection()
self.site = None # Collection()
self._collections = {} # {Collection()}
# Tools
self.identifyMapTool = None # MapToolIndentifyItems()
# Internal variables
self._mapAction = MapAction.MoveMap
self._filterAction = FilterAction.ExclusiveHighlightFilter
self._drawingAction = DrawingAction.NoDrawingAction
self._layerSnappingAction = None # LayerSnappingAction()
self._itemLogPath = ''
# Create the gui when the plugin is first created
def initGui(self):
dock = ProjectDock(self._plugin.iface.mainWindow())
self._initDockGui(dock, Qt.LeftDockWidgetArea, self._plugin.pluginAction)
# self.projectLayerView = QgsLayerTreeView()
# self._layerSnappingAction = LayerSnappingAction(self._plugin.iface, self.projectLayerView)
# self._plugin.iface.legendInterface().addLegendLayerAction(
# self._layerSnappingAction, '', 'arksnap', QgsMapLayer.VectorLayer, True)
"""
# Create the Layer Model and View
# TODO Should only show our subgroup but crashes!
# self.projectLayerModel
# = QgsLayerTreeModel(QgsProject.instance().layerTreeRoot().findGroup(Config.projectGroupName), self);
self.projectLayerModel = QgsLayerTreeModel(QgsProject.instance().layerTreeRoot(), self)
self.projectLayerModel.setFlag(QgsLayerTreeModel.ShowLegend)
self.projectLayerModel.setFlag(QgsLayerTreeModel.ShowLegendAsTree)
self.projectLayerModel.setFlag(QgsLayerTreeModel.AllowNodeReorder, True)
self.projectLayerModel.setFlag(QgsLayerTreeModel.AllowNodeRename, False)
self.projectLayerModel.setFlag(QgsLayerTreeModel.AllowNodeChangeVisibility)
self.projectLayerModel.setFlag(QgsLayerTreeModel.AllowLegendChangeState)
self.projectLayerModel.setFlag(QgsLayerTreeModel.AllowSymbologyChangeState)
self.projectLayerModel.setAutoCollapseLegendNodes(-1)
self.projectLayerView.setModel(self.projectLayerModel)
menuProvider = LayerTreeMenu(self, self.projectLayerView)
self.projectLayerView.setMenuProvider(menuProvider)
self.projectLayerView.setCurrentLayer(self._plugin.iface.activeLayer())
self.projectLayerView.doubleClicked.connect(self._plugin.iface.actionOpenTable().trigger)
self.projectLayerView.currentLayerChanged.connect(self._plugin.mapCanvas().setCurrentLayer)
self.projectLayerView.currentLayerChanged.connect(self._plugin.iface.setActiveLayer)
self._plugin.iface.currentLayerChanged.connect(self.projectLayerView.setCurrentLayer)
self.layerViewAction = self.addDockAction(
':/plugins/ark/tree.svg', self.tr(u'Toggle Layer View'), callback=self._toggleLayerView, checkable=True)
self.layerViewAction.setChecked(True)
"""
# Add Settings to the toolbar TODO move to end of dock?
self.addDockSeparator()
self.addDockAction(':/plugins/ark/settings.svg',
self._plugin.tr(u'Project Settings'), self._triggerSettingsDialog)
# Init the identify tool and add to the toolbar
self.identifyAction = self.addDockAction(
':/plugins/ark/filter/identify.png',
self._plugin.tr(u'Identify Items'),
callback=self.triggerIdentifyAction,
checkable=True
)
self.identifyMapTool = MapToolIndentifyItems(self._plugin)
self.identifyMapTool.setAction(self.identifyAction)
# Init the Load Item tool and add to the toolbar
self.showItemAction = self.addDockAction(
':/plugins/ark/filter/showContext.png',
self._plugin.tr(u'Show Item'),
callback=self._showItem
)
# If the project or layers or legend indexes change make sure we stay updated
self._plugin.legendInterface().groupIndexChanged.connect(self._groupIndexChanged)
# Load the project settings when project is loaded
def loadProject(self):
if Settings.isProjectConfigured():
self.projectGroupIndex = layers.createLayerGroup(self._plugin.iface, Config.projectGroupName)
# Load the layer collections
self._addCollection('grid')
self._addCollection('plan')
self._addCollection('section')
self._addCollection('site')
self.drawingsGroupName = Config.drawings['context']['layersGroupName']
if (self.collection('grid').loadCollection()
and self.collection('plan').loadCollection()
and self.collection('section').loadCollection()
and self.collection('site').loadCollection()):
self._dock.loadProject(self._plugin)
if self.collection('plan').isLogged():
self._itemLogPath = os.path.join(self.collection('plan').projectPath,
self.collection('plan').settings.collectionPath,
'log/itemLog.csv')
if not QFile.exists(self._itemLogPath):
fd = open(self._itemLogPath, 'a')
fd.write('timestamp,action,siteCode,classCode,itemId\n')
fd.close()
# TODO Think of a better way...
# self.metadata = Metadata(self._dock.widget.sourceWidget)
# self.metadata.metadataChanged.connect(self.updateMapToolAttributes)
self._initialised = True
return True
return False
# Close the project
def closeProject(self):
if self.identifyMapTool.action() and self.identifyMapTool.action().isChecked():
self._plugin.iface.actionPan().trigger()
# TODO Unload the drawing tools!
self._dock.closeProject()
# self.metadata.metadataChanged.disconnect(self.updateMapToolAttributes)
# Unload the layers
for collection in self._collections:
self._collections[collection].unload()
del self._collections
self._collections = {}
self._plugin.iface.legendInterface().removeLegendLayerAction(self._layerSnappingAction)
self._initialised = False
# Project
def crs(self):
return self._plugin.iface.mapCanvas().mapSettings().destinationCrs()
def crsId(self):
return self.crs().authid()
def projectFolder(self):
proj = Project.dir()
proj.cdUp()
return proj.absolutePath()
def configure(self):
wizard = ProjectWizard(self._plugin.iface.mainWindow())
ok = wizard.exec_()
if ok:
if wizard.newProject():
if Project.exists():
Project.write()
Project.clear()
projectFolderPath = os.path.join(wizard.projectFolder(), 'project')
if not QDir(projectFolderPath).mkpath('.'):
return False
projectFilePath = os.path.join(projectFolderPath, wizard.projectFilename() + '.qgs')
Project.setFileName(projectFilePath)
Settings.setProjectCode(wizard.project().projectCode())
Settings.setProjectName(wizard.project().projectName())
Settings.setSiteCode(wizard.project().siteCode())
if not Project.title():
Project.setTitle(wizard.project().projectCode() + ' - ' + wizard.project().projectName())
self._initialised = Project.write()
if self._initialised:
# We always want the site collection
self._addCollection('site')
self.collection('site').loadCollection()
# Add the Site Location if entered
location = wizard.projectLocation()
if not location.isEmpty():
siteCode = wizard.project().siteCode() if wizard.project().siteCode() else wizard.project().projectCode()
item = Item(siteCode, 'site', siteCode)
source = Source('other', item)
audit = Audit(Settings.userFullName(), utils.timestamp())
itemFeature = ItemFeature(item, 'loc', None, source, 'New Project Wizard', audit)
layer = self.collection('site').layer('points')
feature = QgsFeature(layer.pendingFields(), 0)
feature.setGeometry(QgsGeometry(location))
attributes = itemFeature.toFeature(feature)
layers.addFeatures([feature], layer)
# Temp load of other collection, later do on demand
self._addCollection('plan')
self.collection('plan').loadCollection()
self._addCollection('section')
self.collection('section').loadCollection()
self._addCollection('grid')
self.collection('grid').loadCollection()
# self._configureDrawing('context')
# self._configureDrawing('plan')
# self._configureDrawing('section')
Settings.setProjectConfigured()
return ok
def _triggerSettingsDialog(self):
if Settings.isProjectConfigured():
self.showSettingsDialog()
else:
self.configure()
def _configureDrawing(self, drawing):
Settings.drawingDir(drawing).mkpath('.')
Settings.georefDrawingDir(drawing).mkpath('.')
def _setDrawing(self, pmd):
self.metadata.setSiteCode(pmd.siteCode)
self.metadata.setClassCode(pmd.sourceClass)
if pmd.sourceId > 0:
self.metadata.setItemId(pmd.sourceId)
self.metadata.setSourceId(pmd.sourceId)
self.metadata.setSourceCode('drawing')
self.metadata.setSourceClass(pmd.sourceClass)
self.metadata.setSourceFile(pmd.filename)
self.metadata.setEditor(Settings.userFullName())
def _groupIndexChanged(self, oldIndex, newIndex):
if (oldIndex == self.projectGroupIndex):
self.projectGroupIndex = newIndex
def loadGeoLayer(self, geoFile, zoomToLayer=True):
# TODO Check if already loaded, remove old one?
self.geoLayer = QgsRasterLayer(geoFile.absoluteFilePath(), geoFile.completeBaseName())
self.geoLayer.renderer().setOpacity(Settings.drawingTransparency() / 100.0)
QgsMapLayerRegistry.instance().addMapLayer(self.geoLayer)
if (self.drawingsGroupIndex < 0):
self.drawingsGroupIndex = layers.createLayerGroup(
self._plugin.iface, self.drawingsGroupName, Config.projectGroupName)
self._plugin.legendInterface().moveLayer(self.geoLayer, self.drawingsGroupIndex)
if zoomToLayer:
self._plugin.mapCanvas().setExtent(self.geoLayer.extent())
def clearDrawings(self):
if (self.drawingsGroupIndex >= 0):
self.drawingsLayerTreeGroup().removeAllChildren()
def drawingsLayerTreeGroup(self):
if (self.drawingsGroupIndex >= 0):
return QgsProject.instance().layerTreeRoot().findGroup(self.drawingsGroupName)
else:
return None
def isArkGroup(self, name):
for collection in self._collections:
if self._collections[collection].isCollectionGroup(name):
return True
return name == Config.projectGroupName or name == self.drawingsGroupName
def isArkLayer(self, layerId):
for collection in self._collections:
if self._collections[collection].isCollectionLayer(layerId):
return True
return False
def _pluginStylesPath(self):
return os.path.join(self._plugin.pluginPath, 'ark', 'styles')
def _styleFile(self, layerPath, layerName):
# First see if the layer itself has a default style saved
filePath = layerPath + '/' + layerName + '.qml'
if QFile.exists(filePath):
return filePath
# Next see if the layer name has a style in the styles folder (which may
# be a special folder, the site folder or the plugin folder)
filePath = Settings.stylePath() + '/' + layerName + '.qml'
if QFile.exists(filePath):
return filePath
# Finally, check the plugin folder for the default style
filePath = self._pluginStylesPath() + '/' + layerName + '.qml'
if QFile.exists(filePath):
return filePath
# If we didn't find that then something is wrong!
return ''
def _addCollection(self, collection):
config = Config.collections[collection]
path = config['path']
bufferPath = path + '/buffer'
logPath = path + '/log'
config['collection'] = collection
config['crs'] = self.crs()
config['parentGroupName'] = Config.projectGroupName
for layer in config['layers']:
name = layer['name']
layer['fields'] = config['fields']
layer['multi'] = config['multi']
layer['crs'] = self.crs()
layer['path'] = layers.shapeFilePath(path, name)
layer['stylePath'] = layers.styleFilePath(self._pluginStylesPath(), name)
layer['buffer'] = config['buffer']
if config['buffer']:
bufferName = name + Config.bufferSuffix
layer['bufferName'] = bufferName
layer['bufferName'] = bufferName
layer['bufferPath'] = layers.shapeFilePath(bufferPath, bufferName)
else:
layer['bufferName'] = ''
layer['bufferPath'] = ''
layer['log'] = config['log']
if config['log']:
logName = name + Config.logSuffix
layer['logName'] = logName
layer['logPath'] = layers.shapeFilePath(logPath, logName)
else:
layer['logName'] = ''
layer['logPath'] = ''
settings = CollectionSettings.fromArray(config)
if config['item']:
self._collections[collection] = ItemCollection(self._plugin.iface, self.projectFolder(), settings)
else:
self._collections[collection] = Collection(self._plugin.iface, self.projectFolder(), settings)
def addDockSeparator(self):
self._dock.toolbar.addSeparator()
def addDockAction(self, iconPath, text, callback=None, enabled=True, checkable=False, tip=None, whatsThis=None):
action = QAction(QIcon(iconPath), text, self._dock)
if callback is not None:
action.triggered.connect(callback)
action.setEnabled(enabled)
action.setCheckable(checkable)
if tip is not None:
action.setStatusTip(tip)
if whatsThis is not None:
action.setWhatsThis(whatsThis)
self._dock.toolbar.addAction(action)
# self.actions.append(action)
return action
def collection(self, collection):
if collection in self._collections:
return self._collections[collection]
return None
# Identify Tool
def triggerIdentifyAction(self, checked):
if checked:
self._plugin.mapCanvas().setMapTool(self.identifyMapTool)
else:
self._plugin.mapCanvas().unsetMapTool(self.identifyMapTool)
# Show Items Tool
def _showItem(self):
classCodes = sorted(set(self.collection('plan').uniqueValues('class')))
dialog = SelectItemDialog(Settings.siteCodes(), Settings.siteCode(),
classCodes, self._plugin.iface.mainWindow())
if dialog.exec_():
self.drawingModule.showItem(dialog.item(), dialog.loadDrawings(), dialog.zoomToItem())
# Plan Tools
def loadDrawing(self, item, zoomToDrawing=True):
if not Config.classCodes[item.classCode()]['drawing']:
return
drawingDir = Settings.georefDrawingDir(item.classCode())
drawingDir.setFilter(QDir.Files | QDir.NoDotAndDotDot)
name = item.name()
nameList = []
nameList.append(name + '.png')
nameList.append(name + '.tif')
nameList.append(name + '.tiff')
nameList.append(name + '_*.png')
nameList.append(name + '_*.tif')
nameList.append(name + '_*.tiff')
drawingDir.setNameFilters(nameList)
drawings = drawingDir.entryInfoList()
for drawing in drawings:
self._setDrawing(Drawing(drawing))
self._plugin.loadGeoLayer(drawing, zoomToDrawing)
def loadSourceDrawings(self, item, clearDrawings=False):
if item.isInvalid():
return
sourceKeys = set()
sourceKeys.add(item)
itemRequest = item.featureRequest()
for feature in self.collection('plan').layer('polygons').getFeatures(itemRequest):
source = Source(feature)
if source.item().isValid():
sourceKeys.add(source.item())
for feature in self.collection('plan').layer('lines').getFeatures(itemRequest):
source = Source(feature)
if source.item.isValid():
sourceKeys.add(source.item())
for feature in self.collection('plan').layer('points').getFeatures(itemRequest):
source = Source(feature)
if source.item().isValid():
sourceKeys.add(source.item())
if clearDrawings and len(sourceKeys) > 0:
self.clearDrawings()
for sourceKey in sorted(sourceKeys):
self.loadDrawing(sourceKey)
# Layer Methods
def mergeBuffers(self):
self._mergeBuffers(self.collection('plan'))
self._mergeBuffers(self.collection('section'))
self._mergeBuffers(self.collection('site'))
def _mergeBuffers(self, collection):
# Check the layers are writable
name = collection.settings.collectionGroupName
if not collection.isWritable():
self._plugin.showCriticalMessage(
name + ' layers are not writable! Please correct the permissions and log out.', 0)
return
# Check the buffers contain valid data
errors = self._preMergeBufferCheck(collection.buffer('points'))
errors.extend(self._preMergeBufferCheck(collection.buffer('lines')))
errors.extend(self._preMergeBufferCheck(collection.buffer('polygons')))
if len(errors) > 0:
dialog = ItemFeatureErrorDialog()
dialog.loadErrors(errors)
dialog.exec_()
if not dialog.ignoreErrors():
return
# Update the audit attributes
timestamp = utils.timestamp()
user = Settings.userFullName()
self._preMergeBufferUpdate(collection.buffer('points'), timestamp, user)
self._preMergeBufferUpdate(collection.buffer('lines'), timestamp, user)
self._preMergeBufferUpdate(collection.buffer('polygons'), timestamp, user)
# Finally actually merge the data
if collection.mergeBuffers('Merge data', timestamp):
self._plugin.showInfoMessage(name + ' data successfully merged.')
# TODO pass current Item...
self._logItemAction(Item(), 'Merge Buffers', timestamp)
# TODO Signal out layers merged for schematic dock to catch
# if self._editSchematic:
# self._editSchematic = False
# self._dock.activateSchematicCheck()
# self._findContext()
else:
self._plugin.showCriticalMessage(
name + ' data merge failed! Some data has not been saved, please check your data.', 5)
def _preMergeBufferCheck(self, layer):
errors = []
row = 0
for feature in layer.getFeatures():
# Set up the error template
error = ItemFeatureError()
error.layer = layer.name()
error.row = row
row = row + 1
error.fid = feature.id()
error.feature.fromFeature(feature)
# Feature must be valid
if not feature.isValid():
error.field = 'feature'
error.message = 'Invalid Feature'
errors.append(copy.deepcopy(error))
# Geometry must be valid
error.field = 'geometry'
if feature.geometry() is None:
error.message = 'No Geometry'
errors.append(copy.deepcopy(error))
elif feature.geometry().isEmpty():
error.message = 'Empty Geometry'
errors.append(copy.deepcopy(error))
else:
error.message = 'Invalid Geometry'
geomErrs = feature.geometry().validateGeometry()
# Ignore the last error, it is just a total
for err in geomErrs[:-1]:
error.message = err.what()
errors.append(copy.deepcopy(error))
# Key attributes that must always be populated
if utils.isEmpty(feature.attribute('site')):
error.field = 'site'
error.message = 'Site Code is required'
errors.append(copy.deepcopy(error))
if utils.isEmpty(feature.attribute('class')):
error.field = 'class'
error.message = 'Class Code is required'
errors.append(copy.deepcopy(error))
if utils.isEmpty(feature.attribute('id')):
error.field = 'id'
error.message = 'ID is required'
errors.append(copy.deepcopy(error))
if utils.isEmpty(feature.attribute('category')):
error.field = 'category'
error.message = 'Category is required'
errors.append(copy.deepcopy(error))
if utils.isEmpty(feature.attribute('source_cd')):
error.field = 'source_cd'
error.message = 'Source Code is required'
error.ignore = True
# errors.append(copy.deepcopy(error))
# Source attributes required depend on the source type
if feature.attribute('source_cd') == 'creator' or feature.attribute('source_cd') == 'other':
if utils.isEmpty(feature.attribute('comment')):
error.field = 'source_cd'
error.message = 'Comment is required for Source type of Creator or Other'
error.ignore = True
# errors.append(copy.deepcopy(error))
elif feature.attribute('source_cd') == 'survey':
if utils.isEmpty(feature.attribute('file')):
error.field = 'source_cd'
error.message = 'Filename is required for Source type of Survey'
error.ignore = True
# errors.append(copy.deepcopy(error))
else: # 'drw', 'unc', 'skt', 'cln', 'mod', 'inf'
if ((feature.attribute('source_cd') == 'drawing' or feature.attribute('source_cd') == 'unchecked')
and utils.isEmpty(feature.attribute('file'))):
error.field = 'source_cd'
error.message = 'Filename is required for Source type of Drawing'
error.ignore = True
# errors.append(copy.deepcopy(error))
if (utils.isEmpty(feature.attribute('source_cl')) or utils.isEmpty(feature.attribute('source_id'))):
error.field = 'source_cd'
error.message = 'Source Class and ID is required'
error.ignore = True
# errors.append(copy.deepcopy(error))
return errors
def _preMergeBufferUpdate(self, layer, timestamp, user):
createdIdx = layer.fieldNameIndex('created')
creatorIdx = layer.fieldNameIndex('creator')
modifiedIdx = layer.fieldNameIndex('modified')
modifierIdx = layer.fieldNameIndex('modifier')
for feature in layer.getFeatures():
if utils.isEmpty(feature.attribute('created')):
layer.changeAttributeValue(feature.id(), createdIdx, timestamp)
layer.changeAttributeValue(feature.id(), creatorIdx, user)
else:
layer.changeAttributeValue(feature.id(), modifiedIdx, timestamp)
layer.changeAttributeValue(feature.id(), modifierIdx, user)
def resetBuffers(self):
self.collection('plan').resetBuffers('Clear Buffers')
self.collection('section').resetBuffers('Clear Buffers')
self.collection('site').resetBuffers('Clear Buffers')
# TODO Signal out layers reset for schematic dock to catch
# if self._editSchematic:
# self._editSchematic = False
# self._dock.activateSchematicCheck()
def _confirmDelete(self, itemId, title='Confirm Delete Item', label=None):
if not label:
label = 'This action ***DELETES*** item ' + \
str(itemId) + ' from the saved data.\n\nPlease enter the item ID to confirm.'
confirm, ok = QInputDialog.getText(None, title, label, text='')
return ok and confirm == str(itemId)
def _logItemAction(self, item, action, timestamp=None):
if self.collection('plan').settings.log:
if not timestamp:
timestamp = utils.timestamp()
fd = open(self._itemLogPath, 'a')
fd.write(utils.doublequote(timestamp) + ',' + utils.doublequote(action) + ',' + item.toCsv() + '\n')
fd.close()
def editInBuffers(self, item):
timestamp = utils.timestamp()
if self.collection('plan').moveItemToBuffers(item, 'Edit Item', timestamp):
self._logItemAction(item, 'Edit Item', timestamp)
self._metadataFromBuffers(item)
def deleteItem(self, item):
if self._confirmDelete(item.itemId(), 'Confirm Delete Item'):
timestamp = utils.timestamp()
if self.collection('plan').deleteItem(item, 'Delete Item', timestamp):
self._logItemAction(item, 'Delete Item', timestamp)
def applyItemActions(self,
item,
mapAction=MapAction.NoMapAction,
filterAction=FilterAction.NoFilterAction,
drawingAction=DrawingAction.NoDrawingAction):
if drawingAction != DrawingAction.NoDrawingAction:
self.loadSourceDrawings(item, drawingAction == DrawingAction.LoadDrawings)
if filterAction != FilterAction.NoFilterAction:
self._plugin.filter().applyItemAction(item, filterAction)
if mapAction == MapAction.ZoomMap:
self._zoomToItem(item)
elif mapAction == MapAction.PanMap:
self._panToItem(item)
elif mapAction == MapAction.MoveMap:
self._moveToItem(item)
self._plugin.mapCanvas().refresh()
def showItem(self, item, loadDrawings=True, zoom=True):
self._plugin.showMessage('Loading ' + item.itemLabel())
self._plugin.filter().filterItem(item)
if loadDrawings:
self.loadSourceDrawings(item, True)
if zoom:
self._zoomToItem(item)
def panToItem(self, item, highlight=False):
if highlight:
self._plugin.filter().highlightItem(item)
self._panToItem(item)
self._plugin.mapCanvas().refresh()
def zoomToItem(self, item, highlight=False):
if highlight:
self._plugin.filter().highlightItem(item)
self._zoomToItem(item)
self._plugin.mapCanvas().refresh()
def moveToItem(self, item, highlight=False):
ret = -1
if highlight:
ret = self._plugin.filter().highlightItem(item)
self._moveToItem(item)
self._plugin.mapCanvas().refresh()
return ret
def _moveToItem(self, item):
self._moveToExtent(self.itemExtent(item))
def _moveToExtent(self, extent):
if extent is None or extent.isNull() or extent.isEmpty():
return
mapExtent = self._plugin.mapCanvas().extent()
if (extent.width() > mapExtent.width() or extent.height() > mapExtent.height()
or extent.width() * extent.height() > mapExtent.width() * mapExtent.height()):
self._zoomToExtent(extent)
else:
self._panToExtent(extent)
def _panToItem(self, item):
self._panToExtent(self.itemExtent(item))
def _panToExtent(self, extent):
if extent is None or extent.isNull() or extent.isEmpty():
return
self._plugin.mapCanvas().setCenter(extent.center())
def _zoomToItem(self, item):
self._zoomToExtent(self.itemExtent(item))
def _zoomToExtent(self, extent):
if extent is None or extent.isNull() or extent.isEmpty():
return
extent.scale(1.05)
self._plugin.mapCanvas().setExtent(extent)
def filterItem(self, item):
self._plugin.filter().filterItem(item)
self._plugin.mapCanvas().refresh()
def excludeFilterItem(self, item):
self._plugin.filter().excludeItem(item)
self._plugin.mapCanvas().refresh()
def highlightItem(self, item):
self._plugin.filter().highlightItem(item)
self._plugin.mapCanvas().refresh()
def addHighlightItem(self, item):
self._plugin.filter().addHighlightItem(item)
self._plugin.mapCanvas().refresh()
def itemExtent(self, item):
requestKey = self._plugin.data().nodesItem(item)
request = requestKey.featureRequest()
points = self._requestAsLayer(request, self.collection('plan').layer('points'), 'points')
lines = self._requestAsLayer(request, self.collection('plan').layer('lines'), 'lines')
polygons = self._requestAsLayer(request, self.collection('plan').layer('polygons'), 'polygons')
extent = None
extent = self._combineExtentWith(extent, polygons)
extent = self._combineExtentWith(extent, lines)
extent = self._combineExtentWith(extent, points)
return extent
def _requestAsLayer(self, request, fromLayer, toName):
toLayer = layers.cloneAsMemoryLayer(fromLayer, toName)
layers.copyFeatureRequest(request, fromLayer, toLayer)
toLayer.updateExtents()
return toLayer
def _combineExtentWith(self, extent, layer):
if (layer is not None and layer.isValid() and layer.featureCount() > 0):
layerExtent = layer.extent()
if layerExtent.isNull() or layerExtent.isEmpty():
return extent
if extent is None:
extent = layerExtent
else:
extent.combineExtentWith(layerExtent)
return extent
def _sectionItemList(self, siteCode):
# TODO in 2.14 use addOrderBy()
request = utils.featureRequest(utils.eqClause('site', siteCode) + ' and ' + utils.eqClause('class', 'sec'))
features = layers.getAllFeaturesRequest(request, self.collection('plan').layer('lines'))
lst = []
for feature in features:
lst.append(ItemFeature(feature))
lst.sort()
return lst
def _sectionLineGeometry(self, item):
if item and item.isValid():
sln = ItemFeature(item, 'sln')
request = sln.featureRequest()
features = layers.getAllFeaturesRequest(request, self.collection('plan').layer('lines'))
for feature in features:
return QgsGeometry(feature.geometry())
return QgsGeometry()
def _metadataFromBuffers(self, item):
feature = self._getFeature(self.collection('plan').buffer('polygons'), item, 'sch')
if feature:
self.metadata.fromFeature(feature)
return
feature = self._getFeature(self.collection('plan').buffer('polygons'), item, 'scs')
if feature:
self.metadata.fromFeature(feature)
return
feature = self._getFeature(self.collection('plan').buffer('polygons'), item)
if feature:
self.metadata.fromFeature(feature)
return
feature = self._getFeature(self.collection('plan').buffer('lines'), item)
if feature:
self.metadata.fromFeature(feature)
return
feature = self._getFeature(self.collection('plan').buffer('points'), item)
if feature:
self.metadata.fromFeature(feature)
def _getFeature(self, layer, item, category=''):
req = None
if category:
sch = ItemFeature(item, 'sch')
req = sch.featureRequest()
else:
req = item.featureRequest()
try:
return layer.getFeatures(req).next()
except StopIteration:
return None
return None
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):
"""Run method that performs all the real work"""
# Add items to Management Practices & Soil Type
k_lists = []
m_lists = []
k_lists = self.k_list()
m_lists = self.m_list()
self.dlg.comboBox.addItems(k_lists)
self.dlg.comboBox_2.addItems(m_lists)
# show dialog box
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Save paths of input directories
selectedBoundary = self.dlg.lineEdit.text()
selectedDEM = self.dlg.lineEdit_2.text()
selectedRLayer = self.dlg.lineEdit_3.text()
selectedOutput = self.dlg.lineEdit_4.text()
for letter in selectedOutput:
if letter == "\\":
selectedOutput = selectedOutput.replace(letter, "/")
print(selectedBoundary)
print(selectedDEM)
print(selectedRLayer)
print(selectedOutput)
# Save indices for K and M
selectedKLayer = self.dlg.comboBox.currentIndex()
selectedMLayer = self.dlg.comboBox_2.currentIndex()
boundary = QgsVectorLayer(selectedBoundary, 'Boundary', 'ogr')
QgsMapLayerRegistry.instance().addMapLayer(boundary)
entries = []
# Retrieve K and M values
k_value = self.k_index(selectedKLayer)
m_value = self.m_index(selectedMLayer)
km_value = k_value * m_value
km_value = str(km_value)
# Process R index
## CSV to Layer
uri = 'file:///' + selectedRLayer + '?delimiter=%s&xField=%s&yField=%s&crs=%s' % (
",", "x", "y", "EPSG:4326")
rainfall_unedited = QgsVectorLayer(uri, "rainfall",
"delimitedtext")
QgsMapLayerRegistry.instance().addMapLayer(rainfall_unedited)
spatRef = QgsCoordinateReferenceSystem(
4326, QgsCoordinateReferenceSystem.EpsgCrsId)
## CSV points to editable shapefile
rainfall_edited = QgsVectorFileWriter(
selectedOutput + '/rainfall_edited.shp', None,
rainfall_unedited.pendingFields(), QGis.WKBPoint, spatRef)
pt = QgsPoint()
outFeature = QgsFeature()
for feat in rainfall_unedited.getFeatures():
attrs = feat.attributes()
pt.setX(feat['x'])
pt.setY(feat['y'])
outFeature.setAttributes(attrs)
outFeature.setGeometry(QgsGeometry.fromPoint(pt))
rainfall_edited.addFeature(outFeature)
del rainfall_edited
rainfall_edited2 = QgsVectorLayer(
selectedOutput + '/rainfall_edited.shp', 'rainfall_edited',
'ogr')
## Add and calculate average field
rainfall_edited2.startEditing()
avgField = QgsField('average', QVariant.Double)
rainfall_edited2.dataProvider().addAttributes([avgField])
rainfall_edited2.updateFields()
idx = rainfall_edited2.fieldNameIndex('average')
time_count = idx - 2
str_output = ''
for i in range(1, time_count + 1):
if i == 1:
a = str(i)
str_output += 'time' + a
else:
a = str(i)
str_output += '+ time' + a
e = QgsExpression(str_output)
e.prepare(rainfall_edited2.pendingFields())
for f in rainfall_edited2.getFeatures():
f[idx] = e.evaluate(f) / time_count
rainfall_edited2.updateFeature(f)
rainfall_edited2.commitChanges()
rainfall_edited3 = QgsVectorLayer(
selectedOutput + '/rainfall_edited.shp', 'rainfall_edited',
'ogr')
QgsMapLayerRegistry.instance().addMapLayer(rainfall_edited3)
## Interpolating average using IDW
### Parameters for interpolation
idx = rainfall_edited3.fieldNameIndex('average')
layer_data = qgis.analysis.QgsInterpolator.LayerData()
layer_data.vectorLayer = rainfall_edited3
layer_data.zCoordInterpolation = False
layer_data.interpolationAttribute = idx
layer_data.mInputType = 1
idw_interpolator = QgsIDWInterpolator([layer_data])
### Output parameter
export_path = selectedOutput + "/interpolated_r_{}.asc".format(idx)
rect = boundary.extent()
res = 0.0001
ncol = (rect.xMaximum() - rect.xMinimum()) / res
nrows = (rect.yMaximum() - rect.yMinimum()) / res
interpolated_r = QgsGridFileWriter(idw_interpolator,
export_path, rect, int(ncol),
int(nrows), res, res)
interpolated_r.writeFile(True)
interpolated_r2 = QgsRasterLayer(export_path, "interpolated_r")
## Clip output to boundary
clippedR = processing.runandload(
'gdalogr:cliprasterbymasklayer',
interpolated_r2, #INPUT <ParameterRaster>
boundary, #MASK <ParameterVector>
"-9999", #NO_DATA <ParameterString>
False, #ALPHA_BAND <ParameterBoolean>
False, #CROP_TO_CUTLINE <ParameterBoolean>
False, #KEEP_RESOLUTION <ParameterBoolean>
5, #RTYPE <ParameterSelection>
4, #COMPRESS <ParameterSelection>
1, #JPEGCOMPRESSION <ParameterNumber>
6, #ZLEVEL <ParameterNumber>
1, #PREDICTOR <ParameterNumber>
False, #TILED <ParameterBoolean>
2, #BIGTIFF <ParameterSelection>
False, #TFW <ParameterBoolean>
"", #EXTRA <ParameterString>
selectedOutput +
'/clip_interpolated_r.tif') #OUTPUT <OutputRaster>
r_layer = QgsRasterLayer(
selectedOutput + '/clip_interpolated_r.tif', "R-index")
boh4 = QgsRasterCalculatorEntry()
boh4.ref = 'boh4@1'
boh4.raster = r_layer
boh4.bandNumber = 1
entries.append(boh4)
# Process S index
## Load DEM
bohLayer1 = QgsRasterLayer(selectedDEM, "DEM")
boh2 = QgsRasterCalculatorEntry()
boh2.ref = 'boh2@1'
boh2.raster = bohLayer1
boh2.bandNumber = 1
entries.append(boh2)
## Clip output to boundary
clippedOutput2 = processing.runandload(
'gdalogr:cliprasterbymasklayer',
bohLayer1, # INPUT <ParameterRaster>
boundary, # MASK <ParameterVector>
"-9999", # NO_DATA <ParameterString>
False, # ALPHA_BAND <ParameterBoolean>
False, # CROP_TO_CUTLINE <ParameterBoolean>
False, # KEEP_RESOLUTION <ParameterBoolean>
5, # RTYPE <ParameterSelection>
4, # COMPRESS <ParameterSelection>
1, # JPEGCOMPRESSION <ParameterNumber>
6, # ZLEVEL <ParameterNumber>
1, # PREDICTOR <ParameterNumber>
False, # TILED <ParameterBoolean>
2, # BIGTIFF <ParameterSelection>
False, # TFW <ParameterBoolean>
"", # EXTRA <ParameterString>
selectedOutput + '/clip_dem.tif') # OUTPUT <OutputRaster>
bohLayer5 = QgsRasterLayer(selectedOutput + '/clip_dem.tif',
"DEM-clipped")
boh5 = QgsRasterCalculatorEntry()
boh5.ref = 'boh5@1'
boh5.raster = bohLayer5
boh5.bandNumber = 1
entries.append(boh5)
## GDAL algorithm for slope
processing.runalg('gdalogr:slope', bohLayer5, 1, False, True, True,
111120, selectedOutput + '/slope(percent).tif')
bohLayer6 = QgsRasterLayer(selectedOutput + '/slope(percent).tif',
"slope(percent)")
QgsMapLayerRegistry.instance().addMapLayer(bohLayer6)
boh6 = QgsRasterCalculatorEntry()
boh6.ref = 'boh6@1'
boh6.raster = bohLayer6
boh6.bandNumber = 1
entries.append(boh6)
# Process calculation with input extent and resolution
calc = QgsRasterCalculator('(boh4@1 * boh6@1) *' + km_value,
selectedOutput + '/soil_risk.tif',
'GTiff', bohLayer6.extent(),
bohLayer6.width(), bohLayer6.height(),
entries)
calc.processCalculation()
bohLayer4 = QgsRasterLayer(selectedOutput + '/soil_risk.tif',
"Soil_Risk")
QgsMapLayerRegistry.instance().addMapLayer(bohLayer4)
dem = gdal.Open(os.path.join(input_Dir,dem_filename)) gt = dem.GetGeoTransform() xorigin, xcellsize, xrotation, yorigion, yrotation, ycellsize = gt # Get and Print Projection Information projInfo=dem .GetProjection() print projInfo demLayer = QgsRasterLayer(os.path.join(input_Dir,dem_filename), "dem") if not demLayer.isValid(): print "DEM Layer failed to load!" # Load raster layer into canvas QgsMapLayerRegistry.instance().addMapLayer(demLayer) # Print Extent of the DEM layer (for use with raster calculator) print demLayer.extent().xMinimum(), demLayer.extent().xMaximum() print demLayer.extent().yMinimum(), demLayer.extent().yMaximum() print demLayer.width(), demLayer.height() name = demLayer.name() print name bands = demLayer.bandCount() print bands # Slope layer degslopeLayer = QgsRasterLayer(os.path.join(input_Dir,'slope_dec.tif'), "Degrees_Slope") if not degslopeLayer.isValid(): print "Slope (decimal degrees) Layer failed to load!" # Load raster layer into canvas QgsMapLayerRegistry.instance().addMapLayer(degslopeLayer) # Aspect layer degaspectLayer = QgsRasterLayer(os.path.join(input_Dir,'aspect_dec.tif'), "Degrees_Aspect")
class FeatureOfInterestDefinerConfigurationWidget(StandardModuleConfigurationWidget):
"""A widget to configure the FeatureOfInterestDefiner Module."""
def __init__(self, module, controller, parent=None):
StandardModuleConfigurationWidget.__init__(self, module, controller, parent)
self.foi_type = module.name
#self.module = module
self.setObjectName("FeatureOfInterestDefinerWidget")
self.parent_widget = module
# FIXME these modules don't exist
self.path_png_icon = vistrails.packages.eo4vistrails.geoinf.visual.__path__[0]
self.path_bkgimg = vistrails.packages.eo4vistrails.geoinf.visual.__path__[0]
self.create_config_window()
def create_config_window(self):
"""TO DO - add docstring"""
self.setWindowTitle(self.foi_type)
self.setMinimumSize(800, 850)
self.center()
self.mainLayout = QtGui.QVBoxLayout()
self.setLayout(self.mainLayout)
#set up Group Box for organising CRS of FOI
self.crsGroupBox = QtGui.QGroupBox("Define Projection or Coordinate Reference System")
self.crsLayout = QtGui.QHBoxLayout()
self.crsProj4Label = QtGui.QLabel('SRS Proj4: ')
self.crsTextAsProj4 = QtGui.QLineEdit('4326')
self.crsChooseButton = QtGui.QPushButton('&Choose SRS')
self.crsChooseButton.setAutoDefault(False)
self.crsChooseButton.setToolTip('Choose a Spatial Reference System or Projection')
self.crsLayout.addWidget(self.crsProj4Label)
self.crsLayout.addWidget(self.crsTextAsProj4)
self.crsLayout.addWidget(self.crsChooseButton)
self.crsGroupBox.setLayout(self.crsLayout)
#set up Group Box for getting coords of Bounding Box
self.bbGroupBox = QtGui.QGroupBox("Define Area of Interest via a Bounding Box in units of SRS")
self.bbLayout = QtGui.QHBoxLayout()
self.bbMinXLabel = QtGui.QLabel('MinX/Left: ')
self.bbMinYLabel = QtGui.QLabel('MinY/Bottom: ')
self.bbMaxXLabel = QtGui.QLabel('MaxX/Right: ')
self.bbMaxYLabel = QtGui.QLabel('MaxY/Top: ')
self.bbMinXText = QtGui.QLineEdit('15')
self.bbMinYText = QtGui.QLineEdit('-35')
self.bbMaxXText = QtGui.QLineEdit('35')
self.bbMaxYText = QtGui.QLineEdit('-20')
self.bbToMapButton = QtGui.QPushButton('&To Map')
self.bbToMapButton.setAutoDefault(False)
self.bbToMapButton.setToolTip('Show Bounding Box on Map')
self.bbLayout.addWidget(self.bbMinXLabel)
self.bbLayout.addWidget(self.bbMinXText)
self.bbLayout.addWidget(self.bbMinYLabel)
self.bbLayout.addWidget(self.bbMinYText)
self.bbLayout.addWidget(self.bbMaxXLabel)
self.bbLayout.addWidget(self.bbMaxXText)
self.bbLayout.addWidget(self.bbMaxYLabel)
self.bbLayout.addWidget(self.bbMaxYText)
self.bbLayout.addWidget(self.bbToMapButton)
self.bbGroupBox.setLayout(self.bbLayout)
#set up Group Box for getting text representation of a geometry
self.asTxtGroupBox = QtGui.QGroupBox("Define Area of Interest via a WKT string in units of SRS")
self.asTxtLayout = QtGui.QVBoxLayout()
self.asTxtLabel = QtGui.QLabel('WKT String: ')
self.asTxtText = QtGui.QTextEdit('')
self.asTxtToMapButton = QtGui.QPushButton('&To Map')
self.asTxtToMapButton.setAutoDefault(False)
self.asTxtToMapButton.setToolTip('Show Bounding Box on Map')
self.asTxtLayout.addWidget(self.asTxtLabel)
self.asTxtLayout.addWidget(self.asTxtText)
self.asTxtLayout.addWidget(self.asTxtToMapButton)
self.asTxtGroupBox.setLayout(self.asTxtLayout)
#set up Group Box for Map
self.MapGroupBox = QtGui.QGroupBox("Map Viewer")
self.MapLayout = QtGui.QHBoxLayout()
#sz = QtCore.QSize(200, 300)
#self.MapLayout.setGeometry(QtCore.QRect(300, 700, 780, 680))
self.MapGroupBox.setLayout(self.MapLayout)
## create canvas
self.canvas = QgsMapCanvas()
self.canvas.setCanvasColor(QtGui.QColor(200, 200, 255))
#self.mainLayout.addWidget(self.canvas)
# icons
actionAddLayer = QtGui.QAction(QtGui.QIcon(self.path_png_icon + \
"/mActionAddLayer.png"), "Add Layer", self)
actionZoomIn = QtGui.QAction(QtGui.QIcon(self.path_png_icon + \
"/mActionZoomIn.png"), "Zoom In", self)
actionZoomOut = QtGui.QAction(QtGui.QIcon(self.path_png_icon + \
"/mActionZoomOut.png"), "Zoom Out", self)
actionPan = QtGui.QAction(QtGui.QIcon(self.path_png_icon + \
"/mActionPan.png"), "Pan", self)
actionIdentify = QtGui.QAction(QtGui.QIcon(self.path_png_icon + \
"/mActionIdentify.png"), "Feature Information", self)
# create toolbar
self.toolbar = QtGui.QToolBar() # "Canvas actions"
self.toolbar.addAction(actionAddLayer)
self.toolbar.addAction(actionZoomIn)
self.toolbar.addAction(actionZoomOut)
self.toolbar.addAction(actionPan)
self.toolbar.addAction(actionIdentify)
# create layer explorer pane
self.explorer = QtGui.QDockWidget("Layers")
self.explorer.resize(60, 100)
#~self.explorerListWidget = QtGui.QListWidget()
#~self.explorerListWidget.setObjectName("listWidget")
#~self.explorer.setWidget(self.explorerListWidget)
# create map tools
self.toolPan = QgsMapToolPan(self.canvas,)
self.toolPan.setAction(actionPan)
self.toolZoomIn = QgsMapToolZoom(self.canvas, False) # false == in
self.toolZoomIn.setAction(actionZoomIn)
self.toolZoomOut = QgsMapToolZoom(self.canvas, True) # true == out
self.toolZoomOut.setAction(actionZoomOut)
self.toolAOI = QgsMapTool(self.canvas)
self.toolIdentify = GetFeatureInfoTool(self.canvas, self.gotFeatureForIdentification)
self.toolIdentify.setAction(actionIdentify)
# layerList explorer
self.GroupBoxLyrExplorer = QtGui.QGroupBox("")
self.vboxLyrExplorer = QtGui.QVBoxLayout()
self.GroupBoxLyrExplorer.setLayout(self.vboxLyrExplorer)
self.MapLayout.addWidget(self.GroupBoxLyrExplorer)
self.label = QtGui.QLabel("")
self.vboxLyrExplorer.addWidget(self.label)
self.vboxLyrExplorer.addWidget(self.explorer)
# toolbar and canvas layout
self.GroupBoxToolBarMapCanvas = QtGui.QGroupBox("")
self.vboxToolBarMapCanvas = QtGui.QVBoxLayout()
self.vboxToolBarMapCanvas.setGeometry(QtCore.QRect(300, 700, 780, 680))
self.GroupBoxToolBarMapCanvas.setLayout(self.vboxToolBarMapCanvas)
self.MapLayout.addWidget(self.GroupBoxToolBarMapCanvas)
self.vboxToolBarMapCanvas.addWidget(self.toolbar)
self.vboxToolBarMapCanvas.addWidget(self.canvas)
#global list to hold inputlayers list -> accessible for toggleLayer
self.mylist = []
#finalise/cancel buttons
self.finishGroupBox = QtGui.QGroupBox("Finish")
self.buttonLayout = QtGui.QHBoxLayout()
self.finishGroupBox.setLayout(self.buttonLayout)
self.buttonLayout.setGeometry(QtCore.QRect(300, 500, 780, 680))
self.buttonLayout.setMargin(5)
self.cancelButton = QtGui.QPushButton('&Cancel', self)
self.cancelButton.setAutoDefault(False)
self.cancelButton.setShortcut('Esc')
self.buttonLayout.addStretch(1) # force buttons to the right
self.buttonLayout.addWidget(self.cancelButton)
self.okButton = QtGui.QPushButton('&OK', self)
self.okButton.setAutoDefault(False)
self.buttonLayout.addWidget(self.okButton)
self.connect(self.okButton,
QtCore.SIGNAL('clicked(bool)'),
self.okTriggered)
self.connect(self.cancelButton,
QtCore.SIGNAL('clicked(bool)'),
self.close)
self.mainLayout.addWidget(self.crsGroupBox)
self.mainLayout.addWidget(self.bbGroupBox)
self.mainLayout.addWidget(self.asTxtGroupBox)
self.mainLayout.addWidget(self.MapGroupBox)
self.mainLayout.addWidget(self.finishGroupBox)
# set signals
self.connect(self.crsChooseButton, QtCore.SIGNAL('clicked(bool)'), self.getSRS)
self.connect(self.bbToMapButton, QtCore.SIGNAL('clicked(bool)'), self.bbToMapBB)
self.connect(self.asTxtToMapButton, QtCore.SIGNAL('clicked(bool)'), self.bbToMapTxt)
self.connect(actionAddLayer, QtCore.SIGNAL("activated()"), self.addLayer)
self.connect(actionZoomIn, QtCore.SIGNAL("activated()"), self.zoomIn)
self.connect(actionZoomOut, QtCore.SIGNAL("activated()"), self.zoomOut)
self.connect(actionPan, QtCore.SIGNAL("activated()"), self.pan)
self.connect(actionIdentify, QtCore.SIGNAL("triggered()"), self.identifyFeature)
#load a backdrop layer
self.mapCanvasLayers = []
fname = self.path_bkgimg + '/bluemarblemerged.img'
fileInfo = QtCore.QFileInfo(fname)
baseName = fileInfo.baseName()
self.bmLayer = QgsRasterLayer(fname, baseName)
QgsMapLayerRegistry.instance().addMapLayer(self.bmLayer)
self.cl = QgsMapCanvasLayer(self.bmLayer)
self.mapCanvasLayers.append(self.cl)
# Set extent to the extent of our layer
self.canvas.setExtent(self.bmLayer.extent())
self.canvas.enableAntiAliasing(True)
self.canvas.freeze(False)
self.canvas.setLayerSet(self.mapCanvasLayers)
self.canvas.refresh()
#now, add a container layer for our text based/ digitised or selected geoms
self.addMemoryLayer()
#self.update()
def center(self):
"""TO DO - add docstring"""
screen = QtGui.QDesktopWidget().screenGeometry()
size = self.geometry()
self.move((screen.width() - size.width()) / 2,
(screen.height() - size.height()) / 2)
def getSRS(self):
# retruns the description and proj4 string of the chosen SRS, from the SRSDialog
srsdlg = SRSChooserDialog("Choose SRS")
if srsdlg.exec_():
self.crsTextAsProj4.setText(srsdlg.getProjection())
def bbToMapBB(self):
self.bbToMap(fullWkt=False)
def bbToMapTxt(self):
self.bbToMap(fullWkt=True)
def bbToMap(self, fullWkt=False):
'''takes bounding box coords and puts them on the map'''
#if self.foi_type == "AreaOfInterestDefiner":
if not fullWkt:
ix = self.bbMinXText.text()
iy = self.bbMinYText.text()
ax = self.bbMaxXText.text()
ay = self.bbMaxYText.text()
wkt = "POLYGON((%s %s, %s %s, %s %s, %s %s, %s %s))" % \
(ix, iy, ix, ay, ax, ay, ax, iy, ix, iy)
else:
wkt = self.asTxtText.toPlainText()
try:
errnum = 0
geom = QgsGeometry().fromWkt(wkt)
print "gotGeom"
if self.foi_type == "AreaOfInterestDefiner" and geom.type() != 2:
errnum = 1
elif self.foi_type == "LineOfInterestDefiner" and geom.type() != 1:
errnum = 1
elif self.foi_type == "PointOfInterestDefiner" and geom.type() != 0:
errnum = 1
else:
print "attempting to add geometry to mem layer"
self.addGeomToMemoryLayer(geom)
if errnum == 1:
raise ModuleError(self, "Incorrect Geometry Type chosen")
except:
raise ModuleError(self, "Could not generate Geometry from text provided")
#else:
#print "Cannot create a Bounding box feature on a line or point layer"
#add to map
#map tool functions
def addLayer(self):
"""TO DO: Add doc string"""
fileName = QtGui.QFileDialog.getOpenFileName(
parent=None,
caption="Select Vector Overlay Layer",
filter="Vector Files (*.shp *.geojson *.gml)")
print fileName
info = QtCore.QFileInfo(fileName)
print info.filePath()
print info.completeBaseName()
# create layer
layer = QgsVectorLayer(info.filePath(), info.completeBaseName(), "ogr")
if not layer.isValid():
print "invalid layer"
return
# add layer to the registry
QgsMapLayerRegistry.instance().addMapLayer(layer)
# set extent to the extent of our layer
#self.canvas.setExtent(layer.extent())
# set the map canvas layer set
cl = QgsMapCanvasLayer(layer)
self.mapCanvasLayers.insert(len(self.mapCanvasLayers) - 2, cl)
#layers = [cl]
self.canvas.setLayerSet(self.mapCanvasLayers)
print "added Layer"
def addMemoryLayer(self):
'''Adds a layer to contain the feature defined by a bounding box, wkt,
digitised poly|line|point or selection from other layer.
'''
foi_type = self.foi_type.lower()
if foi_type == 'areaofinterestdefiner':
layer = QgsVectorLayer("Polygon", "Area of Interest", "memory")
if foi_type == 'lineofinterestdefiner':
layer = QgsVectorLayer("Linestring", "Line of Interest", "memory")
if foi_type == 'pointofinterestdefiner':
layer = QgsVectorLayer("Point", "Point of Interest", "memory")
if foi_type == 'areaofinterestdefiner':
sym = QgsSymbol(QGis.Polygon)
sym.setColor(QtCore.Qt.black)
sym.setFillColor(QtCore.Qt.green)
sym.setFillStyle(QtCore.Qt.Dense6Pattern)
sym.setLineWidth(0.5)
sr = QgsSingleSymbolRenderer(QGis.Polygon)
if foi_type == 'lineofinterestdefiner':
sym = QgsSymbol(QGis.Line)
sym.setColor(QtCore.Qt.black)
sym.setFillColor(QtCore.Qt.green)
sym.setFillStyle(QtCore.Qt.SolidPattern)
sym.setLineWidth(0.5)
sr = QgsSingleSymbolRenderer(QGis.Line)
if foi_type == 'pointofinterestdefiner':
sym = QgsSymbol(QGis.Point)
sym.setColor(QtCore.Qt.black)
sym.setFillColor(QtCore.Qt.green)
sym.setFillStyle(QtCore.Qt.SolidPattern)
sym.setLineWidth(0.3)
sym.setPointSize(4)
sym.setNamedPointSymbol("hard:triangle")
sr = QgsSingleSymbolRenderer(QGis.Point)
sr.addSymbol(sym)
layer.setRenderer(sr)
if not layer.isValid():
print "invalid layer"
return
ml_dp = layer.dataProvider()
ml_dp.addAttributes([QgsField("gid", QtCore.QVariant.String)])
# add layer to the registry
self.mem_layer_obj = QgsMapLayerRegistry.instance().addMapLayer(layer)
# set extent to the extent of our layer
#self.canvas.setExtent(layer.extent())
# set the map canvas layer set
cl = QgsMapCanvasLayer(layer)
self.mapCanvasLayers.insert(0, cl)
#layers = [cl]
self.canvas.setLayerSet(self.mapCanvasLayers)
print "added Layer"
def addGeomToMemoryLayer(self, the_geom, origin=0, delete_when_done=False):
"""TO DO: Add doc string"""
foi_type = self.foi_type.lower()
print "got foi_type"
if self.mem_layer_obj.featureCount() > 0:
if origin == 1: # is added by identify operation
pass
else:
print self.mem_layer_obj.featureCount()
print "there exists a feature, kill it!"
self.mem_layer_obj.select()
print "Feature count selcted for deletion:"
print self.mem_layer_obj.selectedFeatureCount()
self.mem_layer_obj.deleteSelectedFeatures()
#self.mem_layer_obj.deleteFeature(0)
self.mem_layer_obj.commitChanges()
self.mem_layer_obj.triggerRepaint()
ml_dp = self.mem_layer_obj.dataProvider()
print "got DP"
uuid_gid = QtCore.QUuid().createUuid().toString()
print "got uuid"
fet = QgsFeature()
print "got feature with id"
fet.setGeometry(the_geom)
print "set geometry"
fet.addAttribute(0, uuid_gid)
print "set attr "
ml_dp.addFeatures([fet])
self.mem_layer_obj.commitChanges()
print "added layers"
#self.mem_layer_obj.updateFeatureAttributes(fet)
#self.mem_layer_obj.updateFeatureGeometry(fet)
self.mem_layer_obj.updateExtents()
print "updated extents"
#self.mem_layer_obj.drawFeature(fet)
self.mem_layer_obj.triggerRepaint()
print "trp"
return fet.id()
def zoomIn(self):
"""TO DO: Add doc string"""
self.canvas.setMapTool(self.toolZoomIn)
def zoomOut(self):
"""TO DO: Add doc string"""
self.canvas.setMapTool(self.toolZoomOut)
def pan(self):
"""TO DO: Add doc string"""
self.canvas.setMapTool(self.toolPan)
def identifyFeature(self):
'''getFeatureInfo functionality'''
self.canvas.setMapTool(self.toolIdentify)
#print "GFI not yet implemented"
def gotFeatureForIdentification(self, pos):
"""Show a dialog with road information """
#pos is a rectangle
self.mem_layer_obj.select()
ftr = QgsFeature()
ftr_ids = []
while self.mem_layer_obj.nextFeature(ftr):
if ftr.geometry().intersects(pos):
ftr_ids.append(ftr.id())
self.chosenFOIGeoms = []
self.info = QgsMessageViewer()
if ftr_ids != []:
f = QgsFeature()
foi_type = self.foi_type.lower()
if foi_type == 'areaofinterestdefiner':
ftrData = "You have selected the following feature(s) for use as an Area of Interest:\n\n"
if foi_type == 'lineofinterestdefiner':
ftrData = "You have selected the following feature(s) for use as a Line of Interest:\n\n"
if foi_type == 'pointofinterestdefiner':
ftrData = "You have selected the following feature(s) for use as a Point of Interest:\n\n"
for fid in ftr_ids:
self.mem_layer_obj.dataProvider().featureAtId(fid, f, True)
ftrData += f.attributeMap()[0].toString()
ftrData += "\n_____________________________\n"
self.chosenFOIGeoms.append(f.geometry())
id_fid = self.addGeomToMemoryLayer(f.geometry())
self.info.setMessageAsPlainText(ftrData)
else:
self.info.setMessageAsPlainText("no data to show")
self.info.show()
return
def makeAOI(self):
pass
def makeLOI(self):
pass
def makePOI(self):
pass
def okTriggered(self):
the_fet = QgsFeature()
the_geoms = []
print self.mem_layer_obj.featureCount()
self.mem_layer_obj.select()
while self.mem_layer_obj.nextFeature(the_fet):
#self.mem_layer_obj.featureAtId(0, the_fet)
the_geoms.append(str(the_fet.geometry().exportToWkt()))
print the_geoms
wktstr = WKTString()
print wktstr
wktstr.setValue(the_geoms[0])
self.controller.update_ports_and_functions(
self.module.id, [], [], [("WKTGeometry", the_geoms),
("SRS", [self.crsTextAsProj4.text()])])
self.close()
def test_clip_both(self):
"""Raster and Vector layers can be clipped."""
# Create a vector layer
layer_name = 'padang'
vector_layer = QgsVectorLayer(VECTOR_PATH, layer_name, 'ogr')
message = (
'Did not find layer "%s" in path "%s"' % (layer_name, VECTOR_PATH))
assert vector_layer.isValid(), message
# Create a raster layer
layer_name = 'shake'
raster_layer = QgsRasterLayer(RASTERPATH, layer_name)
message = (
'Did not find layer "%s" in path "%s"' % (layer_name, RASTERPATH))
assert raster_layer.isValid(), message
# Create a bounding box
view_port_geo_extent = [99.53, -1.22, 101.20, -0.36]
# Get the Hazard extents as an array in EPSG:4326
hazard_geo_extent = [
raster_layer.extent().xMinimum(),
raster_layer.extent().yMinimum(),
raster_layer.extent().xMaximum(),
raster_layer.extent().yMaximum()
]
# Get the Exposure extents as an array in EPSG:4326
exposure_geo_extent = [
vector_layer.extent().xMinimum(),
vector_layer.extent().yMinimum(),
vector_layer.extent().xMaximum(),
vector_layer.extent().yMaximum()
]
# Now work out the optimal extent between the two layers and
# the current view extent. The optimal extent is the intersection
# between the two layers and the viewport.
# Extent is returned as an array [xmin,ymin,xmax,ymax]
analysis = Analysis()
geo_extent = analysis.get_optimal_extent(
hazard_geo_extent, exposure_geo_extent, view_port_geo_extent)
# Clip the vector to the bbox
result = clip_layer(vector_layer, geo_extent)
# Check the output is valid
assert os.path.exists(result.source())
read_safe_layer(result.source())
# Clip the raster to the bbox
result = clip_layer(raster_layer, geo_extent)
# Check the output is valid
assert os.path.exists(result.source())
read_safe_layer(result.source())
# -------------------------------
# Check the extra keywords option
# -------------------------------
# Clip the vector to the bbox
result = clip_layer(
vector_layer, geo_extent, extra_keywords={'kermit': 'piggy'})
# Check the output is valid
assert os.path.exists(result.source())
safe_layer = read_safe_layer(result.source())
keywords = safe_layer.get_keywords()
# message = 'Extra keyword was not found in %s: %s' % (myResult,
# keywords)
assert keywords['kermit'] == 'piggy'
# Clip the raster to the bbox
result = clip_layer(
raster_layer, geo_extent, extra_keywords={'zoot': 'animal'})
# Check the output is valid
assert os.path.exists(result.source())
safe_layer = read_safe_layer(result.source())
keywords = safe_layer.get_keywords()
message = ('Extra keyword was not found in %s: %s' %
(result.source(), keywords))
assert keywords['zoot'] == 'animal', message
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 DasimetricCalculator(diretorioOut, resolucao):
try:
raster1 = diretorioOut + r"\pop.asc"
popLayer = QgsRasterLayer(raster1, "pop")
raster2 = diretorioOut + r"\rdensity.asc"
rdensityLayer = QgsRasterLayer(raster2, "rdensity")
raster3 = diretorioOut + r"\outputE.asc"
eLayer = QgsRasterLayer(raster3, "e")
raster4 = diretorioOut + r"\outputT.asc"
tLayer = QgsRasterLayer(raster4, "t")
entries = []
pop = QgsRasterCalculatorEntry()
pop.ref = 'pop@1'
pop.raster = popLayer
pop.bandNumber = 1
entries.append(pop)
rdensity = QgsRasterCalculatorEntry()
rdensity.ref = 'rdensity@1'
rdensity.raster = rdensityLayer
rdensity.bandNumber = 1
entries.append(rdensity)
e = QgsRasterCalculatorEntry()
e.ref = 'e@1'
e.raster = eLayer
e.bandNumber = 1
entries.append(e)
t = QgsRasterCalculatorEntry()
t.ref = 't@1'
t.raster = tLayer
t.bandNumber = 1
entries.append(t)
resultado = diretorioOut + r"\dasimetric.tif"
resolucao2 = int(resolucao) * int(resolucao)
expression = '(pop@1 * rdensity@1 *{})/(e@1 * t@1)'.format(resolucao2)
print expression
calc = QgsRasterCalculator(expression, resultado, 'GTiff',
popLayer.extent(), popLayer.width(),
popLayer.height(), entries)
calc.processCalculation()
fileInfo5 = QFileInfo(resultado)
path5 = fileInfo5.filePath()
baseName5 = fileInfo5.baseName()
layer5 = QgsRasterLayer(path5, baseName5)
QgsMapLayerRegistry.instance().addMapLayer(layer5)
if layer5.isValid() is True:
print "Dasimetric result was loaded successfully!"
else:
print "Unable to read basename and file path - Your string is probably invalid"
except CalculationError:
print "Dasimetric calculation error!"
finally:
print "Dasimetric calculation was successfully!"
