Actividad Transformaciones

SECUENCIA EN QUE SE APLICAN LAS TRANSFORMACIONES

Estas transformaciones se aplican siempre sobre la matriz activa, que seleccionamos con la instrucción glMatrixMode. El orden con que se aplican estas transformaciones es importante, no es lo mismo aplicar una translacion y posteriormente un rotación que el orden inverson rotacion y translación.

El orden en que se aplican las transformaciones en OpenGL es al contrario de lo que parece intuitivo a primera vista. Por ejemplo:

glLoadIdentity();

glTranslatef(0.5, 0.5, 1.0);

glRotatef(45.0, 1.0, 1.0, 1.0)

glBegin(GL_TRIANGLE);

glVertex3f(0.0, 0.0, 0.0);

glVertex3f(1.0, 0.0, 0.0);

glVertex3f(0.0, 1.0, 0.0);

glEnd();

 

Primero carga la matriz identidad, luego multiplica por una matriz de translacion y por ultimo una de rotación. El resultado es que primero rota el triangulo y posteriormente lo traslada, esto es debido a que las multiplicaciones las realiza por el lado derecho:

I·R·T·vertice = (I·(R·(T·vertice)))

El vertice primero lo multiplica por la matriz T (de translacion) luego por R y finalmente por I.

La lectura se realiza de abajo arriba, hasta encontrar una funcion glLoadIdentity o glLoadMatrix. Las transformaciones que haya despues de la primitiva de dibujado glBegin - glEnd no se tienen en cuenta porque la primtiva ya ha sido renderizada.

Si deseamos realizar multiplicaciones por la izquierda de una matriz N podemos aplicar el siguiente método:

leer la matriz actual M

cargar la identidad

multiplicar por la nueva transformacion N

multiplicar por la matriz M

 

En OpenGL seria:
 

GLFloat fMatrizM[16];

glLoadMatrixf(fMatrizM);

glLoadIdentity();

glMultMatrixf(fMatrizN), glTranslatef(x, y, z), glScalef(sx, sy, sz) o glRotatef(ang, x, y, z);

glMultMatrixf(fMatrizM);

BIBLIOGRAFIA

http://dmi.uib.es/~josemaria/OpenGL/Transformaciones.html

Actividad Pilas / Programas Rotacion OpenGL

CONCEPTO DE PILA

Una pila (stack en inglés) es una lista ordenada 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).

Las pilas suelen emplearse en los siguientes contextos:

 Evaluación de expresiones en notación postfija (notación polaca inversa).

 Reconocedores sintácticos de lenguajes independientes del contexto

 Implementación de recursividad.

PARA QUE NOS SIRVEN?

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.

Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado.

En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado TOS, Top of Stack en inglés). La operación retirar permite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS.

Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre una pila de platos, y una operación retirar a retirarlo.

MANEJO DE PILAS EN OPENGL

PILA DE MATRICES

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. Ejemplo:

glPushMatrix(); // Guardamos la transformacion del mundo
glTranslatef(cocheX, cocheY, cocheZ);
glRotatef(angulo, ejeX, ejeY, ejeZ);
RenderCarroceria();

glPushMatrix(); // Guardamos la transformacion del coche
glTranslatef(rueda1X, rueda1Y, rueda1Z);glRotatef(anguloRueda1, eje1X, eje1Y, eje1Z);
RenderRueda();
glPopMatrix(); // Recuperamos la transformacion del coche
glPushMatrix();
glTranslatef(rueda2X, rueda2Y, rueda2Z);glRotatef(anguloRueda2, eje2X, eje2Y, eje2Z);
RenderRueda();
glPopMatrix();
glPushMatrix();
glTranslatef(rueda3X, rueda3Y, rueda3Z);glRotatef(anguloRueda3, eje3X, eje4Y, eje3Z);
RenderRueda();
glPopMatrix();

glPushMatrix();
glTranslatef(rueda4X, rueda4Y, rueda4Z);glRotatef(anguloRueda4, eje4X, eje4Y, eje4Z);
RenderRueda();
glPopMatrix();
glPopMatrix(); // Recuperamos la transformacion del mundo

Disponemos de una pila de matrices para cada una de las matrices existentes: MODELVIEW, PROJECTION y TEXTURE.

 

PROGRAMAS ROTACION

 

#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(Perspectiva)

     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);      

    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);       

    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);       

    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);      

    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);      

    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);     

    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':

      Perspectiva=1;

      reshape(ancho,alto);

      break;

    case 'o':

    case 'O':

      Perspectiva=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;

}




#include "GL/gl.h"
#include "gpu940.h"


#include <math.h> //necesario para la función gluPerspective



void gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar);
void draw();


Nuestra función principal, main()
Aquí inicializamos OpenGL y configuramos algunos parámetros, así como la matriz de proyección


int main()
{
glOpen(DEPTH_BUFFER); // Inicializa el OpenGL
glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Especifica el color que se usará para borrar la pantalla (rojo, verde, azul, alpha)
glClearDepth(1.0f);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST); // Activamos el test de profundidad
glShadeModel(GL_SMOOTH); // Sombreado suave
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST ); // Correción de perspectiva
glMatrixMode(GL_PROJECTION); //Cambiamos a la matriz de proyección...
glLoadIdentity(); //Y la reseteamos
gluPerspective(45.0f,(GLfloat)320/(GLfloat)240,0.1f,100.0f); // Esta función la definiremos más adelante
glMatrixMode(GL_MODELVIEW); //Cambiamos a la matriz de modelado

while(true) // Este bucle se ejecutara indefinidamente, por lo que no podremos terminar la aplicación sin matarla
{
draw(); // Función definida por nosotros para dibujar
glSwapBuffers(); // Intercambia los buffers y muestra uno en pantalla. Esto es así porque usamos double buffer
};

glClose(); 
return 0;
}




void gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar){
GLdouble top, bottom, left, right;
top = zNear * tan(pi180*fovy/2);
bottom = -top;
right = aspect*top;
left = -right;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(left, right, bottom, top, zNear, zFar);
glMatrixMode(GL_MODELVIEW);
}


void draw()
{
static GLfloat xrot=0; //variables estáticas para guardar la rotación del cubo
static GLfloat yrot=0;
static GLfloat zrot=0;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //limpiamos la pantalla
glLoadIdentity(); // reseteamos
glTranslatef(0.0f,0.0f,-5.0f); // Nos desplazamos un poco

glRotatef(xrot,1.0f,0.0f,0.0f); //
glRotatef(yrot,0.0f,1.0f,0.0f); // Rotamos en cada eje según nuestras variables de rotación
glRotatef(zrot,0.0f,0.0f,1.0f); //


glBegin(GL_QUADS); // Comenzamos a dibujar polígonos de cuatro vértices

glVertex3f(-1.0f, -1.0f, 1.0f); //Primer vértice del primer polígono
glVertex3f( 1.0f, -1.0f, 1.0f); //Segundo vértice
glVertex3f( 1.0f, 1.0f, 1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);

glVertex3f(-1.0f, -1.0f, -1.0f); //Primer vértice del segundo polígono
glVertex3f(-1.0f, 1.0f, -1.0f); //Segundo vértice
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);
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);
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);
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);
glVertex3f(-1.0f, 1.0f, 1.0f);
glVertex3f(-1.0f, 1.0f, -1.0f);

glEnd(); // Terminamos con los polígonos de cuatro vértices

xrot+=1.3f; // Modificamos las variables de rotación
yrot+=1.2f;
zrot+=1.4f;

}

 

Actividad Traslacion,Escalacion,Rotacion / Piramide

 

 

PIRAMIDE

 

 

Conceptos / Resumen

 

 

Piramide

Despues de dos intentos fallidos, primero se nos apago la computadora y luego se depuro el programa, esto fue lo que rescatamos del programa antes de nos sucediera la tragedia anteriormente relatada.  "Caras vemos, Vertices no sabemos"

 

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.

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.

glScalef(1.0f, 1.0f, 1.0f);

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

 

GLfloat ang = 1.0;
GLfloat ejex=0.5,

 ejey=0.5,

 escalar=1.0;

void reshape (int width,int height)
{
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,15,15,-15,15,-15);
glMatrixMode(GL_MODELVIEW);
}
void display()
{

glClear(GL_COLOR_BUFFER_BIT);

glLoadIdentity();

glRotatef(ang, 2.0f, 0.0f, 0.0f);

glTranslatef(ejex,0.0f,0.0f);
glScalef(escalar, escalar, escalar);

  glColor3f(1,0,0);
glBegin(GL_POLYGON);

glVertex3f(0,0,0);
glVertex3f(4,0,0);
glVertex3f(4,0,-4);
glVertex3f(0,0,-4);

glEnd();

 

glColor3f(0,1,0);
glBegin(GL_POLYGON);

glVertex3f(0,0,0);
glVertex3f(4,0,0);
glVertex3f(2,9,-2);

glEnd();

 

glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(4,0,0);
glVertex3f(2,9,-2);
glVertex3f(4,0,-4);

glEnd();

glColor3f(1,0,1);
glBegin(GL_POLYGON);
glVertex3f(4,0,-4);
glVertex3f(2,9,-2);
glVertex3f(0,0,-4);

glEnd();

glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(0,0,-4);
glVertex3f(2,9,-2);
glVertex3f(0,0,0);

glEnd();

glutSwapBuffers();

ang+=0.1f;

}

void piramide()

{

ang += 2;

if( ang > 360 ) ang -= 360;

glutPostRedisplay();

}

void init()
{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glClearColor(0,0,0,0);

}

void idle()
{
display();
}

void ArrowKey(int key, int x, int y){
switch (key){
case GLUT_KEY_RIGHT:
if( ejex<8.0 ){ejex = ejex + 0.5;}
if(ejex>0.1 && ejex<3){escalar = ejex;}
break;

case GLUT_KEY_LEFT:
if( ejex>-8.0 ){ejex = ejex - 0.5;}
if(ejex>0.1 && ejex<3){escalar = ejex;}
break;

}

}

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_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glEnable(GL_DEPTH_TEST);

glutInitWindowPosition(50,50);
glutInitWindowSize(500,500);
glutCreateWindow("Hello");

glutIdleFunc(piramide);

init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutKeyboardFunc(keyboard);
glutSpecialFunc(ArrowKey);
glutMainLoop();
return 0;
}

Transformaciones Geométricas

TRANSFORMACIONES GEOMÉTRICAS.

Un paquete grafico permite al usuario especificar que parte de una imagen definida se debe visualizar y donde esta parte se debe colocar en el dispositivo de visualización.

En el caso de las imágenes bidimensionales, una vista se selecciona especificando el plano xy y contiene la imagen total o cualquier parte de ella. Cuando se seleccionan múltiples zonas de vista, estas zonas se pueden colocar en ubicaciones de visualización independientes, o algunas zonas se podrían insertar en zonas de visualización más grandes.

TRASLACION.

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 a la posición de coordenadas original (x, y) para mover el punto a una nueva posición (x’, y’).

X’ = x + tx’                         y’ = y + ty

La traslación es una transformación de cuerpo rígido que mueve objetos sin deformarlos, es decir, se traslada cada punto del objeto la misma distancia.

ROTACIÓN.

Se aplica a los objetos al cambiar su posición a lo largo de la trayectoria de una circunferencia en el plano xy, especificamos un ángulo de rotación y la posición, en torno al cual se gira el objeto.

Al igual que las traslaciones, las rotaciones son transformaciones de cuerpos rígidos que mueven los objetos sin deformarlos. Se giran a través del mismo ángulo todos los puntos del objeto.  Los polígonos se giran al desplegar cada vértice a través del ángulo de rotación especifico y se vuelve a generar el polígono utilizando los nuevos vértices.  Las líneas curvas se giran al cambiar la posición de los puntos de definición y se vuelven a trazar las curvas.

ESCALACION.

Una transformación de Escalacion 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 Escalacion sx y sy para producir las coordenadas transformadas (x’, y’):

X’ = x.sx, y’ = y.sy

Los objetos que se transforman con las ecuaciones se escalan y cambian de posición. Los factores de Escalacion con valores menores a 1 acercan los objetos al origen de las coordenadas en tanto que los valores mayores que 1 alejan las posiciones de coordenadas del origen.

Incluir coordenadas para un punto fijo en las ecuaciones de Escalacion es similar a incluir coordenadas para un punto pivote en las ecuaciones de rotación. Se escalan polígonos al aplicar las transformaciones en cada vértice y luego volver a generar el polígono utilizando los vértices transformados.

2.2 COORDENADAS HOMOGENEAS Y REPRESENTACION MATRICIAL

En las aplicaciones de diseño y de creación de imágenes, realizamos traslaciones, rotaciones y escalaciones para ajustar los componentes de la imagen en sus posiciones apropiadas.

Las representaciones de matriz o representaciones matriciales son métodos estándar para implementar transformaciones en sistemas de graficas. En muchos sistemas, las funciones de rotación y Escalacion producen transformaciones con respecto al origen de las coordenadas.

2.3 COMPOSICION DE TRANSFORMACIONES BIDIMENSIONALES.

Traslaciones, rotaciones y escalaciones.

TRASLACIONES.

Se aplican dos vectores de traslación sucesivos en la posición de coordenadas P, la localización transformada final P, donde se representan P y P’ como vectores de columna de coordenadas homogéneas. Se puede verificar este resultado al calcular el producto de la matriz para las dos agrupaciones asociativas, es así, que demuestra que dos transformaciones sucesivas son aditivas.

ROTACIONES.

Dos rotaciones sucesivas que se aplican en el punto P producen la posición transformada. Al multiplicar las dos matrices de rotación, se verifica que dos rotaciones sucesivas son aditivas de modo que es posible calcular las coordenadas giradas finales con la matriz de rotación compuesta.

ESCALACIONES.

Concatenar matrices de transformación para dos operaciones de Escalacion sucesivas produce matriz de Escalacion compuesta. La matriz resultante indica que las operaciones de Escalacion sucesivas con multiplicativas. Es decir, si debiéramos triplicar el tamaño de un objeto dos veces en una sucesión, el tamaño final seria nueve veces al tamaño original.

ROTACIÓN DEL PUNTO PIVOTE GENERAL.

Se realiza una secuencia de operaciones la cual es:

-          Traslade el objeto de modo que mueva la posición del punto pivote al origen de las coordenadas

-          Gire el objeto con respecto del origen de las coordenadas.

-          Traslade el objeto de manera que se regrese el punto pivote a su posición original

ESCALACION DEL PUNTO FIJO GENERAL.

Se realiza una secuencia de operaciones la cual es:

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.

PROPIEDADES DE CONCATENACIÓN.

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

Por tanto podemos evaluar los productos matriciales al utilizar una agrupación asociativa ya sea de izquierda a derecha o de derecha a izquierda.

2.4 TRANSFORMACION VENTANA-AREA DE VISTA

El programador de la aplicación especifica una región rectangular en coordenadas de mundo (programa de aplicación representa un mundo que se crea o presenta interactivamente para el usuario), llamada ventana de coordenadas mundiales y una región rectangular correspondiente en coordenadas de pantalla, llamada área de vista, con la cual se establece la correspondencia de la ventana de coordenadas mundiales. La transformación que establece entre la ventana y el área se aplica a todas las primitivas de salida en coordenadas de mundo para que correspondan a coordenadas de pantalla.

2.5 TRANSFORMACIONES DE COMPOSICION GENERAL Y DE EFICIENCIA COMPUTACIONAL.

Una transformación bidimensional general representa una combinación de traslaciones, rotaciones y escalaciones.

Una implementación eficiente de las operaciones de transformación consiste en formular matrices de transformación, concatenar cualquier secuencia de transformación y calcular coordenadas transformadas al utilizar ecuaciones.

2.6 REPRESENTACION MATRICIAL DE TRANSFORMACIONES TRIDIMENSIONALES.

Así como las transformaciones bidimensionales se pueden presentar 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.

La transformación de un punto a esta forma se denomina homogeneización, igual que antes. Además los puntos cuya coordenada W es cero se llaman puntos en el infinito. También existe una interpretación geométrica. Cada punto en el espacio tridimensional se representa con una línea que pasa por el origen en el espacio de cuatro dimensiones y las representaciones homogeneizadas de estos puntos forman un subespacio tridimensional de un espacio de cuatro dimensiones definido por la ecuación W = 1.

2.7 COMPOSICION DE TRANSFORMACIONES TRIDIMENSIONALES

                                                                               

Se presentan dos formas de lograr la transformación deseada. El primer método es componer las transformaciones primitivas, T, Rx, Ry y Rz. Este método aunque es algo tedioso, es fácil de ilustrar y su comprensión nos ayudara en nuestro conocimiento de las transformaciones. El segundo método, que utiliza las propiedades de las matrices ortogonales especiales es más abstracto.

Transformaciones primitivas.

1.      Traslación de P1 al origen

2.      Rotación sobre el eje y para que P1P2 este en el plano (y, z)

3.      Rotación sobre el eje x para que P1P2 este en el eje z.

4.      Rotación sobre el eje z para que P1P3 esté en el plano (y, z).

Piramide solida

Piramide

Transformaciones Geometricas,Traslación, Rotación y Escalación.

TRANSFORMACIONES GEOMÉTRICAS EN DOS DIMENSIONES. 

Un paquete grafico permite al usuario especificar que parte de una imagen definida se debe visualizar y donde esta parte se debe colocar en el dispositivo de visualización. 

En el caso de las imágenes bidimensionales, una vista se selecciona especificando el plano xy y contiene la imagen total o cualquier parte de ella. Cuando se seleccionan múltiples zonas de vista, estas zonas se pueden colocar en ubicaciones de visualización independientes, o algunas zonas se podrían insertar en zonas de visualización más grandes.

TRASLACION.

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, t_x y t_y a la posición de coordenadas original (x, y) para mover el punto a una nueva posición (x’, y’).

X’ = x + t_x’                         y’ = y + t_y

La traslación es una transformación de cuerpo rígido que mueve objetos sin deformarlos, es decir, se traslada cada punto del objeto la misma distancia. 

ROTACIÓN. 

Se aplica a los objetos al cambiar su posición a lo largo de la trayectoria de una circunferencia en el plano xy, especificamos un ángulo de rotación y la posición, en torno al cual se gira el objeto. 

Al igual que las traslaciones, las rotaciones son transformaciones de cuerpos rígidos que mueven los objetos sin deformarlos. Se giran a través del mismo ángulo todos los puntos del objeto.  Los polígonos se giran al desplegar cada vértice a través del ángulo de rotación especifico y se vuelve a generar el polígono utilizando los nuevos vértices.  Las líneas curvas se giran al cambiar la posición de los puntos de definición y se vuelven a trazar las curvas. 

ESCALACION. 

Una transformación de Escalacion 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 Escalacion s_x y s_y para producir las coordenadas transformadas (x’, y’):

X’ = x.s_x, y’ = y.s_y

Los objetos que se transforman con las ecuaciones se escalan y cambian de posición. Los factores de Escalacion con valores menores a 1 acercan los objetos al origen de las coordenadas en tanto que los valores mayores que 1 alejan las posiciones de coordenadas del origen. 

Incluir coordenadas para un punto fijo en las ecuaciones de Escalacion es similar a incluir coordenadas para un punto pivote en las ecuaciones de rotación. Se escalan polígonos al aplicar las transformaciones en cada vértice y luego volver a generar el polígono utilizando los vértices transformados.

APLICACIÓN

TRASLACIÓN.

Se aplican dos vectores de traslación sucesivos en la posición de coordenadas P, la localización transformada final P, donde se representan P y P’ como vectores de columna de coordenadas homogéneas. Se puede verificar este resultado al calcular el producto de la matriz para las dos agrupaciones asociativas, es así, que demuestra que dos transformaciones sucesivas son aditivas.

ROTACIÓN.

Dos rotaciones sucesivas que se aplican en el punto P producen la posición transformada. Al multiplicar las dos matrices de rotación, se verifica que dos rotaciones sucesivas son aditivas de modo que es posible calcular las coordenadas giradas finales con la matriz de rotación compuesta.

ESCALACION.

Concatenar matrices de transformación para dos operaciones de Escalacion sucesivas produce matriz de Escalacion compuesta. La matriz resultante indica que las operaciones de Escalacion sucesivas con multiplicativas. Es decir, si debiéramos triplicar el tamaño de un objeto dos veces en una sucesión, el tamaño final seria nueve veces al tamaño original.

Codigo Cubo Dos Dimensiones

#include <GL/glut.h>
 void reshape (int width,int height)
  {
     glViewport(0,0,width,height);
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
     glOrtho(0,10,0,10,0,10); //valor minimo X y valor maximo y
    glMatrixMode(GL_MODELVIEW);
   }
    void display()
 {
     glClear(GL_COLOR_BUFFER_BIT);
     glColor3f(1,1,0);
     glLoadIdentity();
     glBegin(GL_LINE_STRIP);

     glVertex2f(0,0);
     glVertex2f(5,0);
     glVertex2f(5,5);
     glVertex2f(0,5);
  glVertex2f(0,0);
 
  glVertex2f(2.5,2.5);
     glVertex2f(2.5,7.5);
     glVertex2f(0,5);
   
     glVertex2f(5,5);
  glVertex2f(7.5,7.5);
  glVertex2f(2.5,7.5);
 glVertex2f(7.5,7.5);
  glVertex2f(7.5,2.5);
  glVertex2f(5,0);
  glVertex2f(7.5,2.5);
  glVertex2f(2.5,2.5);



    glEnd();
     glFlush();

}
 void init()
 {
  glClearColor(0,0,0,0);

}
   int main (int argc,char **argv)
 {
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowPosition(50,50);
    glutInitWindowSize(500,500);
    glutCreateWindow("Hello");
 init();
    glutDisplayFunc(display);
     glutReshapeFunc(reshape);
       glutMainLoop();
       return 0;


}

Imagen Vectorial y Rasterizada

IMAGEN RASTERIZADA 

Una imagen rasterizada es una estructura o fichero de datos que representan generalmente una rejilla rectangular de pixeles o puntos de color en un monitor de ordenador, papel u otro dispositivo de representación.

El color de cada pixel esta definido individualmente. Por ejemplo, una imagen en un espacio de color RGB, almacenara el valor de color de cada pixel en tres bytes: una para el verde, para azul y para rojo.

IMAGEN VECTORIAL

Es la imagen digital. La misma se encuentra conformada por objetos geométricos independientes como ser: polígonos, arcos, entre otros, y a cada uno de ellos se los definirá por distintos atributos matemáticos tales como la forma, el color, la posición.

La principal bondad que nos ofrecen las imágenes vectoriales es la de poder ampliar a placer su tamaño sin sufrir el problema del escalado que tienen los gráficos rasterizados.

Además permiten mover, estirar y hasta retorcer las imágenes de manera muy simple.

Entre las figuras geométricas que se aplican se destacan las siguientes: polígonos, líneas, políneas, curvas de Bézier, Bezigonos, elipses y círculos.

Cabe destacar, que el uso de este tipo de formato se ha extendido a la generación de imágenes en tres dimensiones, ya sean estáticas o dinámicas.

IMÁGENES RASTERIZADAS (FORMATOS)

GIF

Utilizado en la web. Formato de 8 bits (256 colores máximo) con soporte de animación por frames. Utiliza la compresión LZW.

JPEG

Es usado para fotografías e imágenes de gran tamaño y variedad de color en la web y por las cámaras digitales. Formato comprimido con perdida de calidad aunque se puede ajustar.

BMP

Usado por Microsoft Windows y por su Sistema Operativo. Se le puede aplicar compresión sin perdidas, aunque no todos los programas son compatibles.

TIFF

Se utiliza en gráficos de imprenta. Se pueden emplear algoritmos con perdida o sin perdida, muchos programas solo son compatibles con un pequeño conjunto de opciones disponibles y mayormente utilizados en scanner.

PNG

Gráfico libre con compresión sin pérdida que ofrece profundidades desde 8, 24 y 48 bits: 281 trillones de colores y se pueden obtener archivos desde 8 y 16 bits igual a 65536 tonos de grises. Fue diseñado para reemplazar al GIF en la web.

IMÁGENES VECTORIALES (FORMATOS)

DXF

Ficheros estándar de texto ASCII utilizados para almacenar datos vectoriales de programas CAD

CDR

Formato vectorial para aplicaciones CorelDRAW

DWG

Archivo en formato binario usado por AutoCAD. Puede contener tanto en 2D como en 3D con compresion y comprobacion de errores CRC para datos internos.

ODG

Formato creado por Macromedia, es ejecutado por plugin Flash, el cual permite mostrar animaciones contenidas en ficheros SWF.

SWF

Formato de archivo de gráficos vectoriales creado por Macromedia, pueden ser creados por Flash, suelen ser pequeños para ser publicadas en la WWW en forma de animaciones o applets con diversas funciones.

AI

Formato vectorial para Adobe Illustrator.