Problema II de examen

1. Resultados de los vertices despues de cada transformacion, usando excel

2. Programas en opengl de las transformaciones mencionadas:
a) tomando como base los vertices iniciales para cada transformación

#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();

glTranslatef (-2,-2,0);
glColor3f (1,1,.8);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Traslacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}

#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();

glScalef (0.5,0.5,0.0);
glColor3f (1,1,.8);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Escalacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}

#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();

glRotatef(45.0,0,0,1);
glColor3f (1,1,.8);
glBegin(GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Rotacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}

b) tomando las transformaciones en secuencia, es decir despues de la traslacion a los vertices resultantes aplicar la escalacion y al resultado aplicar la rotación.

#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();

glTranslatef (-2,-2,0);
glColor3f (1,1,.8);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Translacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}

#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (0,0);
glVertex2f (5,0);
glVertex2f (5,5);
glVertex2f (0,5);
glEnd();

glScalef (0.5,0.5,0.0);
glColor3f (1,1,.8);
glBegin (GL_POLYGON);
glVertex2f (0,0);
glVertex2f (5,0);
glVertex2f (5,5);
glVertex2f (0,5);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Escalacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}

#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (0,0);
glVertex2f (2.5,0);
glVertex2f (2.5,2.5);
glVertex2f (0,2.5);
glEnd();

glRotatef(45.0,0,0,1);
glColor3f (1,1,.8);
glBegin(GL_POLYGON);
glVertex2f (0,0);
glVertex2f (2.5,0);
glVertex2f (2.5,2.5);
glVertex2f (0,2.5);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Rotacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}

Pelota que rebota

#include <GL/glut.h>
float escala=0.5; //tamaño de la Esfera.
int ResX=300,ResY=200;
float angX=0.0f,angY=0.0f;
enum{EJE=2};
float angB=0.0f,angC=0.0f,angDE=0.0f;
float aceX=0.0f,aceY=-0.00001f; //Entre mas pequeño sea el valor de la aceleracion de Y la pelota tarda mas
//tiempo en rebotar.
float velX=0.001f,velY=0.0f;
float posX=0.0f,posY=10.0f;
//Definición de las caracteristicas opticas del material: coeficientes de reflexión
GLfloat material [4] = {1.0f, 0.2f, 0.2f, 1.0f };
GLfloat RedMaterial [4] = {1.0, 1.0, 0.0, 1.0 };
GLfloat GreenMaterial [4] = {0, 0.0, 1.0, 1.0 };
GLfloat BlueMaterial [4] = {1.0, 1.0, 1.0, 0.6 };
GLfloat WhiteMaterial [4] = {0.6, 0.0, 0.0, 1.0 };
GLfloat BlackMaterial [4] = {0.6, 1.0, 0.4, 1.0 };
GLfloat GrayMaterial [4] = {0.7, 0.6, 0.6, 1.0 };
void pEJE(){
glNewList(EJE,GL_COMPILE);
glPushMatrix();
glutSolidSphere(1.0f,50,50);
glPopMatrix();
glEndList();
}
void RenderScene(void){
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
//CÁMARA
glLoadIdentity( );
glTranslatef(0.0f,0.0f,-5.0f);
glRotatef(angY,1.0f,0.0f,0.0f);
glRotatef(angX,0.0f,1.0f,0.0f);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, GreenMaterial );
glPushMatrix();
glTranslatef(posX,posY,0.0f);
glCallList(EJE);
glPopMatrix();
//glFlush();
glutSwapBuffers();
}
//esta funcion se usa para el rebote de la esfera.
void idle(void){
velY+=aceY; posY+=velY;
velX+=aceX; posX+=velX;
if(posY<0.0f){posY=0.0f; velY*=-0.8f;
if(velY<0.01f){velX=0.0f; velY=0.0f;}
}
glutPostRedisplay();
}
int main(int a, char *b[]){
glutInit(&a,b);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(ResX,ResY);
glutInitWindowPosition(200,300);
glutCreateWindow("REBOTA");
glutDisplayFunc(RenderScene);
glutIdleFunc(idle);
glViewport( 0, 0, ResX, ResY );
glMatrixMode( GL_PROJECTION );
glLoadIdentity( );
glFrustum(-(float)ResX/ResY, (float)ResX/ResY, -1.0, 1.0, 2, 10000.0);
glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glShadeModel(GL_SMOOTH);
pEJE();
glutMainLoop();
return 0;
}

Glosario

CAVE (Cave Automatic Virtual Environment). Es un entorno de realidad virtual inmersiva. Se trata de una sala en forma de cubo en la que hay proyectores orientados hacia las diferentes paredes, suelo y techo. Dependiendo del resultado que se quiera obtener se proyectará la imagen a todas o sólo alguna de las paredes de la sala.

Coordenadas Homogéneas. Las coordenadas homogéneas son un instrumento usado para describir un punto en el espacio proyectivo. Su notación en forma matricial se emplea en bibliotecas de programación gráfica en 3D como OpenGL y Direct3D.

Diafana. Que deja pasar a través la luz casi en su totalidad.

Ecografía. Es un procedimiento de imagenología que emplea los ecos de una emisión de ultrasonidos dirigida sobre un cuerpo u objeto como fuente de datos para formar una imagen de los órganos o masas internas con fines de diagnóstico. 

Espejo cóncavo. Es el que con su superficie forma un paraboloide de revolución, todos los rayos que inciden paralelos al eje del espejo, se reflejan pasando por el foco, y los que inciden pasando por el foco, se reflejan paralelos al eje.

Estereoscopía. Es cualquier técnica capaz de recoger información visual tridimensional y/o crear la ilusión de profundidad mediante una imagen estereográfica, un estereograma, o una imagen tridimensional.

Holografía. Es una técnica avanzada de fotografía, que consiste en crear imágenes tridimensionales. Para esto se utiliza un rayo láser, que graba microscópicamente una película fotosensible. Ésta, al recibir la luz desde la perspectiva adecuada, proyecta una imagen en tres dimensiones.

Obturador. Es el dispositivo que controla el tiempo durante el que llega la luz al dispositivo fotosensible. Este tiempo es conocido como la velocidad de obturación, y de él se desprenden conceptos como el congelado o el barrido fotográfico.

Pila (programacion). Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de informática debido a su simplicidad y ordenación implícita de la propia estructura.

Proyector LCD. El sistema de pantalla de cristal líquido es el más simple, por tanto uno de los más comunes y accesibles para el uso doméstico.
Realidad virtual inmersiva. Los métodos inmersivos de realidad virtual con frecuencia se ligan a un ambiente tridimensional creado por un ordenador, el cual se manipula a través de cascos, guantes u otros dispositivos que capturan la posición y rotación de diferentes partes del cuerpo humano.

Reconstrucción 3D. Es el proceso mediante el cual, objetos reales, son reproducidos en la memoria de una computadora, manteniendo sus características físicas.

Viewport

Aplicaciones
·         Tener varias áreas de dibujo y proyección en una ventana
·         Mantener la proporción del aspecto

SINTAXIS
glViewport(Xminimo, Yminimo,Anco,Alto)

La pila de matrices

En la función display() se encuentran las llamadas a dos funciones de matrices que todavía no han sido comentadas. Se trata de glPushMatrix() y glPopMatrix(). Para comprender su funcionamiento, primero se va a experimentar que es lo que ocurre cuando no están dichas llamadas. Para ello se comentan en la función display() ambas llamadas:
void display(void) {
...
// glPushMatrix();
...
glTranslatef(0.0, 0.0, .5);
...
// glPopMatrix();
glutSwapBuffers();
}

La razón de este movimiento es que en la función display está incluida una llamada a glTranslatef() que se utiliza para posicionar uno de los objetos. Como se ha explicado anteriormente, las funciones de traslación multiplican la matriz actual por una matriz de traslación creada con los argumentos que se le pasan, por tanto, sucesivas llamadas a la función display() provocan sucesivas multiplicaciones de la matriz actual con el efecto que se observa de incrementar la traslación.
Para solucionar este problema OpenGL dispone de unos stacks o pilas de matrices, que permiten almacenar y recuperar una matriz anterior. Aunque OpenGL dispone de pilas para las matrices GL_MODELVIEW y GL_PROJECTION, sólo se suele utilizar la pila de GL_MODELVIEW.
Una pila es un almacén con funcionamiento LIFO, el último en entrar es el primero en salir, por lo que suele comparar a una pila de platos en la que sólo se puede dejar uno encima de la pila o coger el superior que es el último depositado. La pila de matrices tiene el mismo funcionamiento sustituyendo los platos por matrices. La matriz superior de la pila es sobre la que se aplican las distintas transformaciones, multiplicándola por la matriz que generan las distintas funciones.
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. En la figura 1 se observa la pila en la situación inicial con una sola matriz, 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().
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().

Dibujando un rastro

Una característica de Logo es que la tortuga al avanzar va dibujando el camino por el que ha pasado. Hasta ahora la aplicación va transformando las coordenadas del objeto para situarlo en la nueva posición según las instrucciones introducidas pero no muestra la ruta seguida.
Para mostrar la ruta es necesario almacenar los puntos por los que pasa la tortuga. El rastro consistirá en una línea que una estos puntos.
Necesitaremos realizar tres operaciones: calcular la coordendas donde se encuentra la tortuga, almacenar dicha coordenada y dibujar el rastro.
Para almacenar los puntos se utiliza una variable para indicar el número de puntos y tres vectores para las coordenadas x, y, z.
int np = 0;
float px [10000];
float py [10000];
float pz [10000];
Para calcular las coordenadas de la tortuga es necesario conocer la matriz de transformación de modelado. Debido a que en OpenGL, la matriz de modelado se almacena junto con la de visualización en la matriz GL_MODELVIEW, es necesario guardar de modo independiente esta matriz de modelado. Para ello definimos la variable mModel, como una variable global, ya que va a ser accedida en distinos puntos de la aplicación: GLdouble mModel[16]
Para operar con la matriz mModel, se cargará en la pila de matrices de GL_MODELVIEW despues de realizar un PushMatrix(), de modo que no altere la matriz actual. En la función main() se inicializa esta matriz con el código:
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glGetDoublev (GL_MODELVIEW_MATRIX, mModel);
glPopMatrix();

MOSTRAR TEXTO
Las instrucciones introducidas se muestran en la ventana MSDOS. Se pueden mostrar en la ventana gráfica. Para ello es necesario cambiar las matrices de transformación. La siguiente función realiza la representación del texto:
void text(GLuint x, GLuint y, GLfloat scale, char* format, ...) {
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glTranslatef(x, y, 0.0);
glScalef(scale/font_scale, scale/font_scale, scale/font_scale);
for(p = buffer; *p; p++)
glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}