def initAlgorithm(self, config=None):
# Database Connection
if qgs_version < 31400:
db_param = QgsProcessingParameterString(
self.DATABASE,
self.tr('Database Connection'))
db_param.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'}})
else:
db_param = QgsProcessingParameterProviderConnection(
self.DATABASE,
self.tr('Database Connection'),
'postgres')
self.addParameter(db_param)
# Schema
if qgs_version < 31400:
schema_param = QgsProcessingParameterString(
self.SCHEMA,
self.tr('Schema'), 'bc250_reamb')
schema_param.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers_postgis.SchemaWidgetWrapper',
'connection_param': self.DATABASE}})
else:
schema_param = QgsProcessingParameterDatabaseSchema(
self.SCHEMA,
self.tr('Schema'),
defaultValue='bc250_reamb',
connectionParameterName=self.DATABASE)
self.addParameter(schema_param)
# Geopackage
self.addParameter(QgsProcessingParameterFile(self.GEOPACKAGE, 'Geopackage', 0, 'gpkg'))
# Clean Schema
'''
def initAlgorithm(self, config):
"""
Parameter setting.
"""
self.addParameter(
QgsProcessingParameterFile(
self.INPUT_FOLDER,
self.tr('Input folder'),
behavior=QgsProcessingParameterFile.Folder))
self.addParameter(
QgsProcessingParameterBoolean(
self.ONLY_GEO,
self.tr('Search only georreferenced files'),
defaultValue=True))
self.searchTypes = [
'Search only listed formats', 'Exclude listed formats'
]
self.addParameter(
QgsProcessingParameterEnum(self.SEARCH_TYPE,
self.tr('Search type'),
options=self.searchTypes,
defaultValue=0))
self.addParameter(
QgsProcessingParameterMatrix(self.FILE_FORMATS,
self.tr('Formats'),
headers=[self.tr('File Formats')],
numberRows=1,
defaultValue=['shp', 'tif']))
self.addParameter(
QgsProcessingParameterBoolean(self.COPY_FILES,
self.tr('Copy files to output'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterFolderDestination(
self.COPY_FOLDER,
self.tr('Copy files to folder'),
optional=True,
defaultValue=None))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Inventory layer')))
def testModelerParametersDialogAvailableValuesOfType(self):
# test getAvailableValuesOfType from ModelerParametersDialog
m = QgsProcessingModelAlgorithm()
string_param_1 = QgsProcessingModelParameter('string')
m.addModelParameter(QgsProcessingParameterString('string'),
string_param_1)
string_param_2 = QgsProcessingModelParameter('string2')
m.addModelParameter(QgsProcessingParameterString('string2'),
string_param_2)
num_param = QgsProcessingModelParameter('number')
m.addModelParameter(QgsProcessingParameterNumber('number'), num_param)
table_field_param = QgsProcessingModelParameter('field')
m.addModelParameter(QgsProcessingParameterField('field'),
table_field_param)
file_param = QgsProcessingModelParameter('file')
m.addModelParameter(QgsProcessingParameterFile('file'), file_param)
dlg = ModelerParametersDialog(m, m)
# test single types
self.assertEqual(
set(p.parameterName() for p in dlg.getAvailableValuesOfType(
QgsProcessingParameterNumber)), set(['number']))
self.assertEqual(
set(p.parameterName() for p in dlg.getAvailableValuesOfType(
QgsProcessingParameterField)), set(['field']))
self.assertEqual(
set(p.parameterName() for p in dlg.getAvailableValuesOfType(
QgsProcessingParameterFile)), set(['file']))
# test multiple types
self.assertEqual(
set(p.parameterName() for p in dlg.getAvailableValuesOfType([
QgsProcessingParameterString, QgsProcessingParameterNumber,
QgsProcessingParameterFile
])), set(['string', 'string2', 'number', 'file']))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFile(
self.INPUT, self.tr('Input LAS layer'), extension = 'las'))
self.addParameter(QgsProcessingParameterNumber(self.CELLSIZE,
self.tr('Cellsize'), QgsProcessingParameterNumber.Double,
minValue = 0, defaultValue = 10.0))
self.addParameter(QgsProcessingParameterEnum(self.XYUNITS,
self.tr('XY Units'), self.UNITS))
self.addParameter(QgsProcessingParameterEnum(self.ZUNITS,
self.tr('Z Units'), self.UNITS))
self.addParameter(QgsProcessingParameterFileDestination(self.OUTPUT,
self.tr('Output DTM file'),
self.tr('DTM files (*.dtm *.DTM)')))
class_var = QgsProcessingParameterString(
self.CLASS, self.tr('Class'), '', optional = True)
class_var.setFlags(class_var.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(class_var)
return_sel = QgsProcessingParameterString(
self.RETURN, self.tr('Select specific return'), '', optional = True)
return_sel.setFlags(return_sel.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(return_sel)
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFile(self.INPUT,
self.tr('Input LAS layer'),
extension='las'))
self.addParameter(
QgsProcessingParameterNumber(
self.VALUE,
self.tr('Standard Deviation multiplier'),
QgsProcessingParameterNumber.Double,
defaultValue=1))
self.addParameter(
QgsProcessingParameterNumber(self.WINDOWSIZE,
self.tr('Window size'),
QgsProcessingParameterNumber.Double,
defaultValue=10))
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT, self.tr('Output filtered LAS file'),
self.tr('LAS files (*.las *.LAS)')))
self.addAdvancedModifiers()
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterString(
'DownloadURL',
'Download URL',
multiLine=False,
defaultValue=
'http://geodata.rivm.nl/downloads/ank/ANK_084_20170314_gm_Bomenkaart_percentage.zip'
))
self.addParameter(
QgsProcessingParameterFile(
'Outputfolder',
'Output folder',
behavior=QgsProcessingParameterFile.Folder,
fileFilter='All files (*.*)',
defaultValue=None))
self.addParameter(
QgsProcessingParameterBoolean('VERBOSE_LOG',
'Verbose logging',
optional=True,
defaultValue=False))
def initAlgorithm(self, config=None):
# inputs
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT_RASTER,
self.tr('Input raster')))
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT_MASK,
self.tr('Mask raster'),
optional=True))
self.addParameter(
QgsProcessingParameterFile(self.INPUT_MODEL,
self.tr('Model learned')))
# output
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT_RASTER,
self.tr('Output raster'),
optional=False))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterEnum('importMode',
self.tr('Import mode:'),
options=self.IMPORT_MODE,
defaultValue=0))
self.addParameter(
QgsProcessingParameterString('dataset',
self.tr('Name of dataset'),
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
'deleteData',
self.tr('Delete existing data from existing tables'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterFile(
self.XTF,
self.tr('Interlis transfer input file'),
behavior=QgsProcessingParameterFile.File,
optional=False))
self.addParameter(
QgsProcessingParameterString(
self.ILIDIR,
self.tr('Interlis model search path'),
defaultValue='%ILI_FROM_DB;%XTF_DIR;http://models.geo.admin.ch/'
))
self.addParameter(
QgsProcessingParameterString(self.ILIMODELS,
self.tr('Interlis models'),
optional=True))
self.db_connections = dbConnectionNames()
self.addParameter(
QgsProcessingParameterEnum(self.DB,
self.tr('Database (connection name)'),
self.db_connections))
self.addParameter(
QgsProcessingParameterString('dbschema',
self.tr('Database schema name'),
defaultValue='public'))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFile(self.INPUT,
self.tr('Input ASCII file'),
behavior=QgsProcessingParameterFile.File))
self.addParameter(QgsProcessingParameterPoint(self.UL_POINT,
self.tr('Upper left corner of bounding box')))
self.addParameter(QgsProcessingParameterNumber(self.SIZE_X,
self.tr('Output X resolution, meters'),
type=QgsProcessingParameterNumber.Double,
minValue=0,
defaultValue=None))
self.addParameter(QgsProcessingParameterNumber(self.SIZE_Y,
self.tr('Output Y resolution, meters'),
type=QgsProcessingParameterNumber.Double,
minValue=0,
defaultValue=None))
self.addParameter(QgsProcessingParameterCrs(self.CRS,
self.tr('Output coordinate reference system'),
defaultValue='EPSG:4326'))
params = []
params.append(QgsProcessingParameterString(self.ARGUMENTS,
self.tr('Additional arguments'),
defaultValue=None,
optional=True))
options = QgsProcessingParameterString(self.OPTIONS,
self.tr('Raster creation options'),
defaultValue=None,
optional=True)
options.setMetadata({
'widget_wrapper': {
'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
params.append(options)
for p in params:
p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Output raster')))
def initAlgorithm(self, config=None):
"""
Definition of inputs and outputs of the algorithm, along with some other properties.
"""
self.addParameter(
QgsProcessingParameterFile(self.INPUT, self.tr('Input track file'),
0, 'json', None, False))
self.addParameter(
QgsProcessingParameterBoolean(
self.ADD_HEADER_ATTRIBUTES,
self.tr('Add header attributes to points'), False, True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT_POINT_LAYER,
self.tr('Track point layer'),
QgsProcessing.TypeVectorPoint))
self.addOutput(
QgsProcessingOutputNumber(self.NUMBER_TRACK_POINTS,
self.tr('Number of track points')))
def initAlgorithm(self, config=None):
self.modes = ((self.tr('Use strict color matching'), '-exact_color_entry'),
(self.tr('Use closest RGBA quadruplet'), '-nearest_color_entry'),
(self.tr('Use smoothly blended colors'), ''))
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(QgsProcessingParameterBand(self.BAND,
self.tr('Band number'),
1,
parentLayerParameterName=self.INPUT))
self.addParameter(QgsProcessingParameterBoolean(self.COMPUTE_EDGES,
self.tr('Compute edges'),
defaultValue=False))
self.addParameter(QgsProcessingParameterFile(self.COLOR_TABLE,
self.tr('Color configuration file')))
self.addParameter(QgsProcessingParameterEnum(self.MATCH_MODE,
self.tr('Matching mode'),
options=[i[0] for i in self.modes],
defaultValue=2))
options_param = QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
self.addParameter(options_param)
extra_param = QgsProcessingParameterString(self.EXTRA,
self.tr('Additional command-line parameters'),
defaultValue=None,
optional=True)
extra_param.setFlags(extra_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(extra_param)
self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT, self.tr('Color relief')))
def initAlgorithm(self, config=None):
"""
Define the inputs and outputs of the algorithm.
"""
# ADD INPUT FILE AND CRS SELECTOR
self.addParameter(
QgsProcessingParameterFile(self.INPUT,
self.tr('Epanet file'),
extension='inp'))
self.addParameter(
QgsProcessingParameterCrs(
self.CRS, self.tr('Coordinate reference system (CRS)')))
# ADD NODE AND LINK SINKS
self.addParameter(
QgsProcessingParameterFeatureSink(self.NODE_OUTPUT,
self.tr('Epanet nodes')))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.LINK_OUTPUT,
self.tr('Epanet links'),
))
def initAlgorithm(self, config=None):
# INPUT
self.addParameter(
QgsProcessingParameterFile(
self.FOLDER,
self.tr('Folder with raster files',
'Pasta com arquivos raster'),
behavior=QgsProcessingParameterFile.Folder,
defaultValue=None))
self.addParameter(
QgsProcessingParameterBoolean(self.SUBFOLDER,
self.tr('Check subfolders',
'Verificar sub-pastas'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterString(self.FORMAT,
self.tr('Format', 'Formato'),
defaultValue='.tif'))
self.addParameter(
QgsProcessingParameterEnum(self.GEOMETRY,
self.tr('Geometry', 'Geometria'),
options=[
self.tr('Polygon', 'Polígono'),
self.tr('Point', 'Ponto')
],
defaultValue=0))
self.addParameter(
QgsProcessingParameterCrs(self.CRS, self.tr('CRS', 'SRC'),
'ProjectCrs'))
# OUTPUT
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT, self.tr('Inventory Layer',
'Camada de Inventário')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFile(self.INPUT, 'Input PLANS DTM file',
QgsProcessingParameterFile.File, 'dtm'))
params = []
params.append(
QgsProcessingParameterBoolean(
self.MASK,
self.
tr('Produces a mask image showing the areas in the DTM with valid data'
),
defaultValue=None,
optional=True))
for p in params:
p.setFlags(p.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Output')))
def initAlgorithm(self, config=None):
self.services = [
None, 'Bare-CoverFraction-layer', 'BuiltUp-CoverFraction-layer',
'Crops-CoverFraction-layer', 'DataDensityIndicator',
'Discrete-Classification-map', 'Discrete-Classification-proba',
'Forest-Type-layer', 'Grass-CoverFraction-layer',
'MossLichen-CoverFraction-layer',
'PermanentWater-CoverFraction-layer',
'SeasonalWater-CoverFraction-layer', 'Shrub-CoverFraction-layer',
'Snow-CoverFraction-layer', 'Tree-CoverFraction-layer'
]
self.yearlist = ['2015', '2016', '2017', '2018', '2019', None]
self.addParameter(
QgsProcessingParameterEnum('prodotto',
'Product',
options=self.services,
defaultValue=None))
self.addParameter(
QgsProcessingParameterEnum('anno',
'Year',
options=self.yearlist,
defaultValue=None))
# self.addParameter(QgsProcessingParameterString('anno', 'Year', defaultValue=None)
self.addParameter(
QgsProcessingParameterString('nome_tile',
'Tile Name',
defaultValue=None,
optional=True))
# self.addParameter(QgsProcessingParameterString('prodotto', 'prodotto', defaultValue='Bare-CoverFraction-layer'))
self.addParameter(
QgsProcessingParameterFile(
'Download directory',
'Download directory',
behavior=QgsProcessingParameterFile.Folder,
optional=False,
defaultValue=None))
self.plugin_dir = os.path.dirname(__file__)
def initAlgorithm(self, config=None):
"""
Define the inputs and outputs of the algorithm.
"""
# ADD INPUT FILE
self.addParameter(
QgsProcessingParameterFile(self.INPUT,
self.tr('Epanet file'),
extension='inp'))
# ADD NODE AND LINK SINKS
self.addParameter(
QgsProcessingParameterFeatureSink(self.NODES_OUTPUT,
self.tr('Nodes')))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.LINKS_OUTPUT,
self.tr('Links'),
))
def initAlgorithm(self, config):
currentPath = getCurrentPath(self)
self.CURRENT_PATH = currentPath
FULL_PATH = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['ID06'][1]))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.BLOCKS, self.tr('Zonas Censales'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(
QgsProcessingParameterField(self.DPA_SECTOR, self.tr('DPA Zona'),
'dpa_zona', 'BLOCKS'))
self.addParameter(
QgsProcessingParameterFile(
self.ENCUESTA,
self.tr('Encuesta específica de uso del tiempo'),
extension='csv',
defaultValue=''))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.STUDY_AREA_GRID, self.tr(TEXT_GRID_INPUT),
[QgsProcessing.TypeVectorPolygon], '', OPTIONAL_GRID_INPUT))
if OPTIONAL_GRID_INPUT:
self.addParameter(
QgsProcessingParameterNumber(
self.CELL_SIZE, self.tr('Tamaño de la malla'),
QgsProcessingParameterNumber.Integer, P_CELL_SIZE, False,
1, 99999999))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT, self.tr('Salida'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH)))
def initAlgorithm(self, config):
super().initAlgorithm(config)
# fields to use
param = QgsProcessingParameterString(self.DATA_SOURCE_FIELDS_TO_USE,
self.tr("Fields to Use"),
optional=True)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
# panel size
param = QgsProcessingParameterNumber(self.PANEL_SIZE_INPUT,
self.tr("Panel Size"),
minValue=0,
defaultValue=0)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
# drop data-less points
self.addParameter(
QgsProcessingParameterBoolean(
self.DROP_DATALESS_POINTS_INPUT,
self.tr("Drop Data-less Points"),
defaultValue=
False # should maybe change to false in production version
))
# input data
self.addParameter(
QgsProcessingParameterFile(self.DATA_SOURCE_INPUT,
self.tr("Input Data"),
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.DROPPED_PINS_OUTPUT,
self.tr('Dropped Pins')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFile(self.DBPATH,
'Morpheo database',
extension='sqlite'))
self.addParameter(
QgsProcessingParameterBoolean(self.RTOPO,
'Compute topological radius', False))
self.addParameter(
QgsProcessingParameterBoolean(
self.ORTHOGONALITY,
'Compute orthogonality (require attributes)', False))
self.addParameter(
QgsProcessingParameterBoolean(
self.BETWEENNESS,
'Compute betweenness centrality (require attributes)', False))
self.addParameter(
QgsProcessingParameterBoolean(
self.CLOSENESS,
'Compute closeness centrality (require attributes)', False))
self.addParameter(
QgsProcessingParameterBoolean(
self.STRESS, 'Compute stress centrality (require attributes)',
False))
self.addParameter(
QgsProcessingParameterNumber(self.CLASSES,
'Number of classes',
minValue=2,
maxValue=99,
defaultValue=10))
# Outputs
self.addParameter(
QgsProcessingParameterMorpheoDestination(
self.OUTPUT_WAYS, "Ways", type=QgsProcessing.TypeVectorLine))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterVectorLayer(
'addresslayer',
'住所レイヤ',
types=[QgsProcessing.TypeVectorPolygon],
defaultValue=None))
self.addParameter(
QgsProcessingParameterField(
'addressfield',
'住所フィールド',
type=QgsProcessingParameterField.String,
parentLayerParameterName='addresslayer',
allowMultiple=False,
defaultValue=None))
#self.addParameter(QgsProcessingParameterFile('CSVfile', 'CSV file', behavior=QgsProcessingParameterFile.File, fileFilter='All Files（*.*）', defaultValue=None))
self.addParameter(
QgsProcessingParameterFile('INPUT', '入力csvファイル指定',
extension='csv'))
self.addParameter(
QgsProcessingParameterEnum('ENCODING',
'ENCODE',
options=['SJIS', 'UTF-8'],
allowMultiple=False,
defaultValue=None))
self.addParameter(
QgsProcessingParameterCrs('CRS', "出力ファイル座標系", optional=True))
self.addParameter(
QgsProcessingParameterVectorDestination(
'OUTPUT',
'出力ファイル名',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue=None))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(self.LIGHTING,
self.tr('Lighting layer')))
self.addParameter(
QgsProcessingParameterString(self.FLUX_FIELD_NAME,
self.tr('Flux field name'),
defaultValue="flux"))
self.addParameter(
QgsProcessingParameterBoolean(
self.OVERWRITE,
self.tr('Edit layer in place (new layer if unchecked)'),
defaultValue=False))
# self.addParameter(
# QgsProcessingParameterField(
# self.LIGHT_TYPE_FIELD,
# description=self.tr('Light type field'),
# defaultValue=self.DEFAULT_LIGHT_TYPE,
# parentLayerParameterName=self.LIGHTING))
# self.addParameter(
# QgsProcessingParameterFile(
# self.LIGHT_TYPE_ASSOC,
# self.tr('Association file (light type -> light type)')))
# self.addParameter(
# QgsProcessingParameterFile(
# self.FLUX_ASSOC,
# self.tr('Association file (light type -> flux)')))
self.addParameter(
QgsProcessingParameterFile(
self.LED_ASSOC,
self.
tr('LED efficacy association file (LED model -> luminous efficacy)'
),
defaultValue=self.DEFAULT_LED_ASSOC))
self.addParameter(
QgsProcessingParameterVectorDestination(self.OUTPUT,
self.tr('Output layer'),
optional=True))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input raster')))
self.addParameter(
QgsProcessingParameterFile(
self.COLOR_TABLE,
self.tr('Color table file'),
behavior=QgsProcessingParameterFile.File))
params = []
params.append(
QgsProcessingParameterString(self.ARGUMENTS,
self.tr('Additional arguments'),
defaultValue=None,
optional=True))
options = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Raster creation options'),
defaultValue=None,
optional=True)
options.setMetadata({
'widget_wrapper': {
'class':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
}
})
params.append(options)
for p in params:
p.setFlags(p.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Output file')))
def initAlgorithm(self, config=None):
"""Here we define the inputs and output of the algorithm, along
with some other properties.
"""
# The parameters
description = self.tr('INP File')
self.addParameter(
QgsProcessingParameterFile(self.INP_FILE,
description=description,
extension="inp"))
description = self.tr('OUT File')
self.addParameter(
QgsProcessingParameterFileDestination(self.OUT_FILE,
description=description,
fileFilter="out (*.out)"))
description = self.tr('LOG File')
self.addParameter(
QgsProcessingParameterFileDestination(self.LOG_FILE,
description=description,
fileFilter="log (*.log)"))
def initAlgorithm(self, config=None):
"""Here we define the inputs and output of the algorithm, along
with some other properties.
"""
# The parameters
description = self.tr('Database')
self.addParameter(
QgsProcessingParameterString(self.DATABASE,
description=description,
defaultValue="pg_qgep_demo_data"))
description = self.tr('Template INP File')
self.addParameter(
QgsProcessingParameterFile(self.TEMPLATE_INP_FILE,
description=description,
extension="inp"))
description = self.tr('Result INP File')
self.addParameter(
QgsProcessingParameterFileDestination(self.INP_FILE,
description=description,
fileFilter="inp (*.inp)"))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFile(self.INPUT,
self.tr('Input LAS layer'),
extension='las'))
self.addParameter(
QgsProcessingParameterNumber(
self.CELLSIZE,
self.tr('Cellsize for intermediate surfaces'),
QgsProcessingParameterNumber.Double,
minValue=0,
defaultValue=10.0))
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT, self.tr('Output ground LAS file'),
self.tr('LAS files (*.las *.LAS)')))
self.addParameter(
QgsProcessingParameterBoolean(self.SURFACE,
self.tr('Create .dtm surface'),
False))
self.addAdvancedModifiers()
def test_file_input( outputdir ):
""" Test file parameter
"""
param = QgsProcessingParameterFile("FILE", extension=".txt")
inp = parse_input_definition(param)
assert isinstance(inp,ComplexInput)
assert inp.as_reference == False
inp.data = "Hello world"
context = QgsProcessingContext()
context.workdir = str(outputdir)
value = filesio.get_processing_value( param, [inp], context)
outputpath = (Path(context.workdir)/param.name()).with_suffix(param.extension())
assert value == outputpath.name
assert outputpath.exists()
with outputpath.open('r') as f:
assert f.read() == inp.data
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFile(self.INPUT,
'Input PLANS DTM file',
QgsProcessingParameterFile.File,
'dtm'))
self.addParameter(QgsProcessingParameterNumber(self.CELLSIZE,
self.tr('Size of the cell used to report topographic metrics'),
QgsProcessingParameterNumber.Double,
minValue=0,
defaultValue=10.0))
self.addParameter(QgsProcessingParameterNumber(self.POINTSPACING,
self.tr('Point spacing'),
QgsProcessingParameterNumber.Double,
minValue = 0,
defaultValue = 1))
self.addParameter(QgsProcessingParameterNumber(self.LATITUDE,
self.tr('Latitude of the data area (used to compute the solar radiation index)'),
QgsProcessingParameterNumber.Integer,
minValue=-90,
maxValue=90,
defaultValue=0.0))
self.addParameter(QgsProcessingParameterNumber(self.WSIZE,
self.tr('The size of the window used to compute the Topographic Position Index'),
QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=10.0))
self.addParameter(QgsProcessingParameterBoolean(self.SQUARE,
self.tr('Use a square-shaped mask when computing the TPI'),
defaultValue=False))
self.addParameter(QgsProcessingParameterBoolean(self.VERSION64,
self.tr('Use 64-bit version'),
defaultValue=True))
self.addParameter(QgsProcessingParameterFileDestination(self.OUTPUT,
self.tr('Output file with tabular metric information'),
self.tr('CSV files (*.csv *.CSV)')))
self.addAdvancedModifiers()
def initAlgorithm(self, config):
currentPath = getCurrentPath(self)
self.CURRENT_PATH = currentPath
FULL_PATH = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['ID13'][1]))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.BLOCKS, self.tr('Manzanas'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(
QgsProcessingParameterField(self.DPA_MAN, self.tr('DPA Manzanas'),
'dpa_manzan', 'BLOCKS'))
self.addParameter(
QgsProcessingParameterFile(self.CENSO_POBLACION,
self.tr('Censo población'),
extension='csv',
defaultValue=""))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.STUDY_AREA_GRID, self.tr(TEXT_GRID_INPUT),
[QgsProcessing.TypeVectorPolygon], '', OPTIONAL_GRID_INPUT))
if OPTIONAL_GRID_INPUT:
self.addParameter(
QgsProcessingParameterNumber(
self.CELL_SIZE, self.tr('Tamaño de la malla'),
QgsProcessingParameterNumber.Integer, P_CELL_SIZE, False,
1, 99999999))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT, self.tr('Salida'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH)))
def initAlgorithm(self, config=None):
"""
Define the inputs and outputs of the algorithm.
"""
# ADD THE INPUT
self.addParameter(
QgsProcessingParameterFeatureSource(
self.NODE_INPUT,
self.tr('Input nodes layer'),
[QgsProcessing.TypeVectorPoint]
)
)
self.addParameter(
QgsProcessingParameterFeatureSource(
self.LINK_INPUT,
self.tr('Input links layer'),
[QgsProcessing.TypeVectorLine]
)
)
self.addParameter(
QgsProcessingParameterFile(
self.TEMPLATE,
self.tr('Epanet template file'),
extension='inp'
)
)
# ADD A FILE DESTINATION
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT,
self.tr('Epanet model file'),
fileFilter='*.inp'
)
)
def initAlgorithm(self, config=None):
# Banco
db_param = QgsProcessingParameterString(self.DATABASE,
'Database (connection name)')
db_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
})
self.addParameter(db_param)
# Esquema
schema_param = QgsProcessingParameterString(self.SCHEMA,
'Schema (schema name)',
'bc250_base', False, True)
schema_param.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers_postgis.SchemaWidgetWrapper',
'connection_param': self.DATABASE
}
})
self.addParameter(schema_param)
# Shapefile
self.addParameter(
QgsProcessingParameterFile(self.SHAPEFILE,
'Shapefile de recorte',
0,
'shp',
optional=True))
# Geopackage
self.addParameter(
QgsProcessingParameterFileDestination(self.GEOPACKAGE,
'Geopackage', '*.gpkg'))
