def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterVectorLayer(self.INPUT,
self.tr('Input Layer'), types=[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(QgsProcessingParameterCrs(self.CRS, 'CRS'))
self.addOutput(QgsProcessingOutputVectorLayer(self.INPUT,
self.tr('Layer with projection')))
def initAlgorithm(self, config):
#---------------LAYER A
self.addParameter(
QgsProcessingParameterVectorLayer(
self.LAYER_TO #layer id
,
self.tr('Layer to update') #display text
,
[QgsProcessing.TypeVectorPoint, QgsProcessing.TypeVectorLine
] #layer types
,
'',
False #[is Optional?]
))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_JOIN_TO #id
,
self.tr('Field for join layers in A(default well_id)'
) #display text
,
'well_id',
self.LAYER_TO #field layer
,
QgsProcessingParameterField.Any,
optional=True #[is Optional?]
))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_LBLX_TO #id
,
self.tr('Field with label x position(default lablx)'
) #display text
,
'lablx',
self.LAYER_TO #field layer
,
QgsProcessingParameterField.Any,
optional=True #[is Optional?]
))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_LBLY_TO #id
,
self.tr('Field with label y position(default lably)'
) #display text
,
'lably',
self.LAYER_TO #field layer
,
QgsProcessingParameterField.Any,
optional=True #[is Optional?]
))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_LBLXOFF_TO #id
,
self.tr('Field with label x offset position(default labloffx)'
) #display text
,
'labloffx',
self.LAYER_TO #field layer
,
QgsProcessingParameterField.Any,
optional=True #[is Optional?]
))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_LBLYOFF_TO #id
,
self.tr('Field with label y offset position(default labloffy)'
) #display text
,
'labloffy',
self.LAYER_TO #field layer
,
QgsProcessingParameterField.Any,
optional=True #[is Optional?]
))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_LBLOFF_TO #id
,
self.
tr('Field with enable/disable offset offset position(default labloffset)'
) #display text
,
'labloffset',
self.LAYER_TO #field layer
,
QgsProcessingParameterField.Any,
optional=True #[is Optional?]
))
#---------------
self.addParameter(
QgsProcessingParameterBoolean(
self.IS_REMOVE_JOIN #id
,
self.tr('Remove join after algorithm?') #display text
,
'',
True #default
))
#---------------LAYER B
self.addParameter(
QgsProcessingParameterVectorLayer(
self.LAYER_FROM #layer id
,
self.tr('Layer from update') #display text
,
[QgsProcessing.TypeVectorPoint, QgsProcessing.TypeVectorLine
] #layer types
,
'',
False #[is Optional?]
))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_JOIN_FROM #id
,
self.tr(
'Field to for layers in B(default well_id)') #display text
,
'well_id',
self.LAYER_FROM #field layer
,
QgsProcessingParameterField.Any,
optional=True #[is Optional?]
))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_LBLX_FROM #id
,
self.tr('Field with label x position(default lablx)'
) #display text
,
'lablx',
self.LAYER_FROM #field layer
,
QgsProcessingParameterField.Any,
optional=True #[is Optional?]
))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_LBLY_FROM #id
,
self.tr('Field with label y position(default lably)'
) #display text
,
'lably',
self.LAYER_FROM #field layer
,
QgsProcessingParameterField.Any,
optional=True #[is Optional?]
))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_LBLXOFF_FROM #id
,
self.tr('Field with label x offset position(default labloffx)'
) #display text
,
'labloffx',
self.LAYER_FROM #field layer
,
QgsProcessingParameterField.Any,
optional=True #[is Optional?]
))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_LBLYOFF_FROM #id
,
self.tr('Field with label y offset position(default labloffy)'
) #display text
,
'labloffy',
self.LAYER_FROM #field layer
,
QgsProcessingParameterField.Any,
optional=True #[is Optional?]
))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_LBLOFF_FROM #id
,
self.
tr('Field with enable/disable offset offset position(default labloffset)'
) #display text
,
'labloffset',
self.LAYER_FROM #field layer
,
QgsProcessingParameterField.Any,
optional=True #[is Optional?]
))
def initAlgorithm(self, config, label=True):
if DEBUG_MODE:
logMessage("initAlgorithm(): {}".format(self.__class__.__name__),
False)
qgis_iface = qgis.utils.plugins["Qgis2threejs"].iface
self.settings.loadSettingsFromFile()
self.settings.setMapSettings(qgis_iface.mapCanvas().mapSettings())
self.addParameter(
QgsProcessingParameterFolderDestination(
self.OUTPUT, self.tr("Output Directory")))
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT, self.tr("Coverage Layer"),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterField(self.TITLE_FIELD,
self.tr("Title Field"), None,
self.INPUT,
QgsProcessingParameterField.Any))
self.addParameter(
QgsProcessingParameterBoolean(self.CF_FILTER,
self.tr("Current Feature Filter")))
enum = ["Fit to Geometry", "Fixed Scale (based on map canvas)"]
self.addAdvancedParameter(
QgsProcessingParameterEnum(self.SCALE,
self.tr("Scale Mode"),
enum,
defaultValue=enum[0]))
self.addAdvancedParameter(
QgsProcessingParameterNumber(self.BUFFER,
self.tr("Buffer (%)"),
defaultValue=10))
self.addAdvancedParameter(
QgsProcessingParameterNumber(self.TEX_WIDTH,
self.tr("Texture base width (px)"),
defaultValue=1024))
self.addAdvancedParameter(
QgsProcessingParameterNumber(
self.TEX_HEIGHT,
self.
tr('Texture base height (px)\n'
' Leave this zero to respect aspect ratio of buffered geometry bounding box (in "Fit to Geometry" scale mode)\n'
' or map canvas (in "Fixed scale" scale mode).'),
defaultValue=0
# ,optional=True
))
if label:
self.addAdvancedParameter(
QgsProcessingParameterExpression(
self.HEADER, self.tr("Header Label"),
"'{}'".format(self.settings.headerLabel().replace(
"'", "''")), self.INPUT))
self.addAdvancedParameter(
QgsProcessingParameterExpression(
self.FOOTER, self.tr("Footer Label"),
"'{}'".format(self.settings.footerLabel().replace(
"'", "''")), self.INPUT))
self.addAdvancedParameter(
QgsProcessingParameterFile(
self.SETTINGS,
self.tr('Export Settings File (.qto3settings)'),
extension="qto3settings",
optional=True))
def accept(self):
description = self.nameTextBox.text()
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while self.alg.parameterDefinition(name):
name = safeName.lower() + str(i)
i += 1
else:
name = self.param.name()
if (self.paramType == parameters.PARAMETER_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_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
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_EXTENT
or isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
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)
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):
priWorkDir = os.path.join(os.path.dirname(__file__), '../output/')
self.addParameter(
QgsProcessingParameterVectorLayer(
'cavitytreelocations',
'Cavity Tree',
types=[QgsProcessing.TypeVectorPoint],
defaultValue=None))
self.addParameter(
QgsProcessingParameterFeatureSink(
'Cluster_center',
'Cluster Centers',
type=QgsProcessing.TypeVectorPoint,
createByDefault=True,
defaultValue='cluster_center.shp'))
self.addParameter(
QgsProcessingParameterFeatureSink(
'1_4m_voronoi',
'1/4M voronoi',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue='1_4M_voronoi.shp'))
self.addParameter(
QgsProcessingParameterFeatureSink(
'1_2m_voronoi',
'1/2M voronoi',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue='1_2M_voronoi.shp'))
self.addParameter(
QgsProcessingParameterFeatureSink(
'1_4m_cluster_buffer',
'1/4M buffer - Uncheck',
type=QgsProcessing.TypeVectorPolygon,
createByDefault=True,
defaultValue='1_4M_cluster_buffer.shp'))
self.addParameter(
QgsProcessingParameterFeatureSink(
'1_2m_cluster_buffer',
'1/2M buffer - Uncheck',
type=QgsProcessing.TypeVectorPolygon,
createByDefault=True,
defaultValue='1_2M_cluster_buffer.shp'))
self.addParameter(
QgsProcessingParameterFeatureSink(
'1_4m_disolve',
'1/4M disolve - Uncheck',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue='1_4M_disolve.shp'))
self.addParameter(
QgsProcessingParameterFeatureSink(
'1_2m_disolve',
'1/2M disolve - Uncheck',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue='1_2M_disolve.shp'))
self.addParameter(
QgsProcessingParameterFeatureSink(
'VoronoiCenters',
'Voronoi Centers - Uncheck',
type=QgsProcessing.TypeVectorPolygon,
createByDefault=True,
defaultValue='voronoi_center.shp'))
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'),
)
)
self.addParameter(
QgsProcessingParameterExpression(
self.EXISTANT,
self.tr('Field'),
parentLayerParameterName=self.INPUT,
optional=False
)
)
self.addParameter(
QgsProcessingParameterEnum(
self.TYPE,
self.tr('Type'),
options=self.types_data,
defaultValue=0
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.TAILLE,
self.tr('Size'),
QgsProcessingParameterNumber.Integer,
defaultValue=255,
minValue=1,
maxValue=20
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.PRECISION,
self.tr('Precision'),
QgsProcessingParameterNumber.Integer,
defaultValue=15,
minValue=0,
maxValue=15
)
)
self.addParameter(
QgsProcessingParameterExpression(
self.FILTRE,
self.tr('Filter'),
None,
self.INPUT,
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(
QgsProcessingParameterExpression(
self.FORMULE,
self.tr('Formula'),
None,
self.INPUT
)
)
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(QgsProcessingParameterVectorLayer(self.INPUT,
self.tr('Input Layer')))
self.addParameter(QgsProcessingParameterField(self.FIELD,
self.tr('Attribute to index'), None, self.INPUT))
self.addOutput(QgsProcessingOutputVectorLayer(self.OUTPUT, self.tr('Indexed layer')))
def initAlgorithm(self, config):
'''
Here we define the inputs and output of the algorithm, along
with some other properties.
'''
self.addParameter(
QgsProcessingParameterVectorLayer(self.NETWORK,
self.tr('Network layer'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(
QgsProcessingParameterVectorLayer(self.TRAJECTORY,
self.tr('Trajectory layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterField(
self.TRAJECTORY_ID,
self.tr('Trajectory ID'),
parentLayerParameterName=self.TRAJECTORY,
type=QgsProcessingParameterField.Any))
self.addParameter(
QgsProcessingParameterCrs(self.CRS,
self.tr('CRS of the Output layer'),
defaultValue='EPSG:4326'))
self.addParameter(
QgsProcessingParameterNumber(
self.MAX_SEARCH_DISTANCE,
self.tr('Maximum Search Distance [m]'),
type=QgsProcessingParameterNumber.Double,
defaultValue=20.0,
minValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(
self.SIGMA,
self.tr('Standard Deviation'),
type=QgsProcessingParameterNumber.Double,
defaultValue=50.0,
minValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(
self.MY,
self.tr('Expected Value'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0,
minValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(
self.BETA,
self.tr('Transition Weight'),
type=QgsProcessingParameterNumber.Double,
defaultValue=30.0,
minValue=0.0))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Matched Trajectory')))
def initAlgorithm(self, config=None):
priWorkDir = os.path.join(os.path.dirname(__file__), '../output/')
self.addParameter(QgsProcessingParameterVectorLayer('acresadded', 'Acres', types=[QgsProcessing.TypeVectorPolygon], defaultValue=None))
self.addParameter(QgsProcessingParameterFeatureSink('Cluster10plus', 'Cluster 10 Plus Acres', type=QgsProcessing.TypeVectorAnyGeometry, createByDefault=True, defaultValue='cluster10Plus.shp'))
self.addParameter(QgsProcessingParameterFeatureSink('Update1', 'First Update - Uncheck', type=QgsProcessing.TypeVectorAnyGeometry, createByDefault=True, defaultValue=None))
def initAlgorithm(self, config=None):
projectPath = os.path.join(QgsProject.instance().homePath())
scriptPath = os.path.dirname(os.path.abspath(__file__))
outputDir = os.path.join(scriptPath, '../output/')
styleDir = os.path.join(scriptPath, '../data/styles/')
style1 = styleDir + "/ImpactTreeMarkUp.qml" # cavityTree_impact.loadNamedStyle(style1),
style2 = styleDir + "/clusterImpactMarkUp.qml" # cluster_impact.loadNamedStyle(style2),
style3 = styleDir + "/qrtImpactMarkUp.qml" # 1_4M_impact.loadNamedStyle(style3),
style4 = styleDir + "/halfImpactMarkUp.qml" # 1_2M_impact.loadNamedStyle(style4),
style5 = styleDir + "/standImpactMarkUp.qml" # stand_impact.loadNamedStyle(style5),
standardDir = os.path.join(scriptPath, '../data/standards/')
self.addParameter(
QgsProcessingParameterVectorLayer(
'cavitytree',
'Cavity Trees',
types=[QgsProcessing.TypeVectorPoint],
defaultValue=None))
self.addParameter(
QgsProcessingParameterVectorLayer(
'clusters',
'Custer 10 Acres Plus',
types=[QgsProcessing.TypeVectorPolygon],
defaultValue=None))
self.addParameter(
QgsProcessingParameterVectorLayer(
'14mpartition',
'1/4Mile Partition',
types=[QgsProcessing.TypeVectorPolygon],
defaultValue=None))
self.addParameter(
QgsProcessingParameterVectorLayer(
'12mpartition',
'1/2Mile Partition',
types=[QgsProcessing.TypeVectorPolygon],
defaultValue=None))
self.addParameter(
QgsProcessingParameterVectorLayer(
'foreststand',
'Stand Prep',
types=[QgsProcessing.TypeVectorPolygon],
defaultValue=None))
self.addParameter(
QgsProcessingParameterVectorLayer(
'impactfeature',
'Impact Feature',
types=[QgsProcessing.TypeVectorPolygon],
defaultValue=None))
self.addParameter(
QgsProcessingParameterFeatureSink(
'cavityTreeImpact',
'Cavity Tree Impact',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue='cavityTree_impact.shp'))
self.addParameter(
QgsProcessingParameterFeatureSink(
'clusterImpact',
'Cluster Impact',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue='cluster_impact.shp'))
self.addParameter(
QgsProcessingParameterFeatureSink(
'14mImpact',
'1/4Mile Impact',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue='qtrImpact.shp'))
self.addParameter(
QgsProcessingParameterFeatureSink(
'12mImpact',
'1/2Mile Impact',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue='halfImpact.shp'))
self.addParameter(
QgsProcessingParameterFeatureSink(
'standImpact',
'Stand Impact',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue='stand_impact.shp'))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT_CONTOUR,
self.tr('Field contour'),
[QgsProcessing.TypeVectorPolygon]
)
)
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT,
self.tr('Raster to zone')
)
)
self.addParameter(
QgsProcessingParameterEnum(
self.INPUT_METHOD,
self.tr('Classification method'),
['Quantiles', ' Equal-intervals', 'K-means']
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.INPUT_N_CLASS,
self.tr('Number of classes'),
QgsProcessingParameterNumber.Integer,
4,
False,
2,
10
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.INPUT_RNEIGHBORS_SIZE,
self.tr('Size of modal filter'),
QgsProcessingParameterNumber.Double,
3
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.INPUT_MIN_AREA,
self.tr('Minimum areas of zones'),
QgsProcessingParameterNumber.Double,
250
)
)
self.addParameter(
QgsProcessingParameterEnum(
self.INPUT_METHOD_GENERALIZE,
self.tr('Smoothing method'),
['Douglas', 'Douglas Reduction', 'Snakes'] #0,1,10
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.INPUT_ALPHA,
self.tr('alpha (for Snakes method)'),
QgsProcessingParameterNumber.Double,
1
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.INPUT_BETA,
self.tr('beta (for Snakes method)'),
QgsProcessingParameterNumber.Double,
1
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.INPUT_MAX_TOLERANCE,
self.tr('Maximum tolerance value'),
QgsProcessingParameterNumber.Double,
1
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.INPUT_LOOK_AHEAD,
self.tr('Look ahead parameter'),
QgsProcessingParameterNumber.Double,
7
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.INPUT_REDUCTION,
self.tr('Reduction (for Douglas reduction method)'),
QgsProcessingParameterNumber.Double,
50
)
)
self.addParameter(
QgsProcessingParameterVectorDestination(
self.OUTPUT,
self.tr('Within-field zones')
)
)
def initAlgorithm(self, config=None):
"""Here we define the inputs and output of the algorithm, along
with some other properties.
"""
# The parameters
description = self.tr(
'Source value expression. Use <code>COALESCE("field_name", 0)</code> to treat <code>NULL</code> values as 0.'
)
self.addParameter(
QgsProcessingParameterExpression(
self.VALUE_EXPRESSION,
description=description,
parentLayerParameterName=self.REACH_LAYER))
description = self.tr('Branch behavior')
self.addParameter(
QgsProcessingParameterEnum(self.BRANCH_BEHAVIOR,
description=description,
options=[
self.tr('Minimum'),
self.tr('Maximum'),
self.tr('Average')
]))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Summed up')))
description = self.tr('Create a layer with nodes in loops')
self.addAdvancedParameter(
QgsProcessingParameterBoolean(self.CREATE_LOOP_LAYER,
description=description,
defaultValue=False))
self.addAdvancedParameter(
QgsProcessingParameterFeatureSink(
self.LOOP_OUTPUT,
self.
tr('Loop nodes (Only created if "Crate a layer with nodes in loops" option is activated)'
),
optional=True))
description = self.tr('Reach Layer')
self.addAdvancedParameter(
QgsProcessingParameterVectorLayer(
self.REACH_LAYER,
description=description,
types=[QgsProcessing.TypeVectorLine],
defaultValue='vw_qgep_reach'))
description = self.tr('Wastewater Node Layer')
self.addAdvancedParameter(
QgsProcessingParameterVectorLayer(
self.WASTEWATER_NODE_LAYER,
description=description,
types=[QgsProcessing.TypeVector],
defaultValue='vw_wastewater_node'))
description = self.tr('Primary Key Field Reach')
self.addAdvancedParameter(
QgsProcessingParameterField(
self.REACH_PK_NAME,
description=description,
parentLayerParameterName=self.REACH_LAYER,
defaultValue='obj_id'))
description = self.tr('Primary Key Field Node')
self.addAdvancedParameter(
QgsProcessingParameterField(
self.NODE_PK_NAME,
description=description,
parentLayerParameterName=self.WASTEWATER_NODE_LAYER,
defaultValue='obj_id'))
description = self.tr('Foreign Key Field From')
self.addAdvancedParameter(
QgsProcessingParameterField(
self.NODE_FROM_FK_NAME,
description=description,
parentLayerParameterName=self.REACH_LAYER,
defaultValue='rp_from_fk_wastewater_networkelement'))
description = self.tr('Foreign Key Field To')
self.addAdvancedParameter(
QgsProcessingParameterField(
self.NODE_TO_FK_NAME,
description=description,
parentLayerParameterName=self.REACH_LAYER,
defaultValue='rp_to_fk_wastewater_networkelement'))
def initAlgorithm(self, config=None):
# The name that the user will see in the toolbox
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT_RASTER,
self.tr('Input raster')))
# Train algorithm
self.addParameter(
QgsProcessingParameterEnum(self.TRAIN, "Select algorithm to train",
self.TRAIN_ALGORITHMS, 0))
# ROI
# VECTOR
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT_LAYER,
'Input layer',
))
# TABLE / COLUMN
self.addParameter(
QgsProcessingParameterField(
self.INPUT_COLUMN,
'Field (column must have classification number (e.g. \'1\' forest, \'2\' water...))',
parentLayerParameterName=self.INPUT_LAYER,
optional=False)) # save model
# DISTANCE
self.addParameter(
QgsProcessingParameterNumber(
self.DISTANCE,
self.tr('Distance in pixels'),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
maxValue=99999,
defaultValue=100))
# MAX ITER
self.addParameter(
QgsProcessingParameterNumber(
self.MAXITER,
self.
tr('Maximum iteration (default : 0 e.g. class with min effective)'
),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
maxValue=99999,
defaultValue=0))
#
self.addParameter(
QgsProcessingParameterString(
self.PARAMGRID,
self.tr('Parameters for the hyperparameters of the algorithm'),
optional=True))
# SAVE AS
# SAVE MODEL
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_MODEL,
self.tr("Output model (to use for classifying)")))
"""
# SAVE CONFUSION MATRIX
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_MATRIX,
self.tr("Output confusion matrix"),
fileFilter='csv'))#,
#ext='csv'))
"""
# SAVE DIR
self.addParameter(
QgsProcessingParameterFolderDestination(
self.SAVEDIR,
self.tr("Directory to save every confusion matrix")))
def initAlgorithm(self, config=None):
# Call function to look for precalculated values in layer "Bounding Geometry"
self.look_for_precalculated_values()
self.addParameter(
QgsProcessingParameterVectorLayer(
'sites',
'LEC',
types=[QgsProcessing.TypeVectorPoint],
defaultValue=None))
self.addParameter(
QgsProcessingParameterField(
'hubdistlecradii',
'HubDist_LEC_Radii',
type=QgsProcessingParameterField.Numeric,
parentLayerParameterName='sites',
allowMultiple=False,
defaultValue='HubDist'))
self.addParameter(
QgsProcessingParameterNumber(
'gridcellsize',
'Grid_Cellsize',
type=QgsProcessingParameterNumber.Integer,
defaultValue=1000))
self.addParameter(
QgsProcessingParameterExpression(
'formel',
'Formel',
parentLayerParameterName='',
defaultValue=self.formula_default))
self.addParameter(
QgsProcessingParameterNumber(
'lagdist',
'LagDist',
type=QgsProcessingParameterNumber.Double,
defaultValue=self.lag_dist_default))
self.addParameter(
QgsProcessingParameterBoolean('BlockKriging',
'Block_Kriging',
defaultValue=True))
self.addParameter(
QgsProcessingParameterNumber(
'blocksize',
'Block_Size',
type=QgsProcessingParameterNumber.Integer,
defaultValue=100))
self.addParameter(
QgsProcessingParameterNumber(
'maxsearchdist',
'Max_Search_Dist',
type=QgsProcessingParameterNumber.Integer,
defaultValue=self.max_search_dist_default))
self.addParameter(
QgsProcessingParameterNumber(
'numberofptsmin',
'Number_of_Pts_Min',
type=QgsProcessingParameterNumber.Integer,
defaultValue=3))
self.addParameter(
QgsProcessingParameterNumber(
'numberofptsmax',
'Number_of_Pts_Max',
type=QgsProcessingParameterNumber.Integer,
defaultValue=10))
self.addParameter(
QgsProcessingParameterRasterDestination(
'Kriging_raster',
'Kriging_Raster',
createByDefault=True,
defaultValue="Kriging.sdat"))
self.addParameter(
QgsProcessingParameterRasterDestination(
'Quality_measure',
'Quality_Measure',
optional=True,
createByDefault=False,
defaultValue="Variance.sdat"))
def initAlgorithm(self, config):
"""
Parameter setting.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT_CENTER_POINTS,
self.tr('Center Point Layer'),
[QgsProcessing.TypeVectorPoint]
)
)
self.addParameter(
QgsProcessingParameterBoolean(
self.SELECTED,
self.tr('Process only selected features')
)
)
self.addParameter(
QgsProcessingParameterField(
self.ATTRIBUTE_BLACK_LIST,
self.tr('Fields to ignore'),
None,
'INPUT_CENTER_POINTS',
QgsProcessingParameterField.Any,
allowMultiple=True,
optional = True
)
)
self.addParameter(
QgsProcessingParameterMultipleLayers(
self.CONSTRAINT_LINE_LAYERS,
self.tr('Line Constraint Layers'),
QgsProcessing.TypeVectorLine,
optional=True
)
)
self.addParameter(
QgsProcessingParameterMultipleLayers(
self.CONSTRAINT_POLYGON_LAYERS,
self.tr('Polygon Constraint Layers'),
QgsProcessing.TypeVectorPolygon,
optional=True
)
)
self.addParameter(
QgsProcessingParameterVectorLayer(
self.GEOGRAPHIC_BOUNDARY,
self.tr('Geographic Boundary'),
[QgsProcessing.TypeVectorPolygon],
optional=True
)
)
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_POLYGONS,
self.tr('Output Polygons')
)
)
self.addParameter(
QgsProcessingParameterFeatureSink(
self.FLAGS,
self.tr('{0} Flags').format(self.displayName())
)
)
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterVectorLayer(
self.INPUT, 'Input layer'))
self.addParameter(QgsProcessingParameterField(
self.FIELD, 'Element field', defaultValue='ELEMENT', parentLayerParameterName=self.INPUT))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterVectorLayer(self.DATABASE, self.tr('File Database'), [], False, False))
self.addParameter(QgsProcessingParameterString(self.SQL, self.tr('SQL query'), '', True))
def initAlgorithm(self, config):
for par in self.param:
pl = par.split('|')
if pl[0] == 'ParameterRaster':
self.addParameter(
QgsProcessingParameterRasterLayer(pl[1],
self.tr(pl[2]), '',
bool(strtobool(pl[3]))))
if pl[0] == 'ParameterVector':
self.addParameter(
QgsProcessingParameterVectorLayer(pl[1], self.tr(
pl[2]), [QgsProcessing.TypeVector], '',
bool(strtobool(pl[4]))))
if pl[0] == 'ParameterNumber':
try:
int(pl[5])
if pl[4] != 'None':
self.addParameter(
QgsProcessingParameterNumber(
pl[1], self.tr(pl[2]), 0, int(pl[5]), False,
int(pl[3]), int(pl[4])))
else:
self.addParameter(
QgsProcessingParameterNumber(
pl[1], self.tr(pl[2]), 0, int(pl[5]), False,
int(pl[3])))
except ValueError:
if pl[4] != 'None':
self.addParameter(
QgsProcessingParameterNumber(
pl[1], self.tr(pl[2]), 1, float(pl[5]), False,
float(pl[3]), float(pl[4])))
else:
self.addParameter(
QgsProcessingParameterNumber(
pl[1], self.tr(pl[2]), 1, float(pl[5]), False,
float(pl[3])))
if pl[0] == 'ParameterBoolean':
self.addParameter(
QgsProcessingParameterBoolean(pl[1], self.tr(pl[2]),
bool(strtobool(pl[3])),
False))
if pl[0] == 'ParameterEnum':
self.addParameter(
QgsProcessingParameterEnum(pl[1], self.tr(pl[2]),
literal_eval(pl[3]), False,
pl[4], False))
for out in self.outputline:
ol = out.split('|')
if ol[0] == 'OutputRaster':
self.addParameter(
QgsProcessingParameterRasterDestination(
ol[1][1:], self.tr(ol[2])))
if ol[0] == 'OutputVector':
self.addParameter(
QgsProcessingParameterVectorDestination(
ol[1][1:], self.tr(ol[2])))
if ol[0] == 'OutputFile':
self.addParameter(
QgsProcessingParameterFileDestination(
ol[1][1:], self.tr(ol[2])))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterVectorLayer(self.DATABASE, self.tr('File Database'), optional=False))
self.addParameter(QgsProcessingParameterString(self.SQL, self.tr('SQL query'), multiLine=True))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT,
QCoreApplication.translate("AppendFeaturesToLayer",
'Source layer'),
[QgsProcessing.TypeVector]))
self.addParameter(
QgsProcessingParameterField(self.INPUT_FIELD,
QCoreApplication.translate(
"AppendFeaturesToLayer",
'Source field to compare'),
None,
self.INPUT,
optional=True))
self.addParameter(
QgsProcessingParameterVectorLayer(
self.OUTPUT,
QCoreApplication.translate("AppendFeaturesToLayer",
'Target layer'),
[QgsProcessing.TypeVector]))
self.addParameter(
QgsProcessingParameterField(self.OUTPUT_FIELD,
QCoreApplication.translate(
"AppendFeaturesToLayer",
'Target field to compare'),
None,
self.OUTPUT,
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.ACTION_ON_DUPLICATE,
QCoreApplication.translate("AppendFeaturesToLayer",
'Action for duplicate features'),
[
self.NO_ACTION_TEXT, self.SKIP_FEATURE_TEXT,
self.UPDATE_EXISTING_FEATURE_TEXT
],
False,
self.NO_ACTION_TEXT,
optional=False))
self.addOutput(
QgsProcessingOutputVectorLayer(
self.OUTPUT,
QCoreApplication.translate(
"AppendFeaturesToLayer",
"Target layer to paste new features")))
self.addOutput(
QgsProcessingOutputNumber(
self.APPENDED_COUNT,
QCoreApplication.translate("AppendFeaturesToLayer",
"Number of features appended")))
self.addOutput(
QgsProcessingOutputNumber(
self.UPDATED_COUNT,
QCoreApplication.translate("AppendFeaturesToLayer",
"Number of features updated")))
self.addOutput(
QgsProcessingOutputNumber(
self.SKIPPED_COUNT,
QCoreApplication.translate("AppendFeaturesToLayer",
"Number of features skipped")))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterVectorLayer(self.INPUT,
self.tr('Input Layer'),
[QgsProcessing.TypeVectorPolygon, QgsProcessing.TypeVectorPoint, QgsProcessing.TypeVectorLine]))
self.addOutput(QgsProcessingOutputVectorLayer(self.OUTPUT, self.tr('Indexed layer')))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterFile(self.INPUT, 'CSVファイル', extension='csv'))
# encoding of input file
#encParam = QgsProcessingParameterEnum(
# self.ENCODING,
# 'CSVファイルエンコーディング'
# )
#encParam.setOptions(self.encode)
#encParam.setAllowMultiple(False)
#encParam.setDefaultValue(QVariant('SJIS'))
# file encoding
#self.addParameter(
# encParam
#)
self.addParameter(
QgsProcessingParameterEnum('ENCODING',
'CSVファイルエンコーディング',
options=['SJIS', 'UTF-8'],
allowMultiple=False,
defaultValue='SJIS'))
self.addParameter(
QgsProcessingParameterVectorLayer(
'addresslayer',
'住所レイヤ',
types=[QgsProcessing.TypeVectorPolygon],
defaultValue=None))
self.addParameter(
QgsProcessingParameterField(
'addressfield',
'住所フィールド',
type=QgsProcessingParameterField.String,
parentLayerParameterName='addresslayer',
allowMultiple=False,
defaultValue=None))
self.addParameter(
QgsProcessingParameterVectorLayer(
'meshlayer',
'メッシュレイヤ',
types=[QgsProcessing.TypeVectorPolygon],
optional=False,
defaultValue=None))
self.addParameter(
QgsProcessingParameterField(
'meshid',
'メッシュIDフィールド',
type=QgsProcessingParameterField.String,
parentLayerParameterName='meshlayer',
optional=False,
allowMultiple=False))
self.addParameter(
QgsProcessingParameterNumber('limit_sample',
'最小サンプル数',
defaultValue=3))
self.addParameter(
QgsProcessingParameterNumber('maxdivide', '最大分割回数',
defaultValue=4))
self.addParameter(
QgsProcessingParameterBoolean('uneven_div',
'不均等分割',
defaultValue=False))
# propotinal division method
#propParam = QgsProcessingParameterEnum(
# "PROPDIV",
# self.tr('按分方法選択')
# )
#propParam.setOptions(self.proportional_div)
#propParam.setAllowMultiple(False)
#propParam.setDefaultValue(QVariant('人口'))
# file encoding
#self.addParameter(
# propParam
#)
#self.addParameter(QgsProcessingParameterVectorLayer('poplayer', '人口レイヤ',
# types=[QgsProcessing.TypeVectorPolygon], optional=True, defaultValue=None))
#self.addParameter(QgsProcessingParameterField('popfield', '人口フィールド',
# type=QgsProcessingParameterField.String, parentLayerParameterName='addresslayer', optional=True, allowMultiple=False, defaultValue=None))
# 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(
QgsProcessingParameterCrs('CRS', "出力ファイル座標系", optional=True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Output layer')))
def initAlgorithm(self, config):
# INPUTS
# Base de destination
db_param = QgsProcessingParameterString(
self.DATABASE, tr("Connexion à la base de données"))
db_param.setMetadata({
"widget_wrapper": {
"class":
"processing.gui.wrappers_postgis.ConnectionWidgetWrapper"
}
})
db_param.tooltip_3liz = 'Nom de la connexion dans QGIS pour se connecter à la base de données'
self.addParameter(db_param)
# Schema de destination
schema_param = QgsProcessingParameterString(self.SCHEMA, tr("Schéma"),
"veloroutes", False, False)
schema_param.setMetadata({
"widget_wrapper": {
"class": "processing.gui.wrappers_postgis.SchemaWidgetWrapper",
"connection_param": self.DATABASE,
}
})
schema_param.tooltip_3liz = 'Nom du schéma où importer les données'
self.addParameter(schema_param)
# Table de destination
table_param = QgsProcessingParameterString(self.TABLE,
tr("Table de destination"),
'portion', False)
table_param.setMetadata({
"widget_wrapper": {
"class": "processing.gui.wrappers_postgis.TableWidgetWrapper",
"schema_param": self.SCHEMA
}
})
# table_param.tooltip_3liz = 'Table de destination'
self.addParameter(table_param)
# Couche à importer
couche = QgsProcessingParameterVectorLayer(
self.INPUT,
'Couche à importer',
types=[QgsProcessing.TypeVector],
)
self.addParameter(couche)
# Paramètre pour le mapping de champs
table = QgsProcessingParameterMatrix(
self.MATRIX,
'matrix',
headers=['Champs source', 'Champs destination'],
defaultValue=[
"TYPE_PORTION_COVADIS", "type_portion", "MONTANT_SUBVENTION",
"mont_subv", "ANNE_SUBVENTION", "annee_subv", "fid",
"id_import", "LIEN_ITIN", "lien_itin", "LIEN_CYCLO",
"lien_segm"
])
self.addParameter(table)
# OUTPUTS
self.addOutput(
QgsProcessingOutputString(self.OUTPUT_MSG,
tr("Message de sortie")))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterVectorLayer(self.INPUT, self.tr('Input layer')))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Selection')))
def okPressed(self):
description = str(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
== ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN
or isinstance(self.param, QgsProcessingParameterBoolean)):
self.param = QgsProcessingParameterBoolean(name, description,
self.state.isChecked())
elif (self.paramType
== ModelerParameterDefinitionDialog.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()
self.param = QgsProcessingParameterField(
name, description, None, parent, datatype,
self.multipleCheck.isChecked())
elif (self.paramType == ModelerParameterDefinitionDialog.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
== ModelerParameterDefinitionDialog.PARAMETER_RASTER
or isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(name, description)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_TABLE
or isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(name, description)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentIndex() - 1])
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description,
self.datatypeCombo.currentIndex() - 1)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_NUMBER
or isinstance(self.param, QgsProcessingParameterNumber)):
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
== ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(
name, description, str(self.defaultEdit.expression()), parent)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
self.param = QgsProcessingParameterString(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXTENT
or isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.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
== ModelerParameterDefinitionDialog.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.param = QgsProcessingParameterPoint(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.param = QgsProcessingParameterCrs(
name, description,
self.selector.crs().authid())
if not self.requiredCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagOptional)
self.close()
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterExpression('dbconnectionnameexpression', 'DB connection name', parentLayerParameterName='', defaultValue=' @dominode_db_connection_name '))
self.addParameter(QgsProcessingParameterVectorLayer('inputlayer', 'Input layer', types=[QgsProcessing.TypeVectorAnyGeometry], defaultValue=None))
self.addParameter(QgsProcessingParameterString('layername', 'output table name', multiLine=False, defaultValue=''))
self.addParameter(QgsProcessingParameterBoolean('VERBOSE_LOG', 'Verbose logging', optional=True, defaultValue=False))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterVectorLayer(self.INPUT,
self.tr('Input Layer')))
self.addOutput(QgsProcessingOutputVectorLayer(self.OUTPUT, self.tr('Truncated layer')))
def initAlgorithm(self, config):
"""
Parameter setting.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(self.NETWORK_LAYER,
self.tr('Network layer'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(
QgsProcessingParameterField(self.ATTRIBUTE_BLACK_LIST,
self.tr('Fields to ignore'),
None,
'NETWORK_LAYER',
QgsProcessingParameterField.Any,
allowMultiple=True,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(self.IGNORE_VIRTUAL_FIELDS,
self.tr('Ignore virtual fields'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(self.IGNORE_PK_FIELDS,
self.tr('Ignore primary key fields'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterVectorLayer(self.NODE_LAYER,
self.tr('Node layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterVectorLayer(
self.REF_LAYER, self.tr('Reference layer'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(
QgsProcessingParameterVectorLayer(self.SINK_LAYER,
self.tr('Water sink layer'),
[QgsProcessing.TypeVectorPoint],
optional=True))
self.addParameter(
QgsProcessingParameterVectorLayer(self.SPILLWAY_LAYER,
self.tr('Spillway layer'),
[QgsProcessing.TypeVectorPoint],
optional=True))
self.addParameter(
QgsProcessingParameterMultipleLayers(
self.WATER_BODY_LAYERS,
self.tr('Water body layers'),
QgsProcessing.TypeVectorPolygon,
optional=True))
self.addParameter(
QgsProcessingParameterVectorLayer(self.DITCH_LAYER,
self.tr('Ditch layer'),
[QgsProcessing.TypeVectorLine],
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.MAX_CYCLES,
self.tr('Maximum cycles'),
minValue=1,
defaultValue=2,
type=QgsProcessingParameterNumber.Integer))
self.addParameter(
QgsProcessingParameterNumber(
self.SEARCH_RADIUS,
self.tr('Search radius'),
minValue=0,
defaultValue=1,
type=QgsProcessingParameterNumber.Double))
self.addParameter(
QgsProcessingParameterBoolean(
self.SELECT_ALL_VALID,
self.tr('Select all valid lines after the process')))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.FLAGS,
self.tr('{0} network node errors').format(self.displayName())))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.LINE_FLAGS,
self.tr('{0} line errors').format(self.displayName())))
