def define_new_doc_string(newid=1):
@alg(name=ARGNAME.format(newid), label=alg.tr("Test func"), group="unittest",
group_label=alg.tr("Test label"))
@alg.input(type=alg.SOURCE, name="INPUT", label="Input layer")
@alg.output(type=str, name="DISTANCE_OUT", label="Distance out")
def testalg(instance, parameters, context, feedback, inputs):
"""
def define_new_doc_string(newid=1):
@alg(name=ARGNAME.format(newid), label=alg.tr("Test func"), group="unittest",
group_label=alg.tr("Test label"))
@alg.input(type=alg.SOURCE, name="INPUT", label="Input layer")
@alg.output(type=str, name="DISTANCE_OUT", label="Distance out")
def testalg(instance, parameters, context, feedback, inputs):
"""
def define_new_no_inputs(newid=1):
@alg(name="noinputs",
label=alg.tr("Test func"),
group="unittest",
group_label=alg.tr("Test label"))
@alg.output(type=str, name="DISTANCE_OUT", label="Distance out")
def testalg(instance, parameters, context, feedback, inputs):
"""
def define_new_no_outputs_but_sink_instead(newid=1):
@alg(name=ARGNAME.format(newid), label=alg.tr("Test func"), group="unittest",
group_label=alg.tr("Test label"))
@alg.help(HELPSTRING.format(newid))
@alg.input(type=alg.SOURCE, name="INPUT", label="Input layer")
@alg.input(type=alg.DISTANCE, name="DISTANCE", label="Distance", default=30)
@alg.input(type=alg.SINK, name="SINK", label="Output layer")
def testalg(instance, parameters, context, feedback, inputs):
"""
def define_new_no_outputs_but_sink_instead(newid=1):
@alg(name=ARGNAME.format(newid), label=alg.tr("Test func"), group="unittest",
group_label=alg.tr("Test label"))
@alg.help(HELPSTRING.format(newid))
@alg.input(type=alg.SOURCE, name="INPUT", label="Input layer")
@alg.input(type=alg.DISTANCE, name="DISTANCE", label="Distance", default=30)
@alg.input(type=alg.SINK, name="SINK", label="Output layer")
def testalg(instance, parameters, context, feedback, inputs):
"""
def define_new_input_help(newid=1):
@alg(name=ARGNAME.format(newid),
label=alg.tr("Test func"),
group="unittest",
group_label=alg.tr("Test label"))
@alg.help(HELPSTRING.format(newid))
@alg.input(type=alg.SOURCE,
name="INPUT",
label="Input layer",
help="The input layer as source")
@alg.input(type=alg.DISTANCE,
name="DISTANCE",
label="Distance",
default=30,
help="The distance to split the input layer")
@alg.input(type=alg.SINK,
name="SINK",
label="Output layer",
help="The output layer as sink")
@alg.output(type=str, name="DISTANCE_OUT", label="Distance out")
def testalg(instance, parameters, context, feedback, inputs):
"""
import os
import glob
import tempfile
from qgis.core import *
from PyQt5.QtCore import * # TODO pyqt4->5 check if works
from qgis.processing import alg
@alg(
name="pg04waterqualityparameterssubsetting",
label=alg.tr("PG04_WaterQualityParameters_Subsetting"),
group="bc",
group_label=alg.tr("BC"),
)
@alg.input(
type=alg.BOOL,
name="dontsubset",
label="Don't subset products - In this case no shapefile is needed",
default=False,
)
@alg.input(type=alg.SOURCE, name="Input_vector", label="Input_vector", optional=True)
@alg.output(type=alg.FOLDER, name="Output_folder", label="Output_folder")
def pg04waterqualityparameterssubsetting(
instance, parameters, context, feedback, inputs
):
"""
Water quality parameter subsetting
"""
tempfolder = "wq_scripts_"
Input_vector1 = instance.parameterAsVectorLayer(parameters, "Input_vector", context)
dontsubset = instance.parameterAsBool(parameters, "dontsubset", context)
def define_new_no_inputs(newid=1):
@alg(name="noinputs", label=alg.tr("Test func"), group="unittest",
group_label=alg.tr("Test label"))
@alg.output(type=str, name="DISTANCE_OUT", label="Distance out")
def testalg(instance, parameters, context, feedback, inputs):
"""
mainRoutine as mainRoutine_angles,
)
from qgis_fmask.interfaces.fmask_usgsLandsatSaturationMask import (
mainRoutine as mainRoutine_saturation,
)
from qgis_fmask.interfaces.fmask_usgsLandsatTOA import mainRoutine as mainRoutine_toa
from qgis_fmask.interfaces.redirect_stdout import redirect_stdout_to_feedback
from qgis_fmask.interfaces.landsatmeta import find_mtl_in_product_dir
# ##OutputFile|output|Output cloud mask|tif #TODO extention should be tif. - implemented without.
# TODO yields different output than the old one.
@alg(
name="fmasklandsat",
label=alg.tr("FMask Landsat"),
group="fmask",
group_label=alg.tr("FMask"),
)
@alg.input(
type=alg.FILE,
name="productdir",
label="Directory of Landsat product",
behavior=1,
optional=False,
)
@alg.input(
type=alg.ENUM,
name="landsatkeynr",
label="Landsat sensor",
options=["Landsat 4&5", "Landsat 7", "Landsat 8"],
from qgis.processing import alg
from processing.core.ProcessingConfig import ProcessingConfig
from db_manager.db_plugins import data_model
from processing.tools import system
from qgis import processing
@alg(
name="burncloudmask",
label=alg.tr("Burn cloud mask"),
group="fmask",
group_label=alg.tr("FMask"),
)
@alg.input(
type=alg.RASTER_LAYER,
name="dataFile",
label="An image file to burn the cloud mask into",
optional=False,
)
@alg.input(
type=alg.RASTER_LAYER,
name="maskFile",
label="Could mask from FMask",
optional=False,
)
@alg.input(type=bool,
name="maskNull",
label="Mask FMask null pixels",
default=True)
@alg.input(type=bool,
name="maskCloud",
##ParameterFile|infile||False|False|gz
##OutputDirectory|processing_path|Folder to unpack the data to
import glob
import os
import sys
import tarfile
from processing.tools import dataobjects
from qgis.processing import alg
@alg(
name="untarimagery",
label=alg.tr("Untar Imagery"),
group="gt",
group_label=alg.tr("Generic Tools"),
)
@alg.input(
type=alg.FILE,
name="infile",
label="Landsat tar.gz file",
behavior=0,
optional=True,
extension="gz",
)
@alg.input(type=alg.FOLDER_DEST, name="processing_path", label="processing path")
@alg.output(type=alg.FOLDER, name="out_folder", label="out folder")
def untarimagery(instance, parameters, context, feedback, inputs):
""" untarimagery """
processing_path = instance.parameterAsString(parameters, "processing_path", context)
import os
import glob
from qgis.processing import alg
from qgis import processing
import tempfile
@alg(
name="pg04waterqualityparameterscoastcolourl1p",
label=alg.tr("PG04_WaterQualityParameters_CoastColour_L1P"),
group="bc",
group_label=alg.tr("BC"),
)
@alg.input(type=alg.BOOL, name="Icol", label="Icol", default=False)
@alg.input(type=alg.BOOL, name="Calibration", label="Calibration", default=False)
@alg.input(type=alg.BOOL, name="Smile", label="Smile", default=True)
@alg.input(type=alg.BOOL, name="Equalization", label="Equalization", default=True)
@alg.input(
type=alg.BOOL,
name="IgnoreSeaIceClim",
label="Ignore sea ice climatology",
default=False,
)
@alg.input(
type=alg.NUMBER,
name="CloudBufferWidth",
label="lnsert size of cloud buffer in pixel",
default=2,
minValue=0,
)
import os
import glob
import tempfile
from qgis.processing import alg
# TODO label is the same for this and '..._01_CC_L1p'
@alg(
name="pg04waterqualityparameters02c2rcc",
label=alg.tr("PG04_WaterQualityParameters_02_C2RCC"),
group="bc",
group_label=alg.tr("BC"),
)
@alg.input(
type=alg.NUMBER,
name="AverageSalinity",
label="Average Salinity",
default=1,
minValue=0,
)
@alg.input(
type=alg.NUMBER,
name="AverageTemperature",
label="Average Temperature",
default=15,
minValue=0,
)
@alg.input(
type=alg.STRING,
name="validExpression",
label="Valid pixel expression",
import os
import sys
from qgis.processing import alg
if os.path.dirname(__file__) not in sys.path:
sys.path.append(os.path.dirname(__file__))
import segStack
@alg(
name="preparepostprocessingstack",
label=alg.tr("Stack bands for segmentation"),
group="gt",
group_label=alg.tr("Generic Tools"),
)
@alg.input(type=alg.RASTER_LAYER, name="inRst1", label="Input Stack")
@alg.input(type=alg.BOOL, name="B1", label="Band 1", default=False)
@alg.input(type=alg.BOOL, name="B2", label="Band 2", default=False)
@alg.input(type=alg.BOOL, name="B3", label="Band 3", default=False)
@alg.input(type=alg.BOOL, name="B4", label="Band 4", default=False)
@alg.input(type=alg.BOOL, name="B5", label="Band 5", default=False)
@alg.input(type=alg.BOOL, name="B6", label="Band 6", default=False)
@alg.input(type=alg.BOOL, name="B7", label="Band 7", default=False)
@alg.input(type=alg.BOOL, name="B8", label="Band 8", default=False)
@alg.input(type=alg.BOOL, name="B9", label="Band 9", default=False)
@alg.input(type=alg.BOOL, name="B10", label="Band 10", default=False)
@alg.input(type=alg.RASTER_LAYER, name="inRst2", label="Classification Raster")
@alg.input(type=alg.RASTER_LAYER_DEST,
name="outPath",
label="Output Stack for Segmentation")
def algorithm(instance, parameters, context, feedback, inputs):
import os
import sys
import gdal
import numpy as np
from qgis.processing import alg
from processing.tools import dataobjects
@alg(
name="landsatindicies",
label=alg.tr("Landsat Indices"),
group="landsattools",
group_label=alg.tr("Landsat Tools"),
)
@alg.input(
type=alg.RASTER_LAYER,
name="input",
label="Input Reflectance Stack",
optional=False,
)
@alg.input(
type=alg.FOLDER_DEST,
name="outputDirectory",
label="Folder to save the stack of Indices",
)
@alg.input(
type=alg.RASTER_LAYER_DEST,
name="output",
label="Name for Index Stack",
)
def fmasklandsat(instance, parameters, context, feedback, inputs):
from qgis.processing import alg
from qgis.core import QgsFeature, QgsFeatureSink
"""
"""
"""
"""
import processing
@alg(name="gcpfull",
label=alg.tr("GCP Grouping"),
group="vds",
group_label=alg.tr("VDS"))
@alg.input(type=alg.VECTOR_LAYER, name="IMAGE", label="Input images")
@alg.input(type=alg.FIELD,
name="IMAGE_FIELD",
label="Image file name",
parentLayerParameterName="IMAGE")
@alg.input(type=alg.VECTOR_LAYER, name="GCP", label="Input GCPs")
@alg.input(type=alg.FIELD,
name="GCP_FIELD",
label="Name of GCP",
parentLayerParameterName="GCP")
@alg.input(type=alg.CRS,
name="LOCAL_CRS",
label="CRS for processing GCPs",
default="EPSG:2256")
@alg.input(type=alg.DISTANCE,
from qgis.processing import alg
import itertools
@alg(name="gcpimage",
label=alg.tr("GCP Image"),
group="vds",
group_label=alg.tr("VDS"))
@alg.input(type=alg.SOURCE, name="INPUT", label="Input layer")
@alg.input(type=alg.FIELD,
name="GCP_FIELD",
label="GCP number field",
parentLayerParameterName="INPUT")
@alg.input(type=alg.FIELD,
name="NAME_FIELD",
label="Image name field",
parentLayerParameterName="INPUT")
@alg.input(type=alg.FILE_DEST,
name="OUTPUT",
label="Name and path of the output")
def gcp_image(instance, parameters, context, feedback, inputs):
"""
Creates a batch file of image file names, given a layer of joined features
"""
source = instance.parameterAsSource(parameters, "INPUT", context)
gcp_field = instance.parameterAsFields(parameters, "GCP_FIELD", context)[0]
name_field = instance.parameterAsFields(parameters, "NAME_FIELD",
context)[0]
# -*- coding: utf-8 -*-
from qgis.core import QgsProcessing, QgsVectorFileWriter, QgsVectorLayerExporter
from qgis.processing import alg
#dichiarazione generale dell'interfaccia utente dell'algoritmo
@alg(name="salva_in_geopackage", label="salva in geopackage", group="customscripts", group_label=alg.tr("Custom Scripts"))
#dichiarazione dei widget di input ed output
@alg.input(type=alg.MULTILAYER, name="LAYERS", label="Layers da includere", layerType=QgsProcessing.TypeVectorAnyGeometry)
@alg.input(type=alg.FILE_DEST, name="OUTPUT_GEOPACKAGE_FILE", label="Output GEOPACKAGE", fileFilter='GEOPACKAGE files (*.gpkg)')
def algoritmo_di_processing(instance, parameters, context, feedback, inputs):
"""
corpo della procedura di processing
"""
#raccolta dei parametri configurati dall'utente
layers_sorgenti = instance.parameterAsLayerList(parameters, "LAYERS", context)
gpkgPath = instance.parameterAsFile(parameters, "OUTPUT_GEOPACKAGE_FILE", context)
layers_inclusi=[]
primo = True
print(gpkgPath)
#processing
for lyr in layers_sorgenti:
options = QgsVectorFileWriter.SaveVectorOptions()
if primo:
primo = False
else:
options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteLayer
options.EditionCapability = QgsVectorFileWriter.CanAddNewLayer
options.layerName = lyr.name() #"_".join(lyr.name().split(' '))
import os
import glob
import subprocess
from qgis.processing import alg
from processing.core.ProcessingConfig import ProcessingConfig
from os import walk
import tempfile
import shutil
import math
@alg(
name="pg04waterqualityworkflowl3binning",
label=alg.tr("PG04_WaterQualityWorkflow_l3binning"),
group="bc",
group_label=alg.tr("BC"),
)
@alg.input(type=alg.FILE,
name="input_folder",
label="Input folder",
behavior=1)
@alg.input(
type=alg.NUMBER,
name="start_month",
label="Select start month for processing",
default=1,
minValue=1,
maxValue=12,
)
# Definition of inputs and outputs
import os
import glob
import subprocess
from qgis.processing import alg
from processing.core.ProcessingConfig import ProcessingConfig
from os import walk
import tempfile
import shutil
@alg(
name="pg04waterqualityworkflowgraphprocessorv5",
label=alg.tr("PG04_WaterQualityWorkflow_graphProcessor_v5"),
group="bc",
group_label=alg.tr("BC"),
)
@alg.input(type=alg.FILE,
name="Input_files",
label="Select files to be processed")
@alg.input(
type=alg.NUMBER,
name="mem",
default=1,
minValue=1,
maxValue=31,
label="Insert the amount of RAM (inGB) available for processing",
)
@alg.input(type=alg.FOLDER_DEST, name="Output_folder", label="folder")
from qgis.processing import alg
from PyQt5.QtCore import QCoreApplication, QVariant
from qgis.core import (QgsProcessing,
QgsFeatureSink,
QgsFields,QgsField,QgsFeature,QgsGeometry, QgsWkbTypes, QgsRaster)
@alg(name="measure_Elevation_along_lines", label="Measure DTM elevation along lines", group="customscripts", group_label=alg.tr("Custom Scripts"))
@alg.input(type=alg.RASTER_LAYER, name='DTM_LAYER', label="Layer DTM")
@alg.input(type=alg.SOURCE, name='INPUT_LAYER', label="Input layer", types=[QgsProcessing.TypeVectorLine])
@alg.input(type=alg.DISTANCE, name="MEASURE_VALUE", label="Measure step size", default=50.0)
@alg.input(type=alg.SINK, name="OUTPUT_LAYER", label="Output layer")
def processAlgorithm(instance, parameters, context, feedback, inputs):
"""
Algoritm to extract elevation on DTM from linestring paths at specified measure step
"""
vectorLayer = instance.parameterAsSource(parameters, "INPUT_LAYER", context)
dtmLayer = instance.parameterAsRasterLayer(parameters, "DTM_LAYER", context)
measureStep = instance.parameterAsInt (parameters, "MEASURE_VALUE", context)
fields=QgsFields()
fields.append(QgsField('id_poly', QVariant.Int))
fields.append(QgsField('elevation', QVariant.Double))
fields.append(QgsField('step', QVariant.Double))
(sink, dest_id) = instance.parameterAsSink(parameters, "OUTPUT_LAYER", context, fields, QgsWkbTypes.Point, vectorLayer.sourceCrs())
import os
import glob
import tempfile
from qgis.processing import alg
@alg(
name="pg04waterqualityparameters03olcimphchl",
label=alg.tr("PG04_WaterQualityParameters_03_OLCI_MphChl"),
group="bc",
group_label=alg.tr("BC"),
)
@alg.input(
type=alg.STRING,
name="MPHvalidPixelExpression",
label="Valid pixel expression",
default=
"not quality_flags.invalid and (not pixel_classif_flags.IDEPIX_LAND or quality_flags.fresh_inland_water) and not (pixel_classif_flags.IDEPIX_CLOUD or pixel_classif_flags.IDEPIX_CLOUD_BUFFER)",
)
@alg.input(
type=alg.NUMBER,
name="MPHcyanoMaxValue",
label="Cyano maximum value",
default=1000,
minValue=0,
)
@alg.input(
type=alg.NUMBER,
name="MPHchlThreshForFloatFlag",
label="CHL threshold for float flag",
from qgis.processing import alg
from qgis.core import (QgsProject, QgsReferencedRectangle, QgsBookmark)
@alg(name="gcpbookmark", label=alg.tr("GCP Bookmark"), group="vds",
group_label=alg.tr("VDS"))
@alg.input(type=alg.SOURCE, name="INPUT", label="Input layer")
@alg.input(type=alg.FIELD, name="NAME_FIELD", label="Name field",
parentLayerParameterName="INPUT")
@alg.output(type=alg.INT, name="OUTPUT", label="Number of bookmarks made")
def gcp_bookmark(instance, parameters, context, feedback, inputs):
"""
Creates a bookmark for the location of each GCP, given the GCP's buffer.
"""
source = instance.parameterAsSource(parameters, "INPUT", context)
name_field = instance.parameterAsFields(parameters, "NAME_FIELD", context)[0]
bookmark_manager = QgsProject.instance().bookmarkManager()
coord = source.sourceCrs()
total = 100.0 / source.featureCount() if source.featureCount() else 0
features = source.getFeatures()
for current, feature in enumerate(features):
if feedback.isCanceled():
break
# Instead of getting the name from an attribute,
# this gets the feature's id and turns it into the gcp name.
gcp_name = str(feature[name_field])
gcp_view = feature.geometry().boundingBox()
# -*- coding: utf-8 -*-
from qgis.core import QgsProcessing, QgsWkbTypes
from qgis.processing import alg
#dichiarazione generale dell'interfaccia utente dell'algoritmo
@alg(name="dettagli_layer", label="dettagli layer", group="customscripts", group_label=alg.tr("Custom Scripts"))
#dichiarazione dei widget di input ed output
@alg.input(type=alg.SOURCE, name="INPUT", label="Input layer", types=[QgsProcessing.TypeVectorAnyGeometry])
@alg.input(type=alg.FIELD, name="CAMPO", label="Campo da riassumere", parentLayerParameterName="INPUT")
@alg.input(type=alg.FILE_DEST, name="OUTPUT_HTML_FILE", label="Output HTML", fileFilter='HTML files (*.html)')
def algoritmo_di_processing(instance, parameters, context, feedback, inputs):
"""
corpo della procedura di processing
"""
def creaHTML(outputFile, algData):
with open(outputFile, 'w', encoding='utf-8') as f:
f.write('<html><head>')
f.write('<meta http-equiv="Content-Type" content="text/html; \
charset=utf-8" /></head><body>')
f.write('<p>Dati processati: ' + str(len(algData)) + '</p>')
f.write('<p>Valori:</p>')
f.write('<table>')
for s in algData:
f.write('<tr>')
for attr in s:
f.write('<td>' + str(attr) + '</td>')
f.write('</tr>')
f.write('</table></body></html>')
import os
import glob
import tempfile
from qgis.processing import alg
@alg(
name="pg04waterqualityparameters04olcicrsselect",
label=alg.tr("PG04_WaterQualityParameters_04_OLCI_CRS_select"),
group="bc",
group_label=alg.tr("BC"),
)
@alg.input(type=alg.CRS, name="Define_output_CRS", label="Define_output_CRS")
@alg.output(type=alg.FOLDER, name="output", label="Output folder")
def pg04waterqualityparameters04olcicrsselect(instance, parameters, context,
feedback, inputs):
"""
Optical-SAR Water and Wetness Fusion
"""
Define_output_CRS = instance.parameterAsString(parameters,
"Define_output_CRS",
context)
tempfolder = "wq_scripts_"
def folder_check(tempfolder):
try:
tempdir = glob.glob(
os.path.join(tempfile.gettempdir(), tempfolder + "*"))[0]
return False
from qgis.processing import alg
from PyQt5.QtCore import QCoreApplication, QVariant
from qgis.core import (QgsProcessing, QgsFeatureSink, QgsFields, QgsField,
QgsFeature, QgsGeometry, QgsWkbTypes, QgsRaster)
@alg(name="origine_destinazione",
label="Crea grafo origine/destinazione",
group="customscripts",
group_label=alg.tr("Custom Scripts"))
@alg.input(type=alg.SOURCE,
name='INPUT_LINEE',
label="linee",
types=[QgsProcessing.TypeVectorLine])
@alg.input(type=alg.SINK, name='OUTPUT_NODI', label="nodi")
@alg.input(type=alg.SINK, name='OUTPUT_GRAFO', label="grafo")
@alg.output(type=str, name="OUT", label="Output")
def processAlgorithm(instance, parameters, context, feedback, inputs):
"""
Algoritm to extract elevation on DTM from linestring paths at specified measure step
"""
def aggiungi_nodo(nuovo_nodo):
for i, nodo in enumerate(lista_nodi):
if nodo.compare(nuovo_nodo):
return i
lista_nodi.append(nuovo_nodo)
return len(lista_nodi) - 1
linee_layer = instance.parameterAsSource(parameters, "INPUT_LINEE",
context)
from qgis.processing import alg
from qgis import processing
@alg(
name="reprojectrasterandvectorlayers",
label=alg.tr("Reproject raster and vector layers"),
group="sdg661reporting",
group_label=alg.tr("SDG 6.6.1 reporting"),
)
@alg.input(type=alg.RASTER_LAYER, name="inputRaster", label="Raster layer")
@alg.input(type=alg.VECTOR_LAYER, name="inputVector", label="Vector layer")
@alg.input(type=alg.CRS,
name="projection",
label="Metric coordinate system (UTM)")
@alg.input(type=alg.RASTER_LAYER_DEST,
name="outputRaster",
label="Reprojected raster layer")
@alg.input(type=alg.VECTOR_LAYER_DEST,
name="outputVector",
label="Reprojected vector layer")
def reproject_raster_and_vector(instance, parameters, context, feedback,
inputs):
"""
Reproject raster and vector layers
"""
feedback.setProgressText("Reprojecting vector...")
params = {
"INPUT": parameters["inputVector"],
"TARGET_CRS": parameters["projection"],
"OUTPUT": parameters["outputVector"],
