def testShaderCrash(self):
"""Check if we assign a shader and then reassign it no crash occurs."""
myPath = os.path.join(unitTestDataPath('raster'),
'band1_float32_noct_epsg4326.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
myRasterLayer = QgsRasterLayer(myPath, myBaseName)
myMessage = 'Raster not loaded: %s' % myPath
assert myRasterLayer.isValid(), myMessage
myRasterShader = QgsRasterShader()
myColorRampShader = QgsColorRampShader()
myColorRampShader.setColorRampType(QgsColorRampShader.Interpolated)
myItems = []
myItem = QgsColorRampShader.ColorRampItem(10, QColor('#ffff00'), 'foo')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(100, QColor('#ff00ff'),
'bar')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(1000, QColor('#00ff00'),
'kazam')
myItems.append(myItem)
myColorRampShader.setColorRampItemList(myItems)
myRasterShader.setRasterShaderFunction(myColorRampShader)
myPseudoRenderer = QgsSingleBandPseudoColorRenderer(
myRasterLayer.dataProvider(), 1, myRasterShader)
myRasterLayer.setRenderer(myPseudoRenderer)
return
# ####### works first time #############
myRasterShader = QgsRasterShader()
myColorRampShader = QgsColorRampShader()
myColorRampShader.setColorRampType(QgsColorRampShader.Interpolated)
myItems = []
myItem = QgsColorRampShader.ColorRampItem(10, QColor('#ffff00'), 'foo')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(100, QColor('#ff00ff'),
'bar')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(1000, QColor('#00ff00'),
'kazam')
myItems.append(myItem)
myColorRampShader.setColorRampItemList(myItems)
myRasterShader.setRasterShaderFunction(myColorRampShader)
# ####### crash on next line (fixed now)##################
myPseudoRenderer = QgsSingleBandPseudoColorRenderer(
myRasterLayer.dataProvider(), 1, myRasterShader)
myRasterLayer.setRenderer(myPseudoRenderer)
def setRenderer(self, steps, precision):
# TEMP test using ramp - shows something at least
items = []
for v in range(0, steps):
colour = self.pngDbEncode(v) #use integer here
val = v / precision
label = f"{val}"
ramp_item = QgsColorRampShader.ColorRampItem(val, colour, label)
items.append(ramp_item)
raster_shader = QgsRasterShader()
ramp_shader = QgsColorRampShader()
ramp_shader.setColorRampType(
1
) # https://qgis.org/pyqgis/3.2/core/Color/QgsColorRampShader.html#qgis.core.QgsColorRampShader.Quantile
ramp_shader.setColorRampItemList(items)
raster_shader.setRasterShaderFunction(ramp_shader)
band = 1
raster_layer = iface.activeLayer()
renderer = QgsSingleBandPseudoColorRenderer(
raster_layer.dataProvider(), band, raster_shader)
raster_layer.setRenderer(renderer)
raster_layer.triggerRepaint()
print('Set renderer 2')
def style_land_cover_land_deg(outfile):
layer_deg = iface.addRasterLayer(
outfile,
QtGui.QApplication.translate('LDMPPlugin', 'Land cover (degradation)'))
if not layer_deg.isValid():
log('Failed to add layer')
return None
fcn = QgsColorRampShader()
fcn.setColorRampType(QgsColorRampShader.EXACT)
#TODO The GPG doesn't seem to allow for possibility of improvement...?
lst = [
QgsColorRampShader.ColorRampItem(
-1, QtGui.QColor(153, 51, 4),
QtGui.QApplication.translate('LDMPPlugin', 'Degradation')),
QgsColorRampShader.ColorRampItem(
0, QtGui.QColor(246, 246, 234),
QtGui.QApplication.translate('LDMPPlugin', 'Stable')),
QgsColorRampShader.ColorRampItem(
1, QtGui.QColor(0, 140, 121),
QtGui.QApplication.translate('LDMPPlugin', 'Improvement'))
]
fcn.setColorRampItemList(lst)
shader = QgsRasterShader()
shader.setRasterShaderFunction(fcn)
pseudoRenderer = QgsSingleBandPseudoColorRenderer(layer_deg.dataProvider(),
1, shader)
layer_deg.setRenderer(pseudoRenderer)
layer_deg.triggerRepaint()
iface.legendInterface().refreshLayerSymbology(layer_deg)
def create_legend(layer, max_val, min_val, mean_val, value_color=None, area=None):
if max_val is not None and min_val is not None and mean_val is not None:
shader = QgsRasterShader()
color_ramp = QgsColorRampShader()
color_ramp.setColorRampType("INTERPOLATED")
items = []
item = QgsColorRampShader.ColorRampItem(0, QColor('#000005ae'), '0')
items.append(item)
area_lbl = ''
if area:
area_lbl = '/' + str(int(round(area, 0))) + "m²"
if value_color:
item = QgsColorRampShader.ColorRampItem(mean_val, value_color, str(round(mean_val,2)) + " MWh/year" + area_lbl)
items.append(item)
elif not np.isnan(min_val):
if min_val == 0:
min_val_text = "> 0"
else:
min_val_text = str(round(min_val,2))
item = QgsColorRampShader.ColorRampItem(min_val + 0.00001, QColor('#0005ae'), min_val_text + " MWh/year" + area_lbl)
items.append(item)
item = QgsColorRampShader.ColorRampItem(min_val + 0.00001 + round((max_val - min_val) / 2, 2), QColor('#fda000'),
str(round(min_val + ((max_val - min_val) / 2), 2)) + " MWh/year" + area_lbl)
items.append(item)
item = QgsColorRampShader.ColorRampItem(max_val, QColor('#ff0000'), str(round(max_val,2)) + " MWh/year" + area_lbl)
items.append(item)
color_ramp.setColorRampItemList(items)
shader.setRasterShaderFunction(color_ramp)
ps = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1, shader)
layer.setRenderer(ps)
def style_prod_state_emerg(outfile):
# Significance layer
layer = iface.addRasterLayer(outfile, 'Productivity state (emerging)')
fcn = QgsColorRampShader()
fcn.setColorRampType(QgsColorRampShader.EXACT)
lst = [
QgsColorRampShader.ColorRampItem(-2, QtGui.QColor(0, 0, 0), 'No data'),
QgsColorRampShader.ColorRampItem(-1, QtGui.QColor(153, 51, 4),
'Significant decrease'),
QgsColorRampShader.ColorRampItem(0, QtGui.QColor(246, 246, 234),
'No significant change'),
QgsColorRampShader.ColorRampItem(1, QtGui.QColor(0, 140, 121),
'Significant increase'),
QgsColorRampShader.ColorRampItem(2, QtGui.QColor(58, 77, 214),
'Water'),
QgsColorRampShader.ColorRampItem(3, QtGui.QColor(192, 105, 223),
'Urban land cover')
]
fcn.setColorRampItemList(lst)
shader = QgsRasterShader()
shader.setRasterShaderFunction(fcn)
pseudoRenderer = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1,
shader)
layer.setRenderer(pseudoRenderer)
layer.triggerRepaint()
iface.legendInterface().refreshLayerSymbology(layer)
def style_prod_traj_trend(outfile):
# Trends layer
layer_ndvi = iface.addRasterLayer(outfile, 'Productivity trajectory trend')
provider = layer_ndvi.dataProvider()
# Set a colormap centred on zero, going to the extreme value significant to
# three figures
stats = provider.bandStatistics(1, QgsRasterBandStats.All)
#TODO: Make this a 2% stretch rather than simple linear stretch
extreme = get_extreme(stats.minimumValue, stats.maximumValue)
fcn = QgsColorRampShader()
fcn.setColorRampType(QgsColorRampShader.INTERPOLATED)
lst = [
QgsColorRampShader.ColorRampItem(-extreme, QtGui.QColor(153, 51, 4),
'-{} (declining)'.format(extreme)),
QgsColorRampShader.ColorRampItem(0, QtGui.QColor(246, 246, 234),
'0 (stable)'),
QgsColorRampShader.ColorRampItem(extreme, QtGui.QColor(0, 140, 121),
'{} (increasing)'.format(extreme))
]
fcn.setColorRampItemList(lst)
shader = QgsRasterShader()
shader.setRasterShaderFunction(fcn)
pseudoRenderer = QgsSingleBandPseudoColorRenderer(
layer_ndvi.dataProvider(), 1, shader)
layer_ndvi.setRenderer(pseudoRenderer)
layer_ndvi.triggerRepaint()
iface.legendInterface().refreshLayerSymbology(layer_ndvi)
def style_land_cover_lc_target(outfile):
layer_lc_target = iface.addRasterLayer(outfile, 'Land cover (target)')
fcn = QgsColorRampShader()
fcn.setColorRampType(QgsColorRampShader.EXACT)
lst = [
QgsColorRampShader.ColorRampItem(1, QtGui.QColor('#a50f15'),
'Cropland'),
QgsColorRampShader.ColorRampItem(2, QtGui.QColor('#006d2c'),
'Forest land'),
QgsColorRampShader.ColorRampItem(3, QtGui.QColor('#d8d800'),
'Grassland'),
QgsColorRampShader.ColorRampItem(4, QtGui.QColor('#08519c'),
'Wetlands'),
QgsColorRampShader.ColorRampItem(5, QtGui.QColor('#54278f'),
'Settlements'),
QgsColorRampShader.ColorRampItem(6, QtGui.QColor('#252525'),
'Other land')
]
fcn.setColorRampItemList(lst)
shader = QgsRasterShader()
shader.setRasterShaderFunction(fcn)
pseudoRenderer = QgsSingleBandPseudoColorRenderer(
layer_lc_target.dataProvider(), 1, shader)
layer_lc_target.setRenderer(pseudoRenderer)
layer_lc_target.triggerRepaint()
iface.legendInterface().refreshLayerSymbology(layer_lc_target)
def mmi_ramp_roman(raster_layer):
"""Generate an mmi ramp using range of 1-10 on roman.
A standarised range is used so that two shakemaps of different
intensities can be properly compared visually with colours stretched
accross the same range.
The colours used are the 'standard' colours commonly shown for the
mercalli scale e.g. on wikipedia and other sources.
:param raster_layer: A raster layer that will have an mmi style applied.
:type raster_layer: QgsRasterLayer
.. versionadded:: 4.0
"""
items = []
sorted_mmi_scale = sorted(earthquake_mmi_scale['classes'],
key=itemgetter('value'))
for class_max in sorted_mmi_scale:
colour = class_max['color']
label = '%s' % class_max['key']
ramp_item = QgsColorRampShader.ColorRampItem(class_max['value'],
colour, label)
items.append(ramp_item)
raster_shader = QgsRasterShader()
ramp_shader = QgsColorRampShader()
ramp_shader.setColorRampType(QgsColorRampShader.INTERPOLATED)
ramp_shader.setColorRampItemList(items)
raster_shader.setRasterShaderFunction(ramp_shader)
band = 1
renderer = QgsSingleBandPseudoColorRenderer(raster_layer.dataProvider(),
band, raster_shader)
raster_layer.setRenderer(renderer)
def setSBPCRasterRenderer(layer, shader):
if not shader:
utils.internal_error("Could not create raster shader")
renderer = QgsSingleBandPseudoColorRenderer(input=layer.dataProvider(),
band=1,
shader=shader)
setRenderer(layer, renderer)
def mmi_ramp(raster_layer):
"""Generate an mmi ramp using standardised range of 1-12
A standarised range is used so that two shakemaps of different
intensities can be properly compared visually with colours stretched
accross the same range.
The colours used are the 'standard' colours commonly shown for the
mercalli scale e.g. on wikipedia and other sources.
:param raster_layer: A raster layer that will have an mmi style applied.
:type raster_layer: QgsRasterLayer
"""
items = []
for class_max in range(1, 13):
colour = QtGui.QColor(mmi_colour(class_max))
label = '%i' % class_max
ramp_item = QgsColorRampShader.ColorRampItem(class_max, colour, label)
items.append(ramp_item)
raster_shader = QgsRasterShader()
ramp_shader = QgsColorRampShader()
ramp_shader.setColorRampType(QgsColorRampShader.INTERPOLATED)
ramp_shader.setColorRampItemList(items)
raster_shader.setRasterShaderFunction(ramp_shader)
band = 1
renderer = QgsSingleBandPseudoColorRenderer(raster_layer.dataProvider(),
band, raster_shader)
raster_layer.setRenderer(renderer)
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 postProcessLayer(self, layer, context, feedback):
"""
Apply quantile classification.
"""
if not isinstance(layer, QgsRasterLayer):
return
feedback.pushInfo('Apply styling(symbology) to raster layer..')
def get_quantile_ramp_item_list(layer):
"""
Returns the quantile ramp item list and overrides the ramp items
labels with our custom categories.
We use a dummy shader function to help us with the quantile
classification
"""
stats = layer.dataProvider().bandStatistics(
1, QgsRasterBandStats.All)
min_val = stats.minimumValue
max_value = stats.maximumValue
colors = [
QColor('#4c724b'),
QColor('#89a167'),
QColor('#d9d98d'),
QColor('#b08d64'),
QColor('#8a514a')
]
dummy_shader = QgsColorRampShader(
minimumValue=min_val,
maximumValue=max_val,
colorRamp=QgsPresetSchemeColorRamp(colors=colors),
type=QgsColorRampShader.Discrete,
classificationMode=QgsColorRampShader.Quantile)
dummy_shader.classifyColorRamp(classes=5,
band=1,
input=layer.dataProvider())
labels = ['Very low', 'Low', 'Moderate', 'High', 'Very high']
ramp_items = []
for i, ramp_item in enumerate(dummy_shader.colorRampItemList()):
ramp_item.label = labels[i]
ramp_items.append(ramp_item)
return ramp_items
shader_fnc = QgsColorRampShader()
shader_fnc.setColorRampType(QgsColorRampShader.Discrete)
shader_fnc.setColorRampItemList(get_quantile_ramp_item_list(layer))
shader = QgsRasterShader()
shader.setRasterShaderFunction(shader_fnc)
renderer = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1,
shader)
layer.setRenderer(renderer)
def render_GCD(self, type):
self.setRendererOptions(type)
self.shader.setRasterShaderFunction(self.ramp)
renderer = QgsSingleBandPseudoColorRenderer(self.layer.dataProvider(), 1, self.shader)
self.layer.setRenderer(renderer)
self.layer.renderer().setOpacity(self.opacity)
self.layer.triggerRepaint()
def apply_symbology(rlayer, symbology, symbology_enabled, transparent=255):
""" Apply classification symbology to raster layer """
# See: QgsRasterRenderer* QgsSingleBandPseudoColorRendererWidget::renderer()
# https://github.com/qgis/QGIS/blob/master/src/gui/raster/qgssinglebandpseudocolorrendererwidget.cpp
# Get raster shader
raster_shader = QgsRasterShader()
# Color ramp shader
color_ramp_shader = QgsColorRampShader()
# Loop over Fmask values and add to color item list
color_ramp_item_list = []
for name, value, enable in zip([
'Fmask Cloud', 'Fmask Shadow', 'Fmask Snow', 'Fmask Water',
'Blue Band', 'Cloud QA', 'Aerosol', 'Pixel QA'
], [2, 3, 4, 5, 6, 7, 8, 9], symbology_enabled):
if enable is False:
continue
color = symbology[name]
# Color ramp item - color, label, value
color_ramp_item = QgsColorRampShader.ColorRampItem(
value, QColor(color[0], color[1], color[2], color[3]), name)
color_ramp_item_list.append(color_ramp_item)
# Add the NoData symbology
color_ramp_item_list.append(
QgsColorRampShader.ColorRampItem(255, QColor(70, 70, 70, 255),
"No Data"))
# Add the valid data, no masked
color_ramp_item_list.append(
QgsColorRampShader.ColorRampItem(1, QColor(0, 0, 0, 0), "No Masked"))
# After getting list of color ramp items
color_ramp_shader.setColorRampItemList(color_ramp_item_list)
# Exact color ramp
color_ramp_shader.setColorRampType('EXACT')
# Add color ramp shader to raster shader
raster_shader.setRasterShaderFunction(color_ramp_shader)
# Create color renderer for raster layer
renderer = QgsSingleBandPseudoColorRenderer(rlayer.dataProvider(), 1,
raster_shader)
# Set renderer for raster layer
rlayer.setRenderer(renderer)
# Set NoData transparency to layer qgis (temporal)
if not isinstance(transparent, list):
transparent = [transparent]
nodata = [QgsRasterRange(t, t) for t in transparent]
if nodata:
rlayer.dataProvider().setUserNoDataValue(1, nodata)
# Set NoData transparency to file
#for t in transparent:
# rlayer.dataProvider().setNoDataValue(1, t)
# Repaint
if hasattr(rlayer, 'setCacheImage'):
rlayer.setCacheImage(None)
rlayer.triggerRepaint()
def changeLayerColorMap(self, layerId, colorMap):
layer = QgsMapLayerRegistry.instance().mapLayer(layerId)
provider = layer.dataProvider()
extent = layer.extent()
rampStops = colorMap.stops()
valueList = list()
colorList = list()
valueList.append(0.0)
colorList.append(colorMap.color1())
for item in rampStops:
valueList.append(item.offset)
colorList.append(item.color)
valueList.append(1.0)
colorList.append(colorMap.color2())
stats = provider.bandStatistics(1, QgsRasterBandStats.All, extent, 0)
Max = stats.maximumValue
Min = stats.minimumValue
statRange = Max - Min
valueList = self.add(self.multiply(valueList, statRange), Min)
ramplst = list()
rampItemStr = '<= ' + "%.3f" % valueList[0]
ramplst.append(
QgsColorRampShader.ColorRampItem(valueList[0], colorList[0],
rampItemStr))
for i in range(1, len(valueList)):
rampItemStr = "%.3f" % valueList[i -
1] + ' - ' "%.3f" % valueList[i]
ramplst.append(
QgsColorRampShader.ColorRampItem(valueList[i], colorList[i],
rampItemStr))
myRasterShader = QgsRasterShader()
myColorRamp = QgsColorRampShader()
myColorRamp.setColorRampItemList(ramplst)
if not colorMap.isDiscrete:
myColorRamp.setColorRampType(QgsColorRampShader.DISCRETE)
else:
myColorRamp.setColorRampType(QgsColorRampShader.INTERPOLATED)
myRasterShader.setRasterShaderFunction(myColorRamp)
myPseudoRenderer = QgsSingleBandPseudoColorRenderer(
layer.dataProvider(), layer.type(), myRasterShader)
layer.setRenderer(myPseudoRenderer)
layer.triggerRepaint()
def style_prod_traj_trend(outfile):
# Trends layer
layer_ndvi = iface.addRasterLayer(
outfile,
QtGui.QApplication.translate(
'LDMPPlugin',
'Productivity trajectory trend\n(slope of NDVI * 10000)'))
if not layer_ndvi.isValid():
log('Failed to add layer')
return None
provider = layer_ndvi.dataProvider()
# Set a colormap centred on zero, going to the extreme value significant to
# three figures (after a 2 percent stretch)
ds = gdal.Open(outfile)
band1 = np.array(ds.GetRasterBand(1).ReadAsArray())
band1[band1 >= 9997] = 0
ds = None
cutoffs = np.percentile(band1, [2, 98])
extreme = get_extreme(cutoffs[0], cutoffs[1])
fcn = QgsColorRampShader()
fcn.setColorRampType(QgsColorRampShader.INTERPOLATED)
lst = [
QgsColorRampShader.ColorRampItem(
-extreme, QtGui.QColor(153, 51, 4),
QtGui.QApplication.translate('LDMPPlugin',
'-{} (declining)').format(extreme)),
QgsColorRampShader.ColorRampItem(
0, QtGui.QColor(246, 246, 234),
QtGui.QApplication.translate('LDMPPlugin', '0 (stable)')),
QgsColorRampShader.ColorRampItem(
extreme, QtGui.QColor(0, 140, 121),
QtGui.QApplication.translate('LDMPPlugin',
'{} (increasing)').format(extreme)),
QgsColorRampShader.ColorRampItem(
9997, QtGui.QColor(0, 0, 0),
QtGui.QApplication.translate('LDMPPlugin', 'No data')),
QgsColorRampShader.ColorRampItem(
9998, QtGui.QColor(58, 77, 214),
QtGui.QApplication.translate('LDMPPlugin', 'Water')),
QgsColorRampShader.ColorRampItem(
9999, QtGui.QColor(192, 105, 223),
QtGui.QApplication.translate('LDMPPlugin', 'Urban land cover'))
]
fcn.setColorRampItemList(lst)
shader = QgsRasterShader()
shader.setRasterShaderFunction(fcn)
pseudoRenderer = QgsSingleBandPseudoColorRenderer(
layer_ndvi.dataProvider(), 1, shader)
layer_ndvi.setRenderer(pseudoRenderer)
layer_ndvi.triggerRepaint()
iface.legendInterface().refreshLayerSymbology(layer_ndvi)
def test_setRenderer(self):
myPath = os.path.join(unitTestDataPath('raster'),
'band1_float32_noct_epsg4326.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
layer = QgsRasterLayer(myPath, myBaseName)
self.rendererChanged = False
layer.rendererChanged.connect(self.onRendererChanged)
rShader = QgsRasterShader()
r = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1, rShader)
layer.setRenderer(r)
assert self.rendererChanged
assert layer.renderer() == r
def testSingleBandPseudoColorRenderer_Interpolated(self):
# get min and max of the band to renderer
bandNo = 3
stats = self.raster_layer.dataProvider().bandStatistics(
bandNo, QgsRasterBandStats.Min | QgsRasterBandStats.Max)
minValue = stats.minimumValue
maxValue = stats.maximumValue
# create shader for the renderer
shader = QgsRasterShader(minValue, maxValue)
colorRampShaderFcn = QgsColorRampShader(minValue, maxValue)
colorRampShaderFcn.setColorRampType(QgsColorRampShader.Interpolated)
colorRampShaderFcn.setClassificationMode(QgsColorRampShader.Continuous)
colorRampShaderFcn.setClip(True)
items = []
for index in range(10):
items.append(
QgsColorRampShader.ColorRampItem(
index, QColor('#{0:02d}{0:02d}{0:02d}'.format(index)),
"{}".format(index)))
colorRampShaderFcn.setColorRampItemList(items)
shader.setRasterShaderFunction(colorRampShaderFcn)
# create instance to test
rasterRenderer = QgsSingleBandPseudoColorRenderer(
self.raster_layer.dataProvider(), bandNo, shader)
self.raster_layer.setRenderer(rasterRenderer)
# do test
dom, root = self.rendererToSld(self.raster_layer.renderer())
self.assertNoOpacity(root)
self.assertChannelBand(root, 'sld:GrayChannel', '{}'.format(bandNo))
# check ColorMapEntry classes
colorMap = root.elementsByTagName('sld:ColorMap')
colorMap = colorMap.item(0).toElement()
self.assertFalse(colorMap.isNull())
self.assertEqual(colorMap.attribute('type'), 'ramp')
colorMapEntries = colorMap.elementsByTagName('sld:ColorMapEntry')
self.assertEqual(colorMapEntries.count(), 10)
for index in range(colorMapEntries.count()):
colorMapEntry = colorMapEntries.at(index).toElement()
self.assertEqual(colorMapEntry.attribute('quantity'),
'{}'.format(index))
self.assertEqual(colorMapEntry.attribute('label'),
'{}'.format(index))
self.assertEqual(colorMapEntry.attribute('opacity'), '')
self.assertEqual(colorMapEntry.attribute('color'),
'#{0:02d}{0:02d}{0:02d}'.format(index))
def loadLabelImage(imagepath, labeldescriptor = None):
"""
Load a labeled single band raster in the canvas
Keyword arguments:
imagepath -- the path to the image
labeldescriptor -- a dictionnary for label (int) to tuple (QColor, QString) conversion
"""
if imagepath is None:
return
name = os.path.splitext( os.path.basename(imagepath) )[0]
qgslayer = QgsRasterLayer(imagepath, name)
if not qgslayer.isValid():
QtGui.QMessageBox.critical(None,
u"Erreur",
u"Impossible de charger la couche %s" % unicode(imagepath))
QgsMapLayerRegistry.instance().addMapLayer(qgslayer)
qgslayer.setDrawingStyle('SingleBandPseudoColor')
colorlist = []
max_label = 0
for label in sorted(labeldescriptor.keys()):
color = labeldescriptor[label][0]
labeltxt = labeldescriptor[label][1]
colorlist.append(QgsColorRampShader.ColorRampItem(label, color, labeltxt))
if labeltxt > max_label:
max_label = labeltxt
s = QgsRasterShader()
c = QgsColorRampShader()
c.setColorRampType(QgsColorRampShader.INTERPOLATED)
c.setColorRampItemList(colorlist)
s.setRasterShaderFunction(c)
ps = QgsSingleBandPseudoColorRenderer(qgslayer.dataProvider(), 1, s)
qgslayer.setRenderer(ps)
for bandNo in range(1,qgslayer.dataProvider().bandCount()+1):
qgslayer.dataProvider().setUseSrcNoDataValue( bandNo, False )
QGisLayers.iface.legendInterface().refreshLayerSymbology(qgslayer)
if hasattr(qgslayer, "setCacheImage"):
qgslayer.setCacheImage(None)
qgslayer.triggerRepaint()
def displaced_people_style(layer):
"""Simple style to display a displaced count with a binary style.
:param layer: The layer to style.
:type layer: QgsRasterLayer
"""
color_ramp = QgsColorRampShader()
color_ramp.setColorRampType(QgsColorRampShader.INTERPOLATED)
color_ramp.setColorRampItemList(legend_raster_displaced)
shader = QgsRasterShader()
shader.setRasterShaderFunction(color_ramp)
renderer = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1,
shader)
layer.setRenderer(renderer)
def setRasterStyle(self, raster_layer):
shaderType = QgsColorRampShader()
shaderType.setColorRampType(QgsColorRampShader.Discrete)
item_list = []
item_list.append(
QgsColorRampShader.ColorRampItem(1,
QColor(0, 0, 0, 0),
lbl="Sem visada"))
item_list.append(
QgsColorRampShader.ColorRampItem(1,
QColor(0, 255, 0),
lbl="Visível"))
shaderType.setColorRampItemList(item_list)
shader = QgsRasterShader()
shader.setRasterShaderFunction(shaderType)
renderer = QgsSingleBandPseudoColorRenderer(
raster_layer.dataProvider(), 1, shader)
raster_layer.setRenderer(renderer)
def setRasterStyle(self, raster_layer, layer_values):
shaderType = QgsColorRampShader()
shaderType.setColorRampType(QgsColorRampShader.Discrete)
item_list = []
j = 1
for i in list(layer_values.getFeatures()):
color_temp = QColor(0, 0, 0)
color_temp.setHsvF(j / layer_values.featureCount(), 1, 1)
item_list.append(
QgsColorRampShader.ColorRampItem(i[3],
color_temp,
lbl=str(i[0])))
j += 1
shaderType.setColorRampItemList(item_list)
shader = QgsRasterShader()
shader.setRasterShaderFunction(shaderType)
renderer = QgsSingleBandPseudoColorRenderer(
raster_layer.dataProvider(), 1, shader)
raster_layer.setRenderer(renderer)
def save_pointwise_deficit_as_raster(self, iface, points_grid,
end_date_index, save_file_path,
layer_name):
cols = len(points_grid[0])
rows = len(points_grid)
originX = points_grid[0][0].qgsPoint.x()
originY = points_grid[0][0].qgsPoint.y() #top-left
driver = gdal.GetDriverByName('GTiff')
outRaster = driver.Create(save_file_path, cols, rows, 1, gdal.GDT_Byte)
outRaster.SetGeoTransform((originX, STEP, 0, originY, 0, STEP))
outband = outRaster.GetRasterBand(1)
deficit_values_array = np.array([[
p.budget.PET_minus_AET_till_date[end_date_index]
if not p.is_no_evaluation_point else -9999 for p in p_row
] for p_row in points_grid])
max_deficit = np.max(deficit_values_array)
outband.WriteArray(deficit_values_array)
outRasterSRS = osr.SpatialReference()
outRasterSRS.ImportFromEPSG(32643)
outRaster.SetProjection(outRasterSRS.ExportToWkt())
outband.FlushCache()
layer = iface.addRasterLayer(
save_file_path,
layer_name + '_max_deficit_' + str(int(max_deficit)))
layer.dataProvider().setNoDataValue(1, -9999)
fcn = QgsColorRampShader()
fcn.setColorRampType(QgsColorRampShader.INTERPOLATED)
lst = [
QgsColorRampShader.ColorRampItem(0, QColor(240, 240, 240)),
QgsColorRampShader.ColorRampItem(max_deficit, QColor(255, 0, 0))
]
fcn.setColorRampItemList(lst)
shader = QgsRasterShader()
shader.setRasterShaderFunction(fcn)
renderer = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1,
shader)
layer.setRenderer(renderer)
layer.triggerRepaint()
def style_sdg_ld(outfile):
# Significance layer
layer = iface.addRasterLayer(outfile, QtGui.QApplication.translate('LDMPPlugin', 'Degradation (SDG 15.3 - without soil carbon)'))
if not layer.isValid():
log('Failed to add layer')
return None
fcn = QgsColorRampShader()
fcn.setColorRampType(QgsColorRampShader.EXACT)
lst = [QgsColorRampShader.ColorRampItem(-1, QtGui.QColor(153, 51, 4), QtGui.QApplication.translate('LDMPPlugin', 'Degradation')),
QgsColorRampShader.ColorRampItem(0, QtGui.QColor(246, 246, 234), QtGui.QApplication.translate('LDMPPlugin', 'Stable')),
QgsColorRampShader.ColorRampItem(1, QtGui.QColor(0, 140, 121), QtGui.QApplication.translate('LDMPPlugin', 'Improvement')),
QgsColorRampShader.ColorRampItem(2, QtGui.QColor(58, 77, 214), QtGui.QApplication.translate('LDMPPlugin', 'Water')),
QgsColorRampShader.ColorRampItem(3, QtGui.QColor(192, 105, 223), QtGui.QApplication.translate('LDMPPlugin', 'Urban land cover'))]
fcn.setColorRampItemList(lst)
shader = QgsRasterShader()
shader.setRasterShaderFunction(fcn)
pseudoRenderer = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1, shader)
layer.setRenderer(pseudoRenderer)
layer.triggerRepaint()
iface.legendInterface().refreshLayerSymbology(layer)
def runFilter(iface, dlg, conf, dir_dest, rasterSeuilName, rasterFilterName):
# Passage des parametres pour le filtrage
layer = filterRaster(dlg, conf, dir_dest, rasterSeuilName,
rasterFilterName)
if layer != None:
# Informations de style
canvas = iface.mapCanvas()
QgsProject.instance().addMapLayer(layer)
fcn = QgsColorRampShader()
fcn.setColorRampType(QgsColorRampShader.Type.Exact)
lst = [
QgsColorRampShader.ColorRampItem(1, QColor(QColor(255, 177, 67)))
]
fcn.setColorRampItemList(lst)
shader = QgsRasterShader()
shader.setRasterShaderFunction(fcn)
renderer = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1,
shader)
if renderer:
layer.setRenderer(renderer)
if layer.renderer():
layer.renderer().setOpacity(0.5)
layer.triggerRepaint()
setLayerVisible(layer, True)
canvas.refresh()
messInfo(
dlg,
"---> Lancez 'Filtrer' (fonction du radius choisi) pour appliquer un nouveau filtrage ou 'Vectoriser' pour poursuivre le traitement. <---"
)
messInfo(dlg, "")
QMessageBox.information(None, "Traitement de filtrage",
" Filtrage terminé. ", QMessageBox.Ok,
QMessageBox.NoButton)
return
def set_color_heatmap_symbology(layer: QgsRasterLayer, color: QtGui.QColor):
provider = layer.dataProvider()
renderer = layer.renderer()
color_ramp_items = __get_color_ramp_items(renderer, provider, color)
color_ramp = QgsColorRampShader()
color_ramp.setColorRampItemList(color_ramp_items)
color_ramp.setColorRampType(QgsColorRampShader.Interpolated)
raster_shader = QgsRasterShader()
raster_shader.setRasterShaderFunction(color_ramp)
renderer = QgsSingleBandPseudoColorRenderer(
layer.dataProvider(),
layer.type(),
raster_shader
)
layer.setBlendMode(QPainter.CompositionMode_Multiply)
layer.setRenderer(renderer)
def apply_symbology(rlayer, symbology, transparent=None):
""" Apply classification symbology to raster layer """
# See: QgsRasterRenderer* QgsSingleBandPseudoColorRendererWidget::renderer()
# https://github.com/qgis/QGIS/blob/master/src/gui/raster/qgssinglebandpseudocolorrendererwidget.cpp
# Get raster shader
raster_shader = QgsRasterShader()
# Color ramp shader
color_ramp_shader = QgsColorRampShader()
# Loop over Fmask values and add to color item list
color_ramp_item_list = []
for name, value, color in symbology:
# Color ramp item - color, label, value
color_ramp_item = QgsColorRampShader.ColorRampItem(
value, QColor(color[0], color[1], color[2], color[3]), name)
color_ramp_item_list.append(color_ramp_item)
# After getting list of color ramp items
color_ramp_shader.setColorRampItemList(color_ramp_item_list)
# Exact color ramp
color_ramp_shader.setColorRampType('EXACT')
# Add color ramp shader to raster shader
raster_shader.setRasterShaderFunction(color_ramp_shader)
# Create color renderer for raster layer
renderer = QgsSingleBandPseudoColorRenderer(rlayer.dataProvider(), 1,
raster_shader)
# Set renderer for raster layer
rlayer.setRenderer(renderer)
# Set NoData transparency to layer qgis (temporal)
if transparent is not None:
if not isinstance(transparent, list):
transparent = [transparent]
nodata = [QgsRasterRange(t, t) for t in transparent]
if nodata:
rlayer.dataProvider().setUserNoDataValue(1, nodata)
# Repaint
if hasattr(rlayer, 'setCacheImage'):
rlayer.setCacheImage(None)
rlayer.triggerRepaint()
def setStyle(self, layer):
provider = layer.dataProvider()
extent = layer.extent()
stats = provider.bandStatistics(1, QgsRasterBandStats.All, extent, 0)
if stats.minimumValue < 0:
min = 0
else:
min = stats.minimumValue
max = stats.maximumValue
range = max - min
add = range // 2
interval = min + add
colDic = {'red': '#ff0000', 'yellow': '#ffff00', 'blue': '#0000ff'}
valueList = [min, interval, max]
lst = [QgsColorRampShader.ColorRampItem(valueList[0], QColor(colDic['red'])),
QgsColorRampShader.ColorRampItem(valueList[1], QColor(colDic['yellow'])),
QgsColorRampShader.ColorRampItem(valueList[2], QColor(colDic['blue']))]
myRasterShader = QgsRasterShader()
myColorRamp = QgsColorRampShader()
myColorRamp.setColorRampItemList(lst)
myColorRamp.setColorRampType(QgsColorRampShader.INTERPOLATED)
# TODO: add classificationMode=Continuos
# myColorRamp.setClassificationMode(QgsColorRampShader.ClassificationMode(1))
# AttributeError: type object 'QgsColorRampShader' has no attribute 'setClassificationMode'
myRasterShader.setRasterShaderFunction(myColorRamp)
myPseudoRenderer = QgsSingleBandPseudoColorRenderer(layer.dataProvider(),
layer.type(),
myRasterShader)
layer.setRenderer(myPseudoRenderer)
layer.triggerRepaint()
def style_prod_traj_signif(outfile):
# Significance layer
layer_signif = iface.addRasterLayer(
outfile,
QtGui.QApplication.translate(
'LDMPPlugin', 'Productivity trajectory trend (significance)'))
if not layer_signif.isValid():
log('Failed to add layer')
return None
fcn = QgsColorRampShader()
fcn.setColorRampType(QgsColorRampShader.EXACT)
lst = [
QgsColorRampShader.ColorRampItem(
-1, QtGui.QColor(153, 51, 4),
QtGui.QApplication.translate('LDMPPlugin',
'Significant decrease')),
QgsColorRampShader.ColorRampItem(
0, QtGui.QColor(246, 246, 234),
QtGui.QApplication.translate('LDMPPlugin',
'No significant change')),
QgsColorRampShader.ColorRampItem(
1, QtGui.QColor(0, 140, 121),
QtGui.QApplication.translate('LDMPPlugin',
'Significant increase')),
QgsColorRampShader.ColorRampItem(
2, QtGui.QColor(58, 77, 214),
QtGui.QApplication.translate('LDMPPlugin', 'Water')),
QgsColorRampShader.ColorRampItem(
3, QtGui.QColor(192, 105, 223),
QtGui.QApplication.translate('LDMPPlugin', 'Urban land cover'))
]
fcn.setColorRampItemList(lst)
shader = QgsRasterShader()
shader.setRasterShaderFunction(fcn)
pseudoRenderer = QgsSingleBandPseudoColorRenderer(
layer_signif.dataProvider(), 2, shader)
layer_signif.setRenderer(pseudoRenderer)
layer_signif.triggerRepaint()
iface.legendInterface().refreshLayerSymbology(layer_signif)
def getRenderer(self, layer_data_provider, color_map):
"""
Get QgsSingleBandPseudoColorRenderer for NDVI display.
:param layer_data_provider: layer data provider
:type: QgsDataProvider
:param color_map: color list
:type: [ColorRampItem...]
:return: QgsSingleBandPseudoColorRenderer
"""
self.LOGGER.debug("getting renderer")
raster_shader = QgsRasterShader()
color_ramp_shader = QgsColorRampShader()
color_ramp_shader.setColorRampType(QgsColorRampShader.DISCRETE)
color_ramp_shader.setColorRampItemList(color_map)
raster_shader.setRasterShaderFunction(color_ramp_shader)
return QgsSingleBandPseudoColorRenderer(layer_data_provider, 1, raster_shader)
