def testNan(self): shader = QgsColorRampShader() item1 = QgsColorRampShader.ColorRampItem(1, QColor(0, 0, 0)) item2 = QgsColorRampShader.ColorRampItem(2, QColor(255, 255, 255)) shader.setColorRampItemList([item1, item2]) self.assertFalse(shader.shade(float('NaN'))[0]) self.assertFalse(shader.shade(float("inf"))[0])
def testBasic(self): renderer = QgsPointCloudAttributeByRampRenderer() renderer.setAttribute('attr') self.assertEqual(renderer.attribute(), 'attr') renderer.setMinimum(5) self.assertEqual(renderer.minimum(), 5) renderer.setMaximum(15) self.assertEqual(renderer.maximum(), 15) ramp = QgsStyle.defaultStyle().colorRamp("Viridis") shader = QgsColorRampShader(20, 30, ramp) renderer.setColorRampShader(shader) self.assertEqual(renderer.colorRampShader().minimumValue(), 20) self.assertEqual(renderer.colorRampShader().maximumValue(), 30) renderer.setMaximumScreenError(18) renderer.setMaximumScreenErrorUnit(QgsUnitTypes.RenderInches) renderer.setPointSize(13) renderer.setPointSizeUnit(QgsUnitTypes.RenderPoints) renderer.setPointSizeMapUnitScale(QgsMapUnitScale(1000, 2000)) rr = renderer.clone() self.assertEqual(rr.maximumScreenError(), 18) self.assertEqual(rr.maximumScreenErrorUnit(), QgsUnitTypes.RenderInches) self.assertEqual(rr.pointSize(), 13) self.assertEqual(rr.pointSizeUnit(), QgsUnitTypes.RenderPoints) self.assertEqual(rr.pointSizeMapUnitScale().minScale, 1000) self.assertEqual(rr.pointSizeMapUnitScale().maxScale, 2000) self.assertEqual(rr.attribute(), 'attr') self.assertEqual(rr.minimum(), 5) self.assertEqual(rr.maximum(), 15) self.assertEqual(rr.colorRampShader().minimumValue(), 20) self.assertEqual(rr.colorRampShader().maximumValue(), 30) self.assertEqual(rr.colorRampShader().sourceColorRamp().color1().name(), renderer.colorRampShader().sourceColorRamp().color1().name()) self.assertEqual(rr.colorRampShader().sourceColorRamp().color2().name(), renderer.colorRampShader().sourceColorRamp().color2().name()) doc = QDomDocument("testdoc") elem = renderer.save(doc, QgsReadWriteContext()) r2 = QgsPointCloudAttributeByRampRenderer.create(elem, QgsReadWriteContext()) self.assertEqual(r2.maximumScreenError(), 18) self.assertEqual(r2.maximumScreenErrorUnit(), QgsUnitTypes.RenderInches) self.assertEqual(r2.pointSize(), 13) self.assertEqual(r2.pointSizeUnit(), QgsUnitTypes.RenderPoints) self.assertEqual(r2.pointSizeMapUnitScale().minScale, 1000) self.assertEqual(r2.pointSizeMapUnitScale().maxScale, 2000) self.assertEqual(r2.attribute(), 'attr') self.assertEqual(r2.minimum(), 5) self.assertEqual(r2.maximum(), 15) self.assertEqual(r2.colorRampShader().minimumValue(), 20) self.assertEqual(r2.colorRampShader().maximumValue(), 30) self.assertEqual(r2.colorRampShader().sourceColorRamp().color1().name(), renderer.colorRampShader().sourceColorRamp().color1().name()) self.assertEqual(r2.colorRampShader().sourceColorRamp().color2().name(), renderer.colorRampShader().sourceColorRamp().color2().name())
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 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 testTwoClassesDiscrete(self): # test for #47759 shader = QgsColorRampShader(0, 50, None, QgsColorRampShader.Discrete) item1 = QgsColorRampShader.ColorRampItem(50, QColor(0, 0, 0)) item2 = QgsColorRampShader.ColorRampItem(float("inf"), QColor(255, 255, 255)) shader.setColorRampItemList([item1, item2]) color1 = shader.shade(50) self.assertEqual(color1[1:4], (0, 0, 0)) color2 = shader.shade(50.00000000001) self.assertEqual(color2[1:4], (255, 255, 255))
def __init__(self, layer): self.colDic = {'tan':'#ffebb0', 'green':'#267300', 'brown':'#734d00', 'white':'#ffffff', 'red':'#e60000', 'light gray':'#f0f0f0', 'blue':'#004cab'} self.shader = QgsRasterShader() self.ramp = QgsColorRampShader() self.colLst = [] self.valLst = [] self.labLst = [] self.opacity = 1.0 self.layer = layer self.provider = layer.dataProvider() extent = layer.extent() self.ver = self.provider.hasStatistics(1, QgsRasterBandStats.All) self.stats = self.provider.bandStatistics(1, QgsRasterBandStats.All, extent, 0)
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 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 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 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 mkRasterShader(layer, color_ramp, classif_mode=QgsColorRampShader.Continuous): min, med, max = getValuesFromLayer3(layer) rasterShader = QgsRasterShader(minimumValue=min, maximumValue=max) colorRamp = getRandomSingleColorRamp() if not color_ramp: utils.internal_error("Could not create color ramp") colorRampShader = QgsColorRampShader(minimumValue=min, maximumValue=max, colorRamp=color_ramp, classificationMode=classif_mode) colorRampShader.classifyColorRamp(band=1, input=layer.dataProvider()) if colorRampShader.isEmpty(): utils.internal_error("Empty color ramp shader") rasterShader.setRasterShaderFunction(colorRampShader) return rasterShader
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 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 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 testVaryingColorFixedWidth(self): """ test that rendering a interpolated line with fixed width and varying color""" interpolated_width = QgsInterpolatedLineWidth() interpolated_color = QgsInterpolatedLineColor() interpolated_width.setIsVariableWidth(False) interpolated_width.setFixedStrokeWidth(5) color_ramp = QgsColorRampShader( 0, 7, QgsStyle.defaultStyle().colorRamp('Viridis'), QgsColorRampShader.Interpolated) color_ramp.classifyColorRamp(10) interpolated_color.setColor(color_ramp) interpolated_color.setColoringMethod( QgsInterpolatedLineColor.ColorRamp) self.renderImage(interpolated_width, interpolated_color, 'interpolatedlinesymbollayer_2')
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_prod_state_emerg(outfile): # Significance layer layer = iface.addRasterLayer( outfile, QtGui.QApplication.translate('LDMPPlugin', 'Productivity state (emerging)')) 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', '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.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 run(self): """Run method that performs all the real work""" # show the dialog self.dlg.show() self.toggle_widgets(False) self.layer = self.iface.activeLayer() if self.layer is None: self.dlg.header.setText("No layer selected.") self.dlg.header.setStyleSheet("color: #000000;") else: if isinstance(self.layer, QgsRasterLayer) is False: raise TypeError("Expected QgsRasterLayer, got {}".format( type(self.layer))) self.dlg.header.setText("") # Active layer if not hasattr(self.layer, "hasFilter"): self.fcn = QgsColorRampShader() self.fcn.setColorRampType(QgsColorRampShader.Interpolated) self.layer.hasFilter = True else: self.toggle_widgets(True) if self.MAX == float("-inf"): self.startWorker(self.iface, self.layer) # Run the dialog event loop # self.set_values(True) result = self.dlg.exec_() self.dlg.threshold_0_button.clicked.disconnect() self.dlg.threshold_1_button.clicked.disconnect() self.dlg.threshold_2_button.clicked.disconnect() # See if OK was pressed if result: pass # print("OK was pressed.") # Do something useful here - delete the line containing pass and # substitute with your code. else: pass
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 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 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 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 testVaryingColorVaryingWidthExact(self): """ test that rendering a interpolated line with varying width and varying color with exact color ramp """ interpolated_width = QgsInterpolatedLineWidth() interpolated_color = QgsInterpolatedLineColor() interpolated_width.setIsVariableWidth(True) interpolated_width.setMinimumValue(1) interpolated_width.setMaximumValue(8) interpolated_width.setMinimumWidth(1) interpolated_width.setMaximumWidth(10) color_ramp = QgsColorRampShader( 0, 10, QgsStyle.defaultStyle().colorRamp('Viridis'), QgsColorRampShader.Exact) color_ramp.classifyColorRamp(10) interpolated_color.setColor(color_ramp) interpolated_color.setColoringMethod( QgsInterpolatedLineColor.ColorRamp) self.renderImage(interpolated_width, interpolated_color, 'interpolatedlinesymbollayer_6')
def testVaryingColorVaryingWidthDiscrete(self): """ test that rendering a interpolated line with varying width and varying color with discrete color ramp """ interpolated_width = QgsInterpolatedLineWidth() interpolated_color = QgsInterpolatedLineColor() interpolated_width.setIsVariableWidth(True) interpolated_width.setMinimumValue(1) interpolated_width.setMaximumValue(8) interpolated_width.setMinimumWidth(1) interpolated_width.setMaximumWidth(10) color_ramp = QgsColorRampShader( 2, 7, QgsStyle.defaultStyle().colorRamp('RdGy'), QgsColorRampShader.Discrete) color_ramp.classifyColorRamp(5) interpolated_color.setColor(color_ramp) interpolated_color.setColoringMethod( QgsInterpolatedLineColor.ColorRamp) self.renderImage(interpolated_width, interpolated_color, 'interpolatedlinesymbollayer_5')
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 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)