martes, 6 de marzo de 2007

Previo Practica 2

Laboratorio de Computación Gráfica

Cuestionario previo #2
- Modelado Geométrico -

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

Transformaciones: una transformación T es una función que nos cambia un punto Q o un vector v en otro punto P o en otro vector u: P = T (Q); u = T (v), una transformación cualquiera debería ser aplicada punto a punto a todos los puntos de una escena.
Las transformaciones nos ayudan a:
Manipular objetos en el espacio 3D
Ayuda para visualizar y examinar objetos

Tipos de transformaciones afines:
– Traslación
– Rotación
– Escalado
– Cizallado
– Reflexión

Traslación: Desplazamos el origen y los ejes de forma paralela. En dos y tres dimensiones, siendo dx, dy, dz las distancias de traslación:





Rotación: En dos dimensiones: si giramos los ejes un ángulo (positivo si gira en sentido anti-horario)

En tres dimensiones: ahora tenemos tres rotaciones diferentes respecto cada uno de los ejes coordenados (igualmente, consideramos sentido positivo si gira en sentido anti-horario) La rotación sobre Z es prácticamente igual que antes, aunque ahora tenemos que usar una matriz (3x3):

Para la rotación sobre X, también es prácticamente igual que antes, solamente que el eje que antes era X será ahora Y, y el que antesera Y, Z (igualmente, consideramos sentido positivo si gira en sentido anti-horario)

Si rotamos respecto de Y, lo que en Rz era X ahora será Z, y donde teníamos Y, ahora habrá que poner Z. Por tanto hay queintercambiar también filas y columnas en la matriz de rotación...

Las matrices de rotación son ortonormales. Podemos invertirlas por transposición.
La rotación sobre un eje cualquiera va a necesitar, en general, ser realizada como una composición de varias transformaciones:
1. Traslación del eje de rotación (y los objetos a rotar) de forma que el eje pase por el origen
2. Descomposición de la rotación en rotaciones simples respecto a los tres ejes de coordenadas X, Y y Z
3. Deshacer la traslación, efectuando la inversa que se hizo en (1)
Escalado uniforme y no uniforme: Variamos la escala en los ejes coordenados con el mismo factor de escala o diferente para cada eje (factores de escala si iguales o diferentes)

Cizallado:
• No mantiene los ángulos, aunque sí las rectas y el paralelismo
• Menos utilizada en gráficos
• En tres dimensiones es análoga, si bien nos aparecen nuevos coeficientes adicionales

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(x,y,z); nos va a permitir trasladar un objeto en el espacio
Rotación: void glRotate(angulo,x,y,z); nos va a permitir rotar un objeto
Escalado: void glScale(x,y,z); nos va a permitir escalar un objeto

Donde: x,y,z son las coordenadas de un punto.

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: la matriz que contiene las transformaciones originadas por los
cambios de modelado y posición de la cámara.
GL_PROJECTION: la matriz con las transformaciones que realizan la proyección de la
escena de 3 a 2 dimensiones.

Estas dos matrices sirven para hacer una operación de transformación. Se especifica con la función glMatrixMode(Glenum mode) que tiene como argumento una de las tres constantes enumeradas. Se comporta como un estado, por tanto, hasta que se especifique un nuevo estado todas las transformaciones se realizan sobre la última matriz especificada.
En el código de la función resaphe() del capítulo anterior:
void reshape(int width, int height) {
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat)height / (GLfloat)width, 1.0, 128.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0, 1.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}
Se observa que se utiliza la función glMatrixMode() dos veces, la primera con
GL_PROJECTION y la segunda con GL_MODELVIEW .
Despues de la primera llamada a glMatrixMode(), la matriz sobre la que se realizarán
las transformaciones es GL_PROJECTION, la primera operación es inicializar la matriz con la función glLoadIdentity() que carga la matriz identidad y se define una proyección perspectiva con la función gluPerspective(). Esta función se explica en el siguiente capítulo.
Despues de la segunda llamada a glMatrixMode(), la matriz sobre la que se realizarán
las transformaciones es GL_MODELVIEW, igualmente, la primera operación es inicializar la matriz con la función glLoadIdentity() y a continuación se establece la posición de la cámara con gluLookAtAl comportarse OpenGL como una máquina de estados, las siguientes operaciones de transformación que se realicen en el código, que estarán fuera de la función resaphe(), se realizarán sobre la última matriz especificada, es decir sobre GL_MODELVIEW.

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

glPushMatrix(); // 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, al llamar a la función glPushMatrix() se duplica la matriz superior. Las siguientes transformaciones que se realizan se aplican sólo a la matriz superior de la pila, quedando la anterior con los valores que tenía en el momento de llamar a la función glPushMatrix().
glPopMatrix(); La función 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().

glColor4f(1.0,0.0,0.0,1.0);
dibujarCuadro(1.0);
glPushMatrix();
glTranslatef(0.0, 2.0, 0.0);
dibujarCuadro(0.5);
glPopMatrix();
glPushMatrix();
glTranslatef(0.0, -2.0, 0.0);
dibujarCuadro(0.5);
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.

Para crear cualquier figura geométrica en OpenGL hay que definir los vértices entre un par de llamadas a las funciones glBegin() y glEnd(). A la función glBegin se le puede pasar un argumento que determina qué tipo de figura geométrica se va construir. Después se definen los vértices mediante llamadas a la función glVertex. A continuación vemos un ejemplo en el que se define el polígono.
glBegin (GL_POLYGON);
glVertex2f (0.0, 0.0);
glVertex2f (0.0, 3.0);
glVertex2f (3.0, 3.0);
glVertex2f (4.0, 1.5);
glVertex2f (3.0, 0.0);
glEnd ();
void glBegin (GLenum mode); Marca el principio de una lista de vértices que describen una primitiva geométrica. El parámetro mode índica el tipo de primitiva(GL_POINTS Puntos individuales. GL_LINES Cada Par de vértices forman un segmento individual.
GL_POLYGON Vértices de polígono simple y conexo. GL_TRIANGLES Cada terna determina un triángulo. GL_QUADS Cada cuátrupla determina un cuadrado. GL_LINE_STRIP Series de segmentos conectados. GL_LINE_LOOP Series de segmentos conectados y cerrados. GL_TRIANGLE_STRIP Cadenas de triángulos conectados. GL_TRIANGLE_FAN Cadenas de polystrip (el centro es el primer
vértice). GL_QUAD_STRIP Cuadriláteros encadenados.)
void glEnd (void); Marca el final de una lista de vértices.

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

Modelado Geométrico: es una técnica que puede generar distintos tipos de objetos.
Los modelos pueden clasificarse en: alambritos, de superficies (planas o curvas) y sólidos. Los modelos de superficies curvas se dividen en: paramétricas(analíticas y sintéticas) y no paramétricas(explícitas e implícitas). Los modelos sólidos más importantes son: semi-espacios,frontera,CSG, barrido, enumeración espacial,etc.
Entre los modelos no convencionales se encuentran: los fractales, los de gramáticas, los sistemas de partículas, los blobs, y los basados en propiedades físicas.

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.


#include
#include

void init(void)
{
glClearColor (0.0, 0.0, 1.0, 0.0);
glShadeModel (GL_FLAT);
}

void cube(void){
GLfloat vertices[][]={{0.55,0.5,0.5},
{-0.5,-0.5,0.5},
{0.5,-0.5,0.5},
{-0.5,0.5,0.5},
{-0.5,-0,5,-0.5},
{-0.5,0.5,-0.5},
{0.5,0.5,-0.5}};
glBegin(GL_QUADS);
glVertex3fv(vertices[0]);
glVertex3fv(vertices[1]);
glVertex3fv(vertices[2]);
glVertex3fv(vertices[3]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[5]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[7]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[1]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[5]);
glVertex3fv(vertices[2]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[0]);
glVertex3fv(vertices[3]);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[7]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[0]);
glVertex3fv(vertices[7]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[1]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[2]);
glVertex3fv(vertices[5]);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[3]);
glEnd();
}
void display(void)
{

glPushMatrix();
glTranslatef(0.0,1.25,0.0);
glPushMatrix();
glTranslatef(0.25,1.5,0.0);
glScalef(1.5,0.5,0.5);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(0.25,2.0,0.0);
glScalef(1.0,2.0,0.5);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(-4.75,1.75,0.0);
glScalef(0.5,2.0,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(1.5,0.0,0.0);
glScalef(2.0,1.5,0.5);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(2.0,0.0,0.0);
glScalef(2.0,0.5,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(-1.5,0.0,0.0);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(-2.0,0.0,0.0);
glScalef(2.0,1.5,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(-2.0,0.75,0.0);
glScalef(2.0,0.5,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,-2.0,0.0);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(0.75,-2.5,0.0);
glScalef(2.0,3.0,0.5);
cube();
glPopMatrix();
glPushMatrix();
glScalef(0.5,2.0,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(0.25,-2.0,0.0);
glScalef(1.0,2.0,1.0);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(0.5,-1.5,0.0);
glScalef(1.5,0.5,0.5);
cube();
glPopMatrix();
glPopMatrix();

}
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 (500, 300);
glutInitWindowPosition (300,230);
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.

void glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
Activa el color de fondo actual, siguiendo el modelo de representación RGB. Cada argumento representa la cantidad del color indicado que tiene el color de fondo, y toma valores en el intervalo [0, 1. El valor por defecto es el color NEGRO que se representa por el valor: (0, 0, 0, 0).
void display(void)
{
glClearColor(0.0,0.0,0.0,0.0);
// Color de fondo: negro
glClear(GL_COLOR_BUFFER_BIT);
// Boramos la pantalla
glMatrixMode(GL_PROJECTION);
// Modo proyección
glLoadIdentity();
// Cargamos la matriz identidad
glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0);
// Proyección ortográfica, dentro del cubo señalado
glMatrixMode(GL_MODELVIEW);
// Modo de modelado
glBegin(GL_TRIANGLES);
// Dibujamos un triángulo
glColor3f(1.0,0.0,0.0);
// Color del primer vértice: rojo
glVertex3f(0.0,0.8,0.0);
// Coordenadas del primer vértice
glColor3f(0.0,1.0,0.0);
// Color del segundo vértice: verde
glVertex3f(-0.6,-0.2,0.0);
// Coordenadas del segundo vértice
glColor3f(0.0,0.0,1.0);
// Color del tercer vértice: azúl
glVertex3f(0.6,-0.2,0.0);
// Coordenadas del tercer vértice
glEnd();
// Terminamos de dibujar
glFlush();
// Forzamos el dibujado
sleep(10);
// Esperamos 10 segundos
exit(0);
// Salimos del programa
}

void glClear (GLbitfield mask);
Limpia el buffer especificado por el parámetro, inicializándolo al valor que tenía asignada la variable de estado anteriormente. Los posibles valores del argumento, es decir los posibles buffers que tenemos son los siguientes:
Color Buffer GL_COLOR_BUFFER_BIT
Depth Buffer GL_DEPTH_BUFFER_BIT
Accumulate Buffer GL_ACCUM_BUFFER_BIT
Stencil Buffer GL_STENCIL_BUFFER_BIT

void display(void) {
glClear(GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glMultMatrixd(mModel);
glColor3f(1.0,1.0,0.0) ;
drawTurtle();
glPopMatrix();
displayTrace();
glutSwapBuffers();
}
9. Describa los comandos glutInit(), glutInitDisplayMode (), glutInitWindowSize (), glutInitWindowPosition (), glutCreateWindow (), glutDisplayFunc(), glutReshapeFunc(), glutKeyboardFunc() y glutMainLoop(). Describa su funcionamiento, uso y parámetros.

Void glutInit(&argc, argv); que inicializa la GLUT, y negocia con el sistema de ventanas para abrir una. Los parámetros deben ser los mismos argc y argv sin modificar de la main(). Glut entiende una serie de parámetros que pueden ser pasados por línea de comandos.

void glutDisplayFunc( void (*func) (void)) La función func() se llamará cada vez que haya que redibujar la ventana. Inicializa el buffer de la pantalla inicial, esn este caso es el modo y tipo de colores en la pantalla(RGB/RGBA)


void glutReshapeFunc(void (*func) (int width, int height)) La función func(width, height) se llamará cada vez
que la ventana cambie de tamaño, y recibirá como parámetros la nueva anchura y altura.

glutInitDisplayMode. Inicializar el modo de visualización. En este caso, estamos activando el buffer de profundidad (GLUT_DEPTH), el doble buffering (GLUT_DOUBLE) y la renderización en RGB (GLUT_RGB).

glutInitWindowSize (anchura, altura). Inicializar el tamaño de la ventana.

glutInitWindowPosition(x, y). Inicializar la posición de la ventana en el escritorio.

glutCreateWindow(char* titulo). Crear la ventana. Esta función muestra una ventana del tamaño y posición definidas y con el título que le hayamos puesto.

Void glutKeyboardFun(void (*func)(unsigned char key, int x,int y)): Se encarga de la interacción de eventos en el teclado. maneja el control del teclado, haciendo un transición ente ASCII y GLUT

Void glutMainLoop(); es el bucle principal de la visualización, se encarga de interaccionar con eventos. esta función inicializa el framework running de GLUT, y procesa los mensajes de sistema operativo

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

La ejecución de esta función espera a que se produzcan eventos. Cada vez que se produce un evento lo atiende y ejecuta la función registrada, encargada de responder al evento (función de callback).




1 comentario:

mgomez1974 dijo...

Lo felicito, ahora mismo colocare un enlace dentro de mi pagina ya que me sera de mucha utilidad en los examenes escritos.
http://mgomez1974.googlepages.com