Actividad #8 Unidad II Diferencia Rotación en un punto fijo y con respecto al origen, Pilas y Secuencia de transformaciones

Actividad #8

1. Programa, usando opengl donde demuestre la diferencia de rotación en un punto fijo y rotación con respecto al origen.
2. Investigue : 

• En secuencia se aplican las transformaciones.
• Concepto de pila y para que nos sirven el manejo de pilas al dibujar una escena en opengl.

*Rotación en un punto fijo.

*Rotación respecto al origen.





























Ejemplo Respecto al origen: Cubo, Ejemplo Respecto a un punto fijo: Esfera: 

#include "stdafx.h"

#include <stdlib.h>

#include <GL/glut.h>

//GLfloat anguloCuboX = 0.0f;

GLfloat anguloCuboY = 0.0f;

GLfloat anguloEsfera = 0.0f;

GLint ancho=400;

GLint alto=400;

int hazPerspectiva = 0;

void reshape(int width, int height)

{

    glViewport(0, 0, width, height);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    

    if(hazPerspectiva)

     gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);

    else

      glOrtho(-4,4, -4, 4, 1, 10);

    glMatrixMode(GL_MODELVIEW);

    ancho = width;

    alto = height;

}

void drawCube(void)

{

    glColor3f(1.0f, 0.0f, 0.0f);

    glBegin(GL_QUADS);       //cara frontal

    glVertex3f(-1.0f, -1.0f,  1.0f);

    glVertex3f( 1.0f, -1.0f,  1.0f);

    glVertex3f( 1.0f,  1.0f,  1.0f);

    glVertex3f(-1.0f,  1.0f,  1.0f);

    glEnd();

    glColor3f(0.0f, 1.0f, 0.0f);

    glBegin(GL_QUADS);       //cara trasera

    glVertex3f( 1.0f, -1.0f, -1.0f);

    glVertex3f(-1.0f, -1.0f, -1.0f);

    glVertex3f(-1.0f,  1.0f, -1.0f);

    glVertex3f( 1.0f,  1.0f, -1.0f);

    glEnd();

    glColor3f(0.0f, 0.0f, 1.0f);

    glBegin(GL_QUADS);       //cara lateral izq

    glVertex3f(-1.0f,-1.0f, -1.0f);

    glVertex3f(-1.0f,-1.0f,  1.0f);

    glVertex3f(-1.0f, 1.0f,  1.0f);

    glVertex3f(-1.0f, 1.0f, -1.0f);

    glEnd();

    glColor3f(1.0f, 1.0f, 0.0f);

    glBegin(GL_QUADS);       //cara lateral dcha

    glVertex3f(1.0f, -1.0f,  1.0f);

    glVertex3f(1.0f, -1.0f, -1.0f);

    glVertex3f(1.0f,  1.0f, -1.0f);

    glVertex3f(1.0f,  1.0f,  1.0f);

    glEnd(); 

    glColor3f(0.0f,      1.0f, 1.0f);

    glBegin(GL_QUADS);       //cara arriba

    glVertex3f(-1.0f, 1.0f,  1.0f);

    glVertex3f( 1.0f, 1.0f,  1.0f);

    glVertex3f( 1.0f, 1.0f, -1.0f);

    glVertex3f(-1.0f, 1.0f, -1.0f);

    glEnd();

    glColor3f(1.0f, 0.0f, 1.0f);

    glBegin(GL_QUADS);       //cara abajo

    glVertex3f( 1.0f,-1.0f, -1.0f);

    glVertex3f( 1.0f,-1.0f,  1.0f);

    glVertex3f(-1.0f,-1.0f,  1.0f);

    glVertex3f(-1.0f,-1.0f, -1.0f);

    glEnd();

}

void display()

{

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();

    glTranslatef(0.0f, 0.0f, -5.0f);

    //glRotatef(anguloCuboX, 1.0f, 0.0f, 0.0f);

    glRotatef(anguloCuboY, 0.0f, 1.0f, 0.0f);

    drawCube();

    glLoadIdentity();

    glTranslatef(0.0f, 0.0f, -5.0f);

    glRotatef(anguloEsfera, 0.0f, 1.0f, 0.0f);

    glTranslatef(3.0f, 0.0f, 0.0f);

    glColor3f(1.0f, 1.0f, 1.0f);

    glutWireSphere(0.5f, 8, 8);

    glFlush();

    glutSwapBuffers();

    //anguloCuboX+=0.1f;

    anguloCuboY-=0.1f;

    anguloEsfera+=0.2f;

}

void init()

{

    glClearColor(0,0,0,0);

    glEnable(GL_DEPTH_TEST);

    ancho = 400;

    alto = 400;

}

void idle()

{

    display();

}

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

{

    switch(key)

    {

    case 'p':

    case 'P':

      hazPerspectiva=1;

      reshape(ancho,alto);

      break;

    case 'o':

    case 'O':

      hazPerspectiva=0;

      reshape(ancho,alto);

      break;

    case 27:   // escape

      exit(0);

      break;

    }

}

int main(int argc, char **argv)

{

    glutInit(&argc, argv);

    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

    glutInitWindowPosition(100, 100);

    glutInitWindowSize(ancho, alto);

    glutCreateWindow("Cubo 1");

    init();

    glutDisplayFunc(display);

    glutReshapeFunc(reshape);

    glutIdleFunc(idle);

    glutKeyboardFunc(keyboard);

    glutMainLoop();

    return 0;

}

Secuencia de transformaciones:

La secuencia de transformaciones en OpenGL se realiza mediante la premultiplicación de una matriz de 4x4 que codifica la transformación, por cada vector de cuatro dimensiones que representa un punto, una dirección o un plano. Las transformaciones tienen las mismas propiedades que esas operaciones,
en particular la falta de conmutatividad. La cuarta dimensión es un truco que permite usar la misma operación de multiplicación para proyectar en perspectiva y trasladar; con sólo tres dimensiones esas transformaciones no serían tan sencillas. La placa gráfica es una máquina especializada en hacer esas
operaciones además de manejar bloques de píxeles. La cuarta dimensión se llama aquí “coordenada homogénea”: a un punto de coordenadas {x,y,z} le corresponde el vector homogéneo {wx,wy,wz,w}, con cualquier w ≠ 0. En el caso en que w sea cero, diremos que se trata de un vector o una dirección o
“un punto en el infinito” que es una forma común, en la jerga de CG, de denominar a una dirección en el espacio, por ejemplo: la posición del sol en el infinito, para iluminar una escena. Los detalles de los distintos espacios o sistemas de coordenadas los analizaremos en el orden en que aparecen al leer el programa.

Pila:
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
disntintas funciones. Para poder guardar una determinada matriz y posteriormente recuperarla OpenGL dispone de las dos funciones comentadas: glPushMatrix() "apilar" y glPopMatrix() "desapilar".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().

En la función display() al llamar a la función glPushMatrix() se realiza una copia de la matriz actual. La traslación en el eje Z se realiza en la matriz superior de la pila, es decir, en la copia de la matriz, de tal forma que al llamar a la función glPopMatrix(), como se muestra en la figura 1, se elimina la matriz superior, que es la que tenía el efecto de esta transformación, quedando la matriz que estaba en el momento de llamar a glPushMatrix(). Al descomentar las llamadas a las funciones glPushMatrix() y glPopMatrix() las transformaciones realizadas entre ambas no afectan al resto de la aplicación.

¿Para que nos sirven el manejo de pilas al dibujar una escena en opengl?
En algunos casos nos puede interesar guardar la transformación que tenemos en la matriz activa para posteriormente recuperarla, por ejemplo si deseamos renderizar un coche formado por la carroceria y cuatro ruedas. El coche entero tendra una transformación para colocarlo en el lugar (translacion + rotacion) y cada una de las ruedas tendra una transformación de rotación y transformación adicional que la colocara en relación al sistema de coordenadas del coche, para no tener que aplicar la misma transformación del coche a cada rueda podemos almacenarla en una pila y posteriormente recuperarla.

Fuente:

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

actividad#7 Unidad II Dibujo Polígono

actividad#7

Usando su modelo de piramide, con los siguientes puntos dibuje el polígono correspondiente y aplique las siguientes transformaciones:

                                      p0=(2,2) , p1(7,2), p2(7,7), p3(2,7) 

Escriba todos los cálculos realizados.

a) Vector Traslación (-2,-2) 

b) Escalación (0.5,0.5) 

c) Rotacion 45grados eje z

tomando el p0 como base.

Trastacion.
P' = P+T
P0'=(2,2)+(-2,-2) = 0,0
P1'=(7,2)+(-2,-2) = 5,0
P2'=(7,7)+(-2,-2) = 5,5
P3'=(2,7)+(-2,-2) = 0, 5


Escalación:
Escalción P0 = (1,1)
x' = x * Sx = (2)*(0.5) = (1)
y' = y * Sy = (2)*(0.5) = (1)
Escalción P1 = (3.5,1)
x' = x * Sx = (7)*(0.5) = (3.5)
y' = y * Sy = (2)*(0.5) = (1)
Escalción P2 = (3.5,3.5)
x' = x * Sx = (7)*(0.5) = (3.5)
y' = y * Sy = (7)*(0.5) = (3.5)
Escalción P3 = (1,3.5)

x' = x * Sx = (2)*(0.5) = (1)
y' = y * Sy = (7)*(0.5) = (3.5)

Rotación:
Rotación P0=(2,2)
X' = xCos ☼ - YSin☼= 2Cos (45) - 2Sin(45)=0
y' = xSin ☼ - YCos☼= 2Sin(45)- 2Cos(45)=0
Rotación P1=(7,2)
X' = xCos ☼ - YSin☼=7Cos(45)- 2Sin(45)=3.5355
y' = xSin ☼ - YCos☼= 7Sin(45)- 2Cos(45)=3.5355
Rotación P2=(7,7)
X' = xCos ☼ - YSin☼=7Cos(45)- 7Sin(45)=0
y' = xSin ☼ - YCos☼= 7Sin(45)- 7Cos(45)=0
Rotación P3=(2,7)
X' = xCos ☼ - YSin☼=2Cos(45)- 7Sin(45)= -3.5355
y' = xSin ☼ - YCos☼= 2Sin(45)- 7Cos(45)=-3.5355

Actividad #6 Unidad II Piramide 3d, Traslación, Escalación, Rotación

Actividad #6

Usando su modelo de piramide 3d aplique las transformaciones

a)Vector Traslación (-2,-2,0).
b) Escalación (.5,.5,.5) Rotación.
c) 45grados eje z.

Actividad #5 Unidad II Resumen:Transformación ventana-área de vista

Actividad #5 

• Resumen:Transformación ventana-área de vista

Fuente: 
http://graficacionitca3d.blogspot.mx/2012/03/24-transformacion-ventana-area-de-vista.html

• Investigar los siguientes conceptos:
• Aspect ratio: 

La relación de aspecto, ratio, ratio de aspecto, proporción de aspecto o razón de aspecto (traducciones literales de la expresión en inglés aspect ratio) de una imagen es la proporción entre su ancho y su altura. Se calcula dividiendo el ancho por la altura de la imagen visible en pantalla, y se expresa normalmente como «X:Y».

• Viewports o visor: 

Un viewport es una región rectangular visualización en gráficos de computadora, o un término utilizado para los componentes ópticos. Ventana de recorte o de visualizacion.


En arquitectura de pipeline grafico investigue:

• Pipeline Grafico: 

Para llevar a cabo una representación virtual de un ambiente tridimensional, se realiza un modelado del escenario. Dicho modelo incluye la representación geométrica de los objetos presentes, las condiciones de iluminación de la escena y el lugar dentro de la misma desde dónde es apreciada. Cada objeto es representado a través de combinaciones, más o menos complejas, de figuras geométricas, el color o las texturas de sus superficies, y su posición y orientación en la escena. Luego se configuran las condiciones de iluminación, es decir posición, color, tipo y demás atributos de cada fuente de luz presente en la escena. Por último, se determina la posición y dirección del punto de vista o de la cámara a través de la cual se visualiza el ambiente. La visualización del ambiente en un dispositivo, como la pantalla de un monitor, es posible gracias a software y hardware especializado. Dicha especialización permite dibujar eficientemente sobre una pantalla bidimensional la proyección, comúnmente en perspectiva, de una escena tridimensional.



El conjunto de operaciones que se realiza para, a partir del modelado del escenario, lograr una imagen para dibujar en la pantalla es llamado pipeline gráfico.

• Pipeline de OpenGL: 

La mayoría de las implementaciones de OpenGL tienen un orden similar de operaciones, una serie de etapas de procesamiento de llamada de la canalización de representación de OpenGL.Este orden, como se muestra en la Figura , no es una regla estricta de cómo se implementa OpenGL, pero proporciona una guía confiable para predecir lo que va a hacer OpenGL.

• Transformacion: 

Las posiciones de los vértices que modelan cada objeto son, usualmente, relativas a un eje de referencia propio de cada objeto. Esto permite que el mismo modelo sirva para representar distintas instancias del objeto dentro de una escena.

Una primera etapa del pipeline consiste en transformar las coordenadas de los vértices en coordenadas normalizadas del dispositivo. Para esto a cada vértice se le aplica una secuencia de transformaciones utilizando matrices de dimensión 4x4 y coordenadas homogéneas (véase una buena explicación en el OpenGL Programming Book, Apéndice G). Las posiciones de los vértices son afectadas entonces por 3 transformaciones:

• Mundo: A partir de la posición, orientación y escala de la instancia del objeto en la escena, se arma una matriz que lleva las coordenadas de los vértices del sistema de referencia propio del objeto al sistema de referencia de la escena, común a todos los objetos.
• Vista: Para mostrar lo que es percibido desde un punto de vista, se aplica una matriz que hace coincidir la posición de la cámara con el origen de coordenadas. Además, se hace coincidir la dirección de la cámara con el eje Z positivo, quedando el eje Y hacia arriba y el eje X hacia la derecha. Así las posiciones de los vértices de los objetos quedan relativas a la ubicación y orientación de la cámara.
• Proyección: El espacio que es visualizado de la escena es definido por un volumen de visualización. Los objetos dentro de ese volumen son proyectados en la cara delantera de dicho volumen para obtener la imagen a mostrar. Utilizando una proyección perspectiva, el volumen de visualización tiene la forma de la parte inferior de una pirámide de base rectangular truncada, en inglés, frustum. Finalmente, la transformación de proyección convierte ese volumen de visualización en un volumen de visualización canónico, un cubo con sus vértices extremos en (-1, -1, -1) y (1, 1, 1).

• Clipping: 

Es el fenómeno que se produce cuando un cuerpo sólido atraviesa otro "sin romperlo", es decir, si por ejemplo un personaje está pegado a la pared de una habitación y un brazo o parte de su cuerpo puede verse al otro lado de la pared. El clipping puede ser sólo parcial o total, es decir, tomando el ejemplo de antes, si el brazo atraviesa la pared pero no podemos interactuar con él se trata de un clipping parcial. Si con ese brazo podemos interactuar de manera normal como si realmente no estuviese esa pared ahí, por ejemplo en un shooter poder disparar y herir al personaje, se trata de un clipping total. ¿Quién no se ha aprovechado de un error así para matar a un enemigo en un juego de disparos?

• Proyeccion: 

La proyección es la representación gráfica de un objeto sobre una superficie plana, obtenida al unir las intersecciones sobre dicho plano de las líneas proyectantes de todos los puntos del objeto desde el vértice.

En términos generales, las proyecciones transforman puntos en un sistema de coordenadas de dimensión n a puntos en un sistema de coordenadas con dimensión menor que n. De hecho, durante mucho tiempo se ha usado la graficación por computador para estudiar objetos n-dimensionales por medio de su proyección sobre dos dimensiones.

La proyección de objetos tridimensionales es definida por rayos de proyección rectos, llamados proyectores, que emanan de un centro de proyección, pasan por cada punto del objeto e intersecan un plano de proyección para formar la proyección. Por lo general, el centro de proyección se encuentra a una distancia finita del plano de proyección. Sin embargo, en algunos tipos de proyecciones es conveniente pensar en función de un centro de proyección que tienda a estar infinitamente lejos.

En la figura se presentan dos proyecciones diferentes de la misma línea. Afortunadamente, la proyección de una línea es en sí una línea, de manera que sólo hay que proyectar los puntos extremos. La clase de proyecciones que trataremos aquí se conoce como proyecciones geométricas planas, ya que la proyección es sobre un plano y no sobre una superficie curva y porque usa proyectores rectos y no curvos. Varias proyecciones cartográficas son no planas o no geométricas.

• Rasterizacion: 

El objetivo de esta etapa es determinar el conjunto de pixeles que formarán parte de la imagen final a visualizar. Esta etapa usa un buffer bidimensional para la generación progresiva de la imagen o cuadro final,que es llamado frame-buffer. La primera operación consiste en determinar los pixeles necesarios para la representación de cada una de las primitivas a visualizar. El proceso, también conocido como escaneo de conversión (en inglés, scan conversion), genera una estructura transitoria llamada fragmento. Cada fragmento contiene los atributos ingresados con los vértices junto a la posición. El valor de los atributos es obtenido mediante una interpolación lineal de los valores presentes en cada vértice de la primitiva, utilizando como pesos la posición del fragmento relativa a los vértices.

Dos o más primitivas pueden generar fragmentos en la misma posición. El fragmento que debe dibujarse es aquel que se encuentra más cercano al observador, es decir, aquel que no se encuentra tapado por otro. El valor de la coordenada Z, o valor de profundidad, es utilizado para dirimir el fragmento que se convertirá en píxel. Para esto se utiliza una estructura de datos llamada Z-buffer o buffer de profundidad (en inglés, depth buffer) que almacena el valor de profundidad del último fragment (los fragmentos pueden ser procesados en paralelo, de manera independiente uno de otro). dibujado en el frame-buffer. Un fragmento es descartado si su valor de profundidad es mayor al que se encuentra en el Z-buffer para la misma posición.

El color del fragmento candidato a convertirse en un píxel de la imagen final es decidido en esta etapa. El color puede obtenerse del atributo que acompaña a cada vértice o puede muestrearse de una textura en particular, a partir de las coordenadas de textura para ese fragmento. Más aún, operaciones de iluminación y transparencia pueden contribuir en el color final de un píxel.

Finalmente, los fragmentos dibujados en el frame-buffer son mostrados en la pantalla del dispositivo.



Fuente:

• www.wikipedia.org
• guayco-84067.googlecode.com/.../Cap3_El%20pipeline%20gráfico.doc‎
• http://blogs.gamefilia.com/i-yova-i/19-02-2009/19476/tecnicas-algunos-terminos-de-errores-graficos-comunes

Actividad #4 Unidad II Programa Transformaciones geométricas

Transformaciones geométricas

Actividad:

Investigar como se manipulan las transformaciones geométricas en opengl.

Con la imagen de su pirámide y las transformaciones geométricas diseñe un programa que rote su pirámide sobre el eje "x" y el eje "y", se mueva de izquierda a derecha y de derecha a izquierda, y reduzca o amplié la piramide.

Se utilizan las siguientes lineas de código en opengl para:

• Trasladar: glTranslatef("x", "y"," z"); 

Si queremos trasladar una figura a 10 unidades en el plano de las z seria:
glTranslatef(0.0f, 0.0f, 10.0f);

La “f” añadida a la función indica que se usarán flotantes. Los parámetros de glTranslate son las unidades a desplazar en el eje x, y y z, respectivamente. Pueden ser valores negativos, para trasladar en el sentido contrario.

• Rotar: glRotatef(Anguloº, "X","Y","Z"); 

Para rotar, tenemos también una función de alto nivel que construye la matriz de transformación y la multiplica por la matriz activa, glRotate. Lleva como parámetros el ángulo a rotar (en grados, sentido horario), y después x, y y z del vector sobre el cual se quiere rotar el objeto.
Una rotación simple, sobre el eje x, de 10º sería:
glRotatef(10, 1.0f, 0.0f, 0.0f);

• Escalar: glScalef("X","Y","Z"); 

Una transformación de escala incrementa el tamaño de nuestro objeto expandiendo todos los vértices a lo largo de los tres ejes por los factores especificados. La función glScale lleva como parámetros la escala en x, y y z, respectivamente. El valor 1.0f es la referencia de la escala, de tal forma que la siguiente línea:
glScalef(1.0f, 1.0f, 1.0f);

Código:

#include "stdafx.h"
#include <stdlib.h>
#include <GL/glut.h>

GLfloat x1= 1.5f;
GLfloat y1 = 1.5f;
GLfloat escalar = 1.5f;

int banderax; // bandera = 1;- en +X,bandera = 0;- en -X
int banderay;// bandera = 1;- en +Y,bandera = 0;- en -Y

GLfloat angulox = 0.0f; // variable para el angulo x
GLfloat anguloy = 0.0f; // variable para el angulo y
//GLfloat anguloz = 0.0f; // variable para el angulo z

void reshape(int width, int height)/*Esta acción afecta en principio directamente al render, puesto que se está cambiando el tamaño del plano de proyección.*/
{
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-10,10,-10,10,-10,10);/*define la proyección definida por los ejes x,y,z. Estos parámetros demilitan el volumen de vista y son, por este orden: x_mínima, x_máxima, y_mínima, y_máxima, z_mínima, z_máxima,*/
glMatrixMode(GL_MODELVIEW);

}

void piramide(void)
{
//Lado 4 - atras, blanco
glBegin(GL_TRIANGLES);/*glBegin(GL_TRIANGLES);Funcion para puntos, El inicio se une con el final*/
glColor3f(1,1,1);
glVertex3f(0.0f,-3.0f,-1.5f); //Vertice a Formando Lado 4
glVertex3f(-1.5f,0.0f,0.0f); //Vertice b Formando Lado 4
glVertex3f(1.5f,0.0f,0.0f); //Vertice c Formando Lado 4
glEnd();

//Lado 3 - base, amarillo
glBegin(GL_TRIANGLES);/*glBegin(GL_TRIANGLES);Funcion para puntos, El inicio se une con el final*/
glColor3f(1.0f, 1.0f, 0.0f);
glVertex3f(-1.5f,0.0f,0.0f); //Vertice b Formando Lado 3
glVertex3f(1.5f,0.0f,0.0f); //Vertice c Formando Lado 3
glVertex3f(0.0f,-1.5f,1.5f); //Vertice d Formando Lado 3
glEnd();


//Lado 2 - derecho, azul
glBegin(GL_TRIANGLES);/*glBegin(GL_LINE_LOOP);Funcion para puntos, El inicio se une con el final*/
glColor3f(0,0,1);//color azul
glVertex3f(0.0f,-3.0f,-1.5f); //Vertice a Formando Lado 2
glVertex3f(1.5f,0.0f,0.0f); //Vertice c Formando Lado 2
glVertex3f(0.0f,-1.5f,1.5f);//(0,12,1.5); //Vertice d Formando Lado 2
glEnd();

//Lado1 - izquierdo, verde
glBegin(GL_TRIANGLES);/*glBegin(GL_LINE_LOOP);Funcion para puntos, El inicio se une con el final*/
glColor3f(0.0f, 1.0f, 0.0f);//color verde
glVertex3f(0.0f,-3.0f,-1.5f); //Vertice a Formando Lado 1
glVertex3f(0.0f,-1.5f,1.5f);//(0,12,1.5); //Vertice d Formando Lado 1
glVertex3f(-1.5f,0.0f,0.0f); //Vertice b Formando Lado 1
glEnd();
}


void display()/*Aquí se define el primer callback. La función pasada como parámetro será llamada cada vez que GLUT determine oportuno que la ventana debe ser redibujada, como al maximizarse, poner otras ventanas por encima y después quitarlas, etc.*/
{

glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
//glColor3f(1,1,1);/*Define el color glColor3f(0.5,0.0,1.0);*/
glLoadIdentity();

glTranslatef(x1,y1,0.0f);//Se trastala en los ejes: x , y
glScalef(escalar, escalar, escalar);//Para aunmentar y disminuir la escala
glRotatef(angulox, 1.0f, 0.0f, 0.0f);//rotar en x
glRotatef(anguloy, 0.0f, 1.0f, 0.0f);//rotar en y
// glRotatef(anguloz, 0.0f, 0.0f, 1.0f);
piramide();
glFlush();/*vacía todos los comandos en estos buffers y las fuerzas de todos los comandos pendientes voluntad de ser ejecutadas inmediatamente y sin topes de espera están llenas.*/
glutSwapBuffers();/*promueve el contenido de la memoria intermedia posterior de la capa en el uso de la ventana actual para convertirse en el contenido del búfer frontal. */
angulox+=0.1f;
anguloy+=0.1f;
// anguloz+=0.1f;


GLfloat angulox = 0.0f; // variable para el angulo x
//GLfloat anguloy = 0.0f; // variable para el angulo y
//GLfloat anguloz = 0.0f; // variable para el angulo z


}
void init()
{
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);// tapa las lineas que estan debajo de ellas
}

void idle()
{
display();
}

void ArrowKey(int key, int x, int y){ //funcion para trasladar en -x,x,-y,y

switch (key){
case GLUT_KEY_RIGHT:
if( x1<8.0 ){x1 = x1 + 0.5;}//para moverse en la coordenada +x
if(x1>0.1 && x1<3){escalar = x1;}
break;


case GLUT_KEY_LEFT:
if( x1>-8.0 ){x1 = x1 - 0.5;}//para moverse en la coordenada -x
if(x1>0.1 && x1<3){escalar = x1;}
break;


case GLUT_KEY_UP:
if( y1<8.0 ){y1 = y1 + 0.5;}//para moverse en la coordenada +y
break;


case GLUT_KEY_DOWN:
if( y1>-8.0 ){y1 = y1 - 0.5;}//para moverse en la coordenada -y
break;
}
}
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}
int main(int argc, char **argv) //Funcion para crear ventana
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);/*GLUT_DOUBLE para que glutSwapBuffers() tenga efecto, CON GLUT_SINGLE no hay efecto;GLUT_SINGLE para que glFlush() tenga efecto */
glutInitWindowPosition(500,60);//Posicion de la ventana
glutInitWindowSize(600,500);//tamaño de la ventana
glutCreateWindow("Piramide 3D");//Mensaje de la ventana
init();/*activa, define una serie de estados de ogl, antes de pasar el control del programa a la GLUT.*/
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutKeyboardFunc(keyboard);
glutSpecialFunc(ArrowKey);
glutMainLoop();


}

Fuente: http://sabia.tic.udc.es/gc/Tutorial%20OpenGL/tutorial/cap4.htm#_Toc535127350

Actividad #3 Unidad II Resumen Transformaciones Geométricas, Libro graficación

Actividad #3 Resumen.

Transformaciones Geométricas.

Objetivo. El estudiante conocerá y aplicará las principales transformaciones geométricas sobre objetos en 2D y 3D.

Las transformaciones de visualización bidimensional desde las coordenadas universales a las coordenadas del dispositivo implican operaciones de traslación, rotación y cambio de escala, así como procedimientos de borrado de aquellas partes de la imagen que se encuentran fuera de los límites de una zona seleccionada de la escena.

2.1.Transformaciones bidimensionales

Traslación.
Se aplica una traslación en un objeto para cambiar su posición a lo largo de la trayectoria de una línea recta de una dirección de coordenadas a otra. Convertimos un punto bidimensional al agregar las distancias de traslación, tx y ty ( vector de traslación o vector de cambio). Es decir, representar las posiciones de coordenadas y el vector de traslación como:
                         
Esto nos permite expresar las dos ecuaciones de traslación bidimensional en la forma de matriz:.

En términos de vectores de renglón de coordenadas como: P[x y] y T[tx ty].

La traslación es una transformación de cuerpo rígido que mueve objetos sin deformarlos.

•    Los polígonos se trasladan a un nuevo conjunto de coordenadas y vértices; y las especificaciones actuales de los atributos. 

Ejemplo:

Rotación. Se aplica una rotación bidimensional en un objeto al cambiar su posición a lo largo de la trayectoria de una circunferencia en el plano de xy. Para generar una rotación, especificamos un ángulo de rotación θ y la posición (xr, yr) del punto de rotación (o punto pivote) en torno al cual se gira el objeto.

Para obtener las ecuaciones de transformación para la rotación de un punto
con respecto de cualquier posición de rotación específica (xr’, yr):

EscalaciónUna transformación de escalación altera el tamaño de un objeto. Se puede realizar esta operación para polígonos al multiplicar los valores de coordenadas (x, y) de cada vértice por los factores de escalación sx y sy para producir las coordenadas transformadas (x’, y’):    
                                                    x ' = x·sx , y' = y·sy

El factor de escalación sx escala objetos en la dirección de x mientras que el factor de escalación sy lo hace en dirección de y.
Se pueden asignar valores numéricos positivos y negativos a los factores de
escalación sx y sy. Los valores menos que 1 reducen el tamaño de los objetos y los valores mayores que 1 producen una ampliación.

Cuando se asigna el mismo valor a s para sy genera una escalación uniforme que mantiene las proporciones relativas de los objetos. Y cuando sx tienen valores distintos se obtiene una escalación diferencia como la de la ys, por ejemplo:
                     

También podemos controlar la localización de un objetos escalado al seleccionar una posición llamada punto fijo, que debe permanecer sin cambios después de la transformación de escalación. Se pueden seleccionar las coordenadas para el punto fijo (xf, yf) como uno de los vértices, el centroide del objeto o cualquier otra posición. Por ejemplo:

Para un vértice con coordenadas (x, y), se calculan las coordenadas
escaladas (x’, y’) como:  x ' = xf + (x − xf )sx , y' = yf + (y − yf )sy

2.2.Coordenadas homogéneas y representación matricial.

Con el fin de producir una secuencia de transformaciones con estas ecuaciones, como escalación seguida por rotación y luego traslación, debemos calcular las coordenadas transformadas un paso a la vez. Primero, se escalan las posiciones de coordenadas, después se giran estas coordenadas escaladas y por último se trasladan las coordenadas giradas.

Para expresar cualquier transformación bidimensional, representamos cada posición de coordenadas cartesianas (x, y) con las tres coordenadas homogéneas (xh, yh, h), donde:

Por tanto, una representación general de coordenadas homogéneas se puede expresar también como (h·x, h·y, h). 
Para transformaciones geométricas bidimensionales, seleccionamos el parámetro homogéneo h como cualquier valor no cero. Así, existe un número finito de representaciones homogéneas equivalentes para cada punto de coordenadas (x, y). Una opción conveniente consiste en sólo establecer h = 1. Entonces, se representa cada posición bidimensional con las coordenadas homogéneas (x, y, 1). Se requieren otros valores para el parámetro h, por ejemplo, en las formulaciones de matriz de transformaciones de vista tridimensionales.

2.3.Composición de transformaciones Bidimensionales

Con las representaciones de posición de coordenadas cartesianas (x, y) del tema anterior, podemos establecer una representacion de (X,Y), haciendo la transformación compuesta al calcular el producto de la representacion (X,Y).

Traslaciones
Se se aplican dos vectores de traslación sucesivos (tx1, ty1) y (tx2, ty2) en la posición de coordenadas P, la localización transformada final P, la localización transformada final P’ se calcula como:

P' = T (tx2 , ty2 )·{T (tx1, ty1)·P} = T (tx2 , ty2 )·T (tx1, ty1{ )}·P

Rotaciones

Dos rotaciones sucesivas que se aplican en el punto P producen la posición

transformada: como

       P' = R(θ2 )· R(θ1{ )·P} = R(θ2 { )·R(θ1)}·P

Escalaciones

las operaciones de escalación sucesivas son multiplicativas. Es decir, si debiéramos triplicar el tamaño de un objeto dos veces en una sucesión, el tamaño final sería nueve veces el tamaño original: como

       S(sx2 , sy2 )·S(sx1, sy1) = S(sx1·sx2 , sy1·sy2 )

Rotación del punto pivote general

Con un paquete gráfico que sólo ofrezca una función de rotación para girar objetos con respecto del origen de las coordenadas, podemos generar casi cualquier punto pivote seleccionado (xr, yr) al realizar la siguiente secuencia de operaciones de traslación-rotacióntraslación:
           
           1. Traslade el objeto de modo que se mueva la posición del punto pivote                  al origen de las coordenadas.
           2. Gire el objeto con respecto del origen de las coordenadas.
           3. Traslade el objeto de manera que se regrese el punto pivote a su                          posición original.

Formula: T (xr , yr )·R(θ )·T (−xr ,−yr ) = R(xr , yr ,θ )

Escalación del punto fijo general
Secuencia de transformación para producir escalación con respecto de una posición fija seleccionada (xf, yf) al utilizar una función de escalación que sólo puede escalar en relación con el origen de las coordenadas.

       1. Traslade el objeto de modo que el punto fijo coincida con el origen de las
           coordenadas.
       2. Escale el objeto con respecto del origen de las coordenadas.
       3. Utilice la traslación inversa del paso 1 para regresar el objeto a su                          posición original.

Formula: T (xf , yf )·S(sx , sy )·T (−xf ,−yf ) = S(xf , yf , sx , sy )

Propiedades de concatenación

La multiplicación de matrices es asociativa. Para tres matrices cualesquiera A, B y C, el producto matricial A·B·C se puede llevar a cabo al multiplicar primero a por B o multiplicar
primero B por C: A·B·C = (A·B)·C = A·(B·C)

2.4.Transformación ventana-área de vista

Algunos paquetes gráficos permiten que el programador especifique coordenadas de primitivas de salida en un sistema de coordenadas de mundo de punto flotante, usando las unidades que sean relevantes para el programa de aplicación: angstroms, micras, metros,millas, años luz, etcétera.

La transformación que establece la correspondencia entre la-ventana y el área de vista se aplica a todas las primitivas de salida en coordenadas de mundo para que correspondan a coordenadas de pantalla.

Como se puede ver, si la ventana y el área de vista no tienen la misma razón altura-anchura,ocurre un escalamiento no uniforme. Si el programa de aplicación cambia la ventana o el área de vista, las nuevas primitivas de salida que se dibujen en la pantalla se verán afectadas por el cambio, no así las primitivas existentes.

2.5.Transformaciones de composición general y de

eficiencia computacional.

Una transformación bidimensional general, que representa una combinación de
traslaciones, rotaciones y escalaciones se puede expresar como:

Los cuatro elementos rsij son los términos multiplicativos de rotación -escalación en la transformación que implican sólo ángulos de rotación y factores de escalación. Los elementos trsx y trsy son los términos de traslación que contienen combinaciones de distancias de traslación, coordenadas de punto pivote y de punto fijo, así como de ángulos de rotación y parámetros de escalación.

1. Ejemplo:

La figura 2.14 ilustra un objeto que se debe alinear con los vectores de unidad u’ y v’. Al suponer que la orientación original del objeto como se muestra en el inciso a) de la misma figura, está alineada con los ejes de las coordenadas, realizamos la transformación deseada al asignar los elementos de u’ al primer renglón de la matriz de rotación y los elementos de v’ al segundo renglón.

2. Ejemplo:

En el siguiente ejemplo, se escala y gira un polígono con respecto de un punto de

referencia determinado y luego se traslada el objeto. En la figura se ilustran las posiciones original y final del polígono que se transforma mediante esta secuencia.

2.6.Representación matricial de transformaciones

tridimensionales

Así como las transformaciones bidimensionales se pueden representar con matrices de 3 X 3 usando coordenadas homogéneas, las transformaciones tridimensionales se pueden representar con matrices de 4 X 4, siempre y cuando usemos representaciones de coordenadas homogéneas de los puntos en el espacio tridimensional. Así, en lugar de representar un punto como (x, y, z), lo hacemos como (x, y, z, W), donde dos de estos cuádruplos representan el mismo punto si uno es un multiplicador distinto de cero del otro: no se permite el cuádruplo (0, 0, 0, 0). Como sucede en el espacio bidimensional, la representación estándar de un punto (x, y, z, W) con W ≠ 0 se indica (x/W, y/W, z/W, 1). Los puntos cuya coordenada W es cero se llaman puntos en el infinito. Donde w=1.


Una rotación de 90° en sentido contrario al giro de las manecillas del reloj transformará un eje positivo en otro. La tabla siguiente se desprende de esta convención:

• Se usa el sistema de mano derecha porque se trata de una convención matemática estándar. Aunque en la graficación tridimensional es conveniente pensar en un sistema de mano izquierda, ya que un sistema de mano izquierdada la interpretación natural de que los valores mayores de z se encuentran más lejos del observador.:

2.7.Composición de transformaciones

tridimensionales.

En este apartado se analizará la forma de componer matrices de transformación tridimensionales usando un ejemplo. El objetivo es transformar los segmentos de línea dirigida P1P2 y P1P3, de su posición inicial en la parte (a) a su posición final en la parte (b). De esta manera, el punto P1 se trasladará al origen P1P2 quedará en el eje positivo y P1P3 quedará en la mitad del eje positivo del plano (x, y). Las longitudes de las líneas no se verán afectadas por la transformación.

Se presentan dos formas de lograr la transformación deseada:

1. Primer método, componer las transformaciones primitivas T, Rx, Ry y Rz. 
2. El segundo método, utiliza las propiedades de las matrices ortogonales especiales. 

• Primer método,  Pasos:

1. Traslación de P1 al origen.
2. Rotación sobre el eje y para que P1P2 esté en el plano (y, z).
3. Rotación sobre el eje x para que P1P2 esté en el eje z.
4. Rotación sobre el eje z para que P1P3 esté en el plano (y, z).

Paso 1: Traslación P1 al origen. La traslación es:

Al aplicar T a P1, P2 y P3 se obtiene:

       

Paso 2: Rotación sobre el eje y. Así como la proyección de P1P2 sobre el plano (x, z). El ángulo de rotación es –(90 - θ) = θ -90.

Donde:

Al sustituir estos valores en la ecuación  se obtiene:

Como era de esperar, el componente x de P2’’ es cero y el componente z es la longitud:

Paso 3: Rotación sobre el eje x. El ángulo de rotación es φ, para el cual

Donde D2 = |P1’’P2’’|, la longitud de la línea P1’’P2’’ son la nisna, ya que las transformaciones de rotación y traslación conservan la longitud:

 El resultado de la rotación es :


coincidiendo P1P2 con el eje z positivo.

Paso 4. Rotación sobre el eje z.  P3’’’ en la posición:

La rotación a través del ángulo positivo α, con:

 Resultado matriz :

• La segunda manera, Pasos de obtener la matriz R es usar las propiedades de las matrices ortogonales:

Recuerde que los vectores fila unidad de R rotan hacia los ejes principales. Para que la rotación sea más conveniente,

 Como Rz es el vector unidad sobre P1P3 que rotará hacia el eje positivo,

 Además, el vector unidad R, es perpendicular al plano de P1, P2 y P3 y rotará hacia el eje x positivo, de manera que R, debe ser el producto cruz normalizado de dos vectores en el plano:

 Finalmente,

rotará hacia ele eje y positivo. La matriz compuesta se expresa como

Donde Rx, Ry y Rz vectores son individuales.

Fuente: 

Libro de Texto de Graficación por Martha Azucena Fernández Saucedo.Asesor: Rogelio Ferreira Escutia