def unload(self): self.toolbox.setVisible(False) self.iface.removeDockWidget(self.toolbox) self.iface.attributesToolBar().removeAction(self.toolboxAction) self.resultsDock.setVisible(False) self.iface.removeDockWidget(self.resultsDock) self.toolbox.deleteLater() self.menu.deleteLater() # delete temporary output files folder = QgsProcessingUtils.tempFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) # also delete temporary help files folder = tempHelpFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) self.iface.unregisterMainWindowAction(self.toolboxAction) self.iface.unregisterMainWindowAction(self.modelerAction) self.iface.unregisterMainWindowAction(self.historyAction) self.iface.unregisterMainWindowAction(self.resultsAction) self.iface.unregisterOptionsWidgetFactory(self.options_factory) self.iface.deregisterLocatorFilter(self.locator_filter) self.iface.unregisterCustomDropHandler(self.drop_handler) QgsApplication.dataItemProviderRegistry().removeProvider(self.item_provider) removeMenus() Processing.deinitialize()
def unload(self): self.toolbox.setVisible(False) self.iface.removeDockWidget(self.toolbox) self.resultsDock.setVisible(False) self.iface.removeDockWidget(self.resultsDock) self.menu.deleteLater() # delete temporary output files folder = QgsProcessingUtils.tempFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) # also delete temporary help files folder = tempHelpFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) self.iface.unregisterMainWindowAction(self.toolboxAction) self.iface.unregisterMainWindowAction(self.modelerAction) self.iface.unregisterMainWindowAction(self.historyAction) self.iface.unregisterMainWindowAction(self.resultsAction) self.iface.unregisterOptionsWidgetFactory(self.options_factory) self.iface.deregisterLocatorFilter(self.locator_filter) removeMenus() Processing.deinitialize()
def getConsoleCommands(self, parameters, context, feedback): arguments = [] arguments.append('-resolution') arguments.append(self.RESOLUTION_OPTIONS[self.parameterAsEnum(parameters, self.RESOLUTION, context)]) if self.parameterAsBool(parameters, buildvrt.SEPARATE, context): arguments.append('-separate') if self.parameterAsBool(parameters, buildvrt.PROJ_DIFFERENCE, context): arguments.append('-allow_projection_difference') # 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 listFile = os.path.join(QgsProcessingUtils.tempFolder(), 'buildvrtInputFiles.txt') with open(listFile, 'w') as f: layers = [] for l in self.parameterAsLayerList(parameters, self.INPUT, context): layers.append(l.source()) f.write('\n'.join(layers)) arguments.append('-input_file_list') arguments.append(listFile) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) # Ideally the file extensions should be limited to just .vrt but I'm not sure how # to do it simply so instead a check is performed. _, ext = os.path.splitext(out) if not ext.lower() == '.vrt': out = out[:-len(ext)] + '.vrt' if isinstance(parameters[self.OUTPUT], QgsProcessingOutputLayerDefinition): output_def = QgsProcessingOutputLayerDefinition(parameters[self.OUTPUT]) output_def.sink = QgsProperty.fromValue(out) self.setOutputValue(self.OUTPUT, output_def) else: self.setOutputValue(self.OUTPUT, out) arguments.append(out) return ['gdalbuildvrt', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters): arguments = [] arguments.append('-resolution') arguments.append(self.RESOLUTION_OPTIONS[self.getParameterValue(self.RESOLUTION)]) if self.getParameterValue(buildvrt.SEPARATE): arguments.append('-separate') if self.getParameterValue(buildvrt.PROJ_DIFFERENCE): arguments.append('-allow_projection_difference') # 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 listFile = os.path.join(QgsProcessingUtils.tempFolder(), 'buildvrtInputFiles.txt') with open(listFile, 'w') as f: f.write(self.getParameterValue(buildvrt.INPUT).replace(';', '\n')) arguments.append('-input_file_list') arguments.append(listFile) out = self.getOutputValue(buildvrt.OUTPUT) # Ideally the file extensions should be limited to just .vrt but I'm not sure how # to do it simply so instead a check is performed. _, ext = os.path.splitext(out) if not ext.lower() == '.vrt': out = out.replace(ext, '.vrt') self.setOutputValue(self.OUTPUT, out) arguments.append(out) return ['gdalbuildvrt', GdalUtils.escapeAndJoin(arguments)]
def grassDataFolder(): """ Creates and returns the GRASS temporary DB directory. """ tempfolder = os.path.normpath( os.path.join(QgsProcessingUtils.tempFolder(), 'grassdata')) mkdir(tempfolder) return tempfolder
def getTempDirInTempFolder(): """Returns a temporary directory, putting it into a temp folder. """ path = QgsProcessingUtils.tempFolder() path = os.path.join(path, uuid.uuid4().hex) mkdir(path) return path
def getTempFilename(ext=None): tmpPath = QgsProcessingUtils.tempFolder() t = time.time() m = math.floor(t) uid = '{:8x}{:05x}'.format(m, int((t - m) * 1000000)) if ext is None: filename = os.path.join(tmpPath, '{}{}'.format(uid, getNumExportedLayers())) else: filename = os.path.join(tmpPath, '{}{}.{}'.format(uid, getNumExportedLayers(), ext)) return filename
def writeLayerParameterToTextFile(filename, alg, parameters, parameter_name, context, quote=True, executing=False): listFile = os.path.join(QgsProcessingUtils.tempFolder(), filename) with open(listFile, 'w') as f: if executing: layers = [] for l in alg.parameterAsLayerList(parameters, parameter_name, context): if quote: layers.append('"' + l.source() + '"') else: layers.append(l.source()) f.write('\n'.join(layers)) return listFile
def initAlgorithm(self, config): ''' Here we define the inputs and output of the algorithm. ''' # self._define_params() for param in sorted(self.the_params, key=self.the_params.__getitem__): b = self.the_params[param][0] qparam = set_param(param, self.the_params) if qparam != None: if b < 100: self.addParameter(qparam) elif b < 1000: self.addParameter((qparam)) else: self.addParameter(qparam, True) # Other variables self._error = '' self.tmpDir = QgsProcessingUtils.tempFolder()
def getConsoleCommands(self, parameters, context, feedback, executing=True): arguments = [] arguments.append('-resolution') arguments.append(self.RESOLUTION_OPTIONS[self.parameterAsEnum( parameters, self.RESOLUTION, context)]) if self.parameterAsBool(parameters, buildvrt.SEPARATE, context): arguments.append('-separate') if self.parameterAsBool(parameters, buildvrt.PROJ_DIFFERENCE, context): arguments.append('-allow_projection_difference') # 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 listFile = os.path.join(QgsProcessingUtils.tempFolder(), 'buildvrtInputFiles.txt') with open(listFile, 'w') as f: layers = [] for l in self.parameterAsLayerList(parameters, self.INPUT, context): layers.append(l.source()) f.write('\n'.join(layers)) arguments.append('-input_file_list') arguments.append(listFile) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) # Ideally the file extensions should be limited to just .vrt but I'm not sure how # to do it simply so instead a check is performed. _, ext = os.path.splitext(out) if not ext.lower() == '.vrt': out = out[:-len(ext)] + '.vrt' if isinstance(parameters[self.OUTPUT], QgsProcessingOutputLayerDefinition): output_def = QgsProcessingOutputLayerDefinition( parameters[self.OUTPUT]) output_def.sink = QgsProperty.fromValue(out) self.setOutputValue(self.OUTPUT, output_def) else: self.setOutputValue(self.OUTPUT, out) arguments.append(out) return ['gdalbuildvrt', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True): arguments = [] arguments.append('-resolution') arguments.append(self.RESOLUTION_OPTIONS[self.parameterAsEnum(parameters, self.RESOLUTION, context)]) if self.parameterAsBool(parameters, buildvrt.SEPARATE, context): arguments.append('-separate') if self.parameterAsBool(parameters, buildvrt.PROJ_DIFFERENCE, context): arguments.append('-allow_projection_difference') # 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 listFile = os.path.join(QgsProcessingUtils.tempFolder(), 'buildvrtInputFiles.txt') with open(listFile, 'w') as f: layers = [] for l in self.parameterAsLayerList(parameters, self.INPUT, context): layers.append(l.source()) f.write('\n'.join(layers)) arguments.append('-input_file_list') arguments.append(listFile) out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments.append(out) return ['gdalbuildvrt', GdalUtils.escapeAndJoin(arguments)]
def initAlgorithm(self, config): ''' Here we define the inputs and output of the algorithm. ''' # self._define_params() if is_dependencies_satisfied: # Prepare all parameters needed for plotting the colour bar for param in sorted(self.the_params, key=self.the_params.__getitem__): b = self.the_params[param][0] qparam = set_param(param, self.the_params) if qparam != None: if b < 100: self.addParameter(qparam) elif b < 1000: self.addParameter((qparam)) else: self.addParameter(qparam, True) else: qparam = set_param(self.DEP, self._err_param) self.addParameter(qparam) self.tmpDir = QgsProcessingUtils.tempFolder() self._error = ''
def processAlgorithm(self, parameters, context, feedback): # get inputs inputTab = self.parameterAsVectorLayer(parameters, self.inputTab, context) colApply = self.parameterAsFields(parameters, self.colApply, context) thresh = self.parameterAsString(parameters, self.thresh, context) maxIter = self.parameterAsString(parameters, self.maxIter, context) outPath = self.parameterAsString(parameters, self.OUTPUT, context) # create output layer from input data outTab = QgsVectorLayer('Polygon', 'outTab', 'memory') CRS = inputTab.crs() outTab.setCrs(CRS) outTab.dataProvider().addAttributes(inputTab.dataProvider().fields().toList()) outTab.updateFields() feats = [feat for feat in inputTab.getFeatures()] outTab.dataProvider().addFeatures(feats) outTab.updateExtents() # redefine data types thresh = float(thresh) maxIter = int(maxIter) # generate temp folder QgsMessageLog.logMessage('Creating temporary output directory...', 'User notification', 0) tempDir = QgsProcessingUtils.tempFolder() if not os.path.exists(tempDir): os.makedirs(tempDir) # get field indices of interest QgsMessageLog.logMessage('Getting field names and indeces...', 'User notification', 0) fieldIdx = [] fieldNames = outTab.fields().names() for f in list(range(0, len(fieldNames))): if fieldNames[f] in colApply: fieldIdx.append(fieldNames.index(fieldNames[f])) def abideMinCases_func(): # create container for information about processed features allProc = [] # iterate over each feature feats = outTab.getFeatures() feat_iter_count = 0 n_feats = outTab.featureCount() for feat in feats: feat_iter_count += 1 QgsMessageLog.logMessage('Processing feature...(' + str(feat_iter_count) + '/' + str(n_feats) + ')', 'User notification', 0) # get attributes atts = feat.attributes() # iterate over fields of interest for a in list(range(0, len(atts))): QgsMessageLog.logMessage('Processing field...(' + str(a+1) + '/' + str(len(atts)) + ')', 'User notification', 0) # get active if current field is within the fields of interest if a in fieldIdx: # extract value in question and area size for the respective features to_val = atts[a] # get active if attribute value is lower than defined threshold if atts[a] < thresh: # select current feature and create new layer outTab.selectByIds([feat.id()]) temp_fileName = tempDir + '/temp_selected_' + str(feat_iter_count) + '_' + str(a) + '.gpkg' QgsVectorFileWriter.writeAsVectorFormat(outTab, temp_fileName, 'ANSI', outTab.crs(), 'GPKG', 1) # get adjacent features params = {'INPUT' : outTab, 'INTERSECT' : QgsProcessingFeatureSourceDefinition(temp_fileName, False), 'METHOD' : 0, 'PREDICATE' : [4] } adjSel = processing.run('native:selectbylocation', params)['OUTPUT'] adj_feats = adjSel.selectedFeatures() adjSel.removeSelection() # get attribute values of adjacent features adjIdx = [] adjAtts = [] for adj_feat in adj_feats: adjIdx.append(adj_feat.id()) adjAtts.append(adj_feat[a]) QgsMessageLog.logMessage('Feature comparison with ' + str(len(adjIdx)) + ' adjacent features...', 'User notification', 0) # sort adjacent features by attribute values adjIdx = [x for _, x in sorted(zip(adjAtts, adjIdx))] adjAtts = sorted(adjAtts) # iterate over each appropriate adjacent feature pair as long as the threshold is not reached new_val = to_val for p in list(range(0, len(adjIdx))): # collect information about current feature pair pair1 = str(feat.id()) + '_' + str(adjIdx[p]) pair2 = str(adjIdx[p]) + '_' + str(feat.id()) # get active if this feature pair has not been processed before if (pair1 not in allProc) and (pair2 not in allProc) and (new_val < thresh): # get values of adjacent polygon outTab.selectByIds([adjIdx[p]]) comp_val = outTab.selectedFeatures()[0].attributes()[a] outTab.removeSelection() # calculate new value as mean new_val = (to_val + comp_val) / 2 # update attribute values in respective features outTab.startEditing() outTab.changeAttributeValue(adjIdx[p], a, new_val) outTab.changeAttributeValue(feat.id(), a, new_val) outTab.commitChanges() # collect information about this processed feature pair allProc.append(pair1) # update value in question to_val = new_val return outTab # execute function for l in list(range(0, maxIter)): QgsMessageLog.logMessage('Start iterative processing...(' + str(l+1) + '/' + str(maxIter) + ')', 'User notification', 0) outTab = abideMinCases_func() # write to file QgsMessageLog.logMessage('Writing results to file...', 'User notification', 0) QgsVectorFileWriter.writeAsVectorFormat(outTab, outPath, 'ANSI', CRS, 'GPKG') # add the new layer to canvas QgsProject.instance().addMapLayer(outTab) QgsMapCanvas().setExtent(outTab.extent()) QgsMapCanvas().setLayers([outTab]) return {self.OUTPUT: outTab}
def grassDataFolder(): tempfolder = os.path.join(QgsProcessingUtils.tempFolder(), 'grassdata') mkdir(tempfolder) return tempfolder
def processAlgorithm(self, parameters, context, feedback): # get input variables raster_layer = self.parameterAsRasterLayer(parameters, self.INPUT, context) band_number = self.parameterAsInt(parameters, self.BAND, context) z_pos_down = self.parameterAsBoolean(parameters, self.Z_POS_DOWN, context) interval = self.parameterAsInt(parameters, self.INTERVAL, context) output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) # set new default values in config feedback.pushConsoleInfo( self.tr(f'Storing new default settings in config...')) self.config.set(self.module, 'interval', interval) # 5% done feedback.setProgress(5) # get output file extension (.gpkg or .shp) base_path, base_name, ext = utils.get_info_from_path(output) # get CRS from raster file (for some reasons gdal:contour is assigning a false CRS otherwise...) crs = raster_layer.crs() # get temporary folder temp_folder = QgsProcessingUtils.tempFolder() # temp file for raw contours contours_raw = os.path.join(temp_folder, f'contours_raw.{ext}') # parameters for contour algortihm params_contour = { 'INPUT': raster_layer, 'BAND': band_number, 'INTERVAL': interval, 'FIELD_NAME': 'ELEV', 'CREATE_3D': True, 'IGNORE_NODATA': False, 'NODATA': raster_layer.dataProvider().sourceNoDataValue(band_number), 'OFFSET': 0, 'OUTPUT': contours_raw } # create raw contours feedback.pushConsoleInfo( self.tr(f'Creating raw contours with {interval} m interval...')) processing.run('gdal:contour', params_contour) # 35% done feedback.setProgress(35) # temp file for raw contours contours_smooth = os.path.join(temp_folder, f'contours_smooth.{ext}') # parameters for smoothing params_smooth = { 'INPUT': contours_raw, 'ITERATIONS': 3, 'MAX_ANGLE': 180, 'OFFSET': 0.25, 'OUTPUT': contours_smooth } # smooth contours feedback.pushConsoleInfo(self.tr(f'Smoothing contours...')) processing.run('native:smoothgeometry', params_smooth) # 55% done feedback.setProgress(55) # parameters for fixing projection params_prj = { 'INPUT': contours_smooth, 'TARGET_CRS': crs, 'OUTPUT': output } # smooth contours feedback.pushConsoleInfo(self.tr(f'Fixing CRS...')) processing.run('native:reprojectlayer', params_prj) # 60% done feedback.setProgress(60) # make variables accessible for post processing self.output = output self.z_pos_down = z_pos_down result = {self.OUTPUT: output} return result
def processAlgorithm(self, parameters, context, feedback): source = self.parameterAsVectorLayer(parameters, self.INPUT, context) if source is None: raise QgsProcessingException( self.invalidSourceError(parameters, self.INPUT)) max_distance = self.parameterAsDouble(parameters, self.MAX_DISTANCE, context) raster_type = self.RASTER_TYPES[self.parameterAsEnum( parameters, self.RASTER_TYPE, context)] extent = self.parameterAsExtent(parameters, self.EXTENT, context, source.sourceCrs()) if extent is None or extent.width() == 0 or extent.height() == 0: extent = source.sourceExtent() cell_size = self.parameterAsDouble(parameters, self.CELL_SIZE, context) if cell_size <= 0: cell_size = int(min(extent.width(), extent.height()) / 250.0) output_raster = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) # open ogr vector layer from qgs map layer ogrLayer, layerName = self.getOgrCompatibleSource( self.INPUT, parameters, context, feedback, True) if ogrLayer is None: raise QgsProcessingException('Cannot connect OGR driver!') ogr_vector_datasource = ogr.Open(ogrLayer) ogr_vector_layer = ogr_vector_datasource.GetLayer(layerName) feedback.pushInfo('Raster Type = {0}'.format(raster_type)) feedback.pushInfo('Cell Size = {0}'.format(cell_size)) feedback.pushInfo('Extent = {0}'.format(extent)) nodata = -9999 srs = osr.SpatialReference() srs.ImportFromWkt(source.crs().toWkt()) transform = [ extent.xMinimum(), cell_size, 0.0, extent.yMaximum(), 0.0, -cell_size ] raster_width = int( math.ceil(abs(extent.xMaximum() - extent.xMinimum()) / cell_size)) raster_height = int( math.ceil(abs(extent.yMaximum() - extent.yMinimum()) / cell_size)) # rasterize temporary raterdataset from vector layer, extent, cellsize temporary_path = os.path.join( QgsProcessingUtils.tempFolder(), 'euc_distance_{}.tif'.format(uuid.uuid4().hex)) feedback.pushInfo('Temporary path = {0}'.format(temporary_path)) driver = gdal.GetDriverByName('GTiff') rasterizedDS = driver.Create(temporary_path, raster_width, raster_height, 1, gdal.GDT_Byte) rasterizedDS.GetRasterBand(1).SetNoDataValue(nodata) rasterizedDS.SetGeoTransform(transform) rasterizedDS.SetProjection(srs.ExportToWkt()) rasterizedDS.GetRasterBand(1).Fill(nodata) gdal.RasterizeLayer(rasterizedDS, [1], ogr_vector_layer, burn_values=[1]) # compute proximity from rasterized dataset options = ['DISTUNITS=GEO'] if max_distance > 0: options.append('MAXDIST=' + str(max_distance)) proximityDs = driver.Create(output_raster, raster_width, raster_height, 1, gdal.GetDataTypeByName(raster_type)) proximityDs.GetRasterBand(1).SetNoDataValue(nodata) proximityDs.SetGeoTransform(transform) proximityDs.SetProjection(srs.ExportToWkt()) proximityDs.GetRasterBand(1).Fill(nodata) gdal.ComputeProximity(rasterizedDS.GetRasterBand(1), proximityDs.GetRasterBand(1), options, callback=None) # cleanup rasterizedDS = None proximityDs = None ogr_vector_datasource = None return {self.OUTPUT: output_raster}
def shade(self, rgb, b, c, syntax, output, crs, options): '''Create shaded RGB grid from plain color grid and up to two additional shading grids Parameters ---------- rgb : str file path to RGB raster b : str file path to grey raster for calculation c : str file path to grey raster for calculation syntax : str raster calculator syntax output : str file path to shaded raster output crs : QgsCoordinateReferenceSystem target CRS for output raster options : str GDAL create options Returns ------- output : str file path to shaded raster output ''' # create temporary folder tmp_folder = QgsProcessingUtils.tempFolder() tmp_file = os.path.join(tmp_folder, f'shade.{self.ext}') # raster calculator parameters calc_params = { 'INPUT_A': rgb, 'BAND_A': 1, 'INPUT_B': b, 'BAND_B': 1, 'INPUT_C': c, 'BAND_C': 1, 'FORMULA': syntax, 'NO_DATA': 0, 'RTYPE': 0, 'OPTIONS': options, 'EXTRA': '--allBands=A --overwrite', 'OUTPUT': tmp_file } # run raster calculation processing.run('gdal:rastercalculator', calc_params) # translate parameters translate_params = { 'INPUT': tmp_file, 'TARGET_CRS': crs, 'NO_DATA': 0, 'RTYPE': 0, 'OPTIONS': options, 'EXTRA': '-b 1 -b 2 -b 3 -r bilinear -a_nodata "0 0 0"', 'OUTPUT': output } # run translate processing.run('gdal:translate', translate_params) # remove tmp file if os.path.isfile(tmp_file): os.remove(tmp_file) return output
def __toNextPage(self): #check every input layer is exist #---------------------------------------------------------------------- checker = 0 self.__nextButton.setEnabled(False) # ckeckDem if self.__demComboBox.currentText == "": Exception("splitLine could not be null") checker = 1 self.__nextButton.setEnabled(True) # turn to next page if checker == 0: # get crossSection json file crossSectionTemptPath = QgsProcessingUtils.tempFolder() + str("\\crossSection.json") try: # save crossSection json to file # request = requests.get("https://h2-demo.pointing.tw/api/cross-sections/" + self.__countyComboBox.currentData()) # temptJson = json.loads(request.text) # test temptJson = None temptPath = os.path.dirname(__file__) with open(temptPath + "/testCrossSection.json") as temptText: temptJson = json.load(temptText) self.__editCounty = self.__countyComboBox.currentData() # make the geometry only has start and endPoint in it for feature in temptJson["features"]: temptGeometryPoints = feature["geometry"]["coordinates"] # outList, add a buffer to start-end point (each side for 3m) outGeometryPoints =[] startPoint = temptGeometryPoints[0] endPoint = temptGeometryPoints[-1] geometryLength = pow(pow(startPoint[0] - endPoint[0] ,2) + pow(startPoint[1] - endPoint[1] ,2),0.5) startDirection = [(startPoint[0]-endPoint[0])*(3.0/geometryLength) , (startPoint[1]-endPoint[1])*(3.0/geometryLength)] endDirection = [startDirection[0]*-1 , startDirection[1]*-1] outGeometryPoints.append([startPoint[0]+startDirection[0] , startPoint[1]+startDirection[1]]) outGeometryPoints.append([endPoint[0]+endDirection[0] , endPoint[1]+endDirection[1]]) feature["geometry"]["coordinates"] = outGeometryPoints # remove not necessary feild try: del feature["properties"]["originalId"] except: pass try: del feature["properties"]["node_py"] except: pass try: del feature["properties"]["node_px"] except: pass try: del feature["properties"]["node_nm"] except: pass # write json to temptFile writer = AtFileWriter(json.dumps(temptJson), crossSectionTemptPath).textWriter("") # load tempt jsonFile as layer self.__splitLineLayer = QgsVectorLayer(crossSectionTemptPath,"crossSection" , "ogr") self.__splitLineLayer.setCrs(QgsCoordinateReferenceSystem(3826),True) self.__splitLineLayer.loadNamedStyle(temptPath + '/style/crossSectionStyle.qml') QgsProject.instance().addMapLayer(self.__splitLineLayer) except: traceback.print_exc() # setting output paramter self.__demLayer = self.__demComboBox.currentData() # disconnect self.__nextButton.disconnect() self.__demComboBox.disconnect() # close dlg and open another self.__dlg.done(0) self.__isClose = True self.__dlg = PlotPage() self.__dlg.show() # create plotPageClass PlotPageClass(self.__dlg , self)
def processAlgorithm(self, parameters, context, feedback): ''' Here is where the processing itself takes place. ''' # if not is_dependencies_satisfied: return {} # Get get input raster and check its one-band the_layer = self.parameterAsRasterLayer(parameters, self.THE_LAYER, context) # if not self._check_oneband(the_layer): self._error = self._the_strings["ERR_ONEB"] return {} # Get .clr file and check it clr = self.parameterAsFile(parameters, self.THE_CLR, context) if not self._check_clr(clr): self._error = self._the_strings["ERR_NOCLR"] return {} # Get raster min/max values provider = the_layer.dataProvider() ext1 = the_layer.extent() stats = provider.bandStatistics(1, QgsRasterBandStats.All, ext1, 0) minv = stats.minimumValue maxv = stats.maximumValue d = (maxv - minv) / 100. # Scale percentages to raster values with codecs.open(clr, 'r', 'utf-8') as fi: buff = fi.readlines() # 0.00000000000000000 200 215 133 255 ar = [] for e in buff[2:]: br = e[:-1].split() v = float(br[0]) * d + minv ar.append([v, int(br[1]), int(br[2]), int(br[3]), int(br[4])]) if br[0][:3] == '100': # end of colour ramp break # Style raster fcn = qRS() fcn.setColorRampType(qRS.Interpolated) lst = [] for e in ar: lst.append(qRS.ColorRampItem(e[0],QColor(int(e[1]), int(e[2]), int(e[3]), int(e[4])),str(e[0]))) fcn.setColorRampItemList(lst) try: shader = QgsRasterShader() shader.setRasterShaderFunction(fcn) renderer = QgsSingleBandPseudoColorRenderer(the_layer.dataProvider(), the_layer.type(), shader) the_layer.setRenderer(renderer) the_layer.triggerRepaint() except: pass # Get output file name output_file = self.parameterAsFileOutput(parameters, self.OUTPUT, context) if output_file == '': output_file = os.path.join(QgsProcessingUtils.tempFolder(), the_layer.name()) # Save QGIS colour ramp file with codecs.open(output_file, 'w', 'utf-8') as fo: fo.write('# bcclr2tbl Generated Color Map Export File\n') fo.write('INTERPOLATION:INTERPOLATED\n') # 614,46,124,228,255,614 for e in ar: fo.write('%.3f,%d,%d,%d,%d,%.1f\n' % (e[0], int(e[1]), int(e[2]), int(e[3]), int(e[4]), e[0])) return {self.OUTPUT:output_file}
def processAlgorithm(self, parameters, context, feedback): # get input variables raster_layer = self.parameterAsRasterLayer(parameters, self.INPUT, context) shade_by = self.parameterAsEnum(parameters, self.SHADE_BY, context) options = self.parameterAsString(parameters, self.OPTIONS, context) output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) z_pos_down = self.parameterAsBoolean(parameters, self.Z_POS_DOWN, context) feedback.pushConsoleInfo( self.tr(f'Shading by {self.shaders[shade_by]}\n')) # set new default values in config feedback.pushConsoleInfo( self.tr(f'Storing new default settings in config...')) self.config.set(self.module, 'shader', shade_by) # create empty temp file variables rgb_file, hs_file, slope_file, slope_stretch_file, slope_inv_file = None, None, None, None, None # create switches for shade_by hillshade, slope, combo = False, False, False # set settings by shade_by if shade_by == 0: hillshade = True syntax = 'uint8(((A/255.)*(((B*0.5)+(255.*0.5))/255.))*255)' elif shade_by == 1: slope = True syntax = 'uint8(((A/255.)*(((C*0.5)+(255.*0.5))/255.))*255)' elif shade_by == 2: combo = True syntax = 'uint8(((A/255.)*(((B*0.3)+(255.*0.7))/255.)*(((C*0.3)+(255.*0.7))/255.))*255)' # create temporary folder tmp_folder = QgsProcessingUtils.tempFolder() # render selected layer with defined symbology as rgb raster feedback.pushConsoleInfo(self.tr(f'Rendering layer to RGB...')) rgb_file = os.path.join(tmp_folder, f'rgb.{self.ext}') error, result = self.create_rgb(raster_layer, rgb_file) if error: feedback.reportError(self.tr(result), fatalError=True) return {} # 20% done feedback.setProgress(20) # get crs from layer crs_raster = raster_layer.crs() # get scale for vertical units scale = self.get_scale(crs_raster) if hillshade or combo: # create hillshade feedback.pushConsoleInfo(self.tr(f'Creating hillshade grid...')) # if raster is z positive down flip illumination direction if z_pos_down: self.azimuth = (self.azimuth - 180.) % 360. hs_file = os.path.join(tmp_folder, f'hs.{self.ext}') self.create_hs(raster_layer, self.hs_z_factor, scale, self.azimuth, self.altitude, hs_file, options) # 40% done feedback.setProgress(40) if slope or combo: # create slope feedback.pushConsoleInfo(self.tr(f'Creating slope grid...')) slope_file = os.path.join(tmp_folder, f'slope.{self.ext}') self.create_slope(raster_layer, self.slope_z_factor, scale, slope_file, options) # 60% done feedback.setProgress(60) # stretch slope to min max feedback.pushConsoleInfo(self.tr(f'Stretching slope grid...')) slope_stretch_file = os.path.join(tmp_folder, f'slope_stretch.{self.ext}') self.stretch_min_max(slope_file, slope_stretch_file, options) # 70% done feedback.setProgress(70) # invert slope (White to Black instead of Black to White) feedback.pushConsoleInfo( self.tr(f'Inverting stretched slope grid...')) slope_inv_file = os.path.join(tmp_folder, f'slope_inv.{self.ext}') self.invert(slope_stretch_file, slope_inv_file, options) # 80% done feedback.setProgress(80) # shading computation feedback.pushConsoleInfo(self.tr(f'Calculating output raster...\n')) self.shade(rgb_file, hs_file, slope_inv_file, syntax, output, crs_raster, options) # 99% done feedback.setProgress(99) # delete temp files for file in [ rgb_file, hs_file, slope_file, slope_stretch_file, slope_inv_file ]: if os.path.isfile(str(file)): os.remove(file) # 100% done feedback.setProgress(100) feedback.pushInfo( self. tr(f'{utils.return_success()}! Shaded bathymetry file is created!\n' )) result = {self.OUTPUT: output} return result
def processAlgorithm(self, parameters, context, feedback): source = self.parameterAsVectorLayer(parameters, self.INPUT, context) if source is None: raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT)) max_distance = self.parameterAsDouble(parameters, self.MAX_DISTANCE, context) raster_type = self.RASTER_TYPES[self.parameterAsEnum(parameters, self.RASTER_TYPE, context)] extent = self.parameterAsExtent(parameters, self.EXTENT, context, source.sourceCrs()) if extent is None or extent.width() == 0 or extent.height() == 0: extent = source.sourceExtent() cell_size = self.parameterAsDouble(parameters, self.CELL_SIZE, context) if cell_size <= 0: cell_size = int(min(extent.width(), extent.height()) / 250.0) output_raster = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) # open ogr vector layer from qgs map layer ogrLayer, layerName = self.getOgrCompatibleSource(self.INPUT, parameters, context, feedback, True) if ogrLayer is None: raise QgsProcessingException('Cannot connect OGR driver!') ogr_vector_datasource = ogr.Open(ogrLayer) ogr_vector_layer = ogr_vector_datasource.GetLayer(layerName) feedback.pushInfo('Raster Type = {0}'.format(raster_type)) feedback.pushInfo('Cell Size = {0}'.format(cell_size)) feedback.pushInfo('Extent = {0}'.format(extent)) nodata = -9999 srs = osr.SpatialReference() srs.ImportFromWkt(source.crs().toWkt()) transform = [extent.xMinimum(), cell_size, 0.0, extent.yMaximum(), 0.0, -cell_size] raster_width = int(math.ceil(abs(extent.xMaximum() - extent.xMinimum()) / cell_size)) raster_height = int(math.ceil(abs(extent.yMaximum() - extent.yMinimum()) / cell_size)) # rasterize temporary raterdataset from vector layer, extent, cellsize temporary_path = os.path.join(QgsProcessingUtils.tempFolder(), 'euc_distance_{}.tif'.format(uuid.uuid4().hex)) feedback.pushInfo('Temporary path = {0}'.format(temporary_path)) driver = gdal.GetDriverByName('GTiff') rasterizedDS = driver.Create(temporary_path, raster_width, raster_height, 1, gdal.GDT_Byte) rasterizedDS.GetRasterBand(1).SetNoDataValue(nodata) rasterizedDS.SetGeoTransform(transform) rasterizedDS.SetProjection(srs.ExportToWkt()) rasterizedDS.GetRasterBand(1).Fill(nodata) gdal.RasterizeLayer(rasterizedDS, [1], ogr_vector_layer, burn_values=[1]) # compute proximity from rasterized dataset options = ['DISTUNITS=GEO'] if max_distance > 0: options.append('MAXDIST=' + str(max_distance)) proximityDs = driver.Create(output_raster, raster_width, raster_height, 1, gdal.GetDataTypeByName(raster_type)) proximityDs.GetRasterBand(1).SetNoDataValue(nodata) proximityDs.SetGeoTransform(transform) proximityDs.SetProjection(srs.ExportToWkt()) proximityDs.GetRasterBand(1).Fill(nodata) gdal.ComputeProximity(rasterizedDS.GetRasterBand(1), proximityDs.GetRasterBand(1), options, callback = None) # cleanup rasterizedDS = None proximityDs = None ogr_vector_datasource = None return {self.OUTPUT: output_raster}
def initialize(): icon = QgsApplication.getThemeIcon("/processingAlgorithm.svg") ProcessingConfig.settingIcons['General'] = icon 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.PREFER_FILENAME_AS_LAYER_NAME, ProcessingConfig.tr('Prefer output filename for layer names'), 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.SHOW_ALGORITHMS_KNOWN_ISSUES, ProcessingConfig.tr("Show algorithms with known issues"), False)) 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)) invalidFeaturesOptions = [ ProcessingConfig.tr('Do not filter (better performance)'), ProcessingConfig.tr( 'Skip (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)) threads = QgsApplication.maxThreads( ) # if user specified limit for rendering, lets keep that as default here, otherwise max threads = cpu_count( ) if threads == -1 else threads # if unset, maxThreads() returns -1 ProcessingConfig.addSetting( Setting(ProcessingConfig.tr('General'), ProcessingConfig.MAX_THREADS, ProcessingConfig.tr('Max Threads'), threads, valuetype=Setting.INT)) extensions = QgsVectorFileWriter.supportedFormatExtensions() ProcessingConfig.addSetting( Setting( ProcessingConfig.tr('General'), ProcessingConfig.DEFAULT_OUTPUT_VECTOR_LAYER_EXT, ProcessingConfig.tr('Default output vector layer extension'), QgsVectorFileWriter.supportedFormatExtensions()[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'), 'tif', valuetype=Setting.SELECTION, options=extensions)) ProcessingConfig.addSetting( Setting(ProcessingConfig.tr('General'), ProcessingConfig.TEMP_PATH, ProcessingConfig.tr('Temporary output folder path'), QgsProcessingUtils.tempFolder(), valuetype=Setting.FOLDER))