Previo Práctica 2

PREVIO 2

1. ¿Qué es una transformación geométrica? ¿Cuáles son las transformaciones básicas y sus matrices

Una transformación geométrica es una aplicación que hace corresponder a cada punto de un plano con cada punto de otro plano. Así, las figuras se transforman en otras figuras.

A continuación, se presentan las transformaciones básicas y sus matrices:

Translación

P’= T (dx, dy) P = | 1 0 dx | | x | | x + dx |

| 0 1 dy | | y | = | y + dy |

| 0 0 1 | | 1 | | 1 |

Escalado

P’= S (sx, sy) P = | sx 0 0 | | x | | x (sx) |

| 0 sy 0 | | y | = | y (sy) |

| 0 0 1 | | 1 | | 1 |

Rotación

| sen(θ) cos(θ) 0 | | y | = | xsen(θ) + ycos(θ) |

| 0 0 1 | | 1 | | 1 |

Translación

P’= T (dx, dy, dz) P = | 1 0 0 dx | | x | | x + dx |

| 0 1 0 dy | | y | = | y + dy |

| 0 0 1 dz | | z | | z + dz |

| 0 0 0 0 | | 1 | | 1 |

Escalado

P’= S (sx, sy) P = | sx 0 0 0 | | x | | x (sx) |

| 0 sy 0 0 | | y | = | y (sy) |

| 0 0 sz 0 | | z | | z (sz) |

| 0 0 0 1 | | 1 | | 1 |

Rotación en X

P’= Rx (θ) P = | 1 0 0 0 | | x | | x |

| 0 cos(θ ) -sen(θ) 0 | | y | = | ycos(θ) – zsen(θ) |

| 0 0 0 1 | | 1 | | 1 |

Rotación en Y

| 0 1 0 0 | | y | = | y |

| 0 0 0 1 | | 1 | | 1 |

Rotación en Z

| sen(θ) cos(θ) 0 0 | | y | = | xsen(θ) + ycos(θ) |

| 0 0 1 0 | | z | | z |

| 0 0 0 1 | | 1 | | 1 |

2. Escriba los comandos que en OpenGL permiten aplicar transformaciones geométricas, las variantes de dichos comandos y describa sus parámetros.

Translación: void glTranslate{fd}(TYPE x, TYPE y, TYPE z);

Variaciones: glTranslated, glTranslatef (para datos double y float, respectivamente).

Rotación: void glRotate{fd}(TYPE angle,TYPE x, TYPE y, TYPE z);

Variaciones: glRotated, glRotatef (para datos double y float, respectivamente).

Escalación: void glScale{fd}(TYPE x, TYPE y, TYPE z);

Variaciones: glScaled, glScalef (para datos double y float, respectivamente).

En todos los casos, los parámetros (TYPE x, TYPE y, y TYPE z) son los datos por los cuales se van a multiplicar las coordenadas.

3. Describa en OpenGL qué son las matrices GL_MODELVIEW y GL_PROJECTION. ¿Para qué sirven? ¿Cómo se puede intercambiar entre una y otra? ¿Cuál es la matriz activa por defecto? ¿Para que sirve el comando glLoadIdentity()?

GL_MODELVIEW es la matriz que contiene las transformaciones originadas por los cambios de modelado y posición de la cámara; GL_PROJECTION es la matriz con las transformaciones que realizan la proyección de la escena de 3 a 2 dimensiones.

La matriz MODELVIEW determina cómo los vértices de las primitivas de OpenGL se transforman a coordenadas de ojo. La matriz PROJECTION transforma coordenadas de ojo a coordenadas de clip.

Se especifica con la función glMatrixMode(Glenum mode) que tiene como argumento las funciones mencionadas. Se comporta como un estado; por tanto, hasta que se especifique un nuevo estado, todas las transformaciones se realizan sobre la última matriz especificada.

La matriz activa por defecto es la GL_MODELVIEW.

El comando glLoadIdentity() sirve para cargar la matriz identidad y definir una proyección perspectiva con la función gluPerspective().

4. ¿Para qué son los comandos glPushMatrix() y glPopMatrix()? Describa su uso a través de un ejemplo en código.

La función glPushMatrix() realiza una copia de la matriz superior y la pone encima de la pila, de tal forma que las dos matrices superiores son iguales; glPopMatrix() elimina la matriz superior, quedando en la parte superior de la pila la matriz que estaba en el momento de llamar a la función glPushMatrix().

Ejemplo de código:

glPushMatrix();

apply_sphere_transformation();

glPushMatrix();

apply_cube_transformation();

draw_cube();

glPopMatrix()M

draw_sphere();

glPopMatrix();

5. ¿Para qué sirven los comandos glBegin() y glEnd()? Describa su uso, sus parámetros y ejemplifique a través de una pieza de código.

glBegin() y glEnd() se emplean para delimitar los vértices de un primitivo o de un grupo de primitivos parecidos. Con la instrucción glBegin() se debe elegir el tipo de objeto que se va a crear.

A continuación, se presenta un ejemplo en el que se forman triángulos con estas funciones:

glBegin(GL_TRIANGLES);

glVertex3f(100.0f, 100.0f, 0.0f);

glVertex3f(150.0f, 100.0f, 0.0f);

glVertex3f(125.0f, 50.0f, 0.0f);

glEnd( );

6. ¿Qué es modelado geométrico? Describa los tipos de modelado geométrico que existen.

Un modelo geométrico describe la forma de un objeto físico o matemático por medios de conceptos geométricos. El modelado geométrico es la construcción o uso de modelos geométricos. Los modelos geométricos se utilizan en computación gráfica, diseño auxiliado por computadora y manufactura y pueden aplicarse a muchos campos, tales como el procesamiento de imágenes de medicina.

7. Construya código para dibujar un cubo (revisar en la clase de teoría), y a partir de éste modele jerárquicamente el humanoide de la ilustración y escriba el programa que lo dibuja. Las medidas corren por su cuenta.

A continuación, se presenta el código implementado para el despliegue de la figura humanoide.

/** humanoide.c

Este programa despliega una figura humanoide la cual está formada únicamente por cubos de diferentes tamaños, todos creados a partir del cubo base visto en laboratorio la sesión pasada. La estructura desplegada NO está jerarquizada.*/

#include

void init(void)

{

glClearColor (0.0, 0.0, 0.0, 0.0);

glShadeModel (GL_FLAT);

}

void display(void)

{

glClear (GL_COLOR_BUFFER_BIT);

glColor3f (1.0, 1.0, 1.0);

glLoadIdentity (); /* Carga la matriz identidad */

gluLookAt (0.0, 0.0, 9.5, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

/* Posición de la cámara */

/*Comandos para desplegar el torso*/

glPushMatrix();

glScalef (2.0, 3.0, 1.0);

glTranslatef(0.0,0.5,0.0);

glutWireCube(1.0);

glPopMatrix();

/*Comandos para desplegar la cabeza*/

glPushMatrix();

glTranslatef(0.0,3.5,0.0);

glutWireCube(1.0);

glPopMatrix();

/*Comandos para desplegar el brazo derecho*/

glPushMatrix();

glScalef (2.0, 0.5, 1.0);

glTranslatef(1.0,5.5,0.0);

glutWireCube(1.0);

glPopMatrix();

/*Comandos para desplegar el antebrazo derecho*/

glPushMatrix();

glScalef (2.0, 1.0, 1.0);

glTranslatef(2.0,2.75,0.0);

glutWireCube(1.0);

glPopMatrix();

/*Comandos para desplegar la mano derecha*/

glPushMatrix();

glScalef (0.5, 0.5, 1.0);

glTranslatef(10.5,5.5,0.0);

glutWireCube(1.0);

glPopMatrix();

/*Comandos para desplegar el brazo izquierdo*/

glPushMatrix();

glScalef (2.0, 0.5, 1.0);

glTranslatef(-1.0,5.5,0.0);

glutWireCube(1.0);

glPopMatrix();

/*Comandos para desplegar el antebrazo izquierdo*/

glPushMatrix();

glScalef (-2.0, 1.0, 1.0);

glTranslatef(2.0,2.75,0.0);

glutWireCube(1.0);

glPopMatrix();

/*Comandos para desplegar la mano izquierda*/

glPushMatrix();

glScalef (0.5, 0.5, 1.0);

glTranslatef(-10.5,5.5,0.0);

glutWireCube(1.0);

glPopMatrix();

/*Comandos para desplegar el muslo derecho*/

glPushMatrix();

glScalef (0.5, 2.5, 1.0);

glTranslatef(1.5,-0.5,0.0);

glutWireCube(1.0);

glPopMatrix();

/*Comandos para desplegar la pantorrilla derecha*/

glPushMatrix();

glScalef (1.0, 2.5, 1.0);

glTranslatef(0.75,-1.5,0.0);

glutWireCube(1.0);

glPopMatrix();

/*Comandos para desplegar el pie derecho*/

glPushMatrix();

glScalef (1.75, 0.5, 1.0);

glTranslatef(0.635,-10.5,0.0);

glutWireCube(1.0);

glPopMatrix();

/*Comandos para desplegar el muslo izquierdo*/

glPushMatrix();

glScalef (0.5, 2.5, 1.0);

glTranslatef(-1.5,-0.5,0.0);

glutWireCube(1.0);

glPopMatrix();

/*Comandos para desplegar la pantorrilla izquierda*/

glPushMatrix();

glScalef (1.0, 2.5, 1.0);

glTranslatef(-0.75,-1.5,0.0);

glutWireCube(1.0);

glPopMatrix();

/*Comandos para desplegar el pie izquierdo*/

glPushMatrix();

glScalef (1.75, 0.5, 1.0);

glTranslatef(-0.635,-10.5,0.0);

glutWireCube(1.0);

glPopMatrix();

glFlush ();

}

void reshape (int w, int h)

{

glViewport (0, 0, (GLsizei) w, (GLsizei) h);

glMatrixMode (GL_PROJECTION);

glLoadIdentity ();

glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);

glMatrixMode (GL_MODELVIEW);

}

/* ARGSUSED1 */

void keyboard(unsigned char key, int x, int y)

{

switch (key) {

case 27:

exit(0);

break;

}

int main(int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

glutInitWindowSize (700, 700);

glutInitWindowPosition (100, 100);

glutCreateWindow (argv[0]);

init ();

glutDisplayFunc(display);

glutReshapeFunc(reshape);

glutKeyboardFunc(keyboard);

glutMainLoop();

return 0;

}

8. ¿Para qué sirven los comandos glClearColor() y glClear()? Descríbalos su funcionamiento, sus parámetros y ejemplifique a través de una pieza de código.

glClear() fija el área de mapa de bits de la ventana a valores preestablecidos por glClearColor, glClearIndex, glClearDepth, glClearStencil y glClearAccum. Sus argumentos son: GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT, GL_STENCIL_BUFFER_BIT

glClearColor() especifica los valores alpha rojo, verde y azul utilizados por glClear() para limpiar el búffer de colores. Los valores especificados por glClearColor() se limitan al rango [0, 1].

9. Describa los comandos glutInit(), glutInitDisplayMode (), glutInitWindowSize (), glutInitWindowPosition (), glutCreateWindow (), glutDisplayFunc(), glutReshapeFunc(), glutKeyboardFunc() y glutMainLoop(). Describa su funcionamiento, uso y parámetros.

glutInit(): se utiliza para inicializar la librería de GLUT.

Sus parámetros son: void glutInit(int *argcp, char **argv); donde argcp es un apuntador a la variable sin modificar argc desde main. Argv es el valor de la variable sin modificar desde main; esta información será actualizada ya que esta función extrae cualquier opción de comando entendida por la librería de GLUT.

glutInitDisplayMode(): fija el modo de display inicial.

Sus parámetros son: void glutInitDisplayMode(unsigned int mode); el valor entero que se utiliza de argumento funciona como un selector de las máscaras del modo de despliegue.

glutInitWindowSize(): la ventana creada por glutCreateWindow, al utilizar esta función, le será indicado que sea creada bajo el tamaño inicial de ventana especificado. Los parámetros son: void glutInitWindowSize(int width, int height); es decir, int width – ancho e int height – largo.

glutInitWindowPosition(): la ventana creada por glutCreateWindow, al utilizar esta función, le será indicado que sea creada en la posición especificada.

Los parámetros son: void glutInitWindowPosition(int x, int y); es decir, int x – coordenada en x e int y – coordenada en y.

glutCreateWindow(): crea una ventana.

Su parámetro es int glutCreateWindow(char *name); donde name es el nombre que se le va a asignar a la ventana con el cual el sistema de ventanas va a reconocerla.

glutDisplayFunc(): obtiene el callback de display para la ventana actual. Cuando GLUT determina que el plano normal para la ventana necesita ser vuelto a ser mostrado, el callback de display para la función es llamado. Antes de ello, la ventana actual cambia su valor a la ventana que necesita ser mostrada de nuevo y la capa en uso cambia al plano normal. No tiene parámetros.

Se emplea del modo siguiente: void glutDisplayFunc(void (*func)(void));

glutReshapeFunc(): esta función callback especifica cuál función será llamada cada vez que la ventana sea redimensionada o movida; pero también se utiliza para definir inicialmente el área de proyección de la figura en la ventana.

Sus parámetros son: void glutReshapeFunc(void (*func)(int width, int height)); donde func es la nueva función que será llamada cada vez que la ventana sea redimensionada.

glutKeyboardFunc(): especifica la rutina de servicio a ejecutar cada vez que se pulsa una de las teclas correspondiente a un código ASCII.

Sus parámetros son: void glutKeyboardFunc(void (*function)(unsigned char key, int x, int y)); donde el argumento function es un puntero a la función que actúa como rutina de servicio. Esta función espera tres parámetros: el carácter de la tecla pulsada y la posición del ratón sobre la ventana en coordenadas del mundo real.

glutMainLoop(): entra al evento de procesamiento del GLUT en un ciclo infinito; este comando debe ser utilizado por lo menos una vez en cada ocasión que se quiera utilizar GLUT. Una vez llamada nunca se saldrá del proceso, pero llamara todas las rutinas necesarias para el uso de GLUT.

A continuación, se presenta su modo de empleo: void glutMainLoop(void);

10. ¿Qué es un Function Callback en GLUT?

Una Function Callback es una que no se invoca explícitamente por el programador; en vez de ello, la responsabilidad de su invocación se delega a otra función que recibe la dirección de la función Callback.

Fuentes:

http://www.opengl.org/documentation/specs/glut/spec3/node16.html

http://www.google.com/search?sourceid=navclient-ff&ie=UTF-8&rls=DVFB,DVFB:1970--2,DVFB:en&q=glpushmatrix

http://www.tecnun.es/asignaturas/grafcomp/OpenGL/practica/capitulo3.pdf

http://wwwdi.ujaen.es/asignaturas/igaplicada/pdf/tema3.pdf

http://usuarios.lycos.es/andromeda_studios/paginas/tutoriales/tutgl005.htm

http://www.falloutsoftware.com/tutorials/gl/gl2p5.htm

http://www.tutorials-blog.com/opengl/glPushMatrix-glPopMatrix/

Rafa - Computación Gráfica

Archivo del Blog

Acerca de mí

lunes, 5 de marzo de 2007

Previo Práctica 2

No hay comentarios.: