Tema 2

Automatización de tareas

11-14 Diciembre 2018

Curso avanzado ArcGIS - IEO

Ejecución de tareas en lotes (BATCH)

Las herramientas de geoprocesamiento se pueden ejecutar en un modo de lote que le permite ejecutar la herramienta varias veces utilizando muchos datasets de entrada o distintas configuraciones de parámetros. De este modo, es posible ejecutar una herramienta determinada tantas veces como sea necesario, con muy poca interacción

Ejecución de tareas en lotes (BATCH)

¿Automatización de tareas?

¿Necesito programar?

MODEL BUILDER

MODEL BUILDER

http://desktop.arcgis.com/es/arcmap/10.5/analyze/modelbuilder/

INTERFACE

¿Programación?

PROCESOS

¿SOLO ARCGIS TOOLS?

PARAMETROS

DATOS EJERCICIOS

EJERCICIO 1

Crear un modelo en el que se genere una geodatabase de ficheros, un dataset y finalmente se añada la capa "Lances viradas".

Deben ser parámetros, el path donde se almacenara la geodatabase y su nombre y el SRC del dataset.

Fácil???

Variable espacio de trabajo temporal y en memoria

%scratchworkspace%

"in_memory"

Variable espacio de trabajo temporal y en memoria

Escribir datos en el espacio de trabajo en memoria suele ser considerablemente más rápido que escribir en otros formatos, como por ejemplo, un shapefile o una clase de entidad de geodatabase. Sin embargo, los datos escritos en el espacio de trabajo en memoria son temporales y se eliminarán al cerrar la aplicación

SUSTITUCIÓN DE VARIABLES EN LÍNEA

%Variable%

SUSTITUCIÓN DE VARIABLES EN LÍNEA

En ModelBuilder, la ruta al valor o dataset de una variable se puede sustituir por otra variable incluyendo el nombre de la variable de sustitución entre signos de porcentaje (%VariableName%). Este tipo de sustitución de variables se denomina sustitución de variable en línea

SUSTITUCIÓN DE VARIABLES EN LÍNEA

Puede realizar la sustitución de variable en línea utilizando cualquiera de las variables de modelo o del sistema.

Variables de modelo: cualquier variable de un modelo.

Variable del sistema: ModelBuilder proporciona una variable de sistema incorporada, n, que se puede utilizar en flujos de trabajo de iteración. %n% corresponde al número de iteración en el modelo.

SUSTITUCIÓN DE VARIABLES EN LÍNEA

SUSTITUCIÓN DE VARIABLES EN LÍNEA

SUSTITUCIÓN DE VARIABLES EN LÍNEA

Solo se seleccionan las parcelas con ID=9 (el valor seleccionado por el usuario).

SUSTITUCIÓN DE VARIABLES EN LÍNEA

Calcular valor es una utilidad potente de ModelBuilder que permite calcular un valor basado en cualquier expresión de Python y utilizar dicho valor en su modelo. Puede utilizar la sustitución de variables de modelo para transferir valores de variables de modelo a la expresión Calcular valor de Python o utilizar el nombre de la variable de salida que almacena el valor calculado en otra herramienta del modelo.

SUSTITUCIÓN DE VARIABLES EN LÍNEA

LISTAS

LISTAS

Al abrir la variable de lista se mostrará la cuadrícula de lote en la que se introducen los valores de la variable. Después de conectar la variable de lista a una herramienta, esa herramienta y todos los procesos hacia abajo (los procesos que dependen de la salida de la herramienta) se ejecutarán una vez por cada valor de la lista.

Utilizar variables de lista equivale a utilizar lotes (Batch), con la única diferencia de que no es necesario proporcionar valores para otras variables de valor simple del modelo

LISTAS

Cuando se crea una variable de lista de salida en un modelo, puede utilizar %i% como sustitución de variables en línea en el nombre de salida. El valor que asigna corresponde al número en la lista.

PRECONDICIONES

Se pueden utilizar condiciones previas para controlar de forma explícita el orden de operaciones en un modelo. Por ejemplo, se puede ejecutar un proceso después de otro haciendo que la salida del primer proceso sea una condición previa para el segundo proceso.

Cualquier variable puede ser una condición previa para la ejecución de una herramienta, y cualquier herramienta puede tener más de una condición previa.

EJERCICIO 2

Crear un modelo en el que tengamos una variable de tipo string que será parámetro de entrada del proyecto.

Este modelo debe reproyectar todas las capas de lances al sístema Web Mercator y se deben almacenar como shapefiles en una carpeta que se debe crear desde el modelo. La carpeta se debe llamar "Shapefiles_reproyectados" y el path donde se cree esta carpeta debe ser un parámetro del modelo.

El nombre de cada nuevo shapefile debe llevar el nombre de la capa de origen y se debe añadir como sufijo la variable de tipo string que hemos creado.

ITERADORES

ITERADORES

Durante	Valores	Valor	-
WHILE	Valores	Booleano: valor verdadero o falso	-
Iterar selección de entidades	Entidades	no válida	Valor
Iterar selección de filas	de tabla	Grabar	Valor
Iterar valores de campo	de tabla	Valor de campo	-
Iterar valor múltiple	Valores	Valor	-
Iterar datasets	Espacio de trabajo o dataset de entidades	Dataset	Nombre
Iterar clases de entidades	Espacio de trabajo o dataset de entidades	Clase de entidad	Nombre
Iterar archivos	Carpeta	Archivo	Nombre
Iterar rásteres	Espacio de trabajo o Catálogo de ráster	Dataset ráster	Nombre
Iterar tablas	Espacio de trabajo	de tabla	Nombre
Iterar espacios de trabajo	Carpeta	Espacio de trabajo	Nombre

ITERADORES

Solo se puede utilizar un iterador por modelo. Las opciones para agregar otro iterador se desactivarán si existe un iterador en el modelo.

Si se agrega un iterador a un modelo, todas las herramientas del modelo se repetirán para cada valor en el iterador. Si no desea ejecutar cada herramienta del modelo para cada valor iterado, cree un submodelo/modelo dentro de un modelo o modelo anidado que contenga solo el iterador y agréguelo al modelo principal como una herramienta de modelo

ITERADORES

Si se exporta un modelo que contiene un iterador a una secuencia de comandos de Python, dicha secuencia no incluirá la lógica de iteración.

La salida de cualquier herramienta conectada al iterador puede tener (o requerir) un nombre único para cada iteración para evitar que se sobrescriban. Para evitarlo se pueden usar las variables en linea.

RETROALIMENTACIÓN

RETROALIMENTACIÓN

HERRAMIENTAS SOLO MODEL BUILDER

Calcular valor	La herramienta Calcular valor devuelve un valor a partir de una expresión de Python especificada.
Adquirir valores	La herramienta Adquirir valores está diseñada para adquirir los valores de salida de un iterador o para convertir una lista de valores múltiples en una entrada simple. La salida de la herramienta Adquirir valores se puede utilizar como entrada de herramientas como Fusionar, Adjuntar, Mosaico y Estadísticas de celdas.
Obtener valor de campo	La herramienta Obtener valor de campo obtiene el valor de la primera fila de una tabla para el campo especificado.
Fusionar rama	La herramienta Fusionar rama fusiona dos o más ramas lógicas en una única salida.
Analizar ruta	La herramienta Analizar ruta analiza la entrada a su archivo, ruta, nombre o extensión. La salida se puede utilizar como variables en línea en el nombre de salida de otras herramientas.
Seleccionar datos	La herramienta Seleccionar datos selecciona los datos de un elemento de datos principal, como una carpeta, un dataset de entidades o una cobertura.
Detener	Para el conjunto de valores de entrada, la iteración se detendrá si todos los valores de entrada cumplen la condición especificada de Verdadero o Falso. Es funcionalmente similar al iterador While, pero es útil para detener un modelo si hay un iterador While en un modelo y no se pueden agregar más iteradores.

EJEMPLOS DE USO

RAMIFICACIÓN

Es una herramienta del paquete de herramienta exclusivo de Model Builder. Permite crear ramas siguiendo una lógica if-else.

IF-THEN-ELSE

INTEGRAR UN MODELO EN OTRO

INTEGRAR UN MODELO EN OTRO

INTEGRAR UN MODELO EN OTRO

EJERCICIO 3

Crear una herramienta de model builder en la que se cree un dataset nuevo (src = WGS 84).

Esta herramienta debe recorrer todas las capas de lances y debe ejecutar una herramienta que haga un buffer cuatro veces, cada vez que se ejecute el buffer se debe utilizar como entrada el resultado del buffer anterior. Se debe almacenar el resultado en el dataset creado desde el modelo.

EJERCICIO 4

Crear un modelo que acepte un raster como parámetro de entrada. A partir de este raster crear un raster de pendiente, un raster de orientación, un raster de curvatura.

Posteriormente con la herramienta Isocluster crear un shapefile de polígono en el que el usuario pueda seleccionar donde quiere almacenarlo, con que nombre, y cuantas clases debe tener este shapefile.

Añadir todos los raster (inclusive el de parámetro de entrada) y el shapefile a la vista de mapa actual

INTEGRAR PROGRAMAS EXTERNOS

http://desktop.arcgis.com/es/arcmap/10.5/analyze/modelbuilder/integrating-external-programs-within-a-model.htm

EXPORTAR UN MODELO

Si se van a sobreescribir los datos, hay que establecer la propiedad arcpy.env.overwriteOutput a Verdadero.

Si el modelo utilizó capas o vistas de tabla que no se crearon dentro del modelo original, esas capas o vistas de tabla se deberán crear en la secuencia de comandos mediante las herramientas "Crear capa de entidades" y "Crear vista de tabla".

Los elementos de datos del modelo se convierten directamente en variables en la secuencia de comandos que se exportó. Hay que evitar los nombres de elementos de datos que serán incompatibles en Python (por ejemplo, class, global y return).

arcpy.env.overwriteOutput = true

Si el modelo utilizó cualquier sustitución de variable en línea como %workspace%, %scratchworkspace%, %n%, %i% o %variable name%, será necesario sustituirla por el valor correcto.

Si el modelo utilizó un iterador, la lógica de iteración no se exportará y deberá ser reemplazada por los estamentos de bucle en Python.

Solo se exportará el primer valor de una variable de lista.

Si el modelo utilizó un conjunto de entidades o conjunto de registro, el código siguiente se creará en la exportación.

Feature_Set = arcpy.GetParameterAsText(0)
if Feature_Set == '#' or not Feature_Set:
    Feature_Set = "in_memory\\{F15C6411-0F4F-4A68-9BAC-29D6E7874669}"
# provide a default value if unspecified

El código intenta proteger contra una entrada nula o no válida al establecer la variable Feature_Set en una clase de entidad.

Como la clase de entidad in_memory no existirá en el momento de la ejecución, se debe actualizar la ruta para que durante la ejecución señale a una clase de entidad que se sepa que existe. También se puede cambiar la lógica para lanzar un mensaje de error y detener la ejecución si eso tiene sentido para el flujo de trabajo.

Herramientas exclusivas de Model Builder tales como "Fusionar ramas", "Capturar valores" o "Calcular valor", no se ejecutaran en Python. Es necesario implementar el equivalente de las funcionalidades de Python que estas herramientas proporcionan. Por ejemplo, deberá utilizar si/otra lógica de ramificación en la secuencia de comandos.

Si el modelo incluye submodelos, el contenido dentro de estos submodelos no se exporta. En lugar de eso, la caja de herramientas tendrá que ser referenciada y la herramienta de modelo tendrá que ser llamado dentro de la secuencia de comandos.

PROGRAMAR TAREAS EN OS WINDOWS

Se puede ejecutar un modelo de geoprocesamiento a una hora determinada del día o configurar que el modelo se ejecute repetidamente en algún intervalo de tiempo.

Quizá el modelo tarda mucho en ejecutarse y se quiere que los resultados estén disponibles todos los días a una hora determinada. Puede programar la ejecución de un modelo a una hora determinada y con una frecuencia concreta mediante el Programador de tareas de Windows y unas líneas de código de Python.

PROGRAMAR TAREAS EN OS WINDOWS

PROGRAMAR TAREAS EN OS WINDOWS

import arcpy
arcpy.ImportToolbox(r"C:\path\myToolbox.tbx")
arcpy.myModel(r"c:\pathToInput\inputFolder", r"C:\pathToGdb\output.gdb")

PROGRAMAR TAREAS EN OS WINDOWS

https://pro.arcgis.com/es/pro-app/help/analysis/geoprocessing/modelbuilder/scheduling-a-model-run.htm

ARCPY

¿Qué es ArcPy?

ArcPy es un paquete de Python que se basa en el exitoso módulo arcgisscripting y lo sucede. Su objetivo es crear la piedra angular para una manera útil y productiva de realizar análisis de datos geográficos, conversión de datos, administración de datos y automatización de mapas con Python.

¿Qué es ArcPy?

¿Qué es ArcPy?

Python es un lenguaje de programación de propósito general, sencillo de aprender, orientdo a objetos y dinamicamente tipado.

Es adecuado para el trabajo interactivo y la creación rápida de prototipos en programas únicos conocidos como secuencias de comandos, además de ofrecer potencia suficiente como permitir la escritura de aplicaciones grandes.

Las aplicaciones ArcGIS escritas con ArcPy se benefician del desarrollo de módulos adicionales en numerosos nichos de Python por parte de profesionales del SIG y programadores de muchas disciplinas diferentes.

¿Qué es ArcPy?

Es en la actualidad la opción que cumple en mayor medida con los procesos de automatización y rendimiento de ArcGIS.

Vocabulario esencial en ArcPy

ArcPy modules

Un módulo es un archivo de Python que generalmente incluye funciones y clases. ArcPy es compatible con una serie de módulos, incluido un módulo de acceso de datos (arcpy.da), un módulo de representación cartográfica (arcpy.mapping), un módulo de ArcGIS Spatial Analyst (arcpy.sa) y un módulo de ArcGIS Network Analyst (arcpy.na).

ArcPy classes

Una clase es similar a un plano arquitectónico. El plano ofrece el marco sobre cómo crear algo. Las clases se pueden utilizar para crear objetos, que comúnmente se denominan instancias. Las clases de ArcPy, como las clases SpatialReference y Extent, generalmente se utilizan como accesos rápidos de teclado para completar los parámetros de la herramienta de geoprocesamiento que de lo contrario tendrían un equivalente de cadena de texto más complicado.

ArcPy functions

Una función es una funcionalidad definida que realiza una tarea específica y se puede incorporar a un programa más amplio.

Todas las herramientas de geoprocesamiento se proporcionan como funciones, pero no todas las funciones son herramientas de geoprocesamiento. Además de herramientas, ArcPy proporciona diversas funciones para brindar mayor soporte a los flujos de trabajo de geoprocesamiento de Python. Las funciones (que con frecuencia se denominan métodos) se pueden utilizar para enumerar ciertos datasets, recuperar las propiedades de un dataset, validar el nombre de una tabla antes de agregarlo a una geodatabase o realizar muchas otras tareas de secuencia de comandos útiles.

Como cargar y usar ArcPy

Para comenzar, es recomendable aprender los principios básicos de Python. Para poder usar Python dentro de un GIS, necesitamos aprender la sintaxis, los tipos de datos, los comandos, las funcionalidades integradas, los bucles, etc.

No es necesario saber el idioma de la A a la Z para usarlo dentro de un SIG: con algunos conocimientos básicos podemos ponernos al día rápidamente y usarlo dentro de ArcGIS. Es posible enlazar procesos GIS en un script de Python sin apenas haber utilizado más que lo esencial de este lenguaje.

Como cargar y usar ArcPy

ArcGIS Desktop ya viene con Python instalado automáticamente (v. 2.7).

Ventana de Python en ArcGIS Desktop.
Script de Python (Extensión *.py).

Como cargar y usar ArcPy

>>> import arcpy

>>> help(arcpy)

Ventana de Python en ArcGIS Desktop

Ventana de Python en ArcGIS Desktop

EJERCICIO 5

Reproyectar el raster de batimetría a WGS84, calcular la pendiente del raster resultante. Imprimir en pantalla el valor de la extensión del raster resultante.

*Tip: Buscar las propiedades de la clase raster de Arcpy

Introducción a Python
Operaciones Básicas

Lenguaje de Bajo Nivel: Lenguaje de máquina, líneas de código binario. Traducen lenguajes de alto nivel.

Lenguaje de Alto Nivel: Escribir programas de manera mucho mas intuitivas. Paradigma de la programacción orientada a objetos

Python Lenguaje Interpretado

IDE (Integrated Development Environment )

Un entorno de desarrollo integrado o entorno de desarrollo interactivo, es una aplicación informática que proporciona servicios integrales para facilitarle al desarrollador o programador el desarrollo de software

Prompt

Editor

Programación Orientada a Objetos

Programación Orientada a Objetos

La programación orientada a objetos es un paradigma de la programación que está basado en el concepto de los OBJETOS, los cuales son estructuras contenedoras de datos y código que realizan funciones (métodos).

Los principales componentes de la programación orientada a objetos son los objetos, las clases, los métodos y las propiedades

Programación Orientada a Objetos

La programación orientada a objetos es un paradigma de la programación que está basado en el concepto de los OBJETOS, los cuales son estructuras contenedoras de datos y código que realizan funciones (métodos).

Los principales componentes de la programación orientada a objetos son los objetos, las clases, los métodos y las propiedades

Variables en Python

Strings
Integer
Float
Boolean
Listas
Tuplas
Objects...?

Como definir una variable en Python

mi_variable = valor_de_mi variable
No es nececsario definir el tipo
Importante indentacion en sintaxis

Como definir una variable en Python

mi_variable = "perro"   

mi_variable = 3

mi_variable = 3.2353456

mi_variable = {2,8,9}

mi_variable = True

mi_variable = (25, "Mayo", 1810)

mi_variable = {'x': 2, 'y': 1, 'z': 4}



#Para saber el tipo de mi variable usamos la función type

mi_variable = "perro"

type(mi_variable )    #me devuelve <tipe 'str'>

Como definir una variable en Python

mi_variable = "perro"   

mi_variable = 3

mi_variable = 3.2353456

mi_variable = [2,8,9]

mi_variable = True

mi_variable = (25, "Mayo", 1810)

mi_variable = {'x': 2, 'y': 1, 'z': 4}



#Para saber el tipo de mi variable usamos la función type

mi_variable = "perro"

type(mi_variable )    #me devuelve <tipe 'str'>

Operadores en Python

Listas y Tuplas




tupla = (1,2,3,4,5,6,7,8,9,10)
lista = [1,2,3,4,5,6,7,8,9,10]



#Las tuplas ocupan un menor tamaño en disco
print(tupla.__sizeof__()) # 52 bytes
print(lista.__sizeof__()) # 60 bytes

#no podemos alterar una tupla o dara error
tupla[0] = 20
print("%s %s" % ("Lista:",tupla))
#TypeError: 'tuple' object does not support item assignment

#en cambio si podemos alterar una lista por su posición
lista[0] = 20
print("%s %s" % ("Lista:",lista))
# Lista: [20, 2, 3, 4, 5, 6, 7, 8, 9, 10]


#Los strings se comportan como una tupla
mi_var = 'Perro'
print mi_var[2]
# r

materias = {}

materias["lunes"] = [6103, 7540]
materias["martes"] = [6201]
materias["miércoles"] = [6103, 7540]
materias["jueves"] = []
materias["viernes"] = [6201]

print materias["lunes"]
[6103, 7540]


#También podemos crear un diccionario mediante la función dict
materias = dict(lunes = [6103, 7540], martes = [6201])

#Muy utiles para determinar propiedades de objetos y sus valores correspondeintes
Simbologia_carretera = {'size':2, 'color':'255,0,220', 'name':'Carretera', 'posicionTOC':4}

#Con la función list() o el método keys() obtenemos las claves
list(Simbologia_carretera ) ó Simbologia_carretera.keys()
#['color', 'posicionTOC', 'name', 'size']

#Con la funcion values() obtenmos los valores de estas claves
Simbologia_carretera.values()
#['255,0,220', 4, 'Carretera', 2]

Diccionarios en Python

Funciones

def nombre_funcion (argumento1, argumento2,...):

el cuerpo de la función


def mifuncion (arg1, arg2, arg3):
    print "", arg1, " , ", arg2, " , ", arg3

mifuncion("mi","primera","funcion")

# mi , primera , funcion



def mioperacion(cifra1, cifra2, cifra3):
    resultado = cifra1 * 4 + (cifra2 + cifra3) * 3-10
    print resultado

mioperacion(1,4,5)
# 21

class Empleado:
   #'Variable de toda la clase Empleados'
   empCount = 0

   def __init__(self, nombre, salario):
      self.nombre= nombre     #Esto es una propiedad
      self.salario = salario
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Empleados %d" % Empleado.empCount

   def displayEmployee(self):    #Esto es un método
      print "Nombre : ", self.nombre,  ", Salario: ", self.salario


"Esto crearía el primer objeto de la clase Empleado"
emp1 = Employee("Zara", 2000)
"Esto crearía el segundo objeto de la clase Empleado"
emp2 = Employee("Manni", 5000)


emp1.displayEmployee()
emp2.displayEmployee()
print "Total Empleados %d" % Empleado.empCount

#Nombre :  Zara, Salario:  2000
#Nombre :  Manni, Salario:  5000
#Total Empleados 2

Clases

Herencia

A través de ella los diseñadores pueden crear nuevas clases partiendo de una clase o de una jerarquía de clases preexistente (ya comprobadas y verificadas) evitando con ello el rediseño, la modificación y verificación de la parte ya implementada.

La herencia facilita la creación de objetos a partir de otros ya existentes e implica que una subclase obtiene todo el comportamiento (métodos) y eventualmente los atributos (variables) de su superclase

Condiciones y Bucles

Tanto las condiciones como los bucles se estructuran en bloques
Hay que mantener la indentación en la sintaxis

BLOQUE 1:

BLOQUE 2:

BLOQUE 3:

Condiciones if-else elif

num = 6

if num == 5:
    print "La variable num es el número 5"
else:
    print "La variable num no es el número 5"

Existen IDEs nos ayudan a mantener la indentación de los bloques.
Hay que escribir los dos puntos siempre después de una condición.
Hay que usar operadores lógicos en la condición (<, >, ==, !=, <>, ===,...)

Condiciones if-else elif

edad = int(input("¿Cuántos años tiene? "))
if edad < 0:
    print("No se puede tener una edad negativa")
elif edad < 18:
    print("Es usted menor de edad")
else:
    print("Es usted mayor de edad")

                                                # Uno de estos dos programas no funcionará


edad = int(input("¿Cuántos años tiene? "))
if edad < 18:
    print("Es usted menor de edad")
elif edad < 0:
    print("No se puede tener una edad negativa")
else:
    print("Es usted mayor de edad")

Bucles: For

Bucles: For

personas = ["Persona 1", "Persona 2", "Persona 3", "Persona 4"]

for persona in personas:
    print "Hay alguna persona?"
    print persona
print '\n'
print "No hay ninguna persona"


#Hay alguna persona?
#Persona 1
#Hay alguna persona?
#Persona 2
#Hay alguna persona?
#Persona 3
#Hay alguna persona?
#Persona 4


#No hay ninguna persona

Bucles: While

WHILE (condición):

comandos dentro de este bucle

Atención imprescindible: condición = condición +1

Bucles: While


count = 0
while (count < 9):
   print 'The count is:', count
   count = count + 1

print "Good bye!"


# The count is: 0
# The count is: 1
# The count is: 2
# The count is: 3
# The count is: 4
# The count is: 5
# The count is: 6
# The count is: 7
# The count is: 8
# Good bye!

Switch-Case en Python?

def f(x):
    return {
        'a': 1,
        'b': 2,
    }.get(x, 9)    # 9 es el valor por defecto si no existe x

Try - Exception

import arcpy
import sys
try:
    # Ejecuta la herramienta Buffer
    #
    arcpy.Buffer_analysis("c:/transport/roads.shp", "c:/transport/roads_buffer.shp")
except Exception:
    e = sys.exc_info()[1]
    print(e.args[0])
    
    # Si se usa este condigo en un script para una herramienta,
    #se puede usar el método AddError para devolver los menssajes a la herrramienta
    arcpy.AddError(e.args[0])

Trabajando con paths

inputfc = "C:/Datos/Tema2/Ejercicios/Shapes/lances.shp"


inputfc = "C:\\Datos\\Tema2\\Ejercicios\\Shapes\\lances.shp"


inputfc = r"C:\Datos\Tema2\Ejercicios\Shapes\lances.shp"

Tres maneras de especificar paths en Python:

Usando un simple"/"
Usando dos "\\"
Usando un string literal con la letra r

Trabajando con Modulos

#Importar el módulo entero

import arcpy

arcpy.env.workspace = "C:/data"



#Importar una función del módulo

from arcpy import env

env.workspace = "C:/data"

Obtener parámetros de entrada

#Obtener parámetros con módulo sys

import sys

infile = sys.argv[0]

outpath = sys.argv[1]

outnamefile = sys.argv[2]




#Obtener parámetros con módulo arcpy para crear una herramienta de script

import arcpy

infile = arcpy.GetParameterAsText(0)

infile = arcpy.GetParameterAsText(1)

outnamefile = arcpy.GetParameterAsText(2)

EJERCICIO 6

Crear una lista con los días de la semana.

Con un bucle recorrer esta lista e ir añadiendo e un diccionario en el que la llave de cada entrada sea el nombre de la semana y el valor de cada llave sea la segunda letra del nombre de la semana.

SCRIPTING CON ARCPY

import arcpy

USANDO HERRAMIENTAS

import arcpy

arcpy.env.workspace = "C:/Data/study.gdb"

arcpy.analysis.Clip("streams", "interestarea", "result")


#Como saltar argumentos opcionales
arcpy.Buffer_analysis("roads", "buffer", "100 METERS")


arcpy.Buffer_analysis("roads", "buffer", "100 METERS", "", "", "LIST", "Code")

USANDO TOOLBOXES

import arcpy

#Se importa la toolbox y se define el alias que se le quiere dar para usarlo posteriormente

arcpy.ImportToolbox("C:/Data/sampletools.tbx", "mytools")


#Las herramientas se pueden invocan de las siguientes dos formas

arcpy.NombreHerramienta_mytools(<parametros>)

arcpy.mytools.NombreHerramienta(<parametros>)


#Se puede acceder a la ayuda de una herramienta y ver los parámetros necesarios de la siguiente forma
print help (arcpy.Clip_analysis)

FUNCIONES Y CLASES EN ARCPY

import arcpy

#Funciones

arcpy.Exist("C:/Data/lances.shp") #En este caso devuelve un booleano




#Clases

#<classname>.<property> = <value> 
import arcpy
arcpy.env.workspace = "C:/Data"


#Inicializar una nueva instancia de un objeto
import arcpy
prjfile = "C:/Data/myprojection.prj"
spatialref = arcpy.SpatialReference(prjfile)

#Acceder a alas propiedades y métodos del objeto
prjtext = spatialref.exportToString()

FUNCIONES Y CLASES EN ARCPY

import arcpy

#Funciones

arcpy.Exist("C:/Data/lances.shp") #En este caso devuelve un booleano




#Clases

#<classname>.<property> = <value> 
import arcpy
arcpy.env.workspace = "C:/Data"


#Inicializar una nueva instancia de un objeto
import arcpy
prjfile = "C:/Data/myprojection.prj"
spatialref = arcpy.SpatialReference(prjfile)

#Acceder a alas propiedades y métodos del objeto
prjtext = spatialref.exportToString()

FUNCIONES Y CLASES EN ARCPY

import arcpy

out_path = "C:/Data"
out_name = "lines.shp"
prjfile = "C:/Data/myprojection.prj"

spatialref = arcpy.SpatialReference(prjfile)

arcpy.CreateFeatureclass_management(out_path, out_name, "POLYLINE", "", "", "", spatialref)

MENSAJES DE LAS HERRAMIENTAS

Función: arcpy.GetMessage({severity})

Parámetro

Explicación

severity

El nivel de "severidad del mensaje de vuelto.

0 —messages returned.
1 —warning messages returned.
2 —error messages returned.

Si no se especifica devuelve todos los mensajes.

(El valor predeterminado es 0)

MENSAJES DE LAS HERRAMIENTAS

import arcpy

fc = arcpy.GetParameterAsText(0)

arcpy.GetCount_management(fc)

# Imprime el primer y último mensaje devuelto por la última
#  herramienta ejecutada (GetCount)
message_count = arcpy.GetMessageCount()
print(arcpy.GetMessage(0))
print(arcpy.GetMessage(message_count - 1))

MENSAJES DE LAS HERRAMIENTAS

import arcpy

arcpy.env.workspace = "c:/base/data.gdb"

# Check si existe la capa con el buffer y si no la elimina
if arcpy.Exists("pescaBuffer"):
    arcpy.Delete_management("pescaBuffer")

#Ejecuta la herramienta Buffer e imprime un mensaje de completado.
#Si falla imprime el mensaje de error
try:
    arcpy.Buffer_analysis("Roads", "pescaBuffer", "100 metres")
    arcpy.AddMessage("Buffer complete")

except:
    arcpy.AddError(arcpy.GetMessages(2))

FUNCIÓN DESCRIBING

arcpy.Describe({input dataset})

Devuelve un objeto de la clase Describe

import arcpy

desc = arcpy.Describe("c:/Data/streams.shp")

print desc.shapeType

http://desktop.arcgis.com/es/arcmap/10.5/analyze/arcpy-functions/describe-object-properties.htm

FUNCIÓN DESCRIBING

import arcpy

# Get the layer as a parameter and describe it.
#
# The layer could be a layer in ArcMap (like "some_layer")
# Or, it could be a .lyr file (like "C:/data/some.lyr")
#
layerString = arcpy.GetParameterAsText(0)
desc = arcpy.Describe(layerString)

# Print selected layer and describe object properties
# 
print("Name: {}".format(desc.name))
if hasattr(desc, "layer"):
    print("Layer name: {}".format(desc.layer.name))
    print("Layer data source: {}".format(desc.layer.catalogPath))
    print(".lyr file: {}".format(desc.catalogPath))
else:
    print("Layer name: {}".format(desc.name))
    print("Layer data source: {}".format(desc.catalogPath))

if desc.FIDSet != '':
    print("Number of selected features: {}".format(len(desc.FIDSet.split(";"))))

FUNCIONES PARA LISTAR DATOS

Se usan para realizar un inventario de datos disponibles.
Devuelven una lista de Python.
El principal uso de estas listas es para su uso en bucles dentro del script
Las funciones de listas de ArcPy incluyen ListFields, ListIndexes, ListDatasets, ListFeatureClasses, ListFiles, ListRasters, ListTables, ListWorkspaces y ListVersions.

FUNCIONES PARA LISTAR DATOS

ListFeatureClasses ( {wild_card}, {feature_type}, {feature_dataset} )

ListFeatureClasses devuelve una lista de feature classes del workspace actual. La sintesis sería la siguiente:

import arcpy
from arcpy import env

env.workspace = "C:/Data/Lances"

fclist = arcpy.ListFeatureClasses()

print fclist

#[u'lances_prueba1', u'lances_prueba2', u'lances_prueba3', u'lances_prueba4']

FUNCIONES PARA LISTAR DATOS

import os
import arcpy

arcpy.env.workspace = "c:/Data"

# Usamos la función ListFeatureClasses que devuelve una lista de nombres shapefiles.
featureclasses = arcpy.ListFeatureClasses()

# Copiamos los shapefiles a una geodatabase
for fc in featureclasses:
    arcpy.CopyFeatures_management(
        fc, os.path.join("c:/base/output.gdb",
                         os.path.splitext(fc)[0])) #Eliminamos la extensión del nombre

MANIPULACIÓN DE DATOS ESPACIALES: CURSORES

Un cursor es un objeto de acceso a datos que se puede utilizar para recorrer el conjunto de filas de una tabla o insertar nuevas filas en una tabla. Los cursores tienen tres formas: búsqueda, inserción o actualización. Los cursores se utilizan normalmente para leer geometrías existentes y escribir geometrías nuevas.

MANIPULACIÓN DE DATOS ESPACIALES: CURSORES

Cada tipo de cursor se crea con una función de ArcPy (SearchCursor, InsertCursor o UpdateCursor).

Cursor Explicación

arcpy.InsertCursor(dataset, {spatial_reference})	Inserta filas
arcpy.SearchCursor(dataset, {where_clause}, {spatial_reference}, {fields}, {sort_fields})	Acceso de solo lectura
arcpy.UpdateCursor(dataset, {where_clause}, {spatial_reference}, {fields}, {sort_fields})	Actualiza o elimina filas

MANIPULACIÓN DE DATOS ESPACIALES: CURSORES

Los cursores de búsqueda o de actualización se pueden recorrer en un bucle for.

Se puede navegar a los cursores en la dirección de avance; no permiten retroceder y recuperar filas que ya hayan sido recuperadas. Si una secuencia de comandos necesita pasar varias veces por los datos, se puede invocar el método de cursor reset.

MANIPULACIÓN DE DATOS ESPACIALES: CURSORES

El objeto Cursor contiene una lista de objetos tipo row, que representa cada una de las filas de la tabla del dataset de entrada.

Método	Explicación
deleteRow (row)	Deletes a row in the database. The row corresponding to the current position of the cursor will be deleted.
insertRow (row)	Inserts a new row into the database.
newRow ()	Creates an empty row object.
next ()	Returns the next object at the current index.
reset ()	Sets the current enumeration index (used by the next method) back to the first element.
updateRow (row)	The updateRow method can be used to update the row at the current position of an update cursor.

Métodos del objeto Cursor

MANIPULACIÓN DE DATOS ESPACIALES: CURSORES

import arcpy

cursor = arcpy.SearchCursor(fc, ['fieldA', 'fieldB'])
for row in cursor:
    print(row)

import arcpy

#En los cursores se puede usar la instrucción with

with arcpy.SearchCursor(fc, ['fieldA', 'fieldB']) as cursor:
    for row in cursor:
        print(row)

INSERT CURSOR

import arcpy

# Se crea un objeto insert cursor para la tabla
rows = arcpy.InsertCursor("c:/base/data.gdb/lances_pesca")

# Se crean 25 nuevas filas. Se definen el valor de ID y del campo distancia para cada fila
for x in range(1, 26):
    row = rows.newRow()
    row.setValue("rowid", x)
    row.setValue("distance", 100)
    rows.insertRow(row)

# Se eliminan los objetos cursor y row para evitar "locks" en los datos
del row
del rows

Sintaxis:

InsertCursor (dataset, {spatial_reference})

SEARCH CURSOR

import arcpy

# Open a searchcursor
#  Input: C:/Data/Counties.shp
#  Fields: NAME; STATE_NAME; POP2000
#  Sort fields: STATE_NAME A; POP2000 D
rows = arcpy.SearchCursor("c:/data/counties.shp",
                          fields="NAME; STATE_NAME; POP2000",
                          sort_fields="STATE_NAME A; POP2000 D")

# Iterate through the rows in the cursor and print out the
# state name, county and population of each.
for row in rows:
    print("State: {0}, County: {1}, Population: {2}".format(
        row.getValue("STATE_NAME"),
        row.getValue("NAME"),
        row.getValue("POP2000")))

Sintaxis:

SearchCursor (dataset, {where_clause}, {spatial_reference}, {fields}, {sort_fields})

UPDATE CURSOR

import arcpy

arcpy.env.workspace = 'c:/data/output.gdb'
fc = 'c:/data/base.gdb/roads'
fields = ['ROAD_TYPE', 'BUFFER_DISTANCE']

# Create update cursor for feature class 
with arcpy.da.UpdateCursor(fc, fields) as cursor:
    # Update the field used in Buffer so the distance is based on road 
    # type. Road type is either 1, 2, 3, or 4. Distance is in meters. 
    for row in cursor:
        # Update the BUFFER_DISTANCE field to be 100 times the 
        # ROAD_TYPE field.
        row[1] = row[0] * 100
        cursor.updateRow(row) 

# Buffer feature class using updated field values
arcpy.Buffer_analysis(fc, 'roads_buffer', 'BUFFER_DISTANCE')

Sintaxis:

UpdateCursor (in_table, field_names, {where_clause}, {spatial_reference}, {explode_to_points}, {sql_clause})

SELECT LAYER

ATRIBUTOS Y GEOMETRÍA

Sintaxis:

Agrega, actualiza o quita una selección en una capa o vista de tabla basada en una consulta de atributos.

SelectLayerByAttribute_management (in_layer_or_view, {selection_type}, {where_clause})

Selecciona entidades en una capa con base en una relación espacial con las entidades de otra capa.

SelectLayerByLocation_management (in_layer, {overlap_type}, {select_features}, {search_distance}, {selection_type}, {invert_spatial_relationship})

SELECT LAYER

ATRIBUTOS Y GEOMETRÍA

# Name: ExtactFeaturesByLocationAndAttribute.py
# Description: Extract features to a new feature class based on a spatial relationships to
#another layer AND an attribute query
 
# Import system modules
import arcpy

# Set the workspace
env.workspace = "c:/data/mexico.gdb"

# Make a layer from the feature class
arcpy.MakeFeatureLayer_management("cities", "lyr") 
 
# Select all cities which overlap the chihuahua polygon
arcpy.SelectLayerByLocation_management("lyr", "intersect", "chihuahua", 0, "new_selection")

# Within selected features, further select only those cities which have a population > 10,000   
arcpy.SelectLayerByAttribute_management("lyr", "SUBSET_SELECTION", ' "population" > 10000 ')
 
# Write the selected features to a new featureclass
arcpy.CopyFeatures_management("lyr", "chihuahua_10000plus")

TRABAJAR CON GEOMETRIAS (TOKENS)

SHAPE@XY —Una tupla de las coordenadas x,y del centroide de la entidad.
SHAPE@TRUECENTROID —Una tupla de las coordenadas x,y del centroide verdadero de la entidad.
SHAPE@X —Un doble de la coordenada x de la entidad.
SHAPE@Y —Un doble de la coordenada y de la entidad.
SHAPE@Z —Un doble de la coordenada z de la entidad.
SHAPE@M —Un doble del valor m de la entidad.
SHAPE@JSON — Cadena de caracteres JSON de Esri que representa la geometría.
SHAPE@WKB —Representación binaria conocida (WKB) para geometría OGC. Ofrece una representación portátil de un valor de geometría como una transmisión contigua de bytes.
SHAPE@WKT —Representación en texto conocida (WKB) para geometría OGC. Ofrece una representación portátil de un valor de geometría como cadena de caracteres.
SHAPE@ —Objeto de geometría para la entidad.
SHAPE@AREA —Un doble del área de la entidad.
SHAPE@LENGTH —Un doble de la longitud de la entidad.
OID@ —Valor del campo ObjectID.

TRABAJAR CON GEOMETRIAS (TOKENS)

import arcpy

fc = "C:/Data/lances_pesca.shp"
cursor = arcpy.SearchCursor (fc, ["SHAPE@XY"])
for row in cursor:
    x, y = row[0]
    print("{0}, {1}".format(x,y))

TRABAJAR CON GEOMETRIAS (TOKENS)

import arcpy

from arcpy import env

env.workspace = "C:/Data"

fc = "lances_pesca.shp"

cursor = arcpy.SearchCursor (fc, ["OID@", "SHAPE@"])

for row in cursor:
    print ("Feature {0}: ".format(row[0]))
    for point in row[1].getPart(0):
        print("{0}, {1}".format(point.X, point.Y))

CREAR HERRAMIENTAS PERSONALIZADAS

Un script de Python (*.py) puede ser ejecutado de dos formas diferentes:

Como un script independiente: Esto significa que el escript se ejecuta desde el sistema operativo o desde un editor de Python. Para jecutar un geoprocesamiento de Arcpy es necesario que ArcGis for Desktop este instalado y licenciado pero no es necesario que esté abierto.
Como una herramienta dentro de ArcGIS: En este caso el script está includio dentro de una herrmienta para ser ejecutado dentro de una aplicación de ArcGIS Desktop. Puede ser llamado desde otros scripts, modelos y herramientas.

CREAR HERRAMIENTAS PERSONALIZADAS

Hay una serie de venajas de usar un script dentro de una herramienta con respecto a ejecutarlo stand-alone

Una herramienta incluye una caja de dialogo de ArcGIS, lo cual facilita al usuario introducir parámetros y chequear errores.

Una herramienta es accesible desde el Catalog, la ventana Search y ArcMap. También es posible usar la herramienta en Model Builder y en la ventana de Python, o llamarla desde otro script.

Una herramienta esta totalmente integrada en la aplicación. Esto significa que se le pueden pasar las variables de entorno desde la aplicación, como ArcMap.

CREAR HERRAMIENTAS PERSONALIZADAS

Desde una herramientas es posible escribir mensajes en la ventana Results.

Se puede crear documentación tal y como la existente en las herramientas ya integradas en el sistema.

Una herramienta bien diseñada hace que el usuario no tenga porque tener conocimientos de Python para usarla y entenderla.

CREAR HERRAMIENTAS PERSONALIZADAS

1. Crear un script de Python y salvarlo en un archivo *.py.

2. Crear una toolbox (*.tbx) donde la herramienta va a ser almacenada.

3. Añadir la herramienta a la toolbox usando el asistente Add Script.

4. Modificar y ajustar el script con variables de entrada y salida para que quede totalmente integrado en el entorno de geoprocesamiento que ofrece ArcGIS

Para crear una herramienta hay que seguir los siguientes pasos.

CREAR HERRAMIENTAS PERSONALIZADAS

1. Crear un script de Python y salvarlo en un archivo *.py.

2. Crear una toolbox (*.tbx) donde la herramienta va a ser almacenada.

3. Añadir la herramienta a la toolbox usando el asistente Add Script.

4. Modificar y ajustar el script con variables de entrada y salida para que quede totalmente integrado en el entorno de geoprocesamiento que ofrece ArcGIS

Para crear una herramienta hay que seguir los siguientes pasos.

CREAR HERRAMIENTAS PERSONALIZADAS

Luis Miguel Agudo

lmagudo@gmail.com

es.linkedin.com/pub/luis-miguel-agudo-bravo/7b/630/8b2/

IEO - Curso Avanzado GIS - Tema2 - Automatización de tareas

By Luis Miguel Agudo Bravo

IEO - Curso Avanzado GIS - Tema2 - Automatización de tareas

778

Luis Miguel Agudo Bravo

GIS Developer