Cenidet Adriana Judit... · sep seit dgit centro nacional de investigaciÓn y desarrollo tecnolÓgico cenidet entorno de graficaciÓn y generaciÓn de modelos 2d y

SEP SEIT DGIT

CENTRO NACIONAL DE INVESTIGACIÓN Y DESARROLLO TECNOLÓGICO

Cenidet

ENTORNO DE GRAFICACIÓN Y GENERACIÓN DE MODELOS 2D Y 3D PARA APLICACIONES DE VISIÓN ARTIFICIAL

(GrafO3D)

PRESENTA: ARIADNA JUDITH DÍAZ BARRITA

DIRECTORES DE TESIS: DR. RAÚL PINTO ELÍAS

DRA. AZUCENA MONTES RENDÓN

CUERNAVACA, MORELOS AGOSTO DE 2004

T E S I S PARA OBTENER EL GRADO DEMAESTRO EN CIENCIAS ENCIENCIAS COMPUTACIONALES

i

CONTENIDO Lista de figuras …………………………………………………………………………………… iii Lista de tablas …………………………………………………………………………………… v CAPÍTULO I. INTRODUCCIÓN 1.1 Introducción …………………………..……………………………………………….. 2 1.2 Organización de la tesis ……………….……….………………………………………. 4 1.3 Antecedentes ……………………………………………………………………………. 4 1.4 Descripción del problema ……………………………………………………………… 5 1.5 Marco conceptual ………………………..……………………………………………… 7

1.5.1 Estado del arte ……………………..……………………………………………… 7 1.5.1.1 Graficación 3D ……………………..…………………………………………. 7 1.5.1.2 Herramientas CAD/CAM (Computer Aided Design/ Computer Aided

Manufacturing) …………………………………………………………………… 9 1.5.1.3 VRML (Virtual Reality Modeling Language) …………………...…………. 11 1.5.1.4 OpenGL ………………..……………...………………………………………… 12

1.5.2 Estado de la práctica …..……………….………………………………………… 16 1.5.2.1 Anim8or ……………..……………...………………………………………… 16 1.5.2.2 3D Studio Max ………………………………………………………………… 18 1.5.2.3 AC3D ……………………………..…………………………………………….. 19

1.6 Propuesta de solución ……………………..……………………………………………. 21 1.6.1 Objetivo de la tesis …………………..……………………………………………. 21 1.6.2 Beneficios ……………………………………………………………………………. 21

1.6.2.1 Beneficios generales ………………….……………………………………….. 21 1.6.2.2 Beneficios específicos para el grupo de Visión Artificial del cenidet ………. 21

1.6.3 Alcances y limitaciones ……………...…..……………………………………….. 22 1.6.4 Disciplinas involucradas ……………….....……………………………………….. 23

1.7 Aplicaciones ………………………………………………………………………………. 23 1.8 Conclusiones ……………………………………………………………………………. 23 CAPÍTULO II. ANÁLISIS Y DISEÑO 2 Cap2 2.1 Introducción …………………..………………………………………………...……... 25 2.2 Requerimientos funcionales del sistema …………………..………………………… 25 2.3 Otros requerimientos …………………………………..….…………………………… 27 2.4 Modelo conceptual de GrafO3D ..………………...…...……………………………... 27 2.5 Definición y especificación de objetos ………………….……………………………. 28

2.5.1 Mundo virtual tridimensional ………………………….…………...…………… 29 2.5.2 Especificación de objetos en VRML …………………………………………….. 32 2.5.3 Especificación de objetos en OpenGL …………………………………………... 37

2.5.3.1 Primitivas para el dibujado …………………………….…………..……….. 38 2.5.3.2 Transformaciones …………………………………….……………………….. 41

2.6 Especificación de objetos en GrafO3D ……………………………………………….. 43 2.7 Persistencia y recuperación de objetos ……………………………………………….. 46 2.8 Manipulación de objetos …………………………………………………………..……. 52 2.9 Procesos para tratar archivos producidos por otras herramientas ………………… 53 2.10 Conclusiones ………………………………………………………………………........ 54

ii

CAPÍTULO III. IMPLEMENTACIÓN 3 3.1 Introducción …….……………………...…………………………………………….... 56 3.2 Especificación de objetos en GrafO3D ………………….………………………….... 56 3.3 Persistencia y recuperación de objetos ………………..……………………………… 60 3.4 Manipulación de objetos ………………..………………………………………………. 62 3.5 Procesos para tratar archivos producidos por otras herramientas ………………… 70 3.6 Conclusiones ……………..…………………………………………………………….. 71 CAPÍTULO IV. PRUEBAS Y RESULTADOS 4 asd 4.1 Introducción ……………………………….………………………………………….... 73 4.2 Especificación de casos de prueba ……………..……..…………………………….... 73 4.3 Especificación del procedimiento de pruebas ………………………………………… 74

4.3.1 Caso de prueba 1: lectura de un archivo GrafO3D ……………….....………… 74 4.3.2 Caso de prueba 2: aplicación de funciones de graficación ……………...……... 76 4.3.3 Caso de prueba 3: visualización de los modelos: modelos sólidos, en alambre y

en vértices ………………………………………………………………………………. 79 4.3.4 Caso de prueba 4: generación de animación ………………………………….... 80 4.3.5 Caso de prueba 5: lectura de un archivo de texto conformado por puntos (x,y) 86

4.4 Conclusiones ……………………………………………………………………………. 89 CAPÍTULO V. CONCLUSIONES

5 as 5.1 Introducción …………………….…………………………………………………….... 91 5.2 Metas alcanzadas ………………..……………….……..…………………………….... 91 5.3 Conclusiones …………………...……………………………..………………………… 92 5.4 Trabajos futuros ………………….…………………………………..………………….. 93 Referencias ………………………………………………………………………………………… 95 Glosario de términos …………………..…….………………………………………….....……… 97 Anexo A: funciones de bibliotecas de OpenGL ……………………………………………….. 98 Anexo B: tipos de datos de OpenGL …………………………...………………………………. 99 Anexo C: casos de uso de GrafO3D ……………………………………………………………… 100 Anexo D: ejemplo de un archivo GrafO3D ……………………………………………………. 111 Anexo E: ejemplo de un archivo de texto que describe un objeto en términos de puntos …... 112 Anexo F: ejemplo de un archivo VRML ……………………..……………………………….. 113 Anexo G: definición de la clase Lexer en la gramática de GrafO3D ……………………….. 114 Anexo H: definición de la clase Parser en la gramática de GrafO3D ……………………….. 115

iii

LISTA DE FIGURAS Figura 1.1 Ejemplos de objetos rígidos ……….…………………………………………… 2 Figura 1.2 Ejemplos de objetos articulados …..…………………………………………… 3 Figura 1.3 Ejemplos de objetos deformables ……….……………………………………. 3 Figura 1.4 Relación de GrafO3D con algunas herramientas desarrolladas en el cenidet 5 Figura 1.5 Sistema de coordenadas en un espacio 3D ……..……………………………. 8 Figura 1.6 Niveles de abstracción de OpenGL …………………………………………... 14 Figura 1.7 Matrices de transformación lineal ………..…………………………………... 14 Figura 1.8 Interfaz de la herramienta Anim8or ………………………………………… 16 Figura 1.9 Interfaz de la herramienta AC3D ……………..……………………………... 19 Figura 2.1 Diagrama de casos de uso general ……..……………………………………... 25 Figura 2.2 Modelo conceptual de GrafO3D …………………………………………….. 27 Figura 2.3 Tipos de transformaciones ……………………………………………………. 42 Figura 2.4 Tipos de proyección …………………………………………………………... 42 Figura 2.5 Diagrama de paquetes de GrafO3D …………………………………………... 47 Figura 2.6 Clases contenidas en el paquete unspecified ..….……………………………. 47 Figura 2.7 Clases contenidas en el paquete GrafO3D ………..…………………………. 48 Figura 2.8 Clases contenidas en el paquete GrafO3D (continuación de la figura 2.7) … 49 Figura 2.9 Clases contenidas en el paquete GrafO3D (continuación de la figura 2.7) … 50 Figura 2.10 Relaciones de algunas clases abstractas con sus clases hijas ……………… 51 Figura 2.11 Diseño de la interfaz de usuario de GrafO3D ………………………………. 53 Figura 3.1 Proceso para el almacenamiento de los modelos en memoria ……………… 61 Figura 3.2 Menú de opciones y barra de herramientas del entorno gráfico de GrafO3D 62 Figura 3.3 Editores de propiedades del entorno gráfico de GrafO3D ………………… 63 Figura 3.4 Controles para la manipulación de la cámara, luz, piso y ejes del entorno

gráfico de GrafO3D ……………………………………………………………….. 65 Figura 3.5 Pantalla de propiedades de la animación, opción: captura independiente de

frames ……………………………………………………………………………….. 66 Figura 3.6 Pantalla de generación de animación con movimiento de traslación,

rotación o escala ……………………………………………………………………. 67 Figura 3.7 Pantalla de generación de animación con movimiento de traslación ……. 67 Figura 3.8 Proceso para tratar archivos generados por la herramienta para el modelado

automático de objetos alfaflexibles ………………………………………………. 70 Figura 4.1 Archivo de texto y datos almacenados en memoria ………………………….. 75 Figura 4.2 Visualización de los modelos gráficos en la interfaz de usuario …………… 76 Figura 4.3 Propiedades del modelo …………………………………………………………. 77 Figura 4.4 Material del objeto ……………………………………………………………… 77 Figura 4.5 Propiedades de la luz …………………………………………………………… 78 Figura 4.6 Modelo resultante de la aplicación de funciones de graficación …………… 78 Figura 4.7 Modelos sólidos …………………………………………………………………... 79 Figura 4.8 Modelos en alambre ……………………………………………………………… 79 Figura 4.9 Modelos en vértices ……………………………………………………………… 79 Figura 4.10 Frames capturados para generar un archivo de animación ………………… 80 Figura 4.11 Frames generados por GrafO3D correspondientes al modelo de una mano … 81 Figura 4.12 Frames generados por GrafO3D correspondientes al modelo de un brazo de

un robot ……………………………………………………………………………… 82

iv

Figura 4.13 Frames generados por GrafO3D correspondientes al modelo de un gusano ... 83 Figura 4.14 Pantalla de propiedades de la animación ……………………………………… 84 Figura 4.15 Frames generados por GrafO3D ……………………………………………….. 84 Figura 4.16 Pantalla de propiedades de la animación ……………………………………… 85 Figura 4.17 Frames generados por GrafO3D ……………………………………………….. 85 Figura 4.18 Archivo de texto con la descripción del modelo de una boca ……………… 86 Figura 4.19 Modelo gráfico generado por GrafO3D ……………………………………… 87 Figura 4.20 Frames generados por GrafO3D ……………………………………………….. 87 Figura 4.21 Archivo de texto con la descripción del modelo de una boca ……………… 88 Figura 4.22 Modelo gráfico generado por GrafO3D ……………………………………… 88 Figura 4.23 Frames generados por GrafO3D ……………………………………………….. 88 Figura D.1 Modelos descritos en el archivo GrafO3D ……………………………………. 111 Figura E.1 Modelo descrito en términos de puntos en el archivo de texto ……………. 112 Figura F.1 Modelo resultante del archivo VRML ………………………………………… 113

v

LISTA DE TABLAS Tabla 2.1 Descripción de los casos de uso del diagrama ………………………………. 26 Tabla 2.2 Nodos de figura de VRML ……………………………………………………. 33 Tabla 2.3 Nodos de geometría y material de VRML …………………………………… 34 Tabla 2.4 Nodos de transformación de VRML …………………………………………... 35 Tabla 2.5 Nodos de cámara de VRML ………………………………………………….. 36 Tabla 2.6 Nodos de iluminación de VRML …………………………………………….. 36 Tabla 2.7 Nodos de grupo de VRML ……………………………………………………. 36 Tabla 2.8 Primitivas de línea de OpenGL ……………………………………………….. 39 Tabla 2.9 Primitivas de polígonos de OpenGL ………………………………………… 40 Tabla 2.10 Primitivas de GrafO3D …………………………………………………………. 43 Tabla 3.1 Símbolos para la definición de reglas en una gramática ANTLR …….…… 60 Tabla 3.2 Funciones de C++ utilizadas para la creación del archivo de texto …….. 62 Tabla 3.3 Componentes de C++ Builder ……………………………………………….. 63 Tabla 3.4 Instrucciones OpenGL …………………………………………………………. 63 Tabla 3.5 Componentes de C++ Builder ……………………………………………….. 64 Tabla 3.6 Instrucciones OpenGL …………………………………………………………. 64 Tabla 3.7 Componentes de C++ Builder ……………………………………………….. 65 Tabla 3.8 Instrucciones OpenGL …………………………………………………………. 66 Tabla 3.9 Componentes de C++ Builder ……………………………………………….. 68 Tabla 3.10 Instrucciones OpenGL …………………………………………………………. 68 Tabla 3.11 Otras instrucciones OpenGL ……………………………………………….. 68

Entorno de graficación y generación de modelos 2D y 3D para aplicaciones de Visión Artificial Referencias

95

REFERENCIAS [Ac3d04] Inivis (Agosto 2003) AC3D. [On line] Available: http://www.ac3d.org. [Anim8or03] S. Glanville (Agosto 2003) Anim8or. [On line] Available: http://www.anim8or.com. [Antlr03] -- (Agosto, 2003) ANTLR. [On line] Available: http://www.antlr.org. [Avi04] -- (Marzo, 2004) AVI example code for creating AVI files. [On line] Available: http://www.wischik.com/lu/programmer/avi_utils.html. [Booch00] G. Booch [et al], El Lenguaje Unificado de Modelado, Addison Wesley, España, 2000. [Compiladores03] H. Hernández. Apuntes de compiladores, Centro Nacional de Investigación y Desarrollo Tecnológico (Cenidet), Cuernavaca, Morelos, Mayo 2003. [Delrieux03] C. Delrieux, Introducción a la Computación Gráfica, Departamento de Ingeniería Eléctrica, Universidad Nacional del Sur, Agosto, 2003. [García04] C. García (Noviembre, 03) Programación con Delphi y OpenGL. [On line] Available: http://glscene.tripod.com. [Huerta04] J. Huerta (Marzo, 2004) Introducción al CAD/CAM, Universidad Jaime, Departamento de Lenguajes y Sistemas Informáticos. [On line] Available: http://www3.uji.es/~huerta/dfao/apuntes/tema1.pdf. [Lamers96] J. Lamers, M. T. Peterson, 3D Studio Versión 4.0, Prentice Hall, México, 1996. [López03] J. G. López, “Detallador de tareas para procesos de Visión Robótica”, Tesis para obtener el grado de Maestro en Ciencias en Ciencias Computacionales, Departamento de Ciencias Computacionales, Área de Visión Artificial, Centro Nacional de Investigación y Desarrollo Tecnológico (Cenidet), Cuernavaca, Morelos, Julio del 2003. [Magadán99] A. Magadán, “Reconocimiento de rostros invariante a expresiones faciales”, Tesis para obtener el grado de Maestro en Ciencias en Ciencias Computacionales, Departamento de Ciencias Computacionales, Área de Visión Artificial, Centro Nacional de Investigación y Desarrollo Tecnológico (Cenidet), Cuernavaca, Morelos, Noviembre 1999.

Entorno de graficación y generación de modelos 2D y 3D para aplicaciones de Visión Artificial Referencias

96

[May04] I. May, Tesis en desarrollo: “Modelado de objetos deformables, utilizando color y textura”, Departamento de Ciencias Computacionales, Área de Visión Artificial, Centro Nacional de Investigación y Desarrollo Tecnológico (Cenidet), Cuernavaca, Morelos. [Mcmahon98] C. McMahon, J. Browne, CAD CAM. Principles, practice and manufacturing management, 2nd edition, Addisson Wesley, United States of America, 1998. [Nalwa93] V. Nalwa, A Guided Tour to Computer Vision, Addison Wesley, 1993. [Orbe03] E. Orbe, “Herramienta para el Modelado Automático de Objetos Alfaflexibles”, Tesis para obtener el grado de Maestro en Ciencias en Ciencias Computacionales, Departamento de Ciencias Computacionales, Área de Visión Artificial, Centro Nacional de Investigación y Desarrollo Tecnológico (Cenidet), Cuernavaca, Morelos, Julio del 2003. [Pesce96] M. Pesce, VRML para internet, Prentice Hall, México, 1996. [Rueda03] C. Rueda Murillo, Tesis en desarrollo: “Simulador de un brazo articulado con interface gráfica”, Departamento de Ciencias Computacionales, Área de Visión Artificial, Centro Nacional de Investigación y Desarrollo Tecnológico (Cenidet), Cuernavaca, Morelos. [Segal04] M. Segal, K. Akeley, The OpengGL Graphics System: A Specification (Version 1.5). Silicon Graphics, Inc. Copyright 1992-2003. [Suárez03] P. K. Suárez, “Animación y visualización de fenómenos naturales”, Tesis para obtener el grado de Licenciatura en Ingeniería en Ciencias Computacionales, Universidad de las Américas, Cholula, Puebla, Enero del 2003. [On line] Available: http://www.pue.udlap.mx/~tesis/lis/suarez_r_pk/. [Vrml03] -- (Enero, 2004) VRML 97, ISO/IEC 14772, The Virtual Reality Modeling Language. [On line] Available: http://www.web3d.org/x3d/specifications/vrml/ISO_IEC _14772-All/part1/concepts.html#4.2.1. [Wright97] R. Wright Jr., M. Sweet. Programación en OpenGL. Anaya. España 1997. [Zamora04] S. Zamora (Marzo, 2004) La Lengua Española. [On line] Available: http://www.geocities.com/sergiozamorab/quesla.htm.

Entorno de graficación y generación de modelos 2D y 3D para aplicaciones de Visión Artificial Anexos

98

ANEXO A Funciones de bibliotecas de OpenGL

Ejemplos de funciones contenidas en la biblioteca OpenGL.DLL.

FUNCIÓN DESCRIPCIÓN

glClearColor Selecciona los valores de color y alfa para borrar los buffers de color.

glOrtho Describe un volumen de trabajo paralelo.

glViewport Define la porción de ventana en la que puede dibujar OpenGL.

glVertex Especifica las coordenadas 3D de un vértice.

glMatrixMode Especifica la matriz actual

Ejemplos de funciones contenidas en la biblioteca GLU.DLL.


gluLookAt

Define una transformación de visualización basada en la posición del observador, la posición del centro de la escena y un vector que apunta hacia arriba desde la perspectiva del observador.

gluPerspective Define una matriz de Proyección en perspectiva para la visualización.

gluCylinder Dibuja un cilindro cuádrico.

gluSphere Dibuja una esfera cuádrica.

gluQuadricTexture Activa o desactiva la generación de coordenadas de textura para el mapeado de texturas sobre cuádricas.

Ejemplos de funciones contenidas en la biblioteca GLUT.DLL.


glutInit Modifica las variables de estado del Glut para hacer una sesión con el sistema de ventanas.

glutInitWindowPosition Indica la posición en píxeles en la pantalla de la ventana.

glutCreateWindow Crea una ventana.

gluKeyBoardFunc Genera las llamadas al teclado.

glutCreateMenu Crea un menú.


99

ANEXO B Tipos de datos de OpenGL

Tipos de datos de OpenGL.

TIPO DE DATO REPRESENTACIÓN INTERNA

GLbyte Entero de 8 bits.

GLshort Entero de 16 bits.

GLint, GLsizei Entero de 32 bits.

GLfloat, GLclampf Coma flotante de 32 bits.

GLdouble, GLclampd Coma flotante de 64 bits.

GLubyte, GLboolean Entero de 8 bits sin signo.

GLushort Entero de 16 bits sin signo.

GLuint, GLenum, GLbitfield

Entero de 32 bits sin signo.


100

ANEXO C Casos de uso de GrafO3D Documentación de casos de uso Caso de uso: crear nueva escena Actores: usuario Descripción: este caso de uso lo inicia el usuario con la finalidad de crear una nueva escena, eliminando de la pantalla lo que se haya creado anteriormente.

ACTOR SISTEMA Paso Acción Paso Acción Exc.

1 El usuario selecciona la opción para crear una nueva escena.

2 El sistema limpia la pantalla para iniciar una nueva escena.

E1

Excepciones: id Nombre Acción E1 Existe una escena en uso con cambios

sin guardar. El sistema muestra una pantalla al usuario para guardar los cambios.

Caso de uso: abrir escena desde archivo Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea abrir un archivo de texto existente con la descripción de una escena (archivo GrafO3D).


1 El usuario selecciona la opción para abrir un archivo de texto.

2 El sistema presenta una pantalla en la cual el usuario proporciona el nombre de un archivo existente.

3

El usuario introduce el nombre del archivo.

4 El sistema valida que el archivo de texto exista.

E1

5 El sistema presenta los modelos gráficos descritos en el archivo de texto.

E2

Excepciones: id Nombre Acción E1 Nombre de archivo inexistente. Volver a ingresar información. E2 Archivo con errores. Envía mensaje de error. Abrir otro archivo

Crear nueva escena

usuario

Abrir escena desde archivo

usuario


101

Caso de uso: importar archivo Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea abrir un archivo de texto existente que contenga la descripción de un modelo en término de puntos (x,y).


1 El usuario selecciona la opción para importar un archivo de texto.

2 El sistema presenta una pantalla en la cual el usuario proporciona el nombre de un archivo existente.

3


4 El sistema valida que el archivo de texto exista.

E1

5 El sistema presenta el modelo gráfico descrito en el archivo de texto.

6 El sistema presenta al usuario una pantalla para que proporcione el nombre del archivo de animación y el tiempo de espera entre cada frame.

E2

7 El sistema genera los archivos BMP correspondientes a los frames que forman la secuencia de video, y el archivo de video tipo AVI que contiene la animación resultante.

Excepciones: id Nombre Acción E1 Nombre de archivo inexistente. Volver a ingresar información. E2 Información inválida. Volver a ingresar información. Caso de uso: crear nuevo objeto Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea crear un nuevo objeto en la escena.


1 El usuario selecciona la opción para crear un nuevo objeto.

2 El sistema agrega el nombre del objeto al árbol de objetos y primitivas.

Crear nuevo objeto

usuario

Importar archivo

usuario


102

Caso de uso: modificar propiedades de un objeto o primitiva Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea modificar las características de un objeto o primitiva, como lo son: nombre, color, rotación, traslación, escala, textura. Si las modificaciones son hechas a un objeto, todas las primitivas que contenga este objeto son también modificadas.

Caso de uso: cambiar nombre Actores: usuario

Descripción: este caso de uso lo inicia el usuario cuando desea cambiar el nombre de un objeto o primitiva.


1 El usuario selecciona la opción para ver las propiedades del objeto o primitiva.

2 El sistema valida que un objeto o primitiva esté seleccionado.

E1

3 El sistema presenta la pantalla de propiedades del objeto o primitiva.

4

El usuario introduce el nuevo nombre del objeto o primitiva.

5 El usuario acepta las modificaciones. 6 El sistema valida que el nuevo nombre del objeto o primitiva no exista.

E2

7 El sistema presenta al objeto o primitiva con el nuevo nombre, en el árbol de objetos.

Modificar propiedades de un objeto o primitiva

usuario

Cambiar nombre

usuario


103

Excepciones: id Nombre Acción E1 Objeto o primitiva no seleccionada. El sistema envía un mensaje de error: no hay

objeto o primitiva seleccionada. E2 Nombre de objeto o primitiva existente. Volver a ingresar información Caso de uso: cambiar color Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea cambiar el color de un objeto o primitiva existente.


1 El usuario selecciona el objeto o primitiva deseada.



4 El usuario modifica el color del objeto o primitiva.

5 El usuario acepta las modificaciones. 6 El sistema aplica el cambio de color al objeto (y a las primitivas que lo compongan) o a la primitiva seleccionada.

Caso de uso: aplicar rotación Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea rotar algún objeto o primitiva existente en cualquiera de los ejes x, y o z.





4 El usuario maneja los controles para modificar el número de grados a rotar en cualquiera de los tres ejes.

5 El usuario acepta las modificaciones. 6 El sistema aplica la rotación al objeto (y a las primitivas que lo compongan) o a la primitiva seleccionada.

Cambiar color

usuario

Aplicar rotación

usuario


104

Caso de uso: aplicar traslación Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea trasladar o mover algún objeto o primitiva existente en cualquiera de los ejes x, y o z.





4 El usuario maneja los controles para modificar los puntos en los que será trasladado el objeto o primitiva en cualquiera de los tres ejes.

5 El usuario acepta las modificaciones. 6 El sistema presenta el objeto (y las primitivas que lo compongan) o la primitiva con las nuevas modificaciones.

Caso de uso: cambiar escala Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea cambiar la escala o tamaño de un objeto o primitiva existente.





4 El usuario maneja los controles para modificar el tamaño del objeto o primitiva en cualquiera de los tres ejes.

5 El usuario acepta las modificaciones. 6 El sistema presenta el objeto (y las primitivas que lo compongan) o la primitiva con la nueva escala.

Aplicar traslación

usuario

Cambiar escala

usuario


105

Caso de uso: aplicar textura Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea aplicar una textura a un objeto o a una primitiva.





4 El usuario selecciona el botón para abrir un archivo de textura.

5 El sistema envía una pantalla para que el usuario elija el archivo que contiene la textura.

6 El usuario elige un archivo de textura. 7 El sistema valida que el archivo exista.

E1

8 El usuario acepta las modificaciones. 9 El sistema presenta el objeto (y las primitivas que lo compongan) o la primitiva con la nueva textura.

Excepciones: id Nombre Acción E1

Nombre de archivo inexistente. Volver a ingresar información

Caso de uso: agregar primitiva Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea agregar una primitiva a un objeto existente.


1 El usuario selecciona el objeto para agregar una primitiva.

2 El usuario selecciona la opción de agregar primitiva.

3 El sistema habilita la barra de herramientas de primitivas.

E1

4 El usuario selecciona la primitiva deseada.

5 El sistema agrega la primitiva al objeto seleccionado y al árbol de objetos.

6 El sistema dibuja la primitiva en la escena.

Aplicar textura

usuario

Agregar primitiva

usuario


106

Excepciones: id Nombre Acción E1 Objeto no seleccionado El usuario debe seleccionar un objeto. Caso de uso: guardar escena Actores: usuario Descripción: este caso de uso lo inicia el usuario con la finalidad de almacenar en un archivo de texto la información actual de la escena.


1 El usuario selecciona la opción para guardar la escena.

2 El sistema presenta una pantalla para que el usuario proporcione el nombre del archivo.

3


4 El sistema valida que no exista otro archivo de texto con el mismo nombre que introdujo el usuario.

E1

5 El sistema guarda la información de la escena actual en el archivo de texto.

Excepciones: id Nombre Acción E1 Nombre de archivo existente. Preguntar si se quiere reemplazar el archivo, de

lo contrario, volver a ingresar información. Caso de uso: manejo de iluminación Actores: usuario Descripción: este caso de uso lo inicia el usuario con la finalidad de modificar las propiedades de la luz, como lo son: nombre, posición y color.


1 El usuario selecciona el botón para ver la pantalla de propiedades de la luz.

2 El sistema presenta la pantalla en donde se muestran las propiedades de la luz.

3

El usuario modifica las propiedades de color, posición o color.

4 El usuario acepta los cambios.

5 El sistema valida que la información esté correcta.

E1

6 El sistema muestra la escena con las nuevas modificaciones

Guardar escena

usuario

Manejo de iluminación

usuario


107

Caso de uso: cambio de perspectiva Actores: usuario Descripción: este caso de uso lo inicia el usuario con la finalidad de mover la cámara en las direcciones de adelante, atrás, izquierda y derecha.


1 El usuario selecciona el botón dependiendo de la dirección en la que quiera mover la cámara.

2 El sistema mueve la cámara en la dirección indicada por el usuario.

Caso de uso: cambiar vista de modelos Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea cambiar el estilo o vista de los modelos en la escena, como lo son: modelos de alambre, sólidos o vértices.


1 El usuario selecciona desde el menú de opciones, el tipo de vista que desee.

2 El sistema presenta los modelos con el tipo de vista especificado por el usuario.

Caso de uso: eliminar objeto o primitiva Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea eliminar un objeto o primitiva existente.


1 El usuario selecciona el objeto o primitiva a eliminar.

2 El usuario selecciona la opción de eliminar.

3 El sistema elimina el objeto (con todas sus primitivas) o la primitiva seleccionada del árbol de objetos y de la escena.

E1

Cambio de perspectiva

usuario

Cambiar vista de modelos

usuario

Eliminar objeto o primitiva

usuario


108

Excepciones: id Nombre Acción E1 Eliminación de la única primitiva del objeto. El sistema elimina el objeto. Caso de uso: generar animación Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea generar animación con la escena actual. Se puede generar animación de tres formas diferentes: mediante la captura de frames, por la selección del tipo de movimiento (traslación, rotación, escala), o mediante la especificación de puntos (x,y,z) sobre los que se trasladará el objeto.

Caso de uso: captura de frames Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando genera animación de un objeto o primitiva, mediante la captura de frames en el momento en que se desee que esa imagen forme parte del archivo de animación final.


1 El usuario selecciona del menú de animación, la opción de crear nueva animación.

2 El sistema prepara las opciones necesarias para iniciar la captura de frames.

3 El usuario captura el número de frames que desee.

4 El sistema crea las imágenes BMP correspondientes.

5 El usuario finaliza la captura de frames.

6 El usuario selecciona la opción de ver las propiedades de animación.

7 El sistema presenta la pantalla de propiedades de la animación.

8 El usuario proporciona la información necesaria en la pantalla de propiedades.

9 El usuario selecciona la opción para generar el archivo de animación.

10 El sistema crea el archivo de video tipo AVI con los frames capturados.

E1

Generar animación

usuario

Captura de frames

usuario


109

Excepciones: id Nombre Acción E1 Alguna información proporcionada es inválida. No se crea el archivo de video

correctamente. Caso de uso: selección del tipo de movimiento Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando genera animación a través de la selección del tipo de movimiento que tendrá el objeto o primitiva: traslación, rotación o escala. El sistema solicita al usuario información sobre el nombre del archivo de animación, tiempo de espera entre cada frame, número de repeticiones de la secuencia total, tipo de movimiento, eje sobre el cual se aplicará el movimiento, y el número de veces que se repetirá el movimiento.


1 El usuario selecciona del menú de animación, la opción de generar animación.




10 El sistema crea el archivo de video tipo AVI.

E1


correctamente. Caso de uso: traslación Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando genera animación mediante la traslación de una primitiva. El sistema solicita al usuario información sobre el nombre del archivo de animación, tiempo de espera entre cada frame, número de repeticiones de la secuencia total y el conjunto de puntos (x,y,z) por los que la primitiva será trasladada.

Selección del tipo de

movimientousuario

Traslación

usuario


110

ACTOR SISTEMA

Paso Acción Paso Acción Exc. 1 El usuario selecciona del menú de

animación, la opción de generar animación.




10 El sistema crea el archivo de video tipo AVI.

E1


correctamente. Caso de uso: cerrar aplicación Actores: usuario Descripción: este caso de uso lo inicia el usuario cuando desea salir de la aplicación.


1 El usuario selecciona del menú la opción de salir.

2 El sistema verifica que no existan cambios en la escena sin guardar.

E1

3 El sistema cierra la aplicación. Excepciones: id Nombre Acción E1 La escena no ha sido guardada. El sistema muestra una pantalla al usuario

para guardar los cambios.

Cerrar aplicación

usuario


111

ANEXO D Ejemplo de un archivo GrafO3D Ejemplo de un archivo GrafO3D que describe dos objetos que corresponden a la Tierra y a la Luna. Los modelos correspondientes se muestran en la Figura D.1. #Grafo v10 PerspectiveCamera Camara1 {

position 0.00 0.50 6.00 orientation 0.00 1.00 0.00

} Lighting Luz1 {

LightPosition 4.00 4.00 4.00 0.00 LightAmbient 0.20 0.20 0.20 1.00 LightDiffuse 0.80 0.80 0.80 1.00 LightSpecular 1.00 1.00 1.00 1.00

} Separator Objeto1 {

Transform Transform1 {

translation 0.00 0.50 -4.00 rotation 15.00 1.00 0.00 scale 1.00 1.00 1.00

} Material Material1 {

ambientColor 0.80 0.80 0.20 1.00 diffuseColor 0.10 0.50 0.80 1.00 specularColor 1.00 1.00 1.00 1.00 emissiveColor 0.30 0.20 0.20 1.00 shininess 10.00 Texture C:\GrafO3D\texturas\Earth.bmp

}

Sphere Tierra {

radius 1.50 } Transform Transform1 {

translation 2.50 0.50 -3.00 rotation 15.00 1.00 0.00 scale 1.00 1.00 1.00

} Material Material1 {

ambientColor 0.80 0.80 0.20 1.00 diffuseColor 0.10 0.50 0.80 1.00 specularColor 1.00 1.00 1.00 1.00 emissiveColor 0.0 0.20 0.20 1.00 shininess 10.00 Texture C:\GrafO3D\textuas\Sup_Lunar.bmp

} Sphere Luna { radius 1.00 }

}

Figura D.1 Modelos descritos en el archivo GrafO3D.


112

ANEXO E Ejemplo de un archivo de texto que describe un objeto en términos de puntos

Ejemplo de un archivo de texto que describe un objeto en términos de los puntos que forman su contorno. El modelo corresponde al contorno de una boca humana como se muestra en la Figura E.1: 66 3 encabezado de variables 0.0 1.0 0.1 1.2 0.3 1.3 0.5 1.35 0.7 1.37 0.9 1.35 1.0 1.33 1.1 1.31 1.3 1.29 1.5 1.31 1.7 1.33 1.9 1.35 2.0 1.37 2.1 1.35 2.3 1.3 2.5 1.2 2.7 1.0 2.5 0.9 2.3 0.87 2.1 0.85 2.0 0.83 1.9 0.81 1.7 0.79 1.5 0.77 1.3 0.75 1.1 0.77 1.0 0.79 0.9 0.81 0.7 0.83 0.5 0.85 0.3 0.87 0.1 0.89 0.0 0.91 1.0 1.0 1.1 1.2 1.3 1.3 1.5 1.35 1.7 1.37 1.9 1.35 2.0 1.33 2.1 1.31 2.3 1.29 2.5 1.31 2.7 1.33 2.9 1.35 3.0 1.37 3.1 1.35 3.3 1.3 3.5 1.2 3.7 1.0 3.5 0.9 3.3 0.87 3.1 0.85 3.0 0.83 2.9 0.81 2.7 0.79 2.5 0.77 2.3 0.75 2.1 0.77 2.0 0.79 1.9 0.81 1.7 0.83 1.5 0.85 1.3 0.87 1.1 0.89 1.0 0.91 2.0 1.0 2.1 1.2 2.3 1.3 2.5 1.35 2.7 1.37 2.9 1.35 3.0 1.33 3.1 1.31 3.3 1.29 3.5 1.31 3.7 1.33 3.9 1.35 4.0 1.37 4.1 1.35 4.3 1.3 4.5 1.2 4.7 1.0 4.5 0.9 4.3 0.87 4.1 0.85 4.0 0.83 3.9 0.81 3.7 0.79 3.5 0.77 3.3 0.75 3.1 0.77 3.0 0.79 2.9 0.81 2.7 0.83 2.5 0.85 2.3 0.87 2.1 0.89 2.0 0.91

Figura E.1 Modelo descrito en términos de puntos en el archivo de texto.


113

ANEXO F Ejemplo de un archivo VRML Ejemplo de un archivo VRML cuyo objeto descrito corresponde al modelo de una culebra. El resultado se muestra en la Figura F.1. #VRML V2.0 utf8 Background {

skyColor 0.7 0.7 0.9 } #ground Shape {

appearance Appearance { material Material { diffuseColor 0.6 0.6 0 }

} geometry Box { size 20 0.01 20 }

} #snake shape Transform {

translation 0 0.3 0 children Shape {

appearance Appearance { material Material {

diffuseColor 1.0 0.8 0 }

} geometry Extrusion { creaseAngle 1.57 crossSection [ #circle

1 0, 0.9135 -0.4067, 0.6691 -0.7431, 0.309 -0.9511, -0.1045 -0.9945, -0.5 -0.866, -0.809 -0.5878, -0.9781 -0.2079, -0.9781 0.2079, -0.809 0.5878, -0.5 0.866, -0.1045 0.9945, 0.309 0.9511, 0.6691 0.7431, 0.9135 0.4067, 1 0

]

spine [ # sinusoid -4.0000 0.0 0.0000, -3.5556 0.0 0.6428, -3.1111 0.0 0.9848, -2.6667 0.0 0.8660, -2.2222 0.0 0.3420, -1.7778 0.0 -0.3420, -1.3333 0.0 -0.8660, -0.8889 0.0 -0.9848, -0.4444 0.0 -0.6428, 0.0000 0.0 0.0000, 0.4444 0.0 0.6428, 0.8889 0.0 0.9848, 1.3333 0.0 0.8660, 1.7778 0.0 0.3420, 2.2222 0.0 -0.3420, 2.6667 0.0 -0.8660, 3.1111 0.0 -0.9848, 3.5556 0.0 -0.6428, 4.0000 0.0 -0.0000,

] scale [

0.05 0.02, 0.2 0.1, 0.4 0.150, 0.3 0.3, 0.3 0.3, 0.3 0.3, 0.3 0.3, 0.3 0.3, 0.3 0.3, 0.3 0.3, 0.3 0.3, 0.3 0.3, 0.29 0.29, 0.29 0.29, 0.28 0.28, 0.25 0.25, 0.20 0.20, 0.1 0.1, 0.05 0.05

] }

} }

Figura F.1 Modelo resultante del archivo VRML.


114

ANEXO G Definición de la clase Lexer en la gramática de GrafO3D Definición de la clase del analizador léxico de la gramática de GrafO3D generada bajo las especificaciones de ANTLR. options { mangleLiteralPrefix = "TK_"; language="Cpp"; } class miLexer extends Lexer; options { k=2; exportVocab=Tiny; charVocabulary = '\3'..'\377'; defaultErrorHandler = false; } tokens { "Grafo"; "Separator"; "PerspectiveCamera"; "position"; "orientation"; "Material"; "ambientColor"; "diffuseColor"; "specularColor"; "emissiveColor"; "shininess"; "rotation"; "translation"; "scale"; "Transform"; "Points"; "Line"; "Triangle"; "Cone"; "Cylinder"; "Sphere"; "SolidBox"; "SolidCone"; "SolidDodecahedron"; "SolidIcosahedron"; "SolidOctahedron"; "SolidThetrahedron"; "SolidTorus"; "WireBox"; "WireCone"; "WireCube"; "WireCylinder"; "WireDodecahedron"; "WireIcosahedron"; "WireOctahedron"; "WireThetrahedron"; "WireTorus"; "WireSphere"; "Polygon"; "bottomRadius"; "height"; "width"; "depth"; "radius"; "interiorRadius"; "exteriorRadius"; "Lighting"; "LightPosition"; "LightAmbient"; "LightSpecular"; "LightDiffuse"; "Texture" ; } WS_ : (' ' | '\t' | '\n' {newline();} | '\r') { _ttype = antlr::Token::SKIP; } ; SL_COMMENT : "//" (~'\n')* '\n' { _ttype = antlr::Token::SKIP; newline(); } ; DIAGONAL:'/' ; DIAGINV:'\\' ; DIGITO:

( '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' ) ; FLOTANTE: (GUION)? ( (DIGITO)+ PUNTO (DIGITO)+ ) ; GATO:'#' ; ENE: 'ñ' | 'Ñ' ; PUNTOYCOMA:';' ; DOSPUNTOS:':' ; GUION:'-' ; COMA: ',' ; CORCHETEA:'[' ; CORCHETEC:']' ; PUNTO:'.' ; ABRIRPARENT:'(' ; CERRARPARENT:')' ; CURLYR options { paraphrase = "llave cerrada"; } : '}' ; CURLYL options { paraphrase = "llave abierta"; } : '{' ; ID options { testLiterals = true; paraphrase = "an identifier"; } : ('a'..'z'|'A'..'Z') ('a'..'z'|'A'..'Z'|':'|'\\'|'_'|'.'|'0'..'9')* ;


115

ANEXO H Definición de la clase Parser en la gramática de

GrafO3D Definición de la clase parser de la gramática de GrafO3D generada bajo las especificaciones de ANTLR. header "post_include_hpp" { #include <string> #include <iostream> #include <vector.h> # include "CObjects.h" #include "PerspectiveCamera.hpp" #include "Light.hpp" } header "post_include_cpp" { PerspectiveCamera* miParser::Getcamera() { return vcamara; } Light* miParser::Getlight() { return defluz; } } options { language = "Cpp"; } class miParser extends Parser; options { k=2; genHashLines = off; importVocab=Tiny; defaultErrorHandler = false; } { public: vector <CObjects> CObjectsList; PerspectiveCamera* Getcamera(); Light* Getlight(); private: Transform *vtransf; Material *vmat; Transform *aux_transf; Material *aux_mat; PerspectiveCamera *vcamara; CObjects *vobje; Light *defluz; int indexprimitivas; int band_mat; int band_transf; } grafoFile: {vtransf = NULL;} encabezado sentencias ; encabezado: GATO TK_Grafo ID ; sentencias: perspectiva luz (objeto)* ; objeto: { String auxiliar; } TK_Separator { vobje = new CObjects(); indexprimitivas = 0; band_mat = 0; band_transf = 0; } a: ID { auxiliar = a->getText().c_str();

vobje->Setname(auxiliar); } CURLYL (sentencia)* { CObjectsList.push_back(*vobje); } CURLYR ; sentencia: (transform)? (material)? primitiva ; perspectiva: { String auxiliar1,auxiliar2,auxiliar3,auxiliar4,auxiliar5,auxiliar6; } TK_PerspectiveCamera { vcamara = new PerspectiveCamera();} i: ID { auxiliar1 = i->getText().c_str(); vcamara->Setname(auxiliar1); } CURLYL TK_position a: FLOTANTE { auxiliar1 = a->getText().c_str(); } b: FLOTANTE { auxiliar2 = b->getText().c_str(); } c: FLOTANTE { auxiliar3 = c->getText().c_str(); } TK_orientation d: FLOTANTE { auxiliar4 = d->getText().c_str(); } e: FLOTANTE { auxiliar5 = e->getText().c_str(); } f: FLOTANTE { auxiliar6 = f->getText().c_str(); vcamara->PositionCamera (StrToFloat(auxiliar1),StrToFloat(auxiliar2),StrToFloat(auxiliar3),0.0,0.5,5.0,StrToFloat(auxiliar4),StrToFloat(auxiliar5),StrToFloat(auxiliar6)); } CURLYR ; luz: { String auxiliar1,auxiliar2,auxiliar3,auxiliar4,auxiliar5;} TK_Lighting { defluz = new Light();} a: ID { auxiliar1 = a->getText().c_str(); defluz->Setname(auxiliar1); } CURLYL TK_LightPosition b: FLOTANTE { auxiliar2 = b->getText().c_str(); } c: FLOTANTE { auxiliar3 = c->getText().c_str(); } d: FLOTANTE {


116

auxiliar4 = d->getText().c_str(); } e: FLOTANTE { auxiliar5 = e->getText().c_str(); defluz->Setposition(StrToFloat(auxiliar2),StrToFloat(auxiliar3),StrToFloat(auxiliar4),StrToFloat(auxiliar5)); } TK_LightAmbient f: FLOTANTE { auxiliar2 = f->getText().c_str(); } g: FLOTANTE { auxiliar3 = g->getText().c_str(); } h: FLOTANTE { auxiliar4 = h->getText().c_str(); } i: FLOTANTE { auxiliar5 = i->getText().c_str(); defluz->Setambient(StrToFloat(auxiliar2),StrToFloat(auxiliar3),StrToFloat(auxiliar4), StrToFloat(auxiliar5)); } TK_LightDiffuse j: FLOTANTE { auxiliar2 = j->getText().c_str(); } k: FLOTANTE { auxiliar3 = k->getText().c_str(); } l: FLOTANTE { auxiliar4 = l->getText().c_str(); } m: FLOTANTE { auxiliar5 = m->getText().c_str(); defluz->Setdiffuse(StrToFloat(auxiliar2),StrToFloat(auxiliar3),StrToFloat(auxiliar4), StrToFloat(auxiliar5)); } TK_LightSpecular n: FLOTANTE { auxiliar2 = n->getText().c_str(); } o: FLOTANTE { auxiliar3 = o->getText().c_str(); } p: FLOTANTE { auxiliar4 = p->getText().c_str(); } q: FLOTANTE { auxiliar5 = q->getText().c_str(); defluz->Setspecular(StrToFloat(auxiliar2),StrToFloat(auxiliar3),StrToFloat(auxiliar4), StrToFloat(auxiliar5)); } CURLYR ; material: { String auxiliar1,auxiliar2,auxiliar3,auxiliar4; } TK_Material { aux_mat = new Material(); band_mat = 1;} o: ID { auxiliar1 = o->getText().c_str(); aux_mat->Setname(auxiliar1); } CURLYL TK_ambientColor a: FLOTANTE { auxiliar1 = a->getText().c_str(); } b: FLOTANTE { auxiliar2 = b->getText().c_str(); } c: FLOTANTE {

auxiliar3 = c->getText().c_str(); } p: FLOTANTE { auxiliar4 = p->getText().c_str(); aux_mat->SetambientColor(StrToFloat(auxiliar1),StrToFloat(auxiliar2), StrToFloat(auxiliar3),StrToFloat(auxiliar4)); } TK_diffuseColor d: FLOTANTE { auxiliar1 = d->getText().c_str(); } e: FLOTANTE { auxiliar2 = e->getText().c_str(); } f: FLOTANTE { auxiliar3 = f->getText().c_str(); } q: FLOTANTE { auxiliar4 = q->getText().c_str(); aux_mat->SetdiffuseColor(StrToFloat(auxiliar1),StrToFloat(auxiliar2), StrToFloat(auxiliar3),StrToFloat(auxiliar4)); } TK_specularColor g: FLOTANTE { auxiliar1 = g->getText().c_str(); } h: FLOTANTE { auxiliar2 = h->getText().c_str(); } i: FLOTANTE { auxiliar3 = i->getText().c_str(); } r: FLOTANTE { auxiliar4 = r->getText().c_str(); aux_mat->SetespecularColor(StrToFloat(auxiliar1),StrToFloat(auxiliar2),StrToFloat(auxiliar3),StrToFloat(auxiliar4)); } TK_emissiveColor j: FLOTANTE { auxiliar1 = j->getText().c_str(); } k: FLOTANTE { auxiliar2 = k->getText().c_str(); } l: FLOTANTE { auxiliar3 = l->getText().c_str(); } s: FLOTANTE { auxiliar4 = s->getText().c_str(); aux_mat->SetemissiveColor(StrToFloat(auxiliar1),StrToFloat(auxiliar2), StrToFloat(auxiliar3),StrToFloat(auxiliar4)); } TK_shininess m: FLOTANTE { auxiliar1 = m->getText().c_str(); aux_mat->Setshininess(StrToFloat(auxiliar1)); } (TK_Texture u: ID { auxiliar1 = u->getText().c_str(); aux_mat->SetpathTexture(auxiliar1); })? CURLYR ; transform: { String auxiliar; } TK_Transform { aux_transf = new Transform(); band_transf = 1; } a: ID { auxiliar = a->getText().c_str(); aux_transf->Setname(auxiliar); }


117

CURLYL (translate)? (rotate)? (scalefactor)? CURLYR ; rotate: { String auxiliar1, auxiliar2,auxiliar3; } TK_rotation b: FLOTANTE { auxiliar1 = b->getText().c_str(); } c: FLOTANTE { auxiliar2 = c->getText().c_str(); } d: FLOTANTE { auxiliar3 = d->getText().c_str(); aux_transf->Setrotation(StrToFloat(auxiliar1),StrToFloat(auxiliar2), StrToFloat(auxiliar3)); } ; translate: { String auxiliar1,auxiliar2,auxiliar3; } TK_translation f: FLOTANTE { auxiliar1 = f->getText().c_str(); } g: FLOTANTE { auxiliar2 = g->getText().c_str(); } h: FLOTANTE { auxiliar3 = h->getText().c_str(); aux_transf->Settranslation(StrToFloat(auxiliar1),StrToFloat(auxiliar2),StrToFloat(auxiliar3)); } ; scalefactor:TK_scale { String auxiliar1,auxiliar2,auxiliar3; } i: FLOTANTE { auxiliar1 = i->getText().c_str(); } j: FLOTANTE { auxiliar2 = j->getText().c_str(); } k: FLOTANTE { auxiliar3 = k->getText().c_str(); aux_transf->SetscaleFactor(StrToFloat(auxiliar1),StrToFloat(auxiliar2),StrToFloat(auxiliar3)); } ; primitiva: ( point| line | triangle | cone | cylinder | sphere | solidbox | soliddodecahedron | solidicosahedron | solidoctahedron| solidthetrahedron | solidtorus| wirebox| wirecone| wirecylinder| wiredodecahedron | wireicosahedron| wireoctahedron| wirethetrahedron| wiretorus| wiresphere ) ; point : { GLfloat auxx=0,auxy=0,auxz=0,auxi; String auxiliar,auxiliar1,auxiliar2,auxiliar3; } TK_Points { vobje->CreatePoints(); } g: ID { auxiliar = g->getText().c_str(); vobje->nuevopunto->Points::Setname(auxiliar); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevopunto->Material::Setname(aux_mat->Getname()); vobje->nuevopunto->SetambientColor(aux_mat->GetambientColor(0), aux_mat->GetambientColor(1),aux_mat->GetambientColor(2), aux_mat->GetambientColor(3)); vobje->nuevopunto->SetdiffuseColor(aux_mat->GetdiffuseColor(0),

aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2), aux_mat->GetdiffuseColor(3)); vobje->nuevopunto->SetespecularColor(aux_mat->GetespecularColor(0), aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2), aux_mat->GetespecularColor(3)); vobje->nuevopunto->SetemissiveColor(aux_mat->GetemissiveColor(0), aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2), aux_mat->GetemissiveColor(3)); vobje->nuevopunto->Setshininess(aux_mat->Getshininess()); vobje->nuevopunto->Settransparency(aux_mat->Gettransparency()); vobje->nuevopunto->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevopunto->Transform::Setname(aux_transf->Getname()); vobje->nuevopunto->Setrotation(aux_transf->Getrotation(0), aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevopunto->Settranslation(aux_transf->Gettranslation(0), aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevopunto->SetscaleFactor(aux_transf->GetscaleFactor(0), aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } CURLYL (sentencia)* ( a: FLOTANTE { auxiliar1 = a->getText().c_str(); } b: FLOTANTE { auxiliar2 = b->getText().c_str(); } c: FLOTANTE { auxiliar3 = c->getText().c_str(); auxx = StrToFloat(auxiliar1); auxy = StrToFloat(auxiliar2); auxz = StrToFloat(auxiliar3); vobje->nuevopunto->Setpoints(auxx,auxy,auxz); } )+ CURLYR { vobje->SavePointsList(); } ; line options { defaultErrorHandler = true; } : { int auxi; String auxiliar; String auxiliar1; String auxiliar2; String auxiliar3; } TK_Line { vobje->CreateLine(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevalinea->Material::Setname(aux_mat->Getname()); vobje->nuevalinea->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevalinea->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevalinea->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevalinea->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevalinea->Setshininess(aux_mat->Getshininess()); vobje->nuevalinea->Settransparency(aux_mat->Gettransparency()); vobje->nuevalinea->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevalinea->Transform::Setname(aux_transf->Getname()); vobje->nuevalinea->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevalinea->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevalinea->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); }


118

g: ID { auxiliar = g->getText().c_str(); vobje->nuevalinea->Line::Setname(auxiliar); } CURLYL (sentencia)* a:FLOTANTE { auxiliar1 = a->getText().c_str(); } b:FLOTANTE { auxiliar2 = b->getText().c_str(); } c:FLOTANTE { auxiliar3 = c->getText().c_str(); vobje->nuevalinea->Setpoint1(StrToFloat(auxiliar1),StrToFloat(auxiliar2),StrToFloat(auxiliar3)); } d:FLOTANTE { auxiliar1 = d->getText().c_str(); } e:FLOTANTE { auxiliar2 = e->getText().c_str(); } f:FLOTANTE { auxiliar3 = f->getText().c_str(); vobje->nuevalinea->Setpoint2(StrToFloat(auxiliar1),StrToFloat(auxiliar2),StrToFloat(auxiliar3)); } CURLYR { vobje->SaveLineList(); } ; triangle: { int auxi; String auxiliar,auxiliar1,auxiliar2,auxiliar3,auxiliar4,auxiliar5,auxiliar6,auxiliar7,auxiliar8,auxiliar9; } TK_Triangle { vobje->CreateTriangle(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevotriangulo->Material::Setname(aux_mat->Getname()); vobje->nuevotriangulo->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevotriangulo->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevotriangulo->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevotriangulo->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevotriangulo->Setshininess(aux_mat->Getshininess()); vobje->nuevotriangulo->Settransparency(aux_mat->Gettransparency()); vobje->nuevotriangulo->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevotriangulo->Transform::Setname(aux_transf->Getname()); vobje->nuevotriangulo->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevotriangulo->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevotriangulo->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } j: ID { auxiliar = j->getText().c_str(); vobje->nuevotriangulo->Triangle::Setname(auxiliar); } CURLYL (sentencia)* a: FLOTANTE { auxiliar1 = a->getText().c_str(); } b: FLOTANTE { auxiliar2 = b->getText().c_str(); } c: FLOTANTE

{ auxiliar3 = c->getText().c_str(); } d: FLOTANTE { auxiliar4 = d->getText().c_str(); } e: FLOTANTE { auxiliar5 = e->getText().c_str(); } f: FLOTANTE { auxiliar6 = f->getText().c_str(); vobje->nuevotriangulo->Setlinea1(StrToFloat(auxiliar1),StrToFloat(auxiliar2),StrToFloat(auxiliar3),StrToFloat(auxiliar4),StrToFloat(auxiliar5),StrToFloat(auxiliar6)); } g: FLOTANTE { auxiliar7 = g->getText().c_str(); } h: FLOTANTE { auxiliar8 = h->getText().c_str(); } i: FLOTANTE { auxiliar9 = i->getText().c_str(); vobje->nuevotriangulo->Setlinea2(StrToFloat(auxiliar4),StrToFloat(auxiliar5),StrToFloat(auxiliar6),StrToFloat(auxiliar7),StrToFloat(auxiliar8),StrToFloat(auxiliar9)); vobje->nuevotriangulo->Setlinea3(StrToFloat(auxiliar1),StrToFloat(auxiliar2),StrToFloat(auxiliar3),StrToFloat(auxiliar7),StrToFloat(auxiliar8),StrToFloat(auxiliar9)); } CURLYR { vobje->SaveTriangleList(); } ; cone: { String auxiliar; int auxi;} TK_Cone { vobje->CreateCone(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevocil->Material::Setname(aux_mat->Getname()); vobje->nuevocil->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevocil->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevocil->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevocil->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevocil->Setshininess(aux_mat->Getshininess()); vobje->nuevocil->Settransparency(aux_mat->Gettransparency()); vobje->nuevocil->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevocil->Transform::Setname(aux_transf->Getname()); vobje->nuevocil->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevocil->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevocil->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevocil->ABaseCyl::Setname(auxiliar); } CURLYL (sentencia)* TK_bottomRadius a:FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevocil->Setradius(StrToFloat(auxiliar));


119

} TK_height b:FLOTANTE { auxiliar = b->getText().c_str(); vobje->nuevocil->Setheight(StrToFloat(auxiliar)); } CURLYR { vobje->SaveConeList(); } ; cylinder: { int auxi; String auxiliar; } TK_Cylinder { vobje->CreateCylinder(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevocil->Material::Setname(aux_mat->Getname()); vobje->nuevocil->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevocil->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevocil->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevocil->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevocil->Setshininess(aux_mat->Getshininess()); vobje->nuevocil->Settransparency(aux_mat->Gettransparency()); vobje->nuevocil->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevocil->Transform::Setname(aux_transf->Getname()); vobje->nuevocil->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevocil->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevocil->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevocil->ABaseCyl::Setname(auxiliar); } CURLYL (sentencia)* TK_radius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevocil->Setradius(StrToFloat(auxiliar)); } TK_height b :FLOTANTE { auxiliar = b->getText().c_str(); vobje->nuevocil->Setheight(StrToFloat(auxiliar)); } CURLYR { vobje->SaveCylinderList(); } ; sphere: { int auxi; String auxiliar; } TK_Sphere { vobje->CreateSphere(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevopoli->Material::Setname(aux_mat->Getname()); vobje->nuevopoli->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevopoli->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevopoli->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevopoli->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevopoli->Setshininess(aux_mat->Getshininess()); vobje->nuevopoli->Settransparency(aux_mat->Gettransparency());

vobje->nuevopoli->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevopoli->Transform::Setname(aux_transf->Getname()); vobje->nuevopoli->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevopoli->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevopoli->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevopoli->APolyhedron::Setname(auxiliar); } CURLYL (sentencia)* TK_radius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevopoli->Setradius(StrToFloat(auxiliar)); } CURLYR { vobje->SaveSphereList(); } ; solidbox: { int auxi; String auxiliar; } TK_SolidBox { vobje->CreateSBox(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevocuad->Material::Setname(aux_mat->Getname()); vobje->nuevocuad->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevocuad->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevocuad->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevocuad->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevocuad->Setshininess(aux_mat->Getshininess()); vobje->nuevocuad->Settransparency(aux_mat->Gettransparency()); vobje->nuevocuad->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevocuad->Material::Setname(aux_transf->Getname()); vobje->nuevocuad->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevocuad->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevocuad->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } d: ID { auxiliar = d->getText().c_str(); vobje->nuevocuad->AQuad::Setname(auxiliar); } CURLYL (sentencia)* TK_width a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevocuad->Setwidth(StrToFloat(auxiliar)); } TK_height b: FLOTANTE { auxiliar = b->getText().c_str(); vobje->nuevocuad->Setheight(StrToFloat(auxiliar)); } TK_depth c: FLOTANTE {


120

auxiliar = c->getText().c_str(); vobje->nuevocuad->Setdepth(StrToFloat(auxiliar)); } CURLYR { vobje->SaveSBoxList(); } ; soliddodecahedron: { int auxi; String auxiliar; } TK_SolidDodecahedron { vobje->CreateSDod(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevopoli->Material::Setname(aux_mat->Getname()); vobje->nuevopoli->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevopoli->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevopoli->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevopoli->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevopoli->Setshininess(aux_mat->Getshininess()); vobje->nuevopoli->Settransparency(aux_mat->Gettransparency()); vobje->nuevopoli->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevopoli->Transform::Setname(aux_transf->Getname()); vobje->nuevopoli->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevopoli->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevopoli->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevopoli->APolyhedron::Setname(auxiliar); } CURLYL (sentencia)* TK_radius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevopoli->Setradius(StrToFloat(auxiliar)); } CURLYR { vobje->SaveSDodList(); } ; solidicosahedron: { int auxi; String auxiliar; } TK_SolidIcosahedron { vobje->CreateSIco(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevopoli->Material::Setname(aux_mat->Getname()); vobje->nuevopoli->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevopoli->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevopoli->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevopoli->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevopoli->Setshininess(aux_mat->Getshininess()); vobje->nuevopoli->Settransparency(aux_mat->Gettransparency()); vobje->nuevopoli->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevopoli->Transform::Setname(aux_transf->Getname()); vobje->nuevopoli->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevopoli->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2));

vobje->nuevopoli->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevopoli->APolyhedron::Setname(auxiliar); } CURLYL (sentencia)* TK_radius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevopoli->Setradius(StrToFloat(auxiliar)); } CURLYR { vobje->SaveSIcoList(); } ; solidoctahedron: { int auxi; String auxiliar; } TK_SolidOctahedron { vobje->CreateSOct(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevopoli->Material::Setname(aux_mat->Getname()); vobje->nuevopoli->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevopoli->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevopoli->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevopoli->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevopoli->Setshininess(aux_mat->Getshininess()); vobje->nuevopoli->Settransparency(aux_mat->Gettransparency()); vobje->nuevopoli->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevopoli->Transform::Setname(aux_transf->Getname()); vobje->nuevopoli->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevopoli->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevopoli->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevopoli->APolyhedron::Setname(auxiliar); } CURLYL (sentencia)* TK_radius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevopoli->Setradius(StrToFloat(auxiliar)); } CURLYR { vobje->SaveSOctList(); } ; solidthetrahedron: { int auxi; String auxiliar; } TK_SolidThetrahedron { vobje->CreateSThe(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevopoli->Material::Setname(aux_mat->Getname()); vobje->nuevopoli->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevopoli->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3));


121

vobje->nuevopoli->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevopoli->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevopoli->Setshininess(aux_mat->Getshininess()); vobje->nuevopoli->Settransparency(aux_mat->Gettransparency()); vobje->nuevopoli->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevopoli->Transform::Setname(aux_transf->Getname()); vobje->nuevopoli->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevopoli->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevopoli->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevopoli->APolyhedron::Setname(auxiliar); } CURLYL (sentencia)* TK_radius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevopoli->Setradius(StrToFloat(auxiliar)); } CURLYR { vobje->SaveSTheList(); } ; solidtorus: { int auxi; String auxiliar; } TK_SolidTorus { vobje->CreateSTorus(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevotorus->Material::Setname(aux_mat->Getname()); vobje->nuevotorus->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevotorus->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevotorus->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevotorus->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevotorus->Setshininess(aux_mat->Getshininess()); vobje->nuevotorus->Settransparency(aux_mat->Gettransparency()); vobje->nuevotorus->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevotorus->Transform::Setname(aux_transf->Getname()); vobje->nuevotorus->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevotorus->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevotorus->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevotorus->ATorus::Setname(auxiliar); } CURLYL (sentencia)* TK_interiorRadius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevotorus->SetinteriorRadius(StrToFloat(auxiliar)); } TK_exteriorRadius b: FLOTANTE { auxiliar = b->getText().c_str(); vobje->nuevotorus->SetexteriorRadius(StrToFloat(auxiliar)); }

CURLYR { vobje->SaveSTorusList(); } ; wirebox: { String auxiliar; } TK_WireBox { vobje->CreateWBox(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevocuad->Material::Setname(aux_mat->Getname()); vobje->nuevocuad->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevocuad->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevocuad->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevocuad->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevocuad->Setshininess(aux_mat->Getshininess()); vobje->nuevocuad->Settransparency(aux_mat->Gettransparency()); vobje->nuevocuad->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevocuad->Transform::Setname(aux_transf->Getname()); vobje->nuevocuad->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevocuad->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevocuad->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } d: ID { auxiliar = d->getText().c_str(); vobje->nuevocuad->AQuad::Setname(auxiliar); } CURLYL (sentencia)* TK_width a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevocuad->Setwidth(StrToFloat(auxiliar)); } TK_height b: FLOTANTE { auxiliar = b->getText().c_str(); vobje->nuevocuad->Setheight(StrToFloat(auxiliar)); } TK_depth c: FLOTANTE { auxiliar = c->getText().c_str(); vobje->nuevocuad->Setdepth(StrToFloat(auxiliar)); } CURLYR { vobje->SaveWBoxList(); } ; wirecone: { String auxiliar; } TK_WireCone { vobje->CreateWCone(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevocil->Material::Setname(aux_mat->Getname()); vobje->nuevocil->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevocil->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevocil->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevocil->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevocil->Setshininess(aux_mat->Getshininess());


122

vobje->nuevocil->Settransparency(aux_mat->Gettransparency()); vobje->nuevocil->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevocil->Transform::Setname(aux_transf->Getname()); vobje->nuevocil->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevocil->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevocil->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevocil->ABaseCyl::Setname(auxiliar); } CURLYL (sentencia)* TK_bottomRadius a:FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevocil->Setradius(StrToFloat(auxiliar)); } TK_height b:FLOTANTE { auxiliar = b->getText().c_str(); vobje->nuevocil->Setheight(StrToFloat(auxiliar)); } CURLYR { vobje->SaveWConeList(); } ; wirecylinder: { String auxiliar; } TK_WireCylinder { vobje->CreateWCylinder(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevocil->Material::Setname(aux_mat->Getname()); vobje->nuevocil->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevocil->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevocil->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevocil->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevocil->Setshininess(aux_mat->Getshininess()); vobje->nuevocil->Settransparency(aux_mat->Gettransparency()); vobje->nuevocil->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevocil->Transform::Setname(aux_transf->Getname()); vobje->nuevocil->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevocil->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevocil->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevocil->ABaseCyl::Setname(auxiliar); } CURLYL (sentencia)* TK_radius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevocil->Setradius(StrToFloat(auxiliar)); } TK_height b :FLOTANTE { auxiliar = b->getText().c_str(); vobje->nuevocil->Setheight(StrToFloat(auxiliar)); } CURLYR { vobje->SaveWCylinderList(); } ;

wiredodecahedron: { String auxiliar; } TK_WireDodecahedron { vobje->CreateWDod(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevopoli->Material::Setname(aux_mat->Getname()); vobje->nuevopoli->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevopoli->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevopoli->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevopoli->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevopoli->Setshininess(aux_mat->Getshininess()); vobje->nuevopoli->Settransparency(aux_mat->Gettransparency()); vobje->nuevopoli->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevopoli->Transform::Setname(aux_transf->Getname()); vobje->nuevopoli->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevopoli->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevopoli->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevopoli->APolyhedron::Setname(auxiliar); } CURLYL (sentencia)* TK_radius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevopoli->Setradius(StrToFloat(auxiliar)); } CURLYR { vobje->SaveWDodList(); } ; wireicosahedron: { String auxiliar; } TK_WireIcosahedron { vobje->CreateWIco(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevopoli->Material::Setname(aux_mat->Getname()); vobje->nuevopoli->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevopoli->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevopoli->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevopoli->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevopoli->Setshininess(aux_mat->Getshininess()); vobje->nuevopoli->Settransparency(aux_mat->Gettransparency()); vobje->nuevopoli->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevopoli->Transform::Setname(aux_transf->Getname()); vobje->nuevopoli->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevopoli->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2));


123

vobje->nuevopoli->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevopoli->APolyhedron::Setname(auxiliar); } CURLYL (sentencia)* TK_radius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevopoli->Setradius(StrToFloat(auxiliar)); } CURLYR { vobje->SaveWIcoList(); } ; wireoctahedron: { String auxiliar; } TK_WireOctahedron { vobje->CreateWOct(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevopoli->Material::Setname(aux_mat->Getname()); vobje->nuevopoli->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevopoli->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevopoli->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevopoli->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevopoli->Setshininess(aux_mat->Getshininess()); vobje->nuevopoli->Settransparency(aux_mat->Gettransparency()); vobje->nuevopoli->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevopoli->Transform::Setname(aux_transf->Getname()); vobje->nuevopoli->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevopoli->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevopoli->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevopoli->APolyhedron::Setname(auxiliar); } CURLYL (sentencia)* TK_radius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevopoli->Setradius(StrToFloat(auxiliar)); } CURLYR { vobje->SaveWOctList(); } ; wirethetrahedron: { String auxiliar; } TK_WireThetrahedron { vobje->CreateWThe(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevopoli->Material::Setname(aux_mat->Getname()); vobje->nuevopoli->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3));

vobje->nuevopoli->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevopoli->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevopoli->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevopoli->Setshininess(aux_mat->Getshininess()); vobje->nuevopoli->Settransparency(aux_mat->Gettransparency()); vobje->nuevopoli->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevopoli->Transform::Setname(aux_transf->Getname()); vobje->nuevopoli->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevopoli->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevopoli->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevopoli->APolyhedron::Setname(auxiliar); } CURLYL (sentencia)* TK_radius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevopoli->Setradius(StrToFloat(auxiliar)); } CURLYR { vobje->SaveWTheList(); } ; wiretorus: { String auxiliar; } TK_WireTorus { vobje->CreateWTorus(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevotorus->Material::Setname(aux_mat->Getname()); vobje->nuevotorus->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevotorus->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevotorus->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3)); vobje->nuevotorus->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevotorus->Setshininess(aux_mat->Getshininess()); vobje->nuevotorus->Settransparency(aux_mat->Gettransparency()); vobje->nuevotorus->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevotorus->Transform::Setname(aux_transf->Getname()); vobje->nuevotorus->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevotorus->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevotorus->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID {


124

auxiliar = c->getText().c_str(); vobje->nuevotorus->ATorus::Setname(auxiliar); } CURLYL (sentencia)* TK_interiorRadius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevotorus->SetinteriorRadius(StrToFloat(auxiliar)); } TK_exteriorRadius b: FLOTANTE { auxiliar = b->getText().c_str(); vobje->nuevotorus->SetexteriorRadius(StrToFloat(auxiliar)); } CURLYR { vobje->SaveWTorusList(); } ; wiresphere: { String auxiliar; } TK_WireSphere { vobje->CreateWSphere(); if ( band_mat != 1 ) { aux_mat = new Material(); } vobje->nuevopoli->Material::Setname(aux_mat->Getname()); vobje->nuevopoli->SetambientColor(aux_mat->GetambientColor(0),aux_mat->GetambientColor(1),aux_mat->GetambientColor(2),aux_mat->GetambientColor(3)); vobje->nuevopoli->SetdiffuseColor(aux_mat->GetdiffuseColor(0),aux_mat->GetdiffuseColor(1),aux_mat->GetdiffuseColor(2),aux_mat->GetdiffuseColor(3)); vobje->nuevopoli->SetespecularColor(aux_mat->GetespecularColor(0),aux_mat->GetespecularColor(1),aux_mat->GetespecularColor(2),aux_mat->GetespecularColor(3));

vobje->nuevopoli->SetemissiveColor(aux_mat->GetemissiveColor(0),aux_mat->GetemissiveColor(1),aux_mat->GetemissiveColor(2),aux_mat->GetemissiveColor(3)); vobje->nuevopoli->Setshininess(aux_mat->Getshininess()); vobje->nuevopoli->Settransparency(aux_mat->Gettransparency()); vobje->nuevopoli->SetpathTexture(aux_mat->GetpathTexture()); if ( band_transf != 1 ) { aux_transf = new Transform(); } vobje->nuevopoli->Transform::Setname(aux_transf->Getname()); vobje->nuevopoli->Setrotation(aux_transf->Getrotation(0),aux_transf->Getrotation(1),aux_transf->Getrotation(2)); vobje->nuevopoli->Settranslation(aux_transf->Gettranslation(0),aux_transf->Gettranslation(1),aux_transf->Gettranslation(2)); vobje->nuevopoli->SetscaleFactor(aux_transf->GetscaleFactor(0),aux_transf->GetscaleFactor(1),aux_transf->GetscaleFactor(2)); } c: ID { auxiliar = c->getText().c_str(); vobje->nuevopoli->APolyhedron::Setname(auxiliar); } CURLYL (sentencia)* TK_radius a: FLOTANTE { auxiliar = a->getText().c_str(); vobje->nuevopoli->Setradius(StrToFloat(auxiliar)); } CURLYR { vobje->SaveWSphereList(); } ;

Entorno de graficación y generación de modelos 2D y 3D para aplicaciones de Visión Artificial Glosario de términos

97

GLOSARIO DE TÉRMINOS Antializado: sistema de reducción de los efectos de distorsión en los bordes de las gráficas. Operación que se realiza para suavizar el efecto escalera de las líneas en diagonal. Bevel: función que crea un superficie más pequeña que la original, ligeramente más alejada y unidas mediante nuevas superficies alrededor de los bordes. Clipping: operación de eliminar la graficación de entidades que quedan fuera del viewport (puerto ventana o área de trabajo). Este concepto se aplica también al término clipeado. Spline (curvas): sistema de modelado basado en curvas no analíticas, compuestas por trozos unidos. Extrusión: función que crea nuevas superficies a los bordes de la selección actual. Flip: función que cambia la dirección de los vértices de las superficies seleccionadas. Frame: archivo de imagen que forma parte de una secuencia de imágenes contenidas en un archivo de animación. Frame buffer: nombre que recibe la zona de la memoria que se utiliza para almacenar las imágenes antes de ser enviadas a la pantalla. Lathing: procedimiento por el cual se toma una curva en dos dimensiones y se hace rotar alrededor de un eje con el fin de crear una superficie de revolución. Lexer o analizador lexicográfico: lee el programa fuente y obtiene una secuencia de muestras (tokens) que utilizará el analizador sintáctico. Modelado: consiste en la representación de las características estáticas, dinámicas o ambas de un concepto en un dominio, presentada en varias vistas (generalmente diagramas o textuales), dichas vistas son producto del diseño. Es encontrar una manera conveniente para describir y representar una imagen; es, en muchos casos, el paso fundamental y crucial en las tareas de visión. Parser: aplica la estructura gramatical asociada a una cadena de tokens. Rendering: fase de visualización de los gráficos. Este concepto se aplica también al término renderizado. Spike: función que crea una figura con picos por cada cuadro o triángulo seleccionado.

Entorno de graficación y generación de modelos 2D y 3D para aplicaciones de Visión Artificial Capítulo I. Introducción

1

CAPÍTULO I

INTRODUCCIÓN

CONTENIDO:

Introducción Organización de la tesis Antecedentes Descripción del problema Marco conceptual Propuesta de solución Aplicaciones Conclusiones

1 Cap 1


2

1.1 INTRODUCCIÓN Debido a los grandes logros que se han tenido en las ciencias computacionales, surge en los años 50’s el concepto de Inteligencia Artificial, que es una ciencia que intenta la creación de programas para máquinas que imiten el comportamiento y la comprensión humana. Esta ciencia está formada por varias ramas como lo son: Robótica, Sistemas Expertos, Lenguaje Natural, Algoritmos Genéticos y Visión Artificial (VA), por mencionar algunas. La mayor parte de la información que obtiene el hombre de su entorno, es por medio del sentido de la vista, y en el intento por emular de alguna manera estos procesos de visión biológicos por medio de la computadora, surge la Visión Artificial, que pretende resolver problemas relacionados con la percepción del mundo real a través de imágenes digitales, es decir, lo importante, dada una imagen, es su posible interpretación, para lo cual es necesario identificar o reconocer correctamente los objetos en ella [Nalwa93]. A pesar de que la Visión Artificial tiene ciertas limitaciones, el número de aplicaciones se ha venido incrementado en campos como la biología, la meteorología, la medicina, reconocimiento y clasificación de objetos y en la inspección y control de calidad, entre otras. Dentro de la VA, se pueden distinguir básicamente tres tipos de objetos de acuerdo a las características que presentan: los objetos rígidos, los objetos articulados y los objetos alfaflexibles o deformables [Magadán99], los cuales son percibidos como imágenes que son fácilmente interpretadas y comprendidas por el hombre, sin embargo, en todo proceso de VA debe existir una buena representación o modelado1 de los objetos. A continuación se da una breve descripción de cada uno de los tres tipos de objetos mencionados:

- Rígidos: son aquéllos en los cuales sin importar su posición o tamaño, sus características siempre presentan las mismas relaciones geométricas, por lo que los patrones están definidos, figura 1.2.

Figura 1.1 Ejemplos de objetos rígidos.

1 Ver glosario de términos en la página 97.


3

- Articulados: aquéllos que están constituidos de partes rígidas y de uno o varios puntos de articulación y/o de uno o varios ejes de desplazamiento, presentando variaciones en sus relaciones geométricas, figura 1.3.

Figura 1.2 Ejemplos de objetos articulados.

- Flexibles o deformables: este tipo de objetos cuenta con una característica

muy importante, que es la capacidad de transformación, y por ende, se pueden obtener una gran cantidad de instancias del mismo objeto que lo describirían de diversas maneras, siendo difícil obtener una descripción única, ya que puede contener secciones rígidas, articuladas o deformables, figura 1.4.

Figura 1.3 Ejemplos de objetos deformables.

Al hablar del modelado en este documento, se hace referencia a un modelo gráfico del objeto. La importancia de un modelo dentro de un proceso de VA se da cuando se está trabajando con una descripción de los objetos de tal forma que esa información es poco entendible por el humano, como puede ser con la información numérica que a simple vista su comprensión es casi nula, en cambio, con una imagen o modelo gráfico, los datos son interpretados de una manera más clara. Además, un modelo representado en un entorno virtual 3D, podría ser aplicado a problemas como: generación automática de casos de prueba para navegación con robots móviles, reconstrucción de escenas 3D a partir de imágenes 2D, reconstrucción y visualización de volumen partiendo de imágenes médicas (p.e. estudios endoscópicos no invasivos del corazón, arterias e intestinos), reconstrucción de escenas para estudios criminalísticos (aplicando leyes de la física al movimiento de los cuerpos para determinar trayectorias y posibles escenarios alternos de manera automática a partir de la información visual de una escena), entre otras.


4

De lo anterior, se desprende el objetivo de esta tesis, el cual consiste en llevar a cabo una generación automática, creación, edición y manipulación de los modelos de los objetos en estudio, los cuales están descritos en términos de sus características principales como lo son: su geometría, color, tamaño, posición, entre otros, de tal forma que puedan ser manipulados y utilizados en aplicaciones como el modelado de procesos de manufactura o el reconocimiento de patrones visuales.

1.2 ORGANIZACIÓN DE LA TESIS El presente trabajo está organizado en cinco capítulos. En el capítulo I se presentan los antecedentes del tema de tesis, la descripción del problema, el marco conceptual que comprende el estado de arte y el estado de la práctica, y, finalmente, la propuesta de solución al problema. En el capítulo II se detalla la etapa de análisis y diseño del desarrollo de GrafO3D, en donde se establecen los requerimientos tanto para especificar objetos y obtener una recuperación y manipulación posterior, como para la manipulación de información generada por otras herramientas desarrolladas en el cenidet. El capítulo III abarca la etapa de implementación de los requerimientos especificados en la etapa de análisis. En el capítulo IV se presentan las pruebas realizadas y los resultados generados, y, finalmente, en el capítulo V, se hace mención de las metas alcanzadas con el desarrollo del tema de tesis presentado, las conclusiones y los trabajos futuros que surgen a partir de la herramienta desarrollada.

1.3 ANTECEDENTES En el grupo de Visión Artificial del Centro Nacional de Investigación y Desarrollo Tecnológico (cenidet), se han desarrollado proyectos en dos áreas principales, que son el modelado de objetos alfaflexibles y la Visión Robótica, en las cuales se involucra el desarrollo de GrafO3D. En la figura 1.1 se muestra la relación de GrafO3D con las herramientas desarrolladas dentro del grupo.


5

Entorno de graficación y generación de modelos 2D y 3D para aplicaciones de

Visión Artificial (GrafO3D)



Herramienta para el modelado automático de objetos alfaflexibles

[Orbe03]

Archivo de descriptores por cada cuadro del archivo AVI

Detallador de tareas para procesos de Visión Robótica[López03]

Simulador de un brazo articulado con interfacegráfica

[Rueda03]

Modelos

Reconocimiento de patronesVisión ArtificialVisión Robótica





Herramienta para el modelado automático de objetos alfaflexibles

[Orbe03]

Archivo de descriptores por cada cuadro del archivo AVI

Detallador de tareas para procesos de Visión Robótica[López03]

Simulador de un brazo articulado con interfacegráfica

[Rueda03]

Modelos

Reconocimiento de patronesVisión ArtificialVisión Robótica

Figura 1.4 Relación de GrafO3D con algunas herramientas desarrolladas en el cenidet.

El objetivo de la Herramienta para el modelado automático de objetos alfaflexibles [Orbe03], es contribuir con una metodología para generar u obtener de manera automática una buena descripción o caracterización del objeto deseado, obteniendo los cambios que presenta el objeto durante el movimiento del mismo en cada imagen de una secuencia. Esta información es almacenada en un archivo de texto con los descriptores de cada cuadro del archivo AVI (Audio Video Interleave / Audio Video Entrelazado) como lo son: distancias de puntos, color, tamaño, área, centro de gravedad, entre otros. Debido a que parte de la información obtenida son los puntos que conforman el objeto bajo estudio, GrafO3D es capaz de volver a crear esos modelos a partir de esa información para obtener así una visualización gráfica de ellos y hacer corresponder el modelado gráfico con la caracterización del objeto. Además de tomar información resultante de otras herramientas, GrafO3D permite crear, a partir de ciertas figuras geométricas básicas (primitivas), modelos que también son creados, tanto en la herramienta del detallador de tareas para procesos de Visión Robótica [López03] como en la herramienta del simulador de un brazo articulado con interface gráfica [Rueda03].

1.4 DESCRIPCIÓN DEL PROBLEMA En todo proceso de Visión Artificial es indispensable contar con una buena representación y descripción de los objetos bajo estudio, principalmente cuando se trabaja con información que no tiene sentido o no es entendible de manera directa para el hombre, por ejemplo, una representación numérica.


6

La construcción de un modelo gráfico de los objetos ayuda a interpretar de una mejor manera el concepto o la información que se desea proporcionar al usuario, de tal manera que estas imágenes ilustren su forma y características que los componen. Además del tipo de objeto a procesar, existe una gran cantidad de factores que limitan el proceso de análisis de una imagen, tales como la rotación, traslación, escala e iluminación de los objetos. Si con estos problemas propios de todo sistema de Visión Artificial resulta difícil el realizar dicho proceso, el problema se agudiza cuando los objetos de trabajo tienen la propiedad de ser flexibles, en otras palabras, tienen la capacidad de cambiar de forma, tales como la mano, la boca, el cuerpo de una persona, etc., ya que no es posible conocer o determinar todos los posibles cambios o deformaciones que puede presentar dicho objeto, sobre todo cuando los cambios suelen ser variados e impredecibles por naturaleza. Otro de los problemas que se presenta, es que es necesario contar con una gramática para la especificación de los objetos mediante un archivo de texto, de manera que la recuperación de los modelos gráficos se realice sin pérdidas de información y conservando las características principales como lo son: el tamaño, tipo de objeto, posición, color, entre otras. Además de contar con la definición de una gramática, se requieren algoritmos que permitan interpretar esa gramática proporcionada por el usuario para poder generar los modelos correspondientes, y en caso de que los objetos presenten alguna secuencia de movimiento o animación, se requieren también procedimientos que permitan generarla y almacenarla en algún dispositivo. Para volver a generar el modelo descrito en el archivo resultante de la Herramienta para el modelado automático de objetos alfaflexibles, es necesario que esa información sea proporcionada, a GrafO3D, en términos de puntos (x,y), esto es, los puntos que forman al objeto, de tal forma que se traduzcan nuevamente a su modelo gráfico, lo cual es posible con la aplicación de un módulo que permita leer un archivo de texto con esta estructura. Esta información, una vez generada y presentada al usuario, es necesario que pueda ser almacenada nuevamente con los cambios actuales para una recuperación posterior, es decir, debe existir una persistencia de los datos, lo cual se hará guardando esa información en un archivo de texto. Cabe mencionar que la implementación de los módulos mencionados anteriormente, requiere el uso de un hardware más potente para obtener resultados con mayor rapidez, o de lo contrario, se requerirá mayor tiempo para su ejecución.


7

1.5 MARCO CONCEPTUAL

1.5.1 ESTADO DEL ARTE En el ámbito del modelado gráfico o graficación, existen tópicos relacionados como lo son: la graficación 3D, las herramientas CAD/CAM (Computer Aided Design/Computer Aided Manufacturing), el lenguaje para modelado de realidad virtual (VRML/Virtual Reality Modeling Language) y la biblioteca para gráficos OpenGL (Open Graphics Library). Estos tópicos se tomaron como referencia en el proceso de desarrollo del entorno de graficación y generación de modelos 2D y 3D para aplicaciones de Visión Artificial (GrafO3D).

1.5.1.1 Graficación 3D La graficación es la creación y manejo de imágenes gráficas a través de una computadora. Aunque se inició como una técnica para resaltar la información mostrada y generada por una computadora, la graficación permite interpretar y representar datos numéricos en imágenes, con un significativo incremento en la forma en que las computadoras representan información al usuario en una forma clara y entendible. La evolución tecnológica y la rápida difusión de las computadoras determinaron que en la actualidad la Computación Gráfica es el medio de producción de imágenes más importante, superando a la fotografía, diseño y artes gráficas en general, y compitiendo con el cine y la televisión. Tiene la ventaja adicional de poder reproducir imágenes “virtuales” que no necesariamente existen o se pueden ver en la realidad [Delrieux03]. La representación de gráficos en la computadora se puede realizar utilizando una vista ortogonal (bidimensional) o una vista tridimensional. En el primer caso, los modelos se observan de forma plana, es decir, solamente se pueden apreciar el largo y ancho del modelo, y no la profundidad a la que se encuentran del observador. Debido a estas limitaciones, se han desarrollado varios métodos para la representación de la geometría usando esquemas cuya proyección no esté dentro de un espacio planar [Mcmahon98]. Estos esquemas involucran la construcción de una sola representación de la geometría del componente en un espacio tridimensional. Mediante el uso de esta representación se puede evitar el posible error en el uso de múltiples vistas de un componente. Quizá sea más importante en aplicaciones que involucren la extracción de información de un modelo para el análisis y la fabricación.


8

Los métodos que han sido desarrollados para el modelado tridimensional, involucran la representación geométrica en el espacio como una colección de líneas, curvas, superficies o sólidos. Los modelos tridimensionales son construidos en un espacio 3D, típicamente en un sistema cartesiano de coordenadas. Normalmente será un sistema de coordenadas fijo que se usa en la definición global del modelo, es decir, un sistema de coordenadas global (SCG), y además, un sistema de coordenadas de trabajo (SCT) móvil que puede ser usado para ayudar en la construcción del modelo [Mcmahon98], ver figura 1.5.

xT

yT

zT

Sistema local

Arco definido en el sistema local

Sistema de coordenadas principal

xz

y

O

xT

yT

zT

Sistema local

Arco definido en el sistema local

Sistema de coordenadas principal

xz

y

O

Figura 1.5 Sistemas de coordenadas en un espacio 3D.

Las entidades geométricas, por sí mismas, son normalmente instancias de formas geométricas conocidas como primitivas, cuyas dimensiones y orientación están instanciadas para cada entidad en la representación. Dentro de la graficación en tres dimensiones, se encuentran varias técnicas para representar la forma tridimensional de los componentes, entre éstas predominan:

- Modelo de alambre (wire-frame), en el cual la geometría del componente es representada como una serie de líneas y curvas correspondientes a los arcos, o quizá secciones, del objeto.

- Superficies, en el cual la geometría del componente es representada como una colección de superficies, a menudo ligados a un modelo de alambre.

- Modelado sólido, en el cual la geometría del componente es representada, ya sea como una combinación de primitivas geométricas, o como una colección de caras, arcos y vértices que definen los límites de la parte.

Con el uso del modelado geométrico 3D, se pueden obtener ventajas considerables para aquéllos casos donde [Mcmahon98]:

- Las geometrías son intrínsecamente difíciles de representar usando técnicas convencionales, como lo son paneles del cuerpo de un vehículo y molduras para partes plásticas.


9

- El modelo 3D forme una base natural para la fabricación o para el análisis a través de la generación automática de archivos de datos de análisis (procesos CAD/CAM).

- El modelo 3D pueda ser usado para la solución de problemas geométricos como lo es el diseño de partes que involucran geometrías no-rectilíneas o intersecciones de superficies complejas, tal como partes de láminas de metal.

1.5.1.2 Herramientas CAD/CAM (Computer Aided Design/Computer Aided Manufacturing)

El diseño y la fabricación asistidos por computadora (CAD/CAM), son disciplinas que estudian el uso de sistemas informáticos como herramienta de soporte en todos los procesos involucrados en el diseño y la fabricación de cualquier tipo de producto. Estas disciplinas se ha convertido en un requisito indispensable para la industria actual que se enfrenta a la necesidad de mejorar la calidad, disminuir los costos y los tiempos de diseño y producción. La única alternativa para conseguir este triple objetivo es la de utilizar la potencia de las herramientas informáticas actuales e integrar todos los procesos, para reducir los costos (de tiempo y dinero) en el desarrollo de los productos y en su fabricación. El propósito de emplear las computadoras como herramienta de ayuda en los procesos de desarrollo de productos, es el desarrollar los modelos correspondientes que forman las bases para las etapas de diseño, planeación y organización de la actividad de fabricación, así como para el control de máquinas que fabriquen los productos. Muchas propiedades de los productos tienen que ser modeladas, incluyendo forma, dimensión, tolerancia y estructura. En todas estas áreas, la geometría, las imágenes y la manipulación espacial son muy importantes, además de estar presentes en una herramienta CAD. Los enfoques que a menudo se le han dado a una herramienta de este tipo, son [Mcmahon98]:

- En un nivel básico, usar las computadoras para automatizar o asistir tanto en tareas como en la producción de dibujos o diagramas y la generación de listas de partes en un diseño.

- En un nivel más avanzado, para proporcionar nuevas técnicas que ofrezcan al diseñador un reforzamiento de las facilidades para apoyar en procesos de diseño.

Se trata de la tecnología implicada en el uso de las computadoras para realizar tareas de creación, modificación, análisis y optimización de un diseño. De esta forma, cualquier aplicación que incluya una interfaz gráfica y realice alguna tarea de ingeniería se considera software de CAD. Las herramientas de CAD abarcan


10

desde herramientas de modelado geométrico hasta aplicaciones a la medida para el análisis u optimización de un producto especifico. Entre estos dos extremos se encuentran herramientas de modelado y análisis de tolerancias, cálculo de propiedades físicas (masa, volumen, momentos, etc.), modelado y análisis de elementos finitos, ensamblado, etc. La función principal en estas herramientas es la definición de la geometría del diseño (pieza mecánica, arquitectura, circuito electrónico, etc.) ya que la geometría es esencial para las actividades subsecuentes del ciclo del producto. El término CAD se puede definir como el uso de sistemas informáticos para la creación, modificación, análisis u optimización de un producto. Dichos sistemas informáticos cuentan con un hardware y un software específicos. El término CAM se puede definir como el uso de sistemas informáticos para la planificación, gestión y control de las operaciones de una planta de fabricación mediante una interfaz directa o indirecta entre el sistema informático y los recursos de producción. Las aplicaciones de una herramienta CAM se dividen en dos categorías [Huerta04]:

• Interfaz directa: son aplicaciones en las que la computadora se conecta directamente con el proceso de producción para monitorear su actividad y realizar tareas de supervisión y control. Estas aplicaciones se dividen en dos grupos:

o Supervisión: implica un flujo de datos del proceso de producción

proporcionado a la computadora, con el propósito de observar dicho proceso y los recursos asociados, así como para la recolección de datos.

o Control: supone un paso más allá que la supervisión, ya que no sólo se

observa el proceso, sino que se ejerce un control basándose en dichas observaciones.

• Interfaz indirecta: se trata de aplicaciones en las que la computadora se

utiliza como herramienta de ayuda para la fabricación, pero en las que no existe una conexión directa con el proceso de producción.

Una de las técnicas más utilizadas en la fase de fabricación es el Control Numérico. Se trata de la tecnología que utiliza instrucciones programadas para controlar máquinas que cortan, doblan, perforan o transforman una materia prima en un producto terminado. Las aplicaciones informáticas son capaces de generar, de forma automática, gran cantidad de instrucciones de control numérico utilizando la información geométrica generada en la etapa de diseño junto con otra información referente a materiales, máquinas, etc., que también se encuentra en la base de datos. Los esfuerzos de investigación se concentran en la reducción de la intervención de los operarios [Huerta04].


11

Otra función significativa del CAM es la programación de robots que operan normalmente en células de fabricación seleccionando y posicionando herramientas y piezas para las máquinas de control numérico. Estos robots también pueden realizar tareas individuales tales como soldadura, pintura o transporte de equipos y piezas dentro del taller.

1.5.1.3 VRML (Virtual Reality Modeling Language) El Lenguaje para Modelado de Realidad Virtual (VRML), se utiliza para describir simulaciones interactivas de participantes múltiples, esto es, mundos virtuales enlazados de manera global vía internet e hiperenlazados con el World Wide Web [Pesce96]. La especificación VRML define los elementos necesarios para crear mundos virtuales 3D, accesibles vía internet, a través de los cuales es posible navegar con un programa del tipo Netscape Navigator o Microsoft Internet Explorer. Permite la interacción con el usuario, animación, programación y un entorno 3D más rico y elaborado. VRML define un formato de archivo que integra gráficos 3D y multimedia. Conceptualmente, cada archivo VRML es un espacio 3D basado en tiempo, que contiene gráficos y objetos auditivos que pueden ser modificados dinámicamente a través de varios mecanismos. Se define un conjunto primario de objetos con mecanismos que permitan la composición, encapsulado y extensión. Un archivo VRML consta de los siguientes componentes funcionales principales [Vrml03]:

- Encabezado: sirve para identificar cada archivo VRML. - Gráficos de la escena: contiene nodos que describen los objetos y sus

propiedades. Contiene una geometría agrupada jerárquicamente para proporcionar una representación audio-visual de los objetos, así como los nodos que participan en la generación de eventos y el mecanismo de ruteo.

- Prototipos: permite que el conjunto de tipos de nodos de VRML sea

extendible para el usuario. La definición de prototipos puede ser incluida en el archivo en el cual son usados o definidos externamente. Pueden ser definidos en términos de otros nodos VRML o pueden ser definidos usando un mecanismo de extensión de un browser específico.

- Ruteo de eventos: algunos nodos VRML generan eventos en respuesta a

cambios ambientales o interacción del usuario. El ruteo de eventos da al autor un mecanismo, separado de la jerarquía de los gráficos en la escena, a través del cual estos eventos pueden ser propagados a efectuar cambios en otros nodos. Una vez generado, los eventos son enviados a su destino y


12

procesados por el nodo receptor. Este procesamiento puede cambiar el estado del nodo, generar eventos adicionales o cambiar la estructura de los gráficos en la escena.

Los contenidos de estos archivos son procesados para la representación e interacción por un programa conocido como browser. VRML ha sido diseñado para cubrir los siguientes requerimientos [Vrml03]:

- Authorability (autoría): permite el desarrollo de programas de computadora capaces de crear, editar y mantener archivos VRML, así como la traslación automática de programas para convertir otros formatos de archivo 3D comúnmente usados, en archivos VRML.

- Composability (composición): proporciona la habilidad de usar y combinar

objetos 3D dinámicos en un mundo VRML y así permitir la reutilización. - Extensibility (extensibilidad): proporciona la habilidad de agregar nuevos

tipos de objetos no definidos explícitamente en VRML. - Be capable of implementation (capacidad de implementación): capaz de

implementarse en un amplio rango de sistemas. - Performance (desempeño): escalable, desempeño interactivo en una amplia

variedad de plataformas de computadora.

- Scalability (escalable): permite la creación de mundos dinámicos 3D arbitrariamente grandes.

VRML es capaz de representar objetos dinámicos 3D y multimedia estáticos y dinámicos con ligas a otro medio como texto, sonido, películas e imágenes. Los visualizadores VRML, así como las herramientas para la creación de archivos VRML, están ampliamente disponibles para diferentes plataformas.

1.5.1.4 OpenGL OpenGL de Silicon Graphics, es una API (Application Programming Interface/Interface de Programación de Aplicaciones) portable y muy rápida escrita en lenguaje C. Es una interface de software para hardware de gráficos. La interface comprende un conjunto de cientos de procedimientos y funciones que permiten a un programador especificar los objetos y operaciones involucradas en la producción de imágenes gráficas de alta calidad, específicamente imágenes a color de objetos tridimensionales. Proporciona medios para el dibujado y renderizado2 de objetos geométricos (por ejemplo puntos, segmentos de líneas y



13

polígonos) y especifica cómo debieran ser iluminados o coloreados y cómo debieran ser mapeados del espacio del modelo a la pantalla [Segal04]. OpenGL no requiere hardware de desplegado de alto desempeño para presentar los gráficos, sino requiere un frame buffer (memoria que almacena el raster display bitmap)3. OpenGL dibuja directamente en el frame buffer, pero también permite el uso de múltiples buffers donde, por ejemplo, un buffer es desplegado mientras un segundo está siendo actualizado (conocido como doble buffer). OpenGL dibuja primitivas sujetas a un número de modos seleccionables. Cada primitiva es un punto, segmento de línea, polígono o un píxel. Cada modo puede ser cambiado independientemente; la configuración de uno no afecta la configuración de los otros. Los modos son conjuntos, primitivas especificadas y otras operaciones de OpenGL descritas mediante comandos de envío en forma de llamadas a funciones o procedimientos. Las primitivas son definidas por un grupo de uno o más vértices. Un vértice define un punto, el punto final de un arco, o una esquina de un polígono donde se encuentran dos arcos. Los datos (que constan de coordenadas posicionales, colores, normales y coordenadas de textura) son asociados con un vértice, y cada vértice es procesado independientemente, y además, en la misma forma. La única excepción para esta regla es, cuando el grupo de vértices debe ser clippeado3 para que la primitiva indicada se ajuste dentro de una región especificada; en este caso, los datos del vértice deben ser modificados y crear nuevos vértices. El tipo de clipping3 depende de cuál primitiva del grupo de vértices representa [Segal04]. Los comandos siempre son procesados en el orden en el que son recibidos, aunque puede haber una espera indeterminada antes de que los efectos de un comando sean realizados. Esto significa, por ejemplo, que una primitiva debe ser dibujada completamente antes de que cualquiera subsecuente pueda afectar el frame buffer. Esto también significa que operaciones de consulta y lectura de píxeles regresan a un estado consistente con la ejecución completa de todos los comandos OpenGL invocados previamente, excepto cuando se especifica otra cosa explícitamente. OpenGL proporciona un control directo sobre las operaciones fundamentales de gráficos 2D y 3D. Esto incluye la especificación tanto de parámetros como de matrices de transformación, coeficientes de ecuación de iluminación, métodos de antializado3, y operadores de actualización de píxeles. Funcionamiento de OpenGL

OpenGL hace uso de un componente llamado frame buffer, que es el área de memoria donde se construyen los gráficos antes de mostrarlos al usuario, es decir, que un programa en OpenGL escribe en esta área de memoria y automáticamente envía su contenido a la pantalla una vez que la escena está completamente



14

construida. La figura 1.6 muestra gráficamente cómo está constituida la estructura de abstracción de OpenGL [García04].

Programa OpenGL

OpenGL GLU GLUT

frame buffer

Nivel de abstracción más alto

Nivel de abstracción más bajo

Programa OpenGL

OpenGL GLU GLUT

frame buffer

Nivel de abstracción más alto

Nivel de abstracción más bajo

Figura 1.6 Niveles de abstracción en OpenGL.

Toda la geometría que se despliega en las aplicaciones OpenGL, está basada en los conceptos de matrices y vectores y las operaciones aritméticas aplicables a estas estructuras. En OpenGL existen básicamente tres matrices principales [García04]:

- Una matriz de proyección llamada GL_PROJECTION, la cual permite determinar la perspectiva a usar para observar la escena generada, así como el tipo de proyección. Esta matriz tiene una gran relación con otro concepto llamado clipping, que consiste en recortar u ocultar todo aquello que está pero no se ve, es decir, lo que queda fuera del foco de la cámara o del campo visual activo. Este proceso se hace automáticamente una vez que la matriz se ha inicializado pertinentemente.

- Una matriz de modelado llamada GL_MODELVIEW, la cual se usa para

aplicar a la escena funciones de rotación, traslación o escalamiento, o bien para manipular la posición y orientación de la cámara para obtener así las animaciones. En la figura 1.7 se muestran algunos ejemplos de matrices de transformación lineal para el caso de sistemas de tres dimensiones.

Figura 1.7 Matrices de transformación lineal.


15

- Una matriz para el manejo de texturas llamada GL_TEXTURE, sobre la cual se pueden aplicar transformaciones lineales de rotación, traslación y escalamiento para manipular las texturas a utilizar en las figuras de la escena.

Los vectores son un conjunto de valores que permiten definir dentro de la escena, desde los vértices de las figuras, hasta los colores, los materiales y las luces, entre otras. Existen básicamente dos formas de trabajar con vectores en OpenGL: con sus elementos como variables independientes, o manejarlos como una estructura de datos. Cuando se trabaja con los elementos de forma independiente, cada vector es descompuesto en 3 o 4 valores según sea el caso, y cuando se maneja como una estructura, estos valores están contenidos en una estructura de datos que bien puede ser un arreglo o un registro. Los vectores pueden descomponerse en 3 o 4 valores, ya que en el caso de los colores, éstos están compuestos por tres que determinan el color codificados en RGB (Red, Green, Blue), y un elemento extra en algunos casos, que determina el nivel de transparencia para el objeto, cara o vértice al cual corresponda dicho color. A esta característica de transparencia se le conoce como Alpha Blending. Todos estos valores (en el caso de los colores) tienen un dominio que fluctúa en el rango de 0 a 1. Los vectores están compuestos por números que pueden ser de tipo real, entero, byte, double, short, etc., estos tipos de datos son propios de OpenGL a los cuales se les antepone el prefijo GL (ver ejemplos en anexo B). Para declarar un vector como un vértice descomponiendo sus elementos, se usa la instrucción GLVertex3f(x,y,z), donde x, y y z son variables o constantes de tipo GLfloat, GLreal o GLsingle. La parte 3f de la instrucción, indica que recibe como parámetro tres valores de punto flotante. Cuando el vector está definido como una estructura de datos, lo que se hace es pasar la dirección de memoria de esa estructura en la llamada del procedimiento. OpenGL funciona a través de una serie de bibliotecas DLL que cubren funciones muy específicas, además de ser muy sencillas de identificar, éstas son [Wright97]:

- OpenGL.DLL, OpenGL32.DLL ó simplemente GL.DLL (Open Graphics Library, Biblioteca de Gráficos Abierta). Comprende la mayoría de las funciones utilizadas con más frecuencia e inician con las letras gl (ver ejemplos en anexo A).

- GLU.DLL o GLU32.DLL (Graphics Utility Library, Biblioteca de

Utilerías de Gráficos). Contiene funciones para objetos comunes a dibujar como esferas, donas, cilindros y cubos, así como funciones para el manejo de la cámara, entre muchas otras. Las funciones anteponen a su nombre las siglas glu (ver ejemplos en anexo A).

- GLUT.DLL (GL Utility Toolkit, Equipo de Herramientas de Utilería para

el desarrollo de Gráficos). Esta biblioteca permite crear objetos complejos


16

como GLU aunque con la principal función de permitir que los programas se vuelvan interactivos, es decir, que posibilite la libre acción de ventanas, así como el acceso al ratón y al teclado. Las funciones contenidas en esta biblioteca inician con el prefijo glut (ver ejemplos en anexo A).

1.5.2 ESTADO DE LA PRÁCTICA En esta sección se presentan algunas aplicaciones de software comercial que permiten crear gráficos en 3D, como lo son: Anim8or de R. Steven Glanville, 3D Studio Max de Discreet y AC3D de Inivis Corp. Cabe mencionar que el propósito de GrafO3D no es competir con ninguna de estas herramientas, ni con otras existentes en el mercado, sino ser la base para la construcción de una herramienta más compleja, por lo que el análisis de estas aplicaciones comerciales se realizó con el fin de detectar las características principales que componen una herramienta de este tipo, con el propósito de tomarlas en cuenta para el desarrollo de GrafO3D.

1.5.2.1 Anim8or

Anim8or es un programa de animación por computadora en 3D, diseñado para permitir una buena creación de animación [Anim8or03]. Se pueden crear y editar interactivamente objetos, figuras y escenas directamente en la pantalla de la computadora. La interfaz básica es similar a la mayoría de los programas CAD y de animación en 3D, como se muestra en la figura 1.8.

Figura 1.8 Interfaz de la herramienta Anim8or.


17

Cuenta con las siguientes características [Anim8or03]:

- Modelador 3D: crea y modifica modelos 3D. Construye sobre primitivas como esferas, cilindros, sólidos platónicos, etc.; edición de mallas y subdivisión; curvas splines4, extrusión4, lathing4, modificadores, deformaciones y bevel4.

- Soporta fuentes TrueType: extrusión de texto en 2D y 3D para cualquier fuente TrueType.

- Operación en tiempo real basada en OpenGL. - Importa y modifica archivos objeto 3DS (3DStudio), LWO (Lightwave) y

OBJ (Wavefront). - Exporta archivos 3DS. - Construye sobre un visualizador de objetos 3D. - Editor de caracteres articulado. - Software antializado para renderizado de alta calidad, producción de

imágenes de calidad. - Crea escenas y animaciones 3D y como salida, archivos de video AVI e

imágenes JPG y BMP. - Soporta texturas, sombras suaves, focos, niebla, etc. - Soporte de texturas para formatos de archivo BMP, GIF y JPG. - Imprime imágenes de escenas y modelos.

Dentro de la interfaz de Anim8or, se pueden controlar varios aspectos de trabajo usando el ratón de computadora ordinario o un pizarrón óptico. Se puede seleccionar y arrastrar, rotar, escalar y colocar objetos haciendo clic en las vistas de trabajo disponibles. Tiene dos barras de herramientas que se pueden usar para tareas comunes. La barra de la parte de arriba, tiene botones para comandos generales que son usados en cualquier parte de Anim8or, mientras que la barra de la izquierda permite cambiar el modo de operación para tareas comunes actuales. Se puede tener el control de la vista de los objetos para ver su apariencia de frente, de lado, arriba, en perspectiva, etc., y se pueden mostrar múltiples vistas o una sola vista en la pantalla. Tiene cuatro modos principales de trabajo, y un modo de visualización de objetos (object-browsing):

• El primero, es un editor de objetos que es usado para construir, en la mayoría de los casos, objetos estáticos.

• El segundo, tiene un editor de caracter o figura. Se usa para definir la estructura de un caracter que se quiera animar por medio de la unión de huesos y de objetos a ellos.



18

• El tercero, tiene un editor de secuencia o movimiento. Aquí, se pueden definir segmentos de movimiento como un ciclo o paseo. Éstos pueden ser enlazados en cadenas en un editor de escena para secuencias largas.

• En el cuarto, se pueden poner juntas las escenas finales en un editor de escena. Aquí, se pueden colocar los objetos y lo construido en las otras partes de Anim8or, en el “mundo” final. Se puede controlar cómo se mueven y dónde está colocada la cámara. También se puede dar a la escena varios tipos de luces.

Una vez que se haya creado el modelo o escena se pueden obtener imágenes JPG (Joint Photographic Experts Group) y BMP (Mapa de Bits) de alta calidad y videos AVI y almacenarlos en disco para su uso posterior. Finalmente, hay un explorador de objetos que ayudan a la visualización y a organizar los objetos Anim8or.

1.5.2.2 3D Studio Max Dentro de las principales características de 3D Studio Max, se encuentran [Lamers96]:

- Permite crear objetos geométricos elementales, como esferas, conos y cubos, utilizando comandos. Estos objetos se manejan con facilidad (doblarse, comprimirse y cortarse) para crear el producto final.

- Se pueden crear objetos más complejos mediante el dibujado de una serie

de secciones transversales bidimensionales de un objeto, que 3D Studio conecta para formar un objeto 3D.

- Permite la aplicación de materiales a los objetos para modificar la

apariencia del objeto.

- Se pueden definir y utilizar diferentes tipos de luces para crear un ambiente en la escena y llamar la atención del observador.

- Permite ajustar la posición y cambio visual de cada cámara incluida en la

escena para aumentar o disminuir el tamaño aparente de los objetos.

- Crear animaciones que se reproducen en video, película o computadora, que exhiben entre 12 y 30 imágenes por segundo.


19

1.5.2.3 AC3D

Esta herramienta permite ver, editar y crear gráficos 3D; disponible para Windows y Linux. AC3D es muy fácil de usar además de ser muy poderosa, ver figura 1.9.

Figura 1.9 Interfaz de la herramienta AC3D.

AC3D es usado para una amplia variedad de propósitos, incluyendo [Ac3d04]:

• Creación de modelos 3D para juegos. • Producción de modelos para realidad virtual y software de simulación de

vuelos. • Visualización de datos científicos, médicos y generales. • Prototipado rápido de diseños 3D. • Generación de modelos 3D para una alta resolución de renderizado en

3D. Características [Ac3d04]:

• Vistas (2D y 3D) de gráficos OpenGL de tiempo real. • Interface de usuario simple: “pulsar y arrastrar” • Extrusión y revolución de superficies. • Modelado de subdivisión de superficies. • Operaciones booleanas. • Fuente Truetype en 2D y generador de texto 3D. • Un editor de coordenadas de textura de integrado gráfico. • Soporte para varios formatos de archivo 3D incluyendo POV-Ray, VRML

(1 y 2), RenderMan, 3D Studio 3DS, Lightwave, DXF, Alias triangle, Wavefront OBJ, Direct X, Milkshape, MD2, Quake 3 BSP, entre otros.


20

• Kit de desarrollo de software y una interfaz plugin. • Rápido y memoria eficiente, programa binario compacto. • Edición a una granularidad diferente: grupos, objetos, superficies,

vértices. • Edición de polígonos completos, por ejemplo, crear una esfera y mover

fácilmente los puntos (vértices) para deformar la figura. • Crear y editar polígonos multipunto y líneas, no solamente triángulos. • Manipulación individual de superficies:

o Insertar y eliminar vértices o Creación de huecos o Spike5 o Spline o Bevel o Triangulado o Flip5 o Subdivisión

• Agrupación de superficies en objetos nuevos. • 4 vistas, 3 ortográficas y una 3D. Una vista o todas a la vez. • Los objetos pueden ser buscados dentro de una escena. • Navegación/zoom sobre una vista 2D con teclas de cursor y otras teclas

simples. • Ventana de vista jerárquica. • Ocultamiento/aparición de objetos para una edición más fácil/rápida de

escenas complicadas. • Focos y hasta otros 7 focos posicionales. • Paleta de colores de 24 bits con ajuste de las componentes: difusa,

ambiental, de emisión, especular, brillo y transparencia. • Creación de nuevas superficies/objetos alrededor de cualquier selección. • Programa multiplataforma. • La documentación simple de formatos de archivo permite una fácil

conversión de otras formas de datos.



21

1.6 PROPUESTA DE SOLUCIÓN En este apartado se presenta el objetivo general del tema de tesis y los beneficios que se obtienen con su desarrollo, además se puntualizan los alcances y limitaciones del proyecto final. El modelo conceptual que comprende las etapas de desarrollo de GrafO3D, se presenta en el capítulo II, sección 2.4.

1.6.1 OBJETIVO DE LA TESIS Diseñar e implementar un entorno para la creación, edición y visualización de modelos gráficos de objetos rígidos y flexibles en 2D y 3D.

1.6.2 BENEFICIOS

1.6.2.1 Beneficios generales

• Manejo de múltiples objetos en una misma escena mediante un entorno visual de graficación.

• Aplicación en modelado de objetos para aplicaciones de Visión Artificial. • Manejo de funciones básicas y avanzadas de graficación. • Generación de animación con los objetos graficados, que pueda ser

almacenada en un archivo de video (AVI). • Servir de base para construir una herramienta de apoyo para procesos de

manufactura con celdas flexibles que permita un entorno virtual para su especificación y detallado de tareas.

• Posibilidad de ser parte de un proyecto más grande semejante a una herramienta CAD/CAM.

1.6.2.2 Beneficios específicos para el grupo de Visión Artificial del cenidet

• Manipulación de modelos generados por otras herramientas realizadas dentro del grupo.

• Creación de nuevos modelos que puedan servir como datos de entrada para otra herramienta en desarrollo.

• Validación visual de que los modelos generados caractericen la forma de los objetos especificados en el archivo de texto y que tengan una correspondencia con la realidad.


22

1.6.3 ALCANCES Y LIMITACIONES ALCANCES

• Definición de primitivas para el modelado. • Manejo de la especificación de los objetos mediante archivo de texto. • Manejo de múltiples objetos en la misma escena (de 5 a 20 objetos), que

puedan ser seleccionados por el usuario en tiempo de ejecución. • Manejo de funciones básicas de graficación:

o Cambio de perspectiva. o Cambio de escala. o Cambio del vector normal a nivel del objeto. o Cambio de color, por objeto y por secciones del objeto.

• Manejo de funciones avanzadas de graficación: o Modelos de alambre. o Modelos sólidos. o Superficie con texturas. o Ocultamiento de caras. o Animación. o Iluminación.

• Generación de animación mediante la interpretación de los datos numéricos generados por la herramienta de modelado.

• Generación de archivos AVI con la animación resultante. • Generación de animación mediante la especificación de funciones de

transformación de los objetos definidos. LIMITACIONES

• No se realiza un reconocimiento de objetos, solo permite modelarlos. • La información de entrada es mediante un archivo de texto o a través de

instrucciones proporcionadas en la interfaz gráfica de la herramienta. • El modelado se realiza a partir de ciertas primitivas definidas previamente. • El número de objetos que pueden ser graficados en la herramienta, es de 5

a 20 objetos en una misma escena. • La salida generada por la herramienta es el modelo gráfico de los objetos y

un archivo de texto que contiene la descripción de sus características. En caso de haber animación, la salida es también un archivo de video tipo AVI.

• La animación resultante es almacenada en un archivo de video tipo AVI. • La herramienta no permite la modificación de un archivo AVI que resulte

de la misma o algún otro existente. • Para el desarrollo de la herramienta, se hizo uso del entorno de desarrollo

C++ Builder v5.0 y de la biblioteca para gráficos OpenGL v1.5, bajo una plataforma Windows XP.


23

1.6.4 DISCIPLINAS INVOLUCRADAS

- Analizadores y traductores. - Graficación en 3D. - Mundos virtuales tridimensionales.

1.7 APLICACIONES

• En el desarrollo de juegos. • En la industria, para el modelado de procesos de manufactura, modelado

de productos, etc. • Generación de modelos para su utilización en el reconocimiento de

patrones. • Elaboración de casos de prueba que sirvan como entrada a otras

herramientas en desarrollo en el cenidet. • Generación de modelos mediante información arrojada por otras

herramientas desarrolladas en el cenidet.

1.8 CONCLUSIONES En este capítulo se presentó la información que conforma los antecedentes del tema de tesis, así como la problemática contenida en éste y la propuesta de solución, en la que se incluye: el objetivo general, los beneficios que se obtienen con el desarrollo de GrafO3D y sus alcances y limitaciones. Se presentó el marco conceptual que constituyó la base para el desarrollo de las etapas para la creación de GrafO3D, el cual está conformado por tópicos referentes al modelado de objetos en 3D como lo son: VRML, para la descripción de objetos a través de un archivo de texto; OpenGL para la creación de modelos 3D; graficación 3D y herramientas CAD/CAM como una aplicación de modelos tridimensionales. Además se presentaron algunas herramientas existentes en el mercado cuya aplicación es en el modelado de objetos 3D mediante un entorno gráfico, y que sirvieron de referencia para conocer las partes por las que está constituida una herramienta de este tipo.

Entorno de graficación y generación de modelos 2D y 3D para aplicaciones de Visión Artificial Capítulo II. Análisis y Diseño

24

CAPÍTULO II

ANÁLISIS Y DISEÑO

CONTENIDO:

Introducción Requerimientos funcionales del sistema Otros requerimientos Modelo conceptual de GrafO3D Definición y especificación de objetos Especificación de objetos en GrafO3D Persistencia y recuperación de objetos Manipulación de objetos Procesos para tratar archivos producidos por otras herramientas Conclusiones

2 lo II


25

2.1 INTRODUCCIÓN Debido a la importancia que tiene un modelo gráfico para representar información que ocasionalmente es poco entendible por el ser humano, y a la variedad de aplicaciones en que puede ser empleado un modelado de este tipo, se decidió crear una herramienta con un entorno gráfico que permita crear, editar y visualizar modelos en 2D y 3D de objetos rígidos y flexibles (GrafO3D), con el fin de apoyar a procesos de Visión Artificial, Visión Robótica y Reconocimiento de Patrones. El presente capítulo comprende la etapa de análisis y diseño del sistema, en la cual se hace una descripción del problema para identificar y especificar los requerimientos de GrafO3D, y así, detallar la solución lógica para satisfacer dichos requerimientos.

2.2 REQUERIMIENTOS FUNCIONALES DEL SISTEMA Diagrama de casos de uso general En la figura 2.1, se muestra el diagrama de casos de uso general del sistema, en el que se ilustra tanto al actor o persona que hará uso del sistema (usuario), como a las actividades o funciones que el usuario podrá realizar para manipularlo.

Figura 2.1 Diagrama de casos de uso general.


26

En la tabla 2.1, se describen los casos de uso contenidos en el diagrama anterior.

Tabla 2.1 Descripción de los casos de uso del diagrama.

CASO DE USO DESCRIPCIÓN

Crear nueva escena*

Se inicia cuando el usuario desea crear una nueva escena y se elimina de la pantalla lo que se haya creado anteriormente.

Abrir escena desde archivo*

Se inicia cuando el usuario desea abrir un archivo de texto existente con la descripción de una escena y bajo la gramática permitida por la herramienta.

Importar archivo* Se inicia cuando el usuario desea abrir un archivo de texto existente en donde se describa el objeto por medio de puntos (x,y).

Crear nuevo objeto*

Se inicia cuando el usuario desea crear un nuevo objeto en la escena.

Modificar propiedades de un objeto o primitiva*

Se inicia cuando el usuario desea modificar las características de un objeto o de una primitiva, como lo son: nombre, color, rotación, traslación, escala, textura. Si las modificaciones son hechas a un objeto, todas las primitivas que contenga este objeto son también modificadas.

Agregar primitiva* Se inicia cuando el usuario desea agregar una nueva primitiva a un objeto existente.

Guardar escena* Se inicia cuando el usuario desea almacenar en un archivo de texto, la información de la escena actual. Este archivo de texto será escrito bajo la gramática permitida por la herramienta.

Manejo de iluminación*

Se inicia cuando el usuario desea modificar las propiedades de la luz, como lo son: nombre, posición y color.

Cambio de perspectiva*

Se inicia cuando el usuario desea hacer un movimiento con la cámara en las direcciones de adelante, atrás, izquierda y derecha.

Cambiar vista de modelos*

Se inicia cuando el usuario desea cambiar el tipo de vista de los modelos en la escena, como lo son: modelos de alambre, sólidos o vértices.

Eliminar objeto o primitiva*

Se inicia cuando el usuario desea eliminar un objeto o primitiva existente. En caso de eliminarse un objeto, todas las primitivas que contenga serán también eliminadas.

Generar animación*

Se inicia cuando el usuario desea generar animación con los objetos de la escena actual. El usuario proporcionará los


27

parámetros de: nombre del archivo de animación, número de frames6 que formarán la secuencia, el tiempo de espera entre cada uno de ellos y el número de veces o ciclos que la secuencia será repetida.

Cerrar aplicación* Se inicia cuando el usuario desea salir completamente de la aplicación.

* Ver anexo C para su documentación.

2.3 OTROS REQUERIMIENTOS Para que el sistema trabaje de manera adecuada, es necesario que se cumplan al menos las siguientes condiciones externas:

• Hardware - Procesador de la familia pentium II o posterior. - Memoria de al menos 128 Mb. - Espacio en disco para su instalación y ejecución de al menos 50 Mb. - Espacio extra para el almacenamiento de archivos de textura y de

animación.

• Software - Sistema operativo Windows 98 o posterior.

2.4 MODELO CONCEPTUAL DE GrafO3D Para llevar a cabo el desarrollo de GrafO3D, se diseñó el modelo conceptual con las diferentes etapas a realizar para obtener un producto final que cumpla con el objetivo planteado inicialmente. En la figura 2.2 se muestran las etapas por las que está compuesto el desarrollo de GrafO3D.

GrafO3D

MODELOS GRÁFICOS

Archivo de texto

Archivo de v ideoFunciones

avanzadas

Archivo de texto con la

especificación de puntos (x,y)

Salidas

Traductor (estructura de

datos a archivo de texto)

Funciones básicas

Entradas

Instrucciones mediante la

interfaz gráf ica

Archivo de texto definido por el

usuario

Intérprete (Analizador léxico,

sintáctico y semántico)

GrafO3D

MODELOS GRÁFICOS

Archivo de texto

Archivo de v ideoFunciones

avanzadas


especificación de puntos (x,y)

Salidas

Traductor (estructura de

datos a archivo de texto)

Funciones básicas

Entradas

Instrucciones mediante la

interfaz gráf ica

Archivo de texto definido por el

usuario

Intérprete (Analizador léxico,

sintáctico y semántico)

Figura 2.2 Modelo conceptual de GrafO3D.



28

El modelo conceptual de la figura 2.2, está dividido básicamente en las siguientes partes, las cuales se describen en el resto de este capítulo: ♦ Entradas: la información de entrada al sistema será mediante la ejecución de

instrucciones de la interfaz gráfica o a través de un archivo de texto con un formato predefinido, es decir, ya sea un archivo GrafO3D (ver ejemplo en el anexo D) o un archivo que contenga la descripción del objeto en términos de puntos (x,y) (ver ejemplo en anexo E).

♦ Interpretación de la información: la información proporcionada por el usuario

debe ser interpretada para generar los modelos de acuerdo a las características especificadas.

♦ Generación de los modelos gráficos: el resultado de la interpretación de la

información textual será la representación gráfica de los modelos, los cuales podrán ser manipulados por el usuario.

♦ Traducción de información a archivo de texto: una vez que el usuario haya

creado los modelos y desee almacenarlos en un archivo de texto, el sistema traducirá la información correspondiente a la escena, a su representación textual.

♦ Salidas: el sistema generará como salida un archivo de texto con las

especificaciones de la escena que haya creado el usuario, y en caso de haber creado algún tipo de animación, la salida será también un archivo de video tipo AVI.

2.5 DEFINICIÓN Y ESPECIFICACIÓN DE OBJETOS Una escena, dentro de un entorno virtual, está compuesta por objetos los cuales son manipulados por el usuario. Un objeto es aquél que está formado por una serie de primitivas y que contiene un conjunto de características propias como nombre, posición, color, entre otras. Una primitiva es un elemento gráfico con el que se pueden formar figuras de mayor complejidad, conteniendo también sus características propias. Uno de los problemas al crear un mundo virtual, es saber cómo describir los objetos con la información necesaria, de tal manera que se conserven sus principales características para obtener el modelo correcto, y una vez teniendo esa descripción, es necesario que sea proporcionada a la computadora y que a su vez genere el resultado deseado. Uno de los principales alcances de la tesis, es que el usuario pueda crear los objetos mediante primitivas, ya sea a través de un archivo de texto o a través de la interfaz gráfica, y que además puedan ser almacenados en un archivo de texto para que exista la posibilidad de una recuperación posterior.


29

Para llevar a cabo la especificación de objetos en GrafO3D, se analizaron las características que componen un entorno virtual en 3D, la definición de primitivas tanto en VRML como en OpenGL, así como la estructura de un archivo VRML, para tomarla como base en la definición de la estructura del archivo de texto que será leído por GrafO3D, y definir las primitivas que permitirán construir los objetos. Estas características se describen en los siguientes apartados.

2.5.1 MUNDO VIRTUAL TRIDIMENSIONAL Para crear un entorno 3D con un mayor realismo, es necesario incluir diversos componentes que en conjunto permiten observar un resultado de mayor calidad. En este apartado, se presentan las características principales que se deben tomar en cuenta. En el mundo de las gráficas 3D, la computadora utiliza puntos y enlaces que relacionan estos puntos para crear la estructura de los objetos. El conjunto de puntos que estructuran un objeto se denomina nube de puntos, porque al eliminar las líneas que conectan tales puntos, el esquema adquiere la apariencia de una nube punteada que flota en el espacio. De hecho, casi todos los objetos generados por computadora empiezan por ser una nube de puntos [Pesce96]. En el siguiente paso hacia el realismo, la computadora enlaza los puntos para crear la estructura del objeto. Ahora el elemento empieza a parecer real, pero su interior está vacío. Esto se conoce como el acabado delineado de un objeto. Después de crear la estructura, es necesario aplicar la piel (superficie) del objeto. La superficie puede tener diferentes características: al igual que la pintura de un automóvil, el acabado puede ser opaco, brillante, de cualquier color e incluso presentar franjas y otros elementos decorativos. La superficie da una apariencia de solidez al objeto (aunque el interior de éste permanezca vacío) y, si se utiliza un diseño creativo, el objeto puede llegar a tener una apariencia bastante realista. En el mundo real es posible observar los objetos debido a que éstos emiten o reflejan una luz [Pesce96]. Es por eso que la computadora debe iluminar el objeto por medio de una luz generada por ella misma a fin de presentar una visión más realista. Después de iluminar el objeto, la computadora le asigna un sombreado. Cada superficie refleja la luz de manera diferente y la computadora debe calcular el sombreado en las caras del elemento. Cualquier proceso gráfico en 3D debe iniciar con un lugar, es decir, el sitio donde se localizan los objetos. Todo en el mundo tiene una posición, un lugar donde cada objeto se encuentra y que define las relaciones, asociaciones y posibilidades.


30

Además de las posiciones, el mundo físico tiene tres dimensiones llamadas anchura, altura y profundidad. La anchura es la cualidad que se extiende de lado a lado en un objeto; la altura es la característica que comprende el espacio vertical; la profundidad es el factor que interviene cuando el objeto se acerca o se aleja del observador. En el mundo de las computadoras, estas dimensiones son representadas por las letras x, y, z, respectivamente. En el mundo real, todos los objetos tienen una posición y una orientación que representan atributos independientes [Pesce96]. La orientación se representa por medio de tres valores, porque los objetos pueden girar en tres dimensiones para cambiar su orientación. Estos valores se denominan giro (movimiento rotatorio), vuelta (movimiento en ciclos) y rodado (movimiento circular); cada uno corresponde a las variables x, y, z, respectivamente. Como se mencionó anteriormente, los objetos se crean a partir de una nube de puntos; estos puntos se conectan mediante líneas que forman una estructura, que a su vez se cubren con una superficie. Las superficies se conforman por objetos conocidos como polígonos. Un polígono es la pieza básica de construcción en el mundo tridimensional de las computadoras. Una vez que se han creado los polígonos, el objeto deberá iluminarse con una luz generada por la misma máquina, a fin de crear el efecto de la reflexión, brillo y sombra. Como sucede en el mundo real, ningún objeto es visible a menos que sea iluminado; es por eso que las aplicaciones para generar escenas 3D, incluyen a menudo una luz “ambiental” que proporciona una iluminación uniforme cuando no existe otra fuente luminosa. Las luces se manejan de las siguientes formas [Pesce96]: • Luces apuntadoras: irradian la misma luminosidad en todas direcciones, por

ejemplo un foco, una lámpara, el sol. • Luz apuntadora paralela: similar a una luz apuntadora simple. En este caso

los rayos de luz emitidos son paralelos entre sí. Esto significa que la luz actúa como si la fuente estuviera muy lejana, lo cual es de gran utilidad para simular la luz del sol, por ejemplo; el sol se encuentra tan alejado de la Tierra, que sus rayos de luz parecen paralelos desde nuestra perspectiva.

• Luces direccionales: fuente de luz que puede apuntar hacia determinados

objetos. Estas luces tiene una posición (asignada mediante las coordenadas x, y, z) y una orientación (en grados y mediante las variables de giro, vuelta y rodado); estos factores especifican dónde se encuentra la fuente de iluminación, así como la dirección en que ésta se enfoca, por ejemplo, la luz de un semáforo.


31

• Luces fijas: son una variante de las luces direccionales. Además de contar con una dirección hacia la que proyectan sus rayos luminosos, incluye un enfoque denominado umbra. La umbra determina la anchura del rayo de luz y la velocidad con que cruza el espacio del mundo generado por la computadora. Un rayo láser es un ejemplo objetivo, pues permanece en línea recta desde que sale del punto emisor. Las luces que se utilizan en los escenarios de los teatros son, por lo general, fuentes fijas cuya orientación es ajustable.

La forma en cómo el objeto se despliega en pantalla, es mediante las líneas que unen la nube de puntos, sin embargo, si se desea observar las caras de un objeto, se deberá utilizar un acabado sólido. En este caso, los polígonos se “colorean” para que su superficie sea visible. Los objetos sólidos se componen de varias caras poligonales; la normal de estas caras determina cómo se refleja la luz en las mismas. La computadora trata de calcular la cantidad de luz reflejada en las caras del objeto, proveniente de las fuentes luminosas en la escena tridimensional; este proceso se conoce como sombreado. El sombreado puede ser alguno de los siguientes tipos [Pesce96]:

• Sombreado plano: se basa en la normal, es decir, el rayo luminoso que se proyecta hacia el exterior de la cara del polígono. La computadora calcula el valor del ángulo entre la normal y la fuente de luz, y usa la información obtenida para sombrear la cara del polígono. Este tipo de sombreado, aunque es muy rápido, crea una apariencia artificial en los objetos.

• Sombreado Gouraud: utiliza la normal de la cara del primer polígono y la normal de las caras principales en los polígonos contiguos para establecer un sombreado promedio entre todas las caras. Esta labor requiere de muchos cálculos matemáticos, por lo que demora casi diez veces más que el sombreado plano. Este tipo de sombreado da una apariencia más realista a los objetos, aunque a veces se muestra una especie de franjas, esto se debe a una falta de precisión en los cálculos matemáticos que se realizan.

• Sombreado Phong: toma la normal de la cara del primer polígono y determina normales adicionales para cada esquina de la cara, a fin de promediar los valores obtenidos con los valores de las normales de los polígonos adyacentes. El proceso es diez veces más lento que el sombreado Gouraud, pero produce resultados espectaculares en algunos casos. Subsana algunas de las deficiencias del sombreado Gouraud.

• Rastreo de rayos de luz: se utiliza en comerciales de televisión, superproducciones cinematográficas e imágenes fijas muy realistas, pues representa un proceso de sombreado de alta calidad. La computadora calcula casi todos los rayos de luz (rastrea sus trayectorias) que se incluyen


32

en la escena y, a partir de los datos obtenidos, genera una visualización “realista” del mundo en tercera dimensión.

Para crear un mundo más rico y detallado, se puede hacer uso de los mapas de textura. Estos mapas se asemejan a un “papel tapiz” que se aplican a las caras de los polígonos. A menudo, un solo mapa de textura “envuelve” todo un objeto.

2.5.2 ESPECIFICACIÓN DE OBJETOS EN VRML En este apartado, se describe la estructura de un archivo VRML, la cual fue tomada como referencia para definir la estructura de un archivo GrafO3D. En general, los aspectos tomados de dicha estructura son los siguientes, los cuales se detallan en la sección 2.6: - La secuencia para la definición de una escena, es decir, el orden en que los

elementos que la constituyen (encabezado, cámara, iluminación, objetos, etc.), aparecen en el archivo de texto.

- La sintaxis para definir: encabezado (#Grafo v10), cámara (PerspectiveCamera), transformaciones (Transform), material (Material), primitivas (Cone, Cube, Cylinder, Sphere) y objetos (Separator).

- Se tomaron como primitivas las figuras geométricas: cono, cubo, cilindro y esfera.

A continuación se describe cómo se especifican los objetos en un archivo VRML. VRML es el acrónimo de Virtual Reality Modeling Language. Este lenguaje contiene un conjunto básico de primitivas para el modelado geométrico tridimensional y tiene la capacidad de modelar el comportamiento de los objetos y asignar diferentes animaciones que pueden ser activadas por eventos generados por diferentes usuarios [Suárez03]. Un punto central en el concepto del VRML, es el manejo de mundos o documentos VRML. No obstante, cada mundo se debe considerar como una escena. Además de describir el contenido y el esquema de un mundo, los documentos VRML también pueden incluir “enlaces” o “anclas” para relacionarse con otros archivos, por ejemplo archivos Web, películas QuickTime o documentos PostScript. Además permite enlazar varios mundos, es decir, si se puede viajar de una página a otra en la Web, también se podrá trasladar de un mundo a otro. Cada escena VRML tiene un “punto de vista” llamado cámara y es posible que el usuario pueda definir varios puntos de vista.


33

Toda la información de un archivo VRML debe ser de tipo texto y con la extensión .wrl, además debe tener la estructura descrita a continuación [Pesce96]: • Encabezado

Todos los documentos VRML tienen que contar con un encabezado que los identifique como un archivo VRML válido.

#VRML V2.0 ascii En donde:

v2.0 es la versión y ascii es el tipo de formato de caracteres

• Campos

Existen dos clases generales de campos: los que contienen un solo valor, ya sea un simple número, un vector o hasta una imagen; y los campos con valores múltiples que están escritos como una serie de valores separados por comas, dentro de corchetes.

• Nodos

La mayoría de los nodos pueden clasificarse en tres categorías: figura, propiedad o agrupación. Los nodos de figura definen la geometría en la escena. Los nodos de propiedad afectan la manera como se trazan las figuras, mientras que los nodos de grupo unen nodos y ello permite que estos grupos sean tratados como un sólo objeto. Los nodos pueden tener cero o más campos. En cada nodo se define un tipo, nombre y valor por omisión para cada uno de los campos. Los nodos de figura se muestran en la tabla 2.2:

Tabla 2.2 Nodos de figura de VRML.

AsciiText Representa cadenas de caracteres de texto con el conjunto de caracteres ASCII.

Cone Define un cono especificando los campos: parts (partes: sides, bottom o all), bottomRadius (radio), height (alto).

Cube Representa un cubo y tiene los siguientes campos: width (ancho), height (altura), depth (profundidad).

Cylinder Define un cilindro especificando los campos: parts (partes), radius (radio), height (alto).

IndexedFaceSet

Representa una figura 3D elaborada con caras (polígonos), construida a partir de vértices localizados en las coordenadas actuales. Campos: coordIndex (índice de coordenadas), materialIndex (índice material), normalIndex (índice normal)


34

y textureCoordIndex (índice de coordenadas de textura).

IndexedLineSet

Representa una figura 3D, formada al construir polilíneas a partir de vértices localizados en las coordenadas actuales. Campos: coordIndex (índice de coordenadas), materialIndex (índice material), normalIndex (índice normal) y textureCoordIndex (índice de coordenadas de textura).

PointSet Representa a un grupo de puntos localizados en las coordenadas actuales. Campos: starIndex (índice de inicio) y numPoints (número de puntos).

Sphere Representa una esfera y se especifica el campo radius (radio). Los nodos de geometría y material se muestran en la tabla 2.3:

Tabla 2.3 Nodos de geometría y material de VRML.

Coordinate3 Define un grupo de coordenadas 3D, el cual será utilizado por un nodo IndexedFaceSet, IndexedLineSet o PointSet subsecuente.

FontStyle

Define el estilo de fuente actual que se utilizará para todo el texto ASCII subsecuente. Se definen los campos: size (tamaño), family (familia: serif, sans, typewriter), style (estilo: none, bold, italic).

Info Define un nodo de información en la escena. Se define el campo string (cadena).

LOD

Permite que las aplicaciones cambien entre diferentes representaciones de objetos en forma automática. Los hijos de este nodo representan por lo general el mismo objeto u objetos en niveles de detalle distintos: desde el más alto hasta el más bajo. Campos: range (rango) y center (centro).

Material

Define las propiedades actuales del material de la superficie para todas las figuras subsecuentes. Campos: ambientColor (color de ambiente), diffuseColor (color de difuminación), specularColor (color especular), emissiveColor (color de emisión), shininess (brillo), transparency (transparencia).

MaterialBinding Especifica la forma en que los materiales actuales deben unirse a las figuras subsecuentes dentro de la escena. Campo: value (valor).

Normal

Define un grupo de vectores normales de superficies 3D que utilizarán los nodos de figura basados en vértices subsecuentes, que se encuentran en la escena. Campo: vector (vector).

NormalBinding Especifica la manera en cómo las normales actuales se unirán a las figuras subsecuentes de la escena. Campo:


35

value (valor).

Texture2 Define tanto los parámetros para este campo como para un mapa de textura. Campos: filename (nombre del archivo), image (imagen), wrapS, wrapT.

Texture2Transform

Define una transformación bidimensional aplicada a las coordenadas de textura, que afectará la manera en cómo se aplicarán las texturas a las superficies de las figuras subsecuentes. Campos: translation (traslación), rotation (rotación), scaleFactor (factor de escala) y center (centro).

TextureCoordinate2

Define un grupo de coordenadas bidimensionales que se usará para hacer un mapa de texturas para los vértices de los objetos subsecuentes PointSet, IdexedLineSet, IndexedFaceSet. Campo: Point (punto).

ShapeHints

Indica que los grupos de caras indizadas (IndexedFaceSets) son sólidos, contienen vértices ordenados o incluyen caras convexas. Campos: creaseAngle (ángulo de doblez), vertexOrdering (orden de los vértices), shapeType (forma), faceType (tipo de cara).

Los nodos de transformación se muestran en la tabla 2.4:

Tabla 2.4 Nodos de transformación de VRML.

MatrixTransform Define una transformación geométrica 3D con una matriz de 4 x 4. Campo: matrix (matriz)

Rotation Define un movimiento de rotación 3D sobre un eje arbitrario sobre el origen. Campo: rotation (rotación).

Scale Define una escala 3D sobre el origen. Campo: scaleFactor (factor de escala).

Transform

Define una transformación geométrica 3D que consiste en una escala no uniforme sobre un punto arbitrario, una rotación sobre un punto y un eje arbitrarios y una traslación. Campos: translation (traslación), rotation (rotación), scaleFactor (factor de escala), scaleOrientation (orientación de escala) y center (centro).

Translation Define un movimiento de traslación hecha por un vector 3D. Campo: translation (traslación).


36

Los nodos de cámara se muestran en la tabla 2.5:

Tabla 2.5 Nodos de cámara de VRML.

OrthographicCamera Define que el tipo de proyección será ortográfica. Campos: position (posición), orientation (orientación), focalDistance (distancia focal), height (altura).

PerspectiveCamera

Define que el tipo de proyección será en perspectiva. Campos: position (posición), orientation (orientación), FocalDistance (distancia focal), heightAngle (altura del ángulo).

Los nodos de iluminación se muestran en la tabla 2.6:

Tabla 2.6 Nodos de iluminación de VRML.

DirectionalLight

Define que la fuente de luz será direccional, es decir, que iluminará a lo largo de los rayos paralelos de un vector tridimensional dado. Campos: on (activado), intensity (intensidad), color (color), direction (dirección).

PointLight

Define que la fuente de luz será una luz apuntadora especificada en una posición fija 3D. Ilumina igual en todas direcciones (omnidireccional). Campos: on (activado), intensity (intensidad), color (color), location (ubicación).

SpotLight

Define que la fuente de luz será fija y con una posición 3D. Esta fuente de luz ilumina en forma de cono con una dirección particular. Campos: on (activado), intensity (intensidad), color (color), location (ubicación), direction (dirección), dropOffRate (proporción de disminución), cutOffAngle (ángulo del cono).

Los nodos de grupo se muestran en la tabla 2.7:

Tabla 2.7 Nodos de grupo de VRML.

Group Define la clase que será la base para todos los nodos de grupo. Contiene una lista ordenada de los nodos hijos. Funciona como contenedor.

Separator Esta acción aísla los hijos del separador del resto de los objetos contenidos en la escena. Campo: renderCulling (selección de acabado: on, off).

Switch

Desplaza a uno, a todos o a ninguno de sus hijos. Se puede emplear para aplicar o eliminar los efectos de algunas propiedades o intercambiar propiedades diferentes entre los hijos que contenga. Campo: whichChild (cuál hijo).


37

TransformSeparator

Guarda el estado antes de desplazar a sus hijos y lo restituye después, sin embargo, sólo guarda la transformación actual y todos los demás estados permanecen sin cambio.

WWWAnchor Carga una nueva escena dentro de un visualizador VRML, al seleccionar uno de sus hijos. Campos: name (nombre), description (descripción), map (map).

En el anexo F se muestra un ejemplo de un archivo VRML bajo la estructura mencionada.

2.5.3 ESPECIFICACIÓN DE OBJETOS EN OpenGL En este apartado, se describe la manera en cómo se pueden construir objetos 3D con el uso de las funciones de la biblioteca OpenGL. Las primitivas con las que OpenGL permite construir objetos más complejos, se tomaron como primitivas para construir objetos en GrafO3D, estás son: polígono, línea, caja sólida, caja en alambres, cilindro sólido, cilindro en alambres, cono sólido, cono en alambres, esfera sólida, esfera en alambres, tetraedro sólido, tetraedro en alambres, octaedro sólido, octaedro en alambres, icosaedro sólido, icosaedro en alambres, dodecaedro sólido, dodecaedro en alambres, dona sólida y dona en alambres. Entre las funciones que se utilizaron para la graficación de primitivas, se encuentran: glVertexXX(); glBegin()/glEnd en los modos GL_POLYGON, GL_LINES y GL_POINTS; funciones de transformación (traslación, rotación y escala) y funciones que permiten definir una cámara ortográfica o en perspectiva. Las funciones de las que se hizo uso en la etapa de implementación de GrafO3D, se detallan en la sección 3.4 del capítulo III. A continuación se describe cómo se lleva a cabo la especificación de objetos en la biblioteca para gráficos OpenGL. OpenGL es un grupo de rutinas en lenguaje “C”, las cuales pueden crear una representación visible de un ambiente tridimensional a partir de un grupo de comandos. OpenGL se basa en el concepto de la lista de despliegue, un grupo de llamadas a la biblioteca de OpenGL que se llevan a cabo cada vez que la imagen es presentada [Pesce96]. OpenGL define sus propios tipos de datos, los cuales se corresponden con los tipos de datos normales del lenguaje “C”, pero van antecedidos por el prefijo GL, algunos ejemplos son: GLbyte, GLshort, GLint, GLsizei, GLfloat, GLboolean, entre otros.


38

2.5.3.1 Primitivas para el dibujado Cuando se dibuja con OpenGL, lo que se hace es definir un volumen de visualización, y para dibujar objetos, las coordenadas no se indican en píxeles, ni en coordenadas físicas si no con lo que se denomina coordenadas posicionales en el volumen de visualización. Por lo tanto, para poder trabajar con OpenGL, después de crear la ventana de la aplicación, se debe definir la ventana de visualización o volumen de visualización donde se dibujarán los objetos geométricos, tomando como referencia coordenadas posicionales. Después de haber definido el área de visualización, se puede comenzar a dibujar objetos. Para dibujar objetos las funciones que se utilizan son las siguientes: a) glVertexXX() Se usa para especificar las coordenadas de un vértice. Se pueden definir vértices en dos y tres dimensiones, dependiendo del número de coordenadas que se pasen como parámetros a la función. Esta función puede tomar de dos a cuatro parámetros de cualquier tipo numérico (x, y, z, w), donde w es usado para propósitos de escala. El tipo especificado de coordenadas viene determinado a partir de los sufijos que siguen a la función glVertex (sufijo XX). El sufijo está formado por el número de coordenadas y el tipo de dato, éste último puede ser: d (double), indica que las coordenadas deben especificarse en valores double, f (float), i (integer) y finalmente s (short), por lo tanto las coordenadas deberán indicarse con valores que correspondan al sufijo. Existe la posibilidad de definir un punto mediante un vector que contenga las coordenadas, para ello se debe utilizar el sufijo v indicando que es un vector de coordenadas. A continuación se muestra un ejemplo de esta función, en la cual se le pasan tres parámetros de tipo flotante.

glVertex3f(0.5,0.0,0.0) b) glBegin(GLenum modo)

glEnd() Estas funciones se utilizan juntas, y permiten delimitar los vértices de la primitiva pasada como parámetro. El valor de modo indicará la primitiva a dibujar y podrá tomar distintos valores como puede ser: GL_POINTS (puntos), GL_LINES (líneas), GL_POLYGON (polígonos), entre otros.


39

Ejemplo en el que se dibujan líneas horizontales y verticales:

glBegin(GL_LINES); glVertex3f(-50, 0, i); glVertex3f(50, 0, i); glVertex3f(i, 0, -50); glVertex3f(i, 0, 50);

glEnd();

A continuación se describen algunos de los tipos de primitivas que pueden ser dibujadas con la instrucción glBegin(GLenum modo)/glEnd.

♦ Puntos La primitiva para dibujar puntos es GL_POINTS. Este es el parámetro que llevará la función glBegin() y posteriormente se indicarán los puntos mediante la función glVertex(). El tamaño de los puntos a dibujar se puede cambiar utilizando la función glPointSize(GLfloat tamaño).

♦ Líneas Para poder dibujar una línea hay que definir dos puntos en el área de visualización, por lo que, entre los comandos glBegin y glEnd hay que especificar al menos dos vértices con glVertex. Las primitivas disponibles para dibujar líneas son las siguientes, tabla 2.8.

Tabla 2.8 Primitivas de línea de OpenGL.

GL_LINES

Genera una serie de líneas que no se conectan entre sí. Las líneas se definen mediante los pares de puntos sucesivos, por lo tanto el número de vértices debe ser par, en el caso de que fuera impar se ignoraría.

GL_LINE_STRIP

Genera una serie de líneas que se conectan entre sí, es decir el punto final de una línea es el punto inicial de la siguiente. Con este modo se pueden generar figuras cerradas si el punto inicial coincide con el final.


40

GL_LINE_LOOP

Genera una serie de líneas conectadas entre sí, es parecido al modo anterior, pero aquí se conecta automáticamente el punto inicial con el punto final.

♦ Polígonos El dibujado de polígonos es la base de composición de objetos de OpenGL, con lo cual se pueden dibujar superficies sólidas. Para ello hay un conjunto de primitivas especificas, que son las mostradas en la tabla 2.9.

Tabla 2.9 Primitivas de polígonos de OpenGL.

GL_POLYGON

Genera un simple polígono relleno con los vértices especificados.

GL_TRIANGLES

Genera una serie de triángulos rellenos que no se conectan entre sí. El número de vértices debe ser múltiplo de 3, si el total de vértices es menor de tres, OpenGL ignora los vértices que no forma un triángulo.

GL_TRIANGLE_STRIP

Genera una serie de triángulos rellenos conectados entre sí, y dos de los vértices de un triángulo son los vértices del siguiente triángulo.

GL_TRIANGLE_FAN

Genera un conjunto de triángulos rellenos conectados entre sí, con la característica de que todos los triángulos tienen un vértice en común.


41

GL_QUADS

Genera un conjunto de cuadriláteros rellenos sin conectar entre ellos. El número de vértices que se requiere es múltiplo de cuatro, si no se verifica esto, entonces OpenGL ignora los vértices que sobran. Cada cuatro vértices se describe un cuadrilátero.

GL_QUAD_STRIP

Genera un conjunto de cuadriláteros rellenos que se conectan entre sí, es decir dos vértices de un cuadrado se utilizan para generar el siguiente cuadrilátero.

2.5.3.2 Transformaciones Las transformaciones hacen posible la proyección de coordenadas 3D sobre una pantalla 2D. Las transformaciones permiten también rotar objetos, moverlos, estirarlos, encogerlos y envolverlos. Más que modificar los objetos directamente, una transformación modifica el sistema de coordenadas. Una vez que la transformación rota el sistema de coordenadas, el objeto parece girado al dibujarse. Existen varios tipos de transformaciones: • Del observador: especifica la localización del observador o de la cámara. • Del modelado: mueve los objetos por la escena. Las transformaciones que

pueden ser aplicadas a los objetos son: traslación, donde el objeto se desplaza a lo largo de unos ejes dados; rotación, donde el objeto gira sobre uno de los ejes, y; escalado, donde se incrementan o disminuyen las dimensiones del objeto en una cantidad especificada. Ver figura 2.3.


42

Figura 2.3 Tipos de transformaciones.

Las funciones que permiten realizar estos tipos de transformaciones son:

glTranslated( GLdouble x, GLdouble y, GLdouble z ) glRotated ( Gldouble ángulo, GLdouble x, GLdouble y, GLdouble z ) glScaled ( GLdouble x, GLdouble y, GLdouble z )

• Del modelador: describe la dualidad de las transformaciones de modelado y

vista. Entre este tipo de transformación y la del modelado, no existe diferencia, por lo que es lo mismo que se mueva el objeto hacia arriba o que se desplace el eje de coordenadas hacia abajo.

• De la proyección: define y dimensiona el volumen de visualización. Existen

dos tipos: ortográfica y en perspectiva.

En una proyección ortográfica, todos los polígonos se dibujan en pantalla exactamente con las dimensiones relativas especificadas. Una proyección en perspectiva, muestra los objetos y la escena más semejantes a como deben aparecer en la vida real. Ver figura 2.4.

Figura 2.4 Tipos de proyección.


43

Las funciones que permiten definir estos tipos de proyección son: void glOrtho ( GLdouble izquierda, GLdouble derecha, GLdouble abajo, GL arriba, GLdouble cerca, GLdouble lejos ) gluPerpespective ( GLdouble ángulo, GLdouble aspecto, GLdouble zCerca, GLdouble zlejos)

• De la vista: escala la salida final a la ventana, es decir, es el mapeado de la

escena a coordenadas físicas de la ventana. La función que permite definir este tipo de transformación es:

gluLookAt ( GLdouble ojox, GLdouble ojoy, GLdouble ojoz, GLdouble centrox, GLdouble centroy, GLdouble centroz, GLdouble arribax, GLdouble arribay, GLdouble arribaz )

2.6 ESPECIFICACIÓN DE OBJETOS EN GrafO3D En base al análisis hecho al Lenguaje para el Modelado de Realidad Virtual (VRML) para conocer las primitivas sobre las cuales se construyen objetos más complejos, y las primitivas que ofrece OpenGL, se definieron las primitivas con las que cuenta la interfaz gráfica de GrafO3D para la creación de objetos (ver tabla 2.10). Cada una de estas primitivas cuenta con sus propios campos, los cuales pueden ser modificados por el usuario.

Tabla 2.10 Primitivas de GrafO3D.

PRIMITIVA CAMPOS PRIMITIVA CAMPOS PRIMITIVA CAMPOS

Línea

Punto 1 (x,y,z) Punto 2 (x,y,z)

Tetraedro sólido Radio

Cono en alambres

Radio Altura

Triángulo plano

Punto 1 (x,y,z) Punto 2 (x,y,z) Punto 3 (x,y,z)

Octaedro sólido

Radio

Esfera en alambres

Radio

Polígono plano

Punto 1 (x,y,z) Punto 2 (x,y,z) … Punto n (x,y,z)

Icosaedro sólido Radio

Tetraedro en alambres Radio

Caja sólida

Ancho Alto Profundidad

Dodecaedro sólido Radio

Octaedro en alambres Radio

Cilindro sólido

Radio Altura

Dona sólida

Radio Interior Radio Exterior

Icosaedro en alambres Radio

Cono sólido Radio

Altura Caja en alambres

Ancho Alto Profundidad

Dodecaedro en alambres

Radio

Esfera sólida Radio

Cilindro en alambres

Radio Altura

Dona en alambres

Radio Interior Radio Exterior


44

Una vez especificados los bloques básicos de construcción de los objetos, es necesario que el usuario pueda describir una escena mediante un archivo de texto, la cual incluya tanto los elementos que componen una escena de un mundo tridimensional como lo son cámara e iluminación, como las primitivas con sus campos propios y algunas características como lo son el color, posición, escala, rotación y textura. Para la definición de una escena a través de un archivo de texto, se creó la siguiente estructura:

#Grafo v10 PerspectiveCamera Camara1 { position 0.00 0.50 6.00 orientation 0.00 1.00 0.00 } Lighting Luz1 { LightPosition 4.00 4.00 4.00 0.00 LightAmbient 0.20 0.20 0.20 1.00 LightDiffuse 0.80 0.80 0.80 1.00 LightSpecular 1.00 1.00 1.00 1.00 } Separator Objeto1 { Transform Transform1 { translation 0.00 -0.50 -4.00 rotation 15.00 1.00 0.00 scale 1.00 1.00 1.00 } Material Material1 { ambientColor 0.80 0.80 0.20 1.00 diffuseColor 0.10 0.50 0.80 1.00 specularColor 1.00 1.00 1.00 1.00 emissiveColor 0.30 0.20 0.20 1.00 shininess 10.00 Texture C:\GrafO3D\texturas\Madera.bmp } Triangle Triangle1 { 0.00 0.00 2.00 0.50 0.50 2.00 1.00 0.00 2.002 } }

Encabezado

Definición de la cámara

Definición de la luz

Delimitador de objeto

Definición de las transformaciones

Definición del material

Definición de las primitivas con sus respectivos

campos


45

A continuación se detallan cada una de las partes que componen un archivo GrafO3D: ♦ Encabezado: indica que el archivo a leer es un archivo de GrafO3D, seguido de

la versión. ♦ Definición de la cámara: se define la posición y la orientación de la cámara que

contiene la escena. El tipo de cámara es una cámara en perspectiva y los parámetros son dados en las tres componentes x,y,z.

♦ Definición de la luz: se define la posición en x, y, z, w (donde w es cero e

indica la lejanía de la luz), y el color de la luz en sus componentes ambiente, difusa y especular en valores RGBA (Red, Green, Blue, Alpha, este último es usado cuando se trabaja con transparencias). Estos tipos de luz se definen a continuación:

Luz ambiente: es aquélla luz que no proviene de ninguna dirección en particular. Los objetos son igualmente luminosos en todas sus superficies y direcciones. Luz difusa: viene de una dirección particular pero es suavemente reflejada, la superficie del objeto es más brillante si la luz apunta directamente a la superficies que si la luz roza la superficies desde un ángulo. Luz especular: es una luz direccional y no se refleja en alguna dirección en particular.

♦ Delimitador de objeto: permite agrupar la escena por objetos, en ésta se

incluyen todas las primitivas que lo forman. ♦ Definición de las transformaciones: comprende la definición de la traslación

(unidades en x, y, z), rotación (grados en x, y, z) y la escala (unidades en x, y, z).

♦ Definición del material: comprende la definición del color de la primitiva en

sus componentes ambiente, difusa, especular y de emisión, brillo, y en caso de que tenga aplicada alguna textura, incluye la ruta del nombre del archivo que contiene la textura. El color está dado en valores RGBA y el nivel de brillo es un número entre 0 y 128. Las componentes del color se definen a continuación:

Ambiente: es el color de un material en una sombra. Difusa: es lo que en sí, da el color al objeto.


46

Especular: es parte de la contribución del brillo del objeto. Normalmente se usa el color blanco para reflejar el color de la luz. Emisión: representa la luz generada por un material. No es afectada por la luz.

♦ Definición de primitivas: comprende la definición de las primitivas que

componen al objeto descrito. Los campos de las primitivas depende del tipo. Ver tabla 2.10.

2.7 PERSISTENCIA Y RECUPERACIÓN DE OBJETOS Cuando el usuario describe una escena en un archivo de texto, la información debe ser almacenada en memoria para que pueda ser manipulada por el sistema y ser mostrada al usuario como modelos gráficos, de acuerdo a las modificaciones que el usuario realice a los modelos. Por otra parte, cuando el usuario crea una escena desde el entorno gráfico o modifica una ya existente, se debe mantener también la persistencia de esos modelos, lo cual se logra almacenando la información de los modelos y de la escena en un archivo de texto que pueda ser útil para una recuperación posterior. Para el manejo de la información en memoria, se diseñó una estructura de datos basada en la metodología orientada a objetos, usando el Lenguaje de Modelado Unificado (UML). UML es un lenguaje de modelado visual que se usa para especificar, visualizar, construir y documentar artefactos de un sistema de software. Se usa para entender, diseñar, configurar, mantener y controlar la información sobre los sistemas a construir [Booch00]. UML capta la información sobre la estructura estática y el comportamiento dinámico de un sistema. Dicha información es representada por medio de diagramas como son: diagramas de casos de uso, diagramas de clases, diagramas de paquetes, diagramas de secuencia, diagramas de colaboración, diagramas de estado, diagramas de actividad, diagramas de componentes y diagramas de disposición. Un sistema se modela como una colección de objetos discretos que interactúan para realizar un trabajo que finalmente beneficia a un usuario externo. Se creó el Diagrama de Paquetes de GrafO3D (figura 2.5), el cual está compuesto por un paquete que contiene las clases importadas de otras herramientas (figura 2.6), y otro que contiene las clases correspondientes a cada una de las primitivas definidas (figura 2.7, figura 2.8 y figura 2.9).


47

<unspecified>

grafo3d

grafo3d

Figura 2.5 Diagrama de paquetes de GrafO3D.

GLfloat StringGLint

BitSet ANTLR_USE_NAMESPACE

TLabel

TEdit TImage

TMainM...TMenuItem

TPopupMenu

TForm TShape

TGroupBox

TButton

TOpenDialog

TImageList TColorDialog

TSaveDia log

TDataModule

TUpDown

TCheckBox

TPanel

TToolBut...

TPageContro l

TTabSheet

TTreeView

TOpenGLPanel

TActionList TActionTToo lBarUINTIAVIFile

WAVEFORMATEX

IAVIStream

Figura 2.6 Clases contenidas en el paquete unspecified.


48

Figura 2.7 Clases contenidas en el paquete GrafO3D.


49

Figura 2.8 Clases contenidas en el paquete GrafO3D (continuación de la figura 2.7).


50

Figura 2.9 Clases contenidas en el paquete GrafO3D (continuación de la figura 2.7).

El paquete que contiene clases importadas de otras herramientas, corresponde a componentes de la herramienta de desarrollo de la aplicación, así como de archivos externos que son utilizados por GrafO3D para llevar a cabo algunas funciones. El diagrama de clases de GrafO3D está compuesto por una clase CObjects, a la cual están agregadas las clases abstractas ATorus, AVertex, Points, ABaseCyl, APolyhedron, AQuad, Triangle, Line.


51

Una clase abstracta se crea cuando las clases que heredan de ella, comparten las mismas características y aplican los mismos métodos, así, la clase base ATorus hereda a las clases WireTorus y SolidTorus debido a que tiene como característica en común el radio; ABaseCyl hereda a las clases Cylinder, Cone, WireCylinder y WireCone que están formadas por un radio y una altura; AQuad hereda a las clases WireBox y SolidBox que tiene como campos el alto, ancho y profundidad; y así, cada clase abstracta hereda a otras que corresponde a los tipos de primitivas que pertenecen a cada una de las clases base. En la figura 2.10 se pueden observar algunas relaciones de clases abstractas con las clases que representan las primitivas y que corresponden a una parte del diagrama de clases de la figura 2.7.

Figura 2.10 Relaciones de algunas clases abstractas con sus clases hijas.

Debido a que todas las primitivas tienen un material y transformaciones, se crearon las clases Material y Transform para almacenar las características de color, posición, textura, etc. Todas las clases abstractas heredan de estas dos clases. Las clases miLexer y miParser son las clases que contienen los métodos para efectuar el análisis léxico y sintáctico en el proceso de lectura del archivo de texto de GrafO3D, en el cual se recupera la información contenida en el archivo y se van creando los objetos correspondientes a la escena. Las clases aisladas corresponden a clases externas a GrafO3D.


52

2.8 MANIPULACIÓN DE OBJETOS Una vez que se han especificado y creado los modelos, debe existir la posibilidad de manipularlos, para lo cual se diseñó una interfaz gráfica que permita al usuario modificar las características de los objetos de una manera más fácil. Este diseño se hizo en base al análisis de los entornos de graficación vistos en el capítulo I, en el cual se señalan las partes principales que componen a una herramienta de este tipo. La interfaz de GrafO3D contempla las siguientes características: • Tipos de vistas: GrafO3D cuenta con tres vistas ortogonales y una en

perspectiva para que el usuario observe desde diferentes ángulos los modelos creados en la escena. Estos modelos son presentados en el inspector de objetos que contiene los objetos y primitivas. Para la agregación de una primitiva se presenta un panel con todas las primitivas posibles para que el usuario pueda seleccionar la deseada. Además se incluyen controles para la manipulación de la cámara, la iluminación, el piso y los ejes.

• Creación de nuevos modelos: el usuario podrá crear o agregar nuevos modelos

en la escena. Podrá crear objetos nuevos que estarán formados por primitivas que el usuario desee.

• Cambio de propiedades: el usuario podrá ver las propiedades tanto del objeto

completo como de cada una de las primitivas que lo componen, de tal manera que puedan ser modificadas.

• Aplicación de funciones de graficación: la manipulación de los modelos será a

través de funciones tanto básicas como avanzadas de graficación, como lo son: cambio de color, cambio de posición, cambio de escala, movimiento de la cámara, modificación de la iluminación, aplicación de textura, generación de animación, entre otras.

Estas características se pueden observar en la figura 2.11.


53

Figura 2.11 Diseño de la interfaz de usuario de GrafO3D.

2.9 PROCESOS PARA TRATAR ARCHIVOS PRODUCIDOS POR OTRAS HERRAMIENTAS

Dentro del grupo de Visión Artificial del cenidet, se desarrolló una herramienta para el modelado automático de objetos alfaflexibles [Orbe03], la cual trabaja sobre un archivo de video y contribuye con una metodología para generar u obtener de manera automática una buena descripción o caracterización del objeto deseado, obteniendo los cambios que presenta el objeto durante el movimiento del mismo en cada imagen de la secuencia. La información arrojada por esta herramienta, es un archivo de texto con los siguientes datos:

• Cuatro valores más sobresalientes de R (Red) • Cuatro valores más sobresalientes de G (Green) • Cuatro valores más sobresalientes de B (Blue) • Centro de gravedad de x • Centro de gravedad de y • Valor del área del objeto modelado

Debido a que la información resultante es en forma textual, surge la necesidad de contar con un procedimiento que permita generar el modelo gráfico que se está describiendo en ese archivo de texto para observar el objeto y su comportamiento.

Inspector de objetos

Panel de primitivas

Controles para la cámara,

iluminación, pisos y ejes

Vistas ortogonales

Vista en perspectiva


54

Para llevar a cabo lo anterior, se construyó la estructura de un archivo de texto que permita describir el tipo de objeto que se está modelando, esto es, un objeto está formado por varios puntos (x,y) que en conjunto dan la forma o contorno del objeto. Esta información es proporcionada por cada cuadro de la secuencia de imágenes para que se describa el comportamiento que tiene el objeto en un lapso de tiempo. Cabe mencionar, que el archivo generado directamente por dicha herramienta, debe pasar primeramente por un proceso de traducción para obtener la siguiente estructura:

2.10 CONCLUSIONES En este capítulo se presentaron las partes principales que componen una escena dentro de un entorno 3D, como lo es la iluminación y la presencia de una cámara, las cuales fueron incluidas en la definición de una escena en GrafO3D. Además se presentó la estructura bajo la cual se construye un archivo de texto de GrafO3D. Para definir esta estructura, se tomó como referencia el estándar VRML, además sirvió como apoyo para la definición de primitivas de GrafO3D, junto con la biblioteca para gráficos OpenGL. Se presentó la forma en cómo se lleva a cabo la persistencia y recuperación de los objetos, tanto en memoria como en disco; la interfaz gráfica en la cual se manipulan los modelos, y; el tratamiento de información generada por herramientas externas a GrafO3D.

8 7 x1 y1 x2 y2 x3 y3 x4 y4 0.0 1.0 0.1 1.2 0.3 1.3 0.5 1.3 5 0.7 1.37 0.9 1.35 1.0 1.33 1.1 1.3 1.3 1.29 1.5 1.31 1.7 1.33 1.9 1.35 2.0 1.37 2.1 1.35 2.3 1.3 2.5 1.2 2.7 1.0 2.5 0.9 2.3 0.87 2.1 0.85 2.0 0.83 1.9 0.81 1.7 0.83 1.5 0.85 1.3 0.87 1.1 0.89 1.0 0.91 2.0

Número de características

(columnas)

Número de cuadros de la

secuencia (filas)

Descripción del objeto por cada

cuadro de la secuencia

Encabezados de columnas

Entorno de graficación y generación de modelos 2D y 3D para aplicaciones de Visión Artificial Capítulo III. Implementación

55

CAPÍTULO III

IMPLEMENTACIÓN

CONTENIDO:

Introducción Especificación de objetos en GrafO3D Persistencia y recuperación de objetos Manipulación de objetos Procesos para tratar archivos producidos por otras herramientas Conclusiones

3

4 Cap3


56

3.1 INTRODUCCIÓN En este capítulo se presentan las etapas de implementación de cada una de las partes contempladas en la etapa de análisis y diseño de GrafO3D. La implementación de GrafO3D se hizo en el lenguaje C++ Builder 5.0, aplicando funciones de la biblioteca para gráficos OpenGL.

3.2 ESPECIFICACIÓN DE OBJETOS EN GrafO3D Al hablar de la creación de una estructura textual para definir modelos a través de un archivo de texto, se está hablando de la creación de un lenguaje, es decir, un conjunto de oraciones con una estructura bien definida, cuyos elementos principales son un conjunto finito de símbolos (alfabeto) y un cojunto de cadenas o secuencias finitas de elementos de ese alfabeto. El lenguaje usado en GrafO3D está compuesto por una serie de elementos que corresponden a la sintaxis con la cual se construye un archivo de texto. Al momento en que GrafO3D recibe como entrada un archivo de este tipo, se debe llevar a cabo un proceso de interpretación de esa información a instrucciones que puedan ser entendidas por el lenguaje de implementación (C++). Este proceso se lleva a cabo con la construcción de un intérprete, que es un programa que tiene por entrada un programa escrito en lenguaje fuente (alto nivel) y como salida, ejecuta las acciones indicadas por ese lenguaje fuente [Compiladores03]. El funcionamiento de un intérprete se hace a través de tres tipos de análisis: ♦ Analisis lexicográfico: el primer paso para comprender una oración es el

reconocimiento de palabras, que son la unidad más pequeña después de las letras. Explora en forma secuencial el programa fuente y separa los caracteres en grupos para obtener los elementos básicos o muestras (tokens). Se obtienen los tokens que utilizará el analizador sintáctico.

♦ Análisis sintáctico: una vez que las palabras son comprendidas, el segundo

paso es entender la estructura de la oración. Recibe la secuencia de tokens del analizador léxico y analiza su estructura sintáctica.

♦ Análisis semántico: una vez que se entiende la estructura de la oración, el

tercer paso es comprender el significado, es decir, verifica el significado de la oración con respecto a las reglas semánticas del lenguaje.


57

Para llevar a cabo este proceso de interpretación en los archivos GrafO3D, y validar que la estructura del archivo proporcionada es la correcta, se desarrolló una gramática, cuyo objetivo es definir las secuencias de símbolos válidos de un lenguaje, es decir, definir si una oración pertenece o no al lenguaje. Como definición general, se puede decir que una gramática tiene por objeto el estudio de la forma y composición de las palabras (morfología), así como de su interrelación dentro de la oración o de la frase (sintaxis) [Zamora04]. Esta gramática fue creada con las especificaciones de ANTLR 2.7.2 (Another Tool for Language Recognition), que es una herramienta de lenguaje que proporciona un marco de trabajo para la construcción de reconocedores, compiladores y traductores desde descripciones gramaticales que están contenidas en acciones de lenguaje Java, C++, C# [Antlr03]. Las partes principales para construir una gramática en ANTLR se puntualizan a continuación. Los ejemplos mostrados corresponden al archivo de la gramática generada para GrafO3D: ♦ Encabezado: la sección de encabezado contiene el código fuente (en C++ o

Java) que se desea poner antes del código generado por ANTLR como salida del parser. Esto es principalmente útil para salidas en C++, debido a que tiene como requerimiento que los elementos sean declarados antes de ser referenciados. En Java, esto puede ser usado para especificar un paquete para el código resultante del parser y cualquier clase importada. Ejemplo:

header "post_include_hpp" { #include <string> #include <iostream> #include <vector.h> #include "CObjects.h" #include "PerspectiveCamera.hpp" #include "Light.hpp" }

La sección de encabezado es la primera sección en el archivo de la gramática de ANTLR.


58

♦ Definición de la clase parser: todas las reglas del parser deben ser asociadas con una clase parser7. Un archivo de gramática (*.g) puede contener un número arbitrario de definiciones de clases parser junto con clases lexer7. Cada especificación de la clase parser precede las opciones y las definiciones de reglas del parser. Ejemplo:

class miParser extends Parser; options { k=2; genHashLines = off; importVocab=Tiny; defaultErrorHandler = false; } tokens { /* ver anexo H */ } parser rules { /* ver anexo H */ }

♦ Definiciones de la clase del analizador léxico: de una clase parser resultan

objetos parser que conocen cómo aplicar la estructura gramática asociada a un flujo de entrada de tokens. Para realizar el anális léxico, se necesita especificar la clase lexer que describe cómo separar el flujo de caracteres de entrada en un flujo de tokens. Ejemplo:

class miLexer extends Lexer; options { k=2; exportVocab=Tiny; charVocabulary = '\3'..'\377'; defaultErrorHandler = false; } tokens { /* ver anexo G */ } lexer rules { /* ver anexo G */ }



59

♦ Definiciones de reglas: la estructura de un flujo de entrada de átomos (elemento del flujo de entrada: token) se especifica por un conjunto de reglas mutuamente referenciables. Toda regla tiene un nombre, un conjunto de argumentos opcionales, la cláusula “throws” opcional [Antlr03], una acción inicial opcional, un valor de retorno opcional y una alternativa o alternativas. Cada alternativa contiene una serie de elementos que especifican qué hacer y dónde. Ejemplo:

objeto: { String auxiliar; } TK_Separator { vobje = new CObjects(); indexprimitivas = 0; band_mat = 0; band_transf = 0; } a: ID { auxiliar = a->getText().c_str(); vobje->Setname(auxiliar); } CURLYL (sentencia)* { CObjectsList.push_back(*vobje); } CURLYR ;

El código entre los caracteres “{“ “}”, después o antes de un token, se ejecuta al momento que el token es analizado. Para almacenar el valor de un token analizado, se utilizan variables permitidas en ANTLR; estas variables anteceden al token deseado, por ejemplo, en la línea 9 del código anterior, se almacena el valor del identificador leído en la variable ‘a’, para después convertir ese valor a una cadena de caracteres almacenada en la variable ‘auxiliar’ declarada al inicio de la regla ‘objeto’.


60

Los símbolos que pueden ser utilizados en las definiciones de reglas, se muestran en la tabla 3.1:

Tabla 3.1 Símbolos para la definición de reglas en una gramática ANTLR.

SÍMBOLO DESCRIPCIÓN

(...) subregla

(...)* subregla cero o más

(...)+ subregla positiva una o más

(...)? opcional cero o una

{...} acción semántica

| operador de alternativa

.. operador de rango

~ operador de negación

= operador de asignación

: operador de etiqueta, inicio de regla

; fin de regla

3.3 PERSISTENCIA Y RECUPERACIÓN DE OBJETOS Durante todo el proceso de creación de una escena en GrafO3D, lo ideal es que se mantenga la persistencia de los modelos, lo que significa que se pueden guardar en disco cuando termina el programa y se pueden reestablecer cuando se vuelva a iniciar el mismo. La recuperación se realiza a partir de que el archivo de texto es leído, es decir, cuando se lleva a cabo el parseo (ver sección 3.2). Al hacer el análisis de la información contenida en el archivo, la información es almacenada en la estructura de datos mostrada en el diagrama de clases del capítulo II, sección 2.7. En el momento en que se encuentra el token de la declaración de la cámara, se crea un objeto de tipo PerspectiveCamera y se almacenan los datos correspondientes; para la iluminación, el objeto es de tipo Light, y para los objetos, se crea un objeto de la clase CObjects, que almacena las características propias de los objetos. El objeto creado CObjects, contiene una lista de todas las primitivas que lo forman. La creación de los objetos correspondientes a dichas primitivas, se lleva a cabo en el momento que se encuentra su declaración en el archivo de texto, junto con la creación de los objetos de tipo Material y Transform que almacenan el material y las transformaciones de cada primitiva. Este proceso se esquematiza en la figura 3.1.


61

#Grafo v10

PerspectiveCamera Camara1{

posit ion 0.00 0.50 6.00orientation 0.00 1.00 0.00

}Light ing Luz1{

LightPosit ion 4.00 4.00 4.00 0.00LightAmbient 0.20 0.20 0.20 1.00LightDif fuse 0.80 0.80 0.80 1.00LightSpecular 1.00 1.00 1.00 1.00

}Separator Objeto1{

Transform Transform1{

translation 0.00 -0.50 -4.00rotation 15.00 1.00 0.00scale 1.00 1.00 1.00

}Material Material1{

ambientColor 0.80 0.80 0.20 1.00diffuseColor 0.10 0.50 0.80 1.00specularColor 1.00 1.00 1.00 1.00emissiveColor 0.30 0.20 0.20 1.00shininess 10.00Texture

C:\GrafO3D\texturas\Madera.bmp}SolidSphere{

radius 1.0}

}

Archivo de texto Memoria

Camara1: Perspect iveCamera

posit ion[] = { 0.00,0.50,6.00}orientation[] = { 0.00,1.00,0.00} Luz1: Light

posit ion[] = { 4.00,4.00,4.00,0.00}ambient[] = { 0.20,0.20,0.20,1.00}diffuse[] = { 0.80,0.80,0.80,1.00}specular[] = { 1.00,1.00,1.00,1.00}

CObjects

Objeto1

Lista de objetos

Objeto1

Sphere

Lista de primit ivas

#Grafo v10

PerspectiveCamera Camara1{

posit ion 0.00 0.50 6.00orientation 0.00 1.00 0.00

}Light ing Luz1{

LightPosit ion 4.00 4.00 4.00 0.00LightAmbient 0.20 0.20 0.20 1.00LightDif fuse 0.80 0.80 0.80 1.00LightSpecular 1.00 1.00 1.00 1.00

}Separator Objeto1{

Transform Transform1{

translation 0.00 -0.50 -4.00rotation 15.00 1.00 0.00scale 1.00 1.00 1.00

}Material Material1{

ambientColor 0.80 0.80 0.20 1.00diffuseColor 0.10 0.50 0.80 1.00specularColor 1.00 1.00 1.00 1.00emissiveColor 0.30 0.20 0.20 1.00shininess 10.00Texture

C:\GrafO3D\texturas\Madera.bmp}SolidSphere{

radius 1.0}

}

Archivo de texto Memoria

Camara1: Perspect iveCamera

posit ion[] = { 0.00,0.50,6.00}orientation[] = { 0.00,1.00,0.00} Luz1: Light

posit ion[] = { 4.00,4.00,4.00,0.00}ambient[] = { 0.20,0.20,0.20,1.00}diffuse[] = { 0.80,0.80,0.80,1.00}specular[] = { 1.00,1.00,1.00,1.00}

CObjects

Objeto1

Lista de objetos

Objeto1

Sphere

Lista de primit ivas

Figura 3.1 Proceso para el almacenamiento de los modelos en memoria.

Como se puede observar en la figura 3.1, en el almacenamiento en memoria, se tiene una lista de primitivas por cada objeto, que a su vez, están contenidos también en una lista. Estas listas son utilizadas en todo el proceso de ejecución del programa para aplicar las modificaciones que hace el usuario al manipular los modelos. Por otra parte, cuando el usuario ha creado una escena, la persistencia de esta información se hace con el almacenamiento de la misma en un archivo de texto, para lo cual, se implementaron funciones para la escritura del archivo con la información almacenada en la estructura de clases.


62

En esta parte de la implementación, se hizo uso de las funciones del lenguaje C++ que se presentan en la tabla 3.2.

Tabla 3.2 Funciones de C++ utilizadas para la creación del archivo de texto.

SÍMBOLO DESCRIPCIÓN

FileCreate (nombre_archivo )

Crea un nuevo archivo con el nombre especificado.

FileWrite (archivo, *buffer, contador)

Escribe el contenido de un buffer a la posición actual del archivo. Escribe el número de bytes indicado por contador en el archivo especificado con la variable archivo del buffer especificado en buffer.

Para llevar a cabo la escritura del archivo de texto, se escribe primeramente el encabezado, posteriormente se toma la información almacenada en el objeto correspondiente a la cámara y a la luz para continuar con la escritura de la definición de los objetos. Esto último se logra recorriendo la lista de objetos en forma secuencial. Por cada objeto se recorre su propia lista de primitivas, igualmente en forma secuencial, para escribir en el archivo tanto los parámetros de cada primitiva como su material y sus transformaciones.

3.4 MANIPULACIÓN DE OBJETOS La manipulación de los objetos se hace a través de la interfaz gráfica de GrafO3D, la cual está diseñada para que el usuario pueda realizar las siguientes funciones: ♦ Cuenta con un menú principal y una barra de herramientas (ver figura 3.2)

que permiten al usuario crear una nueva escena, abrir un archivo GrafO3D, abrir un archivo de texto especificando los puntos del objeto o guardar una escena, además de permitir la creación de objetos y primitivas, habilitar/deshabilitar la luz, y la visualización de los modelos en estructura de alambres, sólidos o vértices.

Menú de opciones

Barra de herramientas

Menú de opciones

Barra de herramientas

Figura 3.2 Menú de opciones y barra de herramientas del entorno gráfico de GrafO3D.


63

En esta etapa de la implementación, se utilizaron los componentes de C++ Builder que se muestran en la tabla 3.3 y las instrucciones OpenGL de la tabla 3.4.

Tabla 3.3 Componentes de C++ Builder.

COMPONENTE DESCRIPCIÓN

TMainMenu Encapsula una barra de menú y sus menús drop-down que lo acompañen para una forma.

TToolBar Contenedor para botones de herramienta.

TOpenDialog Despliega un diálogo de selección de archivo

TSaveDialog Despliega un diálogo “Guardar como” para guardar archivos.

Tabla 3.4 Instrucciones OpenGL.

INSTRUCCIÓN DESCRIPCIÓN

glEnable ( GL_LIGHTING ) glDisable ( GL_LIGHTING )

Activa / Desactiva la iluminación.

glPolygonMode( modo ) modo: GL_FRONT_AND_BACK,GL_FILL GL_FRONT_AND_BACK,GL_LINE GL_FRONT_AND_BACK,GL_POINT

Selecciona un modo de visualización de los poligonos: sólidos, líneas, puntos (vértices).

♦ El usuario puede modificar las propiedades tanto de los objetos como de las

primitivas por medio de un editor de propiedades, en el cual se pueden cambiar: el nombre, color, posición, rotación, escala y los parámetros propios del objeto o primitiva. Las pantallas se muestran en la figura 3.3.

Figura 3.3 Editores de propiedades del entorno gráfico de GrafO3D.


64

En esta parte de la implementación, se utilizaron los componentes de C++ Builder que se muestran en la tabla 3.5 y las instrucciones OpenGL de la tabla 3.6.



TEdit Control de edición de una sola línea.

TButton Control de botón pulsable.

TLabel Control para desplegar texto en una forma.

TColorDialog Despliega un diálogo modal de selección de color.



glRotatef ( ángulo, x, y, z ) Rota la matriz actual con una matriz de rotación. Parámetros: ángulo de rotación en grados; vector de dirección desde el origen empleado como eje de rotación.

glScalef ( x, y, z ) Multiplica la matriz actual por la matriz de escala. Parámetros: factores de escala a lo largo de los ejes x, y, z.

glTranslatef ( x, y, z ) Multiplica la matriz actual por una matriz de traslación. Parámetros: coordenadas x, y, z del vector de traslación.

glColor4f ( rojo, verde, azul, alpha ) Ajusta el color actual de dibujo. El color está especificado en las componentes RGBA.

glMaterialfv ( cara, pnombre, *params ) cara: GL_FRONT, GL_BACK, GL_FRONT_AND_BACK pnombre: GL_EMISSION, GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_SHININESS

Se usa para seleccionar las propiedades reflectivas de los materiales de los polígonos. Parámetros: cara del polígono; parámetro de material; matriz de valores de coma flotante o enteros que contienen las componentes de la propiedad que se define.

glGenTextures ( índice, elemento del arreglo de texturas )

Genera una única referencia de textura para el índice indicado del arreglo de textura.

glBindTexture ( objetivo, elemento del arreglo de texturas ) objetivo: GL_TEXTURE_1D GL_TEXTURE_2D

Fija la textura actual que está siendo mapeada.

glTexParameteri ( objetivo, pnombre, param ) objetivo: GL_TEXTURE_1D GL_TEXTURE_2D pnombre: GL_TEXTURE_WRAP_S GL_TEXTURE_WRAP_T

Define los parámetros de filtro y repetición de textura. Parámetros: parámetro de textura seleccionado; nombre del método y filtro de la textura; tipo de aplicación de la textura.


65

GL_TEXTURE_MIN_FILTER GL_TEXTURE_MAG_FILTER param: GL_REPEAT GL_LINEAR_MIPMAP_NEAREST GL_LINEAR_MIPMAP_LINEAR

♦ Cambio de perspectiva (cámara), ocultar/mostrar piso y ejes y realizar

modificaciones de las propiedades de la luz, tales como: nombre, color y posición. Véase figura 3.4.

Figura 3.4 Controles para la manipulación de la cámara, luz, piso y ejes del entorno gráfico de

GrafO3D.

Para permitir la manipulación de los controles vistos en la figura 3.4, se utilizaron los componentes de C++ Builder que se muestran en la tabla 3.7 y las instrucciones OpenGL de la tabla 3.8.




TButton Control de botón pulsable.


TColorDialog Despliega un diálogo modal de selección de color.

TUpDown Control arriba-abajo. Permite cambiar el tamaño de un valor numérico haciendo clic en los botones de las flechas.

TCheckBox Control que presenta una opción al usuario para seleccionarla o quitarla.


66



glLightfv ( luz, pnombre, *params ) luz: GL_LIGHT0 – GL-LIGHT7 pnombre: GL_AMBIENT GL_DIFFUSE GL_SPECULAR GL_POSITION

Selecciona los parámetros de una de las 8 fuentes de luz disponibles. Parámetros: tipo de fuente de luz; parámetro de iluminación; matriz de valores de los parámetros especificados.

glLightModelf ( pnombre, param ) pnombre: GL_LIGHT_MODEL_TWO_SIDE param: 1.0

Define los parámetros del modelo de iluminación utilizado por OpenGL. Parámetros: parámetro del modelo de iluminación; número de caras incluidas en los cálculos de iluminación (0.0 = parte frontal, otro valor = ambas caras)

glNormal3fv ( *v ) Define una normal a la superficie para el próximo vértice o grupo de vértices especificados. Parámetros: matriz de tres elementos que contiene las magnitudes x, y, z del vector normal.

gluLookAt ( ojox, ojoy, ojoz, centrox, centroy, centroz, arribax, arribay, arribaz )

Define una transformación de visualización. Parámetros: coordenadas x, y, z del punto de vista; coordenadas x, y, z de la escena a la que se está observando; coordenadas x, y, z del vector de dirección ascendente.

♦ Generación de animación: existe la posibilidad de generar un archivo de

animación de tres formas diferentes:

Figura 3.5 Pantalla de propiedades de la animación,

opción: captura independiente de frames.

Generación de animación a través de la captura independiente de los frames. Esta captura se realiza cuando el usuario hace un cambio en el objeto y desea que esa imagen forma parte de la secuencia. Una vez que los frames son capturados, el usuario puede modificar, desde la pantalla de propiedades de la animación, el orden de los frames, el nombre del archivo resultante con la secuencia y el tiempo de espera entre cada frame. Ver figura 3.5.


67

Figura 3.6 Pantalla de generación de animación

con movimiento de traslación, rotación o escala.

Figura 3.7 Pantalla de generación de animación

con movimiento de traslación.

El cálculo de los puntos intermedios, en este tipo de animación, se hizo en base a la ecuación de la recta (ver eq. 3.1), haciendo el despeje de la variable de la cual se desea obtener el nuevo valor y tomando como base el valor de la variable conocida. Este proceso se hizo para los tres ejes (x, y, z).

( )112

121 xx

xxyyyy −

−−

=− (Eq. 3.1)

Generación de animación a través de la selección de uno de los tres tipos de movimientos (traslación, rotación, escala) y la especificación del número de veces y las unidades del movimiento, número de repeticiones de la secuencia, nombre del archivo resultante con la secuencia y el tiempo de espera entre cada frame. Ver figura 3.6.

Generación de animación a través de la función de transformación de traslación. En esta ventana se especifican: el nombre del archivo resultante con la secuencia, el tiempo de espera entre cada frame, el número de repeticiones de la secuencia y los puntos (x,y,z) por los que será trasladado el objeto. El usuario puede proporcionar el conjunto de puntos mencionado, o simplemente el punto de inicio y el punto final del movimiento para que se generen automáticamente n puntos intermedios. El valor de n es dado por el usuario. Ver figura 3.7.


68

Para la creación de un archivo AVI, se agregó al proyecto la biblioteca de funciones avi_utils.h [Avi04], que hace uso de la biblioteca de windows vfw.h (video for windows).

Además, se hicieron uso de los componentes de C++ Builder de la tabla 3.9 y de las instrucciones de OpenGL de la tabla 3.10.





TListBox Despliega una lista de ítems que el usuario puede seleccionar, agregar o eliminar.

TImage Despliega una imagen gráfica.

TRadioButton Presenta un conjunto de opciones mutuamente exclusivas.

TStringGrid Presenta datos textuales en una forma tabular.

TCheckBox Control que presenta una opción al usuario para seleccionarla o quitarla.


En la tabla 3.11, se muestran otras funciones de OpenGL utilizadas en el desarrollo de GrafO3D.

Tabla 3.11 Otras instrucciones OpenGL.


glViewport ( x,y,ancho,alto ) Define la región dentro de una ventana empleada para mapear las coordenadas del volumen de trabajo sobre coordenadas físicas de ventana. Parámetros: número de píxeles desde la parte izquierda de la ventana en donde empieza la vista; número de píxeles desde la parte inferior de la ventana en donde empieza la vista; ancho en píxeles de la vista; alto en píxeles de la vista.

glMatrixMode ( modo ) modo: GL_MODELVIEW GL_PROJECTION GL_TEXTURE

Especifica qué pila de matrices se usará con las operaciones de matrices.

gluPerspective ( ángulo, aspecto, zcerca, zlejos )

Define una matriz de proyección en perspectiva. Parámetros: campo de visión en grados en la


glRotatef ( ángulo, x, y, z ) glScalef ( x, y, z ) glTranslatef ( x, y, z )

Ver tabla 3.5. Los valores proporcionados en las ventanas, son pasados como parámetros a estas funciones.


69

dirección y; relación de aspecto, campo de visión en la dirección x (x/y); distancia desde el observador a los planos de trabajo próximo y lejano.

glLoadIdentity () Reinicia el sistema de coordenadas a coordenadas oculares. Reemplaza la matriz de transformación actual con la matriz identidad.

glClearColor (rojo, verde, azul, alfa) Especifica el color de limpiado para los buffers de color.

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

Limpia un buffer en particular o una combinación de buffers

glPopMatrix() Saca la última matriz de la pila de matrices actual.

glPushMatrix() Coloca la matriz actual en la pila de matrices actual.

glBegin(modo) glEnd() modo: GL_LINES GL_TRIANGLE GL_QUADS GL_POLYGON GL_TRIANGLE_STRIP

Funciones que delimitan los vértices de una primitiva.

auxWireBox ( ancho, alto, profundidad )

Dibuja una caja alámbrica.

auxWireSphere (radio) Dibuja una esfera alámbrica.

auxWireCylinder (radio,alto) Dibuja un cilindro alámbrico.

auxWireCone (radio,alto) Dibuja un cono alámbrico.

auxWireTetrahedron (radio) Dibuja un tetraedro alámbrico.

auxWireTorus (radio_interior, radio_ exterior)

Dibuja una dona alámbrica.

auxWireOctahedron (radio) Dibuja un octaedro alámbrico.

auxWireIcosahedron (radio) Dibuja un icosaedro alámbrico.

auxWireDodecahedron (radio) Dibuja un dodecaedro alámbrico.

gluCylinder (GLUquadricObj *obj,radio_inferior, radio_superior, altura, segmentos,pilas)

Dibuja un cilindro cuádrico. Parámetros: objeto tipo Cuárico; radio de la base del cilindro; radio de la tapa del cilindro; altura o longitud del cilindro a lo largo del eje z; número de caras del cilindro; número de segmentos del cilindro a lo largo del eje z.

gluSphere (GLUquadricObj *obj, radio, segmentos, pilas)

Dibuja una esfera cuádrica. Parámetros: objeto tipo cuádrico; radio; número de líneas de longitud en la esfera; número de líneas de latitud en la esfera.


70

3.5 PROCESOS PARA TRATAR ARCHIVOS PRODUCIDOS POR OTRAS HERRAMIENTAS

Para que GrafO3D pueda leer un archivo generado por otra herramienta, se creó la estructura del archivo de texto vista en el capítulo II, sección 2.9, el cual comprende la descripción del objeto en términos de los puntos (x,y) que lo forman. Cada línea del archivo corresponde a un frame de la secuencia del movimiento que presenta un objeto descrito por pares de puntos (x,y) que describen su contorno. Esta información es analizada por GrafO3D de tal forma que al abrir (importar) un archivo de este tipo, se crea un objeto de tipo CObjects que va a contener como única primitiva un polígono (objeto de tipo Points), cuyos puntos serán los valores tomados del archivo y contendrá los últimos valores del último frame de la secuencia descrita. Como resultado, GrafO3D presenta el modelo gráfico del objeto con los últimos valores y genera el archivo de animación correspondiente de acuerdo al número de frames (líneas del archivo) que se especifiquen. La herramienta tomada como referencia fue la herramienta para el modelado automático de objetos alfaflexibles [Orbe03]. Cabe mencionar, que para obtener la estructura mencionada, el archivo resultante de la Herramienta de modelado debe pasar antes por un proceso de traducción, como se muestra en la figura 3.8.

Herramienta para el modelado

de objetos alfaflexibles

Traductor


especif icación de puntos (x,y)

Herramienta para el modelado

de objetos alfaflexibles

Traductor


especif icación de puntos (x,y)

Figura 3.8 Proceso para tratar archivos generados por la herramienta para el modelado

automático de objetos alfaflexibles.

El almacenamiento de la escena creada a partir de la lectura del archivo importado, se hace bajo la estructura de un archivo de texto de GrafO3D.


71

3.6 CONCLUSIONES Se presentaron los detalles de implementación para la generación de la gramática, la cual se desarrolló en base a las especificaciones de ANTLR, y la forma en cómo la información leída en el proceso de parseo, es almacenada en memoria en la estructura de clases definida. Además, se presentaron las pantallas que permiten visualizar la forma en cómo se manipulan los modelos desde la interfaz gráfica, tanto para modificar las propiedades de los objetos, como para la generación de animación y, finalmente, se presenta la implementación del módulo para llevar a cabo el tratamiento de archivos producidos por herramientas externas a GrafO3D.

Entorno de graficación y generación de modelos 2D y 3D para aplicaciones de Visión Artificial Capítulo IV. Pruebas y resultados

72

CAPÍTULO IV

PRUEBAS Y RESULTADOS

CONTENIDO:

Introducción Especificación de los casos de prueba Especificación del procedimiento de prueba

Caso de prueba 1: lectura de un archivo GrafO3D Caso de prueba 2: aplicación de funciones de graficación Caso de prueba 3: visualización de los modelos: modelos sólidos, en alambre y en vértices Caso de prueba 4: generación de animación Caso de prueba 5: lectura de un archivo de texto conformado por puntos (x,y)

Conclusiones

4 Cap4


73

4.1 INTRODUCCIÓN En este capítulo se presentan los casos de prueba realizados para verificar tanto el cumplimiento del objetivo general del tema de tesis, como la funcionalidad del sistema. La especificación de los casos de prueba y la especificación del procedimiento de las pruebas, se documentan de acuerdo a los puntos marcados en el estándar para la documentación de pruebas de software del IEEE 829.

4.2 ESPECIFICACIÓN DE CASOS DE PRUEBA • Especificación del caso de prueba 4.2.1

a) Artículos de prueba: se iniciará una nueva escena en GrafO3D y se leerá un archivo de texto.

b) Especificaciones de entrada: el usuario podrá utilizar el ratón para ejecutar las acciones de crear una nueva escena y de abrir un archivo GrafO3D.

c) Especificaciones de salida: los datos leídos del archivo de texto serán mostrados al usuario como modelos gráficos.

d) Dependencias entre casos: este caso de prueba no depende de otro ya que es el inicio de una nueva escena.

• Especificación del caso de prueba 4.2.2

a) Artículos de prueba: se aplicarán funciones de graficación a los modelos creados en la escena.

b) Especificaciones de entrada: el usuario podrá utilizar el ratón para ejecutar las acciones que permiten manipular los modelos.

c) Especificaciones de salida: los cambios hechos a los modelos, serán presentados automáticamente en pantalla al usuario.

d) Dependencias entre casos: si el usuario desea modificar una escena descrita en un archivo de texto, debe iniciar el caso de prueba 4.2.1, de lo contrario, no existe dependencia entre casos, ya que sería el inicio de una nueva escena.


a) Artículos de prueba: se visualizarán los modelos de la escena, en modelos sólidos, de alambre y en vértices.

b) Especificaciones de entrada: el usuario podrá utilizar el ratón para ejecutar las acciones que permiten cambiar de un tipo de visualización a otro.

c) Especificaciones de salida: las acciones ejecutadas por el usuario, serán presentadas automáticamente en pantalla.


74

d) Dependencias entre casos: si el usuario desea cambiar el modo de visualización de los modelos de una escena descrita en un archivo de texto, debe iniciar el caso de prueba 4.2.1, de lo contrario, no existe dependencia entre casos, ya que sería a partir de la creación de una nueva escena.


a) Artículos de prueba: se aplicará animación a los modelos creados en la escena.

b) Especificaciones de entrada: el usuario podrá utilizar el ratón para ejecutar las acciones que permiten iniciar la creación de un nuevo archivo de animación, y el teclado para modificar los parámetros correspondientes al tipo de animación.

c) Especificaciones de salida: el resultado de la generación de animación, serán los frames creados que son parte de la secuencia y un archivo de video tipo AVI con la animación resultante.

d) Dependencias entre casos: si el usuario desea aplicar animación a los modelos de una escena descrita en un archivo de texto, debe iniciar el caso de prueba 4.2.1, de lo contrario, no existe dependencia entre casos, ya que sería a partir de la creación de una nueva escena.


a) Artículos de prueba: se leerá un archivo de texto que contiene la descripción de un modelo en términos de puntos (x,y).

b) Especificaciones de entrada: el usuario podrá utilizar el ratón para ejecutar la acción que permite abrir un archivo de este tipo.

c) Especificaciones de salida: los datos leídos del archivo de texto serán mostrados al usuario como un modelo gráfico y se generará un archivo de video tipo AVI con la animación resultante.

d) Dependencias entre casos: no existe dependencia entre casos, ya que se inicia a partir de una nueva escena.

4.3 ESPECIFICACIÓN DEL PROCEDIMIENTO DE PRUEBAS

4.3.1 CASO DE PRUEBA 1: LECTURA DE UN ARCHIVO GrafO3D a) Propósito: en este caso de prueba se verifica que GrafO3D realice

correctamente la lectura de un archivo de texto, y presente los modelos correspondientes a la escena descrita en el archivo.

b) Requerimientos especiales: el usuario debe crear una escena nueva; el archivo debe estar descrito en base a la estructura vista en el capítulo II, sección 2.6; el archivo debe ser de tipo texto sin formato.

c) Pasos del procedimiento: 1) seleccionar, desde la interfaz gráfica, la opción de abrir un archivo; 2) seleccionar el nombre del archivo deseado.


75

A continuación se muestra la descripción de una escena en un archivo de texto GrafO3D, así como las pantallas que presentan los datos que son almacenados en memoria durante el parseo (figura 4.1). Por último se muestra el modelo gráfico resultante de la escena descrita en el archivo (figura 4.2).

#Grafo v10

PerspectiveCamera Camara1{posit ion 0.00 0.50 6.00orientation 0.00 1.00 0.00}Light ing Luz1{LightPosit ion 4.00 4.00 4.00 0.00LightAmbient 0.20 0.20 0.20 1.00LightDif fuse 0.80 0.80 0.80 1.00LightSpecular 1.00 1.00 1.00 1.00}Separator Objeto1{Transform Transform1{translation 0.00 0.50 -4.00rotation 15.00 1.00 0.00scale 1.00 1.00 1.00}Material Material1{ambientColor 0.80 0.80 0.20 1.00diffuseColor 0.10 0.50 0.80 1.00specularColor 1.00 1.00 1.00 1.00emissiveColor 0.30 0.20 0.20 1.00shininess 10.00Texture C:\GrafO3D\texturas\Earth.bmp}Sphere Tierra{radius 1.50}Transform Transform1{translation 2.50 0.50 -3.00rotation 15.00 1.00 0.00scale 1.00 1.00 1.00}Material Material1{ambientColor 0.80 0.80 0.20 1.00diffuseColor 0.10 0.50 0.80 1.00specularColor 1.00 1.00 1.00 1.00emissiveColor 0.30 0.20 0.20 1.00shininess 10.00Texture C:\GrafO3D\texturas\Sup_Lunar.bmp}Sphere Luna{radius 1.00}}

#Grafo v10


#Grafo v10


Figura 4.1 Archivo de texto y datos almacenados en memoria.


76

Figura 4.2 Visualización de los modelos gráficos en la interfaz de usuario.

4.3.2 CASO DE PRUEBA 2: APLICACIÓN DE FUNCIONES DE GRAFICACIÓN

a) Propósito: en este caso de prueba se verifica que se puede llevar a cabo la

manipulación de los modelos mediante la aplicación de funciones de graficación.

b) Requerimientos especiales: deben existir objetos creados en la escena; debe estar seleccionado un objeto o una primitiva.

c) Pasos del procedimiento: 1) hacer doble clic sobre el nombre del objeto o primitiva de la cual se desee modificar sus propiedades; 2) modificar los parámetros; 3) aceptar los cambios.

En este caso de prueba, se aplicaron a los modelos, funciones de graficación tanto básicas como avanzadas, entre ellas: cambio de color, cambio de escala, cambio de perspectiva, aplicación de textura y de iluminación. El objeto creado fue un cubo, y los cambios hechos a éste se pueden observar en la figura 4.3, figura 4.4 y figura 4.5, mostrándose el resultado final en la figura 4.6.


77

Figura 4.3 Propiedades del modelo.

Figura 4.4 Material del objeto.

En la figura 4.3 se pueden observar los cambios en el modelo de las siguientes propiedades: ♦ Cambio de perspectiva: el objeto se

colocó en la posición (0,-0.5,-4.0) dentro de la escena y se rotó 30 grados sobre el eje x, y 12 grados sobre el eje y para cambiar la perspectiva del objeto.

♦ Escala: se aplicó un factor de escala

igual a 2 en todos los ejes, es decir, el modelo se visualiza en un tamaño mayor (el doble) que el tamaño original.

En la figura 4.4 se pueden observar los cambios en: ♦ Color: se cambió el color por omisión

del objeto por un color azul. En la pantalla se presenta el color y su especificación en las componentes RGB.

♦ Textura: se aplicó un archivo de

textura. En esta figura se muestran tanto la ruta en donde se encuentra el archivo de textura como la imagen correspondiente a ese archivo.


78

Figura 4.5 Propiedades de la luz.

Figura 4.6 Modelo resultante de la aplicación de

funciones de graficación.

En la figura 4.5 se muestra el color aplicado a la luz, cambiando el color por omisión. El color se muestra también en sus componentes RGB, siendo éste un color claro para que los objetos puedan ser visualizados con un mayor brillo.


79

4.3.3 CASO DE PRUEBA 3: VISUALIZACIÓN DE LOS MODELOS: MODELOS SÓLIDOS, EN ALAMBRE Y EN VÉRTICES

a) Propósito: en este caso de prueba se verifica que se puede llevar a cabo la

manipulación de los modelos mediante la vista en modelos sólidos, en alambre o en vértices.

b) Requerimientos especiales: deben existir objetos creados en la escena. c) Pasos del procedimiento: 1) ejecutar, desde la interfaz gráfica, la acción

correspondiente al tipo de vista deseada. En este caso de prueba, se creó el modelo de un soldado, el cual está compuesto por primitivas como cilindros, esferas, cubos, líneas y octágonos. La figura 4.7, figura 4.8 y figura 4.9, muestran el modelo en tres vistas diferentes: modelos sólidos, modelos en alambre y modelos en vértices, respectivamente. Cabe mencionar que esta opción se aplica a todas las primitivas y objetos contenidos en la escena.

Figura 4.7 Modelos sólidos.

Figura 4.8 Modelos en alambre.

Figura 4.9 Modelos en vértices.


80

4.3.4 CASO DE PRUEBA 4: GENERACIÓN DE ANIMACIÓN a) Propósito: en este caso de prueba se verifica que se puede llevar a cabo la

manipulación de los modelos mediante la aplicación de animación de tres diferentes formas: capturando en forma independiente los frames; seleccionando el tipo de movimiento (traslación, rotación y escala); o especificando los puntos (x,y,z) por los que será desplazado el objeto en un movimiento de traslación.

b) Requerimientos especiales: deben existir objetos creados en la escena; debe existir una primitiva u objeto seleccionado

c) Pasos del procedimiento: 1) ejecutar, desde la interfaz gráfica, la acción correspondiente al tipo de animación deseada.

En este caso de prueba se generó animación a partir de las tres formas permitidas en la interfaz de usuario, éstas son: 1) Captura de frames por parte del usuario En este tipo de generación de animación, el usuario realiza modificaciones a los modelos y guarda el frame cuando lo desee. Los frames almacenados serán los que formarán la secuencia de animación final. En este caso, se hicieron cuatro diferentes pruebas, las cuales se presentan a continuación.

♦ Modelo de un soldado: este modelo está compuesto por seis objetos correspondientes a los brazos, piernas, cuerpo y cabeza de un soldado. Cada objeto se conforma por un conjunto de primitivas, entre ellas: cilindros, octaedros, esferas, líneas y cubos. Para este caso se capturaron dos frames (ver figura 4.10) y se duplicaron para hacer una secuencia de 10 cuadros, de tal forma que se pueda apreciar el efecto de movimiento. Desde la pantalla de propiedades, se proporcionó el nombre del archivo de video resultante y el tiempo de espera entre cada frame.

Figura 4.10 Frames capturados para generar un archivo de animación.


81

♦ Modelo de una mano: este modelo está compuesto por seis objetos que corresponden a los dedos y palma que forman la mano. Las primitivas utilizadas fueron cilindros y esferas para representar los dedos, y un cubo para representar la palma de la mano. Se generaron 13 frames que permiten observar el efecto de movimiento. En la figura 4.11 se presentan seis de los 13 frames generados por GrafO3D. Desde la pantalla de propiedades, se proporcionó el nombre del archivo de video resultante y el tiempo de espera entre cada frame.

Figura 4.11 Frames generados por GrafO3D correspondientes al modelo de una

mano.


82

♦ Modelo de un brazo de un robot: este modelo está compuesto por cuatro objetos que corresponden a la base y a cada una de las partes de articulación de un brazo de un robot. Cada objeto está formado por una serie de primitivas, entre ellas: cilindros, cubos y esferas. Se capturaron un total de cinco frames para generar el archivo de animación. En la figura 4.12 se presentan los frames generados por GrafO3D. Desde la pantalla de propiedades, se proporcionó el nombre del archivo de video resultante y el tiempo de espera entre cada frame.

Figura 4.12 Frames generados por GrafO3D correspondientes al modelo de un brazo de un

robot.


83

♦ Modelo de un gusano: este modelo está compuesto por un único objeto que contiene como primitivas, un conjunto de esferas que forman el cuerpo del gusano. En este caso de prueba, se capturaron un total de 11 frames que componen el archivo de animación. En la figura 4.13 se presentan seis de los 11 frames generados por GrafO3D. Desde la pantalla de propiedades, se proporcionó el nombre del archivo de video resultante y el tiempo de espera entre cada frame.

Figura 4.13 Frames generados por GrafO3D correspondientes al modelo de un

gusano.


84

2) Selección del tipo de movimiento

Figura 4.14 Pantalla de propiedades de la animación.

En este caso de prueba se generó la modificación uniforme de la escala de una esfera. Esta modificación corresponde a una secuencia de decrementos del tamaño del objeto. La secuencia está compuesta por diez frames, y en cada frame, el tamaño del objeto se decrementa en 0.1 unidades (ver figura 4.14). En la figura 4.15 se muestran algunos de los frames que forman parte de la secuencia final del archivo de animación, estos frames fueron creados automáticamente por GrafO3D.

Figura 4.15 Frames generados por GrafO3D.

En este tipo de generación de animación, el usuario proporciona los datos correspondientes al nombre del archivo resultante, tiempo de espera entre cada cuadro, tipo de movimiento (traslación, rotación o escala), unidades de incremento o decremento del movimiento, el número de repeticiones del movimiento y el número de repeticiones de la secuencia. Ver figura 4.14.


85

3) Generación de animación mediante la especificación de puntos

Figura 4.16 Pantalla de propiedades de la

animación.

En la figura 4.17 se muestran algunos de los frames que forman parte de la secuencia de animación final y que fueron generados automáticamente por GrafO3D.


En esta parte de la experimentación, se generó la animación de la simulación del movimiento de la luna alrededor de la tierra, para lo cual, se capturaron cada uno de los puntos por los que se mueve el objeto, en este caso se generaron 13 puntos y cada punto corresponde a un frame de la secuencia final. Además, se introdujeron los datos correspondientes al nombre del archivo de animación, el tiempo de espera entre cada frame y el número de repeticiones de la secuencia total. Esta información se observa en la figura 4.16.


86

4.3.5 CASO DE PRUEBA 5: LECTURA DE UN ARCHIVO DE TEXTO CONFORMADO POR PUNTOS (X,Y)

a) Propósito: en este caso de prueba se verifica que GrafO3D es capaz de tomar

como entrada un archivo de texto que contenga la descripción de un objeto en términos de puntos (x,y) y generar el archivo de animación correspondiente.

b) Requerimientos especiales: el usuario debe crear un modelo nuevo; el archivo debe estar descrito en base a la estructura vista en el capítulo II, sección 2.9; el archivo debe ser de tipo texto sin formato.

c) Pasos del procedimiento: 1) seleccionar, desde la interfaz gráfica, la opción de importar archivo; 2) seleccionar el nombre del archivo deseado.

En este caso, se realizaron dos diferentes pruebas, las cuales se presentan a continuación: 1) Traslación del modelo de una boca El objeto corresponde al contorno de una boca, el cual está descrito, en un archivo de texto, por 33 puntos (x,y), es decir, 66 características (x1, y1, x2, y2, etc.) en una secuencia de imágenes de tres frames (número de renglones del archivo de texto) que muestra el movimiento de traslación, en el eje x, del objeto (ver figura 4.18).

66 3encabezados0.0 1.0 0.1 1.2 0.3 1.3 0.5 1.35 0.7 1.37 0.9 1.35 1.0 1.33 1.1 1.31 1.3 1.29 1.5 1.31 1.7 1.33 1.9 1.35 2.0 1.37 2.1 1.35 2.3 1.3 2.5 1.2 2.7 1.0 2.5 0.9 2.3 0.87 2.1 0.85 2.0 0.83 1.9 0.81 1.7 0.79 1.5 0.77 1.3 0.75 1.1 0.77 1.0 0.79 0.9 0.81 0.7 0.83 0.5 0.85 0.3 0.87 0.1 0.89 0.0 0.911.0 1.0 1.1 1.2 1.3 1.3 1.5 1.35 1.7 1.37 1.9 1.35 2.0 1.33 2.1 1.31 2.3 1.29 2.5 1.31 2.7 1.33 2.9 1.35 3.0 1.37 3.1 1.35 3.3 1.3 3.5 1.2 3.7 1.0 3.5 0.9 3.3 0.87 3.1 0.85 3.0 0.83 2.9 0.81 2.7 0.79 2.5 0.77 2.3 0.75 2.1 0.77 2.0 0.79 1.9 0.81 1.7 0.83 1.5 0.85 1.3 0.87 1.1 0.89 1.0 0.912.0 1.0 2.1 1.2 2.3 1.3 2.5 1.35 2.7 1.37 2.9 1.35 3.0 1.33 3.1 1.31 3.3 1.29 3.5 1.31 3.7 1.33 3.9 1.35 4.0 1.37 4.1 1.35 4.3 1.3 4.5 1.2 4.7 1.0 4.5 0.9 4.3 0.87 4.1 0.85 4.0 0.83 3.9 0.81 3.7 0.79 3.5 0.77 3.3 0.75 3.1 0.77 3.0 0.79 2.9 0.81 2.7 0.83 2.5 0.85 2.3 0.87 2.1 0.89 2.0 0.91

Figura 4.18 Archivo de texto con la descripción del modelo de una boca.


87

El resultado generado por GrafO3D, es el modelo gráfico del archivo de texto leído (ver figura 4.19) y el archivo de secuencia con los frames especificados. Los frames que componen la secuencia resultante se muestran en la figura 4.20.

Figura 4.19 Modelo gráfico generado por GrafO3D.



88

2) Movimiento de apertura y cierre del modelo de una boca El objeto corresponde al contorno de una boca, el cual está descrito por 39 puntos (x,y), es decir, 78 características (x1, y1, x2, y2, etc.) en una secuencia de imágenes de 15 frames (número de renglones del archivo de texto) que modelan el movimiento de apertura y cierre de la boca (ver figura 4.21). El resultado generado por GrafO3D, es el modelo gráfico del archivo de texto leído (ver figura 4.22) y el archivo de secuencia con los frames especificados. En la figura 4.23 se muestran seis de los 15 frames que componen la secuencia de animación resultante.

78 15encabezados-2.46 0.37 -2.14 0.59 -1.85 0.78 -1.59 0.94 -1.34 1.07 -1.12 1.20 -0.90 1.29 -0.69 1.36 -0.50 1.39 -0.30 1.39 -0.10 1.39 0.09 1.36 0.30 1.29 0.52 1.20 0.74 1.07 0.99 0.94 1.25 0.78 1.54 0.59 1.86 0.37 2.20 0.16 1.86 -0.11 1.54 -0.36 1.25 -0.57 0.99 -0.76 0.74 -0.92 0.52 -1.05 0.30 -1.15 0.09 -1.22 -0.10 -1.27 -0.30 -1.28 -0.50 -1.27 -0.69 -1.22 -0.90 -1.15 -1.12 -1.05 -1.34 -0.92 -1.59 -0.76 -1.85 -0.57 -2.14 -0.36 -2.46 -0.11 -2.46 0.35 -2.14 0.61 -1.85 0.83 -1.59 1.02 -1.34 1.18 -1.12 1.31 -0.90 1.41 -0.69 1.47 -0.50 1.50 -0.30 1.50 -0.10 1.50 0.09 1.47 0.30 1.41 0.52 1.31 0.74 1.18 0.99 1.02 1.25 0.83 1.54 0.61 1.86 0.35 2.20 0.16 1.86 -0.13 1.54 -0.38 1.25 -0.61 0.99 -0.81 0.74 -0.97 0.52 -1.11 0.30 -1.22 0.09 -1.29 -0.10 -1.34 -0.30 -1.35 -0.50 -1.34 -0.69 -1.29 -0.90 -1.22 -1.12 -1.11 -1.34 -0.97 -1.59 -0.81 -1.85 -0.61 -2.14 -0.38 -2.46 -0.13 -2.46 0.33 -2.14 0.59 -1.85 0.81 -1.59 1.01 -1.34 1.17 -1.12 1.29 -0.90 1.39 -0.69 1.45 -0.50 1.49 -0.30 1.49 -0.10 1.49 0.09 1.45 0.30 1.39 0.52 1.29 0.74 1.17 0.99 1.01 1.25 0.81 1.54 0.59 1.86 0.33 2.20 0.16 1.86 -0.15 1.54 -0.42 1.25 -0.66 0.99 -0.87 0.74 -1.05 0.52 -1.19 0.30 -1.30 0.09 -1.38 -0.10 -1.43 -0.30 -1.45 -0.50 -1.43 -0.69 -1.38 -0.90 -1.30 -1.12 -1.19 -1.34 -1.05 -1.59 -0.87 -1.85 -0.66 -2.14 -0.42 -2.46 -0.15 -2.46 0.31 -2.14 0.60 -1.85 0.86 -1.59 1.08 -1.34 1.24 -1.12 1.37 -0.90 1.46 -0.69 1.53 -0.50 1.56 -0.30 1.56 -0.10 1.56 0.09 1.53 0.30 1.46 0.52 1.37 0.74 1.24 0.99 1.08 1.25 0.86 1.54 0.60 1.86 0.31 2.20 0.16 1.86 -0.17 1.54 -0.46 1.25 -0.72 0.99 -0.95 0.74 -1.14 0.52 -1.29 0.30 -1.41 0.09 -1.50 -0.10 -1.55 -0.30 -1.57 -0.50 -1.55 -0.69 -1.50 -0.90 -1.41 -1.12 -1.29 -1.34 -1.14 -1.59 -0.95 -1.85 -0.72 -2.14 -0.46 -2.46 -0.17 Figura 4.21 Archivo de texto con la descripción del modelo de una boca.

Figura 4.22 Modelo gráfico generado por GrafO3D.



89

4.4 CONCLUSIONES Los casos de prueba realizados parten, desde la creación de modelos simples compuestos por un único objeto, hasta modelos más complejos formados por varios objetos y primitivas. La creación de los modelos se realizó mediante un archivo de texto y a partir de instrucciones proporcionadas en la interfaz gráfica, los cuales fueron manipulados para modificar sus características propias y para generar un archivo de animación que modele el comportamiento de los objetos en un lapso de tiempo. Con estas pruebas se abarcó el modelado de objetos rígidos, articulados y alfaflexibles, además, se comprobó que GrafO3D es capaz de generar modelos a partir de la información de la herramienta para el modelado automático de objetos alfaflexibles [Orbe03], y que permite crear modelos como los del detallador de tareas [López03] y del simulador de un brazo articulado con interface gráfica [Rueda03]. Cabe mencionar, que la complejidad de la creación de un modelo aumenta dependiendo de las características que presenta, es decir, la complejidad del modelado de un objeto articulado o de un objeto alfaflexible es mayor que el de un objeto rígido, esto se debe a que se necesita modelar el comportamiento de éste, para lo cual se requiere un mayor tiempo y una mayor precisión para cada movimiento que realiza el objeto durante la secuencia de animación.

Entorno de graficación y generación de modelos 2D y 3D para aplicaciones de Visión Artificial Capítulo V. Conclusiones

90

CAPÍTULO V

CONCLUSIONES

CONTENIDO:

Introducción Metas alcanzadas Conclusiones Trabajos futuros

5 conclusiones


91

5.1 INTRODUCCIÓN En este capítulo se presentan las metas alcanzadas, así como las conclusiones del presente tema de tesis, además, se mencionan los trabajos futuros que pueden ser desarrollados a partir del resultado presentado en este documento.

5.2 METAS ALCANZADAS Como resultado del desarrollo del tema de tesis presentado, se obtuvo: ♦ Un entorno de graficación que permite la generación automática, creación,

edición y visualización de modelos gráficos en 2D y 3D (GrafO3D). ♦ El desarrollo de una interfaz gráfica para la creación, edición y visualización

de modelos. ♦ La construcción de la estructura de un archivo de texto para la especificación

de escenas. ♦ La especificación de una gramática sobre la cual se verifica la validez de un

archivo de texto recibido como entrada por GrafO3D. ♦ La posibilidad de crear una escena mediante un archivo de texto o a través de

la interfaz gráfica. ♦ El apoyo a otras herramientas en desarrollo dentro del grupo de Visión

Artificial del cenidet, en la elaboración de casos de prueba, como lo es la herramienta para el modelado de objetos deformables, utilizando color y textura [May04].

♦ Tratamiento de archivos generados por otras herramientas desarrolladas

dentro del grupo, como la herramienta para el modelado de objetos alfaflexibles [Orbe03].

♦ Modelado de objetos creados en el detallador de tareas [López03] y en el

simulador de un brazo articulado con interface gráfica [Rueda03].


92

5.3 CONCLUSIONES El resultado final del desarrollo de este tema de tesis, es una herramienta que permite crear modelos en 2D y 3D, los cuales pueden ser editados y manipulados por el usuario. Estos modelos son creados a partir de un conjunto de primitivas que permiten al usuario, construir modelos más complejos. La especificación de una escena comprende tanto los objetos, como la iluminación y la posición de la cámara. Esta escena puede ser creada en la interfaz gráfica de GrafO3D o también puede estar descrita en forma textual en un archivo, bajo la gramática definida, ver anexo G y anexo H. Uno de los resultados que GrafO3D proporciona al usuario, es el modelo gráfico de los objetos, con el cual el usuario interactúa mediante la interfaz gráfica. Otro resultado que se obtiene es mediante la aplicación de funciones de graficación, entre ellas, la generación de animación, de tal forma que el usuario puede almacenar, en un archivo tipo AVI, el comportamiento de un objeto en un lapso de tiempo. Por último, el usuario de GrafO3D obtiene un archivo de texto con la especificación de la escena creada en la interfaz gráfica. Para el desarrollo de GrafO3D, se tomó como referencia el estándar VRML para la definición de objetos mediante un archivo de texto, además se utilizó la biblioteca OpenGL, para la creación de objetos en 3D y el ambiente integrado de desarrollo C++ Builder para su codificación. Es indudable que existen herramientas comerciales para la graficación en 3D, algunas de ellas muy conocidas y utilizadas que son de propósito general, las cuales no se adaptan a los requerimientos que en el cenidet se necesitan, como lo es el importar archivos con una estructura especial, por ejemplo, los archivos generados por las herramientas creadas en el grupo de VA del cenidet. Además, se puede agregar, que las herramientas comerciales generan archivos de salida con la información de los modelos en formatos estándar, ya sea archivos de imágenes (GIF, JPG, BMP, etc.) o de video (AVI, JPEG, MOV, etc.), sin embargo, el archivo de descripción de los modelos es, en su mayoría, en formato binario, por lo que resultaría muy difícil extraer información a partir de estos archivos, debido a esto, se creó un lenguaje de descripción de objetos 3D como parte del desarrollo de este tema de tesis, que en caso que se requiera, podrá ser utilizado en los diferentes proyectos que se desarrollan en el grupo de VA del cenidet. Es necesario mencionar que con este trabajo se desarrolló una herramienta que cumple con el objetivo principal de la tesis, que fue el diseñar e implementar un entorno para la creación, edición y visualización de modelos gráficos de objetos rígidos y flexibles en 2D y 3D.


93

Además se lograron los siguientes puntos:

• Definición de primitivas para el modelado. • Manejo de la especificación de los objetos mediante un archivo de texto. • Manejo de múltiples objetos en la misma escena (de 5 a 20 objetos), que

puedan ser seleccionados por el usuario en tiempo de ejecución. • Manejo de funciones básicas de graficación:

o Cambio de perspectiva. o Cambio de escala. o Cambio del vector normal a nivel del objeto. o Cambio de color, por objeto y por secciones del objeto.

• Manejo de funciones avanzadas de graficación: o Modelos de alambre. o Modelos sólidos. o Superficie con texturas. o Ocultamiento de caras. o Animación. o Iluminación.

• Generación de animación mediante la interpretación de los datos numéricos generados por la herramienta de modelado.

• Generación de archivos AVI con la animación resultante. • Generación de animación mediante la especificación de funciones de

transformación de los objetos definidos.

5.4 TRABAJOS FUTUROS Sin duda, este trabajo de tesis no tiene carácter de concluyente, al contrario, abre perspectivas que lo perfeccionarán y complementarán. A continuación se indican algunos de los trabajos futuros que pueden realizarse a partir del desarrollo de GrafO3D. ♦ Para que la interfaz de usuario de GrafO3D sea más amigable al usuario, es

posible integrar el uso del ratón para la manipulación de los modelos. Algunas de las acciones que se pueden realizar con el ratón son: selección de objetos, traslación y rotación de las primitivas u objetos seleccionados, entre otras.

♦ Dentro de la Visión Artificial, los objetos bajo estudio pueden ser modelos más

complejos y sofisticados como lo es el cuerpo humano, es decir, objetos que estén compuestos por arcos, secciones curvas, mallas, etc., en este caso, es posible agregar a GrafO3D un conjunto de primitivas para crear curvas y superficies.

♦ En el modelado de un proceso de manufactura, se deben tomar en cuenta los

componentes que intervienen en dicho proceso, como lo son: robots, bandas transportadoras, almacenes, entre otros. Para ello es posible agregar a la


94

interfaz de GrafO3D, un módulo que contenga esos componentes en forma de primitivas para ofrecerle al usuario una mayor rapidez en la creación de los modelos.

♦ Para llevar a cabo las interacciones entre las partes que componen una celda de

manufactura, como lo es el movimiento de una banda transportadora o la traslación de un robot a una banda transportadora, es posible agregar funciones de animación que puedan ser definidas por el usuario y que modelen el comportamiento de los objetos bajo cierta trayectoria en un lapso de tiempo.

♦ GrafO3D puede extenderse para integrar mayor funcionalidad y poder

conformar una herramienta de tipo CAD/CAM.

RESUMEN Cuando se está realizando algún proceso de Visión Artificial (VA), por ejemplo, la caracterización de un objeto, el resultado generado es presentado en forma numérica, y en muchas ocasiones, esta información es poco comprensible por el usuario. Sin embargo, existe otra forma de representar estos datos, de tal manera que para el usuario sea más fácil y rápido comprenderlos, esto es, mediante la generación de un modelo gráfico. Dentro de la VA se pueden distinguir principalmente, tres tipos de objetos: objetos rígidos, articulados y alfaflexibles, los cuales pueden ser representados a través de un modelo gráfico. Debido a la importancia de contar con un modelo gráfico del objeto o los objetos bajo estudio, en el grupo de VA del Centro Nacional de Investigación y Desarrollo Tecnológico (cenidet), se implementó una herramienta con interfaz gráfica (GrafO3D) que permite generar y crear modelos gráficos en un entorno 3D a partir de primitivas predefinidas, así mismo, estos modelos pueden ser manipulados y editados para cambiar sus características propias como lo son: color, tamaño, posición, entre otras. Los modelos que conforman una escena en GrafO3D, pueden estar descritos en forma textual mediante un archivo de texto. Este archivo sigue una estructura definida conformada por los datos correspondientes a las características del objeto, y que conservan su apariencia, forma y relación con los demás objetos. Para llevar a cabo el desarrollo de GrafO3D, se implementaron principalmente los módulos de: 1) definición de la estructura del archivo de texto, para lo cual se tomó como referencia el estándar VRML; 2) creación de una gramática que valide la construcción correcta de un archivo GrafO3D; 3) creación de los modelos gráficos a partir de la información leída en el archivo. En este módulo se utilizó la biblioteca para gráficos OpenGL; 4) escritura de un archivo de texto con la información de la escena actual. GrafO3D, como herramienta resultante del desarrollo de este tema de tesis, permite que pueda ser usada en aplicaciones como: reconocimiento de patrones, modelado de procesos de manufactura, entre otras, permitiendo su extensión para el desarrollo de una herramienta más compleja como lo es una herramienta CAD/CAM.

ABSTRACT When some process of Artificial Vision (AV) is being made, for example, the characterization of an object, the generated result is displayed in numerical form, and in many occasions, this information is little comprehensible by the user. However, there is another form to represent these data, in such a way that for the user is easier and faster understand them, that is to say, by means of the generation of a graphical model. In the AV, three object types can be distinguished mainly: rigid, articulated and alfaflexibles objects, which can be represented through of a graphical model. Due to the importance of having a graphical model of the object or the objects under study, in the AV group of the National Center of Investigation and Technological Development (cenidet), a tool with graphical interface (GrafO3D) was implemented, which allows to generate and to create graphical models in a 3D environment with predefined primitives, also, these models can be manipulated and modified to change their own characteristics as they are: color, size, position, among others. The models that conform a scene in GrafO3D, can be described in textual form by means of a text file. This file follows a defined structure conformed by the data corresponding to the characteristics of the object, and that conserves their appearance, form and relationship with the other objects. In order to carry out the development of GrafO3D, these modules were implemented mainly: 1) definition of the text file structure, for this, the standard VRML was taken like reference; 2) creation of a grammar that validates the correct construction of a GrafO3D file; 3) creation of the graphical models from the information read in the file. In this module the graphics library OpenGL was used; 4) writing of a text file with the information of the current scene. GrafO3D, like resulting tool of the development of this thesis topic, allows that it can be used in applications like: pattern recognition, manufacturing processes modeled, among others, allowing its extension for the development of a more complex tool like a CAD/CAM tool.

Documents

Cenidet Adriana Judit... · sep seit dgit centro nacional de investigaciÓn y desarrollo tecnolÓgico cenidet entorno de graficaciÓn y generaciÓn de modelos 2d y