示例#1
0
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)
示例#2
0
def createRasterShader(fields, mode = "rgb", scale = "float"):
    shader = QgsRasterShader()
    colRamp = QgsColorRampShader()
    colRamp.setColorRampType(QgsColorRampShader.INTERPOLATED)
    
    ramp = []
    col = QColor()
    
    for line in fields:
        val = float(line[0])
        txt = unicode(line[1])
       
        if mode == "rgb" or mode == "rnd":
            if scale != "float":
                color = [float(x)/255.0 for x in line[2:6]]
            col.setRgbF(*color)
            
        elif mode == "hsv":
            if scale != "float":
                color = [float(x)/float(y) for x,y in zip(line[2:6], [360, 100, 100, 255])]
            col.setHsvF(*color)
            
        elif mode == "hex":
            col.setNamedColor(str(line[2]))

        ramp.append(QgsColorRampShader.ColorRampItem(val, col, txt))
    
    colRamp.setColorRampItemList(ramp)
    shader.setRasterShaderFunction(colRamp)
    
    return(shader)
    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 aggregate_layers(self, layers, d):
     aggregation = self.frequency.itemData(self.frequency.currentIndex())
     month = str(d.month)
     month = month if len(month) == 2 else '0' + month
     day = str(d.day)
     day = day if len(day) == 2 else '0' + day
     filtered_layers = filter(lambda x: '.tif' in x, layers)
     datasets = []
     file_name = None
     for l in filtered_layers:
         datasets.append(Dataset(l))
     sum = datasets[0]
     for i in range(1,len(datasets)-1):
         sum += datasets[i]
     if aggregation == 'SUM':
         Env.overwrite = True
         avg = sum
         file_name = self.download_folder.text() + '/' + str(d.year) + '_' + month + '_' + day + '_SUM.tif'
         avg.save(file_name)
     elif aggregation == 'AVG':
         Env.overwrite = True
         avg = sum
         avg /= len(datasets)
         file_name = self.download_folder.text() + '/' + str(d.year) + '_' + month + '_' + day + '_AVG.tif'
         avg.save(file_name)
     if self.add_to_canvas.isChecked() is True:
         self.bar.pushMessage(None, str(file_name), level=QgsMessageBar.INFO)
         title = None
         if aggregation == 'SUM':
             title = self.tr('TRMM Aggregate (Sum): ') + str(d.year) + '-' + str(month) + '-' + str(day)
         elif aggregation == 'AVG':
             title = self.tr('TRMM Aggregate (Average): ') + str(d.year) + '-' + str(month) + '-' + str(day)
         rl = self.iface.addRasterLayer(file_name, title)
         fcn = QgsColorRampShader()
         fcn.setColorRampType(QgsColorRampShader.INTERPOLATED)
         lst = [
             QgsColorRampShader.ColorRampItem(0, QColor(247, 251, 255, 0), '< 2.6 [mm]'),
             QgsColorRampShader.ColorRampItem(2.6, QColor(222, 235, 247), '< 5.2 [mm]'),
             QgsColorRampShader.ColorRampItem(5.2, QColor(199, 220, 239), '< 7.8 [mm]'),
             QgsColorRampShader.ColorRampItem(7.8, QColor(162, 203, 226), '< 10.4 [mm]'),
             QgsColorRampShader.ColorRampItem(10.4, QColor(114, 178, 215), '< 13 [mm]'),
             QgsColorRampShader.ColorRampItem(13, QColor(73, 151, 201), '< 15.6 [mm]'),
             QgsColorRampShader.ColorRampItem(15.6, QColor(40, 120, 184), '< 18 [mm]'),
             QgsColorRampShader.ColorRampItem(18, QColor(13, 87, 161), '< 20 [mm]'),
             QgsColorRampShader.ColorRampItem(20, QColor(8, 48, 107), '>= 20 [mm]')
         ]
         fcn.setColorRampItemList(lst)
         shader = QgsRasterShader()
         shader.setRasterShaderFunction(fcn)
         renderer = QgsSingleBandPseudoColorRenderer(rl.dataProvider(), 1, shader)
         rl.setRenderer(renderer)
         rl.triggerRepaint()
    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,
                                                  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 (fixed now)##################
        myPseudoRenderer = QgsSingleBandPseudoColorRenderer(
            myRasterLayer.dataProvider(), 1,  myRasterShader)
        myRasterLayer.setRenderer(myPseudoRenderer)
def setRamp(layer, iface):
    
    renderer = layer.renderer()
    provider = layer.dataProvider()
    extent = layer.extent()
    
    ver = provider.hasStatistics(1, QgsRasterBandStats.All)
    
    stats = provider.bandStatistics(1, QgsRasterBandStats.All,extent, 0)
    
    if ver is not False:
        print "minimumValue = ", stats.minimumValue
    
        print "maximumValue = ", stats.maximumValue
    
    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)
    myRasterShader.setRasterShaderFunction(myColorRamp)
    
    myPseudoRenderer = QgsSingleBandPseudoColorRenderer(layer.dataProvider(), 
                                                        layer.type(),  
                                                        myRasterShader)
    
    layer.setRenderer(myPseudoRenderer)
    
    layer.triggerRepaint()
示例#7
0
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)
示例#8
0
    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])
示例#9
0
    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 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()
示例#11
0
    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
示例#12
0
    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))
示例#13
0
    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')
示例#14
0
    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')
示例#15
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())
示例#16
0
        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
    def testRenderBottomToTop(self):
        layer = QgsPointCloudLayer(
            unitTestDataPath() + '/point_clouds/ept/sunshine-coast/ept.json',
            'test', 'ept')
        self.assertTrue(layer.isValid())

        renderer = QgsPointCloudAttributeByRampRenderer()
        renderer.setAttribute('Intensity')
        renderer.setMinimum(200)
        renderer.setMaximum(1000)
        ramp = QgsStyle.defaultStyle().colorRamp("Viridis")
        shader = QgsColorRampShader(200, 1000, ramp)
        shader.classifyColorRamp()
        renderer.setColorRampShader(shader)

        layer.setRenderer(renderer)

        layer.renderer().setPointSize(6)
        layer.renderer().setPointSizeUnit(QgsUnitTypes.RenderMillimeters)
        layer.renderer().setDrawOrder2d(
            QgsPointCloudRenderer.DrawOrder.BottomToTop)

        mapsettings = QgsMapSettings()
        mapsettings.setOutputSize(QSize(400, 400))
        mapsettings.setOutputDpi(96)
        mapsettings.setDestinationCrs(layer.crs())
        mapsettings.setExtent(QgsRectangle(498061, 7050991, 498069, 7050999))
        mapsettings.setLayers([layer])

        renderchecker = QgsMultiRenderChecker()
        renderchecker.setMapSettings(mapsettings)
        renderchecker.setControlPathPrefix('pointcloudrenderer')
        renderchecker.setControlName('expected_ramp_bottom_to_top')
        result = renderchecker.runTest('expected_ramp_bottom_to_top')
        TestQgsPointCloudAttributeByRampRenderer.report += renderchecker.report(
        )
        self.assertTrue(result)
示例#18
0
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)
示例#19
0
    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)
示例#20
0
    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)
示例#21
0
    def testRenderCrsTransform(self):
        layer = QgsPointCloudLayer(
            unitTestDataPath() + '/point_clouds/ept/sunshine-coast/ept.json',
            'test', 'ept')
        self.assertTrue(layer.isValid())

        renderer = QgsPointCloudAttributeByRampRenderer()
        renderer.setAttribute('Intensity')
        renderer.setMinimum(200)
        renderer.setMaximum(1000)
        ramp = QgsStyle.defaultStyle().colorRamp("Viridis")
        shader = QgsColorRampShader(200, 1000, ramp)
        shader.classifyColorRamp()
        renderer.setColorRampShader(shader)

        layer.setRenderer(renderer)
        layer.renderer().setPointSize(2)
        layer.renderer().setPointSizeUnit(QgsUnitTypes.RenderMillimeters)

        mapsettings = QgsMapSettings()
        mapsettings.setOutputSize(QSize(400, 400))
        mapsettings.setOutputDpi(96)
        mapsettings.setDestinationCrs(
            QgsCoordinateReferenceSystem('EPSG:4326'))
        mapsettings.setExtent(
            QgsRectangle(152.980508492, -26.662023491, 152.980586020,
                         -26.662071137))
        mapsettings.setLayers([layer])
        renderchecker = QgsMultiRenderChecker()
        renderchecker.setMapSettings(mapsettings)
        renderchecker.setControlPathPrefix('pointcloudrenderer')
        renderchecker.setControlName('expected_ramp_render_crs_transform')
        result = renderchecker.runTest('expected_ramp_render_crs_transform')
        TestQgsPointCloudAttributeByRampRenderer.report += renderchecker.report(
        )
        self.assertTrue(result)
示例#22
0
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)
示例#23
0
    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()
示例#24
0
 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 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 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()
示例#27
0
    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()
示例#28
0
 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!')
示例#29
0
 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)
示例#30
0
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
示例#31
0
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)
示例#32
0
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()
示例#33
0
 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()
示例#34
0
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)
示例#35
0
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 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)
示例#37
0
    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()
示例#38
0
文件: styles.py 项目: samnawi/inasafe
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 = (
示例#39
0
def idw_interpolation(layer, parent_dialog):
    """Run interpolation using inverse distance weight algorithm

    :param layer: Vector layer with drivetimes
    :type layer: QgsVectorLayer

    :param parent_dialog: A dialog that called this function.
    :type parent_dialog: QProgressDialog

    :returns raster_layer: Interpolated raster layer with drivetimes
    :rtype raster_layer: QgsRasterLayer

    """
    raster_layer = None
    try:
        Processing.initialize()
        Processing.updateAlgsList()

        output_raster = processing.runalg(
        'gdalogr:gridinvdist',
        layer,
        'minutes',
        2, 0, 0, 0, 0, 0, 0, 0, 5,
        "[temporary file]")

        output_file = output_raster['OUTPUT']
        file_info = QFileInfo(output_file)
        base_name = file_info.baseName()

        # retrieving the raster output , styling it and load it in Qgis

        raster_layer = QgsRasterLayer(output_file, base_name)

    except Exception as exception:  # pylint: disable=broad-except
            # noinspection PyCallByClass,PyTypeChecker,PyArgumentList
        if parent_dialog:
                display_warning_message_box(
                    parent_dialog,
                    parent_dialog.tr(
                        'Error'),
                    parent_dialog.tr('Error loading isochrone map,'
                                     'please check if you have processing '
                                     'plugin installed '))
        else:
            display_warning_message_box(
                parent_dialog,
                'Error',
                'Error loading isochrone map,'
                'please check if you have processing '
                'plugin installed ')

    if raster_layer:
        if raster_layer.isValid():
            color_shader = QgsColorRampShader()
            color_shader.setColorRampType(QgsColorRampShader.INTERPOLATED)
            colors = {
                'deep_green': '#1a9641',
                'light_green': '#a6d96a',
                'pale_yellow': '#ffffc0',
                'light_red': '#fdae61',
                'red': '#d7191c'
            }
            provider = raster_layer.dataProvider()
            stats = provider.bandStatistics(
                1,
                QgsRasterBandStats.All,
                raster_layer.extent(),
                0)

            values = {}

            if stats:
                min = stats.minimumValue
                max = stats.maximumValue
                stat_range = max - min
                add = stat_range / 4
                values[0] = min
                value = min
                for index in range(1, 4):
                    value += add
                    values[index] = value
                values[4] = max
            else:
                display_warning_message_box(
                    parent_dialog,
                    parent_dialog.tr(
                        'Error'),
                    parent_dialog.tr('Error loading isochrone map'
                                     ' Problem indexing the isochrones map'))

            color_list = [
                QgsColorRampShader.ColorRampItem(
                    values[0],
                    QColor(colors['deep_green'])),
                QgsColorRampShader.ColorRampItem(
                    values[1],
                    QColor(colors['light_green'])),
                QgsColorRampShader.ColorRampItem(
                    values[2],
                    QColor(colors['pale_yellow'])),
                QgsColorRampShader.ColorRampItem(
                    values[3],
                    QColor(colors['light_red'])),
                QgsColorRampShader.ColorRampItem(
                    values[4],
                    QColor(colors['red']))
            ]

            color_shader.setColorRampItemList(color_list)
            raster_shader = QgsRasterShader()
            raster_shader.setRasterShaderFunction(color_shader)

            renderer = QgsSingleBandPseudoColorRenderer(
                raster_layer.dataProvider(),
                1,
                raster_shader)
            raster_layer.setRenderer(renderer)

        else:
            if parent_dialog:
                display_warning_message_box(
                    parent_dialog,
                    parent_dialog.tr(
                        'Problem'),
                    parent_dialog.tr('Problem styling the isochrone map'))
            else:
                display_warning_message_box(
                    parent_dialog,
                    'Problem',
                    'Problem styling the isochrone map')

        QgsMapLayerRegistry.instance().addMapLayers([raster_layer])

    else:
        if parent_dialog:

            display_warning_message_box(
                parent_dialog,
                parent_dialog.tr(
                    'Error'),
                parent_dialog.tr('Error loading isochrone map '
                                 'Could not load interpolated file!'))
        else:
            display_warning_message_box(
                parent_dialog,
                'Error',
                'Error loading isochrone map '
                'Could not load interpolated file!')

    return raster_layer
示例#40
0
def _setNewRasterStyle(theQgsRasterLayer, theClasses):
    """Set QGIS raster style based on InaSAFE style dictionary for QGIS >= 2.0.

    This function will set both the colour map and the transparency
    for the passed in layer.

    Args:
        * theQgsRasterLayer: QgsRasterLayer
        * theClasses: List of the form as in the example below.

    Returns:
        * list: RangeList
        * list: TransparencyList

    Example:
        style_classes = [dict(colour='#38A800', quantity=2, transparency=0),
                         dict(colour='#38A800', quantity=5, transparency=50),
                         dict(colour='#79C900', quantity=10, transparency=50),
                         dict(colour='#CEED00', quantity=20, transparency=50),
                         dict(colour='#FFCC00', quantity=50, transparency=34),
                         dict(colour='#FF6600', quantity=100, transparency=77),
                         dict(colour='#FF0000', quantity=200, transparency=24),
                         dict(colour='#7A0000', quantity=300, transparency=22)]

    """
    # Note imports here to prevent importing on unsupported QGIS versions
    # pylint: disable=E0611
    # pylint: disable=W0621
    # pylint: disable=W0404
    from qgis.core import (QgsRasterShader,
                           QgsColorRampShader,
                           QgsSingleBandPseudoColorRenderer,
                           QgsRasterTransparency)
    # pylint: enable=E0611
    # pylint: enable=W0621
    # pylint: enable=W0404

    myRampItemList = []
    myTransparencyList = []
    LOGGER.debug(theClasses)
    for myClass in theClasses:

        LOGGER.debug('Evaluating class:\n%s\n' % myClass)

        if 'quantity' not in myClass:
            LOGGER.exception('Class has no quantity attribute')
            continue

        myMax = myClass['max']
        if math.isnan(myMax):
            LOGGER.debug('Skipping class - max is nan.')
            continue

        myMin = myClass['min']
        if math.isnan(myMin):
            LOGGER.debug('Skipping class - min is nan.')
            continue

        myColour = QtGui.QColor(myClass['colour'])
        myLabel = QtCore.QString()
        if 'label' in myClass:
            myLabel = QtCore.QString(myClass['label'])
        myRampItem = QgsColorRampShader.ColorRampItem(myMax, myColour, myLabel)
        myRampItemList.append(myRampItem)

        # Create opacity entries for this range
        myTransparencyPercent = 0
        if 'transparency' in myClass:
            myTransparencyPercent = int(myClass['transparency'])
        if myTransparencyPercent > 0:
            # Check if range extrema are integers so we know if we can
            # use them to calculate a value range
            myPixel = QgsRasterTransparency.TransparentSingleValuePixel()
            myPixel.min = myMin
            # We want it just a leeetle bit smaller than max
            # so that ranges are discrete
            myPixel.max = myMax
            myPixel.percentTransparent = myTransparencyPercent
            myTransparencyList.append(myPixel)

    myBand = 1  # gdal counts bands from base 1
    LOGGER.debug('Setting colour ramp list')
    myRasterShader = QgsRasterShader()
    myColorRampShader = QgsColorRampShader()
    myColorRampShader.setColorRampType(QgsColorRampShader.INTERPOLATED)
    myColorRampShader.setColorRampItemList(myRampItemList)
    LOGGER.debug('Setting shader function')
    myRasterShader.setRasterShaderFunction(myColorRampShader)
    LOGGER.debug('Setting up renderer')
    myRenderer = QgsSingleBandPseudoColorRenderer(
        theQgsRasterLayer.dataProvider(),
        myBand,
        myRasterShader)
    LOGGER.debug('Assigning renderer to raster layer')
    theQgsRasterLayer.setRenderer(myRenderer)

    LOGGER.debug('Setting raster transparency list')

    myRenderer = theQgsRasterLayer.renderer()
    myTransparency = QgsRasterTransparency()
    myTransparency.setTransparentSingleValuePixelList(myTransparencyList)
    myRenderer.setRasterTransparency(myTransparency)
    # For interest you can also view the list like this:
    #pix = t.transparentSingleValuePixelList()
    #for px in pix:
    #    print 'Min: %s Max %s Percent %s' % (
    #       px.min, px.max, px.percentTransparent)

    LOGGER.debug('Saving style as default')
    theQgsRasterLayer.saveDefaultStyle()
    LOGGER.debug('Setting raster style done!')
    return myRampItemList, myTransparencyList
示例#41
0
class RasterSymbolizer(QgsRasterLayer):

    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 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 setRendererOptions(self, type):

        if type == "DEM":
            self.setValueBreaks_DEM()
            self.setColorRamp_DEM()

        elif type == "DoD":
            self.setValueBreaks_DoD()
            self.setColorRamp_DoD()

        elif type == "Slope_deg":
            self.setValueBreaks_SlopeDeg()
            self.setColorRamp_Slope()

        elif type == "Slope_per":
            self.setValueBreaks_SlopePer()
            self.setColorRamp_Slope()

        elif type == "Roughness":
            self.setValueBreaks_Roughness()
            self.setColorRamp_Roughness()

    def setValueBreaks_DEM(self):
        lo = self.stats.minimumValue
        hi = self.stats.maximumValue
        rng = hi - lo
        interval = rng/3.0
        self.valLst = [lo, lo+interval, hi-interval, hi]

    def setValueBreaks_DoD(self):
        nClasses = 20
        lo = self.stats.minimumValue
        hi = self.stats.maximumValue
        mid = 0.0

        if abs(lo) > abs(hi):
            hi = abs(lo)

        else:
            lo = hi*-1.0

        rng = hi*2.0
        interval = rng/(nClasses*1.0)

        nRound = self.magnitude(rng)

        if nRound < 0:
            nRound = abs(nRound) + 2

        else:
            nRound = 2

        self.valLst.append(lo)

        for i in range(1,nClasses+1,1):
            self.valLst.append(lo + i*interval)
            self.labLst.append(str(round(self.valLst[i-1], nRound))+" to "+str(round(self.valLst[i], nRound)))

    def setValueBreaks_SlopeDeg(self):

        self.valLst.append(self.stats.minimumValue)
        self.valLst.append(2.0)
        self.valLst.append(5.0)
        self.valLst.append(10.0)
        self.valLst.append(15.0)
        self.valLst.append(25.0)
        self.valLst.append(35.0)
        self.valLst.append(45.0)
        self.valLst.append(60.0)
        self.valLst.append(80.0)

        self.labLst.append("0 to 2")
        self.labLst.append("2 to 5")
        self.labLst.append("5 to 10")
        self.labLst.append("10 to 15")
        self.labLst.append("15 to 25")
        self.labLst.append("25 to 35")
        self.labLst.append("35 to 45")
        self.labLst.append("45 to 60")
        self.labLst.append("60 to 80")
        self.labLst.append("80 to 90")

    def setValueBreaks_SlopePer(self):
        self.valLst.append(0.0)
        self.valLst.append(3.5)
        self.valLst.append(8.75)
        self.valLst.append(15.0)
        self.valLst.append(25.0)
        self.valLst.append(45.0)
        self.valLst.append(70.0)
        self.valLst.append(100.0)
        self.valLst.append(175.0)
        self.valLst.append(565.0)

        self.labLst.append("0 to 3.5%")
        self.labLst.append("3.5% to 8.75%")
        self.labLst.append("8.75% to 15%")
        self.labLst.append("15% to 25%")
        self.labLst.append("25% to 45%")
        self.labLst.append("45% to 70%")
        self.labLst.append("70% to 100%")
        self.labLst.append("100% to 175%")
        self.labLst.append("175% to 565%")
        self.labLst.append("> 565%")

    def setValueBreaks_Roughness(self):
        self.valLst.append(0)
        self.valLst.append(2)
        self.valLst.append(16)
        self.valLst.append(64)
        self.valLst.append(256)

        self.labLst.append("Fines, Sand (0 to 2 mm)")
        self.labLst.append("Fine Gravel (2 mm to 16 mm)")
        self.labLst.append("Coarse Gravel (16 mm to 64 mm)")
        self.labLst.append("Cobbles (64 mm to 256 mm)")
        self.labLst.append("Boulders (> 256 mm)")

    def setColorRamp_DEM(self):

        self.colLst = [QgsColorRampShader.ColorRampItem(self.valLst[0], QColor(self.colDic['tan']), str(self.valLst[0])),
                           QgsColorRampShader.ColorRampItem(self.valLst[1], QColor(self.colDic['green']), str(self.valLst[1])),
                           QgsColorRampShader.ColorRampItem(self.valLst[2], QColor(self.colDic['brown']), str(self.valLst[2])),
                           QgsColorRampShader.ColorRampItem(self.valLst[3], QColor(self.colDic['white']), str(self.valLst[3]))]

        self.ramp.setColorRampItemList(self.colLst)
        self.ramp.setColorRampType(QgsColorRampShader.INTERPOLATED)
        self.opacity = 0.6

    def setColorRamp_DoD(self):

        self.colLst = [QgsColorRampShader.ColorRampItem(self.valLst[0], QColor(230,0,0), self.labLst[0]),
                       QgsColorRampShader.ColorRampItem(self.valLst[1], QColor(235,45,23), self.labLst[1]),
                       QgsColorRampShader.ColorRampItem(self.valLst[2], QColor(240,67,41), self.labLst[2]),
                       QgsColorRampShader.ColorRampItem(self.valLst[3], QColor(242,88,61), self.labLst[3]),
                       QgsColorRampShader.ColorRampItem(self.valLst[4], QColor(245,108,81), self.labLst[4]),
                       QgsColorRampShader.ColorRampItem(self.valLst[5], QColor(245,131,105), self.labLst[5]),
                       QgsColorRampShader.ColorRampItem(self.valLst[6], QColor(245,151,130), self.labLst[6]),
                       QgsColorRampShader.ColorRampItem(self.valLst[7], QColor(242,171,155), self.labLst[7]),
                       QgsColorRampShader.ColorRampItem(self.valLst[8], QColor(237,190,180), self.labLst[8]),
                       QgsColorRampShader.ColorRampItem(self.valLst[9], QColor(230,208,207), self.labLst[9]),
                       QgsColorRampShader.ColorRampItem(self.valLst[10], QColor(218,218,224), self.labLst[10]),
                       QgsColorRampShader.ColorRampItem(self.valLst[11], QColor(197,201,219), self.labLst[11]),
                       QgsColorRampShader.ColorRampItem(self.valLst[12], QColor(176,183,214), self.labLst[12]),
                       QgsColorRampShader.ColorRampItem(self.valLst[13], QColor(155,166,207), self.labLst[13]),
                       QgsColorRampShader.ColorRampItem(self.valLst[14], QColor(135,150,201), self.labLst[14]),
                       QgsColorRampShader.ColorRampItem(self.valLst[15], QColor(110,131,194), self.labLst[15]),
                       QgsColorRampShader.ColorRampItem(self.valLst[16], QColor(92,118,189), self.labLst[16]),
                       QgsColorRampShader.ColorRampItem(self.valLst[17], QColor(72,105,184), self.labLst[17]),
                       QgsColorRampShader.ColorRampItem(self.valLst[18], QColor(49,91,176), self.labLst[18]),
                       QgsColorRampShader.ColorRampItem(self.valLst[19], QColor(2,7,168), self.labLst[19])]

        self.ramp.setColorRampItemList(self.colLst)
        self.ramp.setColorRampType(QgsColorRampShader.DISCRETE)

    def setColorRamp_Slope(self):
        self.colLst = [QgsColorRampShader.ColorRampItem(self.valLst[0], QColor(255,235,176), self.labLst[0]),
                       QgsColorRampShader.ColorRampItem(self.valLst[1], QColor(255,219,135), self.labLst[1]),
                       QgsColorRampShader.ColorRampItem(self.valLst[2], QColor(255,202,97), self.labLst[2]),
                       QgsColorRampShader.ColorRampItem(self.valLst[3], QColor(255,186,59), self.labLst[3]),
                       QgsColorRampShader.ColorRampItem(self.valLst[4], QColor(255,170,0), self.labLst[4]),
                       QgsColorRampShader.ColorRampItem(self.valLst[5], QColor(255,128,0), self.labLst[5]),
                       QgsColorRampShader.ColorRampItem(self.valLst[6], QColor(255,85,0), self.labLst[6]),
                       QgsColorRampShader.ColorRampItem(self.valLst[7], QColor(255,42,0), self.labLst[7]),
                       QgsColorRampShader.ColorRampItem(self.valLst[8], QColor(161,120,120), self.labLst[8]),
                       QgsColorRampShader.ColorRampItem(self.valLst[9], QColor(130,10,130), self.labLst[9])]

        self.ramp.setColorRampItemList(self.colLst)
        self.ramp.setColorRampType(QgsColorRampShader.DISCRETE)

    def setColorRamp_Roughness(self):
        self.colLst = [QgsColorRampShader.ColorRampItem(self.valLst[0], QColor(194,82,60), self.labLst[0]),
                       QgsColorRampShader.ColorRampItem(self.valLst[1], QColor(240,180,17), self.labLst[1]),
                       QgsColorRampShader.ColorRampItem(self.valLst[2], QColor(123,237,0), self.labLst[2]),
                       QgsColorRampShader.ColorRampItem(self.valLst[3], QColor(27,168,124), self.labLst[3]),
                       QgsColorRampShader.ColorRampItem(self.valLst[4], QColor(11,44,122), self.labLst[4])]

    def magnitude(self, x):
        return int(math.floor(math.log10(x)))
示例#42
0
    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))
示例#43
0
def set_raster_style(raster_layer, style):
    """Set QGIS raster style based on InaSAFE style dictionary for QGIS >= 2.0.

    This function will set both the colour map and the transparency
    for the passed in layer.

    :param raster_layer: A QGIS raster layer that will be styled.
    :type raster_layer: QgsVectorLayer

    :param style: List of the form as in the example below.
    :type style: list

    Example::

        style_classes = [dict(colour='#38A800', quantity=2, transparency=0),
                         dict(colour='#38A800', quantity=5, transparency=50),
                         dict(colour='#79C900', quantity=10, transparency=50),
                         dict(colour='#CEED00', quantity=20, transparency=50),
                         dict(colour='#FFCC00', quantity=50, transparency=34),
                         dict(colour='#FF6600', quantity=100, transparency=77),
                         dict(colour='#FF0000', quantity=200, transparency=24),
                         dict(colour='#7A0000', quantity=300, transparency=22)]

    :returns: A two tuple containing a range list and a transparency list.
    :rtype: (list, list)

    """
    # Note imports here to prevent importing on unsupported QGIS versions
    # pylint: disable=E0611
    # pylint: disable=W0621
    # pylint: disable=W0404
    # noinspection PyUnresolvedReferences
    from qgis.core import (QgsRasterShader,
                           QgsColorRampShader,
                           QgsSingleBandPseudoColorRenderer,
                           QgsRasterTransparency)
    # pylint: enable=E0611
    # pylint: enable=W0621
    # pylint: enable=W0404

    ramp_item_list = []
    transparency_list = []
    LOGGER.debug(style)
    for style_class in style:

        LOGGER.debug('Evaluating class:\n%s\n' % style_class)

        if 'quantity' not in style_class:
            LOGGER.exception('Class has no quantity attribute')
            continue

        class_max = style_class['max']
        if math.isnan(class_max):
            LOGGER.debug('Skipping class - max is nan.')
            continue

        class_min = style_class['min']
        if math.isnan(class_min):
            LOGGER.debug('Skipping class - min is nan.')
            continue

        colour = QtGui.QColor(style_class['colour'])
        label = ''
        if 'label' in style_class:
            label = style_class['label']
        # noinspection PyCallingNonCallable
        ramp_item = QgsColorRampShader.ColorRampItem(class_max, colour, label)
        ramp_item_list.append(ramp_item)

        # Create opacity entries for this range
        transparency_percent = 0
        if 'transparency' in style_class:
            transparency_percent = int(style_class['transparency'])
        if transparency_percent > 0:
            # Check if range extrema are integers so we know if we can
            # use them to calculate a value range
            # noinspection PyCallingNonCallable
            pixel = QgsRasterTransparency.TransparentSingleValuePixel()
            pixel.min = class_min
            # We want it just a little bit smaller than max
            # so that ranges are discrete
            pixel.max = class_max
            # noinspection PyPep8Naming
            pixel.percentTransparent = transparency_percent
            transparency_list.append(pixel)

    band = 1  # gdal counts bands from base 1
    LOGGER.debug('Setting colour ramp list')
    raster_shader = QgsRasterShader()
    color_ramp_shader = QgsColorRampShader()
    color_ramp_shader.setColorRampType(QgsColorRampShader.INTERPOLATED)
    color_ramp_shader.setColorRampItemList(ramp_item_list)
    LOGGER.debug('Setting shader function')
    raster_shader.setRasterShaderFunction(color_ramp_shader)
    LOGGER.debug('Setting up renderer')
    renderer = QgsSingleBandPseudoColorRenderer(
        raster_layer.dataProvider(),
        band,
        raster_shader)
    LOGGER.debug('Assigning renderer to raster layer')
    raster_layer.setRenderer(renderer)

    LOGGER.debug('Setting raster transparency list')

    renderer = raster_layer.renderer()
    transparency = QgsRasterTransparency()
    transparency.setTransparentSingleValuePixelList(transparency_list)
    renderer.setRasterTransparency(transparency)
    # For interest you can also view the list like this:
    # pix = t.transparentSingleValuePixelList()
    # for px in pix:
    #    print 'Min: %s Max %s Percent %s' % (
    #       px.min, px.max, px.percentTransparent)

    LOGGER.debug('Saving style as default')
    raster_layer.saveDefaultStyle()
    LOGGER.debug('Setting raster style done!')
    return ramp_item_list, transparency_list
示例#44
0
def create_raster_layer(matrix):
    driver = gdal.GetDriverByName("GTiff")

    filename = tempfile.mktemp(prefix="hmtk", suffix=".tif")

    # sort the data by lon, lat
    gridded_data = numpy.array(
        sorted(matrix, key=lambda row: (90 + row[1]) * 180 + (180 + row[0])))

    # extract it into separate vars
    lons, lats, vals = (
        gridded_data[:, 0], gridded_data[:, 1], gridded_data[:, 3])

    ncols = lons[lons == lons[0]].size
    nrows = lats[lats == lats[0]].size

    # put values in a grid
    gridded_vals = vals.reshape((ncols, nrows)).T

    dataset = driver.Create(filename, ncols, nrows, 1, gdal.GDT_Float32)

    dataset.SetGeoTransform((
        min(lons),
        (max(lons) - min(lons)) / ncols,
        0,
        max(lats),
        0,
        -(max(lats) - min(lats)) / nrows))

    out_srs = osr.SpatialReference()
    out_srs.ImportFromEPSG(4326)
    dataset.SetProjection(out_srs.ExportToWkt())

    out_band = dataset.GetRasterBand(1)
    out_band.WriteArray(gridded_vals)
    out_band.SetNoDataValue(0)
    out_band.FlushCache()
    out_band = None
    dataset = None

    fileInfo = QFileInfo(filename)
    baseName = fileInfo.baseName()
    layer = QgsRasterLayer(filename, baseName)

    stat = layer.dataProvider().bandStatistics(1)

    minVal = stat.minimumValue
    maxVal = stat.maximumValue
    entries_nr = 20

    colorRamp = QgsStyleV2().defaultStyle().colorRamp("Spectral")
    currentValue = float(minVal)
    intervalDiff = float(maxVal - minVal) / float(entries_nr - 1)

    colorRampItems = []
    for i in reversed(xrange(entries_nr)):
        item = QgsColorRampShader.ColorRampItem()
        item.value = currentValue
        item.label = unicode(currentValue)
        currentValue += intervalDiff
        item.color = colorRamp.color(float(i) / float(entries_nr))
        item.color.setAlphaF(0.75)
        colorRampItems.append(item)

    rasterShader = QgsRasterShader()
    colorRampShader = QgsColorRampShader()

    colorRampShader.setColorRampItemList(colorRampItems)
    colorRampShader.setColorRampType(QgsColorRampShader.INTERPOLATED)
    rasterShader.setRasterShaderFunction(colorRampShader)

    layer.setDrawingStyle('SingleBandPseudoColor')
    layer.renderer().setShader(rasterShader)

    QgsMapLayerRegistry.instance().addMapLayer(layer)

    return layer
示例#45
0
    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)
示例#46
0
def _setNewRasterStyle(theQgsRasterLayer, theStyle):
    """Set QGIS raster style based on InaSAFE style dictionary for QGIS >= 2.0.

    This function will set both the colour map and the transparency
    for the passed in layer.

    Args:
        * theQgsRasterLayer: QgsRasterLayer
        * style: Dictionary of the form as in the example below.

    Returns:
        * list: RangeList
        * list: TransparencyList

    Example:
        style_classes = [dict(colour='#38A800', quantity=2, transparency=0),
                         dict(colour='#38A800', quantity=5, transparency=50),
                         dict(colour='#79C900', quantity=10, transparency=50),
                         dict(colour='#CEED00', quantity=20, transparency=50),
                         dict(colour='#FFCC00', quantity=50, transparency=34),
                         dict(colour='#FF6600', quantity=100, transparency=77),
                         dict(colour='#FF0000', quantity=200, transparency=24),
                         dict(colour='#7A0000', quantity=300, transparency=22)]

    """
    # Note imports here to prevent importing on unsupported QGIS versions
    # pylint: disable=E0611
    # pylint: disable=W0621
    # pylint: disable=W0404
    from qgis.core import (QgsRasterShader,
                           QgsColorRampShader,
                           QgsSingleBandPseudoColorRenderer,
                           QgsRasterTransparency)
    # pylint: enable=E0611
    # pylint: enable=W0621
    # pylint: enable=W0404

    myClasses = theStyle['style_classes']
    myRampItemList = []
    myTransparencyList = []
    myLastValue = 0
    for myClass in myClasses:
        LOGGER.debug('Evaluating class:\n%s\n' % myClass)
        myMax = myClass['quantity']

        if math.isnan(myMax):
            LOGGER.debug('Skipping class.')
            continue

        myColour = QtGui.QColor(myClass['colour'])
        myLabel = QtCore.QString()
        if 'label' in myClass:
            myLabel = QtCore.QString(myClass['label'])
        myRampItem = QgsColorRampShader.ColorRampItem(myMax, myColour, myLabel)
        myRampItemList.append(myRampItem)
        # Create opacity entries for this range
        myTransparencyPercent = 0
        if 'transparency' in myClass:
            myTransparencyPercent = int(myClass['transparency'])
        if myTransparencyPercent > 0:
            # Check if range extrema are integers so we know if we can
            # use them to calculate a value range
            myPixel = QgsRasterTransparency.TransparentSingleValuePixel()
            myPixel.min = myLastValue
            myPixel.max = myMax
            myPixel.percentTransparent = myTransparencyPercent
            myTransparencyList.append(myPixel)
            myLastValue = myMax

    myBand = 1  # gdal counts bands from base 1
    LOGGER.debug('Setting colour ramp list')
    myRasterShader = QgsRasterShader()
    myColorRampShader = QgsColorRampShader()
    myColorRampShader.setColorRampType(QgsColorRampShader.INTERPOLATED)
    myColorRampShader.setColorRampItemList(myRampItemList)
    LOGGER.debug('Setting shader function')
    myRasterShader.setRasterShaderFunction(myColorRampShader)
    LOGGER.debug('Setting up renderer')
    myRenderer = QgsSingleBandPseudoColorRenderer(
        theQgsRasterLayer.dataProvider(),
        myBand,
        myRasterShader)
    LOGGER.debug('Assigning renderer to raster layer')
    theQgsRasterLayer.setRenderer(myRenderer)
    LOGGER.debug('Setting raster transparency list')
    #if len(myTransparencyList) > 0:
    #    myRasterTransparency = QgsRasterTransparency()
    #    myRasterTransparency.setTransparentSingleValuePixelList(
    #        myTransparencyList)
    #    myRenderer.setRasterTransparency(myRasterTransparency)
    LOGGER.debug('Saving style as default')
    theQgsRasterLayer.saveDefaultStyle()
    LOGGER.debug('Setting raster style done!')
    return myRampItemList, myTransparencyList