def postProcessAlgorithm(self, context, feedback):
output = QgsProcessingUtils.mapLayerFromString(self.output_model,
context)
provider = output.dataProvider()
stats = provider.bandStatistics(1, QgsRasterBandStats.All,
output.extent(), 0)
mean, sd = stats.mean, stats.stdDev
rnd = QgsSingleBandGrayRenderer(provider, 1)
ce = QgsContrastEnhancement(provider.dataType(1))
ce.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.StretchToMinimumMaximum)
ce.setMinimumValue(mean - 3 * sd)
ce.setMaximumValue(min(1, mean + 2 * sd))
rnd.setContrastEnhancement(ce)
output.setRenderer(rnd)
output.triggerRepaint()
return {self.OUTPUT: self.output_model}
def load_layer(self, layer):
r = layer.renderer().clone()
r.setRedBand(self._find_band(layer, "red", 0))
r.setGreenBand(self._find_band(layer, "green", 1))
r.setBlueBand(self._find_band(layer, "blue", 2))
usedBands = r.usesBands()
for b in range(3):
typ = layer.renderer().dataType(b)
enhancement = QgsContrastEnhancement(typ)
enhancement.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.StretchToMinimumMaximum, True)
bandMin, bandMax = layer.dataProvider().cumulativeCut(
usedBands[b], 0.02, 0.98, sampleSize=10000)
enhancement.setMinimumValue(bandMin)
enhancement.setMaximumValue(bandMax)
if b == 0:
r.setRedContrastEnhancement(enhancement)
elif b == 1:
r.setGreenContrastEnhancement(enhancement)
elif b == 2:
r.setBlueContrastEnhancement(enhancement)
layer.setRenderer(r)
QgsProject.instance().addMapLayer(layer)
def update_pc_style(self):
"""Update the grey style using mean+-5*std for all principal components
"""
for view_widget in MainAnalysisDialog.view_widgets:
if view_widget.pc_id is not None:
src_ds = gdal.Open(
str(get_file_path_of_layer(
view_widget.render_widget.layer)), gdal.GA_ReadOnly)
ds = src_ds.GetRasterBand(1).ReadAsArray().flatten().astype(
np.float32)
ds = ds[ds != 0]
try:
mean = np.mean(ds)
std = np.std(ds)
except:
continue
renderer = QgsSingleBandGrayRenderer(
view_widget.render_widget.layer.dataProvider(), 1)
ce = QgsContrastEnhancement(
view_widget.render_widget.layer.dataProvider().dataType(0))
ce.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.StretchToMinimumMaximum)
ce.setMinimumValue(mean - 5 * std)
ce.setMaximumValue(mean + 5 * std)
renderer.setContrastEnhancement(ce)
view_widget.render_widget.layer.setRenderer(renderer)
del src_ds, ds
def set_raster_renderer_to_singleband(layer: QgsRasterLayer, band: int = 1) -> None:
"""
Set raster renderer to singleband
:param layer: raster layer
:param band: band number starting from 1
"""
# https://gis.stackexchange.com/a/377631/123927 and
# https://gis.stackexchange.com/a/157573/123927
provider: QgsRasterDataProvider = layer.dataProvider()
renderer: QgsSingleBandGrayRenderer = QgsSingleBandGrayRenderer(
layer.dataProvider(), band
)
stats: QgsRasterBandStats = provider.bandStatistics(
band, QgsRasterBandStats.All, layer.extent(), 0
)
min_val = max(stats.minimumValue, 0)
max_val = max(stats.maximumValue, 0)
enhancement = QgsContrastEnhancement(renderer.dataType(band))
contrast_enhancement = QgsContrastEnhancement.StretchToMinimumMaximum
enhancement.setContrastEnhancementAlgorithm(contrast_enhancement, True)
enhancement.setMinimumValue(min_val)
enhancement.setMaximumValue(max_val)
layer.setRenderer(renderer)
layer.renderer().setContrastEnhancement(enhancement)
layer.triggerRepaint()
def contrastForRasters(the_raster_layer, min_layer, max_layer, band = None):
"""
Applies a contrast between min and max. If given min and max are 0, then calculates the min and max from gdal.
"""
# type of layer : raster, vector, other
type_of_layer = the_raster_layer.type()
# take the layer renderer to get the min and max
layer_renderer = the_raster_layer.renderer() # for qgis > 1.9
data_provider = the_raster_layer.data_provider()
# the layer has to be a raster layer
if type_of_layer == 1:
if the_raster_layer.rasterType() == 0 and layer_renderer:
# gray band
# layer_renderer <qgis.core.QgsSingleBandGrayRenderer object at 0x514caf0>
layerCE = layer_renderer.contrastEnhancement()
# take the contrast enhancement of the layer threw the renderer
if layerCE:
layerCE.setContrastEnhancementAlgorithm(3) # qgis 1.9
layerCE.setMinimumValue(min_layer)
layerCE.setMaximumValue(max_layer)
elif the_raster_layer.rasterType() == 2 and layer_renderer:
if min_layer == 0 and max_layer == 0:
if band:
min1, max1 = get_min_max_via_qgis(the_raster_layer, band[0])
min2, max2 = get_min_max_via_qgis(the_raster_layer, band[1])
min3, max3 = get_min_max_via_qgis(the_raster_layer, band[2])
# # min1, max1, _, _ = terre_image_utils.computeStatistics(the_raster_layer.source(),0, band[0])
# # min2, max2, _, _ = terre_image_utils.computeStatistics(the_raster_layer.source(),0, band[1])
# # min3, max3, _, _ = terre_image_utils.computeStatistics(the_raster_layer.source(),0, band[2])
# # #print min1, max1, min2, max2, min3, max3
else:
min1, max1, _, _ = OTBApplications.computeStatistics(the_raster_layer.source(), 0, 1)
min2, max2, _, _ = OTBApplications.computeStatistics(the_raster_layer.source(), 0, 2)
min3, max3, _, _ = OTBApplications.computeStatistics(the_raster_layer.source(), 0, 3)
red_enhancement = QgsContrastEnhancement(data_provider.dataType(0))
green_enhancement = QgsContrastEnhancement(data_provider.dataType(1))
blue_enhancement = QgsContrastEnhancement(data_provider.dataType(2))
# set stretch to min max
red_enhancement.setMinimumValue(min1)
red_enhancement.setMaximumValue(max1)
green_enhancement.setMinimumValue(min2)
green_enhancement.setMaximumValue(max2)
blue_enhancement.setMinimumValue(min3)
blue_enhancement.setMaximumValue(max3)
red_enhancement.setContrastEnhancementAlgorithm(3)
green_enhancement.setContrastEnhancementAlgorithm(3)
blue_enhancement.setContrastEnhancementAlgorithm(3)
layer_renderer.setRedContrastEnhancement(red_enhancement) # , QgsRaster.ContrastEnhancementCumulativeCut )
layer_renderer.setGreenContrastEnhancement(green_enhancement) # , QgsRaster.ContrastEnhancementCumulativeCut )
layer_renderer.setBlueContrastEnhancement(blue_enhancement) # , QgsRaster.ContrastEnhancementCumulativeCut )
the_raster_layer.triggerRepaint()
def testRenderWithContrast(self):
layer = QgsPointCloudLayer(
unitTestDataPath() + '/point_clouds/ept/rgb/ept.json', 'test',
'ept')
self.assertTrue(layer.isValid())
layer.renderer().setPointSize(2)
layer.renderer().setPointSizeUnit(QgsUnitTypes.RenderMillimeters)
redce = QgsContrastEnhancement()
redce.setMinimumValue(100)
redce.setMaximumValue(120)
redce.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.StretchToMinimumMaximum)
layer.renderer().setRedContrastEnhancement(redce)
greence = QgsContrastEnhancement()
greence.setMinimumValue(130)
greence.setMaximumValue(150)
greence.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.StretchToMinimumMaximum)
layer.renderer().setGreenContrastEnhancement(greence)
bluece = QgsContrastEnhancement()
bluece.setMinimumValue(170)
bluece.setMaximumValue(190)
bluece.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.StretchToMinimumMaximum)
layer.renderer().setBlueContrastEnhancement(bluece)
mapsettings = QgsMapSettings()
mapsettings.setOutputSize(QSize(400, 400))
mapsettings.setOutputDpi(96)
mapsettings.setDestinationCrs(layer.crs())
mapsettings.setExtent(
QgsRectangle(497753.5, 7050887.5, 497754.6, 7050888.6))
mapsettings.setLayers([layer])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('pointcloudrenderer')
renderchecker.setControlName('expected_rgb_contrast')
result = renderchecker.runTest('expected_rgb_contrast')
TestQgsPointCloudRgbRenderer.report += renderchecker.report()
self.assertTrue(result)
def custom_stretch(the_raster_layer, values, canvas, mono = False):
"""
Applies a contrast between min and max. If given min and max are 0, then calculates the min and max from gdal.
"""
# logger.info("#######################")
logger.info("custom stretch: values")
logger.info(values)
# print "custom stretch"
# print canvas
# print "layer :", the_raster_layer
# type of layer : raster, vector, other
type_of_layer = the_raster_layer.type()
# take the layer renderer to get the min and max
layer_renderer = the_raster_layer.renderer() # for qgis > 1.9
data_provider = the_raster_layer.dataProvider()
# print "values", values
# the layer has to be a raster layer
if type_of_layer == 1:
if (the_raster_layer.rasterType() == 0 or mono) and layer_renderer:
min_layer, max_layer = values[0]
# gray band
# layer_renderer <qgis.core.QgsSingleBandGrayRenderer object at 0x514caf0>
gray_enhancement = QgsContrastEnhancement(data_provider.dataType(1))
# take the contrast enhancement of the layer threw the renderer
if gray_enhancement:
gray_enhancement.setContrastEnhancementAlgorithm(1) # qgis 1.9
gray_enhancement.setMinimumValue(min_layer)
gray_enhancement.setMaximumValue(max_layer)
layer_renderer.setContrastEnhancement(gray_enhancement)
elif the_raster_layer.rasterType() == 2 and layer_renderer:
# print "layer 3 bandes"
min_red, max_red = values[0]
min_green, max_green = values[1]
min_blue, max_blue = values[2]
logger.debug("red : " + str(min_red) + " " + str(max_red))
logger.debug("green : " + str(min_green) + " " + str(max_green))
logger.debug("blue : " + str(min_blue) + " " + str(max_blue))
red_enhancement = QgsContrastEnhancement(data_provider.dataType(1))
green_enhancement = QgsContrastEnhancement(data_provider.dataType(2))
blue_enhancement = QgsContrastEnhancement(data_provider.dataType(3))
logger.debug("red_enhancement : " + str(red_enhancement))
logger.debug("green_enhancement : " + str(green_enhancement))
logger.debug("blue_enhancement : " + str(blue_enhancement))
# set stretch to min max
red_enhancement.setMinimumValue(min_red)
red_enhancement.setMaximumValue(max_red)
green_enhancement.setMinimumValue(min_green)
green_enhancement.setMaximumValue(max_green)
blue_enhancement.setMinimumValue(min_blue)
blue_enhancement.setMaximumValue(max_blue)
logger.debug("red (1): " + str(red_enhancement.minimumValue()) + " " + str(red_enhancement.maximumValue()))
logger.debug("green (1): " + str(green_enhancement.minimumValue()) + " " + str(green_enhancement.maximumValue()))
logger.debug("blue (1): " + str(blue_enhancement.minimumValue()) + " " + str(blue_enhancement.maximumValue()))
red_enhancement.setContrastEnhancementAlgorithm(1)
green_enhancement.setContrastEnhancementAlgorithm(1)
blue_enhancement.setContrastEnhancementAlgorithm(1)
logger.debug("red (2): " + str(red_enhancement.minimumValue()) + " " + str(red_enhancement.maximumValue()))
logger.debug("green (2): " + str(green_enhancement.minimumValue()) + " " + str(green_enhancement.maximumValue()))
logger.debug("blue (2): " + str(blue_enhancement.minimumValue()) + " " + str(blue_enhancement.maximumValue()))
# print "blue enhancement", blue_enhancement
# print "blue max", blue_enhancement.maximumValue()
# print "blue min", blue_enhancement.minimumValue()
layer_renderer.setRedContrastEnhancement(red_enhancement) # , QgsRaster.ContrastEnhancementCumulativeCut )
layer_renderer.setGreenContrastEnhancement(green_enhancement) # , QgsRaster.ContrastEnhancementCumulativeCut )
layer_renderer.setBlueContrastEnhancement(blue_enhancement) # , QgsRaster.ContrastEnhancementCumulativeCut )
# print "layer renderer"
red_enhancement_debug = layer_renderer.redContrastEnhancement()
green_enhancement_debug = layer_renderer.greenContrastEnhancement()
blue_enhancement_debug = layer_renderer.blueContrastEnhancement()
logger.debug("red (3): " + str(red_enhancement_debug.minimumValue()) + " " + str(red_enhancement_debug.maximumValue()))
logger.debug("green (3): " + str(green_enhancement_debug.minimumValue()) + " " + str(green_enhancement_debug.maximumValue()))
logger.debug("blue (3): " + str(blue_enhancement_debug.minimumValue()) + " " + str(blue_enhancement_debug.maximumValue()))
# print "end"
the_raster_layer.setCacheImage(None)
the_raster_layer.triggerRepaint()
# print "2"
canvas.refresh()
canvas.repaint()
def testBasic(self):
renderer = QgsPointCloudRgbRenderer()
renderer.setBlueAttribute('b')
self.assertEqual(renderer.blueAttribute(), 'b')
renderer.setGreenAttribute('g')
self.assertEqual(renderer.greenAttribute(), 'g')
renderer.setRedAttribute('r')
self.assertEqual(renderer.redAttribute(), 'r')
redce = QgsContrastEnhancement()
redce.setMinimumValue(100)
redce.setMaximumValue(120)
redce.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.StretchAndClipToMinimumMaximum)
renderer.setRedContrastEnhancement(redce)
greence = QgsContrastEnhancement()
greence.setMinimumValue(130)
greence.setMaximumValue(150)
greence.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.StretchToMinimumMaximum)
renderer.setGreenContrastEnhancement(greence)
bluece = QgsContrastEnhancement()
bluece.setMinimumValue(170)
bluece.setMaximumValue(190)
bluece.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.ClipToMinimumMaximum)
renderer.setBlueContrastEnhancement(bluece)
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.blueAttribute(), 'b')
self.assertEqual(rr.greenAttribute(), 'g')
self.assertEqual(rr.redAttribute(), 'r')
self.assertEqual(rr.redContrastEnhancement().minimumValue(), 100)
self.assertEqual(rr.redContrastEnhancement().maximumValue(), 120)
self.assertEqual(
rr.redContrastEnhancement().contrastEnhancementAlgorithm(),
QgsContrastEnhancement.StretchAndClipToMinimumMaximum)
self.assertEqual(rr.greenContrastEnhancement().minimumValue(), 130)
self.assertEqual(rr.greenContrastEnhancement().maximumValue(), 150)
self.assertEqual(
rr.greenContrastEnhancement().contrastEnhancementAlgorithm(),
QgsContrastEnhancement.StretchToMinimumMaximum)
self.assertEqual(rr.blueContrastEnhancement().minimumValue(), 170)
self.assertEqual(rr.blueContrastEnhancement().maximumValue(), 190)
self.assertEqual(
rr.blueContrastEnhancement().contrastEnhancementAlgorithm(),
QgsContrastEnhancement.ClipToMinimumMaximum)
doc = QDomDocument("testdoc")
elem = renderer.save(doc, QgsReadWriteContext())
r2 = QgsPointCloudRgbRenderer.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.blueAttribute(), 'b')
self.assertEqual(r2.greenAttribute(), 'g')
self.assertEqual(r2.redAttribute(), 'r')
self.assertEqual(r2.redContrastEnhancement().minimumValue(), 100)
self.assertEqual(r2.redContrastEnhancement().maximumValue(), 120)
self.assertEqual(
r2.redContrastEnhancement().contrastEnhancementAlgorithm(),
QgsContrastEnhancement.StretchAndClipToMinimumMaximum)
self.assertEqual(r2.greenContrastEnhancement().minimumValue(), 130)
self.assertEqual(r2.greenContrastEnhancement().maximumValue(), 150)
self.assertEqual(
r2.greenContrastEnhancement().contrastEnhancementAlgorithm(),
QgsContrastEnhancement.StretchToMinimumMaximum)
self.assertEqual(r2.blueContrastEnhancement().minimumValue(), 170)
self.assertEqual(r2.blueContrastEnhancement().maximumValue(), 190)
self.assertEqual(
r2.blueContrastEnhancement().contrastEnhancementAlgorithm(),
QgsContrastEnhancement.ClipToMinimumMaximum)
def dynamics_multi_band(self, layer_renderer, list_canvas_layer):
"""
Applies the dynamic of the selected layer to all multi band layers
:param layer_renderer:
:param list_canvas_layer:
:return:
"""
# layer_renderer
# <qgis.core.QgsMultiBandColorRenderer object at 0x514c9e0>
layer_ce_red = layer_renderer.redContrastEnhancement()
layer_ce_green = layer_renderer.greenContrastEnhancement()
layer_ce_blue = layer_renderer.blueContrastEnhancement()
if layer_ce_red and layer_ce_green and layer_ce_blue:
# set stretch to min max
layer_ce_red.setContrastEnhancementAlgorithm(1)
layer_ce_green.setContrastEnhancementAlgorithm(1)
layer_ce_blue.setContrastEnhancementAlgorithm(1)
logger.debug("red :" +
str(layer_ce_red.contrastEnhancementAlgorithm()))
logger.debug("green:" +
str(layer_ce_green.contrastEnhancementAlgorithm()))
logger.debug("blue :" +
str(layer_ce_blue.contrastEnhancementAlgorithm()))
# get the min and max of RGB bands
max_current_red = layer_ce_red.maximumValue()
min_current_red = layer_ce_red.minimumValue()
logger.debug("min red:" + str(min_current_red) + "max red:" +
str(max_current_red))
max_current_green = layer_ce_green.maximumValue()
min_current_green = layer_ce_green.minimumValue()
logger.debug("min green:" + str(min_current_green) + "max green:" +
str(max_current_green))
max_current_blue = layer_ce_blue.maximumValue()
min_current_blue = layer_ce_blue.minimumValue()
logger.debug("min blue:" + str(min_current_blue) + "max blue:" +
str(max_current_blue))
# for each layer
logger.debug("there are" + str(len(list_canvas_layer)) +
" layers in the canvas")
for layer_from_list in list_canvas_layer:
logger.debug("layer from list name :" +
str(layer_from_list.name()))
# which is raster
if layer_from_list.type() == QGIS_LAYER_TYPE:
logger.debug("layer from list is a raster file")
# which is multi
if layer_from_list.rasterType() == 2:
logger.debug("multiband file")
data_provider = layer_from_list.dataProvider()
# take the layer renderer to set the min and max
renderer_from_list = layer_from_list.renderer()
# <qgis.core.QgsMultiBandColorRenderer object at 0x3f8a8d0>
logger.debug("renderer from list" +
str(renderer_from_list))
logger.debug("green band" +
str(renderer_from_list.greenBand()))
logger.debug("blue band" +
str(renderer_from_list.blueBand()))
logger.debug("red band" +
str(renderer_from_list.redBand()))
logger.info(renderer_from_list)
red_enhancement = QgsContrastEnhancement(
data_provider.dataType(1))
if red_enhancement:
red_enhancement.setMinimumValue(min_current_red)
red_enhancement.setMaximumValue(max_current_red)
red_enhancement.setContrastEnhancementAlgorithm(1)
renderer_from_list.setRedContrastEnhancement(
red_enhancement)
green_enhancement = QgsContrastEnhancement(
data_provider.dataType(2))
if green_enhancement:
green_enhancement.setMinimumValue(
min_current_green)
green_enhancement.setMaximumValue(
max_current_green)
green_enhancement.setContrastEnhancementAlgorithm(
1)
renderer_from_list.setGreenContrastEnhancement(
green_enhancement)
blue_enhancement = QgsContrastEnhancement(
data_provider.dataType(3))
if blue_enhancement:
blue_enhancement.setMinimumValue(min_current_blue)
blue_enhancement.setMaximumValue(max_current_blue)
blue_enhancement.setContrastEnhancementAlgorithm(1)
renderer_from_list.setBlueContrastEnhancement(
blue_enhancement)
layer_from_list.triggerRepaint()
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()