¿Qué es un script Lava? Un script Lava no es más que un script Perl con algunos módulos adicionales que permiten

comunicación con software Maptek Vulcan. Estos módulos han sido creados por la compañía

dueña creadora del software y tienen como objetivo dar herramientas a los usuarios para

automatizar sus procesos y/o mejorar sus procesos.

Para poder ejecutar un script Lava se requiere de:

1. Tener instalada en el equipo cualquier versión de Vulcan desde 7.0 en adelante.

2. Contar con una licencia Vulcan, ya sea flotante o mediante dongle

3. Crear un directorio de trabajo que cuente con al menos un archivo dg1. Además es deseable

contar con una paleta de colores (archivo scd), modelos de bloques, bases de datos isis, base de

datos de diseño (dgd), etc., dependiendo de los elementos con los cuales vaya a trabajar

nuestro script.

4. Mediante un editor de texto escribir el código Lava y guardar el archivo en el directorio de

trabajo con la extensión .lava

5. Abrir Vulcan y correr el script mediante la opción FIle – Lava.

El objetivo de este blog es enfocarnos en el paso 4, o sea, en generar ejemplos de código Lava

que puedan ser fácilmente replicados con cualquier set de datos. Se asume que el lector cuenta

con una versión de Vulcan instalada, con una licencia, y con un set de datos.

Es altamente recomendable que el lector tenga al menos algunas nociones básicas de

programación en Perl, especialmente en los siguientes tópicos:

Variables escalares y arreglos (incluyendo arreglos asociativos)

Operadores

Condicionales y loops

Lectura y escritura de archivos de texto

Principales funciones propias de Perl

Creación de funciones

Creación de panel Lava básico La creación de paneles es uno de los puntos más llamativos de los scripts Lava ya que le da al

usuario la sensación de participar en la creación de un módulo o nueva opción en Vulcan.

A efectos prácticos, los paneles permiten darle cierta interacción al usuario final del script de tal

manera que este no tenga que estar modificando el código del script para cambiar algún

parámetro.

Debido a que este artículo está enfocado a crear un panel lo más básico posible, nuestro

ejemplo se centrará solo en mostrar cómo capturar información desde el mismo. Lo que se hará

después con la información capturada será motivo de otros artículos en este blog.

Lo primero será invocar al módulo Lava, el cual permite al script comunicarse directamente con

Envisage. Este módulo solo se puede utilizar con Envisage abierto y permite trabajar con

elementos esenciales de Lava Scripting como son: objetos, selección de objetos, paneles, etc.

Vamos al código! Lo primero será entonces agregar las siguientes líneas al script:

# módulo mandatorio (para mí) ya que permite restringir código inseguro o sujeto a errores use strict; # módulo que permite interactuar con Envisage. Nos permitirá crear el panel use Lava;

A continuación, definiremos dos variables escalares las cuales utilizaremos para guardar

información ingresada por el usuario en el panel.

my $nombre_layer; my $valor_flag;

Luego, crearemos otra variable escalar con la cual inmediatamente crearemos una instancia de

la clase Panel. A partir de este punto utilizaremos esta variable para referenciar a nuestro panel

e insertar elementos.

my $panel = new Lava::Panel; # Insertar texto $panel->text(" Nombre de area"); # Insertar texto en negrita $panel->text(" Nombre de la compania", "hi"); # Emular un salto de línea insertando un texto vacío $panel->text(""); # Insertar una caja de texto de largo 20. Lo que el usuario ingrese se guardará # en variable $nombre_layer

$panel->item("Ingrese nombre de layer", \$nombre_layer, 20); # Insertar una caja numérica de largo 6 y solo permitiendo 2 decimales # Lo que el usuario ingrese se guardará en variable $valor_flag $panel->numeric("Ingrese valor para flag", \$valor_flag, 6, 2);

A estas alturas ya tenemos armada la estructura de nuestro panel, sin embargo, si corremos

este script no se mostrará nada. Para lograr que el panel se muestre en Envisage se debe

invocar la función execute de la clase Panel. Una forma recomendable de hacerlo se muestra a

continuación:

# Mostrar el panel con un título específico. # Si el usuario pincha el botón Cancel, el script termina y se muestra un mensaje en consola $panel->execute("Ejemplo panel basico") or die "Script cancelado";

Para finalizar, es importante asegurarnos de que nuestro panel este capturando correctamente

la información ingresada por el usuario en el panel. Para ello utilizaremos la función print que

nos permitirá ver en consola (Envisage Console) los valores capturados.

print "Nombre de layer es: $nombre_layer\n"; print "Valor de flag es: $valor_flag\n";

Como resultado de la ejecución de nuestro script, deberíamos obtener algo como esto:

SI ingresamos valores de prueba y pinchamos el botón Ok, deberíamos ver lo siguiente en

Envisage Console:

El próximo artículo relativo a paneles incluirá la posibilidad de ofrecer listados al usuario,

además del manejo de varios paneles en el mismo script.

A continuación comparto el código completo del script creado en este artículo.

use strict; use Lava; my $nombre_layer; my $valor_flag; my $panel = new Lava::Panel; # Insertar texto $panel->text(" Nombre de area"); # Insertar texto en negrita $panel->text(" Nombre de la compania", "hi"); # Emular un salto de línea insertando un texto vacío $panel->text(""); # Insertar una caja de texto de largo 20. Lo que el usuario ingrese se guardará # en variable $nombre_layer $panel->item("Ingrese nombre de layer", \$nombre_layer, 20); # Insertar una caja numérica de largo 6 y solo permitiendo 2 decimales # Lo que el usuario ingrese se guardará en variable $valor_flag $panel->numeric("Ingrese valor para flag", \$valor_flag, 6, 2); # Mostrar el panel con un título específico. # Si el usuario pincha el botón Cancel, el script termina y se muestra un mensaje en consola $panel->execute("Ejemplo panel basico") or die "Script cancelado"; print "Nombre de layer es: $nombre_layer\n"; print "Valor de flag es: $valor_flag\n";

Crear objeto en Vulcan desde archivo CSV

La creación de un objeto en Vulcan mediante Lava es relativamente sencillo y se puede hacer

en un par de líneas insertando las coordenadas directamente en el código. Sin embargo, resulta

interesante poder crear el objeto con información proveniente desde un archivo externo el

cual, por ejemplo, puede haber sido exportado desde otro software.

Incluiré el script completo directamente y de golpe, ya que en esta ocasión he decidido explicar

todo en el mismo código.

Como requisito previo a la ejecución del script, solo se requiere tener una base de datos de

diseño (DGD) abierta.

use strict; use Lava; my $nombre_layer = "EJEMPLO"; my $csv_coordenadas = "coordenadas_objeto.csv"; # Se crea un objeto Layer # Parametro 1: nombre de layer # Parametro 2: "clear" para limpiar layer. No mandatorio. my $layer = new Lava::Layer($nombre_layer, "clear"); # Se crea un objeto Obj my $objeto = new Lava::Obj; # Se abre archivo coordenadas_objeto.csv en modo lectura open CSV, $csv_coordenadas; # Se lee encabezado, aunque no se utiliza en este ejemplo my $encabezado = <CSV>; # Contador para insertar puntos en el objeto # Indice de puntos comienza en cero my $contador_puntos_objeto = 0; # Se lee csv hasta fin de archivo while (<CSV>) { # Se lee linea actual del archivo my $linea = $_; # Se quita salto de línea chomp $linea; # Se separa elementos de la linea, con comma como separador # El resultado se guarda en las variables $x, $y, $z my ($x, $y, $z) = split(",", $linea); # Creamos una variable para dar nombre a cada punto del objeto

my $nombre_punto = "punto_".$contador_puntos_objeto; # Se inserta un punto al objeto # Parametro 1: indice de punto # Parametros 2,3,4: coordenadas x,y,z # Parametro 5: w tag. No es mandatorio, en este ejemplo se dejará en cero # Parametro 6: Dibujar línea desde punto actual al anterior. # 1, se dibuja linea. 0, no se dibuja linea # Parametro 7: Nombre del punto. No es mandatorio $objeto->coordinates->i($contador_puntos_objeto, $x, $y, $z, 0, 1, $nombre_punto); # Se incrementa contador de puntos en uno $contador_puntos_objeto++; } # Propiedad closed se setea en 1 si se quiere que el objeto sea poligono # Caso contrario se deja en cero $objeto->closed(1); # Algunas propiedades extra con las cuales jugar $objeto->group("GRUPO_1"); $objeto->colour(3); $objeto->line(2); $objeto->pattern(5); # Se agregar objeto a layer creada # En este momento es cuando se dibuja el objeto en Envisage $layer->add($objeto); # Para finalizar se cierra manejador de archivo close CSV;

A continuación, incluyo un screenshot del resultado.

También, si presionamos el botón derecho del mouse sobre el objeto y seleccionamos la opción

Report Details, podremos observar sus coordenadas y atributos. Esta información debería estar

acorde con los datos del csv y con lo que seteamos directamente en el script.

Leer modelo de bloques usando Lava

La clase Vulcan nos permite interactuar con modelos de bloques, bases de datos isis, y

triangulaciones tanto para leer información como para modificarla. En este caso en particular

recorreremos un modelo de bloques obteniendo información de algunas variables por cada

bloque.

Para comenzar crearemos una instancia de la clase block model de la siguiente manera:

use vulcan; my $bm = new vulcan::block_model("modelo.bmf", "r");

El primer argumento es el nombre del modelo de bloques, mientras que el segundo

corresponde al modo en que se abrirá: para modo lectura se utiliza “r”, mientras que para

escritura se usa “w”. En este ejemplo solo leeremos desde el modelo de bloques así que

utilizaremos el modo “r”.

A continuación recorreremos el modelo de bloques de principio a fin mediante las siguientes

funciones de la clase block_model:

rewind: nos ubica en el primer bloque de nuestro modelo

eof: retorna 1 si se llega al final de modelo

next: nos posiciona en el siguiente bloque

Si usamos estas tres funciones en un for, se recorrerá el modelo completo.

for ($bm->rewind; !$bm->eof; $bm->next) { }

Cada iteración del for nos ubicará en un bloque en particular, así que lo que pongamos dentro

del for se aplicará para cada bloque. En este caso leeremos algunas variables del modelo, las

cuales obviamente deben existir con anterioridad.

for ($bm->rewind; !$bm->eof; $bm->next) { # capturamos coordenadas del centroide del bloque en coordenadas globales my $x = $bm->get("xworld"); my $y = $bm->get("yworld"); my $z = $bm->get("zworld");

# leemos una variable cualquiera del modelo my $cut = $bm->get("cut"); }

Luego, aplicamos alguna condición sobre la variable leída e imprimimos en consola los valores

que cumplan con ella. Dentro del for agregamos:

if ($cut >= 1.5) { print "$x , $y , $z , $cut\n"; }

Con esta condición se imprimirán las coordenadas y cut de todos los bloques en que el cut sea

mayor o igual 1.5.

Finalmente, cerramos el modelo de bloques para que este no quede bloqueado

$bm->close;

El código completo del script quedaría como sigue:

use strict; use vulcan; my $block_model_name = "ejemplo.bmf"; my $bm = new vulcan::block_model($block_model_name, "r"); for ($bm->rewind; !$bm->eof; $bm->next) { my $x = $bm->get("xworld"); my $y = $bm->get("yworld"); my $z = $bm->get("zworld"); my $cut = $bm->get("cut"); if ($cut >= 1.5) { print "$x , $y , $z , $cut\n"; } } $bm->close; # se imprime lo siguiente en Envisage Console # 70010, 60100, 2300, 1.52 # 70040, 60160, 2300, 1.68 # .... etc

Exportar objeto de Vulcan a un CSV mediante Lava

El ejemplo que se describirá a continuación corresponde al proceso contrario de lo descrito en

la entrada, el cual permitía crear un objeto totalmente nuevo con datos que provenían desde

un archivo de texto externo. En este caso seleccionaremos un objeto ya creado y cargado en

Envisage y lo exportaremos a un archivo csv.

Primero que todo, comenzaremos creando una instancia de la clase Selection. El primer

argumento que se debe ingresar corresponde a un mensaje de texto que se despliega en la

esquina superior derecha de Envisage. El segundo argumento corresponde a una seria de flags

que se deben indicar separados por comma. Los flags disponibles son: points, para destacar los

puntos del objeto seleccionado; shadow, para que un objeto seleccionado se oscurezca; y multi,

para indicar y dar la posibilidad de seleccionar múltiples objetos.

use strict;

use Lava;

# no se usará ningún flag en este ejemplo

my $sel = new Lava::Selection("Seleccione Poligono para exportacion", "");

A continuación se creará un archivo de texto en modo escritura, el cual se utilizará para escribir

la información objetida desde Vulcan.

my $archivo_csv = "report_poligono.csv"; # Se crea archivo de texto en modo lectura open OUT, ">", $archivo_csv; # Se inserta un encabezado en la primera línea del arcivo print OUT "NOMBRE,X,Y,Z\n";

A continuación procederemos a leer información básica del objeto a seleccionar. En este caso

leeremos el nombre del objeto y el número de puntos que tiene. Luego utilizaremos el número

de puntos para, mediante un bucle for, recorrer y leer las coordenadas de cada punto del

objeto. Como por cada iteración del for se está leyendo un punto del objeto, aprovecharemos

de imprimir su información en el archivo csv.

for (my $i = 0; $i < $poligono_numero_puntos; $i++) { my ($x, $y, $z) = $sel->coordinates->i($i); print OUT "$poligono_nombre,$x,$y,$z\n"; }

Finalmente se debe cerrar el archivo csv, de tal manera que la información se imprima

definitivamente en el mismo.

close OUT;

El código final del script queda como se ve a continuación:

use strict; use Lava; my $poligono_nombre; my $poligono_numero_puntos; my $archivo_csv = "report_poligono.csv"; my $sel = new Lava::Selection("Seleccione Poligono para exportacion", ""); $poligono_nombre = $sel->name; $poligono_numero_puntos = $sel->coordinates->n; open OUT, ">", $archivo_csv; print OUT "NOMBRE,X,Y,Z\n"; for (my $i = 0; $i < $poligono_numero_puntos; $i++) { my ($x, $y, $z) = $sel->coordinates->i($i); print OUT "$poligono_nombre,$x,$y,$z\n"; } close OUT;

A continuación procederemos a ejecutar el script. En la parte superior de Envisage veremos

desplegado nuestro mensaje personalizado de selección:

Luego de seleccionar un objeto, se debería crear un archivo csv en el directorio de trabajo

similar al que se puede ver a continuación:

http://www.lavacodetips.com/wp-content/uploads/2014/03/seleccion_csv.jpg

Exportar objeto de Vulcan a un csv mediante Lava (selección múltiple)

Esta entrada corresponde a una continuación de y permite ampliar la selección de objetos

pudiendo exportar más de uno al csv. Teniendo este antecedente, se procederá entonces

solamente a explicar los cambios que se deben hacer al script Lava original para lograr el

objetivo de este artículo.

Lo primero es agregar el flag multi al momento de instanciar la clase Selection. Adicionalmente

agregaremos la opción shadow para oscurecer cada elemento en la medida que se van

seleccionando.

my $sel = new Lava::Selection("Seleccione Poligono para exportacion", "multi,shadow");

Para poder recorrer cada uno de los objetos seleccionados, utilizaremos las funciones has_more

y next.

has_more: retorna 1 mientras aún no se recorra todos los objetos seleccionados

next: apunta hacia el siguiente objeto seleccionado.

Usaremos estas dos funciones mediante un bucle for e insertaremos el código de lectura del

objeto que ya vimos en:

for (;$sel->has_more;$sel->next) { my $poligono_nombre = $sel->name; my $poligono_numero_puntos = $sel->coordinates->n; for (my $i = 0; $i < $poligono_numero_puntos; $i++) { my ($x, $y, $z) = $sel->coordinates->i($i); print OUT "$poligono_nombre,$x,$y,$z\n"; } }

El código final del script sería:

use strict; use Lava; my $archivo_csv = "report_multi_poligono.csv"; my $sel = new Lava::Selection("Seleccione Poligono para exportacion", "multi,shadow"); open OUT, ">", $archivo_csv;

print OUT "NOMBRE,X,Y,Z\n"; for (;$sel->has_more;$sel->next) { my $poligono_nombre = $sel->name; my $poligono_numero_puntos = $sel->coordinates->n; for (my $i = 0; $i < $poligono_numero_puntos; $i++) { my ($x, $y, $z) = $sel->coordinates->i($i); print OUT "$poligono_nombre,$x,$y,$z\n"; } } close OUT;

Procederemos a utilizar el script donde lo primero que observaremos, es el menú típico de

selección múltiple de Vulcan.

Luego de escoger el método de selección que nos acomode, el script debería crear el siguiente

archivo en el directorio de trabajo: