def _set_zeroes_invisible(self, layer): self.out("setting zeroes to 100% transparency") """ # Set 0 values to NODATA (= transparent): provider = active_raster_layer.dataProvider() provider.setNoDataValue(1, 0) # first one is referred to band number # -> is working """ # better, conserves 0 value: tr = QgsRasterTransparency() tr.initializeTransparentPixelList(0) layer.renderer().setRasterTransparency(tr)
def setTransparence(value, visible): t = QgsRasterTransparency.TransparentSingleValuePixel() t.min = t.max = value percent = 100.0 if not visible else 0.0 t.percentTransparent = percent return t
def setTransparency(raster): renderer = raster.renderer() tvp, setTransparent = None, None if isinstance(renderer, QgsSingleBandGrayRenderer): tvp = QgsRasterTransparency.TransparentSingleValuePixel() setTransparent = renderer.rasterTransparency( ).setTransparentSingleValuePixelList elif isinstance(renderer, QgsMultiBandColorRenderer): tvp = QgsRasterTransparency.TransparentThreeValuePixel() tvp.percentTransparent = 100.0 setTransparent = renderer.rasterTransparency( ).setTransparentThreeValuePixelList else: return tvp.percentTransparent = 100.0 setTransparent([tvp]) raster.triggerRepaint()
def load_vrt(self, iface, suffix=""): # Add to project layer = iface.addRasterLayer(self.path + ".vrt", "VRT-{}{}".format(self, suffix)) layer.setCrs(self.drone_map.crs_dest) # We make black pixels transparent to remove the rotated frame, not ideal if there are actually black pixels in the image rasterTransparency = layer.renderer().rasterTransparency() pixel = QgsRasterTransparency.TransparentThreeValuePixel() pixel.red, pixel.green, pixel.blue, pixel.percentTransparent = 0, 0, 0, 100 rasterTransparency.setTransparentThreeValuePixelList([pixel])
def testTransparency(self): 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 renderer = QgsSingleBandGrayRenderer(myRasterLayer.dataProvider(), 1) myRasterLayer.setRenderer(renderer) myRasterLayer.setContrastEnhancement( QgsContrastEnhancement.StretchToMinimumMaximum, QgsRasterMinMaxOrigin.MinMax) myContrastEnhancement = myRasterLayer.renderer().contrastEnhancement() # print ("myContrastEnhancement.minimumValue = %.17g" % # myContrastEnhancement.minimumValue()) # print ("myContrastEnhancement.maximumValue = %.17g" % # myContrastEnhancement.maximumValue()) # Unfortunately the minimum/maximum values calculated in C++ and Python # are slightly different (e.g. 3.3999999521443642e+38 x # 3.3999999521444001e+38) # It is not clear where the precision is lost. # We set the same values as C++. myContrastEnhancement.setMinimumValue(-3.3319999287625854e+38) myContrastEnhancement.setMaximumValue(3.3999999521443642e+38) #myType = myRasterLayer.dataProvider().dataType(1); #myEnhancement = QgsContrastEnhancement(myType); myTransparentSingleValuePixelList = [] rasterTransparency = QgsRasterTransparency() myTransparentPixel1 = \ QgsRasterTransparency.TransparentSingleValuePixel() myTransparentPixel1.min = -2.5840000772112106e+38 myTransparentPixel1.max = -1.0879999684602689e+38 myTransparentPixel1.percentTransparent = 50 myTransparentSingleValuePixelList.append(myTransparentPixel1) myTransparentPixel2 = \ QgsRasterTransparency.TransparentSingleValuePixel() myTransparentPixel2.min = 1.359999960575336e+37 myTransparentPixel2.max = 9.520000231087593e+37 myTransparentPixel2.percentTransparent = 70 myTransparentSingleValuePixelList.append(myTransparentPixel2) rasterTransparency.setTransparentSingleValuePixelList( myTransparentSingleValuePixelList) rasterRenderer = myRasterLayer.renderer() assert rasterRenderer rasterRenderer.setRasterTransparency(rasterTransparency) QgsProject.instance().addMapLayers([myRasterLayer, ]) myMapSettings = QgsMapSettings() myMapSettings.setLayers([myRasterLayer]) myMapSettings.setExtent(myRasterLayer.extent()) myChecker = QgsRenderChecker() myChecker.setControlName("expected_raster_transparency") myChecker.setMapSettings(myMapSettings) myResultFlag = myChecker.runTest("raster_transparency_python") assert myResultFlag, "Raster transparency rendering test failed"
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
def testTransparency(self): 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 renderer = QgsSingleBandGrayRenderer(myRasterLayer.dataProvider(), 1) myRasterLayer.setRenderer(renderer) myRasterLayer.setContrastEnhancementAlgorithm( QgsContrastEnhancement.StretchToMinimumMaximum, QgsRasterLayer.ContrastEnhancementMinMax) myContrastEnhancement = myRasterLayer.renderer().contrastEnhancement() #print ("myContrastEnhancement.minimumValue = %.17g" % # myContrastEnhancement.minimumValue()) #print ("myContrastEnhancement.maximumValue = %.17g" % # myContrastEnhancement.maximumValue()) # Unfortunately the minimum/maximum values calculated in C++ and Python # are slightly different (e.g. 3.3999999521443642e+38 x # 3.3999999521444001e+38) # It is not clear where the precision is lost. # We set the same values as C++. myContrastEnhancement.setMinimumValue(-3.3319999287625854e+38) myContrastEnhancement.setMaximumValue(3.3999999521443642e+38) #myType = myRasterLayer.dataProvider().dataType(1); #myEnhancement = QgsContrastEnhancement(myType); myTransparentSingleValuePixelList = [] rasterTransparency = QgsRasterTransparency() myTransparentPixel1 = \ QgsRasterTransparency.TransparentSingleValuePixel() myTransparentPixel1.min = -2.5840000772112106e+38 myTransparentPixel1.max = -1.0879999684602689e+38 myTransparentPixel1.percentTransparent = 50 myTransparentSingleValuePixelList.append(myTransparentPixel1) myTransparentPixel2 = \ QgsRasterTransparency.TransparentSingleValuePixel() myTransparentPixel2.min = 1.359999960575336e+37 myTransparentPixel2.max = 9.520000231087593e+37 myTransparentPixel2.percentTransparent = 70 myTransparentSingleValuePixelList.append(myTransparentPixel2) rasterTransparency.setTransparentSingleValuePixelList( myTransparentSingleValuePixelList) rasterRenderer = myRasterLayer.renderer() assert rasterRenderer rasterRenderer.setRasterTransparency(rasterTransparency) QgsMapLayerRegistry.instance().addMapLayers([ myRasterLayer, ]) myMapRenderer = QgsMapRenderer() myLayers = QStringList() myLayers.append(myRasterLayer.id()) myMapRenderer.setLayerSet(myLayers) myMapRenderer.setExtent(myRasterLayer.extent()) myChecker = QgsRenderChecker() myChecker.setControlName("expected_raster_transparency") myChecker.setMapRenderer(myMapRenderer) myResultFlag = myChecker.runTest("raster_transparency_python"); assert myResultFlag, "Raster transparency rendering test failed"
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
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
def processAlgorithm(self, parameters, context, feedback): feedback = QgsProcessingMultiStepFeedback(1, feedback) results = {} outputs = {} # Pfade definieren + Timestamp timestamp = datetime.datetime.now().strftime('%Y%m%d%H%M%S') temp_path = str(parameters[self.TEMP]) + '/temp_' + str(timestamp) final_path = str(parameters[self.TEMP]) + '/final_' + str(timestamp) if not os.path.exists(temp_path): os.makedirs(temp_path) if not os.path.exists(final_path): os.makedirs(final_path) #feedback.pushInfo(str(parameters[self.INPUT_extent])) ## Cell Size und EPSG-Code raster_cs = gdal.Open(str(parameters[self.INPUT_ALS_new])) gt_cs = raster_cs.GetGeoTransform() proj = osr.SpatialReference(wkt=raster_cs.GetProjection()) cs = gt_cs[1] epsg = proj.GetAttrValue('AUTHORITY', 1) srs = osr.SpatialReference() srs.ImportFromEPSG(int(epsg)) ## Buffer buffer = out = temp_path + '/' + 'extent.shp' alg_params = { 'DISSOLVE': False, 'DISTANCE': -0.1, 'END_CAP_STYLE': 2, 'INPUT': str(parameters[self.INPUT_Shape]), 'JOIN_STYLE': 1, 'MITER_LIMIT': 2, 'SEGMENTS': 1, 'OUTPUT': buffer } processing.run('native:buffer', alg_params, context=context, feedback=feedback, is_child_algorithm=True) ## Clip Rasters out_new = temp_path + '/' + 'dhm_new.tif' out_old = temp_path + '/' + 'dhm_old.tif' alg_params = { 'ALPHA_BAND': False, 'CROP_TO_CUTLINE': True, 'DATA_TYPE': 0, 'EXTRA': '', 'INPUT': str(parameters[self.INPUT_ALS_new]), 'KEEP_RESOLUTION': False, 'MASK': str(buffer), 'MULTITHREADING': False, 'NODATA': None, 'OPTIONS': '', 'SET_RESOLUTION': False, 'SOURCE_CRS': QgsCoordinateReferenceSystem('EPSG:' + str(epsg)), 'TARGET_CRS': QgsCoordinateReferenceSystem('EPSG:' + str(epsg)), 'X_RESOLUTION': None, 'Y_RESOLUTION': None, 'OUTPUT': out_new } processing.run('gdal:cliprasterbymasklayer', alg_params, context=context, feedback=feedback, is_child_algorithm=True) alg_params = { 'ALPHA_BAND': False, 'CROP_TO_CUTLINE': True, 'DATA_TYPE': 0, 'EXTRA': '', 'INPUT': str(parameters[self.INPUT_ALS_old]), 'KEEP_RESOLUTION': False, 'MASK': str(buffer), 'MULTITHREADING': False, 'NODATA': None, 'OPTIONS': '', 'SET_RESOLUTION': False, 'SOURCE_CRS': QgsCoordinateReferenceSystem('EPSG:' + str(epsg)), 'TARGET_CRS': QgsCoordinateReferenceSystem('EPSG:' + str(epsg)), 'X_RESOLUTION': None, 'Y_RESOLUTION': None, 'OUTPUT': out_old } processing.run('gdal:cliprasterbymasklayer', alg_params, context=context, feedback=feedback, is_child_algorithm=True) ## Cell Size/ Extent raster_cs = gdal.Open(out_new) gt_cs = raster_cs.GetGeoTransform() cs = gt_cs[1] del raster_cs del gt_cs dtm_clip_gdal = gdal.Open(out_new) format = "GTiff" driver = gdal.GetDriverByName(format) band1 = dtm_clip_gdal.GetRasterBand(1) im = Image.open(out_new) pix = im.load() gt = dtm_clip_gdal.GetGeoTransform() feedback.pushInfo(str(gt)) width = dtm_clip_gdal.RasterXSize height = dtm_clip_gdal.RasterYSize minx = gt[0] miny = gt[3] + width * gt[4] + height * gt[5] maxx = gt[0] + width * gt[1] + height * gt[2] maxy = gt[3] extent = str(minx) + "," + str(maxx) + "," + str(miny) + "," + str( maxy) extent2 = (minx, maxx, miny, maxy) feedback.pushInfo(str(extent)) feedback.pushInfo(str(width)) feedback.pushInfo(str(height)) # Create empty grids grid_diff = np.zeros(shape=(width, height), dtype=np.float32) grid_diff_uc = np.zeros(shape=(width, height), dtype=np.float32) ## DOD out2_old = temp_path + '/' + 'diff.tif' ##Rasters to Arrays new_rds = gdal.Open(out_new) format = "GTiff" driver1 = gdal.GetDriverByName(format) band_new = new_rds.GetRasterBand(1) im_new = Image.open(out_new) pix_new = im_new.load() old_rds = gdal.Open(out_old) format = "GTiff" driver2 = gdal.GetDriverByName(format) band_old = old_rds.GetRasterBand(1) im_old = Image.open(out_old) pix_old = im_old.load() for row in range(0, width): for col in range(0, height): val_new = pix_new[row, col] val_old = pix_old[row, col] if val_new > -9999.0: val_diff = val_new - val_old #feedback.pushInfo(str(val_new)) grid_diff[row, col] = val_diff grid_diff = np.flip(grid_diff, 1) grid_diff = np.rot90(grid_diff) imsave = Image.fromarray(grid_diff, mode='F') imsave.save(out2_old, "TIFF") ## Add Spatial Reference out2 = final_path + '/' + 'diff.tif' src_ds = gdal.Open(out2_old) format = "GTiff" driver = gdal.GetDriverByName(format) dst_ds = driver.CreateCopy(out2, src_ds, 0) dst_ds.SetGeoTransform(gt) srs = osr.SpatialReference() srs.ImportFromEPSG(int(epsg)) dest_wkt = srs.ExportToWkt() dst_ds.SetProjection(dest_wkt) # Close files dst_ds = None src_ds = None ## ----------------------------------------------------------------------------------------------------------## ## ChangeDetection (Uncertainty Model) sel = self.SELECTIONS[self.parameterAsEnum(parameters, self.SELECTION, context)] if str(sel) == str('UncertaintyModel'): feedback.pushInfo(str(sel)) out_uc = temp_path + '/' + 'dhm_uc.tif' alg_params = { 'ALPHA_BAND': False, 'CROP_TO_CUTLINE': True, 'DATA_TYPE': 0, 'EXTRA': '', 'INPUT': str(parameters[self.INPUT_UC]), 'KEEP_RESOLUTION': False, 'MASK': str(buffer), 'MULTITHREADING': False, 'NODATA': None, 'OPTIONS': '', 'SET_RESOLUTION': False, 'SOURCE_CRS': QgsCoordinateReferenceSystem('EPSG:' + str(epsg)), 'TARGET_CRS': QgsCoordinateReferenceSystem('EPSG:' + str(epsg)), 'X_RESOLUTION': None, 'Y_RESOLUTION': None, 'OUTPUT': out_uc } processing.run('gdal:cliprasterbymasklayer', alg_params, context=context, feedback=feedback, is_child_algorithm=True) del (out_uc) analyse = open(final_path + '/' + 'change_detection_UC.txt', "w") analyse_csv = open(final_path + '/' + 'change_detection_UC.csv', "w") analyse_csv.write( " ; AOI [m2]; Detectable Change [m2]; Detectable Change [%]; Surface Lowering [m2]; Surface Raising [m2]; Surface Lowering [m3]; Surface Raising [m3]; Volume of Difference [m3]; Net Volume of Difference [m3]" + "\n") ##Rasters to Arrays out_uc = temp_path + '/' + 'dhm_uc.tif' diff_rds = gdal.Open(out2) format = "GTiff" driver3 = gdal.GetDriverByName(format) band_diff = diff_rds.GetRasterBand(1) im_diff = Image.open(out2) pix_diff = im_diff.load() uc_rds = gdal.Open(out_uc) format = "GTiff" driver4 = gdal.GetDriverByName(format) band_uc = uc_rds.GetRasterBand(1) im_uc = Image.open(out_uc) pix_uc = im_uc.load() ## Classification1 - 0 % 0.1 countAOI = 0 countPosGes = 0 countNegGes = 0 countPos = 0 countNeg = 0 countPosArea = 0 countNegArea = 0 countPosAreaGes = 0 countNegAreaGes = 0 countAcc = 0 countCell = 0 countCellVol = 0 for row in range(0, width): for col in range(0, height): diff = pix_diff[row, col] if diff > -9999.0 and diff < 100: countAOI = countAOI + (cs * cs) if diff < 0 and diff > -100: volNegGes = cs * cs * (abs(diff)) countNegGes = countNegGes + volNegGes countNegAreaGes = countNegAreaGes + (cs * cs) if diff > 0 and diff < 100: volPosGes = cs * cs * (abs(diff)) countPosGes = countPosGes + volPosGes countPosAreaGes = countPosAreaGes + (cs * cs) if diff < -0.1 and diff > -100: # 0.1 m ist der Standardfehler zwischen den 2 Modellen volNeg = cs * cs * ( abs(diff) - 0.1 ) # -0.1 Standardfehler wird bei GCD-Tool nicht abgezogen countNeg = countNeg + volNeg countNegArea = countNegArea + (cs * cs) countAcc = countAcc + (cs * cs * 0.1) if diff > 0.1 and diff < 100: volPos = cs * cs * (diff - 0.1) countPos = countPos + (volPos) countPosArea = countPosArea + (cs * cs) countAcc = countAcc + (cs * cs * 0.1) if diff < 0 and diff > -0.1: countCell = countCell + 1 countCellVol = countCellVol + (cs * cs * abs(diff)) #print countCell if diff > 0 and diff < 0.1: countCell = countCell + 1 countCellVol = countCellVol + (cs * cs * abs(diff)) analyse.write("Total Area [m2] of Interest: " + str(countAOI) + "\n") analyse.write("Total Area [km2] of Interest: " + str(countAOI / 1000000) + "\n") analyse.write("\n") analyse.write("Total Area [m2] of Detectable Change: " + str(countPosAreaGes + countNegAreaGes) + "\n") analyse.write( "Total Area of Interest [%] with Detectable Change: " + str(((countPosAreaGes + countNegAreaGes) / countAOI) * 100) + "\n") analyse.write("Total Area [m2] of Surface Lowering: " + str(countNegAreaGes) + "\n") analyse.write("Total Area [m2] of Surface Raising: " + str(countPosAreaGes) + "\n") analyse.write("Total Volume [m3] of Surface Lowering: " + str(countNegGes) + "\n") analyse.write("Total Volume [m3] of Surface Raising: " + str(countPosGes) + "\n") analyse.write("Total Volume [m3] of Difference: " + str(countPosGes + countNegGes) + "\n") analyse.write("Total Net Volume [m3] of Difference: " + str(countPosGes - countNegGes) + "\n") analyse.write("\n") analyse.write("\n") analyse_csv.write( "0.0; " + str(countAOI) + "; " + str(countPosAreaGes + countNegAreaGes) + "; " + str(((countPosAreaGes + countNegAreaGes) / countAOI) * 100) + "; " + str(countNegAreaGes) + "; " + str(countPosAreaGes) + "; " + str(countNegGes) + "; " + str(countPosGes) + "; " + str(countPosGes + countNegGes) + "; " + str(countPosGes - countNegGes) + "\n") net_v_0 = countPosGes - countNegGes sr_0 = countPosGes sl_0 = countNegGes analyse.write("Analysis with Threshold of +/- 0.1" + "\n") analyse.write( "Thresholded (0.1) Area [m2] of Detectable Change: " + str(countPosArea + countNegArea) + "\n") analyse.write( "Thresholded (0.1) Area [km2] of Detectable Change: " + str((countPosArea + countNegArea) / 1000000) + "\n") analyse.write( "Thresholded (0.1) Area of Interest [%] with Detectable Change: " + str(((countPosArea + countNegArea) / countAOI) * 100) + "\n") analyse.write("Thresholded (0.1) Area [m2] of Surface Lowering: " + str(countNegArea) + "\n") analyse.write( "Thresholded (0.1) Area [km2] of Surface Lowering: " + str(countNegArea / 1000000) + "\n") analyse.write("Thresholded (0.1) Area [m2] of Surface Raising: " + str(countPosArea) + "\n") analyse.write("Thresholded (0.1) Area [km2] of Surface Raising: " + str(countPosArea / 1000000) + "\n") analyse.write( "Thresholded (0.1) Volume [m3] of Surface Lowering: " + str(countNeg) + "\n") analyse.write( "Thresholded (0.1) Volume [m3] of Surface Raising: " + str(countPos) + "\n") analyse.write("Thresholded (0.1) Volume [m3] of Difference: " + str(countPos + countNeg) + "\n") analyse.write("Thresholded (0.1) Net Volume [m3] of Difference: " + str(countPos - countNeg) + "\n") analyse.write("\n") analyse.write("\n") analyse.write( "Volume [m3] of Error within Threshold of -0.1 and 0.1: " + str(countAcc) + "\n") analyse.write("Count of Cells within -0.1 and 0.1: " + str(countCell) + "\n") analyse.write("Volume [m3] of Cells between -0.1 and 0.1: " + str(countCellVol) + "\n") analyse.write( "Percent [%] of Error of Cells between -0.1 and 0.1: " + str((countCellVol / (countPosGes + countNegGes)) * 100) + "\n") analyse.write("\n") analyse.write("\n") analyse_csv.write("0.1; " + str(countAOI) + "; " + str(countPosArea + countNegArea) + "; " + str(((countPosArea + countNegArea) / countAOI) * 100) + "; " + str(countNegArea) + "; " + str(countPosArea) + "; " + str(countNeg) + "; " + str(countPos) + "; " + str(countPos + countNeg) + "; " + str(countPos - countNeg) + "\n") net_v_1 = countPos - countNeg sr_1 = countPos sl_1 = countNeg del countPos del countNeg del countPosArea del countNegArea del countAcc del countCell del countCellVol ## Classification2 - 0.3 countPos = 0 countNeg = 0 countPosArea = 0 countNegArea = 0 countAcc = 0 countCell = 0 countCellVol = 0 for row in range(0, width): for col in range(0, height): diff = pix_diff[row, col] ES = pix_uc[row, col] ES2 = abs(ES) if diff < -0.3 and diff > -100: # 0.1 ist der Standardfehler zwischen den 2 Modellen volNeg = cs * cs * (abs(diff) - 0.3) countNeg = countNeg + volNeg countNegArea = countNegArea + (cs * cs) countAcc = countAcc + (cs * cs * 0.3) if diff > 0.3 and diff < 100: volPos = cs * cs * (diff - 0.3) countPos = countPos + (volPos) countPosArea = countPosArea + (cs * cs) countAcc = countAcc + (cs * cs * 0.3) if diff < 0 and diff > -0.3: countCell = countCell + 1 countCellVol = countCellVol + (cs * cs * abs(diff)) if diff > 0 and diff < 0.3: countCell = countCell + 1 countCellVol = countCellVol + (cs * cs * diff) analyse.write("Analysis with Threshold of +/- 0.3" + "\n") analyse.write( "Thresholded (0.3) Area [m2] of Detectable Change: " + str(countPosArea + countNegArea) + "\n") analyse.write( "Thresholded (0.3) Area [km2] of Detectable Change: " + str((countPosArea + countNegArea) / 1000000) + "\n") analyse.write( "Thresholded (0.3) of Interest [%] with Detectable Change: " + str(((countPosArea + countNegArea) / countAOI) * 100) + "\n") analyse.write("Thresholded (0.3) Area [m2] of Surface Lowering: " + str(countNegArea) + "\n") analyse.write( "Thresholded (0.3) Area [km2] of Surface Lowering: " + str(countNegArea / 1000000) + "\n") analyse.write("Thresholded (0.3) Area [m2] of Surface Raising: " + str(countPosArea) + "\n") analyse.write("Thresholded (0.3) Area [km2] of Surface Raising: " + str(countPosArea / 1000000) + "\n") analyse.write( "Thresholded (0.3) Volume [m3] of Surface Lowering: " + str(countNeg) + "\n") analyse.write( "Thresholded (0.3) Volume [m3] of Surface Raising: " + str(countPos) + "\n") analyse.write("Thresholded (0.3) Volume [m3] of Difference: " + str(countPos + countNeg) + "\n") analyse.write("Thresholded (0.3) Net Volume [m3] of Difference: " + str(countPos - countNeg) + "\n") analyse.write("\n") analyse.write( "Volume [m3] of Error within Threshold of -0.3 and 0.3: " + str(countAcc) + "\n") analyse.write("Count of Cells within -0.3 and 0.3: " + str(countCell) + "\n") analyse.write("Volume [m3] of Cells between -0.3 and 0.3: " + str(countCellVol) + "\n") analyse.write( "Percent [%] of Error of Cells between -0.3 and 0.3: " + str((countCellVol / (countPosGes + countNegGes)) * 100) + "\n") analyse.write("\n") analyse.write("\n") analyse_csv.write("0.3; " + str(countAOI) + "; " + str(countPosArea + countNegArea) + "; " + str(((countPosArea + countNegArea) / countAOI) * 100) + "; " + str(countNegArea) + "; " + str(countPosArea) + "; " + str(countNeg) + "; " + str(countPos) + "; " + str(countPos + countNeg) + "; " + str(countPos - countNeg) + "\n") net_v_2 = countPos - countNeg sr_2 = countPos sl_2 = countNeg del countPos del countNeg del countPosArea del countNegArea del countAcc del countCell del countCellVol ## Classification3 - UC countAOI = 0 countPosGes = 0 countNegGes = 0 countPos = 0 countNeg = 0 countPosArea = 0 countNegArea = 0 countES = 0 countESneg = 0 countESpos = 0 countAcc = 0 countCell = 0 countCellVol = 0 for row in range(0, width): for col in range(0, height): diff = pix_diff[row, col] ES = pix_uc[row, col] ES2 = abs(ES) if diff > -9999.0 and diff < 100: countAOI = countAOI + (cs * cs) if diff < -ES2 and diff > -100.0: grid_diff_uc[row, col] = diff + ES2 volESneg = cs * cs * (abs(diff) - ES2) countESneg = countESneg + volESneg countNegArea = countNegArea + (cs * cs) countAcc = countAcc + (cs * cs * ES2) if diff > ES2 and diff < 100: grid_diff_uc[row, col] = diff - ES2 volESpos = cs * cs * (diff - ES2) countESpos = countESpos + volESpos countPosArea = countPosArea + (cs * cs) countAcc = countAcc + (cs * cs * 0.1) if diff < 0 and diff > -ES2: grid_diff_uc[row, col] = 0.0 countCell = countCell + 1 countCellVol = countCellVol + (cs * cs * abs(diff)) #print countCell if diff > 0 and diff < ES2: grid_diff_uc[row, col] = 0.0 countCell = countCell + 1 countCellVol = countCellVol + (cs * cs * abs(diff)) analyse.write("Analysis including Uncertainty Analysis" + "\n") analyse.write("Thresholded Area [m2] of Detectable Change: " + str(countPosArea + countNegArea) + "\n") analyse.write( "Thresholded Area of Interest [%] with Detectable Change: " + str(((countPosArea + countNegArea) / countAOI) * 100) + "\n") analyse.write("Thresholded Volume [m3] of Surface Lowering: " + str(countESneg) + "\n") analyse.write("Thresholded Volume [m3] of Surface Raising: " + str(countESpos) + "\n") analyse.write("Total Volume [m3] of Difference: " + str(countESpos + countESneg) + "\n") analyse.write("Total Net Volume [m3] of Difference: " + str(countESpos - countESneg) + "\n") analyse.write("\n") analyse.write("\n") analyse.write("Volume [m3] of Error within Threshold of UC: " + str(countAcc) + "\n") analyse.write("Count of Cells within UC: " + str(countCell) + "\n") analyse.write("Volume [m3] of Cells between UC: " + str(countCellVol) + "\n") analyse.write("Percent [%] of Error of Cells between UC: " + str((countCellVol / (countESpos + countESneg)) * 100) + "\n") analyse.write("\n") analyse.write("\n") analyse_csv.write("UC; " + str(countAOI) + "; " + str(countPosArea + countNegArea) + "; " + str(((countPosArea + countNegArea) / countAOI) * 100) + "; ; ; " + str(countESneg) + "; " + str(countESpos) + "; " + str(countESpos + countESneg) + "; " + str(countESpos - countESneg) + "\n") net_v_3 = countESpos - countESneg sr_3 = countESpos sl_3 = countESneg ## BarChart plotdata = pd.DataFrame( { 'surface raising': [sr_0, sr_1, sr_2, sr_3], 'surface lowering': [-sl_0, -sl_1, -sl_2, -sl_3] }, index=['raw', '0.1 m', '0.3 m', 'UC model']) New_Colors = ['silver', 'dimgrey'] rcParams['font.family'] = 'sans-serif' rcParams['font.sans-serif'] = ['Verdana'] plotdata.plot(kind="bar", stacked=True, width=0.5, color=New_Colors, align='center', widtH=0.5) #plt.xticks(np.arange(0, 4, step=1)) plt.xticks(rotation=5, horizontalalignment="center") #plt.yticks(rotation=0, horizontalalignment="center") plt.title('volume changes [m3]', fontsize=10) plt.xlabel('threshold', fontsize=10) #plt.ylabel('volume changes [m3]', fontsize=10) #plt.ylabel('net volume [m3]', fontsize=10) plt.grid(True) plt.savefig(final_path + '/' + 'change_detection_plot.png') ## Grid UC out3 = temp_path + '/' + 'diff_uc_old.tif' out4 = final_path + '/' + 'diff_uc.tif' grid_diff_uc = np.flip(grid_diff_uc, 1) grid_diff_uc = np.rot90(grid_diff_uc) imsave = Image.fromarray(grid_diff_uc, mode='F') imsave.save(out3, "TIFF") ## Raster georeferenzieren src_ds = gdal.Open(out3) format = "GTiff" driver = gdal.GetDriverByName(format) dst_ds = driver.CreateCopy(out4, src_ds, 0) dst_ds.SetGeoTransform(gt) srs = osr.SpatialReference() srs.ImportFromEPSG(int(epsg)) dest_wkt = srs.ExportToWkt() dst_ds.SetProjection(dest_wkt) # Close files dst_ds = None src_ds = None ## ----------------------------------------------------------------------------------------------------------## ## ChangeDetection (Threshold) sel = self.SELECTIONS[self.parameterAsEnum(parameters, self.SELECTION, context)] if str(sel) == str('Threshold'): feedback.pushInfo(str(sel)) val = (parameters[self.INPUT_threshold]) analyse = open( final_path + '/' + 'change_detection_' + str(val) + '.txt', "w") analyse_csv = open( final_path + '/' + 'change_detection_' + str(val) + '.csv', "w") analyse_csv.write( " ; AOI [m2]; Detectable Change [m2]; Detectable Change [%]; Surface Lowering [m2]; Surface Raising [m2]; Surface Lowering [m3]; Surface Raising [m3]; Volume of Difference [m3]; Net Volume of Difference [m3]" + "\n") ##Rasters to Arrays #out_uc = temp_path + '/' + 'dhm_uc.tif' diff_rds = gdal.Open(out2) format = "GTiff" driver3 = gdal.GetDriverByName(format) band_diff = diff_rds.GetRasterBand(1) im_diff = Image.open(out2) pix_diff = im_diff.load() ## Classification1 - Threshold countAOI = 0 countPosGes = 0 countNegGes = 0 countPos = 0 countNeg = 0 countPosArea = 0 countNegArea = 0 countPosAreaGes = 0 countNegAreaGes = 0 countAcc = 0 countCell = 0 countCellVol = 0 for row in range(0, width): for col in range(0, height): diff = pix_diff[row, col] if diff > -9999.0 and diff < 100: countAOI = countAOI + (cs * cs) if diff < 0 and diff > -100: volNegGes = cs * cs * (abs(diff)) countNegGes = countNegGes + volNegGes countNegAreaGes = countNegAreaGes + (cs * cs) if diff > 0 and diff < 100: volPosGes = cs * cs * (abs(diff)) countPosGes = countPosGes + volPosGes countPosAreaGes = countPosAreaGes + (cs * cs) if diff < -val and diff > -100: grid_diff_uc[row, col] = diff + val volNeg = cs * cs * (abs(diff) - val) countNeg = countNeg + volNeg countNegArea = countNegArea + (cs * cs) countAcc = countAcc + (cs * cs * val) if diff > val and diff < 100: grid_diff_uc[row, col] = diff - val volPos = cs * cs * (diff - val) countPos = countPos + (volPos) countPosArea = countPosArea + (cs * cs) countAcc = countAcc + (cs * cs * val) if diff < 0 and diff > -val: grid_diff_uc[row, col] = 0.0 countCell = countCell + 1 countCellVol = countCellVol + (cs * cs * abs(diff)) #print countCell if diff > 0 and diff < val: grid_diff_uc[row, col] = 0.0 countCell = countCell + 1 countCellVol = countCellVol + (cs * cs * abs(diff)) analyse.write("Total Area [m2] of Interest: " + str(countAOI) + "\n") analyse.write("Total Area [km2] of Interest: " + str(countAOI / 1000000) + "\n") analyse.write("\n") analyse.write("Total Area [m2] of Detectable Change: " + str(countPosAreaGes + countNegAreaGes) + "\n") analyse.write( "Total Area of Interest [%] with Detectable Change: " + str(((countPosAreaGes + countNegAreaGes) / countAOI) * 100) + "\n") analyse.write("Total Area [m2] of Surface Lowering: " + str(countNegAreaGes) + "\n") analyse.write("Total Area [m2] of Surface Raising: " + str(countPosAreaGes) + "\n") analyse.write("Total Volume [m3] of Surface Lowering: " + str(countNegGes) + "\n") analyse.write("Total Volume [m3] of Surface Raising: " + str(countPosGes) + "\n") analyse.write("Total Volume [m3] of Difference: " + str(countPosGes + countNegGes) + "\n") analyse.write("Total Net Volume [m3] of Difference: " + str(countPosGes - countNegGes) + "\n") analyse.write("\n") analyse.write("\n") analyse_csv.write( "0.0; " + str(countAOI) + "; " + str(countPosAreaGes + countNegAreaGes) + "; " + str(((countPosAreaGes + countNegAreaGes) / countAOI) * 100) + "; " + str(countNegAreaGes) + "; " + str(countPosAreaGes) + "; " + str(countNegGes) + "; " + str(countPosGes) + "; " + str(countPosGes + countNegGes) + "; " + str(countPosGes - countNegGes) + "\n") net_v_0 = countPosGes - countNegGes sr_0 = countPosGes sl_0 = countNegGes analyse.write("Analysis with Threshold of +/- 0.1" + "\n") analyse.write( "Thresholded (0.1) Area [m2] of Detectable Change: " + str(countPosArea + countNegArea) + "\n") analyse.write( "Thresholded (0.1) Area [km2] of Detectable Change: " + str((countPosArea + countNegArea) / 1000000) + "\n") analyse.write( "Thresholded (0.1) Area of Interest [%] with Detectable Change: " + str(((countPosArea + countNegArea) / countAOI) * 100) + "\n") analyse.write("Thresholded (0.1) Area [m2] of Surface Lowering: " + str(countNegArea) + "\n") analyse.write( "Thresholded (0.1) Area [km2] of Surface Lowering: " + str(countNegArea / 1000000) + "\n") analyse.write("Thresholded (0.1) Area [m2] of Surface Raising: " + str(countPosArea) + "\n") analyse.write("Thresholded (0.1) Area [km2] of Surface Raising: " + str(countPosArea / 1000000) + "\n") analyse.write( "Thresholded (0.1) Volume [m3] of Surface Lowering: " + str(countNeg) + "\n") analyse.write( "Thresholded (0.1) Volume [m3] of Surface Raising: " + str(countPos) + "\n") analyse.write("Thresholded (0.1) Volume [m3] of Difference: " + str(countPos + countNeg) + "\n") analyse.write("Thresholded (0.1) Net Volume [m3] of Difference: " + str(countPos - countNeg) + "\n") analyse.write("\n") analyse.write("\n") analyse.write( "Volume [m3] of Error within Threshold of -0.1 and 0.1: " + str(countAcc) + "\n") analyse.write("Count of Cells within -0.1 and 0.1: " + str(countCell) + "\n") analyse.write("Volume [m3] of Cells between -0.1 and 0.1: " + str(countCellVol) + "\n") analyse.write( "Percent [%] of Error of Cells between -0.1 and 0.1: " + str((countCellVol / (countPosGes + countNegGes)) * 100) + "\n") analyse.write("\n") analyse.write("\n") analyse_csv.write("0.1; " + str(countAOI) + "; " + str(countPosArea + countNegArea) + "; " + str(((countPosArea + countNegArea) / countAOI) * 100) + "; " + str(countNegArea) + "; " + str(countPosArea) + "; " + str(countNeg) + "; " + str(countPos) + "; " + str(countPos + countNeg) + "; " + str(countPos - countNeg) + "\n") net_v_1 = countPos - countNeg sr_1 = countPos sl_1 = countNeg del countPos del countNeg del countPosArea del countNegArea del countAcc del countCell del countCellVol ## BarChart plotdata = pd.DataFrame( { 'surface raising': [sr_0, sr_1], 'surface lowering': [-sl_0, -sl_1] }, index=['raw', str(val) + ' m']) New_Colors = ['silver', 'dimgrey'] rcParams['font.family'] = 'sans-serif' rcParams['font.sans-serif'] = ['Verdana'] plotdata.plot(kind="bar", stacked=True, width=0.5, color=New_Colors, align='center', widtH=0.5) #plt.xticks(np.arange(0, 4, step=1)) plt.xticks(rotation=5, horizontalalignment="center") #plt.yticks(rotation=0, horizontalalignment="center") plt.title('volume changes [m3]', fontsize=10) plt.xlabel('threshold', fontsize=10) #plt.ylabel('volume changes [m3]', fontsize=10) #plt.ylabel('net volume [m3]', fontsize=10) plt.grid(True) plt.savefig(final_path + '/' + 'change_detection_plot.png') ## Grid UC out3 = temp_path + '/' + 'diff_thresholded_old.tif' out4 = final_path + '/' + 'diff_thresholded.tif' grid_diff_uc = np.flip(grid_diff_uc, 1) grid_diff_uc = np.rot90(grid_diff_uc) imsave = Image.fromarray(grid_diff_uc, mode='F') imsave.save(out3, "TIFF") ## Raster georeferenzieren src_ds = gdal.Open(out3) format = "GTiff" driver = gdal.GetDriverByName(format) dst_ds = driver.CreateCopy(out4, src_ds, 0) dst_ds.SetGeoTransform(gt) #srs = osr.SpatialReference() #srs.ImportFromEPSG(epsg) #dest_wkt = srs.ExportToWkt() dst_ds.SetProjection(dest_wkt) # Close files dst_ds = None src_ds = None feedback.pushInfo(str("OK")) ## ----------------------------------------------------------------------------------------------------------## ## Add Layer root = QgsProject.instance().layerTreeRoot() mygroup = root.insertGroup(1, "QCD_Tool") rlayer = QgsRasterLayer(out4, 'ChangeDetection') rprovider = rlayer.dataProvider() colDic = { 'f': '#d7191c', 'f1': '#eb6640', 'f2': '#feb165', 'f3': '#ffdc96', 'f4': '#ffffff', 'f5': '#ffffff', 'f6': '#9cd3a7', 'f7': '#5ea7b1', 'f8': '#2b83ba', 'f9': '#1e5c83' } valueList = [-3, -2, -1, -0.5, -0.05, 0.05, 0.5, 1, 2, 3] lst = [ QgsColorRampShader.ColorRampItem(valueList[0], QColor(colDic['f'])), QgsColorRampShader.ColorRampItem(valueList[1], QColor(colDic['f1'])), QgsColorRampShader.ColorRampItem(valueList[2], QColor(colDic['f2'])), QgsColorRampShader.ColorRampItem(valueList[3], QColor(colDic['f3'])), QgsColorRampShader.ColorRampItem(valueList[4], QColor(colDic['f4'])), QgsColorRampShader.ColorRampItem(valueList[5], QColor(colDic['f5'])), QgsColorRampShader.ColorRampItem(valueList[6], QColor(colDic['f6'])), QgsColorRampShader.ColorRampItem(valueList[7], QColor(colDic['f7'])), QgsColorRampShader.ColorRampItem(valueList[8], QColor(colDic['f8'])), QgsColorRampShader.ColorRampItem(valueList[9], QColor(colDic['f9'])) ] my_shader = QgsRasterShader() my_colorramp = QgsColorRampShader() #fcn = QgsColorRampShader() #fcn.setColorRampType(QgsColorRampShader.Interpolated) #lst = [ QgsColorRampShader.ColorRampItem(0, QColor(0,255,0)),QgsColorRampShader.ColorRampItem(255, QColor(255,255,0)) ] my_colorramp.setColorRampItemList(lst) my_colorramp.setColorRampType(QgsColorRampShader.Interpolated) my_shader.setRasterShaderFunction(my_colorramp) renderer = QgsSingleBandPseudoColorRenderer(rlayer.dataProvider(), 1, my_shader) rasterTransparency = QgsRasterTransparency() myTransparentSingleValuePixelList = [] myTransparentPixel1 = QgsRasterTransparency.TransparentSingleValuePixel( ) myTransparentPixel1.min = -0.05 myTransparentPixel1.max = 0.05 myTransparentPixel1.percentTransparent = 100 myTransparentSingleValuePixelList.append(myTransparentPixel1) rasterTransparency.setTransparentSingleValuePixelList( myTransparentSingleValuePixelList) renderer.setRasterTransparency(rasterTransparency) rlayer.setRenderer(renderer) rlayer.triggerRepaint() QgsProject.instance().addMapLayer(rlayer) mygroup.addLayer(rlayer) outputs['LastStep'] = out4 results['Tool abgeschlossen'] = outputs['LastStep'] return results
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
def _setLegacyRasterStyle(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: dict - 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:: There is currently a limitation in QGIS in that pixel transparency values can not be specified in ranges and consequently the opacity is of limited value and seems to only work effectively with integer values. """ theQgsRasterLayer.setDrawingStyle(QgsRasterLayer.PalettedColor) myClasses = theStyle['style_classes'] LOGGER.debug(myClasses) myRangeList = [] myTransparencyList = [] myLastValue = 0 for myClass in myClasses: LOGGER.debug('Evaluating class:\n%s\n' % myClass) myMax = myClass['quantity'] myColour = QtGui.QColor(myClass['colour']) myLabel = QtCore.QString() if 'label' in myClass: myLabel = QtCore.QString(myClass['label']) myShader = QgsColorRampShader.ColorRampItem(myMax, myColour, myLabel) myRangeList.append(myShader) if math.isnan(myMax): LOGGER.debug('Skipping class.') continue # Create opacity entries for this range myTransparencyPercent = 0 if 'transparency' in myClass: myTransparencyPercent = int(myClass['transparency']) if myTransparencyPercent > 0: # Always assign the transparency to the class' specified quantity myPixel = \ QgsRasterTransparency.TransparentSingleValuePixel() myPixel.pixelValue = myMax myPixel.percentTransparent = myTransparencyPercent myTransparencyList.append(myPixel) # Check if range extrema are integers so we know if we can # use them to calculate a value range if ((myLastValue == int(myLastValue)) and (myMax == int(myMax))): # Ensure that they are integers # (e.g 2.0 must become 2, see issue #126) myLastValue = int(myLastValue) myMax = int(myMax) # Set transparencies myRange = range(myLastValue, myMax) for myValue in myRange: myPixel = \ QgsRasterTransparency.TransparentSingleValuePixel() myPixel.pixelValue = myValue myPixel.percentTransparent = myTransparencyPercent myTransparencyList.append(myPixel) #myLabel = myClass['label'] # Apply the shading algorithm and design their ramp theQgsRasterLayer.setColorShadingAlgorithm(QgsRasterLayer.ColorRampShader) myFunction = theQgsRasterLayer.rasterShader().rasterShaderFunction() # Discrete will shade any cell between maxima of this break # and mamima of previous break to the colour of this break myFunction.setColorRampType(QgsColorRampShader.DISCRETE) myFunction.setColorRampItemList(myRangeList) # Now set the raster transparency theQgsRasterLayer.rasterTransparency()\ .setTransparentSingleValuePixelList(myTransparencyList) theQgsRasterLayer.saveDefaultStyle() return myRangeList, myTransparencyList
def getListTTVP(): t = QgsRasterTransparency.TransparentThreeValuePixel() t.red = t.green = t.blue = 0.0 t.percentTransparent = 100.0 return [t]