.
La consola permite a los usuarios avanzados incrementar su productividad y realizar operaciones complejas que no se pueden realizar utilizando cualquiera de los otros elementos de la GUI del marco de procesamiento. Modelos que involucran varios algoritmos se pueden definir mediante la interfaz de línea de comandos y operaciones adicionales tales como bucles y sentencias condicionales que se pueden añadir para crear flujos de trabajo más flexibles y potentes.
There is not a proccesing console in QGIS, but all processing commands are available instead from the QGIS built-in Python console. That means that you can incorporate those commands into your console work and connect processing algorithms to all the other features (including methods from the QGIS API) available from there.
El código se puede ejecutar desde la consola de Python, incluso si no especifica ningún método de procesamiento, se puede convertir en un nuevo algoritmo que más tarde puede llamar desde la caja de herramientas, el modelador gráfico o algún otro componente, tal como lo hace con cualquier otro algoritmo. De hecho, algunos de los algoritmos que se pueden encontrar en la caja de herramientas son sencillas secuencias de comandos.
In this section, we will see how to use processing algorithms from the QGIS Python console, and also how to write algorithms using Python.
Lo primero que tiene que hacer es importar las funciones de procesamiento con la siguiente línea:
>>> import processing
Ahora, hay básicamente solo una cosa (interesante) que puede hacer con eso desde la consola: ejecutar un algoritmo. Eso se hace utilizando el método runalg()`, que toma el nombre del algoritmo a ejecutar como su primer parámetro, y luego un número variable de parámetros adicionales dependiendo de los requisitos del algoritmo. Así lo primero que necesita saber es el nombre del algoritmo a ejecutar. Ese no es el nombre que se ve en la caja de herramientas, si no más bien un nombre de linea de comando única. Para encontrar el nombre correcto de su algoritmo, se puede utilizar el método ``algslist(). Escribir la siguiente línea en su consola:
>>> processing.alglist()
Veras algo como esto:
Accumulated Cost (Anisotropic)---------------->saga:accumulatedcost(anisotropic)
Accumulated Cost (Isotropic)------------------>saga:accumulatedcost(isotropic)
Add Coordinates to points--------------------->saga:addcoordinatestopoints
Add Grid Values to Points--------------------->saga:addgridvaluestopoints
Add Grid Values to Shapes--------------------->saga:addgridvaluestoshapes
Add Polygon Attributes to Points-------------->saga:addpolygonattributestopoints
Aggregate------------------------------------->saga:aggregate
Aggregate Point Observations------------------>saga:aggregatepointobservations
Aggregation Index----------------------------->saga:aggregationindex
Analytical Hierarchy Process------------------>saga:analyticalhierarchyprocess
Analytical Hillshading------------------------>saga:analyticalhillshading
Average With Mask 1--------------------------->saga:averagewithmask1
Average With Mask 2--------------------------->saga:averagewithmask2
Average With Thereshold 1--------------------->saga:averagewiththereshold1
Average With Thereshold 2--------------------->saga:averagewiththereshold2
Average With Thereshold 3--------------------->saga:averagewiththereshold3
B-Spline Approximation------------------------>saga:b-splineapproximation
...
Esa es una lista de todos los algoritmos disponibles, ordenada alfabéticamente, junto con sus nombres de linea de comandos correspondientes.
Puede utilizar una cadena como parámetro para este método. En lugar de devolver la lista completa de algoritmos, que sólo mostrará aquellos que incluyen esa cadena. Si, por ejemplo, se busca un algoritmo para calcular la pendiente de un DEM, el tipo``alglist(“slope”)`` obtendrá el siguiente resultado:
DTM Filter (slope-based)---------------------->saga:dtmfilter(slope-based)
Downslope Distance Gradient------------------->saga:downslopedistancegradient
Relative Heights and Slope Positions---------->saga:relativeheightsandslopepositions
Slope Length---------------------------------->saga:slopelength
Slope, Aspect, Curvature---------------------->saga:slopeaspectcurvature
Upslope Area---------------------------------->saga:upslopearea
Vegetation Index[slope based]----------------->saga:vegetationindex[slopebased]
El resultado podría cambiar dependiendo de los algoritmos que se tienen disponibles.
Ahora es más fácil encontrar el algoritmo que se busca y el nombre de línea de comando, en este caso saga:slopeaspectcurvature.
Una vez que se conoce el nombre de línea de comandos del algoritmo, el siguiente paso es determinar la sintaxis correcta para ejecutarlo. Eso significa saber que parámetros se necesitan y el orden en el que tienen para pasarlos cuando se llame al método runalg(). Hay un método para describir un algoritmo a detalle, que se puede utilizar para obtener una lista de los parámetros que requiere un algoritmo y las salidas que va a generar. Para obtener esta información, se puede utilizar el método alghelp (name_of_the_algorithm). Utilice el nombre de línea de comandos del algoritmo, no el nombre descriptivo completo.
Llamar al método con saga:slopeaspectcurvature como parámetro, se obtiene la siguiente descripción:
>>> processing.alghelp("saga:slopeaspectcurvature")
ALGORITHM: Slope, Aspect, Curvature
ELEVATION <ParameterRaster>
METHOD <ParameterSelection>
SLOPE <OutputRaster>
ASPECT <OutputRaster>
CURV <OutputRaster>
HCURV <OutputRaster>
VCURV <OutputRaster>
Ahora se tiene todo lo necesario para ejecutar cualquier algoritmo. Como ya hemos mencionado, sólo hay un solo comando para ejecutar algoritmos: runalg(). Su sintaxis es la siguiente:
>>> processing.runalg(name_of_the_algorithm, param1, param2, ..., paramN,
Output1, Output2, ..., OutputN)
La lista de parámetros y salidas para añadir dependen del algoritmo que se desean ejecutar, y es exactamente la lista que el método alghelp() le da, en el mismo orden que se muestra.
Dependiendo del tipo de parámetro, los valores se introducen de manera diferente. La siguiente lista da una rápida revisión de cómo introducir los valores para cada tipo de parámetro de entrada.
Raster Layer, Vector Layer or Table. Simply use a string with the name that identifies the data object to use (the name it has in the QGIS Table of Contents) or a filename (if the corresponding layer is not opened, it will be opened but not added to the map canvas). If you have an instance of a QGIS object representing the layer, you can also pass it as parameter. If the input is optional and you do not want to use any data object, use None.
Selección. Si un algoritmo tiene un parámetro de selección, el valor de ese parámetro debe ser introducido mediante un valor entero. Para conocer las opciones disponibles, se puede utilizar el comando algoptions(), como se muestra en el siguiente ejemplo
>>> processing.algoptions("saga:slopeaspectcurvature")
METHOD(Method)
0 - [0] Maximum Slope (Travis et al. 1975)
1 - [1] Maximum Triangle Slope (Tarboton 1997)
2 - [2] Least Squares Fitted Plane (Horn 1981, Costa-Cabral & Burgess 1996)
3 - [3] Fit 2.Degree Polynom (Bauer, Rohdenburg, Bork 1985)
4 - [4] Fit 2.Degree Polynom (Heerdegen & Beran 1982)
5 - [5] Fit 2.Degree Polynom (Zevenbergen & Thorne 1987)
6 - [6] Fit 3.Degree Polynom (Haralick 1983)
En este caso, el algoritmo tiene uno de tales parámetros, con siete opciones. Tenga en cuenta que ordenar en base cero.
La entrada múltiple. El valor es una cadena con descriptores de entrada separadas por punto y coma (;). Como en el caso de capas individuales o tablas, cada descriptor de entrada se puede el nombre del objeto de datos, o su ruta de archivo.
El campo de la tabla de XXX. Utilice una cadena con el nombre del campo a usar. Este parámetro es sensible a mayúsculas y minúsculas.
Tabla fija. Escribir la lista de todas las tablas de valores separadas por comas (,) y cerrar entre comillas ("). Los valores que empiezan en la fila superior y van de izquierda a derecha. También se puede utilizar un arreglo 2-D de valores que representen la tabla.
SRC. Introduzca el número del código EPSG del SRC deseado.
Extensión. Se debe utilizar una cadena con valores de xmin, xmax, ymin y ymax` separados por comas (,``).
Los parámetros boolean, archivo, cadena y numéricos no necesitan alguna explicación adicional.
Los parámetros de entrada tales como valores string, booleanos o numericos tienen valores predeterminados. Para utilizarlos, especificar None en la entrada del parámetro correspondiente.
Para objetos de datos de salida, escriba la ruta del archivo que se utilizará para guardarlo, del mismo modo que se hace desde la caja de herramientas. Si desea guardar el resultado a un archivo temporal, use None. La extensión del archivo determina el formato de archivo. Si se ingresa la extensión no reconocida por el algoritmo, el formato de archivo predeterminado par el tipo de salida se utilizará, y su extensión correspondiente anexa a la ruta del archivo dado.
Unlike when an algorithm is executed from the toolbox, outputs are not added to the map canvas if you execute that same algorithm from the Python console. If you want to add an output to the map canvas, you have to do it yourself after running the algorithm. To do so, you can use QGIS API commands, or, even easier, use one of the handy methods provided for such tasks.
El método runalg regresa un diccionario con los nombres de salida (los que se muestran en la descripción del algoritmo) como llaves y la ruta del archivo de esas salidas como valores. Se pueden cargar esas capas al pasar las rutas de archivo correspondientes al método load().
Apart from the functions used to call algorithms, importing the processing package will also import some additional functions that make it easier to work with data, particularly vector data. They are just convenience functions that wrap some functionality from the QGIS API, usually with a less complex syntax. These functions should be used when developing new algorithms, as they make it easier to operate with input data.
Below is a list of some of these commands. More information can be found in the classes under the processing/tools package, and also in the example scripts provided with QGIS.
values(layer, fields): Regresa los valores en la tabla de atributos de una capa vectorial, para los campos pasados. Los campos se pueden pasar como nombres de campos o como indices de archivos de base cero. Devuelve un diccionario de listas, con el identificador del campo pasado como llaves. Se considera la selección existente.
features(layer): Devuelve un iterador sobre las características de una capa vectorial, considerando la selección existente.
uniqueValues(layer, field): Devuelve una lista de valores únicos para un atributo dado. Los atributos se pueden pasar como un nombre de campo o indice de campo de base cero. Se considera la selección existente.
Puede crear sus propios algoritmos escribiendo código Python y añadiendo unas pocas líneas extras para suministrar información adicional necesaria para definir la semántica del algoritmo. Se puede encontrar en el menú guilabel:Crear nuevo script bajo el grupo Herramientas en el bloque de algoritmos Script de la caja de herramientas. Haga doble clic en él para abrir el diálogo de edición de script. Eso es donde debe escribir su código. Guarde el script en la carpeta scripts (la carpeta predeterminada cuando abre el diálogo del archivo guardado) con la extensión .py automáticamente crea el algoritmo correspondiente.
El nombre del algoritmo (el que podrá ver en la caja de herramientas) se crea a partir del nombre de archivo, la eliminación su extensión y la sustitución de guiones bajos con espacios en blanco.
Vamos a echar un vistazo a el siguiente código, que calcula el Índice de Humedad topográfica (TWI) directamente de un DEM.
##dem=raster
##twi=output
ret_slope = processing.runalg("saga:slopeaspectcurvature", dem, 0, None,
None, None, None, None)
ret_area = processing.runalg("saga:catchmentarea(mass-fluxmethod)", dem,
0, False, False, False, False, None, None, None, None, None)
processing.runalg("saga:topographicwetnessindex(twi), ret_slope['SLOPE'],
ret_area['AREA'], None, 1, 0, twi)
Como puede ver, el calculo implica tres algoritmos, todos ellos provenientes de SAGA. El último que calcula el TWI, pero se necesita una capa de pendientes y una capa de acumulación de flujo. No tenemos estas capas, pero ya tenemos el DEM, podemos calcularlas llamando a los algoritmos SAGA correspondientes.
La parte del código donde este procesamiento se lleva a cabo no es difícil de entender si ha leído las secciones anteriores de este capítulo. Las primeras líneas, sin embargo, necesitan alguna explicación adicional. Proporcionan la información que se necesita para convertir su código en un algoritmo que se puede ejecutar desde cualquiera de los componentes GUI, como la caja de herramientas o el modelador gráfico.
Estas líneas comienzan con un doble símbolo de comentario en Python (##) y tiene la siguiente estructura:
[parameter_name]=[parameter_type] [optional_values]
Aquí esta una lista de todos los tipos de parámetros que se admiten en scripts de procesamiento, su sintaxis y algunos ejemplos.
ráster. Una capa ráster.
vector. Una capa vectorial.
table. Una tabla.
número. Un valor numérico. Un valor por defecto debe ser proporcionado. Por ejemplo, depth=number 2.4.
string. Una cadena de texto. Como en el caso de valores numéricos, por defecto se debe añadir un valor. Por ejemplo, name=string Victor.
boolean. Un valor boolean. Añade True o False después para establecer el valor predeterminado. Por ejemplo, verbose=boolean True.
ráster múltiple. Un conjunto de capas ráster de entrada.
Vector múltiple. Un conjunto de capas vectoriales de entrada.
Campo. Un campo es la tabla de atributos de una capa vectorial. El nombre de la capa se tiene que añadir después de la etiqueta Campo. Por ejemplo, si ha declarado una vectorial de entrada con mylayer=vector, podría utilizar myfield=field mylayer para añadir un campo de esa capa como parámetro.
folder. Una carpeta.
file. A nombre de archivo.
El nombre del parámetro es el nombre que se mostrará al usuario cuando ejecuta el algoritmo, y también el nombre de variable a utilizar en la secuencia de código. El valor introducido por el usuario para ese parámetro se asignará a la variable con ese nombre.
Cuando muestra el nombre del parámetro al usuario, el nombre será editado para mejorar su apariencia, en sustitución de guiones bajos con espacios. Así, por ejemplo, si desea que el usuario vea un parámetro llamado Un valor numérico, puede utilizar el nombre de la variable A_numerical_value.
Layers and table values are strings containing the file path of the corresponding object. To turn them into a QGIS object, you can use the processing.getObjectFromUri() function. Multiple inputs also have a string value, which contains the file paths to all selected object, separated by semicolons (;).
Las salidas están definidas en una manera similar, utilizando los siguientes etiquetas:
ráster de salida
vector de salida
tabla de salida
html de salida
archivo de salida
número de salida
texto de salida
El valor asignado a las variables de salida es siempre una cadena con una ruta de archivo. Corresponderá a una ruta de archivo temporal en caso de que el usuario no haya introducido ningún nombre de archivo de salida.
When you declare an output, the algorithm will try to add it to QGIS once it is finished. That is why, although the runalg() method does not load the layers it produces, the final TWI layer will be loaded (using the case of our previous example), since it is saved to the file entered by the user, which is the value of the corresponding output.
No utilice el método load() en sus algoritmos de script, sino sólo cuando se trabaja con la línea de la consola. Si una capa es creada como salida de un algoritmo, debe ser declarada como tal. De lo contrario, usted no será capaz de utilizar correctamente el algoritmo en el modelador, ya que su sintaxis (según la definición de las etiquetas explicadas anteriormente) no coincidirá con lo que crea realmente el algoritmo.
Salidas ocultas (números y cadenas) no tienen un valor. En cambio, tiene que asignar un valor a los mismos. Para ello, basta con establecer el valor de una variable con el nombre que utilizó para declarar la salida. Por ejemplo, si ha utilizado esta declaración,
##average=output number
La siguiente linea establecerá el valor de salida a 5:
average = 5
Además de las etiquetas para los parámetros y resultados, también puede definir el grupo en las que se muestra el algoritmo, utilizando la etiqueta grupo.
Si su algoritmo toma mucho tiempo para procesar, es una buen idea informar al usuario. Se tiene una global llamada progreso disponible, con dos métodos posibles: setText(text) y setPercentage(percent) para modificar el texto y la barra de progreso.
Varios ejemplos son proporcionados. Por favor, consulte con ellos para ver ejemplos reales de cómo crear algoritmos utilizando las clases del marco de procesamiento. Haga clic derecho en cualquier script y seleccione Editar script para editar su código o sólo para verlo.
Al igual que en el caso de los modelos, puede crear documentación adicional para sus scripts, para explicar qué hacen y como utilizarlos. En el diálogo de edición de scripts, encontrará un botón [Editor de ayuda]. Haga clic en él y le llevará al diálogo de editor de ayuda. Compruebe la sección acerca del modelador gráfico para conocer más sobre este diálogo y cómo utilizarlo.
Los archivos de ayuda se guardan en el mismo folder como el script mismo, añadiendo la extensión .help al nombre del archivo. Tenga en cuenta que puede editar la ayuda de su script antes de guardarlo la primera vez. Si después cierra el diálogo de edición de script sin guardarlo (es decir, descartarlo), el contenido de la ayuda que escribió se perderá. Si su script ya fue guardado y tiene asociado un nombre de archivo, se guardara automáticamente.
Los scripts también pueden ser utilizados para establecer ganchos pre- y post ejecuciones, que se ejecutan antes y después de la ejecución de un algoritmo. Esto se puede utilizar para automatizar tareas que deben realizarse cada vez que se ejecuta un algoritmo.
La sintaxis es idéntica a la que se ha explicado anteriormente, pero una variable global adicional llamada alg está disponible, lo que representa el algoritmo que acaba de ser (o está a punto de ser) ejecutado.
En el grupo General del cuadro de diálogo de configuración de procesamiento se encuentran dos entradas llamadas Script preejecución y el :guilabel: Script postejecución donde el nombre de archivo de los scripts a ser ejecutados en cada caso se pueden introducir.