def define_layer(self, layer_path): """Create QGIS layer (either vector or raster) from file path input. :param layer_path: Full path to layer file. :type layer_path: str :return: QGIS layer. :rtype: QgsMapLayer """ scenario_dir = self.source_directory.text() joined_path = os.path.join(scenario_dir, layer_path) full_path = os.path.normpath(joined_path) file_name = os.path.split(layer_path)[-1] # get extension and basename to create layer base_name, extension = os.path.splitext(file_name) # load layer in scenario layer = QgsRasterLayer(full_path, base_name) if layer.isValid(): return layer else: layer = QgsVectorLayer(full_path, base_name, 'ogr') if layer.isValid(): return layer # if layer is not vector nor raster else: LOGGER.warning('Input in scenario is not recognized/supported') return
def testImportIntoGpkg(self): # init target file test_gpkg = tempfile.mktemp(suffix='.gpkg', dir=self.testDataDir) gdal.GetDriverByName('GPKG').Create(test_gpkg, 1, 1, 1) source = QgsRasterLayer(os.path.join(self.testDataDir, 'raster', 'band3_byte_noct_epsg4326.tif'), 'my', 'gdal') self.assertTrue(source.isValid()) provider = source.dataProvider() fw = QgsRasterFileWriter(test_gpkg) fw.setOutputFormat('gpkg') fw.setCreateOptions(['RASTER_TABLE=imported_table', 'APPEND_SUBDATASET=YES']) pipe = QgsRasterPipe() self.assertTrue(pipe.set(provider.clone())) projector = QgsRasterProjector() projector.setCrs(provider.crs(), provider.crs()) self.assertTrue(pipe.insert(2, projector)) self.assertEqual(fw.writeRaster(pipe, provider.xSize(), provider.ySize(), provider.extent(), provider.crs()), 0) # Check that the test geopackage contains the raster layer and compare rlayer = QgsRasterLayer('GPKG:%s:imported_table' % test_gpkg) self.assertTrue(rlayer.isValid()) out_provider = rlayer.dataProvider() self.assertEqual(provider.block(1, provider.extent(), source.width(), source.height()).data(), out_provider.block(1, out_provider.extent(), rlayer.width(), rlayer.height()).data()) # remove result file os.unlink(test_gpkg)
def load_layer(layer_path): """Helper to load and return a single QGIS layer. :param layer_path: Path name to raster or vector file. :type layer_path: str :returns: Layer instance. :rtype: QgsMapLayer """ # Extract basename and absolute path file_name = os.path.split(layer_path)[-1] # In case path was absolute base_name, extension = os.path.splitext(file_name) # Create QGis Layer Instance if extension in ['.asc', '.tif']: layer = QgsRasterLayer(layer_path, base_name) elif extension in ['.shp']: layer = QgsVectorLayer(layer_path, base_name, 'ogr') else: message = 'File %s had illegal extension' % layer_path raise Exception(message) # noinspection PyUnresolvedReferences message = 'Layer "%s" is not valid' % layer.source() # noinspection PyUnresolvedReferences if not layer.isValid(): print message # noinspection PyUnresolvedReferences if not layer.isValid(): raise Exception(message) return layer
def testSetDataSource(self): """Test change data source""" temp_dir = QTemporaryDir() options = QgsDataProvider.ProviderOptions() myPath = os.path.join(unitTestDataPath('raster'), 'band1_float32_noct_epsg4326.tif') myFileInfo = QFileInfo(myPath) myBaseName = myFileInfo.baseName() layer = QgsRasterLayer(myPath, myBaseName) renderer = QgsSingleBandGrayRenderer(layer.dataProvider(), 2) image = layer.previewAsImage(QSize(400, 400)) self.assertFalse(image.isNull()) self.assertTrue(image.save(os.path.join(temp_dir.path(), 'expected.png'), "PNG")) layer.setDataSource(myPath.replace('4326.tif', '4326-BAD_SOURCE.tif'), 'bad_layer', 'gdal', options) self.assertFalse(layer.isValid()) image = layer.previewAsImage(QSize(400, 400)) self.assertTrue(image.isNull()) layer.setDataSource(myPath.replace('4326-BAD_SOURCE.tif', '4326.tif'), 'bad_layer', 'gdal', options) self.assertTrue(layer.isValid()) image = layer.previewAsImage(QSize(400, 400)) self.assertFalse(image.isNull()) self.assertTrue(image.save(os.path.join(temp_dir.path(), 'actual.png'), "PNG")) self.assertTrue(filecmp.cmp(os.path.join(temp_dir.path(), 'actual.png'), os.path.join(temp_dir.path(), 'expected.png')), False)
def load(fileName, name=None, crs=None, style=None, isRaster=False): """ Loads a layer/table into the current project, given its file. .. deprecated:: 3.0 Do not use, will be removed in QGIS 4.0 """ from warnings import warn warn("processing.load is deprecated and will be removed in QGIS 4.0", DeprecationWarning) if fileName is None: return prjSetting = None settings = QgsSettings() if crs is not None: prjSetting = settings.value('/Projections/defaultBehavior') settings.setValue('/Projections/defaultBehavior', '') if name is None: name = os.path.split(fileName)[1] if isRaster: qgslayer = QgsRasterLayer(fileName, name) if qgslayer.isValid(): if crs is not None and qgslayer.crs() is None: qgslayer.setCrs(crs, False) if style is None: style = ProcessingConfig.getSetting(ProcessingConfig.RASTER_STYLE) qgslayer.loadNamedStyle(style) QgsProject.instance().addMapLayers([qgslayer]) else: if prjSetting: settings.setValue('/Projections/defaultBehavior', prjSetting) raise RuntimeError(QCoreApplication.translate('dataobject', 'Could not load layer: {0}\nCheck the processing framework log to look for errors.').format( fileName)) else: qgslayer = QgsVectorLayer(fileName, name, 'ogr') if qgslayer.isValid(): if crs is not None and qgslayer.crs() is None: qgslayer.setCrs(crs, False) if style is None: if qgslayer.geometryType() == QgsWkbTypes.PointGeometry: style = ProcessingConfig.getSetting(ProcessingConfig.VECTOR_POINT_STYLE) elif qgslayer.geometryType() == QgsWkbTypes.LineGeometry: style = ProcessingConfig.getSetting(ProcessingConfig.VECTOR_LINE_STYLE) else: style = ProcessingConfig.getSetting(ProcessingConfig.VECTOR_POLYGON_STYLE) qgslayer.loadNamedStyle(style) QgsProject.instance().addMapLayers([qgslayer]) if prjSetting: settings.setValue('/Projections/defaultBehavior', prjSetting) return qgslayer
def load_layer(layer_file, directory=TESTDATA): """Helper to load and return a single QGIS layer :param layer_file: Path name to raster or vector file. :type layer_file: str :param directory: Optional parent dir. If None, path name is assumed to be absolute. :type directory: str, None :returns: tuple containing layer and its category. :rtype: (QgsMapLayer, str) """ # Extract basename and absolute path file_path = os.path.split(layer_file)[-1] # In case path was absolute base_name, extension = os.path.splitext(file_path) if directory is None: path = layer_file else: path = os.path.join(directory, layer_file) keyword_path = path[:-4] + '.keywords' # Determine if layer is hazard or exposure keywords = read_file_keywords(keyword_path) category = 'undefined' if 'category' in keywords: category = keywords['category'] message = 'Could not read %s' % keyword_path assert keywords is not None, message # Create QGis Layer Instance if extension in ['.asc', '.tif']: layer = QgsRasterLayer(path, base_name) elif extension in ['.shp']: layer = QgsVectorLayer(path, base_name, 'ogr') else: message = 'File %s had illegal extension' % path raise Exception(message) # noinspection PyUnresolvedReferences message = 'Layer "%s" is not valid' % str(layer.source()) # noinspection PyUnresolvedReferences if not layer.isValid(): print message # noinspection PyUnresolvedReferences assert layer.isValid(), message return layer, category
def load_layer(layer_path): """Helper to load and return a single QGIS layer :param layer_path: Path name to raster or vector file. :type layer_path: str :returns: tuple containing layer and its layer_purpose. :rtype: (QgsMapLayer, str) """ # Extract basename and absolute path file_name = os.path.split(layer_path)[-1] # In case path was absolute base_name, extension = os.path.splitext(file_name) # Determine if layer is hazard or exposure layer_purpose = 'undefined' try: try: keywords = read_iso19115_metadata(layer_path) except: try: keywords = read_file_keywords(layer_path) keywords = write_read_iso_19115_metadata(layer_path, keywords) except NoKeywordsFoundError: keywords = {} if 'layer_purpose' in keywords: layer_purpose = keywords['layer_purpose'] except NoKeywordsFoundError: pass # Create QGis Layer Instance if extension in ['.asc', '.tif']: layer = QgsRasterLayer(layer_path, base_name) elif extension in ['.shp']: layer = QgsVectorLayer(layer_path, base_name, 'ogr') else: message = 'File %s had illegal extension' % layer_path raise Exception(message) # noinspection PyUnresolvedReferences message = 'Layer "%s" is not valid' % layer.source() # noinspection PyUnresolvedReferences if not layer.isValid(): print message # noinspection PyUnresolvedReferences if not layer.isValid(): raise Exception(message) return layer, layer_purpose
def load(fileName, name=None, crs=None, style=None, isRaster=False): """Loads a layer/table into the current project, given its file. """ if fileName is None: return prjSetting = None settings = QSettings() if crs is not None: prjSetting = settings.value('/Projections/defaultBehaviour') settings.setValue('/Projections/defaultBehaviour', '') if name is None: name = os.path.split(fileName)[1] if isRaster: qgslayer = QgsRasterLayer(fileName, name) if qgslayer.isValid(): if crs is not None and qgslayer.crs() is None: qgslayer.setCrs(crs, False) if style is None: style = ProcessingConfig.getSetting(ProcessingConfig.RASTER_STYLE) qgslayer.loadNamedStyle(style) QgsMapLayerRegistry.instance().addMapLayers([qgslayer]) iface.legendInterface().refreshLayerSymbology(qgslayer) else: if prjSetting: settings.setValue('/Projections/defaultBehaviour', prjSetting) raise RuntimeError('Could not load layer: ' + unicode(fileName) + '\nCheck the processing framework log to look for errors') else: qgslayer = QgsVectorLayer(fileName, name, 'ogr') if qgslayer.isValid(): if crs is not None and qgslayer.crs() is None: qgslayer.setCrs(crs, False) if style is None: if qgslayer.geometryType() == QGis.Point: style = ProcessingConfig.getSetting(ProcessingConfig.VECTOR_POINT_STYLE) elif qgslayer.geometryType() == QGis.Line: style = ProcessingConfig.getSetting(ProcessingConfig.VECTOR_LINE_STYLE) else: style = ProcessingConfig.getSetting(ProcessingConfig.VECTOR_POLYGON_STYLE) qgslayer.loadNamedStyle(style) QgsMapLayerRegistry.instance().addMapLayers([qgslayer]) if prjSetting: settings.setValue('/Projections/defaultBehaviour', prjSetting) return qgslayer
def addToCanvas(self, roles): if self.canOpen(roles): if not oauth2_supported: iface.messageBar().pushMessage( "Cannot load basemap", "OAuth support is not available", QgsMessageBar.WARNING) else: authcfg = get_oauth_authcfg() if authcfg is None: iface.messageBar().pushMessage( "Cannot load basemap", "Cannot find a valid authentication configuration", QgsMessageBar.WARNING) else: authId = authcfg.id() layer = QgsRasterLayer('authcfg={authcfg}&type=xyz&url={url}'.format(url=urllib2.quote("{}?version={}".format(self.url, pluginSetting("apiVersion"))), authcfg=authId), self.name, "wms") if layer.isValid(): QgsMapLayerRegistry.instance().addMapLayer(layer) else: iface.messageBar().pushMessage( "Cannot load basemap", "Cannot create basemap layer", QgsMessageBar.WARNING) else: webbrowser.open_new(SUBSCRIBE_URL)
def accept(self): input_path = str(self.leInputPath.text()) output_path = str(self.leOutputPath.text()) if not output_path.endswith('.tif'): QMessageBox.warning( self.parent, self.tr('InaSAFE'), (self.tr('Output file name must be tif file'))) if not os.path.exists(input_path): QMessageBox.warning( self.parent, self.tr('InaSAFE'), (self.tr('Input file is not exist'))) return my_algorithm = str(self.cboAlgorithm.currentText()).lower() fileName = convert_mmi_data(input_path, output_path, the_algorithm=my_algorithm, algorithm_name=False) if self.cBLoadLayer.isChecked(): fileInfo = QFileInfo(fileName) baseName = fileInfo.baseName() my_raster_layer = QgsRasterLayer(fileName, baseName) if not my_raster_layer.isValid(): LOGGER.debug("Failed to load") else: QgsMapLayerRegistry.instance().addMapLayer(my_raster_layer) self.done(self.Accepted) if not self.test_mode: QMessageBox.warning( self.parent, self.tr('InaSAFE'), (self.tr('Success to convert %1 to %2'). arg(input_path).arg(output_path)))
def testPalettedColorTableToClassData(self): entries = [QgsColorRampShader.ColorRampItem(5, QColor(255, 0, 0), 'item1'), QgsColorRampShader.ColorRampItem(3, QColor(0, 255, 0), 'item2'), QgsColorRampShader.ColorRampItem(6, QColor(0, 0, 255), 'item3'), ] classes = QgsPalettedRasterRenderer.colorTableToClassData(entries) self.assertEqual(classes[0].value, 5) self.assertEqual(classes[1].value, 3) self.assertEqual(classes[2].value, 6) self.assertEqual(classes[0].label, 'item1') self.assertEqual(classes[1].label, 'item2') self.assertEqual(classes[2].label, 'item3') self.assertEqual(classes[0].color.name(), '#ff0000') self.assertEqual(classes[1].color.name(), '#00ff00') self.assertEqual(classes[2].color.name(), '#0000ff') # test #13263 path = os.path.join(unitTestDataPath('raster'), 'hub13263.vrt') info = QFileInfo(path) base_name = info.baseName() layer = QgsRasterLayer(path, base_name) self.assertTrue(layer.isValid(), 'Raster not loaded: {}'.format(path)) classes = QgsPalettedRasterRenderer.colorTableToClassData(layer.dataProvider().colorTable(1)) self.assertEqual(len(classes), 4) classes = QgsPalettedRasterRenderer.colorTableToClassData(layer.dataProvider().colorTable(15)) self.assertEqual(len(classes), 256)
def 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 loadLayer(theLayerFile): """Helper to load and return a single QGIS layer""" # Extract basename and absolute path myBaseName, myExt = os.path.splitext(theLayerFile) myPath = os.path.join(TESTDATA, theLayerFile) myKeywordPath = myPath[:-4] + '.keywords' # Determine if layer is hazard or exposure myKeywords = read_keywords(myKeywordPath) myType = 'undefined' if 'category' in myKeywords: myType = myKeywords['category'] msg = 'Could not read %s' % myKeywordPath assert myKeywords is not None, msg # Create QGis Layer Instance if myExt in ['.asc', '.tif']: myLayer = QgsRasterLayer(myPath, myBaseName) elif myExt in ['.shp']: myLayer = QgsVectorLayer(myPath, myBaseName, 'ogr') else: myMessage = 'File %s had illegal extension' % myPath raise Exception(myMessage) myMessage = 'Layer "%s" is not valid' % str(myLayer.source()) assert myLayer.isValid(), myMessage return myLayer, myType
def testIdentify(self): myPath = os.path.join(unitTestDataPath(), 'landsat.tif') myFileInfo = QFileInfo(myPath) myBaseName = myFileInfo.baseName() myRasterLayer = QgsRasterLayer(myPath, myBaseName) myMessage = 'Raster not loaded: %s' % myPath assert myRasterLayer.isValid(), myMessage myPoint = QgsPoint(786690, 3345803) #print 'Extents: %s' % myRasterLayer.extent().toString() #myResult, myRasterValues = myRasterLayer.identify(myPoint) #assert myResult myRasterValues = myRasterLayer.dataProvider().identify(myPoint, QgsRasterDataProvider.IdentifyFormatValue ) assert len( myRasterValues ) > 0 # Get the name of the first band myBand = myRasterValues.keys()[0] #myExpectedName = QString('Band 1') myExpectedBand = 1 myMessage = 'Expected "%s" got "%s" for first raster band name' % ( myExpectedBand, myBand) assert myExpectedBand == myBand, myMessage # Convert each band value to a list of ints then to a string myValues = myRasterValues.values() myIntValues = [] for myValue in myValues: #myIntValues.append(int(str(myValue))) myIntValues.append( myValue.toInt()[0] ) myValues = str(myIntValues) myExpectedValues = '[127, 141, 112, 72, 86, 126, 156, 211, 170]' myMessage = 'Expected: %s\nGot: %s' % (myValues, myExpectedValues) self.assertEquals(myValues, myExpectedValues, myMessage)
def generateLayer(self, nameCoverage, coverageTime, boundingBox=None): """Generates a raster layer for QGIS. :param nameCoverage: the name identifier of the coverage we want to retrieve. :type nameCoverage: str :param coverageTime: the time dimension of the coverage we want. :type coverageTime: str :returns: a QGIS-compatible raster layer object for the coverage and times provided. :rtype: QgsRasterLayer """ url = self.generateURLForGeoTIFF(nameCoverage, coverageTime, boundingBox) layerName = "{ct}_{nc}-{id}".format(ct=coverageTime, nc=nameCoverage, id=uuid.uuid4()) if Utilities.is_linux(): import requests with tempfile.NamedTemporaryFile(suffix=".tiff", delete=False) as f: r = requests.get(url, stream=True) with open(f.name, "wb") as g: for chunk in r.iter_content(): g.write(chunk) layer = QgsRasterLayer(f.name, layerName) else: layer = QgsRasterLayer(url, layerName) if layer.isValid(): return layer else: msg = "Couldn't create a valid layer." self.standardMessage.emit(msg)
def test_read_existing_geopackage(self): """Test we can read an existing geopackage.""" path = standard_data_path('other', 'jakarta.gpkg') import os path = os.path.normpath(os.path.normcase(os.path.abspath(path))) geopackage = QFileInfo(path) data_store = GeoPackage(geopackage) # We should have 3 layers in this geopackage. self.assertEqual(len(data_store.layers()), 3) # Test we can load a vector layer. roads = QgsVectorLayer( data_store.layer_uri('roads'), 'Test', 'ogr' ) self.assertTrue(roads.isValid()) # Test we can load a raster layers. # This currently fails on windows... # So we have decorated it with expected fail on windows # Should pass on other platforms. path = data_store.layer_uri('flood') flood = QgsRasterLayer(path, 'flood') self.assertTrue(flood.isValid())
def toMapLayer(self): from qgis.core import QgsRasterLayer, QgsContrastEnhancement rl = QgsRasterLayer(self.gdalUri(), self.name) if rl.isValid(): rl.setContrastEnhancement(QgsContrastEnhancement.StretchToMinimumMaximum) return rl
def testIdentify(self): myPath = os.path.abspath(os.path.join(__file__, '..', '..', '..', 'testdata', 'landsat.tif')) myFileInfo = QFileInfo(myPath) myBaseName = myFileInfo.baseName() myRasterLayer = QgsRasterLayer(myPath, myBaseName) myMessage = 'Raster not loaded: %s' % myPath assert myRasterLayer.isValid(), myMessage myPoint = QgsPoint(786690, 3345803) #print 'Extents: %s' % myRasterLayer.extent().toString() myResult, myRasterValues = myRasterLayer.identify(myPoint) assert myResult # Get the name of the first band myBandName = myRasterValues.keys()[0] myExpectedName = QString('Band 1') myMessage = 'Expected "%s" got "%s" for first raster band name' % ( myExpectedName, myBandName) assert myExpectedName == myBandName, myMessage # Convert each band value to a list of ints then to a string myValues = myRasterValues.values() myIntValues = [] for myValue in myValues: myIntValues.append(int(str(myValue))) myValues = str(myIntValues) myExpectedValues = '[127, 141, 112, 72, 86, 126, 156, 211, 170]' myMessage = 'Expected: %s\nGot: %s' % (myValues, myExpectedValues) self.assertEquals(myValues, myExpectedValues, myMessage)
def generateLayerFromGeoTIFFURL(self, geoTiffUrl, layerName): """Generates a new layer based on the GeoTIFF URL provided for the WCS service. This method also appends to the name an UUID so the uniqueness of it's name and ID is guaranteed to avoid problems when managing asynchronous generation of layers between different processes. :param geoTiffUrl: the download URL for this image. :type geoTiffUrl: str :param layerName: the name to give to this layer. The resultant layer will have an UUID appended. :type layerName: str """ tiff_string = "{ln}{id}".format(ln=layerName, id=uuid.uuid4()) layer = QgsRasterLayer(geoTiffUrl, tiff_string) if Utilities.is_linux(): import requests with tempfile.NamedTemporaryFile(suffix=".tiff", delete=False) as f: r = requests.get(geoTiffUrl, stream=True) with open(f.name, "wb") as g: for chunk in r.iter_content(): g.write(chunk) layer = QgsRasterLayer(f.name, layerName) else: layer = QgsRasterLayer(geoTiffUrl, layerName) if layer.isValid(): return layer else: msg = "Couldn't create a valid layer." self.standardMessage.emit(msg)
def test_clip_raster_small(self): """Raster layers can be clipped in small and precise size. For #710.""" # 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 is not None, message # Create a bounding box bounding_box = [97, -3, 104, 1] # Clip the vector to the bbox result = clip_layer(raster_layer, bounding_box) # Check the output is valid assert os.path.exists(result.source()) # Clip and give a desired resolution for the output # small pixel size and high precision # based on pixel size of Flood_Current_Depth_Jakarta_geographic.asc size = 0.00045228819716 result = clip_layer(raster_layer, bounding_box, size) new_raster_layer = QgsRasterLayer(result.source(), layer_name) assert new_raster_layer.isValid(), 'Resampled raster is not valid' message = ( 'Resampled raster has incorrect pixel size. Expected: %.14f, ' 'Actual: %.14f' % ( size, new_raster_layer.rasterUnitsPerPixelX())) result_size = new_raster_layer.rasterUnitsPerPixelX() self.assertAlmostEqual(result_size, size, places=13, msg=message)
def accept(self): """Creates and loads the WMS layer.""" self.close() currentIndex = self.comboBoxLayer.currentIndex() currentLayerId, unused_dataType = self.comboBoxLayer.itemData(currentIndex) currentLayerName = unicode(self.comboBoxLayer.currentText()) mapId = self.labelMapId.text() # Create the WMS layer token = oauth2_utils.getToken() url = 'https://mapsengine.google.com/%s-4/wms/%s/' wmsUrl = url % (mapId, token.access_token) currentFormatIndex = self.comboBoxFormat.currentIndex() imageFormat = unicode(self.comboBoxFormat.itemData(currentFormatIndex)) crs = self.comboBoxCrs.currentText() uri = QgsDataSourceURI() uri.setParam('url', wmsUrl) uri.setParam('layers', currentLayerId) uri.setParam('format', imageFormat) uri.setParam('crs', crs) uri.setParam('styles', '') rlayer = QgsRasterLayer(str(uri.encodedUri()), currentLayerName, 'wms') if rlayer.isValid(): QgsMapLayerRegistry.instance().addMapLayer(rlayer) else: logText = 'Failed to add WMS layer %s with URI %s' % ( currentLayerName, str(uri.encodedUri())) warnText = 'Failed to add WMS layer %s' % currentLayerName QgsMessageLog.logMessage(logText, 'GMEConnector', QgsMessageLog.CRITICAL) self.iface.messageBar().pushMessage( 'Google Maps Engine Connector', warnText, level=QgsMessageBar.CRITICAL, duration=3)
def test_clip_raster(self): """Raster layers can be clipped.""" # 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 is not None, message # Create a bounding box bounding_box = [97, -3, 104, 1] # Clip the vector to the bbox result = clip_layer(raster_layer, bounding_box) # Check the output is valid assert os.path.exists(result.source()) # Clip and give a desired resolution for the output # big pixel size size = 0.05 result = clip_layer(raster_layer, bounding_box, size) new_raster_layer = QgsRasterLayer(result.source(), layer_name) assert new_raster_layer.isValid(), 'Resampled raster is not valid' message = ( 'Resampled raster has incorrect pixel size. Expected: %5f, ' 'Actual: %5f' % (size, new_raster_layer.rasterUnitsPerPixelX())) assert new_raster_layer.rasterUnitsPerPixelX() == size, message
def test_clipRaster(self): """Raster layers can be clipped """ # Create a raster layer myName = 'shake' myRasterLayer = QgsRasterLayer(RASTERPATH, myName) myMessage = 'Did not find layer "%s" in path "%s"' % \ (myName, RASTERPATH) assert myRasterLayer is not None, myMessage # Create a bounding box myRect = [97, -3, 104, 1] # Clip the vector to the bbox myResult = clip_layer(myRasterLayer, myRect) # Check the output is valid assert os.path.exists(myResult.source()) # Clip and give a desired resolution for the output mySize = 0.05 myResult = clip_layer(myRasterLayer, myRect, mySize) myNewRasterLayer = QgsRasterLayer(myResult.source(), myName) assert myNewRasterLayer.isValid(), 'Resampled raster is not valid' myMessage = ('Resampled raster has incorrect pixel size.' 'Expected: %f, Actual: %f' % (mySize, myNewRasterLayer.rasterUnitsPerPixelX())) assert myNewRasterLayer.rasterUnitsPerPixelX() == mySize, myMessage
def test_invalidFilenamesCaught(self): """Invalid filenames raise appropriate exceptions Wrote this test because test_clipBoth raised the wrong error when file was missing. Instead of reporting that, it gave Western boundary must be less than eastern. I got [0.0, 0.0, 0.0, 0.0] See issue #170 """ # Try to create a vector layer from non-existing filename myName = 'stnhaoeu_78oeukqjkrcgA' myPath = 'OEk_tnshoeu_439_kstnhoe' with RedirectStreams(stdout=DEVNULL, stderr=DEVNULL): myVectorLayer = QgsVectorLayer(myPath, myName, 'ogr') myMessage = ('QgsVectorLayer reported "valid" for non ' 'existent path "%s" and name "%s".' % (myPath, myName)) assert not myVectorLayer.isValid(), myMessage # Create a raster layer with RedirectStreams(stdout=DEVNULL, stderr=DEVNULL): myRasterLayer = QgsRasterLayer(myPath, myName) myMessage = ('QgsRasterLayer reported "valid" for non ' 'existent path "%s" and name "%s".' % (myPath, myName)) assert not myRasterLayer.isValid(), myMessage
def add_layer( self, layer_source, layer_name): layer = QgsRasterLayer(layer_source,self.tr(layer_name),"wms") if not layer.isValid(): # Test if string is valid QMessageBox.information(self.iface.mainWindow(),self.tr(u"Error!"), self.tr(u"Layer has no valid token... Try again!")) QSettings().setValue('lmopendata/token', '') # if layer is incorrect clear token key QgsMapLayerRegistry.instance().addMapLayer(layer)
def toMapLayer(self): from qgis.core import QgsRasterLayer, QgsContrastEnhancement # QGIS has no provider to load rasters, let's use GDAL uri = self.gpkgGdalUri() rl = QgsRasterLayer(uri, self.name) if rl.isValid(): rl.setContrastEnhancement(QgsContrastEnhancement.StretchToMinimumMaximum) return rl
def test_get_raster_layer_list(self): wms_url_with_parameters = self.valid_wms_url # use this list for proper testing... visibility = [True, False, True, True, True, False] # when debugging, use the list below instead # visibility = [True] for i, visible in enumerate(visibility): layer_name = layer_interaction.biuniquify_layer_name('r{}_visible:{}'.format(i, visible)) rlayer = QgsRasterLayer(wms_url_with_parameters, layer_name, 'wms') self.assertTrue(rlayer.isValid(), layer_name.join(' is not a valid raster layer')) QgsMapLayerRegistry.instance().addMapLayer(rlayer) self.iface.legendInterface().setLayerVisible(rlayer, visible) self.layer_list.append(layer_name) # get a list of all visible wms layers expected_layers = {} actual_layers = {} visible_raster_layers = layer_interaction.get_raster_layer_list(self.iface, 'visible') for i, visible in enumerate(visibility): if visible: expected_layers[self.layer_list[i]] = True for layer in visible_raster_layers: if '_visible:' in layer.name(): actual_layers[str(layer.name())] = True self.assertDictEqual(expected_layers, actual_layers, 'The returned layers do not match the expected layers.\n\t Expected: {0}\n\t received: {1}.'.format(expected_layers, actual_layers)) # get a list of all invisible wms layers expected_layers = {} actual_layers = {} invisible_raster_layers = layer_interaction.get_raster_layer_list(self.iface, 'invisible') for i, visible in enumerate(visibility): if not visible: expected_layers[self.layer_list[i]] = False for layer in invisible_raster_layers: if '_visible:' in layer.name(): actual_layers[str(layer.name())] = True if layer.name().endswith('True') else False self.assertDictEqual(expected_layers, actual_layers, 'The returned layers do not match the expected layers.\n\t Expected: {0}\n\t received: {1}.'.format(expected_layers, actual_layers)) # get a list of wms layers expected_layers = {} actual_layers = {} invisible_raster_layers = layer_interaction.get_raster_layer_list(self.iface, 'all') for i, visible in enumerate(visibility): expected_layers[self.layer_list[i]] = visible for layer in invisible_raster_layers: if '_visible:' in layer.name(): actual_layers[str(layer.name())] = True if layer.name().endswith('True') else False self.assertDictEqual(expected_layers, actual_layers, 'The returned layers do not match the expected layers.\n\t Expected: {0}\n\t received: {1}.'.format(expected_layers, actual_layers))
def testIssue7023(self): """Check if converting a raster from 1.8 to 2 works.""" myPath = os.path.join(unitTestDataPath("raster"), "raster-pallette-crash2.tif") myFileInfo = QFileInfo(myPath) myBaseName = myFileInfo.baseName() myRasterLayer = QgsRasterLayer(myPath, myBaseName) myMessage = "Raster not loaded: %s" % myPath assert myRasterLayer.isValid(), myMessage # crash on next line QgsMapLayerRegistry.instance().addMapLayers([myRasterLayer])
def loadLayers(theLayerList, theClearFlag=True): """Helper function to load layers as defined in a python list.""" # First unload any layers that may already be loaded if theClearFlag: for myLayer in QgsMapLayerRegistry.instance().mapLayers(): QgsMapLayerRegistry.instance().removeMapLayer(myLayer) # Now go ahead and load our layers myExposureLayerCount = 0 myHazardLayerCount = 0 myCanvasLayers = [] # Now create our new layers for myFile in theLayerList: # Extract basename and absolute path myBaseName, myExt = os.path.splitext(myFile) myPath = os.path.join(TESTDATA, myFile) myKeywordPath = myPath[:-4] + '.keywords' # Determine if layer is hazard or exposure myKeywords = read_keywords(myKeywordPath) msg = 'Could not read %s' % myKeywordPath assert myKeywords is not None, msg if myKeywords['category'] == 'hazard': myHazardLayerCount += 1 elif myKeywords['category'] == 'exposure': myExposureLayerCount += 1 # Create QGis Layer Instance if myExt in ['.asc', '.tif']: myLayer = QgsRasterLayer(myPath, myBaseName) elif myExt in ['.shp']: myLayer = QgsVectorLayer(myPath, myBaseName, 'ogr') else: myMessage = 'File %s had illegal extension' % myPath raise Exception(myMessage) myMessage = 'Layer "%s" is not valid' % str(myLayer.source()) assert myLayer.isValid(), myMessage # Add layer to the registry (that QGis knows about) QgsMapLayerRegistry.instance().addMapLayer(myLayer) # Create Map Canvas Layer Instance and add to list myCanvasLayers.append(QgsMapCanvasLayer(myLayer)) # Quickly add any existing CANVAS layers to our list first for myLayer in CANVAS.layers(): myCanvasLayers.append(QgsMapCanvasLayer(myLayer)) # now load all these layers in the CANVAS CANVAS.setLayerSet(myCanvasLayers) DOCK.getLayers() # Add MCL's to the CANVAS return myHazardLayerCount, myExposureLayerCount
def create_keyword_file(self, algorithm): """Create keyword file for the raster file created. Basically copy a template from keyword file in converter data and add extra keyword (usually a title) :param algorithm: Which re-sampling algorithm to use. valid options are 'nearest' (for nearest neighbour), 'invdist' (for inverse distance), 'average' (for moving average). Defaults to 'nearest' if not specified. Note that passing re-sampling alg parameters is currently not supported. If None is passed it will be replaced with 'nearest'. :type algorithm: str """ keyword_io = KeywordIO() classes = {} for item in earthquake_mmi_scale['classes']: classes[item['key']] = [ item['numeric_default_min'], item['numeric_default_max']] keywords = { 'hazard': hazard_earthquake['key'], 'hazard_category': hazard_category_single_event['key'], 'keyword_version': inasafe_keyword_version, 'layer_geometry': layer_geometry_raster['key'], 'layer_mode': layer_mode_continuous['key'], 'layer_purpose': layer_purpose_hazard['key'], 'continuous_hazard_unit': unit_mmi['key'], 'classification': earthquake_mmi_scale['key'], 'thresholds': classes } if self.algorithm_name: layer_path = os.path.join( self.output_dir, '%s-%s.tif' % ( self.output_basename, algorithm)) else: layer_path = os.path.join( self.output_dir, '%s.tif' % self.output_basename) # append title and source to the keywords file if len(self.title.strip()) == 0: keyword_title = self.output_basename else: keyword_title = self.title keywords['title'] = keyword_title hazard_layer = QgsRasterLayer(layer_path, keyword_title) if not hazard_layer.isValid(): raise InvalidLayerError() keyword_io.write_keywords(hazard_layer, keywords)
def CrossTab(raster1, raster2, vector1, diretorioOut, resolucao, campoID, weight111, weight112, weight121, weight122, weight199, weight299, weight399, weight499599): fileInfo1 = QFileInfo(raster1) path1 = fileInfo1.filePath() baseName1 = fileInfo1.baseName() layer1 = QgsRasterLayer(path1, baseName1) QgsMapLayerRegistry.instance().addMapLayer(layer1) if layer1.isValid() is True: print "Layer1 was loaded successfully!" else: print "Unable to read basename and file path - Your string is probably invalid" provider1 = layer1.dataProvider() extent1 = provider1.extent() rows1 = layer1.height() cols1 = layer1.width() block1 = provider1.block(1, extent1, cols1, rows1) fileInfo2 = QFileInfo(raster2) path2 = fileInfo2.filePath() baseName2 = fileInfo2.baseName() layer2 = QgsRasterLayer(path2, baseName2) QgsMapLayerRegistry.instance().addMapLayer(layer2) if layer2.isValid() is True: print "Layer2 was loaded successfully!" else: print "Unable to read basename and file path - Your string is probably invalid" provider2 = layer2.dataProvider() extent2 = provider2.extent() rows2 = layer2.height() cols2 = layer2.width() block2 = provider2.block(1, extent2, cols2, rows2) fileInfo3 = QFileInfo(vector1) path3 = fileInfo3.filePath() baseName3 = fileInfo3.baseName() layer3 = QgsVectorLayer("%s" % (vector1), "vector1", "ogr") QgsMapLayerRegistry.instance().addMapLayer(layer3) feats_count = layer3.featureCount() if layer3.isValid() is True: print "Layer3 was loaded successfully!" else: print "Unable to read basename and file path - Your string is probably invalid" valoresBGRI = [] valoresBGRIunicos = [] # lista de valores BGRI unicos for feature in layer3.getFeatures(): objectid = feature.attributes()[layer3.fieldNameIndex(campoID)] valoresBGRI.append(objectid) for v in valoresBGRI: if v not in valoresBGRIunicos: valoresBGRIunicos.append(v) a = len(valoresBGRIunicos) print a feats_count = layer3.featureCount() print feats_count valoresCLCunicos = [111, 112, 121, 122, 199, 299, 399, 499, 599] b = len(valoresCLCunicos) print b crossTabMatrix = [[0 for y in range(b + 1)] for x in range(a + 1)] for y in range(b): crossTabMatrix[0][y + 1] = valoresCLCunicos[y] for x in range(a): crossTabMatrix[x + 1][0] = valoresBGRIunicos[x] #print crossTabMatrix #crosstab for i in range(rows1): for j in range(cols1): cell_value1 = int(block1.value(i, j)) cell_value2 = int(block2.value(i, j)) for y in range(b): for x in range(a): if cell_value1 == crossTabMatrix[ x + 1][0] and cell_value2 == crossTabMatrix[0][y + 1]: crossTabMatrix[x + 1][y + 1] += 1 #print crossTabMatrix #exportar a tabulacao para csv csvfile = diretorioOut + r"\crosstab.csv" print csvfile with open(csvfile, "w") as output: writer = csv.writer(output, lineterminator='\n') writer.writerows(crossTabMatrix) # Adicionar campos para calculo (Campo1, Campo 2) shp_uri = vector1 shp = QgsVectorLayer(shp_uri, 'bgri', 'ogr') caps = shp.dataProvider().capabilities() if caps & QgsVectorDataProvider.AddAttributes: res = shp.dataProvider().addAttributes([ QgsField("E", QVariant.Double), QgsField("TOTAL", QVariant.Double) ]) #if caps & QgsVectorDataProvider.DeleteAttributes: # res = shp.dataProvider().deleteAttributes([0]) shp.updateFields() QgsMapLayerRegistry.instance().addMapLayer(shp) # Get input (csv) and target (Shapefile) layers csv_uri = 'file:///' + diretorioOut + r'/crosstab.csv?delimiter=,' print csv_uri csvlayer = QgsVectorLayer(csv_uri, "crosstab", "delimitedtext") QgsMapLayerRegistry.instance().addMapLayer(csvlayer) # Set properties for the join shpField = campoID csvField = '0_1' joinObject = QgsVectorJoinInfo() joinObject.joinLayerId = csvlayer.id() joinObject.joinFieldName = csvField joinObject.targetFieldName = shpField joinObject.memoryCache = True shp.addJoin(joinObject) # Calcular pesos, TOTAL e E # Update do campo TOTAL no shapefile resolucao2 = int(resolucao) * int(resolucao) expressionT = QgsExpression( "(crosstab_111_1+crosstab_112_1+crosstab_121_1+crosstab_122_1+crosstab_199_1+crosstab_299_1+crosstab_399_1+crosstab_499_1+crosstab_599_1)*{}" .format(resolucao2)) indexT = shp.fieldNameIndex("TOTAL") expressionT.prepare(shp.pendingFields()) shp.startEditing() for feature in shp.getFeatures(): valueT = expressionT.evaluate(feature) shp.changeAttributeValue(feature.id(), indexT, valueT) shp.commitChanges() # Update do campo E no shapefile expressionE = QgsExpression( "((crosstab_111_1*{})/TOTAL)*{}+((crosstab_112_1*{})/TOTAL)*{}+((crosstab_121_1*{})/TOTAL)*{}+((crosstab_122_1*{})/TOTAL)*{}+((crosstab_199_1*{})/TOTAL)*{}+((crosstab_299_1*{})/TOTAL)*{}+((crosstab_399_1*{})/TOTAL)*{}" .format(resolucao2, weight111, resolucao2, weight112, resolucao2, weight121, resolucao2, weight122, resolucao2, weight199, resolucao2, weight299, resolucao2, weight399)) indexE = shp.fieldNameIndex("E") expressionE.prepare(shp.pendingFields()) shp.startEditing() for feature in shp.getFeatures(): valueE = expressionE.evaluate(feature) shp.changeAttributeValue(feature.id(), indexE, valueE) shp.commitChanges()
def __add_images(images, description, outdir, msgbar, check, vrt=True, shown=True): if check.isChecked() and vrt: pan = images.pop('pan', None) # take out pan if len(images) > 1: # stack images in a VRT file if there are more than one image left vrtfile = os.path.join(outdir, description + '.vrt') # to sort in r/g/b/nir order here sort(images.keys, key=lambda k: rgbn[k]) _RGBN = {'red': 1, 'green': 2, 'blue': 3, 'nir': 4} images_keys_ordered = sorted(images.keys(), key=lambda k: _RGBN.get(k, 5)) filenames = [images[k] for k in images_keys_ordered ] # filenames list in RGBN order ds = gdal.BuildVRT( vrtfile, filenames, options=gdal.BuildVRTOptions(separate=True, resolution='highest')) for i, bn in enumerate(images_keys_ordered): b = ds.GetRasterBand(i + 1) b.SetDescription(bn) ds.FlushCache() ds = None if pan is None: # nothing to do anymore, add VRT file __add_images({'vrt': vrtfile}, description, outdir, msgbar, check, vrt=False) else: # VERY SLOW TO DO HERE (perhaps as ProcessingProvider?) # nbands = len(images) # if nbands > 2: # may be a setting here for pansharpening choice # pan_ds = gdal.Open(pan) # pansharpened_ds = gdal.CreatePansharpenedVRT(__pszXML(nbands), pan_ds.GetRasterBand(1), # [ds.GetRasterBand(i + 1) for i in range(nbands)]) # pansharpened_filename = os.path.join(outdir, description + '_pansharpened.vrt') # driver = gdal.GetDriverByName('VRT') # driver.CreateCopy(pansharpened_filename, pansharpened_ds, 0) # # add ALL # __add_images({'pansharpened': pansharpened_filename, # 'pan': pan, 'vrt': vrtfile}, description, outdir, msgbar, check, vrt=False, shown=False) # else: # # just add pan and vrt files __add_images({ 'pan': pan, 'vrt': vrtfile }, description, outdir, msgbar, check, vrt=False) else: # do not stack since there are not enough images assert pan is not None # 'pan' should be not 'None' here images.update({'pan': pan}) # restore pan __add_images(images, description, outdir, msgbar, check, vrt=False) else: for k in images.keys(): fn = images[k] name = os.path.basename(fn).split('.')[0] layer = QgsRasterLayer(fn, name) if layer.isValid(): QgsProject.instance().addMapLayer(layer) if not shown: QgsProject.instance().layerTreeRoot().findLayer( layer.id()).setItemVisibilityChecked(shown) msgbar.dismiss()
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 exposed_people_stats(hazard, exposure, aggregation, fatality_rate): """Calculate the number of exposed people per MMI level per aggregation. Calculate the number of exposed people per MMI level per aggregation zone and prepare raster layer outputs. :param hazard: The earthquake raster layer. :type hazard: QgsRasterLayer :param exposure: The population raster layer. :type exposure: QgsVectorLayer :param aggregation: The aggregation layer. :type aggregation: QgsVectorLayer :param fatality_rate: The fatality rate to use. :type fatality_rate: function :return: A tuble with the exposed per MMI level par aggregation and the exposed raster. Tuple (mmi, agg_zone), value: number of exposed people :rtype: (dict, QgsRasterLayer) """ output_layer_name = earthquake_displaced['output_layer_name'] processing_step = earthquake_displaced['step_name'] exposed_raster_filename = unique_filename( prefix=output_layer_name, suffix='.tif') hazard_provider = hazard.dataProvider() extent = hazard.extent() width, height = hazard_provider.xSize(), hazard_provider.ySize() hazard_block = hazard_provider.block(1, extent, width, height) exposure_provider = exposure.dataProvider() exposure_block = exposure_provider.block(1, extent, width, height) agg_provider = aggregation.dataProvider() agg_block = agg_provider.block(1, extent, width, height) exposed = {} # key: tuple (mmi, agg_zone), value: number of exposed people exposed_array = make_array(width, height) classification_key = hazard.keywords['classification'] # walk through the rasters pixel by pixel and aggregate numbers # of people in the combination of hazard zones and aggregation zones for i in xrange(width * height): hazard_mmi = hazard_block.value(long(i)) people_count = exposure_block.value(long(i)) agg_zone_index = int(agg_block.value(long(i))) if hazard_mmi >= 2.0 and people_count >= 0.0: hazard_mmi = int(round(hazard_mmi)) mmi_fatalities = ( int(hazard_mmi * fatality_rate[hazard_mmi])) # rounding down mmi_displaced = ( (people_count - mmi_fatalities) * displacement_rate(hazard_mmi, classification_key)) key = (hazard_mmi, agg_zone_index) if key not in exposed: exposed[key] = 0 exposed[key] += people_count else: # If hazard is less than 2 or population is less than 0 mmi_displaced = -1 # We build a raster only for the aggregation area. if agg_zone_index > 0: exposed_array[i / width, i % width] = mmi_displaced else: exposed_array[i / width, i % width] = -1 # output raster data - e.g. displaced people array_to_raster(exposed_array, exposed_raster_filename, hazard) # I didn't find a way to do that with the QGIS API. data = gdal.Open(exposed_raster_filename, gdalconst.GA_Update) data.GetRasterBand(1).SetNoDataValue(-1) del data exposed_raster = QgsRasterLayer(exposed_raster_filename, 'exposed', 'gdal') assert exposed_raster.isValid() exposed_raster.keywords = dict(exposure.keywords) exposed_raster.keywords['layer_purpose'] = ( layer_purpose_exposure_summary['key']) exposed_raster.keywords['title'] = processing_step exposed_raster.keywords['exposure_keywords'] = dict(exposure.keywords) exposed_raster.keywords['hazard_keywords'] = dict(hazard.keywords) exposed_raster.keywords['aggregation_keywords'] = dict( aggregation.keywords) return exposed, exposed_raster
def add_layer_to_map(ds): layers4add = [] if ds.type.lower() == KNOWN_DRIVERS.TMS.lower(): if ds.alt_tms_urls: tms_url = ds.alt_tms_urls[random.randint(0, len(ds.alt_tms_urls) - 1)] else: tms_url = ds.tms_url if PluginSettings.use_native_tms(): # add version check service_url = tms_url.replace("=", "%3D").replace("&", "%26") if ds.tms_y_origin_top is not None and ds.tms_y_origin_top == False: service_url = service_url.replace('{y}', '{-y}') qgis_tms_uri = 'type=xyz&zmin={0}&zmax={1}&url={2}'.format( ds.tms_zmin or TileDefaultSettings.ZMIN, ds.tms_zmax or TileDefaultSettings.ZMAX, service_url) layer = QgsRasterLayer(qgis_tms_uri, tr(ds.alias), KNOWN_DRIVERS.WMS.lower()) ProjectionHelper.set_tile_layer_proj(layer, ds.tms_epsg_crs_id, ds.tms_postgis_crs_id, ds.tms_custom_proj) layers4add.append(layer) else: service_info = TileServiceInfo(tr(ds.alias), ds.copyright_text, tms_url) service_info.zmin = ds.tms_zmin or service_info.zmin service_info.zmax = ds.tms_zmax or service_info.zmax if ds.tms_y_origin_top is not None: service_info.yOriginTop = ds.tms_y_origin_top service_info.epsg_crs_id = ds.tms_epsg_crs_id service_info.postgis_crs_id = ds.tms_postgis_crs_id service_info.custom_proj = ds.tms_custom_proj if ds.tms_tile_ranges is not None: # needs try block & checks that keys are integers etc.. service_info.tile_ranges = ast.literal_eval(ds.tms_tile_ranges) if ds.tms_tsize1 is not None: service_info.tsize1 = ds.tms_tsize1 if ds.tms_origin_x is not None: service_info.originX = ds.tms_origin_x if ds.tms_origin_y is not None: service_info.originY = ds.tms_origin_y layer = TileLayer(service_info, False) layers4add.append(layer) if ds.type.lower() == KNOWN_DRIVERS.GDAL.lower(): layer = QgsRasterLayer(ds.gdal_source_file, tr(ds.alias)) layers4add.append(layer) if ds.type.lower() == KNOWN_DRIVERS.WMS.lower(): qgis_wms_uri = u'' if ds.wms_params: qgis_wms_uri += ds.wms_params if ds.wms_layers: layers = ds.wms_layers.split(',') if layers: if ds.wms_turn_over: layers.reverse() qgis_wms_uri += '&layers=' + '&layers='.join( layers) + '&styles=' * len(layers) qgis_wms_uri += '&url=' + ds.wms_url + "?" + ds.wms_url_params.replace( "=", "%3D").replace("&", "%26") layer = QgsRasterLayer(qgis_wms_uri, tr(ds.alias), KNOWN_DRIVERS.WMS.lower()) layers4add.append(layer) if ds.type.lower() == KNOWN_DRIVERS.WFS.lower(): qgis_wfs_uri_base = ds.wfs_url if ds.wfs_params is not None: qgis_wfs_uri_base += ds.wfs_params o = urlparse.urlparse(qgis_wfs_uri_base) request_attrs = dict(urlparse.parse_qsl(o.query)) new_request_attrs = {} for k, v in request_attrs.items(): new_request_attrs[k.upper()] = v if ds.wfs_epsg is not None: new_request_attrs['SRSNAME'] = "EPSG:{0}".format(ds.wfs_epsg) layers = [] if len(ds.wfs_layers) > 0: layers.extend(ds.wfs_layers) else: layers_str = request_attrs.get('TYPENAME', '') layers.extend(layers_str.split()) for layer_name in layers: new_request_attrs['TYPENAME'] = layer_name url_parts = list(o) url_parts[4] = "&".join( ["%s=%s" % (k, v) for k, v in new_request_attrs.items()]) qgis_wfs_uri = urlparse.urlunparse(url_parts) layer = QgsVectorLayer(qgis_wfs_uri, "%s - %s" % (tr(ds.alias), layer_name), "WFS") layers4add.append(layer) if ds.type.lower() == KNOWN_DRIVERS.GEOJSON.lower(): layer = QgsVectorLayer(ds.geojson_url, tr(ds.alias), "ogr") layers4add.append(layer) for layer in layers4add: if not layer.isValid(): error_message = tr( 'Layer %s can\'t be added to the map!') % ds.alias iface.messageBar().pushMessage(tr('Error'), error_message, level=QGisMessageBarLevel.Critical) QgsMessageLog.logMessage(error_message, level=QGisMessageLogLevel.Critical) else: # Set attribs layer.setAttribution(ds.copyright_text) layer.setAttributionUrl(ds.copyright_link) # Insert layer toc_root = QgsProject.instance().layerTreeRoot() selected_node = iface.layerTreeView().currentNode() if selected_node.nodeType() == selected_node.NodeGroup: toc_root = selected_node if ds.type.lower() in (KNOWN_DRIVERS.WMS.lower(), KNOWN_DRIVERS.TMS.lower()): position = len( toc_root.children()) # Insert to bottom if wms\tms else: position = 0 # insert to top addMapLayer(layer, False) toc_root.insertLayer(position, layer) # Save link service_layers.append(layer) # Set OTF CRS Transform for map if PluginSettings.enable_otf_3857( ) and ds.type == KNOWN_DRIVERS.TMS: if hasattr(iface.mapCanvas(), "setCrsTransformEnabled"): # Need for QGIS2. In QGIS3 CRS transformation is always enabled iface.mapCanvas().setCrsTransformEnabled(True) iface.mapCanvas().setDestinationCrs(TileLayer.CRS_3857)
os.environ["QT_QPA_PLATFORM"] = "offscreen" # disable QT trying to connect to display; needed on HPC infrastructure qgis_path = which('qgis') # find the QGIS install location QgsApplication.setPrefixPath(qgis_path, True) # supply path to qgis install location qgs = QgsApplication([], False) # create a reference to the QgsApplication, GUI = False qgs.initQgis() # load providers # Convert Path() to string for QGIS catchment_file = str(intersect_path/intersect_name) # needs to be the copied file because output is automatically added to this dem_file = str(dem_path/dem_name) # Load the shape and raster layer_polygon = QgsVectorLayer(catchment_file,'merit_hydro_basin','ogr') layer_raster = QgsRasterLayer(dem_file,'merit_hydro_dem') # Check we loaded the layers correctly if not layer_raster.isValid(): print('Raster layer failed to load') if not layer_polygon.isValid(): print('Polygon layer failed to load') # Create a zonal statistics object, automatically saved to file band = 1 # raster band with the data we are after zonalstats = QgsZonalStatistics(layer_polygon, # shapefile layer_raster, # .tif 'elev_', # prefix for the new column added to the shapefile band, # raster band we're interested in stats=QgsZonalStatistics.Mean).calculateStatistics(None) # Clean memory qgs.exitQgis()
def testBilinearResample(self): with tempfile.TemporaryDirectory() as dest_dir: path = os.path.join(unitTestDataPath(), 'landsat.tif') dest_path = shutil.copy(path, os.path.join(dest_dir, 'landsat.tif')) raster_layer = QgsRasterLayer(dest_path, 'test') raster_layer.dataProvider().setNoDataValue(1, -9999) self.assertTrue(raster_layer.isValid()) extent = QgsRectangle(785994.37761193525511771, 3346249.2209800467826426, 786108.49096253968309611, 3346362.94137834152206779) renderer = QgsSingleBandGrayRenderer(raster_layer.dataProvider(), 1) filter = QgsRasterResampleFilter(renderer) # default (nearest neighbour) resampling block = filter.block(1, extent, 2, 2) self.checkBlockContents(block, [[124, 127], [125, 126]]) block = filter.block(1, extent, 4, 4) self.checkBlockContents(block, [[124, 124, 127, 127], [124, 124, 127, 127], [125, 125, 126, 126], [125, 125, 126, 126]] ) block = filter.block(1, extent, 8, 8) self.checkBlockContents(block, [[124, 124, 124, 124, 127, 127, 127, 127], [124, 124, 124, 124, 127, 127, 127, 127], [124, 124, 124, 124, 127, 127, 127, 127], [124, 124, 124, 124, 127, 127, 127, 127], [125, 125, 125, 125, 126, 126, 126, 126], [125, 125, 125, 125, 126, 126, 126, 126], [125, 125, 125, 125, 126, 126, 126, 126], [125, 125, 125, 125, 126, 126, 126, 126]]) # with resampling filter.setZoomedInResampler(QgsBilinearRasterResampler()) block = filter.block(1, extent, 2, 2) self.checkBlockContents(block, [[124, 127], [125, 126]]) block = filter.block(1, extent, 4, 4) self.checkBlockContents(block, [[124, 124, 126, 126], [124, 124, 125, 126], [124, 124, 125, 126], [125, 125, 125, 126]] ) block = filter.block(1, extent, 8, 8) self.checkBlockContents(block, [[124, 124, 124, 125, 125, 126, 126, 126], [124, 124, 124, 125, 125, 126, 126, 126], [124, 124, 124, 124, 125, 125, 126, 126], [124, 124, 124, 124, 125, 125, 126, 126], [124, 124, 124, 124, 125, 125, 126, 126], [124, 124, 124, 124, 125, 125, 126, 126], [125, 125, 125, 125, 125, 125, 126, 126], [125, 125, 125, 125, 125, 125, 126, 126]] ) # with oversampling extent = QgsRectangle(785878.92593475803732872, 3346136.27493690419942141, 786223.56509550288319588, 3346477.7564090033993125) block = filter.block(1, extent, 2, 2) self.checkBlockContents(block, [[127, 126], [125, 126]]) block = filter.block(1, extent, 4, 4) self.checkBlockContents(block, [[125, 127, 127, 127], [126, 127, 127, 126], [125, 126, 126, 126], [127, 125, 125, 125]] ) block = filter.block(1, extent, 8, 8) self.checkBlockContents(block, [[126, 126, 126, 126, 125, 125, 125, 126], [126, 126, 125, 125, 125, 126, 126, 126], [126, 125, 124, 124, 125, 126, 126, 126], [126, 125, 124, 124, 125, 126, 126, 126], [125, 125, 124, 124, 124, 126, 126, 126], [125, 125, 125, 125, 125, 126, 126, 126], [125, 125, 125, 125, 125, 126, 126, 126], [125, 125, 126, 126, 125, 125, 125, 125]] ) filter.setMaxOversampling(2) block = filter.block(1, extent, 2, 2) self.checkBlockContents(block, [[127, 126], [125, 126]]) block = filter.block(1, extent, 4, 4) self.checkBlockContents(block, [[125, 127, 127, 127], [126, 127, 127, 126], [125, 126, 126, 126], [127, 125, 125, 125]] ) block = filter.block(1, extent, 8, 8) self.checkBlockContents(block, [[126, 126, 126, 126, 125, 125, 125, 126], [126, 126, 125, 125, 125, 126, 126, 126], [126, 125, 124, 124, 125, 126, 126, 126], [126, 125, 124, 124, 125, 126, 126, 126], [125, 125, 124, 124, 124, 126, 126, 126], [125, 125, 125, 125, 125, 126, 126, 126], [125, 125, 125, 125, 125, 126, 126, 126], [125, 125, 126, 126, 125, 125, 125, 125]] ) filter.setMaxOversampling(4) block = filter.block(1, extent, 2, 2) self.checkBlockContents(block, [[127, 126], [125, 126]]) block = filter.block(1, extent, 4, 4) self.checkBlockContents(block, [[125, 127, 127, 127], [126, 127, 127, 126], [125, 126, 126, 126], [127, 125, 125, 125]] ) block = filter.block(1, extent, 8, 8) self.checkBlockContents(block, [[126, 126, 126, 126, 125, 125, 125, 126], [126, 126, 125, 125, 125, 126, 126, 126], [126, 125, 124, 124, 125, 126, 126, 126], [126, 125, 124, 124, 125, 126, 126, 126], [125, 125, 124, 124, 124, 126, 126, 126], [125, 125, 125, 125, 125, 126, 126, 126], [125, 125, 125, 125, 125, 126, 126, 126], [125, 125, 126, 126, 125, 125, 125, 125]] )
def test_project_roundtrip(self): """Tests that a project with bad layers can be saved and restored""" p = QgsProject.instance() temp_dir = QTemporaryDir() for ext in ('shp', 'dbf', 'shx', 'prj'): copyfile(os.path.join(TEST_DATA_DIR, 'lines.%s' % ext), os.path.join(temp_dir.path(), 'lines.%s' % ext)) copyfile( os.path.join(TEST_DATA_DIR, 'raster', 'band1_byte_ct_epsg4326.tif'), os.path.join(temp_dir.path(), 'band1_byte_ct_epsg4326.tif')) copyfile( os.path.join(TEST_DATA_DIR, 'raster', 'band1_byte_ct_epsg4326.tif'), os.path.join(temp_dir.path(), 'band1_byte_ct_epsg4326_copy.tif')) l = QgsVectorLayer(os.path.join(temp_dir.path(), 'lines.shp'), 'lines', 'ogr') self.assertTrue(l.isValid()) rl = QgsRasterLayer( os.path.join(temp_dir.path(), 'band1_byte_ct_epsg4326.tif'), 'raster', 'gdal') self.assertTrue(rl.isValid()) rl_copy = QgsRasterLayer( os.path.join(temp_dir.path(), 'band1_byte_ct_epsg4326_copy.tif'), 'raster_copy', 'gdal') self.assertTrue(rl_copy.isValid()) self.assertTrue(p.addMapLayers([l, rl, rl_copy])) # Save project project_path = os.path.join(temp_dir.path(), 'project.qgs') self.assertTrue(p.write(project_path)) # Re-load the project, checking for the XML properties p.removeAllMapLayers() self.assertTrue(p.read(project_path)) vector = list(p.mapLayersByName('lines'))[0] raster = list(p.mapLayersByName('raster'))[0] raster_copy = list(p.mapLayersByName('raster_copy'))[0] self.assertTrue(vector.originalXmlProperties() != '') self.assertTrue(raster.originalXmlProperties() != '') self.assertTrue(raster_copy.originalXmlProperties() != '') # Test setter raster.setOriginalXmlProperties('pippo') self.assertEqual(raster.originalXmlProperties(), 'pippo') # Now create and invalid project: bad_project_path = os.path.join(temp_dir.path(), 'project_bad.qgs') with open(project_path, 'r') as infile: with open(bad_project_path, 'w+') as outfile: outfile.write(infile.read().replace( './lines.shp', './lines-BAD_SOURCE.shp').replace( 'band1_byte_ct_epsg4326_copy.tif', 'band1_byte_ct_epsg4326_copy-BAD_SOURCE.tif')) # Load the bad project p.removeAllMapLayers() self.assertTrue(p.read(bad_project_path)) # Check layer is invalid vector = list(p.mapLayersByName('lines'))[0] raster = list(p.mapLayersByName('raster'))[0] raster_copy = list(p.mapLayersByName('raster_copy'))[0] self.assertIsNotNone(vector.dataProvider()) self.assertIsNotNone(raster.dataProvider()) self.assertIsNotNone(raster_copy.dataProvider()) self.assertFalse(vector.isValid()) self.assertFalse(raster_copy.isValid()) # Try a getFeatures self.assertEqual([f for f in vector.getFeatures()], []) self.assertTrue(raster.isValid()) self.assertEqual(vector.providerType(), 'ogr') # Save the project bad_project_path2 = os.path.join(temp_dir.path(), 'project_bad2.qgs') p.write(bad_project_path2) # Re-save the project, with fixed paths good_project_path = os.path.join(temp_dir.path(), 'project_good.qgs') with open(bad_project_path2, 'r') as infile: with open(good_project_path, 'w+') as outfile: outfile.write(infile.read().replace( './lines-BAD_SOURCE.shp', './lines.shp').replace( 'band1_byte_ct_epsg4326_copy-BAD_SOURCE.tif', 'band1_byte_ct_epsg4326_copy.tif')) # Load the good project p.removeAllMapLayers() self.assertTrue(p.read(good_project_path)) # Check layer is valid vector = list(p.mapLayersByName('lines'))[0] raster = list(p.mapLayersByName('raster'))[0] raster_copy = list(p.mapLayersByName('raster_copy'))[0] self.assertTrue(vector.isValid()) self.assertTrue(raster.isValid()) self.assertTrue(raster_copy.isValid())
class TestQgsMapLayerAction(unittest.TestCase): def __init__(self, methodName): """Run once on class initialization.""" unittest.TestCase.__init__(self, methodName) self.vector_layer = QgsVectorLayer( "Point?field=fldtxt:string&field=fldint:integer&field=flddate:datetime", "test_layer", "memory") assert self.vector_layer.isValid() self.vector_layer2 = QgsVectorLayer( "Point?field=fldtxt:string&field=fldint:integer&field=flddate:datetime", "test_layer", "memory") assert self.vector_layer2.isValid() raster_path = os.path.join(unitTestDataPath(), 'landsat.tif') self.raster_layer = QgsRasterLayer(raster_path, 'raster') assert self.raster_layer.isValid() def testCanRunUsingLayer(self): """ Test that actions correctly indicate when they can run for a layer """ action_all_layers = QgsMapLayerAction('action1', None) self.assertTrue(action_all_layers.canRunUsingLayer(None)) self.assertTrue(action_all_layers.canRunUsingLayer(self.vector_layer)) self.assertTrue(action_all_layers.canRunUsingLayer(self.raster_layer)) action_vector_layers_only = QgsMapLayerAction('action2', None, QgsMapLayer.VectorLayer) self.assertFalse(action_vector_layers_only.canRunUsingLayer(None)) self.assertTrue( action_vector_layers_only.canRunUsingLayer(self.vector_layer)) self.assertFalse( action_vector_layers_only.canRunUsingLayer(self.raster_layer)) action_raster_layers_only = QgsMapLayerAction('action3', None, QgsMapLayer.RasterLayer) self.assertFalse(action_raster_layers_only.canRunUsingLayer(None)) self.assertFalse( action_raster_layers_only.canRunUsingLayer(self.vector_layer)) self.assertTrue( action_raster_layers_only.canRunUsingLayer(self.raster_layer)) action_specific_layer_only = QgsMapLayerAction('action4', None, self.vector_layer) self.assertFalse(action_specific_layer_only.canRunUsingLayer(None)) self.assertTrue( action_specific_layer_only.canRunUsingLayer(self.vector_layer)) self.assertFalse( action_specific_layer_only.canRunUsingLayer(self.vector_layer2)) self.assertFalse( action_specific_layer_only.canRunUsingLayer(self.raster_layer)) action_specific_raster_layer_only = QgsMapLayerAction( 'action4', None, self.raster_layer) self.assertFalse( action_specific_raster_layer_only.canRunUsingLayer(None)) self.assertFalse( action_specific_raster_layer_only.canRunUsingLayer( self.vector_layer)) self.assertFalse( action_specific_raster_layer_only.canRunUsingLayer( self.vector_layer2)) self.assertTrue( action_specific_raster_layer_only.canRunUsingLayer( self.raster_layer)) action_editable_layer_only = QgsMapLayerAction( 'action1', None, flags=QgsMapLayerAction.EnabledOnlyWhenEditable) self.assertFalse(action_editable_layer_only.canRunUsingLayer(None)) self.assertFalse( action_editable_layer_only.canRunUsingLayer(self.vector_layer)) self.assertFalse( action_editable_layer_only.canRunUsingLayer(self.vector_layer2)) self.assertFalse( action_editable_layer_only.canRunUsingLayer(self.raster_layer)) self.vector_layer.startEditing() self.assertFalse(action_editable_layer_only.canRunUsingLayer(None)) self.assertTrue( action_editable_layer_only.canRunUsingLayer(self.vector_layer)) self.assertFalse( action_editable_layer_only.canRunUsingLayer(self.vector_layer2)) self.assertFalse( action_editable_layer_only.canRunUsingLayer(self.raster_layer)) self.vector_layer.commitChanges() self.assertFalse(action_editable_layer_only.canRunUsingLayer(None)) self.assertFalse( action_editable_layer_only.canRunUsingLayer(self.vector_layer)) self.assertFalse( action_editable_layer_only.canRunUsingLayer(self.vector_layer2)) self.assertFalse( action_editable_layer_only.canRunUsingLayer(self.raster_layer))
class ShakemapConverterDialog(QDialog, FORM_CLASS): """Importer for shakemap grid.xml files.""" def __init__(self, parent=None, iface=None, dock_widget=None): """Constructor for the dialog. Show the grid converter dialog. :param parent: parent - widget to use as parent. :type parent: QWidget :param iface: QGIS QGisAppInterface instance. :type iface: QGisAppInterface :param dock_widget: Dock widget instance. :type dock_widget: Dock """ QDialog.__init__(self, parent) self.parent = parent self.iface = iface self.dock_widget = dock_widget self.setupUi(self) self.setWindowTitle( self.tr('InaSAFE %s Shakemap Converter' % get_version())) self.warning_text = set() self.on_input_path_textChanged() self.on_output_path_textChanged() self.update_warning() self.output_layer = None # Event register # noinspection PyUnresolvedReferences self.use_output_default.toggled.connect(self.get_output_from_input) # noinspection PyUnresolvedReferences self.input_path.textChanged.connect(self.on_input_path_textChanged) # noinspection PyUnresolvedReferences self.output_path.textChanged.connect(self.on_output_path_textChanged) self.load_result.clicked.connect(self.load_result_toggled) # Set up things for context help self.help_button = self.button_box.button(QtGui.QDialogButtonBox.Help) # Allow toggling the help button self.help_button.setCheckable(True) self.help_button.toggled.connect(self.help_toggled) self.main_stacked_widget.setCurrentIndex(1) self.update_warning() # noinspection PyPep8Naming def on_output_path_textChanged(self): """Action when output file name is changed.""" output_path = self.output_path.text() output_not_xml_msg = self.tr('output file is not .tif') if output_path and not output_path.endswith('.tif'): self.warning_text.add(output_not_xml_msg) elif output_path and output_not_xml_msg in self.warning_text: self.warning_text.remove(output_not_xml_msg) self.update_warning() # noinspection PyPep8Naming def on_input_path_textChanged(self): """Action when input file name is changed.""" input_path = self.input_path.text() input_not_grid_msg = self.tr('input file is not .xml') if input_path and not input_path.endswith('.xml'): self.warning_text.add(input_not_grid_msg) elif input_path and input_not_grid_msg in self.warning_text: self.warning_text.remove(input_not_grid_msg) if self.use_output_default.isChecked(): self.get_output_from_input() self.update_warning() def update_warning(self): """Update warning message and enable/disable Ok button.""" if len(self.warning_text) == 0: self.button_box.button(QDialogButtonBox.Ok).setEnabled(True) else: self.button_box.button(QDialogButtonBox.Ok).setEnabled(False) header = html_header() footer = html_footer() string = header heading = m.Heading(self.tr('Shakemap Grid Importer'), **INFO_STYLE) tips = m.BulletedList() message = m.Message() message.add(heading) for warning in self.warning_text: tips.add(warning) message.add(tips) string += message.to_html() string += footer self.info_web_view.setHtml(string) def get_output_from_input(self): """Create default output location based on input location.""" input_path = self.input_path.text() if input_path.endswith('.xml'): output_path = input_path[:-3] + 'tif' elif input_path == '': output_path = '' else: last_dot = input_path.rfind('.') if last_dot == -1: output_path = '' else: output_path = input_path[:last_dot + 1] + 'tif' self.output_path.setText(output_path) def accept(self): """Handler for when OK is clicked.""" input_path = self.input_path.text() input_title = self.line_edit_title.text() input_source = self.line_edit_source.text() output_path = self.output_path.text() if not output_path.endswith('.tif'): # noinspection PyArgumentList,PyCallByClass,PyTypeChecker QMessageBox.warning(self, self.tr('InaSAFE'), (self.tr('Output file name must be tif file'))) if not os.path.exists(input_path): # noinspection PyArgumentList,PyCallByClass,PyTypeChecker QMessageBox.warning(self, self.tr('InaSAFE'), (self.tr('Input file does not exist'))) return if self.nearest_mode.isChecked(): algorithm = 'nearest' else: algorithm = 'invdist' QtGui.qApp.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor)) file_name = convert_mmi_data(input_path, input_title, input_source, output_path, algorithm=algorithm, algorithm_filename_flag=True) # reclassify raster file_info = QFileInfo(file_name) base_name = file_info.baseName() self.output_layer = QgsRasterLayer(file_name, base_name) self.output_layer.keywords = KeywordIO.read_keywords(self.output_layer) self.output_layer.keywords['classification'] = ( earthquake_mmi_scale['key']) keywords = self.output_layer.keywords if self.output_layer.isValid(): self.output_layer = reclassify(self.output_layer, overwrite_input=True) KeywordIO.write_keywords(self.output_layer, keywords) else: LOGGER.debug("Failed to load") QtGui.qApp.restoreOverrideCursor() if self.load_result.isChecked(): # noinspection PyTypeChecker mmi_ramp_roman(self.output_layer) self.output_layer.saveDefaultStyle() if not self.output_layer.isValid(): LOGGER.debug("Failed to load") else: # noinspection PyArgumentList QgsMapLayerRegistry.instance().addMapLayer(self.output_layer) iface.zoomToActiveLayer() if (self.keyword_wizard_checkbox.isChecked() and self.keyword_wizard_checkbox.isEnabled()): self.launch_keyword_wizard() self.done(self.Accepted) @pyqtSignature('') # prevents actions being handled twice def on_open_input_tool_clicked(self): """Autoconnect slot activated when open input tool button is clicked. """ # noinspection PyCallByClass,PyTypeChecker filename = QFileDialog.getOpenFileName( self, self.tr('Input file'), 'grid.xml', self.tr('Raw grid file (*.xml)')) self.input_path.setText(filename) @pyqtSignature('') # prevents actions being handled twice def on_open_output_tool_clicked(self): """Autoconnect slot activated when open output tool button is clicked. """ # noinspection PyCallByClass,PyTypeChecker filename = QFileDialog.getSaveFileName(self, self.tr('Output file'), 'grid.tif', self.tr('Raster file (*.tif)')) self.output_path.setText(filename) def load_result_toggled(self): """Function that perform action when load_result checkbox is clicked. """ self.keyword_wizard_checkbox.setEnabled(self.load_result.isChecked()) @pyqtSlot() @pyqtSignature('bool') # prevents actions being handled twice def help_toggled(self, flag): """Show or hide the help tab in the stacked widget. .. versionadded: 3.2.1 :param flag: Flag indicating whether help should be shown or hidden. :type flag: bool """ if flag: self.help_button.setText(self.tr('Hide Help')) self.show_help() else: self.help_button.setText(self.tr('Show Help')) self.hide_help() def hide_help(self): """Hide the usage info from the user. .. versionadded: 3.2.1 """ self.main_stacked_widget.setCurrentIndex(1) def show_help(self): """Show usage info to the user.""" # Read the header and footer html snippets self.main_stacked_widget.setCurrentIndex(0) header = html_header() footer = html_footer() string = header message = shakemap_converter_help() string += message.to_html() string += footer self.help_web_view.setHtml(string) def launch_keyword_wizard(self): """Launch keyword creation wizard.""" # make sure selected layer is the output layer if self.iface.activeLayer() != self.output_layer: return # launch wizard dialog keyword_wizard = WizardDialog(self.iface.mainWindow(), self.iface, self.dock_widget) keyword_wizard.set_keywords_creation_mode(self.output_layer) keyword_wizard.exec_() # modal
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 testWriteSld(self): """Test SLD generation for the XMLS fields geneerated at RasterLayer level and not to the deeper renderer level.""" myPath = os.path.join(unitTestDataPath(), 'landsat.tif') myFileInfo = QFileInfo(myPath) myBaseName = myFileInfo.baseName() myRasterLayer = QgsRasterLayer(myPath, myBaseName) myMessage = 'Raster not loaded: %s' % myPath assert myRasterLayer.isValid(), myMessage # do generic export with default layer values dom, root, errorMessage = self.layerToSld(myRasterLayer) elements = root.elementsByTagName('sld:LayerFeatureConstraints') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() elements = element.elementsByTagName('sld:FeatureTypeConstraint') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() elements = root.elementsByTagName('sld:UserStyle') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() name = element.firstChildElement('sld:Name') self.assertFalse(name.isNull()) self.assertEqual(name.text(), 'landsat') abstract = element.firstChildElement('sld:Abstract') self.assertTrue(abstract.isNull()) title = element.firstChildElement('sld:Title') self.assertTrue(title.isNull()) featureTypeStyle = element.firstChildElement('sld:FeatureTypeStyle') self.assertFalse(featureTypeStyle.isNull()) rule = featureTypeStyle.firstChildElement('sld:Rule') self.assertFalse(rule.isNull()) temp = rule.firstChildElement('sld:MinScaleDenominator') self.assertTrue(temp.isNull()) temp = rule.firstChildElement('sld:MaxScaleDenominator') self.assertTrue(temp.isNull()) rasterSymbolizer = rule.firstChildElement('sld:RasterSymbolizer') self.assertFalse(rule.isNull()) vendorOptions = rasterSymbolizer.elementsByTagName('sld:VendorOption') self.assertTrue(vendorOptions.size() == 0) # set no default values and check exported sld myRasterLayer.setName('') myRasterLayer.setAbstract('fake') myRasterLayer.setTitle('fake') dom, root, errorMessage = self.layerToSld(myRasterLayer) elements = root.elementsByTagName('sld:LayerFeatureConstraints') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() elements = element.elementsByTagName('sld:FeatureTypeConstraint') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() elements = root.elementsByTagName('sld:UserStyle') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() # no generated if empty name = element.firstChildElement('sld:Name') self.assertTrue(name.isNull()) # generated if not empty abstract = element.firstChildElement('sld:Abstract') self.assertFalse(abstract.isNull()) self.assertEqual(abstract.text(), 'fake') title = element.firstChildElement('sld:Title') self.assertFalse(title.isNull()) self.assertEqual(title.text(), 'fake') # if setScaleBasedVisibility is true print scales myRasterLayer.setScaleBasedVisibility(True) myRasterLayer.setMaximumScale(0.0001) myRasterLayer.setMinimumScale(0.01) dom, root, errorMessage = self.layerToSld(myRasterLayer) elements = dom.elementsByTagName('sld:Rule') self.assertEqual(len(elements), 1) rule = elements.at(0).toElement() self.assertFalse(rule.isNull()) temp = rule.firstChildElement('sld:MinScaleDenominator') self.assertFalse(temp.isNull()) self.assertEqual(temp.text(), '0.0001') temp = rule.firstChildElement('sld:MaxScaleDenominator') self.assertFalse(temp.isNull()) self.assertEqual(temp.text(), '0.01') # check non default hueSaturationFilter values hue = myRasterLayer.hueSaturationFilter() hue.setGrayscaleMode(QgsHueSaturationFilter.GrayscaleLightness) dom, root, errorMessage = self.layerToSld(myRasterLayer) elements = dom.elementsByTagName('sld:RasterSymbolizer') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() self.assertFalse(element.isNull()) self.assertVendorOption(element, 'grayScale', 'lightness') hue = myRasterLayer.hueSaturationFilter() hue.setGrayscaleMode(QgsHueSaturationFilter.GrayscaleLuminosity) dom, root, errorMessage = self.layerToSld(myRasterLayer) elements = dom.elementsByTagName('sld:RasterSymbolizer') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() self.assertFalse(element.isNull()) self.assertVendorOption(element, 'grayScale', 'luminosity') hue = myRasterLayer.hueSaturationFilter() hue.setGrayscaleMode(QgsHueSaturationFilter.GrayscaleAverage) dom, root, errorMessage = self.layerToSld(myRasterLayer) elements = dom.elementsByTagName('sld:RasterSymbolizer') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() self.assertFalse(element.isNull()) self.assertVendorOption(element, 'grayScale', 'average') hue = myRasterLayer.hueSaturationFilter() hue.setGrayscaleMode(QgsHueSaturationFilter.GrayscaleOff) dom, root, errorMessage = self.layerToSld(myRasterLayer) elements = dom.elementsByTagName('sld:RasterSymbolizer') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() self.assertFalse(element.isNull()) self.assertVendorOption(element, 'grayScale', None) # manage colorize vendorOption tags hue = myRasterLayer.hueSaturationFilter() hue.setColorizeOn(True) hue.setColorizeStrength(50) dom, root, errorMessage = self.layerToSld(myRasterLayer) elements = dom.elementsByTagName('sld:RasterSymbolizer') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() self.assertFalse(element.isNull()) self.assertVendorOption(element, 'colorizeOn', '1') self.assertVendorOption(element, 'colorizeRed', '255') self.assertVendorOption(element, 'colorizeGreen', '128') self.assertVendorOption(element, 'colorizeBlue', '128') self.assertVendorOption(element, 'colorizeStrength', '0.5') self.assertVendorOption(element, 'saturation', '0.498039') # other hue non default values, no colorize and saturation = 0 hue = myRasterLayer.hueSaturationFilter() hue.setColorizeOn(False) hue.setSaturation(0) dom, root, errorMessage = self.layerToSld(myRasterLayer) elements = dom.elementsByTagName('sld:RasterSymbolizer') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() self.assertFalse(element.isNull()) self.assertVendorOption(element, 'colorizeOn', None) self.assertVendorOption(element, 'colorizeRed', None) self.assertVendorOption(element, 'colorizeGreen', None) self.assertVendorOption(element, 'colorizeBlue', None) self.assertVendorOption(element, 'colorizeStrength', None) self.assertVendorOption(element, 'saturation', None) self.assertVendorOption(element, 'brightness', None) self.assertVendorOption(element, 'contrast', None) # other hue non default values, no colorize and saturation = 100 hue = myRasterLayer.hueSaturationFilter() hue.setColorizeOn(False) hue.setSaturation(100) dom, root, errorMessage = self.layerToSld(myRasterLayer) elements = dom.elementsByTagName('sld:RasterSymbolizer') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() self.assertFalse(element.isNull()) self.assertVendorOption(element, 'colorizeOn', None) self.assertVendorOption(element, 'colorizeRed', None) self.assertVendorOption(element, 'colorizeGreen', None) self.assertVendorOption(element, 'colorizeBlue', None) self.assertVendorOption(element, 'colorizeStrength', None) self.assertVendorOption(element, 'saturation', '1') hue.setSaturation(-100) dom, root, errorMessage = self.layerToSld(myRasterLayer) self.assertVendorOption(root, 'saturation', '0') # brightness filter default values dom, root, errorMessage = self.layerToSld(myRasterLayer) elements = dom.elementsByTagName('sld:RasterSymbolizer') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() self.assertFalse(element.isNull()) self.assertTrue(myRasterLayer.brightnessFilter().brightness() == 0) self.assertTrue(myRasterLayer.brightnessFilter().contrast() == 0) self.assertVendorOption(element, 'brightness', None) self.assertVendorOption(element, 'contrast', None) # brightness filter no default values bf = myRasterLayer.brightnessFilter() bf.setBrightness(-255) bf.setContrast(-100) dom, root, errorMessage = self.layerToSld(myRasterLayer) elements = dom.elementsByTagName('sld:RasterSymbolizer') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() self.assertFalse(element.isNull()) self.assertVendorOption(element, 'brightness', '0') self.assertVendorOption(element, 'contrast', '0') bf.setBrightness(255) bf.setContrast(100) dom, root, errorMessage = self.layerToSld(myRasterLayer) elements = dom.elementsByTagName('sld:RasterSymbolizer') self.assertEqual(len(elements), 1) element = elements.at(0).toElement() self.assertFalse(element.isNull()) self.assertVendorOption(element, 'brightness', '1') self.assertVendorOption(element, 'contrast', '1')
def addWms(self, wms_name, url, layers, mime_type, epsg_code, protocol): """ # Slot for exposing the same-name function to Javascript. # Adding the WMS to the QGis TOC. :param wms_name: The WMS name to add in TOC as group :type wms_name: str :param url: The WMS URL :type url: str :param layers: The list of the WMS layers to add :type layers: list of str :param mime_type: The image MIME TYPE (e.g. image/png) :type mime_type: str :param epsg_code: The EPSG code (e.g. the number 32632) :type epsg_code: int :param protocol: The protocol (i.e. should be 'ba' for applying basic authentication). Not yet managed. :type protocol: str """ qgs_logger = QgsApplication.messageLog() qgs_logger.logMessage('addWms: wms_name = {}'.format(wms_name), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: url = {}'.format(url), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: layers = {}'.format(layers), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: mime_type = {}'.format(mime_type), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: epsg_code = {}'.format(epsg_code), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: protocol = {}'.format(protocol), tag=configuration.LOGGER_TAG, level=Qgis.Info) # For storing the URI data uri = QgsDataSourceUri() # Split the host with the request data pieces = url.split("?") if len(pieces) == 1: qgs_logger.logMessage('len(pieces) == 1', tag=configuration.LOGGER_TAG, level=Qgis.Info) elif len(pieces) == 2: qgs_logger.logMessage('len(pieces) == 2', tag=configuration.LOGGER_TAG, level=Qgis.Info) # Overriding the URL url = "{}{}".format(pieces[0], "?") parameters_values = pieces[1].split("=") if len(parameters_values) == 2: qgs_logger.logMessage('len(parameters) == 2', tag=configuration.LOGGER_TAG, level=Qgis.Info) uri.setParam(parameters_values[0], parameters_values[1]) qgs_logger.logMessage('uri.param({}): {}'.format( parameters_values[0], uri.param(parameters_values[0])), tag=configuration.LOGGER_TAG, level=Qgis.Info) else: qgs_logger.logMessage('len(p) != 2', tag=configuration.LOGGER_TAG, level=Qgis.Info) else: qgs_logger.logMessage('len(pieces) > 2 Not yet managed!', tag=configuration.LOGGER_TAG, level=Qgis.Warning) # Setting the URL to the URI uri.setParam("url", url) # Process the layers accordingly if just an element or a list of elements layers_list = [] if "," in layers: layers_list = layers.split(",") else: layers_list.append(layers) # Setting the parameter 'layers' in the URI for val in layers_list: uri.setParam("layers", val) # Setting the other parameters # Styles seems required: https://gis.stackexchange.com/questions/183485/load-wms-with-pyqgis uri.setParam("styles", "") uri.setParam("format", mime_type) uri.setParam("crs", "EPSG:{}".format(epsg_code)) # https://docs.qgis.org/3.4/en/docs/pyqgis_developer_cookbook/loadlayer.html#raster-layers # Ignore GetCoverage URL advertised by GetCapabilities. May be necessary if a server is not configured properly. uri.setParam("IgnoreGetMapUrl", "1") # Adding the parameters for the basic authentication qgs_logger.logMessage('Applying Basic-Authentication', tag=configuration.LOGGER_TAG, level=Qgis.Info) uri.setParam("username", self.session_user) uri.setParam("password", self.session_password) # Logging the parameters for debugging qgs_logger.logMessage('uri.param(url): {}'.format(uri.param("url")), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('uri.param(layers): {}'.format( uri.param("layers")), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('uri.param(format): {}'.format( uri.param("format")), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('uri.param(crs): {}'.format(uri.param("crs")), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('uri.service(): {}'.format(uri.service()), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('encodedUri: {}'.format(str(uri.encodedUri())), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('uri.uri(): {}'.format(uri.uri()), tag=configuration.LOGGER_TAG, level=Qgis.Info) # Generating the WMS layer wms_layer = QgsRasterLayer(str(uri.encodedUri()), wms_name, 'wms') # If the WMS is correctly generated, add to the QGis TOC if wms_layer.isValid(): QgsProject.instance().addMapLayer(wms_layer) else: qgs_logger.logMessage( 'Impossibile aggiungere il WMS: {}'.format(wms_name), tag=configuration.LOGGER_TAG, level=Qgis.Warning) self.show_message( "Attenzione!", "Impossibile aggiungere il WMS " + wms_name + " al progetto")
def testRelativePaths(self): """ Test whether paths to layer sources are stored as relative to the project path """ tmpDir = QTemporaryDir() tmpFile = "{}/project.qgs".format(tmpDir.path()) copyfile(os.path.join(TEST_DATA_DIR, "points.shp"), os.path.join(tmpDir.path(), "points.shp")) copyfile(os.path.join(TEST_DATA_DIR, "points.dbf"), os.path.join(tmpDir.path(), "points.dbf")) copyfile(os.path.join(TEST_DATA_DIR, "points.shx"), os.path.join(tmpDir.path(), "points.shx")) copyfile(os.path.join(TEST_DATA_DIR, "lines.shp"), os.path.join(tmpDir.path(), "lines.shp")) copyfile(os.path.join(TEST_DATA_DIR, "lines.dbf"), os.path.join(tmpDir.path(), "lines.dbf")) copyfile(os.path.join(TEST_DATA_DIR, "lines.shx"), os.path.join(tmpDir.path(), "lines.shx")) copyfile(os.path.join(TEST_DATA_DIR, "landsat_4326.tif"), os.path.join(tmpDir.path(), "landsat_4326.tif")) project = QgsProject() l0 = QgsVectorLayer(os.path.join(tmpDir.path(), "points.shp"), "points", "ogr") l1 = QgsVectorLayer(os.path.join(tmpDir.path(), "lines.shp"), "lines", "ogr") l2 = QgsRasterLayer(os.path.join(tmpDir.path(), "landsat_4326.tif"), "landsat", "gdal") self.assertTrue(l0.isValid()) self.assertTrue(l1.isValid()) self.assertTrue(l2.isValid()) self.assertTrue(project.addMapLayers([l0, l1, l2])) self.assertTrue(project.write(tmpFile)) del project with open(tmpFile, 'r') as f: content = ''.join(f.readlines()) self.assertTrue('source="./lines.shp"' in content) self.assertTrue('source="./points.shp"' in content) self.assertTrue('source="./landsat_4326.tif"' in content) # Re-read the project and store absolute project = QgsProject() self.assertTrue(project.read(tmpFile)) store = project.layerStore() self.assertEquals(set([l.name() for l in store.mapLayers().values()]), set(['lines', 'landsat', 'points'])) project.writeEntryBool('Paths', '/Absolute', True) tmpFile2 = "{}/project2.qgs".format(tmpDir.path()) self.assertTrue(project.write(tmpFile2)) with open(tmpFile2, 'r') as f: content = ''.join(f.readlines()) self.assertTrue( 'source="{}/lines.shp"'.format(tmpDir.path()) in content) self.assertTrue( 'source="{}/points.shp"'.format(tmpDir.path()) in content) self.assertTrue('source="{}/landsat_4326.tif"'.format( tmpDir.path()) in content) del project
def plugin_code_by_anshul_iitb(trip_number): trip_number = trip_number.upper() import pandas import psycopg2 import pandas.io.sql as psql QgsMessageLog.logMessage(trip_number) try: conn = psycopg2.connect( "dbname='MTP_transportation' user='******' host='localhost' password='******'" ) print "DB connected" except Exception as e: QMessageBox.information(None, "Error", "Database not connected") return print(e) try: cur = conn.cursor() sql = 'DROP TABLE IF EXISTS output;' cur.execute(sql) sql = """ CREATE TABLE output AS ( SELECT * FROM public.abc_july_final where trip_numbe = '""" + trip_number + "')" cur.execute(sql) conn.commit() cur.close() except Exception as e: print(e) #Removing all layer if any present QgsMapLayerRegistry.instance().removeAllMapLayers() #loading BaseLayer as OSM uri = "url=http://a.tile.openstreetmap.org/{z}/{x}/{y}.png&zmax=19&zmin=0&type=xyz" osm_layer = QgsRasterLayer(uri, 'OSM', 'wms') if not osm_layer.isValid(): print("Layer failed to load!") QgsMapLayerRegistry.instance().addMapLayer(osm_layer) print 'Finished' uri = QgsDataSourceURI() uri.setConnection("localhost", "5432", "MTP_transportation", "postgres", "anshuL@iitb") uri.setDataSource("public", "output", "geom") vlayer = QgsVectorLayer(uri.uri(False), 'output', "postgres") QgsMapLayerRegistry.instance().addMapLayer(vlayer) #setting the color of output layer named 'vlayer' vlayer.selectAll() iface.mapCanvas().setSelectionColor(QColor("blue")) iface.mapCanvas().zoomToSelected() print 'color changed' #setting line width of output layer named 'vlayer' symbols = vlayer.rendererV2().symbols() for symbol in symbols: symbol.setWidth(1) print 'Linewidth changed' # Refresh in order the see the changes iface.mapCanvas().refreshAllLayers() print 'Linewidth and color changed' # iface.zoomToActiveLayer() canvas = iface.mapCanvas() extent = vlayer.extent() canvas.setExtent(extent)
#Permet la suppression des doublons Lt = list(set(tab)) Lt.sort() for c_insee, n_couche in Lt: #AMORCES_CAD,LIEUDIT,CP.CadastralParcel,SUBFISCAL,CLOTURE,DETAIL_TOPO,HYDRO,VOIE_COMMUNICATION,BU.Building,BORNE_REPERE urlWithParams = "url=http://inspire.cadastre.gouv.fr/scpc/" + c_insee + ".wms?contextualWMSLegend=0&crs=EPSG:" + Code_EPSG + "&dpiMode=7&featureCount=10&format=image/png&layers=AMORCES_CAD&styles=&maxHeight=1024&maxWidth=1280" rlayer = QgsRasterLayer( urlWithParams, 'Amorces_cadastrales_' + n_couche + '_' + c_insee, 'wms') progress.setText(u'Nom de la commune : ' + n_couche + ' - ' + c_insee) progress.setText(u'Validite du flux : %s' % rlayer.isValid()) QgsMapLayerRegistry.instance().addMapLayer(rlayer) if rlayer.isValid() == True: iface.messageBar().pushMessage( "Information :", "Ajout du flux WMS pour la commune : " + n_couche, QgsMessageBar.INFO, duration=5) iface.mapCanvas().refresh() else: iface.messageBar().pushMessage("Warning :", "WMS invalide pour la commune : " + n_couche,
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
def plugin_code_by_anshul_iitb(BusStopFrom, BusStopTo, TimeFrom, TimeTo, Day): #QMessageBox.information(None,"Plugin function by Anshul the great","\nSource: "+ BusStopFrom+"\nDestination: "+ BusStopTo+ "\nTime: " +TimeFrom+" to "+ TimeTo+"\nDay"+ Day) import pandas import psycopg2 import pandas.io.sql as psql QgsMessageLog.logMessage( "\nUser_Input_Source-"+ BusStopFrom+\ "\nUser_Input_Destination-"+ BusStopTo+\ "\nUser_Input_From-"+ TimeFrom+\ "\nUser_Input_To-"+ TimeTo +\ "\nUser_Input_Day-"+ Day ) try: conn = psycopg2.connect( "dbname='MTP_transportation' user='******' host='localhost' password='******'" ) #QMessageBox.information(None,"Plugin stage process","DB connected") print "DB connected" except Exception as e: QMessageBox.information(None, "Error", "Database not connected") return print(e) #The mentioned below file contained the Nashik Bus stop Route Sequence with respective Route no.. This file has been derieved from Nashik All route Master file recieved RouteSequenceFile = psql.read_sql("SELECT * FROM route_seq", conn) #The mentioned below file contains Route no. to Trip No. Mapping. This file has been derieved by Sinnar August 2019 ETIM data with Following query "Select distinct Trip_no, Route_no from ETIM_File" RouteNoToTripNoFile = psql.read_sql('SELECT * FROM route_to_trip', conn) #ABC data of Sinner recieved of July month # ABCSinnarJul19File=pandas.read_csv('/home/anshulgoel031gmailcom/Desktop/MTP2/MTP/ABCJuly19_filtered.csv') ABCSinnarJul19File = psql.read_sql('SELECT * FROM ABCJuly19_filtered', conn) #This mentioned below file contains the Nashik Bus stop Route sequences Master file as recieved by Nashik depot # RouteSequenceMasterFile= pandas.read_csv('/home/anshulgoel031gmailcom/Desktop/MTP2/MTP/All_Routes_Stops_Master_of_Nashik_Division.csv') RouteSequenceMasterFile = psql.read_sql( 'SELECT * FROM All_Routes_Stops_Master_of_Nashik_Division', conn) #Closing the databse conn.close() #Converting Bus Stop code to upper case so that we can comapre with database values with considering case sensitivity BusStopFrom = BusStopFrom.upper() BusStopTo = BusStopTo.upper() #Assuming bus speed to be 30km/hour, We dont have Bus arrrival time and departure time on a particular bus stop, so based on route length and average speed expected time has been calculated Bus_speed = 30 def abc(BusStopFrom, BusStopTo, TimeFrom, TimeTo): #print (BusStopFrom) #print (BusStopTo) Required_Route_Sequence = [] Required_From_KM = [] for i in range(0, len(RouteSequenceFile)): if (RouteSequenceFile['Route_seq'][i].find(BusStopFrom) > -1 and RouteSequenceFile['Route_seq'][i].find(BusStopTo) > -1 and RouteSequenceFile['Route_seq'][i].find(BusStopFrom) < RouteSequenceFile['Route_seq'][i].find(BusStopTo)): Required_Route_Sequence.append( RouteSequenceFile['Route_no'][i]) # Required_From_KM.append(RouteSequenceFile['KM'][i]) print len(Required_Route_Sequence) print Required_Route_Sequence QMessageBox.information( None, "All Possible Routes", "Total No.of all possible routes are " + str(len(Required_Route_Sequence)) + '\n\n Routes are ' + str(Required_Route_Sequence)) return Required_Route_Sequence # In[4]: Required_Route_Sequence = abc(BusStopFrom, BusStopTo, TimeFrom, TimeTo) # In[5]: # This functions return a DataFrame which contains Trip Numbers and Respective Route Numbers which have routes NSKCBS to SNNR without considering time # This Functions required inputs a 'list' which contains all route no. having routes from NSKCBS to SNNR irrespective of time def Route_to_trip(Required_Route_Sequence): Required_Trips = [] Required_Routes = [] for i in range(0, len(Required_Route_Sequence)): for j in range(0, len(RouteNoToTripNoFile)): if (Required_Route_Sequence[i] == RouteNoToTripNoFile['Route_no'][j]): Required_Trips.append(RouteNoToTripNoFile['trip_no'][j]) Required_Routes.append(RouteNoToTripNoFile['Route_no'][j]) # This 'dict' variable contains Trip Numbers and Respective Route Numbers which have routes NSKCBS to SNNR dict = {'Trips': Required_Trips, 'Routes': Required_Routes} # print(len(Required_Trip_Sequence)) # Converting this Dict into DataFrame and returning via function df = pandas.DataFrame(dict) print(len(df)) print(df) QMessageBox.information( None, "All possible Trips", "Total number of all possible Trips are " + str(len(df['Trips'].tolist())) + "\n\nTrips are " + str([str(i) for i in df['Trips'].tolist()])) return df # return Required_Trip_Sequence # In[6]: # This Required_Trip_Route is the 'Dataframe' which contain Trip_no and Route_no having Bus Stops from NSKCBS to SNNR Required_Trip_Route = Route_to_trip(Required_Route_Sequence) # In[7]: # This function return the list containinf "trip no." under Sinnar jurisdiction in month Oct 19 which provide NSKCBS to SNNR irrespective of time #Input of the function are two Dataframe one contians ABC Analysis of Sinnar Taluka For month Oct 2019 #Second Dataframe contains all the (Trips, Route No.) pair under Nashik Jurisdiction which provide NSKCBS TO SNNR Service def ReturnABCTripsIrrespectiveTime(Required_Trip_Route, ABCSinnarJul19File): Trips = [] Routes = [] Trip_start_time = [] for i in Required_Trip_Route.index: for j in ABCSinnarJul19File.index: if (Required_Trip_Route['Trips'][i] == ABCSinnarJul19File['Trip'][j]): Trips.append(Required_Trip_Route['Trips'][i]) Routes.append(Required_Trip_Route['Routes'][i]) Trip_start_time.append(ABCSinnarJul19File['Dept Time'][j]) dict = { 'Trips': Trips, 'Routes': Routes, 'Trip Start Time': Trip_start_time } # for i in Trips: # for j in ABCSinnarJul19File.index: df = pandas.DataFrame(dict) # print len(df) # print df return df # In[8]: ABCTripsIrrespectiveTime = ReturnABCTripsIrrespectiveTime( Required_Trip_Route, ABCSinnarJul19File) print ABCTripsIrrespectiveTime # In[9]: list_Route_no = list( dict.fromkeys(ABCTripsIrrespectiveTime['Routes'].tolist())) print list_Route_no list_Route_KM = [] # for i in ABCTripsIrrespectiveTime.index: # for j in ABCSinnarJul19File.index: # if ABCTripsIrrespectiveTime['Trips'][i].upper()==ABCSinnarJul19File['Trip'][j].upper(): # for k in RouteSequenceMasterFile.index: # if ABCTripsIrrespectiveTime['Routes'][i]==RouteSequenceMasterFile['ROUTE_NO'][k] and RouteSequenceMasterFile['BUS_STOP_CD'][k]==BusStopFrom: # print RouteSequenceMasterFile['KM'][k] # break list_Route_KM2 = [] for i in list_Route_no: for j in RouteSequenceMasterFile.index: if i == RouteSequenceMasterFile['ROUTE_NO'][ j] and RouteSequenceMasterFile['BUS_STOP_CD'][ j] == BusStopFrom: print i, RouteSequenceMasterFile['KM'][j] list_Route_KM.append(RouteSequenceMasterFile['KM'][j]) # break if i == RouteSequenceMasterFile['ROUTE_NO'][ j] and RouteSequenceMasterFile['BUS_STOP_CD'][ j] == BusStopTo: print i, RouteSequenceMasterFile['KM'][j] list_Route_KM2.append(RouteSequenceMasterFile['KM'][j]) break # df_Final=pandas.DataFrame() print list_Route_KM list_km = [] list_km2 = [] for i in ABCTripsIrrespectiveTime['Routes'].tolist(): for j in list_Route_no: if i == j: # df_final=df_final.append({'Route no.':ABCTripsIrrespectiveTime['Routes'][i],'Trip Start time':ABCTripsIrrespectiveTime['Trip Start time '][i],'Trips':ABCTripsIrrespectiveTime['Trips'][i] }) list_km.append(list_Route_KM[list_Route_no.index(j)]) list_km2.append(list_Route_KM2[list_Route_no.index(j)]) print list_km ABCTripsIrrespectiveTime['Start KM'] = list_km ABCTripsIrrespectiveTime['End KM'] = list_km2 ABCTripsIrrespectiveTime['Expected Time in hour'] = ( ABCTripsIrrespectiveTime['End KM'] - ABCTripsIrrespectiveTime['Start KM']) / Bus_speed ABCTripsIrrespectiveTime.sort_values(by='Trip Start Time', ascending=True, inplace=True) ABCTripsIrrespectiveTime.reset_index(drop=True, inplace=True) print ABCTripsIrrespectiveTime # In[10]: #this function has been used to compare time def time_in_hour(t): return float(t.split(':')[0]) + float(t.split(':')[1]) / 60 list_Final_output_index = [] for i in ABCTripsIrrespectiveTime.index: # print i #converting time into hours and then comparing if time_in_hour(ABCTripsIrrespectiveTime['Trip Start Time'] [i]) >= time_in_hour(TimeFrom) and time_in_hour( ABCTripsIrrespectiveTime['Trip Start Time'] [i]) <= time_in_hour(TimeTo): list_Final_output_index.append(i) # In[11]: ABCTripsIrrespectiveTime.iloc[list_Final_output_index] # In[12]: l = ABCTripsIrrespectiveTime['Trips'][list_Final_output_index].tolist() l = str([str(r) for r in l]) l = '(' + l[1:len(l) - 1] + ')' print l ABCTripsIrrespectiveTime['Trips'][list_Final_output_index].tolist() # QMessageBox.information(None,"Final output","No. of Bus Trips are "+str(len(ABCTripsIrrespectiveTime['Trips'][list_Final_output_index].tolist()))+"\n Final Trips betweeen provided bus stops and Time are :"+ l[1:len(l)-1]) try: conn = psycopg2.connect( "dbname='MTP_transportation' user='******' host='localhost' password='******'" ) #QMessageBox.information(None,"Final output","DB connected") print "DB connected" except: QMessageBox.information(None, "Error", "Database not connected") print 'DB Not connected' str1 = '' for i in ABCTripsIrrespectiveTime['Trips'][list_Final_output_index].tolist( ): cur = conn.cursor() sql = "select distinct abc_status from abc_july_final where trip_numbe='" + i + "'" cur.execute(sql) temp = str(cur.fetchone()) str1 = str1 + i + ' , ' + temp[2:len(temp) - 1] + '\n' msg = QMessageBox() msg.setText("Final Number of Bus Trips are " + str( len(ABCTripsIrrespectiveTime['Trips'] [list_Final_output_index].tolist())) + "\n Final Trips betweeen provided bus stops and Time are :" + l[1:len(l) - 1]) msg.setInformativeText("ABC Details of trips") msg.setWindowTitle("Final Output") msg.setDetailedText("ABC details:\n" + str1) retval = msg.exec_() # In[13]: try: conn = psycopg2.connect( "dbname='MTP_transportation' user='******' host='localhost' password='******'" ) #QMessageBox.information(None,"Final output","DB connected") print "DB connected" except: QMessageBox.information(None, "Error", "Database not connected") print 'DB Not connected' try: cur = conn.cursor() sql = 'DROP TABLE IF EXISTS output;' cur.execute(sql) sql = """ CREATE TABLE output AS ( SELECT * FROM public.abc_july_final where trip_numbe in """ + l + ')' # Here variable 'l' above in the above SQL query is the list containing all the required bus trips to be displayed if len(ABCTripsIrrespectiveTime['Trips'] [list_Final_output_index].tolist()) != 0: cur.execute(sql) conn.commit() cur.close() except Exception as e: print(e) #Removing all layer if any present QgsMapLayerRegistry.instance().removeAllMapLayers() #loading BaseLayer as OSM uri = "url=http://a.tile.openstreetmap.org/{z}/{x}/{y}.png&zmax=19&zmin=0&type=xyz" osm_layer = QgsRasterLayer(uri, 'OSM', 'wms') if not osm_layer.isValid(): print("Layer failed to load!") QgsMapLayerRegistry.instance().addMapLayer(osm_layer) print 'Finished' #if len(ABCTripsIrrespectiveTime['Trips'][list_Final_output_index].tolist())!=0: uri = QgsDataSourceURI() uri.setConnection("localhost", "5432", "MTP_transportation", "postgres", "anshuL@iitb") uri.setDataSource("public", "output", "geom") vlayer = QgsVectorLayer(uri.uri(False), 'output', "postgres") QgsMapLayerRegistry.instance().addMapLayer(vlayer) #zooming to the output layer vlayer.selectAll() mCanvas = iface.mapCanvas() mCanvas.zoomToSelected() vlayer.removeSelection() iface.mapCanvas().refreshAllLayers() print 'Linewidth and color changed' #setting the color of output layer named 'vlayer' vlayer.selectAll() iface.mapCanvas().setSelectionColor(QColor("blue")) print 'color changed' #setting line width of output layer named 'vlayer' symbols = vlayer.rendererV2().symbols() for symbol in symbols: symbol.setWidth(1) print 'Linewidth changed' # Refresh in order the see the changes iface.mapCanvas().refreshAllLayers() print 'Linewidth and color changed'
def testNoPk(self): """Read raster with no PK""" rl = QgsRasterLayer(self.dbconn + ' sslmode=disable srid=3035 table="public"."raster_3035_tiled_no_pk"' + 'sql=', 'test', 'postgresraster') self.assertTrue(rl.isValid())
def toMapLayer(self): from qgis.core import QgsRasterLayer, QgsContrastEnhancement rl = QgsRasterLayer(self.gdalUri(), self.name) if rl.isValid(): rl.setContrastEnhancement(QgsContrastEnhancement.StretchToMinimumMaximum) return rl
def testPkGuessing(self): """Read raster layer with no pkey in uri""" rl = QgsRasterLayer(self.dbconn + ' sslmode=disable srid=3035 table="public"."raster_tiled_3035" sql=', 'test', 'postgresraster') self.assertTrue(rl.isValid())
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!"
def create_keyword_file(self, algorithm): """Create keyword file for the raster file created. Basically copy a template from keyword file in converter data and add extra keyword (usually a title) :param algorithm: Which re-sampling algorithm to use. valid options are 'nearest' (for nearest neighbour), 'invdist' (for inverse distance), 'average' (for moving average). Defaults to 'nearest' if not specified. Note that passing re-sampling alg parameters is currently not supported. If None is passed it will be replaced with 'nearest'. :type algorithm: str """ keyword_io = KeywordIO() # Set thresholds for each exposure mmi_default_classes = default_classification_thresholds( earthquake_mmi_scale) mmi_default_threshold = { earthquake_mmi_scale['key']: { 'active': True, 'classes': mmi_default_classes } } generic_default_classes = default_classification_thresholds( generic_hazard_classes) generic_default_threshold = { generic_hazard_classes['key']: { 'active': True, 'classes': generic_default_classes } } threshold_keyword = {} for exposure in exposure_all: # Not all exposure is supported by earthquake_mmi_scale if exposure in earthquake_mmi_scale['exposures']: threshold_keyword[exposure['key']] = mmi_default_threshold else: threshold_keyword[exposure['key']] = generic_default_threshold extra_keywords = { extra_keyword_earthquake_latitude['key']: self.latitude, extra_keyword_earthquake_longitude['key']: self.longitude, extra_keyword_earthquake_magnitude['key']: self.magnitude, extra_keyword_earthquake_depth['key']: self.depth, extra_keyword_earthquake_description['key']: self.description, extra_keyword_earthquake_location['key']: self.location, extra_keyword_earthquake_event_time['key']: self.time.strftime('%Y-%m-%dT%H:%M:%S'), extra_keyword_time_zone['key']: self.time_zone, extra_keyword_earthquake_x_minimum['key']: self.x_minimum, extra_keyword_earthquake_x_maximum['key']: self.x_maximum, extra_keyword_earthquake_y_minimum['key']: self.y_minimum, extra_keyword_earthquake_y_maximum['key']: self.y_maximum, extra_keyword_earthquake_event_id['key']: self.event_id } for key, value in list(self.extra_keywords.items()): extra_keywords[key] = value # Delete empty element. empty_keys = [] for key, value in list(extra_keywords.items()): if value is None: empty_keys.append(key) for empty_key in empty_keys: extra_keywords.pop(empty_key) keywords = { 'hazard': hazard_earthquake['key'], 'hazard_category': hazard_category_single_event['key'], 'keyword_version': inasafe_keyword_version, 'layer_geometry': layer_geometry_raster['key'], 'layer_mode': layer_mode_continuous['key'], 'layer_purpose': layer_purpose_hazard['key'], 'continuous_hazard_unit': unit_mmi['key'], 'classification': earthquake_mmi_scale['key'], 'thresholds': threshold_keyword, 'extra_keywords': extra_keywords, 'active_band': 1 } if self.algorithm_name: layer_path = os.path.join( self.output_dir, '%s-%s.tif' % (self.output_basename, algorithm)) else: layer_path = os.path.join(self.output_dir, '%s.tif' % self.output_basename) # append title and source to the keywords file if len(self.title.strip()) == 0: keyword_title = self.output_basename else: keyword_title = self.title keywords['title'] = keyword_title hazard_layer = QgsRasterLayer(layer_path, keyword_title) if not hazard_layer.isValid(): raise InvalidLayerError() keyword_io.write_keywords(hazard_layer, keywords)
def testNoConstraintRaster(self): """Read unconstrained raster layer""" rl = QgsRasterLayer(self.dbconn + ' sslmode=disable key=\'pk\' srid=3035 table="public"."raster_3035_no_constraints" sql=', 'test', 'postgresraster') self.assertTrue(rl.isValid())
def createMapLayer(self, mapLayerName, layerStyleName, boundingBox, layerTime="", minMaxRange=None): """Will create a QGIS valid raster layer for the parsed map, using the passed parameters to get the layer we need, with the requested style, and optionally a time dimension. The possibility of using WMS-T (Time) is provided by a 'hack' (QGIS does not allow it through its WMS provider API), taken from Anita Graser's Time Manager (GPL2). :param mapLayerName: The name identifier of the coverage we want to retrieve.. :type mapLayerName: str :param layerStyleName: The name identifier of the layer style we want used to paint our layer. :type layerStyleName: str :param layerTime: The time dimension we want (optional). :type layerTime: str :param minMaxRange: A tuple or list containing the min and max values to be used in the request of this map. Used for rendering the proper colors. If none or not provided, it will ask the server for the max-min values of this time-defined map and use them instead. :type minMaxRange: list or tuple with floats (min, max) :returns: A QGIS-compatible raster layer object with the given parameters. :rtype: QgsRasterLayer """ if self.mapInfo is None: self.getMapInfoFromCapabilities() if minMaxRange == None: minMaxRange = self.getMinMaxRasterValuesFromTimeRange( mapLayerName, layerStyleName, [layerTime], boundingBox) rasterMinMaxValues = str(minMaxRange[0]) + "," + str(minMaxRange[1]) print("Raster range for " + mapLayerName + "_" + layerStyleName + ": " + rasterMinMaxValues) finalUrl = self.baseWMSUrl.format(layer=mapLayerName, style=layerStyleName, url=self.mapInfo.getURL()) print("FinalUrl : " + finalUrl) #We add an UUID to guarantee uniqueness in the layer name and id layerName = self.mapInfo.getName() + "-" + str(uuid.uuid4()) print("LayerName :" + layerName) resultLayer = QgsRasterLayer(finalUrl, layerName, 'wms') if resultLayer.isValid(): print "Layer is valid" print resultLayer else: print "Layer is not valid" print("Wms uri : " + resultLayer.dataProvider().dataSourceUri()) ##print (self.qgisWMSThack+resultLayer.dataProvider().dataSourceUri() ## + "?TIME={time}%26COLORSCALERANGE={scale}%26BBOX={bbox}" ## .format(time = layerTime, ## scale=rasterMinMaxValues, ## bbox=str(boundingBox)) ) #HACK taken from Anita Graser's Time Manager: #https://github.com/anitagraser/TimeManager/blob/master/raster/wmstlayer.py #(Under GPL2 license) with an extra added for COLORSCALERANGE ncWMS attribute #and BOUNDINGBOX information (which is removed when constructing layers by qgis #it seems?) #TODO: Bounding box information is not processed by QGIS. QGIS C++ WMS provider #apparently re-creates the request with a previously read bounding box information #from the capabilities.xml file. This needs a workaround, or reature request to QGIS. resultLayer.dataProvider().setDataSourceUri( self.qgisWMSThack + resultLayer.dataProvider().dataSourceUri() + "?TIME={time}%26COLORSCALERANGE={scale}%26BBOX={bbox}".format( time=layerTime, scale=rasterMinMaxValues, bbox=str(boundingBox))) if resultLayer.isValid(): self.mapLayer = resultLayer else: raise StandardError('No se pudo crear una capa vĂ¡lida.')
def load_raster(self, path, name): layer = QgsRasterLayer(path, name) if not layer.isValid(): self.log_message(f"Failed to load raster: {path}") return None return layer