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
