コード例 #1
0
    def dynamicsMultiBand(self, layerRenderer, listCanvasLayer):
        """
        Applies the dynamic of the selected layer to all multi band layers
        :param layerRenderer:
        :param listCanvasLayer:
        :return:
        """
        #       layerRenderer
        #       <qgis.core.QgsMultiBandColorRenderer object at 0x514c9e0>
        layerCERed = layerRenderer.redContrastEnhancement()
        layerCEGreen = layerRenderer.greenContrastEnhancement()
        layerCEBlue = layerRenderer.blueContrastEnhancement()

        if layerCERed and layerCEGreen and layerCEBlue:
            #set stretch to min max
            layerCERed.setContrastEnhancementAlgorithm(1)
            layerCEGreen.setContrastEnhancementAlgorithm(1)
            layerCEBlue.setContrastEnhancementAlgorithm(1)

            logger.debug("red :" +
                         str(layerCERed.contrastEnhancementAlgorithm()))
            logger.debug("green:" +
                         str(layerCEGreen.contrastEnhancementAlgorithm()))
            logger.debug("blue :" +
                         str(layerCEBlue.contrastEnhancementAlgorithm()))

            #get the min and max of RGB bands
            maxCurrentRed = layerCERed.maximumValue()
            minCurrentRed = layerCERed.minimumValue()

            logger.debug("min red:" + str(minCurrentRed) + "max red:" +
                         str(maxCurrentRed))

            maxCurrentGreen = layerCEGreen.maximumValue()
            minCurrentGreen = layerCEGreen.minimumValue()

            logger.debug("min green:" + str(minCurrentGreen) + "max green:" +
                         str(maxCurrentGreen))

            maxCurrentBlue = layerCEBlue.maximumValue()
            minCurrentBlue = layerCEBlue.minimumValue()

            logger.debug("min blue:" + str(minCurrentBlue) + "max blue:" +
                         str(maxCurrentBlue))

            # for each layer
            logger.debug("there are" + str(len(listCanvasLayer)) +
                         " layers in the canvas")
            for layerFromList in listCanvasLayer:
                logger.debug("layer from list name :" +
                             str(layerFromList.name()))

                # which is raster
                if layerFromList.type() == 1:
                    logger.debug("layer from list is a raster file")

                    # which is multi
                    if layerFromList.rasterType() == 2:
                        logger.debug("multiband file")

                        dataProvider = layerFromList.dataProvider()
                        #take the layer renderer to set the min and max
                        rendererFromList = layerFromList.renderer()
                        #<qgis.core.QgsMultiBandColorRenderer object at 0x3f8a8d0>
                        logger.debug("renderer from list" +
                                     str(rendererFromList))

                        logger.debug("green band" +
                                     str(rendererFromList.greenBand()))
                        logger.debug("blue band" +
                                     str(rendererFromList.blueBand()))
                        logger.debug("red band" +
                                     str(rendererFromList.redBand()))

                        logger.info(rendererFromList)

                        redEnhancement = None
                        if QGis.QGIS_VERSION_INT == 10800:  # for QGIS = 1.8
                            redEnhancement = QgsContrastEnhancement(
                                QgsContrastEnhancement.QgsRasterDataType(
                                    dataProvider.dataType(0)))
                        elif QGis.QGIS_VERSION_INT >= 10900:  # for QGIS = 1.9
                            redEnhancement = QgsContrastEnhancement(
                                dataProvider.dataType(1))

                        if redEnhancement:
                            redEnhancement.setMinimumValue(minCurrentRed)
                            redEnhancement.setMaximumValue(maxCurrentRed)
                            redEnhancement.setContrastEnhancementAlgorithm(1)
                            rendererFromList.setRedContrastEnhancement(
                                redEnhancement)

                        greenEnhancement = None
                        if QGis.QGIS_VERSION_INT == 10800:  # for QGIS = 1.8
                            greenEnhancement = QgsContrastEnhancement(
                                QgsContrastEnhancement.QgsRasterDataType(
                                    dataProvider.dataType(1)))
                        elif QGis.QGIS_VERSION_INT >= 10900:  # for QGIS = 1.9
                            greenEnhancement = QgsContrastEnhancement(
                                dataProvider.dataType(2))

                        if greenEnhancement:
                            greenEnhancement.setMinimumValue(minCurrentGreen)
                            greenEnhancement.setMaximumValue(maxCurrentGreen)
                            greenEnhancement.setContrastEnhancementAlgorithm(1)
                            rendererFromList.setGreenContrastEnhancement(
                                greenEnhancement)

                        blueEnhancement = None
                        if QGis.QGIS_VERSION_INT == 10800:  # for QGIS = 1.8
                            blueEnhancement = QgsContrastEnhancement(
                                QgsContrastEnhancement.QgsRasterDataType(
                                    dataProvider.dataType(2)))
                        elif QGis.QGIS_VERSION_INT >= 10900:  # for QGIS = 1.9
                            blueEnhancement = QgsContrastEnhancement(
                                dataProvider.dataType(3))

                        if blueEnhancement:
                            blueEnhancement.setMinimumValue(minCurrentBlue)
                            blueEnhancement.setMaximumValue(maxCurrentBlue)
                            blueEnhancement.setContrastEnhancementAlgorithm(1)
                            rendererFromList.setBlueContrastEnhancement(
                                blueEnhancement)

                        layerFromList.setCacheImage(None)
                        layerFromList.triggerRepaint()