Capítulo 5: Viewing

Contenido
5.1 Clasificación de Proyecciones.
5.2 Posicionamiento de la Cámara.
5.3 Proyecciones Simples.
5.4 Eliminación de Superficies Ocultas.

Viewing

• En el modelo de la cámara sintética se distinguen 2 partes:
– definición de los objetos a observar.
– definición de la cámara para observar.

• Se debe considerar:
– posición de la cámara.
– tipo de proyección.
– volumen de visión (window 3D, clipping volume).

• Elementos: Objeto, observador, proyectores y plano de proyección.

• COP = Center of Projection (posición de cámara)

Centro de Proyección en Infinito
• Si se mueve el COP al infinito se obtiene una proyección paralela con DOP (direction of projection).

5.1 Clasificación de Proyecciones
• Proyecciones Geométricas Planas

Proyección Ortográfica
• Los proyectores son perpendicular al plano de proyección.

Proyecciones Ortográficas
Perfil, Planta y Elevación
• El plano de proyección es paralelo a una cara del objeto.
• Preservación de distancias y ángulos.
• Se utilizan en el dibujo técnico.

Proyección Axonométrica
• Los proyectores siguen perpendiculares sobre el plano de proyección, pero el plano de proyección no está paralelo a una cara del objeto.

Vistas Axonométricas
• Isométrica: plano está simétrico a las 3 principales caras. Los ángulos entre las proyecciones de los tres ejes son iguales.
• Dimétrica: plano está simétrico a 2 caras. Los ángulos entre dos de los ejes son iguales.
• Trimétrica: caso general. Los ángulos entre los tres ejes son diferentes.

Vista Oblicua
• Proyectores no son perpendiculares al plano de proyecciones

Vista Perspectiva
• Perspectiva clásica: observador se encuentra simétricamente con respecto al objeto.
• Se utiliza para obtener una impresión realista en 3 dimensiones del espacio (arquitectura y animación).

Proyecciones Perspectivas con cero, uno y dos Puntos
• A: 0 direcciones principales son paralelas al plano.
• B: 1 dirección principal es paralela al plano.
• C: 2 direcciones principales son paralelas al plano.

5.2 Posicionamiento de la Cámara

• Cámara en el Origen y Traslación de matriz Model-View.
– glTranslatef(0.0, 0.0, -5.0);
– mueve por defecto la cámara en dirección de +Z.

Posicionamiento de la Cámara
• glMatrixMode(GL_MODELVIEW);
• glLoadIdentity();
• glTranslatef(0.0, 0.0, -5.0);
• glRotatef(-90.0, 0.0, 1.0, 0.0);

Definir la Posición a través de la Función gluLookAt()
gluLookAt(eyex,eyey,eyez,atx,aty,atz,upx,upy,upz)

Otras formas de Viewing (1/2)
Roll, Pitch y Yaw

5.3 Proyecciones Simples

• Cámara
a. Fondo de la cámara perpendicular a la dirección Z.
b. Caso general, fondo de la cámara con cualquier orientación.

Proyección Perspectiva
• zp = -d
• x/z = -xp / d xp = -x /(z/d) x / (z/d)
• yp = -y / (z/d) y / (z/d)
• Nonuniform foreshortening.
• Transformación irreversible.

Proyección Perspectiva
• Coordenadas Homogéneas:
– (x, y, z) 􀃆 (x, y, z, 1)
• Suponer:
– (x,y,z) (wx, wy, wz, w), w != 0
- Para recobrar (x,y,z) dividimos por w.

Pipeline de Proyección

Etapas en la Transformación de Vértices
v’ = Mv
con v = ( x, y, z, w), vector columna.

En la Proyección Ortogonal toman valores x e y, z = 0.

5.4 Eliminación de Superficies Ocultas
• Algoritmos “hidden surface removal”.
• Algoritmos “visible surface”

Hidden Surface Removal
• Los algoritmos se dividen en 2 clases:
– Object-Space: ordena las superficies del objeto.
– Image-Space: trabaja en conjunto con la proyección para determinar la relación entre los puntos del objeto.
• Algoritmo Z-Buffer (Image-Space).

Hidden Surface Removal

Algoritmo Z-Buffer
• OpenGL:
– glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
– glEnable(GL_DEPTH_TEST);
– glClear(GL_DEPTH_BUFFER_BIT);

Contenido Capítulo 4 : Color

Color en el Computador

• Los colores de cada pixel son almacenados:
– Modo RGB o RGBA
– Modo Color-Index

• Los colores son almacenados en el buffer de color.
– glColor3f (1.0, 0.0, 0.0);
– glBegin (GL_POINTS);
– glVertex3fv (point_array);
– glEnd();

• El color es especificado por vértice para cada primitiva.
• Se aplica el modelo de Shading.
• Las primitivas son rasterizadas (convertidas a imagen 2d).
• Rastering implica determinar qué cuadrados de la grilla, en coordenadas de la ventana, son ocupados por la primitiva.
• Cada cuadrado tiene asociado un color, z (depth), coordenadas de textura. El conjunto se llama Fragmento.
• Los pixeles son elementos del framebuffer.
• Un pixel con un fragmento son combinados para formar el nuevo pixel.

Modo RGBA versus Color-Index
• Un dato de color se almacena en un pixel.
• El número de colores se determina por el número de planos de bits del framebuffer.
• 8 planos de colores = 256
• Para obtener el número de planos disponibles:
– void glGetIntegerv(GLenum pname, GLint *params)
• pname: GL_RED_BITS, GL_GREEN_BITS, GL_BLUE_BITS, GL_ALPHA_BITS, GL_INDEX_BITS.
• params: retorna el valor buscado.

Modo RGBA
• Valores de cada componente: 0.0 a 1.0

Dithering
• Dithering es una técnica que combina algunos colores para crear el efecto de otros colores.
• Para habilitar dithering:
– glEnable(GL_DITHER);

Modo Color-Index
• Usa un mapa de color (o tabla de búsqueda).

Especificación de Color en RGBA
• Selecciona el color actual:
void glColor3{b s i f d ub us ui} (TYPEr, TYPEg, TYPEb);
void glColor4{b s i f d ub us ui} (TYPEr, TYPEg, TYPEb, TYPEa);
void glColor3{b s i f d ub us ui}v (const TYPE*v);
void glColor4{b s i f d ub us ui}v (const TYPE*v);

Especificación de Color en RGBA
• Conversión de valores de colores a números flotantes. (ver tabla)

Especificación de Color en Color-Index
• Selecciona el índice de color actual:
void glIndex{sifd ub}(TYPE c);
void glIndex{sifd ub}v(const TYPE *c);
• Especifica el índice usado para limpiar el buffer de índice de color: void glClearIndex(GLfloat cindex);
• OpenGL no tiene funciones para cargar el mapa de colores. Ver glutSetColor().

Especificación del Modelo Shading
• voidglShadeModel (GLenum mode);
– mode: GL_SMOOTH (default), GL_FLAT.
• Ejemplo: smooth.c

Capítulo 3 : Entrada e Interacción

Contenido
• Interacción.
• Dispositivos de Entrada.
• Clientes y Servidores.
• Listas de Despliegue.
• Programación de Manejo de Eventos.
• Menús.

Entrada e Interacción
• 1963 Ivan Sutherland presentó con su tesis doctoral en el MIT, Sketchpad, uno de los primeros sistemas gráficos interactivos.
• Sutherland introduce un paradigma simple: El usuario puede interactuar con un dispositivo a través de gráfica con el sistema.

Interacción Gráfica
• Los 2 temas más importantes desde la presentación de Sketchpad son:
– La interfaz hombre-computador y
– las estructuras de datos para implementaciones eficientes.

• El tema de la interfaz no es apoyado por OpenGL, para eso existen herramientas como GLUT.
• GLUT permite el manejo de ventanas, el teclado, el mouse y de simples menús.

Dispositivos de Entrada
• Los dispositivos de entrada se separan en:
– dispositivos físicos
– dispositivos lógicos

• Esta separación permite el desarrollo de programas independientemente de las características de un dispositivo físico específico.

Dispositivos de Entrada Físicos
• Existen 2 tipos de dispositivos de entrada físicos:
– dispositivos para apuntar (Mouse y Trackball)
– dispositivos teclados (Tableta Gráfica)
• Los dispositivos para apuntar permiten al usuario indicar una posición en la pantalla y casi siempre incorporan uno o más botones para el envío de señales o interrupciones al computador.
• Los dispositivos teclados son generalmente los conocidos teclados, pero se puede generalizar a cualquier dispositivo que retorna códigos de caracteres.

De Velocidad a Posición
• Las velocidades de los movimientos del mouse en las direcciones X e Y son integradas para obtener una posición relativa X e Y.

Dispositivo de Entrada:
Tableta Gráfica: Se obtienen posiciones absolutas.
Lápiz de Luz: Dispositivo que usó Sutherland en Sketchpad.
Joystick: Se puede agregar elementos mecánicos que dan la sensación de fuerza y resistencia. Se usa para simuladores de vuelo y juegos.
Spaceball: Dispositivo de entrada 3D con 6 grados de libertad. Sensores de presión miden las fuerzas aplicadas por el usuario.

Dispositivos de Entrada Lógicos

En general se pueden observar 6 clases de dispositivos lógicos de entrada:

1. String: provee texto.
2. Locator: provee una posición en coordenadas del mundo a la aplicación.
3. Pick: retorna el identificador de un objeto.
4. Choice: selecciona una opción de varias alternativas.
5. Dial: provee entrada análoga.
6. Stroke: retorna un arreglo de posiciones.

Medida y Gatillador
• La manera en la cual dispositivos físicos y lógicos proveen entradas a programas de aplicación se puede describir en términos de 2 entidades:
– un proceso de “medida” y
– un “gatillador” del dispositivo
• La Medida es lo que retorna el dispositivo al programa.
• Gatillador es la operación física que inicia la entrada.
– Ejemplo-1: string y tecla enter
– Ejemplo-2: posición y tecla del mouse

Modos de Entrada

Se distinguen 3 tipos de modos de entrada: (Revisar gráficos sobre estos 3)
1. Request
2. Sample
3. Event

En OpenGL/GLUT realizado a través de funciones del tipo “callback”.

Clientes y Servidores
• Servidores Gráficos

Listas de Despliegue
Arquitectura de los años 60
Arquitectura Display-Processor

Modos de Despliegue

Hay 2 modos para desplegar primitivas gráficas:

• Modo Inmediato
– La primitiva es definida y enviada directamente al servidor gráfico, no queda almacenada en la memoria. Para un nuevo despliegue, se debe redefinir la primitiva.

• Modo Retenido
– La primitiva es definida y enviada a una memoria – la lista de despliegue (display list). La primitiva puede ser desplegada nuevamente sin una nueva definición desde la lista de despliegue.

Lista de Despliegue: Ejemplo (1/2)
glNewList(BOX, GL_COMPILE); // Alternativa: GL_COMPILE_AND_EXECUTE
glBegin(GL_POLYGON);
glColor3f(1.0, 0.0, 0.0);
glVertex2f(-1.0, -1.0);
glVertex2f( 1.0, -1.0);
glVertex2f( 1.0, 1.0);
glVertex2f(-1.0, 1.0);
glEnd();
glEndList();
glCallList(BOX); // Para desplegar el elemento BOX de color rojo

Lista de Despliegue: Ejemplo (2/2)
glMatrixMode(GL_PROJECTION);
for(int i = 1; i <>
glLoadIdentity();
gluOrtho2D(-2.0*i, 2.0*i, -2.0*i, 2.0*i);
glCallList(BOX);}

Programación de Eventos de Entrada con GLUT

• Eventos de Mouse:
– Botón presionado
– Botón soltado
– Movimiento

glutMouseFunc( mouse_callback_func );
void mouse_callback_func( int button, int state, int x, int y)
{
if ( button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
exit(0);
}

Programación de Eventos de Entrada con GLUT

• Eventos de Ventana: Eventos de Ventana:
– Cambio de tamaño.
glutReshapeFunc( reshape );

Programación de Eventos de Entrada con GLUT

• Eventos de Ventana: Eventos de Ventana:
void myReshape(GLsizei w, GLsizei h){
/* Adjust clipping box */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0,(GLdouble)w, 0.0,(GLdouble)h, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* Adjust viewport and clear */
glViewport(0,0,w,h);
glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}

Programación de Eventos de Entrada con GLUT

• Eventos de Teclado: Eventos de Teclado:
– Tecla presionada Tecla presionada
glutKeyboardFunc glutKeyboardFunc( keyboard keyboard); );
void void keyboard keyboard( unsigned unsigned char char key key, int int x, x, int int y) y)
{
if if( key key == == ‘q’ || || key key == == ‘Q’) exit exit(0); (0);
}

Programación de Eventos de Entrada con GLUT

• Eventos de Eventos de Display Display e Idle Idle:
– Display Display: redibujado redibujado de la ventana. de la ventana.
– Idle Idle: cuando no ocurren eventos : cuando no ocurren eventos.
glutDisplayFunc glutDisplayFunc( display display ); );
glutIdleFunc glutIdleFunc( idle idle ); );

Menús con GLUT

• GLUT dispone de men GLUT dispone de menús pop s pop-up: up:
– Id_menu Id_menu = glutCreateMenu glutCreateMenu( menu_func menu_func )
– glutAddMenuEntry glutAddMenuEntry( “nombre nombre”, valor ); , valor );
– glutAddSubMenu glutAddSubMenu (“nombre nombre”, Id_menu Id_menu ); );
– glutAttachMenu glutAttachMenu( button button ); );

Capítulo 3: Viewing

Analogía de la Cámara

• El proceso de transformación para producir la visión de una escena es análogo al proceso de tomar un fotografía con la cámara:
– Colocar el trípode y la cámara apuntando a la escena (transformación de la vista).
– Colocar en la posición deseada los objetos que van a ser fotografiados en la escena (transformación del modelado).
– Elegir un lente para la cámara o ajustar el zoom (transformación de la proyección).
– Determinar que tan grande va a ser la fotografía final (transformación del viewport).

Ejemplo Cube.c
void display(void){
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity ();

/* viewing transformation */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glScalef (1.0, 2.0, 1.0); /* modeling transformation */
glutWireCube (1.0);
glFlush ();
}

void reshape (int w, int h){
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

Transformaciones Generales

• glMatrixMode( modo ):
– Selecciona la matriz actual.
– Modo: GL_MODELVIEW, GL_PROJECTION, GL_TEXTURE.

• glLoadIndentity():
– Asigna a la matriz actual la matriz identidad (m4x4).

• glLoadMatrix{fd}( const TYPE *m ) :
– Asigna 16 valores de m a la matriz actual.

• glMultMatrix{fd}( const TYPE *m ) :
– Multiplica la matriz actual por m y el resultado queda en la matriz actual.

Transformaciones del Modelview
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMultMatrixf(N); /* apply transformation N */
glMultMatrixf(M); /* apply transformation M */
glMultMatrixf(L); /* apply transformation L */
glBegin(GL_POINTS);
glVertex3f(v); /* draw transformed vertexv */
glEnd();
v’ = NMLv

Sistema de Coordenadas Fijo
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMultMatrixf(T); /* translation */
glMultMatrixf(R); /* rotation */
draw_the_object();

Transformaciones del Modelado

• voidglTranslate{fd}(TYPE x, TYPE y, TYPE z);
– Multiplica la matriz actual por una matriz de traslación dada por (x,y, z).

• voidglRotate{fd}(TYPE angle, TYPE x, TYPE y, TYPE z);
– Multiplica la matriz actual por una matriz de rotación en el sentido inverso al movimiento de las manecillas del reloj, alrededor del rayo que forma el origen con el punto (x,y,z).
– Angle especifica el ángulo en grados.

• voidglScale{fd}(TYPE x, TYPE y, TYPE z);
– Multiplica la matriz actual por una matriz de escalamiento.
– Cada coordenada (x,y,z) se multiplica por el correspondiente parámetro x, y o z.

Transformaciones de la Vista
• Se pueden realizar de diferentes formas:
– Usando glTranslate y glRotate.
– Usando gluLookAt()
– Creando funciones propias que encapsulen rotaciones y traslaciones.

void gluLookAt( GLdouble eyex, eyey, eyez, GLdouble centerx, centery, centerz, GLdouble upx, upy, upz );
– Define una matriz de vista y la multiplica por la derecha con la matriz actual.
– La posición del punto del ojo se especifica por eyex, eyey y eyez.
– El centro de la escena se especifica por centerx, centery y centerz.
– La dirección hacia arriba se indica por upx, upy y upz.

Transformación de la Proyección
• Proyección en Perspectiva.
• Proyección Ortográfica.

Proyección en Perspectiva
• voidglFrustum(left, right, bottom,top, near, far);
– Crea una matrix de un frustum en perspectiva y lo multiplica por la actual matrix. El volumen de visión se define por los parámetros:
(left, bottom, -near) and (right, top, -near)
– Los valores near y far deben ser positivos.

• voidgluPerspective( fovy, aspect, near, far);
– Crea a matriz de un frustum en perspectiva simétrica y lo multiplica por la matriz actual.
– Fovy: ángulo en el plano x-z [0.0,180.0].
– Aspect: razón entre ancho y el alto (w/h).

Proyección Ortográfica
• voidglOrtho( left, right, bottom, top, near, far);
– Crea una matriz de un volumen ortográfico paralelo y lo multiplica por la matriz actual.
– (left, bottom, -near) y (right, top, -near) son puntos en el plano cercano.
– (left,bottom, -far) y (right, top, -far) son punto en el plano lejano.

Manipulación del Stack de Matrices
• OpenGL dispone de un stack de matrices.
• Esto facilita la construcción de modelos jerárquicos.
• Dispone de un stack de matrices para cada modo de matriz.
• En modo GL_MODELVIEW, profundidad es de por lo menos 32.
• En modo GL_PROJECTION y GL_TEXTURE, profundidad es por lo menos 2.
• La matriz actual en cualquier modo está en el tope.

• voidglPushMatrix(void);

– Empuja hacia abajo el stack de matrices y agrega en el tope la matriz actual duplicada.

– Inicialmente, cada stack de matrices tiene la identidad.

• voidglPopMatrix(void);

– Saca fuera la matriz del tope del stack, reemplazando la matriz actual por la que estaba más abajo.

Contenido Capítulo 2 : Programación Gráfica

• Sierpinski Gasket
• API OpenGL
• Primitivas y Atributos
• Color
• Viewing
• Funciones de Control

Sierpinski Gasket (SG)
• Problema de dibujado abordado en áreas tales como geometría fractal.
• SG es un objeto que puede ser definido recursiva y aleatoriamente, pero que en el limite tiene propiedades no aleatorias.

Sierpinski Gasket
• Algoritmo: Inicialmente se dispone de 3 vértices en un plano:
1. Aleatóriamente se toma un punto dentro del triángulo.
2. Aleatóriamente se selecciona uno de los tres vértices.
3. Se encuentra el punto medio entre el vértice y el punto inicial.
4. Se dibuja el nuevo punto.
5. Se reemplaza el punto inicial por el nuevo punto.
6. Retorna al paso

2. El Modelo Pen-Plotter
• Modelo tradicional en sistemas 2D.
• Dispositivo que mueve un lápiz sujeto a un caballete en direcciones ortogonales para dibujar en el papel.
2 Comandos: moveto(x, y); lineto(x, y);
Puntos 2D/3D
• Los objetos reales tienen 3 dimensiones y se encuentran en un mundo 3D.
• El modelo pen plotter es 2D.
• Los sistemas gráficos permiten el trabajo en 3D y ellos se preocupan de la proyección a 2D.
• Aplicaciones 2D se encuentran en el plano z=0, es decir un punto p = (x, y, 0).

Punto en OpenGL glVertex*()
* = ntv
n = 2, 3 o 4 (especifica la dimensión).
t = i (int), f (float) o d (double) (especifica el tipo).
v = la variable está dada por un puntero a un arreglo.

Ejemplos:
• glVertex2i(GLint xi, GLint yi);
• glVertex3f(GLfloat x, GLfloat y, GLfloat z);
• GLfloat arreglo[3];
• glVertex3fv(arreglo);

Diferentes Objetos Ejemplos:
glBegin(GL_LINES);
glVertex2f(x1, y1);
glVertex2f(x2, y2);
glEnd();

glBegin(GL_POINTS);
glVertex2f(x1, y1);
glVertex2f(x2, y2);
glEnd();

• ¿Qué unidades tienen las variables? ¿Dónde está el origen?
• Resp: Depende del usuario (programador) Sistemas de Coordenadas

• Inicialmente el sistema de coordenadas estaba directamente ligado al dispositivo de despliegue. • Actuales sistemas gráficos permiten trabajar en cualquier sistema de coordenadas.
• Sist. de coord. del mundo viene a ser el sist. de coord. del usuario.

La API OpenGL
• Las propiedades del sistema gráfico se describen a través de sus entradas y salidas.
Una API debería proveer 6 grupos de funciones:
1. Funciones de Primitivas (qué?)
2. Funciones de Atributos (cómo?)
3. Funciones de Visión (viewing)
4. Funciones de Transformación
5. Funciones de Entrada
6. Funciones de Control (sistema de ventanas, errores)

Primitivas y Atributos
• Primitivas son todos los objetos/elementos gráficos que posee el sistema gráfico.
• Las primitivas deberían ser ortogonales y su cantidad mínima.
• La librería GL contiene un conjunto mínimo y GLU una extensión con primitivas más complejas basadas en GL.

GL_POINTS = punto
GL_LINES = linea
GL_LINE_STRIP = poligono abierto
GL_LINE_LOOP = poligono cerrado

Detección de Punto Interior - Test Impar-Par
• El test Par-Impar es el más usado para detectar si un punto está en el interior de un polígono: – Suponiendo que P es un punto al interior de un polígono, en ese caso cada rayo que parte de P y va al infinito cruza el polígono una cantidad impar de veces.
– Un rayo que parte de un punto desde el exterior, cruza el polígono una cantidad par de veces (0 es par). Detección de Punto Interior
- Test de Número de Vuelta no 0 Desde un punto sale un rayo. Si la suma de las aristas que cruzan desde la izquierda menos la suma de las que cruzan desde la derecha es distinto de 0, el punto está adentro, si es 0 está afuera.

Test de Convexidad
Si se orientan las aristas en el sentido de las manecillas del reloj, un punto al interior de un polígono convexo, se encuentra siempre a la derecha de las aristas.
Atributos Color
Modelo de Color RGB (Red-Green-Blue)
Color Indexado

Especificación de Atributos
• glClearColor ( 1.0, 1.0, 1.0, 1.0 );
• glColor3f ( 1.0, 0.0, 0.0 );

Proyección Ortográfica
• glOrtho (left, right, bottom, top, near, far);
• gluOrtho2D ( left, right, bottom, top );

Modos de Matrices
• Matrices principales:
– Model-view
– Projection glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluOrtho2D ( 0.0, 500.0, 0.0, 500.0 );
glMatrixMode( GL_MODELVIEW );

Funciones de Control
• Las funciones de control varían entre diferentes sistemas operativos y pueden ser complejas.
• GLUT provee una simple interfaz entre el sistema gráfico y el S.O.

Interacción con el Sistema de Ventanas
• glutInit( int *argc, char **argv );
• glutCreateWindow( char *name );
• glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE );
• glutInitWindowSize( 640, 480 );
• glutInitWindowPosition( 0, 0 );

Razón de Aspecto y Viewport
• Razón de Aspecto: relación entre el ancho y el alto.
• Viewport: área rectangular de despliegue dentro de la ventana.

Proyección al Viewport
• glViewport( x, y, width, height );

Capítulo 2: Manejo de Estados y Dibujado de Objetos Geométricos

Limpiado de la Ventana
• Seleccionar el color de limpiado del buffer de color en modo RGBA:
– glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
• Limpiar el actual buffer: – glClear(GL_BUFFER_BIT);
1. Buffers de Limpiado
Ejemplo: glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Especificación de un Color
• glColor3f(0.0, 0.0, 0.0); negro
• glColor3f(1.0, 0.0, 0.0); rojo
• glColor3f(0.0, 1.0, 0.0); verde
• glColor3f(1.0, 1.0, 0.0); amarillo
• glColor3f(0.0, 0.0, 1.0); azul
• glColor3f(1.0, 0.0, 1.0); magenta
• glColor3f(0.0, 1.0, 1.0); cyan
• glColor3f(1.0, 1.0, 1.0); blanco
Describiendo Primitivas
• Rectángulos:
– void glRect{sifd}( x1, y1, x2, y2 );
– void glRect{sifd}v( v1, v2 );
• Especificación de vértices:
– voidglVertex{234}{sifd}[v](coodenadas);

Describiendo Primitivas
glBegin(GL_POLYGON);
glVertex2f(0.0, 0.0);
glVertex2f(0.0, 3.0);
glVertex2f(4.0, 3.0);
glVertex2f(6.0, 1.5);
glVertex2f(4.0, 0.0);
glEnd();

#define PI 3.1415926535898
GLint circle_points = 100;
glBegin(GL_LINE_LOOP);
for (i = 0; i < circle_points; i++) {
angle = 2*PI*i/circle_points;
glVertex2f(cos(angle), sin(angle)); }
glEnd();

Manejo de Estados Básicos
• Ciertos estados se pueden habilitar o deshabilitar:
– void glEnable(GLenum cap);
– void glDisable(GLenum cap);
• Ejemplos:
– glEnable( GL_BLEND );
– glEnable( GL_DEPTH_TEST );
– glEnable( GL_FOG );
– glEnable( GL_LINE_STIPPLE );
– glEnable( GL_LIGHTING );

• Chequear el actual estado de una cierta características:
– GLboolean glIsEnabled(GLenum capability)

• Chequear diferentes estados:
– voidglGetBooleanv(GLenum pname, GLboolean *params);
– voidglGetIntegerv(GLenum pname, GLint *params);
– voidglGetFloatv(GLenum pname, GLfloat *params);
– voidglGetDoublev(GLenum pname, GLdouble *params);
– voidglGetPointerv(GLenum pname, GLvoid **params);

Despliegue de Polígonos
• Definir el tamaño de un punto:
– voidglPointSize(GLfloat size);
• El tamaño debe ser mayor que 0.0 y por defecto es 1.0.

• Definir el ancho de línea:
– voidglLineWidth(GLfloat width);
• Dibujar líneas punteadas o segmentadas:
– voidglLineStipple(GLint factor, GLushort pattern);
– glEnable(GL_LINE_STIPPLE);
– Ejemplo: glLineStipple(1, 0x3F07);
glEnable(GL_LINE_STIPPLE);
• Patrones de línea

• Detalle de Polígonos:
– Polígonos tienen dos lados: front y back.
– Por defecto ambos lados se dibujan.
– Para cambiar la propiedades de dibujado:
• voidglPolygonMode( GLenum face, GLenum mode );
• Face: GL_FRONT_AND_BACK, GL_FRONT o GL_BACK;
• Mode: GL_POINT, GL_LINE, o GL_FILL
• Ejemplo:
– glPolygonMode(GL_FRONT, GL_FILL);
– glPolygonMode(GL_BACK, GL_LINE);

• Inversión y Descarte de Caras de Polígonos:
– Por defecto la cara-front corresponde a la secuencia de vértices dibujados en contra de la manecillas de reloj.
– Se puede cambiar la orientación:
• voidglFrontFace(GLenum mode);
• Mode: GL_CCW o GL_CW. – Se puede descartar el dibujado de caras: • voidglCullFace( GLenum mode );
• Mode: GL_FRONT, GL_BACK, o GL_FRONT_AND_BACK.
• Para activar descarte de caras:
– glEnable( GL_CULL_FACE );
Vectores Normales
• Un vector normal es un vector con dirección perpendicular a la superficie.
• OpenGL permite especificar una normal por polígono o por vértice.
• Las normales se usan para calcular la porción de luz que recibe un objeto en cada vértice.
• Una normal se especifica por:
– voidglNormal3{bsidf}( nx, ny, nz );
– voidglNormal3{bsidf}v( v );
glBegin (GL_POLYGON);
glNormal3fv(n0);
glVertex3fv(v0);
glNormal3fv(n1);
glVertex3fv(v1);
glNormal3fv(n2);
glVertex3fv(v2);
glNormal3fv(n3);
glVertex3fv(v3);
glEnd();

Grupos de Atributos
• Es posible guardar y restaurar conjuntos de atributos.
• En OpenGL se relacionan variables de estados en grupos de atributos.
• Para guardar y restaurar atributos se utiliza:
– glPushAttrib( GLbitfield mask );
– glPopAttrib();

Conceptos : Sistemas Gráficos y Modelos

Contenido Capítulo 1:
• Aplicaciones en Computación Gráfica.
• Un Sistema Gráfico.
• Imágenes: Físicas y Sintéticas.
• El Sistema Visual Humano.
• La Cámara Pinhole.
• El Modelo de la Cámara Sintética.
• La Interfaz del Programador.
• Arquitecturas Gráficas.

• Aplicaciones Computación Gráfica: Es el estudio de todo lo relacionado con la generación de imágenes, arte y fotografía usando computadores. En general se dividen en 4 áreas: Despliegue de Información.Diseño.Simulación.Interfaces de Usuario.
• Un sistema gráfico es esencialmente un computador con un conjunto de componentes: Procesador – Memoria - Frame Buffer - Dispositivos de salida - Dispositivos de entrada Conceptos: – Raster, Rasterization o conversión scan. – Pixels. – Profundidad de colores. – Resolución. – Frame Buffer.

Definiciones extraídas de Wikipedia & Google
Raster: Un Raster es una malla o matriz regular de celdas de un área determinada.
Píxel: combinación de "picture" y "element". Elemento gráfico mínimo con el que se componen las imágenes en la pantalla de una computadora.
Resolución: número máximo de píxeles que se ven en una pantalla. Dos ejemplos: 800 x 600 y 640 x 480. / En una impresora, la resolución es la calidad de la imagen reproducida y se mide en dpi.
El frame es una imagen independiente, una sucesión de frames compone una animación. Esto viene dado por las pequeñas diferencias que hay entre cada uno de ellos que producen a la vista la sensación de movimiento. El framebuffer es un concepto de sistemas operativos que designa a un método de acceso a dispositivos gráficos. El framebuffer es un dispositivo virtual del sistema operativo que se presenta ante las aplicaciones de diferentes maneras en función del sistema de que hablemos, aunque generalmente aparece como un archivo o un bloque de memoria RAM reservado en la computadora, y que puede ser accedido en lectura/escritura por uno o más procesos; en este archivo o zona de memoria especial cualquier escritura modifica directamente las imágenes desplegadas en el dispositivo de vídeo, para que de esa manera los programas puedan mostrar información en pantalla sin preocuparse de los detalles de implantación, ni de la interacción real entre el ordenador y el dispositivo de vídeo. Cabe notar que los sistemas gráficos de los ordenadores personales funcionan internamente como un framebuffer: todos y cada uno de los píxeles desplegados en cualquier instante determinado están almacenados en una porción de la memoria principal del computador en forma de octetos binarios. Debido a que las pantallas poseen diferentes capacidades de despliegue de colores (lo que se conoce como profundidad de color), la cantidad de información necesaria para representar un píxel varía. Las pantallas generalmente admiten 8, 15, 16 ó 24 bits de profundidad de color lo que equivale a 256, 32.768, 65.536 ó 16.777.216 colores respectivamente. Para cambiar la imagen presente en la pantalla, basta con escribir las direcciones de memoria dedicadas al píxel que se quiere modificar. De tal modo que el ordenador modifica efectivamente las imágenes desplegadas en pantalla modificando el contenido de la zona de memoria citada anteriormente, cosa que cabe perfectamente en la definición comúnmente aceptada de lo que es un framebuffer. Sin embargo, la idea de framebuffer se asocia más bien con aquellos dispositivos del sistema que son visibles o accesibles a las aplicaciones de usuario. En algunos sistemas operativos puede ocurrir que el acceso a la memoria del dispositivo de vídeo esté oculto a las aplicaciones, y que toda modificación de las imágenes desplegadas en pantalla se efectúe por medio de una API (como ocurre por ejemplo, en el caso de los sistemas operativos Windows).

Cathode-Ray Tube (CRT) = Tubo de Rayos Catódicos

• Imágenes: Físicas y Sintéticas
– Los objetos son tridimensionales.
– Tienen una posición en el espacio.
– Se busca una representación visual (física) de una relación espacial entre objetos (matemática).
– Dos entidades son parte del proceso de formación de una imagen:
1. Objeto (conjunto de vértices)
2. Observador (perspectiva)
Luz e Imagen
- Una escena está compuesta de:
– Fuente de Luz
– Objeto
– Observador (cámara)

Método Ray Tracing Es una técnica general de la óptica geométrica de modelar la trayectoria tomada por la luz por los rayos siguientes de la luz pues obran recíprocamente con las superficies ópticas. Se utiliza en el diseño de sistemas ópticos, tales como lentes de cámara fotográfica, de microscopios, de telescopios y de prismáticos. El término también se aplica para significar un específico que rinde acercamiento algorítmico en los gráficos de computadora 3D, donde las visualizaciones matemático-modeladas de escenas programadas se producen usando una técnica que siga rayos del eyepoint hacia fuera, más bien que originando en las fuentes de luz. Produce los resultados similares para irradiar el bastidor y el scanline que rinden, pero facilita efectos ópticos más avanzados, tales como simulaciones exactas de la reflexión y de la refracción, y sigue siendo bastante eficiente con frecuencia estar de uso práctico cuando se busca tal salida de la alta calidad.

• Sistema Visual Humano
Rod = Bastón: sensor para la vista en oscuridad.
Cone = Cono: sensor para la vista en claridad.
Intensidad (intensity) = Medida física para medir la energía de la luz.
Claridad (brightness) = Medida para medir la percepción de la luz.

Curva Estándar CIE (Commision Internationale de L’Eclairage)
• Sensibilidad alta para luz verde y baja para luz roja y azul.
Curva de Sensibilidad de Conos
• Sistema de visión humano tiene 3 tipos de conos y cada uno tiene su propia curva de sensibilidad para la luz.

Cámara Pinhole (wiki) Una cámara fotográfica del agujero de alfiler es una cámara fotográfica sin una lente. La luz que produce la imagen pasa a través de un agujero pequeño. Para producir una imagen razonablemente clara, la abertura tiene que ser un agujero de alfiler pequeño en la orden de 0.5 milímetros (0.02 pulgadas) o de menos. El obturador de una cámara fotográfica del agujero de alfiler consiste en generalmente una aleta manual de un poco de material resistente a la luz para cubrir y para destapar el agujero de alfiler. Las cámaras fotográficas del agujero de alfiler requieren tiempos mucho más largos de la exposición que cámaras fotográficas convencionales debido a la abertura pequeña; los tiempos típicos de la exposición pueden extenderse a partir de 5 segundos a las horas o a los días. La imagen se puede proyectar en una pantalla translúcida para la visión en tiempo real (popular para los eclipses solares de la visión; ver también el obscura de la cámara fotográfica), o puede exponer la película o un dispositivo acoplado de carga eléctrica (CCD). Las cámaras fotográficas del agujero de alfiler con CCDs se utilizan a veces para el trabajo de la vigilancia debido a su tamaño pequeño.

Cámara Pinhole
• Ventajas:
– Infinito campo de profundidad.
– Un punto de imagen es un punto.
• Desventajas:
– Admite un sólo rayo de un punto fuente.
– No se puede ajustar a un ángulo de visión diferente.

La Interfaz del Programador
• Una interfaz entre un programa y un sistema gráfico puede ser especificada a través de un conjunto de funciones en una librería gráfica (API gráfica).
• APIs basadas en el modelo de cámara sintética: OpenGL, Direct3D, PHIGS, GKS-3D. Especificaciones de la API
• Una API debe entregar funciones para especificar:
– Objetos
– Observadores
– Fuentes de Luces
– Propiedades de los materiales

Observador:
Cámara • Un observador puede ver de diferentes formas:
– Posición
– Orientación
– Longitud Focal
– Plano de Proyección