def clip_raster(raster, column_count, row_count, output_extent): """Clip raster to specified extent, width and height. Note there is similar utility in safe_qgis.utilities.clipper, but it uses gdal whereas this one uses native QGIS. :param raster: Raster :type raster: QgsRasterLayer :param column_count: Desired width in pixels of new raster :type column_count: Int :param row_count: Desired height in pixels of new raster :type row_count: Int :param output_extent: Extent of the clipped region :type output_extent: QgsRectangle :returns: Clipped region of the raster :rtype: QgsRasterLayer """ provider = raster.dataProvider() pipe = QgsRasterPipe() pipe.set(provider.clone()) base_name = unique_filename() file_name = base_name + ".tif" file_writer = QgsRasterFileWriter(file_name) file_writer.writeRaster(pipe, column_count, row_count, output_extent, raster.crs()) return QgsRasterLayer(file_name, "clipped_raster")
def raster_to_file(self, layer, filename): ''' write the contents of the raster-layer to a file (tif) ''' extent = layer.extent() width, height = layer.width(), layer.height() pipe = QgsRasterPipe() # setting renderer leads to export as rendered image (strange: causes conversion from grayscale to multicolor with 4 bands) # else raw data is written (in grayscale) #renderer = layer.renderer() provider = layer.dataProvider() #pipe.set(renderer.clone()) pipe.set(provider.clone()) # another possible way to pipe (take the referenced one), references the renderer as well # -> causes wrong color bands while exporting (see some lines above) #pipe = layer.pipe() file_writer = QgsRasterFileWriter(filename) file_writer.writeRaster(pipe, width, height, extent, layer.crs())
def read_from_qgis_native(self, qgis_layer): """Read raster data from qgis layer QgsRasterLayer. A stub is used now: save all data in a file, then call safe.read_from_file Raises: * TypeError if qgis is not avialable * IOError if can't store temporary file * GetDataError if can't create copy of qgis_layer's dataProvider """ base_name = unique_filename() file_name = base_name + '.tif' file_writer = QgsRasterFileWriter(file_name) pipe = QgsRasterPipe() provider = qgis_layer.dataProvider() if not pipe.set(provider.clone()): msg = "Cannot set pipe provider" raise GetDataError(msg) file_writer.writeRaster( pipe, provider.xSize(), provider.ySize(), provider.extent(), provider.crs()) # Write keywords if any write_keywords(self.keywords, base_name + '.keywords') self.read_from_file(file_name)
def _add_raster_layer(self, raster_layer, layer_name, save_style=False): """Add a raster layer to the folder. :param raster_layer: The layer to add. :type raster_layer: QgsRasterLayer :param layer_name: The name of the layer in the datastore. :type layer_name: str :param save_style: If we have to save a QML too. Default to False. :type save_style: bool :returns: A two-tuple. The first element will be True if we could add the layer to the datastore. The second element will be the layer name which has been used or the error message. :rtype: (bool, str) .. versionadded:: 4.0 """ if not self.is_writable(): return False, 'The destination is not writable.' output = QFileInfo(self.uri.filePath(layer_name + '.tif')) source = QFileInfo(raster_layer.source()) if source.exists() and source.suffix() in ['tiff', 'tif']: # If it's tiff file based. QFile.copy(source.absoluteFilePath(), output.absoluteFilePath()) else: # If it's not file based. renderer = raster_layer.renderer() provider = raster_layer.dataProvider() crs = raster_layer.crs() pipe = QgsRasterPipe() pipe.set(provider.clone()) pipe.set(renderer.clone()) file_writer = QgsRasterFileWriter(output.absoluteFilePath()) file_writer.Mode(1) file_writer.writeRaster( pipe, provider.xSize(), provider.ySize(), provider.extent(), crs) del file_writer if save_style: style_path = QFileInfo(self.uri.filePath(layer_name + '.qml')) raster_layer.saveNamedStyle(style_path.absoluteFilePath()) assert output.exists() return True, output.baseName()
def testDriverForExtension(self): self.assertEqual(QgsRasterFileWriter.driverForExtension('tif'), 'GTiff') self.assertEqual(QgsRasterFileWriter.driverForExtension('TIF'), 'GTiff') self.assertEqual(QgsRasterFileWriter.driverForExtension('tIf'), 'GTiff') self.assertEqual(QgsRasterFileWriter.driverForExtension('.tif'), 'GTiff') self.assertEqual(QgsRasterFileWriter.driverForExtension('img'), 'HFA') self.assertEqual(QgsRasterFileWriter.driverForExtension('.vrt'), 'VRT') self.assertEqual(QgsRasterFileWriter.driverForExtension('.jpg'), 'JPEG') self.assertEqual(QgsRasterFileWriter.driverForExtension('asc'), 'AAIGrid') self.assertEqual(QgsRasterFileWriter.driverForExtension('not a format'), '') self.assertEqual(QgsRasterFileWriter.driverForExtension(''), '')
def getFileFilter(param): """ Returns a suitable file filter pattern for the specified parameter definition :param param: :return: """ if param.type() == 'layer': vectors = QgsProviderRegistry.instance().fileVectorFilters().split(';;') vectors.pop(0) rasters = QgsProviderRegistry.instance().fileRasterFilters().split(';;') rasters.pop(0) filters = set(vectors + rasters) filters = sorted(filters) return tr('All files (*.*)') + ';;' + ";;".join(filters) elif param.type() == 'multilayer': if param.layerType() == QgsProcessing.TypeRaster: exts = QgsRasterFileWriter.supportedFormatExtensions() elif param.layerType() == QgsProcessing.TypeFile: return tr('All files (*.*)', 'QgsProcessingParameterMultipleLayers') else: exts = QgsVectorFileWriter.supportedFormatExtensions() for i in range(len(exts)): exts[i] = tr('{0} files (*.{1})', 'QgsProcessingParameterMultipleLayers').format(exts[i].upper(), exts[i].lower()) return tr('All files (*.*)') + ';;' + ';;'.join(exts) elif param.type() == 'raster': return QgsProviderRegistry.instance().fileRasterFilters() elif param.type() == 'rasterDestination': if param.provider() is not None: exts = param.provider().supportedOutputRasterLayerExtensions() else: exts = QgsRasterFileWriter.supportedFormatExtensions() for i in range(len(exts)): exts[i] = tr('{0} files (*.{1})', 'ParameterRaster').format(exts[i].upper(), exts[i].lower()) return ';;'.join(exts) + ';;' + tr('All files (*.*)') elif param.type() in ('sink', 'vectorDestination'): if param.provider() is not None: exts = param.provider().supportedOutputVectorLayerExtensions() else: exts = QgsVectorFileWriter.supportedFormatExtensions() for i in range(len(exts)): exts[i] = tr('{0} files (*.{1})', 'ParameterVector').format(exts[i].upper(), exts[i].lower()) return ';;'.join(exts) + ';;' + tr('All files (*.*)') elif param.type() == 'source': return QgsProviderRegistry.instance().fileVectorFilters() elif param.type() == 'vector': return QgsProviderRegistry.instance().fileVectorFilters() elif param.type() == 'fileDestination': return param.fileFilter() + ';;' + tr('All files (*.*)') if param.defaultFileExtension(): return tr('Default extension') + ' (*.' + param.defaultFileExtension() + ')' else: return ''
def testSupportedFiltersAndFormat(self): # test with formats in recommended order formats = QgsRasterFileWriter.supportedFiltersAndFormats(QgsRasterFileWriter.SortRecommended) self.assertEqual(formats[0].filterString, 'GeoTIFF (*.tif *.TIF *.tiff *.TIFF)') self.assertEqual(formats[0].driverName, 'GTiff') self.assertTrue('netCDF' in [f.driverName for f in formats]) # alphabetical sorting formats2 = QgsRasterFileWriter.supportedFiltersAndFormats(QgsRasterFileWriter.RasterFormatOptions()) self.assertTrue(formats2[0].driverName < formats2[1].driverName) self.assertCountEqual([f.driverName for f in formats], [f.driverName for f in formats2]) self.assertNotEqual(formats2[0].driverName, 'GTiff')
def testSupportedFormatExtensions(self): formats = QgsRasterFileWriter.supportedFormatExtensions() self.assertTrue('tif' in formats) self.assertFalse('exe' in formats) self.assertEqual(formats[0], 'tif') self.assertTrue('nc' in formats) # alphabetical sorting formats2 = QgsRasterFileWriter.supportedFormatExtensions(QgsRasterFileWriter.RasterFormatOptions()) self.assertTrue(formats2[1] < formats2[2]) self.assertCountEqual(formats, formats2) self.assertNotEqual(formats2[0], 'tif')
def run_raster_upload(self): # The selected layer should be a raster layer. layer = self.iface.activeLayer() if not isinstance(layer, QgsRasterLayer): pop_up_info("Error: you must select the raster layer") return fd, tiff_filename = tempfile.mkstemp(suffix='.tiff') os.close(fd) # ^^^ We just want the filename, not the opened file descriptor. provider = layer.dataProvider() pipe = QgsRasterPipe() pipe.set(provider.clone()) file_writer = QgsRasterFileWriter(tiff_filename) file_writer.writeRaster(pipe, provider.xSize(), provider.ySize(), provider.extent(), provider.crs()) # http://build-failed.blogspot.nl/2014/12/splitting-vector-and-raster-files-in.html # print(tiff_filename) # Optionally TODO: grab title from dialog. title = "Uploaded by the qgis plugin on %s" % ( datetime.datetime.now().isoformat()) form = urllib2_upload.MultiPartForm() form.add_field('title', title) form.add_field('organisation_id', str(self.selected_organisation)) filename = os.path.basename(tiff_filename) form.add_file('raster_file', filename, fileHandle=open(tiff_filename, 'rb')) request = urllib2.Request('https://ggmn.un-igrac.org/upload_raster/') request.add_header('User-agent', 'qgis ggmn uploader') request.add_header('username', self.username) request.add_header('password', self.password) body = str(form) request.add_header('Content-type', form.get_content_type()) request.add_header('Content-length', len(body)) # print("content-length: %s" % len(body)) request.add_data(body) fd2, logfile = tempfile.mkstemp(prefix="uploadlog", suffix=".txt") open(logfile, 'w').write(request.get_data()) # print("Printed what we'll send to %s" % logfile) answer = urllib2.urlopen(request).read() # print(answer) # print("Uploaded geotiff to the server") pop_up_info("Uploaded geotiff to the server")
def polygonize_gdal( raster, threshold_min=0.0, threshold_max=float('inf')): """ Function to polygonize raster. Areas (pixels) with threshold_min < pixel_values < threshold_max will be converted to polygons. :param raster: Raster layer :type raster: QgsRasterLayer :param threshold_min: Value that splits raster to flooded or not flooded. :type threshold_min: float :param threshold_max: Value that splits raster to flooded or not flooded. :type threshold_max: float :returns: Polygonal geometry :rtype: QgsGeometry """ # save qgis raster to disk base_name = unique_filename() file_name = base_name + '.tif' file_writer = QgsRasterFileWriter(file_name) pipe = QgsRasterPipe() provider = raster.dataProvider() if not pipe.set(provider.clone()): msg = "Cannot set pipe provider" raise GetDataError(msg) file_writer.writeRaster( pipe, provider.xSize(), provider.ySize(), provider.extent(), provider.crs()) ( inside_file_name, inside_layer_name, outside_file_name, outside_layer_name ) = polygonize_thresholds(file_name, threshold_min, threshold_max) inside_layer = \ QgsVectorLayer(inside_file_name, inside_layer_name, 'ogr') outside_layer = \ QgsVectorLayer(outside_file_name, outside_layer_name, 'ogr') if inside_layer.featureCount() == 0: return None, None else: return inside_layer, outside_layer
def getConsoleCommands(self, parameters, context, feedback, executing=True): inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) sourceCrs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context) targetCrs = self.parameterAsCrs(parameters, self.TARGET_CRS, context) nodata = self.parameterAsDouble(parameters, self.NODATA, context) resolution = self.parameterAsDouble(parameters, self.TARGET_RESOLUTION, context) arguments = [] if sourceCrs.isValid(): arguments.append('-s_srs') arguments.append(sourceCrs.authid()) if targetCrs.isValid(): arguments.append('-t_srs') arguments.append(targetCrs.authid()) if nodata: arguments.append('-dstnodata') arguments.append(str(nodata)) if resolution: arguments.append('-tr') arguments.append(str(resolution)) arguments.append(str(resolution)) arguments.append('-r') arguments.append(self.methods[self.parameterAsEnum(parameters, self.RESAMPLING, context)][1]) extent = self.parameterAsExtent(parameters, self.TARGET_EXTENT, context) if not extent.isNull(): arguments.append('-te') arguments.append(extent.xMinimum()) arguments.append(extent.yMinimum()) arguments.append(extent.xMaximum()) arguments.append(extent.yMaximum()) extentCrs = self.parameterAsCrs(parameters, self.TARGET_EXTENT_CRS, context) if extentCrs: arguments.append('-te_srs') arguments.append(extentCrs.authid()) if self.parameterAsBool(parameters, self.MULTITHREADING, context): arguments.append('-multi') arguments.append('-ot') arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)]) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.extend(GdalUtils.parseCreationOptions(options)) arguments.append(inLayer.source()) arguments.append(out) return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback): arguments = ['aspect'] inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) arguments.append(inLayer.source()) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append(out) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) arguments.append('-b') arguments.append(str(self.parameterAsInt(parameters, self.BAND, context))) if self.parameterAsBool(parameters, self.TRIG_ANGLE, context): arguments.append('-trigonometric') if self.parameterAsBool(parameters, self.ZERO_FLAT, context): arguments.append('-zero_for_flat') if self.parameterAsBool(parameters, self.COMPUTE_EDGES, context): arguments.append('-compute_edges') if self.parameterAsBool(parameters, self.ZEVENBERGEN, context): arguments.append('-alg') arguments.append('ZevenbergenThorne') options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.append('-co') arguments.append(options) return ['gdaldem', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True): inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) bbox = self.parameterAsExtent(parameters, self.EXTENT, context, inLayer.crs()) nodata = self.parameterAsDouble(parameters, self.NODATA, context) options = self.parameterAsString(parameters, self.OPTIONS, context) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments = [] arguments.append('-projwin') arguments.append(str(bbox.xMinimum())) arguments.append(str(bbox.yMaximum())) arguments.append(str(bbox.xMaximum())) arguments.append(str(bbox.yMinimum())) if nodata: arguments.append('-a_nodata {}'.format(nodata)) arguments.append('-ot') arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)]) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) if options: arguments.append('-co') arguments.append(options) arguments.append(inLayer.source()) arguments.append(out) return ['gdal_translate', GdalUtils.escapeAndJoin(arguments)]
def test02_SaveAsGeoTIFF(self): """Save raster layer as a GeoTIFF file""" self._testAvailable() or self.skipTest("Not available") layer = self._testLayer(self.fileName) # write to a disk # ref. to the InaSAFE plugin provider = layer.dataProvider() pipe = QgsRasterPipe() assert pipe.set(provider.clone()), "cannot set provider to pipe" outfile = self._testDataPath(self.fileName, output=True) writer = QgsRasterFileWriter(outfile) assert not writer.writeRaster(pipe, provider.xSize(), provider.ySize(), provider.extent(), provider.crs()), "failed to write" assert os.path.exists(outfile), "output file cannot be found"
def getConsoleCommands(self, parameters, context, feedback, executing=True): inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if inLayer is None: raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT)) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments = [] bands = self.parameterAsInts(parameters, self.BANDS, context) for band in bands: arguments.append('-b {}'.format(band)) data_type = self.parameterAsEnum(parameters, self.DATA_TYPE, context) if data_type: arguments.append('-ot ' + self.TYPES[data_type]) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.extend(GdalUtils.parseCreationOptions(options)) arguments.append(inLayer.source()) arguments.append(out) return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True): ogrLayer, layerName = self.getOgrCompatibleSource(self.INPUT, parameters, context, feedback, executing) arguments = ['-l'] arguments.append(layerName) fieldName = self.parameterAsString(parameters, self.Z_FIELD, context) if fieldName: arguments.append('-zfield') arguments.append(fieldName) params = 'nearest' params += ':radius1={}'.format(self.parameterAsDouble(parameters, self.RADIUS_1, context)) params += ':radius2={}'.format(self.parameterAsDouble(parameters, self.RADIUS_2, context)) params += ':angle={}'.format(self.parameterAsDouble(parameters, self.ANGLE, context)) params += ':nodata={}'.format(self.parameterAsDouble(parameters, self.NODATA, context)) arguments.append('-a') arguments.append(params) arguments.append('-ot') arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)]) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) self.setOutputValue(self.OUTPUT, out) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.extend(GdalUtils.parseCreationOptions(options)) arguments.append(ogrLayer) arguments.append(out) return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback): ogrLayer, layerName = self.getOgrCompatibleSource(self.INPUT, parameters, context, feedback) arguments = ['-l'] arguments.append(layerName) fieldName = self.parameterAsString(parameters, self.Z_FIELD, context) if fieldName: arguments.append('-zfield') arguments.append(fieldName) params = 'linear' params += ':radius={}'.format(self.parameterAsDouble(parameters, self.RADIUS, context)) params += ':nodata={}'.format(self.parameterAsDouble(parameters, self.NODATA, context)) arguments.append('-a') arguments.append(params) arguments.append('-ot') arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)]) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.append('-co') arguments.append(options) arguments.append(ogrLayer) arguments.append(out) return ['gdal_grid', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True): arguments = ['color-relief'] inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if inLayer is None: raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT)) arguments.append(inLayer.source()) arguments.append(self.parameterAsFile(parameters, self.COLOR_TABLE, context)) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) self.setOutputValue(self.OUTPUT, out) arguments.append(out) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) arguments.append('-b') arguments.append(str(self.parameterAsInt(parameters, self.BAND, context))) if self.parameterAsBoolean(parameters, self.COMPUTE_EDGES, context): arguments.append('-compute_edges') arguments.append(self.modes[self.parameterAsEnum(parameters, self.MATCH_MODE, context)][1]) return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True): arguments = ['aspect'] inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if inLayer is None: raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT)) arguments.append(inLayer.source()) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append(out) self.setOutputValue(self.OUTPUT, out) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) arguments.append('-b') arguments.append(str(self.parameterAsInt(parameters, self.BAND, context))) if self.parameterAsBoolean(parameters, self.TRIG_ANGLE, context): arguments.append('-trigonometric') if self.parameterAsBoolean(parameters, self.ZERO_FLAT, context): arguments.append('-zero_for_flat') if self.parameterAsBoolean(parameters, self.COMPUTE_EDGES, context): arguments.append('-compute_edges') if self.parameterAsBoolean(parameters, self.ZEVENBERGEN, context): arguments.append('-alg') arguments.append('ZevenbergenThorne') options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.extend(GdalUtils.parseCreationOptions(options)) return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True): arguments = ['roughness'] inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if inLayer is None: raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT)) arguments.append(inLayer.source()) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append(out) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) arguments.append('-b') arguments.append(str(self.parameterAsInt(parameters, self.BAND, context))) if self.parameterAsBool(parameters, self.COMPUTE_EDGES, context): arguments.append('-compute_edges') options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.append('-co') arguments.append(options) return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True): arguments = [] arguments.append('-st') arguments.append(str(self.parameterAsInt(parameters, self.THRESHOLD, context))) if self.parameterAsBool(parameters, self.EIGHT_CONNECTEDNESS, context): arguments.append('-8') else: arguments.append('-4') if self.parameterAsBool(parameters, self.NO_MASK, context): arguments.append('-nomask') mask = self.parameterAsRasterLayer(parameters, self.INPUT, context) if mask: arguments.append('-mask {}'.format(mask.source())) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) arguments.append(self.parameterAsRasterLayer(parameters, self.INPUT, context).source()) arguments.append(out) commands = [] if isWindows(): commands = ['cmd.exe', '/C ', 'gdal_sieve.bat', GdalUtils.escapeAndJoin(arguments)] else: commands = ['gdal_sieve.py', GdalUtils.escapeAndJoin(arguments)] return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True): inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if inLayer is None: raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT)) arguments = [] arguments.append(inLayer.source()) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) arguments.append('-o') arguments.append(out) arguments.append('-near') arguments.append(str(self.parameterAsInt(parameters, self.NEAR, context))) if self.parameterAsBool(parameters, self.WHITE, context): arguments.append('-white') options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.extend(GdalUtils.parseCreationOptions(options)) return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, parameters, context, feedback): inputFile = self.parameterAsRasterLayer(parameters, self.INPUT, context).source() zFactor = self.parameterAsDouble(parameters, self.Z_FACTOR, context) automaticColors = self.parameterAsBoolean(parameters, self.AUTO_COLORS, context) outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) frequencyDistribution = self.parameterAsFileOutput(parameters, self.FREQUENCY_DISTRIBUTION, context) outputFormat = QgsRasterFileWriter.driverForExtension(os.path.splitext(outputFile)[1]) relief = QgsRelief(inputFile, outputFile, outputFormat) if automaticColors: reliefColors = relief.calculateOptimizedReliefClasses() else: colors = ParameterReliefColors.valueToColors(parameters[self.COLORS]) if colors is None or len(colors) == 0: raise QgsProcessingException( self.tr('Specify relief colors or activate "Generate relief classes automatically" option.')) reliefColors = [] for c in colors: v = c.split(',') color = QgsRelief.ReliefColor(QColor(int(v[2]), int(v[3]), int(v[4])), float(v[0]), float(v[1])) reliefColors.append(color) relief.setReliefColors(reliefColors) relief.setZFactor(zFactor) if frequencyDistribution: relief.exportFrequencyDistributionToCsv(frequencyDistribution) relief.processRaster(feedback) return {self.OUTPUT: outputFile, self.FREQUENCY_DISTRIBUTION: frequencyDistribution}
def getConsoleCommands(self, parameters, context, feedback, executing=True): arguments = [] arguments.append('-st') arguments.append(str(self.parameterAsInt(parameters, self.THRESHOLD, context))) if self.parameterAsBool(parameters, self.EIGHT_CONNECTEDNESS, context): arguments.append('-8') else: arguments.append('-4') if self.parameterAsBool(parameters, self.NO_MASK, context): arguments.append('-nomask') mask = self.parameterAsRasterLayer(parameters, self.MASK_LAYER, context) if mask: arguments.append('-mask {}'.format(mask.source())) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) raster = self.parameterAsRasterLayer(parameters, self.INPUT, context) if raster is None: raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT)) arguments.append(raster.source()) arguments.append(out) commands = [self.commandName() + '.py', GdalUtils.escapeAndJoin(arguments)] if isWindows(): commands.insert(0, 'python3') return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True): arguments = [] inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if inLayer is None: raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT)) arguments.append(inLayer.source()) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) self.setOutputValue(self.OUTPUT, out) arguments.append(out) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) arguments.append('-b') arguments.append(str(self.parameterAsInt(parameters, self.BAND, context))) if self.parameterAsBoolean(parameters, self.RGBA, context): arguments.append('-rgba') if isWindows(): commands = ["python3", "-m", self.commandName()] else: commands = [self.commandName() + '.py'] commands.append(GdalUtils.escapeAndJoin(arguments)) return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True): spectral = self.parameterAsRasterLayer(parameters, self.SPECTRAL, context) if spectral is None: raise QgsProcessingException(self.invalidRasterError(parameters, self.SPECTRAL)) panchromatic = self.parameterAsRasterLayer(parameters, self.PANCHROMATIC, context) if panchromatic is None: raise QgsProcessingException(self.invalidRasterError(parameters, self.PANCHROMATIC)) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) self.setOutputValue(self.OUTPUT, out) arguments = [] arguments.append(panchromatic.source()) arguments.append(spectral.source()) arguments.append(out) arguments.append('-r') arguments.append(self.methods[self.parameterAsEnum(parameters, self.RESAMPLING, context)][1]) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.extend(GdalUtils.parseCreationOptions(options)) if isWindows(): commands = ['python3', '-m', self.commandName()] else: commands = [self.commandName() + '.py'] commands.append(GdalUtils.escapeAndJoin(arguments)) return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True): inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) nodata = self.parameterAsDouble(parameters, self.NODATA, context) arguments = [] crs = self.parameterAsCrs(parameters, self.TARGET_CRS, context) if crs.isValid(): arguments.append('-a_srs') arguments.append(crs.authid()) if nodata: arguments.append('-a_nodata') arguments.append(nodata) if self.parameterAsBool(parameters, self.COPY_SUBDATASETS, context): arguments.append('-sds') arguments.append('-ot') arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)]) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.append('-co') arguments.append(options) arguments.append(inLayer.source()) arguments.append(out) return ['gdal_translate', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True): arguments = ['slope'] inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) arguments.append(inLayer.source()) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append(out) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) arguments.append('-b') arguments.append(str(self.parameterAsInt(parameters, self.BAND, context))) arguments.append('-s') arguments.append(str(self.parameterAsDouble(parameters, self.SCALE, context))) if self.parameterAsBool(parameters, self.AS_PERCENT, context): arguments.append('-p') if self.parameterAsBool(parameters, self.COMPUTE_EDGES, context): arguments.append('-compute_edges') if self.parameterAsBool(parameters, self.ZEVENBERGEN, context): arguments.append('-alg') arguments.append('ZevenbergenThorne') options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.append('-co') arguments.append(options) return ['gdaldem', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True): arguments = [] inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) arguments.append(inLayer.source()) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append(out) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) arguments.append('-b') arguments.append(str(self.parameterAsInt(parameters, self.BAND, context))) if self.parameterAsBool(parameters, self.RGBA, context): arguments.append('-rgba') commands = [] if isWindows(): commands = ['cmd.exe', '/C ', 'pct2rgb.bat', GdalUtils.escapeAndJoin(arguments)] else: commands = ['pct2rgb.py', GdalUtils.escapeAndJoin(arguments)] return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True): inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if inLayer is None: raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT)) distance = self.parameterAsDouble(parameters, self.MAX_DISTANCE, context) replaceValue = self.parameterAsDouble(parameters, self.REPLACE, context) if self.NODATA in parameters and parameters[self.NODATA] is not None: nodata = self.parameterAsDouble(parameters, self.NODATA, context) else: nodata = None options = self.parameterAsString(parameters, self.OPTIONS, context) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) self.setOutputValue(self.OUTPUT, out) arguments = [] arguments.append('-srcband') arguments.append(str(self.parameterAsInt(parameters, self.BAND, context))) arguments.append('-distunits') arguments.append(self.distanceUnits[self.parameterAsEnum(parameters, self.UNITS, context)][1]) values = self.parameterAsString(parameters, self.VALUES, context) if values: arguments.append('-values') arguments.append(values) if distance: arguments.append('-maxdist') arguments.append(str(distance)) if nodata is not None: arguments.append('-nodata') arguments.append(str(nodata)) if replaceValue: arguments.append('-fixed-buf-val') arguments.append(str(replaceValue)) arguments.append('-ot') arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)]) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) if options: arguments.extend(GdalUtils.parseCreationOptions(options)) arguments.append(inLayer.source()) arguments.append(out) if isWindows(): commands = ["python3", "-m", self.commandName()] else: commands = [self.commandName() + '.py'] commands.append(GdalUtils.escapeAndJoin(arguments)) return commands
def getFileFilter(param): """ Returns a suitable file filter pattern for the specified parameter definition :param param: :return: """ if param.type() == 'layer': vectors = QgsProviderRegistry.instance().fileVectorFilters().split( ';;') vectors.pop(0) rasters = QgsProviderRegistry.instance().fileRasterFilters().split( ';;') rasters.pop(0) filters = set(vectors + rasters) filters = sorted(filters) return tr('All files (*.*)') + ';;' + ";;".join(filters) elif param.type() == 'multilayer': if param.layerType() == QgsProcessing.TypeRaster: exts = QgsRasterFileWriter.supportedFormatExtensions() elif param.layerType() == QgsProcessing.TypeFile: return tr('All files (*.*)', 'QgsProcessingParameterMultipleLayers') else: exts = QgsVectorFileWriter.supportedFormatExtensions() for i in range(len(exts)): exts[i] = tr('{0} files (*.{1})', 'QgsProcessingParameterMultipleLayers').format( exts[i].upper(), exts[i].lower()) return tr('All files (*.*)') + ';;' + ';;'.join(exts) elif param.type() == 'raster': return QgsProviderRegistry.instance().fileRasterFilters() elif param.type() == 'rasterDestination': if param.provider() is not None: exts = param.provider().supportedOutputRasterLayerExtensions() else: exts = QgsRasterFileWriter.supportedFormatExtensions() for i in range(len(exts)): exts[i] = tr('{0} files (*.{1})', 'ParameterRaster').format(exts[i].upper(), exts[i].lower()) return ';;'.join(exts) + ';;' + tr('All files (*.*)') elif param.type() in ('sink', 'vectorDestination'): if param.provider() is not None: exts = param.provider().supportedOutputVectorLayerExtensions() else: exts = QgsVectorFileWriter.supportedFormatExtensions() for i in range(len(exts)): exts[i] = tr('{0} files (*.{1})', 'ParameterVector').format(exts[i].upper(), exts[i].lower()) return ';;'.join(exts) + ';;' + tr('All files (*.*)') elif param.type() == 'source': return QgsProviderRegistry.instance().fileVectorFilters() elif param.type() == 'vector': return QgsProviderRegistry.instance().fileVectorFilters() elif param.type() == 'fileDestination': return param.fileFilter() + ';;' + tr('All files (*.*)') if param.defaultFileExtension(): return tr( 'Default extension') + ' (*.' + param.defaultFileExtension() + ')' else: return ''
def initialize(): icon = QgsApplication.getThemeIcon("/processingAlgorithm.svg") ProcessingConfig.settingIcons['General'] = icon ProcessingConfig.addSetting( Setting(ProcessingConfig.tr('General'), ProcessingConfig.SHOW_DEBUG_IN_DIALOG, ProcessingConfig.tr('Show extra info in Log panel'), True)) ProcessingConfig.addSetting( Setting( ProcessingConfig.tr('General'), ProcessingConfig.KEEP_DIALOG_OPEN, ProcessingConfig.tr( 'Keep dialog open after running an algorithm'), True)) ProcessingConfig.addSetting( Setting(ProcessingConfig.tr('General'), ProcessingConfig.USE_FILENAME_AS_LAYER_NAME, ProcessingConfig.tr('Use filename as layer name'), False)) ProcessingConfig.addSetting( Setting(ProcessingConfig.tr('General'), ProcessingConfig.SHOW_RECENT_ALGORITHMS, ProcessingConfig.tr('Show recently executed algorithms'), True)) ProcessingConfig.addSetting( Setting( ProcessingConfig.tr('General'), ProcessingConfig.SHOW_PROVIDERS_TOOLTIP, ProcessingConfig.tr( 'Show tooltip when there are disabled providers'), True)) ProcessingConfig.addSetting( Setting(ProcessingConfig.tr('General'), ProcessingConfig.OUTPUT_FOLDER, ProcessingConfig.tr('Output folder'), defaultOutputFolder(), valuetype=Setting.FOLDER)) ProcessingConfig.addSetting( Setting( ProcessingConfig.tr('General'), ProcessingConfig.SHOW_CRS_DEF, ProcessingConfig.tr( 'Show layer CRS definition in selection boxes'), True)) ProcessingConfig.addSetting( Setting( ProcessingConfig.tr('General'), ProcessingConfig.WARN_UNMATCHING_CRS, ProcessingConfig.tr( "Warn before executing if parameter CRS's do not match"), True)) ProcessingConfig.addSetting( Setting(ProcessingConfig.tr('General'), ProcessingConfig.RASTER_STYLE, ProcessingConfig.tr('Style for raster layers'), '', valuetype=Setting.FILE)) ProcessingConfig.addSetting( Setting(ProcessingConfig.tr('General'), ProcessingConfig.VECTOR_POINT_STYLE, ProcessingConfig.tr('Style for point layers'), '', valuetype=Setting.FILE)) ProcessingConfig.addSetting( Setting(ProcessingConfig.tr('General'), ProcessingConfig.VECTOR_LINE_STYLE, ProcessingConfig.tr('Style for line layers'), '', valuetype=Setting.FILE)) ProcessingConfig.addSetting( Setting(ProcessingConfig.tr('General'), ProcessingConfig.VECTOR_POLYGON_STYLE, ProcessingConfig.tr('Style for polygon layers'), '', valuetype=Setting.FILE)) ProcessingConfig.addSetting( Setting(ProcessingConfig.tr('General'), ProcessingConfig.PRE_EXECUTION_SCRIPT, ProcessingConfig.tr('Pre-execution script'), '', valuetype=Setting.FILE)) ProcessingConfig.addSetting( Setting(ProcessingConfig.tr('General'), ProcessingConfig.POST_EXECUTION_SCRIPT, ProcessingConfig.tr('Post-execution script'), '', valuetype=Setting.FILE)) ProcessingConfig.addSetting( Setting( ProcessingConfig.tr('General'), ProcessingConfig.MODELS_SCRIPTS_REPO, ProcessingConfig.tr('Scripts and models repository'), 'https://raw.githubusercontent.com/qgis/QGIS-Processing/master' )) invalidFeaturesOptions = [ ProcessingConfig.tr('Do not filter (better performance)'), ProcessingConfig.tr('Ignore features with invalid geometries'), ProcessingConfig.tr( 'Stop algorithm execution when a geometry is invalid') ] ProcessingConfig.addSetting( Setting(ProcessingConfig.tr('General'), ProcessingConfig.FILTER_INVALID_GEOMETRIES, ProcessingConfig.tr('Invalid features filtering'), invalidFeaturesOptions[2], valuetype=Setting.SELECTION, options=invalidFeaturesOptions)) extensions = QgsVectorFileWriter.supportedFormatExtensions() ProcessingConfig.addSetting( Setting( ProcessingConfig.tr('General'), ProcessingConfig.DEFAULT_OUTPUT_VECTOR_LAYER_EXT, ProcessingConfig.tr('Default output vector layer extension'), extensions[0], valuetype=Setting.SELECTION, options=extensions)) extensions = QgsRasterFileWriter.supportedFormatExtensions() ProcessingConfig.addSetting( Setting( ProcessingConfig.tr('General'), ProcessingConfig.DEFAULT_OUTPUT_RASTER_LAYER_EXT, ProcessingConfig.tr('Default output raster layer extension'), extensions[0], valuetype=Setting.SELECTION, options=extensions))
def processAlgorithm(self, parameters, context, feedback): source = self.parameterAsSource(parameters, self.INPUT, context) radius = self.parameterAsDouble(parameters, self.RADIUS, context) kernel_shape = self.parameterAsEnum(parameters, self.KERNEL, context) pixel_size = self.parameterAsDouble(parameters, self.PIXEL_SIZE, context) decay = self.parameterAsDouble(parameters, self.DECAY, context) output_values = self.parameterAsEnum(parameters, self.OUTPUT_VALUE, context) outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) output_format = QgsRasterFileWriter.driverForExtension( os.path.splitext(outputFile)[1]) weight_field = self.parameterAsString(parameters, self.WEIGHT_FIELD, context) radius_field = self.parameterAsString(parameters, self.RADIUS_FIELD, context) attrs = [] kde_params = QgsKernelDensityEstimation.Parameters() kde_params.source = source kde_params.radius = radius kde_params.pixelSize = pixel_size # radius field if radius_field: kde_params.radiusField = radius_field attrs.append(source.fields().lookupField(radius_field)) # weight field if weight_field: kde_params.weightField = weight_field attrs.append(source.fields().lookupField(weight_field)) kde_params.shape = kernel_shape kde_params.decayRatio = decay kde_params.outputValues = output_values kde = QgsKernelDensityEstimation(kde_params, outputFile, output_format) if kde.prepare() != QgsKernelDensityEstimation.Success: raise QgsProcessingException( self.tr('Could not create destination layer')) request = QgsFeatureRequest() request.setSubsetOfAttributes(attrs) features = source.getFeatures(request) total = 100.0 / source.featureCount() if source.featureCount() else 0 for current, f in enumerate(features): if feedback.isCanceled(): break if kde.addFeature(f) != QgsKernelDensityEstimation.Success: feedback.reportError( self.tr( 'Error adding feature with ID {} to heatmap').format( f.id())) feedback.setProgress(int(current * total)) if kde.finalise() != QgsKernelDensityEstimation.Success: raise QgsProcessingException( self.tr('Could not save destination layer')) return {self.OUTPUT: outputFile}
def getConsoleCommands(self, parameters, context, feedback): inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) sourceCrs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context) targetCrs = self.parameterAsCrs(parameters, self.TARGET_CRS, context) nodata = self.parameterAsDouble(parameters, self.NODATA, context) resolution = self.parameterAsDouble(parameters, self.TARGET_RESOLUTION, context) arguments = [] if sourceCrs.isValid(): arguments.append('-s_srs') arguments.append(sourceCrs.authid()) if targetCrs.isValid(): arguments.append('-t_srs') arguments.append(targetCrs.authid()) if nodata: arguments.append('-dstnodata') arguments.append(str(nodata)) if resolution: arguments.append('-tr') arguments.append(str(resolution)) arguments.append(str(resolution)) arguments.append('-r') arguments.append(self.methods[self.parameterAsEnum( parameters, self.RESAMPLING, context)][1]) extent = self.parameterAsExtent(parameters, self.TARGET_EXTENT, context) if not extent.isNull(): arguments.append('-te') arguments.append(rasterExtent.xMinimum()) arguments.append(rasterExtent.yMinimum()) arguments.append(rasterExtent.xMaximum()) arguments.append(rasterExtent.yMaximum()) extentCrs = self.parameterAsCrs(parameters, self.TARGET_EXTENT_CRS, context) if extentCrs: arguments.append('-te_srs') arguments.append(extentCrs.authid()) if self.parameterAsBool(parameters, self.MULTITHREADING, context): arguments.append('-multi') arguments.append('-ot') arguments.append(self.TYPES[self.parameterAsEnum( parameters, self.DATA_TYPE, context)]) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append('-of') arguments.append( QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.append('-co') arguments.append(options) arguments.append(inLayer.source()) arguments.append(out) return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def exportRasterLayer(layer, safeLayerName, dataPath): name_ts = safeLayerName + unicode(int(time.time())) # We need to create a new file to export style piped_file = os.path.join(tempfile.gettempdir(), name_ts + '_piped.tif') piped_extent = layer.extent() piped_width = layer.height() piped_height = layer.width() piped_crs = layer.crs() piped_renderer = layer.renderer() piped_provider = layer.dataProvider() pipe = QgsRasterPipe() pipe.set(piped_provider.clone()) pipe.set(piped_renderer.clone()) file_writer = QgsRasterFileWriter(piped_file) file_writer.writeRaster(pipe, piped_width, piped_height, piped_extent, piped_crs) # Extent of the layer in EPSG:3857 crsSrc = layer.crs() crsDest = QgsCoordinateReferenceSystem(3857) xform = QgsCoordinateTransform(crsSrc, crsDest) extentRep = xform.transform(layer.extent()) extentRepNew = ','.join([ unicode(extentRep.xMinimum()), unicode(extentRep.xMaximum()), unicode(extentRep.yMinimum()), unicode(extentRep.yMaximum()) ]) # Reproject in 3857 piped_3857 = os.path.join(tempfile.gettempdir(), name_ts + '_piped_3857.tif') # Export layer as PNG out_raster = dataPath + '.png' qgis_version = QGis.QGIS_VERSION if int(qgis_version.split('.')[1]) < 15: processing.runalg("gdalogr:warpreproject", piped_file, layer.crs().authid(), "EPSG:3857", "", 0, 1, 0, -1, 75, 6, 1, False, 0, False, "", piped_3857) processing.runalg("gdalogr:translate", piped_3857, 100, True, "", 0, "", extentRepNew, False, 0, 0, 75, 6, 1, False, 0, False, "", out_raster) else: try: warpArgs = { "INPUT": piped_file, "SOURCE_SRS": layer.crs().authid(), "DEST_SRS": "EPSG:3857", "NO_DATA": "", "TR": 0, "METHOD": 2, "RAST_EXT": extentRepNew, "EXT_CRS": "EPSG:3857", "RTYPE": 0, "COMPRESS": 4, "JPEGCOMPRESSION": 75, "ZLEVEL": 6, "PREDICTOR": 1, "TILED": False, "BIGTIFF": 0, "TFW": False, "EXTRA": "", "OUTPUT": piped_3857 } procRtn = processing.runalg("gdalogr:warpreproject", warpArgs) # force exception on algorithm fail for val in procRtn: pass except: try: warpArgs = { "INPUT": piped_file, "SOURCE_SRS": layer.crs().authid(), "DEST_SRS": "EPSG:3857", "NO_DATA": "", "TR": 0, "METHOD": 2, "RAST_EXT": extentRepNew, "RTYPE": 0, "COMPRESS": 4, "JPEGCOMPRESSION": 75, "ZLEVEL": 6, "PREDICTOR": 1, "TILED": False, "BIGTIFF": 0, "TFW": False, "EXTRA": "", "OUTPUT": piped_3857 } procRtn = processing.runalg("gdalogr:warpreproject", warpArgs) # force exception on algorithm fail for val in procRtn: pass except: try: warpArgs = { "INPUT": piped_file, "SOURCE_SRS": layer.crs().authid(), "DEST_SRS": "EPSG:3857", "NO_DATA": "", "TR": 0, "METHOD": 2, "RTYPE": 0, "COMPRESS": 4, "JPEGCOMPRESSION": 75, "ZLEVEL": 6, "PREDICTOR": 1, "TILED": False, "BIGTIFF": 0, "TFW": False, "EXTRA": "", "OUTPUT": piped_3857 } procRtn = processing.runalg("gdalogr:warpreproject", warpArgs) for val in procRtn: pass except: shutil.copyfile(piped_file, piped_3857) try: processing.runalg("gdalogr:translate", piped_3857, 100, True, "", 0, "", extentRepNew, False, 5, 4, 75, 6, 1, False, 0, False, "", out_raster) except: shutil.copyfile(piped_3857, out_raster)
def getConsoleCommands(self, parameters, context, feedback, executing=True): out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments = [] if self.parameterAsBool(parameters, self.PCT, context): arguments.append('-pct') if self.parameterAsBool(parameters, self.SEPARATE, context): arguments.append('-separate') if self.NODATA_INPUT in parameters and parameters[ self.NODATA_INPUT] is not None: nodata_input = self.parameterAsInt(parameters, self.NODATA_INPUT, context) arguments.append('-n') arguments.append(str(nodata_input)) if self.NODATA_OUTPUT in parameters and parameters[ self.NODATA_OUTPUT] is not None: nodata_output = self.parameterAsInt(parameters, self.NODATA_OUTPUT, context) arguments.append('-a_nodata') arguments.append(str(nodata_output)) arguments.append('-ot') arguments.append(self.TYPES[self.parameterAsEnum( parameters, self.DATA_TYPE, context)]) arguments.append('-of') arguments.append( QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.extend(GdalUtils.parseCreationOptions(options)) arguments.append('-o') arguments.append(out) # Always write input files to a text file in case there are many of them and the # length of the command will be longer then allowed in command prompt list_file = GdalUtils.writeLayerParameterToTextFile( filename='mergeInputFiles.txt', alg=self, parameters=parameters, parameter_name=self.INPUT, context=context, quote=True, executing=executing) arguments.append('--optfile') arguments.append(list_file) commands = [] if isWindows(): commands = [ 'cmd.exe', '/C ', self.commandName() + '.bat', GdalUtils.escapeAndJoin(arguments) ] else: commands = [ self.commandName() + '.py', GdalUtils.escapeAndJoin(arguments) ] return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True): arguments = ['hillshade'] inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if inLayer is None: raise QgsProcessingException( self.invalidRasterError(parameters, self.INPUT)) arguments.append(inLayer.source()) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) self.setOutputValue(self.OUTPUT, out) arguments.append(out) arguments.append('-of') arguments.append( QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) arguments.append('-b') arguments.append( str(self.parameterAsInt(parameters, self.BAND, context))) arguments.append('-z') arguments.append( str(self.parameterAsDouble(parameters, self.Z_FACTOR, context))) arguments.append('-s') arguments.append( str(self.parameterAsDouble(parameters, self.SCALE, context))) multidirectional = self.parameterAsBool(parameters, self.MULTIDIRECTIONAL, context) # azimuth and multidirectional are mutually exclusive if not multidirectional: arguments.append('-az') arguments.append( str(self.parameterAsDouble(parameters, self.AZIMUTH, context))) arguments.append('-alt') arguments.append( str(self.parameterAsDouble(parameters, self.ALTITUDE, context))) if self.parameterAsBool(parameters, self.COMPUTE_EDGES, context): arguments.append('-compute_edges') if self.parameterAsBool(parameters, self.ZEVENBERGEN, context): arguments.append('-alg') arguments.append('ZevenbergenThorne') if self.parameterAsBool(parameters, self.COMBINED, context): arguments.append('-combined') if multidirectional: arguments.append('-multidirectional') options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.extend(GdalUtils.parseCreationOptions(options)) return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True): inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if inLayer is None: raise QgsProcessingException( self.invalidRasterError(parameters, self.INPUT)) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) sourceCrs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context) targetCrs = self.parameterAsCrs(parameters, self.TARGET_CRS, context) if self.NODATA in parameters and parameters[self.NODATA] is not None: nodata = self.parameterAsDouble(parameters, self.NODATA, context) else: nodata = None resolution = self.parameterAsDouble(parameters, self.TARGET_RESOLUTION, context) arguments = [] if sourceCrs.isValid(): arguments.append('-s_srs') arguments.append(GdalUtils.gdal_crs_string(sourceCrs)) if targetCrs.isValid(): arguments.append('-t_srs') arguments.append(GdalUtils.gdal_crs_string(targetCrs)) if nodata is not None: arguments.append('-dstnodata') arguments.append(str(nodata)) if resolution: arguments.append('-tr') arguments.append(str(resolution)) arguments.append(str(resolution)) arguments.append('-r') arguments.append(self.methods[self.parameterAsEnum( parameters, self.RESAMPLING, context)][1]) extent = self.parameterAsExtent(parameters, self.TARGET_EXTENT, context) if not extent.isNull(): arguments.append('-te') arguments.append(extent.xMinimum()) arguments.append(extent.yMinimum()) arguments.append(extent.xMaximum()) arguments.append(extent.yMaximum()) extentCrs = self.parameterAsCrs(parameters, self.TARGET_EXTENT_CRS, context) if extentCrs: arguments.append('-te_srs') arguments.append(extentCrs.authid()) if self.parameterAsBool(parameters, self.MULTITHREADING, context): arguments.append('-multi') data_type = self.parameterAsEnum(parameters, self.DATA_TYPE, context) if data_type: arguments.append('-ot ' + self.TYPES[data_type]) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append('-of') arguments.append( QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.extend(GdalUtils.parseCreationOptions(options)) arguments.append(inLayer.source()) arguments.append(out) return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True): inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if inLayer is None: raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT)) maskLayer, maskLayerName = self.getOgrCompatibleSource(self.MASK, parameters, context, feedback, executing) sourceCrs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context) targetCrs = self.parameterAsCrs(parameters, self.TARGET_CRS, context) if self.NODATA in parameters and parameters[self.NODATA] is not None: nodata = self.parameterAsDouble(parameters, self.NODATA, context) else: nodata = None options = self.parameterAsString(parameters, self.OPTIONS, context) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) self.setOutputValue(self.OUTPUT, out) arguments = [] if sourceCrs.isValid(): arguments.append('-s_srs') arguments.append(GdalUtils.gdal_crs_string(sourceCrs)) if targetCrs.isValid(): arguments.append('-t_srs') arguments.append(GdalUtils.gdal_crs_string(targetCrs)) data_type = self.parameterAsEnum(parameters, self.DATA_TYPE, context) if data_type: arguments.append('-ot ' + self.TYPES[data_type]) arguments.append('-of') arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) if self.parameterAsBoolean(parameters, self.KEEP_RESOLUTION, context): arguments.append('-tr') arguments.append(str(inLayer.rasterUnitsPerPixelX())) arguments.append(str(-inLayer.rasterUnitsPerPixelY())) arguments.append('-tap') if self.parameterAsBoolean(parameters, self.SET_RESOLUTION, context): arguments.append('-tr') if self.X_RESOLUTION in parameters and parameters[self.X_RESOLUTION] is not None: xres = self.parameterAsDouble(parameters, self.X_RESOLUTION, context) arguments.append('{}'.format(xres)) else: arguments.append(str(inLayer.rasterUnitsPerPixelX())) if self.Y_RESOLUTION in parameters and parameters[self.Y_RESOLUTION] is not None: yres = self.parameterAsDouble(parameters, self.Y_RESOLUTION, context) arguments.append('{}'.format(yres)) else: arguments.append(str(-inLayer.rasterUnitsPerPixelY())) arguments.append('-tap') arguments.append('-cutline') arguments.append(maskLayer) if self.parameterAsBoolean(parameters, self.CROP_TO_CUTLINE, context): arguments.append('-crop_to_cutline') if self.parameterAsBoolean(parameters, self.ALPHA_BAND, context): arguments.append('-dstalpha') if nodata is not None: arguments.append('-dstnodata {}'.format(nodata)) if self.parameterAsBoolean(parameters, self.MULTITHREADING, context): arguments.append('-multi') if options: arguments.extend(GdalUtils.parseCreationOptions(options)) arguments.append(inLayer.source()) arguments.append(out) return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def testExtensionsForFormat(self): self.assertCountEqual(QgsRasterFileWriter.extensionsForFormat('not format'), []) self.assertCountEqual(QgsRasterFileWriter.extensionsForFormat('GTiff'), ['tiff', 'tif']) self.assertCountEqual(QgsRasterFileWriter.extensionsForFormat('GPKG'), ['gpkg']) self.assertCountEqual(QgsRasterFileWriter.extensionsForFormat('JPEG'), ['jpg', 'jpeg']) self.assertCountEqual(QgsRasterFileWriter.extensionsForFormat('AAIGrid'), ['asc'])
def getConsoleCommands(self, parameters, context, feedback, executing=True): ogrLayer, layerName = self.getOgrCompatibleSource( self.INPUT, parameters, context, feedback, executing) arguments = ['-l'] arguments.append(layerName) fieldName = self.parameterAsString(parameters, self.FIELD, context) if fieldName: arguments.append('-a') arguments.append(fieldName) else: arguments.append('-burn') arguments.append( self.parameterAsDouble(parameters, self.BURN, context)) units = self.parameterAsEnum(parameters, self.UNITS, context) if units == 0: arguments.append('-ts') else: arguments.append('-tr') arguments.append( self.parameterAsDouble(parameters, self.WIDTH, context)) arguments.append( self.parameterAsDouble(parameters, self.HEIGHT, context)) initValue = self.parameterAsDouble(parameters, self.INIT, context) if initValue: arguments.append('-init') arguments.append(initValue) if self.parameterAsBool(parameters, self.INVERT, context): arguments.append('-i') if self.parameterAsBool(parameters, self.ALL_TOUCH, context): arguments.append('-at') if self.NODATA in parameters and parameters[self.NODATA] is not None: nodata = self.parameterAsDouble(parameters, self.NODATA, context) arguments.append('-a_nodata') arguments.append(nodata) extent = self.parameterAsExtent(parameters, self.EXTENT, context) if not extent.isNull(): arguments.append('-te') arguments.append(extent.xMinimum()) arguments.append(extent.yMinimum()) arguments.append(extent.xMaximum()) arguments.append(extent.yMaximum()) arguments.append('-ot') arguments.append(self.TYPES[self.parameterAsEnum( parameters, self.DATA_TYPE, context)]) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append('-of') arguments.append( QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) options = self.parameterAsString(parameters, self.OPTIONS, context) if options: arguments.extend(GdalUtils.parseCreationOptions(options)) arguments.append(ogrLayer) arguments.append(out) return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def exportLayers(iface, layers, folder, precision, optimize, popupField, json, restrictToExtent, extent, feedback): canvas = iface.mapCanvas() epsg4326 = QgsCoordinateReferenceSystem("EPSG:4326") layersFolder = os.path.join(folder, "layers") QDir().mkpath(layersFolder) for count, (layer, encode2json, popup) in enumerate(zip(layers, json, popupField)): if (layer.type() == layer.VectorLayer and (layer.providerType() != "WFS" or encode2json)): feedback.showFeedback("Exporting %s to JSON..." % layer.name()) cleanLayer = writeTmpLayer(layer, popup, restrictToExtent, iface, extent) fields = layer.pendingFields() for field in fields: exportImages(layer, field.name(), layersFolder + "/tmp.tmp") if is25d(layer, canvas, restrictToExtent, extent): provider = cleanLayer.dataProvider() provider.addAttributes([ QgsField("height", QVariant.Double), QgsField("wallColor", QVariant.String), QgsField("roofColor", QVariant.String) ]) cleanLayer.updateFields() fields = cleanLayer.pendingFields() renderer = layer.rendererV2() renderContext = QgsRenderContext.fromMapSettings( canvas.mapSettings()) feats = layer.getFeatures() context = QgsExpressionContext() context.appendScope( QgsExpressionContextUtils.layerScope(layer)) expression = QgsExpression('eval(@qgis_25d_height)') heightField = fields.indexFromName("height") wallField = fields.indexFromName("wallColor") roofField = fields.indexFromName("roofColor") renderer.startRender(renderContext, fields) cleanLayer.startEditing() for feat in feats: context.setFeature(feat) height = expression.evaluate(context) if isinstance(renderer, QgsCategorizedSymbolRendererV2): classAttribute = renderer.classAttribute() attrValue = feat.attribute(classAttribute) catIndex = renderer.categoryIndexForValue(attrValue) categories = renderer.categories() symbol = categories[catIndex].symbol() elif isinstance(renderer, QgsGraduatedSymbolRendererV2): classAttribute = renderer.classAttribute() attrValue = feat.attribute(classAttribute) ranges = renderer.ranges() for range in ranges: if (attrValue >= range.lowerValue() and attrValue <= range.upperValue()): symbol = range.symbol().clone() else: symbol = renderer.symbolForFeature2( feat, renderContext) sl1 = symbol.symbolLayer(1) sl2 = symbol.symbolLayer(2) wallColor = sl1.subSymbol().color().name() roofColor = sl2.subSymbol().color().name() provider.changeAttributeValues({ feat.id() + 1: { heightField: height, wallField: wallColor, roofField: roofColor } }) cleanLayer.commitChanges() renderer.stopRender(renderContext) sln = safeName(cleanLayer.name()) + unicode(count) tmpPath = os.path.join(layersFolder, sln + ".json") path = os.path.join(layersFolder, sln + ".js") options = [] if precision != "maintain": options.append("COORDINATE_PRECISION=" + unicode(precision)) QgsVectorFileWriter.writeAsVectorFormat(cleanLayer, tmpPath, "utf-8", epsg4326, 'GeoJson', 0, layerOptions=options) with open(path, "w") as f: f.write("var %s = " % ("geojson_" + sln)) with open(tmpPath, "r") as f2: for line in f2: if optimize: line = line.strip("\n\t ") line = removeSpaces(line) f.write(line) os.remove(tmpPath) elif (layer.type() == layer.RasterLayer and layer.providerType() != "wms"): feedback.showFeedback("Exporting %s to PNG..." % layer.name()) name_ts = (safeName(layer.name()) + unicode(count) + unicode(int(time.time()))) # We need to create a new file to export style piped_file = os.path.join(tempfile.gettempdir(), name_ts + '_piped.tif') piped_extent = layer.extent() piped_width = layer.height() piped_height = layer.width() piped_crs = layer.crs() piped_renderer = layer.renderer() piped_provider = layer.dataProvider() pipe = QgsRasterPipe() pipe.set(piped_provider.clone()) pipe.set(piped_renderer.clone()) file_writer = QgsRasterFileWriter(piped_file) file_writer.writeRaster(pipe, piped_width, piped_height, piped_extent, piped_crs) # Extent of the layer in EPSG:3857 crsSrc = layer.crs() crsDest = QgsCoordinateReferenceSystem(3857) xform = QgsCoordinateTransform(crsSrc, crsDest) extentRep = xform.transform(layer.extent()) extentRepNew = ','.join([ unicode(extentRep.xMinimum()), unicode(extentRep.xMaximum()), unicode(extentRep.yMinimum()), unicode(extentRep.yMaximum()) ]) # Reproject in 3857 piped_3857 = os.path.join(tempfile.gettempdir(), name_ts + '_piped_3857.tif') # Export layer as PNG out_raster = os.path.join( layersFolder, safeName(layer.name()) + unicode(count) + ".png") qgis_version = QGis.QGIS_VERSION if int(qgis_version.split('.')[1]) < 15: processing.runalg("gdalogr:warpreproject", piped_file, layer.crs().authid(), "EPSG:3857", "", 0, 1, 0, -1, 75, 6, 1, False, 0, False, "", piped_3857) processing.runalg("gdalogr:translate", piped_3857, 100, True, "", 0, "", extentRepNew, False, 0, 0, 75, 6, 1, False, 0, False, "", out_raster) else: try: warpArgs = { "INPUT": piped_file, "SOURCE_SRS": layer.crs().authid(), "DEST_SRS": "EPSG:3857", "NO_DATA": "", "TR": 0, "METHOD": 2, "RAST_EXT": extentRepNew, "EXT_CRS": "EPSG:3857", "RTYPE": 0, "COMPRESS": 4, "JPEGCOMPRESSION": 75, "ZLEVEL": 6, "PREDICTOR": 1, "TILED": False, "BIGTIFF": 0, "TFW": False, "EXTRA": "", "OUTPUT": piped_3857 } procRtn = processing.runalg("gdalogr:warpreproject", warpArgs) # force exception on algorithm fail for val in procRtn: pass except: try: warpArgs = { "INPUT": piped_file, "SOURCE_SRS": layer.crs().authid(), "DEST_SRS": "EPSG:3857", "NO_DATA": "", "TR": 0, "METHOD": 2, "RAST_EXT": extentRepNew, "RTYPE": 0, "COMPRESS": 4, "JPEGCOMPRESSION": 75, "ZLEVEL": 6, "PREDICTOR": 1, "TILED": False, "BIGTIFF": 0, "TFW": False, "EXTRA": "", "OUTPUT": piped_3857 } procRtn = processing.runalg("gdalogr:warpreproject", warpArgs) # force exception on algorithm fail for val in procRtn: pass except: try: warpArgs = { "INPUT": piped_file, "SOURCE_SRS": layer.crs().authid(), "DEST_SRS": "EPSG:3857", "NO_DATA": "", "TR": 0, "METHOD": 2, "RTYPE": 0, "COMPRESS": 4, "JPEGCOMPRESSION": 75, "ZLEVEL": 6, "PREDICTOR": 1, "TILED": False, "BIGTIFF": 0, "TFW": False, "EXTRA": "", "OUTPUT": piped_3857 } procRtn = processing.runalg( "gdalogr:warpreproject", warpArgs) # force exception on algorithm fail for val in procRtn: pass except: shutil.copyfile(piped_file, piped_3857) try: processing.runalg("gdalogr:translate", piped_3857, 100, True, "", 0, "", extentRepNew, False, 5, 4, 75, 6, 1, False, 0, False, "", out_raster) except: shutil.copyfile(piped_3857, out_raster) feedback.completeStep()
def getConsoleCommands(self, parameters, context, feedback, executing=True): inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if inLayer is None: raise QgsProcessingException( self.invalidRasterError(parameters, self.INPUT)) distance = self.parameterAsDouble(parameters, self.MAX_DISTANCE, context) replaceValue = self.parameterAsDouble(parameters, self.REPLACE, context) if self.NODATA in parameters and parameters[self.NODATA] is not None: nodata = self.parameterAsDouble(parameters, self.NODATA, context) else: nodata = None options = self.parameterAsString(parameters, self.OPTIONS, context) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments = [] arguments.append('-srcband') arguments.append( str(self.parameterAsInt(parameters, self.BAND, context))) arguments.append('-distunits') arguments.append(self.distanceUnits[self.parameterAsEnum( parameters, self.UNITS, context)][1]) values = self.parameterAsString(parameters, self.VALUES, context) if values: arguments.append('-values') arguments.append(values) if distance: arguments.append('-maxdist') arguments.append(str(distance)) if nodata is not None: arguments.append('-nodata') arguments.append(str(nodata)) if replaceValue: arguments.append('-fixed-buf-val') arguments.append(str(replaceValue)) arguments.append('-ot') arguments.append(self.TYPES[self.parameterAsEnum( parameters, self.DATA_TYPE, context)]) arguments.append('-of') arguments.append( QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1])) if options: arguments.extend(GdalUtils.parseCreationOptions(options)) arguments.append(inLayer.source()) arguments.append(out) commands = [] if isWindows(): commands = [ 'cmd.exe', '/C ', self.commandName() + '.bat', GdalUtils.escapeAndJoin(arguments) ] else: commands = [ self.commandName() + '.py', GdalUtils.escapeAndJoin(arguments) ] return commands