def layers_create(self, missing=None): """Utworzenie warstw w projekcie. Podanie atrybutu 'missing' spowoduje, że tylko wybrane warstwy będą dodane.""" # Ustalenie ilości dodawanych warstw: i_max = len(missing) if missing else self.lyr_cnt # Utworzenie listy ze słownikami warstw do dodania: lyrs = [] if missing: for l_dict in self.lyrs: if l_dict["name"] in missing: lyrs.append(l_dict) else: lyrs = self.lyrs i = 0 # Dodanie warstw: for l_dict in lyrs: i += 1 raw_uri = l_dict["uri"] uri = eval("f'{}'".format(raw_uri)) if l_dict["source"] == "wms" or l_dict["source"] == "gdal": lyr = QgsRasterLayer(uri, l_dict["name"], l_dict["source"]) lyr_required = False else: lyr = QgsVectorLayer(uri, l_dict["name"], l_dict["source"]) lyr_required = True if not lyr.isValid() and not lyr_required: m_text = f'Nie udało się poprawnie wczytać podkładu mapowego: {l_dict["name"]}. Naciśnięcie Tak spowoduje kontynuowanie uruchamiania wtyczki (podkład mapowy nie będzie wyświetlany), naciśnięcie Nie przerwie proces uruchamiania wtyczki. Jeśli problem będzie się powtarzał, zaleca się powiadomienie administratora systemu.' reply = QMessageBox.question(dlg.app, "WellMatch", m_text, QMessageBox.Yes, QMessageBox.No) if reply == QMessageBox.No: return False elif not lyr.isValid() and lyr_required: m_text = f'Nie udało się poprawnie wczytać warstwy: {l_dict["name"]}. Jeśli problem będzie się powtarzał, proszę o powiadomienie administratora systemu ([email protected]).' QMessageBox.critical(dlg.app, "WellMatch", m_text) return False if l_dict["source"] == "memory": lyr.setCustomProperty("skipMemoryLayersCheck", 1) pr = lyr.dataProvider() pr.addAttributes(l_dict["attrib"]) lyr.updateFields() if "crs" in l_dict: lyr.setCrs(CRS_1992) dlg.proj.addMapLayer(lyr, False) if l_dict["root"]: parent_grp = self.root parent_grp.insertChildNode(l_dict["pos"], QgsLayerTreeLayer(lyr)) parent_grp.findLayer(lyr).setItemVisibilityChecked( l_dict["visible"]) else: if "pos" in l_dict: parent_grp = self.root.findGroup(l_dict["parent"]) parent_grp.insertChildNode(l_dict["pos"], QgsLayerTreeLayer(lyr)) parent_grp.findLayer(lyr).setItemVisibilityChecked(False) else: parent_grp = self.root.findGroup(l_dict["parent"]) node = parent_grp.addLayer(lyr) node.setItemVisibilityChecked(l_dict["visible"]) lyr.loadNamedStyle(f'{STYLE_PATH}{l_dict["style"]}') return True
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 if name is None: name = os.path.split(fileName)[1] if isRaster: options = QgsRasterLayer.LayerOptions() options.skipCrsValidation = True qgslayer = QgsRasterLayer(fileName, name, 'gdal', options) 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: raise RuntimeError( QCoreApplication.translate( 'dataobject', 'Could not load layer: {0}\nCheck the processing framework log to look for errors.' ).format(fileName)) else: options = QgsVectorLayer.LayerOptions() options.skipCrsValidation = True qgslayer = QgsVectorLayer(fileName, name, 'ogr', options) 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]) return qgslayer
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 gee_layer_make_xml(self): eelayer = self.iface.activeLayer() dest_dir = QgsProject.instance().absolutePath() or os.getcwd() dest_name = eelayer.name().replace('/', '_') + '.xml' dest_file = os.path.join(dest_dir, dest_name) source_xml = eelayer.dataProvider().dataSourceUri() dest_xml, _ = QFileDialog.getSaveFileName(self.dlg, 'Select output file', dest_file, 'XML files (*.xml)') if dest_xml: shutil.copyfile(source_xml, dest_xml) newname = os.path.splitext(os.path.basename(dest_xml))[0] newlayer = QgsRasterLayer(dest_xml, newname) if newlayer.isValid(): imageid = eelayer.customProperty('ee-image-id') date = eelayer.customProperty('ee-image-date') qml = eelayer.customProperty('ee-image-qml') extent = eelayer.customProperty('ee-image-wkt') # load qml must be first since this clean all custom properties if qml is not None: if isfile(qml + '_' + QSettings().value('locale/userLocale') + '.qml'): newlayer.loadNamedStyle( qml + '_' + QSettings().value('locale/userLocale') + '.qml') else: newlayer.loadNamedStyle(qml + '.qml') newlayer.setCustomProperty('ee-image', 'XML') newlayer.setCustomProperty('ee-image-id', imageid) newlayer.setCustomProperty('ee-image-date', date) newlayer.setCustomProperty( 'ee-image-bands', eelayer.customProperty('ee-image-bands')) newlayer.setCustomProperty( 'ee-image-scale', eelayer.customProperty('ee-image-scale')) newlayer.setCustomProperty( 'ee-image-b_min', eelayer.customProperty('ee-image-b_min')) newlayer.setCustomProperty( 'ee-image-b_max', eelayer.customProperty('ee-image-b_max')) newlayer.setCustomProperty( 'ee-image-palette', eelayer.customProperty('ee-image-palette')) newlayer.setCustomProperty('ee-image-qml', qml) newlayer.setCustomProperty('ee-image-wkt', extent) if date is not None: newlayer.setAbstract( f"ee.Image('{imageid}') \n\nDate: {date}") else: newlayer.setAbstract(f"ee.Image('{imageid}')") bb = QgsRectangle.fromWkt(extent) newlayer.setExtent(bb) QgsProject.instance().addMapLayer(newlayer) QgsProject.instance().layerTreeRoot().findLayer( newlayer.id()).setItemVisibilityChecked(False)
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 = 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(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 __init__(self, out_directory=None, EPSG=4326, raster=None, band=1, origin=(0, 0), width=25, height=25, cellWidth=1, cellHeight=1, overwrite=True, qmlStyle=os.path.join( os.path.dirname(os.path.realpath(__file__)), "GameofLife_Style.qml")): # (2.0.1) Create Default Path at Script Directory if out_directory == None: outPath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "GameofLife_Output") createDirectory(outPath) else: outPath = createDirectory(out_directory) # (2.0.1) Create Random Raster if no raster settings defined if raster == None: random_array = numpy.random.randint(2, size=(height, width)) rasterPath = os.path.join(outPath, "start.tif") Array2Raster(random_array, rasterPath, origin, cellWidth, cellHeight, EPSG) # (2.0.2) Otherwise use the Raster Defined by the User else: rasterPath = raster # (2.0.3) Add Raster to Display startLayer = QgsRasterLayer(rasterPath, "start") startLayer.loadNamedStyle(qmlStyle) QgsMapLayerRegistry.instance().addMapLayer(startLayer) # (2.0.4) Main Attribute Settings self.startRaster = rasterPath self.inRaster = rasterPath self.output = outPath self.cycles = 0 self.board = Cells(rasterPath, band, EPSG) self.speed = 0.65 ## delay in seconds after creating each cycle self.overwrite = overwrite ## whether or not to overwrite each cycle self.style = qmlStyle ## raster legend style # (2.0.6) Sub Attribute Settings self.EPSG = EPSG self.band = band
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 add_raster_layer(self, path, id): """Add a downloaded raster layer to the workspace.""" # create a new rasterlayer from the supplied TIF file layer = QgsRasterLayer(path, id) # load layer style based on number of bands bands = layer.bandCount() if bands == 1: path = os.path.join(self.plugin_dir, 'styles', 'singleband.qml') else: path = os.path.join(self.plugin_dir, 'styles', 'multiband.qml') layer.loadNamedStyle(path) # add the layer to the workspace QgsMapLayerRegistry.instance().addMapLayer(layer)
def reset(self): # (2.2.1) Reset the Game Board and Cycles QgsMapLayerRegistry.instance().removeAllMapLayers() ## clear disp self.cycles = 0 self.inRaster = self.startRaster self.board = Cells(self.startRaster, self.band, self.EPSG) startLayer = QgsRasterLayer(self.inRaster, "start") startLayer.loadNamedStyle(self.style) QgsMapLayerRegistry.instance().addMapLayer(startLayer) # (2.2.2) Delete the Cycle Files for the_file in os.listdir(self.output): file_path = os.path.join(self.output, the_file) if "cycle" in file_path: ## Try to delete cycle files try: os.remove(file_path) ## Notify if unable to delete cycle file except Exception: basename = os.path.basename(os.path.splitext(file_path)[0]) print("**Unable to Delete Cycle Raster: " + basename)
def load_dem(self, event): """lookup DEM raster reference of scenario, load raster and give styling""" global_settings_layer = QgsProject.instance().mapLayersByName( "v2_global_settings" )[0] source = Path( global_settings_layer.dataProvider() .dataSourceUri() .split(" ")[0] .split("=")[1][1:-1] ) model_directory = source.parents[0] root = QgsProject.instance().layerTreeRoot() if not root.findGroup("background"): grp_background = root.insertGroup(-1, "background") else: grp_background = root.findGroup("background") feature = list(global_settings_layer.getFeatures())[ self.selected_scenario_index ] dem_file = model_directory / Path(feature["dem_file"]) fileInfo = QFileInfo(str(dem_file)) path = fileInfo.filePath() baseName = fileInfo.baseName() dem_layer = QgsRasterLayer(str(dem_file), "Digital Elevation Model") QgsProject.instance().addMapLayer(dem_layer, False) grp_background.insertChildNode(0, QgsLayerTreeLayer(dem_layer)) dem_layer.loadNamedStyle( os.path.join(os.path.dirname(__file__), "styles\DEM.qml") ) dem_layer.renderer().setOpacity(0.5) dem_layer.setCustomProperty("embeddedWidgets/count", 1) dem_layer.setCustomProperty("embeddedWidgets/0/id", "transparency") self.iface.layerTreeView().refreshLayerSymbology(dem_layer.id())
def readRasterLayer(i, allBandData): # pylint: disable=too-many-locals fileInfo = QFileInfo(shared.rasterFileName[i]) fileBaseName = fileInfo.baseName() layer = QgsRasterLayer(shared.rasterFileName[i], fileBaseName) if not layer.isValid(): shared.fpOut.write("Raster layer '" + shared.rasterFileName[i] + "'failed to load") return -1 # Store the title as the first list item allBandData.append(shared.rasterFileTitle[i]) # Get more info xSize = layer.width() ySize = layer.height() cellWidth = layer.rasterUnitsPerPixelX() cellHeight = layer.rasterUnitsPerPixelY() provider = layer.dataProvider() extnt = provider.extent() dpi = provider.dpi() shared.fpOut.write("Raster layer '" + shared.rasterFileTitle[i] + "' loaded with X, Y resolution = " + str(cellWidth) + ", " + str(cellHeight) + " m\n") #shared.fpOut.write(layer.metadata()) #shared.fpOut.write(layer.rasterType()) # Store the above as the second list item allBandData.append( [provider, xSize, ySize, cellWidth, cellHeight, extnt, dpi]) # Now store the data for each band as a QgsRasterBlock nBands = layer.bandCount() for band in range(nBands): #shared.fpOut.write(layer.bandName(i)) bandData = provider.block(band, extnt, xSize, ySize) # Store as a further list item allBandData.append(bandData) # Sort out style #shared.fpOut.write("Style file " + str(i) + " is " + shared.rasterFileStyle[i]) if not shared.rasterFileStyle[i]: # No style file specified, so try the default style for this layer shared.rasterFileStyle[i] = layer.styleURI() #shared.fpOut.write("Trying default style file " + shared.rasterFileStyle[i]) if not layer.loadDefaultStyle(): shared.fpOut.write("Could not load default style '" + shared.rasterFileStyle[i] + "' for raster layer '" + shared.rasterFileTitle[i] + "'") else: # A style file was specified, so try to load it #shared.fpOut.write("Trying style file " + shared.rasterFileStyle[i]) if not layer.loadNamedStyle(shared.rasterFileStyle[i]): shared.fpOut.write("Could not load style '" + shared.rasterFileStyle[i] + "' for raster layer '" + shared.rasterFileTitle[i] + "'") # Set opacity layer.renderer().setOpacity(shared.rasterFileOpacity[i]) # Add this layer to the app's registry QgsProject.instance().addMapLayer(layer) return layer
def processAlgorithm(self, parameters, context, feedback): # get input variables raster = self.parameterAsFile(parameters, self.INPUT, context) color_ramp = self.parameterAsEnum(parameters, self.COLORRAMP, context) colors = self.color_ramps[self.colors_list[color_ramp]] min = self.parameterAsInt(parameters, self.MIN, context) max = self.parameterAsInt(parameters, self.MAX, context) z_pos_down = self.parameterAsBoolean(parameters, self.Z_POS_DOWN, context) # set new default values in config feedback.pushConsoleInfo( self.tr(f'Storing new default settings in config...')) self.config.set(self.module, 'min', min) self.config.set(self.module, 'max', max) self.config.set(self.module, 'color_ramp', color_ramp) # get file info base_path, base_name, ext = utils.get_info_from_path(raster) # BATHY: # load grid feedback.pushConsoleInfo( self.tr(f'Creating new raster layer [ {base_name} ]...')) dem_layer = QgsRasterLayer(raster, base_name) # test if the files loads properly if not dem_layer.isValid(): raise QgsProcessingException( self.invalidSourceError(parameters, self.INPUT)) # create color scale values feedback.pushConsoleInfo(self.tr(f'Creating color ramp...')) n_values = len(colors) width = max - min step = width / (n_values - 1) values = [] value = min for i in range(n_values): values.append(value) value = value + step # create color_ramp ramp = [] for i, item in enumerate(colors): ramp.append( QgsColorRampShader.ColorRampItem(values[i], QColor(str(item)), str(values[i]))) color_ramp = QgsColorRampShader() color_ramp.setColorRampItemList(ramp) color_ramp.setColorRampType(QgsColorRampShader.Interpolated) # create shader and set color_ramp feedback.pushConsoleInfo(self.tr(f'Creating raster shader...')) shader = QgsRasterShader() shader.setRasterShaderFunction(color_ramp) # create renderer feedback.pushConsoleInfo(self.tr(f'Creating raster renderer...')) renderer = QgsSingleBandPseudoColorRenderer(dem_layer.dataProvider(), dem_layer.type(), shader) # set min max values renderer.setClassificationMin(min) renderer.setClassificationMax(max) # apply renderer to layer dem_layer.setRenderer(renderer) # apply brightness & contrast of layer feedback.pushConsoleInfo(self.tr(f'Adjusting display filters...')) brightness_filter = QgsBrightnessContrastFilter() brightness_filter.setBrightness(-20) brightness_filter.setContrast(10) dem_layer.pipe().set(brightness_filter) # apply resample filter (Bilinear) feedback.pushConsoleInfo(self.tr(f'Setting up resampling...')) resample_filter = dem_layer.resampleFilter() resample_filter.setZoomedInResampler(QgsBilinearRasterResampler()) resample_filter.setZoomedOutResampler(QgsBilinearRasterResampler()) # create group with layer base_name feedback.pushConsoleInfo(self.tr(f'Creating layer group...')) root = context.project().layerTreeRoot() bathy_group = root.addGroup(base_name) # add bathy layer to group bathy_group.insertChildNode(1, QgsLayerTreeLayer(dem_layer)) # add bathy layer to project dem_layer.triggerRepaint() context.project().addMapLayer(dem_layer, False) # 50% done feedback.setProgress(50) # HILLSHADE: # load grid again with layer style file style_hillshade.qml feedback.pushConsoleInfo( self.tr( f'Creating new hillshade layer [ {base_name}_hillshade ]...')) hillshade_layer = QgsRasterLayer(raster, base_name + '_hillshade') # if raster is geographic, load hillshade_geo style (different exaggeration) # if raster is Z positive down, load *_pos_down_* style feedback.pushConsoleInfo(self.tr(f'Setting hillshade style...\n')) if dem_layer.crs().isGeographic() and not z_pos_down: hillshade_layer.loadNamedStyle(self.style_hillshade_geo) elif dem_layer.crs().isGeographic() and z_pos_down: hillshade_layer.loadNamedStyle(self.style_hillshade_pos_down_geo) # else load hillste_prj style elif z_pos_down: hillshade_layer.loadNamedStyle(self.style_hillshade_pos_down_prj) else: hillshade_layer.loadNamedStyle(self.style_hillshade_prj) # add hillshade layer to group bathy_group.insertChildNode(0, QgsLayerTreeLayer(hillshade_layer)) # add hillshade layer to project hillshade_layer.triggerRepaint() context.project().addMapLayer(hillshade_layer, False) # 100% done feedback.setProgress(100) feedback.pushInfo( self.tr(f'{utils.return_success()}! Grid loaded successfully!\n')) result = { self.GROUP: bathy_group, self.DEM_LAYER: dem_layer, self.HILLSHADE_LAYER: hillshade_layer } return result
def cycle(self, n=1, jump=1): # (2.1.1) Cycle Cells of Game Board n Times sumTime = 0 rows = self.board.rows cols = self.board.cols iterations = (n * jump) + 1 for cyclenum in range(1, iterations): ## store copy of original cells inBoard = Cells(self.inRaster, nband=self.band, EPSG=self.EPSG) start_time = time.time() ## start cycle time # (2.1.1) Keep track of number of cycles if cyclenum % jump == 0: self.cycles += jump print "Cycle: " + str(cyclenum) # (2.1.1) Iterate All Cells on Board n Times for i in range(0, rows): for j in range(0, cols): sumNeighbors = 0 ## counter for neighbors boardValue = inBoard.get(j, i, geographic=False) # (2.1.1) Count Neighbours for k in range(i - 1, i + 2): for l in range(j - 1, j + 2): ## Only count neighbours and not the cell itself if (l, k) != (j, i): sumNeighbors = sumNeighbors + inBoard.get( l % cols, k % rows, geographic=False) # (2.1.2a) Alive Cells if boardValue == 1: ## Under-population if sumNeighbors < 2: self.board.modify(j, i, 0, geographic=False) ## Over-crowding elif sumNeighbors > 3: self.board.modify(j, i, 0, geographic=False) # (2.1.2b) Reproduction elif boardValue == 0 and sumNeighbors == 3: self.board.modify(j, i, 1, geographic=False) # (2.1.3) Save Cycle as Raster ## Overwrite Raster if needed if self.overwrite: outLayer = "cycle" ## Otherwise Produce Rasters else: outLayer = "cycle" + str(self.cycles) ## Set input raster to new cycle outCyclePath = os.path.join(self.output, outLayer + ".tif") self.board.toRaster(outCyclePath) self.board = Cells(outCyclePath, self.band, self.EPSG) self.inRaster = outCyclePath # (2.1.4) Display the Saved Raster Cycle if (cyclenum % jump == 0) or cyclenum + 1 == iterations: if self.overwrite: ## remove layer displays if overwriting QgsMapLayerRegistry.instance().removeAllMapLayers() rlayer = QgsRasterLayer(outCyclePath, outLayer) rlayer.loadNamedStyle(self.style) QgsMapLayerRegistry.instance().addMapLayer(rlayer) time.sleep(self.speed) ## suspend display sumTime += (time.time() - start_time) ## end time cycles print "Average Cycle Time: " + str(round(sumTime / n, 2)) + " sec"
def add_ee_image_layer(imageid, name, date, bands, scale, b_min=None, b_max=None, palette=None, qml=None, extent=None, shown=False, destination=None): nbands = len(bands) # if nbands > 3: # rgb = ee.Image(imageid).select(bands[0:3]) # pan = ee.Image(imageid).select(bands[3]) # huesat = rgb.rgbToHsv().select('hue', 'saturation') # image = ee.Image.cat(huesat, pan).hsvToRgb().select([0, 1, 2], bands[0:3]) # nbands = 3 # else: image = ee.Image(imageid) if not any([b_min, b_max, palette, qml]): image_stats = image.select(bands[0:nbands]).reduceRegion(ee.Reducer.minMax(), None, scale, None, None, False, 1.0E13).getInfo() b_min = [image_stats[bands[n] + '_min'] for n in range(nbands)] b_max = [image_stats[bands[n] + '_max'] for n in range(nbands)] # b_min = [image_stats[bands[0] + '_min'], image_stats[bands[1] + '_min'], image_stats[bands[2] + '_min']] # b_max = [image_stats[bands[0] + '_max'], image_stats[bands[1] + '_max'], image_stats[bands[2] + '_max']] rgb = image.visualize(bands=bands[0:nbands], min=b_min, max=b_max, palette=palette) tms = get_ee_image_tms(rgb) if extent is None: image_geojson = get_ee_image_bb(rgb) extent = geojson_to_wkt(image_geojson) bb = QgsRectangle.fromWkt(extent) url = tms_to_gdalurl(tms) xml = get_gdal_xml(url, nbands=nbands+1) # vfn = write_vsimem_xml(xml) # changed to named temporary file tmp, fn = write_xmlfile(xml, name, dest=destination) layer = QgsRasterLayer(fn, name) if layer.isValid(): if qml is not None: if isfile(qml + '_' + QSettings().value('locale/userLocale') + '.qml'): layer.loadNamedStyle(qml + '_' + QSettings().value('locale/userLocale') + '.qml') else: layer.loadNamedStyle(qml + '.qml') layer.setExtent(bb) if tmp: layer.setCustomProperty('ee-image', 'MEM') else: layer.setCustomProperty('ee-image', 'XML') layer.setCustomProperty('ee-image-id', imageid) layer.setCustomProperty('ee-image-date', date) layer.setCustomProperty('ee-image-bands', bands) layer.setCustomProperty('ee-image-scale', scale) layer.setCustomProperty('ee-image-b_min', b_min) layer.setCustomProperty('ee-image-b_max', b_max) layer.setCustomProperty('ee-image-palette', palette) layer.setCustomProperty('ee-image-qml', qml) layer.setCustomProperty('ee-image-wkt', extent) # else: # layer.setAbstract(f"ee.Image('{imageid}')") # if len(bands) < 4: # try: # layer.setCustomProperty('ee-image-stats', image_stats) # except NameError: # pass if date is not None: layer.setAbstract(f"ee.Image('{imageid}') \n\nDate: {date}") else: layer.setAbstract(f"ee.Image('{imageid}')") QgsProject.instance().addMapLayer(layer) if not shown: QgsProject.instance().layerTreeRoot().findLayer(layer.id()).setItemVisibilityChecked(shown)
def add_layer_to_map(item: QStandardItem): """ Add a layer to the map :param layer: :return: """ # No multiselect so there is only ever one item pt_data: ProjectTreeData = item.data(Qt.UserRole) project = pt_data.project map_layer: QRaveMapLayer = pt_data.data settings = Settings() # Loop over all the parent group layers for this raster # ensuring they are in the tree in correct, nested order ancestry = [] if map_layer.exists is True: parent = item.parent() while parent is not None and len(ancestry) < 50: ancestry.append((parent.text(), parent.row())) parent = parent.parent() else: # Layer does not exist. do not try to put it on the map return ancestry.reverse() parentGroup = None for agroup in ancestry: parentGroup = QRaveMapLayer._addgrouptomap(agroup[0], agroup[1], parentGroup) assert parentGroup, "All rasters should be nested and so parentGroup should be instantiated by now" # Loop over all the parent group layers for this raster # ensuring they are in the tree in correct, nested order # Only add the layer if it's not already in the registry exists = False existing_layers = QgsProject.instance().mapLayersByName( map_layer.label) layers_ancestry = [ QRaveMapLayer.get_layer_ancestry(lyr) for lyr in existing_layers ] # Now we compare the ancestry group labels to the business logic ancestry branch names # to see if this layer is already in the map for lyr in layers_ancestry: if len(lyr) == len(ancestry) \ and all(iter([ancestry[x][0] == lyr[x] for x in range(len(ancestry))])): exists = True break if not exists: layer_uri = map_layer.layer_uri rOutput = None # This might be a basemap if map_layer.layer_type == QRaveMapLayer.LayerTypes.WEBTILE: rOutput = QgsRasterLayer(layer_uri, map_layer.label, 'wms') elif map_layer.layer_type in [ QRaveMapLayer.LayerTypes.LINE, QRaveMapLayer.LayerTypes.POLYGON, QRaveMapLayer.LayerTypes.POINT ]: if map_layer.layer_name is not None: layer_uri += "|layername={}".format(map_layer.layer_name) rOutput = QgsVectorLayer(layer_uri, map_layer.label, "ogr") elif map_layer.layer_type == QRaveMapLayer.LayerTypes.RASTER: # Raster rOutput = QgsRasterLayer(layer_uri, map_layer.label) if rOutput is not None: ########################################## # Symbology ########################################## symbology = map_layer.bl_attr[ 'symbology'] if map_layer.bl_attr is not None and 'symbology' in map_layer.bl_attr else None # If the business logic has symbology defined if symbology is not None: qml_fname = '{}.qml'.format(symbology) os.path.abspath( os.path.join(project.project_dir, qml_fname)) # Here are the search paths for QML files in order of precedence hierarchy = [ os.path.abspath( os.path.join(project.project_dir, qml_fname)), # This is the default one os.path.abspath( os.path.join(SYMBOLOGY_DIR, project.project_type, qml_fname)), os.path.abspath( os.path.join(SYMBOLOGY_DIR, 'Shared', qml_fname)) ] # Find the first match try: chosen_qml = next( iter([ candidate for candidate in hierarchy if os.path.isfile(candidate) ])) # Report to the terminal if we couldn't find a qml file to use if chosen_qml is None: settings.msg_bar( "Missing Symbology", "Could not find a valid .qml symbology file for layer {}. Search paths: [{}]" .format(layer_uri, ', '.join(hierarchy)), level=Qgis.Warning) # Apply the QML file else: rOutput.loadNamedStyle(chosen_qml) except StopIteration: settings.log( 'Could not find valid symbology for layer at any of the following search paths: [ {} ]' .format(', '.join(hierarchy)), Qgis.Warning) ############################################################ # Transparency. A few notes: # - QML transparency will prevail for rasters before 3.18 # - We set this here so that QML layer transparency will be # overruled ############################################################ transparency = 0 try: if 'transparency' in map_layer.bl_attr: transparency = int(map_layer.bl_attr['transparency']) except Exception as e: settings.log( 'Error deriving transparency from layer: {}'.format(e)) try: if transparency > 0: if rOutput.__class__ is QgsVectorLayer: rOutput.setLayerTransparency(transparency) # rOutput.triggerRepaint() elif rOutput.__class__ is QgsRasterLayer: renderer = rOutput.renderer() renderer.setOpacity((100 - transparency) / 100.0) # rOutput.triggerRepaint() except Exception as e: settings.log( 'Error deriving transparency from layer: {}'.format(e)) QgsProject.instance().addMapLayer(rOutput, False) parentGroup.insertLayer(item.row(), rOutput) # if the layer already exists trigger a refresh else: QgsProject.instance().mapLayersByName( map_layer.label)[0].triggerRepaint()
class ElevationDockWidget(QtWidgets.QDockWidget, FORM_CLASS): closingPlugin = pyqtSignal() dataChange = pyqtSignal(QRiSProject, str) def __init__(self, raster, qris_project, parent=None): """Constructor.""" super(ElevationDockWidget, self).__init__(parent) # Set up the user interface from Designer. # After setupUI you can access any designer object by doing # self.<objectname>, and you can use autoconnect slots - see # http://doc.qt.io/qt-5/designer-using-a-ui-file.html # #widgets-and-dialogs-with-auto-connect self.setupUi(self) self.qris_project = qris_project self.raster = raster self.elevation_value = 1.0 self.txtRasterName.setText(self.raster.name) self.raster_path = os.path.join(self.qris_project.project_path, raster.path) self.group_layer = None self.raster_layer = QgsRasterLayer(self.raster_path, 'Elevation Explorer') self.base_raster_layer = QgsRasterLayer(self.raster_path, self.raster.name) self.base_raster_layer.loadNamedStyle(os.path.join(os.path.dirname(__file__), "..", 'resources', 'symbology', 'hand.qml')) self.updateElevationLayer(self.elevation_value) QgsProject.instance().addMapLayer(self.base_raster_layer) QgsProject.instance().addMapLayer(self.raster_layer) # TODO Get min max of raster and apply to slider tools self.elevationSlider.valueChanged.connect(self.sliderElevationChange) self.numElevation.valueChanged.connect(self.spinBoxElevationChange) self.btnExport.clicked.connect(self.exportPolygonDlg) # self.closingPlugin.connect(self.closeWidget) def closeEvent(self, event): QgsProject.instance().removeMapLayer(self.base_raster_layer.id()) QgsProject.instance().removeMapLayer(self.raster_layer.id()) iface.mapCanvas().refresh() self.close() self.destroy() def updateElevationLayer(self, value=1.0): fcn = QgsColorRampShader() fcn.setColorRampType(QgsColorRampShader.Discrete) fcn.setColorRampItemList([QgsColorRampShader.ColorRampItem(value, QColor(255, 20, 225), f'Elevation {value}')]) shader = QgsRasterShader() shader.setRasterShaderFunction(fcn) renderer = QgsSingleBandPseudoColorRenderer(self.raster_layer.dataProvider(), 1, shader) self.raster_layer.setRenderer(renderer) self.raster_layer.triggerRepaint() def sliderElevationChange(self, value): self.elevation_value = value / 10 self.updateElevationLayer(value / 10) self.numElevation.setValue(value / 10) def spinBoxElevationChange(self, value): self.elevation_value = value self.updateElevationLayer(value) self.elevationSlider.setValue(int(value * 10)) def exportPolygonDlg(self): self.export_dlg = ExportElevationSurfaceDlg(self.raster, self.elevation_value, self.qris_project) self.export_dlg.dataChange.connect(self.exportPolgyon) self.export_dlg.show() def exportPolgyon(self, updated_project, surface_name): self.qris_project = updated_project self.dataChange.emit(self.qris_project, surface_name) self.closeWidget() return def closeWidget(self): QgsProject.instance().removeMapLayer(self.base_raster_layer.id()) QgsProject.instance().removeMapLayer(self.raster_layer.id()) self.close() self.destroy() return
def renderer(self): if 'QGIS_AUTH_DB_DIR_PATH' not in os.environ: os.environ['QGIS_AUTH_DB_DIR_PATH'] = '/tmp' qgis = None while True: options, result = self.queue.get() # Don't start QGIS until first request if qgis is None: qgis = QgsApplication([], False) qgis.setPrefixPath(self.settings.get('path'), True) qgis.setDefaultSvgPaths(qgis.svgPaths() + self.settings.get('svgpaths')) qgis.setMaxThreads(1) qgis.initQgis() try: if isinstance(options, LegendOptions): style, = options layer = self._qgs_memory_layer(style) layer.setName(style.parent.display_name) QgsMapLayerRegistry.instance().addMapLayer(layer) root = QgsLayerTreeGroup() root.addLayer(layer) # 'Cannot create a QPixmap when no GUI is being used' # warning occurs here model = QgsLayerTreeModel(root) settings = QgsLegendSettings() settings.setTitle('') settings.setBoxSpace(1) settings.setSymbolSize(QSizeF(5, 3)) settings.setDpi(96) renderer = QgsLegendRenderer(model, settings) # Dots per mm dpmm = settings.dpi() / 25.4 min_size = renderer.minimumSize() size = QSize(dpmm * min_size.width(), dpmm * min_size.height()) img = QImage(size, QImage.Format_ARGB32) img.fill(QColor(0, 0, 0, 0)) painter = QPainter() painter.begin(img) painter.scale(dpmm, dpmm) renderer.drawLegend(painter) painter.end() QgsMapLayerRegistry.instance().removeAllMapLayers() ba = QByteArray() bf = QBuffer(ba) bf.open(QIODevice.WriteOnly) img.save(bf, 'PNG') bf.close() buf = StringIO() buf.write(bf.data()) buf.seek(0) result.put(buf) else: path = features = None if isinstance(options, VectorRenderOptions): style, features, render_size, \ extended, target_box = options layer = self._qgs_memory_layer(style, features=features) elif isinstance(options, RasterRenderOptions): style, path, render_size, \ extended, target_box = options layer = QgsRasterLayer(path) layer.loadNamedStyle( self.env.file_storage.filename(style.qml_fileobj)) settings = QgsMapSettings() settings.setLayers([layer.id()]) settings.setFlag(QgsMapSettings.DrawLabeling) settings.setFlag(QgsMapSettings.Antialiasing) settings.setCrsTransformEnabled(True) settings.setDestinationCrs(layer.crs()) settings.setMapUnits(layer.crs().mapUnits()) settings.setOutputSize(QSize(*render_size)) settings.setExtent(QgsRectangle(*extended)) settings.setOutputImageFormat(QImage.Format_ARGB32) bgcolor = QColor.fromRgba(qRgba(255, 255, 255, 0)) settings.setBackgroundColor(bgcolor) settings.setOutputDpi(96) QgsMapLayerRegistry.instance().addMapLayer(layer) settings.setLayers([layer.id()]) # Create QImage by hand to be able to use # QgsMapRendererCustomPainterJob. Others will not # allow to workaround a bug with overlay rendering. img = QImage(settings.outputSize(), QImage.Format_ARGB32) # These cludges are needed for rendering # on transparent background, otherwise it's a mess. img.fill(QColor.fromRgba(qRgba(255, 255, 255, 255))) img.fill(QColor.fromRgba(qRgba(255, 255, 255, 0))) # DPI should be equal to settings, otherwise an error. # In QImage the resolution is set in dots per meter # for each axis. dpm = settings.outputDpi() / 25.4 * 1000 img.setDotsPerMeterX(dpm) img.setDotsPerMeterY(dpm) painter = QPainter(img) job = QgsMapRendererCustomPainterJob(settings, painter) job.renderSynchronously() painter.end() QgsMapLayerRegistry.instance().removeAllMapLayers() img = self._qimage_to_pil(img) # Clip needed part result.put(img.crop(target_box)) # Cleanup if path is not None: gdal.Unlink(path) except Exception as exc: self.logger.error(exc.message) result.put(exc) qgis.exitQgis()