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()
