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 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 testCreateColorRamp(self):
shader = QgsColorRampShader(1, 3)
item1 = QgsColorRampShader.ColorRampItem(1, QColor(255, 0, 0))
item2 = QgsColorRampShader.ColorRampItem(2, QColor(255, 255, 0))
item3 = QgsColorRampShader.ColorRampItem(3, QColor(255, 255, 255))
shader.setColorRampItemList([item1, item2, item3])
shaderRamp = shader.createColorRamp()
gradientRamp = QgsGradientColorRamp(
QColor(255, 0, 0), QColor(255, 255, 255), False,
[QgsGradientStop(0.5, QColor(255, 255, 0))])
self.assertEqual(shaderRamp.color1(), gradientRamp.color1())
self.assertEqual(shaderRamp.color2(), gradientRamp.color2())
self.assertEqual(shaderRamp.stops(), gradientRamp.stops())
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 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 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 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 style_land_cover_land_deg(outfile):
layer_deg = iface.addRasterLayer(outfile, 'Land cover (degradation)')
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),
'Degradation'),
QgsColorRampShader.ColorRampItem(0, QtGui.QColor(246, 246, 234),
'Stable'),
QgsColorRampShader.ColorRampItem(1, QtGui.QColor(0, 140, 121),
'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 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_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 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 colormap(self):
self.project.read('C:/Users/william/Documents/Qgis/example.qgs')
#project = QgsProject.instance()
path_to_tif = os.path.join(QgsProject.instance().homePath(),
"qgis_sample_data", "raster",
"SR_50M_alaska_nad.TIF")
self.rlayer = QgsRasterLayer(path_to_tif)
fcn = QgsColorRampShader()
fcn.setColorRampType(QgsColorRampShader.Interpolated)
lst = [
QgsColorRampShader.ColorRampItem(0, QColor(0, 25, 25)),
QgsColorRampShader.ColorRampItem(255, QColor(255, 255, 0))
]
fcn.setColorRampItemList(lst)
shader = QgsRasterShader()
shader.setRasterShaderFunction(fcn)
renderer = QgsSingleBandPseudoColorRenderer(self.rlayer.dataProvider(),
1, shader)
self.rlayer.setRenderer(renderer)
QgsProject.instance().addMapLayer(self.rlayer)
QgsProject.instance().layerTreeRoot()
QMessageBox.information(None, 'Example:', 'Colormap is loaded!')
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 categoraize_raster_layer(self, layer=None, layer_name=None):
"""
"""
if not layer:
layer = self.get_layer_by_name(layer_name)
if not layer:
return
fnc = QgsColorRampShader()
fnc.setColorRampType(QgsColorRampShader.Discrete)
fnc.setColorRampItemList([
QgsColorRampShader.ColorRampItem(0, QColor(0, 0, 0, 0), '-'),
QgsColorRampShader.ColorRampItem(1, QColor(187, 187, 187), '1 - Cloud'),
QgsColorRampShader.ColorRampItem(2, QColor(255, 255, 26), '2 - Subsurface'),
QgsColorRampShader.ColorRampItem(3, QColor(247, 126, 60), '3 - Surface'),
QgsColorRampShader.ColorRampItem(4, QColor(0, 0, 0), '4 - NoData')
])
shader = QgsRasterShader()
shader.setRasterShaderFunction(fnc)
renderer = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 1, shader)
layer.setRenderer(renderer)
def render(self):
t_0 = self.dlg.threshold_0_slider.value() / (10.0**self.precision)
t_1 = self.dlg.threshold_1_slider.value() / (10.0**self.precision)
t_2 = self.dlg.threshold_2_slider.value() / (10.0**self.precision)
base = self.dlg.base_slider.value() / (10.0**self.precision)
lst = [
QgsColorRampShader.ColorRampItem(t_0 - base, self.CLEAR),
QgsColorRampShader.ColorRampItem(t_0, self.t_0_COLOR),
QgsColorRampShader.ColorRampItem(t_1, self.t_1_COLOR),
QgsColorRampShader.ColorRampItem(t_2, self.t_2_COLOR),
]
self.fcn = QgsColorRampShader()
self.fcn.setColorRampType(QgsColorRampShader.Interpolated)
self.fcn.setColorRampItemList(lst)
self.shader = QgsRasterShader()
self.shader.setRasterShaderFunction(self.fcn)
self.renderer = QgsSingleBandPseudoColorRenderer(
self.layer.dataProvider(), 1, self.shader)
self.layer.setRenderer(self.renderer)
self.layer.triggerRepaint()
def style_prod_state_init(outfile):
# Significance layer
layer = iface.addRasterLayer(
outfile,
QtGui.QApplication.translate('LDMPPlugin',
'Productivity state (initial)'))
if not layer.isValid():
return None
fcn = QgsColorRampShader()
fcn.setColorRampType(QgsColorRampShader.EXACT)
lst = [
QgsColorRampShader.ColorRampItem(
-2, QtGui.QColor(0, 0, 0),
QtGui.QApplication.translate('LDMPPlugin', 'No data')),
QgsColorRampShader.ColorRampItem(
-1, QtGui.QColor(153, 51, 4),
QtGui.QApplication.translate('LDMPPlugin',
'Potentially degraded')),
QgsColorRampShader.ColorRampItem(
0, QtGui.QColor(246, 246, 234),
QtGui.QApplication.translate('LDMPPlugin', 'Stable')),
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 style_prod_perf(outfile):
layer_perf = iface.addRasterLayer(
outfile,
QtGui.QApplication.translate('LDMPPlugin',
'Productivity performance (degradation)'))
if not layer_perf.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')),
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_perf.dataProvider(), 1, shader)
layer_perf.setRenderer(pseudoRenderer)
layer_perf.triggerRepaint()
iface.legendInterface().refreshLayerSymbology(layer_perf)
def testShaderCrash(self):
"""Check if we assign a shader and then reassign it no crash occurs."""
myPath = os.path.abspath(
os.path.join(__file__, '..', '..', '..', 'testdata', '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, QtGui.QColor('#ffff00'),
'foo')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(100, QtGui.QColor('#ff00ff'),
'bar')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(1000,
QtGui.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, QtGui.QColor('#ffff00'),
'foo')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(100, QtGui.QColor('#ff00ff'),
'bar')
myItems.append(myItem)
myItem = QgsColorRampShader.ColorRampItem(1000,
QtGui.QColor('#00ff00'),
'kazam')
myItems.append(myItem)
myColorRampShader.setColorRampItemList(myItems)
myRasterShader.setRasterShaderFunction(myColorRampShader)
######## crash on next line ##################
myPseudoRenderer = QgsSingleBandPseudoColorRenderer(
myRasterLayer.dataProvider(), 1, myRasterShader)
myRasterLayer.setRenderer(myPseudoRenderer)
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 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 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 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 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 setLayerSymbology(layer, qmlFilename):
styleFilepath = os.path.dirname(__file__) + os.sep + 'styles' + os.sep + qmlFilename
layer.loadNamedStyle(styleFilepath)
# getting statistics from the layer
stats = layer.dataProvider().bandStatistics(1, QgsRasterBandStats.All, layer.extent())
min = stats.minimumValue
max = stats.maximumValue
# adjusting the symbology to equal intervals from the
renderer = layer.renderer()
shader = renderer.shader()
colorRampShader = shader.rasterShaderFunction()
if type(colorRampShader) is QgsColorRampShader:
colorRampItemList = colorRampShader.colorRampItemList()
nbClasses = len(colorRampItemList)
newColorRampList = []
for i in range(0,nbClasses):
val = min + (i*(max-min)/(nbClasses-1))
item = QgsColorRampShader.ColorRampItem(val, (colorRampItemList[i]).color, str(val))
newColorRampList.append(item)
colorRampShader.setColorRampItemList(newColorRampList)
layer.triggerRepaint()
def style_land_cover_lc_baseline(outfile):
layer_lc_baseline = iface.addRasterLayer(
outfile,
QtGui.QApplication.translate('LDMPPlugin', 'Land cover (baseline)'))
if not layer_lc_baseline.isValid():
log('Failed to add layer')
return None
fcn = QgsColorRampShader()
fcn.setColorRampType(QgsColorRampShader.EXACT)
lst = [
QgsColorRampShader.ColorRampItem(
1, QtGui.QColor('#a50f15'),
QtGui.QApplication.translate('LDMPPlugin', 'Cropland')),
QgsColorRampShader.ColorRampItem(
2, QtGui.QColor('#006d2c'),
QtGui.QApplication.translate('LDMPPlugin', 'Forest land')),
QgsColorRampShader.ColorRampItem(
3, QtGui.QColor('#d8d800'),
QtGui.QApplication.translate('LDMPPlugin', 'Grassland')),
QgsColorRampShader.ColorRampItem(
4, QtGui.QColor('#08519c'),
QtGui.QApplication.translate('LDMPPlugin', 'Wetlands')),
QgsColorRampShader.ColorRampItem(
5, QtGui.QColor('#54278f'),
QtGui.QApplication.translate('LDMPPlugin', 'Settlements')),
QgsColorRampShader.ColorRampItem(
6, QtGui.QColor('#252525'),
QtGui.QApplication.translate('LDMPPlugin', 'Other land'))
]
fcn.setColorRampItemList(lst)
shader = QgsRasterShader()
shader.setRasterShaderFunction(fcn)
pseudoRenderer = QgsSingleBandPseudoColorRenderer(
layer_lc_baseline.dataProvider(), 1, shader)
layer_lc_baseline.setRenderer(pseudoRenderer)
layer_lc_baseline.triggerRepaint()
iface.legendInterface().refreshLayerSymbology(layer_lc_baseline)
MMI_2 = QColor('#209fff')
MMI_3 = QColor('#00cfff')
MMI_4 = QColor('#55ffff')
MMI_5 = QColor('#aaffff')
MMI_6 = QColor('#fff000')
MMI_7 = QColor('#ffa800')
MMI_8 = QColor('#ff7000')
MMI_9 = QColor('#ff0000')
MMI_10 = QColor('#dd0000')
MMI_11 = QColor('#880000')
MMI_12 = QColor('#440000')
# Displaced people raster after an EQ raster. The first item is the value in
# the raster.
legend_raster_displaced = [
QgsColorRampShader.ColorRampItem(0, transparent, tr('Not Displaced')),
QgsColorRampShader.ColorRampItem(1, QColor('#a53c12'), tr('Displaced')),
]
# Colors used in reporting.
affected_column_background = QColor('#fff8e9')
charcoal_black = QColor('#36454F')
# Map legend templates according to standards :
# https://github.com/inasafe/inasafe/issues/3653#issuecomment-275011957
# The space between count and exposure_unit will be automatically added if
# the unit is not empty.
template_without_thresholds = u'{name} ({count}{exposure_unit})'
template_with_maximum_thresholds = (
u'{name} <= {max} {hazard_unit} ({count}{exposure_unit})')
template_with_minimum_thresholds = (
def cvt_vtr(self):
QSWATMOD_path_dict = self.dirs_and_paths()
selectedVector = self.dlg.comboBox_vector_lyrs.currentText()
layer = QgsProject.instance().mapLayersByName(str(selectedVector))[0]
# Find .dis file and read number of rows, cols, x spacing, and y spacing (not allowed to change)
for filename in glob.glob(str(QSWATMOD_path_dict['SMfolder']) + "/*.dis"):
with open(filename, "r") as f:
data = []
for line in f.readlines():
if not line.startswith("#"):
data.append(line.replace('\n', '').split())
nrow = int(data[0][1])
ncol = int(data[0][2])
delr = float(data[2][1]) # is the cell width along rows (y spacing)
delc = float(
data[3][1]) # is the cell width along columns (x spacing).
# get extent
ext = layer.extent()
xmin = ext.xMinimum()
xmax = ext.xMaximum()
ymin = ext.yMinimum()
ymax = ext.yMaximum()
extent = "{a},{b},{c},{d}".format(a=xmin, b=xmax, c=ymin, d=ymax)
fdnames = [
field.name() for field in layer.dataProvider().fields()
if not (field.name() == 'fid' or field.name() == 'id'
or field.name() == 'xmin' or field.name() == 'xmax'
or field.name() == 'ymin' or field.name() == 'ymax'
or field.name() == 'grid_id' or field.name() == 'row'
or field.name() == 'col' or field.name() == 'elev_mf')
]
# Create swatmf_results tree inside
root = QgsProject.instance().layerTreeRoot()
if root.findGroup("swatmf_results"):
swatmf_results = root.findGroup("swatmf_results")
else:
swatmf_results = root.insertGroup(0, "swatmf_results")
if root.findGroup(selectedVector):
rastergroup = root.findGroup(selectedVector)
else:
rastergroup = swatmf_results.insertGroup(0, selectedVector)
per = 0
self.dlg.progressBar_cvt_vtr.setValue(0)
for fdnam in fdnames:
QCoreApplication.processEvents()
nodata = float(self.dlg.lineEdit_nodata.text())
mincolor = self.dlg.mColorButton_min_rmap.color().name()
maxcolor = self.dlg.mColorButton_max_rmap.color().name()
name = fdnam
name_ext = "{}.tif".format(name)
output_dir = QSWATMOD_path_dict['SMshps']
# create folder for each layer output
rasterpath = os.path.join(output_dir, selectedVector)
if not os.path.exists(rasterpath):
os.makedirs(rasterpath)
output_raster = os.path.join(rasterpath, name_ext)
params = {
'INPUT': layer,
'FIELD': fdnam,
'UNITS': 1,
'WIDTH': delc,
'HEIGHT': delr,
'EXTENT': extent,
'NODATA': nodata,
'DATA_TYPE': 5, #Float32
'OUTPUT': output_raster
}
processing.run("gdal:rasterize", params)
rasterlayer = QgsRasterLayer(output_raster,
'{0} ({1})'.format(fdnam, selectedVector))
QgsProject.instance().addMapLayer(rasterlayer, False)
rastergroup.insertChildNode(0, QgsLayerTreeLayer(rasterlayer))
stats = rasterlayer.dataProvider().bandStatistics(
1, QgsRasterBandStats.All)
rmin = stats.minimumValue
rmax = stats.maximumValue
fnc = QgsColorRampShader()
lst = [
QgsColorRampShader.ColorRampItem(rmin, QColor(mincolor)),
QgsColorRampShader.ColorRampItem(rmax, QColor(maxcolor))
]
fnc.setColorRampItemList(lst)
fnc.setColorRampType(QgsColorRampShader.Interpolated)
shader = QgsRasterShader()
shader.setRasterShaderFunction(fnc)
renderer = QgsSingleBandPseudoColorRenderer(rasterlayer.dataProvider(),
1, shader)
rasterlayer.setRenderer(renderer)
rasterlayer.triggerRepaint()
# create image
img = QImage(QSize(800, 800), QImage.Format_ARGB32_Premultiplied)
# set background color
# bcolor = QColor(255, 255, 255, 255)
bcolor = QColor(255, 255, 255, 0)
img.fill(bcolor.rgba())
# create painter
p = QPainter()
p.begin(img)
p.setRenderHint(QPainter.Antialiasing)
# create map settings
ms = QgsMapSettings()
ms.setBackgroundColor(bcolor)
# set layers to render
flayer = QgsProject.instance().mapLayersByName(rasterlayer.name())
ms.setLayers([flayer[0]])
# set extent
rect = QgsRectangle(ms.fullExtent())
rect.scale(1.1)
ms.setExtent(rect)
# set ouptut size
ms.setOutputSize(img.size())
# setup qgis map renderer
render = QgsMapRendererCustomPainterJob(ms, p)
render.start()
render.waitForFinished()
# get timestamp
p.drawImage(QPoint(), img)
pen = QPen(Qt.red)
pen.setWidth(2)
p.setPen(pen)
font = QFont()
font.setFamily('Times')
# font.setBold(True)
font.setPointSize(18)
p.setFont(font)
# p.setBackground(QColor('sea green')) doesn't work
p.drawText(QRect(0, 0, 800, 800), Qt.AlignRight | Qt.AlignBottom,
fdnam)
p.end()
# save the image
img.save(os.path.join(rasterpath, '{:03d}_{}.jpg'.format(per, fdnam)))
# Update progress bar
per += 1
progress = round((per / len(fdnames)) * 100)
self.dlg.progressBar_cvt_vtr.setValue(progress)
QCoreApplication.processEvents()
self.dlg.raise_()
duration = self.dlg.doubleSpinBox_ani_r_time.value()
# filepaths
fp_in = os.path.join(rasterpath, '*.jpg')
fp_out = os.path.join(rasterpath, '{}.gif'.format(selectedVector))
# https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#gif
fimg, *fimgs = [Image.open(f) for f in sorted(glob.glob(fp_in))]
fimg.save(fp=fp_out,
format='GIF',
append_images=fimgs,
save_all=True,
duration=duration * 1000,
loop=0,
transparency=0)
msgBox = QMessageBox()
msgBox.setWindowIcon(QtGui.QIcon(':/QSWATMOD2/pics/sm_icon.png'))
msgBox.setWindowTitle("Coverted!")
msgBox.setText(
"Fields from {} were converted successfully!".format(selectedVector))
msgBox.exec_()
questionBox = QMessageBox()
questionBox.setWindowIcon(QtGui.QIcon(':/QSWATMOD2/pics/sm_icon.png'))
reply = QMessageBox.question(questionBox, 'Open?',
'Do you want to open the animated gif file?',
QMessageBox.Yes, QMessageBox.No)
if reply == QMessageBox.Yes:
os.startfile(os.path.join(rasterpath, '{}.gif'.format(selectedVector)))
def styleRaster(filename):
# Create outfile name
outfile = "".join(filename.strip().split('.raw'))
# Open layer from filename
rasterfile = filename.strip().split('/')[-1]
rasterlayer = rasterfile.split('.')[0]
rlayer = QgsRasterLayer(filename, rasterlayer, 'gdal')
# Check if layer is valid
if rlayer.isValid() is True:
# Get layer data provider
provider = rlayer.dataProvider()
# Calculate histrogram
provider.initHistogram(QgsRasterHistogram(), 1, 100)
hist = provider.histogram(1)
# Get histograms stats
nbins = hist.binCount
minv = hist.minimum
maxv = hist.maximum
# Create histogram array, bin array, and histogram index
hista = np.array(hist.histogramVector)
bins = np.arange(minv, maxv, (maxv - minv) / nbins)
index = np.where(hista > 5)
# Get bottom and top color values from bin values
bottomcolor = bins[index[0][0]]
topcolor = bins[index[0][-1]]
# Calculate range value between the bottom and top color values
if bottomcolor < 0:
vrange = topcolor + bottomcolor
else:
vrange = topcolor - bottomcolor
# Calculate values for bottom middle, and top middle color values
if rasterlayer == 'maxele':
bottommiddle = vrange * 0.3333
topmiddle = vrange * 0.6667
else:
bottommiddle = vrange * 0.375
topmiddle = vrange * 0.75
# Create list of color values
valueList = [bottomcolor, bottommiddle, topmiddle, topcolor]
# Create color dictionary
if rasterlayer == 'maxele':
colDic = {
'bottomcolor': '#0000ff',
'bottommiddle': '#00ffff',
'topmiddle': '#ffff00',
'topcolor': '#ff0000'
}
else:
colDic = {
'bottomcolor': '#000000',
'bottommiddle': '#ff0000',
'topmiddle': '#ffff00',
'topcolor': '#ffffff'
}
# Create color ramp function and add colors
fnc = QgsColorRampShader()
fnc.setColorRampType(QgsColorRampShader.Interpolated)
lst = [QgsColorRampShader.ColorRampItem(valueList[0], QColor(colDic['bottomcolor'])),\
QgsColorRampShader.ColorRampItem(valueList[1], QColor(colDic['bottommiddle'])), \
QgsColorRampShader.ColorRampItem(valueList[2], QColor(colDic['topmiddle'])), \
QgsColorRampShader.ColorRampItem(valueList[3], QColor(colDic['topcolor']))]
fnc.setColorRampItemList(lst)
# Create raster shader and add color ramp function
shader = QgsRasterShader()
shader.setRasterShaderFunction(fnc)
# Create color render and set opacity
renderer = QgsSingleBandPseudoColorRenderer(provider, 1, shader)
renderer.setOpacity(0.75)
# Get output format
output_format = QgsRasterFileWriter.driverForExtension(
os.path.splitext(outfile)[1])
# Open output file for writing
rfw = QgsRasterFileWriter(outfile)
rfw.setOutputProviderKey('gdal')
rfw.setOutputFormat(output_format)
# Add EPSG 4326 to layer crs
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(4326)
# Create Raster pipe and set provider and renderer
pipe = QgsRasterPipe()
pipe.set(provider.clone())
pipe.set(renderer.clone())
# Get transform context
transform_context = QgsProject.instance().transformContext()
# Write to file
rfw.writeRaster(pipe, provider.xSize(), provider.ySize(),
provider.extent(), crs, transform_context)
logger.info(
'Conveted data in ' + rasterfile +
' from float64 to 8bit, added color palette and saved to tiff (' +
outfile.split('/')[-1] + ') file')
if not rlayer.isValid():
raise Exception('Invalid raster')
return (valueList)
