JuanGonzalezGraficacion
domingo, 20 de mayo de 2012
Investigacion
Medicina.
El desarrollo tecnológico ha propiciado un cambio
asombroso en la medicina; su avance ha permitido conocer infinidad de procesos
que explican el porqué de muchas enfermedades, de eventos que ocurren en el
organismo humano y de las consecuencias de relacionarse con su entorno. Esto ha
generado una forma más simple del razonamiento en la ejecución del acto medico,
surgiendo dos tendencias distintas de pensamiento: Una en la que se investiga,
reflexiona y estudia permanentemente acerca de los procesos y otra en la que se
aplica la tecnología sin la labor indagatoria por parte del médico.
Tecnología:
Resonancia
Magnética Nuclear
Rayos x
Educación
Constantemente, se utilizan como instrumentos de
ayuda educativa modelos de sistemas físicos, financieros y económicos, los
cuales se generan por computadora. Modelos de sistemas físicos, sistemas
fisiológicos, tendencias de población o equipo, pueden ayudar a los estudiantes
a comprender la operación del sistema. En el caso de algunas aplicaciones de
capacitación, se diseñan sistemas especiales, como los simuladores para
sesiones de práctica o capacitación de capitanes de barco, pilotos de avión,
operadores de equipo pesado y el personal de control de tráfico aéreo. Algunos
simuladores no tienen pantallas de video; por ejemplo, un simulador de vuelo
que sólo tiene un panel de control como instrumento de vuelo. No obstante, la
mayor parte de los simulado-res cuenta con pantallas gráficas para la operación
visual.
Tecnología:
Pizarrones Inteligentes.
Computadoras.
Publicidad
Los métodos de Informática Gráfica se utilizan de
forma generalizada tanto en aplicaciones de bellas artes como en aplicaciones
de arte comercial y publicidad. La mayoría de ilustraciones que encontramos en
las revistas, carátulas de discos etc, se realizan con paquetes informáticos de
Diseño Gráfico.
Tecnología:
Cámaras.
Software:
Paint.
Photoshop.
Entretenimiento.
En la actualidad se utilizan comúnmente los métodos
de Informática Gráfica en la producción de cine, videojuegos etc.
Es muy común
utilizar métodos de gráficas por computadora para producir películas, videos
musicales y programas de televisión. En ocasiones, se despliegan sólo imágenes
gráficas y otras veces, se combinan los objetos con los actores y escenas en
vivo. Por ejemplo, en una escena gráfica creada para la película Start Treck -
The Wrath of Khan, se dibujan en forma de armazón el planeta y la nave espacial
y se sonbrean con métodos de presentación para producir superficies sólidas. Al
igual que pueden aparecer personas en forma de armazón combinadas con actores y
una escena en vivo.
Tecnología:
Computadoras.
Software:
3D max
Maya
Blender
miércoles, 2 de mayo de 2012
Unidad 4 Iluminación y Sombreado
Relleno de Polígonos.
Existen dos modos de relleno de
polígonos. En general la diferencia es mínima, y sólo se manifiesta en casos de
polígonos complejos, con varias superposiciones.
Los dos modos de relleno son:
·
Alternativo: rellena las áreas entre las líneas impares y pares de cada
línea de rastreo. Para ver cómo funciona este modo, imaginemos que recorremos
cada línea horizontal de la pantalla de izquierda a derecha. El espacio entre
el borde y la primera línea del polígono se deja sin rellenar, el espacio entre
la primera línea y la segunda se rellena, el espacio entre la segunda y la
tercera, si existe, se deja sin rellenar, etc. Por ejemplo:
Alternado de relleno
·
Tortuoso (winding): en este modo se asigna un número a cada región de la
pantalla dependiendo del número de veces que se ha usado la pluma para trazar
el polígono que la define. Hay que tener en cuenta la dirección en que se
recorre cada línea. Las regiones en que ese número no sea nulo, se rellenarán.
Relleno tortuoso
Al seguir las líneas del cuadrado
externo en el sentido de las flechas, cada uno de los dos cuadrados son rodeado
una vez, a cada uno de ellos le asignamos un valor de winding igual a uno.
Al seguir las líneas de cuadrado
interno, en el caso de la izquierda recorremos el cuadrado interno en el mismo
sentido que la primera vez, por lo tanto, le sumamos a esa figura una unidad a
su valor de winding. En el caso de la figura de la derecha, la recorremos en
sentido contrario, por lo tanto le restamos una unidad al cuadrado interno, es
decir, que en el caso de la derecha, el valor winding del cuadrado interno es
cero, y no se rellena.
Si seleccionamos el modo de llenado
alternativo, el cuadrado interno no se rellenará nunca, como de hecho sucede en
la primera imagen.
Rellenos de Polígonos en OpenGL.
Es el método que
utiliza OpenGL para rellenar de color los polígonos. Se especifica con la
función glShadeModel. Si el parámetro es GL_FLAT, ogl rellenará los polígonos
con el color activo en el momento que se definió el último parámetro; si es
GL_SMOOTH, ogl rellenará el polígono interpolando los colores activos en la
definición de cada vértice.
Técnicas
de sombreado clásicas y avanzadas
Clásicas:
Iluminación local.
Luces que no son
extensas, como las reales, sino inextensas, puntuales. Y, por añadidura, se
relacionan con los objetos como mónadas aisladas, sin tener en cuenta la
interacción entre ellos. Esto explica lo artificioso de muchas de las técnicas
que se describirán más adelante y que buscan compensar estas limitaciones.
Cálculos
de iluminación por vértices.
Para aplicar
iluminaciona un objeto necesitamos asociar un vector normal a cada vertice del
objeto. Cuando tenemos la normal
calculada tenemos que normalizarla, o sea, dividir ese vector por su propio
modulo para que sea unitario, pero también podemos hacer que se encargue la
OpengGl activando la normalización con el comando glEnable GL_NORMALIZE o
desactivarla con glDisable GL_NORMALIZE.
El usar GL_NORMALIZE
dependerá de nuestra aplicación ya que si forzamos a que sea OpenGl el que las
utilice se ralentiza por que le estamos obligando a hacer mas cálculos de los
que debe.
Para definir las
normales en opengl utilizaremos la función glNormal3f(X,Y,Z) por ejemplo para
definir una cara con 4 vértices la definiremos de la siguiente manera:
GlBegin GL_QUADS
glNormal3f nX,nY,nZ
glvertex3f x,y,z
glvertex3f x,y,z
glvertex3f x,y,z
glvertex3f x,y,z
glEnd
Posterior
relleno de triángulos
Rellenado de los
triángulos (rastering). Para ello se realizan varias fases de procesamiento por
Pixel. Comprobar si cada nuevo pixel es visible o no (comprobación de
profundidad). Interpolación lineal del color para el nuevo pixel (método de
Gouraud).
Si existe una textura
definida o transparencia, efectuar la modificación de color correspondiente.
Se trata de la última
fase, en ocasiones la más costosa, del proceso, por lo que es la primera que se
suele integrar en el hardware gráfico. En esta etapa se trata de asignar
colores a los pixels correspondientes al interior de cada triángulo proyectado
que cae dentro del área de visualización. Los colores asignados deben
calcularse por el método de Gouraud, interpolando linealmente entre los colores
de los tres vértices.
Renderizado
en Tiempo real
La idea fundamental del
procesado en tiempo real es que todos los objetos deben ser descompuestos en
polígonos. Estos polígonos serán descompuestos a su vez en triángulos. Cada
triángulo será proyectado sobre la ventana bidimensional y rellenado con los
colores adecuados para reflejar los efectos de la iluminación, texturas, etc.
Una vez se han generado los triángulos, en la pipeline existen dos partes
claramente diferenciadas: una primera etapa operaciones realizadas sobre cada
uno de los vértices, y después de que éstos se proyecten sobre la ventana,
entonces comienza una segunda fase de cálculos realizados para cada pixel
cubierto por triángulos.
Iluminación global.
•
Considera
la luz reflejada por un punto teniendo en cuenta toda la luz que llega
•
No
solo procedente de las luces
•
Efectos
–
producen
sombras
–
reflexión
de un objeto en los otros
–
transparencias
Trazado de Rayos
El trazado de rayos computa la interacción de la luz
desde un punto de vista determinado y es particularmente adecuado para
superficies reflectantes. Puede utilizarse como propiedad específica de un
determinado material.
Radiosidad
Está basado en
principios generales que se pueden encontrar en un manual general sobre
rendering. En el estadio inicial la escena consta de dos tipos de objetos:
objetos que emiten luz y objetos que reciben luz. A partir de aquí, en una
primera vuelta, se computa la luz que recibe cada objeto o, en una aproximación
más exacta, cada parte de un objeto, según una subdivisión cuya densidad puede
precisarse en sucesivas aproximaciones.
Cálculos
de iluminación por pixel
Iluminación por
fragmento (por pixel) puede ser elaborada en hardware de gráficos moderno como
un proceso de post-rasterización por medio de un programa de shader.
Pixel Shader (PS) como
un pequeño programa que procesa fragments (algo así como pixelscon más datos) y
que se ejecuta en la GPU. Al crear un PS, se crea una función de procesado de
fragmentos que manipula datos de fragmentos.
Alto
Acabado
Sombreado Constante o
plano. Un cálculo para todo el polígono. Obtenemos una intensidad que aplicamos a un conjunto de puntos de un
objeto (p.ej. todo un triángulo). Aceleramos el proceso de síntesis. Correcto si se verifica: Fuente de luz en el
infinito. Observador en el infinito. El polígono representa una superficie
plana real del objeto que se modela y no es una aproximación de un objeto
curvo.
Sombreado
Constante o Plano
§ Obtenemos
una intensidad que aplicamos a un conjunto de puntos de un objeto .
§ - Aceleramos el proceso de síntesis.
§ - Correcto
si se verifica.
§ - Fuente
de luz en el infinito.
§ - Observador
en el infinito.
Un
cálculo para todo el polígono
Obtenemos una
intensidad que aplicamos a un conjunto
de puntos de un objeto (p.ej. todo un triángulo)
§ Aceleramos
el proceso de síntesis
§ Correcto
si se verifica
§ Fuente
de luz en el infinito
§ Observador
en el infinito
§ El
polígono representa una superficie plana real del objeto que se modela y no es
una aproximación de un objeto curvo.
Interpolación de Intensidades (Gouraud)
Se basa en la interpolación de intensidad o
color, considera que facetas planas vecinas proceden de aproximar una superficie
curva.
·
Elimina en gran medida las
discontinuidades de iluminación
·
Es sencilla, pero produce peores
resultados en objetos con brillos especulares que el método de Phong
·
Implementado en OpenGL
Calcula
normales al polígono
Evaluar la ecuación de
iluminación en cada punto de una superficie genérica es muy costoso. Posible
solución: aproximar mediante facetas planas e interpolar dentro de cada polígono.
Ray
Tracing
En muchas formas, ray
tracing es una extensión al enfoque de rendering con un modelo de iluminación
local. Está basado en la observación previa que, de los rayos de luz saliendo
de una fuente, los únicos que contribuyen a la imagen son aquellos que entran
el lente de la cámara sintética y pasan por el centro de proyección.
Buffer
de Profundidad.
El Z-Buffer se basa en
que al generar la posición de un punto en la pantalla la computadora reserve
una zona de memoria especial, llamada Z-Buffer, información relacionada con la
profundidad del punto que ocupa en la escena representada. Cuando el ordenador
representa un nuevo punto consulta el Z-Buffer del píxel que corresponde en
pantalla. Si el valor que ya existe en el píxel es mayor que el que posee el
nuevo punto, el sistema asume que este último es el visible y lo sustituye en
la memoria del Z- Buffer.
Buffer
Stencil.
Stencill Buffer es una
memoria intermedia que analiza y actualiza píxeles (con sus operaciones) junto
con “depth buffer” o buffer de profundidad. Añade planos de bits adicionales
para cada píxel además de los bits de color y profundidad.
Stencil buffer es similar al buffer de
profundidad en que los dos son colección de planos de bit que no se pueden
mostrar. Del mismo modo que el buffer de profundidad asocia a cada píxel de la
ventana un valor de profundidad, el stencil buffer asocia su propio valor a
cada píxel mostrado. Cuando el buffer de profundidad esta activado los valores
de profundidad son usados para aceptar o rechazar fragmentos, del mismo modo
los valores de Stencil buffer son usados para aceptar o rechazar fragmentos.
Fuentes
de Color
No solamente las
fuentes de luz emiten diferentes cantidades de luz en diferentes frecuencias,
pero también sus propiedades direccionales varían con la frecuencia. Por lo
tanto, un modelos físicamente correcto puede ser muy complejo. Para la mayoría
de las aplicaciones, se puede modelar fuentes de luz en base a tres componentes
primarios, RGB, y puede usar cada uno de los tres colores fuentes para obtener
el componente de color correspondiente que un observador humano vería.
Luz
Ambiente
La luz ambiente ilumina
por igual todas las zonas en sombra para simular el efecto de interacción entre
objetos que hace que las partes en sombra de los objetos queden parcialmente
iluminadas.
Spotlights
Los spotlights se caracterizan por un rango
delgado de ángulos por los cuales se emite luz. Se puede construir un spotlight
sencillo de una fuente de punto limitando los ángulos de donde la luz de la
fuente se puede ver. Se puede usar un cono cuyo ápice está en ps, apuntando en
la dirección ls, y cuyo ancho está determinado por el ángulo θ.
Fuentes
de Luz Distantes
La mayoría de los
cálculos de sombreado requieren la dirección de un punto sobre la superficie a
la fuente de luz. Según se mueve a lo largo de la superficie, se debe
recomputar este vector para calcular la intensidad en cada punto, una computación
que es una parte significativa del cálculo del sombreado. Sin embargo, si la
fuente de luz está lejos de la superficie, el vector no cambiará mucho según se
mueve de un punto a otro, al igual que la luz del sol da en todos los objetos
cercanos entre si con el mismo ángulo.
miércoles, 25 de abril de 2012
Circulo y Elipse
La ecuación del Círculo
En la
mayoría de las gráficas generadas por fórmulas, la formula está dado en la
forma
y = f(x)
Tal
forma hace muy facil encontrar los puntos en la gráfica. Todo lo que hay que
hacer es elegir x, calcular f(x) (= alguna expresión dada que implique a x) y
tendremos el valor correspondiente de y.
Sin
embargo, cualquier ecuación concerniente a x e y puede ser
usada como la propiedad compartida por todos los puntos de la gráfica. La
diferencia principal es que en ecuaciones más complicadas, después de elegir
la x, encontrar la y correspondiente requiere trabajo extra, ( y algunas
veces es más fácil elegir la y y encontrar la x).
Quizá
la gráfica más conocida de este tipo es el círculo de radio
R, cuya ecuación es
|
x2 + y2
= R2
Dibujar
un círculo de radio R centrado en el origen O de un sistema de ejes (x,y).
Determinado algún punto P en el círculo con los valores especificados de
(x,y), dibujar una línea perpendicular desde P hasta el punto A en el eje de
las x. Luego
|
x = OA
y = AP R = OP
|
Aquí x
y/o y pueden ser negativas, si están hacia la izquierda del eje de las y o
por debajo del eje de las x, pero a pesar del signo, x2 e y2 son
ambas siempre positivas. Puesto que el triángulo OAP tiene un ángulo de 90°,
por el teorema de Pitágoras, para cualquier elección de P, la relación de
abajo siempre contiene:
OA2 + AP2
= OP2
También
se puede escribir
x2 + y2
= R2
La
ecuación del círculo es cumplida por cualquier punto localizado en el. Por
ejemplo, si la gráfica está definida por la ecuación:
x2 + y2
= 25
esta
ecuación se cumple por todos los puntos listados abajo:
|
x
|
5
|
4
|
3
|
0
|
-3
|
-4
|
-5
|
-4
|
-3
|
0
|
3
|
4
|
( 5
)
|
y
|
0
|
3
|
4
|
5
|
4
|
3
|
0
|
-3
|
-4
|
-5
|
-4
|
-3
|
( 0
)
|
La Ecuación de una Elipse
La
ecuación del círculo aún expresa la misma relación si ambos lados se dividen
por R2:
(x2/R2)
+ (y2/R2) = 1
La
ecuación de una elipse es esa misma con una pequeña
modificación:
(x2/a2)
+ (y2/b2) = 1
donde
(a,b) son dos números dados, por ejemplo (8,4). ¿Cual será la gráfica de esa
ecuación? Cerca del eje x y es muy pequeña y la ecuación se acerca casi
a
(x2/a2)
= 1
De
donde
|
x2 = a2 y por lo tanto x
= a ó x = -a (a veces combinado con x
= ±a)
|
La
gráfica en esas cercanías se asemeja a la sección de un círculo de
radio a, cuya ecuación
(x2/a2)
+ (y2/a2) = 1
en esta
región también está cercana a x2 = a2. De la misma
forma puede observar que cerca del eje de las y, donde x es pequeña, la
gráfica corta el eje en y=±b y su figura aparenta la de un círculo de radio
b.
|
glutLookAt
glutLookAt
Esta es la función que determina dónde y
cómo está dispuesta la cámara. Cuidado que la posición de la cámara no tiene
nada que ver con el tipo de proyección que hayamos definido. La proyección se
define sólo una vez, típicamente al principio del programa en una función
inicializadora, mientras que la cámara se mueve continuamente.
glTranslatef
Produce una traducción de x y z. La matriz actual (ver glMatrixMode) se multiplica por la matriz de traducción, con el producto sustitución de la matriz actual, como si glMultMatrix fueron llamados con la siguiente matriz
de su argumento.
lunes, 23 de abril de 2012
El Carro
#include <GL/glut.h>
GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;
GLint ancho=600;
GLint alto=400;
int ang =0 ;
int movx = 0;
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 Piso(void)
{
glColor3f(1.0f, 1.0f, 1.0f);
glScalef(1.5f,0.0f,1.5f);
glBegin(GL_QUADS);
glVertex3f( 10.0f,-10.0f, -10.0f);
glVertex3f( 10.0f,-10.0f, 10.0f);
glVertex3f(-10.0f,-10.0f, 10.0f);
glVertex3f(-10.0f,-10.0f, -10.0f);
glEnd();
}
void carro(void)
{
glColor3f(1.0f, 0.0f, 0.0f);
glBegin(GL_POLYGON);
glVertex3f(-1.5f,0.5f, -2.0f);
glVertex3f( 3.5f,0.5f, -2.0f);
glVertex3f(3.5f,2.0f, -2.0f);
glVertex3f(2.0f,2.0f, -2.0f);
glVertex3f(1.f,3.0f, -2.0f);
glVertex3f(-0.5f,3.0f, -2.0f);
glVertex3f(-1.5f,2.0f, -2.0f);
glEnd();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -5.0f);
glRotatef(15, 1.0f, 0.0f, 0.0f);
glRotatef(15, 0.0f, 1.0f, 0.0f);
Piso();
glLoadIdentity();
glColor3f(0.0f, 0.0f, 1.0f);
glTranslatef(movx,0.0,0.0);
carro();
glLoadIdentity();
glTranslatef(-.5f,0.5f,-1.0f);
glColor3f(0.0f, 0.0f, 1.0f);
glRotatef(ang,1.0,0.0,0.0);
glTranslatef(movx,0.0,0.0);
glutSolidSphere(0.5f, 16, 16);
glLoadIdentity();
glTranslatef(3.0f,0.5f,-1.0f);
glColor3f(0.0f, 1.0f, 0.0f);
glRotatef(ang,1.0,0.0,0.0);
glTranslatef(movx,0.0,0.0);
glutSolidSphere(0.5f, 16, 16);
glLoadIdentity();
glFlush();
glutSwapBuffers();
}
void init()
{
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);
ancho = 600;
alto = 900;
}
void idle()
{
display();
}
void specialkeyevent( int key, int Xx, int Yy )
{
switch ( key ) {
case GLUT_KEY_LEFT:
movx-=1;
ang-=1;
display();
break;
case GLUT_KEY_RIGHT:
movx+=1;
ang-=1;
display();
break;
}
glutPostRedisplay();
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(100, 100);
glutInitWindowSize(ancho, alto);
glutCreateWindow("Coche en movimiento");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutSpecialFunc(specialkeyevent );
glutMainLoop();
return 0;
}
GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;
GLint ancho=600;
GLint alto=400;
int ang =0 ;
int movx = 0;
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 Piso(void)
{
glColor3f(1.0f, 1.0f, 1.0f);
glScalef(1.5f,0.0f,1.5f);
glBegin(GL_QUADS);
glVertex3f( 10.0f,-10.0f, -10.0f);
glVertex3f( 10.0f,-10.0f, 10.0f);
glVertex3f(-10.0f,-10.0f, 10.0f);
glVertex3f(-10.0f,-10.0f, -10.0f);
glEnd();
}
void carro(void)
{
glColor3f(1.0f, 0.0f, 0.0f);
glBegin(GL_POLYGON);
glVertex3f(-1.5f,0.5f, -2.0f);
glVertex3f( 3.5f,0.5f, -2.0f);
glVertex3f(3.5f,2.0f, -2.0f);
glVertex3f(2.0f,2.0f, -2.0f);
glVertex3f(1.f,3.0f, -2.0f);
glVertex3f(-0.5f,3.0f, -2.0f);
glVertex3f(-1.5f,2.0f, -2.0f);
glEnd();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -5.0f);
glRotatef(15, 1.0f, 0.0f, 0.0f);
glRotatef(15, 0.0f, 1.0f, 0.0f);
Piso();
glLoadIdentity();
glColor3f(0.0f, 0.0f, 1.0f);
glTranslatef(movx,0.0,0.0);
carro();
glLoadIdentity();
glTranslatef(-.5f,0.5f,-1.0f);
glColor3f(0.0f, 0.0f, 1.0f);
glRotatef(ang,1.0,0.0,0.0);
glTranslatef(movx,0.0,0.0);
glutSolidSphere(0.5f, 16, 16);
glLoadIdentity();
glTranslatef(3.0f,0.5f,-1.0f);
glColor3f(0.0f, 1.0f, 0.0f);
glRotatef(ang,1.0,0.0,0.0);
glTranslatef(movx,0.0,0.0);
glutSolidSphere(0.5f, 16, 16);
glLoadIdentity();
glFlush();
glutSwapBuffers();
}
void init()
{
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);
ancho = 600;
alto = 900;
}
void idle()
{
display();
}
void specialkeyevent( int key, int Xx, int Yy )
{
switch ( key ) {
case GLUT_KEY_LEFT:
movx-=1;
ang-=1;
display();
break;
case GLUT_KEY_RIGHT:
movx+=1;
ang-=1;
display();
break;
}
glutPostRedisplay();
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(100, 100);
glutInitWindowSize(ancho, alto);
glutCreateWindow("Coche en movimiento");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutSpecialFunc(specialkeyevent );
glutMainLoop();
return 0;
}
lunes, 26 de marzo de 2012
Resumen Unidad 3
Hardware
El API
de ogl está pensado para trabajar bajo el respaldo de un hardware capaz de
realizar las operaciones necesarias para el renderizado, pero si no se dispone
de ese hardware, estas operaciones se calcularan por medio de un software
contra la CPU del sistema.
Windows
En
principio, cualquier versión de windows viene con las librerías necesarias para
ejecutar cualquier aplicación que utilice OpenGL. Para el desarrollo de las
mismas, el Microsoft Visual Studio, y en particular Visual C++ trae también
todo lo necesario.
Linux
Para
visualizar aplicaciones OpenGL en XFree86 necesitarás instalar un paquete para
el soporte de las librerías Mesa (que es el equivalente en software libre de
OpenGL) y de las utilidades GLU y GLUT. Para realizar desarrollo necesitarás, a
mayores, los paquetes equivalentes en modo dev.
En
“Primeros Pasos en OpenGL” se mencionaba de manera general algunos conceptos
relacionados con las transformaciones en OpenGL, específicamente la proyección.
Es recomendable revisar y entender “Primeros Pasos en OpenGL” antes de
aventurarse a leer el presente tutorial.
En los
“Hola Mundo 3d en OpenGL” y “Hola Complicado Mundo OpenGL-win32” se utilizaron
algunas transformaciones de proyección y viewport para ajustar la
inicialización de la ventana, pero sin entrar mucho en detalle acerca de su
funcionamiento.
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: Que definen y afectan la posición desde la cual se visualizan las
escenas tridimensionales.
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.
void glMatrixMode(
enum mode ); Permite seleccionar la matriz sobre la cual se realizaran las
operaciones, los posibles valores de mode son TEXTURE, MODELVIEW, COLOR o
PROJECTION . Por ahora las más interesantes son MODELVIEW y PROJECTION, las
otras se verán en su momento.
Void
glLoadMatrix{fd} (T m[16]); Recibe una matriz de 4×4 que reemplaza la actual
seleccionada. El arreglo es ordenado en forma de una matriz que tiene orden Y,
a diferencia de las matrices convencionales que tienen orden X, lo que quiere
decir que tiene la forma
void
glMultMatrix{fd}( T m[16] ); Multiplica la matriz actual por la matriz m[16] y
reemplaza la matriz actual con el resultado de la operación. La operación
resultante sería algo así como A’ = A M , donde A es la matriz actual, M es la
matriz suministrada y A’ es la nueva matriz que resulta de la operación y que
reemplaza a A.
void
glLoadTransposeMatrix{fd}( T m[16] ); Realiza una función similar a
LoadMatrix(), con la diferencia que trabaja sobre una matriz en orden X así: que
es evidentemente la transpuesta de la m que recibe LoadMatrix.
void
glPushMatrix( void ); Coloca una copia de la matriz actual en la parte superior
de la pila correspondiente.
void
glPopMatrix( void ); Saca el elemento superior de la pila, que pasa a
reemplazar a la matriz actual.
void
glGetFloatv(enum value, float *data); Permite obtener una copia de aquello que
se indica en value. Por ejemplo si se pasan como parámetros MODELVIEW_MATRIX y
un apuntador a un arreglo de flotantes tamaño 16 se obtiene una copia de dicha
matriz a través del arreglo.
Proyección
Como ya
se ha visto en tutoriales anteriores, OpenGL maneja 2 tipos de proyección, en
perspectiva y ortográfica, donde la primera corresponde a la visión “realista”
de la escena, mientras que la segunda es una “plana” que no deforma las
dimensiones de los objetos dependiendo de su distancia a la cámara.
Ortográfica:
Para ajustar la proyección ortográfica se 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.
gluOrtho2D(GLdouble left, GLdouble right, GLdouble
bottom, GLdouble top);
Esta
función es simplemente una forma de la anterior, en donde se ha despreciado el
valor de Z asignando los valores near = -1 y far = 1, generalmente se utiliza
para escenas planas, en las que los objetos carecen de profundidad.
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”.
Transformaciones
ModelView
Una
tarea muy común en la creación de gráficos 2d, 3d y videojuegos es la de mover
objetos par crear cierta animación. La primera idea que se nos viene a la
cabeza en el caso de OpeGL es que todo modelo está formado por primitivas, toda
primitiva por puntos y finalmente todo punto por una tripleta de coordenadas
XYZ, así que si se cambian las coordenadas todo de ahí hacia arriba se mueve.
Coordenadas
oculares
Las
coordenadas oculares se sitúan en el punto de vista del observador, sin
importar las transformaciones que tengan lugar. Por tanto, estas coordenadas
representan un sistema virtual de coordenadas fijo usado como marco de
referencia común.
Transformaciones
Las
transformaciones son las que hacen posible la proyección de coordenadas 3D
sobre superficies 2D. También son las encargadas de mover, rotar y escalar
objetos. En realidad, estas transformaciones no se aplican a los modelos en sí,
si no al sistema de coordenadas, de forma que si se quiere rotar un objeto, no
lo se le rota, sino que se rota el eje sobre el que se sitúa.
El
modelador
En esta
sección se recogen las transformaciones del observador y del modelado puesto
que, como se verá en el apartado 4.2.1.3, constituyen, al fin y al cabo, la
misma transformación.
Transformaciones
del observador
La
transformación del observador es la primera que se aplica a la escena, y se usa
para determinar el punto más ventajoso de la escena. Por defecto, el punto de
vista está en el origen (0,0,0) mirando en dirección negativa del eje z. La
transformación del observador permite colocar y apuntar la cámara donde y hacia
donde se quiera. Todas las transformaciones posteriores tienen lugar basadas en
el nuevo sistema de coordenadas modificado.
Transformaciones
del modelo
Estas
transformaciones se usan para situar, rotar y escalar los objetos de la escena.
La apariencia final de los objetos depende en gran medida del orden con el que
se hayan aplicado las transformaciones.
Transformaciones
de la proyección
La transformación de proyección se aplica a la
orientación final del modelador. Esta proyección define el volumen de
visualización y establece 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.
Matrices
Las matemáticas que hay tras estas
transformaciones se simplifican gracias a las matrices. Cada una de las
transformaciones de las que se acaba de hablar puede conseguirse multiplicando
una matriz que contenga los vértices por una matriz que describa la transformación.
Por tanto todas las transformaciones ejecutables con ogl pueden describirse
como la multiplicación de dos o más matrices.
El canal
de transformaciones
Para poder llevar a cabo todas las
transformaciones de las que se acaba de hablar, deben modificarse dos matrices:
la matriz del Modelador y la matriz de Proyección. OpenGL proporciona muchas
funciones de alto nivel que hacen muy sencillo la construcción de matrices para
transformaciones. Éstas se aplican sobre la matriz que este activa en ese
instante. Para activar una de las dos matrices utilizamos la función glMatrixMode.
La
matriz del modelador
La
matriz del modelador es una matriz 4x4 que representa el sistema de coordenadas
transformado que se está usando para colocar y orientar los objetos. Si se
multiplica la matriz del vértice (de tamaño 1x4) por ésta se obtiene otra
matriz 1x4 con los vértices transformados sobre ese sistema de coordenadas.
Definición:
Producto escalar en cualquier espacio. Espacio euclídeo.
Cualquier
operación en un espacio vectorial que cumpla las anteriores propiedades, diremos que es un producto escalar (aunque no se
trate del producto escalar usual).
Llamaremos
espacio euclídeo a un espacio vectorial dotado de un producto escalar.
Conceptos
geométricos obtenidos del producto escalar.
Por
analogía con lo que ocurre en el plano o el espacio con el producto escalar
usual, podemos definir los siguientes
conceptos, siempre referidos a un cierto producto escalar.
Nos
situamos en V, un espacio euclídeo.
.
Vectores ortogonales.
Dos
vectores u, v son ortogonales si su producto escalar es cero: u · v = 0. Se denota u⊥ v.
Diremos
que un conjunto de vectores es un conjunto ortogonal si cada uno de ellos
es ortogonal a todos los demás.
• Notar que si dos vectores u, v son ortogonales
entonces también lo son sus múltiplos α u
y β v (α, β escalares).
Norma o
módulo de un vector.
La norma
o módulo de un vector es | v |= v · v
La noción corresponde, intuitivamente, a
la “longitud” del vector. También se puede denotar || v || .
Distancia
entre dos vectores.
La
distancia entre u y v es la norma del vector diferencia entre ambos.
dist (u,
v) = | u – v |
Ángulo
entre dos vectores.
Es
sabido que para el producto escalar usual de
ℜ²
se tiene que u · v = | u | | v | cos α ,
donde α
es el ángulo que forman ambos vectores. Por tanto, para generalizar la
noción de ángulo a cualquier espacio euclídeo.
Suscribirse a:
Entradas (Atom)