def initAlgorithm(self, config=None):
self.predicates = (
('intersects', self.tr('intersects')),
('contains', self.tr('contains')),
('isEqual', self.tr('equals')),
('touches', self.tr('touches')),
('overlaps', self.tr('overlaps')),
('within', self.tr('within')),
('crosses', self.tr('crosses')))
self.statistics = [
('count', self.tr('count')),
('unique', self.tr('unique')),
('min', self.tr('min')),
('max', self.tr('max')),
('range', self.tr('range')),
('sum', self.tr('sum')),
('mean', self.tr('mean')),
('median', self.tr('median')),
('stddev', self.tr('stddev')),
('minority', self.tr('minority')),
('majority', self.tr('majority')),
('q1', self.tr('q1')),
('q3', self.tr('q3')),
('iqr', self.tr('iqr')),
('empty', self.tr('empty')),
('filled', self.tr('filled')),
('min_length', self.tr('min_length')),
('max_length', self.tr('max_length')),
('mean_length', self.tr('mean_length'))]
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(QgsProcessingParameterFeatureSource(self.JOIN,
self.tr('Join layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
predicate = QgsProcessingParameterEnum(self.PREDICATE,
self.tr('Geometric predicate'),
options=[p[1] for p in self.predicates],
allowMultiple=True, defaultValue=[0])
predicate.setMetadata({
'widget_wrapper': {
'useCheckBoxes': True,
'columns': 2}})
self.addParameter(predicate)
self.addParameter(QgsProcessingParameterField(self.JOIN_FIELDS,
self.tr('Fields to summarise (leave empty to use all fields)'),
parentLayerParameterName=self.JOIN,
allowMultiple=True, optional=True))
self.addParameter(QgsProcessingParameterEnum(self.SUMMARIES,
self.tr(
'Summaries to calculate (leave empty to use all available)'),
options=[p[1] for p in self.statistics],
allowMultiple=True, optional=True))
self.addParameter(QgsProcessingParameterBoolean(self.DISCARD_NONMATCHING,
self.tr('Discard records which could not be joined'),
defaultValue=False))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Joined layer')))
def initAlgorithm(self, config=None):
self.predicates = (
('intersects', self.tr('intersects')),
('contains', self.tr('contains')),
('isEqual', self.tr('equals')),
('touches', self.tr('touches')),
('overlaps', self.tr('overlaps')),
('within', self.tr('within')),
('crosses', self.tr('crosses')))
self.statistics = [
('count', self.tr('count')),
('unique', self.tr('unique')),
('min', self.tr('min')),
('max', self.tr('max')),
('range', self.tr('range')),
('sum', self.tr('sum')),
('mean', self.tr('mean')),
('median', self.tr('median')),
('stddev', self.tr('stddev')),
('minority', self.tr('minority')),
('majority', self.tr('majority')),
('q1', self.tr('q1')),
('q3', self.tr('q3')),
('iqr', self.tr('iqr')),
('empty', self.tr('empty')),
('filled', self.tr('filled')),
('min_length', self.tr('min_length')),
('max_length', self.tr('max_length')),
('mean_length', self.tr('mean_length'))]
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(QgsProcessingParameterFeatureSource(self.JOIN,
self.tr('Join layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
predicate = QgsProcessingParameterEnum(self.PREDICATE,
self.tr('Geometric predicate'),
options=[p[1] for p in self.predicates],
allowMultiple=True, defaultValue=[0])
predicate.setMetadata({
'widget_wrapper': {
'useCheckBoxes': True,
'columns': 2}})
self.addParameter(predicate)
self.addParameter(QgsProcessingParameterField(self.JOIN_FIELDS,
self.tr('Fields to summarise (leave empty to use all fields)'),
parentLayerParameterName=self.JOIN,
allowMultiple=True, optional=True))
self.addParameter(QgsProcessingParameterEnum(self.SUMMARIES,
self.tr(
'Summaries to calculate (leave empty to use all available)'),
options=[p[1] for p in self.statistics],
allowMultiple=True, optional=True))
self.addParameter(QgsProcessingParameterBoolean(self.DISCARD_NONMATCHING,
self.tr('Discard records which could not be joined'),
defaultValue=False))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Joined layer')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT,
self.tr('Input layer'),
types=[QgsProcessing.TypeVector]))
self.addParameter(
QgsProcessingParameterString(self.FIELD_NAME,
self.tr('Result field name'),
defaultValue='NewField'))
types = [(QVariant.Int, QVariant.Invalid),
(QVariant.Double, QVariant.Invalid),
(QVariant.String, QVariant.Invalid),
(QVariant.Bool, QVariant.Invalid),
(QVariant.Date, QVariant.Invalid),
(QVariant.Time, QVariant.Invalid),
(QVariant.DateTime, QVariant.Invalid),
(QVariant.ByteArray, QVariant.Invalid),
(QVariant.StringList, QVariant.String),
(QVariant.List, QVariant.Int),
(QVariant.List, QVariant.Double)]
type_names = []
type_icons = []
for type_name, subtype_name in types:
type_names.append(
QgsVariantUtils.typeToDisplayString(type_name, subtype_name))
type_icons.append(
QgsFields.iconForFieldType(type_name, subtype_name))
param = QgsProcessingParameterEnum('FIELD_TYPE',
'Field type',
options=type_names)
param.setMetadata({'widget_wrapper': {'icons': type_icons}})
self.addParameter(param)
self.addParameter(
QgsProcessingParameterNumber(self.FIELD_LENGTH,
self.tr('Field length'),
minValue=0,
defaultValue=10))
self.addParameter(
QgsProcessingParameterNumber(self.FIELD_PRECISION,
self.tr('Field precision'),
minValue=0,
maxValue=15,
defaultValue=3))
self.addParameter(
QgsProcessingParameterString(self.GLOBAL,
self.tr('Global expression'),
multiLine=True,
optional=True))
self.addParameter(
QgsProcessingParameterString(self.FORMULA,
self.tr('Formula'),
defaultValue='value = ',
multiLine=True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Calculated')))
def initAlgorithm(self, config):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT,
self.tr("Importér observationer indenfor (within)"),
[QgsProcessing.TypeVectorPolygon],
))
self.OBSERVATION_TYPES = [
(1, self.tr("Koteforskel opmålt geometrisk")),
(2, self.tr("Koteforskel opmålt trigonometrisk")),
]
o = QgsProcessingParameterEnum(
name=self.OBSERVATION_TYPE,
description=self.tr("Observationstype"),
options=[x[1] for x in self.OBSERVATION_TYPES],
allowMultiple=True,
defaultValue=[0, 1],
)
o.setMetadata(
{"widget_wrapper": {
"useCheckBoxes": True,
"columns": 2
}})
self.addParameter(o)
param = QgsProcessingParameterString(name=self.FROM_DATE,
description="Fra Dato",
optional=True)
param.setMetadata(
{"widget_wrapper": {
"class": NullableDateTimeWrapper
}})
self.addParameter(param)
param = QgsProcessingParameterString(name=self.TO_DATE,
description="Til Dato",
optional=True)
param.setMetadata(
{"widget_wrapper": {
"class": NullableDateTimeWrapper
}})
self.addParameter(param)
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr("Observationer")))
self.addParameter(
QgsProcessingParameterBoolean(
self.APPLY_THEME,
self.tr("Anvend standard fikspunktregister-symbologi"),
defaultValue=True,
))
def initAlgorithm(self, config=None):
self.predicates = (
('intersects', self.tr('intersects')),
('contains', self.tr('contains')),
('equals', self.tr('equals')),
('touches', self.tr('touches')),
('overlaps', self.tr('overlaps')),
('within', self.tr('within')),
('crosses', self.tr('crosses')))
self.reversed_predicates = {'intersects': 'intersects',
'contains': 'within',
'isEqual': 'isEqual',
'touches': 'touches',
'overlaps': 'overlaps',
'within': 'contains',
'crosses': 'crosses'}
self.methods = [
self.tr('Create separate feature for each located feature (one-to-many)'),
self.tr('Take attributes of the first located feature only (one-to-one)')
]
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(QgsProcessingParameterFeatureSource(self.JOIN,
self.tr('Join layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
predicate = QgsProcessingParameterEnum(self.PREDICATE,
self.tr('Geometric predicate'),
options=[p[1] for p in self.predicates],
allowMultiple=True, defaultValue=[0])
predicate.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers.EnumWidgetWrapper',
'useCheckBoxes': True,
'columns': 2}})
self.addParameter(predicate)
self.addParameter(QgsProcessingParameterField(self.JOIN_FIELDS,
self.tr('Fields to add (leave empty to use all fields)'),
parentLayerParameterName=self.JOIN,
allowMultiple=True, optional=True))
self.addParameter(QgsProcessingParameterEnum(self.METHOD,
self.tr('Join type'), self.methods))
self.addParameter(QgsProcessingParameterBoolean(self.DISCARD_NONMATCHING,
self.tr('Discard records which could not be joined'),
defaultValue=False))
self.addParameter(QgsProcessingParameterString(self.PREFIX,
self.tr('Joined field prefix'), optional=True))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Joined layer')))
def initAlgorithm(self, config=None):
self.predicates = (
('intersects', self.tr('intersects')),
('contains', self.tr('contains')),
('equals', self.tr('equals')),
('touches', self.tr('touches')),
('overlaps', self.tr('overlaps')),
('within', self.tr('within')),
('crosses', self.tr('crosses')))
self.reversed_predicates = {'intersects': 'intersects',
'contains': 'within',
'isEqual': 'isEqual',
'touches': 'touches',
'overlaps': 'overlaps',
'within': 'contains',
'crosses': 'crosses'}
self.methods = [
self.tr('Create separate feature for each located feature (one-to-many)'),
self.tr('Take attributes of the first located feature only (one-to-one)')
]
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(QgsProcessingParameterFeatureSource(self.JOIN,
self.tr('Join layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
predicate = QgsProcessingParameterEnum(self.PREDICATE,
self.tr('Geometric predicate'),
options=[p[1] for p in self.predicates],
allowMultiple=True, defaultValue=[0])
predicate.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers.EnumWidgetWrapper',
'useCheckBoxes': True,
'columns': 2}})
self.addParameter(predicate)
self.addParameter(QgsProcessingParameterField(self.JOIN_FIELDS,
self.tr('Fields to add (leave empty to use all fields)'),
parentLayerParameterName=self.JOIN,
allowMultiple=True, optional=True))
self.addParameter(QgsProcessingParameterEnum(self.METHOD,
self.tr('Join type'), self.methods))
self.addParameter(QgsProcessingParameterBoolean(self.DISCARD_NONMATCHING,
self.tr('Discard records which could not be joined'),
defaultValue=False))
self.addParameter(QgsProcessingParameterString(self.PREFIX,
self.tr('Joined field prefix'), optional=True))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Joined layer')))
def initAlgorithm(self, config=None):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.predicates = (('Yes', self.tr('Yes')), ('No', self.tr('No')))
predicate = QgsProcessingParameterEnum(
self.PREDICATE,
self.tr('Do you require to merge multiple raster files?'),
options=[p[1] for p in self.predicates],
allowMultiple=False,
defaultValue=[0])
predicate.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers.EnumWidgetWrapper',
'useCheckBoxes': True,
'columns': 2
}
})
self.addParameter(predicate)
self.addParameter(
QgsProcessingParameterFeatureSource(self.RASTER,
self.tr('Input raster file'),
[QgsProcessing.TypeRaster]))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.TRAINING,
self.tr('Input training vector layer'),
[QgsProcessing.TypeVector],
optional=True))
# 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(
QgsProcessingParameterFeatureSink(self.OUTPUTRASTER,
self.tr('Output Raster')))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUTVECTOR,
self.tr('Output Shortest Path')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.TARGET,
self.tr('Target layer'),
types=[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.JOIN,
self.tr('Join layer'),
types=[QgsProcessing.TypeVectorAnyGeometry]))
op = QgsProcessingParameterEnum(
self.OP,
self.tr('Join option (geometric predicate)'),
options=[p[1] for p in self.op],
allowMultiple=False,
defaultValue=0)
op.setMetadata(
{'widget_wrapper': {
'useCheckBoxes': True,
'columns': 3
}})
self.addParameter(op)
self.addParameter(
QgsProcessingParameterString(
self.COLUMNS_AGG,
self.tr('Columns to join (separated by semicolon)'),
defaultValue=None))
self.addParameter(
QgsProcessingParameterEnum(self.HOW,
self.tr('Join type'),
options=[o[1] for o in self.how],
defaultValue=0))
self.addParameter(
QgsProcessingParameterBoolean(
self.KEEP_ALL,
self.tr('Keep all features in the target layer'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterVectorDestination(self.OUTPUT,
self.tr('Output layer')))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterString(
self.INPUT_KPI_LINK,
self.tr('Dirección URL KoboToolBox)'),
defaultValue='https://kf.kobotoolbox.org/'))
self.addParameter(
QgsProcessingParameterString(self.INPUT_USER,
self.tr('Usuario KoboToolBox'),
defaultValue=''))
self.addParameter(
QgsProcessingParameterString(self.INPUT_PASSWORD,
self.tr('Contraseña KoboToolBox'),
defaultValue=''))
self.addParameter(
QgsProcessingParameterString(
self.INPUT_FORM_ID,
self.tr('Código del Formulario'),
defaultValue='aY4FQFrco8HsQDMjGqpCPQ'))
self.addParameter(
QgsProcessingParameterString(self.INPUT_COD_ESTUDIO,
self.tr('Código del Estudio'),
optional=True,
defaultValue=''))
self.addParameter(
QgsProcessingParameterString(
self.INPUT_NOMBRE_USUARIO,
self.tr('Nombre de usuario evaluador'),
optional=True))
tipo_lev_param = QgsProcessingParameterEnum(
self.INPUT_TIPO_LEVANTAMIENTO,
self.tr('Tipo de Levantamiento'),
options=self.tipos_levantamiento,
allowMultiple=True,
defaultValue=[0])
tipo_lev_param.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers.EnumWidgetWrapper',
'useCheckBoxes': True,
'columns': 3
}
})
self.addParameter(tipo_lev_param)
self.addParameter(
QgsProcessingParameterEnum(self.INPUT_TITLE,
'Cabecera',
options=self.titles_type,
allowMultiple=False,
defaultValue=1))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_SEGMENTS,
self.tr('eMAPS: Evaluación de SEGMENTOS'),
type=QgsProcessing.TypeFile))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_PARCELS,
self.tr('eMAPS: Evaluación de LOTES'),
type=QgsProcessing.TypeFile))
def initAlgorithm(self, config=None):
self.predicates = (('intersects', self.tr('intersects')),
('contains', self.tr('contains')),
('isEqual', self.tr('equals')),
('touches',
self.tr('touches')), ('overlaps',
self.tr('overlaps')),
('within', self.tr('within')), ('crosses',
self.tr('crosses')))
self.reversed_predicates = {
'intersects': 'intersects',
'contains': 'within',
'isEqual': 'isEqual',
'touches': 'touches',
'overlaps': 'overlaps',
'within': 'contains',
'crosses': 'crosses'
}
self.methods = [
self.
tr('Create separate feature for each located feature (one-to-many)'
),
self.
tr('Take attributes of the first located feature only (one-to-one)'
)
]
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Input layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.JOIN, self.tr('Join layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
predicate = QgsProcessingParameterEnum(
self.PREDICATE,
self.tr('Geometric predicate'),
options=[p[1] for p in self.predicates],
allowMultiple=True,
defaultValue=[0])
predicate.setMetadata(
{'widget_wrapper': {
'useCheckBoxes': True,
'columns': 2
}})
self.addParameter(predicate)
self.addParameter(
QgsProcessingParameterField(
self.JOIN_FIELDS,
self.tr('Fields to add (leave empty to use all fields)'),
parentLayerParameterName=self.JOIN,
allowMultiple=True,
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.METHOD, self.tr('Join type'),
self.methods))
self.addParameter(
QgsProcessingParameterBoolean(
self.DISCARD_NONMATCHING,
self.tr('Discard records which could not be joined'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterString(self.PREFIX,
self.tr('Joined field prefix'),
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT,
self.tr('Joined layer'),
QgsProcessing.TypeVectorAnyGeometry,
defaultValue=None,
optional=True,
createByDefault=True))
non_matching = QgsProcessingParameterFeatureSink(
self.NON_MATCHING,
self.tr('Unjoinable features from first layer'),
QgsProcessing.TypeVectorAnyGeometry,
defaultValue=None,
optional=True,
createByDefault=False)
# TODO GUI doesn't support advanced outputs yet
# non_matching.setFlags(non_matching.flags() | QgsProcessingParameterDefinition.FlagAdvanced )
self.addParameter(non_matching)
self.addOutput(
QgsProcessingOutputNumber(
self.JOINED_COUNT,
self.tr("Number of joined features from input table")))
def initAlgorithm(self, config=None):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.db_variables = QgsSettings()
self.period_variables = [
"Pas de filtre temporel", "5 dernières années",
"10 dernières années",
"Date de début - Date de fin (à définir ci-dessous)"
]
# Data base connection
db_param = QgsProcessingParameterString(
self.DATABASE,
self.
tr("""<b style="color:#0a84db">CONNEXION À LA BASE DE DONNÉES</b><br/>
<b>*1/</b> Sélectionnez votre <u>connexion</u> à la base de données LPO AuRA (<i>gnlpoaura</i>)"""
),
defaultValue='gnlpoaura')
db_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
})
self.addParameter(db_param)
# # List of DB schemas
# schema_param = QgsProcessingParameterString(
# self.SCHEMA,
# self.tr('Schéma'),
# defaultValue='public'
# )
# schema_param.setMetadata(
# {
# 'widget_wrapper': {
# 'class': 'processing.gui.wrappers_postgis.SchemaWidgetWrapper',
# 'connection_param': self.DATABASE
# }
# }
# )
# self.addParameter(schema_param)
# # List of DB tables
# table_param = QgsProcessingParameterString(
# self.TABLENAME,
# self.tr('Table')
# )
# table_param.setMetadata(
# {
# 'widget_wrapper': {
# 'class': 'processing.gui.wrappers_postgis.TableWidgetWrapper',
# 'schema_param': self.SCHEMA
# }
# }
# )
# self.addParameter(table_param)
# Input vector layer = study area
self.addParameter(
QgsProcessingParameterFeatureSource(
self.STUDY_AREA,
self.tr("""<b style="color:#0a84db">ZONE D'ÉTUDE</b><br/>
<b>*2/</b> Sélectionnez votre <u>zone d'étude</u>, à partir de laquelle seront extraites les données d'observations"""
), [QgsProcessing.TypeVectorPolygon]))
### Taxons filters ###
self.addParameter(
QgsProcessingParameterEnum(
self.GROUPE_TAXO,
self.tr(
"""<b style="color:#0a84db">FILTRES DE REQUÊTAGE</b><br/>
<b>3/</b> Si cela vous intéresse, vous pouvez sélectionner un/plusieurs <u>taxon(s)</u> dans la liste déroulante suivante (à choix multiples)<br/> pour filtrer vos données d'observations. <u>Sinon</u>, vous pouvez ignorer cette étape.<br/>
<i style="color:#952132"><b>N.B.</b> : D'autres filtres taxonomiques sont disponibles dans les paramètres avancés (plus bas, juste avant l'enregistrement des résultats).</i><br/>
- Groupes taxonomiques :"""),
self.db_variables.value("groupe_taxo"),
allowMultiple=True,
optional=True))
regne = QgsProcessingParameterEnum(self.REGNE,
self.tr("- Règnes :"),
self.db_variables.value("regne"),
allowMultiple=True,
optional=True)
regne.setFlags(regne.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(regne)
phylum = QgsProcessingParameterEnum(self.PHYLUM,
self.tr("- Phylum :"),
self.db_variables.value("phylum"),
allowMultiple=True,
optional=True)
phylum.setFlags(phylum.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(phylum)
classe = QgsProcessingParameterEnum(self.CLASSE,
self.tr("- Classe :"),
self.db_variables.value("classe"),
allowMultiple=True,
optional=True)
classe.setFlags(classe.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(classe)
ordre = QgsProcessingParameterEnum(self.ORDRE,
self.tr("- Ordre :"),
self.db_variables.value("ordre"),
allowMultiple=True,
optional=True)
ordre.setFlags(ordre.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(ordre)
famille = QgsProcessingParameterEnum(
self.FAMILLE,
self.tr("- Famille :"),
self.db_variables.value("famille"),
allowMultiple=True,
optional=True)
famille.setFlags(famille.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(famille)
group1_inpn = QgsProcessingParameterEnum(
self.GROUP1_INPN,
self.
tr("- Groupe 1 INPN (regroupement vernaculaire du référentiel national - niveau 1) :"
),
self.db_variables.value("group1_inpn"),
allowMultiple=True,
optional=True)
group1_inpn.setFlags(group1_inpn.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(group1_inpn)
group2_inpn = QgsProcessingParameterEnum(
self.GROUP2_INPN,
self.
tr("- Groupe 2 INPN (regroupement vernaculaire du référentiel national - niveau 2) :"
),
self.db_variables.value("group2_inpn"),
allowMultiple=True,
optional=True)
group2_inpn.setFlags(group2_inpn.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(group2_inpn)
### Datetime filter ###
period_type = QgsProcessingParameterEnum(
self.PERIOD,
self.
tr("<b>*4/</b> Sélectionnez une <u>période</u> pour filtrer vos données d'observations"
),
self.period_variables,
allowMultiple=False,
optional=False)
period_type.setMetadata({
'widget_wrapper': {
'useCheckBoxes': True,
'columns': len(self.period_variables) / 2
}
})
self.addParameter(period_type)
start_date = QgsProcessingParameterString(
self.START_DATE,
"""- Date de début <i style="color:#952132">(nécessaire seulement si vous avez sélectionné l'option <b>Date de début - Date de fin</b>)</i> :""",
defaultValue="",
optional=True)
start_date.setMetadata({'widget_wrapper': {'class': DateTimeWidget}})
self.addParameter(start_date)
end_date = QgsProcessingParameterString(
self.END_DATE,
"""- Date de fin <i style="color:#952132">(nécessaire seulement si vous avez sélectionné l'option <b>Date de début - Date de fin</b>)</i> :""",
optional=True)
end_date.setMetadata({'widget_wrapper': {'class': DateTimeWidget}})
self.addParameter(end_date)
# Extra "where" conditions
extra_where = QgsProcessingParameterString(
self.EXTRA_WHERE,
self.
tr("""Vous pouvez ajouter des <u>conditions "where"</u> supplémentaires dans l'encadré suivant, en langage SQL <b style="color:#952132">(commencez par <i>and</i>)</b>"""
),
multiLine=True,
optional=True)
extra_where.setFlags(extra_where.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(extra_where)
# Output PostGIS layer name
self.addParameter(
QgsProcessingParameterString(
self.OUTPUT_NAME,
self.
tr("""<b style="color:#0a84db">PARAMÉTRAGE DES RESULTATS EN SORTIE</b><br/>
<b>*5/</b> Définissez un <u>nom</u> pour votre nouvelle couche PostGIS"""
), self.tr("Données d'observation")))
# Output PostGIS layer = biodiversity data
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT,
self.tr(
"""<b style="color:#DF7401">EXPORT DES RESULTATS</b><br/>
<b>6/</b> Si cela vous intéresse, vous pouvez <u>exporter</u> votre nouvelle couche sur votre ordinateur. <u>Sinon</u>, vous pouvez ignorer cette étape.<br/>
<u>Précisions</u> : La couche exportée est une couche figée qui n'est pas rafraîchie à chaque réouverture de QGis, contrairement à la couche PostGIS.<br/>
<font style='color:#DF7401'><u>Aide</u> : Cliquez sur le bouton [...] puis sur le type d'export qui vous convient</font>"""
),
QgsProcessing.TypeVectorPoint,
optional=True,
createByDefault=False))
def initAlgorithm(self, config=None):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.db_variables = QgsSettings()
self.period_variables = ["Pas de filtre temporel", "5 dernières années", "10 dernières années", "Date de début - Date de fin (à définir ci-dessous)"]
# Data base connection
db_param = QgsProcessingParameterString(
self.DATABASE,
self.tr("""<b style="color:#0a84db">CONNEXION À LA BASE DE DONNÉES</b><br/>
<b>*1/</b> Sélectionnez votre <u>connexion</u> à la base de données LPO AuRA (<i>gnlpoaura</i>)"""),
defaultValue='gnlpoaura'
)
db_param.setMetadata(
{
'widget_wrapper': {'class': 'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'}
}
)
self.addParameter(db_param)
# Input vector layer = study area
self.addParameter(
QgsProcessingParameterFeatureSource(
self.STUDY_AREA,
self.tr("""<b style="color:#0a84db">ZONE D'ÉTUDE</b><br/>
<b>*2/</b> Sélectionnez votre <u>zone d'étude</u>, à partir de laquelle seront extraits les résultats"""),
[QgsProcessing.TypeVectorPolygon]
)
)
### Taxons filters ###
self.addParameter(
QgsProcessingParameterEnum(
self.GROUPE_TAXO,
self.tr("""<b style="color:#0a84db">FILTRES DE REQUÊTAGE</b><br/>
<b>3/</b> Si cela vous intéresse, vous pouvez sélectionner un/plusieurs <u>taxon(s)</u> dans la liste déroulante suivante (à choix multiples)<br/> pour filtrer vos données d'observations. <u>Sinon</u>, vous pouvez ignorer cette étape.<br/>
<i style="color:#952132"><b>N.B.</b> : D'autres filtres taxonomiques sont disponibles dans les paramètres avancés (tout en bas).</i><br/>
- Groupes taxonomiques :"""),
self.db_variables.value("groupe_taxo"),
allowMultiple=True,
optional=True
)
)
regne = QgsProcessingParameterEnum(
self.REGNE,
self.tr("- Règnes :"),
self.db_variables.value("regne"),
allowMultiple=True,
optional=True
)
regne.setFlags(regne.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(regne)
phylum = QgsProcessingParameterEnum(
self.PHYLUM,
self.tr("- Phylum :"),
self.db_variables.value("phylum"),
allowMultiple=True,
optional=True
)
phylum.setFlags(phylum.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(phylum)
classe = QgsProcessingParameterEnum(
self.CLASSE,
self.tr("- Classe :"),
self.db_variables.value("classe"),
allowMultiple=True,
optional=True
)
classe.setFlags(classe.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(classe)
ordre = QgsProcessingParameterEnum(
self.ORDRE,
self.tr("- Ordre :"),
self.db_variables.value("ordre"),
allowMultiple=True,
optional=True
)
ordre.setFlags(ordre.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(ordre)
famille = QgsProcessingParameterEnum(
self.FAMILLE,
self.tr("- Famille :"),
self.db_variables.value("famille"),
allowMultiple=True,
optional=True
)
famille.setFlags(famille.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(famille)
group1_inpn = QgsProcessingParameterEnum(
self.GROUP1_INPN,
self.tr("- Groupe 1 INPN (regroupement vernaculaire du référentiel national - niveau 1) :"),
self.db_variables.value("group1_inpn"),
allowMultiple=True,
optional=True
)
group1_inpn.setFlags(group1_inpn.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(group1_inpn)
group2_inpn = QgsProcessingParameterEnum(
self.GROUP2_INPN,
self.tr("- Groupe 2 INPN (regroupement vernaculaire du référentiel national - niveau 2) :"),
self.db_variables.value("group2_inpn"),
allowMultiple=True,
optional=True
)
group2_inpn.setFlags(group2_inpn.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(group2_inpn)
### Datetime filter ###
period_type = QgsProcessingParameterEnum(
self.PERIOD,
self.tr("<b>*4/</b> Sélectionnez une <u>période</u> pour filtrer vos données d'observations"),
self.period_variables,
allowMultiple=False,
optional=False
)
period_type.setMetadata(
{
'widget_wrapper': {
'useCheckBoxes': True,
'columns': len(self.period_variables)/2
}
}
)
self.addParameter(period_type)
start_date = QgsProcessingParameterString(
self.START_DATE,
"""- Date de début <i style="color:#952132">(nécessaire seulement si vous avez sélectionné l'option <b>Date de début - Date de fin</b>)</i> :""",
defaultValue="",
optional=True
)
start_date.setMetadata(
{'widget_wrapper': {'class': DateTimeWidget}}
)
self.addParameter(start_date)
end_date = QgsProcessingParameterString(
self.END_DATE,
"""- Date de fin <i style="color:#952132">(nécessaire seulement si vous avez sélectionné l'option <b>Date de début - Date de fin</b>)</i> :""",
optional=True
)
end_date.setMetadata(
{'widget_wrapper': {'class': DateTimeWidget}}
)
self.addParameter(end_date)
# Extra "where" conditions
extra_where = QgsProcessingParameterString(
self.EXTRA_WHERE,
self.tr("""Vous pouvez ajouter des <u>conditions "where"</u> supplémentaires dans l'encadré suivant, en langage SQL <b style="color:#952132">(commencez par <i>and</i>)</b>"""),
multiLine=True,
optional=True
)
extra_where.setFlags(extra_where.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(extra_where)
# Output PostGIS layer = summary table
self.addOutput(
QgsProcessingOutputVectorLayer(
self.OUTPUT,
self.tr('Couche en sortie'),
QgsProcessing.TypeVectorAnyGeometry
)
)
# Output PostGIS layer name
self.addParameter(
QgsProcessingParameterString(
self.OUTPUT_NAME,
self.tr("""<b style="color:#0a84db">PARAMÉTRAGE DES RESULTATS EN SORTIE</b><br/>
<b>*5/</b> Définissez un <u>nom</u> pour votre nouvelle couche PostGIS"""),
self.tr("Tableau synthèse espèces")
)
)
# Boolean : True = add the summary table in the DB ; False = don't
self.addParameter(
QgsProcessingParameterBoolean(
self.ADD_TABLE,
self.tr("Enregistrer les résultats en sortie dans une nouvelle table PostgreSQL"),
False
)
)
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.CLUSTER,
description=self.tr('Clusters from value(s)'),
defaultValue='')
fieldsParam.setMetadata({
'widget_wrapper': {
'class':
'Chloe.chloe_algorithm_dialog.ChloeValuesWidgetWrapper'
}
})
self.addParameter(fieldsParam)
clusterTypeParam = QgsProcessingParameterEnum(self.CLUSTER_TYPE,
self.tr('Cluster type'),
self.types_of_cluster)
self.addParameter(clusterTypeParam)
clusterTypeParam.setMetadata({
'widget_wrapper': {
'class':
'Chloe.chloe_algorithm_dialog.ChloeMultiEnumUpdateStateWidgetWrapper',
'dependantWidgetConfig': [{
'paramName': self.CLUSTER_DISTANCE,
'enableValue': '2,3'
}]
}
})
self.addParameter(
QgsProcessingParameterNumber(
name=self.CLUSTER_MIN_AREA,
description=self.tr('Minimal area (Ha)'),
defaultValue=0,
minValue=0))
self.addParameter(
QgsProcessingParameterNumber(
name=self.CLUSTER_DISTANCE,
description=self.
tr('Distance in meters (only for euclidean and functional distance)'
),
optional=True,
minValue=0))
self.addParameter(
QgsProcessingParameterFile(name=self.CLUSTER_FRICTION,
description=self.tr('Friction file'),
optional=True))
# === OUTPUT PARAMETERS ===
self.addParameter(
ChloeCSVParameterFileDestination(
name=self.OUTPUT_CSV,
description=self.tr('Output csv (*.csv)')))
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):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.db_variables = QgsSettings()
self.taxonomic_ranks_variables = [
"Groupes taxonomiques", "Règnes", "Phylum", "Classes", "Ordres",
"Familles",
"Groupes 1 INPN (regroupement vernaculaire du référentiel national - niveau 1)",
"Groupes 2 INPN (regroupement vernaculaire du référentiel national - niveau 2)"
]
self.period_variables = [
"Pas de filtre temporel", "5 dernières années",
"10 dernières années",
"Date de début - Date de fin (à définir ci-dessous)"
]
histogram_variables = [
"Pas d'histogramme", "Histogramme du nombre de données par taxon",
"Histogramme du nombre d'espèces par taxon",
"Histogramme du nombre d'observateurs par taxon",
"Histogramme du nombre de dates par taxon",
"Histogramme du nombre de données de mortalité par taxon"
]
# Data base connection
db_param = QgsProcessingParameterString(
self.DATABASE,
self.
tr("""<b style="color:#0a84db">CONNEXION À LA BASE DE DONNÉES</b><br/>
<b>*1/</b> Sélectionnez votre <u>connexion</u> à la base de données LPO AuRA (<i>gnlpoaura</i>)"""
),
defaultValue='gnlpoaura')
db_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
})
self.addParameter(db_param)
# Input vector layer = study area
self.addParameter(
QgsProcessingParameterFeatureSource(
self.STUDY_AREA,
self.tr("""<b style="color:#0a84db">ZONE D'ÉTUDE</b><br/>
<b>*2/</b> Sélectionnez votre <u>zone d'étude</u>, à partir de laquelle seront extraits les résultats"""
), [QgsProcessing.TypeVectorPolygon]))
# Taxonomic rank
taxonomic_rank = QgsProcessingParameterEnum(
self.TAXONOMIC_RANK,
self.tr("""<b style="color:#0a84db">RANG TAXONOMIQUE</b><br/>
<b>*3/</b> Sélectionnez le <u>rang taxonomique</u> qui vous intéresse"""
),
self.taxonomic_ranks_variables,
allowMultiple=False)
taxonomic_rank.setMetadata({
'widget_wrapper': {
'useCheckBoxes': True,
'columns': len(self.taxonomic_ranks_variables) / 2
}
})
self.addParameter(taxonomic_rank)
### Taxons filters ###
self.addParameter(
QgsProcessingParameterEnum(
self.GROUPE_TAXO,
self.tr(
"""<b style="color:#0a84db">FILTRES DE REQUÊTAGE</b><br/>
<b>4/</b> Si cela vous intéresse, vous pouvez sélectionner un/plusieurs <u>taxon(s)</u> dans la liste déroulante suivante (à choix multiples)<br/> pour filtrer vos données d'observations. <u>Sinon</u>, vous pouvez ignorer cette étape.<br/>
<i style="color:#952132"><b>N.B.</b> : D'autres filtres taxonomiques sont disponibles dans les paramètres avancés (plus bas, juste avant l'enregistrement des résultats).</i><br/>
- Groupes taxonomiques :"""),
self.db_variables.value("groupe_taxo"),
allowMultiple=True,
optional=True))
regne = QgsProcessingParameterEnum(self.REGNE,
self.tr("- Règnes :"),
self.db_variables.value("regne"),
allowMultiple=True,
optional=True)
regne.setFlags(regne.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(regne)
phylum = QgsProcessingParameterEnum(self.PHYLUM,
self.tr("- Phylum :"),
self.db_variables.value("phylum"),
allowMultiple=True,
optional=True)
phylum.setFlags(phylum.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(phylum)
classe = QgsProcessingParameterEnum(self.CLASSE,
self.tr("- Classe :"),
self.db_variables.value("classe"),
allowMultiple=True,
optional=True)
classe.setFlags(classe.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(classe)
ordre = QgsProcessingParameterEnum(self.ORDRE,
self.tr("- Ordre :"),
self.db_variables.value("ordre"),
allowMultiple=True,
optional=True)
ordre.setFlags(ordre.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(ordre)
famille = QgsProcessingParameterEnum(
self.FAMILLE,
self.tr("- Famille :"),
self.db_variables.value("famille"),
allowMultiple=True,
optional=True)
famille.setFlags(famille.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(famille)
group1_inpn = QgsProcessingParameterEnum(
self.GROUP1_INPN,
self.
tr("- Groupe 1 INPN (regroupement vernaculaire du référentiel national - niveau 1) :"
),
self.db_variables.value("group1_inpn"),
allowMultiple=True,
optional=True)
group1_inpn.setFlags(group1_inpn.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(group1_inpn)
group2_inpn = QgsProcessingParameterEnum(
self.GROUP2_INPN,
self.
tr("- Groupe 2 INPN (regroupement vernaculaire du référentiel national - niveau 2) :"
),
self.db_variables.value("group2_inpn"),
allowMultiple=True,
optional=True)
group2_inpn.setFlags(group2_inpn.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(group2_inpn)
### Datetime filter ###
period = QgsProcessingParameterEnum(
self.PERIOD,
self.
tr("<b>*5/</b> Sélectionnez une <u>période</u> pour filtrer vos données d'observations"
),
self.period_variables,
allowMultiple=False,
optional=False)
period.setMetadata({
'widget_wrapper': {
'useCheckBoxes': True,
'columns': len(self.period_variables) / 2
}
})
self.addParameter(period)
start_date = QgsProcessingParameterString(
self.START_DATE,
"""- Date de début <i style="color:#952132">(nécessaire seulement si vous avez sélectionné l'option <b>Date de début - Date de fin</b>)</i> :""",
defaultValue="",
optional=True)
start_date.setMetadata({'widget_wrapper': {'class': DateTimeWidget}})
self.addParameter(start_date)
end_date = QgsProcessingParameterString(
self.END_DATE,
"""- Date de fin <i style="color:#952132">(nécessaire seulement si vous avez sélectionné l'option <b>Date de début - Date de fin</b>)</i> :""",
optional=True)
end_date.setMetadata({'widget_wrapper': {'class': DateTimeWidget}})
self.addParameter(end_date)
# Extra "where" conditions
extra_where = QgsProcessingParameterString(
self.EXTRA_WHERE,
self.
tr("""Vous pouvez ajouter des <u>conditions "where"</u> supplémentaires dans l'encadré suivant, en langage SQL <b style="color:#952132">(commencez par <i>and</i>)</b>"""
),
multiLine=True,
optional=True)
extra_where.setFlags(extra_where.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(extra_where)
# Output PostGIS layer = summary table
self.addOutput(
QgsProcessingOutputVectorLayer(
self.OUTPUT, self.tr('Couche en sortie'),
QgsProcessing.TypeVectorAnyGeometry))
# Output PostGIS layer name
self.addParameter(
QgsProcessingParameterString(
self.OUTPUT_NAME,
self.
tr("""<b style="color:#0a84db">PARAMÉTRAGE DES RESULTATS EN SORTIE</b><br/>
<b>*6/</b> Définissez un <u>nom</u> pour votre nouvelle couche PostGIS"""
), self.tr("État des connaissances")))
# Boolean : True = add the summary table in the DB ; False = don't
self.addParameter(
QgsProcessingParameterBoolean(
self.ADD_TABLE,
self.
tr("Enregistrer les résultats en sortie dans une nouvelle table PostgreSQL"
),
defaultValue=False))
### Histogram ###
histogram_options = QgsProcessingParameterEnum(
self.HISTOGRAM_OPTIONS,
self.
tr("<b>7/</b> Si cela vous intéresse, vous pouvez <u>exporter</u> les résultats sous forme d'<u>histogramme</u>. Dans ce cas, sélectionnez le type<br/> d'histogramme qui vous convient. <u>Sinon</u>, vous pouvez ignorer cette étape."
),
histogram_variables,
defaultValue="Pas d'histogramme")
histogram_options.setMetadata({
'widget_wrapper': {
'useCheckBoxes': True,
'columns': len(histogram_variables) / 3
}
})
self.addParameter(histogram_options)
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_HISTOGRAM,
self.
tr("""<b style="color:#0a84db">ENREGISTREMENT DES RESULTATS</b><br/>
<b>8/</b> <u style="color:#952132">Si (et seulement si !)</u> vous avez sélectionné un type d'<u>histogramme</u>, veuillez renseigner un emplacement pour l'enregistrer<br/> sur votre ordinateur (au format image). <u>Dans le cas contraire</u>, vous pouvez ignorer cette étape.<br/>
<font style='color:#06497a'><u>Aide</u> : Cliquez sur le bouton [...] puis sur 'Enregistrer vers un fichier...'</font>"""
),
self.tr('image PNG (*.png)'),
optional=True,
createByDefault=False))
def initAlgorithm(self, config=None):
self.predicates = (
('intersects', self.tr('intersects')),
('contains', self.tr('contains')),
('isEqual', self.tr('equals')),
('touches', self.tr('touches')),
('overlaps', self.tr('overlaps')),
('within', self.tr('within')),
('crosses', self.tr('crosses')))
self.reversed_predicates = {'intersects': 'intersects',
'contains': 'within',
'isEqual': 'isEqual',
'touches': 'touches',
'overlaps': 'overlaps',
'within': 'contains',
'crosses': 'crosses'}
self.methods = [
self.tr('Create separate feature for each located feature (one-to-many)'),
self.tr('Take attributes of the first located feature only (one-to-one)')
]
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(QgsProcessingParameterFeatureSource(self.JOIN,
self.tr('Join layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
predicate = QgsProcessingParameterEnum(self.PREDICATE,
self.tr('Geometric predicate'),
options=[p[1] for p in self.predicates],
allowMultiple=True, defaultValue=[0])
predicate.setMetadata({
'widget_wrapper': {
'useCheckBoxes': True,
'columns': 2}})
self.addParameter(predicate)
self.addParameter(QgsProcessingParameterField(self.JOIN_FIELDS,
self.tr('Fields to add (leave empty to use all fields)'),
parentLayerParameterName=self.JOIN,
allowMultiple=True, optional=True))
self.addParameter(QgsProcessingParameterEnum(self.METHOD,
self.tr('Join type'), self.methods))
self.addParameter(QgsProcessingParameterBoolean(self.DISCARD_NONMATCHING,
self.tr('Discard records which could not be joined'),
defaultValue=False))
self.addParameter(QgsProcessingParameterString(self.PREFIX,
self.tr('Joined field prefix'), optional=True))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Joined layer'),
QgsProcessing.TypeVectorAnyGeometry,
defaultValue=None, optional=True, createByDefault=True))
non_matching = QgsProcessingParameterFeatureSink(self.NON_MATCHING,
self.tr('Unjoinable features from first layer'),
QgsProcessing.TypeVectorAnyGeometry,
defaultValue=None, optional=True, createByDefault=False)
# TODO GUI doesn't support advanced outputs yet
# non_matching.setFlags(non_matching.flags() | QgsProcessingParameterDefinition.FlagAdvanced )
self.addParameter(non_matching)
self.addOutput(QgsProcessingOutputNumber(self.JOINED_COUNT, self.tr("Number of joined features from input table")))
def initAlgorithm(self, config=None):
# === INPUT PARAMETERS ===
inputAscParam = QgsProcessingParameterRasterLayer(
name=self.INPUT_LAYER_ASC,
description=self.tr('Input layer asc'))
inputAscParam.setMetadata({
'widget_wrapper': {
'class': 'Chloe.chloe_algorithm_dialog.ChloeAscRasterWidgetWrapper'
}
})
self.addParameter(inputAscParam)
# ANALYZE TYPE
analyzeTypeParam = QgsProcessingParameterEnum(
name=self.ANALYZE_TYPE,
description=self.tr('Analyze type'),
options=self.types_of_analyze)
analyzeTypeParam.setMetadata({
'widget_wrapper': {
'class': 'Chloe.chloe_algorithm_dialog.ChloeEnumUpdateStateWidgetWrapper',
'dependantWidgetConfig': [{
'paramName': self.DISTANCE_FUNCTION,
'enableValue': 1
}]
}
})
self.addParameter(analyzeTypeParam)
# DISTANCE FUNCTION
self.addParameter(QgsProcessingParameterString(
name=self.DISTANCE_FUNCTION,
description=self.tr('Distance function'),
optional=True))
windowShapeParam = QgsProcessingParameterEnum(
name=self.WINDOW_SHAPE,
description=self.tr('Window shape'),
options=self.types_of_shape)
windowShapeParam.setMetadata({
'widget_wrapper': {
'class': 'Chloe.chloe_algorithm_dialog.ChloeEnumUpdateStateWidgetWrapper',
'dependantWidgetConfig': [{
'paramName': self.FRICTION_FILE,
'enableValue': 2
}]
}
})
self.addParameter(windowShapeParam)
self.addParameter(QgsProcessingParameterFile(
name=self.FRICTION_FILE,
description=self.tr('Friction file'),
optional=True))
windowSizeParam = QgsProcessingParameterString(
name=self.WINDOW_SIZES,
description=self.tr('Windows sizes (pixels)')) # [constraint V2.0: "select only one"]
windowSizeParam.setMetadata({
'widget_wrapper': {
'class': 'Chloe.chloe_algorithm_dialog.ChloeIntListWidgetWrapper',
'initialValue': 3,
'minValue' : 3,
'maxValue' : 100001,
'oddNum' : True
}
})
self.addParameter(windowSizeParam)
self.addParameter(QgsProcessingParameterNumber(
name=self.DELTA_DISPLACEMENT,
description=self.tr('Delta displacement (pixels)'),
defaultValue=1,
minValue=1))
self.addParameter(QgsProcessingParameterBoolean(
name=self.INTERPOLATE_VALUES_BOOL,
description=self.tr('Interpolate Values'),
defaultValue=False))
fieldsParam = QgsProcessingParameterString(
name=self.FILTER,
description=self.tr('Filters - Analyse only'),
defaultValue='',
optional=True)
fieldsParam.setMetadata({
'widget_wrapper': {
'class': 'Chloe.chloe_algorithm_dialog.ChloeValuesWidgetWrapper'
}
})
self.addParameter(fieldsParam)
fieldsParam = QgsProcessingParameterString(
name=self.UNFILTER,
description=self.tr('Filters - Do not analyse'),
defaultValue='',
optional=True)
fieldsParam.setMetadata({
'widget_wrapper': {
'class': 'Chloe.chloe_algorithm_dialog.ChloeValuesWidgetWrapper'
}
})
self.addParameter(fieldsParam)
self.addParameter(QgsProcessingParameterNumber(
name=self.MAXIMUM_RATE_MISSING_VALUES,
description=self.tr('Maximum rate of missing values'),
minValue=0,
maxValue=100,
defaultValue=100))
metricsParam = QgsProcessingParameterString(
name=self.METRICS,
description=self.tr('Select metrics'))
metricsParam.setMetadata({
'widget_wrapper': {
'class': 'Chloe.chloe_algorithm_dialog.ChloeMultipleMetricsSelectorWidgetWrapper',
'dictValues': self.types_of_metrics,
'initialValue': 'value metrics',
'rasterLayerParamName': self.INPUT_LAYER_ASC,
'parentWidgetConfig': { 'paramName': self.INPUT_LAYER_ASC, 'refreshMethod': 'refreshMetrics'}
}
})
self.addParameter(metricsParam)
# === OUTPUT PARAMETERS ===
self.addParameter(ChloeParameterFolderDestination(
name=self.OUTPUT_DIR,
description=self.tr('Output directory')))
self.addParameter(QgsProcessingParameterFileDestination(
name=self.SAVE_PROPERTIES,
description=self.tr('Properties file'),
fileFilter='Properties (*.properties)'))
def initAlgorithm(self, config=None):
# === INPUT PARAMETERS ===
#Asc
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)
# Value ranges
fieldsParam = QgsProcessingParameterString(
name=self.VALUES_RANGES,
description=self.tr('Values'),
defaultValue='')
fieldsParam.setMetadata({
'widget_wrapper': {
'class':
'Chloe.chloe_algorithm_dialog.ChloeValuesWidgetWrapper'
}
})
self.addParameter(fieldsParam)
# Distance type
distanceTypeParam = QgsProcessingParameterEnum(
name=self.DISTANCE_TYPE,
description=self.tr('Distance type'),
options=self.types_of_distance)
distanceTypeParam.setMetadata({
'widget_wrapper': {
'class':
'Chloe.chloe_algorithm_dialog.ChloeEnumUpdateStateWidgetWrapper',
'dependantWidgetConfig': [{
'paramName': self.DISTANCE_FRICTION,
'enableValue': 1
}]
}
})
self.addParameter(distanceTypeParam)
# Friction file
self.addParameter(
QgsProcessingParameterFile(name=self.DISTANCE_FRICTION,
description=self.tr('Friction file'),
optional=True))
# Max distance
self.addParameter(
QgsProcessingParameterNumber(
name=self.DISTANCE_MAX,
description=self.tr('Maximum distance (in meters)'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
minValue=1,
optional=True))
# === 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):
# === INPUT PARAMETERS ===
inputAscParam = QgsProcessingParameterRasterLayer(
name=self.INPUT_LAYER_ASC,
description=self.tr('Input layer asc'))
inputAscParam.setMetadata({
'widget_wrapper': {
'class': 'Chloe.chloe_algorithm_dialog.ChloeAscRasterWidgetWrapper'
}
})
self.addParameter(inputAscParam)
# ANALYZE TYPE
analyzeTypeParam = QgsProcessingParameterEnum(
name=self.ANALYZE_TYPE,
description=self.tr('Analyze type'),
options=self.types_of_analyze)
analyzeTypeParam.setMetadata({
'widget_wrapper': {
'class': 'Chloe.chloe_algorithm_dialog.ChloeEnumUpdateStateWidgetWrapper',
'dependantWidgetConfig': [{
'paramName': self.DISTANCE_FUNCTION,
'enableValue': 1
}]
}
})
self.addParameter(analyzeTypeParam)
# DISTANCE FUNCTION
self.addParameter(QgsProcessingParameterString(
name=self.DISTANCE_FUNCTION,
description=self.tr('Distance function'),
optional=True))
# WINDOW SHAPE
windowShapeParam = QgsProcessingParameterEnum(
name=self.WINDOW_SHAPE,
description=self.tr('Window shape'),
options=self.types_of_shape)
windowShapeParam.setMetadata({
'widget_wrapper': {
'class': 'Chloe.chloe_algorithm_dialog.ChloeEnumUpdateStateWidgetWrapper',
'dependantWidgetConfig': [{
'paramName': self.FRICTION_FILE,
'enableValue': 2
}]
}
})
self.addParameter(windowShapeParam)
# FRICTION FILE
self.addParameter(QgsProcessingParameterFile(
name=self.FRICTION_FILE,
description=self.tr('Friction file'),
optional=True))
# WINDOW SIZE
windowSizeParam = QgsProcessingParameterString(
name=self.WINDOW_SIZES,
description=self.tr('Windows sizes (pixels)')) # [constraint V2.0: "select only one"]
windowSizeParam.setMetadata({
'widget_wrapper': {
'class': 'Chloe.chloe_algorithm_dialog.ChloeIntListWidgetWrapper',
'initialValue': 3,
'minValue' : 3,
'maxValue' : 100001,
'oddNum' : True
}
})
self.addParameter(windowSizeParam)
# POINT PIXEL
pointPixelParam = QgsProcessingParameterEnum(
name=self.PIXELS_POINTS_SELECT,
description=self.tr('Pixels/points selection'),
options=self.types_of_pixel_point_select)
pointPixelParam.setMetadata({
'widget_wrapper': {
'class': 'Chloe.chloe_algorithm_dialog.ChloeEnumUpdateStateWidgetWrapper',
'dependantWidgetConfig': [{
'paramName': self.PIXELS_FILE,
'enableValue': 0
},
{
'paramName': self.POINTS_FILE,
'enableValue': 1
}]
}
})
self.addParameter(pointPixelParam)
# PIXEL FILE
self.addParameter(QgsProcessingParameterFile(
name=self.PIXELS_FILE,
description=self.tr('Pixels file'),
optional=True))
# POINT FILE
self.addParameter(QgsProcessingParameterFile(
name=self.POINTS_FILE,
description=self.tr('Points file'),
optional=True))
# MAXIMUM RATE MISSING VALUE
self.addParameter(QgsProcessingParameterNumber(
name=self.MAXIMUM_RATE_MISSING_VALUES,
description=self.tr('Maximum rate of missing values'),
minValue=0,
maxValue=100,
defaultValue=100))
metricsParam = QgsProcessingParameterString(
name=self.METRICS,
description=self.tr('Select metrics'))
metricsParam.setMetadata({
'widget_wrapper': {
'class': 'Chloe.chloe_algorithm_dialog.ChloeMultipleMetricsSelectorWidgetWrapper',
'dictValues': self.types_of_metrics,
'initialValue': 'value metrics',
'rasterLayerParamName': self.INPUT_LAYER_ASC,
'parentWidgetConfig': { 'paramName': self.INPUT_LAYER_ASC, 'refreshMethod': 'refreshMetrics'}
}
})
self.addParameter(metricsParam)
# === OUTPUT PARAMETERS ===
self.addParameter(ChloeParameterFolderDestination(
name=self.OUTPUT_DIR,
description=self.tr('Output directory')))
self.addParameter(QgsProcessingParameterFileDestination(
name=self.SAVE_PROPERTIES,
description=self.tr('Properties file'),
fileFilter='Properties (*.properties)'))
def initAlgorithm(self, config=None):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.ts = datetime.now()
self.db_variables = QgsSettings()
self.interval_variables = ["Par année", "Par mois"]
self.months_names_variables = [
"Janvier", "Février", "Mars", "Avril", "Mai", "Juin", "Juillet",
"Août", "Septembre", "Octobre", "Novembre", "Décembre"
]
self.taxonomic_ranks_variables = ["Espèces", "Groupes taxonomiques"]
self.agg_variables = ["Nombre de données", "Nombre d'espèces"]
# Data base connection
db_param = QgsProcessingParameterString(
self.DATABASE,
self.
tr("""<b style="color:#0a84db">CONNEXION À LA BASE DE DONNÉES</b><br/>
<b>*1/</b> Sélectionnez votre <u>connexion</u> à la base de données LPO AuRA (<i>gnlpoaura</i>)"""
),
defaultValue='gnlpoaura')
db_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
})
self.addParameter(db_param)
# Input vector layer = study area
self.addParameter(
QgsProcessingParameterFeatureSource(
self.STUDY_AREA,
self.tr("""<b style="color:#0a84db">ZONE D'ÉTUDE</b><br/>
<b>*2/</b> Sélectionnez votre <u>zone d'étude</u>, à partir de laquelle seront extraits les résultats"""
), [QgsProcessing.TypeVectorPolygon]))
### Time interval and period ###
time_interval = QgsProcessingParameterEnum(
self.TIME_INTERVAL,
self.
tr("""<b style="color:#0a84db">AGRÉGATION TEMPORELLE ET PÉRIODE</b><br/>
<b>*3/</b> Sélectionnez l'<u>agrégation temporelle</u> qui vous intéresse"""
),
self.interval_variables,
allowMultiple=False)
time_interval.setMetadata({
'widget_wrapper': {
'useCheckBoxes': True,
'columns': len(self.interval_variables)
}
})
self.addParameter(time_interval)
add_five_years = QgsProcessingParameterEnum(
self.ADD_FIVE_YEARS,
self.
tr("""<b>4/</b> <u style="color:#952132">Si (et seulement si !)</u> vous avez sélectionné l'<u>agrégation <b>Par année</b></u> :<br/> cochez la case ci-dessous si vous souhaitez ajouter des colonnes dîtes "bilan" par intervalle de 5 ans.<br/>
<i style="color:#952132"><b>N.B.</b> : En cochant cette case, vous devez vous assurer de renseigner une période en années (cf. <b>*5/</b>) qui soit <b>divisible par 5</b>.<br/> Exemple : 2011 - 2020.</i>"""
),
[
'Oui, je souhaite ajouter des colonnes dîtes "bilan" par intervalle de 5 ans'
],
allowMultiple=True,
optional=True)
add_five_years.setMetadata(
{'widget_wrapper': {
'useCheckBoxes': True,
'columns': 1
}})
self.addParameter(add_five_years)
self.addParameter(
QgsProcessingParameterEnum(
self.START_MONTH,
self.
tr("""<b>*5/</b> Sélectionnez la <u>période</u> qui vous intéresse<br/>
- Mois de début <i style="color:#952132">(nécessaire seulement si vous avez sélectionné l'agrégation <b>Par mois</b>)</i> :"""
),
self.months_names_variables,
allowMultiple=False,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.START_YEAR,
self.tr("- *Année de début :"),
QgsProcessingParameterNumber.Integer,
defaultValue=2010,
minValue=1800,
maxValue=int(self.ts.strftime('%Y'))))
self.addParameter(
QgsProcessingParameterEnum(
self.END_MONTH,
self.
tr("""- Mois de fin <i style="color:#952132">(nécessaire seulement si vous avez sélectionné l'agrégation <b>Par mois</b>)</i> :"""
),
self.months_names_variables,
allowMultiple=False,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.END_YEAR,
self.tr("- *Année de fin :"),
QgsProcessingParameterNumber.Integer,
defaultValue=self.ts.strftime('%Y'),
minValue=1800,
maxValue=int(self.ts.strftime('%Y'))))
# Taxonomic rank
taxonomic_rank = QgsProcessingParameterEnum(
self.TAXONOMIC_RANK,
self.tr("""<b style="color:#0a84db">RANG TAXONOMIQUE</b><br/>
<b>*6/</b> Sélectionnez le <u>rang taxonomique</u> qui vous intéresse"""
),
self.taxonomic_ranks_variables,
allowMultiple=False)
taxonomic_rank.setMetadata({
'widget_wrapper': {
'useCheckBoxes': True,
'columns': len(self.taxonomic_ranks_variables)
}
})
self.addParameter(taxonomic_rank)
# Aggregation type
aggregation_type = QgsProcessingParameterEnum(
self.AGG,
self.tr(
"""<b style="color:#0a84db">AGRÉGATION DES RÉSULTATS</b><br/>
<b>*7/</b> Sélectionnez le <u>type d'agrégation</u> qui vous intéresse pour les résultats<br/>
<i style="color:#952132"><b>N.B.</b> : Si vous avez choisi <b>Espèces</b> pour le rang taxonomique, <b>Nombre de données</b> sera utilisé <b>par défaut</b></i>"""
),
self.agg_variables,
allowMultiple=False,
defaultValue="Nombre de données")
aggregation_type.setMetadata({
'widget_wrapper': {
'useCheckBoxes': True,
'columns': len(self.agg_variables)
}
})
self.addParameter(aggregation_type)
### Taxons filters ###
self.addParameter(
QgsProcessingParameterEnum(
self.GROUPE_TAXO,
self.tr(
"""<b style="color:#0a84db">FILTRES DE REQUÊTAGE</b><br/>
<b>8/</b> Si cela vous intéresse, vous pouvez sélectionner un/plusieurs <u>taxon(s)</u> dans la liste déroulante suivante (à choix multiples)<br/> pour filtrer vos données d'observations. <u>Sinon</u>, vous pouvez ignorer cette étape.<br/>
<i style="color:#952132"><b>N.B.</b> : D'autres filtres taxonomiques sont disponibles dans les paramètres avancés (plus bas, juste avant l'enregistrement des résultats).</i><br/>
- Groupes taxonomiques :"""),
self.db_variables.value("groupe_taxo"),
allowMultiple=True,
optional=True))
regne = QgsProcessingParameterEnum(self.REGNE,
self.tr("- Règnes :"),
self.db_variables.value("regne"),
allowMultiple=True,
optional=True)
regne.setFlags(regne.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(regne)
phylum = QgsProcessingParameterEnum(self.PHYLUM,
self.tr("- Phylum :"),
self.db_variables.value("phylum"),
allowMultiple=True,
optional=True)
phylum.setFlags(phylum.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(phylum)
classe = QgsProcessingParameterEnum(self.CLASSE,
self.tr("- Classe :"),
self.db_variables.value("classe"),
allowMultiple=True,
optional=True)
classe.setFlags(classe.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(classe)
ordre = QgsProcessingParameterEnum(self.ORDRE,
self.tr("- Ordre :"),
self.db_variables.value("ordre"),
allowMultiple=True,
optional=True)
ordre.setFlags(ordre.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(ordre)
famille = QgsProcessingParameterEnum(
self.FAMILLE,
self.tr("- Famille :"),
self.db_variables.value("famille"),
allowMultiple=True,
optional=True)
famille.setFlags(famille.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(famille)
group1_inpn = QgsProcessingParameterEnum(
self.GROUP1_INPN,
self.
tr("- Groupe 1 INPN (regroupement vernaculaire du référentiel national - niveau 1) :"
),
self.db_variables.value("group1_inpn"),
allowMultiple=True,
optional=True)
group1_inpn.setFlags(group1_inpn.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(group1_inpn)
group2_inpn = QgsProcessingParameterEnum(
self.GROUP2_INPN,
self.
tr("- Groupe 2 INPN (regroupement vernaculaire du référentiel national - niveau 2) :"
),
self.db_variables.value("group2_inpn"),
allowMultiple=True,
optional=True)
group2_inpn.setFlags(group2_inpn.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(group2_inpn)
# Extra "where" conditions
extra_where = QgsProcessingParameterString(
self.EXTRA_WHERE,
self.
tr("""Vous pouvez ajouter des <u>conditions "where"</u> supplémentaires dans l'encadré suivant, en langage SQL <b style="color:#952132">(commencez par <i>and</i>)</b>"""
),
multiLine=True,
optional=True)
extra_where.setFlags(extra_where.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(extra_where)
# Output PostGIS layer = summary table
self.addOutput(
QgsProcessingOutputVectorLayer(
self.OUTPUT, self.tr('Couche en sortie'),
QgsProcessing.TypeVectorAnyGeometry))
# Output PostGIS layer name
self.addParameter(
QgsProcessingParameterString(
self.OUTPUT_NAME,
self.
tr("""<b style="color:#0a84db">PARAMÉTRAGE DES RESULTATS EN SORTIE</b><br/>
<b>*9/</b> Définissez un <u>nom</u> pour votre couche PostGIS"""
), self.tr("Tableau synthèse temps")))
# Boolean : True = add the summary table in the DB ; False = don't
self.addParameter(
QgsProcessingParameterBoolean(
self.ADD_TABLE,
self.
tr("Enregistrer les résultats en sortie dans une nouvelle table PostgreSQL"
), False))
### Histogram ###
add_histogram = QgsProcessingParameterEnum(
self.ADD_HISTOGRAM,
self.
tr("""<b>10/</b> Cochez la case ci-dessous si vous souhaitez <u>exporter</u> les résultats sous la forme d'un <u>histogramme</u> du total par<br/> pas de temps choisi."""
),
[
"Oui, je souhaite exporter les résultats sous la forme d'un histogramme du total par pas de temps choisi"
],
allowMultiple=True,
optional=True)
add_histogram.setMetadata(
{'widget_wrapper': {
'useCheckBoxes': True,
'columns': 1
}})
self.addParameter(add_histogram)
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_HISTOGRAM,
self.
tr("""<b style="color:#0a84db">ENREGISTREMENT DES RESULTATS</b><br/>
<b>11/</b> <u style="color:#952132">Si (et seulement si !)</u> vous avez sélectionné l'export sous forme d'<u>histogramme</u>, veuillez renseigner un emplacement<br/> pour l'enregistrer sur votre ordinateur (au format image). <u>Dans le cas contraire</u>, vous pouvez ignorer cette étape.<br/>
<font style='color:#06497a'><u>Aide</u> : Cliquez sur le bouton [...] puis sur 'Enregistrer vers un fichier...'</font>"""
),
self.tr('image PNG (*.png)'),
optional=True,
createByDefault=False))
