Lava
Derechos Reservados © 2009 Maptek Todos los derechos reservados. Ninguna parte de este manual puede ser reproducido, almacenado o transmitido por ningún medio de recuperación – electrónico, mecánico, fotocopiado, registrado, o de otra manera – sin el permiso escrito de Maptek Computación Chile Ltda. No se asume ninguna responsabilidad con respecto al uso de la información contenida adjunta. Aunque se ha tomado la precaución en la preparación de este manual, el editor y autor(es) no asumen ninguna responsabilidad de errores u omisiones. Maptek no se responsabiliza por daños o perjuicios, directos o indirectos, que surjan del uso, interpretación de la información contenida en este manual.
[email protected] www.maptek.cl
Marcas Debido a la naturaleza del material, muchos de los productos del hardware y de software se mencionan por nombre. Las compañías que fabrican los productos demandan muchos de estos nombres del producto como marcas registradas. No es la intención de Maptek demandar estos nombres o marcas registradas como propias.
Historial de Revisión Mayo 2008
2
Introducción
Contenidos 1
INTRODUCCIÓN ..................................................................................................................................................... 4
2
PERL ....................................................................................................................................................................... 5
3
MÓDULO LAVA .................................................................................................................................................... 21
4
MÓDULO VULCAN ............................................................................................................................................... 50
www.maptek.cl
3
Introducción La programación de aplicaciones puede ser una tarea muy simple o muy compleja dependiendo del tópico y de la factibilidad técnica de lo que se quiere realizar, tanto en algorítmica como de herramientas de programación.
Para el aprendizaje de las materias tratadas aquí no se requiere de conocimiento avanzados de programación ni de uso de Vulcan, pero dependerá de la habilidad y capacidad de estudio y aprendizaje de cada alumno el nivel que pueda alcanzar.
El presente manual le entrega al lector las herramientas que le facilitarán el trabajo para la implementación de aplicaciones bajo el entorno Vulcan. Los contenidos abarcan desde el manejo de archivos, modelos de bloques, bases de datos y objetos gráficos de Vulcan
Los contenidos tratados corresponden a los módulos más comúnmente usados e incluyen imágenes, ejemplos y ejercicios de modo de hacer más simple y didáctico su aprendizaje.
Una vez finalizado este manual, el lector será capaz de:
4
Crear y editar objetos gráficos de Vulcan, líneas, polígonos, textos, triangulaciones. Crear paneles personalizados. Automatización de procesos batch. Manipular archivos de texto. Acceder y manipular modelo de bloques. Acceder a datos de Bases de Datos Isis. Creación y modificación de macros Vulcan.
Introducción
Perl 1.1. Introducción. PERL (Practical Extraction and Report Language) es un lenguaje interpretado que tiene varias utilidades, pero está principalmente orientado a la búsqueda, extracción y formateado de archivos de texto. También es muy usado para manejo y gestión de procesos (estado de procesos, conteo y extracción de parámetros característicos, etc...). Perl toma muchas características del C, como también del lenguaje interpretado AWK, sed, shell (sh), Lisp entre otros. Estructuralmente, Perl está basado en un estilo de bloques como los del C o AWK, y es muy usado por su flexibilidad en el procesamiento de texto y no tiene ninguna de las limitaciones de los otros lenguajes de script.
1.2. Un primer ejemplo de programa. Para ejecutar un programa en PERL debemos abrir la consola de comandos TShell de Vulcan Se puede correr de dos formas 1.- Llamar desde la línea de comandos al intérprete perl, pasando como parámetro el nombre del programa. perl primer.pl o bien $VULCAN_EXE/perl primer.pl Se acostumbra poner la extensión pl a este tipo de script. 2.- Añadir en la primera línea del programa lo siguiente: #! c:/usr/bin/perl
www.maptek.cl
5
Cambiar los permisos del archivo fuente, para poderlo ejecutar. Esto se realiza mediante la instrucción chmod:
chmod u+x primer.pl A continuación de la primera línea del script escribiríamos el programa en si, y una vez hecho esto simplemente invocamos el nombre del programa (ahora ejecutable) directamente desde la línea de comandos.
primer.pl Los caracteres #! sirven para denotar que lo que viene a continuación hace referencia a un intérprete de comandos. Como el intérprete perl se encuentra en los ejecutables de Vulcan se puede crear una estructura de carpetas en el disco C, copiando el programa perl.exe allí de modo que esté siempre disponible en un solo lugar (c:/usr/bin/).
Por ejemplo un script que muestre en la pantalla el mensaje Hola mundo forma:
se haría de la siguiente
#! C:/usr/bin/perl print "Hola mundo\n"; Nota: Al usar primera forma de correr el script no se requiere de la primera línea de este programa.
1.3. Tipos de datos. Perl tiene tres tipos de datos: 1.
Escalar.
2.
Array de escalares.
3.
Array asociativo de escalares.
Tipo Escalar. El tipo escalar es denotado con un nombre de variable precedido de $. Puede almacenar un número o un string. Por ejemplo:
$valor = 12; $nombre = ´Juan´; $palabra = "Hola mundo\n";
6
Perl
Al usar comillas dobles se puede interpretar caracteres especiales del string al momento de ser impresos, por ejemplo en pantalla:
print $palabra; También es posible definir varias variables al mismo tiempo mediante el uso de paréntesis:
($nombre,$apellido,$edar) = ("Ferenando","Leiva",26);
Tipo Array de escalares. El tipo de dato array de escalares es denotado mediante un nombre precedido del símbolo @. Ejemplo de inicialización de una variable de este tipo podría ser:
@paises = ("Chile","Peru","Bolivia","Argentina"); El número de elementos de un array de escalares se puede obtener de la siguiente manera:
$num_elementos = @paises; o bien
$num_elementos = $#paises+1; $# devuelve el último índice del array, y como el valor para el primer índice es 0 el número de elementos - 1 será el último valor permitido para indexar el array.
Para acceder al los elementos de un array se usa el índice de la posición donde se almacena el dato (0 a n-1)
$segundo_elemento = $paises[1]; Se puede acceder a varios elementos de un array de la forma @nom_array[indice1,...,indicen]. Por ejemplo:
print @paises[0,3];
www.maptek.cl
7
que es lo mismo que
$ultimo = $#paises; print @paises[0,$ultimo]; Imprimirá el primer y último elemento del array @paises.
Otra forma es usando el operador rango .. , si se quisiera imprimir todos los valores desde un índice i hasta un indice j se debe utilizar el siguiente formato @nom_variable[i..j], por ejemplo:
print
@paises[0..3];
Imprimirá todos los elementos del array @paises.
Tipo Array asociativo de escalares. Mediante este tipo de datos se puede acceder a un determinado elemento del array a través de una clave anteriormente definida, Este tipo de dato se denota mediante un nombre precedido con el símbolo %. Por ejemplo:
%precio=("manzana",50,"pera",70,"ciruela",20); Para acceder a un elemento de un array asociativo se debe utilizar el siguiente formato @nom_arrayt { clave }. Por ejemplo:
$numero_peras = 10; $valor_total = @precio{"pera"} * $numero_peras;
1.4. Sintaxis general. Todas las instrucciones de PERL deben terminar en ";". Por ejemplo
$nombre = “Me llamo Juan\n”; print $nombre; Las únicas cosas que deben de ser declaradas en PERL son los formatos de salida o reportes y las subrutinas. Todas las variables creadas y no inicializadas tienen como valor por defecto nulo o cero. Los comentarios deben ir precedidos del símbolo #.
8
Perl
Sentencias de control condicionales e iterativas El uso de las sentencias de control condicionales e iterativas se usa para alterar el flujo de un programa. Se entiende por BLOQUE a todo conjunto de sentencias que se encuentren entre dos llaves, por
{$nombre = “Me llamo Juan\n”;print $nombre;} Se entiende como EXPRESION a toda expresión cuya evaluación resulte ser un valor booleano, es decir, verdadero o falso. En PERL se considera como verdadero todo valor no nulo.
1.5. Sintaxis esquemas condicionales. Dentro de los primeros tenemos los siguientes formatos:
if (EXPRESION) BLOQUE. Un ejemplo de uso podría ser:
print "\n\nPENSANDO UN NUMERO ....\n"; $numero = int (rand(9) + .5); print "Adivina el número pensado (1 a 10): "; $entrada =
; $entrada = int($entrada); if($entrada == $numero) {print "Has acertado.\n";} if($entrada > $numero){print "El numero es mayor que el pensado.\n";} if($entrada < $numero) {print "El numero es menor que el pensado.\n";} print "\nEL NUMERO PENSADO ERA: ",$numero,"\n\n";
if (EXPRESION) BLOQUE else BLOQUE. Por ejemplo:
print "\n\nPENSANDO UN NUMERO ....\n"; $numero = int (rand(9) + .5); print "Adivina el número pensado (1 a 10): "; $entrada = ;
www.maptek.cl
9
$entrada = int($entrada); if($entrada == $numero) {print "Has acertado.\n";} elsif($entrada > $numero) {print "El numero es mayor que el pensado.\n";} Else {print "El numero es menor que el pensado.\n";} print "\nEL NUMERO PENSADO ERA: ",$numero,"\n\n"; En lugar de if podemos usar unless que tiene el significado contrario.
1.6. Sintaxis esquemas iterativos. while (EXPRESION) BLOQUE . Mientras se cumpla la condición EXPRESION se ejecutará todo lo que haya en BLOQUE. Por ejemplo;
print "\n\nPENSANDO UN NUMERO ....\n"; $numero = int (rand(9) + .5); $entrada = -1; while ($entrada != $numero){ print "Adivina el número pensado (1 a 10): "; $entrada = ; $entrada = int($entrada); if($entrada == $numero){ print "Has acertado.\n";} elsif($entrada > $numero) {print "El numero es mayor que el pensado.\n";} Else {print "El numero es menor que el pensado.\n";}} print "\nEL NUMERO PENSADO ERA: ",$numero,"\n\n"; Se puede usar until en lugar de while, que tiene el efecto contrario a éste. Si lo que se desea es hacer la primera comparación después de la primera iteración se puede usar un esquema iterativo do BLOQUE until o do BLOQUE while. for (EXPRESION1; EXPRESION2; EXPRESION3)
10
Perl
Se isa igual que en C. Por ejemplo
@valores = (35..70); print "\nValores del arreglo:\n"; for($i=0;$i<@valores;$i++) {print "Valor ",$i+1,"=",$valores[$i],"\n";} Y por último tenemos:
foreach var (array) BLOQUE Con este esquema se obtiene cada uno de los valores que contiene array que son depositaos en la variable var. Por ejemplo:
@valores = (35..70); print "\nValores del arreglo:\n"; foreach $val (@valores) {print "$val \n";}
1.7. Subrutinas. Otro aspecto de interés en PERL es la definición y manejo de subrutinas. El formato de declaración de una subrutina es: sub NOMBRE BLOQUE Ejemplo:
sub saludo{print
"Hola\n";}
Para llamar a la subrutina existen varias formas: nombre_de_la_subrutina(); o do nombre_de_la_subrutina(); o &nombre_de_la_subrutina;
www.maptek.cl
11
Las tres formas producen el mismo resultado con la excepción de que en el caso de la última no es necesario poner los paréntesis. Si se necesita pasar argumentos, estos deben ir entre los paréntesis, y serán almacenados en el array de escalares @_, es decir para saber el número y el valor de los argumentos pasados a una subrutina hay que leer de este array predefinido.
Por ejemplo:
sub muestra_valor {local ($string)=@_;print ($string;} muestra_valor ("Hola\n"); La función local() sirve para declarar variables locales a la subrutina, sin embargo se puede haber referencias directamente el array @_. Por defecto las rutinas retornan la última expresión evaluada, pero se puede devolver explícitamente un o más valores usando return.
Se puede pasar un arreglo como parámetro de la siguiente forma;
sub muestra_valores {my ($mensaje,@datos) = @_;print $mensaje;foreach $val (@datos) {print "$val \n";}} @valores = (35..70); muestra_valores ("Valores del arreglo:\n",@valores);
1.8. Operadores. Gran parte de los operadores de PERL son heredados del lenguaje C. Tiene una gran variedad y se usan igual que en todos los lenguajes y se utilizan principalmente para realizar operaciones aritméticas y lógicas. Se puede clasificar a los operadores en los siguientes tipos:
Operadores de comparación: se usan para comparar dos expresiones y el resultado puede ser lógico numérico. Los siguientes son los operadores de comparación:
Compara dos valores iguales. Devuelve un valor lógico verdadero cuando son iguales y falso en caso contrario
if ($radio == 1) { ...} si el valor almacenado en $radio es uno entonces entrará en el BLOQUE entre paréntesis. eq Se usa igual que == pero para expresiones tipo string.
12
Perl
!= Es el caso opuesto a ==, es decir, compara si dos expresiones son distintas.
if ($radio != 1) { ...} Entra al bloque si los valores son diferentes ne Se usa igual que != pero para expresiones tipo string.
< Retorna un valor lógico verdadero el valor numérico de la expresión de la izquierda es menor que el valor de la expresión de la derecha, en caso contrario retorna falso.
if ($radio < 1) { ...} Ejecuta las instrucciones entre paréntesis si el valor de $radio es inferior que 1.
> Es el comparador inverso de <. Retorna verdadero si la expresión numérica de la izquierda es mayor que el de la derecha, retorna false en otro caso: if ($radio > 1) { ...} Ejecuta las instrucciones entre paréntesis si el valor de $radio es mayor a 1.
<= ,>= Los operadores <= y >= además verifican la condición de igualdad
lt , gt Son los equivalentes de < y > para los tipos de dato no numéricos, como las cadenas. Por ejemplo lt devuelve verdadero si el orden de la cadena de la izquierda es menor que el de la cadena de la derecha, y gt que devuelve cierto si la cadena de la izquierda es mayor que el orden de la cadena de la derecha.
le , ge Son los equivalentes de <= y >= para los tipos de dato no numéricos
cmp Se usa para comparar caracteres. Retorna 0 si los caracteres comparados son iguales, 1 si la cadena de la derecha se encuentra al comienzo de la de la izquierda, y -1 en el caso contrario:
'one' cmp 'one'
retorna
0
'one dog ' cmp 'one'
retorna
1
'dog one' cmp 'one'
retorna -1
'es diferente' cmp 'one'
retorna -1
<=> Se usa para comparar valores numéricos, retornando 0 cuando son iguales, 1 cuando el termino de la derecha es menor que el de la izquierda y -1 en el caso contrario. =~ Se usa en las expresiones regulares para indicar la presencia de un patrón de comparación dentro de una variable que contiene una cadena de caracteres:
if ($var =~/pepe/) { ...} Verifica si la cadena 'pepe' se encuentra dentro de $var y si es así, ejecuta el código entre llaves. !~. Verifica la no existencia del patrón de búsqueda en una cadena:
if ($var !~/pepe/) { ...}
www.maptek.cl
13
Si la cadena 'pepe' no está en $var se ejecuta el código entre llaves.
Operadores de asignación: se usan para dar valores a cualquier tipo de variables validas en PERL. = Se utiliza para asignar a la variable que se encuentra a la izquierda del operador el valor de la expresión de la derecha.
$nombre = 'Juan Soto'; Asigna la cadena 'Juan Soto' a la variable $nombre.
=~ A parte de la función de verificación de existencia de un patrón dentro de una cadena que anteriormente se explicó, este operador dentro de una expresión regular de sustitución se utiliza para sustituir un patrón de comparación por otra cadena:
$var =~ s/one/uno/; Se reemplaza la ocurrencia de la cadena 'one' por la cadena 'uno'.
Operadores aritméticos: Se utilizan para realizar las operaciones aritméticas necesarias en el manejo de las expresiones. Además de los operadores aritméticos comunes como +(suma), (resta), *(multiplicación) y /(división), PERL incluye los siguientes operadores: ** Se emplea para obtener la potencia de un valor numérico, por ejemplo:
$var = 3; $var**2; El valor almacenado en var es 9.
. Se utiliza para concatenar dos cadenas de caracteres. Por ejemplo: $var = 'Juan'; $var . ' Soto'; var contendrá la cadena Juan Soto
x Multiplica n veces la cadena de caracteres especificada, por ejemplo:
'ja' x 3; Expresa una cadena de 6 caracteres: jajaja.
% Se usa para obtener el módulo de la división entre dos números, ejemplo:
$var = 5 % 2; El valor que se asigna a var es 1.
| Permite realizar una operación binaria 'o' entre 2 valores numéricos, por ejemplo
$var = 3 | 2;
14
Perl
El valor que se asigna a la variable es 3.
& Permite realizar una operación binaria 'y' entre 2 valores numéricos, por ejemplo:
$var = 3 & 2; El valor asignado es 2.
El operador = está muy relacionado con los operadores aritméticos de modo que es posible combinarlos siguiendo el siguiente formato:
$variable (operador aritmético)= expresión; Con esto se logra realizar la operación aritmética, y posteriormente asignar el valor a la variable, como por ejemplo: $var = 5; $var += 6; A $var se asigna 5 luego se suma el valor de $var más 6 y el resultado se asigna a $var, es decir 11.
$var = “Juan”; $var .= “ Soto”; El valor de la variable será Juan Soto.
Operadores lógicos o relacionales: permiten relacionar dos o más expresiones condicionales para determinar si el resultado lógico es verdadero o falso. Estos son los diferentes operadores lógicos de Perl: | Se utiliza en las expresiones regulares como operador lógico 'o', de modo que retorna verdadero siempre que cualquiera de los patrones de búsqueda que componen la expresión sea cierto y falso cuando los dos son falsos. Por ejemplo
if ($var !~/pepe | juan/) { ...} El código entre llaves se ejecuta si en la cadena que se encuentra dentro de la variable no existe una ocurrencia igual a 'pepe' o igual a 'juan'. También se usa para unir dos expresiones condicionales, por ejemplo:
if ($var == 6 | $var < 3) { ...} Ejecuta el código entre llaves si la variable es igual a 6 o menor que 3.
|| También representa la operación lógica 'o' pero en este caso se utiliza sobre instrucciones y no sobre expresiones regulares. & Trabaja como un operador lógico 'y' en expresiones regulares, permite confrontar 2 patrones, por ejemplo:
if ($var =~ /pepe & juan/) { ...}
www.maptek.cl
15
El código entre paréntesis se ejecuta si dentro de la variable existe una ocurrencia de la cadena 'pepe' y otra de la cadena 'juan'. También se utiliza para comparar expresiones condicionales. && Trabaja como un operador lógico 'y', pero sólo sobre instrucciones y no sobre expresiones regulares. ! Con este operador se puede realizar una evaluación negativa de la expresión, por ejemplo: if (!$var) { ...} Entra al bloque si la variable var es nulo o 0.
Operadores de Archivo: Se utilizan para verificar en el sistema operativo los permisos de un archivo, o su naturaleza de ejecución, etc.
-r : indica si el archivo tiene permiso de lectura.
-W : indica si el archivo tiene permiso de escritura.
-T : indica si el archivo es de tipo texto.
-e : indica si el archivo existe.
-z : indica si el archivo tiene tamaño 0.
-s : indica si el archivo es mayor que 0.
-f : indica si el archivo es plano.
-d : indica si se trata de un directorio.
-M : indica el número dias después de la última modificación
-B : indica si el archivo es binario.
-t : indica si el archivo esta abierto en un terminal.
16
Perl
1.9. Variables predefinidas. El siguiente es un listado de los nombres especiales más usados que incluye PERL: "$_" contiene el contenido del último registro leído de un archivo. "$. " contiene el número de la última línea leída de un archivo. "$/ " separador de campo para la entrada. "$," separador de campo para la salida, aplicable a print. "$\ " separador de registro para la salida, aplicable a print. "$~" contiene el nombre del formato o reporte definido para la salida actual. "$^" contiene el nombre de la cabecera de formato o reporte definido para la salida actual. "$$" número de proceso perl scripts que se esta ejecutando actualmente. "$&" representa el valor de la última cadena de caracteres comparada exitosamente. "$`" y "$'" estos dos términos se utilizan conjuntamente para separar cadenas de caracteres comparadas exitosamente. "$!" contiene el valor actual de ERRNO, es decir, el último error acontecido. "$0" contiene el nombre del archivo que hemos dado a nuestro perl script. "$[" contiene el valor del primer índice de una array de escalares, por defecto es 0. "$<" uid real del proceso actual. "$>" uid efectivo del proceso actual. "$(" gid real del proceso actual. "$)" gid efectivo del proceso actual. @ARGV contiene los parámetros pasados a nuestro perl script.
1.10. Funciones. El siguiente es un listado con algunas de las funciones más utilizadas:
abs: devuelve el valor absoluto de la expresión pasada. chmod: cambia los permisos de los archivos dados. chop: recorta y retorna el último carácter de una cadena. chown: cambia el propietario de los archivos dados. close : cierra un archivo. cos: devuelve el coseno del ángulo dado en radianes. defined: sirve para comprobar si existe una variable, formato, subrutina, etc.. delete: borra un valor de un array asociativo a través de su clave. die: imprime en la salida del error estándar un mensaje pasado como parámetro cuando ocurre un error en la ejecución de una sentencia.
www.maptek.cl
17
eof: retorna verdadero si el final del archivo dado. eval: evalúa la expresión pasada como si se tratase de un pequeño programa perl. exec: ejecuta lo que pasemos como parámetro y sale del programa. exit: hace que salgamos del perl script devolviendo al sistema operativo el valor pasado como argumento. exp: retorna el número e elevado a la potencia pasada como parámetro. fileno: devuelve el descriptor del manejador del archivo pasado como parámetro. fork: realiza una llamada fork. getc: lee el siguiente caracter del archivo especificado. hex: devuelve el valor decimal del numero hexadecimal pasado como parámetro. index: devuelve la posición de la primera ocurrencia de una cadena en otra. int: devuelve la parte entera del parámetro pasado. join: une las cadenas pasadas como argumento con un separador también pasado como argumento. keys: devuelve todas las claves de un array asociativo. length: devuelve la longitud en caracteres del parámetro pasado. local: declara como locales las variables pasadas como argumentos. log: devuelve el logaritmo del número dado. mkdir: crea un directorio en el camino dado. oct: devuelve el valor decimal del numero octal pasado como parámetro. open: abre el archivo dado asociándole un manejador de archivo especificado también como parámetro. pop: retorna y borra el último elemento del array dado. print: muestra en la salida standard o en el archivo especificado la expresión dada. printf: permite formatear expresiones que se muestra en la salida standard o en el archivo. push: añade el valor dado al final del array pasado como parámetro. rand: devuelve un numero aleatorio entre 0 y el valor pasado como argumento. read: lee un determinado número de caracteres desde el archivo pasado como argumento. rename: sirve para renombrar un archivo. require: sirve para incluir código externo en nuestro guión. return: devuelve un valor desde una subrutina. rmdir: borra un directorio. seek: sitúa un puntero a archivo en un lugar determinado. select: sirve para seleccionar el manejador de archivo que será utilizado por defecto para la salida de los comandos o funciones que no especifiquen un determinado manejador de archivo como parámetro. shift: devuelve el primer valor del array dado borrándolo posteriormente. sin: devuelve el seno del ángulo pasado en radianes. sleep: causa que el perl script o guión se detenga el número de segundos especificados.
18
Perl
sort: ordena el array dado. split: divide una cadena en subcadenas según el separador especificado. sqrt: devuelve la raiz cuadrada del número pasado. system: igual que exec pero no se sale del perl script. tell: devuelve la posición actual del puntero a archivo del manejador de archivo especificado. values: devuelve todos los valores del array asociativo dado. write: escribe un registro con formato en el archivo asociado a ese formato. %ENV array asociativo que contiene las variables de entorno bajo el que se ejecuta nuestro perl script.
1.11. Referencias. Esta sección fue elaborada en base a manuales y referencias de Perl tomadas de Internet
http://www.perl.com/ http://www.ulpgc.es/otros/tutoriales/perl/indice.htm http://perldoc.perl.org/index-functions.html http://kataix.umag.cl/~mmarin/topinf/perl.html http://www.htmlpoint.com/perl/index.html
www.maptek.cl
19
20
Perl
Módulo LAVA 2.1. Introducción. Lava es un módulo creado por Maptek para ser usado en scripts Perl. Este módulo entrega acceso a funciones y objetos dentro del entorno gráfico de Vulcan, Envisage. También permite acceder y modificar modelos de bloques, bases de datos ISIS, además de la edición y creación de triangulaciones. Varias de las opciones que actualmente incorpora nuestro software fueron en su inicio scripts lava, por ejemplo: Pit Optimiser. Contact Profile. Chornos Gantt Chart, Flag 2D Polygons, Direccional Variography, Export Block Model to 4X, etc. Las que fueron desarrolladas localmente para luego ser probadas e incorporadas definitivamente en Vulcan. Actualmente este módulo es usado en la automatización de procesos del usuario mediante el uso de Macros. Dada esta potencialidad es que permanentemente Maptek ha fomentado el uso de Lava entre sus clientes.
2.2. Estructura. Dado que Lava es un módulo para ser usado en un script perl. Siempre debe ser declarado al principio del script. Así es como se declara:
use Lava La estructura de un script lava es la misma que la de un script perl. La extensión que se usa para los lava scripts es .lava, y puede ser ejecutado desde el menú File/Lava. El hecho de que un script lava es básicamente un script perl trae como consecuencia de que sea posible ejecutar scripts perl desde el mismo menú, con la diferencia que debe ser cambiada la extensión pl por lava.
www.maptek.cl
21
En esta sección usaremos la siguiente estructura para la elaboración de scripts lava:
Cabecera
La idea de tener una cabecera es básicamente por un tema de orden y seguimiento de los cambios realizados a cada script.
###################################################### # Nombre
: mi_script.lava
# Propósito: Ejemplo de script lava # Creacion : 21-Mayo-2008 # Autor
: Nelson González Yentzen
# Lugar : Maptek – Oficina Viña del Mar Modificado # Modifid 26-Mayo-2008 NGY – Nueva rutina AutoBMF # Modifid
:
: 24-Mayo-2008 NGY – Agrega use strict
# ###################################################### Declaración de módulos incluidos
use Lava; use Win32::OLE; use strict; use vulcan;
Declaración de variables globales;
A continuación se declaran las variables que serán visibles y modificables en cualquier lugar del script. Por ejemplo:
my $variable1; my @array1;
22
Módulo LAVA
Declaración de subrutinas
sub subroutine1 {my ($var1,$arr1) = @_;my $result = -1;..return($result);} Parte principal del script
En esta sección es donde se lleva el control de flujo principal del programa. Por ejemplo
My $value1 = subroutine1 ($var1,@array1); Esta forma de estructurar el script es igual que la usada en el lenguaje C, sin embargo no existe una regla para ello, por lo que las subrutinas podrían estar declaradas al final del script.
2.3. Funciones Lava::Version Esta función determina la versión actual de Lava.
$version = Lava::Version(); Lava::Show Muestra temporalmente el mensaje guardado en $message
Lava::Show($message);$msg : Texto a ser desplegado Lava::Message Despliega el mensaje guardado en pantalla espera que el usuario presione el botón OK
$msg = “Peoceso finalizado.”;Lava::Message($msg); Lava::Error Despliega un mensaje de error, espera que el usuario presione el botón OK.
$msg = “Error cargando datos”;Lava::Error ($msg);
www.maptek.cl
23
Lava::Report Despliega un mensaje de texto en la ventana de reporte
Lava::Report($meg);$msg : Texto a ser desplegado en el reporte Lava::Project Retorna el código de proyecto actual.
$project = Lava::Project(); Lava::Environment Retorna el código de ambiente actual
$envir = Lava::Environment(); Lava::Current_BModel Retorna el nombre del modelo de bloques actualmente abierto o un string vacío si no hay modelo de bloques abierto.
$nombre_bm = Lava::Current_BModel($modo)
$nombre_bm : contiene nombre de modelo de bloques actualmente abierto (si es aplicable).$modo: modo de retornar el nombre (0 = retorna el nombre con la ruta completa, 1 = sólo el nombre). Nota: $nombre_bm será un string nulo si no hay modelo de bloques abierto.
Lava::Object_Visibility Cambia la visibilidad de un objeto, usando el segmento gráfico que lo identifica ($seg). Lava::Object_Visibility($seg,$modo) $seg : segment gráfico del objeto $modo : modo de visibilidad (0=visible,1=sombreado,2=invisible) Lava::View Esta función despliega un mensaje
Lava::View($msg) $msg : Texto a ser desplegado
24
Módulo LAVA
2.4. Clases Existen tres tipos de clases, clases Lava (que solo pueden ser usadas dentro de Envisage), clases Vulcan (que pueden ser usadas fuera de Envisage) y la clase Triangulación, que al igual que las clases Vulcan, puede ser usada fuera de Envisage.
2.5. Clases Lava 2.5.1. Lava::Panel
Se utiliza para crear paneles en el ambiente de Envisage. Sólo puede ser abierto un panel a la vez
Métodos El constructor crea una nueva instancia de Lava::Panel e inicialízalo valores requeridos. No es posible un nuevo panel si uno está “abierto”.
$panel = new Lava::Panel; $panel: nueva instancia de la clase Lava::Panel
execute Levanta el panel creado
$panel->execute($titulo); $titulo: Texto que se despliega en la barra superior del panel
text Crea una línea de texto en el panel
$panel->text($text); $text: Texto que se desplegará dentro del panel
ítem
www.maptek.cl
25
Crea una caja de edición para tomar diferentes tipos de datos
$panel->item($label,$variable,$length); $label: Etiqueta del componente a desplegar $variable: variable donde se guardará el valor leído $length: largo del campo
numeric Crea una caja de edición para tomar datos de tipo numérico
$panel->numeric($label,$variable,$length,$decimals); $label: Etiqueta del componente a desplegar $variable: Variable numérica donde se guardara el valor leído $length: número de elementos del campo $decimals: número de decimales del valor leído
Ejemplo:
$edad="21"; $panel->numeric("Ingresa tu edad”,\$edad,3,0);
colour Permite seleccionar un color desde la paleta de colores
$panel->colour($label,$variable); $label: Etiqueta del componente a desplegar $variable: Variable entera donde se guardará el número del color seleccionado (1-32)
line
26
Módulo LAVA
Permite seleccionar un tipo de línea
$panel->line($label,$variable); $label: Etiqueta del componente a desplegar $variable: variable entera donde se guardará el número del tipo de línea seleccionado
pattern Permite seleccionar un tipo de pattern
$panel->pattern($label,$variable); $label: Etiqueta del componente a desplegar $variable: Variable entera donde se guardara el numero del pattern seleccionado (1-32)
on_side Indica que el elemento previamente definido en el panel va a la derecha del que fue establecido antes que él.
$panel->on_side; pick_list Este método siempre va acompañando a un método item. Permite seleccionar un archivo de un grupo de archivos en un directorio específico.
$panel->pick_list($dir,$file_ext, $remueve_ext); $dir: Directorio donde se buscaran los archivos (ejemplo: ¨.¨) $file_ext: Tipo de archivos a mostrar en la lista $remueve_ext: Especifica si se oculta la extensión (0=no, 1=si)
Ejemplo:
$image = "fase.gif"; $panel->item("Enter image name",\$image); $panel->pick_list(".","*.gif;*.rgb",1);
pick_list_data
www.maptek.cl
27
Permite seleccionar un elemento de un array. Al igual que el anterior siempre va acompañando a un método ítem
$panel->pick_list_data(@array); @array: Conjunto de todo tipo de valores logical_button Crea una casilla de verificación (tick) en el panel
$panel->logical_button($label,$variable); $label: Etiqueta del componente a desplegar $variable: Asume un 1 si se selecciona y 0 en caso contrario
radio_button Crea un radio button. Al activarse uno de los radio buttons en un panel todos los otros con el mismo grupo son desactivados.
$panel->radio_button($rnum,$label,$variable); $rnum: Número que identifica al grupo de botones $label: Etiqueta del componente a desplegar $variable: Al activarse el botón asume el valor 1, en caso contrario 0
if; y endif Utilizado conjuntamente con logical_button y radio_button, indica que la parte contenida entre estos dos métodos depende de la selección del botón previamente definido
new_page Permite dividir el panel en dos o más paneles.
28
Módulo LAVA
begin_indent; y end_indent; Indenta los elementos definidos dentro de estos. Ejemplo:
# Variables globales # my $true = 1; my $false = 0; my $invalidval = -9999; my $bigvalue = 10000000000.0; my @expantypes = ("Use the major part of the polygon", "Use the minor part of the polygon", "Always ask me which part to use"); ################## my $panel; #
Variables de criterio de trabajo
my $crteline = $true; my $crtepoly = $true; my $expancrit = $expantypes[0]; # Variables para las lineas my $lncol = 7; my $lntyp = 0; my $lngrp = ""; my $lnnam = ""; # Variables para los poligonos de trabajo my $wrkpollncol = 2; my $wrkpollntyp = 20; # Variables para los lineas de trabajo my $wrklncol = 6; my $wrklntyp = 20; # Variables de layers my $lay = "TU_LineLay";
my $cllay = $true;
my $tmplay = "TU_TempLay"; # Metodo para la fusion de poligonos my $method = “”; my $polymerge = $false; my $boundary_method = $true; my $Bcdeginterv = 9.0;
www.maptek.cl
29
my $Bcradius = 0.05; my $rcf_method = $false; my $min_ang = 90.0; my $conv_fence = $false; my $fustol = 0.0; my $svpolylay = $false; my $fustol1 = 0.05; my $fustol2 = 0.05; # Layer donde seran guardados los resultados my $polylay = "TU_PolyLay"; my $clpolylay = $true; my $panel = new Lava::Panel; $panel = new Lava::Panel;
$panel->text("
SOFTWARE VULCAN - TOE UPDATE");
$panel->text("
Version $version");
$panel->text(""); $panel->logical_button("Building-Fusioning polygons",\$crtepoly); $panel->if; $panel->begin_indent; $panel->radio_button(2,"Boundary connection",\$boundary_method); $panel->radio_button(2,"Polygon merge",\$polymerge); $panel->end_indent; $panel->begin_indent; $panel->logical_button("Save in layer",\$svpolylay); $panel->end_indent; $panel->if; $panel->item("",\$polylay,10); $panel->on_side; $panel->end_indent; $panel->text(" "); $panel->on_side; $panel->logical_button("
Clear before",\$clpolylay);
$panel->on_side; $panel->endif; $panel->endif;
30
Módulo LAVA
$panel->text(""); $panel->logical_button("Create expansion lines",\$crteline); $panel->if; $panel->item("
Expansion criteria",\$expancrit,33);
$panel->pick_list_data(@expantypes); $panel->colour("
Line ",\$lncol);
$panel->line("
",\$lntyp);
$panel->on_side; $panel->item("
Group",\$lngrp,10);
$panel->on_side; $panel->item("
Name",\$lnnam,10);
$panel->on_side; $panel->item("
Layer",\$lay,10);
$panel->text(" "); $panel->on_side; $panel->logical_button("
Clear before",\$cllay);
$panel->on_side; $panel->text(" "); $panel->logical_button("Display remaining polygons",\$dspremaining); $panel->on_side; $panel->endif; $panel->text(""); $panel->text("Temporal - Working Parameters"); $panel->item("Working layer",\$tmplay,10); $panel->text("Polygons"); $panel->colour("",\$wrkpollncol); $panel->on_side; $panel->line("
",\$wrkpollntyp);
$panel->on_side; $panel->text("
Lines");
$panel->on_side; $panel->colour("",\$wrklncol); $panel->on_side; $panel->line("
",\$wrklntyp);
$panel->on_side; $panel->execute("Maptek Chile Application") or exit;
Resultados:
www.maptek.cl
31
32
Módulo LAVA
2.5.2. Lava::Obj
Permite la creación de objetos, los que pueden ser agregados a Envisage
Métodos
El constructor crea la instancia de la clases Lava::Obj e inicializa las variables necesarias. Si se le agrega “text” el objeto será tipo texto sino será polígono (línea). $my_obj = new LavaObj [“text”];$obj: nueva instancia de la clase Lava::Obj
Name Nombre del objeto
[$objname] =$obj-> name([$newname]); $objname: contiene el nombre del objeto $newname: renombra el objeto al ponerse en esta forma
De esta forma el nombre del método indica el atributo del objeto en si… name:
Nombre (texto)
description: Descripción (texto) group: Grupo (texto) primitive: Primitiva (ver referencias) control: Control (ver referencias) colour: Color (entero) line: Tipo de línea (entero) pattern: Tipo de pattern (entero) closed: Cerrado/Abierto (1:Cerrado ó 0:Abierto) feature: Feature (ver referencias)
[$objdesc] = $obj->description([$newdesc]); [$objgroup] = $obj->group([$newgroup]); [$primitiva] = $obj->primitive([$newprimitive]); [$objcontrol] = $obj->control ([$newcontrol]); [$objcolour] = $obj->colour ([$newcolour]); [$objline] = $obj->line([$newline]); [$objpattern] = $obj->pattern([$newpattern]);
www.maptek.cl
33
[$objclosed] = $obj->closed([$newclosed]); [$objfeature] = $obj->feature([$newfeature]);
Coordinates Coordenadas espaciales del objeto
($coords) = $obj->coordinates([$new_coords]) Ejemplo:
$coords = $obj->coordinates(); ($x,$y,$z,$w) = $coords->i(0) primera coordenada del objeto
($text) = $obj->text($newtext) $text contiene el puntero del texto del objeto
Ejemplo Dibujar un triangulo en el plano XY
($poly[0][0], $poly[0][1], $poly[0][2]) = (0,0,0); ($poly[1][0], $poly[1][1], $poly[1][2]) = (0,1,0); ($poly[2][0], $poly[2][1], $poly[2][2]) = (1,1,0); # se crea el objeto $obj = new Lava::Obj; $newcoords = $obj->coordinates; $obj->name(“name”); $obj->colour(1); $obj->line(0); $obj->group(“group1”); $obj->closed(1); for ($p=0 ; $p<3; $p++) {$newcoords->i($p,$poly[$p][0], $poly$p][1], $poly[$p][2], 0,1);}
34
Módulo LAVA
# anora se agrega el objeto en el layer
$layer->add($obj);
2.5.3. Lava::Coord El objeto Lava::Coord encapsula un arreglo de registros de coordenadas. En el punto anterior se mostró cómo se tratan tales registros. Los objetos textos solo usan la primera coordenada para definir su posición (registro 0, o coordenada 0). Métodos:
($coord) = new Lava::Coord $coord: nueva instancia creada de un objeto Lava::Coord Un objeto Lava::Coord vacío puede ser creado usando este método. Este paso usualmente no es utilizado porque el objeto Lava::Coord es automáticamente creado cuando se crea un objeto Lava::Obj y usualmente se adquiere una referencia a éste del objeto Lava::Obj. i Permite acceder a una coordenada, tanto para examinarla como para setearla.
([$x,$y,$z,$w,$t,$name]) = $coords>i($i[,$n_x[,$n_y[,$n_z[,$n_w[,$n_t[,$n_name]]]]]]) $x: Si $n_x no es puesto, $x = valor X de la i-ésima coordenama.
$y: Si $n_x no es puesto, $y = valor Y de la i-ésima coordenama.
$z: Si $n_x no es puesto, $z = valor Z de la i-ésima coordenama.
$w: Si $n_x no es puesto, $w = valor W de la i-ésima coordenama.
$t : Si $n_x no es puesto, $t = Tipo de la i-ésima coordenada.
$Name: Si $n_x no es puesto, $name = Nombre de la i-ésima coordenada.
$i: Especifica que coordenada está siendo seteada/examinada.
$n_x: Si es suministrada, setea el valor X de la i-ésima coordenada.
www.maptek.cl
35
$n_y: Si es suministrada, setea el valor Y de la i-ésima coordenada.
$n_z: Si es suministrada, setea el valor Z de la i-ésima coordenada.
$n_w: Si es suministrada, setea el valor W de la i-ésima coordenada.
$n_t: Si es suministrada, setea el Tipo de la i-ésima coordenada.
$n_x: Si es suministrada, setea el Nombre de la i-ésima coordenada.
n Entrega el número de coordenadas válidas
($n) = $coords->n $n: Número de coordenadas contenidas
2.5.4. Lava::Text
Crea objetos tipo texto. En general es preferible usar la opción de crear el objeto como el paso anterior.
Métodos [$text_instance] = new Lava::Text() $text_instance: nueva instancia de la clase Lava::Text
Al igual que el tipo Lava::Obj el nombre del método indica el atributo del objeto en si… angle: Ángulo del texto height: Altura size: Tamaño de fuente font: Tipo de fuente scale: Escala Estos atributos dependen mucho de la fuente utilizada (ver referencias)
[$angle] [$height] [$size] [$font] [$scale]
36
= = = = =
angle([$newangle]) height([$newheight]) size([$newsize]) font([$newfont]) scale([$newscale])
Módulo LAVA
Ejemplo:
$obj = new Lava::Obj "text"; $obj->name(“Objeto texto”); $obj->colour(2); $obj->group("hole_ang"); $text = $obj->text; $text->font(4); $text->size(0.05); $text->height(0.5); for ($i=0; $i<3;$i++) { $msg = “hola”.$i; $text->i($i,$msg); } # ubicación del texto $obj->coordinates->i(0,100,200,300, 0, 1); $layer->add($obj);
2.5.5. Lava::Layer
Permite la creación de capas (layers)
Métodos El constructor crea una nueva instancia de Lava::Layer e inicialízalo los valores necesarios.
$layer = new Lava::Layer [$nom],[$desc],["clear"];
www.maptek.cl
37
$layer: nueva instancia de la clase panel panel $nom: Nombre del layer $descn: Descripcion; "clear": Indica que se limpiara al momento de crear o abrir
is_valid Indica si el layer es válido
($valid) = $layer->is_valid() add Agrega un objeto (de tipo Lava::Obj) al layer
$layer->add($my_obj); $my_obj: Objeto a ser agregado
2.5.6. Lava::Point
Permite seleccionar puntos dentro del ambiente grafico
$point = new Lava::Point($msg); $point: nueva instancia de la clase Lava::Point $msg: Mensaje a ser desplegado en la barra de diálogo al momento de solicitar el punto
Métodos is_valid Retorna verdadero si el punto es válido o no
$result = $point->is_valid(); $result: indica si el punto es válido o no
38
Módulo LAVA
get Toma el punto de envisage
($result) = $point->get(); $result indica si el usuario selecciono o no un punto
position Retorna las coordenadas X,Y,Z del punto seleccionado
($x,$y,$z) = $point->position(); $X,$Y,$Z: coordenadas del punto pinchado
Ejemplo
my $point = new Lava::Point("Select a point"); my $x,$y,$z; ($x,$y,$z) = $point->position if ($point->get); 2.5.7. Lava::Selection
Permite seleccionar objetos del ambiente grafico 3D.
$sel = new Lava::Selection ([$prompt[,$flags]]); $prompt: mensaje a desplegar en la barra de dialogo $flags: opciones de selección: (multi: selección múltiple; shadow: ensombrece lo seleccionado; points: realza los puntos de la selección)
www.maptek.cl
39
Ejemplo:
a)$sel = new Lava::Selection “Select any object”; $sel: objeto seleccionado
b)$sel = new Lava::Selection “Select the objects”,”multi”; Este es un tipo de selección múltiple (multi) y se desplegará el panel popup típico de selección de objetos. Requiere de algunos métodos para recorrer la selección de objetos.
Métodos has_more Indica que la selección corresponde a un objeto valido next Avanza al siguiente objeto en la selección is_first Indica si el objeto es el primero en la lista de selección id Identificador unico del objeto seleccionado layer Nombre del layer del que proviene el objeto seleccionado replace Reemplaza los atributos de los objetos (name,group,colour,line,pattern,etc…) en caso de ser modificados
Ejemplos:
a)
Cambia el color de los objetos seleccionados y borra el nombre
$sel = new Lava::Selection “Select the objects”,”multi,shadow”; while ($sel->has_more()) { $color = $sel ->colour(); $color += 1 if ($color < 30); $sel->colour($color); $sel->name(“”); $sel->replace();
40
Módulo LAVA
$sel->next();} b)
Escrito de otro modo
for ($sel = new Lava::Selection “Select the objects”,”multi,shadow”; $sel->has_more();$sel->next) {$color = $sel ->colour(); $color += 1 if ($color < 30); $sel->colour($color); $sel->name(“”); $sel->replace();} 2.1.7. Lava::TriSelection
Permite seleccionar y editar triangulaciones cargadas en el ambiente grafico.
($trisel) = new Lava::TriSelection [$prompt]: $trisel: triangulacion seleccionada $prompt: mensaje de selección
Métodos is_valid Indica si el usuario ha seleccionado una triangulación ($result) = $trisel->is_valid() $result: Tiene 1 si es válida y 0 en caso contrario
name Nombre de la triangulación seleccionada. El nombre incluye la ruta completa donde se encuentra.
($name) = $trisel->name()
www.maptek.cl
41
Index Índice de la triangulación. Número único que la identifica de entre todas las triangulaciones cargadas
($index) = $trisel->index() triangulation Retorna la estructura de la triangulación
($triangulation) = $trisel->triangulation; $triangulation: recibe las estructuras de la triangulación seleccionada (puntos e índices);
replace Guarda la triangulación seleccionada y la carga nuevamente en Envisage
$trisel->replace() Ejemplo
# Debe cargar al menos un triangulación en Envisage # Muestra los atributos de la triangulación y la traslada de lugar use Lava; # Lava::TriSelection ($trisel) = new Lava::TriSelection "Seleccione la Triangulation"; $valid = $trisel->is_valid(); printf “Is valid = %d\n“,$valid); $name = $trisel->name(); printf “Name = %s\n”,$name; $index = $trisel->index(); printf “Indice = %d”,$index;
42
Módulo LAVA
# Toma los indices de los triángulos $triang = $trisel->triangulation; $points = $triang->points(); printf “Number of points = %d\n”,$points; $triangles = $triang->triangles(); printf “Number of triangles = %d\n”,$triangles; $moveX = 200; $moveY = 200; $moveZ = 200; for ($i=0;$i<$points;$i++) {($x,$y,$z) = $triang->point($i); $x += $moveX; $y += $moveY; $z += $moveZ; $triang->point($i,$x,$y,$z); printf "\nPoint %d = %.3f
%.3f
%.3f",$i,$x,$y,$z;}
for ($i=0;$i<$triangles;$i++) {($i1,$i2,$i3) = $triang->triangle($i); printf "\nTriangle %d = %d
%d
%d",$i,$i1,$i2,$i3;}
$trisel->replace(); 2.5.8. Lava::Contourer
Permite crear contornos de triangulaciones. Se necesita que este una triangulación cargada en el ambiente 3D.
Ejemplo
use Lava;$trisel = new Lava::TriSelection;if($trisel->is_valid){ # Toma el nombre de la triangulación # que se necesita # para crear el contorno $name=$trisel->name();
www.maptek.cl
43
# Crea el objeto contorno $contourer = new Lava::Contourer($name); $layer = new Lava::Layer("CONTOURS"); $valid=1; #Select some Z levels ... while($valid) {$point=new Lava::Point("Select level"); $point->get(); if ($valid=$point->is_valid()) {my ($x,$y,$z)=$point->position(); $obj=$contourer->create_contour($z); $obj->colour(3); $obj->line(0); $obj->pattern(0); $n = $obj->coordinates->n; Lava::Message("Countor wuth $n pts Z=$z"); $layer->add($obj);}}}
2.6. Clase Triangulation Permite abrir triangulaciones desde archivo, modificarlas o crear triangulaciones nuevas.
($triangulation) = new Triangulation [$name]; $triangulation recibe la estructura de la triangulación seleccionada $name es el nombre de la triangulación a abrir
Métodos
is_valid Retorna si la triangulación es válida o no
($valid) = $triangulation->is_valid; $valid: Es 1 cuando una triangulación ha sido correctamente leida o seteada
44
Módulo LAVA
points Entrega el número de puntos de la triangulación
($npoints) = $triangulation->points $npoints: Contiene número de puntos en la triangulación
triangles Retorna el número de triángulos
($ntriangles) = $triangulation->triangles $ntriangles: Contiene el número de triángulos de la triangulación
point Permite acceder a un punto de la triangulación
([$x,$y,$z]) = $triangulation->point($i[,$newx[,$newy[,$newz]]]]) $i: numero del punto en la triangulación $x,$y,$z: coordenadas del punto $i de la triangulación $newx,$newy,$newz: nuevas coordenadas para el punto
triangle Permite acceder al índice (índice en la lista de puntos) de los vértices de un triangulo de la triangulación
([$i1,$i2,$i3]) = $triangulation>triangle($i[,$newi1[,$newi2[,$newi3]]]]) $i: numero del triangulo en la triangulación $i1,$i2,$i3: índices de los vértices del triangulo $i en la triangulación $newx,$newy,$newz: nuevos índices para el triangulo
read Permite leeri una triangulación de un disco. Si no se pone el nombre entonces es usado el nombre entregado al constructor.
$triangulation->read([$name]) $name:Nombre de la triangulación a ser leída
www.maptek.cl
45
write Este método escribe una triangulación a disco. Si no se pone el nombre entonces es usado el nombre entregado al constructor.
$triangulation->write ([$name]) $name: nombre de la triangulacion a ser guardada en disco
Ejemplos:
a)
# Abriendo desde archivo use Lava; #($trisel) = new Triangulation # ("C:/cursolava/ejercicios/lava.00t"); # o bien ($trisel) = new Triangulation ("lava.00t"); ($valid) = $trisel->is_valid(); printf “Is valid = %d\n”,$valid; ($points) = $trisel->points(); printf “Points = %d\n”,$points; ($triangles) = $trisel->triangles(); printf “Triangles = %d\n”,$triangles; for ($i=0;$i<$points;$i++) { ($x,$y,$z) = $trisel->point($i); printf "\n%.3f
%.3f
%.3f",$x,$y,$z;
} for ($i=0;$i<$triangles;$i++) { ($x,$y,$z) = $trisel->triangle($i);
46
Módulo LAVA
printf "\n%d
%d
%d",$x,$y,$z;}
b) # Creando una nueva triangulacion use Lava; ($newtri) = new Triangulation; $newtri->points(10); $newtri->point(0,91718.514,61917.882,2300.000); $newtri->point(1,91718.514,61917.882,2400.000); $newtri->point(2,92014.099,62666.965,2300.000); $newtri->point(3,92014.099,62666.965,2400.000); $newtri->point(4,92155.817,62395.675,2300.000); $newtri->point(5,92155.817,62395.675,2400.000); $newtri->point(6,92580.973,62448.314,2300.000); $newtri->point(7,92580.973,62448.314,2400.000); $newtri->point(8,92597.169,62011.011,2300.000); $newtri->point(9,92597.169,62011.011,2400.000); $newtri->triangles(16); $newtri->triangle(0,0,1,2); $newtri->triangle(1,0,1,9); $newtri->triangle(2,0,2,4); $newtri->triangle(3,0,4,8); $newtri->triangle(4,0,8,9); $newtri->triangle(5,1,2,3); $newtri->triangle(6,1,3,5); $newtri->triangle(7,1,5,9); $newtri->triangle(8,2,3,4); $newtri->triangle(9,3,4,5); $newtri->triangle(10,4,5,6); $newtri->triangle(11,4,6,8); $newtri->triangle(12,5,6,7); $newtri->triangle(13,5,7,9); $newtri->triangle(14,6,7,8); $newtri->triangle(15,7,8,9); $newtri->write("nelson.00t");
www.maptek.cl
47
48
Módulo LAVA
www.maptek.cl
49
Módulo Vulcan 3.1. Introducción. Las clases Vulcan para Lava han sido diseñadas para trabajar desde fuera de Envisage, es decir, podemos acceder al modelo de bloque o las base de datos Isis, sin necesidad que se ejecute dentro de envisage. Dentro de estas clases se encuentran la clase Block Model (vulcan::block_model), la case Isis data base (vulcan::isisdb) la clase para Map file (vulcan_mapio) y la clase de triangulación (vulcan::triangulation). Para usar estas clases es necesario agregar la instrucción de uso de la clase en la parte superior del archivo.
use vulcan;
3.2. Clases 3.2.1. Clase Block Model
La clase block model incluye métodos para abrir, acceder, recorrer, obtener información, obtener valores de campos y escribir en el modelo de bloques.
Métodos:
50
Módulo Vulcan
Acceder a un modelo de bloque:
Sintaxis:
$bm = new vulcan::block_model(name, mode); Donde: name es el nombre del modelo de bloques mode es el modo de apertura del modelo de bloques.
El modo de apertura es “r” (read) para lectura y “w” (write) para escritura.
Ejemplo:
$bm = new vulcan::block_model(model.bmf, “r”); Con la instrucción anterior abrimos, en modo de lectura, un modelo de bloques llamado model.bmf
Cerrar un modelo de bloque
Sintaxis:
$bm->close(); Obtener información sobre los campos y el modelo de bloque en general.
Obtener la lista de campos que contiene el modelo de bloques
Sintaxis:
$bm->field_list(); Obtener la lista de campos numéricos del modelo
Sintaxis:
$bm->field_list_numbers();
www.maptek.cl
51
Obtener la lista de campos textos del modelo
Sintaxis:
$bm->->field_list_string(); Verifica si un texto es un campo válido en el modelo de bloques
Sintaxis:
$bm->is_field(name); Donde: name es el nombre del campo a consultar.
Verifica si un campo es numérico
Sintaxis:
$bm->is_number(name); Donde: name es el nombre del campo a consultar.
Verifica si un campo es de tipo texto
Sintaxis:
$bm->is_string(name); Donde: name es el nombre del campo a consultar.
Obtiene la extensión del bloque actual en coordenadas relativas
Sintaxis:
$bm->model_extent();
52
Módulo Vulcan
Obtiene el origen del modelo de bloques en coordenadas reales
Sintaxis:
$bm->model_origin();
Obtiene la orientación del modelo de bloques
Sintaxis:
$bm->model_orientation(); Para un modelo no rotado estos ángulos son 90 ó 0
Obtiene el número de subesquemas del modelo de bloques
Sintaxis:
$bm->model_n_schemas();
Obtiene el k-ésimo esquema del modelo de bloques Sintaxis:
$bm->model_schema_extent(k); Donde: k corresponde al número del k-ésimo esquema
Obtiene el tamaño de bloques del k-ésimo esquema del modelo de bloques
Sintaxis:
$bm->model_schema_size(k);
www.maptek.cl
53
Donde: k corresponde al número del k-ésimo esquema
El resultado es una lista de 6 números, los primeros 3 corresponden al tamaño mínimo en X, Y, Z. Los restantes valores corresponden a los tamaños máximos de los bloques en las direcciones X, Y, Z.
Obtiene el valor de una variable del bloque actual
Sintaxis:
$bm->get(name); Donde: name es el nombre del campo a consultar.
Obtiene el valor de texto de una variable en el bloque actual
Sintaxis:
$bm->get_string(name); Donde: name es el nombre del campo a consultar.
Obtiene multiples valores para variables en el bloque actual
Sintaxis:
$bm->get_multiple( \@vl ); Donde: V1 es la lista de campos a consultar.
Asigna un valor a una variable
Sintaxis:
$bm->put(name, value);
54
Módulo Vulcan
Donde: name es el nombre del campo a escribir. value es el valor numérico a escribir
Asigna un valor a una variable de tipo texto
Sintaxis:
$bm->put_string(name, value); Donde: name es el nombre del campo a escribir. value es el valor texto a escribir
Escribe el bloque actual
Sintaxis:
$bm->write(); Avanza al siguiente bloque
Sintaxis:
$bm->next(); Si es necesario, actualiza el bloque actual antes de pasar al siguiente.
Verifica si se encontró el fin del archivo (End Of File)
Sintaxis:
$bm->eof(); Mueve el cursor al primer bloque.
Sintaxis:
$bm->rewind();
www.maptek.cl
55
Obtiene la posición actual del bloque
Sintaxis:
$bm->get_position(); Mueve el cursor a la posición especificada
Sintaxis:
$bm->set_position(pos); Busca el bloque definido por las coordenadas (x, y, z)
Sintaxis:
$bm->find_xyz(x,y,z); Donde: x, y, z es la coordenada relativa al modelo
Busca el bloque definido por las coordenadas (x, y, z)
Sintaxis:
$bm->world_xyz(x,y,z); Donde: x, y, z es la coordenada real
Métodos de conversión
Convierte coordenadas relativas al modelo en coordenadas reales
Sintaxis:
$bm->to_world(x,y,z); Donde: x, y, z es la coordenada que se desea convertir.
56
Módulo Vulcan
Convierte coordenadas reales en coordenadas relativas al modelo
Sintaxis:
$bm->to_model(x,y,z); Donde: x, y, z es la coordenada que se desea convertir.
Métodos asociados a la selección de bloques.
Crear una selección de bloques
Sintaxis:
$bm->select(expresion); La expresión sigue la norma de la selección de bloques utilizada por los programas externos de modelo de bloques.
Ejemplos de expresiones:
-C \'density eq 2.5\' Selecciona bloques de acuerdo a una condición. En este caso significa que selecciona bloques cuya densidad es igual a 2.5
-t tri.00t Selecciona bloques que estén dentro de una triangulación
www.maptek.cl
57
Los parámetros de selección son los siguientes:
-v [value]
Selecciona por variable.
-t
Selecciona por sólido (Triangulación).
-n
Superficie superior.
-u
Superficie inferior.
-O
Incluye bloques fuera de la triangulación.
-bm
Selección usando una caja con coordenadas relativas al modelo.
-bw
Selección usando una caja con coordenadas reales.
-C
Selección utilizando una expresión condicional.
-X
Usa volúmenes proporcionales cuando se utiliza selección por sólidos.
Obtiene la extensión del bloque actual
Sintaxis:
$bm->match_extent(); Si el método de selección utiliza proporción en sólidos (-X), la extensión será menor que la extensión del bloque actual. El volumen de la extensión es igual al volumen de la intersección del bloque y la triangulación.
Obtiene la extension del bloque actual
Sintaxis:
$bm->block_extent();
Almacena la selección actual y comienza una nueva selección
Sintaxis:
$bm->push_select(selection); El cursor es posicionado en el primer bloque del criterio de selección
58
Módulo Vulcan
Recupera la selección almacenada
Sintaxis:
$bm->pop_select(); El cursor se ubica en el bloque en el cual se llamo al método push_select y se recupera el criterio de selección almacenado. Las selecciones pueden ser anidadas hasta en 5 niveles. Un uso típico de estos métodos es buscar bloques cercanos a un bloque dentro de la selección creada.
Ejemplo:
Use vulcan; my $bm = new vulcan::block_model("n1.bmf", "w"); # Seleccion de bloques dentro del solido. $bm->select("-t abc.00t"); for(; !$bm->eof(); $bm->next()) {$bm->put("density", 2.5);}
www.maptek.cl
59
3.2.2. Clase IsisDB Una base de datos Isis consiste en una secuencia de registros. Cada registro tiene un tipo, el cual especifica a que tabla pertenece, en otras palabras, que campos tiene un registro. Los registros están agrupados en objetos. Un objeto es un conjunto de registros que pertenecen a una clave en particular. Una clave es un conjunto de valores del campo de clave primaria (la primera tabla definida en el diseño). Como ejemplo podemos mencionar una base de datos de sondajes, en la cual cada sondaje es un objeto y las claves corresponden al campo HOLEID de la tabla collar.
Es muy importante el orden de los registros en la base de datos. Un objeto comienza con un registro de cabecera simple (un registro cuyo tipo es la primera tabla en el diseño) y continua con los restantes registros hasta que se encuentra con el próximo registro de cabecera o el fin de la base de datos.
Métodos.
Abrir o crear una base de datos
Sintaxis:
$db = new vulcan::isisdb(name, mode, env); Donde: name es el nombre de la base de dato mode del modo en el que se abrirá la base de datos. “r” para solo lectura y “w” para lectura/escritura. env es el nombre del ambiente
60
Módulo Vulcan
Verifica si la base de datos se abrió correctamente
Sintaxis :
$db->is_open(); Este método debe ser llamado inmediatamente después de la instrucción new vulcan::isisdb para verificar que la base de datos se ha abierto correctamente. Cierra la base de datos
Sintaxis:
$db->close(); Si esta instrucción no se ejecuta antes de salir del script los cambios realizados no serán guardados.
Obtiene una lista con las tablas
Sintaxis:
$db->table_list(); Obtiene una lista de los campos de una tabla
Sintaxis:
$db->field_list(table); Donde: Table es la tabla a consultar.
Obtiene el índice de un campo
Sintaxis:
$db->field_index(field, table);
www.maptek.cl
61
Donde: Field es el nombre del campo a consultar. Table es la tabla en donde pertenece el campo.
El método retorna el índice del campo partiendo desde 1. Si el campo no existe el método retorna 1.
Obtiene una lista de los campos numéricos
Sintaxis:
$db->field_list_numbers(table); Donde: Table es la tabla a consultar.
Obtiene una lista de los campos de textos
Sintaxis:
$db->field_list_strings(table); Donde: Table es la tabla a consultar.
Elimina el registro actual
Sintaxis:
$db->delete_record() Si el registro es un registro cabecera, al eliminarlo genera que todos los registros que están a continuación pasen a pertenecer al objeto previo. Debido a este comportamiento es necesario tener cuidado al eliminar registros. Se recomienda utilizar delete_key() si se desea eliminar todo el objeto. El método retorna 0 si el registro se eliminó correctamente.
Elimina todos los registros de un objeto.
Sintaxis:
$db->delete_key(key)
62
Módulo Vulcan
Donde: Key es la clave del objeto que se desea eliminar.
Calcula la clave del objeto actual.
Sintaxis:
$db->determine_key() Calcula internamente la clave del objeto actual si el registro actual es un registro de cabecera. El valor de la clave del objeto puede ser recuperado utilizando get_key(). Este procedimiento es útil al usar find_key() con patrones. Al llamar a determine_key() y get_key() retornarán el nombre de la clave del objeto que se encontró.
Obtiene la clave del objeto actual.
Sintaxis:
$db->get_key() Se debe invocar primero el método determine_key() cuando el registro actual apunte a un registro de cabecera. Por ejemplo inmediatamente después de llamar a find_key().
Verifica si existe un campo.
Sintaxis:
$db->is_field(field, table); Donde: Field es el nombre del campo a consultar. Table es la tabla en donde pertenece el campo.
Verifica si un campo es numérico
Sintaxis:
$db->is_number(field, table); Donde: Field es el nombre del campo a consultar. Table es la tabla en donde pertenece el campo.
www.maptek.cl
63
Verifica si un campo es te tipo texto
Sintaxis:
$db->is_string(field, table); Donde: Field es el nombre del campo a consultar. Table es la tabla en donde pertenece el campo.
Obtiene el valor de un campo numérico
Sintaxis:
$db->get(field); $db->get(index); Donde Field es el nombre del campo a consultar. Index es el índice del campo a consultar.
Este método no puede ser utilizado en campos no numéricos.
Obtiene el valor de un campo no numérico
Sintaxis:
$db->get_string(field); $db->get_string(index); Donde Field es el nombre del campo a consultar. Index es el índice del campo a consultar.
Si este método se utiliza con un campo numérico el valor retornado será la representación de texto del número.
64
Módulo Vulcan
Obtiene un conjunto de valores de campos numéricos
Sintaxis:
$db->get_multiple( \@vl ); Donde v1 es una lista con los nombres de los campos que se desean recuperar.
Este método fallará si algunos de los campos en la lista es no numérico.
Obtiene un conjunto de valores de campos no numéricos
Sintaxis:
$db->get_multiple_string( \@vl ); Donde v1 es una lista con los nombres de los campos que se desean recuperar.
Si este método se utiliza con un campo numérico el valor retornado será la representación de texto del número.
Actualiza un campo numérico.
Sintaxis:
$db->put(field, value); $db->put(index, value); Donde Field es el nombre del campo a consultar. Index es el índice del campo a consultar. Value es el valor a actualizar el campo.
Este método fallará si el campo es no numérico.
www.maptek.cl
65
Actualiza un campo no numérico.
Sintaxis:
$db->put_string(field, value); $db->put_string(index, value); Donde Field es el nombre del campo a consultar. Index es el índice del campo a consultar. Value es el valor a actualizar el campo.
Si el valor es numérico, el método convierte el valor a su representación de texto.
Mueve a la siguiente posición el registro actual.
Sintaxis:
$db->next(); Si el siguiente registro es un registro válido, el método retorna el valor 0. Si al mover el cursor los datos del registro han sido modificados, éstos serán actualizados automáticamente en la base de datos.
Obtiene el nombre de la tabla del registro actual.
Sintaxis:
$db->get_table_name(); Actualiza el nombre de la tabla del registro actual.
Sintaxis:
$db->put_table_name();
Guarda el buffer en el registro actual.
Sintaxis:
$db->write();
66
Módulo Vulcan
Agrega un nuevo registro al final de la base de datos
Sintaxis:
$db->append(); Este método sólo se debe emplear cuando se agregan nuevos objetos, en general, es bastante difícil determinar a cual objeto pertenece el nuevo registro. Utilice insert_after() e insert_before() para insertar registros en objetos existentes.
Insertar un nuevo registro después del registro actual.
Sintaxis:
$db->insert_after(); Inserta un nuevo registro antes del registro actual.
Sintaxis:
$db->insert_before(); Hay que tener precaución al utilizar este método. Se debe verificar que no se encuentre en un registro de cabecera. Al utilizar este método en dicho registro, el registro se creará en el objeto anterior.
Verificar el fin de la base de datos.
Sintaxis:
$db->eof();
Obtiene la posición del registro actual Sintaxis:
$db->get_position(); Este método se puede utilizar al estilo de marcadores, para volver más tarde a una posición determinada.
www.maptek.cl
67
Ubica a la base de datos en el primer registro
Sintaxis:
$db->rewind(); Si la base de datos no contiene datos, el método eof() retornará verdadero.
Mueve la posición actual a una predeterminada
Sintaxis:
$db->set_position(pos); Donde Pos es una posición obtenida con el método get_position().
Bajo ninguna circunstancia se debe dar una posición obtenida de otra forma.
Mueve el cursor al registro cabecera con la clave dada.
Sintaxis:
$db->find_key(key); Donde: Key es la clave que se desea buscar.
La clave puede ser el nombre completo o usar caracteres comodines.
Los caracteres válidos son:
*
reemplaza 0 o más caracteres %
reemplaza un carácter.
El método retorna 0 si fue exitoso.
68
Módulo Vulcan
Mueve el cursor al siguiente objeto
Sintaxis:
$db->next_key(key); Donde: Key es la clave del objeto
El método retorna 0 si fue exitoso.
Mueve el cursor al siguiente registro del objeto
Sintaxis:
$db->next_same_key(); El método devuelve 0 si la posición resultante es un registro del mismo objeto. En otras circunstancias el estado de la base de datos pasará a EOD (end of data) o el método eof() retornará verdadero.
Agrega el buffer a un nuevo registro del la tabla
Sintaxis:
$db->append_buffer(table, buffer); Donde: Table es la tabla en la que se agregará el registro Buffer es un buffer obtenido con get_buffer().
El registro se creará al final de la base de datos. El registro pertenecerá al último objeto de la base de datos, de tal manera que este método debe usarse cuando se agregan nuevos objetos. Este método en conjunto con get_buffer() se utilizan para copiar registros a un nuevo objeto.
Obtiene un buffer desde la base de datos
Sintaxis:
$db->get_buffer();
www.maptek.cl
69
El buffer devuelto es binario y no puede ser manipulado. Se debe recuperar el tipo de tabla correspondiente al buffer usando get_table_name() y almacenar ambos valores para ser usados en conjunto con el método append_buffer()
Ejemplo
use vulcan; # abrir la base de datos para lectura my $db = new vulcan::isisdb("thordemo.dhd","r","krj"); die "Could not open database\n" unless $db->is_open(); # Obtiene una lista de tablas del diseño my @tables = $db->table_list(); # Loop a través de las tablas foreach $t ( @tables ) { # Obtiene los campos por cada tabla @fl = $db->field_list($t); # Imprime las tablas y campos print "table $t: fields "; foreach $f ( @fl ) { print "$f "; } print "\n";} # Posiciona la base de datos en el primer registro $db->rewind(); # Lee secuencialmente todos los registros for (; !$db->eof(); $db->next()) { # Imprime el HOLEID y DEPTH si el registro viene de # la table COLLAR if( $db->get_table_name() eq "COLLAR" ) {print $db->get_string("HOLEID"), " ", $db->get("DEPTH"), "\n";}} # Cierra la base de datos $db->close();
70
Módulo Vulcan
3.2.3. Clase Mapio La clase mapio nos da acceso a los archivos map y los datos contenidos en el.
Métodos.
Abrir o crear un archivo map
Sintaxis:
$db = new vulcan::mapio(name, mode, env, proj); Donde: name es el nombre del archivo map mode es el modo en el que se abrirá el archivo. “r” para solo lectura y “w” para lectura/escritura. env es el nombre del ambiente. En el caso del mapfile se deja en blanco. Proj es el nombre del proyecto. En el caso de un mapfile se deja en blanco.
Obtiene la lista de tablas.
Sintaxis:
$db->table_list(); En el caso del mapfile esta lista solo correponde al texto “data”
Obtiene los campos de la tabla
Sintaxis:
$db->field_list(); Obtiene una lista de los campos numéricos
Sintaxis:
$db->field_list_numbers(table); Donde: Tabla es el nombre de la tabla de la que se quiere obtener información
www.maptek.cl
71
Obtiene una lista de los campos no numéricos
Sintaxis:
$db->field_list_string(table); Donde: Tabla es el nombre de la tabla de la que se quiere obtener información
Test if a field exists
Sintaxis:
$db->is_field(name, table); Donde: Tabla es el nombre de la tabla de la que se quiere obtener información Field nombre del campo que se quiere probar
Verifica si un Campo es numérico
Sintaxis:
$db->is_number(name, table); Donde: Name nombre del campo que se desea probar. Tabla es el nombre de la tabla de la que se quiere obtener información
Verifica es un campo es no numérico
Sintaxis:
$db->is_string(name, table); Donde: Name nombre del campo que se desea probar. Tabla es el nombre de la tabla de la que se quiere obtener información
72
Módulo Vulcan
Obtiene el valor numérico de un campo
Sintaxis:
$db->get(name); Donde: Name nombre del campo que se desea obtener el valor.
Obtiene el valor no numérico de un campo
Sintaxis:
$db->get_string(name); Donde: Name nombre del campo que se desea obtener el valor.
Obtiene una lista de valores
Sintaxis:
$db->get_multiple( \@vl ); Donde v1 es una lista con los nombres de los campos que se desean recuperar.
Actualiza el valor de un campo numérico
Sintaxis:
$db->put(name, value); Donde: Name nombre del campo que se desea probar. Value es el valor con el cual se actualizará el campo.
www.maptek.cl
73
Actualiza el valor de un campo no numérico
Sintaxis:
$db->put_string(name, value); Donde: Name nombre del campo que se desea probar. Value es el valor con el cual se actualizará el campo.
Mueve el cursor al siguiente registro
Sintaxis:
$db->next(); Obtiene el tipo de table actual
Sintaxis:
$db->get_table_type(); Actualiza el tipo de tabla actual.
Sintaxis:
$db->put_table_type(); Escribe el bloque actual
Sintaxis:
$db->write(); Agrega al final de la base de datos
Sintaxis:
$db->append();
74
Módulo Vulcan
Verifica si se encontró el fin de archivo
Sintaxis:
$db->eof(); Obtine la posición del registro actual
Sintaxis:
$db->get_position(); Mueve el cursor al primer registro de la base de datos Sintaxis:
$db->rewind(); Mueve el cursor de la base de datos a una posición definida
Sintaxis:
$db->set_position(pos); Mueve el cursor a una clave dada (group id)
Sintaxis:
$db->find_key(key); Mueve el cursor al siguiente registro
Sintaxis:
$db->next_key(key); Mueve el cursor a la siguiente tabla
Sintaxis:
$db->next_same_key();
www.maptek.cl
75
Ejemplo:
use vulcan; my $db = new vulcan::mapio("arcabc.map","r","","arc"); my @recs = $db->table_list(); foreach $r ( @recs ) {@fl = $db->field_list($r);print "table $r\n";foreach $f (@fl) {print "
FIELD ", $r, " ", $f, "\n";}}for(; !$db->eof(); $db-
>next()){print $db->get("X"), " ", $db->get("Y"), " ", $db->get("Z"), " ", $db->get("W"), "\n";}
76
Módulo Vulcan
