def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterField(
self.XFIELD,
self.tr('X attribute'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.Numeric))
self.addParameter(
QgsProcessingParameterField(
self.YFIELD,
self.tr('Y attribute'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.Numeric))
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT, self.tr('Scatterplot'),
self.tr('HTML files (*.html)')))
self.addOutput(
QgsProcessingOutputHtml(self.OUTPUT, self.tr('Scatterplot')))
def initAlgorithm(self, config=None):
super(TilesXYZAlgorithmDirectory, self).initAlgorithm()
self.addParameter(QgsProcessingParameterNumber(self.TILE_WIDTH,
self.tr('Tile width'),
minValue=1,
maxValue=4096,
defaultValue=256))
self.addParameter(QgsProcessingParameterNumber(self.TILE_HEIGHT,
self.tr('Tile height'),
minValue=1,
maxValue=4096,
defaultValue=256))
self.addParameter(QgsProcessingParameterBoolean(self.TMS_CONVENTION,
self.tr('Use inverted tile Y axis (TMS convention)'),
defaultValue=False,
optional=True))
self.addParameter(QgsProcessingParameterFolderDestination(self.OUTPUT_DIRECTORY,
self.tr('Output directory'),
optional=True))
self.addParameter(QgsProcessingParameterFileDestination(self.OUTPUT_HTML,
self.tr('Output html (Leaflet)'),
self.tr('HTML files (*.html)'),
optional=True))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT1, self.tr('Select stop points'),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterField(self.FID, 'Choose id field', 'fid',
self.INPUT1))
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT2,
self.tr('Select flowdir raster'),
'flowdir'))
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTDIR,
self.tr('Output dir'),
defaultValue='D:/WaterOutletIterator/'))
self.addParameter(
QgsProcessingParameterBoolean(self.KEEPTEMP,
self.tr('keep temporal files'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Output')))
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 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(
QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input vector')))
params = []
params.append(
QgsProcessingParameterString(self.FIELDS,
self.tr('Fields to export'),
defaultValue=None,
optional=True))
params.append(
QgsProcessingParameterString(self.SEPARATOR,
self.tr('Field separator'),
defaultValue=None,
optional=True))
params.append(
QgsProcessingParameterBoolean(
self.POSITION,
self.tr('Include position (X and Y)'),
defaultValue=False,
optional=True))
params.append(
QgsProcessingParameterBoolean(self.TRANSPOSE,
self.tr('Transpose output'),
defaultValue=False,
optional=True))
for p in params:
p.setFlags(p.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT, self.tr('Output file'),
self.tr('Text files (*.txt *.TXT)')))
def initAlgorithm(self, config = None):
# define input parameters
self.addParameter(
QgsProcessingParameterFeatureSource(
self.inShape,
self.tr('Eingabedatensatz'),
[QgsProcessing.TypeFile]
)
)
self.addParameter(
QgsProcessingParameterFeatureSource(
self.outShape,
self.tr('Zielflächen'),
[QgsProcessing.TypeFile]
)
)
self.addParameter(
QgsProcessingParameterField(
self.colApply,
self.tr('Spalten, die auf die Zielflächen übertragen werden sollen'),
None,
self.inShape,
-1,
True
)
)
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT,
self.tr('Ausgabedatensatz'),
fileFilter = '*.gpkg'
)
)
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=None):
self.addParameter(
QgsProcessingParameterVectorLayer(
'vectorwithclassificationandreference',
'Vector with reference data',
types=[QgsProcessing.TypeVector],
defaultValue=None))
#self.addParameter(QgsProcessingParameterVectorLayer('vectorwithclassificationandreference', 'Vector with classification', types=[QgsProcessing.TypeVector], defaultValue='C:/Users/Gorica/Documents/Teaching_2020_2021/Lab/Sampling points/stratified_random_sampling1_classified.gpkg'))
self.addParameter(
QgsProcessingParameterField(
'reference',
'Reference data column',
type=QgsProcessingParameterField.Numeric,
parentLayerParameterName='vectorwithclassificationandreference',
allowMultiple=False,
defaultValue=None))
self.addParameter(
QgsProcessingParameterString('Newfieldname',
'Name of new field for raster values',
multiLine=False,
defaultValue='Thematic_class'))
self.addParameter(
QgsProcessingParameterRasterLayer('raster',
'Raster to be sampled',
defaultValue=None))
self.addParameter(
QgsProcessingParameterFileDestination(
'Outputfolder',
'Error matrix output path',
fileFilter='CSV Files (*.csv)',
defaultValue=None))
self.addParameter(
QgsProcessingParameterFeatureSink(
'Sampled',
'Sampled',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True)) #, defaultValue=None))
def initAlgorithm(self, config=None):
# === INPUT PARAMETERS ===
inputAscParam = QgsProcessingParameterRasterLayer(
name=self.INPUT_ASC, description=self.tr('Input layer asc'))
inputAscParam.setMetadata({
'widget_wrapper': {
'class':
'Chloe.chloe_algorithm_dialog.ChloeAscRasterWidgetWrapper'
}
})
self.addParameter(inputAscParam)
fieldsParam = QgsProcessingParameterString(
name=self.DOMAINS,
description=self.tr('New classification'),
defaultValue='')
fieldsParam.setMetadata({
'widget_wrapper': {
'class':
'Chloe.chloe_algorithm_dialog.ChloeClassificationTableWidgetWrapper'
}
})
self.addParameter(fieldsParam)
# === OUTPUT PARAMETERS ===
fieldsParam = ChloeASCParameterFileDestination(
name=self.OUTPUT_ASC, description=self.tr('Output Raster ascii'))
self.addParameter(fieldsParam, createOutput=True)
self.addParameter(
QgsProcessingParameterFileDestination(
name=self.SAVE_PROPERTIES,
description=self.tr('Properties file'),
fileFilter='Properties (*.properties)'))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFile(
name=self.INPUT_PCL_1,
description=self.tr(
'Input LAS (or LAZ if managed by installed PDAL)'),
behavior=QgsProcessingParameterFile.File,
extension=None,
defaultValue=None,
optional=True))
self.addParameter(
QgsProcessingParameterFile(
name=self.INPUT_PCL_2,
description=self.tr('Input LAS/LAZ file'),
behavior=QgsProcessingParameterFile.File,
extension=None,
defaultValue=None,
optional=True))
self.addParameter(
QgsProcessingParameterString(name=self.INPUT_PIPELINE,
description=self.tr('Input pipeline'),
defaultValue=None,
optional=False))
self.addParameter(
QgsProcessingParameterBoolean(
name=self.INPUT_SKIP_IF_OUT_EXISTS,
description=self.tr('Skip if output already exists'),
defaultValue=True,
optional=False))
# set outputs
self.addParameter(
QgsProcessingParameterFileDestination(
name=self.OUTPUT_PCL,
description=self.tr('Output file'),
defaultValue=None,
createByDefault=True))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFile(
self.DB,
self.tr('GPKG database file'),
optional=False,
# behavior=QgsProcessingParameterFile.File, ext='gpkg'))
behavior=QgsProcessingParameterFile.File))
self.addParameter(
QgsProcessingParameterString('dataset',
self.tr('Name of dataset'),
optional=True))
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')))
self.addParameter(
QgsProcessingParameterFileDestination(
self.XTF, description="Interlis transfer output file"))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
default_extent = iface.mapCanvas().extent()
default_extent_value = '{0},{1},{2},{3}'.format(
default_extent.xMinimum(), default_extent.xMaximum(),
default_extent.yMinimum(), default_extent.yMaximum())
self.addParameter(
QgsProcessingParameterString(self.CANVAS_NAME, tr('Canvas name')))
self.addParameter(
QgsProcessingParameterExtent(
self.EXTENT,
tr('Minimum extent to render'),
defaultValue=str(default_extent_value)))
self.addParameter(
QgsProcessingParameterNumber(self.WIDTH,
tr('Output image width'),
defaultValue=800))
self.addParameter(
QgsProcessingParameterNumber(self.HEIGHT,
tr('Output image height'),
defaultValue=600))
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT,
tr('Output file'),
'csv(*.csv)',
))
def initAlgorithm(self, config=None):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
# We add the input vector features source. It can have any kind of
# geometry.
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Input layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterNumber(
self.RES,
self.tr('Raster resolution, m'),
type=QgsProcessingParameterNumber.Double,
defaultValue=10,
))
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT, self.tr('Output width raster')))
def initAlgorithm(self, config=None): # pylint: disable=missing-docstring,unused-argument
self.addParameter(
QgsProcessingParameterFile(self.INPUT,
'Style database',
extension='style'))
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT,
'Destination XML file',
fileFilter="XML files (*.xml)"))
self.addOutput(
QgsProcessingOutputNumber(self.FILL_SYMBOL_COUNT,
'Fill Symbol Count'))
self.addOutput(
QgsProcessingOutputNumber(self.LINE_SYMBOL_COUNT,
'Line Symbol Count'))
self.addOutput(
QgsProcessingOutputNumber(self.MARKER_SYMBOL_COUNT,
'Marker Symbol Count'))
self.addOutput(
QgsProcessingOutputNumber(self.COLOR_RAMP_COUNT,
'Color Ramp Count'))
self.addOutput(
QgsProcessingOutputNumber(self.UNREADABLE_FILL_SYMBOLS,
'Unreadable Fill Symbol Count'))
self.addOutput(
QgsProcessingOutputNumber(self.UNREADABLE_LINE_SYMBOLS,
'Unreadable Line Symbol Count'))
self.addOutput(
QgsProcessingOutputNumber(self.UNREADABLE_MARKER_SYMBOLS,
'Unreadable Marker Symbol Count'))
self.addOutput(
QgsProcessingOutputNumber(self.UNREADABLE_COLOR_RAMPS,
'Unreadable Color Ramps'))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterMeshLayer(
self.INPUT_LAYER,
'Input mesh layer',
optional=False))
self.addParameter(QgsProcessingParameterString(
self.INPUT_FORMULA,
'Formula',
multiLine=True,
optional=False))
self.addParameter(QgsProcessingParameterExtent(
self.INPUT_EXTENT,
'Extent',
optional=False
))
self.addParameter(TimestepParameter(
self.INPUT_STARTTIME,
'Start Time',
self.INPUT_LAYER,
optional=False))
self.addParameter(TimestepParameter(
self.INPUT_ENDTIME,
'End Time',
self.INPUT_LAYER,
optional=False))
# only dat file exporter is implemented in MDAL
self.addParameter(QgsProcessingParameterFileDestination(
self.OUTPUT_FILE,
'Exported dataset group file',
'binary DAT (*.dat)',
))
def initAlgorithm(self, config):
self.addParameter(
QgsProcessingParameterFile(self.INPUT,
'Initial QGIS project',
behavior=QgsProcessingParameterFile.File,
extension='qgs')
)
self.addParameter(
QgsProcessingParameterString(self.VARIABLE_NAME,
'Variable name')
)
self.addParameter(
QgsProcessingParameterMapLayer(self.VARIABLE_VALUE,
'Variable value')
)
self.addParameter(
QgsProcessingParameterFileDestination(self.OUTPUT,
'Modified QGIS project',
'QGIS project files (*.qgs)')
)
def initAlgorithm(self, config):
self.addParameter(
QgsProcessingParameterFile(self.INPUT,
'Initial QGIS project',
behavior=QgsProcessingParameterFile.File,
extension='qgs')
)
self.addParameter(
QgsProcessingParameterString(self.OLD_LAYER_ID,
'Old layer ID')
)
self.addParameter(
QgsProcessingParameterMapLayer(self.NEW_LAYER,
'New layer')
)
self.addParameter(
QgsProcessingParameterFileDestination(self.OUTPUT,
'Modified QGIS project',
'QGIS project files (*.qgs)')
)
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'))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterFile(
self.INPUT,
self.tr('GTFS folder'),
QgsProcessingParameterFile.Folder
)
)
self.addParameter(
QgsProcessingParameterString(
self.DEBUT_PERIODE,
self.tr('Calendar start'),
datetime.date.today().strftime("%d/%m/%Y")
)
)
self.addParameter(
QgsProcessingParameterString(
self.FIN_PERIODE,
self.tr('Calendar end'),
datetime.date.today().strftime("%d/%m/%Y")
)
)
# We add a feature sink in which to store our processed features (this
# usually takes the form of a newly created vector layer when the
# algorithm is run in QGIS).
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT,
self.tr('Musliw timetable network'),
'*.txt'
)
)
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterMeshLayer(self.INPUT_LAYER,
'Input mesh layer',
optional=False))
self.addParameter(
DatasetParameter(self.INPUT_DATASETS,
'Dataset groups',
self.INPUT_LAYER,
allowMultiple=False,
optional=False))
self.addParameter(
TimestepParameter(self.INPUT_TIMESTEP,
'Timestep',
self.INPUT_LAYER,
optional=False))
self.addParameter(
QgsProcessingParameterNumber(
self.INPUT_RESOLUTION,
self.tr('Line segmentation resolution'),
type=QgsProcessingParameterNumber.Double,
optional=False,
defaultValue=1.))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT_LINES, 'Lines for data export',
[QgsProcessing.TypeVectorLine]))
self.addParameter(
QgsProcessingParameterFileDestination(self.OUTPUT_FILE,
'Exported data CSV file',
'CSV file (*.csv)'))
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):
self.methods = (
(self.tr('Nearest neighbour'), 'near'),
(self.tr('Bilinear'), 'bilinear'),
(self.tr('Cubic'), 'cubic'),
(self.tr('Cubic spline'), 'cubicspline'),
(self.tr('Lanczos windowed sinc'), 'lanczos'),
)
self.addParameter(
QgsProcessingParameterMultipleLayers(self.INPUT,
self.tr('Input files'),
QgsProcessing.TypeRaster))
self.addParameter(
QgsProcessingParameterNumber(
self.TILE_SIZE_X,
self.tr('Tile width'),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=256))
self.addParameter(
QgsProcessingParameterNumber(
self.TILE_SIZE_Y,
self.tr('Tile height'),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=256))
self.addParameter(
QgsProcessingParameterNumber(
self.OVERLAP,
self.tr('Overlap in pixels between consecutive tiles'),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.LEVELS,
self.tr('Number of pyramids levels to build'),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=1))
params = []
params.append(
QgsProcessingParameterCrs(
self.SOURCE_CRS,
self.tr('Source coordinate reference system'),
optional=True))
params.append(
QgsProcessingParameterEnum(self.RESAMPLING,
self.tr('Resampling method'),
options=[i[0] for i in self.methods],
allowMultiple=False,
defaultValue=0))
params.append(
QgsProcessingParameterString(
self.DELIMITER,
self.tr('Column delimiter used in the CSV file'),
defaultValue=';',
optional=True))
options_param = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setMetadata({
'widget_wrapper': {
'class':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
}
})
params.append(options_param)
params.append(
QgsProcessingParameterEnum(self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=5))
params.append(
QgsProcessingParameterBoolean(self.ONLY_PYRAMIDS,
self.tr('Build only the pyramids'),
defaultValue=False))
params.append(
QgsProcessingParameterBoolean(
self.DIR_FOR_ROW,
self.tr('Use separate directory for each tiles row'),
defaultValue=False))
for param in params:
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
self.addParameter(
QgsProcessingParameterFolderDestination(
self.OUTPUT, self.tr('Output directory')))
output_csv_param = QgsProcessingParameterFileDestination(
self.OUTPUT_CSV,
self.tr(
'CSV file containing the tile(s) georeferencing information'),
'CSV files (*.csv)',
optional=True)
output_csv_param.setCreateByDefault(False)
self.addParameter(output_csv_param)
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterFeatureSource(
self.POLES,
self.tr('OD Table'),
))
self.addParameter(
QgsProcessingParameterField(
self.ORIGIN,
self.tr('Origin'),
parentLayerParameterName=self.POLES,
))
self.addParameter(
QgsProcessingParameterField(
self.DESTINATION,
self.tr('Destination'),
parentLayerParameterName=self.POLES,
))
self.addParameter(
QgsProcessingParameterNumber(
self.NB_PASSAGERS,
self.tr('Demand'),
QgsProcessingParameterNumber.Double,
defaultValue=1.0,
))
self.addParameter(
QgsProcessingParameterNumber(
self.JOUR,
self.tr('Day'),
QgsProcessingParameterNumber.Integer,
defaultValue=1,
))
self.addParameter(
QgsProcessingParameterString(self.DEBUT_PERIODE,
self.tr('Start time'),
defaultValue=str.format(
"{0}:00:00",
datetime.datetime.now().hour)))
self.addParameter(
QgsProcessingParameterString(
self.FIN_PERIODE,
self.tr('End time'),
defaultValue=str.format("{0}:00:00",
datetime.datetime.now().hour + 1)))
self.addParameter(
QgsProcessingParameterNumber(
self.INTERVALLE,
self.tr('Step'),
QgsProcessingParameterNumber.Double,
defaultValue=15,
))
self.addParameter(
QgsProcessingParameterEnum(
self.DEPART,
self.tr("Departure/Arrival"),
[self.tr('Departure'),
self.tr('Arrival')],
defaultValue=0))
self.addParameter(
QgsProcessingParameterBoolean(self.LABEL, self.tr("OD label?"),
False))
# We add a feature sink in which to store our processed features (this
# usually takes the form of a newly created vector layer when the
# algorithm is run in QGIS).
self.addParameter(
QgsProcessingParameterFileDestination(self.SORTIE,
self.tr('Musliw matrix'),
'*.txt'))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(self.INPUT_LAYER,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_NAME, self.tr('Field to calculate statistics on'),
None, self.INPUT_LAYER, QgsProcessingParameterField.Any))
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_HTML_FILE, self.tr('Statistics'),
self.tr('HTML files (*.html)'), None, True))
self.addOutput(
QgsProcessingOutputHtml(self.OUTPUT_HTML_FILE,
self.tr('Statistics')))
self.addOutput(QgsProcessingOutputNumber(self.COUNT, self.tr('Count')))
self.addOutput(
QgsProcessingOutputNumber(self.UNIQUE,
self.tr('Number of unique values')))
self.addOutput(
QgsProcessingOutputNumber(
self.EMPTY, self.tr('Number of empty (null) values')))
self.addOutput(
QgsProcessingOutputNumber(self.FILLED,
self.tr('Number of non-empty values')))
self.addOutput(
QgsProcessingOutputNumber(self.MIN, self.tr('Minimum value')))
self.addOutput(
QgsProcessingOutputNumber(self.MAX, self.tr('Maximum value')))
self.addOutput(
QgsProcessingOutputNumber(self.MIN_LENGTH,
self.tr('Minimum length')))
self.addOutput(
QgsProcessingOutputNumber(self.MAX_LENGTH,
self.tr('Maximum length')))
self.addOutput(
QgsProcessingOutputNumber(self.MEAN_LENGTH,
self.tr('Mean length')))
self.addOutput(
QgsProcessingOutputNumber(self.CV,
self.tr('Coefficient of Variation')))
self.addOutput(QgsProcessingOutputNumber(self.SUM, self.tr('Sum')))
self.addOutput(
QgsProcessingOutputNumber(self.MEAN, self.tr('Mean value')))
self.addOutput(
QgsProcessingOutputNumber(self.STD_DEV,
self.tr('Standard deviation')))
self.addOutput(QgsProcessingOutputNumber(self.RANGE, self.tr('Range')))
self.addOutput(
QgsProcessingOutputNumber(self.MEDIAN, self.tr('Median')))
self.addOutput(
QgsProcessingOutputNumber(
self.MINORITY, self.tr('Minority (rarest occurring value)')))
self.addOutput(
QgsProcessingOutputNumber(
self.MAJORITY,
self.tr('Majority (most frequently occurring value)')))
self.addOutput(
QgsProcessingOutputNumber(self.FIRSTQUARTILE,
self.tr('First quartile')))
self.addOutput(
QgsProcessingOutputNumber(self.THIRDQUARTILE,
self.tr('Third quartile')))
self.addOutput(
QgsProcessingOutputNumber(self.IQR,
self.tr('Interquartile Range (IQR)')))
def initAlgorithm(self, config):
"""Initialize algorithm with inputs and output parameters."""
if HAS_DB_PROCESSING_PARAMETER:
db_param = QgsProcessingParameterProviderConnection(
self.DATABASE,
self.tr('PostgreSQL database (connection name)'),
'postgres',
)
schema_param = QgsProcessingParameterDatabaseSchema(
self.SCHEMA,
self.tr('PostgreSQL schema name'),
connectionParameterName=self.DATABASE,
defaultValue='public',
)
table_param = QgsProcessingParameterDatabaseTable(
self.TABLENAME,
self.tr('PostgreSQL original table name'),
connectionParameterName=self.DATABASE,
schemaParameterName=self.SCHEMA)
else:
db_param = QgsProcessingParameterString(
self.DATABASE,
self.tr('PostgreSQL database (connection name)'),
)
db_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
})
schema_param = QgsProcessingParameterString(
self.SCHEMA,
self.tr('PostgreSQL schema name'),
'public',
False,
True,
)
schema_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.SchemaWidgetWrapper',
'connection_param': self.DATABASE,
}
})
table_param = QgsProcessingParameterString(
self.TABLENAME,
self.tr('PostgreSQL original table name'),
'',
False,
True,
)
table_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.TableWidgetWrapper',
'schema_param': self.SCHEMA,
}
})
self.addParameter(db_param)
self.addParameter(schema_param)
self.addParameter(table_param)
self.addParameter(
QgsProcessingParameterFeatureSource(
self.NEW_INPUT,
self.tr('New layer'),
types=[QgsProcessing.TypeVector],
))
self.addParameter(
QgsProcessingParameterField(
self.FIELDS_TO_COMPARE,
self.tr('Fields to compare'),
None,
self.NEW_INPUT,
allowMultiple=True,
))
self.addParameter(
QgsProcessingParameterEnum(
self.HIGHLIGHT_METHOD,
self.tr('Highlight method'),
options=[
self.tr('Only highlight different lines'),
self.
tr('Highligt different lines and inta-line character changes (Slower on '
'large layers)'),
],
defaultValue=0,
))
self.addParameter(
QgsProcessingParameterExpression(
self.SORT_EXPRESSION,
self.tr('Sort expression (put in ORDER BY clause)'),
parentLayerParameterName=self.NEW_INPUT,
defaultValue='',
))
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_HTML_FILE, self.tr('HTML report'),
self.tr('HTML files (*.html)'), None, True))
def accept(self):
description = self.nameTextBox.text()
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while self.alg.parameterDefinition(name):
name = safeName.lower() + str(i)
i += 1
else:
name = self.param.name()
if (self.paramType == parameters.PARAMETER_BOOLEAN
or isinstance(self.param, QgsProcessingParameterBoolean)):
self.param = QgsProcessingParameterBoolean(name, description,
self.state.isChecked())
elif (self.paramType == parameters.PARAMETER_TABLE_FIELD
or isinstance(self.param, QgsProcessingParameterField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
default = self.defaultTextBox.text()
if not default:
default = None
self.param = QgsProcessingParameterField(
name,
description,
defaultValue=default,
parentLayerParameterName=parent,
type=datatype,
allowMultiple=self.multipleCheck.isChecked())
elif (self.paramType == parameters.PARAMETER_BAND
or isinstance(self.param, QgsProcessingParameterBand)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterBand(name, description, None,
parent)
elif (self.paramType == parameters.PARAMETER_MAP_LAYER
or isinstance(self.param, QgsProcessingParameterMapLayer)):
self.param = QgsProcessingParameterMapLayer(name, description)
elif (self.paramType == parameters.PARAMETER_RASTER
or isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(name, description)
elif (self.paramType == parameters.PARAMETER_TABLE
or isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description, self.datatypeCombo.currentData())
elif (self.paramType == parameters.PARAMETER_NUMBER or isinstance(
self.param,
(QgsProcessingParameterNumber, QgsProcessingParameterDistance))):
try:
self.param = QgsProcessingParameterNumber(
name, description, QgsProcessingParameterNumber.Double,
self.defaultTextBox.text())
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType == parameters.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(
name, description, str(self.defaultEdit.expression()), parent)
elif (self.paramType == parameters.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
self.param = QgsProcessingParameterString(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_EXTENT
or isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
elif (self.paramType == parameters.PARAMETER_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = QgsProcessingParameterFile(
name, description, QgsProcessingParameterFile.Folder
if isFolder else QgsProcessingParameterFile.File)
elif (self.paramType == parameters.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.param = QgsProcessingParameterPoint(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.param = QgsProcessingParameterCrs(
name, description,
self.selector.crs().authid())
elif (self.paramType == parameters.PARAMETER_ENUM
or isinstance(self.param, QgsProcessingParameterEnum)):
self.param = QgsProcessingParameterEnum(
name, description, self.widget.options(),
self.widget.allowMultiple(), self.widget.defaultOptions())
elif (self.paramType == parameters.PARAMETER_MATRIX
or isinstance(self.param, QgsProcessingParameterMatrix)):
self.param = QgsProcessingParameterMatrix(
name,
description,
hasFixedNumberRows=self.widget.fixedRows(),
headers=self.widget.headers(),
defaultValue=self.widget.value())
# Destination parameter
elif (isinstance(self.param, QgsProcessingParameterFeatureSink)):
self.param = QgsProcessingParameterFeatureSink(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterFileDestination)):
self.param = QgsProcessingParameterFileDestination(
name=name,
description=self.param.description(),
fileFilter=self.param.fileFilter(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterFolderDestination)):
self.param = QgsProcessingParameterFolderDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterRasterDestination)):
self.param = QgsProcessingParameterRasterDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterVectorDestination)):
self.param = QgsProcessingParameterVectorDestination(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.getValue())
else:
if self.paramType:
typeId = self.paramType
else:
typeId = self.param.type()
paramTypeDef = QgsApplication.instance().processingRegistry(
).parameterType(typeId)
if not paramTypeDef:
msg = self.tr(
'The parameter `{}` is not registered, are you missing a required plugin?'
.format(typeId))
raise UndefinedParameterException(msg)
self.param = paramTypeDef.create(name)
self.param.setDescription(description)
self.param.setMetadata(paramTypeDef.metadata())
if not self.requiredCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagOptional)
else:
self.param.setFlags(
self.param.flags()
& ~QgsProcessingParameterDefinition.FlagOptional)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterString(self.CTC,
self.tr('In vehicle weight'), '1'))
self.addParameter(
QgsProcessingParameterString(self.CATT, self.tr('Waiting weight'),
'1'))
self.addParameter(
QgsProcessingParameterString(self.CMAP,
self.tr('Individual modes weight'),
'1.5'))
self.addParameter(
QgsProcessingParameterString(self.CBOA, self.tr('Boarding weight'),
'3'))
self.addParameter(
QgsProcessingParameterString(
self.CTMAP, self.tr('Individual mode speed factor'), '1'))
self.addParameter(
QgsProcessingParameterString(self.TBOA_MIN,
self.tr('Minimum transfer delay'),
'2'))
self.addParameter(
QgsProcessingParameterString(self.TBOA_MAX,
self.tr('Maximum transfer delay'),
'60'))
self.addParameter(
QgsProcessingParameterNumber(
self.NBJOURS,
self.tr('Extra day duration'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.TMAP_MAX,
self.tr('Max. individual time budget'),
type=QgsProcessingParameterNumber.Double,
defaultValue=60.0))
self.addParameter(
QgsProcessingParameterNumber(
self.COUT_MAX,
self.tr('Maximum generalized time'),
type=QgsProcessingParameterNumber.Double,
defaultValue=1500.0))
self.addParameter(
QgsProcessingParameterString(self.TOLL, self.tr('Toll weight'),
'0'))
self.addParameter(
QgsProcessingParameterString(self.FILTRE,
self.tr('Output filter'),
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.TEMPS_DETAILLES,
self.tr('Output links times?'), [
self.tr('No output'),
self.tr('Without timetable links'),
self.tr("With timetable links")
],
defaultValue=0))
self.addParameter(
QgsProcessingParameterBoolean(self.DEMI_TOURS_INTERDITS,
self.tr('Prohibited U-turns?'),
True))
self.addParameter(
QgsProcessingParameterBoolean(self.SORTIE_CHEMINS,
self.tr('Output paths?'), True))
self.addParameter(
QgsProcessingParameterBoolean(self.SORTIE_SERVICES,
self.tr('Output services?'), False))
self.addParameter(
QgsProcessingParameterBoolean(self.SORTIE_TRANSFERTS,
self.tr('Output transfers?'), False))
self.addParameter(
QgsProcessingParameterBoolean(self.SORTIE_NOEUDS,
self.tr('Output node times?'),
False))
self.addParameter(
QgsProcessingParameterNumber(
self.ECHELLE,
self.tr('Algorithm scale?'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=20))
self.addParameter(
QgsProcessingParameterNumber(
self.PU,
self.tr('Algorithm exponent?'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=2))
self.addParameter(
QgsProcessingParameterNumber(
self.MAX_CLASSES,
self.tr('nb classes?'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=10000))
self.addParameter(
QgsProcessingParameterFileDestination(self.SORTIE,
self.tr('Parameters file'),
"*.txt"))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterFeatureSource(
self.NODES, self.tr('Nodes'), [QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterField(
self.NUM,
self.tr('Node ID'),
parentLayerParameterName=self.NODES,
))
self.addParameter(
QgsProcessingParameterPoint(
self.START_POINT,
self.tr('Trip start'),
))
self.addParameter(
QgsProcessingParameterPoint(
self.END_POINT,
self.tr('Trip end'),
))
self.addParameter(
QgsProcessingParameterNumber(
self.DEMAND,
self.tr('Demand'),
QgsProcessingParameterNumber.Double,
defaultValue=1.0,
))
self.addParameter(
QgsProcessingParameterNumber(
self.DAY,
self.tr('Day'),
QgsProcessingParameterNumber.Integer,
defaultValue=1,
))
self.addParameter(
QgsProcessingParameterString(
self.TIME,
self.tr('Time'),
defaultValue=datetime.datetime.now().strftime("%H:%M:%S")))
self.addParameter(
QgsProcessingParameterEnum(
self.DEPARTURE,
self.tr("Departure/Arrival"),
[self.tr('Departure'),
self.tr('Arrival')],
defaultValue=0))
# We add a feature sink in which to store our processed features (this
# usually takes the form of a newly created vector layer when the
# algorithm is run in QGIS).
self.addParameter(
QgsProcessingParameterFileDestination(self.OUTPUT,
self.tr('Musliw matrix'),
'*.txt'))
self.addParameter(
QgsProcessingParameterEnum(
self.WRITE_MODE,
self.tr('Write Mode'),
[self.tr('Write'), self.tr('Append')],
defaultValue=0))
def initAlgorithm(self, config=None):
# The name that the user will see in the toolbox
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT_RASTER,
self.tr('Input raster')))
# SLOO
self.addParameter(
QgsProcessingParameterBoolean(
self.SLOO,
self.tr(
'Check for Leave-One-Out validation. Uncheck for 50\\50.'),
defaultValue=True))
# Train algorithm
self.addParameter(
QgsProcessingParameterEnum(self.TRAIN, "Select algorithm to train",
self.TRAIN_ALGORITHMS, 0))
# ROI
# VECTOR
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT_LAYER,
'Input layer',
))
# TABLE / COLUMN
self.addParameter(
QgsProcessingParameterField(
self.INPUT_COLUMN,
'Field (column must have classification number (e.g. \'1\' forest, \'2\' water...))',
parentLayerParameterName=self.INPUT_LAYER,
optional=False)) # save model
self.addParameter(
QgsProcessingParameterField(
self.STAND_COLUMN,
'Stand number (column must have unique id per stand)',
parentLayerParameterName=self.INPUT_LAYER,
optional=False)) # save model
self.addParameter(
QgsProcessingParameterNumber(
self.MAXITER,
self.tr('Maximum iteration (default : 5)'),
type=QgsProcessingParameterNumber.Integer,
minValue=1,
maxValue=99999,
defaultValue=5))
self.addParameter(
QgsProcessingParameterString(
self.PARAMGRID,
self.tr('Parameters for the hyperparameters of the algorithm'),
optional=True))
# SAVE AS
# SAVE MODEL
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_MODEL,
self.tr("Output model (to use for classifying)")))
"""
# SAVE CONFUSION MATRIX
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_MATRIX,
self.tr("Output confusion matrix"),
fileFilter='csv'))#,
#ext='csv'))
"""
# SAVE DIR
self.addParameter(
QgsProcessingParameterFolderDestination(
self.SAVEDIR,
self.tr("Directory to save every confusion matrix")))
