def refreshtiles_apply(self, tilestoclean, tilestoload, tilefiles, extent): #clean layerstoclean = [self.loadedlayers[tile] for tile in tilestoclean] for tile in tilestoclean: del self.loadedlayers[tile] QgsMapLayerRegistry.instance().removeMapLayers(layerstoclean) log("defining self.actualzoom") if len(tilestoload) > 0: self.actualzoom = tilestoload[0][2] else: self.actualzoom = None #load log("loading tiles") for i in range(len(tilestoload)): #check file exists if os.path.exists(tilefiles[i]): auxfile = tm.auxfilename(tilefiles[i]) if not os.path.exists(auxfile): osm.writeauxfile(*tilestoload[i], filename=auxfile, imagesize=tm.tilesize(self.tiletype)) #create layer, add to self.loadedlayers layername = "qosm_%s_x%s_y%s_z%s" % ((self.tiletype,) + tilestoload[i]) layer = QgsRasterLayer(tilefiles[i], layername) if layer.isValid(): layer = QgsMapLayerRegistry.instance().addMapLayer(layer, False) layer.resampleFilter().setZoomedOutResampler(QgsBilinearRasterResampler()) layer.resampleFilter().setZoomedInResampler(QgsBilinearRasterResampler()) self.loadedlayers[tilestoload[i]] = layer.id() else: log("ERROR invalid layer produced:" + layername) else: #report error? log("tile filename does not exist: " + tilefiles[i]) log("setting extent: " + extent.toString()) self.setExtent(extent)
def createBaseMapLayer(self, map_theme, layer, tile_size, map_units_per_pixel): """ Create a basemap from map layer(s) :param dataPath: The path where the basemap should be writtent to :param extent: The extent rectangle in which data shall be fetched :param map_theme: The name of the map theme to be rendered :param layer: A layer id to be rendered. Will only be used if map_theme is None. :param tile_size: The extent rectangle in which data shall be fetched :param map_units_per_pixel: Number of map units per pixel (1: 1 m per pixel, 10: 10 m per pixel...) """ extent_string = '{},{},{},{}'.format(self.extent.xMinimum(), self.extent.xMaximum(), self.extent.yMinimum(), self.extent.yMaximum()) alg = QgsApplication.instance().processingRegistry( ).createAlgorithmById('qgis:rasterize') params = { 'EXTENT': extent_string, 'MAP_THEME': map_theme, 'LAYER': layer, 'MAP_UNITS_PER_PIXEL': map_units_per_pixel, 'TILE_SIZE': tile_size, 'MAKE_BACKGROUND_TRANSPARENT': False, 'OUTPUT': os.path.join(self.export_folder, 'basemap.gpkg') } feedback = QgsProcessingFeedback() context = QgsProcessingContext() context.setProject(QgsProject.instance()) results, ok = alg.run(params, context, feedback) new_layer = QgsRasterLayer(results['OUTPUT'], self.tr('Basemap')) resample_filter = new_layer.resampleFilter() resample_filter.setZoomedInResampler(QgsCubicRasterResampler()) resample_filter.setZoomedOutResampler(QgsBilinearRasterResampler()) self.project_configuration.project.addMapLayer(new_layer, False) layer_tree = QgsProject.instance().layerTreeRoot() layer_tree.insertLayer(len(layer_tree.children()), new_layer)
def createBaseMapLayer(self, map_theme, layer, tile_size, map_units_per_pixel): """ Create a basemap from map layer(s) :param dataPath: The path where the basemap should be writtent to :param extent: The extent rectangle in which data shall be fetched :param map_theme: The name of the map theme to be rendered :param layer: A layer id to be rendered. Will only be used if map_theme is None. :param tile_size: The extent rectangle in which data shall be fetched :param map_units_per_pixel: Number of map units per pixel (1: 1 m per pixel, 10: 10 m per pixel...) """ extent_string = '{},{},{},{}'.format(self.extent.xMinimum(), self.extent.xMaximum(), self.extent.yMinimum(), self.extent.yMaximum()) alg = QgsApplication.instance().processingRegistry().createAlgorithmById('qgis:rasterize') params = { 'EXTENT': extent_string, 'MAP_THEME': map_theme, 'LAYER': layer, 'MAP_UNITS_PER_PIXEL': map_units_per_pixel, 'TILE_SIZE': tile_size, 'MAKE_BACKGROUND_TRANSPARENT': False, 'OUTPUT': os.path.join(self.export_folder, 'basemap.gpkg') } feedback = QgsProcessingFeedback() context = QgsProcessingContext() context.setProject(QgsProject.instance()) results, ok = alg.run(params, context, feedback) new_layer = QgsRasterLayer(results['OUTPUT'], self.tr('Basemap')) resample_filter = new_layer.resampleFilter() resample_filter.setZoomedInResampler(QgsCubicRasterResampler()) resample_filter.setZoomedOutResampler(QgsBilinearRasterResampler()) self.project_configuration.project.addMapLayer(new_layer, False) layer_tree = QgsProject.instance().layerTreeRoot() layer_tree.insertLayer(len(layer_tree.children()), new_layer)
def createBaseMapLayer(self, map_theme, layer, tile_size, map_units_per_pixel): """ Create a basemap from map layer(s) :param dataPath: The path where the basemap should be writtent to :param extent: The extent rectangle in which data shall be fetched :param map_theme: The name of the map theme to be rendered :param layer: A layer id to be rendered. Will only be used if map_theme is None. :param tile_size: The extent rectangle in which data shall be fetched :param map_units_per_pixel: Number of map units per pixel (1: 1 m per pixel, 10: 10 m per pixel...) """ extent_string = '{},{},{},{}'.format(self.extent.xMinimum(), self.extent.xMaximum(), self.extent.yMinimum(), self.extent.yMaximum()) alg = processing.Processing.getAlgorithm( 'qfieldsync:basemap').getCopy() alg.setParameterValue('EXTENT', extent_string) alg.setParameterValue('MAP_THEME', map_theme) alg.setParameterValue('LAYER', layer) alg.setParameterValue('MAP_UNITS_PER_PIXEL', map_units_per_pixel) alg.setParameterValue('TILE_SIZE', tile_size) alg.setOutputValue('OUTPUT_LAYER', os.path.join(self.export_folder, 'basemap.gpkg')) alg.execute(progress=self.convertorProcessingProgress()) out = alg.outputs[0] new_layer = QgsRasterLayer(out.value, self.tr('Basemap')) resample_filter = new_layer.resampleFilter() resample_filter.setZoomedInResampler(QgsCubicRasterResampler()) resample_filter.setZoomedOutResampler(QgsBilinearRasterResampler()) self.project_configuration.project.addMapLayer(new_layer, False) layer_tree = QgsProject.instance().layerTreeRoot() layer_tree.insertLayer(len(layer_tree.children()), new_layer)
def _export_basemap(self) -> bool: self.total_progress_updated.emit(0, 1, self.trUtf8("Creating base map…")) if not self._export_basemap_requirements_check(): return False project = QgsProject.instance() basemap_extent = self.area_of_interest.boundingBox() if basemap_extent.isNull() or not basemap_extent.isFinite(): self.warning.emit( self.tr("Failed to create basemap"), self.tr( "Cannot create basemap for the given area of interest."), ) return False if not self.project_configuration.base_map_layer.strip(): self.warning.emit( self.tr("Failed to create basemap"), self. tr("No basemap layer selected. Please check the project configuration." ).format(self.project_configuration.base_map_layer), ) return False extent = basemap_extent base_map_type = self.project_configuration.base_map_type if base_map_type == ProjectProperties.BaseMapType.SINGLE_LAYER: basemap_layer = project.mapLayer( self.project_configuration.base_map_layer) if not basemap_layer: self.warning.emit( self.tr("Failed to create basemap"), self. tr('Cannot find the configured base layer with id "{}". Please check the project configuration.' ).format(self.project_configuration.base_map_layer), ) return False # we need to transform the extent to match the one of the selected layer extent = QgsCoordinateTransform( QgsCoordinateReferenceSystem(self.area_of_interest_crs), project.crs(), project, ).transformBoundingBox(basemap_extent) elif base_map_type == ProjectProperties.BaseMapType.MAP_THEME: if not project.mapThemeCollection().hasMapTheme( self.project_configuration.base_map_theme): self.warning.emit( self.tr("Failed to create basemap"), self. tr('Cannot find the configured base theme with name "{}". Please check the project configuration.' ).format(self.project_configuration.base_map_theme), ) return False extent_string = "{},{},{},{}".format( extent.xMinimum(), extent.xMaximum(), extent.yMinimum(), extent.yMaximum(), ) alg = (QgsApplication.instance().processingRegistry(). createAlgorithmById("native:rasterize")) params = { "EXTENT": extent_string, "EXTENT_BUFFER": 0, "TILE_SIZE": self.project_configuration.base_map_tile_size, "MAP_UNITS_PER_PIXEL": self.project_configuration.base_map_mupp, "MAKE_BACKGROUND_TRANSPARENT": False, "OUTPUT": os.path.join(self.export_folder, "basemap.gpkg"), } if base_map_type == ProjectProperties.BaseMapType.SINGLE_LAYER: params["LAYERS"] = [self.project_configuration.base_map_layer] elif base_map_type == ProjectProperties.BaseMapType.MAP_THEME: params["MAP_THEME"] = self.project_configuration.base_map_theme feedback = QgsProcessingFeedback() context = QgsProcessingContext() context.setProject(QgsProject.instance()) results, ok = alg.run(params, context, feedback) if not ok: self.warning.emit(self.tr("Failed to create basemap"), feedback.textLog()) return False new_layer = QgsRasterLayer(results["OUTPUT"], self.tr("Basemap")) resample_filter = new_layer.resampleFilter() resample_filter.setZoomedInResampler(QgsCubicRasterResampler()) resample_filter.setZoomedOutResampler(QgsBilinearRasterResampler()) self.project_configuration.project.addMapLayer(new_layer, False) layer_tree = QgsProject.instance().layerTreeRoot() layer_tree.insertLayer(len(layer_tree.children()), new_layer) return True
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