Contenido

INTRODUCCION...................................................................................2

Perspectiva conceptos...........................................................................3

La cámara en OpenGL..........................................................................8

LookAt..................................................................................................11

Explicación del ejemplo de perspectiva...............................................13

Ejemplo de perspectiva........................................................................13

Resultados de la ejecución del ejemplo..............................................28

CONCLUSION.....................................................................................31

No se encuentran elementos de tabla de ilustraciones.

INTRODUCCION

El uso de las perspectivas nos permite realizar la visión de distintas

estructuras en diferentes ángulos de visión, con el desarrollo del siguiente informe de

práctica, se espera poder concretar definiciones concretas que nos permitan

comprender en que se fundamentan los distintos tipos de perspectivas y asi mismo en

que se diferencian cada una de estas. De igual manera, se espera que con la

comprensión de los fundamentos de los tipos de perspectivas, se realice un ejemplo

practico del uso en acción de este tipo de visión de cuerpos, ya sea de forma

bidimensional o lograr apreciarlas de forma tridimensional.

 Perspectiva conceptos.

La perspectiva (en latín, perspicere "para ver a través de") se utiliza

en gráficos, generalmente en una superficie plana para transmitir la representación de

un objeto tal como lo percibe el ojo y permitir la determinación intuitiva de su

composición tridimensional.

Geométricamente, las representaciones se consiguen a partir de la

intersección de un plano y un conjunto de objetivos, es decir, líneas rectas o rayos que

conectan los puntos del objeto representado con el punto desde el que se observa

(llamado punto de vista).

Existen dos tipos fundamentales de perspectivas, en función de la

posición relativa entre el modelo representado y el punto de vista:

Perspectiva cónica: También llamada perspectiva central, se

caracteriza por el hecho de que los objetos representados se hacen más pequeños a

medida que se alejan del espectador. Convergencia en el punto de fuga de la

representación de líneas paralelas del modelo. La mira forma un haz cónico, cuyo

vértice se encuentra en el punto de mira (ver figura 1).

 Figura 1. Ejemplo de perspectiva cónica

Perspectiva axonométrica: Este es un tipo de proyección en la que

todos los elementos visuales son paralelos entre sí, lo que equivale a infinitos ángulos

de visión. Con este tipo de perspectiva, las líneas paralelas en el modelo permanecen

paralelas a la imagen, por lo que los objetos no se encogen a medida que se alejan del

espectador y no hay un punto de fuga para que las líneas de los personajes converjan

(ver figura 1.1).

Figura 1.1. Ejemplo de perspectiva axonométrica

 Una de las formas más obvias de expresar la tridimensionalidad es la

disposición de los elementos en el espacio. En fotografía, o superficies

bidimensionales, la perspectiva se puede representar con tres opciones principales:

- La convergencia de líneas

En muchas fotografías, las líneas convergen en puntos llamados

puntos de fuga. El ejemplo más obvio de un punto de fuga es una vía de tren donde las

vías del tren parecen converger en un punto distante. Según la lente y el ángulo de

visión utilizados, el punto de fuga puede aparecer algo lejano (ver figura 1.3).

Figura 1.3. Ejemplo de convergencia de líneas

- La escala

La escala es el tamaño relativo de un objeto en una representación

gráfica. La reducción de tamaño es esencial para representar la distancia desde la

cámara. Por ejemplo, un camino bordeado de árboles a ambos lados (ver figura 1.4).
 Figura 1.4. Ejemplo de escala

- El tono y el color

Los tonos y colores ayudan a crear perspectiva. Los tonos claros

crean la impresión visual de estar detrás de los tonos oscuros. Por ejemplo, en una

toma de un paisaje brumoso, las montañas (tonos oscuros) parecen estar por delante

del cielo (tonos claros). Si hay varias pilas, se clasifican por intensidad del tono de color

(ver imagen 1.5).

Figura 1.5. Ejemplo del uso de tono y color

 La perspectiva es el arte de expresar objetos tridimensionalmente en

un plano y darles un efecto tridimensional. Los objetos están representados por tres

ejes XYZ. La altura se muestra en el eje Z, el ancho se muestra en el eje Y y la longitud

se muestra en el eje X.

Entre los sistemas más utilizados se encuentran la isométrica y la

caballera.

Proyección Isométrica - Es en la que los ejes están separados por el

mismo ángulo (120º). Las dimensiones siempre se refieren a tres ejes y su origen está

en un punto (ver imagen 1.6).

Figura 1.6. Ejemplo de proyección isométrica

 Perspectiva Caballera - El ángulo entre los ejes X y Z es de 90 grados

y la inclinación del eje Y con respecto al Z es de 135 grados. En este caso, las medidas

X y Z son reales y las medidas Y tienen un factor de reducción de 0,5 (ver imagen 1.7

para ver una representación gráfica de la perspectiva caballera).

Figura 1.7. Ejemplo de perspectiva de caballera

La cámara en OpenGL.

La cámara en OpenGL es la posición virtual del espectador dentro de

una escena en OpenGL. Se define por la posición del espectador en la escena y hacia

dónde o en qué dirección mira el espectador. La posición de la cámara dentro de una

escena OpenGL determina qué partes de la escena se representan en el dispositivo de

visualización y en qué ángulos. Se puede mover la cámara por la escena para ver

diferentes áreas o simular movimiento, pero a menudo es más fácil o más eficiente

mover objetos en la escena que la cámara.

 Se utilizan dos matrices para describir una cámara OpenGL. Una

matriz de vista de modelo (ModelView) y una matriz de proyección. Estos describen la

posición de la cámara y cómo renderizar los objetos que ve, respectivamente:

 La posición de la cámara se define utilizando la matriz de Modelview. La cámara

se puede colocar en cualquier lugar de la escena y se puede desplazar o rotar a

lo largo de cualquier eje. Para muchas aplicaciones, especialmente aquellas con

una pequeña cantidad de objetos, puede ser más fácil aplicar una

transformación inversa a los objetos de la escena para representar el

movimiento. Básicamente, en este caso toda la escena se mueve alrededor de

una cámara estática. Para escenas grandes, mover la cámara libremente y

mantener la escena estacionaria ayuda a lidiar con la complejidad computacional

de las tuberías y las matrices.

 La matriz de proyección controla los atributos de la cámara. Para usar la

analogía de la cámara, la matriz de proyección es como un tipo de lente que usa

la cámara. La matriz de proyección a menudo se modifica para realizar

proyecciones en perspectiva que tienen en cuenta la distancia para determinar el

tamaño de los objetos y proyecciones ortográficas que no tienen ajuste de

perspectiva. Otros efectos como la lente de ojo de pez, la distancia focal y otras

relaciones de aspecto se pueden configurar a través de la matriz de proyección.

Cuando se habla de cámara/espacio de vista, se refiere a todas las

coordenadas de vértice vistas desde la perspectiva de la cámara como el origen de la

escena: la matriz de vista transforma todas las coordenadas del mundo en

coordenadas de vista que son relativas a la posición de la cámara y dirección.

 Para definir una cámara necesitamos su posición en el espacio

mundial, la dirección en la que mira, un vector que apunta hacia la derecha y un vector

que apunta hacia arriba desde la cámara. Se va a crear un sistema de coordenadas

con 3 ejes unitarios perpendiculares con la posición de la cámara como origen (ver

imagen 1.8).

Figura 1.8. Ejemplo de sistema de coordenadas

1. Posición de la cámara. Conseguir la posición de la cámara es fácil.

La posición de la cámara es un vector en el espacio mundial que apunta a la posición

de la cámara.

2. Dirección de la cámara. El siguiente vector requerido es la dirección

de la cámara, por ejemplo, en qué dirección está apuntando.

3. Eje derecho. El siguiente vector que necesitamos es un vector

derecho que representa el eje x positivo del espacio de la cámara.

4. Eje ascendente. Ahora que tenemos tanto el vector del eje x como

el vector del eje z, recuperar el vector que apunta al eje y positivo de la cámara es

relativamente fácil: tomamos el producto vectorial del vector derecho y el de dirección.

 Figura 1.9. Ejemplo del funcionamiento de una cámara

LookAt

Una gran cosa acerca de las matrices es que si define un espacio de

coordenadas usando 3 ejes perpendiculares (o no lineales), puede crear una matriz con

esos 3 ejes más un vector de traducción y puede transformar cualquier vector en ese

espacio de coordenadas multiplicándolo por esta matriz. Esto es exactamente lo que el

LookAt hace.

Las partes de rotación (matriz izquierda) y traducción (matriz derecha)

están invertidas (transpuestas y negadas respectivamente) ya que queremos rotar y

trasladar el mundo en la dirección opuesta a donde queremos que se mueva la cámara.

El uso de esta matriz LookAt como nuestra matriz de vista transforma efectivamente

todas las coordenadas del mundo al espacio de vista que acabamos de definir ( ver

imagen 1.10).
 Figura 1.10. Ejemplo de matriz LookAt

La matriz LookAt entonces crea una matriz de vista que dónde R es el

vector derecho, U es el vector ascendente, D es el vector de dirección y P es el vector

de posición de la cámara.

GLM ya hace todo este trabajo por nosotros. Solo tenemos que

especificar una posición de cámara, una posición de destino y un vector que represente

el vector ascendente en el espacio mundial (el vector ascendente que usamos para

calcular el vector correcto). GLM luego crea la matriz LookAt que podemos usar como

nuestra matriz de vista (ver imagen 1.11):

Figura 1.11. Representación de la matriz LookAt en código

 Explicación del ejemplo de perspectiva

El ejemplo realizado en CodeBlocks con OpenGL logra mostrar el

funcionamiento de la perspectiva y el uso de la profundidad, de acuerdo a la posición

en la que llegue a establecer la cámara (rotación de los cubos) las figuras tomaran una

forma diferente, si la vista de los cubos es frontal la figura parecerá 2D (ver imagen

2.1), sin embargo, si se rota se lograra ver la profundidad que las figuras poseen,

pasando de 2D a 3D, y lograra mostrar lo que escondía, es decir, los demás cubos

atrás del cubo naranja (ver imagen 2.2), sin embargo, el ejemplo muestra cómo

funciona la cámara dentro de un juego, ya que si se hace el zoom suficiente las figuras

irán desapareciendo una a uno, y aunque existan no se verán, lo que concordaría con

el funcionamiento de la perspectiva, que si no se tiene en un rango de vista a un objeto

este no se podrá apreciar, como cuando una persona camina y deja de ver los objetos

que antes estaban delante de el, pero al avanzar los pierde ya que pasan a ser objetos

que se posicionan detrás de él, lugar donde no hay visión.

Ejemplo de perspectiva

#include <windows.h>

#include <GL/glut.h>

#include <stdlib.h>

#include <iostream>

#include <stdio.h>
 /*

|||||||||||||||||||||||||||

|| INTEGRANTES DEL EQUIPO||

|||||||||||||||||||||||||||||||||||||||||||||||||

||Márquez del Río Mayel Isaac ||||| 20321100||

||Gallardo Ignacio Christopher ||||| 20321028||

||Mauricio Bustamante Roberto ||||| 20321108||

||Martínez Gómez Oscar Iván ||||| 20321106||

||Gutiérrez Damián Jesús Uriel ||||| 20321053||

||Miranda Orbe Jesús Francisco ||||| 20321119||

||Scugall Duran Sergio Alejandro ||||| 20321221||

|||||||||||||||||||||||||||||||||||||||||||||||||

*/

using namespace std;

//SE DECLARAN LAS VARIABLES PERTINENTES PARA HACER

ROTAR LOS CUBOS

float angulolento=0.0,rotacion_y=0,rotacion_x=0;
 //SE ESTABLECE LA VARIABLE PARA PODER ESCALAR LA

PANTALLA

float tamanio=0;

bool instruccion=false;//SE USA PARA MOSTRAR O NO EL CUADRO

DE INSTRUCCIONES

char Int_a_CHAR[20]={0};//GUARDA EL NUMERO QUE SE

CONVERTIRA A CHAR

int vel=0;

//METODO INICIALIZA

void Inicializa()

{ glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE |

GLUT_DEPTH );

glutInitWindowSize(800,600); //SE ESTABLECE EL TAMANIO DE LA

PANTALLA

glutCreateWindow("Perspectiva y profundidad"); //SE ESTABLECE

EL NOMBRE DE LA ESCENA

glMatrixMode(GL_PROJECTION);

glLoadIdentity();
 glOrtho(-50,50,-50,50,-50,50); //SE ESTABLECE LA LONGITUD DE

LA ESCENA EN X Y Z

}//FIN DEL METODO INICIALIZA

/*

void RedimensionaPantalla(int w, int h)

{ glViewport(0, 0, w, h);

glMatrixMode(GL_MODELVIEW);

gluPerspective(45.0, (double)w / (double)h,1.0, 200.0);

}*/

//METODO QUE ESTABLECE EL TEXTO

void Texto(int tipoletra, int PosX, int PosY, char *s)

unsigned int i;

glRasterPos2i(PosX,PosY);

for ( i=0; i<strlen(s); i++)

switch ( tipoletra ) //establece los tipos de letra

 {

case 1: //TIPO DE LETRA BY

glutBitmapCharacter(GLUT_BITMAP_9_BY_15, s[i]);

break;

case 3: //TIPO DE LETRA TIMES ROMAN

glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,

s[i]);

break;

case 8: //TIPO DE LETRA BY

glutBitmapCharacter(GLUT_BITMAP_9_BY_15, s[i]);

break;

//METODO QUE HACE USO DE LAS TECLAS ESPECIALES PARA

ROTAR LOS CUBOS

 void teclas_especiales( int key, int x, int y ){

if (key == GLUT_KEY_RIGHT){ //CONDICION IF QUE SI PRECIONA

LA TECLA DERECHA

//ROTA EL CUBO EN EL EJE "Y" Y VA DE 10 EN

10

rotacion_y +=10;

else if (key == GLUT_KEY_LEFT){ //CONDICION IF QUE SI

PRECIONA LA TECLA IZQUIERDA

//ROTA EL CUBO EN EL EJE "Y" Y VA DE -10 EN -

10

rotacion_y -=10;

else if (key == GLUT_KEY_UP){//CONDICION IF QUE SI PRECIONA

LA TECLA UP

//ROTA EL CUBO EN EL EJE "X" Y VA DE 10 EN

10

rotacion_x +=10;
 }

else if (key == GLUT_KEY_DOWN){//CONDICION IF QUE SI

PRECIONA LA TECLA ABAJO

//ROTA EL CUBO EN EL EJE "X" Y VA DE -10 EN -

10

rotacion_x -=10;

glutPostRedisplay(); //SIRVE PARA QUE SE REPITA EL PROCESO

}//FIN DEL METODO DE TECLAS ESPECIALES

//METODO DE ESCALAMIENTO

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

switch (key)

case 27://Si se presiona el escape cierra el programa

exit(0);

case '+'://Si se presiona la tecla + se acerca a la pantalla

 if(tamanio<35) //Condicion if que marca el limite de aumento

tamanio+=0.1; //aumenta

break;

case '-'://Si se presiona la tecla - se aleja de la pantalla

if(tamanio>1){ //Condicion que nos permite delimitar el limite de

alejamiento

tamanio-=0.1;//disminuye

break;

case 'p'://Si se presiona la tecla p se establece el tamanio de 0

para asi ver las instrucciones

tamanio=0;//establece el tamanio

break;

} //FIN DEL METODO DE ESCALAMIENTO

//METODO QUE DIBUJA LA ESCENA

void Dibuja()

{ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 glEnable(GL_DEPTH_TEST);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

//CONDICION IF QUE MIENTRAS SE ENCUENTRE EN LA

POSICION 0 MUESTRE LAS INSTRUCCIONES

if (tamanio ==0){

glColor3f(1.0,1.0,1.0); //Da color al texto Colores

Texto(3,-5,30,"Instrucciones:"); //Se establece lo que hara cada

tecla

//ESTA PRIMITIVA SIRVE PARA HACER UN CONTRASTE CON

LA LETRAS INSTRUCCIONES

//Y LLAMAR LA ATENCION

glBegin(GL_QUADS);

glColor3f(0.0,0.0,0.1); //Da color a la primitiva

glVertex2i(-7,34);

glVertex2i(-7,28);

glVertex2i(13,28);

glVertex2i(13,34);

glEnd();
 glColor3f(0.0,0.0,0.0); //Se establece el color a los textos siguientes

Texto(8,-25,20,"Tecla Up rota en posicion X de manera

positiva");//Se establece las instrucciones

Texto(8,-25,10,"Tecla Down rota en posicion X de manera

negativa");//Se establece las instrucciones

Texto(8,-25,-0,"Tecla Right rota en posicion Y de manera

positiva");//Se establece las instrucciones

Texto(8,-25,-10,"Tecla LEFT rota en posicion Y de manera

negativa");//Se establece las instrucciones

Texto(8,-25,-20,"La tecla + se acerca a la pantalla");//Se establece

las instrucciones

Texto(8,-25,-30,"La tecla - se aleja de la pantalla");//Se establece

las instrucciones

Texto(8,-25,-40,"La tecla P muestra el menu de instrucciones");//Se

establece las instrucciones

//ESTA PRIMITIVA SIRVE PARA HACER UN CONTRASTE CON

LA LETRAS INSTRUCCIONES

//Y LLAMAR LA ATENCION

 glBegin(GL_QUADS);

glColor3f(0.0,1.0,0.6); //Da color a la primitiva

glVertex2i(-28,30);

glVertex2i(-28,-45);

glVertex2i(35,-45);

glVertex2i(35,30);

glEnd();

glBegin(GL_QUADS);

glColor3f(0.0,0.0,0.2); //Da color al texto Colores

glVertex2i(-50,50);

glVertex2i(-50,-50);

glVertex2i(50,-50);

glVertex2i(50,50);

glEnd();

}//FIN DE LA CONDICION IF

//ESCALA LA PANTALLA (ACERCA Y ALEJA LA PANTALLA CON

LAS VARIABLES TAMANIO)

 glScalef(tamanio,tamanio,tamanio);

glColor3f(1.0,1.0,1.0); //COLOR BLANCO PARA EL CUBO DE

CABLES

glPushMatrix(); //Sirve como detonante para que los demas cubos no

giren en torno al cubo de cables

//pero para ello debe activarse el glPopMatrix();

glTranslatef(0.0,0.0,0.0);

//METODO QUE HACE QUE ROTE RESPECTO AL EJE "X" Y EL

EJE "Y"

glRotatef(rotacion_x,1.0,0.0,0.0);

glRotatef(rotacion_y,0.0,1.0,0.0);

glutWireCube(2.0);//DIBUJA EL CON UN TAMANIO DE 2, EL CUBO

ES CON ALAMBRES/CABLES, NO ES SOLIDO

//Activar esta funcion en caso de querer que rote el cubo decables

//pero que los demas cubos no roten al rededor de el

//serviria para ver como funciona la perspectiva

//es decir, un objeto podria estar en movimiento, sin embargo, debido

al punto de vista no lo notariamos

 //glPopMatrix();

glColor3f(1.0,0.0,0.0);//SE ESTABLECE EL COLOR ROJO AL CUBO

SOLIDO

glTranslatef(0.0,0.0,5.0);//SE ESTABLECE LA POSICION DEL

CUBO, AQUI DESTACA LA POSICION Z PARA NO SOBREPONER AL CUBO

ANTERIOR

//glRotatef(rotate_x,1.0,0.0,0.0);

//glRotatef(rotate_y,0.0,1.0,0.0);

glutSolidCube(5.0);//DIBUJA EL CUBO CON UN TAMANIO DE 5

glColor3f(1.0,0.3,0.0);//SE ESTABLECE EL COLOR NARANJA AL

CUBO SOLIDO

glTranslatef(0.0,0.0,10.0);//SE ESTABLECE LA POSICION DEL

CUBO, AQUI DESTACA LA POSICION Z PARA NO SOBREPONER AL CUBO

ANTERIOR

//AQUI HAY DOS CODIGOS COMO COMENTARIO, SIRVE PARA

ROTAR EL CUBO
 //EN EL EJE "X" Y "Y", DESCOMENTARLO EN CASO DE QUERER

QUE ROTE

//glRotatef(rotate_x,1.0,0.0,0.0);

//glRotatef(rotate_y,0.0,1.0,0.0);

glutSolidCube(10.0); //DIBUJA EL CUBO CON UN TAMANIO DE 10

glColor3f(1.0,1.0,0.0); //SE ESTABLECE EL COLOR AL CUBO

glTranslatef(20.0,0.0,20.0);//SE ESTABLECE LA POSICION

//AQUI HAY DOS CODIGOS COMO COMENTARIO, SIRVE PARA

ROTAR EL CUBO

//EN EL EJE "X" Y "Y", DESCOMENTARLO EN CASO DE QUERER

QUE ROTE

//glRotatef(rotate_x,1.0,0.0,0.0);

//glRotatef(rotate_y,0.0,1.0,0.0);

glutSolidCube(20.0); //DIBUJA EL CUBO CON UN TAMANIO DE 20

//OBLIGA A REDIBUJAR LA ESCENA Y AMBOS SERVIRAN PARA

QUE LA ESCENA FUNCIONE BIEN

 glutPostRedisplay();

glutSwapBuffers();

}//FIN DEL METO QUE DIBUJA LA ESCENA

//METODO MAIN

int main(int argc, char **argv)

{ glutInit(&argc, argv);

Inicializa(); //EJECUTA EL METODO DE INICIALIZA

glutDisplayFunc(Dibuja); //LLAMA AL METODO DIBUJA

glutSpecialFunc(teclas_especiales); //LLAMA AL METODO TECLAS

ESPECIALES

glutKeyboardFunc(teclaOprimida); //LLAMA AL METODO TECLA

OPRIMIDA

glutMainLoop(); // METE EL MAIN EN UN LOOP PARA REDIBUJAR

LA ESCENA

return 0;

}//FIN DEL METODO MAIN

Resultados de la ejecución del ejemplo

Figura 2. Pantalla inicial, instrucciones sobre el programa

Figura 2.1. Resultado al hacer zoom a los cubos (perspectiva 2D)
Figura 2.2. Resultado al girar el cubo en x (perspectiva 3D)

Figura 2.3. Resultado de aplicar todo el zoom

 Figura 2.4. Resultado al rotar la figura en el eje y (visión aérea)

CONCLUSION

El uso de la perspectiva brinda infinidad de opciones para ver distintas

cosas de distintas formas, las variaciones dependerán desde el ángulo del que se

vean, un camino podrá verse más largo o más corto dependiendo de lo angosto del

camino, estas perspectivas ayudan a grandes cosas dentro de la graficación, ya que

permite engañar al ojo humano en muchas ocasiones, en los videojuegos se suele

aplicar las técnicas de ilusiones para así administrar recursos, desde la posición de la

cámara hasta la aparición de objetos, así mismo, el pasar de 2d a 3d permite ampliar el

mundo, haciéndolo más inmersivo.

Existen diversas formas de aplicar la perspectiva, alguna pueden ser

creativas y otra más simples, la forma más optima recae en cada programador y las

necesidades que requiera, cuando se habla de cámaras y perspectivas inmediatamente

se piensa en un mundo 3d y amplio en el cual se pueda navegar, sin embargo no

siempre es así, existen formas de mostrar profundidad con modelos 2d, siendo la

animación y los dibujos los ejemplos más claros, pero más difíciles de realizar debido a

que se debe de tener un conocimiento sobre cómo funciona la vista y

los puntos de fuga.