UNIDAD 3 CONCEPTOS

TRABAJO1

Como repaso de las unidades anteriores se nos mencionan los tipos de transformaciones existentes en OpenGL, a continuacion se nos da la definicion de cada una:

·  Proyección: Trasforman una escena 3d “abstracta”, en una imagen plana que puede ser visualizada en una pantalla.

·         Viewport: Ajustan el producto de la proyección a las dimensiones de un rectángulo contenedor (ventana).

De vista: o conocida tambien como ortograficanQue definen y afectan la posición desde la cual se visualizan las escenas tridimensionales. Pero para poder ajustar la proyección ortográfica se puede hacer uso del siguiente grupo de funciones:

glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far);

Esta función permite controlar los parámetros del volumen de vista izquierdo, derecho, abajo, arriba, cerca y lejos. Hay que recordar que debido a que no se posee percepción de profundidad en este modo el valor del volumen deberá corresponder en la mayoría de los casos a un volumen suficientemente grande para contener los objetos de la escena.

·Modelado: Sirven para manipular los objetos en la escena, permitiendo trasladarlos, rotarlos y deformarlos (escalarlos).

·  Modelo-Vista: Son la combinación de las dos transformaciones anteriores, que desde un punto de vista práctico son semejantes.

· Ortográfica: este permite ajustar la proyección ortográfica de lo cual utiliza el siguiente grupo de funciones:

glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far);

Esta función permite controlar los parámetros del volumen de vista izquierdo, derecho, abajo, arriba, cerca y lejos. Hay que recordar que debido a que no se posee percepción de profundidad en este modo el valor del volumen deberá corresponder en la mayoría de los casos a un volumen suficientemente grande para contener los objetos de la escena.

·       Perspectiva: Existen dos manera de manejar la proyección en perspectiva, a través de de una función gl o mediante la librería glu (una tercera puede ser realizar los cálculos de la matriz “manualmente”. En el primer caso:

glFrustrum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)

ROTACIÓN EN UN SOLO PUNTO

A CONTINUACIÓN SE MUESTRA EL CÓDIGO PARA PODER ROTAR EN UN SOLO PUNTO LA PELOTA EN ESTE CÓDIGO

#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, 1.0f, 0.0f, 0.0f);//CODIGO PARA Q SOLO TENGA ROTACION EN UN SOLO PUNTO
    glTranslatef(0.3f, 0.0f, 0.0f);// TRASLADAR EL CUBO A OTRA DISTANCIA EN EL EJE X

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

PRESENTACION DE PROYECCION ORTOGONAL

PROYECCIÓN ORTOGONAL

Proyección ortogonal

De las proyecciones que hemos manejado mayormente han sido ortogonales. Antes que nada una proyección ortogonal es aquella que nos define un volumen a la vista de un paralepipédo. Las características de esta proyección es que es indispensable el tamaño de los objetos y es independiente de la distancia a la que este el observador de la imagen.

ejemplo

Proyeccion perspectiva

Esta proyeccion da la sensacion de profundidad porque el tamaño de los objetos no depende de la distancia del observador, porque para conseguir este efecto se debe definir una proyeccion perspectiva. Debido a que esta proyeccion define el volumende la vista.

 

Como hemos visto en clase OpenGL proporciona funciones para controlar la traslación, rotación y escalado. Estas tranformaciones se pueden representar como matrices 4x4 ordenadas como vectores columna.
Las  funciones que implementan las transformaciones es:

void glTranslate{fd}(TIPO x, TIPO y, TIPO z);
void glTranslatef(float x, float y, float z);
void glTranslated(double x, dluble y, double z);
void glRotate{fd}(TIPO angulo_en_grados, TIPO x, TIPO y, TIPO z);
void glScale{fd}(TIPO sx, TIPO sy, TIPO sz);

Ejemplo de matriz                                                              Ejemplo de matriz de rotación

De traslación

 

 

4. pila de matrices en opengl lea y resuma el siguiente enlace

las funciones de traslación aplicados en las imágenes provocan la multiplicación de la matriz actual de la imagen por una matriz de traslación creada con los argumentos que se le pasan, por lo que las continuas llamadas a la función display() provocan la creación de constantes multiplicaciones de la matriz actual con el efecto que se observa de incrementar la traslación.

Por ello para solucionar el problema OpenGL llega a dispoder de las pilas de matrices las cuales permiten el almacenamiento y la recuperación de las matrices anteriormente usadas o manejadas. Antes que nada una pila es un almacén con funcionamiento FIFO, 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.

En el código que a continuación se muestra, se encuentra declarando dos funciones de matrices las cuales se tratan de glPushMatrix() y glPopMatrix().

La función glPushMatrix() lo que hace es 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().

La función glPopMatrix() provoca la eliminación de la matriz superior, dejando asi en la parte superior de la pila la matriz que estaba en el momento de llamar a la función GlPushMatrix().

void display(void) {

...

// glPushMatrix();

...

glTranslatef(0.0, 0.0, .5);

...

// glPopMatrix();

glutSwapBuffers();

}

Al ejecutar de nuevo la aplicación, primeramente tiene el mismo aspecto que sin comentar las llamadas, pero si obligamos a que se llame varias veces a la función display(). 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.

PROYECCION ORTOGONAL

Coordenadas oculares
Este tipo de coordenadas se encuentran situadas en el punto de vista que tiene el observador, sin que importe las transformaciones que llegue a temer. Lo cual representan de manera virtual un sistema de coordenadas. Dando la impresión de una imagen en 3D.

Transformaciones

Son las que posibilitan la proyección de las coordenadas como anteriormente se menciono en 3D con rotación y movimiento sobre la superficie de 2D. Y es solamente aplicado a modelos en si o al sistema de coordenadas para que sea posible la rotación de algún objeto.

Existen cuatro tipos de transformaciones que son:

Transformación del observador

Transformación del modelo
Transformación de la proyección
Transformaciones de la vista

Transformación del observador

Es aplicado a la escena y es usado para determinar el punto ventajoso de las escenas graficas. Esto debido a que permite ciclar y apuntar la cámara hacia donde se quiera.

Transformación del modelo

Se usa para situar, rotar y escalar los objetos de la escena y poder ver la diferencia en rotación y en traslación y realizarlo nuevamente pero invirtiendo el orden.

Transformación de la proyección

Aplicado en la orientación del modelador. Esto quiere decir que define el volumen de visualización y establece lo que son los planos de trabajo.

Transformaciones de la vista

En el momento en que se ha terminado todo el proceso de transformaciones, solo queda un último paso: proyectar lo que hemos dibujado en 3D al 2D de la pantalla, en la ventana en la que estamos trabajando. Esta es la denominada transformación de la vista.

Matrices

Las matemáticas son aplicadas en las transformaciones debido al uso de las matrices. Esto porque cada una de las transformaciones anteriores se realiza debido a la aplicación de matrices las cuales contienen los vértices de manera como descripción. Por lo tanto las transformaciones que son ejecutables con open GL pueden describirse con la multiplicación de dos o más matrices.

Matriz del modelador

Es una matriz con una dimensión de 4x4 que representa cierto sistema de coordenadas ya transformado que se esté usando para poder colocar y orientar a los objetos de la grafica que estemos manejando.

Translación

Es aquella imagen que se origina de otra imagen base por decirlo de cierta forma, que se encuentra fija en un origen fijo (x,y,z) y se quiere mover n unidades hacia la derecha, izquierda, etc. Para ello es necesaria una matriz de transformación y multiplicarla por la matriz del modelador. Por eso se hace uso de la función glTranslate, el cual crea a la matriz necesaria para la traslación de la imagen.

Rotación

 Para llevar a cabo esta acción se cuenta con una función de alto nivel que al igual que el de traslación construye una matriz de transformación la cual es multiplicada por la matriz activa de la imagen que se tiene realizada y es glRotate, el cual lleva como parámetros del ángulo que se va a rotar (en grados, sentido horario).

 Escalado

Como el mismo tema lo dice es la transformación de escala el cual incrementa el tamaño de nuestro objeto al expandirlo por todos los vértices a lo largo de los tres ejes por los factores especificados. La función que se usa para realizar dicha acción es glScale el cual lleva como parámetros la escala en x, y y z, respectivamente.

matriz identidad

El “problema” del uso de las funciones de escalado, rotación y traslación surge cuando se tiene más de un objeto en la escena. Estas funciones tienen efectos acumulativos. Para resolver el problema se hace un reinicio de la matriz del modeladora un estado que ya sea conocido, en este caso, centrada en el origen del sistema de coordenadas oculares.