Universidad Nacional del Altiplano

FACULTAD DE INGENIERIA MECANICA ELECTRICA, ELECTRONICA Y

SISTEMAS

ESCUELA PROFESIONAL DE INGENIERIA DE SISTEMAS

TRABAJO ENCARGADO

TEMA: Proyecciones en OpenGL

CURSO: COMPUTACIÓN GRÁFICA

DOCENTE: ING. MARIELA ALAVE AGUILAR

INTEGRANTES:

1. ARCE ANCACHI EVELYN KATTY

2. MENDOZA CALISAYA VERÒNICA

SEMESTRE VI

1
 Índice
1. Resumen............................................................................................................................... 5
2. Introducción ........................................................................................................................ 6
3. Proyección en OpenGL ...................................................................................................... 7
4. Posición de la cámara ......................................................................................................... 7
5. Tipos de proyecciones ......................................................................................................... 8
a) Proyeccion ortogonal o paralela: .................................................................................... 8
b) Proyeccion perspectiva ..................................................................................................... 9
6. Manteniendo la proporción de los objetos ...................................................................... 11
8. Bibliografía ........................................................................................................................ 14

2
DEDICATORIA

Queremos dedicarle este trabajo a

Dios que nos ha dado la vida y la
fortaleza para terminar este
trabajo de proyección en OpenGL.
Y a nuestra docente por estar ahí
cuando se nos presentaba alguna
duda.

3
AGRADECIMIENTO

Agradecemos a Dios por habernos

dado un día más de vida y por
habernos ayudado a llegar hasta
este punto.

4
 1. Resumen
Antes de presentar los detalles de cómo implementar las transformaciones 3D enOp
enGL, necesitamos dibujar objetos 3D. La librería GLUT ofrece una colección
interesante de objetos 3D. Cada objeto está disponible en dos versiones: alambre (Wire)
y solido(Solid).
La Realidad Aumentada es la tecnología que nos permite superponer elementos gráficos
sobre el mundo real. Para que esta pueda funcionar adecuadamente es necesario conocer con
precisión cuál es la posición de la cámara desde la que vemos el mundo y como se conforman
las imágenes que nos muestra. En este trabajo mostramos como calcular la posición de la
cámara a partir de diferentes marcas tanto naturales como artificiales, vemos cual es la mejor
forma de proyectar sobre estas marcas mediante el estudio del error de calibración,
diseñamos un modo de obtener la matriz de intrínsecos a partir de los para ‘metros físicos de
la cámara (distancia focal y ángulos de visión), elaboramos un modelo de proyección que
permita emplear la matriz de intrínsecos para obtener la matriz de proyección de OpenGL y
por ultimo proyectamos una figura en tres dimensiones (3D) sobre el patrón. Este patrón
será´ un tipo especial de letreros que detectamos empleando una técnica de seguimiento en
el espacio de color.

5
 2. Introducción

OpenGL es una librería grafica en la cual utilizaremos en proyecciones para poder relisar las
siguientes proyecciones escritas originalmente en C que permite la manipulaci6n de gráficos
3D a todos los niveles. Esta librería se concibi6 para programar en máquinas nativas Silicon
Graphics bajo el nombre de GL (Graphics Library). Posteriormente se consideró la
posibilidad de extenderla a cualquier tipo de plataforma y asegurar así su portabilidad y
extensibilidad de uso con lo que se legó al termino Open Graphics Library, es decir,
OpenGL. La librería se ejecuta a la par con nuestro programa independientemente de la
capacidad grafica de la máquina que usamos. Esto significa que la ejecuci6n se clara por
software a no ser que contemos con hardware grafico específico en nuestra máquina. Si
contamos con tarjetas aceleradoras de video, tecnología MMX, aceleradoras 3D, pipelines
gráficos implementados en placa, etc. por supuesto gozaremos de una ejecuci6n muchísimo
más rápida en tiempo real.
Así esta librería puede usarse bajo todo tipo de sistemas operativos e incluso
Usando una gran variedad de lenguajes de programaci6n. Podemos encontrar variantes de
OpenGL para Windows 95/NT, Unix, Linux, Iris, Solaris, Delphi, Java e incluso Visual
Basic. No obstante, su uso más extenso suele ser el lenguaje Co C++. Por supuesto no
podemos desligar el mundo de los gráficos de OpenGL y por tanto se intentara que este sea
un curso de "gráficos usando OpenGL", más que una larga menci6n de funciones y constantes
integradas en esta librería. Trabajaremos con C y por tanto nos referiremos siempre a
ejemplos codificados según este lenguaje. Simplemente necesitaremos las librerías
adecuadas y un compilador cualquiera de Ansi C, es decir, el estándar de este lenguaje. Algo
de algebra lineal también hará falta para entender que es lo que ocurre internamente y cómo
podemos operar con nuestra geometría para lograr los efectos deseados.

6
 3. Proyección en OpenGL

Una vez definida una escena en coordenadas del mundo, tenemos que “tomar la foto”. Para
esto, tenemos que hacer dos cosas: colocar la cámara en el mundo (o sea, en la escena) y
definir el tipo de proyección que realizará la cámara.

Tras las transformaciones homogéneas para nuestra geometría ya somos capaces de modelar
y situar objetos a lo largo y ancho de nuestra escena virtual. 1, Pero como hacer que aparezcan
en nuestra ventana del Sistema Operativo? La ventana es 2D y en cambio está mostrando
geometría 3D dando sensación de que hay profundidad. Tenemos que proyectar Ia geometría
en un plano de proyección. Como plano es obviamente 2D y suele situarse por convencion
en Z = 0 (plano XY). La idea es proyectar primero para "discretizar" despues. Por discretica
entendemos pasar del mundo real (float o double) al entero (integer) que es el de los pixels
de nuestro monitor.

4. Posición de la cámara

Tenemos que definir no sólo la posición de la cámara (o donde está), sino también hacia
dónde mira y con qué orientación (no es lo mismo mirar con la cara torcida que recta, aunque
veamos lo mismo). Para hacer esto, basta con modificar la matriz ModelView para mover
toda la escena de manera que parezca que hemos movido la cámara. El problema de este
sistema es que tenemos que pensar bastante en las transformaciones a aplicar. Es por ello que
OpenGL proporciona la función gluLookAt. Su sintaxis es la siguiente:
void gluLookAt( eyeX, eyeY, eyeZ, cenX, cenY, cenZ, vp_X, vp_Y, vp_Z);

donde eye corresponde a la posición de la cámara, cen corresponde al punto hacia donde mira
la cámara y vp es un vector que define la orientación de la cámara. No podemos llamar a
gluLookAt en cualquier momento, puesto que tiene postmultiplicar la matriz ModelView
(por tanto, conviene llamarla primero). El vector vp no puede ser paralelo al vector formado
por eye y cen, es más, debería ser perpendicular. Si no, el resultado es impredecible.

figura 01

7
Al mismo tiempo que se define la posición y orientación de la cámara, hay que definir el tipo
de “foto” que se hará como si seleccionáramos el objetivo. Es decir, definir la forma del
volumen de visualización.
La primera elección que tenemos que hacer es si queremos una proyección ortogonal o
perspectiva. Dependiendo del tipo de aplicación, utilizaremos una u otra.
En OpenGL, para definir la proyección, modificaremos la matriz Projection. Para hacer esto,
pues, tendremos que hacer una llamada a glMatrixMode(GL_PROJECTION), para indicarle
que vamos a modificar esta matriz. A partir de ese momento, todas las funciones de
transformación (glRotatef, glTranslatef, glScalef, …etc) y las de la pila (glPushMatrix y
glPopMatrix) se aplican sobre esta matriz.

5. Tipos de proyecciones

En estas se define una direccion de vision (viewing) que va desde el observador hasta el
objeto en cuestion. Esta direccion se establece por medio de proyectores (lineas) que cortan
el plano de proyeccion generando asi Ia imagen 2D que finalmente aparecera en pantalla.
Como primera gran clasificacion de las proyecciones planares podemos hablar de:
Proyecciones planares
1. Paralelas
a) Oblicua
b) Ortografica
2. Perspectiva
a) 1 punto
b) 2 puntos
c) 3 puntos
No comentaremos todas las existentes, no sera necesario. Nos centraremos en las
proyecciones planares
Nosotros nos centraremos en dos de estas proyecc10nes. La ortográfica y la perspectiva de
un solo punto.

a) Proyeccion ortogonal o paralela:

Para el caso de la proyección ortogonal la analogía de la cámara no es tan evidente, porque

en realidad estamos definiendo una caja, o volumen de visualización alrededor del eye de la
cámara (esto es, podemos ver detrás) Para hacer esto, llamamos a glOrtho(left, right, bottom,
top, near, far)
Como se aprecia en la figura, la “foto” obtenida incluye tanto a la tetera como al toro, puesto
que el volumen de visualización tiene un near negativo (detrás de la cámara) y por tanto el
volumen de visualización lo incluirá.

8
 figura 02
Esto sería equivalente a tener la cámara situada de la siguiente manera:

figura 03

En este caso, la imagen sería la misma, pero near y far serían ambos positivos, puesto que el
volumen se está definiendo por delante de la cámara. Si near y far fueran los valores de la
figura anterior, entonces seguramente sólo aparecería en la imagen el toro, puesto que el
volumen de visualización estaría centrado en la cámara.

b) Proyeccion perspectiva

El caso de la proyección perspectiva es más intuitivo, puesto que la analogía de la cámara se

cumple bastante bien. Así, una vez que hemos situado la cámara en la escena, definimos el
volumen de visualización mediante la función: glFrustum(left, right, bottom, top, near, far).
Esta función, aunque tiene los mismos parámetros que glOrtho, éstos tienen un significado
ligeramente distinto. Mientras que left, right, bottom y top siguen definiendo el tamaño y
forma del plano near de proyección, los parámetros near y far ahora deben cumplir la relación
0 < near < far. De hecho, en ningún caso near debe tomar el valor 0, puesto que los resultados
serán impredecibles. El volumen de visualización generado es como se muestra en la figura
siguiente:

figura 04

9
Observando la imagen obtenida, el toro tiene una apariencia mucho mayor que la tetera, que
está más lejos. Esta es la principal diferencia con la proyección ortogonal, los rayos
proyectivos no son paralelos.Una manera más simple de definir la proyección perspectiva es
mediante la función gluPerspective(alpha, aspect, near, far). Veamos con detalle cada uno de
estos parámetros:

figura 05

En esta función, alpha corresponde al ángulo de apertura del campo de visión en la dirección
de y, near es la distancia mínima a la que deben estar los objetos para salir en la foto y far
es la distancia máxima (ambas siempre positivas) El parámetro aspect define la relación entre
el ángulo de visión horizontal y vertical (es la anchura/altura), y típicamente debería ser
entre 30 y 35 grados para obtener resultados realistas. La relación entre far/near debería ser
lo más cercana posible a 1.

Ejemplo de definición de la posición de la cámara y el tipo de proyección

glMatrixMode(GL_PROJECTION);
glPushMatrix(); /* Guardamos la matriz de proyeccion */
glLoadIdentity(); /* P = I */
gluPerspective(30.0f, anchura / altura, 1.0, 10.0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix(); /* Guardamos la matriz del modelo */
glLoadIdentity(); /* M = I; */
/* Colocamos la camara en el punto deseado */
gluLookAt(0, 5, 5, 0, 0, 0, 0, 1, 0);
/* Dibujamos una tetera roja centrada en (-1, 0, 0) */
glTranslatef(-1.0f, 0.0f, 0.0f);
glColor3f(1.0f, 0.0f, 0.0f);
glutWireTeapot(0.5f);
glPopMatrix(); /* Recuperamos la antigua matriz del modelo */
glMatrixMode(GL_PROJECTION);
glPopMatrix(); /* Recuperamos la antigua matriz de proyeccion */

La definición del viewport se realiza de manera sencilla mediante la función:

glViewport

10
(x, y, cx, cy);

donde (x, y) es la esquina superior izquierda del viewport en coordenadas de la pantalla y

(cx, cy) corresponden a la anchura y altura del viewport deseado. Por defecto, GLUT define
el viewport ocupando toda la ventana.

6. Manteniendo la proporción de los objetos

En la sección anterior hemos introducido el concepto de aspect, que corresponde a la relación

anchura/altura. Cuando definimos el volumen de visualización, es importante que el aspect
de éste sea el mismo que el de viewport (ventana de visualización). Así, si definimos un
volumen de visualización que es el doble de alto que de ancho (aspect = 0.5), y nuestro
viewport es cuadrado (aspect = 1) la imagen que obtendremos podría tener la siguiente
apariencia:

figura 06

Como se puede observar, aunque el volumen de visualización es suficientemente grande para

contener todo el objeto, la imagen sale deformada. En cambio, si nuestro volumen de
visualización tiene aspect 1, aunque estemos incluyendo más volumen del necesario para
incluir nuestro objeto en su totalidad, la imagen obtenida será:

figura 07

11
que no ha sufrido ninguna deformación, lo cual es interesante en la mayoría de aplicaciones.
La definición del aspect del volumen de visualización cuando se usa gluPerspective es trivial,
basta con pasarle el parámetro adecuado. Para el caso de las funciones glFrustum y glOrtho
hay que definir los valores left, right, top y bottom teniendo en cuenta que a relación que
tienen que mantener entre ellos tiene que ser la misma que el ancho y alto de nuestro
viewport.

Ejemplo de preservación de la proporción

#include <gl/glut.h>
float aspect = 1.0f;

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(20.0f, aspect aspect, 1.0f, 10.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
glutWireTeapot(0.5);
glFlush();
glutSwapBuffers();
}
void onSize(int sx, int sy)
{
glViewport(0, 0, sx, sy); aspect = (float) sx / (float) sy;
}
void main(void)
{
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(400, 400);
glutInitWindowPosition(100, 100);
glutCreateWindow("Ejemplo de proporcion");
glutDisplayFunc(display);
glutReshapeFunc(onSize);
glutMainLoop();
}

12
7. Conclusión:

 La proyección en OpenGL es una buena elección para generación de efectos visuales,

escenas, etc, debido a su portabilidad, estandarización y potencia gráfica.
 La proyección en OpenGL esta pasando a segundo plano ante los nuevos programas
de diseño que realizan tareas automáticamente.
 Se prevee que con la versión 2.0 se produzca un relanzamiento.
 Fue muy interesante trabajar proyecciones en openGL y darnos cuenta que es muy
importante

13
8. Bibliografía

 Agoston, M., Computer graphics & geometric modeling / Mathematics, Springer-Verlag

London Ltd., 2005

 Angel, E., Shreiner, D., Interactive Computer Graphics: A top-down approach with
shader-based OpenGL, Addison Wesley, 6th. Ed., 2011

 Barnsley, M., Fractals Everywhere, Academic Press, Boston, 2000

 Blinn, J., Jim Blinn's Corner: A Trip Down The Graphics Pipeline, Morgan Kaufmann
Publishers, Inc., San Francisco, 1996

 Blinn, J., Jim Blinn's Corner: Dirty Pixels, Morgan Kaufmann Publishers, Inc., San
Francisco, 1998

 Tapa del libro

 Cunningham, S., Computer Graphics, Prentice Hall, 2007

 Eberly, D., 3D Game Engine Design: A Practical Approach to Real-Time Computer

Graphics, Morgan Kaufmann, 2006.

 Foley, J., Van Dam, A., Fundamentals of Interactive Computers Graphics, Addison-
Wesley, Reading, Massachussetts, 2nd Edition, 1992

 Hearn, D. Jr., Baker, M.P., Computer Graphics C versionL, 3rd Edition, Prentice Hall,
2003

 Hill, F. Jr., Kelley, S., Computer Graphics using OpenGL, 3rd Edition, Prentice Hall,
2006

 Mandelbrot, B., The Fractal Geometry of Nature, W.H.Freeman, New York, 1983

 Mc Reynolds , T., Blythe, D., Advanced Graphics Programming Using OpenGL, Morgan
Kaufmann, 2005

 Nguyen, H., GPU Gems 3, Addison Wesley, 2007

 Parent, R., Computer Animation. Algorithms and Techniques, 2nd. Edition, Morgan
Kaufman, 2007

14