Analytical data visualizations at ICC 2017/es

Este es un material para dos sesiones en del taller ICC 2017 SDI-Open (Spatial data infrastructures, standards, open source and open data for geospatial) llamado Analytical data visualizations with GRASS GIS and Blender y Mapping open data with open source geospatial tools que se dio en Washington, DC el 1-2 de Julio, 2017. Estas dos sesiones dan una introducción a GRASS GIS y Blender, ejemplos de sus capacidades de procesamiento y técnicas de visualización. Los participantes visualizan datos abiertos y diseñan mapas con diferentes herramientas geoespaciales, incluyendo el sistema de Tangible Landscape.

Autores: Vaclav Petras, Anna Petrasova, Payam Tabrizian, Brendan Harmon, y Helena Mitasova

Pruebas y revisión: Garrett Millar

Empezamos el taller con una presentación sobre las herramientas geoespaciales que se usan en este taller.

Datos

Datos preparados

Datos para el taller, contiene:

• modelo digital de superficie (1m de resolución) realizado a partir del lidar publicamente accesible de North Carolina Flood Plain Mapping
• ortofoto (0.5 m de resolución) de la USGS

Descargar datos de OpenStreetMap

Vamos a usar overpass turbo (una herramienta de filtrado basada en la web (web-based)) para crear y correr una consulta en la Overpass API para obtener los datos de OpenStreetMap.

Puede usar el Asistente para crear consultas simples en la extensión que está visualizando. Por ejemplo, haga zoom a un área pequeña y pegue esto en el Asistente y corra la consulta:

highway=* and type:way

La consulta fue construida en el editor y corrida de tal manera que ahora puede ver los resultados en el mapa.

Ahora pegue esta consulta en la ventana editor:

[out:json][timeout:25];
// gather results
(
  // query part for: “highway=*”
  way["highway"](35.76599,-78.66249,35.77230,-78.65261);
);
// print results
out body;
>;
out skel qt;

Encuentra los caminos en su área de estudio. Cuando corre una consulta, los caminos aparecen en el mapa y podemos exportarlos como GeoJSON (Exportar - Datos - como GeoJSON). Nombre el archivo vectorial roads.geojson.

Ahora vamos a descargar todos los edificios y exportarlos como GeoJSON. Nombre el archivo vectorial buildings.geojson.

[out:json][timeout:25];
// gather results
(
  // query part for: “building=*”
  way["building"](35.76599,-78.66249,35.77260,-78.65261);
  relation["building"](35.76599,-78.66249,35.77260,-78.65261);
);
// print results
out body;
>;
out skel qt;

En los siguientes pasos vamos a importar los datos a GRASS GIS.

Sesión 1: Introducción a GRASS GIS

Aquí brindamos una introducción a GRASS GIS. Para este ejercicio no es necesario tener un entendimiento entero de cómo usar GRASS GIS. Sin embargo, va a necesitar saber cómo colocar sus datos en un directorio de bases de datos GRASS GIS correcto, así como algunas funcionalidades básicas de GRASS GIS.

Estructura de la base de datos espacial de GRASS GIS

GRASS usa una terminología y estructura de la base de datos única (base de datos GRASS) que es importante entender para correr este tutorial, ya que es posible que necesite colocar los datos (ej. Localización en una base de datos específica de GRASS. En lo que sigue revisaremos la terminología y se dan las direcciones paso a paso de cómo descargar y colocar sus datos en el lugar correcto.

• Una Base de datos espacial de GRASS GIS (GRASS database) consiste de un directorio con Localizaciones (proyectos) específicos donde los datos (datos capas/mapas) se guardan.
• Localización es un directorio con datos relacionados a una localidad geográfica o a un proyecto. Todos los datos dentro de una Localización tienen el mismos sistema de coordenadas de referencia.
• Directorio de mapas es una colección de mapas dentro de una Localización, contiene los datos relacionados a una tarea específica, usuario o subproyecto.

• 

  GRASS GIS Spatial Database structure

Creando una base de datos de GRASS para este tutorial

Inicie GRASS GIS, debe aparecer una pantalla de inicio. A menos que tenga un directorio llamado grassdata en su carpeta de Documentos (en MS Windows), o en su carpeta home (en Linux), cree una. Puede usar el botón Explorar del cuadro de diálogo de la pantalla de inicio de GRASS GIS para realizar esto.

Vamos a crear una nueva Localización para nuestro proyecto con un SCR (sistema de coordenadas de referencia) de NC State Plane Meters cuyo código EPSG es 3358.

Abra el Asistente de Localizaciones con el botón Nueva en la parte izquierda de la pantalla de bienvenida. Seleccione el nombre de la nueva Localización, seleccione el método EPSG y el código 3358. Cuando el Asistente haya terminado, la nueva Localización estará enlistada en la pantalla de bienvenida. Seleccione la nueva Localización y el Directorio de mapas PERMANENT y presione Iniciar sesión de GRASS.

• 

  Cuadro de diálogo de GRASS GIS 7.2

• 

  Iniciar Asistente de Localización e ingrese el nombre de la nueva Localización

• 

  Seleccione el método para describir el SCR

• 

  Encontrar y seleccionar el EPSG 3358

• 

  Revisar la paǵina de resumen y confirmar

Directorio (entorno) de trabajo actual

El directorio (entorno) de trabajo actual es un concepto separado de la base de datos GRASS, la Localización y el Directorio de mapas discutidos más arriba. El directorio (entorno) de trabajo actual el directorio (o carpeta) donde cualquier programa (no solo GRASS GIS) escribe y lee archivos a menos se le de una ruta para el archivo. Cuando se use GRASS GIS GUI, el directorio de trabajo actual normalmente no se usa. Sin embargo, cuando se usa la línea de comando o se hace un script, el directorio de trabajo es importante.

Cambie su directorio (entorno) de trabajo actual a algún lugar en donde tenga permisos de lectura y escritura. Por ejemplo, puede crear un directorio ICC en Documentos. El directorio de trabajo actual puede ser cambiado desde la GUI usando Configuraciones → Entorno de trabajo de GRASS → Cambiar entorno de trabajo o desde la consola usando el comando cd.

Importando los datos

Importado datos ráster

En este paso vamos a importar los datos a GRASS GIS. En el menú Archivo - Importar datos ráster seleccione Formatos comunes de importación y en el diálogo explore a encontrar dsm.tif y de click en el botón Importar. Repita esto para el archivo ráster ortho.tif.

De manera similar, vaya a Archivo - Importar datos vectoriales - Formatos comunes de importación e importe los archivos roads.geojson y buildings.geojson. Note que en este caso necesitamos cambiar el nombre de la salida desde el predeterminado OGRGeoJSON a roads y buildings, respectivamente. Estos datos vectoriales tienen un SCR diferente, así que aparecerá un cuadro de diálogo informando que necesita reproyectar los datos y le damos confirmar.

Todas las capas importadas deberán aparecer en la GUI, si no es así, añádalas manualmente (ver abajo).

Mostrar y explorar los datos

La interfaz GUI le permite mostrar datos vectoriales y ráster, así como navegar acercandose o alejándose (zoom). Es posible tener explpraciones y visualización más avanzada, usando por ejemplo, consultas o añadiendo leyendas. Las capturas de pantalla de más abajo muestran cómo añadir diferentes capas de mapas (izquierda) y mostrar los metadatos de las capas.

• 

  Añadir capa de mapa ráster

• 

  Añadir leyenda ráster

• 

  Administrador de capas y Visualizador de mapas. Las anotaciones muestran cómo añadir capas ráster, hacer consultas y añadir leyendas.

• 

  Mostrar metadatos de mapa ráster haciendo click derecho en la capa

Resumen de los módulos GRASS GIS

Una de las ventajas d eGRASS es la diversidad y cantidad de módulos que le permiten analizar los diferentes aspectos espaciales y temporales. GRASS GIS tiene más de 500 módulos distintos en la distribución núcleo y más de 230 módulos de extensión addon que pueden ser usados para preparar y analizar capas de datos.

La funcionalidad de GRASS está disponible a través de módulos (herramientas, funciones). Existe en GRASS una convención de nombrar a los módulos de acuerdo a su función, de la siguiente manera:

Prefijo	Función	Ejemplo
r.*	procesamiento ráster	r.mapcalc: álgebra de mapas
v.*	procesamiento vectorial	v.clean: limpieza topológica
i.*	procesamiento de imágenes	i.segment: reconocimiento de objetos
db.*	administración de bases de datos	db.select: seleccionar valores de una tabla
r3.*	procesamiento ráster 3D	r3.stats: estadísticas de ráster 3D
t.*	procesamiento de datos temporales	t.rast.aggregate: agregación temporal
g.*	administración general de datos	g.rename: renombrar mapa
d.*	pantalla	d.rast: mostrar mapa ráster

Estos son los grupos de módulos principales. Hay algunos otros que son específicos. Note también que algunos módulos tienen varios puntos dentro del nombre. Esto sugiere otro agrupamiento. Por ejemplo, los módulos que inician con v.net. tienen que ver con análisis de redes vectoriales.

El nombre del módulo ayuda a entender su función, por ejemplo v.in.lidar inicia con v así que tiene que ver con mapas vectoriales, el nombre continúa con in lo que indica que el módulo es para importar datos a la Base de datos espacial de GRASS GIS y finalmente lidar indica que tiene que ver con nubes de puntos lidar.

Finding and running a module

Para encontrar un módulo para su análisis, escriba el término en la caja de búsqueda en la pestaña Módulos (Modules) en el Administrador de capas (Layer manager), luego presione Enter hasta que encuentre el módulo.

De manera alternativa, puede buscar a través de el árbol de módulos en la pestaña Módulos (Modules). Puede también buscar en el menú principal. Por ejemplo, para encontrar información sobre un mapa ráster, use:Ráster → Reportes y estadísticas → Metadatos básicos del ráster (Raster → Reports and statistics → Basic raster metadata).

Si ya conoce el nombre del módulo, puede simplemente usar la línea de comandos. La GUI ofrece una pestaña de Consola con una línea de comandos específicamente costruida para los módulos de GRASS GIS. Si teclee el nombre del módulo, va a recibir sugerencias para el autocompletado del nombre. Luego, si presiona Enter le saldrá el cuadro de diálogo del módulo.

• 

  Buscar un módulo en el árbol de módulos (nombre, descripciones o palabras clave)

• 

  Los módulos pueden ser encontrados en el menú principal

• 

  Sugerencia automática cuando teclea el nombre del módulo: ingresando el prefijo r. tenemos la lista de módulos que empiezan con este prefijo.

Puede también usar la línea de comandos para completar los comandos, i.e. módulo y lista de parámetros. Esto módulos son lo que usualmente se encuentra en la documentación o en este material. Puede usarlos directamente en la pestaña de Consola o puede usarlos como instrucciones rellenando el cuadro de diálogo de la GUI.

Línea de comandos vs. interfaz GUI

Cuadro de diálogo de un módulo

Los módulos GRASS pueden ser ejecutados tanto a través de la GUI o en la interfaz de línea de comandos. La GUI ofrece una aproximación más amigable para ejecutar los módulos donde el usuario navega en las capas de datos que quiere anañizar y modifica las opciones seleccionandolas. La GUI ofrece un manual fácilmente accesible de cómo ejecutar el módulo. La interfaz de la línea de comandos permite a los usuarios ejecutar un módulo usando opciones para ese módulo (prompts specific to that module). Esto es útil cuando haga análisis similares con modificaciones menores o ya está familiarizado con los comandos del módulo para un procesamiento más eficiente. En este taller proveemos lasllamadas de los módulos y estas pueden ser copiadas y pegadas e la línea de comandos para seguir el flujo de trabajo, pero también puede usar la GUI y la interfaz de la línea de comandos, dependiendo de su preferencia personal. Vea cómo la GUI y la interfaz de la línea de comandos representa la misma herramienta.

El mismo análisis puede ser realizado usando el siguiente comando:

r.neighbors -c input=elevation output=elev_smooth size=5

De manera análoga, puede rellenar los parámetros de la GUI, modificando parámetro por parámetro cuando tiene el comando.

Región computacional

Antes de usar un módulo para calcular un nuevo mapa ráster, debemos definir de una manera adecuada la región computacional. Todos los cálculos ráster se realizarán en la extensión especificada y con la resolución dada.

La región computacional es un concepto importante en GRASS GIS. En GRASS se puede definir la región computacional en una parte pequeña de una extensión mayor de los datos para realizar pruebas de un análisis o para analizar regiones específicas basadas en las unidades administrativas. Vamos a proveer algunos puntos que debe tener en mente cuando use la función de la región computacional:

• definida por la extensión y resolución ráster
• aplica a todas las operaciones ráster
• persiste entre sesiones de GRASS, puede ser diferente para distintos Directorios de mapas
• ventajas: mantiene consistencia en resultados, evita el recorte, para cálculos computacionalmente demantantes se puede definir una región de extensión menor y revisar si el resultado es correcto para luego realizar en toda la región o área de estudio.
• corra g.region -p o en el menú Configuraciones - Región - Mostrar región para ver la configuración actual de la región

• 

  Concepto de región computacional: un ráster con una extensión grade (azul) se muestra junto con otro más pequeño (verde). La región computacional (rojo) se define para que sea igual al ráster pequeño, así los cálculos estarán limitados a la región que ocupa el ráster menor aún cuando la entrada sea el ráster mayor. (No se muestra en la imagen: también la resolución, no solo la extensión, es igual a la resolución del ráster menor.)

• 

  Modos sencillos para definir la región computacional desde la GUI. A la izquierda, definir la región para que sea igual a un mapa ráster. A la derecha, seleccionar la opción señalada y luego defina la región dibujando un rectángulo.

• 

  Definir la región computacional (extensión y resolución) para que sea igual a un ráster (pestaña de Capas en el Administrador de capas)

Los valores numéricos de la región computacional pueden ser revisados usando:

g.region -p

Luego de ejecutar el comando, obtendrá algo como esto:

norte:      220750
sur:      220000
oeste:       638300
este:       639000
nsres:      1
eores:      1
rows:       750
columnas:       700
celdas:      525000

La región computacional puede ser definida usando un mapa ráster:

g.region raster=dsm -p

Running modules

Encuentre el módulo para calcular el área visible (viewshed) en el menú o en el árbol de módulos en Ráster → Análisis de terreno → Visibilidad, o simplemente en la Consola corra r.viewshed.

r.viewshed input=dsm output=dsm_viewshed coordinates=640167,223907 observer_elevation=1.72 target_elevation=1 max_distance=400

Vista 3D

Visualización 3D de un MDS (DSM) con una ortofoto superpuesta

Podemos explorar nuestra área de estudio en la vista 3D (use la imagen si necesita clarificar los siguientes pasos):

1. Añadir ráster dsm y deseleccionar o remover cualquier otra capa. Note que el deseleccionar (o remover) cualquier otra capa es importante porque cualquier otra capa cargada en Capas es interpretada como un suerficie en la vista 3D.
2. Cambie a la vista 3D (en la esquina derecha del Visualizador de Mapas).
3. Ajuste la vista (perspectiva, altura).
4. En la pestaña Data, defina Modo de resolución fina a 1 y defina ortho como superficie de color (la ortofoto será mostrada sobre el DSM).
5. Regrese a la pestaña Vista y explore las diferentes direcciones de vista usando el controlador verde.
6. Vaya a la pestaña Aparienciay cambie las condiciones de luz (mejor altura de la luz, cambio de dirección).
7. Trate también usando el ráster landforms como la superficie de colores.
8. Cuando termine, cambie de nuevo a la vista 2D.

Session 1: Introduction to scripting in GRASS GIS with Python

La manera más sencilla de ejecutar el código de Python que usa los paquetes de GRASS GIS es usar el Editor simple de Python integrado a GRASS GIS (accesible desde la barra de herramientas o la pestaña Python en el Administrador de capas). Otra opción es usar su editor de texto favorito y luego correr el script de GRASS GIS usando el menú principal Archivo → Lanzar script.

• 

  Editor simple de Python integrado en GRASS GIS (desde la versión 7.2) con la pestaña Python de fondo, que contiene una consola interactiva de Python.

• 

  Pestaña Python con una consola interactiva de Python

La librería GRASS GIS 7 Python Scripting Library provee funciones para llamar módulos de GRASS dentro de scripts como subprocesos. Las funciones más frecuentes incluyen:

• script.core.run_command(): usada para módulos cuya salida es un vectorial o ráster y no se espera salida de texto
• script.core.read_command(): usada cuando interesa la salida de texto, que se obtiene como un texto de Python (string, cadena)
• script.core.parse_command(): usada con módulos que producen texto como pares clave=valor y que son procesados automáticamente como diccionarios de Python
• script.core.write_command(): para módulos que esperan ingreso de texto, ya sea de un archivo o de la entrada estándar

Vamos a usar el Editor Python simple de GRASS GUI para correr los comandos. Puede abrirlo desde la pestaña Python. Para scripts más largos, puede crear un archivo de texto, salvarlo en el directorio de trabajo actual y correrlo con python myscript.py desde la consola de comandos de la GUI o desde la terminal.

Cuando abra el Editor simple de Python, primero encontrará un pequeño código. Empieza importando la librería GRASS GIS Python Scripting Library:

import grass.script as gscript

En la función principal llamamos g.region para ver la configuración de la región computacional acual:

gscript.run_command('g.region', flags='p')

Note que la sintaxis es similar a la sintaxis de la consola (linux) (g.region -p), solamente que la bandera (flag) se especifica como un parámetro. Ahora podemos correr el script presionando el botón Correr de la barra de herramientas. En el Administrador de capas podemos obtener la salida de g.region.

Antes de correr cualquier módulo GRASS de ráster, necesitamos definir la región computacional. En este ejemplo, definimos la extensión y resolución de a la capa ráster elevation.

Reemplace el comando g.region anterior con la siguiente línea:

gscript.run_command('g.region', raster='dsm')

La función run_command() es la más usada. Vamos a usarla para calcular la viewshed usando el comando r.viewshed. Añada la siguiente línea luego del comando g.region:

gscript.run_command('r.viewshed', input='dsm', output='python_viewshed', coordinates=(640645, 224035), overwrite=True)

El parámetro overwrite se necesita si queremos volver a correr el script y reescribir el ráster.

Ahora vamos a ver qué tan grande es la viewshed usando el comando r.univar. Aquí usamos parse_command para obtener las estadísticas como un diccionario Python

univar = gscript.parse_command('r.univar', map='python_viewshed', flags='g')
print univar['n']

El resultado mostrado es la cantidad de celdas de la vista (viewshed).

La librería GRASS GIS Python Scripting Library también tiene varias funciones atajo (wrapper functions) para algunos módulos que se llaman frecuentemente. La lista de funciones atajo junto con ejemplos incluyen:

• Metadatos ráster usando script.raster.raster_info(): gscript.raster_info('viewshed_python')
• Metadatos vectoriales usando script.vector.vector_info(): gscript.vector_info('roads')
• Lista de datos ráster incluyendo la Localización usando script.core.list_grouped(): gscript.list_grouped(type=['raster'])
• Obtener la región computacional actual usando script.core.region(): gscript.region()

Aquí hay dos comandos (a ejecutarse en la Consola) usados frecuentemente cuando se trabaja con scripts. Lo primero es definir la región computacional. Queremos hacerlo en un script, pero es mejor y más general el hacerlo antes de ejecutar el script (así que script puede usar diferentes configuraciones de la región computacional):

g.region raster=dsm

El segundo comando es útil cuando queremos correr un script muchas veces. En este caso, primero necesitamos remover los mapas ráster creados, por ejemplo:

g.remove type=raster pattern="viewshed*"

El comando de arriba de hecho no remueve (elimina) los mapas, pero informa cuales va a remover si establece la bandera -f.

Sesión 1: Procesamiento por lotes (batch processing) usando Python

En este ejemplo vamos a calcular las viewshed a lo largo de un camino para simular, de una manera simple qué es lo que vería alguien que vaya manejando por el camino. Primero prerparamos el punto de vista corriendo el módulo directamente a través de los diálogos de la GUI o en la Consola. Luego usamos Python para procesar todos los puntos creados.

Primero extraemos solamente los segmentos del camino con el nombre 'Umstead Drive' (use el código en la pestaña de Consola o use el diálog GUI):

v.extract input=roads where="name = 'Umstead Drive'" output=umstead_drive_segments

Vamos a unir los segmentos en una polilínea usando v.build.polylines

v.build.polylines input=umstead_drive_segments output=umstead_drive cats=first

Ahora generamos puntos de visión (viewpoints) a intervalos regulares sobre la línea:

v.to.points input=umstead_drive type=line output=viewpoints dmax=50

Calculamos la viewshed para cada punto usando un script de Python. A partir de estas viewsheds podemos facilmente calcular el Área de visión acumulada (Cumulative viewshed) (qué tan visible es un lugar). Para eso vamos a usar el módulo r.series, que sobrepone los rásters de las viewsheds y calcula cuantas veces cada celda es visible en todos los rásters.

Copie el siguiente código en el Editor Simple de Python (asegúrese de sobreescribir cualquier código preexistente) y presione el botón Correr.

#!/usr/bin/env python

import grass.script as gscript

def main():
    # obtener las coordenas de los puntos 
    viewpoints = gscript.read_command('v.out.ascii', input='viewpoints',
                                      separator='comma', layer=2).strip()
    # loop a través de los puntos y calcular la viewshed de cada uno
    for point in viewpoints.splitlines():
        if not point:
            # skip empty lines
            continue
        x, y, cat = point.split(',')
        gscript.run_command('r.viewshed', input='dsm', output='viewshed' + cat,
                            coordinates=(x, y), max_distance=300, overwrite=True)
    # obtener todos lso resultados de las viewshed y definir su color a amarillo
    # exportar la lista de nombres de los mapas de viewshed a un archivo
    maps_file = 'viewsheds.txt'
    gscript.run_command('g.list', type='raster', pattern='viewshed*', output=maps_file)
    gscript.write_command('r.colors', file=maps_file, rules='-',
                          stdin='0% yellow \n 100% yellow')
    # área de visibilidad acumulada (cumulative viewshed)
    gscript.run_command('r.series', file='viewsheds.txt', output='cumulative_viewshed', method='count')
    # definir el color de la cumulative viewshed de gris a amarillo
    gscript.write_command('r.colors', map='cumulative_viewshed', rules='-',
                          stdin='0% 70:70:70 \n 100% yellow')

if __name__ == '__main__':
    main()

Podemos visualizar la cumulative viewshed superpuesta sobre un MDS usando la vista 3D. Si lo necesita, revise las instrucciones en la sección anterior de vista 3D.

Cumulative viewshed calculada sobre un camino

Para lo siguiente vamos a exportar los puntos de observación y el área visible acumulada (cumulative viewshed) para usarlos dentro de Blender. Copie y pegue las líneas individuales a la consola de comandos de la GUI y ejecútelos de manera separada, omita las líneas que inician con #.

# volver los puntos 2D points a 3D usando la información del MDS
v.drape input=viewpoints output=viewpoints_3d elevation=dsm method=bilinear
# exportarlos, ignorar errores de los nombres de las columnas demasiado largos
v.out.ogr input=viewpoints_3d output=viewpoints_3d.shp format=ESRI_Shapefile
# exportar el área visible acumulada cumulative viewshed) como PNG
r.out.gdal input=cumulative_viewshed output=cumulative_viewshed.png format=PNG

Sesión 1: Introducción a Blender

Los materiales para la parte de Blender de este taller están disponibles aquí:

https://github.com/ptabriz/ICC_2017_Workshop/blob/master/README.md

Sesión 2: Animación en GRASS GIS

En el siguiente ejercicio visualizaremos el área visible acumulada sobre el camino (calculada más arriba) como una animación. Vamos a usar GRASS GIS Animation Tool. Iniciela desde el menú Archivo - Herramienta de animación:

Menú principal de la herramienta de animación

Inicie con Añadir nueva animación y de click en Añadir conjunto de datos espacio-temporales o series de capas de mapas. En Añadir capas de conjunto de datos espacio temporales de click en el botón Siguiente para ingresar el campo y de teclee ^viewshed. Esto filtra los rásters que inician con "viewshed". Puede usar expresiones regulares de Python para filtrar los mapas en este diálogo. Revise si los mapas deseados están seleccionados y luego confirme el diálogo y regrese al de Añadir nueva animación.

Lo siguiente que queremos es añadir la ortofoto como capa base. Use Añadir capa de mapa ráster y seleccione el ráster ortho.

Añadir serie de rásters de áreas visibles (viewsheds) a la herramienta de animación.

Añadir ortofoto como ráster de base

Haga lo mismo para el vectorial de caminos umstead_drive, solo que en vez de ráster, añada vectorial. Luego, reacomode las capas de tal manera que la ortofoto (ortophoto) quede debajo de las otras capas. Confirme el diálogo y la animación debe cargarse.

Cambie el orden de las capas

Animación resultante

Más exploración:

• Si quiere darle zoom (acercarse), vuela al Visualizador de mapas, luego defina la región computacional a la extensión que quiera usando -de la barra de herramientas- el botón 'Varias opciones de zoom - Definir la región computacional'. Luego presione Render map (Mostrar mapa) en la barra de herramientas de la herramienta de Animación, esto hará que se vuelva a mostrar de nuevo la animación pero basada en la nueva extensión de la región computacional.

Sesión 2: Scripting of rendering in GRASS GIS

La visualización de los mapas se puede hacer en GRASS GIS usando la API de Python en un modo que es similar a lo que se hace en la GUI. De manera similar a correr el procesamiento en los módulos, los diálogos GUI tienen un botón Copiar que da el equivalente de la línea de comandos de lo que se está haciendo en el diálogo de la GUI. Por ejemplo, el diálogo de propiedades de un ráster da el siguiente código d.rast map=viewshed. El código escrito en la sintaxis de Python como run_command('d.rast', map='viewshed'). Ademas de los comandos para visualizar, ecesitamos especificar dónde (nombre del archivo, filename) y cómo (ej. formato del archivo) visualizarlo, lo que se puede hacer usando el comando d.mon como se muestra abajo, o variables ambientales (en la GUI no necesitamos declarar nada dado que el contexto es claro). Un ejemplo completo se muestra más abajo:

#!/usr/bin/env python

import grass.script as gscript

viewsheds = gscript.list_strings(type=['raster'], pattern='viewshed*')

for viewshed in viewsheds:
    # tomar el nombre del Directorio de mapas del archivo de la imagen
    filename = '{}.png'.format(viewshed.split('@')[0])
    # iniciar la visualización
    gscript.run_command('d.mon', start='cairo', output=filename)
    # comandos de visualización
    gscript.run_command('d.rast', map='ortho')
    gscript.run_command('d.vect', map='umstead_drive', color='232:232:232', width=3)
    gscript.run_command('d.rast', map=viewshed)
    # finalizar visualización
    gscript.run_command('d.mon', stop='cairo')

Los números 232:232:232 en la llamada del comando d.vect son los tripletes GRASS RGB. En otras palabras, los colores rojo, verde y azul son expresados como números del 0 al 255 separados por los dos puntos (usando sintaxis HTML, el equivalente sería rgb(232,232,232) o #E8E8E8).

Información para realizar scripts, paralelizar y supercómputo: al realizar scripts, el comando d.mon generalmente no es usado dado que solo un monitor está activo. Esta es una simplificación conveniente para uso interactivo, pero limitante al realizar scripts. Cuando la visualización corre en paralelo, es necesario usar variables ambientales en lugar del módulo d.mon. Las variables se definen globalmente (usando el diccionario os.environ) o para cada llamada de la función (usando el parámetro env). Las siguientes tres variables son las más importantes: GRASS_RENDER_IMMEDIATE (usualmente definida a cairo), GRASS_RENDER_FILE_READ (definida a TRUE), y GRASS_RENDER_FILE (nombre del archivo de la imagen resultante). Variables adicionales incluyen: GRASS_FONT (nombre de la fuente que se va a usar, por ej. sans) y GRASS_LEGEND_FILE (archivo para leyenda vectorial, puede ser una ruta a un archivo temporal).

Más exploración:

• Use el mapa vectorial roads en lugar de solamente umstead_drive.
• Añada el mapa vectorial buildings del mismo modo que el mapa vectorial roads. Esta ves, necesita definir dos opciones de color: color (para la línea exterior) y fill_color (para la parte interna). Use el diálogo de propiedades de la capa en la GUI para crear el estilo deseado. Use el botón Copiar para obtener los parámetros en la sintaxis de la línea de comandos y reescribirlos a Python. Puede solamente usar los siguientes colores 188:82:47, 213:115:82 (#BC522F, #D57352) o 170:166:157, 213:205:189 (#AAA69D, #D5CDBD).
• Si tiene ImageMagic disponible, cree una animación GIF usando algo como: convert 'viewshed?.png' 'viewshed??.png' viewshed.gif

Sesión 2: Light up the terrain with viewsheds

Los materiales para la parte de Blender de este taller están disponibles aquí:

https://github.com/ptabriz/ICC_2017_Workshop/blob/master/README.md#light-up-the-terrain-with-viewsheds

Session 2: Tangible Landscape

Tangibly explore landscapes with Tangible Landscape

Tangible Landscape (photos by Anna Klevtcova)

Software

Software should be pre-installed at ICC, but the following instructions can be used to install software on participants' laptops.

We use GRASS GIS 7.2 and Blender 2.78.

MS Windows

Download the standalone GRASS GIS binaries (64-bit version, or 32-bit version) from grass.osgeo.org.

Mac OS

Install GRASS GIS using Homebrew osgeo4mac:

brew tap osgeo/osgeo4mac
brew install grass7

OSGeo-Live

All needed software is included except for Blender.

Ubuntu

Install GRASS GIS from packages:

sudo add-apt-repository ppa:ubuntugis/ubuntugis-unstable
sudo apt-get update
sudo apt-get install grass

Linux

For other Linux distributions other then Ubuntu, please try to find GRASS GIS in their package managers.

See also

• GRASS GIS at ICC 2017
• Unleash the power of GRASS GIS at US-IALE 2017
• Creating animation from FUTURES output in GRASS GIS
• Introduction to GRASS GIS with terrain analysis examples
• GRASS Location Wizard
• GRASS and Blender