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!"