def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(QgsProcessingParameterBand(self.BAND,
self.tr('Band number'),
1,
parentLayerParameterName=self.INPUT))
self.addParameter(QgsProcessingParameterNumber(self.INTERVAL,
self.tr('Interval between contour lines'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=10.0))
self.addParameter(QgsProcessingParameterString(self.FIELD_NAME,
self.tr('Attribute name (if not set, no elevation attribute is attached)'),
defaultValue='ELEV',
optional=True))
create_3d_param = QgsProcessingParameterBoolean(self.CREATE_3D,
self.tr('Produce 3D vector'),
defaultValue=False)
create_3d_param.setFlags(create_3d_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(create_3d_param)
ignore_nodata_param = QgsProcessingParameterBoolean(self.IGNORE_NODATA,
self.tr('Treat all raster values as valid'),
defaultValue=False)
ignore_nodata_param.setFlags(ignore_nodata_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(ignore_nodata_param)
nodata_param = QgsProcessingParameterNumber(self.NODATA,
self.tr('Input pixel value to treat as "nodata"'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True)
nodata_param.setFlags(nodata_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(nodata_param)
offset_param = QgsProcessingParameterNumber(self.OFFSET,
self.tr('Offset from zero relative to which to interpret intervals'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0,
optional=True)
nodata_param.setFlags(offset_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(offset_param)
options_param = QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(options_param)
self.addParameter(QgsProcessingParameterVectorDestination(
self.OUTPUT, self.tr('Contours'), QgsProcessing.TypeVectorLine))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(QgsProcessingParameterFeatureSource(self.MASK,
self.tr('Mask layer'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(QgsProcessingParameterNumber(self.NODATA,
self.tr('Assign a specified nodata value to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
self.addParameter(QgsProcessingParameterBoolean(self.ALPHA_BAND,
self.tr('Create an output alpha band'),
defaultValue=False))
self.addParameter(QgsProcessingParameterBoolean(self.CROP_TO_CUTLINE,
self.tr('Match the extent of the clipped raster to the extent of the mask layer'),
defaultValue=True))
self.addParameter(QgsProcessingParameterBoolean(self.KEEP_RESOLUTION,
self.tr('Keep resolution of output raster'),
defaultValue=False))
target_extent_param = QgsProcessingParameterExtent(self.TARGET_EXTENT,
self.tr('Georeferenced extents of output file to be created'),
optional=True)
target_extent_param.setFlags(target_extent_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(target_extent_param)
target_extent_crs_param = QgsProcessingParameterCrs(self.TARGET_EXTENT_CRS,
self.tr('CRS of the target raster extent'),
optional=True)
target_extent_crs_param.setFlags(target_extent_crs_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(target_extent_crs_param)
multithreading_param = QgsProcessingParameterBoolean(self.MULTITHREADING,
self.tr('Use multithreaded warping implementation'),
defaultValue=False)
multithreading_param.setFlags(multithreading_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(multithreading_param)
options_param = QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
self.addParameter(options_param)
dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=0)
dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(dataType_param)
self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Clipped (mask)')))
def initAlgorithm(self, config=None):
class ParameterVrtDestination(QgsProcessingParameterRasterDestination):
def __init__(self, name, description):
super().__init__(name, description)
def clone(self):
copy = ParameterVrtDestination(self.name(), self.description())
return copy
def type(self):
return 'vrt_destination'
def defaultFileExtension(self):
return 'vrt'
self.addParameter(QgsProcessingParameterMultipleLayers(self.INPUT,
self.tr('Input layers'),
QgsProcessing.TypeRaster))
self.addParameter(QgsProcessingParameterEnum(self.RESOLUTION,
self.tr('Resolution'),
options=self.RESOLUTION_OPTIONS,
defaultValue=0))
self.addParameter(QgsProcessingParameterBoolean(self.SEPARATE,
self.tr('Place each input file into a separate band'),
defaultValue=True))
self.addParameter(QgsProcessingParameterBoolean(self.PROJ_DIFFERENCE,
self.tr('Allow projection difference'),
defaultValue=False))
add_alpha_param = QgsProcessingParameterBoolean(self.ADD_ALPHA,
self.tr('Add alpha mask band to VRT when source raster has none'),
defaultValue=False)
add_alpha_param.setFlags(add_alpha_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(add_alpha_param)
assign_crs = QgsProcessingParameterCrs(self.ASSIGN_CRS,
self.tr('Override projection for the output file'),
defaultValue=None, optional=True)
assign_crs.setFlags(assign_crs.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(assign_crs)
resampling = QgsProcessingParameterEnum(self.RESAMPLING,
self.tr('Resampling algorithm'),
options=self.RESAMPLING_OPTIONS,
defaultValue=0)
resampling.setFlags(resampling.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(resampling)
src_nodata_param = QgsProcessingParameterString(self.SRC_NODATA,
self.tr('Nodata value(s) for input bands (space separated)'),
defaultValue=None,
optional=True)
src_nodata_param.setFlags(src_nodata_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(src_nodata_param)
self.addParameter(ParameterVrtDestination(self.OUTPUT, QCoreApplication.translate("ParameterVrtDestination", 'Virtual')))
def initAlgorithm(self, config=None):
self.units = [self.tr("Pixels"),
self.tr("Georeferenced units")]
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(QgsProcessingParameterField(self.FIELD,
self.tr('Field to use for a burn-in value'),
None,
self.INPUT,
QgsProcessingParameterField.Numeric,
optional=True))
self.addParameter(QgsProcessingParameterNumber(self.BURN,
self.tr('A fixed value to burn'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0,
optional=True))
self.addParameter(QgsProcessingParameterEnum(self.UNITS,
self.tr('Output raster size units'),
self.units))
self.addParameter(QgsProcessingParameterNumber(self.WIDTH,
self.tr('Width/Horizontal resolution'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=0.0))
self.addParameter(QgsProcessingParameterNumber(self.HEIGHT,
self.tr('Height/Vertical resolution'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=0.0))
self.addParameter(QgsProcessingParameterExtent(self.EXTENT,
self.tr('Output extent')))
self.addParameter(QgsProcessingParameterNumber(self.NODATA,
self.tr('Assign a specified nodata value to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0,
optional=True))
options_param = QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation parameters'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
self.addParameter(options_param)
dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=5)
dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(dataType_param)
init_param = QgsProcessingParameterNumber(self.INIT,
self.tr('Pre-initialize the output image with value'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0,
optional=True)
init_param.setFlags(init_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(init_param)
invert_param = QgsProcessingParameterBoolean(self.INVERT,
self.tr('Invert rasterization'),
defaultValue=False)
invert_param.setFlags(invert_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(invert_param)
self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Rasterized')))
def initAlgorithm(self, config=None):
self.methods = ((self.tr('Nearest neighbour'), 'near'),
(self.tr('Bilinear'), 'bilinear'),
(self.tr('Cubic'), 'cubic'),
(self.tr('Cubic spline'), 'cubicspline'),
(self.tr('Lanczos windowed sinc'), 'lanczos'),
(self.tr('Average'), 'average'),
(self.tr('Mode'), 'mode'),
(self.tr('Maximum'), 'max'),
(self.tr('Minimum'), 'min'),
(self.tr('Median'), 'med'),
(self.tr('First quartile'), 'q1'),
(self.tr('Third quartile'), 'q3'))
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer')))
self.addParameter(QgsProcessingParameterCrs(self.SOURCE_CRS,
self.tr('Source CRS'),
optional=True))
self.addParameter(QgsProcessingParameterCrs(self.TARGET_CRS,
self.tr('Target CRS'),
'EPSG:4326'))
self.addParameter(QgsProcessingParameterNumber(self.NODATA,
self.tr('Nodata value for output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0))
self.addParameter(QgsProcessingParameterNumber(self.TARGET_RESOLUTION,
self.tr('Output file resolution in target georeferenced units'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=None))
options_param = QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation parameters'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
self.addParameter(options_param)
self.addParameter(QgsProcessingParameterEnum(self.RESAMPLING,
self.tr('Resampling method to use'),
options=[i[0] for i in self.methods],
defaultValue=0))
dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=5)
dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(dataType_param)
target_extent_param = QgsProcessingParameterExtent(self.TARGET_EXTENT,
self.tr('Georeferenced extents of output file to be created'),
optional=True)
target_extent_param.setFlags(target_extent_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(target_extent_param)
target_extent_crs_param = QgsProcessingParameterCrs(self.TARGET_EXTENT_CRS,
self.tr('CRS of the target raster extent'),
optional=True)
target_extent_crs_param.setFlags(target_extent_crs_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(target_extent_crs_param)
multithreading_param = QgsProcessingParameterBoolean(self.MULTITHREADING,
self.tr('Use multithreaded warping implementation'),
defaultValue=False)
multithreading_param.setFlags(multithreading_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(multithreading_param)
self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Reprojected')))
def initAlgorithm(self, config=None):
self.units = [self.tr("Pixels"),
self.tr("Georeferenced units")]
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(QgsProcessingParameterField(self.FIELD,
self.tr('Field to use for a burn-in value'),
None,
self.INPUT,
QgsProcessingParameterField.Numeric,
optional=True))
self.addParameter(QgsProcessingParameterNumber(self.BURN,
self.tr('A fixed value to burn'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0,
optional=True))
self.addParameter(QgsProcessingParameterEnum(self.UNITS,
self.tr('Output raster size units'),
self.units))
self.addParameter(QgsProcessingParameterNumber(self.WIDTH,
self.tr('Width/Horizontal resolution'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=0.0))
self.addParameter(QgsProcessingParameterNumber(self.HEIGHT,
self.tr('Height/Vertical resolution'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=0.0))
self.addParameter(QgsProcessingParameterExtent(self.EXTENT,
self.tr('Output extent')))
self.addParameter(QgsProcessingParameterNumber(self.NODATA,
self.tr('Assign a specified nodata value to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0,
optional=True))
options_param = QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
self.addParameter(options_param)
dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=5)
dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(dataType_param)
init_param = QgsProcessingParameterNumber(self.INIT,
self.tr('Pre-initialize the output image with value'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0,
optional=True)
init_param.setFlags(init_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(init_param)
invert_param = QgsProcessingParameterBoolean(self.INVERT,
self.tr('Invert rasterization'),
defaultValue=False)
invert_param.setFlags(invert_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(invert_param)
self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Rasterized')))
def initAlgorithm(self, config=None):
class ParameterVrtDestination(QgsProcessingParameterRasterDestination):
def __init__(self, name, description):
super().__init__(name, description)
def clone(self):
copy = ParameterVrtDestination(self.name(), self.description())
return copy
def type(self):
return 'vrt_destination'
def defaultFileExtension(self):
return 'vrt'
self.addParameter(
QgsProcessingParameterMultipleLayers(
self.INPUT,
QCoreApplication.translate("ParameterVrtDestination",
'Input layers'),
QgsProcessing.TypeRaster))
self.addParameter(
QgsProcessingParameterEnum(self.RESOLUTION,
QCoreApplication.translate(
"ParameterVrtDestination",
'Resolution'),
options=self.RESOLUTION_OPTIONS,
defaultValue=0))
self.addParameter(
QgsProcessingParameterBoolean(
self.SEPARATE,
QCoreApplication.translate(
"ParameterVrtDestination",
'Place each input file into a separate band'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(self.PROJ_DIFFERENCE,
QCoreApplication.translate(
"ParameterVrtDestination",
'Allow projection difference'),
defaultValue=False))
add_alpha_param = QgsProcessingParameterBoolean(
self.ADD_ALPHA,
QCoreApplication.translate(
"ParameterVrtDestination",
'Add alpha mask band to VRT when source raster has none'),
defaultValue=False)
add_alpha_param.setFlags(
add_alpha_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(add_alpha_param)
assign_crs = QgsProcessingParameterCrs(
self.ASSIGN_CRS,
QCoreApplication.translate(
"ParameterVrtDestination",
'Override projection for the output file'),
defaultValue=None,
optional=True)
assign_crs.setFlags(assign_crs.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(assign_crs)
resampling = QgsProcessingParameterEnum(
self.RESAMPLING,
QCoreApplication.translate("ParameterVrtDestination",
'Resampling algorithm'),
options=self.RESAMPLING_OPTIONS,
defaultValue=0)
resampling.setFlags(resampling.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(resampling)
self.addParameter(
ParameterVrtDestination(
self.OUTPUT,
QCoreApplication.translate("ParameterVrtDestination",
'Virtual')))
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):
class ParameterVrtDestination(QgsProcessingParameterRasterDestination):
def __init__(self, name, description):
super().__init__(name, description)
def clone(self):
copy = ParameterVrtDestination(self.name(), self.description())
return copy
def type(self):
return 'vrt_destination'
def defaultFileExtension(self):
return 'vrt'
def parameterAsOutputLayer(self, definition, value, context):
return super(QgsProcessingParameterRasterDestination, self).parameterAsOutputLayer(definition, value, context)
self.RESAMPLING_OPTIONS = ((self.tr('Nearest Neighbour'), 'nearest'),
(self.tr('Bilinear'), 'bilinear'),
(self.tr('Cubic Convolution'), 'cubic'),
(self.tr('B-Spline Convolution'), 'cubicspline'),
(self.tr('Lanczos Windowed Sinc'), 'lanczos'),
(self.tr('Average'), 'average'),
(self.tr('Mode'), 'mode'))
self.RESOLUTION_OPTIONS = ((self.tr('Average'), 'average'),
(self.tr('Highest'), 'highest'),
(self.tr('Lowest'), 'lowest'))
self.addParameter(QgsProcessingParameterMultipleLayers(self.INPUT,
self.tr('Input layers'),
QgsProcessing.TypeRaster))
self.addParameter(QgsProcessingParameterEnum(self.RESOLUTION,
self.tr('Resolution'),
options=[i[0] for i in self.RESOLUTION_OPTIONS],
defaultValue=0))
self.addParameter(QgsProcessingParameterBoolean(self.SEPARATE,
self.tr('Place each input file into a separate band'),
defaultValue=True))
self.addParameter(QgsProcessingParameterBoolean(self.PROJ_DIFFERENCE,
self.tr('Allow projection difference'),
defaultValue=False))
add_alpha_param = QgsProcessingParameterBoolean(self.ADD_ALPHA,
self.tr('Add alpha mask band to VRT when source raster has none'),
defaultValue=False)
add_alpha_param.setFlags(add_alpha_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(add_alpha_param)
assign_crs = QgsProcessingParameterCrs(self.ASSIGN_CRS,
self.tr('Override projection for the output file'),
defaultValue=None, optional=True)
assign_crs.setFlags(assign_crs.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(assign_crs)
resampling = QgsProcessingParameterEnum(self.RESAMPLING,
self.tr('Resampling algorithm'),
options=[i[0] for i in self.RESAMPLING_OPTIONS],
defaultValue=0)
resampling.setFlags(resampling.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(resampling)
src_nodata_param = QgsProcessingParameterString(self.SRC_NODATA,
self.tr('Nodata value(s) for input bands (space separated)'),
defaultValue=None,
optional=True)
src_nodata_param.setFlags(src_nodata_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(src_nodata_param)
extra_param = QgsProcessingParameterString(self.EXTRA,
self.tr('Additional command-line parameters'),
defaultValue=None,
optional=True)
extra_param.setFlags(extra_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(extra_param)
self.addParameter(ParameterVrtDestination(self.OUTPUT, QCoreApplication.translate("ParameterVrtDestination", 'Virtual')))
def initAlgorithm(self, config=None):
self.TYPES = [self.tr('Use Input Layer Data Type'), 'Byte', 'Int16', 'UInt16', 'UInt32', 'Int32', 'Float32', 'Float64', 'CInt16', 'CInt32', 'CFloat32', 'CFloat64']
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(QgsProcessingParameterFeatureSource(self.MASK,
self.tr('Mask layer'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(QgsProcessingParameterCrs(self.SOURCE_CRS,
self.tr('Source CRS'),
optional=True))
self.addParameter(QgsProcessingParameterCrs(self.TARGET_CRS,
self.tr('Target CRS'),
optional=True))
self.addParameter(QgsProcessingParameterExtent(self.EXTENT,
self.tr('Target extent'),
optional=True))
self.addParameter(QgsProcessingParameterNumber(self.NODATA,
self.tr('Assign a specified nodata value to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
self.addParameter(QgsProcessingParameterBoolean(self.ALPHA_BAND,
self.tr('Create an output alpha band'),
defaultValue=False))
self.addParameter(QgsProcessingParameterBoolean(self.CROP_TO_CUTLINE,
self.tr('Match the extent of the clipped raster to the extent of the mask layer'),
defaultValue=True))
self.addParameter(QgsProcessingParameterBoolean(self.KEEP_RESOLUTION,
self.tr('Keep resolution of input raster'),
defaultValue=False))
self.addParameter(QgsProcessingParameterBoolean(self.SET_RESOLUTION,
self.tr('Set output file resolution'),
defaultValue=False))
self.addParameter(QgsProcessingParameterNumber(self.X_RESOLUTION,
self.tr('X Resolution to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
self.addParameter(QgsProcessingParameterNumber(self.Y_RESOLUTION,
self.tr('Y Resolution to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
multithreading_param = QgsProcessingParameterBoolean(self.MULTITHREADING,
self.tr('Use multithreaded warping implementation'),
defaultValue=False)
multithreading_param.setFlags(multithreading_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(multithreading_param)
options_param = QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
self.addParameter(options_param)
dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=0)
dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(dataType_param)
extra_param = QgsProcessingParameterString(self.EXTRA,
self.tr('Additional command-line parameters'),
defaultValue=None,
optional=True)
extra_param.setFlags(extra_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(extra_param)
self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Clipped (mask)')))
def initAlgorithm(self, config=None):
class ParameterVrtDestination(QgsProcessingParameterRasterDestination):
def __init__(self, name, description):
super().__init__(name, description)
def clone(self):
copy = ParameterVrtDestination(self.name(), self.description())
return copy
def defaultFileExtension(self):
return 'vrt'
def createFileFilter(self):
return '{} (*.vrt *.VRT)'.format(
QCoreApplication.translate("GdalAlgorithm", 'VRT files'))
def supportedOutputRasterLayerExtensions(self):
return ['vrt']
def parameterAsOutputLayer(self, definition, value, context):
return super(QgsProcessingParameterRasterDestination,
self).parameterAsOutputLayer(
definition, value, context)
def isSupportedOutputValue(self, value, context):
output_path = QgsProcessingParameters.parameterAsOutputLayer(
self, value, context)
if pathlib.Path(output_path).suffix.lower() != '.vrt':
return False, QCoreApplication.translate(
"GdalAlgorithm",
'Output filename must use a .vrt extension')
return True, ''
self.RESAMPLING_OPTIONS = ((self.tr('Nearest Neighbour'), 'nearest'),
(self.tr('Bilinear'), 'bilinear'),
(self.tr('Cubic Convolution'),
'cubic'), (self.tr('B-Spline Convolution'),
'cubicspline'),
(self.tr('Lanczos Windowed Sinc'),
'lanczos'), (self.tr('Average'),
'average'), (self.tr('Mode'),
'mode'))
self.RESOLUTION_OPTIONS = ((self.tr('Average'), 'average'),
(self.tr('Highest'),
'highest'), (self.tr('Lowest'), 'lowest'))
self.addParameter(
QgsProcessingParameterMultipleLayers(self.INPUT,
self.tr('Input layers'),
QgsProcessing.TypeRaster))
self.addParameter(
QgsProcessingParameterEnum(
self.RESOLUTION,
self.tr('Resolution'),
options=[i[0] for i in self.RESOLUTION_OPTIONS],
defaultValue=0))
separate_param = QgsProcessingParameterBoolean(
self.SEPARATE,
self.tr('Place each input file into a separate band'),
defaultValue=True)
# default to not using separate bands is a friendlier option, but we can't change the parameter's actual
# defaultValue without breaking API!
separate_param.setGuiDefaultValueOverride(False)
self.addParameter(separate_param)
self.addParameter(
QgsProcessingParameterBoolean(
self.PROJ_DIFFERENCE,
self.tr('Allow projection difference'),
defaultValue=False))
add_alpha_param = QgsProcessingParameterBoolean(
self.ADD_ALPHA,
self.tr('Add alpha mask band to VRT when source raster has none'),
defaultValue=False)
add_alpha_param.setFlags(
add_alpha_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(add_alpha_param)
assign_crs = QgsProcessingParameterCrs(
self.ASSIGN_CRS,
self.tr('Override projection for the output file'),
defaultValue=None,
optional=True)
assign_crs.setFlags(assign_crs.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(assign_crs)
resampling = QgsProcessingParameterEnum(
self.RESAMPLING,
self.tr('Resampling algorithm'),
options=[i[0] for i in self.RESAMPLING_OPTIONS],
defaultValue=0)
resampling.setFlags(resampling.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(resampling)
src_nodata_param = QgsProcessingParameterString(
self.SRC_NODATA,
self.tr('Nodata value(s) for input bands (space separated)'),
defaultValue=None,
optional=True)
src_nodata_param.setFlags(
src_nodata_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(src_nodata_param)
extra_param = QgsProcessingParameterString(
self.EXTRA,
self.tr('Additional command-line parameters'),
defaultValue=None,
optional=True)
extra_param.setFlags(extra_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(extra_param)
self.addParameter(
ParameterVrtDestination(
self.OUTPUT,
QCoreApplication.translate("ParameterVrtDestination",
'Virtual')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.MASK, self.tr('Mask layer'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(
QgsProcessingParameterNumber(
self.NODATA,
self.tr('Assign a specified nodata value to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.ALPHA_BAND,
self.tr('Create an output alpha band'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.CROP_TO_CUTLINE,
self.
tr('Match the extent of the clipped raster to the extent of the mask layer'
),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.KEEP_RESOLUTION,
self.tr('Keep resolution of output raster'),
defaultValue=False))
target_extent_param = QgsProcessingParameterExtent(
self.TARGET_EXTENT,
self.tr('Georeferenced extents of output file to be created'),
optional=True)
target_extent_param.setFlags(
target_extent_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(target_extent_param)
target_extent_crs_param = QgsProcessingParameterCrs(
self.TARGET_EXTENT_CRS,
self.tr('CRS of the target raster extent'),
optional=True)
target_extent_crs_param.setFlags(
target_extent_crs_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(target_extent_crs_param)
multithreading_param = QgsProcessingParameterBoolean(
self.MULTITHREADING,
self.tr('Use multithreaded warping implementation'),
defaultValue=False)
multithreading_param.setFlags(
multithreading_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(multithreading_param)
options_param = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
}
})
self.addParameter(options_param)
dataType_param = QgsProcessingParameterEnum(
self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=0)
dataType_param.setFlags(
dataType_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(dataType_param)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Clipped (mask)')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFile(self.INPUT,
self.tr('Input LAS layer'),
extension='las'))
self.addParameter(
QgsProcessingParameterNumber(self.CELLSIZE,
self.tr('Cellsize'),
QgsProcessingParameterNumber.Double,
minValue=0,
defaultValue=10.0))
self.addParameter(
QgsProcessingParameterEnum(self.XYUNITS, self.tr('XY Units'),
self.UNITS))
self.addParameter(
QgsProcessingParameterEnum(self.ZUNITS, self.tr('Z Units'),
self.UNITS))
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_DTM, self.tr('Output surface'),
self.tr('DTM files (*.dtm *.DTM)')))
ground = QgsProcessingParameterFile(
self.INPUT,
self.tr('Input FUSION canopy height model'),
optional=True)
ground.setFlags(ground.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(ground)
median = QgsProcessingParameterString(self.MEDIAN,
self.tr('Median'),
'',
optional=True)
median.setFlags(median.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(median)
smooth = QgsProcessingParameterString(self.SMOOTH,
self.tr('Smooth'),
'',
optional=True)
smooth.setFlags(smooth.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(smooth)
class_var = QgsProcessingParameterString(self.CLASS,
self.tr('Class'),
'',
optional=True)
class_var.setFlags(class_var.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(class_var)
slope = QgsProcessingParameterBoolean(self.SLOPE,
self.tr('Calculate slope'),
False)
slope.setFlags(slope.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(slope)
self.addParameter(
QgsProcessingParameterBoolean(self.ASCII,
self.tr('Add an ASCII output'),
False))
self.addAdvancedModifiers()
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
# We add the input vector features source. It can have any kind of
# geometry.
self.addParameter(
QgsProcessingParameterRasterLayer(self.TI,
self.tr('Training raster')))
self.addParameter(
QgsProcessingParameterBand(self.BANDS_TI,
self.tr('Selected band(s)'),
None,
self.TI,
allowMultiple=True))
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT, self.tr('Raster on which to simulate')))
self.addParameter(
QgsProcessingParameterBand(self.BANDS_INPUT,
self.tr('Selected band(s)'),
None,
self.INPUT,
allowMultiple=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(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('QS simulation')))
self.addParameter(
QgsProcessingParameterNumber(
self.PARAM_K,
self.tr('Parameter k'),
QgsProcessingParameterNumber.Double,
1.2,
minValue=1,
))
self.addParameter(
QgsProcessingParameterNumber(
self.PARAM_N,
self.tr('Parameter N'),
QgsProcessingParameterNumber.Integer,
30,
minValue=1,
))
self.addParameter(
QgsProcessingParameterEnum(self.KERNEL_TYPE,
self.tr('Type of kernel'), [
self.tr('Uniform'),
self.tr('Exponential'),
self.tr('Gaussian')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.KERNEL_ALPHA,
self.tr('Kernel Alpha OR Max radius'),
QgsProcessingParameterNumber.Double,
1,
minValue=0.001,
optional=True))
paramj = QgsProcessingParameterNumber(
self.PARAM_J,
self.
tr('Parallelization, interger for number of cores, and decimal ]0,1[, for porcentage of total cores'
),
QgsProcessingParameterNumber.Double,
0.5,
minValue=0.001,
optional=True)
paramj.setFlags(paramj.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
paramSA = QgsProcessingParameterString(
self.PARAM_SA,
self.tr('DNS name or IP of the G2S server'),
'localhost',
optional=True)
paramSA.setFlags(paramSA.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
ignoreResolution = QgsProcessingParameterBoolean(
self.PARAM_IGNORE_RESOLUTION,
self.tr('ignore resolution check'),
False,
optional=True)
ignoreResolution.setFlags(
ignoreResolution.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(paramj)
self.addParameter(paramSA)
self.addParameter(ignoreResolution)
def initAlgorithm(self, config):
print('initAlgorithm()')
#super(MappiaPublisherAlgorithm, self).initAlgorithm()
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
options = OptionsCfg.read()
self.last_update_date = options[OptionsCfg.UPDATE_CHECK]
#self.addParameter(
# QgsProcessingParameterEnum(
# self.OPERATION,
# self.tr('Operation Type'),
# options=[self.tr(curOption) for curOption in OperationType.getOptions()],
# defaultValue=9
# )
#)
#TODO Implement layer attribute later.
# self.addParameter(
# QgsProcessingParameterString(
# self.LAYER_ATTRIBUTE,
# self.tr('Layer style name (Change to different style names only if interested in publishing multiple (layers or attributes) of the same file.)'),
# optional=False,
# defaultValue=options['attrName']
# )
# )
self.addParameter(
QgsProcessingParameterString(
self.GITHUB_REPOSITORY,
self.tr('* Repository name (or map group name)'),
optional=False,
defaultValue=options['gh_repository']))
# We add the input vector features source. It can have any kind of
# geometry.
layerParam = QgsProcessingParameterMultipleLayers(
self.LAYERS, self.tr('* Maps to display online'),
QgsProcessing.TypeMapLayer
#, defaultValue=[layer.id() for layer in iface.mapCanvas().layers()]#[layer.dataProvider().dataSourceUri(False) for layer in iface.mapCanvas().layers()]
)
layerParam.setMinimumNumberInputs(1)
self.addParameter(layerParam)
self.m_layerParam = layerParam
maxZoomParameter = QgsProcessingParameterNumber(
self.ZOOM_MAX,
self.tr('Map max Zoom level [1 ~ 13] (lower is faster)'),
minValue=1,
maxValue=13,
defaultValue=options["zoom_max"])
maxZoomParameter.setFlags(
maxZoomParameter.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(maxZoomParameter)
includeSourceDownload = QgsProcessingParameterBoolean(
self.INCLUDE_DOWNLOAD,
self.tr(
'Upload maps for further download (2GB limit per unique map)'),
defaultValue=options['include_dl'])
includeSourceDownload.setFlags(
includeSourceDownload.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(includeSourceDownload)
gitExeParameter = QgsProcessingParameterString(
self.GIT_EXECUTABLE,
self.tr('Git client executable path.'),
optional=True,
defaultValue=UTILS.getGitDefault(options['git_exe']))
gitExeParameter.setFlags(
gitExeParameter.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(gitExeParameter)
ghUserParameter = QgsProcessingParameterString(
self.GITHUB_USER,
self.tr('Github USERNAME (Credentials for https://github.com)'),
optional=True,
defaultValue=options['gh_user'])
ghUserParameter.setFlags(
ghUserParameter.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(ghUserParameter)
# ghPassParameter = QgsProcessingParameterString(
# self.GITHUB_PASS,
# self.tr('Github Access Token *'),
# optional=True,
# defaultValue=options['gh_pass']
# )
# ghPassParameter.setFlags(ghPassParameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
# self.addParameter(ghPassParameter)
askUserConfirmation = QgsProcessingParameterBoolean(
self.ASK_USER,
self.tr('Ask user confirmation before each step.'),
defaultValue=options['ask_user'])
askUserConfirmation.setFlags(
askUserConfirmation.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(askUserConfirmation)
outputDirParameter = QgsProcessingParameterFolderDestination(
self.OUTPUT_DIRECTORY,
self.tr('Output directory'),
optional=True,
defaultValue=options["folder"] or None)
outputDirParameter.setFlags(
outputDirParameter.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(outputDirParameter)
def initAlgorithm(self, config=None):
self.methods = ((self.tr('Nearest neighbour'), 'near'),
(self.tr('Bilinear'), 'bilinear'),
(self.tr('Cubic'), 'cubic'),
(self.tr('Cubic spline'), 'cubicspline'),
(self.tr('Lanczos windowed sinc'), 'lanczos'),
(self.tr('Average'), 'average'),
(self.tr('Mode'), 'mode'),
(self.tr('Maximum'), 'max'),
(self.tr('Minimum'), 'min'),
(self.tr('Median'), 'med'),
(self.tr('First quartile'), 'q1'),
(self.tr('Third quartile'), 'q3'))
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer')))
self.addParameter(QgsProcessingParameterCrs(self.SOURCE_CRS,
self.tr('Source CRS'),
optional=True))
self.addParameter(QgsProcessingParameterCrs(self.TARGET_CRS,
self.tr('Target CRS'),
'EPSG:4326'))
self.addParameter(QgsProcessingParameterNumber(self.NODATA,
self.tr('Nodata value for output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0))
self.addParameter(QgsProcessingParameterNumber(self.TARGET_RESOLUTION,
self.tr('Output file resolution in target georeferenced units'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=None))
options_param = QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation parameters'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
self.addParameter(options_param)
self.addParameter(QgsProcessingParameterEnum(self.RESAMPLING,
self.tr('Resampling method to use'),
options=[i[0] for i in self.methods],
defaultValue=0))
dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=5)
dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(dataType_param)
target_extent_param = QgsProcessingParameterExtent(self.TARGET_EXTENT,
self.tr('Georeferenced extents of output file to be created'),
optional=True)
target_extent_param.setFlags(target_extent_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(target_extent_param)
target_extent_crs_param = QgsProcessingParameterCrs(self.TARGET_EXTENT_CRS,
self.tr('CRS of the target raster extent'),
optional=True)
target_extent_crs_param.setFlags(target_extent_crs_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(target_extent_crs_param)
multithreading_param = QgsProcessingParameterBoolean(self.MULTITHREADING,
self.tr('Use multithreaded warping implementation'),
defaultValue=False)
multithreading_param.setFlags(multithreading_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(multithreading_param)
self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Reprojected')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterBand(self.BAND,
self.tr('Band number'),
parentLayerParameterName=self.INPUT))
self.addParameter(
QgsProcessingParameterNumber(
self.INTERVAL,
self.tr('Interval between contour lines'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=10.0))
self.addParameter(
QgsProcessingParameterString(
self.FIELD_NAME,
self.
tr('Attribute name (if not set, no elevation attribute is attached)'
),
defaultValue='ELEV',
optional=True))
create_3d_param = QgsProcessingParameterBoolean(
self.CREATE_3D, self.tr('Produce 3D vector'), defaultValue=False)
create_3d_param.setFlags(
create_3d_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(create_3d_param)
ignore_nodata_param = QgsProcessingParameterBoolean(
self.IGNORE_NODATA,
self.tr('Treat all raster values as valid'),
defaultValue=False)
ignore_nodata_param.setFlags(
ignore_nodata_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(ignore_nodata_param)
nodata_param = QgsProcessingParameterNumber(
self.NODATA,
self.tr('Input pixel value to treat as "nodata"'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True)
nodata_param.setFlags(nodata_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(nodata_param)
offset_param = QgsProcessingParameterNumber(
self.OFFSET,
self.tr(
'Offset from zero relative to which to interpret intervals'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0,
optional=True)
nodata_param.setFlags(offset_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(offset_param)
options_param = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(options_param)
self.addParameter(
QgsProcessingParameterVectorDestination(
self.OUTPUT, self.tr('Contours'),
QgsProcessing.TypeVectorLine))
def initAlgorithm(self, config=None):
"""
Here we define the inputs and output of the algorithm, along with some other properties.
"""
# We add the input vector features source. It can have any kind of geometry.
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT,
self.tr('Input layer'),
[QgsProcessing.TypeVector]
)
)
optional_start_value = QgsProcessingParameterNumber(
self.OPTIONAL_START_VALUE,
self.tr('Optional start value for progressive (default = 0)'), 0
)
optional_start_value.setFlags(optional_start_value.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(optional_start_value)
result_field_name = QgsProcessingParameterString(
self.RESULT_FIELD_NAME,
self.tr('Optional new Field name suffix'), ' '
)
result_field_name.setFlags(result_field_name.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(result_field_name)
id_calc = QgsProcessingParameterBoolean(
self.ID_CALC,
self.tr('Optional add Id calculation column'), 0
)
id_calc.setFlags(id_calc.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(id_calc)
id_dec = QgsProcessingParameterBoolean(
self.ID_DEC,
self.tr('Optional 5 decimal places'), 0
)
id_dec.setFlags(id_dec.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(id_dec)
self.addParameter(QgsProcessingParameterField(self.OPERATION_FIELD_NAME,
'Choose operation field',
type=QgsProcessingParameterField.Numeric,
parentLayerParameterName=self.INPUT))
self.addParameter(QgsProcessingParameterEnum(self.OUTPUT_OPERATION, 'Option calc: Prog, %, M Mobile, M Ponderata, Var, Var %',
options=['PROGRESSIVA','PERCENTUALE','MEDIA MOBILE','MEDIA PONDERATA','VARIAZIONE','VARIAZIONE %'],
allowMultiple=False, defaultValue = None))
self.addParameter(QgsProcessingParameterField(self.WEIGHT_FIELD_NAME,
self.tr('Choose weight field'),
optional = 1,
type=QgsProcessingParameterField.Numeric,
parentLayerParameterName=self.INPUT))
# 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('Calc_' + str(datetime.datetime.now().strftime("%d-%m-%Y %H:%M:%S")))
)
)
