def initAlgorithm(self, config=None):
self.METHODS = [self.tr('Linear'),
self.tr('Clough-Toucher (cubic)')
]
self.addParameter(ParameterInterpolationData(self.INTERPOLATION_DATA,
self.tr('Input layer(s)')))
self.addParameter(QgsProcessingParameterEnum(self.METHOD,
self.tr('Interpolation method'),
options=self.METHODS,
defaultValue=0))
self.addParameter(QgsProcessingParameterNumber(self.COLUMNS,
self.tr('Number of columns'),
minValue=0, maxValue=10000000, defaultValue=300))
self.addParameter(QgsProcessingParameterNumber(self.ROWS,
self.tr('Number of rows'),
minValue=0, maxValue=10000000, defaultValue=300))
self.addParameter(QgsProcessingParameterExtent(self.EXTENT,
self.tr('Extent'),
optional=False))
self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Interpolated')))
triangulation_file_param = QgsProcessingParameterFeatureSink(self.TRIANGULATION,
self.tr('Triangulation'),
type=QgsProcessing.TypeVectorLine,
optional=True)
triangulation_file_param.setCreateByDefault(False)
self.addParameter(triangulation_file_param)
def initAlgorithm(self, config=None):
self.METHODS = [self.tr('Linear'),
self.tr('Clough-Toucher (cubic)')
]
self.addParameter(ParameterInterpolationData(self.INTERPOLATION_DATA,
self.tr('Input layer(s)')))
self.addParameter(QgsProcessingParameterEnum(self.METHOD,
self.tr('Interpolation method'),
options=self.METHODS,
defaultValue=0))
self.addParameter(QgsProcessingParameterExtent(self.EXTENT,
self.tr('Extent'),
optional=False))
pixel_size_param = ParameterPixelSize(self.PIXEL_SIZE,
self.tr('Output raster size'),
layersData=self.INTERPOLATION_DATA,
extent=self.EXTENT,
minValue=0.0,
default=0.1)
self.addParameter(pixel_size_param)
cols_param = QgsProcessingParameterNumber(self.COLUMNS,
self.tr('Number of columns'),
optional=True,
minValue=0, maxValue=10000000)
cols_param.setFlags(cols_param.flags() | QgsProcessingParameterDefinition.FlagHidden)
self.addParameter(cols_param)
rows_param = QgsProcessingParameterNumber(self.ROWS,
self.tr('Number of rows'),
optional=True,
minValue=0, maxValue=10000000)
rows_param.setFlags(rows_param.flags() | QgsProcessingParameterDefinition.FlagHidden)
self.addParameter(rows_param)
self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Interpolated')))
triangulation_file_param = QgsProcessingParameterFeatureSink(self.TRIANGULATION,
self.tr('Triangulation'),
type=QgsProcessing.TypeVectorLine,
optional=True)
triangulation_file_param.setCreateByDefault(False)
self.addParameter(triangulation_file_param)
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(
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': {
'class': 'processing.gui.wrappers.EnumWidgetWrapper',
'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'), [QgsProcessing.TypeVectorPoint]))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Delaunay triangulation'), type=QgsProcessing.TypeVectorPolygon))
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
# point.
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Input Point Layer'),
[QgsProcessing.TypeVectorPoint]))
self.keys = [
'accommodation', 'administrative-areas-buildings',
'administrative-region', 'airport', 'ambulance-services',
'amusement-holiday-park', 'atm-bank-exchange', 'bar-pub',
'body-of-water', 'bookshop', 'building', 'business-industry',
'business-services', 'camping', 'car-dealer-repair', 'car-rental',
'casino', 'cinema', 'city-town-village',
'clothing-accessories-shop', 'coffee', 'coffee-tea',
'communication-media', 'dance-night-club', 'department-store',
'eat-drink', 'education-facility', 'electronics-shop',
'ev-charging-station', 'facilities', 'facility',
'fair-convention-facility', 'ferry-terminal', 'fire-department',
'food-drink', 'forest-heath-vegetation', 'going-out',
'government-community-facility', 'hardware-house-garden-shop',
'hospital-health-care-facility', 'hospital-health-care-facility',
'hostel', 'hotel', 'intersection', 'kiosk-convenience-store',
'landmark-attraction', 'leisure-outdoor', 'library', 'mall',
'motel', 'mountain-hill', 'museum', 'natural-geographical',
'outdoor-area-complex', 'parking-facility', 'petrol-station',
'pharmacy', 'police-emergency', 'police-station', 'post-office',
'postal-area', 'public-transport', 'railway-station', 'recreation',
'religious-place', 'restaurant', 'service', 'shop', 'shopping',
'sights-museums', 'snacks-fast-food', 'sport-outdoor-shop',
'sports-facility-venue', 'street-square', 'taxi-stand', 'tea',
'theatre-music-culture', 'toilet-rest-area', 'tourist-information',
'transport', 'travel-agency', 'undersea-feature',
'wine-and-liquor', 'zoo'
]
self.addParameter(
QgsProcessingParameterEnum(
self.KEYS,
self.tr('POI Categories'),
options=self.keys,
# defaultValue=0,
optional=False,
allowMultiple=True))
# self.modes = [
# "walk", #indicates that the user is on foot.
# "drive", #indicates that the user is driving.
# "public_transport", #indicates that the user is on public transport.
# "bicycle", #indicates that the user is on bicycle.
# "none" #if the user is neither on foot nor driving.
# ]
# self.addParameter(
# QgsProcessingParameterEnum(
# self.MODES,
# self.tr('Traffic Mode'),
# options=self.modes,
# #defaultValue=0,
# optional=False,
# allowMultiple=False
# )
# )
# self.addParameter(
# QgsProcessingParameterNumber(
# self.RADIUS,
# self.tr('Radius around Points [m]'),
# parentParameterName=self.INPUT,
# options=self.keys,
# defaultValue=100,
# minValue=1,
# maxValue=100000,
# defaultUnit="DistanceMeters",
# optional=False,
# )#.setDefaultUnit(QgsUnitTypes.DistanceMeters)
# )
# 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.OUTPUT,
self.tr('POI layer')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterExpression(
self.GROUP_BY,
self.tr('Group by expression (NULL to group all features)'),
defaultValue='NULL',
optional=False,
parentLayerParameterName=self.INPUT))
class ParameterAggregates(QgsProcessingParameterDefinition):
def __init__(self,
name,
description,
parentLayerParameterName='INPUT'):
super().__init__(name, description)
self._parentLayerParameter = parentLayerParameterName
def clone(self):
copy = ParameterAggregates(self.name(), self.description(),
self._parentLayerParameter)
return copy
def type(self):
return 'aggregates'
def checkValueIsAcceptable(self, value, context=None):
if not isinstance(value, list):
return False
for field_def in value:
if not isinstance(field_def, dict):
return False
if not field_def.get('input', False):
return False
if not field_def.get('aggregate', False):
return False
if not field_def.get('name', False):
return False
if not field_def.get('type', False):
return False
return True
def valueAsPythonString(self, value, context):
return str(value)
def asScriptCode(self):
raise NotImplementedError()
@classmethod
def fromScriptCode(cls, name, description, isOptional, definition):
raise NotImplementedError()
def parentLayerParameter(self):
return self._parentLayerParameter
self.addParameter(
ParameterAggregates(self.AGGREGATES,
description=self.tr('Aggregates')))
self.parameterDefinition(self.AGGREGATES).setMetadata({
'widget_wrapper':
'processing.algs.qgis.ui.AggregatesPanel.AggregatesWidgetWrapper'
})
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Aggregated')))
def initAlgorithm(self, config=None):
self.DIRECTIONS = OrderedDict([
(self.tr('Forward direction'),
QgsVectorLayerDirector.DirectionForward),
(self.tr('Backward direction'),
QgsVectorLayerDirector.DirectionBackward),
(self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)
])
self.STRATEGIES = [
self.tr('Shortest Path (distance optimization)'),
self.tr('Fastest Path (time optimization)')
]
self.ENTRY_COST_CALCULATION_METHODS = [
self.tr('Ellipsoidal'),
self.tr('Planar (only use with projected CRS)')
]
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Network Layer'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.POINTS, self.tr('Point Layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterField(self.ID_FIELD,
self.tr('Unique Point ID Field'),
None,
self.POINTS,
optional=False))
self.addParameter(
QgsProcessingParameterEnum(self.STRATEGY,
self.tr('Optimization Criterion'),
self.STRATEGIES,
defaultValue=0))
params = []
params.append(
QgsProcessingParameterEnum(
self.ENTRY_COST_CALCULATION_METHOD,
self.tr('Entry Cost calculation method'),
self.ENTRY_COST_CALCULATION_METHODS,
defaultValue=0))
params.append(
QgsProcessingParameterField(self.DIRECTION_FIELD,
self.tr('Direction field'),
None,
self.INPUT,
optional=True))
params.append(
QgsProcessingParameterString(
self.VALUE_FORWARD,
self.tr('Value for forward direction'),
optional=True))
params.append(
QgsProcessingParameterString(
self.VALUE_BACKWARD,
self.tr('Value for backward direction'),
optional=True))
params.append(
QgsProcessingParameterString(self.VALUE_BOTH,
self.tr('Value for both directions'),
optional=True))
params.append(
QgsProcessingParameterEnum(self.DEFAULT_DIRECTION,
self.tr('Default direction'),
list(self.DIRECTIONS.keys()),
defaultValue=2))
params.append(
QgsProcessingParameterField(self.SPEED_FIELD,
self.tr('Speed field'),
None,
self.INPUT,
optional=True))
params.append(
QgsProcessingParameterNumber(self.DEFAULT_SPEED,
self.tr('Default speed (km/h)'),
QgsProcessingParameterNumber.Double,
5.0, False, 0, 99999999.99))
params.append(
QgsProcessingParameterNumber(self.TOLERANCE,
self.tr('Topology tolerance'),
QgsProcessingParameterNumber.Double,
0.0, False, 0, 99999999.99))
for p in params:
p.setFlags(p.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Output OD Matrix'),
QgsProcessing.TypeVectorLine),
True)
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(QgsProcessingParameterEnum(self.METHOD,
self.tr('Calculate using'), options=self.calc_methods, defaultValue=0))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Added geom info')))
def initAlgorithm(self, config):
currentPath = getCurrentPath(self)
FULL_PATH_A01 = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['IA01'][1]))
FULL_PATH_A02 = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['IA02'][1]))
FULL_PATH_A03 = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['IA03'][1]))
FULL_PATH_A04 = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['IA04'][1]))
FULL_PATH_A05 = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['IA05'][1]))
FULL_PATH_A06 = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['IA06'][1]))
FULL_PATH_A07 = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['IA07'][1]))
FULL_PATH_A08 = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['IA08'][1]))
FULL_PATH_A09 = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['IA09'][1]))
FULL_PATH_A10 = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['IA10'][1]))
FULL_PATH_A11 = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['IA11'][1]))
FULL_PATH_A12 = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['IA12'][1]))
FULL_PATH_A13 = buildFullPathName(
currentPath, nameWithOuputExtension(NAMES_INDEX['IA13'][1]))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.STUDY_AREA_GRID,
self.tr(TEXT_GRID_INPUT),
[QgsProcessing.TypeVectorPolygon],
optional=OPTIONAL_GRID_INPUT,
))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.BLOCKS,
self.tr('Manzanas'), [QgsProcessing.TypeVectorPolygon],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterField(self.FIELD_POPULATION,
self.tr('Población'),
'poblacion',
'BLOCKS',
optional=True))
self.addParameter(
QgsProcessingParameterField(self.FIELD_HOUSING,
self.tr('Viviendas'),
'viviendas',
'BLOCKS',
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.CADASTRE,
self.tr('Catastro'), [QgsProcessing.TypeVectorPolygon],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterField(self.CONSTRUCTION_AREA,
self.tr('Area de construcción'),
'Area Cons',
'CADASTRE',
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.FLOORS,
self.tr('Pisos de construcción catastro'),
'Pisos cons',
'CADASTRE',
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.BLOCKS_LAST,
self.tr('Manzanas en el último año'),
[QgsProcessing.TypeVectorPolygon],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterField(self.FIELD_POPULATION_LAST,
self.tr('Población en el último año'),
'poblacion',
'BLOCKS_LAST',
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.BLOCKS_BEGIN,
self.tr('Manzanas en el año inicial'),
[QgsProcessing.TypeVectorPolygon],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterField(self.FIELD_POPULATION_BEGIN,
self.tr('Población en el último año'),
'poblacion',
'BLOCKS_BEGIN',
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.BUILT_LAST,
self.tr('Área edificada en el último año'),
[QgsProcessing.TypeVectorPolygon],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.BUILT_BEGIN,
self.tr('Área edificada en el año inicial'),
[QgsProcessing.TypeVectorPolygon],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterNumber(
self.YEARS, self.tr('Años entre el inicial y el final'),
QgsProcessingParameterNumber.Integer, 10, False, 1, 99999999))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.EMPTY_PROPERTIES,
self.tr('Predios vacíos'),
[QgsProcessing.TypeVectorAnyGeometry],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.EDIFICACIONES,
self.tr('Edificaciones'), [QgsProcessing.TypeVectorPolygon],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterField(
self.FLOORS_EDIFICACIONES,
self.tr('Pisos de construcción edificaciones'),
'Pisos cons',
'EDIFICACIONES',
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSource(self.ROADS,
self.tr('Red vial'),
[QgsProcessing.TypeVectorLine],
optional=True,
defaultValue=''))
self.addParameter(
QgsProcessingParameterEnum(self.DISTANCE_OPTIONS,
self.tr('Tipo de distancia'),
options=['ISOCRONA', 'RADIAL'],
allowMultiple=False,
defaultValue=1))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.EDUCATION,
self.tr('Educación'), [QgsProcessing.TypeVectorPoint],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.HEALTH,
self.tr('Salud'), [QgsProcessing.TypeVectorPoint],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.APPROVAL,
self.tr('Aprovisionamiento'), [QgsProcessing.TypeVectorPoint],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.SPORTS,
self.tr('Deportivos recreativos'),
[QgsProcessing.TypeVectorPoint],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.ADMIN_PUBLIC,
self.tr('Gestión Pública'), [QgsProcessing.TypeVectorPoint],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.EQUIPMENT_PUBLIC_SPACE,
self.tr('Espacios públicos abiertos'),
[QgsProcessing.TypeVectorAnyGeometry],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.SHOP,
self.tr('Tiendas de abarrotes, despensas, minimercado'),
[QgsProcessing.TypeVectorPoint], '', True))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.PHARMACY, self.tr('Farmacias y droguerías'),
[QgsProcessing.TypeVectorPoint], '', True))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.STATIONERY, self.tr('Papelerías y bazares'),
[QgsProcessing.TypeVectorPoint], '', True))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.BAKERY, self.tr('Panaderías, heladería y pastelería'),
[QgsProcessing.TypeVectorPoint], '', True))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.GAS,
self.tr('Depósitos de distribución de cilindros de gas'),
[QgsProcessing.TypeVectorPoint], '', True))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.TERTIARYUSES,
self.tr('Uos terciarios (comercio, servicios u oficinas)'),
[QgsProcessing.TypeVectorPoint],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.TERTIARYUSES_ACTIVITIES,
self.tr('Equipamientos de actividades'),
[QgsProcessing.TypeVectorPoint],
optional=True,
defaultValue=""))
self.addParameter(
QgsProcessingParameterField(self.FIELD_ACTIVITIES,
self.tr('Actividades'),
'categoria',
'TERTIARYUSES_ACTIVITIES',
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.ROADS_SINTAXIS,
self.tr('Vías SINTAXIS ESPACIAL'),
[QgsProcessing.TypeVectorLine],
optional=True,
defaultValue=""))
# self.addParameter(
# QgsProcessingParameterField(
# self.FIELD_SINTAXIS,
# self.tr('Valor'),
# 'NACH_slen', 'ROADS_SINTAXIS',
# optional = True
# )
# )
# ---------------------OUTPUTS---------------------------------
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_A01, self.tr('A01 Densidad neta de habitantes'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH_A01)))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_A02, self.tr('A02 Densidad neta de viviendas'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH_A02)))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_A03, self.tr('A03 Compacidad absoluta'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH_A03)))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_A04,
self.tr('A04 Eficiencia en el uso del territorio'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH_A04)))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_A05, self.tr('A05 Área de predios vacíos'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH_A05)))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_A06, self.tr('A06 Proporción de la calle'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH_A06)))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_A07,
self.tr('A07 Proximidad a servicios urbanos básicos'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH_A07)))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_A08,
self.tr('A08 Proximidad al espacio público abierto'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH_A08)))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_A09,
self.tr('A09 Cobertura de actividades comerciales cotinianas'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH_A09)))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_A10,
self.tr('A10 Relación entre actividad y residencia'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH_A10)))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_A11, self.tr('A11 Complejidad urbana'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH_A11)))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_A12,
self.tr('A12 Densidad de intersecciones peatonales'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH_A12)))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_A13, self.tr('A13 Accesibilidad al tejido'),
QgsProcessing.TypeVectorAnyGeometry, str(FULL_PATH_A13)))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(self.INPUT,
self.tr('Layer to filter')))
self.addParameter(
QgsProcessingParameterField(
self.FIELD,
self.tr("Field selection"),
QVariant(),
self.INPUT,
type=QgsProcessingParameterField.Numeric))
self.addParameter(
QgsProcessingParameterEnum(
self.INPUT_METHOD, self.tr('Filtering method'),
['Normal distribution', 'Coefficient of Variation', 'IDW']))
self.addParameter(
QgsProcessingParameterEnum(
self.INPUT_CONFIANCE,
self.tr(
'Confidence interval (for normal distribution method)'),
['68%', '95%', '99,5%']))
self.addParameter(
QgsProcessingParameterNumber(
self.INPUT_SD, self.tr('Number of standard deviations (IDW)'),
QgsProcessingParameterNumber.Integer, 2))
self.addParameter(
QgsProcessingParameterNumber(self.INPUT_VOISINS,
self.tr('Number of neighbours'),
QgsProcessingParameterNumber.Integer,
5))
self.addParameter(
QgsProcessingParameterNumber(
self.INPUT_CV_MAX,
self.
tr('Maximum Coefficient of variation (for coefficient of variation method)'
), QgsProcessingParameterNumber.Double, 2))
self.addParameter(
QgsProcessingParameterBoolean(
self.BOOLEAN_DISTANCE,
self.tr('Consider a distance-based neighbourhood')))
self.addParameter(
QgsProcessingParameterNumber(self.INPUT_DISTANCE,
self.tr('Neighbourhood distance'),
QgsProcessingParameterNumber.Double,
5e-5))
self.addParameter(
QgsProcessingParameterBoolean(self.BOOLEAN,
self.tr('Remove outliers')))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Filtered layer')))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Input layer'), [QgsProcessing.TypeVectorPoint]))
self.addParameter(QgsProcessingParameterDistance(self.BUFFER, self.tr('Buffer region'), parentParameterName=self.INPUT,
minValue=0.0, maxValue=9999999999, defaultValue=0.0))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Voronoi polygons'), type=QgsProcessing.TypeVectorPolygon))
def initAlgorithm(self, config):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.PrmInputLayer, tr('Input point layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterEnum(self.PrmShapeType,
tr('Shape type'),
options=SHAPE_TYPE,
defaultValue=0,
optional=False))
self.addParameter(
QgsProcessingParameterField(
self.PrmCuspsField,
tr('Number of cusps field'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PrmStartingAngleField,
tr('Starting angle field'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PrmRadiusField,
tr('Radius field'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.PrmCusps,
tr('Number of cusps'),
QgsProcessingParameterNumber.Integer,
defaultValue=4,
minValue=3,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.PrmStartingAngle,
tr('Starting angle'),
QgsProcessingParameterNumber.Double,
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.PrmRadius,
tr('Radius'),
QgsProcessingParameterNumber.Double,
defaultValue=40.0,
minValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.PrmUnitsOfMeasure,
tr('Radius units of measure'),
options=DISTANCE_LABELS,
defaultValue=0,
optional=False))
self.addParameter(
QgsProcessingParameterNumber(self.PrmDrawingSegments,
tr('Number of drawing segments'),
QgsProcessingParameterNumber.Integer,
defaultValue=720,
minValue=4,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.PrmExportInputGeometry,
tr('Add input geometry fields to output table'),
False,
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.PrmOutputLayer,
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.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer'), [QgsProcessing.TypeVectorLine]))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Exploded'), QgsProcessing.TypeVectorLine))
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_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, types=[self.datatypeCombo.currentData()])
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_DISTANCE
or isinstance(self.param, QgsProcessingParameterDistance)):
self.param = QgsProcessingParameterDistance(
name, description, self.defaultTextBox.text())
try:
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
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()
if parent:
self.param.setParentParameterName(parent)
elif (self.paramType == parameters.PARAMETER_SCALE
or isinstance(self.param, QgsProcessingParameterScale)):
self.param = QgsProcessingParameterScale(
name, description, self.defaultTextBox.text())
elif (self.paramType == parameters.PARAMETER_NUMBER
or isinstance(self.param, QgsProcessingParameterNumber)):
type = self.type_combo.currentData()
self.param = QgsProcessingParameterNumber(
name, description, type, self.defaultTextBox.text())
try:
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
# Destination parameter
elif (isinstance(self.param, QgsProcessingParameterFeatureSink)):
self.param = QgsProcessingParameterFeatureSink(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterFileDestination)):
self.param = QgsProcessingParameterFileDestination(
name=name,
description=self.param.description(),
fileFilter=self.param.fileFilter(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterFolderDestination)):
self.param = QgsProcessingParameterFolderDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterRasterDestination)):
self.param = QgsProcessingParameterRasterDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterVectorDestination)):
self.param = QgsProcessingParameterVectorDestination(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.value())
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)
if self.advancedCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
else:
self.param.setFlags(
self.param.flags()
& ~QgsProcessingParameterDefinition.FlagAdvanced)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input image'))
)
self.addParameter(
QgsProcessingParameterVectorDestination (
self.OUTPUT_FOOTPRINT,
self.tr('Image footprint'),
QgsProcessing.TypeVectorPolygon
)
)
self.addParameter(
QgsProcessingParameterFeatureSink (
self.OUTPUT_NADIR,
self.tr('Drone nadir point'),
QgsProcessing.TypeVectorPoint
)
)
self.addParameter(
QgsProcessingParameterCrs(
self.SOURCE_CRS,
self.tr('Source CRS'),
defaultValue='EPSG:4326'
)
)
self.addParameter(
QgsProcessingParameterCrs(
self.DESTINATION_CRS,
self.tr('Destination CRS'),
optional = True,
defaultValue='ProjectCrs'
)
)
# horizontar referred to flight direction => means wide angle
self.addParameter(
QgsProcessingParameterNumber(
self.HORIZONTAL_FOV,
self.tr('Wide camera angle'),
type = QgsProcessingParameterNumber.Double,
defaultValue = 84.0,
minValue = 0,
maxValue = 360
)
)
# vertical referred to flight direction => means tall angle
parameter = QgsProcessingParameterBoolean(self.USE_IMAGE_RATIO_FOR_VERTICAL_FOV,
self.tr('Calc vertical FOV using image ratio'),
defaultValue = True)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
parameter = QgsProcessingParameterNumber(self.VERTICAL_FOV,
self.tr('Tall camera angle'),
type = QgsProcessingParameterNumber.Double,
defaultValue = 54.0,
minValue = 0,
maxValue = 360)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
parameter = QgsProcessingParameterNumber(self.VERTICAL_FOV_MULTIPLIER,
self.tr('Empiric multiplier to fix tall FOV basing on image ratio'),
type = QgsProcessingParameterNumber.Double,
defaultValue = 0.855)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
parameter = QgsProcessingParameterNumber(self.NADIR_TO_BOTTOM_OFFSET,
self.tr('Offset to add to bottom distance result'),
type = QgsProcessingParameterNumber.Double)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
parameter = QgsProcessingParameterNumber(self.NADIR_TO_UPPPER_OFFSET,
self.tr('Offset to add to upper distance result'),
type = QgsProcessingParameterNumber.Double)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterMapLayer(self.INPUT, self.tr('Input layer')))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Extent'), type=QgsProcessing.TypeVectorPolygon))
def initAlgorithm(self, config=None):
"""
Definition of inputs and outputs of the algorithm, along with some other properties.
"""
# We add the input vector layer. It can have any kind of geometry
# It is a mandatory (not optional) one, hence the False argument
self.addParameter(
QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer'),
[QgsProcessing.TypeVector],
None, False))
self.addParameter(
QgsProcessingParameterField(self.FIELD_SEGMENT_ID,
self.tr('Segment ID field'), None,
self.INPUT,
QgsProcessingParameterField.Any))
# read server connections and prepare enum items
self.connection_options.clear()
default_graph_server = Settings.get_selected_graph_server()
selected_index = 0
for index, connection in enumerate(
self.connection_manager.read_connections()):
self.connection_options.append(connection.name)
if selected_index == 0 and isinstance(default_graph_server, str)\
and connection.name == default_graph_server:
selected_index = index
self.addParameter(
QgsProcessingParameterEnum(self.SERVER_NAME,
self.tr('Server name'),
self.connection_options, False,
selected_index, False))
default_graph_name = Settings.get_selected_graph_name()
graph_name = ''
if isinstance(default_graph_name, str):
graph_name = default_graph_name
self.addParameter(
QgsProcessingParameterString(self.GRAPH_NAME,
self.tr('Graph name'), graph_name,
False, False))
default_graph_version = Settings.get_selected_graph_version()
graph_version = ''
if isinstance(default_graph_version, str):
graph_version = default_graph_version
self.addParameter(
QgsProcessingParameterString(self.GRAPH_VERSION,
self.tr('Graph version'),
graph_version, False, False))
# We add a vector layer as output
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT_SEGMENTS,
self.tr('Segments'),
QgsProcessing.TypeVectorLine))
self.addOutput(
QgsProcessingOutputNumber(self.OUTPUT_SEGMENT_COUNT,
self.tr('Number of segments')))
self.addOutput(
QgsProcessingOutputNumber(
self.OUTPUT_SEGMENT_WITH_GEOMETRY_COUNT,
self.tr('Number of segments with geometry')))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Nodes'), QgsProcessing.TypeVectorPoint))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer'), types=[QgsProcessing.TypeVectorLine]))
self.addParameter(QgsProcessingParameterBoolean(self.KEEP_FIELDS,
self.tr('Keep table structure of line layer'), defaultValue=False, optional=True))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Polygons from lines'), QgsProcessing.TypeVectorPolygon))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Cleaned')))
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()
# Destination parameter
if (isinstance(self.param, QgsProcessingParameterFeatureSink)):
self.param = QgsProcessingParameterFeatureSink(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterFileDestination)):
self.param = QgsProcessingParameterFileDestination(
name=name,
description=self.param.description(),
fileFilter=self.param.fileFilter(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterFolderDestination)):
self.param = QgsProcessingParameterFolderDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterRasterDestination)):
self.param = QgsProcessingParameterRasterDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterVectorDestination)):
self.param = QgsProcessingParameterVectorDestination(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.value())
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)
if self.advancedCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
else:
self.param.setFlags(
self.param.flags()
& ~QgsProcessingParameterDefinition.FlagAdvanced)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
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=None):
self.addParameter(QgsProcessingParameterMultipleLayers(self.LAYERS,
self.tr('Layers to merge'),
QgsProcessing.TypeVectorAnyGeometry))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Merged')))
def initAlgorithm(self, config=None):
self.DIRECTIONS = OrderedDict([
(self.tr('Forward direction'),
QgsVectorLayerDirector.DirectionForward),
(self.tr('Backward direction'),
QgsVectorLayerDirector.DirectionBackward),
(self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)
])
self.STRATEGIES = [self.tr('Shortest'), self.tr('Fastest')]
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Vector layer representing network'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.START_POINTS, self.tr('Vector layer with start points'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterEnum(self.STRATEGY,
self.tr('Path type to calculate'),
self.STRATEGIES,
defaultValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.TRAVEL_COST,
self.tr(
'Travel cost (distance for "Shortest", time for "Fastest")'
), QgsProcessingParameterNumber.Double, 0.0, False, 0))
params = []
params.append(
QgsProcessingParameterField(self.DIRECTION_FIELD,
self.tr('Direction field'),
None,
self.INPUT,
optional=True))
params.append(
QgsProcessingParameterString(
self.VALUE_FORWARD,
self.tr('Value for forward direction'),
optional=True))
params.append(
QgsProcessingParameterString(
self.VALUE_BACKWARD,
self.tr('Value for backward direction'),
optional=True))
params.append(
QgsProcessingParameterString(self.VALUE_BOTH,
self.tr('Value for both directions'),
optional=True))
params.append(
QgsProcessingParameterEnum(self.DEFAULT_DIRECTION,
self.tr('Default direction'),
list(self.DIRECTIONS.keys()),
defaultValue=2))
params.append(
QgsProcessingParameterField(self.SPEED_FIELD,
self.tr('Speed field'),
None,
self.INPUT,
optional=True))
params.append(
QgsProcessingParameterNumber(self.DEFAULT_SPEED,
self.tr('Default speed (km/h)'),
QgsProcessingParameterNumber.Double,
5.0, False, 0))
params.append(
QgsProcessingParameterDistance(self.TOLERANCE,
self.tr('Topology tolerance'), 0.0,
self.INPUT, False, 0))
params.append(
QgsProcessingParameterBoolean(
self.INCLUDE_BOUNDS,
self.tr('Include upper/lower bound points'),
defaultValue=False))
for p in params:
p.setFlags(p.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
lines_output = QgsProcessingParameterFeatureSink(
self.OUTPUT_LINES,
self.tr('Service area (lines)'),
QgsProcessing.TypeVectorLine,
optional=True)
lines_output.setCreateByDefault(True)
self.addParameter(lines_output)
nodes_output = QgsProcessingParameterFeatureSink(
self.OUTPUT,
self.tr('Service area (boundary nodes)'),
QgsProcessing.TypeVectorPoint,
optional=True)
nodes_output.setCreateByDefault(False)
self.addParameter(nodes_output)
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': {
'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'),
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):
self.DIRECTIONS = OrderedDict([
(self.tr('Forward direction'),
QgsVectorLayerDirector.DirectionForward),
(self.tr('Backward direction'),
QgsVectorLayerDirector.DirectionBackward),
(self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)
])
self.STRATEGIES = [self.tr('Shortest'), self.tr('Fastest')]
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Vector layer representing network'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(
QgsProcessingParameterPoint(self.START_POINT,
self.tr('Start point')))
self.addParameter(
QgsProcessingParameterNumber(
self.MAX_DIST,
self.
tr('Size of Iso-Area (distance or seconds depending on strategy)'
), QgsProcessingParameterNumber.Double, 2500.0, False, 0,
99999999.99))
self.addParameter(
QgsProcessingParameterEnum(self.STRATEGY,
self.tr('Path type to calculate'),
self.STRATEGIES,
defaultValue=0))
params = []
params.append(
QgsProcessingParameterField(self.DIRECTION_FIELD,
self.tr('Direction field'),
None,
self.INPUT,
optional=True))
params.append(
QgsProcessingParameterString(
self.VALUE_FORWARD,
self.tr('Value for forward direction'),
optional=True))
params.append(
QgsProcessingParameterString(
self.VALUE_BACKWARD,
self.tr('Value for backward direction'),
optional=True))
params.append(
QgsProcessingParameterString(self.VALUE_BOTH,
self.tr('Value for both directions'),
optional=True))
params.append(
QgsProcessingParameterEnum(self.DEFAULT_DIRECTION,
self.tr('Default direction'),
list(self.DIRECTIONS.keys()),
defaultValue=2))
params.append(
QgsProcessingParameterField(self.SPEED_FIELD,
self.tr('Speed field'),
None,
self.INPUT,
optional=True))
params.append(
QgsProcessingParameterNumber(self.DEFAULT_SPEED,
self.tr('Default speed (km/h)'),
QgsProcessingParameterNumber.Double,
5.0, False, 0, 99999999.99))
params.append(
QgsProcessingParameterNumber(self.TOLERANCE,
self.tr('Topology tolerance'),
QgsProcessingParameterNumber.Double,
0.0, False, 0, 99999999.99))
for p in params:
p.setFlags(p.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Output Pointcloud'),
QgsProcessing.TypeVectorLine))
def initAlgorithm(self, config):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.PrmInputLayer, tr('Input point layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterEnum(self.PrmShapeType,
tr('Shape type'),
options=SHAPE_TYPE,
defaultValue=0,
optional=False))
self.addParameter(
QgsProcessingParameterField(
self.PrmSemiMajorAxisField,
tr('Semi-major axis field'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PrmSemiMinorAxisField,
tr('Semi-minor axis field'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PrmOrientationField,
tr('Orientation of axis field'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.PrmDefaultSemiMajorAxis,
tr('Default semi-major axis'),
QgsProcessingParameterNumber.Double,
defaultValue=40.0,
minValue=0.00001,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.PrmDefaultSemiMinorAxis,
tr('Default semi-minor axis'),
QgsProcessingParameterNumber.Double,
defaultValue=20.0,
minValue=0.00001,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.PrmDefaultOrientation,
tr('Default orientation of axis'),
QgsProcessingParameterNumber.Double,
defaultValue=0,
minValue=-360,
maxValue=360,
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.PrmUnitsOfMeasure,
tr('Radius units'),
options=DISTANCE_LABELS,
defaultValue=0,
optional=False))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmDrawingSegments,
tr('Number of drawing segments (approximate)'),
QgsProcessingParameterNumber.Integer,
defaultValue=64,
minValue=8,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.PrmExportInputGeometry,
tr('Add input geometry fields to output table'),
False,
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.PrmOutputLayer,
tr('Output layer')))
def initAlgorithm(self, config):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.PrmInputLayer, tr('Input point vector layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterEnum(self.PrmOutputFormat,
tr('Output format'),
options=[
tr('Coordinates in 2 fields'),
tr('Coordinates in 1 field'),
'GeoJSON', 'WKT', 'MGRS',
'Plus Codes'
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.PrmYFieldName,
tr('Latitude (Y), GeoJSON, WKT, MGRS, or Plus Codes field name'
),
defaultValue='y',
optional=True))
self.addParameter(
QgsProcessingParameterString(self.PrmXFieldName,
tr('Longitude (X) field name'),
defaultValue='x',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmCoordinateOrder,
tr('Coordinate order when using 1 field'),
options=[
tr('Lat,Lon (Y,X) - Google map order'),
tr('Lon,Lat (X,Y) order')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmCoordinateDelimiter,
tr('Coordinate delimiter when using 1 field'),
options=[tr('Comma'),
tr('Space'),
tr('Tab'),
tr('Other')],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.PrmOtherDelimiter,
tr('Other delimiter when using 1 field'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmOutputCRSType,
tr('Output CRS of coordinates added to a field'),
options=[
tr('WGS 84'),
tr('Layer CRS'),
tr('Project CRS'),
tr('Custom CRS')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterCrs(
self.PrmCustomCRS,
tr('Custom CRS for coordinates added to a field'),
'EPSG:4326',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmWgs84NumberFormat,
tr('Select Decimal or DMS degress for WGS 84 numbers'),
options=[tr('Decimal degrees'),
tr('DMS'),
tr('DDMMSS')],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmCoordinatePrecision,
tr('Decimal number precision'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=8,
optional=True,
minValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmDMSSecondPrecision,
tr('DMS second precision'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=0,
optional=True,
minValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmPlusCodesLength,
'Plus Codes length',
type=QgsProcessingParameterNumber.Integer,
defaultValue=11,
optional=False,
minValue=10,
maxValue=20))
self.addParameter(
QgsProcessingParameterFeatureSink(self.PrmOutputLayer,
'Output layer'))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT_RASTER,
self.tr('Raster layer')))
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT_VECTOR,
self.tr('Vector layer'), [QgsProcessing.TypeVectorLine]))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Points along lines'), QgsProcessing.TypeVectorPoint))
def initAlgorithm(self, config=None):
self.DIRECTIONS = OrderedDict([
(self.tr('Forward direction'), QgsVectorLayerDirector.DirectionForward),
(self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward),
(self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)])
self.STRATEGIES = [self.tr('Shortest'),
self.tr('Fastest')
]
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Vector layer representing network'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(QgsProcessingParameterPoint(self.START_POINT,
self.tr('Start point')))
self.addParameter(QgsProcessingParameterEnum(self.STRATEGY,
self.tr('Path type to calculate'),
self.STRATEGIES,
defaultValue=0))
self.addParameter(QgsProcessingParameterNumber(self.TRAVEL_COST,
self.tr('Travel cost (distance for "Shortest", time for "Fastest")'),
QgsProcessingParameterNumber.Double,
0.0, False, 0))
params = []
params.append(QgsProcessingParameterField(self.DIRECTION_FIELD,
self.tr('Direction field'),
None,
self.INPUT,
optional=True))
params.append(QgsProcessingParameterString(self.VALUE_FORWARD,
self.tr('Value for forward direction'),
optional=True))
params.append(QgsProcessingParameterString(self.VALUE_BACKWARD,
self.tr('Value for backward direction'),
optional=True))
params.append(QgsProcessingParameterString(self.VALUE_BOTH,
self.tr('Value for both directions'),
optional=True))
params.append(QgsProcessingParameterEnum(self.DEFAULT_DIRECTION,
self.tr('Default direction'),
list(self.DIRECTIONS.keys()),
defaultValue=2))
params.append(QgsProcessingParameterField(self.SPEED_FIELD,
self.tr('Speed field'),
None,
self.INPUT,
optional=True))
params.append(QgsProcessingParameterNumber(self.DEFAULT_SPEED,
self.tr('Default speed (km/h)'),
QgsProcessingParameterNumber.Double,
5.0, False, 0))
params.append(QgsProcessingParameterDistance(self.TOLERANCE,
self.tr('Topology tolerance'),
0.0, self.INPUT, False, 0))
params.append(QgsProcessingParameterBoolean(self.INCLUDE_BOUNDS,
self.tr('Include upper/lower bound points'),
defaultValue=False))
for p in params:
p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
lines_output = QgsProcessingParameterFeatureSink(self.OUTPUT_LINES,
self.tr('Service area (lines)'),
QgsProcessing.TypeVectorLine, optional=True)
lines_output.setCreateByDefault(True)
self.addParameter(lines_output)
nodes_output = QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Service area (boundary nodes)'),
QgsProcessing.TypeVectorPoint, optional=True)
nodes_output.setCreateByDefault(False)
self.addParameter(nodes_output)
def initAlgorithm(self, config):
currentPath = getCurrentPath(self)
self.CURRENT_PATH = currentPath
FULL_PATH = buildFullPathName(currentPath, nameWithOuputExtension(NAMES_INDEX['ID14'][1]))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.BLOCKS,
self.tr('Manzanas'),
[QgsProcessing.TypeVectorPolygon]
)
)
self.addParameter(
QgsProcessingParameterField(
self.DPA_MAN,
self.tr('DPA Manzanas'),
'dpa_manzan', 'BLOCKS'
)
)
self.addParameter(
QgsProcessingParameterFile(
self.CENSO_POBLACION,
self.tr('Censo población'),
extension='csv',
defaultValue=""
)
)
self.addParameter(
QgsProcessingParameterFeatureSource(
self.STUDY_AREA_GRID,
self.tr(TEXT_GRID_INPUT),
[QgsProcessing.TypeVectorPolygon],
'', OPTIONAL_GRID_INPUT
)
)
if OPTIONAL_GRID_INPUT:
self.addParameter(
QgsProcessingParameterNumber(
self.CELL_SIZE,
self.tr('Tamaño de la malla'),
QgsProcessingParameterNumber.Integer,
P_CELL_SIZE, False, 1, 99999999
)
)
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT,
self.tr('Salida'),
QgsProcessing.TypeVectorAnyGeometry,
str(FULL_PATH)
)
)
