Python QgsProcessingUtils.tempFolder方法代码示例

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import tempFolder [as 别名]
    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)]

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import tempFolder [as 别名]
    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()

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import tempFolder [as 别名]
    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)]

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import tempFolder [as 别名]
    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()

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import tempFolder [as 别名]
 def grassDataFolder():
     """
     Creates and returns the GRASS temporary DB directory.
     """
     tempfolder = os.path.normpath(
         os.path.join(QgsProcessingUtils.tempFolder(), 'grassdata'))
     mkdir(tempfolder)
     return tempfolder

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import tempFolder [as 别名]
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

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import tempFolder [as 别名]
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

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import tempFolder [as 别名]
 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

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import tempFolder [as 别名]
    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)]

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import tempFolder [as 别名]
    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}

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import tempFolder [as 别名]
 def grassDataFolder():
     tempfolder = os.path.join(QgsProcessingUtils.tempFolder(), 'grassdata')
     mkdir(tempfolder)
     return tempfolder